धीरे-धीरे ज़िगज़ैग जुटाना

Question

इनपुट के रूप में एक एकल सकारात्मक विषम पूर्णांक को देखते हुए, इस रूप में स्ट्रिंग की एक सूची, वर्णों की सूची, या न्यूलाइन-पृथक स्ट्रिंग के रूप में एक परिवर्तित ज़िगज़ैग लौटाएं:

#
 #
  #
   #
    #
   #
  #
 #
  #
   #
  #

आप #किसी भी गैर-व्हाट्सएप चरित्र के साथ बदल सकते हैं । प्रत्येक लाइन पर ट्रेलिंग व्हाट्सएप की अनुमति है और एक अनुगामी न्यूलाइन की अनुमति है।

ज़िग-ज़ैग कॉलम पर शुरू होता है 1और प्रत्येक पंक्ति के लिए एक कॉलम सही चलता है, जब तक कि यह कॉलम तक नहीं पहुंचता n(जहां nइनपुट है)। फिर, यह बाएं ओर जाता है 2, फिर दाएं n-1, फिर बाएं ओर 3, दो सीमा के साथ तब तक परिवर्तित होता है जब तक कि बीच के कॉलम ( (n+1)/2) में ज़िगज़ैग समाप्त न हो जाए ।

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

उपरोक्त उदाहरण के लिए परीक्षण का मामला है 5।

निम्नलिखित व्यक्ति परीक्षण मामले हैं:

3
#
 #
  #
 #

7
#
 #
  #
   #
    #
     #
      #
     #
    #
   #
  #
 #
  #
   #
    #
     #
    #
   #
  #
   #
    #
   #

1

#

Comments

क्या अग्रणी (लेकिन सुसंगत यानी आकार नहीं तोड़ने वाला) व्हाट्सएप की अनुमति है?

— आउटगॉल्फ जूल

@EriktheOutgolfer मैं उसके लिए नहीं कहने जा रहा हूं।

— १२:२६ पर HyperNeutrino

Answer 1

सी (जीसीसी) , 89 बाइट्स

f(n,a,b){puts("0");for(a=n;--a>n/2;)for(b=n-2*a;b<=2*a-n;)printf(" %*d\n",a-abs(b++),0);}

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

के रूप में रिक्त स्थान की संख्या के अनुक्रम का विश्लेषण करके काम करता है (एन = 7 के लिए):

          0
1 2 3 4 5 6 5 4 3 2 1
    2 3 4 5 4 3 2
        3 4 3

और n = 3 के लिए:

  0
1 2 1

हम देख सकते हैं कि मध्य संख्या ( aकोड में) [n-1, n / 2] से चलती है। फिर, पहली संख्या और मध्य संख्या के बीच का अंतर है:

a  n  b  2a-n
-------------
6  7  5  5
5  7  3  3
4  7  1  1
2  3  1  1

इसलिए, अगर हम b[- (2a-n), 2a-n] से गुजर रहे हैं, तो a-abs(b)हमें वांछित अनुक्रम मिलेगा। यह अनिवार्य रूप से कोड क्या करता है।

Answer 2

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

ＦＮ«↗ι‖»/

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: सहेजे गए 2 बाइट्स @dzaima को इंगित करने के लिए कि मुझे #s का उपयोग करने की आवश्यकता नहीं है ।

Comments

अंत में, जेली

— जुंगह्वान मिन

Answer 3

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

l=range(1,input())
print 8
for i in l:
 for i in l:print' '*i+'8'
 l=l[-2::-1]

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

Answer 4

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

ṖṖṚ$ÐĿẎ0;⁶ẋp1Y

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

पूरा कार्यक्रम।

उपयोग करता है 1।

-1 जोनाथन एलन को धन्यवाद ।
-1 जोनाथन एलन को धन्यवाद ।

Comments

’R-> Ṗएक बाइट के लिए।

— जोनाथन एलन

@JonathanAllan Ooh बेशक धन्यवाद। मैंने पहले

