अल्फाबेट सूप का बाउल बनाएं

Question

इसे हम वर्णमाला के सूप का एक कटोरा कहेंगे - परिधि बनाने के लिए 26 बड़े अक्षरों वाले अंग्रेजी अक्षरों (AZ) के साथ घड़ी की व्यवस्था के साथ एक लगभग गोलाकार एससी-कला आकृति:

   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK

एक प्रोग्राम लिखें जो एकल अक्षर वर्ण, AZ में लेता है, और वर्णक्रमीय सूप का एक ही कटोरा "घुमाया", इसलिए बोलने के लिए आउटपुट करता है, इसलिए इनपुट पत्र प्रकट होता है जहां A करता है ऊपर उदाहरण में और बाकी वर्णमाला चक्र पूरी तरह से चारों ओर है दक्षिणावर्त।

तो इनपुट के लिए आउटपुट A वर्णमाला सूप का एक ही मूल कटोरा होगा।

और इनपुट के लिए आउटपुट Bयह एक होगा:

   YZABCD
 WX      EF
V          G
U          H
T          I
 SR      KJ
   QPONML

इसी तरह के लिए उत्पादन Hहोगा:

   EFGHIJ
 CD      KL
B          M
A          N
Z          O
 YX      QP
   WVUTSR

या इसके लिए Z:

   WXYZAB
 UV      CD
T          E
S          F
R          G
 QP      IH
   ONMLKJ

यह सभी 26 अक्षरों के लिए काम करने की आवश्यकता है, ए जेड के माध्यम से।

विवरण:

• आप मान सकते हैं कि एकमात्र इनपुट जेड के माध्यम से एक एकल पत्र, ए होगा।
• यदि आप इनपुट और / या आउटपुट के लिए लोअरकेस एज़ का उपयोग कर सकते हैं, तो आप निम्न और अपरकेस को भी मिला सकते हैं।
• वर्णानुक्रम क्रम को दक्षिणावर्त चक्रित करना चाहिए, न कि दक्षिणावर्त।
• सूप के कटोरे को इंडेंट करने और भरने के लिए आपको रिक्त स्थान का उपयोग करना चाहिए, न कि कुछ और।
• जब तक सूप के कटोरे को ठीक से व्यवस्थित नहीं किया जाता है तब तक आउटपुट में न्यूलाइन्स या रिक्त स्थान का नेतृत्व या अनुगामी हो सकता है।
• ध्यान दें कि कटोरे का आकार 7 अक्षरों से 12 गुणा चौड़ा है, ताकि यह पाठ के रूप में लगभग गोलाकार दिखाई दे। आपके कटोरे समान आकार के होने चाहिए।

यह कोड गोल्फ है इसलिए सबसे छोटा कोड जीतता है!

Comments

बड़ी चुनौती! यह शुरू में आसान लगता है, लेकिन यह नहीं है

— लुइस Mendo

Answer 1

05AB1E , 21 बाइट्स

एक प्रोग्राम को परिभाषित करता है$f : \color{purple}{\texttt{AlphabeticChar}} \rightarrow \color{purple}{\texttt{String}}$

कोड:

2AA¹k._•1못*Ć,ãiDΣ•Λ

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

टूट - फूट:

2AA¹k._•1못*Ć,ãiDΣ•Λ

2                       # <length>
 AA¹k._                 # <filler>
       •1못*Ć,ãiDΣ•    # <pattern>
                    Λ   # Invoke the canvas function.

स्पष्टीकरण:

कैनवास ( Λ) इस विशेष संदर्भ में निम्नलिखित हस्ताक्षर के साथ एक समारोह के रूप में काम करता है:

$$\mathsf{\Lambda} : \left(\texttt{length}: \color{purple}{\texttt{Nat}},\ \texttt{filler}: \color{purple}{\texttt{String}},\ \texttt{pattern}: \color{purple}{\texttt{Nat}}\right) \rightarrow \color{purple}{\texttt{String}}$$

पैरामीटर इस स्थिति में एक नंबर दिशाओं को परिभाषित है। कोड में, इस संख्या को इस रूप में दर्शाया गया है , जो कि बड़ी संख्या का एक संपीड़ित संस्करण है । निम्नलिखित तरीके से दिशाओं को दर्शाया गया है:$\texttt{pattern}$ 2232344565666667670012122•1못*Ć,ãiDΣ•$2232344565666667670012122$

$$\begin{array}{l} 7 & & 0 & & 1 \\ & \nwarrow & \uparrow & \nearrow & \\ 6 & \leftarrow & \bullet & \rightarrow & 2 \\ & \swarrow & \downarrow & \searrow & \\ 5 & & 4 & & 3 \end{array}$$

