La disposition du clavier que les gens utilisent couramment est la disposition QWERTY comme indiqué ci-dessous.

Mais il existe également d'autres dispositions de clavier:

DVORAK

COLEMAK

OUVRIER

Ta tâche

Votre code prendra deux entrées: le nom de la disposition du clavier et une chaîne à transcrire. Votre objectif est de convertir votre entrée QWERTY comme si vous tapiez avec la disposition du clavier donnée comme premier paramètre.

Règles

Le format d'entrée est gratuit, vous pouvez utiliser des chaînes, des tableaux, etc.

Il vous suffit de manipuler les touches avec un fond blanc. Plus précisément, vous devez transposer les caractères ASCII imprimables de l'alphabet QWERTY à l'un des autres alphabets:

 QWERTY: !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~
 DVORAK: !_#$%&-()*}w[vz0123456789SsW]VZ@AXJE>UIDCHTNMBRL"POYGK<QF:/\=^{`axje.uidchtnmbrl'poygk,qf;?|+~
COLEMAK: !"#$%&'()*+,-./0123456789Oo<=>?@ABCSFTDHUNEIMKY:QPRGLVWXJZ[\]^_`abcsftdhuneimky;qprglvwxjz{|}~
WORKMAN: !"#$%&'()*+,-./0123456789Ii<=>?@AVMHRTGYUNEOLKP:QWSBFCDXJZ[\]^_`avmhrtgyuneolkp;qwsbfcdxjz{|}~

(Remarque: cela a été transcrit à la main par @ETHproductions, donc si vous voyez des erreurs, veuillez les signaler!)

Exemple

DVORAK zZxX comme entrée donnera comme sortie ;:qQ

Il s'agit de code-golf, donc la réponse la plus courte en octets l'emporte!

Rubis , 258 247 238 octets

