मैं थोड़ी देर के लिए वर्णमाला का शिकार हुआ

Question

Y'now, हम हाल ही में "वर्णमाला" चुनौतियों का एक बहुत कुछ किया है। ^{( एक दो तीन चार पांच ।)} जबकि मैं एक अच्छी चुनौती से प्यार करता हूं, और वे चुनौतियां बहुत मजेदार थीं, मुझे लगता है कि यह बदलाव का समय है। हमें भविष्य में ऐसी चुनौतियों को बाहर करने की जरूरत है। यह स्वचालन के लिए समय है !

आप मेरे लिए कुछ अक्षर खोजने जा रहे हैं, और स्वचालन के लिए (और महिमा के लिए!) अक्षर मुश्किल हैं और खुद को छिपाने के लिए पसंद करते हैं। ^{[उद्धरण वांछित]} आपको निम्नलिखित कारकों पर ध्यान देना होगा:

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

---

आपकी चुनौती एक प्रोग्राम, फंक्शन इत्यादि लिखने की है, जिसमें एक स्ट्रिंग दी जाती है, यदि एक स्ट्रिंग में कम से कम एक वर्णमाला या अन्यथा एक गलत मूल्य होता है, तो एक सत्य मान देता है। यह एक कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कार्यक्रम जीत जाता है।

परीक्षण के मामलों

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

Comments

"मैं वर्णमाला की चुनौतियों से बीमार हूँ। यहाँ एक वर्णमाला चुनौती है।" lol +1

— AdmBorkBork

क्या आयत बनाने के लिए हमारे पास रिक्त स्थान के साथ इनपुट हो सकता है? : 3

— डाउगोएट

@Downgoat हाँ, आप कर सकते हैं।

— कॉनर ओ'ब्रायन

अपने संग्रह में जोड़ने के लिए एक और चुनौती ।

— लीक नून

क्या हम स्ट्रिंग्स का 2 डी सरणी ले सकते हैं? प्रत्येक पंक्ति एक पंक्ति होगी, जो आयतों को बनाने के लिए रिक्त स्थान के साथ गद्देदार होगी

— लुइस मेंडो

Answer 1

जेली , 28 23 22 बाइट्स

1 बाइट डेनिस के लिए धन्यवाद।

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

इसे ऑनलाइन आज़माएं!

तार की एक सरणी लेता है।

Comments

वाट कैसे जेली हमेशा इतनी छोटी है ।___

— डाउनगोट

@Downgoat क्या आप जेली हैं?

— पैट्रिक रॉबर्ट्स

@PatrickRoberts <s> हाँ </ s> नहीं मैं बकरी हूँ

— डाउनगोट

Answer 2

चेडर, 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 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))

बल्कि धीमा है, लेकिन यह _ \ _ (_) _ / ather काम करता है। 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
    )
  )

Comments

क्या c?मतलब है?

— कॉनर ओ'ब्रायन

@ ConorO'Brien का c?अर्थ है वैकल्पिक तर्क। मूल रूप से एक ही हैc=nil

— डाउनगोट

एक प्रतिस्पर्धात्मक संस्करण बनाएं, फिर इस गैर-प्रतिस्पर्धात्मक संस्करण को नीचे रखें।

— लीक नून

@LeakyNun इस पर काम कर रहा है, {}हालांकि इसके बिना कैसे पता लगाया जा सकता है

— डाउनगोट

any(...)बस हैmap(...?1:0).sum

— लीक नून

Answer 3

05AB1E, 43 बाइट्स

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

संक्षेप में व्याख्या

वर्णमाला के अलग-अलग रूप (कैप, नो-कैप्स, उलट, सामान्य) और एक्स में स्टोर करें।

A‚Duìvy26FÀD}})U

तार की एक सूची के रूप में इनपुट की प्रत्येक पंक्ति और स्तंभ प्राप्त करें।

                 |Dø€J)˜

प्रत्येक ऐसे तार की जाँच करें यदि उसमें वर्णमाला का रूपांतर हो।

                        vXDgs`rFysk>ˆ}}

सम और डबल नेगेट, 1 को सही और 0 को गलत।

                                       ¯O__

इसे ऑनलाइन आज़माएं

Answer 4

पायथन, 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))'a' से जुड़कर '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' बन जाता है

यदि पैटर्न लंबे स्ट्रिंग में है तो सही लौटें।

Comments

बहुत यकीन है कि आप ऐसा करने के लिए regex की जरूरत नहीं है; विशेष रूप से, विकल्प के लिए inजाँच करता है।

— लीक नून

@ लीकन्यू, मैं संभावित अल्फ़ाज़ों (घुमाव, उलट, मामला) पर बहुत सारे छोरों से बचने की कोशिश कर रहा था। रेगेक्स पैटर्न में सभी संभावनाएं हैं - केवल एक लूप का उपयोग करके। इसके अलावा, खोज करने के लिए स्ट्रिंग में सामान्य और पंक्ति-फ़्लिप दोनों संस्करणों में इनपुट स्ट्रिंग शामिल है, इसलिए कोई भी लूपिंग नहीं है।

— RootTwo