Klawiatura tak realna, że ​​możesz ją prawie SMRZEĆ

126

... Nie tak, prawda? Zadanie jest proste, wypisz następujący tekst:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________ 
||` |||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    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

To jest klawiatura przyszłości, ponieważ w przyszłości spacje nie mają znaczenia, podobnie jak spacje.

Aby ci było nieco łatwiej:

  1. 0123456789ABC...XYZ-=[]\;',./ - Znaki te znajdują się na klawiszach o długości 6 (łącznie z wypełnieniem).
  2. TAB / BS / ENTER - Te klucze mają długość 10 (łącznie z wypełnieniem).
  3. CAPS - Ten klucz ma długość 11 (łącznie z wypełnieniem).
  4. SHIFT - Ten klucz ma długość 13 (w tym obicie z obu stron).

Każdy pojedynczy klucz wygląda mniej więcej tak:

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

Należy jednak pamiętać, że dwa kolejne klucze nie są:

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

Ale są „połączone”:

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

To wyzwanie nie powinno być takie złe, powodzenia; nie przegap nadużywania powtórzeń! Ale nie lekceważ też „specjalnych” kluczy;).

Zwycięski?

Najkrótszy kod wygrywa, ponieważ znasz ten kod-golf .

code-golf  ascii-art  kolmogorov-complexity 
— Urna Magicznej Ośmiornicy
źródło
49
Muszę przyznać, że jestem zaskoczony, że niewielu ludzi martwi się futurystycznymi klawiaturami niezawierającymi spacji ...
— Magic Octopus Urn
97
Wydaje mi się, że spacje wcale nie były ostatnią granicą.
— Greg Martin
48
„SMAK” to niemieckie słowo „klucz” :)
— QBrute,
31
„SMAK” to norweskie słowo oznaczające „pisanie na klawiaturze” :)
— Stewie Griffin,
32
Ale to angielskie słowo „smak”. Tutaj .
— Pan Lister,

Odpowiedzi:

117

V , 189, 179, 175, 164, 161, 157, 155, 149, 145, 141 , 135 bajtów

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

Wypróbuj online!

Ta odpowiedź jest teraz dostępna na Twitterze!

Zobacz, jak biegnie! Jest to nieco zmodyfikowana wersja, która jest aktualizowana podczas pracy, abyś mógł zobaczyć, jak to działa. To jest przestarzała wersja, ponieważ nie udało mi się jeszcze jej nagrać, ale ogólne podejście jest identyczne.

Jest to prawdopodobnie najdłuższa odpowiedź V, jaką kiedykolwiek napisano. Z pewnością nie pomogło to, że tłumacz V jest bardzo wolny. Napisanie pierwszej wersji zajęło mi około godziny, ale wielokrotnie do niej wracałem, żeby za każdym razem golić kilka bajtów. Ponieważ pełna klawiatura ma 1215 bajtów, obecnie ta odpowiedź jest o 91% krótsza niż wynik, więc jestem całkiem zadowolony z wyników.

Ponieważ zawiera on niektóre niedrukowalne znaki i wiele wulgarnych znaków spoza ASCII, oto zrzut heksowy:

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

Jak do cholery to działa?

W porządku, to wyjaśnienie będzie kłopotliwe. Jesteś gotowy? Po pierwsze, musimy wprowadzić litery, abyśmy mogli zbudować wokół nich klucze. To jest

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

Które wstawia:

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

Wchodzi w to dość prosto, ale istnieje kilka sztuczek, których używamy do ratowania postaci. Na przykład ¬19wpisuje „123456789”, ³wprowadza trzy spacje i powielamy zmianę, aby nie trzeba było jej wprowadzać wiele razy.

Zwróć uwagę, jak litery są tutaj małe. Dzięki temu możemy łatwo odróżnić klawisze wielkich liter, takie jak „ENTER” i pojedyncze litery. Pisanie ich w ten sposób ułatwia stwierdzenie, które postacie wcześniej umieścić pasek, i dodaje tylko jeden bajt, aby później przekonwertować je na małe litery. Dlatego wykonujemy polecenie zastępcze, aby przekonwertować je na wielkie litery i dodawać po jednym spacji po każdym z nich:

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

Teraz bierzemy każdą sekwencję klawiszy (dowolny ciąg spacji) i umieszczamy trzy paski przed i po nich:

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

W tym momencie bufor wygląda następująco:

|||` |||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    |||