इसका अर्थ है कि बड़ी संख्या निर्देशों के निम्नलिखित पैटर्न का प्रतिनिधित्व करती है:

$$[\rightarrow, \rightarrow, \searrow, \rightarrow, \searrow, \downarrow, \downarrow, \swarrow, \leftarrow, \swarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \leftarrow, \nwarrow, \leftarrow, \nwarrow, \uparrow, \uparrow, \nearrow, \rightarrow, \nearrow, \rightarrow, \rightarrow]$$

इस हस्ताक्षर के संदर्भ में, कैनवास सूची के माध्यम से पुनरावृत्त करता है और वर्तमान दिशा में से वर्ण लिखता है ।$\texttt{pattern}$$\texttt{length}$$\texttt{filler}$

के रूप में कोड में निर्दिष्ट किया जाता है (कोड की शुरुआत में)। के लिए , हम वर्णमाला ऐसी है कि वह दिए गए इनपुट के साथ शुरू होता की एक घुमाया संस्करण की आवश्यकता है। यह निम्नलिखित कोड के साथ किया जाता है ( इसे यहां देखें ):$\texttt{length}$$2$$\texttt{filler}$

AA¹k._
वर्णमाला में दिए गए इनपुट चरित्र का 
 inputk # <सूचकांक> ढूंढें
A ._ # वर्णमाला को बाईं ओर <<> बार घुमाएं ।

स्यूडोकोड में, यह कैनवास फ़ंक्शन द्वारा निष्पादित किया जाएगा:

$\begin{array}{l} 1. & \text{Write } \color{blue}{\texttt{ab}} \text{ in the direction} \rightarrow \\ 2. & \text{Write } \color{blue}{\texttt{bc}} \text{ in the direction} \rightarrow \\ 3. & \text{Write } \color{blue}{\texttt{cd}} \text{ in the direction} \searrow \\ 4. & \text{Write } \color{blue}{\texttt{de}} \text{ in the direction} \rightarrow \\ 5. & \text{Write } \color{blue}{\texttt{ef}} \text{ in the direction} \searrow \\ 6. & \text{Write } \color{blue}{\texttt{fg}} \text{ in the direction} \downarrow \\ \dots \end{array}$

अंत में, आप देख सकते हैं कि भराव तर्क 'घुमाया हुआ' बार दाईं ओर, जिसका अर्थ है कि कैनवास निम्न (चक्रीय और इसलिए अनंत) सूची के माध्यम से पुनरावृति करेगा:$\texttt{length} - 1$

$$[\color{blue}{\texttt{ab}}, \color{blue}{\texttt{bc}}, \color{blue}{\texttt{cd}}, \color{blue}{\texttt{de}}, \color{blue}{\texttt{ef}}, \color{blue}{\texttt{fg}}, \color{blue}{\texttt{gh}}, \color{blue}{\texttt{hi}}, \color{blue}{\texttt{ij}}, \color{blue}{\texttt{jk}}, ...$$

जिसके परिणामस्वरूप वांछित वर्णमाला सूप एससीआई-कला आकार होता है।

Comments

ठीक है मैं हार मानता हूँ। छोटे विकल्पों को खोजने की कोशिश की, लेकिन मैं इसे नहीं देख रहा हूं। AA¹k._वैकल्पिक रूप से हो सकता है A¹¡RJ«, लेकिन यह एक ही बाइट-काउंट है। •1못*Ć,ãiDΣ•वैकल्पिक रूप से हो सकता है •õÕ₆qηµñ–†f•·, लेकिन यह एक ही बाइट-काउंट है। ठीक है। अच्छा जवाब!

— केविन क्रूज़सेन

Answer 2

पर्ल 6 , 100 बाइट्स

{"2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK".trans(/\S/=>{(try ' 'x$/+1)||chr ($/.ord+.ord)%26+65})}

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

स्ट्रिंग के सभी अक्षरों को उनके स्थानांतरित किए गए समकक्षों के साथ प्रतिस्थापित करते हुए, अंकों को उन रिक्त स्थान की संख्या के साथ प्रतिस्थापित करते हैं जो वे प्लस वन का प्रतिनिधित्व करते हैं।

व्याख्या

{                                                            }# Anonymous code block
 "...".trans(/\S/=>{                                       }) # Translate non-whitespace
                    (try ' 'x$/+1)      # If digits, the amount of spaces plus one
                                  ||chr ($/.ord+.ord)%26+64  # Else the shifted letter

Answer 3

रूबी , 107 बाइट्स

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=(1i**((i.ord-n.ord-6)/6.5)).rect;a[3.5*k+=1][5.2*j+6]=i}
a*$/}

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

