Un aspetto del test di sicurezza della password è l'esecuzione di lettere adiacenti sulla tastiera. In questa sfida, è necessario creare un programma che ritorni truese una stringa contiene esecuzioni di lettere adiacenti.

Cosa conta come una sequenza di lettere adiacenti?

Per questa versione semplificata di un tester di sicurezza della password, una sequenza di caratteri adiacenti è composta da 3 o più lettere che si trovano una accanto all'altra in una sola direzione (sinistra, destra, sopra o sotto) su una tastiera QWERTY. Ai fini di questa sfida, il layout della tastiera è simile al seguente:

1234567890
QWERTYUIOP
ASDFGHJKL
ZXCVBNM

Nel diagramma sopra Qè sotto 1ma non sotto 2, quindi una stringa che contiene 1qao aq1dovunque al suo interno farebbe tornare il programma true, ma 2qanon lo farebbe.

Ingresso

La stringa della password da controllare. Conterrà solo i caratteri [0-9a-z]o [0-9A-Z](la tua scelta).

Produzione

Il programma deve restituire un valore di verità se la password contiene una o più esecuzioni di chiavi adiacenti o false se non ne contiene.

Esempi

I seguenti input dovrebbero produrre true:

• asd
• ytrewq
• ju7
• abc6yhdef

E questi input dovrebbero generare false:

• abc
• aaa
• qewretry
• zse
• qwdfbn
• pas

Regole

• Le risposte possono essere programmi o funzioni completi.
• Le scappatoie standard non sono ammesse.
• Questo è code-golf , il punteggio più basso (in byte) vince!

Pyth - 66 62 60 byte

Approccio piuttosto diretto. Verifica se una delle sottostringhe len 3 è in una delle rotazioni della tastiera. Utilizzerà la codifica di base per la tastiera.

.E}Rjb+J+Kc+jkS9"0
qwertyuiop
asdfghjkl
zxcvbnm"b.tKN_MJ.:z3

Test Suite .

Japt , 78 byte

Japt è una versione abbreviata di Ja vaScri pt . Interprete

V=1oA ¬+`0\nqØÆyuiop\n?dfghjkl \nzxcvbnm`;1+¡Y©(((VbX -VbUgY-1)-5 a -5 %A a)bB

Output 0per casi falsi; altrimenti, un numero intero positivo. La ?deve essere sostituito con il non stampabile Unicode char U + 0086, o se non si vuole andare a tutti i problemi che, proprio as.

Come funziona

V=1oA q +"0\nqwertyuiop\nasdfghjkl \nzxcvbnm";1+Um@Y&&(((VbX -VbUgY-1)-5 a -5 %A a)bB
           // Implicit: U = input string
V=1oA q    // Set variable V to the digits 1-9, plus
+"...";    // this string.
Um@        // Take U and map each character X and its index Y with this function:
Y&&        //  If Y is 0, return Y; otherwise,
VbX -      //  take the index of X in V, subtract
VbUgY-1    //  the index of (char at position Y - 1 in U) in V,
-5 a -5    //  subtract 5, take the absolute value, subtract 5 again,
%A a       //  take modulo by 10, then take the absolute value.
           //  This returns 1 for any pair of characters that is adjacent
           //  within V, horizontally or vertically.
bB +1      // Take the index of 11 in the result and add one.
           // Implicit: output last expression

C #, 227

int h(string k){var q="1234567890,QWERTYUIOP,ASDFGHJKL,ZXCVBNM,1QAZ,2WSX,3EDC,4RFV,5TGB,6YHN,7UJM,8IK,9OL,";int i=0,j=0;for(;i<k.Length-2;i++)if((q+String.Concat(Enumerable.Reverse(q))).Contains(k.Substring(i,3)))j=1;return j;}

0 è falso, 1 è vero. Concatenati tutti i tasti orizzontali e verticali, e invertiti, e controlla se all'interno sono presenti 3 caratteri di input.

C # è davvero prolisso, devo immergermi in altre lingue :(

PHP, 173 + 1 byte

while(~$argn[$i+2])($p=preg_match)($r=_.join(".{10}",str_split(($t=substr($argn,$i++,3))))."|$t"._,$d=_1234567890_qwertyuiop_asdfghjkl__zxcvbnm)||$p($r,strrev($d))?die(1):0;

Esegui come pipe con -nRinput in minuscolo o provalo online .

Clojure, 156 byte

#(some(set(for[R[["1234567890""QWERTYUIOP""ASDFGHJKL.""ZXCVBNM..."]]R[R(apply map list R)]r R p(partition 3 1 r)p((juxt seq reverse)p)]p))(partition 3 1 %))

Questo è stato un compito abbastanza interessante da implementare.