Un clavier si réel que vous pouvez presque y goûter

126

... Pas que vous voudriez, voulez-vous? La tâche est simple, affichez le texte suivant:

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

C'est le clavier du futur car à l'avenir, les espaces ne sont pas pertinents, les barres d'espace le sont aussi.

Pour vous faciliter la tâche:

  1. 0123456789ABC...XYZ-=[]\;',./ - Ces caractères sont sur des clés de longueur 6 (y compris le rembourrage).
  2. TAB / BS / ENTER - Ces touches sont de longueur 10 (y compris le rembourrage).
  3. CAPS - Cette clé est de longueur 11 (y compris le rembourrage).
  4. SHIFT - Cette clé est de longueur 13 (y compris le rembourrage, des deux côtés).

Chaque clé individuelle ressemble plus ou moins à ceci:

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

Cependant, vous devez noter que deux clés consécutives ne sont pas:

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

Mais ils sont "conjoints":

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

Ce défi ne devrait pas être trop mauvais, bonne chance à vous; ne manquez pas d'abuser de la répétition! Mais ne sous-estimez pas non plus les touches "spéciales";).

Gagnant?

Le code le plus court gagne car c'est le code-golf que vous connaissez.

code-golf  ascii-art  kolmogorov-complexity 
— Urne Magique De Pieuvre
source
49
Je dois avouer que je suis surpris de constater que peu de gens s'inquiètent pour les claviers futuristes ne contenant pas d'espaces ...
— Magic Octopus Urn
97
Je suppose que les espaces ne sont pas la dernière frontière après tout.
— Greg Martin
48
"TASTE" est le mot allemand pour "clé" :)
— QBrute
31
"TASTE" est le mot norvégien pour "dactylographie" :)
— Stewie Griffin
32
Mais c'est le mot anglais pour "flavour". Ici .
— M. Lister

Réponses:

117

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

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

Essayez-le en ligne!

Cette réponse est maintenant tweetable!

Regardez-le courir! Ceci est une version légèrement modifiée qui se met à jour au fur et à mesure de son exécution pour vous permettre de voir comment cela fonctionne. Ceci est une version obsolète puisque je n'ai pas encore pris la peine de le réenregistrer, mais l'approche générale est identique.

C'est probablement la plus longue réponse en V jamais écrite. Cela n'a certainement pas aidé que l'interprète de V soit extrêmement lent. Il m’a fallu environ une heure pour écrire la première révision, mais j’y suis retourné à plusieurs reprises pour gagner quelques octets à chaque fois. Le clavier complet ayant une longueur de 1215 octets, cette réponse est actuellement 91% plus courte que la sortie. Je suis donc assez satisfait du résultat.

Comme il contient des caractères non imprimables et beaucoup de caractères non-ASCII, voici un vidage hexadécimal:

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

Comment diable ça marche?

Bon, cette explication va être un doozy. Tu es prêt? Tout d’abord, nous devons entrer les lettres pour pouvoir construire les clés autour d’elles. C'est

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

Quels inserts:

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

Cela entre assez facilement, mais nous utilisons quelques astuces pour sauvegarder des personnages. Par exemple, entrez ¬19"123456789", ³entrez trois espaces et nous dupliquons le décalage afin d'éviter de le saisir plusieurs fois.

Notez comment les lettres sont en minuscule ici. Cela permet de distinguer facilement les touches majuscules telles que "ENTRER" et les lettres simples. En les écrivant de cette manière, il est plus facile de déterminer quels caractères doivent être placés avant, et d'ajouter un octet pour les convertir en minuscules plus tard. Nous faisons donc une commande de substitution pour convertir ceux-ci en majuscules, et ajoutons un espace après chacun d'eux:

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

Maintenant, prenons chaque séquence de touches (toute série d’espaces non-blancs) et mettons trois barres avant et après elles:

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

À ce stade, le tampon ressemble à ceci:

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

Avoir trois barres sur les première et dernière colonnes est en fait très pratique et permet d'économiser beaucoup d'octets à long terme.

Et voici où nous courons une boucle géante. Cela convertira quelque chose comme ceci:

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

dans quelque chose comme ça:

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

