Dado cualquiera de los siguientes caracteres (o una nueva línea):

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

Su programa debe generar la fila que está en el teclado

Debido a que mi teclado está (casi) sin batería, su código debe ser lo más corto posible

El teclado que debe usar su programa (para la búsqueda de filas) debe verse así:

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                                                   

¿Dónde ^↵  returnestá una nueva línea? Las llaves vacías no significan nada.

Ejemplos

"$"
1

"R"
2

"a"
3

"?"
4

"\n"
3

" "
5

donde \nes un personaje de nueva línea.

Presupuesto

• Su programa debe ser insensible a mayúsculas y minúsculas
• Su programa solo necesita manejar los caracteres en el teclado que se muestra

Pyth, 62 66 65 bytes

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

Pruébalo en línea.

Utiliza una cadena empaquetada que representa un número en hexadecimal que, cuando se corta en pedazos de dos bits, representa la fila de cada carácter excepto y !como un valor de 0 a 3. Dejamos de lado y !no tenemos que almacenar 4 o tener un 0 al comienzo de este número, luego agregue sus valores de fila usando +,4Z. Una vez que hayamos convertido la cadena en valores de fila, todo lo que tenemos que hacer es usar el código de caracteres de la entrada para indexar en la matriz de valores, y luego agregar 1.

Newline se maneja por separado porque Pyth lo interpreta como una cadena vacía y, por lo tanto, tiene un código de caracteres de 0.

Esto sería más corto si pudiera descubrir cómo usar la base 256 en Pyth, pero no puedo hacer que funcione.

JavaScript (ES6), 105 102 101 bytes

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

Explicación

En JavaScript testdevuelve un booleano que actúa igual 1o más o 0menos, los multiplico por su fila. Las pruebas para la fila 2 tomaron la mayor cantidad de bytes, por lo que usé esa como predeterminada si no coinciden otras.

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

Prueba

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 bytes

Glava es un dialecto de Java que acorta el código Java. Lamentablemente, este código no es competitivo ya que el commit (2 horas tarde ...) utilizado se realizó después de este desafío, que solucionó algunos errores vitales que no permitirían que este programa funcionara.

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

Este es un programa completo que toma datos a través de argumentos de línea de comandos. Funciona simplemente probando para qué expresión regular de la fila coincide, luego genera el número correspondiente.

Pitón 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)

Probablemente hay una forma más corta que estoy pasando por alto ¯ \ _ (ツ) _ / ¯

Pyth , 98

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

no estoy seguro de cómo hacer que el rango 0-9 funcione por alguna razón: |, inspirado en la respuesta del usuario 81655

Bash, 108

No hay respuesta Bash? Bash respuesta. grep -FinDefinitivamente es la herramienta adecuada para este trabajo.

Este programa está en dos archivos.

k73 bytes

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

Hay 5 líneas, la última es un espacio. Si tiene problemas para reproducir el archivo, la base64 es:

YDEyMzQ1Njc4OTAtPX4hQCMkJV4mKigpXysKcXdlcnR5dWlvcFtdXHt9fAphc2RmZ2hqa2w7JzoiCnp4Y3Zibm0sLi88Pj8KIA==

b, 34 bytes

Este es el programa en sí, toma la entrada como el único argumento de línea de comando.

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

Puntuación: 34 + 73 + 1 (para kel nombre del archivo) = 108 bytes

Sin golf

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

Explicación

