Ya sabes, hemos tenido muchos desafíos de "alfabeto" recientemente. ^{( uno, dos, tres, cuatro, cinco ).} Aunque me encantan los buenos desafíos, y esos desafíos fueron muy divertidos, creo que es hora de un cambio de ritmo. Necesitamos excluir tales desafíos en el futuro. ¡Es hora de la automatización !

Encontrarás algunos alfabetos para mí y para la automatización (¡y para la gloria!) Los alfabetos son complicados y les gusta disfrazarse. ^{[cita requerida]} Deberá tener en cuenta los siguientes factores:

1. Los alfabetos pueden ser mayúsculas o minúsculas (pero no ambas). Por lo tanto, debe buscar ABCDEFGHIJKLMNOPQRSTUVWXYZy abcdefghijklmnopqrstuvwxyz, pero no AbCdeFGhIJkLmNOpQRsTuvwxyZ. Es decir, solo busque alfabetos que estén compuestos por un solo caso.
2. Los alfabetos pueden cambiar. Es posible que no siempre comiencen A, sino que comiencen con Go U. Entonces tendrás que buscar cosas como OPQRSTUVWXYZABCDEFGHIJKLMN.
3. Los alfabetos pueden no siempre leer hacia adelante. También pueden leer al revés, arriba y abajo. Por ejemplo, ZYXWVUTSRQPONMLKJIHGFEDCBAtambién es un alfabeto válido.

Aquí hay un ejemplo de una cadena que tiene un alfabeto:

JIHGFEDCBAZYXWVUTSRQPONMLK

Este es un alfabeto desplazado y orientado hacia atrás:

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

Esto también contiene 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

es un alfabeto orientado hacia abajo:

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

Su desafío es escribir un programa, función, etc. que, dada una cadena, genera / devuelve un valor verdadero si la cadena contiene al menos un alfabeto, o un valor falsey de lo contrario. Este es un código de golf , por lo que gana el programa más corto en bytes.

Casos de prueba

Verdad

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

Jalea , 28 23 22 bytes

1 byte gracias a Dennis.

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

Pruébalo en línea!

Toma una gran variedad de cuerdas.

Cheddar, 148 bytes

(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

Pruébalo en línea!

Sin copmeting, 146 132 bytes

Esto es exactamente lo mismo que el anterior, excepto que se map(...?1:0).sumha convertido 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))

Bastante lento pero funciona ¯ \ _ (ツ) _ / ¯. anyfunción agregada después de la fecha de lanzamiento del desafío.

La entrada no necesita ser rellenada con espacios en blanco. Pero si una entrada no funciona, rellene con espacios en blanco para hacer un rectángulo. La turnfunción es realmente delicada y no estoy seguro de cuándo funciona y cuándo no.

Explicación

Recorre todos los ciclos posibles del alfabeto. En cada iteración, verifique si el ciclo actual del alfabeto existe en la cadena; de lo contrario, verifique si alguna de las posibles rotaciones de la cadena tiene el alfabeto.

Sin golf

(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 bytes

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

Explicación en resumen

Obtenga diferentes variaciones del alfabeto (mayúsculas, sin mayúsculas, invertidas, normales) y almacene en X

A‚Duìvy26FÀD}})U

Obtenga cada fila y columna de entrada como una lista de cadenas.

                 |Dø€J)˜

Marque cada una de esas cadenas si contiene una variación del alfabeto.

                        vXDgs`rFysk>ˆ}}

Suma y doble negación, dando 1 para verdadero y 0 para falso.

                                       ¯O__

Pruébalo en línea

Python, 182 bytes

No se siente muy "golfista", pero ...

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

Teoría de operación:

Primero, crea un patrón regex que combine todos los alfabetos posibles:

p=P.join(a[i:]+a[:i] for i in range(26))crea una cadena de todas las rotaciones de 'a' unidas con '|'. por ejemplo, "abc ... z | bcd ... za | ..."

p+=P+p[::-1] añade una versión inversa de sí mismo.

p+=P+p.upper() agrega una versión en mayúscula.

Luego, cree una cadena larga que combine el original sy una versión de scon las columnas convertidas en filas:

N.join(map(''.join,zip(*s.split(N)))) voltea las filas y columnas, por lo que 'a \ nb \ nc' se convierte en 'abc'

devuelve verdadero si el patrón está en la cadena larga.