Dado um dos seguintes caracteres (ou uma nova linha):

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

Seu programa deve gerar a linha em que está no teclado

Como meu teclado está (quase) sem bateria, seu código deve ser o mais curto possível

O teclado que seu programa deve usar (para a pesquisa de linha) deve se parecer com:

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                                                   

Onde ^↵  returnestá uma nova linha. Chaves vazias não significam nada.

Exemplos

"$"
1

"R"
2

"a"
3

"?"
4

"\n"
3

" "
5

onde \né um caractere de nova linha.

Especificações

• Seu programa não diferencia maiúsculas de minúsculas
• Seu programa só precisa manipular os caracteres no teclado mostrado

Pitão, 62 66 65 bytes

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

Experimente online.

Usa uma string empacotada representando um número em hexadecimal que, quando dividida em pedaços de dois bits, representa a linha de todos os caracteres, exceto e !como um valor de 0 a 3. Nós deixamos de fora e !não precisamos armazenar 4 ou ter a 0 no início desse número e adicione seus valores de linha usando +,4Z. Depois de transformarmos a string em valores de linha, tudo o que precisamos fazer é usar o código de caractere da entrada para indexar na matriz de valores e adicionar 1.

A nova linha é tratada separadamente, porque é interpretada por Pyth como uma sequência vazia e, portanto, possui um código de caractere 0.

Isso seria mais curto se eu descobrisse como usar a base 256 no Pyth, mas não consigo fazê-lo funcionar.

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

Explicação

Em JavaScript testretorna um booleano que age da mesma forma 1, ou 0então eu multiplicá-los por sua linha. O teste para a linha 2 teve o maior número de bytes, então usei esse como padrão se nenhum outro corresponder.

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

Teste

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 é um dialeto de Java que reduz o código Java. Infelizmente, esse código não é competitivo, pois o commit (2 horas atrasado ...) usado foi feito após esse desafio, que corrigiu alguns erros vitais que não permitiam que esse programa funcionasse.

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 é um programa completo que recebe entrada por meio de argumentos da linha de comando. Funciona simplesmente testando para qual regex de linha corresponde e, em seguida, gera o número correspondente.

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)

Provavelmente existe uma maneira mais curta que eu estou ignorando ¯ \ _ (ツ) _ / ¯

Pyth , 98

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

Não tenho certeza de como fazer o intervalo de 0 a 9 funcionar por algum motivo: |, inspirado na resposta do user81655

Bash, 108

Nenhuma resposta do Bash? Bash resposta. grep -Finé definitivamente a ferramenta certa para este trabalho.

Este programa está em dois arquivos.

k, 73 bytes

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

Existem 5 linhas, a última é um espaço. Se você tiver problemas para reproduzir o arquivo, a base64 é:

YDEyMzQ1Njc4OTAtPX4hQCMkJV4mKigpXysKcXdlcnR5dWlvcFtdXHt9fAphc2RmZ2hqa2w7JzoiCnp4Y3Zibm0sLi88Pj8KIA==

b, 34 bytes

Este é o próprio programa, recebe a entrada como o único argumento da linha de comando.

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

Pontuação: 34 + 73 + 1 (para ko nome do arquivo) = 108 bytes

Ungolfed

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

Explicação

