हेक्सागोल्फ: वर्डागन्स

Question

यह भी देखें: रोटेटागोन

चुनौती

इनपुट के रूप में एक स्ट्रिंग को देखते हुए, इसके वर्डगन को आउटपुट करता है।

Wordagons

एक शब्दकोष एक षट्भुज में एक स्ट्रिंग का प्रतिनिधित्व करने का एक तरीका है। अब, आइए स्ट्रिंग से एक शब्दकोष बनाएँ hexa:

सबसे पहले, आप स्ट्रिंग के पहले चरित्र के साथ इसे केंद्र में जगह देते हैं:

h

फिर, आप अगले वर्ण को स्ट्रिंग में लेते हैं और एक षट्कोणीय परत जोड़ते हैं:

 e e
e h e
 e e

फिर, अगली परत जोड़ें:

  x x x
 x e e x
x e h e x
 x e e x
  x x x

अंत में, अंतिम परत जोड़ें:

   a a a a
  a x x x a
 a x e e x a
a x e h e x a
 a x e e x a
  a x x x a
   a a a a

और आपके पास अब स्ट्रिंग के लिए शब्दकोष है hexa।

उदाहरण

यहाँ कुछ मैंने पहले तैयार किया है:

hello

    o o o o o
   o l l l l o
  o l l l l l o
 o l l e e l l o
o l l e h e l l o
 o l l e e l l o
  o l l l l l o
   o l l l l o
    o o o o o

PPcg

   g g g g
  g c c c g
 g c P P c g
g c P P P c g
 g c P P c g
  g c c c g
   g g g g

o *

  * * *
 *     *
*   o   *
 *     *
  * * *

(T_T)

    ) ) ) ) )
   ) T T T T )
  ) T _ _ _ T )
 ) T _ T T _ T )
) T _ T ( T _ T )
 ) T _ T T _ T )
  ) T _ _ _ T )
   ) T T T T )
    ) ) ) ) )

ध्यान दें कि अनुगामी और / या अग्रणी नई सूचियों की अनुमति है।

जीतना

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

बोनस अंक अगर कोई हेक्सागोनी में ऐसा करता है? ;)

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

क्या इनपुट स्ट्रिंग में लाइनफीड हो सकता है? मुझे नहीं लगता कि यह किसी भी कार्यान्वयन की समस्या का कारण बनेगा, बस अवैध शब्दजाल का उत्पादन करें

— हारून

@ ऐरन नहीं, इनपुट स्ट्रिंग में कभी भी नई पंक्ति शामिल नहीं होगी

— बीटा डिके

क्या यह ठीक है अगर आउटपुट एक फ़ंक्शन से लौटी नईलाइन्स के साथ एक स्ट्रिंग है?

— डैनियल

ओह। मैं निराश हूं क्योंकि मैंने शीर्षक "शब्द-ड्रेगन" के रूप में पढ़ा ...

— mbomb007

Answer 1

पायथ - 29 बाइट्स

j+_K.e+*kdjdjF+*bhk*L2>zhkztK

टेस्ट सूट ।

Answer 2

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

s=input()
l=len(s)
while 1:l-=1;y=abs(l);print' '*y+' '.join(s[:y:-1]+s[y]*y+s[y:])

शब्द को प्रिंट करता है और फिर क्रैश (जो केवल STDERR को प्रिंट करता है)।

उदाहरण:

% python2.7 wordagon.py <<<'"abcde"' 2&>/dev/null
    e e e e e
   e d d d d e
  e d c c c d e
 e d c b b c d e
e d c b a b c d e
 e d c b b c d e
  e d c c c d e
   e d d d d e
    e e e e e

xnor ने 5 बाइट्स बचाए। धन्यवाद!

Comments

सुरुचिपूर्ण समाधान।

— डेविड

आप कर के माध्यम से लूप कर सकते yहैं n=len(s)\nwhile 1:n-=1;y=abs(n);...और त्रुटि के साथ समाप्त कर सकते हैं ।

— 21

Answer 3

विम, 92 बाइट्स

:se ri|s/./ &/g
ⓋCⓇ"Ⓓ␛$vpmlmrqqYpi ␛`ljxxhmlylv`rjlmr:s/\%V\(.\)./Ⓡ" /g
@qq@qVdy2G:g/^/m0
Gp

चक्कर वाले अक्षर Control+ अक्षर का प्रतिनिधित्व करते हैं ; ␛ बच रहा है।

Comments

क्या इसे कीस्ट्रोक्स के रूप में नहीं गिना जाएगा?

— सोरेन

