द एवर एम्प्लिफाइंग ज़िगज़ैग

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है और इस प्रवर्धित ज़िगज़ैग पैटर्न के पहले एन नंबर को आउटपुट करता है, केवल आवश्यक लाइनों का उपयोग करके:

                                         26
                                       25  27                                      .
         10                          24      28                                  .
        9  11                      23          29                              .
 2     8     12                  22              30                          44
1 3   7        13              21                  31                      43
   4 6           14          20                      32                  42
    5              15      19                          33              41
                     16  18                              34          40
                       17                                  35      39
                                                             36  38
                                                               37

तो, अगर N 1आउटपुट है

1

यदि N है 2, तो आउटपुट है

 2
1

यदि N 3आउटपुट है

 2
1 3

यदि N 4आउटपुट है

 2
1 3
   4

यदि N 10आउटपुट है

         10
        9
 2     8
1 3   7
   4 6
    5

यदि N 19आउटपुट है

         10
        9  11
 2     8     12
1 3   7        13
   4 6           14
    5              15      19
                     16  18
                       17

और इसी तरह।

टिप्पणियाँ

• ज़िगज़ैग का प्रत्येक शिखर या गर्त 1पिछले शिखर या गर्त की तुलना में इसके साथ रेखा से दूर एक बिंदु तक पहुँचता है ।

• N तक सीमित नहीं है 44। ज़िगज़ैग उसी पैटर्न में बढ़ता है और बड़े एन का समर्थन किया जाना चाहिए।

• कई अंकों वाले नंबरों को उनके कोनों में केवल "स्पर्श" करना चाहिए, जैसा कि दर्शाया गया है। सुनिश्चित करें कि यह काम तब है जब N 100ऊपर और ऊपर है।

• आउटपुट में कोई खाली (या केवल स्थान) लाइनें नहीं होनी चाहिए, एक वैकल्पिक अनुगामी न्यूलाइन को छोड़कर।

• किसी भी लाइन में किसी भी प्रकार के अनुगामी स्थान हो सकते हैं।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। टाईब्रेकर पहले जवाब है।

Comments

अधिकतम संभव एन क्या है?

— जूली पेलेटियर

@JuliePelletier सिद्धांत में कोई नहीं है, लेकिन आप यह मान सकते हैं कि यह 2 ^ 16 से कम होगा।

— केल्विन के शौक

क्या नियंत्रण वर्णों का उपयोग करने की अनुमति है या क्या हम अंकों के स्थान और लाइनफीड तक सीमित हैं?

— डेनिस

@ डेनिस चलो ना कहते हैं। बस अंक / रिक्त स्थान / newlines।

— केल्विन के शौक

किसी को उस प्रारूप में OEIS को मजाक के रूप में प्रस्तुत करना चाहिए।

— DanTheMan

Answer 1

जेली , 41 37 29 बाइट्स

RDµḌ’½Ċ-*_\x©L€Ṣ.ị®ạ€⁶ẋj"FZj⁷

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

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

RDµḌ’½Ċ-*_\x©L€Ṣ.ị®ạ€⁶ẋj"FZj⁷  Main link. Argument: n (integer)

R                              Range; yield [1, ..., n].
 D                             Decimal; yield A =: [[1], ..., [1, 0], ...].
  µ                            Begin a new, monadic chain. Argument: A
   Ḍ                           Undecimal; convert back to falt range.
    ’                          Decrement to yield [0, ..., n-1].
     ½Ċ                        Take the square root and round up (ceil).
       -*                      Elevate -1 to each rounded square root.
         _\                    Cumulatively reduce by subtraction.
                               This yields [1, 2, 1, 0, -1, 0, ...], i.e., the
                               vertical positions of the digits in A.
             L€                Compute the length of each list in A.
           x                   Repeat the nth position l times, where l is the
                               nth length.
            ©                  Copy the result to the register.
               Ṣ               Sort.
                .ị             At-index 0.5; yield the last and first element,
                               which correspond to the highest and lowest position.
                  ạ€®          Take the absolute difference of each position in the
                               register and the extrema.
                               This yields the number of spaces above and below
                               the integers in r as a list of pairs.
                     ⁶ẋ        Replace each difference with that many spaces.
                         F     Flatten the list A.
                       j"      Join the nth pair of strings of spacing, separating
                               by the nth digit in flat A.
                          Z    Zip/transpose the result.
                           j⁷  Join, separating by linefeeds.

Comments

अपनी भाषा (जेली) में ऐसा फंक्शन क्यों न करें जो आपके पास होने के दौरान कुछ वर्णों में हो सकता है?

— जूली पेलेटियर

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

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

