कुछ पाठ हीरा

Question

लंबाई के एक इनपुट स्ट्रिंग को देखते हुए 2या लंबे समय तक केवल वर्णमाला वर्ण [A-Z]या [a-z](आपकी पसंद यदि वे सभी बड़े या सभी लोअरकेस हैं) को देखते हुए, दोहरे हीरे के पैटर्न का निर्माण करने वाले वर्णों की एक निरंतर स्ट्रिंग का उत्पादन करते हैं।

इनपुट स्ट्रिंग केंद्र रेखा पर शुरू होती है और इनपुट स्ट्रिंग के अंत तक एक विकर्ण पर नीचे-और-दाएँ फैली हुई है। फिर, पैटर्न एक विकर्ण पर ऊपर-और-दाएं तब तक जारी रहता है, जब तक आप केंद्र रेखा के ऊपर इनपुट स्ट्रिंग माइनस की लंबाई के रूप में नहीं होते हैं। 1. नीचे-और-दाईं ओर वापस केंद्र रेखा पर जारी रखें, फिर नीचे-और- बाएँ, फिर ऊपर-और-बाएँ (केंद्र चरित्र के पीछे ""), और अंत में नीचे-और-बाएँ वापस प्रारंभिक वर्ण पर।

यह थोड़ा चिंताजनक है, और यह कुछ उदाहरणों से बेहतर प्रदर्शित होता है:

"YOU"
  U   Y
 Y O U O
Y   O   U
 O Y U Y
  U   O

  ^   ^
 ↙ ↖ ↗ ↘
↘   ↗   >
 ↘ ↗ ↖ ↙
  V   V

देखें कि YOUकेंद्र रेखा पर शुरुआत कैसे होती है और डाउन-एंड-राइट, फिर अप-एंड-राइट, आदि का अनुसरण करती है, जब तक कि यह शुरुआत में वापस नहीं आती। विशेष रूप से ध्यान दें Yकि ऊपर और बाएं हिस्से पर कैसे "पीछे" है Oऔर इसलिए नहीं दिखाया गया है।

कुछ और उदाहरण:

"HI"
 I I
H H H
 I I

"TEST"
   E     E
  S T   T S
 T   T T   T
T     S     T
 E   E E   E
  S T   T S
   T     T

"HELLO"
    L       L
   O L     E L
  H   E   H   O
 E     H O     H
H       L       E
 E     L L     L
  L   E   L   L
   L H     E O
    O       H

---

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

Comments

यकीन है कि ऐसा नहीं है कि यह मायने रखता है, वास्तव में, लेकिन क्यों करता है दूसरा (ऊपर छोड़ दिया) पास जाना पीछे पहले (अप दाएं) पारित? कम सहज ज्ञान युक्त बनाता है और उस पत्र को छोड़ने या फिर से आकर्षित करने के लिए थोड़ा परेशान भी करता है।

— ब्रैडेक

@BradC मैं अपनी मेज पर मोबीस स्ट्रिप के साथ खेल रहा था, जब मैं चुनौती के साथ आया था, और स्ट्रिप थोरा "पीछे" चला गया, इसलिए। कोई और कारण नहीं।

— AdmBorkBork

तीर वर्णों का उपयोग करके पथ का "ड्राइंग" शामिल करने का एक विचार हो सकता है, जिससे हमें इसकी कल्पना करने में मदद मिल सके।

— झबरा

@ झबरा एक ड्राइंग जोड़ा गया।

— AdmBorkBork

एक अच्छा है, यह एक और अधिक चुनौतीपूर्ण है तो पहली नज़र ..

— booshlinux

Answer 1

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

ＧＨ<↗↘>↖↙ＬθθＧＨ<Ｌθθ

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

ＧＨ

एक रास्ते के साथ ड्रा।

<↗↘>↖↙

