Clavier à une ligne

20

Le défi

Le but de ce défi est de déterminer si une chaîne donnée peut être saisie à l'aide d'une seule ligne d'un clavier QWERTY britannique standard.

C'est code golfdonc la solution la plus courte en octets qui gagne!

IO

L'entrée sera une seule chaîne de zéro ou plusieurs caractères dans la plage décimale ASCII de 32 à 126 inclus. Vous pouvez supposer pour ce défi qu'une chaîne vide ne nécessite aucune saisie et peut donc être saisie à l'aide d'une seule ligne.

Vous pouvez prendre l'entrée comme une chaîne, une liste de caractères ou un formulaire équivalent pour votre langue.

La sortie doit être une valeur véridique pour toute chaîne pouvant être saisie à l'aide d'une seule ligne, ou falsey pour celle qui ne le peut pas.

Clavier

Pour clarifier toute ambiguïté sur la disposition du clavier standard ci-dessous est une liste de touches disponibles sur chaque ligne, y compris les touches supérieures alternatives (accessibles via Maj).

  • Ligne 1
    • La norme: `1234567890-=
  • Ligne 2
    • La norme: qwertyuiop[]
  • Ligne 3
    • La norme: asdfghjkl;'#
    • Majuscule: ASDFGHJKL
    • Spécial: Verrouillage des majuscules
  • Ligne 4
    • La norme: \zxcvbnm,./
    • Alterner: |<>?
    • Majuscule: ZXCVBNM
    • Spécial: Shift
  • Ligne 5
    • Spécial: barre d'espace

Les touches supérieures alternatives ne peuvent être enfoncées que si Shift est également sur la même ligne, et les touches majuscules ne sont accessibles que via le verrouillage des majuscules ou Shift. Vous ne pouvez vraiment utiliser qu'une seule ligne de clavier!

Cas de test

            -> true     (empty string)
45-2=43     -> true     (line 1)
qwerty      -> true     (line 2)
tryitout    -> true     (line 2)
Qwerty      -> false    (no shift or caps on line 2)
#sad        -> true     (line 3)
AsDf        -> true     (caps lock used)
@sDF        -> false    (no shift for alternate upper)
zxcvbn?     -> true     (line 4)
zxc vbn     -> false    (spacebar on separate line)
123abc      -> false    (multiple lines)
            -> true     (just space bar)
!!!         -> false    (exclamation marks cannot be printed by a single line)
code-golf  string  decision-problem  keyboard 
— Luke Stevens
source
Il s'agit donc de dispositions de clavier strictement américaines? (J'ai une mise en page au Royaume-Uni).
— ouflak
2
@ouflak Au contraire, ce n'est strictement que la disposition du clavier britannique QWERTY
— Luke Stevens
@Arnauld Oui, merci de l'avoir remarqué!
— Luke Stevens
Oui, j'ai commencé à regarder les deux et j'ai remarqué que votre disposition semble suivre la disposition de mon clavier britannique, pas celle des États-Unis. Hmmm ... Je me demande à quoi ressemble mon autrichien en comparaison.
— ouflak
Sommes-nous autorisés à prendre l'entrée comme une liste de caractères, ou doit-il s'agir d'une chaîne?
— Kevin Cruijssen

Réponses:

12

Python 2 , 130 123 121 121 115 octets

lambda s:any(set(s)<=set(l+l.lower())for l in["`1234567890-=","eqwrtyuiop[]","ASDFGHJKL;'#","ZXCVBNM\,./|<>?"," "])

Essayez-le en ligne!

Python 3 , 111 octets

lambda s:any({*s}<={*l+l.lower()}for l in["`1234567890-=","eqwrtyuiop[]","ASDFGHJKL;'#","ZXCVBNM\,./|<>?"," "])

Essayez-le en ligne!

-4 octets, grâce à nedla2004

— TFeld
source
1
Si vous êtes prêt à utiliser Python 3, vous pouvez le réduire à 111 octets .
— nedla2004
9

Retina 0.8.2 , 72 71 octets

