El diseño del teclado que la gente usa comúnmente es el diseño QWERTY como se muestra a continuación.

Pero también hay otros diseños de teclado:

DVORAK

COLEMAK

OBRERO

Tu tarea

Su código tomará dos entradas: el nombre de la distribución del teclado y una cadena para transcribir. Su objetivo es convertir su entrada QWERTY como si estuviera escribiendo con la distribución del teclado dada como primer parámetro.

Reglas

El formato de entrada es gratuito, puede usar cadenas, matrices, etc. Además, puede usar tres valores distintos para representar los diseños para reducir su conteo de bytes, pero cada uno debe ser representable en 10 bytes o menos.

Solo necesita manejar las teclas con un fondo blanco. Específicamente, debe transponer los caracteres ASCII imprimibles del alfabeto QWERTY a uno de los otros alfabetos:

 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: esto fue transcrito a mano por @ETHproductions, así que si ve algún error, ¡indíquelo!)

Ejemplo

DVORAK zZxX como entrada dará como salida ;:qQ

Este es el código de golf, por lo que gana la respuesta más corta en bytes.

Rubí , 258 247 238 bytes

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

Pruébalo en línea!

Esta es una función que toma dos argumentos: el mensaje que se intercambiará y un valor 0-2 que representa el diseño al que se intercambiará, donde 0 corresponde a Dvorak, 1 a Colemak y 2 a Workman.

Fundamentalmente, no creo que esto sea muy diferente a las otras respuestas. Más legible, se ve así:

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

La string#trfunción de Ruby toma dos argumentos: una cadena que contiene caracteres para ser reemplazados y una cadena que contiene sus reemplazos. A modo de ayuda, le permite especificar rangos de caracteres mediante la a-zsintaxis. La otra realización clave para ahorrar espacio es que no es necesario incluir caracteres que sean iguales en los cuatro diseños, lo que me permitió deshacerme de todos los dígitos, la letra "A" en mayúsculas y minúsculas, y un puñado de caracteres especiales.

Otro poco extraño de sintaxis es el uso de %W(). Esto crea una serie de cadenas que contienen todo dentro de los paréntesis, separados por espacios en blanco. Todos los saltos de línea en el envío realmente funcionan como separadores de elementos. %W()también permite la interpolación de cadenas (que se realiza con el #{}operador): %w()hubiera sido lo mismo, pero sin la interpolación de cadenas.

También me gustaría tomar un momento para culpar a Dvorak por jugar con mis planes de optimización a través de su insistencia en ser totalmente diferente a los demás, todo el tiempo; una solución Qwerty / Colemak / Workman podría haber sido tan bellamente corta ...

JavaScript (ES7), 282 273 251 250 bytes

Toma una ID de diseño de teclado ky una matriz de caracteres aen sintaxis curry (k)(a). Devuelve una matriz de caracteres traducidos.

Los ID de diseño son:

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

Pruébalo en línea!

Cómo funciona

Compresión

Los tres diseños de destino se almacenan en una sola cadena comprimida, donde cada carácter es:

• un personaje de traducción de QWERTY
• un dígito que representa el número de caracteres consecutivos que no necesitan ser traducidos

$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

Por ejemplo, #$%&-()*en DVORAK se almacena como 3-2causa #$%&y ()*tienen asignaciones idénticas en QWERTY y sólo -es una traducción real.

En particular, 0123456789se asigna de la misma manera en todos los diseños y nunca tiene que traducirse. Por lo tanto, no existe una posible ambigüedad entre un dígito utilizado para la compresión y un dígito utilizado para la traducción.

Descompresión

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

Traducción

Para cada carácter cen a, extraemos el carácter traducción t, usando kcomo un desplazamiento en la cadena de diseño sin comprimir, y la prueba si se trata de un dígito con 1/t. Si es así, sacamos el carácter original en su clugar.

Retina , 273 270 bytes

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

Pruébalo en línea! Prefije el mensaje con una sola letra D, Co Wpara la distribución de teclado deseada. Desafortunadamente, Retina admite un montón de letras mágicas ( psiendo la obvia, pero logré meterme en una d) que todas necesitan ser citadas, excepto que pude usarlas en v-xlugar de v\wx. Editar: Guardado 3 bytes gracias a @ETHproductions.

PHP, 364 bytes

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

La matriz contiene 3 matrices donde la clave representa 0 = W, 1 = C, 2 = D

Pruébalo en línea!

Python 2, 422 bytes

Intenté combinar diseños con alguna forma inteligente, pero no ayudó mucho.
Pruébalo en línea

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 bytes

Escribí la versión original de la siguiente en mi teléfono mientras estaba sentado en un autobús y luego se me acabó el tiempo para jugarlo correctamente para que haya más crujidos a seguir. Gracias a @ETHproductions por la ayuda hasta ahora.

Las cadenas del teclado se copiaron directamente de la pregunta, ¡así que culpe a Antoine ETH por cualquier error!

Esto toma un número entero que representa la distribución del teclado (0 para DVORAK, 94 para COLEMAK y 188 para WORKMAN) y una matriz de la cadena como argumentos mediante currículum, por ejemplo, f(0)(["z","Z","x","X"])salidas ;: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``

Intentalo

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 bytes

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

Utiliza identificadores 1para DVORAK; 2para COLEMAK y 3para WORKMAN.
Primero empuja la ID, luego la cadena que queremos transliterar.

Pruébelo en línea o verifique el rango ASCII completo para los tres .

Explicación:

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

Vea esta sugerencia mía 05AB1E (sección ¿Cómo comprimir cadenas que no forman parte del diccionario? ) Para comprender cómo funcionan las cadenas comprimidas.

C ++, 528 bytes

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

Corre con ./multitrans <0-2> <string>donde 0 = Dvorak, 1 = Colemak y 2 = Workman.

Agregué nuevas líneas en el medio para hacer que el código sea un poco más legible a continuación. Este código genera un mapa de traducción a partir de las cadenas donde al buscar el carácter Qwerty devuelve la traducción ( t[0]['s'] = 'o'por s en Dvorak), y luego usa el mapa para traducir. Las cadenas de traducción se acortan porque algunos caracteres no necesitan cambiarse nunca. Sin embargo, probablemente podría reducirse aún más.

#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 bytes)

Recientemente escribí este código que cambia Qwerty a Dvorak, aunque las mayúsculas no se traducen.

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

Probar en línea

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