दिशाओं में ड्रा करें in ( <और >उन दो जोड़े के लिए शॉर्टहैंड हैं, लेकिन अन्य जोड़े शॉर्टहैंड नहीं हैं।)

Ｌθ

प्रत्येक पथ खंड की लंबाई समान होती है, जिसमें इनपुट की लंबाई भी होती है।

θ

पथ के साथ लिखे जाने वाले पाठ के रूप में इनपुट का उपयोग करें।

ＧＨ<Ｌθθ

पथ के पहले दो हिस्सों को फिर से प्रिंट करें ताकि मध्य चरित्र सही हो।

Comments

यह चुनौती चारकोल के लिए बनाया गया दर्जी लगता है

— योना

@ जोना दुख की बात है कि पाठ पथ कमांड अंतिम चरित्र को आकर्षित नहीं करता है यदि पथ बंद है, तो आप यहां रिवर्स ड्राइंग ट्रिक का उपयोग नहीं कर सकते। (हालांकि अगर यह किया जाता है, तो यह वैसे भी एक ही बाइट की गिनती होगी, क्योंकि स्ट्रिंग को 6 बाइट को घुमाने के लिए।)

— नील

Answer 2

05AB1E , 12 बाइट्स

gIR7._•Íη•Λ

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

           Λ    use the canvas function
g               with the length of input for each segment
 IR7._          the input reversed and rotated left by 7 characters (we will draw this backwards to have the right center character)
      •Íη•     and the directions 1, 3, 3, 1, 7, 5, 5, 7 as a compressed number. 

Comments

क्या आपका मतलब था 1, 3, 3, 1, 7, 5, 5, 7?

— नील

ओह, तुम सही हो। मैंने संख्याओं को थोड़ा मिलाया

— डोरियन

Answer 3

जावास्क्रिप्ट (ईएस 6),  157 155  154 बाइट्स

वर्णों का एक मैट्रिक्स लौटाता है।

s=>(y=n=s.length,y+=i=X=Y=-1,m=[...Array(y+n)].map(_=>r=Array(4*n-3).fill` `),g=x=>x?g(x-=r[m[y][++i==6*n-6||+x]=s[i%n],y-=m[y-Y]?Y:Y=-Y,x-X]?X:X=-X):m)``

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

कैसे?

इनपुट स्ट्रिंग की लंबाई को देखते हुए , हम आकार के एक मैट्रिक्स का निर्माण के साथ करते हैं:$n$$w\times h$

• $w = 4n-3$
• $h = 2n-1$

हम इस मैट्रिक्स में उछलते हुए एक 'बॉल' का अनुकरण चलाते हैं, से शुरू होकर दक्षिण-पूर्व की ओर बढ़ते हुए, जब तक कि यह अपनी प्रारंभिक स्थिति में नहीं आ जाता।$(0,n-1)$

केंद्र वर्ण का 0-आधारित सूचकांक जिसे हीरे के आकार में छोड़ दिया जाना चाहिए:

$$p=6n-6$$

लिए उदाहरण :$n=4$

टिप्पणी की गई

s => (                           // s = input string
  y = n = s.length,              // n = length of s
  y += i = X = Y = -1,           // y = n - 1; i = X = Y = -1
  m =                            // create a matrix m[]:
    [...Array(y + n)].map(_ =>   //   - of height 2n-1
      r = Array(4 * n - 3)       //   - of width 4n-3 (save one of these rows in r[])
          .fill` `               //   - initially filled with spaces
    ),                           //
    g = x =>                     // g is a recursive function taking x
      x ?                        //   if x is truthy:
        g(                       //     do a recursive call:
          x -= r[                //       update x:
            m[y][                //         update m[y][x]:
              ++i == 6 * n - 6   //           unless this is the 2nd pass through the
              || +x              //           center cell, set it to the next character
            ] = s[i % n],        //           in s (otherwise we write to m[y][true]
                                 //           instead, which has no effect)
            y -=                 //         update y:
              m[y - Y] ? Y       //           bounce vertically if m[y - Y] is undefined
                       : Y = -Y, //
            x - X                //         bounce horizontally
          ] ? X                  //         if r[x - X] is undefined
            : X = -X             //
        )                        //     end of recursive call
      :                          //   else:
        m                        //     stop recursion and return m[]
)``                              // initial call to g with x = [''] (zero-ish but truthy)

