Eine Tastatur, die so echt ist, dass Sie sie fast SCHMECKEN können

126

... Würdest du nicht? Die Aufgabe ist einfach, geben Sie den folgenden Text aus:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ 
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Dies ist die Tastatur der Zukunft, denn in Zukunft sind Leerzeichen und Leertasten irrelevant.

Um es Ihnen ein bisschen leichter zu machen:

  1. 0123456789ABC...XYZ-=[]\;',./ - Diese Zeichen stehen auf Tasten der Länge 6 (einschließlich Polsterung).
  2. TAB / BS / ENTER - Diese Schlüssel haben eine Länge von 10 (einschließlich Polsterung).
  3. CAPS - Dieser Schlüssel hat die Länge 11 (einschließlich Polsterung).
  4. SHIFT - Dieser Schlüssel hat die Länge 13 (einschließlich Polsterung auf beiden Seiten).

Jeder einzelne Schlüssel sieht ungefähr so ​​aus:

 ____ 
||* ||
||__||
|/__\|

Sie sollten jedoch beachten, dass zwei aufeinander folgende Schlüssel nicht sind:

 ____  ____ 
||* ||||* ||
||__||||__||
|/__\||/__\|

Aber sie sind "verbunden":

 ____ ____ 
||* |||* ||
||__|||__||
|/__\|/__\|

Diese Herausforderung sollte nicht so schlimm sein, viel Glück für Sie; Verpassen Sie nicht, die Wiederholung zu missbrauchen! Aber unterschätze auch nicht die "speziellen" Tasten;).

Gewinnen?

Kürzester Code gewinnt, weil Sie wissen, dass es sich um Code-Golf handelt .

code-golf  ascii-art  kolmogorov-complexity 
— Magische Kraken-Urne
quelle
49
Ich muss zugeben, ich bin überrascht, dass nicht viele Leute sich Sorgen um futuristische Tastaturen machen, die keine Leerzeichen enthalten ...
— Magic Octopus Urn
97
Ich denke, Räume waren schließlich nicht die letzte Grenze.
— Greg Martin
48
"GESCHMACK" ist das deutsche Wort für "Schlüssel" :)
— QBrute
31
"GESCHMACK" ist das norwegische Wort für "Tippen" :)
— Stewie Griffin
32
Aber es ist das englische Wort für "Flavour". Hier .
— Mr Lister

Antworten:

117

V , 189, 179, 175, 164, 161, 157, 155, 149, 145, 141 , 135 Bytes

¬19É`A0-=BS´ 
TAB³ qwertyuiop[]\
CAPS³ asdfghjkl;'ENTER 
SHIFT´ ÄJizxcvbnm,./Í„A-Z ]/Õ& 
ÍÓ«ü$/|||&
òÙÓ„|]/_
ÙÓ׫/Ü|¯
kkPÓ/_ _
kòÎx$x

Probieren Sie es online!

Diese Antwort ist jetzt tweetbar!

Schau es dir an! Dies ist eine leicht modifizierte Version, die während der Ausführung aktualisiert wird, damit Sie sortieren können, wie es funktioniert. Dies ist eine veraltete Version, da ich noch nicht dazu gekommen bin, sie neu aufzunehmen, aber der allgemeine Ansatz ist identisch.

Dies ist wahrscheinlich die längste V-Antwort, die jemals geschrieben wurde. Es hat sicherlich nicht geholfen, dass Vs Interpreter extrem langsam ist. Ich habe ungefähr eine Stunde gebraucht, um die erste Revision zu schreiben, aber ich bin immer wieder darauf zurückgekommen, um jedes Mal ein paar Bytes weniger zu schreiben. Da die vollständige Tastatur 1215 Byte umfasst, ist diese Antwort derzeit um 91% kürzer als die Ausgabe, sodass ich mit den Ergebnissen ziemlich zufrieden bin.

Da dies einige nicht druckbare Zeichen und eine Menge grober Nicht-ASCII-Zeichen enthält, ist hier ein Hexdump:

00000000: ac31 39c9 6041 302d 3d42 53b4 200a 5441  .19.`A0-=BS. .TA
00000010: 42b3 2071 7765 7274 7975 696f 705b 5d5c  B. qwertyuiop[]\
00000020: 0a43 4150 53b3 2061 7364 6667 686a 6b6c  .CAPS. asdfghjkl
00000030: 3b27 454e 5445 5220 0a53 4849 4654 b420  ;'ENTER .SHIFT. 
00000040: 1bc4 4a69 7a78 6376 626e 6d2c 2e2f 1bcd  ..Jizxcvbnm,./..
00000050: 8441 2d5a 205d 2fd5 2620 0acd d3ab fc24  .A-Z ]/.& .....$
00000060: 2f7c 7c7c 260a f2d9 d384 7c5d 2f5f 0ad9  /|||&.....|]/_..
00000070: d3d7 ab2f dc7c af0a 6b6b 50d3 2f5f 205f  .../.|..kkP./_ _
00000080: 0a6b f2ce 7824 78                        .k..x$x

Wie zum Teufel funktioniert das?

Okay, diese Erklärung wird ein Trottel sein. Bereit? Zuerst müssen wir die Buchstaben eingeben, damit wir die Schlüssel um sie herum aufbauen können. Das ist

¬19É`A0-=BS´ 
TAB³ qwertyuiop[]\
CAPS³ asdfghjkl;'ENTER 
SHIFT´ <esc>ÄJizxcvbnm,./<esc>

Welche Beilagen:

`1234567890-=BS    
TAB   qwertyuiop[]\
CAPS   asdfghjkl;'ENTER 
SHIFT    zxcvbnm,./SHIFT

Das geht ganz einfach, aber es gibt ein paar Tricks, mit denen wir Charaktere speichern. ¬19Geben Sie beispielsweise "123456789" ein, geben Sie ³drei Leerzeichen ein, und wir duplizieren die Schicht, damit wir sie nicht mehrmals eingeben müssen.

Beachten Sie, wie die Buchstaben hier klein geschrieben sind. Dies ist so, dass wir leicht zwischen den Großbuchstaben wie "ENTER" und den einzelnen Buchstaben unterscheiden können. Wenn Sie sie auf diese Weise schreiben, können Sie leichter erkennen, vor welche Zeichen ein Balken gesetzt werden soll, und es wird nur ein Byte hinzugefügt, um sie später in Kleinbuchstaben umzuwandeln. Also führen wir einen Ersatzbefehl aus, um diese in Großbuchstaben umzuwandeln, und fügen nach jedem ein Leerzeichen hinzu:

Í               " Globally replace
 [^A-Z ]        " Anything but a uppercase alphabet character or a space
        /       " with
         Õ&     " The matched pattern made uppercase, followed by a space

Jetzt nehmen wir jede Tastenfolge (jede Folge von Nicht-Leerzeichen) und setzen drei Takte vor und nach ihnen:

Í           " Globally replace
 Ó«         "   Any number of non-space characters
   ü        "   or
    $       "   an end of line
     /      " with
      |||   "    Three bars 
         &  "    And the matched pattern

Zu diesem Zeitpunkt sieht der Puffer folgendermaßen aus:

|||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
|||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
|||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||

Drei Balken in der ersten und letzten Spalte zu haben, ist sehr praktisch und spart auf lange Sicht viele Bytes.

Und hier laufen wir eine riesige Schleife. Dies wird so etwas konvertieren:

|||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||

in so etwas:

 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ 
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Alles zwischen zwei Instanzen von òwird ausgeführt, bis ein Fehler auftritt, der auftritt, wenn wir versuchen, in eine Zeile aufzusteigen, die noch vorhanden ist. Da wir gerade einen global ersetzenden Befehl ausgeführt haben, befindet sich unser Cursor in der letzten Zeile und wir werden diese nach oben transformieren.

ò         " Recursively:
 Ù        "   Duplicate this line
  Ó       "   Substitute all on this line:
   [^|]   "     Anything but a bar
       /  "   With:
        _ "     An underscore

Dies ist das

|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||

Linie.

Ù         "   Duplicate this line
 Ó        "   Subsitute all on this line:
  ׫      "     A run of *non-word characters* (that is, [^0-9A-Za-z_])
    /     "   With:
     Ü|¯  "     '\|/'

Dies ist das

\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/

Linie.

kk        "   Move up two lines (to the original text with "SHIFT")
  P       "   Paste the last line we duplicated (the one with all the underscores)
   Ó      "   Substitute:
          "     Since we don't give any regex here, it re-uses the last one 
          "     (a run of *non-word* characters)
    /     "   With:
     _ _  "     '_ _'

Dies ist das:

_ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _

Linie.

k         "   Move up a line (this will throw an error, breaking the loop when we're done)
 ò        " Endwhile

Jetzt haben wir die vollständige Tastatur, aber jede Zeile enthält entweder einen zusätzlichen Strich, einen zusätzlichen Schrägstrich (vorwärts oder rückwärts) oder einen zusätzlichen Unterstrich. Super einfache Lösung

Î             " On every line:
 x            "   Delete a character
  $           "   Move to the end of the line
   x          "   and delete another character

Nach all dem Wahnsinn wird der Puffer implizit gedruckt.

