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!

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.

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!

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

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}

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.

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

Perl 5 -pl , 76 octets

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

Essayez-le en ligne!

L'approche regex évidente.

Rubis -n , 86 81 octets

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

Essayez-le en ligne!

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.

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.

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

Powershell, 87 octets

Port de la rétine regex de Neil .

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

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!@#).

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.

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!

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

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.

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!