Tout ce qui se trouve entre deux instances de òfonctionnera jusqu'à ce qu'une erreur se produise, ce qui se produira lorsque nous essayons de monter dans une ligne qui existe encore. Comme nous venons d'exécuter une commande de substitution globale , notre curseur se trouve sur la dernière ligne et nous allons les transformer en remontant.

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

C'est le

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

ligne.

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

C'est le

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

Ligne.

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

C'est le:

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

Ligne.

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

Nous avons maintenant le clavier complet, mais chaque ligne contient une barre supplémentaire, une barre oblique supplémentaire (en avant ou en arrière) ou un trait de soulignement supplémentaire. Solution super facile

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

Après toute cette folie, le tampon est implicitement imprimé.

— DJMcMayhem
source
1
Il semble y avoir 4 traits de soulignement supplémentaires dans l'espace vide du côté droit de la sortie?
— ErikE
7
Vous sous-estimez à quel point cette réponse est lamentable.
— Urne Magique Octopus
1
@carusocomputing Haha, je suppose que vous avez raison. Je suis très fier de cette réponse et de mon langage comme étant la seule réponse à battre bubblegum. :)
— DJMcMayhem
2
@DJMcMayhem Vous marquer comme le gagnant si personne ne vous bat avant le 1/3/2017;).
— Urne magique Octopus
7
C'est toujours de loin ma réponse préférée sur le site, d'ailleurs. Je ne peux pas compter combien de fois j'ai regardé le GIF.
— Urne Magic Octopus
41

Lua 5.3, 416 394 octets.

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 et avec des commentaires.

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

Sortie

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

Je vais être détruit par d'autres langues, mais je pensais tenter le coup. Belle quantité de complexité, et au moins c'est plus court que le clavier!

— ATaco
source
15
Voyez d'autres langues, vous avez été le premier dans une langue rare! Impressionnant, même si je suis sûr que vous n’avez certainement pas besoin de mettre des séparateurs comme séparateurs à chaque lettre. Notez que les touches "spéciales" se trouvent uniquement au début et à la fin des lignes. Je suis sûr que cet indice pourrait vous faire économiser de précieux octets.
— Urne magique Octopus
Quelle version de Lua utilisez-vous? Sur Lua 5.1, cela me donne une erreur de syntaxe: stdin: 1: nombre mal formé près de '2j'
— brianush1
5
@ Brianush1 Lua 5.3, Il permet aux constantes numériques de s'asseoir à côté de toute lettre qui n'est pas un chiffre hexadécimal ou 'x' dans le cas 0.
— ATaco
29

Bubblegum , 191 octets

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

Essayez-le en ligne!

— Dennis
source
1
Bubblegum n'est pas juste.
— Joshua
7
@ Josué, il est bon de définir une base de référence pour les solutions. et si rien ne peut battre bubblegum, c'est le problème du problème.
— Sarge Borsch
19