@JuliePelletier और यह भी PPCG एसई के नियमों के खिलाफ जाना होगा

— Bálint

Answer 2

PHP, 211 177 164 163 बाइट्स

आउटपुट कर्सर $nका उपयोग करके, किसी भी दिशा में गतिशील रूप से चोटियों को बढ़ाएं और सरणी को बढ़ाएं ($x, $y)।

संख्याओं के साथ संरेखित किया जाता है str_pad()और अंतिम आउटपुट implode()स्ट्रिंग्स के उस सरणी ( $g) का होता है।

for($x=0,$d=-1,$h=$n=2,$y=$a=1;$a<=$argv[1];$y+=$d){$g[$y]=str_pad($g[$y],$x).$a;$x+=strlen($a);if($a++==$n){$h+=2;$n+=$h-1;$d*=-1;}}ksort($g);echo implode(~õ,$g);

इसे ऑनलाइन टेस्ट करें!

अद्यतन: हटाए गए सरणी_पैड () से छुटकारा पाकर 34 बाइट्स निकाले। Update2: @ insertusernamehere की सलाह के बाद इसे थोड़ा और छोटा करने की सलाह दी। Update3: ~ with के साथ एक और बाइट को बचाने के लिए @ लिन की सलाह का पालन किया जो IN LATIN-1 चारसेट के उपयोग को रोकता है। (ऑनलाइन PHP एमुलेटर में उपलब्ध नहीं है इसलिए वहां शामिल नहीं है)

Comments

इस कोड के बारे में बस एक सवाल .. क्या आपको किसी विशिष्ट तत्व तक पहुँचने से पहले सरणी $ g को इनिशियलाइज़ नहीं करना है? मेरा मतलब है, इसे लंबाई देना या पंक्तियों को सम्मिलित करना? मैं PHP के साथ बहुत अनुभवी नहीं हूं, इसलिए यह सिर्फ मुझे अजीब लगता है ... धन्यवाद।

— यॉटम साल्मन

एक बार जब आप परिभाषित करते हैं $arr = [];, तो आप इसका उल्लेख कर सकते हैं $arr[anything]। कुछ मामले नोटिस का उत्पादन करेंगे, लेकिन उन पर ध्यान नहीं दिया जाता है। ध्यान दें कि इस तरह से सामान पढ़ना शायद आपको भाषा सीखने में बहुत मदद नहीं करेगा। आपकी टिप्पणी ने मुझे एहसास दिलाया कि मैं इसे छोटा बना सकता हूं, क्योंकि जैसा कि मैंने शुरू में सोचा था कि मुझे अपनी सरणी को पैड करने की आवश्यकता होगी, लेकिन मैं नहीं करता। :)

— जूली पेलेटियर

Haha मदद करने के लिए खुश;) बस एहसास हुआ कि PHP में एक सरणी और एक शब्दकोश को एक ही तरह से आरम्भ किया गया है और वाक्यविन्यास (Why, PHP ?!) को देखते हुए पूरी तरह से एक जैसे हैं

— Yotam Salmon

कुछ मामूली सुधार - 164 बाइट्स : for($x=0,$d=-1,$h=$n=2,$y=$a=1;$a<=$argv[1];$y+=$d){$g[$y]=str_pad($g[$y],$x).$a;$x+=strlen($a);if($a++==$n){$h+=2;$n+=$h-1;$d*=-1;}}ksort($g);echo implode("⏎",$g);(⏎ एक वास्तविक न्यू लाइन के साथ बदलें।)

— insertusernamehere

मेरा मानना ​​है कि यदि आप अपना एन्कोडिंग सही सेट करते हैं (लैटिन -1, यूटीएफ -8 नहीं), ~õतो दो-बाइट विकल्प है "⏎"।

— लिन

Answer 3

Pyth, 60 53 52 46 42 39 38 36 34 32 31 बाइट्स

39: यह अब जेली के बग-फिक्स्ड संस्करण के साथ सम्‍मिलित है, और मेरे पास आउट-गोल्‍ड डेनिस प्रतियोगिता है!

38: मैं बाहर गोल्फ की डेनिस है!

36: मैंने फिर से डेनिस को बाहर कर दिया है!

34: उसके बग-फिक्स्ड संस्करण से भी कम!

31: 32 -> 31 डेनिस के लिए धन्यवाद।