Posiadanie trzech słupków w pierwszej i ostatniej kolumnie jest w rzeczywistości bardzo wygodne i pozwala zaoszczędzić wiele bajtów na dłuższą metę.

I tutaj biegamy jedną gigantyczną pętlą. Spowoduje to konwersję czegoś takiego:

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

w coś takiego:

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

Wszystko między dwoma wystąpieniami òbędzie działało, dopóki nie wystąpi błąd, co nastąpi, gdy spróbujemy przejść do linii, która jeszcze istnieje. Ponieważ właśnie uruchomiliśmy globalną komendę zastępczą , nasz kursor znajduje się w ostatnim wierszu i zmienimy je, przesuwając się w górę.

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

To jest

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

linia.

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

To jest

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

Linia.

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:
     _ _  "     '_ _'

To jest:

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

Linia.

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

Teraz mamy pełną klawiaturę, ale każda linia zawiera dodatkowy pasek, dodatkowy ukośnik (do przodu lub do tyłu) lub dodatkowy znak podkreślenia. Bardzo łatwa naprawa

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

Po całym tym szaleństwie bufor jest domyślnie drukowany.

— DJMcMayhem
źródło
1
Wydaje się, że są 4 dodatkowe podkreślenia w pustej przestrzeni po prawej stronie wydruku?
— ErikE
7
Nie doceniasz, jak golfowa jest ta odpowiedź.
— Magic Octopus Urn
1
@carusocomputing Haha, myślę, że masz rację. Jestem bardzo dumny z tej odpowiedzi i mojego języka jako jedynej odpowiedzi pokonującej gumę do żucia. :)
— DJMcMayhem
2
@DJMcMayhem Oznaczenie Cię jako zwycięzcy, jeśli nikt nie pokona Cię do 1/3/2017;).
— Magic Octopus Urn
7
Nawiasem mówiąc, jest to zdecydowanie moja ulubiona odpowiedź na stronie. Nie mogę policzyć, ile razy oglądałem GIF.
— Magic Octopus Urn
41

Lua 5.3, 416 394 bajtów.

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

Bez golfa i z komentarzami.

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

Wynik

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||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    ||
||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
|/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Zostanę zniszczony przez inne języki, ale pomyślałem, że dam temu szansę. Niezła złożoność, a przynajmniej krótsza niż klawiatura!

— ATaco
źródło
15
Pieprzyć inne języki, byłeś pierwszy w rzadkim języku! Imponujące, ale jestem pewien, że zdecydowanie nie musisz umieszczać potoków jako ograniczników na każdej literze. Zauważ, że „specjalne” klawisze znajdują się tylko na początku i na końcu linii. Jestem pewien, że ta podpowiedź może jakoś zaoszczędzić cenne bajty.
— Magic Octopus Urn
Z jakiej wersji Lua korzystasz? Na Lua 5.1 daje mi błąd składniowy: stdin: 1: zniekształcona liczba w pobliżu '2j'
— brianush1
5
@ Brianush1 Lua 5.3, pozwala stałym liczbom siedzieć obok dowolnej litery, która nie jest cyfrą szesnastkową lub „x” w przypadku 0.
— ATaco
29

Bubblegum , 191 bajtów

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......|.

Wypróbuj online!

— Dennis
źródło
1
Bubblegum jest niesprawiedliwe.
— Joshua
7
@Joshua dobrze jest ustalić punkt odniesienia dla rozwiązań. i jeśli nic nie jest w stanie pokonać gumy do żucia, to jest problem.
— Sarge Barszcz
19