• grep - busca en un archivo líneas que coincidan con una cadena o expresión regular, genera solo esas líneas
• -Faka --fixed-strings- deshabilita las expresiones regulares para que [etc. se manejen correctamente
• -iaka -yaka --ignore-case- coincidencia entre mayúsculas y minúsculas
• -naka --line-number- muestra el número de línea y: antes de cada línea (por ejemplo 4:zxcvbnm,./<>?)
• "$1" - busque el primer argumento de la línea de comandos del script, las comillas son necesarias para manejar la nueva línea y el espacio
• k - buscar en el archivo k
• Este grepcomando coincidirá con las cinco líneas si la entrada es una nueva línea, y solo una línea de lo contrario.
• | - pipe, envía la salida estándar de un comando a la entrada estándar del siguiente
• tail - muestra las últimas N líneas o caracteres de entrada estándar
• -n3aka --lines=3- genera las últimas 3 líneas
• Si la entrada no era una nueva línea, solo hay una línea para procesar, que comienza con el número de fila debido a la -nbandera activada grep. De lo contrario, este comando solo toma las líneas 3, 4 y 5 (las últimas 3 líneas).
• | - tubería
• head - muestra las primeras N líneas o caracteres de entrada estándar
• -c1aka --bytes=1- muestra el primer caracter
• Si la entrada no era una nueva línea, toma el primer carácter, que es el número de línea donde se encuentra la entrada. Si la entrada es una nueva línea, toma el primer carácter de las líneas 3, 4 y 5 combinadas, que es 3, que resulta ser el número de fila correcto para la nueva línea.

Japt, 73 70 66 bytes

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

Pruébalo en línea! (en el ejemplo, la entrada es literalmente una nueva línea)

Java, 300 bytes

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

No soy un experto, y este es mi primer intento de jugar al golf, pero pensé, ¿qué demonios, por qué no? Arriba está la versión completa del programa, el código real que entra probablemente quitaría una cantidad decente de caracteres.

Pyth, 105 bytes

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

Explicación:

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.

Decidí elegir la primera fila como la fila "debe ser si no hay nada más" porque requería la mayor cantidad de bytes para representar incluso después del golf.

Perl 6, 128 bytes

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

Hago una lista de expresiones regulares que contienen clases de caracteres junto con un espacio literal de cadena. Luego llamo al firstmétodo en la lista (que es solo la versión del método de la firstfunción de orden superior), usando smartmatch para comparar el argumento pasado al programa con el elemento actual en la lista. Tenga en cuenta que smartmatch hace "lo correcto" tanto para expresiones regulares como para un literal de cadena. El :kparámetro opcional firsthace que el método devuelva el índice del elemento coincidente en la lista, al que luego agrego 1 y envío a través desay .

Tenga en cuenta que cuando use este programa tendrá que escapar correctamente de ciertos caracteres como `y espacio en su shell. Por ejemplo: perl6 keyboard.p6 \ `

JavaScript ES6, 114 bytes

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

Otra solución de JavaScript. El principio es devolver el índice del carácter de entrada en la matriz de filas más 2 (de modo que la fila 0-9 devuelve -1, es decir, no existe, -1 + 2 = 1. qEstá en la primera cadena de la matriz, entonces devuelve 0 + 2 = 2da fila).

Perl, 96 77 76 bytes

Ejecutar usando perl -p. Asegúrese de alimentarlo solo con caracteres individuales; por ejemplo, para ejecutarlo desde un archivo key.pl(para evitar perder el tiempo con secuencias de escape de shell) echo -n q|perl -p key.pl.

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

Abusar de la funcionalidad de la gama regex es divertido.

PHP, 173 bytes

La idea aquí era usar el número de grupo de captura de expresiones regulares como índice de fila. Probablemente algunas optimizaciones más en la expresión regular en sí.

$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()llamada creará una serie $mde coincidencias, y si imprimiéramos eso, se vería así (suponiendo que zfuera la entrada):

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

Voltear esa matriz, intercambiando claves y valores, se mueve de izquierda a derecha y solo mantiene la última clave distinta, por lo que terminamos con:

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

Luego usamos el carácter de entrada como índice en la matriz para obtener nuestro resultado.

Pruébalo aquí .

C, 145143136132127106 bytes

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

Esto utiliza index()desde POSIX.1-2001 y está en desuso en POSIX.1-2008. Esto supone ASCII y entradas de 32 bits.

Python 3, 89 bytes

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

Como aún no puedo comentar, estoy publicando la mejora para la respuesta actual de Python 3 separado.

Editar : Todo el código printahora y más ajustado.

Ruby , 82 bytes

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

Pruébalo en línea!

CJam, 125 bytes

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

Explicación

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 bytes

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)

Usé una cadena larga donde cada fila tiene 26 caracteres (el # 34 es código para comillas dobles y el # 13 es código para retorno).

Luego imprima el resultado de la posición de redondeo / 26.

C # 6, 201 bytes

Nada especial aquí. Me pareció más barato escribir ambos casos en lugar de usar ToUpper () debido al ancho fijo de la cadena.

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

Sangrado:

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 bytes

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

Excel, 132 bytes

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

Los intentos de usar el caso distinguen entre mayúsculas y minúsculas en SEARCH()lugar de FIND()revelar que Excel coincide ~, *y ?con (tick). The matching of? means we can't useSEARCH () `, que habría reducido 5 bytes masivos ...