Haskell, 263 caractères (353 octets 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(:" ")

capture d'écran de ce clavier

Comme il a été beaucoup question de la partition à la lumière de ces caractères unicode ... voici le même programme, réduit à tout ASCII:

Haskell, 263 caractères (263 octets 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(:" ")
— a cessé de tourner dans le sens antihoraire
source
3
Clavier Unicode? Choix intéressant (belles lettres de mathématiques là-bas), mais je pense que cela enfreint les règles de la concurrence.
— Mario Carneiro
@MarioCarneiro Pour être juste, cela n’affecte en rien la durée du programme.
— Pydsigner
1
@pydsigner C'est le cas, car les mots tels que ENTERsont plus longs que les caractères ↩︎.
— Timothymh
5
Mais vous comparez ENTER et ↩︎ , le remplissage d'espaces en fait la même longueur.
— CodeMonkey
2
En fait, je m'attends à ce que l'unicode rallonge le programme par nombre d'octets, car unicode élevé correspond à plus d'octets en UTF8 qu'en ASCII.
— Mario Carneiro
18

PHP, 303 octets

Fainéant mais efficace. :)

<?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbEAvA88wBuzPsg8vPyLZo3tOMUXmt1k/iy+ycfXYj88kacvIg1oQgva0IEu9KAPA6hDBUYQJn4+IvldxogWhrtqxmRamEw8t66afMc0CO26soczTOAAKVzhCAvYwg7u8IDs06tYVx3Oc+uqw7lef3lfUbBLimABJDCGKcxgDktYwRqGULJ143Ry+O71r/elDvb7vnSx3r2S+WKaFn+U3OACEZzs7wYxbKAMVajZvO6066WK9dNLFcuefgE'));
— Alex Howansky
source
1
Agréable. De manière ennuyeuse, je ne peux pas obtenir le même niveau de compression avec compress / gzip / bzip2 / 7z, sinon la version Bash serait trivialement plus courte. Dans l'état actuel des choses, il s'agit de 318 caractères.
— Konrad Rudolph
14
Je suis presque sûr que l'utilisation d'un algorithme de compression externe qui n'est pas dans votre programme est interdite ou du moins mal vue. Cela va à l'encontre du but de la question.
— Personne
1
@KonradRudolph Si je comprends bien, gzdeflate () utilise la même compression que la ligne de commande gzip, mais ignore l'en-tête du fichier et la somme de contrôle, de sorte qu'elle sera toujours un peu plus courte.
— Alex Howansky
300 octets: <?=gzinflate(base64_decode('rdO5DoJAEIDhnqegs/G+jbHA+0QEvDHrg8zDy79EMbTDFF+3m8yfXdek42phHJG3KyItaEMHutCDPgxgCCNoQg0mMI3cdETSu4wRLQx3NYxJtDCJOL9t1cnSFWNvareVE1xhASHEcIczbOAIATzhBck3V7atupuTb6vulucq43XNvCDKenkQwRyWsII1bGEHexhDxcb140X4n6us16XuVXxdulZZrmi9WcbZd5IH3GAGF/vXwIcDVKEODVs3P53nUrUq5FK1sqc/'));. Compresseur: sandbox.onlinephpfunctions.com/code/… Décompresseur: sandbox.onlinephpfunctions.com/code/…
— Ismael Miguel
4
@Nobody Il n'y a rien d'extérieur, gz fait partie de la compilation par défaut de PHP et est donc implicitement autorisé.
— Alex Howansky
18

Python 3.5+, 239 octets

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
source
Est-ce que Python 3.5+ est nécessaire pour le splat à l'intérieur des n-uplets ou autre chose?
— mbomb007
1
Vous pouvez enregistrer un octet si vous inversez la construction de chaque clé et utilisez-le "".join(...) + f[0]dans la boucle interne. L'échange de l' formatordre des arguments et des espaces réservés dans la chaîne enregistre également deux octets supplémentaires.
— dfernan
['{1}__ ','|{} ||','|{1}||','/{1}\\|']est plus courte que l'utilisation de split.
— Alex Hall
16

Lot, 465 452 octets

@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

Le :csous-programme gère une ligne de clés. Les clés contenant des espaces supplémentaires doivent être cités, comme les =, ;, ,clés, peut - être en raison d'un bogue dans la shiftcommande. Les premier et dernier paramètres sont des chaînes de _s de même longueur que les première et dernière clés pour faciliter la concaténation. tpuis se termine comme le _s commun aux première, troisième et quatrième lignes, avec #s marquant la jointure, qui sont remplacées de manière appropriée avant l’ajout des caractères de début et de fin, tandis que sc’est la deuxième ligne, mais |s est changé en !s lorsqu’elles se réduisent le nombre de "s dont j'ai besoin. Édition: enregistré 1 octet en imprimant les quatre lignes dans une seule instruction et 12 octets en optimisant la manière dont j'ai affecté la svariable.

— Neil
source
14

Ruby, 226 octets

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

Améliorations comme suit:

1.Aucun élément de chaîne vide au début et à la fin du tableau. Au lieu de cela, la matrice est triplée pour créer 3 claviers côte à côte. Après la conversion en chaîne, nous avons 3 claviers avec des bords extérieurs manquants. Ceci est tronqué pour afficher uniquement celui du milieu, avec des arêtes.

Version 2.Changed de Ruby. Utilisé Ideone au lieu de 1.9.3 installé sur ma machine. Ce moyen .chars.to_apeut être réduit à juste .chars.

Ruby, 239 octets

Il reste encore quelques octets à jouer. Je vais regarder demain.

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

non-golfé

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
source
13

C #, 357 octets (sur une seule ligne et intégrant la plupart des suggestions)

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

Ou, 353 avec interpolation de chaîne et autres suggestions

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 (sans interpolation de chaîne):

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
source
5
Vous pouvez économiser de nombreux octets en formatant le code golfé sur une seule ligne:foreach(var r in q){for(int i=0;i<4;i++){foreach...
— Mario
1
@Mario Je viens de vérifier, la valeur donnée est en fait le nombre sans nouvelles lignes, donc cela a déjà été fait techniquement
— Alfie Goodacre
1
Léger golf jusqu'à 397 octets en utilisant l'interpolation et le remplacement ==par< s+=i<1?$" {u}__":i<2?$"||{k.PadRight(l)}|":i<3?$"||{u}|":$"|/{u}\\";
— Alfie Goodacre
Merci @Alfie Goodacre. J'ai remplacé '==' par '<' selon votre suggestion. J'ai omis l'interpolation afin de la rendre moins spécifique à la version.
— Klinger
@ Klinger Je suis d'accord, l'interpolation ne fonctionne pas sur les compilateurs en ligne non plus, alors c'est un bon choix!
— Alfie Goodacre
10

PowerShell v2 +, 465 octets

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

Je suis à moitié embarrassé d'afficher cette réponse, étant donné la brièveté des réponses PHP et Python, tenez compte de la réponse C #, mais je ne parviens pas à obtenir cette méthode plus courte. D'autres approches peuvent donner de meilleurs résultats.

En gros, il s’agit simplement d’une chaîne géante de plusieurs lignes, avec des variables ( $aet autres) se substituant à différentes chaînes, et quelques -replacesecondes à la fin pour la terminer. Des blocs de script $(...)sont insérés si nécessaire pour introduire de nouvelles variables.

Essayez-le en ligne!

— AdmBorkBork
source
7

Python, 493 458 octets.

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)

Fonctionnellement équivalent mais un peu plus lisible:

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)

Malheureusement, c'est déjà plus long que la réponse fournie à Lua.

— Cobi
source
Vous pouvez placer les lignes de la pfonction sur une ligne, séparées par des points-virgules. De plus, je pensais que vous ne pouviez pas faire la première ligne k=[['|']*75]*16, savez-vous pourquoi?
— nedla2004
Vous pouvez également définir '_'et ' 'à une variable pour sauver quelques octets.
— nedla2004
Merci pour les conseils! Je pense que k = [['|'] * 75] * 16 crée seize références au même tableau, de sorte qu'un changement dans une ligne affecte également les autres.
— Cobi
Ok, alors vous pouvez au moins changer range(16)pour [0]*16.
— nedla2004
Un petit problème est que votre code ne produit pas techniquement la sortie à droite, mais vous pouvez corriger cela en changeant for l in k:print ' '.join(l)à for l in k:print''.join(l).
— nedla2004
7

PHP, 316 312 octets

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;

Je suis à peu près sûr que cette approche ne peut plus être utilisée. Mais si quelqu'un trouve 10 octets supplémentaires ...: D
Run with -r.

panne

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
source
6

Bash (sur OSX), 12 8 + 221 + 1 = 234 230 octets

Oui, je sais, la compression. Mais ça marche, non?

gunzip<f

Requiert un fichier appelé "f" dans le répertoire en cours avec le contenu suivant (placé en base64 pour la compatibilité PPCG - vous pouvez le décoder dans le fichier "f" en premier):

H4sIAHbPT1gAA63TuQ6CQBCA4Z6noLPxvo2xALwPPMAbsz7IPLz8i2aN7TjFFxo2mT+7vsnH12I/PJGnLyINaEIL2tCBLvSgDwOoQwVGECZ+PiL5WcaIFoazasZkWphMPLeumnzHNAjturKHM0zgAClc4QgL2MIO7vCA7NOrWFcdznPrqsO5Xn+5X1GwS4pgASQwhinMYA5LWMEahlCydeN0cvju9a/7pQ72e790sd69kvlimhYvSm5wgQhO9rlBDBsoQxVqNq/72/VSxfrppYpV9HoBoNfjQcAEAAA=
— Addison Crump
source
4
Peut être trivialement raccourci en écrivant gunzip<f.
— Konrad Rudolph
@ KonradRudolph Excellent point. Merci.
— Addison Crump
Vous pouvez enregistrer 2 octets avec zcat fet 2 octets en supprimant les deux octets nuls de fin (gzip se plaint mais produit la sortie souhaitée).
— Gilles
@ Gilles ne me sauve pas vraiment les octets - je devrais renommer le fichier "fZ" (au moins sur OSX). En supprimant les octets nuls de fin, non seulement gzip se plaint, mais également une erreur de sortie et aucune impression.
— Addison Crump
@VoteToClose Oh oui, zcat<falors. Sous Linux, zcat sans les zéros de fin fait gzip se plaindre («gzip: stdin: fin de fichier inattendue») mais uniquement après avoir imprimé le résultat souhaité.
— Gilles
5

JavaScript (ES6), 286

Une fonction anonyme sans paramètres

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

Moins golfé

_=>[..."`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>
Développer l'extrait

— edc65
source
5

Rapide, 777 octets

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 n’est généralement pas une excellente langue de choix pour jouer au golf. Par conséquent, être moins du double de la plus petite réponse actuelle (c’était rapide) est un bon défi ici!

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()
— nom d'utilisateur tbd
source
2
au moins ce n'est pas applescript
— Addison Crump
1
Maintenant, je dois faire Java, je ne le sais pas
— CAD97
4

SOGL V0.12 , 131 128 127 octets (en compétition? )

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

SOGL a le 2*2/et les 2/2*bizarreries, mais celles-ci se sentent trop intégrées à ce défi.
Essayez-le ici!

...‘               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
source
Wow, c'est super impressionnant! Personne n'a encore réussi à me battre, si bon travail! Je vais peut-être essayer de raccourcir un peu le mien, mais pas de promesses. ;)
— DJMcMayhem
@ Dzamia, même si elle est en compétition maintenant, j'ai accepté la réponse alors que ce n'était pas le cas. Devrais-je changer de réponse?
— Magic Octopus Urn
@MagicOctopusUrn OMI c'est à vous de choisir. Il y a une raison pour laquelle il est suggéré de ne pas accepter les réponses: p
— dzaima
Il est suggéré de ne pas accepter les réponses? Oh ... assez bien. Ensuite, je suppose que je vais arrêter d’accepter les réponses à l’avenir et laisser les choses telles quelles.
— Urne magique Octopus
@MagicOctopusUrn ok, peut-être que ne pas accepter les réponses est un peu controversé, mais c'est quand même un point positif majeur
— dzaima
4

Python 2, 394 388 380 octets

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)

