Układ klawiatury, z którego często korzystają ludzie, to układ QWERTY, jak pokazano poniżej.

Ale są też inne układy klawiatury:

DVORAK

COLEMAK

ROBOTNIK

Twoje zadanie

Twój kod wymaga dwóch danych wejściowych: nazwy układu klawiatury i ciągu do transkrypcji. Twoim celem jest konwersja danych wejściowych QWERTY tak, jakbyś pisał z układem klawiatury podanym jako pierwszy parametr.

Zasady

Format wejściowy jest bezpłatny, możesz używać ciągów, tablic itp. Ponadto możesz użyć dowolnych trzech różnych wartości do przedstawienia układów w celu zmniejszenia liczby bajtów, ale każda z nich musi być reprezentowalna w 10 bajtach lub mniej.

Musisz tylko obsługiwać klucze z białym tłem. W szczególności należy transponować drukowane znaki ASCII z alfabetu QWERTY na jeden z pozostałych alfabetów:

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

(Uwaga: zostało to ręcznie przepisane przez @ETHproductions, więc jeśli zobaczysz jakieś błędy, proszę je wskazać!)

Przykład

DVORAK zZxX jako wejście da jako wynik ;:qQ

To jest golf golfowy, więc wygrywa najkrótsza odpowiedź w bajtach!

Rubin , 258 247 238 bajtów

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

Wypróbuj online!

Jest to funkcja przyjmująca dwa argumenty: wiadomość do zamiany i wartość 0-2 reprezentującą układ, który ma zostać zamieniony, gdzie 0 odpowiada Dvorak, 1 do Colemak i 2 do Workman.

Zasadniczo nie sądzę, aby różniło się to od innych odpowiedzi. Bardziej czytelnie wygląda to tak:

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

string#trFunkcja Ruby przyjmuje dwa argumenty: ciąg zawierający znaki do zastąpienia i ciąg zawierający ich zamienniki. Pomocnie pozwala określić zakresy znaków za pomocąa-z składni. Inną kluczową realizacją oszczędzającą miejsce jest to, że nie jest konieczne dołączanie znaków, które są takie same we wszystkich czterech układach, co pozwoliło mi pozbyć się wszystkich cyfr, litery „A”, zarówno wielkiej, jak i małej, oraz garści znaki specjalne.

Kolejną dziwną częścią składni jest użycie %W(). Tworzy to tablicę ciągów zawierających wszystko w nawiasach, oddzielonych białymi znakami. Wszystkie podziały wierszy w przesyłaniu faktycznie działają jako separatory elementów. %W()zezwala również na interpolację ciągów (co odbywa się za pomocą #{}operatora) -%w() byłoby to samo, ale bez interpolacji łańcuchów.

Chciałbym również poświęcić chwilę na obwinianie Dvoraka za to, że bałaganił moje plany optymalizacji, ponieważ nalegał, aby być całkowicie innym niż wszyscy przez cały czas; rozwiązanie Qwerty / Colemak / Workman mogło być tak pięknie krótkie ...

JavaScript (ES7), 282 273 251 250 bajtów

Pobiera identyfikator układu klawiatury ki tablicę znakówa w składni curry(k)(a) . Zwraca tablicę przetłumaczonych znaków.

Identyfikatory układu to:

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

Wypróbuj online!

Jak to działa

Kompresja

Wszystkie trzy docelowe układy są przechowywane w jednym skompresowanym ciągu, gdzie każdy znak to:

• znak tłumaczenia z QWERTY
• cyfra reprezentująca liczbę kolejnych znaków, które nie muszą być tłumaczone

$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

Na przykład #$%&-()*w DVORAK jest przechowywany jako 3-2ponieważ#$%& i ()*ma identyczne odwzorowania w QWERTY i tylko- jest rzeczywistym tłumaczeniem.

W szczególności, 0123456789 jest odwzorowany w ten sam sposób na wszystkich układach i nigdy nie musi być tłumaczony. Dlatego nie ma możliwej niejednoznaczności między cyfrą używaną do kompresji a cyfrą używaną do tłumaczenia.

Dekompresja

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

Tłumaczenie

Dla każdego znaku cw a, możemy wyodrębnić charakter tłumaczenia t, używając kjako przesunięcie w nieskompresowanej ciąg układu i sprawdzić, czy jest to cyfra z 1/t. Jeśli tak, wyprowadzamy oryginalny znak c.

Siatkówka , 273 270 bajtów

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

Wypróbuj online! Prefiks wiadomość z jednej litery D, Club Wdo pożądanego układu klawiatury. Niestety Retina obsługuje kilka magicznych liter (co pjest oczywiste, ale udało mi się wślizgnąć w a d), z których wszystkie trzeba zacytować, z wyjątkiem tego, że mogłem użyć v-xzamiast nich v\wx. Edycja: Zapisano 3 bajty dzięki @ETHproductions.

PHP, 364 bajtów

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

Tablica zawiera 3 tablice, w których klucz oznacza 0 = W, 1 = C, 2 = D

Wypróbuj online!

Python 2, 422 bajty

Próbowałem połączyć układy w jakiś sprytny sposób, ale to niewiele pomogło.
Wypróbuj 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 bajtów

Oryginalną wersję poniżej napisałem na telefonie, gdy siedziałem w autobusie, a potem zabrakło mi czasu, aby odpowiednio zagrać w golfa, aby było więcej do zrobienia. Dzięki @ETHproductions za pomoc do tej pory.

Ciągi klawiatury zostały skopiowane bezpośrednio z pytania, więc obwiniaj Antoine ETH za wszelkie błędy!

Pobiera to liczbę całkowitą reprezentującą układ klawiatury (0 dla DVORAK, 94 dla COLEMAK i 188 dla WORKMAN) i tablicę ciągu jako argumenty przez curry - np . f(0)(["z","Z","x","X"])Wyjścia ;: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``

Spróbuj

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 bajtów

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

Używa identyfikatorów 1dla DVORAK; 2dla COLEMAK i 3WORKMAN.
Najpierw wypycha identyfikator, a następnie ciąg, który chcemy transliterować.

Wypróbuj online lub sprawdź pełny zakres ASCII dla wszystkich trzech .

Wyjaśnienie:

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

Zapoznaj się z moją wskazówką 05AB1E (sekcja Jak kompresować ciągi, które nie są częścią słownika? ), Aby zrozumieć, jak działają skompresowane ciągi.

C ++, 528 bajtów

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

Biegnij z ./multitrans <0-2> <string> gdzie 0 = Dvorak, 1 = Colemak, a 2 = Robotnik.

Dodałem nowe wiersze pomiędzy, aby kod był nieco bardziej czytelny poniżej. Ten kod generuje mapę translacji z ciągów, w których wyszukiwanie znaku Qwerty zwraca tłumaczenie ( t[0]['s'] = 'o'dla s do Dvorak), a następnie używa mapy do tłumaczenia. Ciągi tłumaczenia są skracane, ponieważ niektóre znaki nie muszą być nigdy zmieniane. Prawdopodobnie można to jednak jeszcze bardziej zmniejszyć.

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

Dodatkowo: Qwerty -> Tylko Dvorak (197 bajtów)

Niedawno napisałem ten kod, który zmienia Qwerty w Dvorak, choć wielkie litery nie są przetłumaczone.

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

Wypróbuj 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++;}