J1K.u+N=J_WsI@Y2JtQZjsM.t.e ++ *] * dl`hkabhSK`hk *] * dl`hkabeSKKd 
J1K.u+N=[e-mail] *] * dl`hkhaeSKhSKabhSKhkKd 
J1K.u + N=J_WsI@Y2JtQZ=-RhSKKjsM.t.eX *] * dl`hkheSKbhkKd 
J1K.u+N=J_WsI@Y2JtQQj-#dsMC.eX *] * dl`hkheSKbhkK 
J1j- # dsMC.eX *] * dl`hkyQ + Qbhkm = + Z = J_WsI @ td2J 
J1j- # dsMCmm * *] *; l`hdyQ + Q = + Z = J_WsI @ 
td2Jhd # 5j- # dsMCmX *] *; l`hdyQ + Q = + Z_WdyI @ 
td2J - # dsMCmX *] *; l`hdyQ + Q = + Z = @ _ BJsI @ td2h 
j- # dsMCmX *] *; l`hdyQ + Q = + Zsty s s @ td2 2h 
j- # dsMCmX *] *; l; `hdyQ + Q = + Z @ _B1.E @ d2h 
JQj- # dsMCmm * *]; l`hdyQ = + J @ _B1.E @ d2h 
JyQj- [dsMCmX *] *; l`hdJ = + Q @ _B1। E @ d2h 
j- # dsMCmX *] *; l`hdyQ = + Q @ _B1.E @ d2h
जम्मू # dsMCmX *] *; l`hdyQ=+Q^_1.E@d2h

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

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

