Das häufig verwendete Tastaturlayout ist das unten gezeigte QWERTZ- Layout.

Es gibt aber auch andere Tastaturlayouts:

DVORAK

COLEMAK

ARBEITER

Deine Aufgabe

Ihr Code benötigt zwei Eingaben: den Namen des Tastaturlayouts und eine zu transkribierende Zeichenfolge. Ihr Ziel ist es, Ihre QWERTZ-Eingabe so zu konvertieren, als würden Sie mit dem als ersten Parameter angegebenen Tastaturlayout tippen.

Regeln

Das Eingabeformat ist frei, Sie können Zeichenfolgen, Arrays usw. verwenden. Darüber hinaus können Sie drei verschiedene Werte verwenden, um die Layouts darzustellen, um die Anzahl der Bytes zu verringern. Sie müssen jedoch jeweils in maximal 10 Bytes darstellbar sein.

Sie müssen nur die Schlüssel mit einem weißen Hintergrund behandeln. Insbesondere müssen Sie die druckbaren ASCII-Zeichen aus dem QWERTZ-Alphabet in eines der anderen Alphabete umwandeln:

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

(Hinweis: Dies wurde von @ETHproductions von Hand transkribiert. Wenn Sie also Fehler sehen, weisen Sie Sie bitte darauf hin!)

Beispiel

DVORAK zZxX als Eingabe wird als Ausgabe geben ;:qQ

Das ist Code-Golf, also gewinnt die kürzeste Antwort in Bytes!

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

Probieren Sie es online!

Dies ist eine Funktion mit zwei Argumenten: der Nachricht, die ausgetauscht werden soll, und einem Wert 0-2, der das Layout darstellt, in das ausgetauscht werden soll, wobei 0 Dvorak, 1 Colemak und 2 Workman entspricht.

Grundsätzlich denke ich nicht, dass dies viel anders ist als die anderen Antworten. Genauer gesagt sieht es so aus:

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

Rubys string#trFunktion benötigt zwei Argumente: eine Zeichenkette, die zu ersetzende Zeichen enthält, und eine Zeichenkette, die deren Ersetzungen enthält. Es ist hilfreich, Zeichenbereiche mithilfe der a-zSyntax anzugeben . Die andere wichtige platzsparende Erkenntnis ist, dass es nicht erforderlich ist, Zeichen zu verwenden, die in allen vier Layouts gleich sind. Dadurch konnte ich alle Ziffern, den Buchstaben "A" in Groß- und Kleinbuchstaben und eine Handvoll Zeichen entfernen spezielle Charaktere.

Ein anderes seltsames Stück Syntax ist die Verwendung von %W(). Dadurch wird ein Array von Zeichenfolgen erstellt, die alle Elemente in Klammern enthalten, die durch Leerzeichen voneinander getrennt sind. Alle Zeilenumbrüche in der Übermittlung fungieren tatsächlich als Elementtrennzeichen. %W()erlaubt auch String-Interpolation (was mit dem #{}Operator gemacht wird) - %w()wäre dasselbe gewesen, aber ohne String-Interpolation.

Ich würde mir auch gerne einen Moment Zeit nehmen, um Dvorak die Schuld dafür zu geben, dass er meine Optimierungspläne durcheinandergebracht hat, indem er darauf besteht, die ganze Zeit ganz anders zu sein als alle anderen. Eine Qwerty / Colemak / Workman-Lösung hätte so schön kurz sein können ...

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

Probieren Sie es online! Präfix die Nachricht mit einem einzigen Buchstaben D, Coder Wfür das gewünschte Tastaturlayout. Leider unterstützt Retina eine Reihe magischer Buchstaben ( pdie naheliegend sind, aber ich habe es geschafft, sie einzufügen d), die alle zitiert werden müssen, außer ich konnte sie v-xanstelle von verwenden v\wx. Bearbeiten: 3 Bytes dank @ETHproductions gespeichert.

JavaScript (ES7), 282 273 251 250 Byte

Nimmt eine Tastaturlayout-ID kund ein Array von Zeichen ain der aktuellen Syntax auf (k)(a). Gibt ein Array übersetzter Zeichen zurück.

Die Layout-IDs lauten:

• DVORAK: -32
• COLEMAK: 64
• Arbeiter: 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)

Wie es funktioniert

Kompression

Alle drei Ziellayouts werden in einer einzelnen komprimierten Zeichenfolge gespeichert, wobei jedes Zeichen entweder:

• ein Übersetzungscharakter von QWERTY
• Eine Ziffer, die die Anzahl der aufeinanderfolgenden Zeichen darstellt, die nicht übersetzt werden müssen

