Il layout di tastiera comunemente utilizzato dalle persone è il layout QWERTY come mostrato di seguito.

Ma ci sono anche altri layout di tastiera:

DVORAK

Colemak

OPERAIO

Il tuo compito

Il codice richiederà due input: il nome del layout della tastiera e una stringa da trascrivere. Il tuo obiettivo è convertire l'input QWERTY come se stessi digitando con il layout di tastiera indicato come primo parametro.

Regole

Il formato di input è gratuito, è possibile utilizzare stringhe, array, ecc. Inoltre, è possibile utilizzare tre valori distinti per rappresentare i layout per ridurre il conteggio dei byte, ma devono essere rappresentabili ciascuno in 10 byte o meno.

Hai solo bisogno di gestire i tasti con uno sfondo bianco. In particolare, è necessario trasporre i caratteri ASCII stampabili dall'alfabeto QWERTY a uno degli altri alfabeti:

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

(Nota: questo è stato trascritto a mano da @ETHproductions, quindi se vedi degli errori, ti preghiamo di segnalarli!)

Esempio

DVORAK zZxX come input darà come output ;:qQ

Questo è code-golf quindi vince la risposta più breve in byte!

Rubino , 258 247 238 byte

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

Provalo online!

Questa è una funzione che accetta due argomenti: il messaggio da scambiare e un valore 0-2 che rappresenta il layout da scambiare, dove 0 corrisponde a Dvorak, 1 a Colemak e 2 a Workman.

Fondamentalmente, non penso che questo sia molto diverso dalle altre risposte. Più facilmente, si presenta così:

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

La string#trfunzione di Ruby accetta due argomenti: una stringa contenente caratteri da sostituire e una stringa contenente i loro sostituti. Utilmente, ti permette di specificare intervalli di caratteri usando la a-zsintassi. L'altra realizzazione chiave salvaspazio è che non è necessario includere caratteri uguali in tutti e quattro i layout, il che mi ha permesso di eliminare tutte le cifre, la lettera "A" sia in maiuscolo che in minuscolo, e una manciata di personaggi speciali.

Un'altra strana parte della sintassi è l'uso di %W(). Questo crea una matrice di stringhe contenenti tutto all'interno delle parentesi, separate da spazi bianchi. Tutte le interruzioni di riga nell'invio funzionano effettivamente come separatori di elementi. %W()consente anche l'interpolazione di stringhe (che viene eseguita con l' #{}operatore) - %w()sarebbe stata la stessa cosa, ma senza interpolazione di stringhe.

Vorrei anche prendermi un momento per incolpare Dvorak per aver incasinato i miei piani di ottimizzazione attraverso la sua insistenza di essere totalmente diverso da tutti gli altri, sempre; una soluzione Qwerty / Colemak / Workman avrebbe potuto essere meravigliosamente breve ...

JavaScript (ES7), 282 273 251 250 byte

Accetta un ID layout di tastiera ke una matrice di caratteri anella sintassi del curry(k)(a) . Restituisce una matrice di caratteri tradotti.

Gli ID layout sono:

• $-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)

Provalo online!

Come funziona

Compressione

Tutti e tre i layout di destinazione sono memorizzati in una singola stringa compressa, dove ogni carattere è:

• un personaggio di traduzione di QWERTY
• una cifra che rappresenta il numero di caratteri consecutivi che non devono essere tradotti

$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

Ad esempio, #$%&-()*in DVORAK è memorizzato come 3-2perché #$%&e ()*ha mappature identiche in QWERTY e solo- è una traduzione effettiva.

In particolare, 0123456789è mappato allo stesso modo su tutti i layout e non deve mai essere tradotto. Pertanto, non esiste alcuna ambiguità tra una cifra utilizzata per la compressione e una cifra utilizzata per la traduzione.

Decompressione

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

Traduzione

Per ogni carattere cin a, estraiamo il carattere di traduzione t, usando kcome offset nella stringa di layout non compresso, e testiamo se è una cifra con 1/t. In tal caso, viene invece visualizzato il carattere originale c.

Retina , 273 270 byte

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

Provalo online! Prefisso il messaggio con una sola lettera D, Co Wper il layout di tastiera desiderato. Sfortunatamente Retina supporta un mucchio di lettere magiche ( pessendo quella ovvia, ma sono riuscito a scivolare in a d) che tutti devono essere citati, tranne che sono stato in grado di usare al v-xposto di v\wx. Modifica: salvato 3 byte grazie a @ETHproductions.

PHP, 364 byte

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

L'array contiene 3 array in cui la chiave sta per 0 = W, 1 = C, 2 = D

Provalo online!

Python 2, 422 byte

Ho cercato di combinare i layout con un modo intelligente, ma non ha aiutato molto.
Provalo online

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 byte

Ho scritto la versione originale di seguito sul mio telefono mentre ero seduto su un autobus e poi ho finito il tempo per giocare a golf correttamente, quindi c'è più scricchiolio da seguire. Grazie a @ETHproductions per l'aiuto finora.

Le stringhe della tastiera sono state copiate direttamente dalla domanda, quindi incolpare Antoine ETH per eventuali errori!

Questo richiede un numero intero che rappresenta il layout della tastiera (0 per DVORAK, 94 per COLEMAK e 188 per WORKMAN) e una matrice della stringa come argomenti tramite il curry, ad esempio f(0)(["z","Z","x","X"])output ;: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``

Provalo

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 byte

ž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.;}‡‡

Utilizza ID 1per DVORAK; 2per COLEMAK e 3per WORKMAN.
Invia prima l'ID, quindi la stringa che vogliamo traslitterare.

Provalo online o verifica l'intera gamma ASCII per tutti e tre .

Spiegazione:

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

Vedi questo mio suggerimento 05AB1E (sezione Come comprimere le stringhe che non fanno parte del dizionario? ) Per capire come funzionano le stringhe compresse.

C ++, 528 byte

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

Corri con ./multitrans <0-2> <string> dove 0 = Dvorak, 1 = Colemak e 2 = Workman.

Ho aggiunto nuove righe in mezzo per rendere il codice leggermente più leggibile di seguito. Questo codice genera una mappa di traduzione dalle stringhe in cui la ricerca del carattere Qwerty restituisce la traduzione ( t[0]['s'] = 'o'per s in Dvorak) e quindi utilizza la mappa per tradurre. Le stringhe di traduzione sono abbreviate perché alcuni caratteri non devono essere cambiati mai. Tuttavia, potrebbe probabilmente essere ulteriormente ridotto.

#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 -> Solo Dvorak (197 byte)

Di recente ho scritto questo codice che trasforma Qwerty in Dvorak, anche se i capitali non sono tradotti.

#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 byte

Prova online

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