अष्टभुजाकार शब्द बनाना

Question

पिछले गुरुवार के उपयोगकर्ता @SpookyGengar ने स्क्वॉयड शब्द बनाने के बारे में अपनी पहली चुनौती के साथ हमें खुशी दी । क्या होगा यदि हम पक्षों की संख्या को दोगुना कर दें?

चुनौती

किसी भी उचित प्रारूप में इनपुट के रूप में एक स्ट्रिंग लें जो आपको चाहिए ( string, charसरणी ...) और इनपुट का एक ऑक्टोगोनल प्रतिनिधित्व (किसी भी उचित प्रारूप में भी: s, मैट्रिक्स stringकी सूची ...) अगले उदाहरणों में:stringchar

Input: golf
Output:

   golf
  o    l
 l      o
f        g
l        o
o        l
g        f
 o      l
  l    o
   flog


Input: HelloWorld
Output:

         HelloWorld
        e          l
       l            r
      l              o
     o                W
    W                  o
   o                    l
  r                      l
 l                        e
d                          H
l                          e
r                          l
o                          l
W                          o
o                          W
l                          o
l                          r
e                          l
H                          d
 e                        l
  l                      r
   l                    o
    o                  W
     W                o
      o              l
       r            l
        l          e
         dlroWolleH


Input: a
Output:

a


Input: ab
Output:

 ab
b  a
a  b
 ba


Input: code golf
Output:

        code golf
       o         l
      d           o
     e             g

   g                 e
  o                   d
 l                     o
f                       c
l                       o
o                       d
g                       e

e                       g
d                       o
o                       l
c                       f
 o                     l
  d                   o
   e                 g

     g             e
      o           d
       l         o
        flog edoc

टिप्पणियाँ

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

Comments

"क्या होगा अगर हम पक्षों की संख्या को दोगुना कर दें?" <- फिर चारकोल अभी भी जीत जाएगा

— लीक नून

सुझाए गए टेस्टकेस:code golf

— लीक नून

@LeakyNun को <Space>प्रिंट करने योग्य माना जाता है?

— वी। कोर्टोइस

@ वी.कौरतोयस हाँ

— लीक नून

@LeakyNun ने टेस्ट केस जोड़ा।

— चार्ली

Answer 1

चारकोल , 16 बाइट्स (10 बाइट्स नॉनकमेटिंग)

Ｆ⁸«✂θ⁰±¹↷¹Ａ⮌θθ»θ

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

Ｆ⁸«                 Repeat for each side of the octagon
   ✂θ⁰±    ¹        Print the input except the last character
        ↷¹          Rotate 45° clockwise
          Ａ⮌θθ      Reverse the input string
              »θ    Print the input again, to handle the length 1 case

वैकल्पिक लंबाई 1 फिक्स, 16 बाइट्स भी: वर्बोज़ संस्करण।

ＰθＦ⁸«✂θ⁰±¹↷¹Ａ⮌θθ

एक चारकोल बगफिक्स का मतलब है कि निम्नलिखित 10-बाइट कोड अब काम करता है: वर्बोज़ संस्करण।

Ｆ⁴«θ←↘⮌θ↖⟲

Comments

⟲ऐसा लगता है कि यह बस ऐसा करना चाहिए। लोल

— मैजिक ऑक्टोपस Urn

उम्म, मुझे नहीं लगता कि code golfयह काम करता है?

— निकोल आउटफॉल जूल

ओह, और यह वास्तव में 16 बाइट्स (के θθθसाथ बदलें θθ»θ) है।

— निकोलग्राफ जूल

@EriktheOutgolfer उफ़, इसके बारे में क्षमा करें, मैंने लंबाई 1 मामले के लिए अपने फिक्स का परीक्षण करने के बारे में नहीं सोचा था ... प्रश्न पर मेरा परीक्षण रिकॉर्ड बहुत अच्छा नहीं रहा है?

— नील