Il suffit de construire une grosse chaîne représentant l’ensemble du clavier, remplace * par% s pour les touches spéciales, puis utilise le formatage de chaîne pour mettre à jour les promotions.

Modifier

Il y a maintenant un retour à la fin à la fin de la sortie, mais je ne vois aucun endroit non autorisé.

Essayez-le en ligne!

— ElPedro
source
Je pense que vous devriez supprimer la sortie, car elle n’ajoute rien de pertinent.
— sergiol
1
@ergiol - bon point. Je n'étais pas au courant de TIO au moment de la publication. Maintenant mis à jour.
— ElPedro
3

C #, 376 octets (sur une seule ligne)

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

Ceci est entièrement basé sur la réponse C # de Klinger. Je n'ai pas assez de rep pour commenter sa réponse, sinon je le ferais.

J'ai pu réduire le code de Klinger de 5 octets en modifiant la boucle initiale foreach et en supprimant les crochets superflus.

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
source
Bon un @ Bence Joful. Avec votre suggestion, je pourrais l’obtenir au numéro 367. Je n’ai pas incorporé la réponse actuelle.
— Klinger
Pas pu résister. Votre suggestion + quelques modifications mineures supplémentaires la portent à 361 (ou 358 avec interpolation de chaîne).
— Klinger
@ Klinger - veuillez utiliser mes réglages! J'ai été inspiré pour jouer avec elle en fonction de votre travail. J'ai appris quelque chose sur l'initialisation dans le processus.
— Bence Joful
Pourriez-vous inclure le programme one line? Vous ne perdrez pas beaucoup de lisibilité par rapport à l’actuel
— Cyoce
@ Cyoce, vous l'avez compris, merci pour la suggestion. Klinger a déjà publié une nouvelle version intégrant ces modifications.
— 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    )