Haskell, 263 znaków (353 bajtów 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(:" ")

zrzut ekranu tej klawiatury

Ponieważ dyskutowano o wynikach w świetle tych znaków Unicode ... oto ten sam program, zredukowany do wszystkich ASCII:

Haskell, 263 znaki (263 bajty 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(:" ")
— przestał się obracać w lewo
źródło
3
Klawiatura Unicode? Ciekawy wybór (ładnie wyglądające litery matematyczne), ale myślę, że narusza to zasady konkursu.
— Mario Carneiro
@MarioCarneiro Szczerze mówiąc, nie ma to żadnego wpływu na długość programu.
— pydsigner
1
@pydsigner Tak, ponieważ podobne słowa ENTERsą dłuższe niż takie jak znaki ↩︎.
— timothymh,
5
Ale porównujesz, ENTER a ↩︎ wypełnienie spacjami sprawia, że ​​ma tę samą długość.
— CodeMonkey,
2
Właściwie oczekuję, że Unicode wydłuży program o liczbę bajtów, ponieważ wysoki Unicode to więcej bajtów w UTF8 niż ASCII.
— Mario Carneiro,
18

PHP, 303 bajty

Leniwy, ale skuteczny. :)

<?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbEAvA88wBuzPsg8vPyLZo3tOMUXmt1k/iy+ycfXYj88kacvIg1oQgva0IEu9KAPA6hDBUYQJn4+IvldxogWhrtqxmRamEw8t66afMc0CO26soczTOAAKVzhCAvYwg7u8IDs06tYVx3Oc+uqw7lef3lfUbBLimABJDCGKcxgDktYwRqGULJ143Ry+O71r/elDvb7vnSx3r2S+WKaFn+U3OACEZzs7wYxbKAMVajZvO6066WK9dNLFcuefgE'));
— Alex Howansky
źródło
1
Miły. Irytujące jest to, że nie mogę uzyskać tego samego poziomu kompresji w przypadku kompresji / gzip / bzip2 / 7z, w przeciwnym razie wersja Bash byłaby troszkę krótsza. W obecnej postaci ma 318 znaków.
— Konrad Rudolph,
14
Jestem prawie pewien, że użycie zewnętrznego algorytmu kompresji, którego nie ma w twoim programie, jest zbanowane lub przynajmniej źle przyjęte. To przeczy celowi pytania.
— Nikt
1
@KonradRudolph Jak rozumiem, gzdeflate () używa tej samej kompresji, co linia poleceń gzip, ale pomija nagłówek pliku i sumę kontrolną, więc zawsze będzie nieco krótsza.
— Alex Howansky
300 bajtów: <?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbHA+0QEvDHrg8zDy79EMbTDFF+3m8yfXdek42phHJG3KyItaEMHutCDPgxgCCNoQg0mMI3cdETSu4wRLQx3NYxJtDCJOL9t1cnSFWNvareVE1xhASHEcIczbOAIATzhBck3V7atupuTb6vulucq43XNvCDKenkQwRyWsII1bGEHexhDxcb140X4n6us16XuVXxdulZZrmi9WcbZd5IH3GAGF/vXwIcDVKEODVs3P53nUrUq5FK1sqc/'));. Kompresor: sandbox.onlinephpfunctions.com/code/… Dekompresor: sandbox.onlinephpfunctions.com/code/…
— Ismael Miguel
4
@ Nikt Nie ma nic zewnętrznego, gz jest częścią domyślnej kompilacji PHP i dlatego jest domyślnie dozwolony.
— Alex Howansky
18

Python 3.5+, 239 bajtów

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
źródło
Czy Python 3.5+ jest potrzebny na ikonę wewnątrz krotek, czy coś innego?
— mbomb007,
1
Możesz zapisać jeden bajt, jeśli odwrócisz konstrukcję każdego klucza i użyjesz go "".join(...) + f[0]w wewnętrznej pętli. Zamiana formatkolejności argumentów i odpowiednich symboli zastępczych w ciągu również oszczędza dwa kolejne bajty.
— dfernan
['{1}__ ','|{} ||','|{1}||','/{1}\\|']jest krótszy niż użycie split.
— Alex Hall,
16

Partia, 465 452 bajtów

@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

:cPodprogram obsługuje linię kluczy. Klucze zawierające dodatkowe spacje muszą być cytowane, jak zrobić =, ;, ,klucze, prawdopodobnie z powodu błędu w shiftpoleceniu. Pierwszy i ostatni parametr to ciągi o _tej samej długości, co pierwszy i ostatni klucz ułatwiający konkatenację. tnastępnie kończy się jako _s wspólny dla pierwszego, trzeciego i czwartego rzędu, ze #znakiem s łączenia, które są odpowiednio zamieniane przed dodaniem znaków wiodących i końcowych, podczas gdy sjest drugim rzędem, ale |s zmienia się na !s, ponieważ zmniejszają się liczba "potrzebnych mi. Edycja: Zapisano 1 bajt, drukując wszystkie cztery linie w jednej instrukcji i 12 bajtów, optymalizując sposób, w jaki przypisałem szmienną.

— Neil
źródło
14

Rubinowy, 226 bajtów

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]}

