您知道，最近我们遇到了很多“字母”挑战。^{（一个 2 3 4 5。）}虽然我喜欢挑战，而这些挑战是很好玩的，我认为它的时间节奏的变化。我们将来需要排除这些挑战。现在是自动化的时候了！

您会为我找到一些字母，并为自动化（和荣耀！）找到一些字母。字母很棘手，喜欢伪装自己。^{[需要引用]}您需要考虑以下因素：

1. 字母可以是大写或小写（但不能两者都写）。因此，您需要查找ABCDEFGHIJKLMNOPQRSTUVWXYZ和abcdefghijklmnopqrstuvwxyz，但不需要AbCdeFGhIJkLmNOpQRsTuvwxyZ。即，仅查找完全由一种情况组成的字母。
2. 字母可以四处移动。它们可能并非总是以开头A，而是以G或开头U。因此，您必须寻找类似的东西OPQRSTUVWXYZABCDEFGHIJKLMN。
3. 字母可能并不总是向前读。他们还可以向后，向上和向下阅读。例如，ZYXWVUTSRQPONMLKJIHGFEDCBA也是有效的字母。

这是一个带有字母的字符串的示例：

JIHGFEDCBAZYXWVUTSRQPONMLK

这是一个向后的移位字母：

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

这还包含一个字母：

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

这是一个向下的字母：

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

您面临的挑战是编写一个程序，函数等，给定一个字符串，如果该字符串包含至少一个字母，则输出/返回真实值，否则返回假值。这是一个代码高尔夫球，因此以字节为单位的最短程序获胜。

测试用例

特鲁西

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

虚假

Hello, World!

KLMNOPQRSTUVWXYZABCDEF

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

A
 BCDEFGHIJKLMNOPQRSTUVWXYZ

ABCDEFGHIJKLmnopqrstuvwxyz

果冻，28 23 22 字节

1字节感谢丹尼斯。

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

在线尝试！

接受字符串数组。

Cheddar，148个字节

(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

在线尝试！

非copmeting，146个 132字节

这与上面的完全一样，只是map(...?1:0).sum变成了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))

速度虽然很慢，但是可以使用\ _（ツ）_ /¯。any在挑战发布日期之后增加了功能。

输入不需要用空格填充。但是，如果输入无效，则用空格填充以形成矩形。该turn功能真的很挑剔，我不确定什么时候该起作用，什么时候不起作用

说明

循环遍历所有可能的字母循环。在每次迭代中，检查字符串中是否存在字母的当前循环，如果不存在，请检查字符串的任何可能旋转中是否包含字母。

不打高尔夫球

(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字节

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

简而言之

获取字母的不同变体（大写，无大写，反写，普通）并存储在X中。

A‚Duìvy26FÀD}})U

获取输入的每一行和每一列作为字符串列表。

                 |Dø€J)˜

检查每个这样的字符串是否包含字母的变体。

                        vXDgs`rFysk>ˆ}}

求和和双重否定，给定1为真，0为假。

                                       ¯O__

在线尝试

Python，182字节

感觉不太“高兴”，但是...

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

操作原理：

首先，构建结合所有可能字母的正则表达式模式：

p=P.join(a[i:]+a[:i] for i in range(26))建立一个由'|'加上'|'的所有旋转的字符串。例如“ abc ... z | bcd ... za | ...”

p+=P+p[::-1] 追加本身的反向版本。

p+=P+p.upper() 追加大写版本。

然后创建一个长字符串，将原始s版本和版本组合在一起s，并将列变成行：

N.join(map(''.join,zip(*s.split(N)))) 翻转行和列，因此'a \ nb \ nc'变为'abc'

如果模式在长字符串中，则返回true。