(C’est en fait la première fois que je joue au code et que j’essaie m4.)

— Thriller
source
Pas mal pour une première réponse. Bienvenue sur le site! :)
— DJMcMayhem
3

empilés , 228 octets

Essayez-le ici!

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

Ou légèrement plus lisible:

{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

Cela fonctionne en définissant une fonction pqui crée une clé, puis en hcatutilisant plusieurs clés.

— Conor O'Brien
source
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]

Rétrospectivement, le concept est similaire à celui de cette réponse de Haskell , mais le clavier ASCII est produit et le jeu est légèrement différent.

Formaté et renommé:

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
source
2

tcl, 368

Tel que compté par http://textmechanic.com/text-tools/basic-text-tools/count-characters-words-lines/ avec la mention "Le nombre de lignes est divisé en espaces." réglé sur on, il occupe 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"}

Démo: http://rextester.com/live/NTVAV88033

L'Ungolf:

Coopération en direct sur 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
}

Tout le monde est libre et bienvenue pour améliorer ma version sur les sites de coopération en direct, mais s'il vous plait: ne modifiez pas ma réponse originale ici; Dites simplement que vous avez édité dans les commentaires et que les gens visiteront les liens.

UPDATE 1: remplacé forpar foreach, car ce dernier produit un code plus court

