Étant donné l'un des caractères suivants (ou une nouvelle ligne):

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

Votre programme doit sortir la ligne qu'il est sur le clavier

Parce que mon clavier est (presque) à court de batterie, votre code doit être le plus court possible

Le clavier que votre programme devrait utiliser (pour la recherche de ligne) devrait ressembler à ceci:

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                                                   

Où ^↵  returnest une nouvelle ligne. Les clés vides ne veulent rien dire.

Exemples

"$"
1

"R"
2

"a"
3

"?"
4

"\n"
3

" "
5

où \nest un caractère de nouvelle ligne.

Caractéristiques

• Votre programme devrait être insensible à la casse
• Votre programme n'a besoin que de gérer les caractères du clavier indiqué

Pyth, 62 66 65 octets

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

Essayez-le en ligne.

Utilise une chaîne compactée représentant un nombre en hexadécimal qui, une fois coupé en morceaux à deux bits, représente la ligne de tous les caractères sauf et en !tant que valeur de 0 à 3. Nous laisser de côté et !que nous ne devons pas stocker 4 ou avoir 0 au début de ce nombre, puis ajoutez leurs valeurs de ligne avec +,4Z. Une fois que la chaîne a été convertie en valeurs de ligne, il ne reste plus qu'à utiliser le code de caractère de l'entrée pour l'indexer dans le tableau de valeurs, puis ajouter 1.

Newline est gérée séparément car elle est interprétée par Pyth comme une chaîne vide et a donc un code de caractère de 0.

Ce serait plus court si je pouvais comprendre comment utiliser la base 256 en Pyth, mais je ne peux pas le faire fonctionner correctement.

JavaScript (ES6), 105 102 101 octets

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

Explication

JavaScript testrenvoie un booléen qui agit le même que 1ou 0si je les multiplier par leur rang. Le test de la ligne 2 a pris le plus grand nombre d'octets, j'ai donc utilisé celui-ci par défaut si aucun autre ne correspondait.

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

Tester

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 octets

Glava est un dialecte de Java qui raccourcit le code Java. Ce code est malheureusement non compétitif car le commit (2 heures de retard ...) utilisé a été fait après ce challenge, qui corrigeait quelques bugs essentiels qui ne permettaient pas à ce programme de fonctionner.

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

C'est un programme complet qui prend des entrées via des arguments en ligne de commande. Fonctionne simplement en testant pour quelle rangée regex elle correspond, puis affiche le nombre correspondant.

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)

Il y a probablement un moyen plus court que j'oublie ¯ \ _ (ツ) _ / ¯

Pyth , 98

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

Je ne sais pas comment faire fonctionner la gamme 0-9 pour une raison quelconque: |, inspirée par la réponse de user81655

Bash, 108

Pas de réponse Bash? Bash répond. grep -Finest certainement le bon outil pour ce travail.

Ce programme est en deux fichiers.

k, 73 octets

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

Il y a 5 lignes, la dernière est un espace. Si vous rencontrez des problèmes pour reproduire le fichier, le base64 est:

YDEyMzQ1Njc4OTAtPX4hQCMkJV4mKigpXysKcXdlcnR5dWlvcFtdXHt9fAphc2RmZ2hqa2w7JzoiCnp4Y3Zibm0sLi88Pj8KIA==

b, 34 octets

C'est le programme lui-même, il prend en entrée comme seul argument de ligne de commande.

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

Score: 34 + 73 + 1 (pour kle nom du fichier) = 108 octets

Ungolfed

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

Explication