->c,t{c.tr"#{$f='\'"+,-./<=>?[]{'}}:;B-Z_b-z",%W(-_}w[vzW]VZ/=?+SsXJE>UIDCHTNMBRL"POYGK<QF:{xje.uidchtnmbrl'poygk,qf;
#$f}OoBCSFTDHUNEIMKY:QPRGLVWXJZ_bcsftdhuneimky;qprglvwxjz
#$f}IiVMHRTGYUNEOLKP:QWSBFCDXJZ_vmhrtgyuneolkp;qwsbfcdxjz)[t]}

Essayez-le en ligne!

Il s'agit d'une fonction prenant deux arguments: le message à échanger et une valeur 0-2 représentant la disposition à échanger, où 0 correspond à Dvorak, 1 à Colemak et 2 à Workman.

Fondamentalement, je ne pense pas que ce soit très différent des autres réponses. Plus lisible, cela ressemble à ceci:

def swap_layout(message, layout)
    keyboards = [DVORAK, COLEMAK, WORKMAN] # Omitted here for brevity
    return message.tr(QWERTY, keyboards[layout])
end

La string#trfonction de Ruby prend deux arguments: une chaîne contenant des caractères à remplacer et une chaîne contenant leurs remplacements. Utilement, il vous permet de spécifier des plages de caractères à l'aide de la a-zsyntaxe. L'autre réalisation clé pour gagner de l'espace est qu'il n'est pas nécessaire d'inclure des caractères identiques dans les quatre dispositions, ce qui m'a permis de me débarrasser de tous les chiffres, de la lettre "A" en majuscule et en minuscule, et d'une poignée de caractères spéciaux.

Un autre bit de syntaxe étrange est l'utilisation de %W() . Cela crée un tableau de chaînes contenant tout à l'intérieur des parenthèses, séparées par des espaces. Tous les sauts de ligne dans la soumission fonctionnent en fait comme des séparateurs d'éléments. %W()permet également l'interpolation de chaînes (ce qui est fait avec l' #{}opérateur) - %w()aurait été la même chose, mais sans interpolation de chaînes.

Je voudrais également prendre un moment pour blâmer Dvorak d'avoir gâché mes plans d'optimisation en insistant pour être totalement différent de tout le monde, tout le temps; une solution Qwerty / Colemak / Workman aurait pu être si magnifiquement courte ...

JavaScript (ES7), 282 273 251 250 octets

Prend un ID de disposition de clavier ket un tableau de caractèresa dans la syntaxe de curry (k)(a). Renvoie un tableau de caractères traduits.

Les ID de mise en page sont les suivants:

• $-32$
• $64$
• $160$

k=>a=>a.map(c=>1/(t=`1_3-2}w[vz8SsW]VZ1XJE>UIDCHTN0BRL"POYGK<QF:/0=0{1xje.uidchtn0brl'poygk,qf;?0+995Oo6SFTD0UNEI0KY:0PRGL2J8sftd0unei0ky;0prgl2j998Ii5VMHRT0YUNEOLKP:0W0BFCD0J6vmhrt0yuneolkp;0w0bfcd0j5`.replace(/\d/g,n=>15**n)[c.charCodeAt()+k])?c:t)

Essayez-le en ligne!

Comment ça fonctionne

Compression

Les trois dispositions cibles sont stockées dans une seule chaîne compressée, où chaque caractère est soit:

• un caractère de traduction de QWERTY
• un chiffre représentant le nombre de caractères consécutifs qui n'ont pas besoin d'être traduits

$n$$15^n$$10$

n | 15**n       | length
--+-------------+-------------
0 | 1           | 1
1 | 15          | 2
2 | 225         | 3
3 | 3375        | 4
4 | 50625       | 5 (not used)
5 | 759375      | 6
6 | 11390625    | 8
7 | 170859375   | 9 (not used)
8 | 2562890625  | 10
9 | 38443359375 | 11

Par exemple, #$%&-()*dans DVORAK est stocké comme 3-2parce que #$%&et()* a des mappages identiques dans QWERTY et -n'est qu'une traduction réelle.

En particulier, il 0123456789est mappé de la même manière sur toutes les mises en page et n'a jamais à être traduit. Par conséquent, il n'y a aucune ambiguïté possible entre un chiffre utilisé pour la compression et un chiffre utilisé pour la traduction.

Décompression

$n$$15^n$3-23375-225

Traduction

Pour chaque caractère cdans a, nous extrayons le caractère de traduction t, en utilisant kcomme décalage dans la chaîne de mise en page non compressée, et testons s'il s'agit d'un chiffre avec 1/t. Si c'est le cas, nous sortons le caractère original à la cplace.

Rétine , 273270 octets

T`p` !_#-&\-()*}\w[vzdSsW]VZ@AXJ\E>UIDC\HTNMBR\L"P\OYGK<QF:/\\=^{\`axje.ui\dc\htnmbr\l'\p\oygk,qf;?|+~`^D.*
T`p` -9\O\o<-CSFTD\HUN\EIMKY:QPRG\LVWXJZ-csft\d\huneimky;q\prg\lv-xjz-~`^C.*
T`p` -9Ii<-AVM\HRTGYUN\E\O\LKP:QWSBFCDXJZ-avm\hrtgyune\o\lk\p;q\wsbfc\dxjz-~`^W.*
^.

Essayez-le en ligne! Préfixer le message avec une seule lettre D, Cou Wpour la mise en page du clavier souhaitée. Malheureusement, Retina prend en charge un tas de lettres magiques ( pétant évidente, mais j'ai réussi à y glisser un d) qui doivent toutes être citées, sauf que j'ai pu utiliser à la v-xplace de v\wx. Edit: sauvé 3 octets grâce à @ETHproductions.

PHP, 364 octets

echo strtr($argv[2],($t=[[":;BCDEFHIJKLMNOPRTUVWYbcdefhijklmnoprtuvwy","IiVMHRTYUNEOLKP:WBFCDJvmhrtyuneolkp;wbfcdj"],[":;DEFGIJKLNOPRSTUYdefgijklnoprstuy","OoSFTDUNEIKY:PRGLJsftduneiky;prglj"],["\"'+,-./:;<=>?BCDEFGHIJKLNOPQRSTUVWXYZ[]_bcdefghijklnopqrstuvwxyz{}","_-}w[vzSsW]VZXJE>UIDCHTNBRL\"POYGK<QF:/={xje.uidchtnbrl'poygk,qf;?+"]][ord($argv[1])%3])[0],$t[1]);

Le tableau contient 3 tableaux où la clé représente 0 = W, 1 = C, 2 = D

Essayez-le en ligne!

Python 2, 422 octets

J'ai essayé de combiner des mises en page avec une manière intelligente, mais cela n'a pas beaucoup aidé.
Essayez-le en ligne

from string import*
Q=' '+printable
D=' '+digits
p,P=punctuation.split(':;')
w='avmhrtgyuneolkp;qwsbfcdxjz'
c='abcsftdhuneimky;qprglvwxjz'
d="uidchtnmbrl'poygk"
K={'C':D+c+c.upper().replace('Y;','Y:')+p+'Oo'+P,'W':D+w+w.upper().replace('P;','P:')+p+'Ii'+P,'D':D+'axje.'+d+',qf;AXJE>'+d.upper().replace("L'",'L"')+'<QF:!_#$%&-()*}w[vzSsW]VZ@/\=^{`?|+~'}
k,s=input().split()
print''.join(map(lambda x:K[k[0]][Q.index(x)],s))

JavaScript (ES6), 461 409 404 395 385 octets

J'ai écrit la version originale de ce qui suit sur mon téléphone alors que j'étais assis dans un bus, puis j'ai manqué de temps pour bien jouer au golf, donc il y a plus de craquements à suivre. Merci à @ETHproductions pour l'aide jusqu'à présent.

Les cordes du clavier ont été copiées directement à partir de la question, donc blâmez Antoine ETH pour toute erreur!

Cela prend un entier représentant la disposition du clavier (0 pour DVORAK, 94 pour COLEMAK & 188 pour WORKMAN) et un tableau de la chaîne comme arguments par curry - par exemple, les f(0)(["z","Z","x","X"])sorties ;:qQ.

k=>s=>s.map(c=>`!_#$%&-()*}w[vz${a="0123456789"}SsW]VZ@AXJE>UIDCHTNMBRL"POYGK<QF:/\\=^{\`axje.uidchtnmbrl'poygk,qf;?|+~${b="!\"#$%&'()*+,-./"+a}Oo<=>?@ABCSFTDHUNEIMKY:QPRGLVWXJ${d="Z[\\]^_\`a"}bcsftdhuneimky;qprglvwxjz{|}~${b}Ii<=>?@AVMHRTGYUNEOLKP:QWSBFCDXJ${d}vmhrtgyuneolkp;qwsbfcdxjz{|}~`[`${b}:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY${d}bcdefghijklmnopqrstuvwxyz{|}~`.search(c)+k]).join``

Essayez-le

f=
k=>s=>s.map(c=>`!_#$%&-()*}w[vz${a="0123456789"}SsW]VZ@AXJE>UIDCHTNMBRL"POYGK<QF:/\\=^{\`axje.uidchtnmbrl'poygk,qf;?|+~${b="!\"#$%&'()*+,-./"+a}Oo<=>?@ABCSFTDHUNEIMKY:QPRGLVWXJ${d="Z[\\]^_\`a"}bcsftdhuneimky;qprglvwxjz{|}~${b}Ii<=>?@AVMHRTGYUNEOLKP:QWSBFCDXJ${d}vmhrtgyuneolkp;qwsbfcdxjz{|}~`[`${b}:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY${d}bcdefghijklmnopqrstuvwxyz{|}~`.search(c)+k]).join``
o.innerText=f(j.value=0)([...i.value="zZxX"])
i.oninput=j.oninput=_=>o.innerText=f(+j.value)([...i.value].filter(c=>`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_\`abcdefghijklmnopqrstuvwxyz{|}~`.includes(c)))

<select id=j><option value=0>DVORAK<option value=94>COLEMAK<option value=188>WORKMAN</select><input id=i><pre id=o>

05AB1E , 199 192 187 octets

žQDIiA¦'mKDuì“"'+,-./:;<=>?[]_{}“«.•4Zl˜η‡#ûwj˜ÐAδO•Duìð“>"<:.',;“S.;“_-}w[vzSsW]VZ/={?+“«ë¹<i.•2¸3'ÐQïK¤)•Duì„:;©ì.•C^ÿ¶₆*γŽ¨ï•Duì„Ooìë.•Brì·=ζW˜ΛlÝδ•Duì®ì.•]X)àƒ₆ä¤QúØM•Duì„Iiì}ð®S.;}‡‡

Utilise les identifiants 1pour DVORAK; 2pour COLEMAK et 3pour WORKMAN.
Pousse d'abord l'ID, puis la chaîne que nous voulons translittérer.

Essayez-le en ligne ou vérifiez la gamme ASCII complète pour les trois .

Explication:

žQ                    # Push printable ASCII builtin string:
                      #  “ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~“
  D                   # Duplicate it
   Ii                 # If the input-integer is 1:
     A                #  Push the lowercase alphabet
      ¦'mK           '#  Remove the first character (the 'a') and 'm'
          Duì         #  Prepend an uppercase copy
     “"'+,-./:;<=>?[]_{}“«
                     "#  And then append the string “"'+,-./:;<=>?[]_{}“
     .•4Zl˜η‡#ûwj˜ÐAδO• 
                      #  Push compressed string "xje uidchtnbrl poygk qf "
        Duì           #  Prepend an uppercase copy
     ð                #  Push a space " "
      “>"<:.',;“S    "#  Push the characters [">",'"',"<",":",".","'",",",";"]
                 .;   #  Replace the first space with ">", second with '"', etc.
     “_-}w[vzSsW]VZ/={?+“«
                      #  And then append the string “_-}w[vzSsW]VZ/={?+“
   ë                  # Else:
    ¹<i               #  If the input-integer is 2 instead: 
       .•2¸3'ÐQïK¤)• '#   Push compressed string "defgijklnoprstuy"
          Duì         #   Prepend an uppercase copy
       „:;            #   Push string ":;"
          ©           #   Store it in the register (without popping)
           ì          #   And then prepend this ":;" in front of the "DEF...def..."-string
       .•C^ÿ¶₆*γŽ¨ï•  #   Push compressed string "sftduneiky prglj"
          Duì         #   Prepend an uppercase copy
       „Ooì           #   And then prepend "Oo"
    ë                 #  Else (so the input-integer is 3):
     .•Brì·=ζW˜ΛlÝδ•  #   Push compressed string "bcdefhijklmnoprtuvwy"
        Duì           #   Prepend an uppercase copy
     ®ì               #   And then prepend ":;" (from the register)
     .•]X)àƒ₆ä¤QúØM•  #   Push compressed string "vmhrtyuneolkp wbfcdj"
        Duì           #   Prepend an uppercase copy
     „Iiì             #   And then prepend "Ii"
    }                 #  After the inner if-else:
     ð                #  Push a space " "
      ®S              #  Push the characters [":",";"] (from the register)
        .;            #  Replace the first space with ":" and the second space with ";"
   }                  # After the outer if-else:
    ‡                 # Transliterate the two strings we created,
                      #  in the duplicate printable ASCII string
     ‡                # And then transliterate the printable ASCII string with this string,
                      #  in the (implicit) string-input
                      # (after which the result is output implicitly)