@ नील लेकिन इस मुद्दे के बारे में क्या code golf? मुझे लगता है कि चारकोल ने इनपुट कैसे लिया, इसके साथ क्या करना है, दुर्भाग्यवश, इस चुनौती से पूरी तरह से अयोग्य हो जाता है क्योंकि इसे दरकिनार नहीं किया जा सकता है।

— निकोलग्राफ जूल

Answer 2

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

f=
s=>[...Array((l=s.length-1)*3+1)].map((_,i,a)=>a.map((_,j)=>s[i+j-l?l*5-i-j?i+l*2-j?j+l*2-i?i%(l*3)?j%(l*3)?-1:j?i-l:l+l-i:i?l+l-j:j-l:j:l-i:l*3-i:i]||` `))

<input oninput=o.textContent=this.value?f(this.value).map(function(a){return(a.join``)}).join`\n`:``><pre id=o>

एक चरित्र सरणी देता है।

Comments

यह केवल लंबाई के तार के साथ काम करने लगता है 4.

— चार्ली

@CarlosAlejo क्षमा करें, ध्यान से पर्याप्त जाँच नहीं की। आसानी से, 2 बाइट्स को ठीक करें!

— नील

ओह मेरी यह बहुत टेरी है ?:!

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

@EriktheOutgolfer अच्छी बात यह अजगर नहीं है या जो वास्तव में क्रिया होगी: P

— स्टीफन

Answer 3

गणितज्ञ, 247 बाइट्स

