Teclado de una línea

20

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!


IO

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.


Diseño del teclado

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!


Casos de prueba

            -> 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)
Luke Stevens
fuente
Entonces, ¿esto es estrictamente diseños de teclado de EE. UU.? (Tengo un diseño del Reino Unido).
ouflak
2
@ouflak Por el contrario, es estrictamente solo la distribución del teclado QWERTY del Reino Unido
Luke Stevens
@Arnauld Sí, lo hice, ¡gracias por notarlo!
Luke Stevens
Sí, comencé a mirar a ambos y noté que su diseño parece seguir el diseño de mi teclado del Reino Unido, no el de EE. UU. Hmmm ... Me pregunto cómo será mi austriaco en comparación.
ouflak
¿Se nos permite tomar la entrada como una lista de caracteres, o tiene que ser una cadena?
Kevin Cruijssen

Respuestas:

12

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

TFeld
fuente
1
Si está dispuesto a usar Python 3, puede reducirlo a 111 bytes .
nedla2004
9

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.

Neil
fuente
opqrse puede cambiar a o-rpor -1. Además, ¿olvidó un carácter de retroceso para la línea 1, no lo veo?
Kirill L.
@KirillL. Whoops, debe haber olvidado accidentalmente seleccionarlo al copiar / pegar, gracias por detectar eso.
Neil
nice [][...:)
mazzy
8

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
Kevin Cruijssen
fuente
8

Perl 5 -pl , 76 bytes

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

Pruébalo en línea!

El obvio enfoque regex.

nwellnhof
fuente
5

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.

Shieru Asakoto
fuente
¿Por qué tienes asdfghjkly ASDFGHJKLallí? ¿Por qué no usas la ibandera, como x=>/.../i.test(x)?
Ismael Miguel
@IsmaelMiguel porque QWERTYUIOPno debería coincidir con la expresión regular. El cheque adicional costará más que codificar esas letras mayúsculas directamente en la expresión regular.
Shieru Asakoto
No importa, es buggy. x=>/^([-`=\d]+|[wetyuio-r\[\]]+)$/.test(x)||/^([asdfghjkl;'#]+|[zxcvbnm,.\/<>?\\|]+| *)$/i.test(x)tiene la misma duración
Ismael Miguel
@IsmaelMiguel Usar un bit a bit |ahorra 1 byte.
Arnauld
1
@IsmaelMiguel Esto es parte de la especificación ECMAScript. Los únicos 3 caracteres que deben escaparse dentro de una clase de caracteres son \ , ]y -(vea ClassAtomNoDash en la especificación). El guión también puede aparecer sin escape si es el primer o el último carácter (de lo contrario, se interpreta como un separador de rango de caracteres).
Arnauld
5

Perl 6 , 102101100 bytes

-1 byte gracias a nwellnhof!

->\a{max map {a.combcomb $_~.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.

Jo King
fuente
Puede usar en maxlugar de ?any(y en minlugar de ?all).
nwellnhof
1
Para lo que vale, una solución basada en expresiones regulares sería 84 bytes u 80 bytes usando Perl 5 expresiones regulares con m:P5//. Pero no creo que valga la pena publicar ninguno de ellos como respuesta.
nwellnhof
4

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
Kevin Cruijssen
fuente
Buena solución, pero devuelve cierto a !!!pesar de que los signos de exclamación no se pueden imprimir con una sola línea. Acabo de agregar eso como un caso de prueba
Luke Stevens,
@LukeStevens Ah, supuse falsamente que la entrada siempre es válida para una de las cinco líneas. Modificaré mi solución Es una solución simple (pero agregará algunos bytes ...)
Kevin Cruijssen
¿Por qué no usar (?i)para las otras letras mayúsculas?
Neil
@Neil Debido a la fuga requerida para la barra, también es de 209 bytes .
Kevin Cruijssen
Sugerir en p==" "lugar dep.equals(" ")
ceilingcat
4

Powershell, 87 bytes

Puerto de Neil's Retina regex .

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

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

dylnan
fuente
3

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.

Lynn
fuente
2

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!

ouflak
fuente
2

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);
Titus
fuente
2

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.

Phil F
fuente
44
"Todas las soluciones a los desafíos deberían: (...) Ser un contendiente serio para los criterios ganadores en uso. Por ejemplo, una entrada a un concurso de golf de código debe ser golfizada, y una entrada a un concurso de velocidad debe hacer algún intento de ser rápido ". - centro de ayuda No hay necesidad de declarar esas 2 variables y definitivamente no hay necesidad de convertirlas en cadenas. Y un solo printes suficiente: ¡ Pruébelo en línea!
manatwork
Su comentario de que las soluciones deberían ser serias es válido, pero diría que cualquier solución, por lo tanto, después de la 05AB1E revisada, es irrelevante ya que no podrían igualar o mejorar el resultado. No veo cómo no puede usar print dos veces para obtener tanto verdadero como falso (ciertamente para algo que lee cadenas hasta el final de la entrada). Y dije optimizado no óptimo en el momento. Gracias a tus pensamientos se puede reducir a 143 caracteres.
Phil F
Y, de hecho, ir hasta el final hará 121 caracteres ...
Phil F
2
code-golf no es una competencia para el código más corto en general, sino el más corto para su idioma. Si puedes mejorar tu solución, entonces te sugiero que lo hagas
Jo King
@Jo King, gracias por tu (s) aclaración (es). el código revisado sería / podría ser: {print/^[-```1234567890=]*$/||/^[]qwertyuiop\[]*$/||/^[asdfghjkl;'#ASDFGHJKL]*$/||/^[zxcvbnm,.\/\|<>?ZXCVBNM]*$/||/^ *$/}
Phil F
1

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!

Phil F
fuente
Tenga en cuenta que la solución Bash también significa que mi solución @ / manatwork AWK puede reducirse a 113 bytes.
Phil F