Sur quelle rangée se trouve la clé?

39

É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:~` !1@2 #3$4 %5^6 &7*8 (9)0 _-+=                          

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                                                   

  returnest une nouvelle ligne. Les clés vides ne veulent rien dire.

Exemples

"$"
1

"R"
2

"a"
3

"?"
4

"\n"
3

" "
5

\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é
Downgoat
la source
3
Peut-être la classification ?
lirtosiast
3
Est-ce un double imbriqué kbd?
Conor O'Brien
Je me souviens d’avoir utilisé une langue qui rendait les touches 100 × rangée + position, il y a bien des années… Cela aurait été parfait, mais malheureusement, je ne me souviens pas de quoi il s’agissait. Peut-être une forme de BASIC ...
Adám
@ NBZ Est-ce Blitz Basic?
wizzwizz4
1
@ wizzwizz4 Avez-vous essayé BlitzPlus? c'est gratuit et on dirait que c'est ce que vous voulez.
HolyBlackCat

Réponses:

6

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.

Luke
la source
4
o.0 commence à serrer Japt
nicael
cela me fait honte
JuanPotato
:( J'ai oublié newline! @Nicael, tu es de retour au top.
Luke
Maintenant nous sommes morts même!
Luke
Vous devez échapper aux octets nuls en Pyth.
lirtosiast
12

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

utilisateur81655
la source
1
> NaN XOR 2 = 2 - ???
lirtosiast
1
@ThomasKwa C'est comme ça que JS fonctionne lol. Si c="q", ++c= NaN, NaN*7= NaN, NaN^2convertit les opérandes en entiers (non diffusables comme NaNdevenir 0), alors ce 0 XOR 2qui est 2.
user81655
5

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.

GamrCorps
la source
Glava = Goyave + Java?
Downgoat
2
@ Doᴡɴɢᴏᴀᴛ Glava = Golf + Java (c'était l'idée de Conor)
GamrCorps
Effectivement! @ Doᴡɴɢᴏᴀᴛ
Conor O'Brien
4

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 ¯ \ _ (ツ) _ / ¯

Juan Potato
la source
4

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

Juan Potato
la source
Vous pouvez utiliser jkUTpour la chaîne comprise entre 0 et 9, sans savoir s'il existe un moyen plus court. Vous pouvez également utiliser des chaînes empaquetées pour économiser quelques octets, par exemple, ."!~WÏù¹_(<]úÝ"pour "~`!@#$%^&*()_-=+".
Luke
De @benstopics, cela échoue pour les métacaractères regex
FryAmTheEggman
4

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.

la source
4

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)

nicael
la source
Nice, le plus court jusqu'à présent!
ETHproductions
@Eth yup, au moins une fois je devrais poster quelque chose de court: D
nicael
@Eth Heh, !1est quelque chose qui correspond à "faux", enfin je sais comment le faire, merci :)
nicael
@Eth halp, nécessite 5 octets pour battre Pyth.
nicael
4

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.

Andrew
la source
Je viens de remarquer qu’il se bloque avec une entrée vide (nouvelle ligne / retour chariot). va réparer quand je peux
Andrew
Bienvenue dans la communauté!
Erik l'Outgolfer
Bienvenue (un peu tard depuis que vous avez posté en janvier xD). Vous pouvez jouer un peu au golf sans changer votre approche actuelle comme ceci: class A{public static void main(String[]a){int f="~'!1@2#3$4%5^6&7*8(9)0_-+=qQwWeErRtTyYuUiIoOpP[{]}\\|aAsSdDfFgGhHjJkKlL;:\'\"\r".indexOf(new java.util.Scanner(System.in).nextLine().charAt(0));System.out.print(f<0?4:f<26?1:f<53?2:f<76?3:5);}}( 243 octets ). J'ai supprimé certaines parenthèses inutiles. raccourci args; enlevé public ; directement utilisé la chaîne et le scanner; et supprimé l'importation maintenant qui java.util.Scannerest utilisé une fois.
Kevin Cruijssen
219 octets vous n'avez pas besoin d'utiliser Scanner pour cela
PrincePolka
3

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.

benstopics
la source
Bienvenue dans Programmation Puzzles et Code Golf! Utilisez les commentaires pour que @JuanPotato l'obtienne. Cependant, cela nécessite 50 rep. Donc, vous devez travailler.
user48538
3

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 \ `

seiche
la source
Puisque personne ne l’a encore dit, bienvenue dans la programmation de Puzzles & Code Golf!
Erik l'Outgolfer
2

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

nicael
la source
2

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.

marque
la source
Pour moi cela ne fonctionne pas, en le lançant, je récupère l'index de la ligne + 3 (c'est-à-dire 3 au lieu de 0, 7 au lieu de 4, etc.).
ChatterOne
Cela dépend de la façon dont vous fournissez vos commentaires. Vous fournissez probablement un personnage suivi d'une nouvelle ligne. J'utilise echopour contrôler avec précision l'entrée - par exemple. echo -n q|perl -n key.pl, qui produit correctement 2.
Mark
Oh je vois. Eh bien, cela explique également pourquoi vous ne faites pas chompcette entrée.
ChatterOne
1
Si je chompsaisis l'entrée, je ne serais pas en mesure de renvoyer «3» pour la clé de retour.
Marc
1
Hey @Mark, vous n’avez pas besoin du $_=~pour les matchs, m//(qui est ce qui /.../est) fonctionne $_automatiquement! Aussi, si vous utilisez -pau lieu de, -nvous pouvez utiliser $_=au lieu de printsauvegarder quelques octets supplémentaires. Utiliser une nouvelle ligne littérale à la place de \npeut aussi vous faire économiser un autre octet! Cela devrait réduire votre code un peu! Cela vaut peut-être la peine d’ajouter un exemple d’utilisation afin que tous les tests sachent que vous devez utiliser echo -n:)
Dom Hastings
2

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 .

nickb
la source
2

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.

plafondcat
la source
2

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é.

créatifecodage
la source
Il ne s'agit que d'un extrait de code et, par conséquent, d'une réponse non valide. Vous devez l'envelopper dans une instruction print (en faire un programme complet) ou en faire une fonction.
FlipTack
@ FlipTack: Vous avez raison. J'ai intégré votre suggestion.
creativecoding
Bienvenue chez PPCG!
Martin Ender
@MartinEnder: Merci! :-)
creativecoding
1

Ruby , 82 octets

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

Essayez-le en ligne!

GB
la source
0

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
Zach Gates
la source
0

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.

Brian
la source
0

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);
}
Hand-E-Food
la source
1
Je ne vois pas que cela fonctionne pour ~ ou `?
Ash Burlaczenko
@AshBurlaczenko, merci! J'ai raté cette clé. Fixé sans changement à mon score.
Hand-E-Food le
0

Python 2, 146 octets

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

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

Wernisch
la source