Comments

मेरे पास एक 136 बाइट समाधान है जो आपके समाधान से प्रेरित है, हालांकि मुझे लगता है कि अब तक यह एक अलग उत्तर के रूप में अर्हता प्राप्त करने के लिए पर्याप्त भिन्न हो सकता है।

— नील

@ नील आपको शायद इसे एक नए उत्तर के रूप में पोस्ट करना चाहिए।

— अरनुलद

Answer 4

जावास्क्रिप्ट (ईएस 6), 136 बाइट्स

f=
(s,l=s.length-1,z=l*4,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `),g=x=>x--?g(x,a[a[y=(x+l)%z]?y:z-y][x>z?z+z-x:x]=s[x%-~l]):a)=>g(z+z)

<input oninput=o.textContent=f(this.value).map(c=&gt;c.join``).join`\n`><pre id=o>

एक दो आयामी सरणी देता है। स्ट्रिंग को एरे में ड्राइंग करके काम करता है जो गंतव्य को सीधे-सीधे समन्वयित करता है और अंत से पीछे की ओर काम करता है ताकि सेंटर सेल स्वचालित रूप से ओवरराइट हो जाए। स्पष्टीकरण:

(s

इनपुट स्ट्रिंग।

,l=s.length-1

"बाउंस" के बीच की दूरी, अंतिम पंक्ति सूचकांक का आधा भी और लंबाई से एक कम।

,z=l*4

अंतिम कॉलम इंडेक्स, ड्रा करने के लिए टेक्स्ट की लंबाई का भी आधा।

,a=[...Array(l-~l)].map(_=>Array(z+1).fill` `)

रिक्त स्थान की सरणी।

,g=x=>x--

अंतिम सेल से पहली तक की गणना करें।

  ?g(x

शेष कोशिकाओं को संसाधित करने के लिए पुनरावर्ती कॉल।

    ,a[a[y=(x+l)%z]?y:z-y]

इस सेल की पंक्ति की गणना करें।

      [x>z?z+z-x:x]=s[x%-~l])

इस सेल के कॉलम और वहां मौजूद चरित्र की गणना करें।

  :a

सरणी वापस करके समाप्त करें।

)=>g(z+z)

पाठ के अंत में प्रारंभ करें।

Comments

यह एक अच्छा है, +1

— वेर निक कहते हैं

Answer 5

जे , ^{79 77} 75 बाइट्स

(|.@$~8*])`([:;/(1,~<:@])+/\@,(_2{&1 _1\#:33495)}.@#~])`(' '$~1+2 4*])}<:@#

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

Answer 6

सी (क्लैंग) , 201 196 188 बाइट्स

x,y,i,v,m,n;f(s,z){char*a=s,o[i=(y=z*2-1)*(x=y+y)];for(v=x*2-2;i;n=m=1)o[--i]=i%x?32:10;for(i=x*--z;v--;i+=x*m+n)o[i]==32?o[i]=*a:0,a=*++a?a:s,n=i%x>x-3?-1:n,m=i/x?i/x<y-1?m:-1:1;puts(o);}

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

-13 @ceilingcat सुझाव

Answer 7

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

s=input();n=len(s);m=2*n-2
for r in range(m+1):print''.join([s[[x,-8-x][(x<=m)==(m>2*r)]%n],' '][r!=(x+1-n)%m!=m-r]for x in range(4*n-3))

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

एक पूर्ण प्रोग्राम जो इनपुट के रूप में एक स्ट्रिंग लेता है, हीरे के संस्करण को प्रिंट करता है।