O desafio

O objetivo deste desafio é determinar se uma determinada String pode ser digitada usando apenas uma linha de um teclado QWERTY padrão do Reino Unido.

Isto é code golf, a solução mais curta em bytes vence!

A entrada será uma única sequência de zero ou mais caracteres no intervalo decimal ASCII de 32 a 126, inclusive. Você pode assumir que, para esse desafio, uma String vazia não requer digitação e, portanto, pode ser digitada usando uma única linha.

Você pode considerar a entrada como uma sequência, lista de caracteres ou forma equivalente para o seu idioma.

A saída deve ser um valor verdadeiro para qualquer String que pode ser digitada usando uma única linha, ou falsey para uma que não pode.

Para esclarecer qualquer ambiguidade sobre o que está abaixo o layout padrão do teclado, há uma lista de teclas disponíveis em cada linha, incluindo teclas superiores alternativas (acessadas usando shift).

• Linha 1
  • Padrão: `1234567890-=
• Linha 2
  • Padrão: qwertyuiop[]
• Linha 3
  • Padrão: asdfghjkl;'#
  • Maiúsculas: ASDFGHJKL
  • Especial: Caps Lock
• Linha 4
  • Padrão: \zxcvbnm,./
  • Alternar: |<>?
  • Maiúsculas: ZXCVBNM
  • Especial: Turno
• Linha 5
  • Especial: Barra de espaço

As teclas superiores alternativas somente podem ser pressionadas se Shift também estiver na mesma linha, e as teclas maiúsculas somente podem ser acessadas através de Caps Lock ou Shift. Você realmente só pode usar uma linha 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\,./|<>?"," "])

Experimente online!

Python 3 , 111 bytes

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

Experimente online!

_{-4 bytes, graças a nedla2004}

Retina 0.8.2 , 72 71 bytes

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

Experimente online! Explicação: Cada alternação corresponde a uma linha diferente do teclado. O (?i)meio do padrão faz com que todo o restante do padrão seja correspondido sem distinção entre maiúsculas e minúsculas. Editar: salvou 1 byte graças a @KirillL.

05AB1E , 66 47 bytes

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

Toma a entrada como uma lista de caracteres.

-19 bytes graças a @Emigna . Esquecemos completamente que tínhamos built-in constantes de teclado qwerty. : D

Experimente online ou verifique todos os casos de teste .

Explicação:

ž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,.|<>?]+)$/

Experimente online!

A abordagem óbvia regex.

Ruby -n , 86 81 bytes

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

Experimente online!

JavaScript (Node.js) , 99 98 95 bytes

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

Experimente online!

-1 do comentário de @Kirill L. na resposta da Retina.
-3 agradece a @Ismael Miguel e @Arnauld pelo esforço conjunto.

Perl 6 , 102 101 100 bytes

-1 byte graças a nwellnhof!

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

Experimente online!

Implementação bastante padrão. Provavelmente existe uma solução mais curta baseada em regex para isso, mas não conheço a regex do Perl 6 o suficiente para fazer uma tentativa.

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 graças a @TFeld .

Experimente online.

Explicação:

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

Regex do porto de Neil's Retina .

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

Geléia , 55 bytes

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

Experimente online!

A primeira linha produz uma lista das linhas do teclado e a segunda verifica se a entrada do programa está contida em uma única (ou zero) linhas e se não há caracteres que não possam ser digitados (como QWE!@#).

C , 150 bytes

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

Experimente online!

Não ganhará nenhum prêmio, mas é uma abordagem divertida: mapeamos caracteres nas cinco linhas do teclado 4 8 16 32 64e todos os caracteres inválidos 3. Nós bit a bit OU o valor de cada caractere na string juntos, e verificamos se o resultado é satisfatório x&(x-1) == 0, o que é verdadeiro quando xé uma potência de 2 ou zero, ou seja, sempre que xhouver no máximo um bit definido.

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)

Experimente online!

PHP, 98 bytes

Estou um pouco triste por não haver nada mais curto que regex. Provavelmente não é a solução mais rápida.

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

Execute como pipe -Fou experimente online .

A solução não-regex mais curta que encontrei (124 bytes; quebra de linha e guia para facilitar a leitura):

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

sai com código 1para verdade, 0para falsidade. Corra como cano com -R.
Requer PHP 5.4 ou posterior; para PHP antigo, use em array(...)vez de [...](+5 bytes)
ou use esses 123 bytes -nRno PHP <7:

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

AWK , 163 119 113 bytes

Esta é uma resposta AWK, retorna uma string numérica 1 para true, 0 string para false. (Escrito como AWK, invoque como arquivo awk -f para uso interativo.)

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

Experimente online!

No entanto, não lida com o caractere TAB como gravado (extensão trivial) como parte da especificação.

Bash , 119 bytes

Inclui um eco para fornecer saída "legível". Se você colocar um invólucro de casca adequado (sua escolha) ao redor para incluir impressão / saída, poderá salvar 8 bytes. Minha leitura do desafio sugere que a solução deve gerar uma indicação de saída adequada, portanto, permaneço com 119 bytes.

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

Experimente online!