Consultez cette astuce 05AB1E (section Comment compresser des chaînes ne faisant pas partie du dictionnaire? ) Pour comprendre comment fonctionnent les chaînes compressées.

C ++, 528 octets

#include <map>
#define M(a,b)a!='\0'?a:b
std::map<char,char>t[3];char*c[]={"\"'+,-./:;<=>?BCDEFGHIJKLMNOPQRSTUVWXYZ[]_bcdefghijklmnopqrstuvwxyz{}","_-}w[vzSsW]VZXJE>UIDCHTNMBRL\"POYGK<QF:/={xje.uidchtnmbrl'poygk,qf;?+","\"'+,-./Oo<=>?BCSFTDHUNEIMKY:QPRGLVWXJZ[]_bcsftdhuneimky;qprglvwxjz{}","\"'+,-./Ii<=>?VMHRTGYUNEOLKP:QWSBFCDXJZ[]_vmhrtgyuneolkp;qwsbfcdxjz{}"};int main(int d,char*v[]){for(int i=1;i<4;i++)for(int j=0;j<68;j++)t[i-1][c[0][j]]=c[i][j];for(int k=0;v[2][k];k++)printf("%c",M(t[v[1][0]-'0'][v[2][k]],v[2][k]));}

Courir avec ./multitrans <0-2> <string> où 0 = Dvorak, 1 = Colemak et 2 = Workman.