बेहतर सिंटैक्स "i".to_c-> 1i(जॉर्डन द्वारा सुझाया गया)

समन्वित प्रणाली को बदल दिया गया है इसलिए शीर्ष के बजाय 0 डिग्री सही है। यह सक्षम करता है 0.5->6

की कमी के लिए jऔर कई गुणा समायोजितk

प्रिंट आउटपुट के बजाय puts a, एरेनेट एलीमेंट को सम्‍मिलित करें और एक स्ट्रिंग लौटाएंa*$/

रूबी , 119 बाइट्स

->n{a=(0..6).map{' '*11}
(?A..?Z).map{|i|j,k=("i".to_c**((i.ord-n.ord+0.5)/6.5)).rect;a[3.5-j*3.3][6+k*5.17]=i}
puts a}

एक दीर्घवृत्त को मैप करने की शक्ति के लिए उठाए गए एक जटिल संख्या का उपयोग करता है। एक पूर्ण मोड़ 26 है, इसलिए प्रत्येक चतुर्थांश 6.5 है।

यह दृष्टिकोण एक दीर्घवृत्त के सदृश आवश्यक आउटपुट पर निर्भर करता है ताकि एक वैध मानचित्रण प्राप्त किया जा सके।

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

Comments

@ जोर्डन धन्यवाद, मैंने पहले उस वाक्य रचना को नहीं देखा है!

— लेवल रिवर सेंट

Answer 4

चारकोल , 33 बाइट्स

ＧＨ→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→²✂⁺αα⌕αＳ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

ＧＨ

एक रास्ता ट्रेस करें।

→→↘→↘↓↓77←←←←↖←↖↑↑↗→↗→→

कटोरे को रेखांकित करें। प्रत्येक को 7फैलता है ↙←।

²

एक बार में एक वर्ण को स्थानांतरित करें (यह एपीआई प्रत्येक पंक्ति के छोर को अगले के साथ ओवरलैप करता है)।

✂⁺αα⌕αＳ

दोगुनी वर्णमाला का उपयोग करके ड्रा करें, लेकिन इनपुट चरित्र की स्थिति पर शुरू करें।

Answer 5

MATL , 49 बाइट्स

7I8*32tvB[1b]&Zvc2Y2j7+_YSy&f7-w4-_Z;YPE\,&S])yg(

क्या झंझट है। लेकिन यह लिखने में मजेदार था। वहाँ भी एक अभिजात वर्ग शामिल है।

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

व्याख्या

कोड

7I8*32tvB

संख्याओं की एक सरणी बनाता है और उन्हें बाइनरी में परिवर्तित करता है। यह शून्य-एक मैट्रिक्स देता है

0 0 0 1 1 1
0 1 1 0 0 0
1 0 0 0 0 0
1 0 0 0 0 0

अक्षरों के पदों को निर्दिष्ट करने वाले मैट्रिक्स के शीर्ष बाएँ चतुर्थांश है।

[1b]&Zv

अंतिम पंक्ति को दोहराए बिना उस चतुर्थांश को लंबवत रूप से दर्शाता है, और पूर्ण मैट्रिक्स का उत्पादन करने के लिए अंतिम कॉलम को क्षैतिज रूप से दोहराता है:

0 0 0 1 1 1 1 1 1 0 0 0
0 1 1 0 0 0 0 0 0 1 1 0
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 0 0 0 1
0 1 1 0 0 0 0 0 0 1 1 0
0 0 0 1 1 1 1 1 1 0 0 0

अब हमारे पास पदों के साथ एक मुखौटा है। कोड

c

इसे चार में परिवर्तित करता है, क्योंकि अंतिम परिणाम एक चार मैट्रिक्स होगा। चरित्र 0 को अंतरिक्ष के रूप में प्रदर्शित किया जाता है, और गैर-प्रविष्टि प्रविष्टियां उपयुक्त अक्षरों के साथ लिखी जाएंगी।

2Y2

स्ट्रिंग को धकेलता है 'abc···xyz', जिसमें 26 अक्षर होते हैं। इस स्ट्रिंग को इनपुट के अनुसार परिपत्र रूप से स्थानांतरित करने की आवश्यकता है। ऐसा करने के लिए,

j7+_YS

इनपुट पत्र पढ़ता है, अपने ASCII कोड में 7 जोड़ता है, और परिणाम को नकारता है। इनपुट के लिए 'a'यह ,104 देता है, जो कि 26 का एक गुणक है, इसलिए इस राशि द्वारा परिपत्र रूप से स्थानांतरण कुछ भी नहीं करेगा। यदि इनपुट है, तो bयह −105 देता है, जो उत्पादन करने के लिए बाईं ओर स्ट्रिंग 1 चरण को स्थानांतरित करता है 'bcd···yza'; आदि।

अगला चरण उस क्रम को परिभाषित करना है जिसमें स्थानांतरित स्ट्रिंग को मैट्रिक्स की नॉनजेरो प्रविष्टियों में लिखा जाएगा। इस कोने तक,

y&f

मैट्रिक्स की एक प्रति बनाता है और गैर-अक्ष की 1-आधारित पंक्ति और स्तंभ स्थिति वाले दो वैक्टर को धक्का देता है। फिर

7-w4-_

उत्तरार्द्ध से 7 घटाता है, पूर्व को शीर्ष पर लाता है, इसमें से 4 को हटाता है और इसे नकारता है। 7 और 4 निर्देशांक की एक उत्पत्ति निर्दिष्ट करते हैं, ताकि उस मूल के संबंध में नॉनज़रो प्रविष्टियों की स्थिति वैक्टर के कोण वांछित क्रम को परिभाषित करें।

Z;YPE\

उन कोणों का निर्माण करने के लिए दो-तर्क आर्कटेंट मोडुलो 2 * पीआई की गणना करता है। अब सबसे छोटा कोण, जो 0 है, उस प्रविष्टि से मेल खाता है जहां पहला अक्षर जाना चाहिए, और बाकी अग्रिम प्रति-घड़ी।

,&S])

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

