Dato uno dei seguenti caratteri (o una nuova riga):

`1234567890-=~!@#$%^&*()_+qwertyuiop[]\QWERTYUIOP{}|asdfghjkl;'ASDFGHJKL:"zxcvbnm,./ZXCVBNM<>?

Il programma deve generare la riga che si trova sulla tastiera

Poiché la mia tastiera è (quasi) scarica, il codice deve essere il più corto possibile

La tastiera che il tuo programma dovrebbe usare (per la ricerca di righe) dovrebbe apparire come:

Row 1:^~_` ^!₁^@₂ ^#₃^$₄ ^%₅^{^}₆ ^&₇^*₈ ⁽₉⁾₀ ^__-⁺₌                          

Row 2:                         Q W E R T Y U I O P ^{_[ ^}_]    ^|_\   
Row 3:                              A S D F G H J K L ^:_; ^"_' ^↵ _return  
Row 4:                                 Z X C V B N M ^<_, ^>_. ^?_/                 
Row 5:                                                    space                                                   

Dov'è ^↵  returnuna newline. I tasti vuoti non significano nulla.

Esempi

"$"
1

"R"
2

"a"
3

"?"
4

"\n"
3

" "
5

dove \nè un personaggio newline.

specificazioni

• Il tuo programma non dovrebbe fare distinzione tra maiuscole e minuscole
• Il tuo programma deve solo gestire i caratteri sulla tastiera mostrata

Pyth, 62 66 65 byte

?zh@+,4Zmid2c.Bi."0fÀÓ¸[9Ѷ¤KïLäHÉðbÀ`]ü©¬vS"16 2-CzCd3

Provalo online.

Utilizza una stringa compressa che rappresenta un numero in esadecimale che, se tagliato in blocchi di due bit, rappresenta la riga di ogni carattere tranne e !come valore compreso tra 0 e 3. Lasciamo fuori e !quindi non dobbiamo memorizzare 4 o avere uno 0 all'inizio di questo numero, quindi aggiungere i loro valori di riga usando +,4Z. Dopo aver trasformato la stringa in valori di riga, tutto ciò che dobbiamo fare è utilizzare il codice carattere dell'input per indicizzare l'array di valori, quindi aggiungere 1.

Newline è gestito separatamente perché è interpretato da Pyth come una stringa vuota e quindi ha un codice carattere di 0.

Questo sarebbe più breve se potessi capire come usare la base 256 in Pyth, ma non riesco proprio a farlo funzionare.

JavaScript (ES6), 105 102 101 byte