J'ai ajouté des nouvelles lignes entre les deux pour rendre le code légèrement plus lisible ci-dessous. Ce code génère une carte de traduction à partir des chaînes où la recherche du caractère Qwerty renvoie la traduction ( t[0]['s'] = 'o'pour les s dans Dvorak), puis il utilise la carte pour traduire. Les chaînes de traduction sont raccourcies car certains caractères n'ont jamais besoin d'être modifiés. Cependant, il pourrait probablement être encore réduit.

#include <map>
#define M(a,b)a!='\0'?a:b
std::map<char,char>t[4];
char*c[4]={
"\"'+,-./:;<=>?BCDEFGHIJKLMNOPQRSTUVWXYZ[]_bcdefghijklmnopqrstuvwxyz{}",
"_-}w[vzSsW]VZXJE>UIDCHTNMBRL\"POYGK<QF:/={xje.uidchtnmbrl'poygk,qf;?+",
"\"'+,-./Oo<=>?BCSFTDHUNEIMKY:QPRGLVWXJZ[]_bcsftdhuneimky;qprglvwxjz{}",
"\"'+,-./Ii<=>?VMHRTGYUNEOLKP:QWSBFCDXJZ[]_vmhrtgyuneolkp;qwsbfcdxjz{}"};
int main(int d,char*v[]){
    for(int i=1;i<4;i++)
        for(int j=0;j<68;j++)
            t[i-1][c[0][j]]=c[i][j];
    for(int k=0;v[2][k];k++)
        printf("%c",M(t[v[1][0]-'0'][v[2][k]],v[2][k]));
}

