Sai, abbiamo avuto molte sfide "alfabetiche" di recente. ^{( uno due tre quattro cinque .)} Mentre adoro una bella sfida, e quelle sfide sono state molto divertenti, penso che sia tempo di cambiare ritmo. Dobbiamo escludere tali sfide in futuro. È tempo di automazione !

Troverai alcuni alfabeti per me e per l'automazione (e per gloria!) Gli alfabeti sono complicati e amano mascherarsi. ^{[citazione necessaria]} Dovrai tenere conto dei seguenti fattori:

1. Gli alfabeti possono essere maiuscoli o minuscoli (ma non entrambi). Quindi, devi cercare ABCDEFGHIJKLMNOPQRSTUVWXYZe abcdefghijklmnopqrstuvwxyz, ma non AbCdeFGhIJkLmNOpQRsTuvwxyZ. Ossia, cerca solo alfabeti composti da un solo caso.
2. Gli alfabeti possono spostarsi. potrebbero non iniziare sempre con A, ma potrebbero iniziare con Go U. Quindi dovrai cercare cose come OPQRSTUVWXYZABCDEFGHIJKLMN.
3. Gli alfabeti potrebbero non sempre leggere in avanti. Possono anche leggere indietro, su e giù. Ad esempio, ZYXWVUTSRQPONMLKJIHGFEDCBAè anche un alfabeto valido.

Ecco un esempio di una stringa che ha un alfabeto:

JIHGFEDCBAZYXWVUTSRQPONMLK

Questo è un alfabeto spostato all'indietro:

JIHGFEDCBAZYXWVUTSRQPONMLK
<--------|<---------------

Questo contiene anche un alfabeto:

F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
A
B
C
D
E

è un alfabeto orientato verso il basso:

F |
G |
H |
I |
J |
K |
L |
M |
N |
O |
P |
Q |
R |
S |
T |
U |
V |
W |
X |
Y |
Z V
A===
B |
C |
D |
E V

La tua sfida è scrivere un programma, una funzione, ecc. Che, data una stringa, restituisca / restituisca un valore di verità se la stringa contiene almeno un alfabeto o un valore di falsa in caso contrario. Questo è un codice-golf , quindi vince il programma più breve in byte.

Casi test

Truthy

ABCDEFGHIJKLMNOPQRSTUVWXYZ

abcdefghijklmnopqrstuvwxyz

ABCDEFGHIJKLMNOPQRSTUVWXYabcdefghijklmnopqrstuvwxyz

ZABCDEFGHIJKLMNOPQRSTUVWXYghijklmnopqrstuvwxyzabcdef

ZBCDEFGHIJghijklmnopqrstuvwxyzabcdef

AAAAAAAA
BBBBBBBB
CCCCCCCC
DDDDDDDD
EEEEEEEE
FFFFFFFF
GGGGGGGG
HHHHHHHH
IIIIIIII
JJJJJJJJ
KKKKKKKK
LLLLLLLL
MMMMMMMM
NNNNNNNN
OOOOOOOO
PPPPPPPP
QQQQQQQQ
RRRRRRRR
SSSSSSSS
TTTTTTTT
UUUUUUUU
VVVVVVVV
WWWWWWWW
XXXXXXXX
YYYYYYYY
ZZZZZZZZ

 J54
 Igeh
 H
 G
 Fzx6
 E
 Dv
 Cvzxc
 Bs
 Adf
 Z
@Yascvf
 Xsf
 W
 Vfas
 Uw
 Te
~S
 R
 Qasdfasdf
 P
 O
 N
 M
 LMNOPQR
 K

Falsey

Hello, World!

KLMNOPQRSTUVWXYZABCDEF

K        ZYXW
 L         V
  M       U
   N     T
    O   S
     P R
      Q

A
 BCDEFGHIJKLMNOPQRSTUVWXYZ

ABCDEFGHIJKLmnopqrstuvwxyz

Gelatina , 28 23 22 byte

1 byte grazie a Dennis.

26RØAṙ;U$;Œl$
;Zẇ@þ¢FS

Provalo online!

Accetta una serie di stringhe.

Cheddar, 148 byte

(s,b=65@"90,c?)->(|>27).map(->s has(b=b.slice(1)+b[0])||s has b.lower||(1|>3).map(j->(c=s.lines.turn(j).vfuse)has b||c has b.lower?1:0).sum?1:0).sum

Provalo online!

Non copeting, 146 132 byte

Questo è esattamente lo stesso sopra, tranne che map(...?1:0).sumè diventato any(...).

(s,b=65@"90,c?)->(|>27).any(->s has(b=b.slice(1)+b[0])||s has b.lower||(1|>3).any(j->(c=s.lines.turn(j).vfuse)has b||c has b.lower))

Piuttosto lento ma funziona ¯ \ _ (ツ) _ / ¯. aggiunta anyfunzione dopo la data di rilascio della sfida.

Non è necessario riempire l'input con spazi bianchi. Ma se un input non funziona, riempilo di spazi bianchi per creare un rettangolo. La turnfunzione è davvero pignola e non sono sicuro di quando funziona e quando no

Spiegazione

Passa attraverso tutti i possibili cicli dell'alfabeto. Ad ogni iterazione controlla se il ciclo corrente dell'alfabeto esiste nella stringa, altrimenti controlla se una delle possibili rotazioni della stringa ha l'alfabeto.

Ungolfed

(str, a = 65@"90)->
  (|>27).any(->
    str has (a = a.slice(1) + a[0]) ||
    str has a.lower                 ||
    (1|>3).any(j ->
      (c = str.lines.turn(j).vfuse) has a ||
      c has a.lower
    )
  )

05AB1E, 43 byte

A‚Duìvy26FÀD}})U|Dø€J)˜vXDgs`rFysk>ˆ}}¯O__

Spiegazione in breve

Ottieni diverse varianti dell'alfabeto (maiuscolo, no-cap, invertito, normale) e memorizza in X.

A‚Duìvy26FÀD}})U

Ottieni ogni riga e colonna di input come un elenco di stringhe.

                 |Dø€J)˜

Controlla ciascuna di queste stringhe se contiene una variazione dell'alfabeto.

                        vXDgs`rFysk>ˆ}}

Somma e doppio negazione, dando 1 per vero e 0 per falso.

                                       ¯O__

Provalo online

Python, 182 byte

Non sembra molto "golfato", ma ...

import re
a='abcdefghijklmnopqrstuvwxyz'
P,N='|\n'
p=P.join(a[i:]+a[:i] for i in range(26))
p+=P+p[::-1]
p+=P+p.upper()
lambda s:re.search(p,s+N+N.join(map(''.join,zip(*s.split(N)))))

Teoria dell'operazione:

Innanzitutto, crea un modello regex combinando tutti i possibili alfabeti:

p=P.join(a[i:]+a[:i] for i in range(26))crea una stringa di tutte le rotazioni di 'a' unita a '|'. ad es. "abc ... z | bcd ... za | ..."

p+=P+p[::-1] aggiunge una versione invertita di se stesso.

p+=P+p.upper() accoda una versione maiuscola.

Quindi crea una stringa lunga che combina l'originale se una versione scon le colonne trasformate in righe:

N.join(map(''.join,zip(*s.split(N)))) inverte le righe e le colonne, quindi "a \ nb \ nc" diventa "abc"

restituisce vero se il modello è nella stringa lunga.