Die Herausforderung

Das Ziel dieser Herausforderung besteht darin, zu bestimmen, ob eine bestimmte Zeichenfolge mit nur einer Zeile einer Standard-QWERTZ-Tastatur in Großbritannien eingegeben werden kann.

Dies ist code golf, so dass die kürzeste Lösung in Bytes gewinnt!

Die Eingabe ist eine einzelne Zeichenfolge mit null oder mehr Zeichen im ASCII-Dezimalbereich von 32-126 einschließlich. Sie können für diese Herausforderung annehmen, dass eine leere Zeichenfolge keine Eingabe erfordert und daher mit einer einzigen Zeile eingegeben werden kann.

Sie können die Eingabe als eine Zeichenfolge, eine Liste von Zeichen oder eine äquivalente Form für Ihre Sprache annehmen.

Die Ausgabe sollte ein wahrer Wert für jeden String sein, der mit einer einzelnen Zeile eingegeben werden kann, oder ein falscher Wert für einen String, der nicht eingegeben werden kann.

Um Unklarheiten in Bezug auf das Standard-Tastaturlayout zu beseitigen, finden Sie in jeder Zeile eine Liste der verfügbaren Tasten, einschließlich alternativer oberer Tasten (Zugriff über Umschalttaste).

• Linie 1
  • Standard: `1234567890-=
• Zeile 2
  • Standard: qwertyuiop[]
• Zeile 3
  • Standard: asdfghjkl;'#
  • Großbuchstaben: ASDFGHJKL
  • Besonderheit: Feststelltaste
• Zeile 4
  • Standard: \zxcvbnm,./
  • Wechseln: |<>?
  • Großbuchstaben: ZXCVBNM
  • Spezial: Schicht
• Zeile 5
  • Spezial: Leertaste

Alternative obere Tasten können nur gedrückt werden, wenn sich die Umschalttaste ebenfalls in derselben Zeile befindet, und auf Großbuchstaben kann nur über die Feststelltaste oder die Umschalttaste zugegriffen werden. Sie können wirklich nur eine Tastaturzeile verwenden!

            -> 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\,./|<>?"," "])

Probieren Sie es online!

Python 3 , 111 Bytes

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

Probieren Sie es online!

_{-4 Bytes, danke an nedla2004}

Retina 0.8.2 , 72 71 Bytes

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

Probieren Sie es online! Erläuterung: Jede Abwechslung entspricht einer anderen Tastaturzeile. Die (?i)Mitte des Musters bewirkt, dass der gesamte Rest des Musters unabhängig von Groß- und Kleinschreibung abgeglichen wird. Bearbeiten: 1 Byte dank @KirillL gespeichert.

05AB1E , 66 47 Bytes

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

Übernimmt die Eingabe als Liste von Zeichen.

-19 Bytes dank @Emigna . Völlig vergessen, dass wir QWERTY-Tastatur-Konstanten eingebaut hatten. : D

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Probieren Sie es online!

Der offensichtliche Regex-Ansatz.

Ruby -n , 86 81 Bytes

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

Probieren Sie es online!

JavaScript (Node.js) , 99 98 95 Byte

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

Probieren Sie es online!

-1 aus dem Kommentar von @Kirill L. in der Retina-Antwort.
-3 danke @Ismael Miguel und @Arnauld für ihren gemeinsamen Einsatz.

Perl 6 , 102 101 100 Bytes

-1 byte dank nwellnhof!

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

Probieren Sie es online!

Ziemlich Standardimplementierung. Es gibt wahrscheinlich eine kürzere, auf Regex basierende Lösung, aber ich kenne Perl 6s Regex nicht gut genug, um einen Versuch zu unternehmen.

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 dank @TFeld .

Probieren Sie es online aus.

Erläuterung:

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

Port von Neils Retina-Regex .

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

Jelly , 55 Bytes

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

Probieren Sie es online!

Die erste Zeile liefert eine Liste der Tastaturzeilen und die zweite prüft, ob die Programmeingabe in einer einzelnen Zeile (oder in einer Nullzeile) enthalten ist und ob es keine Zeichen gibt, die nicht eingegeben werden können (wie QWE!@#).

C 150 Bytes

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

Probieren Sie es online!

Es wird keine Preise gewinnen, aber das ist ein lustiger Ansatz: Wir ordnen Zeichen in den fünf Zeilen der Tastatur 4 8 16 32 64und jedem ungültigen Zeichen zu 3. Wir führen eine bitweise ODER-Verknüpfung der Werte für jedes Zeichen in der Zeichenfolge durch und prüfen, ob das Ergebnis zufriedenstellend x&(x-1) == 0ist. Dies ist der Fall, wenn xeine Potenz von 2 oder Null vorliegt, dh wenn xhöchstens ein Bit gesetzt ist.

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)

Probieren Sie es online!

PHP, 98 Bytes

Ich bin ein bisschen traurig, dass es nichts kürzeres als Regex gibt. Es ist wahrscheinlich nicht die schnellste Lösung.

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

Laufen Sie als Pipe mit -Foder versuchen Sie es online .

Kürzeste nicht-reguläre Lösung, die ich gefunden habe (124 Bytes; Zeilenumbruch und Tabulator zur Vereinfachung des Lesens):

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

Exits mit Code 1für Wahrhaftigkeit, 0für Falschheit. Als Rohr mit laufen lassen -R.
Benötigt PHP 5.4 oder neuer; Verwenden Sie für älteres PHP array(...)anstelle von [...](+5 Bytes)
oder verwenden Sie diese 123 Bytes mit -nRin PHP <7:

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

AWK , 163 119 113 Bytes

Dies ist eine AWK-Antwort, die eine numerische 1-Zeichenfolge für true und eine 0-Zeichenfolge für false zurückgibt. (Als AWK geschrieben, als awk -f-Datei für die interaktive Verwendung aufrufen.)

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

Probieren Sie es online!

Behandelt TAB-Zeichen jedoch nicht als geschrieben (einfache Erweiterung), da sie nicht Teil der Spezifikation sind.

Bash , 119 Bytes

Enthält ein Echo für eine "lesbare" Ausgabe. Wenn Sie einen geeigneten Shell-Wrapper (Ihrer Wahl) verwenden, um Print / Output einzuschließen, können Sie 8 Bytes einsparen. Meine Lektüre der Herausforderung legt nahe, dass die Lösung eine geeignete Ausgabeanzeige ausgeben sollte, also halte ich mich an 119 Bytes.

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

Probieren Sie es online!