UPDATE 2: remplacé foreachpar lmap, car ce dernier produit un code plus court

UPDATE 3: Rasé un caractère parce que je l'ai remplacé " "par\

MISE À JOUR 4: En ce qui concerne le premier commentaire, j'ai changé tous les caractères de substitution de caractères Unicode de 1ère ligne sur 2 octets en caractères ASCII à 1 octet.

UPDATE 5: plusieurs putslignes en une seule

UPDATE 6: utiliser directement les splitcommandes renvoyant des valeurs sur l' lmapappel au lieu d'utiliser des variables de liste intermédiaires

MISE À JOUR 7: Les citations ENTERn'étaient pas nécessaires

UPDATE 8: string map est assez long et répété un certain nombre de fois qu’il vaut la peine de l’encapsuler dans unproc

UPDATE 9: split $x \n est suffisamment long et répété plusieurs fois pour qu'il soit utile de l'encapsuler dans unproc

UPDATE 10: La chaîne "de remplacement" peut être utilisée à la &place de \1, car dans ce cas les deux coïncident; une autre conséquence est que cela permet de se débarrasser de ()la chaîne "correspondante".

UPDATE 11: Utilisez @plutôt \nque comme séparateur de ligne pour une utilisation ultérieure dans les splitinstructions. Bien que la chaîne « match » de rallonge \Spour [^@]elle est payante, en raison du nombre de répétitions

UPDATE 12: Remplacement de la première regsubchaîne "match" {[^@|]}par \[^@|]pour supprimer un caractère. Malheureusement, ne pouvait pas faire la même chose à la seconde regsub, parce que l'instruction est à l'intérieur d'une paire de []:(

UPDATE 13: Rasé à deux Entrez les caractères en concentrant le lmapcorps avec son propre en-tête.

UPDATE 14: Utilisé un appel à la splitprocédure basée Nau lieu d'un appel direct à la string mapprocédure basée Nqui permet de raccourcir de 3 caractères

MISE À JOUR 15: Il y avait un caractère d'espace inutile . Supprimé pour raser un caractère.

UPDATE 16: set h peut être intégré pour se débarrasser d' $hun personnage.

UPDATE 17: set h déclaration peut vraiment être rasé.

UPDATE 18: l' puts argument est passé du ...\n...\n...\n...format au

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

format.

Merci aux gens qui m'ont aidé à le raccourcir, en particulier evilotto et l'aspect du canal IRC de tcl!