`^([-=\d`]+|[][eio-rtuwy]+|(?i)[adfghjkls;'#]+|[\\bcnmvxz,./|<>?]+| *)$

Essayez-le en ligne! Explication: chaque alternance correspond à une ligne différente du clavier. Au (?i)milieu du motif, le reste du motif est mis en correspondance sans tenir compte de la casse. Edit: 1 octet enregistré grâce à @KirillL.

— Neil
source
opqrpeut être changé o-rpour -1. Aussi, avez-vous oublié un caractère de backtick pour la ligne 1, je ne le vois pas?
— Kirill L.
@KirillL. Oups, doit avoir accidentellement manqué de le sélectionner lors du copier / coller, merci de l'avoir repéré.
— Neil
nice [][...:)
— mazzy
8

05AB1E , 66 47 octets

žh…`-=«žS„[]«žTDu…;'#««žUDu"\,./|<>?"««ð)εISåP}O

Prend l'entrée comme une liste de caractères.

-19 octets grâce à @Emigna . J'ai complètement oublié que nous avions des constantes constantes qwerty-keyboard. :RÉ

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

žh                # Push "0123456789"
  …`-=            # Push "`-="
      «           # Merge them together
žS                # Push "qwertyuiop"
  „[]             # Push "[]"
     «            # Merge them togeter
žT                # Push "asdfghjkl"
  Du              # Duplicate, and toUppercase the copy
    …;'#          # Push ";'#"
        ««        # Merge all three together
žU                # Push "zxcvbnm"
  Du              # Duplicate, and toUppercase the copy
    "\,./|<>?"    # Push "\,./|<>?"
              ««  # Merge all three together
ð                 # Push a space
 )                # Wrap all string in an array
  ε   }           # Map each to:
   I              #  Take the input (list of characters)
    å             #  Check for each if it's in the current string of the map-iteration
     P            #  Take the product (1 if all are truthy, 0 otherwise)
       O          # Take the sum (either 1 or 0, so truthy/falsey), and output implicitly
— Kevin Cruijssen
source
5

JavaScript (Node.js) , 99 98 95 octets

