30

कम से कम दो शब्दों (केवल लोअरकेस अक्षरों से बने) की एक सूची को देखते हुए, लिखने की दिशा को पहले दाईं ओर, फिर बाईं ओर, अपेक्षाकृत बाईं ओर से आरंभिक दिशा की ओर से वैकल्पिक रूप से लिखकर ASCII सीढ़ी का निर्माण और प्रदर्शन करें ।

जब आप एक शब्द लिखना समाप्त कर दें, तो दिशा बदल दें और उसके बाद ही अगला शब्द लिखना शुरू करें।

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

अग्रणी और अनुगामी व्हाट्सएप की अनुमति है।

["hello", "world"] या "hello world"

hello
    w
    o
    r
    l 
    d

यहां हम लिखना शुरू करते हैं helloऔर जब हम अगले शब्द पर आते हैं (या एक स्ट्रिंग के रूप में इनपुट के मामले में - एक स्थान मिल जाता है), हम दाईं ओर सापेक्ष दिशा बदलते हैं और लिखना जारी रखते हैंworld

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

["another", "test", "string"] or "another test string" ->   

another
      t
      e
      s
      tstring


["programming", "puzzles", "and", "code", "golf"] or "programming puzzles and code golf" ->

programming
          p
          u
          z
          z
          l
          e
          sand
             c
             o
             d
             egolf

["a", "single", "a"] or "a single a" ->

a
s
i
n
g
l
ea

मानदंड

हर भाषा में बाइट्स में सबसे छोटा कोड जीतता है। चलो गोल्फ भाषाओं द्वारा हतोत्साहित मत करो!

सैंडबॉक्स

code-golf ascii-art

— गैलेन इवानोव
स्रोत

1

सम्बंधित

— बैसब्रांड कंबरवबूबबूब

1

@Arnauld हां, मैं इसे विवरण में जोड़ूंगा।

— गैलेन इवानोव

12

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

Ｆ⮌Ａ«↑⮌ι‖↗

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: पाठ को पीछे की ओर खींचकर, हर शब्द के बाद कैनवास को ट्रांसफ़ॉर्म करना। स्ट्रिंग इनपुट के लिए 10 बाइट्स:

Ｆ⮌Ｓ≡ι ‖↗←ι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण: पाठ को पीछे की ओर खींचता है, कैनवास को रिक्त स्थान के लिए स्थानांतरित करता है।

— नील
स्रोत

9

सी (जीसीसी) , 94 78 74 बाइट्स

-4 जोहान डू टिट से

o,f;g(int*s){for(o=f=0;*s;s++)*s<33?f=!f:printf("\n%*c"+!f,f*(o+=!f),*s);}

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

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

— attinat
स्रोत

1

बदल सकता है *s==32में *s<33एक बाइट को बचाने के लिए।

— गैस्ट्रोपनर

74 बाइट्स

— जोहान डू टिट

6

05AB1E , 19 16 बाइट्स

€θ¨õšøíJD€gs24SΛ

-3 बाइट्स @Emigna की बदौलत ।

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

सामान्य स्पष्टीकरण:

ठीक @Emigna के 05AB1E उत्तर की तरह (उसे btw को आगे बढ़ाने के लिए सुनिश्चित करें !!), मैं कैनवस Λबिलिन का उपयोग करता हूं ।

मेरे द्वारा उपयोग किए जाने वाले विकल्प अलग-अलग हैं (यही वजह है कि मेरा उत्तर लंबा है ..):

b(प्रिंट करने के लिए तार): मैं अपरिवर्तित सूची में पहला स्ट्रिंग छोड़ता हूं, और सूची में प्रत्येक अगले स्ट्रिंग में अनुगामी चरित्र जोड़ता हूं। उदाहरण के लिए ["abc","def","ghi","jklmno"]बन जाएगा ["abc","cdef","fghi","ijklmno"]।
a(लाइनों का आकार): यह इन तारों के बराबर होगा, इसलिए [3,4,4,7]ऊपर दिए गए उदाहरण के साथ।
c(दिशा में मुद्रित करने के लिए):, [2,4]जो नक्शा करेगा[→,↓,→,↓,→,↓,...]

तो उपरोक्त उदाहरण चरण-दर-चरण निम्न कार्य करेगा:

abcदिशा में खींचना 2/ →।
cdefदिशा में ड्रा करें 4/ ↓(जहां पहला चरित्र अंतिम चरित्र के साथ ओवरलैप होता है, यही कारण है कि हमें इस तरह सूची को संशोधित करना पड़ा)
ड्रा fghiदिशा में 2/ →फिर से (भी पीछे की ओवरलैप के साथ / प्रमुख अक्षर)
ijklmnoदिशा में 4/ ↓फिर से ड्रा करें (ओवरलैप के साथ भी)
तैयार किए गए कैनवस के परिणाम को तुरंत STDOUT में आउटपुट करें

कोड स्पष्टीकरण:

€θ                # Only leave the last characters in the (implicit) input-list
  ¨               # Remove the last one
   õš             # And prepend an empty string "" instead
     ø            # Create pairs with the (implicit) input-list
      í           # Reverse each pair
       J          # And then join each pair together to single strings
        D€g       # Get the length of each string (without popping by duplicating first)
           s      # Swap so the lengths are before the strings
            24S   # Push [2,4]
               Λ  # Use the Canvas builtin (which outputs immediately implicitly)

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

1

आपके संस्करण 2/3/4 के साथ 3 बाइट बचा सकते हैं €θ¨õšsøJ।

— Emigna

@Emigna धन्यवाद! अब जब मैं देख रहा हूँ कि यह बहुत आसान लग रहा है .. और यहाँ मेरे पास तीन वैकल्पिक 19 बायर्स थे ..

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