j-#dsMCmX*]*;l`hdyQ=+Q^_1.E@d2h      input: Q
j-#dsMCmX*]*;l`hdyQ=+Q^_1.E@d2hdQ    implicit filling arguments

       m                        Q    for each number d from 0 to Q-1:
                           @d2           yield the square root of d.
                         .E              yield its ceiling.
                      ^_1                raise -1 to that power. this
                                         yields the desired direction.
                   =+Q                   increment Q by this amount.

               hd                        yield d+1.
              `                          yield its string representation.
             l                           yield its length.
           *;                            repeat " " for that number of times
          ]                              yield a list containing the string above.
         *       yQ                      repeat the list for Q*2 times.
                                         the Q has changed, but Q*2 is
                                         an overshoot that is high
                                         enough, so we don't have to
                                         worry about it.

        X                                in that list, replace the
                                         element with index being the
                                         number generated above
                              hd         with d+1.

      C                              transpose the resulting array.
    sM                               flatten each element.
 -#d                                 remove lines containing only spaces.
                                     (filter on truthiness of set difference with space)
j                                    join by newlines.

Comments

" 39: जेली के साथ बराबर "; " 38: मैंने डेनिस को बाहर कर दिया है! " कुछ घंटों के लिए आपने किया था, लेकिन ऐसा लग रहा है कि @ डेनिस कोड-गोल्फिंग में बाजी मारना पसंद नहीं करता है: जेली 37 बाइट्स ;)

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

@ केविनक्रूजसेन किया।

— लीक नून

अच्छा! xD M̶aDy̶b̶e̶ मेरे पास एक जंगली कल्पना है, लेकिन अब मुझे लगता है कि आपने देखा है और घंटों तक निराशा में देखा है जब तक कि आप अंत में इस छोटे से समाधान को नहीं ढूंढ पाए, और अब @ डेनिस लापरवाही से जाग जाएगा और फिर से अपने कोड को छोटा कर देगा। (Jk, मुझे आशा है कि आप डेनिस से नीचे

— रहेंगे

@ केविनक्रूजसेन टाडा! यह अब बग-फिक्स्ड संस्करण से कम है।

— लीक नून

Answer 4

MATLAB, 148 बाइट्स

n=input('');k=fix(n^.5);m=0;w=1;d=-1;for l=1:n;s=num2str(l);m(k+1,w:w+nnz(s)-1)=s;w=w+nnz(s);k=k+d;d=d*(-1)^(l^.5==fix(l^.5));end;[m(any(m,2),:),'']

ध्यान दें कि रिक्त स्थान ओक्टेव में गायब हैं, क्योंकि MATLAB 0एक स्थान के रूप में अनुक्रमित वर्ण को प्रिंट करता है, जबकि ऑक्टेव उस चरित्र को छोड़ देता है।

स्पष्टीकरण:

n=input('');
k=fix(n^.5);                    %caculate starting height
m=0;w=1;d=-1;                   %initialize counters and output matrix
for l=1:n;
    s=num2str(l);
    m(k+1,w:w+nnz(s)-1)=s;      %insert current index as a string
    w=w+nnz(s);                 %current horizontal position
    k=k+d;                      %current vertical position
    d=d*(-1)^(l^.5==fix(l^.5)); %if we reached a square number, change direction
end
[m(any(m,2),:),'']              %delete all zero rows

Answer 5

हास्केल, 144 142 बाइट्स

g n|k<-take n$scanl(+)0$[1..]>>= \x->(-1)^x<$[2..2*x]=unlines[[1..n]>>= \x->show x#(k!!(x-1)==y)|y<-[minimum k..maximum k]]
s#g|g=s|1<2=' '<$s

उपयोग उदाहरण:

*Main> putStr $ g 19
         10                  
        9  11                
 2     8     12              
1 3   7        13            
   4 6           14          
    5              15      19
                     16  18  
                       17    

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

s#g|g=s|1<2=' '<$s              -- # is a helper function that expects a string s
                                -- and a boolean g. It returns s if g is True, else
                                -- as many spaces as there a characters in s 

k<-take n$                      -- bind k to the first n elements of
 [1..]>>= \x->(-1)^x<$[2..2*x]  -- 2*x-1 copies of (-1)^x for each x in [1,2,3,...]
                                -- i.e. [-1, 1,1,1, -1,-1,-1,-1,-1, 1,1,1,1,1,1,1..]
 scanl(+)0                      -- build partial sums, starting with 0
                                -- i.e. [0,-1,0,1,2,1,0,-1,-2,-3,-2,-1...]
                                -- -> k is the list of y coordinates for the
                                --    numbers 1,2,3,...

 [  |y<-[minimum k..maximum k]] -- for all y coordinates in k 
      \x->show x#(k!!(x-1)==y)  -- map the # function
  [1..n]>>=                     -- over [1..n] (the x coordinates)
                                -- where # is called with
                                --  s -> a string representation of x 
                                --  g -> True if k at index x equals the current y
unlines                         -- join with newlines

संपादित करें: धन्यवाद @ बाइट दो बाइट्स के लिए!

Answer 6

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

with(Math)n=>(a=[...Array(n)].map((_,i)=>n-=1+sqrt(--i)&1||-1).map((e,_,a)=>e-min(...a))).map((e,i)=>r[e][i]=++i,r=[...Array(1+max(...a))].map(_=>a.map((_,i)=>` `.repeat(1+log10(++i)))))&&r.map(a=>a.join``).join`\n`

जहां \nएक शाब्दिक न्यूलाइन चरित्र का प्रतिनिधित्व करता है। स्पष्टीकरण:

with(Math)                          Bring functions into scope
 n=>                                Accepts one parameter
  (a=                               Intermediate result variable
   [...Array(n)].map(               For each number 0..n-1
    (_,i)=>n-=                      Accumulate index for each number
     1+sqrt(--i)&1||-1              Calculate the direction
    ).map((e,_,a)=>e-min(...a))     Scale the smallest index to zero
  ).map((e,i)=>r[e][i]=++i,         Overwrite the padding with 1..n
   r=[...Array(1+max(...a))].map(   Calculate number of lines
    _=>a.map((_,i)=>                For each number 1..n
     ` `.repeat(1+log10(++i)))))    Calculate the padding needed
  &&r.map(a=>a.join``).join`\n`     Join everything together

इसे छोटा करने के लिए pow(-1,ceil(sqrt(i)))मैं इसे फिर से लिखता हूं क्योंकि यह ठीक करने के sqrt(i-1)&1||-1लिए काम नहीं करता है i=0कि मैं 1 जोड़ देता हूं लेकिन इसके बाद परिणाम का संकेत फ़्लिप होता है यही कारण है कि मैं इसके साथ समाप्त होता हूं n-=।

Comments

अरे, तुम एक सोने का बिल्ला मिला! अच्छी नौकरी! और पवित्र धूम्रपान करता है कि आप लगभग उतना ही प्रतिनिधि है जितना मैं करता हूं। चलते रहने दो!

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ यह "केवल" कट्टरपंथी बिल्ला है। जाहिरा तौर पर मैं वास्तव में गोल्ड कोड-गोल्फ टैग बैज पाने के करीब हूं!

— नील

डबल पवित्र धूम्रपान। मुझे XD

— कॉनर ओ'ब्रायन

Answer 7

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

l={}
i=x=y=n=v=0
exec"v+=1;l[y]=l.get(y,'').ljust(x)+`v`;x+=len(`v`);i=-~i%-~n;y+=n%4-1;n+=2>>i*2;"*input()
for k in sorted(l):print l[k]

आइडोन पर आउटपुट देखें ।

Comments

हम्म ... यह और पर और पर और पर जाना नहीं है।

— Zizouz212

@ Zizouz212 यह करता है, विचारधारा बस के साथ एक निश्चित उत्पादन है और स्वचालित रूप से बहुत लंबी है कि लाइनों को तोड़ता है।

— 13:25 बजे दोष