@moo_we_all_do नहीं। यह कोड-गोल्फ है (संपादक गोल्फ के विपरीत), इसलिए सभी उत्तरों को बाइट्स में स्कोर किया जाना चाहिए।

— मार्टिन एंडर

दूसरा @qमेरे लिए एक अनंत लूप का कारण बनता है। यह पूरी तरह से काम करता है अगर इसे हटा दिया जाता है।

— MTCoster

Answer 4

गणितज्ञ 100 219 बाइट्स

यदि ASCII- कला को टर्मिनल-आर्ट की आवश्यकता नहीं है, तो यह वैध होना चाहिए।

मेरे पहले सबमिशन ने गलती से एक स्टार को षट्भुज के बजाय आकर्षित किया। मैं यह नहीं देख सकता कि मैं कैसे बंद था!

c = CirclePoints@6;
f@s_:=Graphics[{Text[s~StringPart~1,{0,0}],Flatten@Table[Text[StringPart[s,n+1],#]&/@Subdivide[Sequence@@#,n]&/@Partition[Riffle[(n)CirclePoints@6,RotateLeft[n CirclePoints@6]],2],{n,1,StringLength@s-1}]},BaseStyle->20]

CirclePoints@6 एक इकाई षट्भुज के कोने लौटाता है, यह मानते हुए कि केंद्र मूल में है।

Subdivideपड़ोसी छोरों के लिए निर्देशांक को समान रूप से संबंधित किनारे के साथ समान स्थान पाता है।

StringLength -1इनपुट स्ट्रिंग के माध्यम से 1 से एक काउंटर शब्दग्राम की प्रत्येक परत को अलग से नियंत्रित करने की अनुमति देता है।
जैसा कि nबढ़ता है, इसलिए मूल से प्रत्येक शीर्ष की संबंधित दूरी होती है।

Text[s~StringPart~1,{0,0}] मूल में इनपुट के पहले अक्षर को प्रिंट करता है।

---

च @ "Wordagon"

---

जिज्ञासु के लिए, यह वही है जो स्टार संस्करण जैसा दिखता था। मुझे पता है, यह निशान से दूर था । इसने केवल षट्भुज के कोने पर अक्षरों को दिखाया।

Graphics@Table[Text[Style[StringPart[#, r + 1], 54], r {Cos@t, Sin@t}], {t, 0, 2π, π/3}, {r, 0, StringLength@# - 1}] &["Hexa"]

Comments

क्या आप पोस्ट कर सकते हैं कि स्टार कैसा दिख रहा था? : डी

— बीटा डिके

ज़रूर। यह अब पोस्ट किया गया है।

— डेविड सेप

वाह, वह एक अच्छा सितारा है

— बीटा डेके

Answer 5

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

->s{n=s.size-1
(r=-n..n).map{|i|(" "*k=i.abs)+r.map{|j|s[[k+j,k,-j].max]}*" "}*$/}

1-n..n-1i = y और j = x दोनों दिशाओं में पुनरावृत्त करता है । प्रत्येक पंक्ति पर अग्रणी रिक्त स्थान के बिना, s सूचकांक के साथ एक चरित्र चुनने के परिणामस्वरूप, आउटपुट नीचे की तरह दिखता है [[i.abs+j,i.abs,-j].max]। प्रमुख स्थानों को जोड़ने से आवश्यक षट्भुज बनते हैं।

f f f f
f l l l f
f l o o l f
f l o G o l f
f l o o l f
f l l l f
f f f f

परीक्षण कार्यक्रम में अपराजित

f=->s{
  n=s.size-1             n=string length - 1
  (r=-n..n).map{|i|      iterate from -n to n, build an array of lines
    (" "*k=i.abs)+       k=i.abs. Start each line with k spaces.
    r.map{|j|            iterate from -n to n, build an array of characters.
      s[[k+j,k,-j].max]  select character from s (store null string in array if index past end of string)
    }*" "                concatenate the array of characters into a line, separated by spaces
  }*$/                   concatenate the array of lines into a single string, separate by newlines
}

puts f[gets.chomp]

विशिष्ट उत्पादन

   f f f f
  f l l l f
 f l o o l f
f l o G o l f
 f l o o l f
  f l l l f
   f f f f

Answer 6

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

s=>[...Array((l=s.length-1)*2+1)].map((_,i,a)=>a.map((_,j)=>s[Math.max(i-l,l-i,j-l,i-j,l+l-i-j)]||``).join` `).join`\n`

जहां \nशाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। Hexplosive ASCII- कला चुनौती के लिए मेरे जवाब के आधार पर हालांकि समाधान के कुछ हिस्सों @ LevelRiverSt के रूबी जवाब से मिलते जुलते हैं। Math.maxनिम्नलिखित उत्पादन के विभिन्न घटक निम्न के लिए उत्पादन करते हैं l=3:

    i - l           l - i           j - l            i - j        l + l - i - j
- - - - - - -   3 3 3 3 3 3 3   - - - 0 1 2 3    0 - - - - - -    6 5 4 3 2 1 0
- - - - - - -   2 2 2 2 2 2 2   - - - 0 1 2 3    1 0 - - - - -    5 4 3 2 1 0 -
- - - - - - -   1 1 1 1 1 1 1   - - - 0 1 2 3    2 1 0 - - - -    4 3 2 1 0 - -
0 0 0 0 0 0 0   0 0 0 0 0 0 0   - - - 0 1 2 3    3 2 1 0 - - -    3 2 1 0 - - -
1 1 1 1 1 1 1   - - - - - - -   - - - 0 1 2 3    4 3 2 1 0 - -    2 1 0 - - - -
2 2 2 2 2 2 2   - - - - - - -   - - - 0 1 2 3    5 4 3 2 1 0 -    1 0 - - - - -
3 3 3 3 3 3 3   - - - - - - -   - - - 0 1 2 3    6 5 4 3 2 1 0    0 - - - - - -

अधिकतम मान लिया जाता है, और इससे अधिक मूल्य lहटा दिए जाते हैं, इस प्रकार षट्भुज आकार का निर्माण होता है, जबकि शेष मान स्ट्रिंग के पात्रों के लिए मैप करते हैं:

6 5 4 3 3 3 3      3 3 3 3          a a a a
5 4 3 2 2 2 3     3 2 2 2 3        a x x x a
4 3 2 1 1 2 3    3 2 1 1 2 3      a x e e x a
3 2 1 0 1 2 3   3 2 1 0 1 2 3    a x e h e x a
4 3 2 1 1 2 3    3 2 1 1 2 3      a x e e x a
5 4 3 2 2 2 3     3 2 2 2 3        a x x x a
6 5 4 3 3 3 3      3 3 3 3          a a a a

Answer 7

05AB1E , 31 बाइट्स

R.pvy`¹gN-©×NFs.ø}Sðý®ð×ì})¦«»

व्याख्या

केवल हेक्सागोन के शीर्ष भाग को उत्पन्न करने के लिए समरूपता का उपयोग करना,
फिर उस निचले हिस्से को बनाने के लिए प्रतिबिंबित करना।

R.pv                     }       # for each prefix of the reversed string
                                 # ['f', 'fl', 'flo', 'floG']
    y`                           # split into chars, ex: 'f', 'l', 'o'
      ¹gN-©×                     # repeat the last char len(input)-N times, 
                                 # where N is the 0-based list index of the current prefix
                                 # ex: 'oo'
            NF   }               # N times do
              s.ø                # surround current char with the next char on stack
                                 # ex: 'floolf'
                  Sðý            # insert spaces between each letter, ex: 'f l o o l f'
                     ®ð×ì        # prefix string with len(input)-N spaces
                                 # ex: '  f l o o l f'
                          )      # wrap all strings in a list
                           ¦    # create a reversed copy of the list and 
                                 # remove the first item (as we only need the middle once)
                             «»  # concatenate the lists and merge with newlines

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

Answer 8

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

def f(s):
 for n in range(len(s)*2-1):x=abs(n-len(s)+1);print' '*x+' '.join(s[x+1:][::-1]+s[x]*x+s[x:])

Answer 9

PHP - 202 बाइट्स

$w=$argv[1];$l=$i=$a=strlen($w)-1;while(-$l<=$i){$s=join(" ",str_split(str_repeat($w[$l],($a-1)/2).substr($w,$a?$a:1,$l+1),1));echo str_pad("",$a).strrev($s).($a%2?" ":" {$w[$a]} ")."$s
";$a=abs(--$i);}

कमांड लाइन से उपयोग:

php.exe -r "put the escaped code here" "put your desired word here"

उदाहरण के लिए:

php.exe -r "$w=$argv[1];$l=$i=$a=strlen($w)-1;while(-$l<=$i){$s=join(\" \",str_split(str_repeat($w[$l],($a-1)/2).substr($w,$a?$a:1,$l+1),1));echo str_pad(\"\",$a).strrev($s).($a%2?\" \":\" {$w[$a]} \").\"$s\n\";$a=abs(--$i);}" "example"

टेस्ट सूट ।