— DJMcMayhem
quelle
1
Es scheinen 4 zusätzliche Unterstriche in der Leerstelle rechts neben der Ausgabe zu sein.
— ErikE
7
Sie unterschätzen, wie golfen diese Antwort tatsächlich ist lol.
— Magic Octopus Urn
1
@carusocomputing Haha, ich denke du hast recht. Ich bin sehr stolz auf diese Antwort und meine Sprache ist die einzige Antwort, die Bubblegum schlägt. :)
— DJMcMayhem
2
@DJMcMayhem Markiere dich als Gewinner, wenn dich bis zum 03.01.2017 niemand schlägt;).
— Magic Octopus Urn
7
Dies ist übrigens immer noch meine Lieblingsantwort auf der Website. Ich kann nicht zählen, wie oft ich mir das GIF angesehen habe.
— Magic Octopus Urn
41

Lua 5.3, 416 394 Bytes.

k="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT"S={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9}for v in k:gmatch"[^|]+"do for i=1,4 do for s in v:gmatch"%S+"do l=S[s]or 2j=("_"):rep(l)io.write(i==1 and" _"..j.."_"or i==2 and"||"..s..(" "):rep(l-#s).."|"or i==3 and"||"..j.."|"or"|/"..j.."\\")end print(i>1 and"|"or"")end end

Ungolfed und mit Kommentaren.

keys="` 1 2 3 4 5 6 7 8 9 0 - = BS|TAB Q W E R T Y U I O P [ ] \\|CAPS A S D F G H J K L ; ' ENTER|SHIFT Z X C V B N M , . / SHIFT" -- Define a keyboard. Separated with |'s, there's probably a nicer way to do this, but I'm not sure about how to yet.
special_keys={TAB=6,BS=6,ENTER=6,CAPS=7,SHIFT=9} -- Special keys get special definitions
for v in keys:gmatch"[^|]+" do -- For each row on the keyboard...
    for i=1, 4 do -- Each of the 4 rows per key...
        for s in v:gmatch"%S+" do -- Match each individual key.
            l=special_keys[s]or 2 j=("_"):rep(l) -- l is the length of the key, j is "_" repeated length times, which is used a bit.
            io.write(i==1 and -- Lua needs Switch Statements!
                     " _"..j.."_" -- The top of the key is a Space, then j with two _'s around it.
                     or
                     i==2 and
                     "||"..s..(" "):rep(l - #s).."|" -- Second row is || then the key, then the remaining whitespace, and then one more |, which chains together.
                     or
                     i==3 and
                     "||"..j.."|" -- Third row is like the second, but without the key. Instead of whitespace, uses j, which is the underlines.
                     or
                     "|/"..j.."\\") -- Last row is like the third row, but with "|/" and "\" instead of "||" and "|"
        end
        print(i>1 and"|"or"") -- First line is the only line that doresn't need a "|", everything else gets a "|" before the newline.

    end
end

Ausgabe

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Ich werde von anderen Sprachen zerstört, aber ich dachte, ich würde es versuchen. Sehr viel Komplexität und zumindest kürzer als die Tastatur!

— Ein Taco
quelle
15
Scheiß auf andere Sprachen, du warst der Erste in einer seltenen Sprache! Beeindruckend, obwohl ich mir sicher bin, dass Sie nicht bei jedem Buchstaben Pfeifen als Trennzeichen verwenden müssen. Beachten Sie, dass sich die Sondertasten nur am Anfang und Ende von Zeilen befinden. Ich bin sicher, dieser Hinweis könnte Ihnen wertvolle Bytes irgendwie ersparen.
— Magic Octopus Urn
Welche Version von Lua benutzt du? Auf Lua 5.1 gibt es mir einen Syntaxfehler: stdin: 1: fehlerhafte Nummer in der Nähe von '2j'
— brianush1
5
@ Brianush1 Lua 5.3, Damit können Zahlenkonstanten neben jedem Buchstaben stehen, der keine Hexadezimalziffer oder 'x' im Fall von 0 ist.
— ATaco
29

Bubblegum , 191 Bytes

0000000: ad d2 35 7a c6 30 10 06 e1 5e a7 50 15 66 fe 99  ..5z.0...^.P.f..
0000010: c1 8c 61 50 0e b2 87 8f 27 24 f7 eb af 78 2b e3  ..aP....'$...x+.
0000020: 3c b2 ae 99 1a 66 8d c8 a7 15 91 73 b8 80 4b b8  <....f.....s..K.
0000030: 82 6b b8 81 5b b8 83 1e 9c c1 31 8c 60 5e d9 66  .k..[.....1.`^.f
0000040: 22 46 c4 39 d1 c2 78 d6 a9 73 6f 5a d8 9b 18 ff  "F.9..x..soZ....
0000050: bb 5a e8 55 cf e6 fc ae 48 01 8f b0 82 12 6a 78  .Z.U....H.....jx
0000060: 86 7b 08 20 83 1c 5e e1 1d de e8 e5 7f 57 b4 d0  .{. ..^......W..
0000070: 8b a9 9b f9 5e 5d 9d af c5 2c af 7e 82 cd a0 82  ....^]...,.~....
0000080: 25 ac 61 03 5b 08 21 82 18 06 b0 0b ab b4 5e 95  %.a.[.!.......^.
0000090: ad 5e 5d 9d 2f d6 e9 f9 d2 c4 f2 bd aa 6d b0 ae  .^]./........m..
00000a0: ed 4f b1 17 78 82 05 3c c0 1c 52 48 e0 08 4e e0  .O..x..<..RH..N.
00000b0: 14 5a 77 fb 5e aa 58 be 97 aa 98 bf db 7c 01     .Zw.^.X......|.

Probieren Sie es online!

— Dennis
quelle
1
Bubblegum ist nicht fair.
— Joshua
7
@Joshua, es ist gut, eine Grundlinie für Lösungen festzulegen. Und wenn nichts Bubblegum schlagen kann, ist das das Problem.
— Sarge Borsch
19

Haskell, 263 Zeichen (353 Byte UTF-8)

import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"   ←"
 ,"↹   ":s"𝑄𝑊𝐸𝑅𝑇𝑌𝑈𝐼𝑂𝑃[]\\"
 ,"⇩    ":s"𝐴𝑆𝐷𝐹𝐺𝐻𝐽𝐾𝐿;'"%"     ↵"
 ,"⇧       ":s"𝑍𝑋𝐶𝑉𝐵𝑁𝑀,./"%"       ⇧"]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")

Screenshot dieser Tastatur

Da es in Anbetracht dieser Unicode-Zeichen viele Diskussionen über die Punktzahl gegeben hat ... ist hier dasselbe Programm, das auf alle ASCII-Zeichen reduziert ist:

Haskell, 263 Zeichen (263 Byte UTF-8)

import Data.List
main=mapM_ putStrLn$transpose.foldr k[g]=<<
 [s"`1234567890-="%"BS  "
 ,"TAB ":s"QWERTYUIOP[]\\"
 ,"CAPS ":s"ASDFGHJKL;'"%"ENTER "
 ,"SHIFT   ":s"ZXCVBNM,./"%"SHIFT   "]
r%e=r++[e]
g=" |||"
k s r=g:"_||/":['_':c:"__"|c<-s]%"_||\\"++r
s=map(:" ")
— hörte auf, sich gegen den Uhrzeigersinn zu drehen
quelle
3
Unicode-Tastatur? Interessante Wahl (gut aussehende mathematische Buchstaben), aber ich denke, es verstößt gegen die Wettbewerbsregeln.
— Mario Carneiro
@MarioCarneiro Um fair zu sein, es hat keinen Einfluss auf die Länge des Programms.
— pydsigner
1
@pydsigner Tut es, da Wörter wie ENTERlänger sind als Zeichen wie ↩︎.
— timothymh
5
Aber du vergleichst ENTER und ↩︎ , das Leerzeichen macht es gleich lang.
— CodeMonkey
2
Eigentlich erwarte ich, dass der Unicode die Anzahl der Bytes des Programms verlängert, da ein hoher Unicode in UTF8 mehr Bytes enthält als in ASCII.
— Mario Carneiro
18

PHP, 303 Bytes

Faul aber effektiv. :)

<?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbEAvA88wBuzPsg8vPyLZo3tOMUXmt1k/iy+ycfXYj88kacvIg1oQgva0IEu9KAPA6hDBUYQJn4+IvldxogWhrtqxmRamEw8t66afMc0CO26soczTOAAKVzhCAvYwg7u8IDs06tYVx3Oc+uqw7lef3lfUbBLimABJDCGKcxgDktYwRqGULJ143Ry+O71r/elDvb7vnSx3r2S+WKaFn+U3OACEZzs7wYxbKAMVajZvO6066WK9dNLFcuefgE'));
— Alex Howansky
quelle
1
Nett. Ärgerlicherweise kann ich mit compress / gzip / bzip2 / 7z nicht die gleiche Komprimierungsstufe erreichen, da sonst die Bash-Version geringfügig kürzer wäre. In der jetzigen Form sind es stattdessen 318 Zeichen.
— Konrad Rudolph
14
Ich bin mir ziemlich sicher, dass die Verwendung eines externen Komprimierungsalgorithmus, der nicht in Ihrem Programm enthalten ist, verboten oder zumindest verpönt ist. Es macht den Zweck der Frage zunichte.
— Niemand
1
@KonradRudolph Wie ich es verstehe, verwendet gzdeflate () die gleiche Komprimierung wie die gzip-Befehlszeile, überspringt jedoch den Dateikopf und die Prüfsumme, sodass sie immer etwas kürzer sind.
— Alex Howansky
300 Bytes <?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbHA+0QEvDHrg8zDy79EMbTDFF+3m8yfXdek42phHJG3KyItaEMHutCDPgxgCCNoQg0mMI3cdETSu4wRLQx3NYxJtDCJOL9t1cnSFWNvareVE1xhASHEcIczbOAIATzhBck3V7atupuTb6vulucq43XNvCDKenkQwRyWsII1bGEHexhDxcb140X4n6us16XuVXxdulZZrmi9WcbZd5IH3GAGF/vXwIcDVKEODVs3P53nUrUq5FK1sqc/'));. Compressor: sandbox.onlinephpfunctions.com/code/… Decompressor: sandbox.onlinephpfunctions.com/code/…
— Ismael Miguel
4
@Nobody Es gibt nichts Externes, gz ist Teil der PHP-Standardkompilierung und daher implizit zulässig.
— Alex Howansky
18

Python 3.5+, 239 Bytes

s="SHIFT   "
for k in[(*"`1234567890-=","BS   "),("TAB  ",*"QWERTYUIOP[]\\"),("CAPS  ",*"ASDFGHJKL;'","ENTER"),(s,*"ZXCVBNM,./",s)]:
 for f in"{1}__ ,|{} ||,|{1}||,/{1}\|".split(","):print(f[-1]+"".join(f.format(c,"_"*-~len(c))for c in k))
— orlp
quelle
Wird Python 3.5+ für den Splat in den Tupeln benötigt oder etwas anderes?
— mbomb007
1
Sie können ein Byte speichern, wenn Sie die Konstruktion jedes Schlüssels invertieren und "".join(...) + f[0]in der inneren Schleife verwenden. Durch Vertauschen der formatArgumentreihenfolge und der entsprechenden Platzhalter in der Zeichenfolge werden außerdem zwei weitere Bytes gespart.
— dfernan
['{1}__ ','|{} ||','|{1}||','/{1}\\|']ist kürzer als die Verwendung von split.
— Alex Hall
16

Batch, 465 452 Bytes

@echo off
call:c _ ` 1 2 3 4 5 6 7 8 9 0 - "=" "BS   " _____
call:c _____ "TAB  " Q W E R T Y U I O P [ ] \ _
call:c ______ "CAPS  " A S D F G H J K L ";" ' ENTER _____
call:c ________ "SHIFT   " Z X C V B N M "," . / "SHIFT   " ________
exit/b
:c
set t=%1_
set s=!!%~2 !!!%3 !!
:l
set t=%t%#__
set s=%s%!%~4 !!
shift
if not "%~5"=="" goto l
set t=%t%#%4_
for %%l in (" _%t:#=_ _%_" "%s:!=|%" "||%t:#=|||%||" "|/%t:#=\|/%\|")do echo %%~l

Die :cUnterroutine behandelt eine Reihe von Tasten. Schlüssel enthält zusätzliche Leerzeichen müssen zitiert werden, wie auch die =, ;, ,Tasten, möglicherweise aufgrund eines Fehlers in dem shiftBefehl. Der erste und der letzte Parameter sind Zeichenfolgen mit _der gleichen Länge wie der erste und der letzte Schlüssel, um die Verkettung zu erleichtern. tDas Ergebnis ist dann das _gemeinsame s für die erste, dritte und vierte Zeile, wobei #s den Join kennzeichnet. Diese werden vor dem Hinzufügen der führenden und nachfolgenden Zeichen entsprechend ersetzt, während ses sich um die zweite Zeile handelt, wobei |s bei der !Reduzierung in s geändert wird die Anzahl der "s, die ich brauche. Bearbeiten: 1 Byte durch Drucken aller vier Zeilen in einer einzigen Anweisung und 12 Byte durch Optimieren der Art und Weise, wie ich die sVariable zugewiesen habe, gespeichert.

— Neil
quelle
14

Ruby, 226 Bytes

16.times{|i|puts (([[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars+[['BS   ',?\\,'ENTER',s][j]]).map{|e|e.tr('^|'[-i%4/3,2],?_)}*3*"__ _ |||_|||_\\|/"[i%4*4,4])[72,75]}

Verbesserungen wie folgt:

1.Keine leeren Zeichenkettenelemente am Anfang und Ende des Arrays. Stattdessen wird das Array verdreifacht und es werden 3 Tastaturen nebeneinander erstellt. Nach der Umwandlung in einen String fehlen 3 Keyboards mit Außenkanten. Dies wird abgeschnitten, um nur die mittlere mit Kanten anzuzeigen.

2.Changed Version von Ruby. Ich habe Ideone anstelle von 1.9.3 auf meinem Computer installiert. Das heißt, es .chars.to_akann auf gerade gekürzt werden .chars.

Ruby, 239 Bytes

Es gibt noch ein paar Bytes, die man aus dieser Situation herausholen kann. Werde morgen schauen.

16.times{|i|puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+%w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+[['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|e.tr('^|'[-i%4/3,2],?_)}*"__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]}

ungolfed

16.times{|i|                                                            #iterate throug 16 lines of output
  puts ((['']+[[?`,'TAB  ','CAPS  ',s='SHIFT   '][j=i/4]]+              #build row from blank element plus left special key
    %w{1234567890-= QWERTYUIOP[] ASDFGHJKL;' ZXCVBNM,./}[j].chars.to_a+ #plus regular keys
   [['BS   ',?\\,'ENTER',s][j]]+['']).map{|e|                           #plus right special key and another blank element
                                      e.tr('^|'[-i%4/3,2],?_)}*         #if i%4 != 1, replace the keytop legend with _ characters 
   "__ _ |||_|||_\\|/"[i%4*4,4])[2..-2]                                 #join the middle parts of the keys with ends. truncate spurious outer ends before printing.
}
— Level River St
quelle
13