• grep - pesquise em um arquivo as linhas correspondentes a uma string ou expressão regular, produza apenas essas linhas
• -Faka --fixed-strings- desabilite expressões regulares para que [etc. sejam tratadas corretamente
• -iaka -yaka --ignore-case- correspondência que não diferencia maiúsculas de minúsculas
• -naka --line-number- mostra o número da linha e: antes de cada linha (por exemplo 4:zxcvbnm,./<>?)
• "$1" - procure o primeiro argumento de linha de comando do script, as aspas são necessárias para lidar com nova linha e espaço
• k - pesquisa no arquivo k
• Este grepcomando corresponderá a todas as cinco linhas se a entrada for uma nova linha e apenas uma linha caso contrário.
• | - pipe, envia a saída padrão de um comando para a entrada padrão do próximo
• tail - gera as últimas N linhas ou caracteres da entrada padrão
• -n3aka --lines=3- gera as últimas 3 linhas
• Se a entrada não fosse uma nova linha, há apenas uma linha a processar, que começa com o número da linha devido ao -nsinalizador ativado grep. Caso contrário, este comando terá apenas as linhas 3, 4 e 5 (as últimas 3 linhas).
• | - tubo
• head - produz as primeiras N linhas ou caracteres da entrada padrão
• -c1aka --bytes=1- gera o primeiro caractere
• Se a entrada não era uma nova linha, isso leva o primeiro caractere, que é o número da linha em que a entrada é encontrada. Se a entrada for uma nova linha, ele assumirá o primeiro caractere das linhas 3, 4 e 5 combinadas, que é 3, que passa a ser o número de linha correto para a nova linha.

Japt, 73 70 66 bytes

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

Experimente online! (no exemplo, a entrada é literalmente uma nova linha)

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

Eu não sou um especialista, e esta é a minha primeira tentativa de jogar golfe, mas pensei: que diabos, por que não? Acima está a versão completa do programa, o código real inserido provavelmente levaria uma quantidade decente de caracteres.

Pitão, 105 bytes

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

Explicação:

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.

Decidi escolher a primeira linha como a linha "deve ser se nada mais" porque exigia o máximo de bytes para representar, mesmo após o golfe.

Perl 6, 128 bytes

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

Eu faço uma lista de expressões regulares contendo classes de caracteres junto com um espaço literal de cadeia de caracteres. Em seguida, chamo o firstmétodo na lista (que é apenas a versão do método da firstfunção de ordem superior), usando smartmatch para comparar o argumento passado ao programa com o item atual da lista. Observe que o smartmatch "faz a coisa certa" para as regexes e uma string literal. O :kparâmetro opcional para firstfaz com que o método retorne o índice do item correspondente na lista, ao qual adiciono 1 e a saída via say.

Note que ao usar este programa, você terá que escapar corretamente de certos caracteres como `e espaço no seu shell. Por exemplo: perl6 keyboard.p6 \ `

JavaScript ES6, 114 bytes

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

Outra solução JavaScript. O princípio é retornar o índice do caractere de entrada na matriz de linhas mais 2 (para que a linha 0-9 retorne -1, ou seja, não exista, -1 + 2 = 1. qEsteja na primeira sequência da matriz, portanto, retorna 0 + 2 = 2ª linha).

Perl, 96 77 76 bytes

Corra usando perl -p. Verifique se você está alimentando apenas caracteres únicos; por exemplo, para executá-lo a partir de um arquivo key.pl(para evitar mexer nas seqüências de escape do shell) echo -n q|perl -p key.pl.

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

Abusar a funcionalidade do intervalo regex é divertido.

PHP, 173 bytes

A idéia aqui era usar o número do grupo de captura regex como o índice de linha. Provavelmente mais algumas otimizações no próprio 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];

A preg_match()chamada criará uma matriz $mde correspondências e, se imprimíssemos isso, seria algo parecido com isto (assumindo que zfoi a entrada):

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

Como inverter essa matriz, trocando chaves e valores, move-se da esquerda para a direita e mantém apenas a última chave distinta; portanto, terminamos com:

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

Em seguida, usamos o caractere de entrada como o índice na matriz para obter nosso resultado.

Experimente aqui .

C, 145 143 136 132 127 106 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;}

Isso usa index()do POSIX.1-2001 e está obsoleto no POSIX.1-2008. Isso assume ASCII e 32 bits de ints.

Python 3, 89 bytes

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

Como ainda não posso comentar, estou publicando a melhoria para a resposta atual do Python 3 separadamente.

Edit : Todo o código printagora e mais aprimorado.

Ruby , 82 bytes

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

Experimente online!

CJam, 125 bytes

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

Explicação

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)

Eu usei uma string longa, em que cada linha tem 26 caracteres (# 34 é código para aspas duplas e # 13 é código para retorno).

Em seguida, imprima o resultado da posição de arredondamento / 26.

C # 6, 201 bytes

Nada de especial aqui. Achei mais barato escrever os dois casos do que usar ToUpper () devido à largura fixa da string.

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

Recuado:

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

As tentativas de usar o caso in-sensível SEARCH()em vez de FIND()revelou que Excel partidas ~, *e ?para (tick). The matching of? means we can't useSEARCH () `, que teria raspado uns 5 bytes maciços ...