c=>/[~`0-9!@#-&^(-+_=-]/.test(c)+/[asdfghjkl;:'"\n]/i.test(c)*3+/[zxcvbnm,<.>/?]/i.test(c)*4||++c*7^2

Spiegazione

In JavaScript testrestituisce un valore booleano che agisce nello stesso modo 1o 0così li moltiplico per la loro riga. Il test per la riga 2 ha richiesto il maggior numero di byte, quindi l'ho usato come predefinito se nessun altro corrisponde.

c=>
  /[~`0-9!@#-&^(-+_=-]/.test(c)   // row 1 regex
  +/[asdfghjkl;:'"\n]/i.test(c)*3 // row 3 regex
  +/[zxcvbnm,<.>/?]/i.test(c)*4   // row 4 regex
  ||++c                           // space ++ = 1, any character on row 2 ++ = NaN
    *7^2                          // 7 XOR 2 = 5, NaN XOR 2 = 2

Test

var solution = c=>/[~`0-9!@#-&^(-+_=-]/.test(c)+/[asdfghjkl;:'"\n]/i.test(c)*3+/[zxcvbnm,<.>/?]/i.test(c)*4||++c*7^2

<textarea id="input">-</textarea><br />
<button onclick="result.textContent=solution(input.value)">Go</button>
<pre id="result"></pre>

Glava 1,5 , 164 byte

Glava è un dialetto di Java che accorcia il codice Java. Questo codice purtroppo non è competitivo poiché l'impegno (2 ore di ritardo ...) utilizzato è stato fatto dopo questa sfida, che ha risolto alcuni bug vitali che non avrebbero permesso a questo programma di funzionare.

p(A[0].matches("[`0-9-=~!@#$%^&*()_+]")?1:A[0].replace("\\n","\n").matches("(?i)[asdfghjkl;':\"\n]")?3:A[0].matches("(?i)[zxcvbnm,.\\/<>?]")?4:A[0].matches(" ")?5:2

Questo è un programma completo che accetta input tramite argomenti della riga di comando. Funziona semplicemente testando per quale regex di riga corrisponde, quindi genera il numero corrispondente.

Python 3, 142

print(int(("~`!1@2#3$4%5^6&7*8(9)0_-+=""qwertyuiop{[}\|"+"]"*11+'asdfghjkl;:"\n'"'"*13+"zxcvbnm,<.>/""?"*14+" ").index(input().lower())/26)+1)

Probabilmente c'è un modo più breve di trascurare ¯ \ _ (ツ) _ / ¯

Pyth , 98

|+++l:"~`0123456789!@#$%^&*()_-=+"z1*l:"asdfghjkl;:'\"\n"rz0 1 3*l:"zxcvbnm,<.>/? "rz0 1 4 l:dz1 2

non so come far funzionare l'intervallo 0-9 per qualche motivo: |, ispirato alla risposta di user81655

Bash, 108

Nessuna risposta Bash? Risposta Bash. grep -Finè sicuramente lo strumento giusto per questo lavoro.

Questo programma è in due file.

k, 73 byte

`1234567890-=~!@#$%^&*()_+
qwertyuiop[]\{}|
asdfghjkl;':"
zxcvbnm,./<>?

Ci sono 5 linee, l'ultima è uno spazio. In caso di problemi con la riproduzione del file, la base64 è:

YDEyMzQ1Njc4OTAtPX4hQCMkJV4mKigpXysKcXdlcnR5dWlvcFtdXHt9fAphc2RmZ2hqa2w7JzoiCnp4Y3Zibm0sLi88Pj8KIA==

b, 34 byte

Questo è il programma stesso, accetta input come unico argomento della riga di comando.

grep -Fin "$1" k|tail -n3|head -c1

Punteggio: 34 + 73 + 1 (per kil nome del file) = 108 byte

Ungolfed

grep --fixed-strings --ignore-case --line-number "$1" k|tail --lines=3|head --bytes=1

Spiegazione

• grep - cerca in un file le righe corrispondenti a una stringa o un'espressione regolare, genera solo quelle righe
• -Faka --fixed-strings- disabilita le espressioni regolari, quindi [ecc. vengono gestite correttamente
• -iaka -yaka --ignore-case- abbinamento senza distinzione tra maiuscole e minuscole
• -naka --line-number- mostra il numero di riga e: prima di ogni riga (ad es. 4:zxcvbnm,./<>?)
• "$1" - cerca il primo argomento della riga di comando dello script, le virgolette sono necessarie per gestire newline e spazio
• k - cerca nel file k
• Questo grepcomando corrisponderà a tutte e cinque le righe se l'input è una nuova riga e solo una riga in caso contrario.
• | - pipe, invia l'output standard di un comando all'input standard del successivo
• tail - produce le ultime N righe o caratteri di input standard
• -n3aka --lines=3- emette le ultime 3 righe
• Se l'input non era una nuova riga, c'è solo una riga da elaborare, che inizia con il numero di riga a causa del -nflag attivo grep. Altrimenti, questo comando prende solo le linee 3, 4 e 5 (le ultime 3 linee).
• | - tubo
• head - produce le prime N righe o caratteri di input standard
• -c1aka --bytes=1- genera il primo carattere
• Se l'input non era una nuova riga, questo prende il primo carattere, che è il numero di riga in cui si trova l'input. Se l'input è una nuova riga, prende il primo carattere delle righe 3, 4 e 5 combinate, che è 3, che risulta essere il numero di riga corretto per la nuova riga.

Japt, 73 70 66 byte

2+`qØÆyuiop\{}[]|\\1dfghjkl;:
'1zxcvbnm,.<>?/\"1 `q1 ®bUv)<0} b!1

Provalo online! (nell'esempio, l'input è letteralmente una nuova riga)

Java, 300 byte

import java.util.Scanner;public class A{public static void main(String[] args){String g="~`!1@2#3$4%5^6&7*8(9)0_-+=qQwWeErRtTyYuUiIoOpP[{]}\\|aAsSdDfFgGhHjJkKlL;:\'\"\r";Scanner i=new Scanner(System.in);int f=g.indexOf((i.nextLine().charAt(0)));System.out.print(f<0?4:(f<26?1:(f<53?2:(f<76?3:5))));}}

Non sono un esperto, e questo è il mio primo tentativo di giocare a golf, ma ho pensato, che diavolo, perché no? Sopra è la versione completa del programma, il codice reale che lo inserisce molto probabilmente toglierebbe una discreta quantità di caratteri.

Pyth, 105 byte

J?<l-c".^$*+?{}[]\|()"1]z14+\\zrz0?qJd5?:"qwertyuiop[]\|"J)2?:"asdfghjkl;':\"\n"J)3?:"zxcvbnm,./<>?"J)4 1