(T=Table;k=Length[s=Characters@#];If[k==1,#,Column[Flatten@{#,T[""<>{s[[i]],T["  ",k/2-2+i],s[[-i]]},{i,2,k}],T[""<>{s[[-i]],T["  ",k+k/2-2],s[[i]]},{i,2,k}],T[""<>{s[[i]],T["  ",3k/2-1-i],s[[-i]]},{i,2,k-1}],StringReverse@#},Alignment->Center]])&

Comments

आपको पुनरावृत्ति को कम करने के लिए Alignmentविलंबित ( :=) का उपयोग करके बाइट्स की आवश्यकता नहीं है s[[i]]और s[[-i]], आप इन विचारों के साथ 224 बाइट्स के लिए नीचे आते हैं: (टी = तालिका; q: = s [[i]; r:; = s [[- i]; k = लंबाई [s = अक्षर @ #]; अगर [k == 1, #, कॉलम [फ्लैट @ {#, टी ["> <" {क्यू, टी ["], k / 2-2 + i], r}, {i, 2, k}], T ["" <> {r, T ["", k + k / 2-2], q}, {i 2, k}], T ["" <<> {q, T [", 3k / 2-1-i], r}, {i, 2, k-1}], StringReverse @ #}, केंद्र] ]) और इसके अलावा, मेरे पास एक वैकल्पिक समाधान है जो इस टिप्पणी के समय केवल 145 बाइट्स है।

— मार्क एस।

Answer 4

पायथ , 79 69 65 बाइट्स

j++K+]+*dJtlzzm+++*;-Jd@zd*;+ytdlz@z_hdSJjL*;t*3tlztC_B_zt__MC.tK

टेस्ट सूट ।

Answer 5

जाप , 84 79 बाइट्स

-5 बाइट्स @ETHproductions के लिए धन्यवाद।

Ål
VoA{A?(UÅw +Uê)£Y¥V*2+AªY¥V-A?X:SÃ:Vç +U+Vç
Wf cU¬£V?(V*3 ç hUg~Y)+X:XÃcWz2

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

इसे ऑनलाइन आज़माएं! साथ -Rझंडा नई-पंक्तियों के साथ परिणामी सरणी शामिल होने के लिए।

मेरा सबसे गौरवशाली काम नहीं है, लेकिन मैंने इसे कम से कम ~ 100 बाइट्स से नीचे कर दिया। यहाँ मेरा विचार शीर्ष और मध्य भागों को बनाना था, फिर शीर्ष भाग को जोड़ दिया, 180 ° घुमाया।

Comments

अच्छा लगा। मैं सुधार का एक बहुत अभी नहीं दिख रहा है, लेकिन आप को बदल सकता है Ul Éके लिए UÅl, और स्विच वी और डब्ल्यू 2 अधिक बाइट्स को बचाने के लिए: codepen.io/justinm53/full/...

— ETHproductions

इसके अलावा, AnV ?-> V-A?, और Uq £->U£

— ETHproductions

@ETHproductions बहुत बढ़िया, धन्यवाद! विश्वास नहीं कर सकता कि मैं भूल गया ¬।

— जस्टिन मैरीनर

Answer 6

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

• हैरानी की बात है कि जितना मैंने सोचा था।

a=input()
l=len(a)
r=range(l)
print'\n'.join(p.center(l*3-2)for p in[a]+(l>1)*([a[i]+(2*i-2+l)*' '+a[~i]for i in r[1:-1]]+[a[~i]+(l*3-4)*' '+a[i]for i in r]+[a[i]+(3*l-2*i-4)*' '+a[~i]for i in r[1:-1]]+[a[::-1]]))

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

Answer 7

PHP 7.1, 230 156 155 बाइट्स

for($x=$e=strlen($s=$argn)-1;$n<9;$r[$y][$x+=$n+1&3?$n&4?-1:1:0]=$s[$i],$i+=($n+=!$i||$i==$e)&1?:-1)$r[$y+=$n-1&3?$n<6?:-1:0]=$r[$y]?:"";echo join("
",$r);

ऑनलाइन के साथ पाइप के रूप में चलाएं -nRया इसे आज़माएं ।

टूट - फूट

for($x=$e=strlen($s=$argn)-1;   # import to $s, set $e to length-1, init $x
    $n<9;                       # loop through 8 repetitions of string
    $r[$y][
        $x+=$n+1&3?$n&4?-1:1:0      # 3. increment/decrement $x depending on $n
    ]=$s[$i],                       # 4. copy character to current position
    $i+=(
        $n+=!$i||$i==$e             # 5. if first or last character of string, increment $n
    )&1?:-1                         # 6. if odd repetition next, else previous character
)
    $r[
        $y+=$n-1&3?$n<6?:-1:0       # 1. increment/decrement $y depending on $n
    ]=$r[$y]?:"";                   # 2. if empty, init row to string
echo join("\n",$r);             # output

Answer 8

गणितज्ञ, 168 166 147 127 बाइट्स

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&

यह एक-वर्ण स्ट्रिंग्स की एक सूची लेता है और एक-वर्ण स्ट्रिंग्स के मैट्रिक्स को आउटपुट करता है।

मैं उपयोग करने के लिए समरूपता का दुरुपयोग करके 18 बाइट्स बचाया -lऔर Cross/@lजो लेता है एक क्रॉस-उत्पाद की तरह कुछ दो सिंगल 2 डी वैक्टर लेने के लिए में से प्रत्येक के {x,y}लिए {-y,x}। मूल रूप से, दो प्रारंभिक दिशाएँ पूर्व (ऊपरी किनारे) और दक्षिण-पश्चिम (ऊपरी दाएँ किनारे) हैं। फिर हम उनके साथ 90 डिग्री के वामावर्त घुमाव में जोड़ते हैं Cross: बाएं किनारे के लिए उत्तर और नीचे बाएं किनारे के लिए दक्षिण पूर्व। फिर हम अन्य चार टुकड़ों में जोड़ते हैं, -lहम जो कवर करते हैं उसे फ्लिप करने के लिए।

आप इसे सैंडबॉक्स पर कुछ इस तरह से देख सकते हैं:

(n=Length@#;b=Array[" "&,3{n,n}-2];Do[l={{1,n+k-1},{k,n-k+1}};l=Join[l,Cross/@l];b=ReplacePart[b,Join[l,-l]->#[[k]]],{k,n}];b)&[{"H","e","l","l","o"," ","G","o","l","f"}]//MatrixForm