x=>/^([-`=\d]+|[wetyuio-r[\]]+)$/.test(x)|/^([asdfghjkl;'#]+|[zxcvbnm,./<>?\\|]+| *)$/i.test(x)

Essayez-le en ligne!

-1 du commentaire de @Kirill L. dans la réponse Retina.
-3 remercie @Ismael Miguel et @Arnauld pour leurs efforts combinés.

— Shieru Asakoto
source
Pourquoi avez-vous asdfghjklet ASDFGHJKLlà-dedans? Pourquoi n'utilisez-vous pas le idrapeau, comme x=>/.../i.test(x)?
— Ismael Miguel
@IsmaelMiguel car QWERTYUIOPne devrait pas correspondre à l'expression régulière. La vérification supplémentaire coûtera plus cher que de coder ces lettres majuscules directement dans l'expression régulière.
— Shieru Asakoto
Peu importe, c'est buggy. x=>/^([-`=\d]+|[wetyuio-r\[\]]+)$/.test(x)||/^([asdfghjkl;'#]+|[zxcvbnm,.\/<>?\\|]+| *)$/i.test(x)est de la même longueur
— Ismael Miguel
@IsmaelMiguel L'utilisation d'un bit à bit |enregistre 1 octet.
— Arnauld
1
@IsmaelMiguel Cela fait partie de la spécification ECMAScript. Les 3 seuls caractères devant être échappés dans une classe de caractères sont \ , ]et -(voir ClassAtomNoDash dans la spécification). Le tiret peut également apparaître sans échappement s'il s'agit du premier ou du dernier caractère (sinon, il est interprété comme un séparateur de plage de caractères).
— Arnauld
5

Perl 6 , 102 101 100 octets

-1 octet grâce à nwellnhof!

->\a{max map {a.comb⊆comb $_~.lc:},|<eqwrtyuiop[] ASDFGHJKL;'# ZXCVBNM\,./|<>?>,' ',"`-="~[~] ^10}

Essayez-le en ligne!

Implémentation assez standard. Il existe probablement une solution basée sur des expressions rationnelles plus courte, mais je ne connais pas suffisamment les expressions rationnelles de Perl 6 pour faire une tentative.

— Jo King
source
Vous pouvez utiliser à la maxplace de ?any(et minau lieu de ?all).
— nwellnhof
1
Pour ce que ça vaut, une solution basée sur des expressions régulières serait de 84 octets ou 80 octets en utilisant des expressions régulières Perl 5 avec m:P5//. Mais je ne pense pas que l'un d'eux mérite d'être publié comme réponse.
— nwellnhof
4

Java 10, 209 208 octets

s->{int l=0,t;for(var p:s){t=p.matches("[[0-9]`\\-=]")?1:"qwertyuiop[]".contains(p)?2:p.matches("(?i)[asdfghjkl;'#]")?3:"\\zxcvbnm,./|<>?ZXCVBNM".contains(p)?4:p.equals(" ")?5:9;l=l<1?t:l!=t?9:l;}return l<6;}

-1 octet grâce à @TFeld .

Essayez-le en ligne.

Explication:

s->{                    // Method with String-array parameter and boolean return-type
  int l=0,              //  Line-integer, starting at 0
      t;                //  Temp integer
  for(var p:s){         //  Loop over the characters
    t=p.matches("[[0-9]`\\-=]")?
                        //   If it's a character from the first line: 
       1                //    Set `t` to 1
      :"qwertyuiop[]".contains(p)?
                        //   Else-if it's a character from the second line:
       2                //    Set `t` to 2
      :p.matches("(?i)[asdfghjkl;'#]")?
                        //   Else-if it's a character from the third line
       3                //    Set `t` to 3
      :"\\zxcvbnm,./|<>?ZXCVBNM".contains(p)?
                        //   Else-if it's a character from the fourth line:
       4                //    Set `t` to 4
      :p.equals(" ")?   //   Else-if it's a space from the fifth line:
       5                //    Set `t` to 5
      :                 //   Else (invalid character):
       9;               //    Set `t` to 9
    l=l<1?              //   If `l` is still 0:
       t                //    Set it to `t`
      :l!=t?            //   Else-if `t` is a different line than `l`:
       9                //    Set `l` to 9 (non-existing line)
      :                 //   Else (`t` is the same line as `l`):
       l;}              //    Leave `l` the same
  return l<6;}          //  Return whether `l` is not 9
— Kevin Cruijssen
source
Belle solution, mais elle est vraie car les !!!points d'exclamation ne peuvent pas être imprimés par une seule ligne. Je viens d'ajouter cela comme cas de test
— Luke Stevens
@LukeStevens Ah, j'ai supposé à tort que l'entrée est toujours valide pour l'une des cinq lignes. Je modifierai ma solution. C'est une solution simple (mais ajoutera quelques octets ..)
— Kevin Cruijssen
Pourquoi ne pas utiliser (?i)pour les autres lettres majuscules?
— Neil
@Neil En raison de l'évasion requise pour la barre oblique, c'est aussi 209 octets .
— Kevin Cruijssen
Suggérer à la p==" "place dep.equals(" ")
— plafondcat
4

Powershell, 87 octets

Port de la rétine regex de Neil .

"$args"-cmatch"^([-=\d``]+|[][eio-rtuwy]+|(?i)[adfghjkls;'#]+|[\\bcnmvxz,./|<>?]+| *)$"
— mazzy
source
4

Gelée , 55 octets

ØDW;Øq;Œu$€3,4¦;"“rɠ3“Ż²“¿µ|“aƲƘ0ÞḅzḂ»⁶ṭ
¢f€ẈṠSỊafƑ¢F¤$

Essayez-le en ligne!

La première ligne donne une liste des lignes du clavier et la seconde vérifie si l'entrée du programme est contenue sur une seule (ou zéro) ligne et qu'il n'y a pas de caractères qui ne peuvent pas être tapés (comme QWE!@#).

— dylnan
source
3

C , 150 octets

x;f(char*s){for(x=0;*s;x|="@               "[*s++-32]);return!(x&x-1);}

Essayez-le en ligne!

Il ne gagnera aucun prix, mais c'est une approche amusante: nous mappons les caractères sur les cinq lignes du clavier à 4 8 16 32 64, et chaque caractère invalide à3 . Nous bit à bit OU la valeur de chaque caractère de la chaîne ensemble, et vérifions si le résultat est satisfaisant x&(x-1) == 0, ce qui est vrai quand xest une puissance de 2 ou zéro, c'est-à-dire chaque fois xqu'un maximum de bits est défini.

— Lynn
source
2

LUA , 282 262 259 270 octets

s=io.read()l=0
t=0
for c in s:gmatch"."do
f=c.find
t=f(c,"[0-9%`-=]")or 0|(f(c,"[qwertyuiop%[%]]")or 0)*2|(f(c,"[aAsSdDfFgGhHjJkKlL:'@#~]")or 0)*4|(f(c,"[\\zxcvbnm,./|<>?ZXCVBNM]")or 0)*8|(f(c," ")or 0)*16
t=t==0 and 17or t
l=l<1 and t or l~=t and 17or l
end
print(l<17)

Essayez-le en ligne!

— ouflak
source
2

PHP, 98 octets

Je suis un peu triste qu'il n'y ait rien de plus court que l'expression régulière. Ce n'est probablement pas la solution la plus rapide.

<?=preg_match("%^([`\d=-]*|[wetyuio-r[\]]*|(?i)[asdfghjkl;'#]*|[\\\zxcvbnm,./|<>?]*| *)$%",$argn);

Exécuter en tant que pipe avec -Fou l' essayer en ligne .

Solution non regex la plus courte que j'ai trouvée (124 octets; saut de ligne et tabulation pour plus de commodité de lecture):

foreach(["`1234567890-=","qwertyuiop[]","asdfghjkl;'#ASDFGHJKL","zxcvbnm,./\|<>?ZXCVBNM"," "]as$d)
    trim($argn,$d)>""||die(1);

sort avec le code 1pour véridique, 0pour faux. Exécuter en tant que tuyau avec -R.
Nécessite PHP 5.4 ou version ultérieure; pour les anciens PHP, utilisez à la array(...)place de [...](+5 octets)
ou utilisez ces 123 octets avec -nRen PHP <7:

foreach(split(_,"`1234567890-=_qwertyuiop[]_asdfghjkl;'#ASDFGHJKL_zxcvbnm,./\|<>?ZXCVBNM_ ")as$d)
    trim($argn,$d)>""||die(1);
— Titus
source
2

AWK , 163 119 113 octets

Il s'agit d'une réponse AWK, renvoie une chaîne numérique 1 pour true, 0 chaîne pour false. (Écrit en tant qu'AWK invoquer en tant que fichier awk -f pour une utilisation interactive.)

{print/^[-`1234567890=]*$/||/^[]qwertyuiop\[]*$/||/^[asdfghjkl;'#ASDFGHJKL]*$/||/^[zxcvbnm,.\/\|<>?ZXCVBNM]*$/||/^ *$/}

Essayez-le en ligne!

Cependant, ne gère pas le caractère TAB tel qu'il est écrit (extension triviale) comme ne faisant pas partie de la spécification.

— Phil F
source
4
"Toutes les solutions aux défis doivent: (…) être un concurrent sérieux pour les critères gagnants utilisés. Par exemple, une entrée à un concours de golf à code doit être jouée, et une entrée à un concours de vitesse devrait faire une tentative d'être rapide . " - centre d'aide Il n'est pas nécessaire de déclarer ces 2 variables et certainement pas besoin de leur faire des chaînes. Et un seul printsuffit: essayez-le en ligne!
— manatwork
Votre commentaire selon lequel les solutions devraient être sérieuses est valable, mais je dirais que toute solution par conséquent après la version révisée 05AB1E n'est donc pas pertinente car elle ne pourrait pas correspondre ou améliorer le résultat. Je ne vois pas comment vous ne pouvez pas utiliser print deux fois pour obtenir à la fois vrai et faux (certainement pour quelque chose qui lit les chaînes jusqu'à la fin de l'entrée). Et j'ai dit optimisé pas optimal à l'époque. Grâce à vos réflexions, il peut être réduit à 143 caractères.
— Phil F
Et en fait, aller jusqu'au bout fera 121 caractères ...
— Phil F
2
code-golf n'est pas une compétition pour le code le plus court dans son ensemble, mais le plus court pour votre langue. Si vous pouvez améliorer votre solution, je vous suggère de le faire
— Jo King
@Jo King, merci pour vos éclaircissements. le code révisé serait / pourrait être: {print/^[-```1234567890=]*$/||/^[]qwertyuiop\[]*$/||/^[asdfghjkl;'#ASDFGHJKL]*$/||/^[zxcvbnm,.\/\|<>?ZXCVBNM]*$/||/^ *$/}
— Phil F
1

Bash , 119 octets

Comprend un écho pour fournir une sortie "lisible". Si vous mettez un emballage approprié de shell (votre choix) autour pour inclure l'impression / sortie, vous pouvez économiser 8 octets. Ma lecture du défi suggère que la solution devrait produire une indication de sortie appropriée, donc je m'en tiens à 119 octets. 

[[ "$@" =~ ^[asdfghjklASDFGHJKL\;\'#]*$|^[-\`0-9=]+$|^[]qwertyuiop\[]*$|^[zxcvbnm,./\|\<\>\?ZXCVBNM]*$|^\ *$ ]];echo $?

Essayez-le en ligne!

— Phil F
source
Sachez que la solution Bash signifie également que ma solution AWK / @ manatwork peut être réduite à 113 octets.
— Phil F
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.