Spiegazione:

J?<l-c".^$*+?{}[]\|()"1]z14+\\zrz0     # Escape input if regex metachar
?qJd5                                  # Check space
?:"qwertyuiop[]\|"J)2                  # Check second row
?:"asdfghjkl;':\"\n"J)3                # Check third row
?:"zxcvbnm,./<>?"J)4                   # Check fourth row
1                                      # If none of these, must be on first row.

Ho deciso di scegliere la prima riga come riga "deve essere se non altro" perché richiedeva il maggior numero di byte per rappresentare anche dopo il golf.

Perl 6, 128 byte

say 1+(/<[-\d=~!@#$%^&*()_+/`]>/,/<[qwertyuiop[\]\\{}|]>/,/<[asdfghjkl;':"\n]>/,/<[zxcvbnm,./<>?]>/,' ').first: @*ARGS.lc~~*,:k

Faccio un elenco di regex contenenti classi di caratteri insieme a uno spazio letterale di stringa. Quindi chiamo il firstmetodo nell'elenco (che è solo la versione del metodo della firstfunzione di ordine superiore), usando smartmatch per confrontare l'argomento passato al programma con l'elemento corrente nell'elenco. Nota che smartmatch fa "la cosa giusta" sia per le regex che per una stringa letterale. Il :kparametro facoltativo firstfa sì che il metodo restituisca l'indice dell'elemento corrispondente nell'elenco, a cui aggiungo 1 e lo esitosay .

Nota che quando usi questo programma dovrai fuggire correttamente alcuni caratteri come `e spazio nella tua shell. Ad esempio: perl6 keyboard.p6 \ `

JavaScript ES6, 114 byte

n=>[`qwertyuiop{}[]|\\`,`asdfghjkl;:
'`,`zxcvbnm,.<>?/"`,` `].map(x=>+(x.indexOf(n.toLowerCase())<0)).indexOf(0)+2

Un'altra soluzione JavaScript. Il principio è di restituire l'indice del carattere di input nella matrice di righe più 2 (così come la riga 0-9 restituisce -1, cioè non esiste, -1 + 2 = 1. qÈ nella prima stringa della matrice, quindi restituisce 0 + 2 = 2a riga).

Perl, 96 77 76 byte

Esegui utilizzando perl -p. Assicurati di dargli da mangiare solo singoli personaggi; ad esempio, per eseguirlo da un file key.pl(per evitare confusioni con le sequenze di escape della shell) echo -n q|perl -p key.pl.

$_=/[\d~`!@#-&(-+_=-]/+/[adfghjkls"':;
]/i*3+/[bcnmvxz<>,.?\/]/i*4+/ /*5||2

Abusare della funzionalità della gamma regex è divertente.

PHP, 173 byte

L'idea qui era di usare il numero di gruppo di acquisizione regex come indice di riga. Probabilmente alcune ulteriori ottimizzazioni nella stessa regex.

$i=$argv[1];preg_match("%([!#-&\(-+-0-9=@^-`~])|([EIO-RT-UWY[-]eio-rt-uwy{-}])|([\"':-;ADF-HJ-LSadf-hj-ls])|([,.-/<>-?B-CM-NVXZb-cm-nvxz])%",$i,$m);echo array_flip($m)[$i];

La preg_match()chiamata creerà una serie $mdi corrispondenze e, se dovessimo stamparla, sarebbe simile a questa (supponendo che zfosse l'input):

Array ( [0] => 'z', [1] => '', [2] => '', [3] => '', [4] => 'z' )

Lanciando quell'array, scambiando chiavi e valori, si sposta da sinistra a destra e mantiene solo l'ultima chiave distinta, quindi finiamo con:

Array ( 'z' => 4, '' => 3 )

Quindi utilizziamo il carattere di input come indice nell'array per ottenere il nostro risultato.

Provalo qui .

C, 145 143 136 132 127 106 byte

#define c 2124850936,91714965
b[]={8<<18,0,-218071008,7796<<19,c,c};f(a){return a-32?b[a>>4]>>a%16*2&3:4;}

Questo utilizza index()da POSIX.1-2001 ed è obsoleto in POSIX.1-2008. Ciò presuppone ASCII e ints a 32 bit.

Python 3, 89 byte

print("qwertyuiop{}[]\\|asdfghjkl;:\"\n'''zxcvbnm,.<>/???? ".find(input().lower())//16+2)

Dato che non posso ancora commentare, sto pubblicando il miglioramento per l' attuale risposta di Python 3 separatamente .

Modifica : tutto il codice printora e ulteriormente ottimizzato.

Rubino , 82 byte

->i{1+((0>r=i.ord-33)?r%5:"bc7xdutvz4ind3bwqf6mcu5vxiahnmlfs93c".to_i(36)>>2*r&3)}

Provalo online!

CJam, 125 byte

q_" "={;5}{"`1234567890-=~!@#$%^&*()_+qwertyuiop[]\QWERTYUIOP{}|asdfghjkl;'ASDFGHJKL:\"    zxcvbnm,./ZXCVBNM<>?    "\#26/1+}?

Spiegazione

q                          e# read input
 _" "=                     e# decide if the input is a space
      {;5}                 e# if it is, push 5
          {"..."\#26/1+}?  e# if it isn't, push the correct row

SpecBAS - 178 byte

1 a$="~`!1@2#3$4%5^6&7*8(9)0-_+=qQwWeErRtTyYuUiIoOpP{[}]|\aaaaAsSdDfFgGhHjJkKlL:;'"#34#13"zzzzzzzZxXcCvVbBnNmM<,>.?/"+" "*26
2 INPUT k$: IF k$="" THEN k$=#13
3  ?CEIL(POS(k$,a$)/26)

Ho usato una stringa lunga in cui ogni riga è lunga 26 caratteri (# 34 è il codice per la virgoletta doppia e # 13 è il codice per il ritorno).

Quindi stampare il risultato della posizione di arrotondamento / 26.

C # 6, 201 byte

Niente di speciale qui. Ho trovato più economico scrivere entrambi i casi piuttosto che usare ToUpper () a causa della larghezza fissa della stringa.

using C=System.Console;class P{static void Main(string[]a)=>C.Write("`1234567890-=~!@#$%^&*()_+qwertyuiop[]\\QWERTYUIOP{}|asdfghjkl;'\raASDFGHJKL:\"\nazxcvbnm,./zzzZXCVBNM<>?zzz ".IndexOf(a[0])/26+1);}

rientrato:

using C=System.Console;
class P{
    static void Main(string[]a)=>
        C.Write("`1234567890-=~!@#$%^&*()_+qwertyuiop[]\\QWERTYUIOP{}|asdfghjkl;'\raASDFGHJKL:\"\nazxcvbnm,./zzzZXCVBNM<>?zzz ".IndexOf(a[0])/26+1);
}

Python 2, 146 byte

e="\n";lambda x:("`1234567890-=~!@#$%^&*()_+qwertyuiop[]\\QWERTYUIOP{}|asdfghjkl;'ASDFGHJKL:\""+e*4+"zxcvbnm,./ZXCVBNM<>?"+e*13+" ").index(x)/26+1

Excel, 132 byte

=INT((FIND(A1,"`1234567890-=~!@#$%^&*()_+qwertyuiop[]\QWERTYUIOP{}|asdfghjkl;'ASDFGHJKL:""aaa zxcvbnm,./ZXCVBNM<>?zzzzzz ")-1)/26)+1

I tentativi di utilizzare il caso in sensibile SEARCH()anziché FIND()rivelato che Excel partite ~, *e ?per (tick). The matching of? means we can't useRICERCA () `, che avrebbe rasato ben 5 byte ...