El reto

El objetivo de este desafío es determinar si una cadena determinada se puede escribir usando solo una línea de un teclado QWERTY estándar del Reino Unido.

Esto es code golf, ¡la solución más corta en bytes gana!

La entrada será una sola cadena de cero o más caracteres en el rango decimal ASCII de 32-126 inclusive. Puede suponer para este desafío que una cadena vacía no requiere escritura y, por lo tanto, puede escribirse con una sola línea.

Puede tomar la entrada como una cadena, una lista de caracteres o una forma equivalente para su idioma.

La salida debe ser un valor verdadero para cualquier cadena que se pueda escribir usando una sola línea, o falsey para una que no se puede escribir.

Para aclarar cualquier ambigüedad sobre cuál es la distribución estándar del teclado a continuación, hay una lista de teclas disponibles en cada línea, incluidas las teclas superiores alternativas (a las que se accede mediante Mayús).

• Línea 1
  • Estándar: `1234567890-=
• Línea 2
  • Estándar: qwertyuiop[]
• Línea 3
  • Estándar: asdfghjkl;'#
  • Mayúscula: ASDFGHJKL
  • Especial: Bloqueo de mayúsculas
• Línea 4
  • Estándar: \zxcvbnm,./
  • Alterno: |<>?
  • Mayúscula: ZXCVBNM
  • Especial: cambio
• Línea 5
  • Especial: barra espaciadora

Las teclas superiores alternativas solo se pueden presionar si Shift también está en la misma línea, y solo se puede acceder a las teclas mayúsculas a través de Mayúsculas o Mayúsculas. ¡Realmente solo puedes usar una línea de teclado!

            -> 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 115 bytes

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

Pruébalo en línea!

Python 3 , 111 bytes

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

Pruébalo en línea!

_{-4 bytes, gracias a nedla2004}

Retina 0.8.2 , 72 71 bytes

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

Pruébalo en línea! Explicación: Cada alternancia coincide con una fila diferente del teclado. El (?i)en el medio del patrón hace que todo el resto del patrón coincida entre mayúsculas y minúsculas. Editar: guardado 1 byte gracias a @KirillL.

05AB1E , 66 47 bytes

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

Toma la entrada como una lista de caracteres.

-19 bytes gracias a @Emigna . Olvidé por completo que teníamos qwerty-keyboard constantes incorporados. :RE

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

ž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 bytes

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

Pruébalo en línea!

El obvio enfoque regex.

Ruby -n , 86 81 bytes

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

Pruébalo en línea!

JavaScript (Node.js) , 99 98 95 bytes

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

Pruébalo en línea!

-1 del comentario de @Kirill L. en la respuesta Retina.
-3 agradece a @Ismael Miguel y @Arnauld por su esfuerzo combinado.

Perl 6 , 102101100 bytes

-1 byte gracias a nwellnhof!

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

Pruébalo en línea!

Implementación bastante estándar. Probablemente haya una solución más breve basada en expresiones regulares para esto, pero no conozco la expresión regular de Perl 6 lo suficientemente bien como para intentarlo.

Java 10, 209 208 bytes

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 byte gracias a @TFeld .

Pruébalo en línea.

Explicación:

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 bytes

Puerto de Neil's Retina regex .

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

Jalea , 55 bytes

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

Pruébalo en línea!

La primera línea produce una lista de las líneas del teclado y la segunda verifica si la entrada del programa está contenida en una sola línea (o cero) y si no hay caracteres que no puedan escribirse (como QWE!@#).

C , 150 bytes

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

Pruébalo en línea!

No ganará ningún premio, pero este es un enfoque divertido: asignamos caracteres en las cinco filas del teclado 4 8 16 32 64y todos los caracteres no válidos 3. O bit a bit el valor para cada carácter en la cadena juntos, y verificamos si el resultado satisface x&(x-1) == 0, lo cual es cierto cuando xes una potencia de 2 o cero, es decir, siempre que xtenga como máximo un bit establecido.

LUA , 282 262 259 270 bytes

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)

Pruébalo en línea!

PHP, 98 bytes

Estoy un poco triste porque no hay nada más corto que regex. Probablemente no sea la solución más rápida.

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

Ejecutar como tubería -Fo probarlo en línea .

La solución no regex más corta que encontré (124 bytes; salto de línea y pestaña para facilitar la lectura):

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

sale con código 1de verdad, 0de falsedad. Ejecutar como tubería con -R.
Requiere PHP 5.4 o posterior; para PHP anterior, use en array(...)lugar de [...](+5 bytes)
o use estos 123 bytes con -nRPHP <7:

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

AWK , 163 119 113 bytes

Esta es una respuesta AWK, devuelve una cadena numérica 1 para verdadero, 0 cadena para falso. (Escrito como invocación AWK como archivo awk -f para uso interactivo).

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

Pruébalo en línea!

Sin embargo, no maneja el carácter TAB como está escrito (extensión trivial) como no parte de la especificación.

Bash , 119 bytes

Incluye un eco para proporcionar una salida "legible". Si coloca un envoltorio adecuado de shell (su elección) alrededor para incluir impresión / salida, entonces puede guardar 8 bytes. Mi lectura del desafío sugiere que la solución debería generar una indicación de salida adecuada, por lo que me quedo con 119 bytes.

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

Pruébalo en línea!