Ulepszenia w następujący sposób:

1. Brak pustych elementów łańcucha na początku i na końcu tablicy. Zamiast tego tablica jest potrojona, tworząc 3 klawiatury obok siebie. Po konwersji na ciąg mamy 3 klawiatury z brakującymi krawędziami zewnętrznymi. Jest on obcinany, aby wyświetlać tylko środkowy, wraz z krawędziami.

2. Zmieniona wersja Ruby. Użyłem Ideone zamiast 1.9.3 zainstalowanego na moim komputerze. Oznacza to, że .chars.to_amożna go skrócić do sprawiedliwego .chars.

Rubinowy, 239 bajtów

Jest z tego jeszcze kilka bajtów. Będzie wyglądać jutro.

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]}

bez golfa

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
źródło
13

C #, 357 bajtów (w jednym wierszu i zawierające większość sugestii)

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);

Lub 353 z interpolacją ciągów znaków i wszystkimi innymi sugestiami

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);

Nie golfowany (bez interpolacji ciągów):

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
źródło
5
Możesz zapisać wiele bajtów formatujących kod w golfa jako jedną linię:foreach(var r in q){for(int i=0;i<4;i++){foreach...
— Mario,
1
@Mario Właśnie sprawdziłem bajt, podana wartość jest w rzeczywistości liczbą bez nowych
— wierszy
1
Lekko golf w dół do 397 bajtów, stosując interpolację i zastępowania ==z< s+=i<1?$" {u}__":i<2?$"||{k.PadRight(l)}|":i<3?$"||{u}|":$"|/{u}\\";
— Alfie Goodacre
Dzięki @Alfie Goodacre. Zamieniłem „==” na „<” zgodnie z twoją sugestią. Zostawiłem interpolację, aby była mniej specyficzna dla wersji.
— Klinger
@Klinger Zgadzam się, interpolacja również nie działa na żadnym kompilatorze online, więc jest to dobry wybór!
— Alfie Goodacre,
10

PowerShell v2 +, 465 bajtów

($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'#','|||'

Jestem w połowie zawstydzony, że mogę opublikować tę odpowiedź, biorąc pod uwagę, jak krótkie są odpowiedzi PHP i Python, bez względu na odpowiedź w języku C #, ale nie jestem w stanie skrócić tej metody. Inne podejścia mogą dać lepsze wyniki.

Zasadniczo jest to po prostu gigantyczny wieloliniowy ciąg znaków, ze zmiennymi ( $ai podobnymi) zastępującymi różne podciągi i kilkoma -replaces na końcu, aby je zakończyć. W $(...)razie potrzeby wstawiane są bloki skryptów w celu wprowadzenia nowych zmiennych.

Wypróbuj online!

— AdmBorkBork
źródło
7

Python, 493 458 bajtów.

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)

Funkcjonalnie równoważny, ale nieco bardziej czytelny:

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)

Niestety jest już dłuższy niż odpowiedź udzielona w Lua.

— Cobi
źródło
Możesz umieścić linie w pfunkcji na jednym wierszu oddzielonym średnikami. Pomyślałem też, że nie możesz zrobić pierwszego wiersza k=[['|']*75]*16, wiesz dlaczego?
— nedla2004
Możesz także zdefiniować '_'i ' 'do zmiennej, aby zapisać niektóre bajty.
— nedla2004
Dzięki za wskazówki! Myślę, że k = [['|'] * 75] * 16 tworzy szesnaście odwołań do tej samej tablicy, więc zmiana w jednej linii wpływa również na inne.
— Cobi,
Okej, możesz przynajmniej zmienić range(16)na [0]*16.
— nedla2004
Niewielkim problemem jest to, że Twój kod nie generuje technicznie właściwych danych wyjściowych, ale możesz to naprawić, zmieniając for l in k:print ' '.join(l)na for l in k:print''.join(l).
— nedla2004
7

PHP, 316 312 bajtów

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;

Jestem prawie pewien, że tego podejścia nie można dalej grać w golfa. Ale jeśli ktoś znajdzie jeszcze 10 bajtów ...: D
Uruchom z -r.

awaria

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
            ;
— Tytus
źródło
6

Bash (w OSX), 12 8 + 221 + 1 = 234 230 bajtów

Tak, wiem, kompresja. Ale to działa, nie?

gunzip<f

Wymaga pliku o nazwie „f” w bieżącym katalogu z następującą zawartością (włożony do base64 dla wygody PPCG - można go najpierw zdekodować do pliku „f”.):

H4sIAHbPT1gAA63TuQ6CQBCA4Z6noLPxvo2xALwPPMAbsz7IPLz8i2aN7TjFFxo2mT+7vsnH12I/PJGnLyINaEIL2tCBLvSgDwOoQwVGECZ+PiL5WcaIFoazasZkWphMPLeumnzHNAjturKHM0zgAClc4QgL2MIO7vCA7NOrWFcdznPrqsO5Xn+5X1GwS4pgASQwhinMYA5LWMEahlCydeN0cvju9a/7pQ72e790sd69kvlimhYvSm5wgQhO9rlBDBsoQxVqNq/72/VSxfrppYpV9HoBoNfjQcAEAAA=
— Addison Crump
źródło
4
Może być trywialnie krótszy, pisząc gunzip<f.
— Konrad Rudolph,
@KonradRudolph Doskonały punkt. Dzięki.
— Addison Crump,
Możesz zapisać 2 bajty za pomocą zcat fi 2 bajty, usuwając dwa końcowe bajty zerowe (gzip narzeka, ale generuje pożądane dane wyjściowe).
— Gilles
@Gilles Tak naprawdę nie oszczędza mi bajtów - musiałbym zmienić nazwę pliku „fZ” (przynajmniej na OSX). Usunięcie końcowych bajtów zerowych nie tylko powoduje narzekanie przez gzip - powoduje błąd i nie drukuje niczego.
— Addison Crump,
@VoteToClose No tak, zcat<fwięc. W Linuksie Zcat bez końcowych zer powoduje, że gzip narzeka („gzip: stdin: nieoczekiwany koniec pliku”), ale tylko po wydrukowaniu pożądanego wyniku.
— Gilles
5

JavaScript (ES6), 286

Anonimowa funkcja bez parametrów

_=>[..."`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`
`

Mniej golfa

_=>[..."`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>
Rozwiń fragment kodu

— edc65
źródło
5

Szybki, 777 bajtów

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 nie jest na ogół dobrym wyborem do gry w golfa, więc bycie mniej niż dwukrotnością obecnej najmniejszej odpowiedzi (która była szybka) jest tutaj dobrym wyzwaniem!

Nie golfowany:

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()
— nazwa użytkownika tbd
źródło
2
przynajmniej nie jest to Applecript
— Addison Crump,
1
Teraz muszę zrobić Java nie ja
— CAD97
4

SOGL V0.12 , 131 128 127 bajtów ( konkuruje? )

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

SOGL ma 2*2/i 2/2*dziwactwa, ale te wydają się zbyt wbudowane w to wyzwanie.
Wypróbuj tutaj!

...‘               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
źródło
Wow, to jest super imponujące! Nikomu jeszcze nie udało się mnie pokonać, więc dobra robota! Mogę spróbować trochę skrócić moje, ale żadnych obietnic. ;)
— DJMcMayhem
@dzamia, mimo że teraz konkuruje, zaakceptowałem odpowiedź, kiedy tak nie było. Czy powinienem zamieniać odpowiedzi?
— Magic Octopus Urn
@MagicOctopusUrn IMO to zależy od Ciebie. Jest powód, dla którego sugeruje się, że nie przyjmuje odpowiedzi: p
— dzaima
Sugeruje się, aby nie akceptować odpowiedzi? Och ... w porządku. Więc chyba przestanę akceptować odpowiedzi w przyszłości i zostawię rzeczy takimi, jakie są.
— Magic Octopus Urn
@MagicOctopusUrn w porządku, być może nieakceptowanie odpowiedzi jest nieco kontrowersyjne, ale wciąż bardzo pozytywne
— dzaima
4

Python 2, 394 388 380 bajtów

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)