कुछ विकल्प €θ¨õšsøJहैं õIvy«¤}), õUεXì¤U}और ε¯Jθì¤ˆ}(अंतिम दो की आवश्यकता है --no-lazy)। दुर्भाग्य से, वे सभी एक ही लंबाई के हैं। यह बहुत आसान होगा अगर कोई एक चर चूक गया ""...

— ग्रैमी

@Grimy " यह बहुत आसान होगा अगर कोई एक वैरिएबल डिफ़ॉल्ट रूप से ""... " क्या आप खोज रहे हैं õ, या आप का मतलब है X/ Y/ ®होगा ""? Btw, Emigna के उत्तर की टिप्पणी में अच्छा 13 बटर। [→,↙,↓,↗]आपके द्वारा उपयोग किए गए निर्देशों के साथ, मेरा और उसकी tbh दोनों से अलग है ।

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

õएक चर नहीं है। हां, मेरा मतलब एक ऐसा वैरिएबल है जो डिफॉल्ट करता है ""। मैं सचमुच õUस्निपेट्स में से एक की शुरुआत में करता हूं , इसलिए यदि एक्स (या किसी अन्य चर) को डिफ़ॉल्ट किया जाता है "", तो यह दो बाइट्स को तुच्छ रूप से बचाएगा। धन्यवाद! हाँ, the थोड़ा नया है, लेकिन मुझे इमिग्ना के उत्तर से लंबाई 2 डमी लिखता है के साथ सही लिखने को इंटरसेप्ट करने का विचार मिला।

— ग्रैमी

6

05AB1E , 14 13 बाइट्स

1 बाइट ग्रिम के लिए धन्यवाद बचा लिया

€ðÀD€g>sŽ9÷SΛ

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

व्याख्या

                 # example input ["Hello", "World"]
€ðÀ              # push a space after each word
                 # STACK: ["Hello"," ","World"," "]
   D             # duplicate
    €g>          # get the length of each word in the copy and add 1
                 # these are the lengths to draw
                 # STACK: ["Hello"," ","World"," "], [6, 2, 6, 2]
       s         # swap the list of word to the top of the stack
        Ž9÷S     # push [2, 5, 4, 1]
                 # this is the list of directions to draw
                 # 1=northeast, 2=east, 4=south, 5=southwest
            Λ    # paint on canvas

— Emigna
स्रोत

1

ओह, अच्छा दृष्टिकोण! मैं अपने 19-बाइट संस्करणों को एक पल में पोस्ट करूंगा, लेकिन बिफुरसेट के साथ बहुत अच्छा और सिर्फ दो अक्षर खींचना।

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

1

Btw, तुम्हें पता है कि वहाँ interspersing के लिए एक अंतर्निहित है, है ना? €Y¦हो सकता है 2.ý(यह नहीं कि यह यहां किसी भी बाइट को बचाएगा)। और यह पहली बार है जब मैंने €नियमित मानचित्र की तुलना में नए व्यवहार को उपयोगी होते हुए देखा है।

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

@ केविनक्रूजसेन: मैंने .ýपहले भी देखा है लेकिन मैंने कभी खुद का इस्तेमाल नहीं किया है इसलिए मैंने इसके बारे में सोचा नहीं था। €मेरे लिए नियमित रूप से नक्शा है और मैंने अक्सर इसका इस्तेमाल किया है, दूसरा "नया" नक्शा है;)

— एमिग्ना

13 , अन्य 13

— ग्रैमी

2

मेरा बुरा, मैं भी / विषम कठिनाई नोटिस करने में विफल रहा! यहाँ एक 13 है कि वास्तव में काम करना चाहिए है: € पिता € जी> sŽ9 ÷ SΛ

— ग्रिमी

5

कैनवस , 17 12 11 10 बाइट्स

ø⁸⇵｛⟳Ｋ└×∔⤢

यहाँ यह कोशिश करो!

स्पष्टीकरण:

ø⁸⇵{⟳K└×∔⤢  full program taking array as input (loaded with ⁸)

ø         push an empty canvas               ["test", "str"], ""
 ⁸⇵{      for each input word, in reverse:   "str", "test" (showing 2nd iter)
    ⟳       rotate the word vertically       "str", "t¶e¶s¶t"
     K      pop off the last letter          "str", "t¶e¶s", "t"
      └     swap the two items below top     "t¶e¶s", "str", "t"
       ×    prepend                          "t¶e¶s", "tstr"
        ∔   vertically append                "t¶e¶s¶tstr"
         ⤢  transpose the canvas             "test
                                                 s
                                                 t
                                                 r"

— dzaima
स्रोत

5

जावास्क्रिप्ट (ईएस 8), 91 79 77 बाइट्स

शब्दों की एक सरणी के रूप में इनपुट लेता है।

a=>a.map((s,i)=>i&1?[...s].join(p):s+=p+=''.padEnd(s.length-!i),p=`
`).join``

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

टिप्पणी की गई

a =>                 // a[] = input array
  a.map((s, i) =>    // for each word s at position i in a[]:
    i & 1 ?          //   if this is a vertical word:
      [...s].join(p) //     split s and join it with p
    :                //   else:
      s +=           //     add to s:
        p +=         //       add to p:
          ''.padEnd( //         as many spaces
            s.length //         as there are letters in s
            - !i     //         minus 1 if this is the 1st word (because it's not connected
          ),         //         with the last letter of the previous vertical word)
    p = `\n`         //   start with p = linefeed
  ).join``           // end of map(); join everything

— Arnauld
स्रोत

pलाइन एंडिंग का ट्रैक रखने के लिए उपयोग बहुत स्मार्ट है +1

— डाउनगोट

5

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

b=p=0
r=''
for w in input():
 for c in w:r+='\n'.ljust(p)*b+c;p+=1-b
 b^=1
print r

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

— XNOR
स्रोत

5

ब्रेनफक , 57 बाइट्स

->,[[.<+>,],[<<[-]++++++++++.--[-<++++>]>[-<+<.>>]>.<,],]

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

एनयूएल द्वारा अलग किए गए तार के रूप में इनपुट लेता है। ध्यान दें कि यह ईओएफ 0 के रूप में उपयोग कर रहा है, और जब सीढ़ी 256 रिक्त स्थान से अधिक हो जाएगी तो काम करना बंद कर देगा।

स्पष्टीकरण:

-           Initialise counter as -1
>,[         Start ladder
   [.<+>,]  Print the first word, adding the length of it to the counter
   ,[       Loop over each letter of the second word
      <<[-]++++++++++.    Print a newline
      --[-<++++>]         Create a space character
      >[-<+<.>>]          Print counter many spaces
      >.<,                Print the letter and move to the next letter
   ] 
   ,        Repeat until there are no more words
]

— मजाक कर रहा है
स्रोत

क्या मैं ब्रेन-फ्लैक में समाधान के लिए पूछ सकता हूं?

— गैलेन इवानोव

बीएफ को समझने का मेरा पहला प्रयास। 2 प्रश्न: .पंक्ति 3 (टिप्पणी संस्करण में) में कोई चार्ट नहीं होने पर पहला शब्द कैसे मुद्रित किया जा रहा है ? मैं TIO पर इनपुट के साथ खेलने की कोशिश कर रहा था। मैक पर, मैंने कीबोर्ड को यूनिकोड टेक्स्ट इनपुट पर स्विच किया और टाइप करके नई शब्द सीमाएँ बनाने की कोशिश की, option+0000लेकिन यह काम नहीं किया। कोई विचार क्यों नहीं?

— जोनाह

1

@ जोना आह अच्छी पकड़, मैंने गलती से स्पष्टीकरण के -बजाय टाइप किया .। TIO में NUL बाइट्स जोड़ने के लिए, मैं कंसोल का उपयोग करने और जैसे कमांड चलाने की सलाह देता हूं $('#input').value = $('#input').value.replace(/\s/g,"\0");। मुझे नहीं पता कि आपका रास्ता काम क्यों नहीं किया

— जो किंग ने

5

जावास्क्रिप्ट, 62 बाइट्स

a=>' '+a.replace(/./g,c=>1-c?(a=!a,''):a?(p+=' ',c):p+c,p=`
`)

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

धन्यवाद रिक हिचकॉक , 2 बाइट्स बचाए गए।

जावास्क्रिप्ट, 65 बाइट्स

a=>a.replace(/./g,c=>1-c?(t=!t,''):t?p+c:(p+=p?' ':`
`,c),t=p='')

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

a => a.replace (/./ g, c => (// स्ट्रिंग में प्रत्येक वर्ण c के लिए a)
    1 - सी? // अगर (c स्पेस है)
      (t =! t, // अपडेट t: बूलियन मूल्य शब्द सूचकांक का वर्णन करता है
                       // सत्य: विषम अनुक्रमित शब्द;
                       // मिथ्या: यहां तक कि अनुक्रमित शब्द भी
        ''): // अंतरिक्ष के लिए कुछ भी नहीं उत्पन्न करते हैं
    टी? // यदि (विषम सूचकांक है) जिसका अर्थ है लंबवत
      p + c: // कुछ रिक्त स्थान, और एक सिगर चार्जर जोड़ें
                       // अन्य
      (p + = p? '': '\ n', // ऊर्ध्वाधर शब्दों के लिए प्रीपेंड स्ट्रिंग तैयार करें
         ग) // एक एकल वर्ण जोड़ें
),
  t = p = '' // आरंभ करें
)

— TSH
स्रोत

मुझे लगता है कि आप की जगह 2 बाइट्स बचा सकता है tके साथ aहै, तो दूर करनेt=

— रिक हिचकॉक

5

ऐहुई (esotope) , 490 458 455 बाइट्स

삭뱃밸때샏배샐배새뱄밿때빠뱋빼쌘투＠밧우
＠두내백뱃빼선대내백뱃섣＠여우샐처샐추
희차＠＠＠뭏누번사＠빼뭏오추뻐＠＠＠배
Ｂｙ＠＠＠새대백＠＠＠우뻐색
Ｌｅｇｅｎ＠＠빼쵸누번＠＠빼
ＤＵＳＴ＠＠＠샌뽀터본섣숃멓
＠＠＠＠＠＠＠오어아＠먛요아＠＠샏매우
＠＠＠＠＠아＠＠＠＠＠＠오＠＠＠＠＠서어
＠＠＠＠＠희차＠＠요

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

कोरियाई (3 बाइट्स) के बजाय पूर्ण-चौड़ाई वाले पात्रों (2 बाइट्स) का उपयोग करके थोड़ा सा गोल्फ।

व्याख्या

ऐहुई बेफ्यूज-लाइक एसोलैंग है। यहाँ रंग के साथ कोड है: 1 भाग की जाँच करता है कि वर्तमान वर्ण स्थान है या नहीं।

? 2 भागों की जाँच करें कि क्या शब्द दाएं से बाएं या ऊपर से नीचे लिखे गए थे।

? 3 भाग लूप की स्थिति है जो रिक्त स्थान टाइप करता है।

? 4 भागों की जाँच करें कि क्या वर्तमान वर्ण पंक्ति (-1) का अंत है।

लाल भाग स्टैक इनिशियलाइज़ेशन है। ऐहुई मूल्य को संग्रहीत करने के Nothingलिए स्टैक (से ㅎ: 28 स्टैक) का उपयोग करता है ।

ऑरेंज भाग इनपुट ( 뱋) लेता है और जांचता है कि क्या यह अंतरिक्ष है, 32(अंतरिक्ष के एससीआई कोड) के साथ घटाकर ।

हरे रंग का हिस्सा 1 को जोड़ देता है जो कि अंतरिक्ष की लंबाई के मूल्य को संग्रहीत करता है, अगर राइट-टू-लेफ्ट लिखता है।

बैंगनी रिक्त स्थान मुद्रण के लिए लूप है, अगर ऊपर-नीचे लिख रहा है।

यदि वर्तमान वर्ण है -1, तो एक वर्ण को वर्तमान वर्ण में जोड़कर ग्रे भाग जांचें ।

ब्लू पार्ट वर्तमान चरित्र को प्रिंट करता है, और अगले चरित्र के लिए तैयार करता है।

— LegenDUST
स्रोत

इस पोस्ट में छवि बनाने के लिए आपने क्या प्रयोग किया?

— bb94

@ bb94 आधार AheuiChem , अच्छा निर्मित कोरियाई Aheui ऑनलाइन (आईडी) का प्रकार है। और मैंने इसे रंगीन करने के लिए पावरपॉइंट का उपयोग किया।

— लेगेनडुस्टस्ट

4

जाप `-P` , 15 बाइट्स

ò mrÈ+R+YÕùT±Xl

कोशिश करो

ò mrÈ+R+YÕùT±Xl     :Implicit input of string array
ò                   :Partition into 2s
  m                 :Map each pair
   r                :  Reduce by
    È               :  Passing through the following function as X & Y
     +              :    Append to X
      R             :    Newline
       +            :    Append
        YÕ          :    Transpose Y
          ù         :    Left pad each line with spaces to length
           T±       :      T (initially 0) incremented by
             Xl     :      Length of X
                    :Implicitly join and output

— झबरा
स्रोत

4

बैश, 119 चार

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for((i=0;i<l;i++));do
c="${w:$i:1}"
[ -z $c ]&&d=$((1-d))||printf ${X[$d]}$c
done

यह कर्सर को स्थानांतरित करने के लिए एएनएसआई नियंत्रण दृश्यों का उपयोग करता है - यहां मैं केवल बचत \e7और पुनर्स्थापना का उपयोग कर रहा हूं \e8; लेकिन \nअगर यह पहले से ही टर्मिनल के नीचे है तो आउटपुट को स्क्रॉल करने के लिए रीस्टोर को प्रीफिक्स किया जाना चाहिए । किसी कारण से यह काम नहीं करता है यदि आप पहले से ही टर्मिनल के नीचे नहीं हैं । * श्रग *

वर्तमान चरित्र $cको इनपुट स्ट्रिंग से एकल-वर्ण के रूप में अलग किया जाता है $w, forलूप इंडेक्स $iको स्ट्रिंग में इंडेक्स के रूप में उपयोग किया जाता है।

मैं यहाँ इस्तेमाल कर रहा हूँ केवल असली चाल है, [ -z $c ]जो वापस आ जाएगी true, यानी स्ट्रिंग खाली है, जब $cएक जगह है, क्योंकि यह निर्विवाद है। बैश के सही उपयोग में, आप -zइस स्थिति से बचने के लिए परीक्षण किए जा रहे स्ट्रिंग को उद्धृत करेंगे । यह हमें दिशा ध्वज फ्लिप की अनुमति देता है $dके बीच 1और 0है, जो तब, एएनएसआई नियंत्रण अनुक्रम सरणी में एक सूचकांक के रूप में प्रयोग किया जाता है Xकी अगली गैर अंतरिक्ष मूल्य पर $c।

मैं कुछ है कि उपयोग करता है देखने के लिए दिलचस्पी होगी printf "%${x}s" $c।

ओह, चलो कुछ व्हाट्सएप जोड़ें। मैं नहीं देख सकता कि मैं कहाँ हूँ ...

X=("\e7" "\n\e8")
w="$@"
l=${#w}
d=0
for ((i=0;i<l;i++)); do
  c="${w:$i:1}"
  [ -z $c ] && d=$((1-d)) || printf ${X[$d]}$c
done

— धनी
स्रोत

ओह, आप इसे उस tio.run साइट पर नहीं आज़मा सकते - कुछ अन्य लोगों की तरह, कोई एएनएसआई नियंत्रण अनुक्रम नहीं संभाल रहा है, इसलिए यह सिर्फ बारफ्स है।

— रिच

4

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

{$/=0;.map:{$/+=$++%2??!.comb.fmt("%$/s","
").print!!.say*.comb}}

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

अनाम कोड ब्लॉक जो सीधे शब्दों की एक सूची लेता है और सीधे STDOUT पर प्रिंट करता है।

व्याख्या

{                           }  # Anonymous code block
 $/=0;                         # Initialise $/ to 0
 .map:{                    }   # Map the list of words to
       $/+=                    # Increment $/ by
           $++%2??             # For even indexes
                   .comb       # Each letter of the word
                   .fmt(           ) # Formatted as
                        "%$/s"       # Padded with $/-1 spaces
                              ,"\n"  # Joined by newlines
                   .print            # And printed without a newline
                  !   # Boolean not this to add 0 to $/
                !!            # For odd indexes
                  .say        # Print with a newline
                      *.comb  # And add the length of the word

— मजाक कर रहा है
स्रोत

मैं उत्सुक हूं कि यह कैसे जो काम करता है, मैं पर्ल 6 को नहीं जानता

— जोनाह

@ जोनाह मैंने एक स्पष्टीकरण जोड़ा है

— जो किंग

धन्यवाद, अच्छा समाधान।

— योना

3

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

ＦＬθ¿﹪ι²«↓§θι↗»«§θι↙

तार की सूची के रूप में इनपुट

इसे ऑनलाइन (क्रिया) आज़माएँ या इसे ऑनलाइन आज़माएँ (शुद्ध)

स्पष्टीकरण:

सीमा में लूप [0, input-length):

For(Length(q))
ＦＬθ

यदि सूचकांक विषम है:

If(Modulo(i,2)){...}
﹪ι²«...»

iनीचे की दिशा में तर्जनी पर स्ट्रिंग प्रिंट करें :

Print(:Down, AtIndex(q,i));
↓§θι

और फिर कर्सर को एक बार ऊपर-दाहिनी ओर घुमाएँ:

Move(:UpRight);
↗

एल्स (इंडेक्स सम है):

Else{...}
«...

iनियमित सही दिशा में तर्जनी पर स्ट्रिंग प्रिंट करें :

Print(AtIndex(q,i));
§θι

और फिर नीचे-बाएँ की ओर कर्सर ले जाएँ:

Move(:DownLeft);
↙

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

3

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

s=i=-1
r=''
for w in input():r+=[('\n'+' '*s).join(' '+w),w][i];s-=i*len(w);i=~i
print r

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

— TFeld
स्रोत

3

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

a=>{int i=0;var t="\n";foreach(var z in a)Write(i++%2<1?z+(t+="".PadRight(z.Length-(i<2?1:0))):string.Join(t,z.Skip(0)));}

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

— अज्ञान का अवतार
स्रोत

3

जे , ^{47 45} 43 बाइट्स

;[`(([:<@(+/)\#&>##$#:@1 2)@])`([' '"0/[)}]

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

मुझे एक मजेदार, अलग दृष्टिकोण मिला ...

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

समाधान को लगभग पूरी तरह से अमेंड द्वारा नियंत्रित किया जाता है }:

; [`(([: <@(+/)\ #&> # # $ #:@1 2)@])`([ ' '"0/ [)} ]

; ( single verb that does all the work ) ] समग्र कांटा
; बायां हिस्सा इनपुट को रेज़ करता है, अर्थात, सभी अक्षरों को एक सन्निहित स्ट्रिंग में डालता है
] दाहिना भाग इनपुट ही है
(stuff)}हम संशोधन के gerund रूप का उपयोग करते }हैं, जिसमें तीन भाग होते हैं v0`v1`v2।
- v0हमें "नए मूल्य" प्रदान करता है, जो कि (एक स्ट्रिंग के रूप में इनपुट के सभी वर्ण) है, इसलिए हम उपयोग करते हैं [।
- v2हमें शुरुआती मूल्य देता है, जिसे हम बदल रहे हैं। हम बस आवश्यक आयामों के रिक्त स्थान का एक रिक्त कैनवास चाहते हैं। ([ ' '"0/ [)हमें एक आकार देता है (all chars)x(all chars)।
- मध्य क्रिया v1का चयन होता है कि हम किस स्थिति में अपने प्रतिस्थापन पात्रों को डालेंगे। यह तर्क का चरम है ...
0 0ऊपरी बाएँ में स्थिती से शुरू करते हुए , हम देखते हैं कि प्रत्येक नया वर्ण पिछली स्थिति के दाईं ओर 1 (यानी, prev + 0 1) या एक नीचे (यानी, prev + 1 0) है। दरअसल हम पूर्व "शब्द 1 की लेन" बार करते हैं, फिर बाद में "शब्द 2 की लेन", और इसी तरह, बारी-बारी से। तो हम सिर्फ इन आंदोलनों का सही क्रम बनाएंगे, फिर उन्हें स्कैन करेंगे, और हमारे पास हमारी स्थिति होगी, जो हम तब बॉक्स करते हैं क्योंकि यह कैसे काम करता है। क्या इस विचार के सिर्फ यांत्रिकी है ...
([: <@(+/)\ #&> # # $ 1 - e.@0 1)
- पहले #:@1 2स्थिर मैट्रिक्स बनाता है 0 1;1 0।
- # $फिर इसे विस्तारित करता है इसलिए इसमें इनपुट के रूप में कई पंक्तियाँ हैं। उदाहरण के लिए, यदि इनपुट में 3 शब्द हैं तो यह उत्पादन करेगा 0 1;1 0;0 1।
- #&> #उस का बायां हिस्सा इनपुट शब्दों की लंबाई का एक सरणी है और #प्रतिलिपि है, इसलिए यह 0 1"शब्द 1 की लेन" को कॉपी करता है , फिर 1 0"शब्द 2 बार का लेन", आदि।
- [: <@(+/)\ स्कैन योग और बॉक्स करता है।

— जोनाह
स्रोत

3

टी-एसक्यूएल, 185 बाइट्स

DECLARE @ varchar(max)='Thomas Clausen Codegolf Script'
,@b bit=0,@s INT=0SET @+=':'WHILE @ like'%_:%'SELECT
@b+=len(left(@,1))-1,@=stuff(@,1,1,'')+iif(left(@,@b)='','','
'+space(@s))+trim(left(@,1)),@s+=len(left(@,~@b))PRINT
stuff(@,1,1,'')

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

— t-clausen.dk
स्रोत

1

बीआईटी मूल्यों, सीमांकक रिक्त स्थान और परिपत्र स्ट्रिंग प्रसंस्करण का बहुत चालाक उपयोग। मेरे से बेहतर जवाब!

— Muqo

2

रेटिना , 51 बाइट्स

1,2,`\w+
;$&
+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;
; |;$

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

एक सीधा दृष्टिकोण जो हर दूसरे शब्द को चिह्नित करता है और फिर परिवर्तन को सीधे लागू करता है।

व्याख्या

1,2,`\w+
;$&

हम प्रत्येक शब्द का मिलान करके अर्धविराम के साथ हर दूसरे शब्द को चिह्नित करते हैं, लेकिन केवल मैचों के प्रतिस्थापन को लागू करते हैं (जो शून्य अनुक्रमित होते हैं) मैच 1 से शुरू होता है और फिर 3 और इसी तरह।

+(m`^(.(.*?)) ?;(.)
$1¶$.2* $3;

+(mनिम्नलिखित चरणों के लिए कुछ गुण निर्धारित करता है। प्लस एक "शुरू होता है, जबकि चरणों का यह समूह कुछ बदल जाता है" लूप, और खुले ब्रैकेट का अर्थ है कि प्लस को निम्नलिखित सभी चरणों पर लागू करना चाहिए जब तक कि एक बैकटिक के सामने एक करीबी ब्रैकेट न हो (जो सभी चरणों में है ये मामला)। mबस का इलाज करने के लिए regex बताता ^भी सिर्फ स्ट्रिंग की शुरुआत के बजाय लाइनों की शुरुआत से मिलान के रूप में।

वास्तविक रेगेक्स बहुत सीधा है। हम पहले अर्धविराम से पहले सामान की उपयुक्त मात्रा से मेल खाते हैं और फिर रेटिना के *प्रतिस्थापन सिंटैक्स का उपयोग सही स्थानों की संख्या में करने के लिए करते हैं।

; |;$

यह चरण उन शब्दों के अंत में अर्धविराम और रिक्त स्थान को हटाने के लिए पिछले एक के बाद लागू किया जाता है जिन्हें हमने ऊर्ध्वाधर में बदल दिया था।

— FryAmTheEggman
स्रोत

2

रेटिना 0.8.2 , 58 बाइट्स

(?<!^(\S* \S* )*\S*)
¶
¶? 

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

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

( \S*) 
$1¶
+` (.)
¶$1 
 ¶

+`(..(.)*¶)((?<-2> )*\S)
$1 $3

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण मामले शामिल हैं।

मैं जानबूझकर रेटिना 1 का उपयोग नहीं कर रहा हूं, इसलिए मुझे मुफ्त में वैकल्पिक शब्दों पर संचालन नहीं मिलता है; इसके बजाय मेरे पास दो दृष्टिकोण हैं। पहला दृष्टिकोण पूर्ववर्ती रिक्त स्थान की गणना करके वैकल्पिक शब्दों में सभी अक्षरों पर विभाजन करता है, जबकि दूसरा दृष्टिकोण वैकल्पिक स्थानों को नई-नई खांचों से बदल देता है और फिर वैकल्पिक शब्दों को अक्षरों में विभाजित करने में मदद करने के लिए शेष रिक्त स्थान का उपयोग करता है। प्रत्येक दृष्टिकोण को फिर अगले क्षैतिज शब्द के साथ अंतिम ऊर्ध्वाधर अक्षर में शामिल होना पड़ता है, हालांकि कोड अलग है क्योंकि वे शब्दों को अलग-अलग तरीकों से विभाजित करते हैं। दोनों दृष्टिकोण का अंतिम चरण तब प्रत्येक पंक्ति को पैड करता है जब तक कि उसका पहला गैर-स्थान वर्ण पिछली पंक्ति के अंतिम वर्ण के तहत संरेखित न हो जाए।

ध्यान दें कि मैं यह नहीं मानता कि शब्द सिर्फ अक्षर हैं क्योंकि मुझे नहीं करना है।

— नील
स्रोत

2

पॉवरशेल , 101 89 83 बाइट्स

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

$args|%{$l+=if(++$i%2){$_.length-1;$t+=$_}else{1;$_|% t*y|%{$t+='
'+' '*$l+$_}}};$t

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

— आंद्रेई ओडेगो
स्रोत

अच्छा। आप कर सकते हैं: 1) पहली पंक्ति को हटा दें, 2) एक splatting का उपयोग करें & $b @p(प्रत्येक शब्द एक तर्क के रूप में), 3) new lineनिरंतर के लिए छोटे रूप का उपयोग करें । पर 3,4 लाइन को देखने के इस उदाहरण

— Mazzy

@ माज़ी, छींटाकशी के साथ मुझे गलत जवाब मिलता है foo। कोड देखें ।

— आंद्रेई ओडेगो

ऊ! बंटवारा एक शब्द को चार सरणी में विभाजित करता है। दिलचस्प। धन्यवाद!

— Mazzy

1

@ माज़ी, यह मेरी गलती नहीं है :)

— आंद्रेई ओडेगो

मुझे लगता है कि हम नियम का उपयोग कर सकते हैंGiven a list of at least two words...

— Mazzy

2

पॉवरशेल , 74 65 बाइट्स

-join($args|%{$_|% t*y|%{($p+=(' ','
')[!$p]*!$i)*$i;$_};$i=!$i})

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

— Mazzy
स्रोत

2

आर , 126 बाइट्स

function(x,`>`=strrep)for(i in seq(x)){H=i%%2;cat(paste0('
'>!H,' '>F*!H,e<-'if'(H,x,strsplit(x,''))[[i]]))
F=F+nchar(e[1])-H}

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

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

— digEmAll
स्रोत

2

टी-एसक्यूएल, 289 बाइट्स

DECLARE @ VARCHAR(MAX)='a a',@I INT=1,@S INT=0,@B INT=0WHILE @I<=LEN(@)IF SUBSTRING(@,@I,1)=''IF @B=0SELECT @S-=1,@=STUFF(@,@I,1,'
'+SPACE(@S)),@I+=@S+3,@B=1 ELSE SELECT @=STUFF(@,@I,1,''),@S+=1,@B=\ELSE IF @B=0SELECT @I+=1,@S+=1 ELSE SELECT @=STUFF(@,@I,0,'
'+SPACE(@S)),@I+=@S+3PRINT @

यह SQL Server 2016 और अन्य संस्करणों पर चलता है।

@ स्थान-सीमांकित सूची रखता है। @ मैं स्ट्रिंग में इंडेक्स स्थिति को ट्रैक करता है। @ एस बाईं ओर से इंडेंट करने के लिए रिक्त स्थान की कुल संख्या को ट्रैक करता है। @B ट्रैक, जो धुरी स्ट्रिंग बिंदु @I के साथ संरेखित है।

बाइट काउंट में न्यूनतम उदाहरण सूची शामिल है। स्क्रिप्ट सूची, चरित्र द्वारा चरित्र के माध्यम से जाती है, और स्ट्रिंग को बदल देती है ताकि यह आवश्यकताओं के अनुसार प्रदर्शित हो। जब स्ट्रिंग का अंत पहुँच जाता है, तो स्ट्रिंग को प्रिंट किया जाता है।

— Muqo
स्रोत

हाय @ मुगो ऐसा लगता है कि लंबे समय तक इनपुट का उपयोग करने पर आपकी स्क्रिप्ट में गड़बड़ है। यदि आप मेरे उत्तर के डेटा के साथ परीक्षण करते हैं, तो आप देखेंगे कि पी और टी के बीच अंतिम शब्द में एक अनपेक्षित मोड़ है

— t-clausen.dk

@ t-clausen.dk ओह, मैंने पिछली यात्रा को ठीक से नहीं किया है। धन्यवाद!

— Muqo

यह अब काम करता है की पुष्टि की

— t-clausen.dk

1

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

a=>a.map(x=>i++&1?[,...x].join(`
`.padEnd(n)):(n+=x.length,x),n=i=0).join``

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

स्पष्टीकरण और अपुष्ट

function f(a) {                   // Main function:
 return a.map(                    //  Map through all words:
  function(x) {
   if (i++ & 1)                   //   If i % 2 == 1 (i.e. vertical):
    return [,...x].join(          //    Since the first one needs to have its own linefeed 
                                  //    and indentation, add a dummy item to the start.
     "\n".padEnd(n)               //    Join the array with the padded line feeds.
    );
   else {                         //   If i % 2 == 0 (i.e. horizontal):
    n += x.length;                //    Add the length of this string to the variable that
                                  //    counts how long the padded line feeds should be.
    return x;                     //    Append the string at the end without line feeds.
   }
  },
  n = i = 0                       //   Initialize variables.
                                  //   n: the length of the padded line feeds 
                                  //      (including the line feed)
                                  //   i: keeps track of the direction
 ).join("")                       //  Join all stuffs and return.
}

— शायरु असकोतो
स्रोत

1

स्टैक्स , 12 बाइट्स

ìZΣFτëWº═φ‼R

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

1

जेली , 21 बाइट्स

Ẉm2Ä’x2Ż⁶xⱮṛ;⁷ɗ;ⱮY¥ƭ"

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

एक पूर्ण कार्यक्रम इनपुट को स्ट्रिंग्स की एक सूची के रूप में ले रहा है और स्पष्ट रूप से आउटपुट शब्द सीढ़ी को रोकना है।

— निक केनेडी
स्रोत

1

सी (जीसीसी) , 93 87 बाइट्स

सुझावों के लिए गैस्ट्रोपनर को धन्यवाद।

यह संस्करण NULL पॉइंटर द्वारा समाप्त किए गए स्ट्रिंग्स की एक सरणी लेता है।

c,d;f(s,t)char**s,*t;{for(c=d=0;t=*s++;d=!d)for(;*t;c+=!d)printf("\n%*c"+!d,d*c,*t++);}

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

— ErikF
स्रोत

87 बाइट्स

— गैस्ट्रोपनर

1

ब्रेन-फ्लैक , 152 बाइट्स

<>([()])<>{<>({}<>{()<({}<>)><>}<>)<>{}{<>({}<((()()()()()){})>)({<({}[()]<((((()()()()){}){}){})>)>()}{})<>(({}<>({}))[({}[{}])])<>}{}}<>{}{({}<>)<>}<>

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

मुझे संदेह है कि यह दो छोरों को विषम और यहां तक कि शब्दों के संयोजन से छोटा कर सकता है।

— मजाक कर रहा है
स्रोत

1

इसके लिए शुक्रिया!

— गैलेन इवानोव

1

जे, 35 33 बाइट्स

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y'

यह एक क्रिया है जो रिक्त स्थान द्वारा अलग किए गए शब्दों के साथ इनपुट को एक स्ट्रिंग के रूप में लेती है। उदाहरण के लिए, आप इसे इस तरह कह सकते हैं:

3 :'[;.0>(,|:)&:,.&.>/_98{.;:|.y' 'programming puzzles and code golf'

आउटपुट अक्षरों और रिक्त स्थान का एक मैट्रिक्स है, जो दुभाषिया आवश्यकतानुसार नईलाइन्स के साथ आउटपुट करता है। प्रत्येक पंक्ति को रिक्त स्थान के साथ गद्देदार किया जाएगा ताकि उनकी लंबाई समान हो।

कोड के साथ एक मामूली समस्या है: यदि इनपुट में 98 से अधिक शब्द हैं तो यह काम नहीं करेगा। यदि आप एक लंबे इनपुट की अनुमति देना चाहते हैं, _98तो कोड _998को 998 शब्दों आदि की अनुमति देकर कोड में बदलें ।

मुझे समझाएं कि यह कुछ उदाहरणों के माध्यम से कैसे काम करता है।

मान लीजिए हमारे पास अक्षरों और रिक्त स्थान का एक मैट्रिक्स है जो हम कल्पना करते हैं कि कुछ शब्दों के लिए एक आंशिक उत्पादन होता है, एक क्षैतिज शब्द से शुरू होता है।

   [m=: 3 3$'vwx  y  z'
vwx
  y
  z

इससे पहले, हम एक नया शब्द कैसे प्रस्तुत कर सकते हैं? यह मुश्किल नहीं है: नए शब्द को क्रिया के साथ अक्षरों के एकल-स्तंभ मैट्रिक्स में बदल दें ,., फिर आउटपुट को उस एकल-स्तंभ मैट्रिक्स में जोड़ें। (क्रिया ,.सुविधाजनक है क्योंकि यह एक पहचान फ़ंक्शन के रूप में व्यवहार करता है यदि आप इसे मैट्रिक्स पर लागू करते हैं, जिसे हम गोल्फ के लिए उपयोग करते हैं।)

   (,.'cat') , m
c  
a  
t  
vwx
  y
  z

अब हम इस तरह से किसी शब्द को प्रस्तुत करने के तरीके को पूरा नहीं कर सकते, क्योंकि तब हमें केवल ऊर्ध्वाधर शब्द मिलेंगे। लेकिन अगर हम प्रत्येक चरण के बीच आउटपुट मैट्रिक्स को स्थानांतरित करते हैं, तो हर दूसरा शब्द क्षैतिज होगा।

   (,.'dog') , |: (,.'cat') , m
d     
o     
g     
catv  
   w  
   xyz

तो एक समाधान के लिए हमारा पहला प्रयास प्रत्येक शब्द को एकल-स्तंभ मैट्रिक्स में डालना है, फिर उन्हें बीच में जोड़कर और स्थानांतरित करके उन्हें मोड़ो।

   > (,|:)&.>/ ,.&.>;: 'car house dog children'
c            
a            
r            
housed       
     o       
     g       
     children

लेकिन इसके साथ एक बड़ी समस्या है। यह दाहिने कोण को मोड़ने से पहले अगले शब्द का पहला अक्षर डालता है, लेकिन पहले अक्षर को डालने से पहले विनिर्देश की आवश्यकता होती है, इसलिए आउटपुट कुछ इस तरह होना चाहिए:

c             
a             
rhouse        
     d        
     o        
     gchildren

जिस तरह से हम इसे प्राप्त करते हैं वह पूरे इनपुट स्ट्रिंग को उल्टा करना है, जैसे कि

nerdlihc god esuoh rac

फिर ज़िग-ज़ैग बनाने के लिए उपरोक्त प्रक्रिया का उपयोग करें लेकिन प्रत्येक शब्द के पहले अक्षर के बाद ही मुड़ें:

फिर उत्पादन फ्लिप करें:

   [;.0> (,|:)&.>/ ,.&.>;:|. 'car house dog children'
car   
  h   
  o   
  u   
  s   
  edog
     c
     h
     i
     l
     d
     r
     e
     n

लेकिन अब हमें एक और समस्या है। यदि इनपुट में विषम संख्या में शब्द हैं, तो आउटपुट में पहला शब्द ऊर्ध्वाधर होगा, जबकि विनिर्देश कहता है कि पहला शब्द क्षैतिज होना चाहिए। इसे ठीक करने के लिए, मेरा समाधान 98 शब्दों के लिए शब्दों की सूची को खाली करता है, खाली शब्दों को जोड़ देता है, क्योंकि यह आउटपुट नहीं बदलता है।

— b_jonas
स्रोत

एक शब्द सीढ़ी का निर्माण

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

मानदंड

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

सी (जीसीसी) , 94 78 74 बाइट्स

05AB1E , 19 16 बाइट्स

05AB1E , 14 13 बाइट्स

कैनवस , 17 12 11 10 बाइट्स

जावास्क्रिप्ट (ईएस 8), 91 79 77 बाइट्स

टिप्पणी की गई

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

ब्रेनफक , 57 बाइट्स

स्पष्टीकरण:

जावास्क्रिप्ट, 62 बाइट्स

जावास्क्रिप्ट, 65 बाइट्स

ऐहुई (esotope) , 490 458 455 बाइट्स

व्याख्या

जाप -P , 15 बाइट्स

बैश, 119 चार

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

व्याख्या

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

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

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

जे , 47 45 43 बाइट्स

टी-एसक्यूएल, 185 बाइट्स

रेटिना , 51 बाइट्स

व्याख्या

रेटिना 0.8.2 , 58 बाइट्स

पॉवरशेल , 101 89 83 बाइट्स

पॉवरशेल , 74 65 बाइट्स

आर , 126 बाइट्स

टी-एसक्यूएल, 289 बाइट्स

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

स्पष्टीकरण और अपुष्ट

स्टैक्स , 12 बाइट्स

जेली , 21 बाइट्स

सी (जीसीसी) , 93 87 बाइट्स

ब्रेन-फ्लैक , 152 बाइट्स

जे, 35 33 बाइट्स

जाप `-P` , 15 बाइट्स

जे , ^{47 45} 43 बाइट्स