Insbesondere wird eine Ziffer n als die Länge der Zahl 15 ⁿ in der Basis 10 interpretiert :

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

Zum Beispiel wird #$%&-()*in DVORAK als 3-2weil gespeichert #$%&und ()*haben identische Zuordnungen in QWERTY und nur -eine tatsächliche Übersetzung.

Insbesondere 0123456789wird auf allen Layouts gleich abgebildet und muss nie übersetzt werden. Daher gibt es keine mögliche Mehrdeutigkeit zwischen einer für die Komprimierung verwendeten Ziffer und einer für die Übersetzung verwendeten Ziffer.

Dekompression

Um den Layout-String zu dekomprimieren, ersetzen wir jede Ziffer n durch 15 ⁿ . Beispielsweise 3-2wird als dekomprimiert 3375-225.

Übersetzung

Für jedes Zeichen cin aextrahieren wir das Übersetzungszeichen tund verwenden es kals Versatz in der unkomprimierten Layoutzeichenfolge. Dann testen wir , ob es sich um eine Ziffer mit handelt 1/t. In diesem Fall geben wir cstattdessen das Originalzeichen aus .

Demo

let f =

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)

console.log(JSON.stringify(f(-32)([...'zZxX'])))        // DVORAK
console.log(JSON.stringify(f( 64)([...'QWERTYUIOP'])))  // COLEMAK
console.log(JSON.stringify(f(160)([...'QWERTYUIOP'])))  // WORKMAN

Python 2, 422 Bytes

Versucht, Layouts mit einer cleveren Methode zu kombinieren, aber es hat nicht viel geholfen.
Probieren Sie es online aus

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

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

Array enthält 3 Arrays, wobei key für 0 = W, 1 = C, 2 = D steht

Probieren Sie es online!

C ++, 535 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;k<strlen(v[2]);k++)printf("%c",M(t[v[1][0]-'0'][v[2][k]],v[2][k]));}

Laufen Sie mit ./multitrans <0-2> <string>0 = Dvorak, 1 = Colemak und 2 = Workman.

Ich habe dazwischen Zeilenumbrüche eingefügt, um den Code weiter unten etwas lesbarer zu machen. Dieser Code generiert eine Übersetzungszuordnung aus den Zeichenfolgen, in denen das Nachschlagen des QWERTY-Zeichens die Übersetzung zurückgibt ( t[0]['s'] = 'o'für s in Dvorak). Anschließend wird die Zuordnung zum Übersetzen verwendet. Die Übersetzungszeichenfolgen werden gekürzt, da einige Zeichen nie geändert werden müssen. Es könnte jedoch wahrscheinlich weiter reduziert werden.

#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;k<strlen(v[2]);k++)
        printf("%c",M(t[v[1][0]-'0'][v[2][k]],v[2][k]));
}

Extra: Qwerty -> Nur Dvorak (197 Bytes)

Ich habe kürzlich diesen Code geschrieben, der Qwerty in Dvorak ändert, obwohl Großbuchstaben nicht übersetzt werden.

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

JavaScript (ES6), 461 409 404 395 385 Bytes

Ich habe die Originalversion von unten auf mein Handy geschrieben, während ich in einem Bus saß, und dann hatte ich nicht mehr genug Zeit, um richtig Golf zu spielen, damit es noch knirschender wird. Vielen Dank an @ETHproductions für die bisherige Hilfe.

Die Keyboard-Strings wurden direkt aus der Frage kopiert, also mach Antoine ETH für eventuelle Fehler verantwortlich!

Dies setzt eine Ganzzahl voraus, die das Tastaturlayout darstellt (0 für DVORAK, 94 für COLEMAK und 188 für WORKMAN), und ein Array der Zeichenfolge als Argumente für die Ausgabe, z . B. f(0)(["z","Z","x","X"])Ausgaben ;: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``

Versuch es

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>

C 394 Bytes

Versuchen Sie es 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++;}

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

Verwendet IDs 1für DVORAK; 2für COLEMAK und 3für WORKMAN.
Drückt zuerst die ID und dann den String, den wir transliterieren möchten.

Probieren Sie es online aus oder überprüfen Sie den gesamten ASCII-Bereich für alle drei .

Erläuterung:

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

Sehen Sie sich meinen Tipp 05AB1E an (Abschnitt So komprimieren Sie Zeichenfolgen, die nicht Teil des Wörterbuchs sind ), um zu verstehen, wie die komprimierten Zeichenfolgen funktionieren.