— वाले जेल

”X-> 1दूसरे के लिए।

— जोनाथन एलन

@JonathanAllan हेह ने स्पष्ट रूप से एक और अनदेखी की ... मैंने पूर्णांक से भी बचने की कोशिश की।

— आउटगोल्फ जूल

Answer 5

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

g[]=[]
g a=a++g(reverse$init a)
r="#":map(' ':)r
("#":).g.tail.(`take`r)

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

हम एक अपरिमित सूची को परिभाषित करते हैं जो ऊपरी बाएँ हाथ के कोने से शुरू rहोने वाली विकर्ण है #।

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

यहां हमारा मुख्य कार्य एक बिंदु-मुक्त कार्य है। यह फ़ंक्शन nअनंत सूची से तत्वों को लेने से शुरू होता है r, यह पहले तत्व की चॉप करता है और लागू होता है g। अंतिम बार हमें #शुरुआत में वापस जोड़ना होगा , ऐसा इसलिए है क्योंकि प्रश्न के लिए चश्मा थोड़ा अजीब है, मुझे यकीन नहीं है कि पहला विकर्ण हमेशा एक से अधिक लंबा क्यों होना चाहिए लेकिन यह होना चाहिए, इसलिए हमें करना होगा आ जोड़ #।

Comments

@ नमि मैं समाप्त कर ("#":).g.init.(ले, r)लेकिन धन्यवाद!

— गेहूं जादूगर

Answer 6

SOGL V0.12 , 19 बाइट्स

┘.»∫«I╝:±jk+jl0;±Iž

यह कोशिश करो!

Answer 7

05AB1E , 22 बाइट्स

i8ë<LZFD¨R})˜0¸ìε8sú}»

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

उपयोग करता है 8।

Answer 8

05AB1E , 6 बाइट्स

LN71SΛ

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

     Λ     use the canvas function with

L          a range list [1 .. input] as lengths for each path 

 N         a "0" as character to be printed 
           (N is the index variable used by loops. If there was no loop yet, its
           default value is 0. By using N, I avoid an extra space between 0 and 71)

  71S      and the directions 7 and 1 (NW and NE), that alternate automatically until
           the range list is finished.

Comments

नहीं, मैंने कोशिश की कि पहले, लेकिन यह दोनों दिशाओं को खींचता है, इससे पहले कि यह सीमा सूची के अगले तत्व के साथ जारी रहे, जब मैं हटाता हूं S। तो आउटपुट दोगुना हो जाएगा। मुझे अभी तक + और × के बारे में पता नहीं था। वे वास्तव में दिलचस्प पैटर्न बनाते हैं जब आप उन्हें संख्याओं के साथ जोड़ते हैं

— डोरियन

आह, तुम वास्तव में सही हो। मेरी गलती। मैं इसे बिना काम देखा Sहै, लेकिन उत्पादन करने के लिए पर्याप्त ध्यान दिया नहीं था ..>।> और +और ×के लिए मूल रूप से builtins हैं [0,4,4,0,2,6,6,2]और [1,5,5,1,3,7,7,3]। और 8उस मूल पर रीसेट कर देंगे जहां से आपने शुरुआत की थी। यहाँ थोड़ी और जानकारी।

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

Answer 9

सीजेएम , 29 बाइट्स

ri,(;_,{_);W%}*]e_0\+Sf*8f+N*

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

उपयोग करता है 8।

Answer 10

पायथ, 23 बाइट्स

8JStQKdVQjbm+*\ d8J=_PJ

इसे यहाँ आज़माएँ।

Answer 11

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

gप्राप्त करने के लिए लक्ष्य ( ) की गणना करता है। जब यह लक्ष्य पूरा हो जाए, तो अगले लक्ष्य की ओर मुड़ें। हर असमान संख्या को Math.round()जोड़कर उपयोग करने से बचने के लिए एक चाल का उपयोग करता है 0.5।

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f=n=>{c=0;for(i=0;i<n;i++){m=i/2;g=i%2==0?n-m:m+1.5;while(c!=g){c>g?c--:c++;console.log(' '.repeat(c-1)+'#'+' '.repeat(n-c))}}}