— sergiol
source
Bonne réponse, et bienvenue sur le site! J'ai apporté une modification mineure à votre message afin que le nombre d'octets apparaisse dans l'en-tête, j'espère que cela ne vous dérange pas. Juste pour que vous sachiez, je pense qu'il s'agit en fait de 469 octets, car certains de ces caractères sont des octets multiples en UTF-8. Je ne sais pas trop sur tcl, utilise-t-il un encodage personnalisé contenant un octet?
— DJMcMayhem
@DJMcMayhem Je ne savais pas qu'il s'agissait d'un décompte d'octets basé sur le nombre de caractères, mais ce n'est pas un problème car tout symbole représentant un octet non encore utilisé peut constituer un espace réservé et j'en ai encore beaucoup.
— sergiol
@DJMcMayhem après mon édition, le non-problème que vous avez signalé est parti!
— sergiol
@DJMcMayhem Pourquoi la 401 a eu un fond jaune pendant un certain temps?
— sergiol
2

tcl, 369

Initialement basé sur la version sergiol de tcl.
(Notez que beaucoup d'espaces à gauche font partie de la "nature" de 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
source
@muddyfish Edité et corrigé. Merci!
— Alejandro Muzzachiodi
Vous pouvez raccourcir davantage si vous remplacez directement toutes les foreachoccurrences par lmap!
— sergiol
interp aliasJ'ai essayé d'utiliser votre approche pour raccourcir ma version, mais le plus court que j'ai pu obtenir en le faisant était 398 :( rextester.com/live/NTVAV88033
— sergiol
Mon dernier essai, j'ai eu 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
Vous pouvez enregistrer un caractère si vous avez supprimé un espace inutile, comme dans ma dernière mise à jour!
— sergiol
2

C (gcc) , 378 342 330 octets

-10 octets grâce à ceilingcat.

Un premier coup de poignard. Les répétitions de g () suggèrent des possibilités d'amélioration.

Edit: Nous y voilà.

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

Essayez-le en ligne!

— gastropner
source
1

Python 2, 672 octets

Utiliser une chaîne zlib compressée:

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')
— Peu importe
source
2
C'est 672 octets, pas 232 octets.
— nneonneo
Expliquez plus loin, je ne vous ai pas compris. @nneonneo
— Peu importe
1
Si vous collez votre code dans un fichier, celui-ci aura une longueur de 672 octets. Vous semblez avoir compté votre code avec len("print 'x\x9c...'")lequel le décollement se produira, ce qui donnera \xun nombre d'octets incorrect . Vous pouvez obtenir un nombre correct en comptant avec, len(r"print 'x\x9c...'")mais la solution la plus simple est, comme toujours, de voir ce que dit votre éditeur de texte ou votre système de fichiers.
— nneonneo
1

Powershell, 249 242 octets

"``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 & Explained

Le middot ·utilise à la place des espaces pour clarifier la chaîne source.

"``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: clavier avec barre d'espacement et étiquettes alignées à droite, 278 octets

J'ai ajouté quelques octets à l'expression régulière pour gérer la barre d'espace (ancienne expression rationnelle (.[a-z ]*), nouvelle ~|(.[a-z ]*)). C'est un petit pas pour l'expression rationnelle, un pas de géant pour la solution: vous pouvez maintenant afficher la barre d'espacement et les étiquettes de touches alignées à droite (voir SHIFT, CTRL et BS du côté droit du clavier).

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

Sortie:

 ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ____ ________
||` |||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
source
0

/// , 360 octets

/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

Essayez-le en ligne!

— Conor O'Brien
source
0

Mathematica 323 octets

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

Ennuyeux et peu créatif. La chaîne n'est que la sortie de la Compresscommande intégrée appliquée à la sortie souhaitée.

— Ian Miller
source
@Downvoted veuillez indiquer ce qui ne va pas avec mon programme.
— Ian Miller
0

Wolfram Language (Mathematica) , 293 octets

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

Essayez-le en ligne!

Relativement simple: encode des lignes de clés sous forme de listes de (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
source
0

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

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

Essayez-le en ligne!

— Xcali
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.