Sabe, tivemos muitos desafios de "alfabeto" recentemente. ^{( um dois três quatro cinco .)} Embora eu goste de um bom desafio, e esses desafios foram muito divertidos, acho que é hora de mudar de ritmo. Precisamos excluir esses desafios no futuro. Está na hora da automação !

Você encontrará alguns alfabetos para mim e para automação (e para a glória!) Os alfabetos são complicados e gostam de se disfarçar. ^{[citation-needed]} Você precisará levar em consideração os seguintes fatores:

1. Alfabetos podem ser maiúsculos ou minúsculos (mas não ambos). Então, você precisa procurar ABCDEFGHIJKLMNOPQRSTUVWXYZe abcdefghijklmnopqrstuvwxyz, mas não AbCdeFGhIJkLmNOpQRsTuvwxyZ. Ou seja, procure apenas alfabetos compostos inteiramente por um caso.
2. Alfabetos podem mudar de lugar. eles nem sempre podem começar com A, mas podem começar com Gou U. Então você terá que procurar coisas como OPQRSTUVWXYZABCDEFGHIJKLMN.
3. Os alfabetos nem sempre podem ser lidos adiante. Eles também podem ler para trás, para cima e para baixo. Por exemplo, ZYXWVUTSRQPONMLKJIHGFEDCBAtambém é um alfabeto válido.

Aqui está um exemplo de uma sequência que possui um alfabeto:

JIHGFEDCBAZYXWVUTSRQPONMLK

Este é um alfabeto deslocado para trás:

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

Este também contém um 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

é um alfabeto voltado para baixo:

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

Seu desafio é escrever um programa, função etc. que, dada uma string, produza / retorne um valor verdadeiro se a string contiver pelo menos um alfabeto ou um valor falsey de outra forma. Este é um código de golfe , portanto o programa mais curto em bytes vence.

Casos de teste

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

Geléia , 28 23 22 bytes

1 byte graças a Dennis.

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

Experimente online!

Toma uma matriz de seqüências de caracteres.

Queijo 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

Experimente online!

Não contencioso, 146 132 bytes

É exatamente o mesmo que acima, exceto que map(...?1:0).sumse tornou 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, mas funciona ¯ \ _ (ツ) _ / ¯. anyfunção adicionada após a data de lançamento do desafio.

A entrada não precisa ser preenchida com espaços em branco. Mas se uma entrada não funcionar, preencha-a com espaços em branco para criar um retângulo. A turnfunção é realmente exigente e não tenho certeza de quando funciona e quando não funciona.

Explicação

Loops através de todos os ciclos possíveis do alfabeto. Em cada iteração, verifique se o ciclo atual do alfabeto existe na sequência; caso contrário, verifique se alguma das possíveis rotações da sequência possui o 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 bytes

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

Explicação resumida

Obtenha diferentes variações de alfabeto (maiúsculas, sem maiúsculas, invertido, normal) e armazene no X.

A‚Duìvy26FÀD}})U

Obtenha cada linha e coluna de entrada como uma lista de cadeias.

                 |Dø€J)˜

Verifique cada uma dessas strings se ela contém uma variação do alfabeto.

                        vXDgs`rFysk>ˆ}}

Soma e negação dupla, dando 1 para verdadeiro e 0 para falso.

                                       ¯O__

Experimente online

Python, 182 bytes

Não parece muito "jogado", mas ...

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 de Operação:

Primeiro, crie um padrão regex combinando todos os alfabetos possíveis:

p=P.join(a[i:]+a[:i] for i in range(26))cria uma sequência de todas as rotações de 'a' unidas a '|'. por exemplo "abc ... z | bcd ... za | ..."

p+=P+p[::-1] acrescenta uma versão invertida de si mesma.

p+=P+p.upper() anexa uma versão em maiúsculas.

Em seguida, crie uma sequência longa combinando o original se uma versão scom as colunas transformadas em linhas:

N.join(map(''.join,zip(*s.split(N)))) vira as linhas e colunas, para que 'a \ nb \ nc' se torne 'abc'

return true se o padrão estiver na cadeia longa.