f(5);

Answer 12

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

f[x]=[x]
f s=s++tail(f$reverse$tail s)
g n=f[(' '<$[2..x])++"#"|x<-[1..n]]

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

यह काम किस प्रकार करता है:

    [(' '<$[2..x])++"#"|x<-[1..n]]     -- build the first diagonal, e.g. for n=3:
                                         -- ["#", " #", "  #"]
  f                                      -- call f, which is

f s = s ++                               -- the input list, followed by
           tail                          -- all but the first element of
                f                        -- a recursive call with
                  reverse                -- the reverse of
                          tail s         -- all but the first element of the input 
                                         -- list
f[x]=[x]                                 -- base case: stop if the input list a
                                         -- singleton list

प्रत्येक पुनरावर्ती कॉल fअगले विकर्ण को जोड़ता है।

Comments

कुछ दोस्ताना प्रतियोगिता ।

— गेहूं जादूगर

Answer 13

हस्क , 19 बाइट्स

mo`:'#R' ∫`Ṙ¢e1_1tṫ

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

व्याख्या

यह थोड़ा क्लंकी लगता है।

mo`:'#R' ∫`Ṙ¢e1_1tṫ  Input is n (e.g. 5)
                  ṫ  Range from input to 1: [5,4,3,2,1]
                 t   Drop first element: [4,3,2,1]
             e1_1    The list [1,-1]
            ¢        repeated infinitely: [1,-1,1,-1,..
          `Ṙ         Clone with respect to the list above: [1,1,1,1,-1,-1,-1,1,1,-1]
         ∫           Cumulative sum: [0,1,2,3,4,3,2,1,2,3,2]
mo                   For each element k (e.g. 3) do this:
      R'             Repeat space k times: "   "
  `:'#               Append '#': "   #"
                     Print implicitly separated by linefeeds.

Answer 14

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

def z(n):l=range(1,n);print(8);exec("[print(' '*i+'8')for i in l];l=l[-2::-1];"*n)

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

Answer 15

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

.+
$* 
^
:>
 $
:
;{*T`:<>`_#
( ) >(:)|( )<
$1<$2$3
(:)( )<|>( )
$2$1$3>

इसे ऑनलाइन आज़माएं! स्पष्टीकरण: पहले तीन चरण इनपुट को उस रूप में परिवर्तित करते हैं, :> :जहां :s के बीच वर्णों की संख्या इनपुट संख्या होती है। अंतिम दो चरणों के बाद >(या <, जब बाईं ओर बढ़ते हैं) को उछालें :। चौथा चरण प्रत्येक बार स्ट्रिंग के आवश्यक भागों को प्रिंट करते हुए उछाल को ढीला करता है। ;पाश के बाद मुद्रित किया जा रहा से स्ट्रिंग बंद हो जाता है।

Answer 16

05AB1E , 16 बाइट्स

Î<L¤F¦})˜Ôð×X«»

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

व्याख्या

Î<L               # push 0 and range [1 ... input-1]
   ¤              # get the last element of the list
    F             # that many times do
     Â            # bifurcate
      ¦           # remove the head
       })˜        # end loop and wrap in flattened list
          Ô       # remove consecutive duplicates
           ð×     # repeat space a number of times corresponding to each number in the list
             X«   # append 1 to each
               »  # join on newline

Answer 17

के (कोना), 27 बाइट्स