• grep - recherche dans un fichier les lignes correspondant à une chaîne ou à une expression régulière, affiche uniquement ces lignes
• -Faka --fixed-strings- désactive les expressions régulières, [etc. sont gérées correctement
• -iaka -yaka --ignore-case- correspondance insensible à la casse
• -naka --line-number- affiche le numéro de la ligne et: avant chaque ligne (par exemple 4:zxcvbnm,./<>?)
• "$1" - recherche du premier argument de ligne de commande du script, les guillemets sont nécessaires pour gérer les nouvelles lignes et l'espace
• k - recherche dans le fichier k
• Cette grepcommande correspondra aux cinq lignes si l'entrée est une nouvelle ligne, et à une seule ligne sinon.
• | - pipe, envoie la sortie standard d’une commande à l’entrée standard de la suivante
• tail - afficher les N dernières lignes ou caractères d’entrée standard
• -n3aka --lines=3- affiche les 3 dernières lignes
• Si l'entrée n'était pas une nouvelle ligne, il n'y a qu'une seule ligne à traiter, qui commence par le numéro de ligne en raison de l' -nindicateur activé grep. Sinon, cette commande ne prend que les lignes 3, 4 et 5 (les 3 dernières lignes).
• | - pipe
• head - afficher les N premières lignes ou caractères d’entrée standard
• -c1aka --bytes=1- affiche le premier caractère
• Si l'entrée n'était pas une nouvelle ligne, cela prend le premier caractère, qui correspond au numéro de la ligne où l'entrée est trouvée. Si l'entrée est une nouvelle ligne, il prend le premier caractère des lignes 3, 4 et 5 combinées, qui est 3, qui correspond au numéro de ligne correct pour la nouvelle ligne.

Japt, 73 70 66 octets

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

Essayez-le en ligne! (dans l'exemple, l'entrée est littéralement une nouvelle ligne)

Java, 300 octets

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

Je ne suis pas un expert, et c’est ma première tentative de golf, mais j’ai pensé que c’était quoi, pourquoi pas? La version complète du programme est présentée ci-dessus. Le code qui y est contenu enlèverait très probablement un nombre décent de caractères.

Pyth, 105 octets

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

Explication:

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.

J'ai décidé de choisir la première ligne comme étant la ligne "doit être si rien d'autre" car elle nécessitait le plus grand nombre d'octets à représenter, même après le golf.

Perl 6, 128 octets

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

Je fais une liste de regex contenant des classes de caractères avec un espace littéral de chaîne. J'appelle ensuite la firstméthode de la liste (qui est simplement la version de la méthode de la firstfonction d'ordre supérieur), en utilisant smartmatch pour comparer l'argument transmis au programme à l'élément actuel de la liste. Notez que smartmatch fait "la bonne chose" pour les expressions rationnelles et un littéral de chaîne. Le :kparamètre facultatif to firstforce la méthode à renvoyer l’index de l’élément correspondant dans la liste, à laquelle j’ajoute ensuite 1 et le produit via say.

Notez que lorsque vous utilisez ce programme, vous devrez correctement échapper certains caractères tels que `et l'espace dans votre shell. Par exemple: perl6 keyboard.p6 \ `

JavaScript ES6, 114 octets

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

Une autre solution JavaScript. Le principe consiste à renvoyer l'index du caractère d'entrée dans le tableau de lignes plus 2 (de sorte que la ligne 0 à 9 renvoie -1, c'est-à-dire qu'il n'existe pas, -1 + 2 = 1. qFigure dans la première chaîne du tableau, donc il retourne 0 + 2 = 2e ligne).

Perl, 96 77 76 octets

Courir en utilisant perl -p. Assurez-vous de ne le nourrir que de caractères simples; par exemple, pour l'exécuter à partir d'un fichier key.pl(pour éviter toute confusion avec les séquences d'échappement du shell) echo -n q|perl -p key.pl.

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

Abuser de la fonctionnalité de la gamme regex est amusant.

PHP, 173 octets

L'idée ici était d'utiliser le nombre de groupes de capture d'expression régulière comme index de lignes. Probablement quelques optimisations supplémentaires dans la regex elle-même.

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

L' preg_match()appel créera un tableau $mde correspondances, et si nous devions l'imprimer, cela ressemblerait à ceci (en supposant qu'il s'agisse de zl'entrée):

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

En retournant ce tableau, en échangeant des clés et des valeurs, on se déplace de gauche à droite et ne conserve que la dernière clé distincte. On obtient donc:

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

Ensuite, nous utilisons le caractère d'entrée comme index dans le tableau pour obtenir notre résultat.

Essayez-le ici .

C, 145 143 136 132 127 127 106 octets

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

Cela utilise index()POSIX.1-2001 et est déconseillé dans POSIX.1-2008. Cela suppose des entrées ASCII et 32 ​​bits.

Python 3, 89 octets

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

Comme je ne peux pas encore commenter, je publie l'amélioration de la réponse actuelle à Python 3 séparément.

Edit : Tout le code est printmaintenant et plus peaufiné.

Ruby , 82 octets

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

Essayez-le en ligne!

CJam, 125 octets

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

Explication

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 octets

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)

J'ai utilisé une longue chaîne de 26 caractères (n ° 34 pour les guillemets doubles et n ° 13 pour les retours).

Imprimez ensuite le résultat de la position d'arrondi / 26.

C # 6, 201 octets

Rien de spécial ici. J'ai trouvé moins coûteux d'écrire les deux cas plutôt que d'utiliser ToUpper () en raison de la largeur fixe de la chaîne.

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

Dentelé:

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 octets

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

Excel, 132 octets

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

Les tentatives d’utilisation de l’affaire SEARCH()non sensible au lieu de FIND()révéler que Excel correspond ~, *et ?à (tick). The matching of? means we can't useSEARCH () `, qui aurait rasé une masse de 5 octets ...