C #, 357 Bytes (in einer Zeile und mit den meisten Vorschlägen)

var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)
foreach(var k in r.Split('|'))
{
var u=new string('_',k.Length+1);
s+=i<1?" "+u+"__"
:i<2
?"||"+k+" |"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
Console.Write(s);

Oder 353 mit String-Interpolation und allen anderen Vorschlägen

var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0;i<4;s+=i>0?"|\n":"\n",i++)foreach(var k in r.Split('|')){var u=new string('_',k.Length+1);s+=i<1?$" {u}__":i<2?$"||{k} |":i<3?$"||{u}|":$@"|/{u}\";}Console.Write(s);

Ungolfed (ohne Stringinterpolation):

var solution = "";
foreach (var row in @"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for (int i = 0; i < 4; solution += i > 0 ? "|\n" : "\n", i++)
foreach (var key in row.Split('|'))
{
   var underscores = new string('_', key.Length + 1);
   solution += i < 1 ? " " + underscores + "__"
                     : i < 2
                     ? "||" + key + " |"
                     : i < 3
                     ? "||" + underscores + "|"
                     : "|/" + underscores + @"\";
}
Console.Write(solution);
— Klinger
quelle
5
Sie können viele Bytes speichern, die den Golf-Code als eine Zeile formatieren:foreach(var r in q){for(int i=0;i<4;i++){foreach...
— Mario
1
@ Mario Ich habe es gerade byteweise überprüft, der angegebene Wert ist eigentlich die Zählung ohne Zeilenumbrüche, also ist es technisch schon erledigt
— Alfie Goodacre
1
Leichtes Golfen auf 397 Bytes durch Interpolation und Ersetzen ==durch< s+=i<1?$" {u}__":i<2?$"||{k.PadRight(l)}|":i<3?$"||{u}|":$"|/{u}\\";
— Alfie Goodacre
Vielen Dank an Alfie Goodacre. Ich habe '==' gemäß Ihrem Vorschlag durch '<' ersetzt. Ich habe die Interpolation weggelassen, um sie weniger versionsspezifisch zu machen.
— Klinger
@Klinger Ich stimme zu, die Interpolation funktioniert auch bei keinem Online-Compiler, das ist also eine gute Wahl!
— Alfie Goodacre
10

PowerShell v2 +, 465 Byte

($b=($a=' ____')*10)+$a*3+" "+($d='_'*8)
"||``@$(1..9-join'@')@0@-@=@BS    ||
||$(($f=,'__'*10-join'#'))#__#__#__#$(($g='_'*6))||
$(($c=($e='|/__\')*10))$e$e$e|/$g\|
 $d$b$a$a$a
||TAB  @Q@W@E@R@T@Y@U@I@O@P@[@]@\ ||
||$g#$f#__#__#__||
|/$g\$c$e$e$e|
 _$d$b$a $d
||CAPS  @A@S@D@F@G@H@J@K@L@;@'@ENTER ||
||_$g#$f#__#$g||
|/_$g\$c$e|/$g\|
 ___$d$b ___$d
||SHIFT   @Z@X@C@V@B@N@M@,@.@/@SHIFT    ||
||___$g#$f#___$g||
|/___$g\$c|/___$g\|"-replace'@',' #'-replace'#','|||'

Es ist mir halbwegs peinlich, diese Antwort zu veröffentlichen, da die PHP- und Python-Antworten zwar kurz sind, die C # -Antwort jedoch nicht berücksichtigt wird, aber ich kann diese Methode nicht kürzer machen. Andere Ansätze können zu besseren Ergebnissen führen.

Es handelt sich im Grunde genommen nur um eine riesige mehrzeilige Zeichenfolge, bei der Variablen ( $aund dergleichen) verschiedene Teilzeichenfolgen ersetzen, und -replaceam Ende ein paar s, um sie fertigzustellen. Bei $(...)Bedarf werden Skriptblöcke eingefügt, um neue Variablen einzufügen.

Probieren Sie es online!

— AdmBorkBork
quelle
7

Python, 493 458 Bytes.

k=[['|']*75 for i in [0]*16]
v=' '
w='_'
y=0
def a(s,x,o):k[y+o][x:x+len(s)]=list(s)
def p(s,i,x):a(s+v*(i-len(s)),x+2,1);a(v+w*(i+2)+v,x,0);a(w*i,x+2,2);a(w*i,x+2,3);a('/',x+1,3);a('\\',x+i+2,3);return x+i+3
def q(s,x):return reduce(lambda a,b:p(b,2,a),list(s),x)
p('BS',6,q('`1234567890-=',0))
y=4
q('QWERTYUIOP[]\\',p('TAB',6,0))
y=8
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0)))
y=12
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0)))
for l in k:print''.join(l)

Funktional gleichwertig, aber etwas besser lesbar:

k=[['|']*75 for i in range(16)]
def a(s,x,y):k[y][x:x+len(s)]=list(s)
def p(s,i,x,y):
    a(s+' '*(i-len(s)),x+2,y+1)
    a(' '+'_'*(i+2)+' ',x,y)
    a('_'*i,x+2,y+2)
    a('_'*i,x+2,y+3)
    k[y+3][x+1]='/'
    k[y+3][x+i+2]='\\'
    return x+i+3
def q(s,x,y):return reduce(lambda a,b:p(b,2,a,y),list(s),x)
p('BS',6,q('`1234567890-=',0,0),0)
q('QWERTYUIOP[]\\',p('TAB',6,0,4),4)
p('ENTER',6,q('ASDFGHJKL;\'',p('CAPS',7,0,8),8),8)
p('SHIFT',9,q('ZXCVBNM,./',p('SHIFT',9,0,12),12),12)
for l in k:print ''.join(l)

Leider ist es schon länger als die Antwort in Lua.

— Cobi
quelle
Sie können die Zeilen in der pFunktion in eine durch Semikolon getrennte Zeile setzen. Ich dachte auch, dass du nicht die erste Zeile k=[['|']*75]*16machen kannst, weißt du warum?
— nedla2004
Sie können auch '_'und ' 'für eine Variable definieren, um einige Bytes zu speichern.
— nedla2004
Danke für die Tipps! Ich denke, k = [['|'] * 75] * 16 erzeugt sechzehn Referenzen auf dasselbe Array, so dass eine Änderung in einer Zeile auch die anderen beeinflusst.
— Cobi
Okay, dann können Sie zumindest Änderung range(16)zu [0]*16.
— nedla2004
Ein kleines Problem ist , dass der Code nicht technisch die richtige Ausgabe erzeugen, aber Sie können das Problem beheben , indem Wechsel for l in k:print ' '.join(l)zu for l in k:print''.join(l).
— nedla2004
7

PHP, 316 312 Bytes

foreach([($s=str_split)("`1234567890-=")+[13=>"BS   "],["TAB  "]+$s("_QWERTYUIOP[]\\"),["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],[$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]]as$r)for($y=-1;$y++<3;)foreach($r as$i=>$k)echo["\n".$a="| "[!$y]][$i],"_||/"[$y],str_pad($y-1?_:$k,strlen($k)+1,$y-1?_:" "),"_||\\"[$y],$a;

Ich bin mir ziemlich sicher, dass dieser Ansatz nicht weiter verfolgt werden kann. Aber wenn jemand 10 weitere Bytes findet ...: D
Run with -r.

Nervenzusammenbruch

foreach([                       // loop through rows
    ($s=str_split)("`1234567890-=")+[13=>"BS   "],
    ["TAB  "]+$s("_QWERTYUIOP[]\\"),
    ["CAPS  "]+$s("_ASDFGHJKL;'")+[12=>ENTER],
    [$h="SHIFT   "]+$s("_ZXCVBNM,./")+[11=>$h]
]as$r)
    for($y=-1;$y++<3;)          // loop through lines 0..3
        foreach($r as$i=>$k)    // loop through keys
            echo["\n".$a="| "[!$y]][$i],// first key in row: leading NL + space/pipe
                "_||/"[$y],             // key edges
                str_pad(
                    $y-1?_:$k,          // line 1: key label; else underscore
                    strlen($k)+1,       // pad to length+1
                    $y-1?_:" "),        // with spaces for label, underscores else
                "_||\\"[$y],            // more key edges
                $a                      // joining edges
            ;
— Titus
quelle
6

Bash (unter OSX), 12 8 + 221 + 1 = 234 230 Bytes

Ja, ich weiß, Kompression. Aber es funktioniert, nein?

gunzip<f

Benötigt eine Datei mit dem Namen "f" im aktuellen Verzeichnis mit folgendem Inhalt (aus Gründen der PPCG-Freundlichkeit in base64 - Sie können diese zuerst in die Datei "f" entschlüsseln.):

H4sIAHbPT1gAA63TuQ6CQBCA4Z6noLPxvo2xALwPPMAbsz7IPLz8i2aN7TjFFxo2mT+7vsnH12I/PJGnLyINaEIL2tCBLvSgDwOoQwVGECZ+PiL5WcaIFoazasZkWphMPLeumnzHNAjturKHM0zgAClc4QgL2MIO7vCA7NOrWFcdznPrqsO5Xn+5X1GwS4pgASQwhinMYA5LWMEahlCydeN0cvju9a/7pQ72e790sd69kvlimhYvSm5wgQhO9rlBDBsoQxVqNq/72/VSxfrppYpV9HoBoNfjQcAEAAA=
— Addison Crump
quelle
4
Kann durch Schreiben geringfügig gekürzt werden gunzip<f.
— Konrad Rudolph
@ KonradRudolph Ausgezeichneter Punkt. Vielen Dank.
— Addison Crump
Sie können 2 Bytes mit zcat fund 2 Bytes sparen , indem Sie die beiden nachfolgenden Null-Bytes entfernen (gzip beschwert sich, erzeugt aber die gewünschte Ausgabe).
— Gilles
@Gilles Spart mir nicht wirklich Bytes - ich müsste die Datei "fZ" umbenennen (zumindest unter OSX). Das Entfernen der nachfolgenden Null-Bytes führt nicht nur dazu, dass sich gzip beschwert, sondern dass Fehler ausgegeben und nichts gedruckt wird.
— Addison Crump
@VoteToClose Also gut zcat<f. Unter Linux führt zcat ohne die nachgestellten Nullen dazu, dass sich gzip beschwert ("gzip: stdin: unerwartetes Dateiende"), jedoch erst nach dem Drucken der gewünschten Ausgabe.
— Gilles
5

JavaScript (ES6), 286

Eine anonyme Funktion ohne Parameter

_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`

Weniger golfen

_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"]
  .map(x=>
      (
        w = x < y // special chars are marked '~' that is > '|'
            ? 2 // normal key, width 2
            : ( // else special key, set x and width
                // p should be incremented at next step, but I need to make it numeric as it starts as []
                x = ["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',
                ' 667699'[p], // value for w (note p is off by 1)
              ),
        b = '_'.repeat(w), // bottom border (and top, almost)
        o +=`/${b}\\|`, //  line 4
        n += y+b+y+y,   //  line 3
        m += y+(x+'    ').slice(0,w)+y+y, // line 2
        l += ' __'+b    // top line, the border must be longer
      )[70] && // check if at end of row (check position in l)
         (
            k.push(l, m, n, o), // add lines to list
            l = '', // reset all
            m = n = o = y
         )
    , // initial setup
    // y stays fixed to '|', lines 2,3,4 start as '|'
    m = n = o = y ='|',
    // k is the lines array, l will become as string and starts empty
    // p is the index of current special key and will become numeric
    p = l = k = [] 
  ) 
  && k.join`\n` // return lines as a single string

F=_=>[..."`1234567890-=~~QWERTYUIOP[]\\~ASDFGHJKL;'~~ZXCVBNM,./~"].map(x=>(o+=`/${b='_'.repeat(w=x<y?2:' 667699'[x=["BS","TAB","CAPS","ENTER"][p++]||'SHIFT',p])}\\|`,m+=y+(x+'    ').slice(0,w)+y+y,n+=y+b+y+y,l+=' __'+b)[73]&&(k.push(l,m,n,o),l='',m=n=o=y),m=n=o=y='|',p=l=k=[])&&k.join`
`

O.textContent=F()
<pre id=O></pre>
Erweitern Sie das Snippet

— edc65
quelle
5

Schnell, 777 Bytes

func b(_ c:String,_ d:Int,_ e:Int)->[String]{var f=Array(" __ |||||||||/\\|".characters),g=[String]()
for h in 0..<4{var i="";for j in e..<4{i.append(f[j+h*4])
if j==1{var k="_",l=0;if h==1{k=" ";l=c.characters.count;i += c}
for _ in l..<d{i+=k}}};g.append(i)};return g}
func c(_ d:String)->[(String,Int)]{return Array(d.characters).map{("\($0)",2)}}
func d(_ e:String,_ f:Int)->[(String,Int)]{return [(e,f)]}
var e=[c("`1234567890-=")+d("BS",6),d("TAB",6)+c("QWERTYUIOP[]\\")]
e+=[d("CAPS",7)+c("ASDFGHJKL;'")+d("ENTER",6),d("SHIFT",9)+c("ZXCVBNM,./")+d("SHIFT",9)]
var f="";for g in 0..<e.count{let h=e[g]
var i=[[String]]();for j in 0..<h.count{
let k=h[j],l=b(k.0,k.1,(j>0 ? 1:0));i.append(l)}
for k in 0..<4{if g>0||k>0{f+="\n"}
for l in i{f+=l[k]}}};print(f,separator:"")

Swift ist im Allgemeinen keine gute Sprache für das Golfen, daher ist es hier eine gute Herausforderung , weniger als das Doppelte der derzeit kleinsten Antwort (die schnell war) zu haben!

Ungolfed:

func createKeyboard() {
    func createKey(_ text: String, _ middleWidth: Int, _ startingColumn: Int) -> [String] {
        var keyTempalte = " __ |||||||||/\\|"
        var keyTemplateCharacters = Array(keyTempalte.characters)

        var output = [String]()

        for y in 0 ..< 4 {
            var line = ""
            for x in startingColumn ..< 4 {
                line.append(keyTemplateCharacters[x + y*4])

                if x == 1 {
                    var spacingCharacter = "_"
                    var startingOffset = 0
                    if y == 1 {
                        spacingCharacter = " "
                        startingOffset = text.characters.count
                        line += text
                    }

                    for _ in startingOffset ..< middleWidth {
                        line += spacingCharacter
                    }
                }
            }
            output.append(line)
        }

        return output
    }

    func stringToCharacterStrings(_ str: String) -> [(String, Int)] {
        return Array(str.characters).map {("\($0)",2)}
    }

    func specialKey(_ str: String, _ middleWidth: Int) -> [(String, Int)] {
        return [(str, middleWidth)]
    }

    var keys = [stringToCharacterStrings("`1234567890-=") + specialKey("BS", 6),
                specialKey("TAB", 6) + stringToCharacterStrings("QWERTYUIOP[]\\")]
    keys += [specialKey("CAPS", 7) + stringToCharacterStrings("ASDFGHJKL;'") + specialKey("ENTER", 6),
                specialKey("SHIFT", 9) + stringToCharacterStrings("ZXCVBNM,./") + specialKey("SHIFT", 9)]

    var output = ""
    for r in 0 ..< keys.count {
        let row = keys[r]
        var rowKeys = [[String]]()
        for i in 0 ..< row.count {
            let elem = row[i]
            let key = createKey(elem.0, elem.1, (i>0 ? 1 : 0))
            rowKeys.append(key)
        }

        for y in 0 ..< 4 {
            if r > 0 || y > 0 {
                output += "\n"
            }

            for key in rowKeys {
                output += key[y]
            }
        }
    }

    print(output)
}

createKeyboard()
— Benutzername tbd
quelle
2
Zumindest ist es kein Apfelskript
— Addison Crump
1
Jetzt muss ich Java machen, nicht
— wahr?
4

SOGL V0.12 , 131 128 127 Bytes (im Wettbewerb? )

⅟]y‘9Δø∑"`ŗ0-=”čΚ"TAB  ”QWERTYUIOP[]\”č+"oF«▒Β²‘⁷Ο‘ASDFGHJKL;'”čΚ+"_№K³‘ZXCVBNM,./”č⁴++¹{"^쳑č;{U;"_||/”┼;{"_ŗ__”┼}"Ο  ψ¦℮³‘┼}O

SOGL hat die 2*2/und 2/2*Macken, aber diese fühlen sich zu sehr wie ein Eingebauter für diese Herausforderung.
Probieren Sie es hier aus!

...‘               push "BS   "                                            ["BS   "]
    9Δ             push an array of numbers up to 9                        ["BS   ", [1,2,3,4,5,6,7,8,9]]
      ø∑           join into a single string (without ø it results to 45)  ["BS   ", "123456789"]
        "`ŗ0-=”    push "`ŗ0-=" with ŗ replaced with the digits            ["BS   ", "`1234567890-="]
               č   chop that into an array of characters                   ["BS   ", ["`","1","2","3","4","5","6","7","8","9","0","-","="]]
                Κ  add the first "BS   " to the end of the array           [["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="]]

"TAB  ”            push "TAB  "                  [[..], "TAB  "]
       Q..P[]\”    push "QWERTYUIOP[]\"          [[..], "TAB  ", "QWERTYUIOP[]\"]
               č   chop that                     [[..], "TAB  ", ["Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]
                +  prepend to the array "TAB  "  [[..], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"]]

"...‘             push "caps  "                       [.. , "caps  "]
     ⁷Ο‘          push "enter"                        [.. , "caps  ", "enter"]
        AL;'”     push "ASDFGHJKL;'"                  [.. , "caps  ", "enter", "ASDFGHJKL;'"]
             č    chop that                           [.. , "caps  ", "enter", ["A","S","D","F","G","H","J","K","L",";","'"]]
              Κ   append "enter" to the end of array  [.. , "caps  ", ["A","S","D","F","G","H","J","K","L",";","'","enter"]]
               +  prepend "caps  " to the array       [.. , ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"]]

"..‘             push "shift   "                [..., "shift   "]
    ZM,./”       push "ZXCVBNM,./"              [..., "shift   ", "ZXCVBNM,./"]
          č      chop it                        [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"]]
           ⁴     duplicate the shift            [..., "shift   ", ["Z","X","C","V","B","N","M",",",".","/"], "shift   "]
            ++   append and prepend the shifts  [..., ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]
              ¹  get all the arrays into one big array
result: [[["BS   ","`","1","2","3","4","5","6","7","8","9","0","-","="], ["TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\"], ["caps  ","A","S","D","F","G","H","J","K","L",";","'","enter"], ["shift   ","Z","X","C","V","B","N","M",",",".","/","shift   "]]]
 - a 2D array of the keyboard characters

{                                    for each array in the array do
 "...‘                                 push " |||"
      č                                chop to chars
       ;                               get the main array ontop
        {                        }     for each string in the array
         U                               uppercase it (before lowercase was used for better compression)
          ;                              get the chopped array ontop
           "_||/”                        push "_||/"
                 ┼                       append vertically
                  ;                      get the string ontop
                   {       }             for each char in the string do
                    "_ŗ__”                 push "_ŗ__"
                          ┼                append vertically
                            "..‘         push "    _||\ |||"
                                ┼        append vertically-then horizontally
                                  O    output that in a newline
— dzaima
quelle
Wow, das ist super beeindruckend! Niemand hat es geschafft, mich in diesem Fall zu schlagen, so gute Arbeit! Ich könnte versuchen, meine etwas kürzer zu machen, aber keine Versprechungen. ;)
— DJMcMayhem
@dzamia obwohl es jetzt konkurriert, akzeptierte ich die Antwort zurück, als dies nicht war. Soll ich die Antworten wechseln?
— Magic Octopus Urn
@MagicOctopusUrn IMO liegt an Ihnen. Es gibt einen Grund, warum Antworten nicht akzeptiert werden sollten: p
— dzaima
Es wird empfohlen, keine Antworten zu akzeptieren? Oh ... fair genug. Dann werde ich wohl in Zukunft keine Antworten mehr annehmen und die Dinge so lassen, wie sie sind.
— Magic Octopus Urn
@MagicOctopusUrn okay, vielleicht nicht akzeptieren Antworten ist ein bisschen umstritten, aber immer noch eine große positive
— Dzaima
4

Python 2, 394 388 380 Bytes

k=[4]*13+[8],[8]+[4]*13,[9]+[4]*11+[8],[11]+[4]*10+[11];m='`1234567890-=*','*QWERTYUIOP[]*',"*ASDFGHJKL;'*",'*ZXCVBNM,./*';c,d,e,n,u=0,'','|','\n','_'
for a in 0,1,2,3:
 f=s=t=o='';x=0
 for y in k[a]:g=y-2;f+=' '+u*y;s+=e*2+m[a][x].replace('*','%s')+' |';t+=e*2+u*g+e;o+='|/'+u*g+'\\';x+=1
 d+=f+n+s+e+n+t+e+n+o+e+n
l='SHIFT   ';print d%('BS   ','TAB  ','\\','CAPS  ','ENTER',l,l)

Erstellt einfach eine große Zeichenfolge, die die gesamte Tastatur darstellt, ersetzt * durch% s für die Sondertasten und aktualisiert die Sondertasten mithilfe der Zeichenfolgenformatierung.

Bearbeiten

Am Ende der Ausgabe befindet sich jetzt eine nachgestellte Zeile, aber ich sehe nirgendwo etwas, das nicht zulässig ist.

Probieren Sie es online!

— ElPedro
quelle
Ich denke, Sie sollten die Ausgabe entfernen, da es nichts Relevantes hinzufügt.
— Sergiol
1
@ Sergiol - guter Punkt. War TIO zum Zeitpunkt der Veröffentlichung nicht bekannt. Jetzt aktualisiert.
— ElPedro
3

C #, 376 Bytes (wenn in einer Zeile)

var s="";foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))for(int i=0,l;i<4;i++){foreach(var k in r.Split('|')){l=k.Length+1;var u=new string('_',l);s+=i<1?" "+u+"__":i<2?"||"+k.PadRight(l)+"|":i<3?"||"+u+"|":"|/"+u+@"\";}s+=i>0?"|\n":"\n";}Console.Write(s);

Dies basiert vollständig auf Klingers C # -Antwort. Ich habe nicht genug Repräsentanten, um seine Antwort zu kommentieren, sonst würde ich.

Ich konnte Klingers Code um 5 Byte verkleinern, indem ich die anfängliche foreach-Schleife modifizierte und überflüssige Klammern entfernte.

var s="";
foreach(var r in@"`|1|2|3|4|5|6|7|8|9|0|-|=|BS   ~TAB  |Q|W|E|R|T|Y|U|I|O|P|[|]|\~CAPS  |A|S|D|F|G|H|J|K|L|;|'|ENTER~SHIFT   |Z|X|C|V|B|N|M|,|.|/|SHIFT   ".Split('~'))
for(int i=0,l;i<4;i++)
{
foreach(var k in r.Split('|'))
{
l=k.Length+1;
var u=new string('_',l);
s+=i<1?" "+u+"__"
:i<2
?"||"+k.PadRight(l)+"|"
:i<3
?"||"+u+"|"
:"|/"+u+@"\";
}
s+=i>0?"|\n":"\n";
}
Console.Write(s);
— Bence Joful
quelle
Guter @Bence Joful. Mit Ihrem Vorschlag würde ich es auf 367 bringen können. Ich habe mich nicht in die aktuelle Antwort eingearbeitet.
— Klinger
Konnte nicht widerstehen. Ihr Vorschlag + einige zusätzliche geringfügige Änderungen bringen es auf 361 (oder 358 mit String-Interpolation).
— Klinger
@Klinger - bitte benutze meine Tweaks! Ich war inspiriert, damit zu spielen, basierend auf Ihrer Arbeit. Dabei habe ich etwas über die Initialisierung gelernt.
— Bence Joful
Könnten Sie das einzeilige Programm aufnehmen? Sie werden nicht gerade viel Lesbarkeit verlieren gegenüber dem aktuellen
— Cyoce
@Cyoce, du hast es verstanden, danke für den Vorschlag. Zu diesem Zeitpunkt hat Klinger jedoch bereits eine neue, kleinere Version veröffentlicht, die diese Änderungen enthält.
— Bence Joful
3

m4, 456

changequote({,})define(d,{define($@)})d(p,{patsubst($@)})d(a,{{_}p({$1},.,_)_ })d(b,{|$1||})d(c,{|p({$1},.,_)||})d(e,{/p({$1},.,_)\|})d(f,{ifelse(len({$2}),0,,{indir({$1},{$2})f({$1},shift(shift($@)))})})d(g,{ f({a},$@)
|f({b},$@)
|f({c},$@)
|f({e},$@)
})g(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )g(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )g(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )g(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )

Ungolfed:

changequote({,})dnl
define(key1, {{_}patsubst({$1}, ., _)_ })dnl _______ 
define(key2, {|$1||})dnl                     |TAB  ||
define(key3, {|patsubst({$1}, ., _)||})dnl   |_____||
define(key4, {/patsubst({$1}, ., _)\|})dnl   /_____\|
define(rkey, {dnl
ifelse(dnl
len({$2}), 0, ,dnl terminate on empty argument
{dnl
indir({$1}, {$2})dnl
rkey({$1}, shift(shift($@)))dnl
}dnl
)dnl
})dnl
define(row, {dnl
 rkey({key1}, $@)
|rkey({key2}, $@)
|rkey({key3}, $@)
|rkey({key4}, $@)dnl
})dnl
row(` ,1 ,2 ,3 ,4 ,5 ,6 ,7 ,8 ,9 ,0 ,- ,= ,BS    )
row(TAB   ,Q ,W ,E ,R ,T ,Y ,U ,I ,O ,P ,[ ,] ,\ )
row(CAPS   ,A ,S ,D ,F ,G ,H ,J ,K ,L ,; ,' ,ENTER )
row(SHIFT    ,Z ,X ,C ,V ,B ,N ,M ,{,} ,. ,/ ,SHIFT    )

(Dies ist eigentlich das erste Mal, dass ich Code-Golf spiele und m4 ausprobiere.)

— Thriller
quelle
Nicht schlecht für eine erste Antwort. Willkommen auf der Seite! :)
— DJMcMayhem
3

gestapelt , 228 Bytes

Probieren Sie es hier aus!

[,{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*:@o'|'LF'|/'o'\')sum}"!$hcat#/!' |||'hcat out]@:p$chars@:c'`1234567890-='c'BS   'p'TAB  ' 'QWERTYUIOP[]\'c p'CAPS  ' 'ASDFGHJKL;'''c,'ENTER'p'SHIFT   ':@q'ZXCVBNM,./'c,q p

Oder etwas besser lesbar:

{a:a size@n(' __' '_'n 1+:@k*LF'||'a' ' '|'LF'||' '_'k*'|'LF'|/' '_'k*'\')sum}"@:m
[,m$hcat#/!' |||'hcat out]@:p
'`1234567890-='chars'BS   'p
'TAB  ' 'QWERTYUIOP[]\'chars p
'CAPS  ' 'ASDFGHJKL;'''chars,'ENTER'p
'SHIFT   ':@q'ZXCVBNM,./'chars,q p

Dies funktioniert, indem eine Funktion definiert wird p, die eine Taste erstellt, und dann hcatmehrere Tasten.

— Conor O'Brien
quelle
2

Haskell, 255

import Data.List;a#b=a++[b];e=" |||";s=map(:" ");k x=[e,"_||/"]++['_':c:"__"|c<-x]#"_||\\";t="SHIFT    ";main=mapM_ putStrLn$transpose.(#e).(k=<<)=<<[s"`1234567890-="#"BS    ","TAB   ":s"QWERTYUIOP[]\\","CAPS   ":s"ASDFGHJKL;'"#"ENTER ",t:s"ZXCVBNM,./"#t]

Im Nachhinein ähnelt das Konzept dieser Haskell-Antwort , produziert aber die ASCII-Tastatur und mit etwas anderem Golf.

Formatiert und umbenannt:

import Data.List

main :: IO ()
main = mapM_ putStrLn
  $ concatMap (transpose . (`append` end) . concatMap key)
  [ split "`1234567890-=" `append` "BS    "
  , "TAB   " : split "QWERTYUIOP[]\\"
  , "CAPS   " : split "ASDFGHJKL;'" `append` "ENTER "
  , shift : split "ZXCVBNM,./" `append` shift
  ]

key :: String -> [String]
key x
  = [end, "_||/"]
  ++ ['_' : c : "__" | c <- x]
  `append` "_||\\"

append :: [a] -> a -> [a]
append a b = a ++ [b]

split :: [Char] -> [String]
split = map (: " ")

end :: String
end = " |||"

shift :: String
shift = "SHIFT    "
— Jon Purdy
quelle
2

tcl, 368

Wie von http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/ mit der Angabe "Zeilenumbrüche als Leerzeichen zählen" gezählt. auf on gesetzt, belegt es 505 496 452 451 439 403 401 396 391 388 385 384 382 379 378 377 369 368 

proc N x {split $x @}
proc M a\ b {string map $a $b}
regsub -all \[^@|] [set b [M [N {||||@|||@$@BS   @%@TAB  @&@CAPS @? @ENTER  @*@SHIFT   }] [regsub -all {[^@]} "`1234567890-=$@%QWERTYUIOP\[\]\\@&ASDFGHJKL;'?@*ZXCVBNM,./*" {||& ||}]]] _ f
lmap x [N [M {\\ _ / _ | \ } [set g [M {||_ |/_ _|| _\\|} [M {||| \\|/} $f]]]]] y [N $b] z [N $f] w [N $g] {puts "$x
$y
$z
$w"}

Demo: http://rextester.com/live/NTVAV88033

Der Ungolf:

Live-Zusammenarbeit unter http://rextester.com/live/UDO43692

regsub -all {(\S)} "`1234567890-=←\n%QWERTYUIOP\[\]\\\n⇩ASDFGHJKL;'↵\n⇧ZXCVBNM,./⇧" {||\1 ||} b
set b [string map {|||| |||  ← "BS   " % "TAB  " ⇩ "CAPS  " ↵ "ENTER" ⇧ "SHIFT   "} $b]

regsub -all {[^\n|]} $b _ f

set g [string map {||| \\|/} $f]
set g [string map {||_ |/_  _|| _\\|} $g]
set h [string map {\\ _ / _ | " "} $g]

set H [split $h \n]
set B [split $b \n]
set F [split $f \n]
set G [split $g \n]

lmap x $H y $B z $F w $G {
puts $x
puts $y
puts $z
puts $w
}

Es steht jedem frei, meine Version auf Websites für Live-Zusammenarbeit zu verbessern. Bitte: Meine ursprüngliche Antwort hier nicht bearbeiten. Sagen Sie einfach, Sie haben in den Kommentaren bearbeitet und die Leute werden die Links besuchen.

UPDATE 1: Ersetzt fordurch foreach, da letzterer kürzeren Code erzeugt

UPDATE 2: Ersetzt foreachdurch lmap, da letzterer kürzeren Code erzeugt

UPDATE 3: Rasierte ein Zeichen, weil ich durch ersetzt " "wurde\

UPDATE 4: In Bezug auf den ersten Kommentar habe ich alle Unicode-Platzhalterzeichen der 1. Zeile (2 Byte) in ASCII-Zeichen (1 Byte) geändert

UPDATE 5: Mehrere putsZeilen werden zu einer einzigen Zeile

UPDATE 6: Verwenden Sie direkt splitBefehle, um Werte beim lmapAufruf zurückzugeben, anstatt Zwischenlistenvariablen zu verwenden

UPDATE 7: Anführungszeichen ENTERwurden nicht benötigt

UPDATE 8: string map ist lang genug und wird so oft wiederholt, dass es sich lohnt, es in ein einzuschließenproc

UPDATE 9: split $x \n ist lang genug und wird so oft wiederholt, dass es sich lohnt, es in ein einzuschließenproc

UPDATE 10: On "replacement" kann &anstelle von string verwendet werden \1, da in diesem Fall beide übereinstimmen; Eine weitere Folge davon ist, dass ()die "passende" Zeichenfolge entfernt werden kann.

UPDATE 11: Verwenden Sie @anstelle von \nals Zeilentrennzeichen, um splitAnweisungen weiterzuverwenden. Obwohl sich die "Übereinstimmungszeichenfolge" von \Szu verlängert , [^@]zahlt sich dies aufgrund der Anzahl der Wiederholungen aus

UPDATE 12: Ersetzte den ersten regsub"Match" String {[^@|]}durch \[^@|], um ein Zeichen zu entfernen. Konnte leider nicht gleich zur Sekunde machen regsub, da die Anweisung in einem Paar von []:(

UPDATE 13: Rasiert zwei Enter-Zeichen, indem der lmapKörper mit einer eigenen Überschrift konzentriert wird.

UPDATE 14: Verwendet einen Aufruf der splitbasierten Prozedur Nanstelle eines direkten Aufrufs der string mapbasierten Prozedur, Nder eine Kürzung um 3 Zeichen ermöglicht

UPDATE 15: Es gab ein nicht benötigtes Leerzeichen. Entfernte es, um ein Zeichen weg zu rasieren.

UPDATE 16: set h Kann eingebettet werden, um $heinen Charakter loszuwerden und zu rasieren.

UPDATE 17: set h Aussage kann wirklich abgeschabt werden.

UPDATE 18: puts Argument geändert vom ...\n...\n...\n...Format zum

"...
...
...
..."

Format.

Vielen Dank an Leute, die mir geholfen haben, es zu verkürzen, besonders an Evilotto und Aspekt des tcl-IRC-Kanals!

— Sergiol
quelle
Schöne Antwort und Willkommen auf der Seite! Ich habe Ihren Beitrag geringfügig bearbeitet, sodass die Byteanzahl in der Kopfzeile angezeigt wird. Ich hoffe, es macht Ihnen nichts aus. Nur damit Sie wissen, denke ich, dass dies tatsächlich 469 Bytes sind, da einige dieser Zeichen in UTF-8 mehrere Bytes sind. Ich weiß nicht viel über tcl. Verwendet es eine benutzerdefinierte Codierung, bei der es sich um ein Byte handelt?
— DJMcMayhem
@DJMcMayhem Ich wusste nicht, dass es auf der Anzahl der Bytes statt der Anzahl der Zeichen basiert, aber es ist kein Problem, da alles, was ein Ein-Byte-Symbol ist, immer noch nicht verwendet wird, ein Platzhalter sein kann und ich immer noch viele zur Verfügung habe.
— Sergiol
@DJMcMayhem Nach meiner Bearbeitung ist das von Ihnen gemeldete Nicht-Problem verschwunden!
— Sergiol
@DJMcMayhem Warum hatte der 401 oben einige Zeit einen gelben Hintergrund?
— Sergiol
2

tcl, 369

Ursprünglich basiert es auf der Sergiol-Version von tcl.
(Beachten Sie, dass viele linke Leerzeichen Teil der "Natur" von tcl sind.)

lmap z {S R M} w {set "regsub -all" "string map"} {interp alias {} $z {} {*}$w};lmap x {"`1234567890-=¿BS   ¿" "¿TAB  ¿QWERTYUIOP\[\]\\" "¿CAPS  ¿ASDFGHJKL;'¿ENTER¿" "¿SHIFT   ¿ZXCVBNM,./¿SHIFT   ¿"} {S h [M {\\ _ / _ | \ } [S g [M {||_ |/_  _|| _\\|} [M {||| \\|/} [S f [R {[^\n|]} [S b [M {|||| |||} [R {¿(\S+\s*)¿|(.)} $x {||\1\2 ||}]]] _ ]]]]]];puts $h\n$b\n$f\n$g}
— Alejandro Muzzachiodi
quelle
@muddyfish Bearbeitet und behoben. Vielen Dank!
— Alejandro Muzzachiodi
Sie können mehr verkürzen, wenn Sie alle foreachVorkommen direkt durch ersetzen lmap!
— Sergiol
Versucht, Ihren interp aliasAnsatz zu verwenden, um meine Version zu verkürzen, aber das kürzeste, das ich bekommen konnte, wenn ich es tat, war 398 :( rextester.com/live/NTVAV88033
— sergiol
Mein letzter Versuch bekam ich 395:lmap z {S R M N} w {set "regsub -all" "string map" split} {interp alias {} $z {} {*}$w};lmap y [N [S b [M [N {||||@|||@$@BS @%@TAB @&@CAPS @? @ENTER @*@SHIFT } @] [R {[^@]} "`1234567890-=$@%QWERTYUIOP\[\]\\@&ASDFGHJKL;'?@*ZXCVBNM,./*" {||& ||}]]] @] z [N [S f [R {[^@|]} $b _]] @] w [N [S g [M {||_ |/_ _|| _\\|} [M {||| \\|/} $f]]] @] x [N [M {\\ _ / _ | \ } $g] @] {puts $x\n$y\n$z\n$w}
— Sergiol
Sie können ein Zeichen sparen, wenn Sie einen nicht benötigten Platz wie in meinem letzten Update entfernt haben!
— Sergiol
2

C (gcc) , 378 342 330 Bytes

-10 bytes dank ceilingcat.

Ein erster Versuch. Das wiederholte g () deutet auf Verbesserungspotential hin.

Edit: Los geht's.

char*k[]={"eZXCVBNM,./e","cASDFGHJKL;'d","bQWERTYUIOP[]\\","`1234567890-=a","BS","TAB","CAPS","ENTER","SHIFT"},*s;f(w,i,j){for(i=4;i--;)for(j=4;j--;puts(""))for(s=k[i];w=*s>96?"FFGFI"[*s-97]-64:2,*s;)printf("%s%s%-*.*s%.2s",L" |"+(s++-k[i]?2:j<3),L"/||"+j,w,j<2?w:j^3?w>2?w:1:w+2,j^2?"___________":w>2?k[*s-93]:s,"\\||||| "+j*2);}

Probieren Sie es online!

— Gastropner
quelle
1

Python 2, 672 Bytes

Verwenden einer komprimierten zlib-Zeichenfolge:

print 'x\x9c\xad\xd3\xb9\x0e\x82@\x10\x80\xe1\x9e\xa7\xa0\xb3\xf1\xbe\x8d\xb1\x00\xbc\x0f<\xc0\x1b\xb3>\xc8<\xbc\xfc\x8bf\x8d\xed8\xc5\x17\x9a\xddd\xfe,\xbe\xc9\xc7\xd7b?<\x91\xa7/"\rhB\x0b\xda\xd0\x81.\xf4\xa0\x0f\x03\xa8C\x05F\x10&~>"\xf9]\xc6\x88\x16\x86\xbbj\xc6dZ\x98L<\xb7\xae\x9a|\xc74\x08\xed\xba\xb2\x873L\xe0\x00)\\\xe1\x08\x0b\xd8\xc2\x0e\xee\xf0\x80\xec\xd3\xabXW\x1d\xces\xeb\xaa\xc3\xb9^\x7fy_Q\xb0K\x8a`\x01$0\x86)\xcc`\x0eKX\xc1\x1a\x86P\xb2u\xe3tr\xf8\xee\xf5\xaf\xf7\xa5\x0e\xf6\xfb\xbet\xb1\xde\xbd\x92\xf9b\x9a\x16\x7f\x94\xdc\xe0\x02\x11\x9c\xec\xef\x061l\xa0\x0cU\xa8\xd9\xbc\xee\xb4\xeb\xa5\x8a\xf5\xd3K\x15\xcb\x9e~\x01r\xfc\xb9\xee'.decode('zlib')
— Wie auch immer
quelle
2
Das sind 672 Bytes, nicht 232 Bytes.
— Nneonneo
Erkläre weiter, ich habe dich nicht verstanden. @ Nneonneo
— Was auch immer
1
Wenn Sie Ihren Code in eine Datei einfügen, ist diese Datei 672 Byte lang. Sie scheinen Ihren Code gezählt zu haben, mit len("print 'x\x9c...'")dem die \xs nicht mehr lesbar sind , was zu einer falschen Byteanzahl führt . Sie könnten eine korrekte Zählung erhalten, indem Sie mit zählen, len(r"print 'x\x9c...'")aber die einfachste Lösung besteht wie immer darin, zu sehen, was Ihr Texteditor oder Dateisystem sagt.
— Nneonneo
1

Powershell, 249 242 Bytes

"``1234567890-=Bs   
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./Shift   "-split'
'|%{($u=($r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}

Ungolfed & Erklärt

Das Middot ·verwendet stattdessen Leerzeichen, um die Quellzeichenfolge zu verdeutlichen.

"``1234567890-=Bs···
Tab··QWERTYUIOP[]\
Caps··ASDFGHJKL;'Enter
Shift···ZXCVBNM,./Shift···"-split"`n"|%{        # split the string with rows by new line
$r=,''+($_-csplit'(.[a-z ]*)'-ne''|% t*per)+''  # split each row by key labels (any char plus small letters or spaces), 't*per' is shortcut for toUpper method
$u=$r-replace'.','_'                            # replace any char to _ to take an upper 
$u-join'__ _'                                   # join labels and push 4 strings to pipe
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'
}|%{
    -join$_[2..76]                              # return substring for each string
}

# $r =
# ["","`","1","2","3","4","5","6","7","8","9","0","-","=","BS   ",""]
# ["","TAB  ","Q","W","E","R","T","Y","U","I","O","P","[","]","\",""]
# ["","CAPS  ","A","S","D","F","G","H","J","K","L",";","'","ENTER",""]
# ["","SHIFT   ","Z","X","C","V","B","N","M",",",".","/","SHIFT   ",""]
# $u =
# ["","_","_","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","_____","_","_","_","_","_","_","_","_","_","_","_","_","_",""]
# ["","______","_","_","_","_","_","_","_","_","_","_","_","_____",""]
# ["","________","_","_","_","_","_","_","_","_","_","_","________",""]
# before substring:
# __ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    |||
# _|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ _
#  |||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ |||
# _|||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||
# _\|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/
# __ _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ _
#  |||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER |||
# _|||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______|||
# _\|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|/
# __ ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________ _
#  |||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    |||
# _|||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________|||
# _\|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|/
# final output:
#  ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||BS    ||
# ||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
# ||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
# ||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
# |/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
#  _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
# ||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
# ||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
# |/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
#  ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
# ||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||SHIFT    ||
# ||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
# |/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Extra: Tastatur mit Leertaste und rechtsbündigen Beschriftungen, 278 Byte

Ich habe dem regulären Ausdruck ein paar Bytes hinzugefügt, um die Leertaste zu behandeln (alter regulärer Ausdruck (.[a-z ]*), neuer ~|(.[a-z ]*)). Das ist ein kleiner Schritt für die reguläre Ausdrucksweise, ein großer Schritt für die Lösung: Sie können jetzt rechtsbündig angeordnete Leertaste und Tastenbeschriftungen anzeigen (siehe UMSCHALTTASTE, STRG und BS auf der rechten Seite der Tastatur).

"``1234567890-=~   bs
Tab  QWERTYUIOP[]\
Caps  ASDFGHJKL;'Enter
Shift   ZXCVBNM,./~   shift
Ctrl  Alt ~$(' '*34)Alt ~  ctrl"-split'
'|%{($u=($r=,''+($_-csplit'~|(.[a-z ]*)'-ne''|% t*per)+'')-replace'.','_')-join'__ _'
$r-join' |||'
$u-join'_|||'
$u-join'_\|/'}|%{-join$_[2..76]}

Ausgabe:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||1 |||2 |||3 |||4 |||5 |||6 |||7 |||8 |||9 |||0 |||- |||= |||   BS ||
||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____
||TAB   |||Q |||W |||E |||R |||T |||Y |||U |||I |||O |||P |||[ |||] |||\ ||
||______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__||
|/______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|
 _________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||CAPS   |||A |||S |||D |||F |||G |||H |||J |||K |||L |||; |||' |||ENTER ||
||_______|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||______||
|/_______\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/______\|
 ___________ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ___________
||SHIFT    |||Z |||X |||C |||V |||B |||N |||M |||, |||. |||/ |||   SHIFT ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|
 _________ _______ _____________________________________ _______ _________
||CTRL   |||ALT  |||                                   |||ALT  |||  CTRL ||
||_______|||_____|||___________________________________|||_____|||_______||
|/_______\|/_____\|/___________________________________\|/_____\|/_______\|
— mazzy
quelle
0

/// 360 Bytes

/f/!!//e/SHIFT   //d/\/\///c/ "db/ 
\|\|da/\\\|d@/#####d?/__d>/?\\\\a
c"d</aa
ad:/fffff!d&/ccccd%/ aaad#/?aaa?aaad"/??d!/?\\\\a\\\d&&&cc"b`%1%2%3%4%5%6%7%8%9%0%-%=%BS    <|@#?|||"?<\/:f">&&&cbTAB  %Q%W%E%R%T%Y%U%I%O%P%[%]%\\ <|"@#?|||?<\/":f>_&&&"bCAPS  %A%S%D%F%G%H%J%K%L%;%'%ENTER <|"_@#"?<\/"_:!">?_&&ccc"?_be%Z%X%C%V%B%N%M%,%.%\/%e <|""_|||@""_<\/"?_:""_\a

Probieren Sie es online!

— Conor O'Brien
quelle
0

Mathematica 323 Bytes

Uncompress@"1:eJyt00luwjAUgGE2vUdYsWGeEeoiUGYIEKcTTWXEBXqBd3jy26CUYWe/xads8iT/sounv1gFL4VCoLNxxnyk9UZT5BiISAOa0II2dKALPejDAOpQgVcYqSAbEbtOa3GFuayraZ2mPmWyL5bnIZyxR0/CkQkhe/iECcSQwDe8wwK2sIMf+IV/IW0H56LXkJej+016E9LXlRyHO2VLhqDgDaYwgzksYQVrGELJZI+SSXxX0uOV9Jry2Y10q5iHVPPFNLGvUw7wBWP4ME8XIthAGapQM93zv29COlV8DOkrol10BmvF28U="

Langweilig und unkreativ. Die Zeichenfolge ist nur die Ausgabe des integrierten CompressBefehls, der auf die gewünschte Ausgabe angewendet wird.

— Ian Miller
quelle
@Downvoted Bitte geben Sie an, was mit meinem Programm nicht stimmt.
— Ian Miller
0

Wolfram Language (Mathematica) , 293 Byte

c=##&@@(#|2&/@Characters@#)&
r=StringRiffle
p=StringPadRight
Print/@{j=p["",#2,"_"]&@@@#;(" __"<>#&/@j)<>" ",r[p@@@#,i={l="||","|||",l}],j~r~i,j~r~{"|/","\|/","\|"}}&/@{{c@"`1234567890-=","BS"|6},{"TAB"|6,c@"QWERTYUIOP[]\\"},{"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},{h="SHIFT"|9,c@"ZXCVBNM,./",h}}

Probieren Sie es online!

Relativ einfach: Codiert Schlüsselzeilen als Listen von (key name)|(key width)

c=##&@@(#|2&/@Characters@#)&    (*converts a string into (key)|2 s*)
r=StringRiffle
p=StringPadRight
 Print/@
  {j=p["",#2,"_"]&@@@#;
   (" __"<>#&/@j)<>" ",         (*top of the keys*)
   r[p@@@#,i={l="||","|||",l}], (*key names*)
   j~r~i,                       (*space under key names*)
   j~r~{"|/","\|/","\|"}            (*bottom of the keys*)
  }
 &/@
{
 {c@"`1234567890-=","BS"|6},
 {"TAB"|6,c@"QWERTYUIOP[]\\"},
 {"CAPS"|7,c@"ASDFGHJKL;'","ENTER"|6},
 {h="SHIFT"|9,c@"ZXCVBNM,./",h}
}
— attinat
quelle
0

Perl 5 -MList::Util=pairmap , 313 Bytes

pairmap{$_=$b;s/\|{3}/|-|/g;y/-/_/c;y/-/ /;s/./ /;chop;say;$_=$b;for$r($a=~/./g){s/\| /|$r/}say;y/|/_/c;say;s,\|_,/_,g;s/_\|/_\\/g;say}"`1234567890-=",($;="||  |")x13 ."||BS    ||","QWERTYUIOP[]\\",'||TAB   |'.$;x13 .'|',"ASDFGHJKL;'","||CAPS   |".$;x11 ."||ENTER ||","ZXCVBNM,./",($s='||SHIFT    |').$;x10 ."$s|"

Probieren Sie es online!

— Xcali
quelle
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.