Extra: Qwerty -> Dvorak uniquement (197 octets)

J'ai récemment écrit ce code qui transforme Qwerty en Dvorak, bien que les majuscules ne soient pas traduites.

#include<string>
char*d="\',.pyfgcrlaoeuidhtns;qjkxbmwvz ";std::string t="qwertyuiopasdfghjkl;zxcvbnm,./ ";int main(int c,char*v[]){for(int j=0;j<strlen(v[1]);j++)printf("%c",d[t.find(v[1][j])]);}

C, 394 octets

Essayez en ligne

char*K[3]={"!_#$%&-()*}w[vz0123456789SsW]VZ@AXJE>UIDCHTNMBRL\"POYGK<QF:/\\=^{`axje.uidchtnmbrl'poygk,qf;?|+~",
"!\"#$%&'()*+,-./0123456789Oo<=>?@ABCSFTDHUNEIMKY:QPRGLVWXJZ[\\]^_`abcsftdhuneimky;qprglvwxjz{|}~",
"!\"#$%&'()*+,-./0123456789Ii<=>?@AVMHRTGYUNEOLKP:QWSBFCDXJZ[\\]^_`avmhrtgyuneolkp;qwsbfcdxjz{|}~"};
main(int c,char**v){char*t=v[2];while(*t)putchar(*t>32?K[atoi(v[1])][*t-33]:*t),t++;}