ใช่แล้วเราเพิ่งเจอความท้าทาย "ตัวอักษร" มากมาย ^{( หนึ่ง สอง สาม สี่ ห้า )}ในขณะที่ฉันรักความท้าทายที่ดีและความท้าทายเหล่านั้นสนุกมากฉันคิดว่าถึงเวลาสำหรับการเปลี่ยนแปลงของจังหวะ เราจำเป็นต้องยกเว้นความท้าทายดังกล่าวในอนาคต ถึงเวลาสำหรับระบบอัตโนมัติ !

คุณกำลังจะหาตัวอักษรสำหรับฉันและสำหรับระบบอัตโนมัติ (และเพื่อความรุ่งโรจน์!) ตัวอักษรนั้นมีเล่ห์เหลี่ยมและชอบปกปิดตัวเอง ^{[จำเป็นต้องมีการอ้างอิง]}คุณจะต้องคำนึงถึงปัจจัยต่อไปนี้:

1. ตัวอักษรสามารถเป็นตัวพิมพ์ใหญ่หรือตัวพิมพ์เล็ก (แต่ไม่ใช่ทั้งคู่) ดังนั้นคุณต้องมองหาABCDEFGHIJKLMNOPQRSTUVWXYZและแต่ไม่abcdefghijklmnopqrstuvwxyz AbCdeFGhIJkLmNOpQRsTuvwxyZนั่นคือมองหาตัวอักษรที่ประกอบด้วยหนึ่งกรณีเท่านั้น
2. ตัวอักษรสามารถเลื่อนไปมา พวกเขาอาจไม่เริ่มต้นด้วยAแต่อาจเริ่มต้นด้วยหรือG ดังนั้นคุณจะต้องมองหาสิ่งที่ต้องการUOPQRSTUVWXYZABCDEFGHIJKLMN
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

ความท้าทายของคุณคือการเขียนโปรแกรมฟังก์ชั่นและอื่น ๆ ที่ได้รับสตริงเอาท์พุท / ส่งกลับค่าความจริงถ้าสตริงที่มีอย่างน้อยหนึ่งตัวอักษรหรือค่าเท็จเป็นอย่างอื่น นี่คือรหัสกอล์ฟดังนั้นโปรแกรมที่สั้นที่สุดในหน่วยไบต์ชนะ

กรณีทดสอบ

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

เยลลี่ , 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

ลองออนไลน์!

การไม่ทำสำเนา146 146ไบต์

นี้เป็นที่แน่นอนเดียวกันกับข้างต้นยกเว้นได้กลายเป็นmap(...?1:0).sumany(...)

(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ฟังก์ชั่นเป็นจู้จี้จุกจิกจริงๆและผมไม่แน่ใจว่าเมื่อมันทำงานและเมื่อมันไม่ได้

คำอธิบาย

วนซ้ำไปตามวงจรของตัวอักษรที่เป็นไปได้ทั้งหมด ในการวนซ้ำแต่ละรอบให้ตรวจสอบว่ามีการหมุนเวียนรอบตัวอักษรในสตริงหรือไม่ถ้าไม่มีให้ตรวจสอบว่าการหมุนใด ๆ ที่เป็นไปได้ของสตริงนั้นมีตัวอักษรหรือไม่

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 ไบต์

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

ทฤษฎีการทำงาน:

ก่อนอื่นให้สร้างรูปแบบ regex โดยรวมตัวอักษรที่เป็นไปได้ทั้งหมด:

p=P.join(a[i:]+a[:i] for i in range(26))สร้างสตริงการหมุนทั้งหมดของ 'a' รวมกับ '|' เช่น "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'

กลับจริงถ้ารูปแบบที่อยู่ในสตริงยาว