Po prostu buduje duży ciąg znaków reprezentujący całą klawiaturę, zamienia * na% s dla klawiszy specjalnych, a następnie używa formatowania łańcucha, aby zaktualizować specjalne.

Edytować

Teraz ma końcowy znak nowej linii na końcu wyniku, ale nie widzę nigdzie niedozwolonego.

Wypróbuj online!

— ElPedro
źródło
Myślę, że powinieneś usunąć wynik, ponieważ nie dodaje nic istotnego.
— sergiol
1
@sergiol - dobry punkt. Nie był świadomy TIO w momencie publikacji. Teraz zaktualizowane.
— ElPedro
3

C #, 376 bajtów (w jednym wierszu)

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);

Jest to całkowicie oparte na odpowiedzi C # Klingera. Nie mam wystarczającej liczby przedstawicieli, aby skomentować jego odpowiedź, inaczej bym to zrobił.

Byłem w stanie zmniejszyć kod Klingera o 5 bajtów, modyfikując początkową pętlę foreach i usuwając zewnętrzne nawiasy klamrowe.

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
źródło
Dobry @Bence Joful. Z twoją sugestią byłbym w stanie uzyskać ją do 367. Nie uwzględniłem obecnej odpowiedzi.
— Klinger
Nie może się oprzeć. Twoja sugestia + kilka dodatkowych drobnych zmian sprowadza ją do 361 (lub 358 z interpolacją łańcuchów).
— Klinger
@Klinger - skorzystaj z moich poprawek! Zainspirowałem się do zabawy w oparciu o twoją pracę. Nauczyłem się czegoś o inicjalizacji.
— Bence Joful
Czy możesz dołączyć program jednowierszowy? Nie stracisz zbyt wiele czytelności w porównaniu z obecną
— Cyoce
@Cyoce, rozumiesz, dzięki za sugestię. Chociaż w tym momencie Klinger opublikował już nową, mniejszą wersję zawierającą te zmiany.
— 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    )

