La sfida

L'obiettivo di questa sfida è determinare se una determinata stringa può essere digitata usando solo una riga di una tastiera QWERTY del Regno Unito standard.

Questa è la code golfsoluzione più breve in byte vince!

L'input sarà una singola stringa di zero o più caratteri nell'intervallo decimale ASCII di 32-126 inclusi. Si può presumere per questa sfida che una stringa vuota non richiede alcuna digitazione e quindi può essere digitata utilizzando una sola riga.

Puoi prendere l'input come stringa, elenco di caratteri o forma equivalente per la tua lingua.

L'output dovrebbe essere un valore di verità per qualsiasi stringa che può essere digitata usando una sola riga o falsa per una stringa che non può.

Per chiarire qualsiasi ambiguità su ciò che è il layout di tastiera standard di seguito è un elenco di tasti disponibili su ogni riga, inclusi i tasti superiori alternati (accessibili tramite MAIUSC).

• Linea 1
  • Standard: `1234567890-=
• Linea 2
  • Standard: qwertyuiop[]
• Linea 3
  • Standard: asdfghjkl;'#
  • Maiuscolo: ASDFGHJKL
  • Speciale: Blocco maiuscole
• Linea 4
  • Standard: \zxcvbnm,./
  • Alternato: |<>?
  • Maiuscolo: ZXCVBNM
  • Speciale: Maiusc
• Linea 5
  • Speciale: barra spaziatrice

I tasti superiori alternativi possono essere premuti solo se Shift si trova anche sulla stessa riga e i tasti maiuscoli sono accessibili solo tramite BLOC MAIUSC o MAIUSC. Puoi davvero usare solo una riga di tastiera!

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

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

Provalo online!

Python 3 , 111 byte

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

Provalo online!

_{-4 byte, grazie a nedla2004}

Retina 0.8.2 , 72 71 byte

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

Provalo online! Spiegazione: Ogni alternanza corrisponde a una riga diversa della tastiera. La (?i)parte centrale del motivo fa sì che tutto il resto del motivo sia abbinato a maiuscole e minuscole. Modifica: salvato 1 byte grazie a @KirillL.

05AB1E , 66 47 byte

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

Prende l'input come un elenco di caratteri.

-19 byte grazie a @Emigna . Dimenticato completamente che avevamo builtin costanti tastiera qwerty. : D

Provalo online o verifica tutti i casi di test .

Spiegazione:

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

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

Provalo online!

L'ovvio approccio regex.

Rubino -n , 86 81 byte

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

Provalo online!

JavaScript (Node.js) , 99 98 95 byte

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

Provalo online!

-1 dal commento di @Kirill L. nella risposta Retina.
-3 grazie @Ismael Miguel e @Arnauld per il loro sforzo combinato.

Perl 6 , 102 101 100 byte

-1 byte grazie a nwellnhof!

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

Provalo online!

Implementazione piuttosto standard. Probabilmente esiste una soluzione basata su regex più breve, ma non conosco la regex di Perl 6 abbastanza bene da fare un tentativo.

Java 10, 209 208 byte

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

Provalo online.

Spiegazione:

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 byte

Regex di Retina del porto di Neil .

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

Gelatina , 55 byte

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

Provalo online!

La prima riga produce un elenco delle righe della tastiera e la seconda controlla se l'input del programma è contenuto su una singola (o zero) righe e che non ci sono caratteri che non possono essere digitati (come QWE!@#).

C , 150 byte

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

Provalo online!

Non vincerà alcun premio, ma questo è un approccio divertente: mappiamo i caratteri sulle cinque righe della tastiera 4 8 16 32 64e ogni carattere non valido su 3. Analizziamo bit a bit il valore di ciascun carattere nella stringa insieme e controlliamo se il risultato è soddisfacente x&(x-1) == 0, il che è vero quando xè una potenza di 2 o zero, cioè ogni volta che xè impostato al massimo un bit.

LUA , 282 262 259 270 byte

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)

Provalo online!

PHP, 98 byte

Sono un po 'triste che non ci sia niente di più breve di regex. Probabilmente non è la soluzione più veloce.

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

Esegui come pipe -Fo provalo online .

La soluzione non regex più corta che ho trovato (124 byte; interruzione di riga e scheda per comodità di lettura):

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

esce con il codice 1per la verità, 0per la falsità. Esegui come pipe con -R.
Richiede PHP 5.4 o successivo; per PHP più vecchi, usa array(...)invece di [...](+5 byte)
o usa questi 123 byte con -nRin PHP <7:

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

AWK , 163 119 113 byte

Questa è una risposta AWK, restituisce una stringa numerica 1 per true, 0 stringa per false. (Scritto come AWK invoca come file awk -f per uso interattivo.)

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

Provalo online!

Tuttavia, non gestisce il carattere TAB come scritto (estensione banale) come non parte delle specifiche.

Bash , 119 byte

Include un'eco per fornire un output "leggibile". Se si inserisce un involucro adatto di shell (a scelta) per includere stampa / output, è possibile salvare 8 byte. La mia lettura della sfida suggerisce che la soluzione dovrebbe fornire un'indicazione di output adeguata, quindi rimango con 119 byte.

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

Provalo online!