yg(

उदाहरण के लिए, यदि इनपुट है 'a'तो स्ट्रिंग को परिपत्र रूप से स्थानांतरित नहीं किया गया था:

abcdefghijklmnopqrstuvwxyz

कोणों के अनुसार पुनर्रचना इसे में बदल देती है

utsvrwqxpyoznamblckdjeifgh

ताकि 'u'सही ढंग से पहले (स्तंभ-प्रमुख क्रम में) नॉनज़ेरो प्रविष्टि पर जाए, जो कि मैट्रिक्स नोटेशन में (3,1) है; 't'(४,१) पर जाएगा, 's'(५,१); 'v'(2,2) आदि:

   ······   
 v·      ·· 
u          ·
t          ·
s          ·
 ··      ·· 
   ······   

Comments

@EriktheOutgolfer अंत में मुझे स्पष्टीकरण देने के लिए कुछ समय मिला

— लुइस मेंडो

वाह ... मैंने वास्तव में सोचा था कि आपने इसे छोड़ दिया क्योंकि आपने उस टिप्पणी को हटा दिया था। : पी

— एरिक आउटगोल्फर

Answer 6

पायथन 2 , 129 बाइट्स

lambda x:''.join((i,chr((ord(x)+ord(i))%26+65),' '*5)[ord(i)/46]for i in'''   XYZABC
 VW] DE
U]]F
T]]G
S]]H
 RQ] JI
   PONMLK''')

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

Answer 7

आर , 139 122 बाइट्स

-17 बाइट्स ग्यूसेप के लिए धन्यवाद

u=utf8ToInt;`*`=rep;o=c(' '*12,'
')*7;o[u("  &3@LKWVUTSRDC5(")]=LETTERS[(13:38+u(scan(,'')))%%26+1];cat(o,sep='')

स्पष्टीकरण:

o=rep(c(rep(' ',12),'
'),7) 

रिक्त स्थान का एक खाली बॉक्स बनाता है

u(" &3@LKWVUTSRDC5(")

निम्नलिखित के लिए पत्र पदों के लिए सूचकांकों का एक समूह है:

c(7:9,23,24,38,51,64,76,75,87:82,68,67,53,40,27,15,16,4:6)

TIO

Comments

आप कभी intToUtf8भी उन अतिरिक्त बाइट्स का उपयोग नहीं करते हैं, लेकिन यदि आप *इसके स्थान पर उपयोग करते हैं rep, तो आप 2 बाइट्स बचा सकते हैं और 125 बाइट्स

— Giuseppe

ओह, और मुद्रण योग्य एससीआई के बजाय कम-बाइट वर्णों का उपयोग करके आप 122 बाइट्स के-32 लिए दाढ़ी कर सकते हैं । आप उन्हें उपयोग करके स्वयं उत्पन्न कर सकते हैं । cat(intToUtf8(bytes))

— ग्यूसेप

@Giuseppe मुझे पूरा यकीन था कि मैंने पहले ही हटा दिया था intToUtf8, एक बार मुझे लगता है कि फ़ंक्शन के कई संस्करण खुले हैं। नीस ने सभी गोल बचाया, धन्यवाद

— आरोन हेमैन

Answer 8

जावास्क्रिप्ट (Node.js) ,  121  119 बाइट्स

@ बाइट के लिए धन्यवाद 2 बाइट्स सहेजे गए

c=>`2XYZABC
0VW5DE
U9F
T9G
S9H
0RQ5JI
2PONMLK`.replace(/./g,x=>''.padEnd(+x+1)||(B=Buffer)([65+([a,b]=B(c+x),a+b)%26]))

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

कैसे?

Buffer$x$$c$

$c=$"H"$x=$"B"

// extracting the ASCII codes
Buffer(c + x) → Buffer("HB") → <Buffer 48 42>

// assigning them to variables
[a, b] = Buffer(c + x) → a = 0x48 (72) and b = 0x42 (66)

// computing the ASCII code of the target letter
65 + ((a + b) % 26) → 65 + (138 % 26) → 65 + 8 → 73

// turning it back into a character
Buffer([73]) → <Buffer 49> → implicitly coerced to "I" by replace()

Comments

119 बाइट्स

— 5

Answer 9

एपीएल + विन, 72 बाइट्स

चरित्र के लिए संकेत

m←7 12⍴' '⋄n←(7⍴2)⊤v,⌽v←(⍳3)/28 34 65⋄((,n)/,m)←(22+s⍳⎕)⌽s←⎕av[65+⍳26]⋄m

यह ऑनलाइन की कोशिश करो! Dyalog क्लासिक के Coutesy

Answer 10

आर , 218 197 बाइट्स

-21 बाइट्स ग्यूसेप के लिए धन्यवाद

function(t,l=letters,`*`=rep,s=" ",n="
",`~`=`[`,r=c(l~l>=t,l))cat(s*3,r~24:26,r~1:3,n,s,r~22:23,q<-s*6,r~4:5,n,r~21,u<-s*10,r~6,n,r~20,u,r~7,n,r~19,u,r~8,n,s,r~17:18,q,r~10:9,n,s*3,r~16:11,sep='')

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

Ungolfed:

alphasoup <- function(startlet){
  startnum <- which(l == startlet)
  rotatedletters <- c(letters[startnum:26], letters[1:(startnum -1)])[1:26]
  cat('   ',rotatedletters[24:26],rotatedletters[1:3], '\n ', 
      rotatedletters[22:23], s6 <- '      ', rotatedletters[4:5], '\n',
      rotatedletters[21], s10 <- rep(' ', 10), rotatedletters[6], '\n',
      rotatedletters[20], s10, rotatedletters[7], '\n',
      rotatedletters[19], s10, rotatedletters[8], '\n ',
      rotatedletters[17:18], s6, rotatedletters[10:9], '\n   ',
      rotatedletters[16:11],
      sep = '')
}

घुमाया गया पत्र वेक्टर और catउस वेक्टर के साथ कटोरे के रिम को भरने के लिए उपयोग करता है।

Comments

203 बाइट्स यदि आप एक-पंक्ति वाली राक्षसीताओं का बुरा नहीं मानते हैं; सबसे बड़ा सुधार संभवतः सूचकांक को सीधे हटाने whichऔर उपयोग करने l>=tके लिए था, जिसकी कीमत 12 बाइट्स थी।

— ग्यूसेप

के[ साथ अलियासिंग द्वारा 198 बाइट्स~ । यह एक महान जवाब है; मैं अपने पहले कुछ प्रयासों में बहुत अधिक जटिल दृष्टिकोण के साथ लगभग 250 बाइट्स खर्च कर रहा था।

— ग्यूसेप

आह, यह चतुर है, मैं स्ट्रिंग तुलना के बारे में भूल जाता हूं।

— सीटी हॉल

Answer 11

जावा 11, 134 बाइट्स

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.print(i<59?" ".repeat(i-47):(char)(i>90?10:(c+i)%26+65)))

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

136 बाइट्स संस्करण गोल्फ होने की संभावना के साथ?

c->"2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK".chars().forEach(i->System.out.printf("%"+(i<59?i-47:"")+"c",i>90?10:i<59?32:(c+i)%26+65))

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

स्पष्टीकरण (पहले उत्तर का)

c->                          // Method with character parameter and no return-type
  "2XYZABC_0VW5DE_U9F_T9G_S9H_0RQ5JI_2PONMLK"
                             //  Template-String
    .chars().forEach(i->     //  Loop over the unicode values of its characters:
    System.out.print(        //   Print:
     i<59?                   //    If the value is below 59 (so a digit character):
      " ".repeat(i-47)       //     Repeat a space that digit + 1 amount of times
     :(char)(i>90?           //    Else-if the value is above 90 (an underscore character):
              10             //     Print a newline
             :               //    Else:
              (c+i)          //     Add the current value and the input together
                   %26       //     Take modulo-26 of it to get the index in the alphabet
                      +65))) //     And add 65 to make it an uppercase letter

Comments

क्यों न अंकों को अनप्रिंट्स से बदला जाए? इस तरह, आप बस छोड़ सकता हैi-47

— अज्ञान की अवतार

@EododimentofIgnorance मुझे डर है कि यह किसी भी बाइट को नहीं बचाएगा। रिक्त स्थान की संख्या 3, 1, 6 और 10 है। 10 का उपयोग तीन बार किया जाता है और प्रत्येक के रूप में 2 बाइट्स वर्ण ( \n) के होते हैं। तो क्या मैं unprintables और 3x का उपयोग \nके साथ iया अंक-1 के साथ i-47, दोनों एक ही 134 बाइट गिनती कर रहे हैं। और दुर्भाग्य से मेरे पास एक 0अप्राप्य नहीं हो सकता है, अन्यथा मैं इसके बजाय 2,0,5,9 का उपयोग कर सकता था, और i+1कुल मिलाकर 1 बाइट बचाने के लिए उपयोग कर सकता था।

— केविन क्रूज़सेन

Answer 12

वोल्फ्राम भाषा (गणितज्ञ) , 258 बाइट्स

(t[x_]:=Table[" ",x];w=RotateRight[Alphabet[],4-LetterNumber@#];j=Join;a[x_,y_]:=j[{w[[x]]},t@10,{w[[y]]}];b[m_,n_]:=j[t@1,w[[m;;m+1]],t@6,w[[n;;n+1]],t@1];""<>#&/@{j[t@3,w[[1;;6]]],b[25,7],a[24,9],a[23,10],a[22,11],Reverse@b[12,20],j[t@3,w[[19;;14;;-1]]]})&

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

Answer 13

हास्केल, 127 बाइट्स

("cXYZABC aVWfDE UjF TjG SjH aRQfJI cPONMLK">>=).(?)
t?c|c>'Z'=' '<$['a'..c]|c<'!'="\n"|t<'B'=[c]|c>'Y'=t?'@'|1<2=pred t?succ c

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

एन्कोडेड स्ट्रिंग में प्रत्येक वर्ण स्ट्रिंग द्वारा फ़ंक्शन द्वारा डिकोड किया ?गया है:

t?c                             -- 't' is the starting char,
                                -- 'c' the char from the encoded string
   |c>'Z'=' '<$['a'..c]         -- if 'c' is a lowercase letter, return some spaces
                                -- 'a': one, 'b': two, etc
   |c<'!'="\n"                  -- if 'c' is a space, return a newline
   |t<'B'=[c]                   -- if 't' is the letter A, return 'c'
   |c>'Y'=t?'@'                 -- wrap around Z
   |1<2=pred t?succ c           -- else the result is the same as starting one letter
                                -- earlier (pred t) but looking at the successor of 'c'

Answer 14

कोटलिन , 148 146 145 बाइट्स

-2 के लिए अतिरिक्त
कच्चे स्ट्रिंग के लिए अतिरिक्त कोष्ठक निकाले

{l:Char->"2XYZABC 0VW5DE U9F T9G S9H 0RQ5JI 2PONMLK".map{c->if(c>'@')((c-'A'+(l-'A'))%26+65).toChar()
else if(c>' ')" ".repeat(c-'/')
else '\n'}}

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

Answer 15

C # (विजुअल C # इंटरएक्टिव कंपाइलर) , 126 118 बाइट्स

n=>$@"   XYZABC
 VW{"",6}DE
U {"",9}F
T {"",9}G
S {"",9}H
 RQ{"",6}JI
   PONMLK".Select(b=>b<65?b:(char)((b+n)%26+65))

@ ब्यूटोन के लिए धन्यवाद 8 बाइट्स बचाए। हां, यह वास्तव में उनका उपयोगकर्ता नाम है।

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

Comments

118 बाइट्स के लिए स्ट्रिंग प्रक्षेप । यह संभव है कि चारकोल की एक सरणी लौटा दी जाए (~ 8 बाइट्स बचाकर), लेकिन मुझे यकीन नहीं है।

— कोई

@someone नाइस, स्ट्रिंग इंटरपोलेशन के बारे में भूल गया

— इग्नोरेंस

Answer 16

TSQL क्वेरी, 238 बाइट्स

DECLARE @y char='G'

,@ char(91)=3;WITH C as(SELECT'5585877636333330301125255'z,8a,ascii(@y)x
UNION ALL
SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65FROM
C WHERE''<z)SELECT
@=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))FROM
C PRINT @

इस उत्तर के लिए परीक्षण लिंक ने रेखाओं को तोड़ दिया और रिक्त स्थान को बाहर कर दिया। मैंने समय के साथ रिक्त स्थान बदल दिया है और पढ़ने योग्य परिणाम दिखाने के लिए चार (13) को चार (13) + चार (10) के साथ बदल दिया है।

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

Ungolfed:

DECLARE @y char='G'

-- @ is the string being printed last. 
-- @ is populated with 3 to save a byte
-- the number 3 gets replaced later
-- (this could have been any 1 digit value), 
-- @ is automatically filled with spaces, because
-- it is declared as a char(x) and assigned a value
,@ char(91)=3;
-- recursive query
WITH C as
(
-- z string containing digits for the direction of next letter
-- z should not contain 4 because it will point to same position.
-- values in z 0,1,2,3,4,5,6,7,8 can logally convert to 
-- (-1,-1),(-1,0),(-1,1),(0,-1),(0,0),(0,1),(1,-1),(1,0),(1,1)
-- a is the starting position
  SELECT'5585877636333330301125255'z,8a,ascii(@y)x
  UNION ALL
-- stuff remove first character from the z string
-- a calculate next position of the next letter
-- x cycle the input letter
  SELECT stuff(z,1,1,''),a+left(z,1)/3*13+left(z,1)%3-14,(x+14)%26+65
-- repeat recursive until long string is empty
  FROM C
  WHERE''<z
)
SELECT
-- 1st stuff replace the character to created the start of a 
--   logical line in the string @ this is where 3 gets overwritten
-- 2nd stuff replaces a character(space if coded correct) 
--  with the letter at the calculated position.
  @=stuff(stuff(@,a,1,char(x)),1+a/13*13,1,char(13))
FROM C

PRINT @

Comments

@ मिक्की ठीक है, आपकी प्रतिक्रिया के लिए धन्यवाद, मैं इसे बाद में आज ठीक करूंगा अगर मुझे db

— t-clausen.dk

@ मिक्की यह अब तय किया जाना चाहिए

— t-clausen.dk

अब अच्छा लग रहा है।

— मिकट

Answer 17

PHP , 236 229 226 बाइट्स

<?=($a=ord(file_get_contents('php://stdin'))-65)?preg_replace_callback('~\w~',function($m)use($a){return chr((ord($m[0])-65+$a)%26+65);},'   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK'):'';

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

पूर्व गोल्फ:

<?php
$adjust = ord(file_get_contents('php://stdin')) - 65;
echo preg_replace_callback('~\w~', function($match) use ($adjust) {
    $new = ord($match[0]) - 65;
    $new = ($new + $adjust) % 26;
    $new += 65;
    return chr($new);
}, '   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK');

स्पष्टीकरण:

ordहम 0 और 255 के बीच पूर्णांक में कनवर्ट करते हैं । A 65 है और Z 90 है।
इस ज्ञान का उपयोग करते हुए, हम इनपुट लेते हैं और इसे 65 से घटाते हैं, इसलिए हमारे पास एक समायोजन मूल्य है।
हम फिर सभी वर्णों पर पुनरावृत्ति ordकरते हैं, उन पर कॉल करते हैं, उन्हें 65 से कम करते हैं, उन्हें हमारे समायोजन मूल्य से बढ़ाते हैं। मॉडुलो का उपयोग करते हुए हम लूप को वापस 0 पर लाते हैं यदि वे 26 से अधिक हो जाते हैं।
हम फिर उन्हें 65 से बढ़ाते हैं और उन्हें वापस अक्षरों में बदल देते हैं chr।

दुख की बात है कि php: // स्टडिन को केवल एक बार इंटरोगेट किया जा सकता है, इसलिए हमें अपने लूप में फंक्शन में इनपुट पास करना होगा, हमें बाइट्स को बचाने से रोकना होगा use($a)और फंक्शन के बाहर एक वैरिएबल घोषित करने के लिए हमें <?=इको विधि का उपयोग करके सफाई से रोकना होगा - हमें एक विशाल टर्नरी में सब कुछ लपेटना होगा।

Answer 18

सी (जीसीसी) 286 बाइट्स

सबसे छोटा गोल्फ नहीं है, लेकिन यह काम करता है

#define r(a)(a+c)%26+65
#define R(a)for(i=10;i;a[--i]<33?:(a[i]=r(a[i])));
i;f(c){char*S="          ",T[]="   XYZABC\n",E[]="VW      DE\n",F[]="RQ      JI\n",B[]="   PONMLK";R(T)R(E)R(F)R(B)printf("%s %s%c%s%c\n%c%s%c\n%c%s%c\n %s%s",T,E,r(85),S,r(70),r(84),S,r(71),r(83),S,r(72),F,B);}

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

Comments

274 बाइट्स

— छत

Answer 19

लाल , 139 बाइट्स

func[a][foreach c{   XYZABC
 VW      DE
U          F
T          G
S          H
 RQ      JI
   PONMLK}[if c > sp[c: c + a % 26 + 65]prin c]]

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

एक बहुत भोला समाधान।

Answer 20

पर्ल 5 -p , 110 बाइट्स

$b=/A/?Z:chr(-1+ord);$_=eval("'2XYZABC
 VW5DE
U9F
T9G
S9H
 RQ5JI
2PONMLK'=~y/A-Z/$_-ZA-$b/r");s/\d/$".$"x$&/eg

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

Comments

$ b अनावश्यक है। -24 बाइट्स: टीआईओ ।

— ग्रिममी

-2 बाइट्स TIO

— Nahuel Fouilleul

Answer 21

जावास्क्रिप्ट (V8), 316 बाइट्स

function a(b){n="abcdefghijklmnopqrstuvwxyz".split(b);n=b+n[1]+n[0],console.log(`   ${n[23]+n[24]+n[25]+n[0]+n[1]+n[2]}\n ${n[21]+n[22]}      ${n[3]+n[4]}\n${n[20]}          ${n[5]}\n${n[19]}          ${n[6]}\n${n[18]}          ${n[7]}\n ${n[17]+n[16]}      ${n[9]+n[8]}\n   ${n[15]+n[14]+n[13]+n[12]+n[11]+n[10]}`)}

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

पहली बार कोड गोल्फ की कोशिश कर रहा है। किसी भी सुझाव / प्रतिक्रिया की सराहना करें।

न्यूनतम करने से पहले मूल कोड:

function a(b){
    var c = ("abcdefghijklmnopqrstuvwxyz").split(b);
    c = b+c[1]+c[0]
    console.log(`   ${c[23]+c[24]+c[25]+c[0]+c[1]+c[2]}\n ${c[21]+c[22]}      ${c[3]+c[4]}\n${c[20]}          ${c[5]}\n${c[19]}          ${c[6]}\n${c[18]}          ${c[7]}\n ${c[17]+c[16]}      ${c[9]+c[8]}\n   ${c[15]+c[14]+c[13]+c[12]+c[11]+c[10]}`)
}

Comments

नमस्कार और पीपीसीजी में आपका स्वागत है। जैसा कि यह खड़ा है, आपका सबमिशन एक स्निपेट है, जो I / O अमान्य है। कृपया अपने उत्तर को या तो पूर्ण कार्यक्रम या कार्य के रूप में तय करें - जैसा कि आप गैर-लघु संस्करण में करते हैं।

— जोनाथन फ्रेच

@ जोनाथन फ्रेस्च धन्यवाद! क्या यह पर्याप्त होगा?

— एडविन चुआ

हां, अब यह एक वैध सबमिशन है।

— जोनाथन फ्रीच

Answer 22

APL (Dyalog Classic) , 50 बाइट्स

⎕a@((-⎕a⍳⍞)⌽∪⌊.5+{3 5.5×1-2 1○○⍵÷¯19}¨⍳38)⊢7 12⍴''

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

Answer 23

सी (जीसीसी) , 200 198 197 बाइट्स

सीट्स के लिए -3 बाइट्स धन्यवाद।

x,z;f(c){char*y,t[27],i=0;for(c-=46;i<14;t[13+i++]=(c-i)%26+65)t[i]=(c+i)%26+65;for(i=-4;++i<4;printf("%*.*s%*.*s\n",3273>>x*3&7,x?:1,y,z,x?:1,y+2*!i+z))z="--*%"[x=abs(i)]-34,y=t+x+(x>2)+13*(i>0);}

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

Answer 24

PHP , 131 बाइट्स

for(;$s='2YZABCD
 WX5EF
V9G
U9H
T9I
 SR5KJ
2QPONML'[$i++];)echo$s<A?$s<'0'?$s:str_pad('',$s+1,' '):chr(65+(ord($s)+ord($argn))%26);

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