Nie golfowany:

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    )

(Właściwie to po raz pierwszy gram w golfa i próbuję m4.)

— Kryminał
źródło
Nieźle jak na pierwszą odpowiedź. Witamy na stronie! :)
— DJMcMayhem
3

ułożone w stos , 228 bajtów

Wypróbuj tutaj!

[,{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

Lub, nieco bardziej czytelny:

{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

Działa to poprzez zdefiniowanie funkcji, pktóra tworzy klucz, a następnie wprowadzenie hcatwielu kluczy.

— Conor O'Brien
źródło
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]

Z perspektywy czasu, podobny w koncepcji do odpowiedzi Haskella , ale produkuje klawiaturę ASCII i nieco różni się golfem.

Sformatowane i przemianowane:

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
źródło
2

tcl, 368

Jak policzone przez http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/ z „Policz podziały linii jako spacje”. włączony, zajmuje 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

Ungolf:

Współpraca na żywo na stronie 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
}

Każdy może bezpłatnie poprawić moją wersję na stronach współpracy na żywo, ale proszę: nie edytuj mojej oryginalnej odpowiedzi tutaj; po prostu powiedz, że edytowałeś w komentarzach, a ludzie odwiedzą linki.

AKTUALIZACJA 1: Zastąpiony forprzez foreach, ponieważ ten ostatni tworzy krótszy kod

AKTUALIZACJA 2: Zastąpiona foreachprzez lmap, ponieważ ta ostatnia wytwarza krótszy kod

AKTUALIZACJA 3: Ogoliłem jeden znak, ponieważ zostałem zastąpiony " "przez\

AKTUALIZACJA 4: W odniesieniu do pierwszego komentarza zmieniłem wszystkie znaki zastępcze Unicode pierwszego wiersza 2 bajty na 1 bajt ASCII

AKTUALIZACJA 5: wiele putslinii utworzonych w jedną

AKTUALIZACJA 6: użyj bezpośrednio splitpoleceń zwracających wartości lmapwywołania zamiast używać zmiennych listy pośredniej

AKTUALIZACJA 7: Cytaty wokół ENTERnie były potrzebne

AKTUALIZACJA 8: string map jest wystarczająco długa i kilkakrotnie powtarzana, że ​​warto ją zamknąć w plikuproc

AKTUALIZACJA 9: split $x \n jest wystarczająco długa i kilkakrotnie powtarzana, że ​​warto ją zamknąć w plikuproc

AKTUALIZACJA 10: Przy „zamianie” można użyć łańcucha &zamiast \1, ponieważ w tym przypadku oba się pokrywają; kolejną tego konsekwencją jest to, że pozwala pozbyć ()się „pasującego” łańcucha.

AKTUALIZACJA 11: Użyj @zamiast \njako separatora linii do dalszego wykorzystania splitinstrukcji. Mimo, że „mecz” ciąg od wydłuża \Ssię [^@]to opłaca, ze względu na liczbę powtórzeń

AKTUALIZACJA 12: Zastąpił pierwszy regsubciąg „dopasowujący” {[^@|]}, \[^@|]aby zgolić jeden znak. Niestety nie mógł zrobić tego samego z drugim regsub, ponieważ instrukcja znajduje się w parze []:(

AKTUALIZACJA 13: Ogolono dwa znaki Enter, koncentrując lmapciało własnym nagłówkiem.

AKTUALIZACJA 14: Użyto wywołania splitprocedury Nbazowej zamiast bezpośredniego wywołania string mapprocedury bazowej, Nco pozwala skrócić o 3 znaki

AKTUALIZACJA 15: Wystąpiła niepotrzebna postać spacji. Usunąłem go, aby zgolić jeden węgiel.

AKTUALIZACJA 16: set h można go osadzić, aby się go pozbyć $h, aby ogolić jedną postać.

AKTUALIZACJA 17: set h instrukcję można naprawdę zgolić.

AKTUALIZACJA 18: puts argument zmieniono z ...\n...\n...\n...formatu na

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

format.

Dzięki ludziom, którzy pomogli mi go skrócić, szczególnie evilotto i aspekt kanału IRC tcl!

— sergiol
źródło
Ładna odpowiedź i Witamy na stronie! Wprowadziłem niewielką zmianę w twoim poście, aby liczba bajtów pojawiła się w nagłówku. Mam nadzieję, że nie masz nic przeciwko. Wiesz, myślę, że w rzeczywistości jest to 469 bajtów, ponieważ niektóre z tych znaków są wielobajtowe w UTF-8. Nie wiem bardzo dużo o tcl, czy używa niestandardowego kodowania, gdy są one jednym bajtem?
— DJMcMayhem
@DJMcMayhem Nie wiedziałem, że była oparta na liczbie bajtów zamiast liczby znaków, ale nie stanowi to problemu, ponieważ wszystko, co jest jeszcze jednym bajtem, nie jest używane, może być symbolem zastępczym i wciąż mam wiele dostępnych.
— sergiol,
@DJMcMayhem po mojej edycji zniknął zgłoszony przez Ciebie problem!
— sergiol,
@DJMcMayhem Dlaczego 401 na górze miało przez jakiś czas żółte tło?
— sergiol,
2

tcl, 369

Początkowo oparty na wersji sergiol tcl.
(Zauważ, że wiele lewych spacji jest częścią „natury” tcl)

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
źródło
@muddyfish Edytowane i naprawione. Dzięki!
— Alejandro Muzzachiodi
Możesz skrócić więcej, jeśli bezpośrednio zastąpisz wszystkie foreachwystąpienia lmap!
— sergiol
Próbowałem użyć twojego interp aliaspodejścia do skrócenia mojej wersji, ale najkrótszy jaki mogłem uzyskać, robiąc to 398 :( rextester.com/live/NTVAV88033
— sergiol
Moja ostatnia próba dostałem 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
Możesz zapisać jeden znak, jeśli usunąłeś niepotrzebne miejsce, jak w mojej ostatniej aktualizacji!
— sergiol
2

C (gcc) , 378 342 330 bajtów

-10 bajtów dzięki pułapkowi cat.

Pierwsze dźgnięcie w to. Powtarzane g () sugeruje pole do poprawy.

Edycja: Proszę bardzo.

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);}

Wypróbuj online!

— gastropner
źródło
1

Python 2, 672 bajtów

Za pomocą skompresowanego ciągu zlib:

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')
— Cokolwiek
źródło
2
To 672 bajty, a nie 232 bajty.
— nneonneo
Wyjaśnij dalej, nie zrozumiałem cię. @nneonneo
— Cokolwiek
1
Jeśli wkleisz kod do pliku, plik ten będzie miał 672 bajty. Wygląda na to, że policzyłeś kod, za pomocą len("print 'x\x9c...'")którego usuniesz \xobraz z s, co spowoduje niepoprawną liczbę bajtów. Możesz uzyskać prawidłową liczbę, licząc za pomocą, len(r"print 'x\x9c...'")ale najłatwiejszym rozwiązaniem, jak zawsze, jest sprawdzenie, co mówi twój edytor tekstu lub system plików.
— nneonneo,
1

PowerShell, 249 242 bajtów

"``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]}

Nieskluczone i wyjaśnione

Middot ·używa zamiast tego spacji do wyjaśnienia ciągu źródłowego.

"``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    ||
# ||_________|||__|||__|||__|||__|||__|||__|||__|||__|||__|||__|||_________||
# |/_________\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/__\|/_________\|

Dodatkowo: klawiatura ze spacją i wyrównanymi do prawej etykietami, 278 bajtów

Dodałem kilka bajtów do wyrażenia regularnego, aby obsłużyć spację (stary regexp (.[a-z ]*), nowy ~|(.[a-z ]*)). To jeden mały krok do wyrażenia regularnego, jeden wielki skok dla rozwiązania: możesz teraz wyświetlać spację i etykiety klawiszy wyrównane do prawej (patrz SHIFT, CTRL i BS po prawej stronie klawiatury).

"``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]}

Wynik:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||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
źródło
0

/// , 360 bajtów

/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

Wypróbuj online!

— Conor O'Brien
źródło
0

Mathematica 323 bajty

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

Nudne i mało kreatywne. Ciąg jest tylko wynikiem wbudowanego Compresspolecenia zastosowanego do pożądanego wyniku.

— Ian Miller
źródło
@Downvoted proszę wskazać, co jest nie tak z moim programem.
— Ian Miller
0

Wolfram Language (Mathematica) , 293 bajty

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}}

Wypróbuj online!

Stosunkowo proste: koduje rzędy kluczy jako listy (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
źródło
0

Perl 5 -MList::Util=pairmap , 313 bajtów

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|"

Wypróbuj online!

— Xcali
źródło
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.