`0:{|x$"#"}'1,,/{1_|x}\-2-!

खाली होने तक वेक्टर के सिर को बार-बार उलट-पलट कर अंतर्निहित संख्यात्मक अनुक्रम का उत्पादन करता है।

Comments

PPCG.SE में आपका स्वागत है! बस इतना पता है, आप अपने कोड को TIO नामक एक ऑनलाइन दुभाषिया में डाल सकते हैं (इसे ऑनलाइन प्रयास करें) और इससे लिंक करें ताकि लोग आपके कोड को आज़मा सकें। tio.run/#k-kona यह आपको यहां सबमिट करने के लिए एक स्वरूपित PPCG पोस्ट भी प्रदान करेगा।

— नॉट्स 90

Answer 18

PHP, 65 बाइट्स

<?while(--$n||$n=$d=--$argn)echo str_pad("X
",2+$x-=$d&1?:-1);?>X

ऑनलाइन के साथ पाइप के रूप में चलाएं -nFया इसका परीक्षण करें ।

स्पष्टीकरण:

पहली यात्रा: $nहै NULL, तो --$nकोई प्रभाव नहीं है और करने के लिए मूल्यांकन करता है NULL
-> सेट $nऔर $dकरने के लिए पहले से कम कर तर्क
1. वेतन वृद्धि $xभी के लिए $dअजीब के लिए, घटती $d
2. प्रिंट X, एक नई पंक्ति और $xरिक्त स्थान

आगे पुनरावृत्तियों: क्षय $n; जब यह हिट हो जाता है 0, तो पूर्व-विघटित तर्क को रीसेट करें $n(और $d)

समापन: एक और प्रिंट करें X।

Answer 19

जाप , 31 बाइट्स

Ç+V ç +QÃê ¯-2 c´U?ß´UVÄ :Vç +Q

पुनरावर्ती समाधान जो लाइनों की एक सरणी लौटाता है।

इसे ऑनलाइन आज़माएं! -Rnewlines के साथ आउटपुट में शामिल होने के लिए ध्वज का उपयोग करना ।

Answer 20

पायथन 2, 159 145 141 136 बाइट्स

print"".join([" "*p+"#\n"for p in(lambda l:[sum(l[:i])for i in range(len(l))])(sum([i*[1-i%2*2]for i in range(input())[::-1]],[])+[1])])

इस समस्या के लिए पहले से ही बहुत अच्छे पायथन संस्करण हैं, लेकिन मुझे लगा कि मैं अभी भी अपने भयानक वन-लाइनर को पोस्ट करूंगा। (हालांकि अर्धविराम के बिना!)

संपादित करें: डबल सूची समझ के बजाय राशि का उपयोग करते हुए, 14 बाइट्स नीचे

संपादित करें: बस अजगर 2 में देखा गया है आप कच्चे_इनपुट के बजाय इनपुट का उपयोग कर सकते हैं। मैंने हमेशा केवल बाद का उपयोग किया है।

Answer 21

गणितज्ञ, 142 102 बाइट्स (स्वतंत्र)

इस घोल में मैथी का स्वाद है:

UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&

यह मूल रूप से गणना करता है कि हम किस सेगमेंट में हैं (त्रिकोणीय संख्या फ़ंक्शन को सम्मिलित करके) और फिर -1 की शक्ति जोड़कर बाएं या दाएं घूम रहे हैं।

आप इसे कोड को चिपकाकर UnitVector[#,1-Sum[(-1)^Floor[#+1/2-Sqrt[9/4+#*#-#-2x]],{x,k}]]~Table~{k,0,#(#-1)/2}/.{0->" ",1->"X"}&@6//MatrixFormऔर Shift + Enter या Numpad Enter या दबाकर गियर -> "मूल्यांकन सेल" पर क्लिक करके वुल्फराम कोड सैंडबॉक्स पर परीक्षण कर सकते हैं ।

---

यह एरिक के पायथन 2 समाधान के मेरे मूल गलत पोर्ट के समान लंबाई का होता है (यह पोर्ट किसी इनपुट के उच्चतर आउटपुट देता है):

(Print[X];l=Range@#;Do[Do[Print[StringRepeat[" ",l[[j]]]<>"X"],{j,Length@l}];l=l[[-2;;1;;-1]],{i,#}])&