बीच में बाधाओं के साथ सम अंकों का चक्रीय अनुक्रम

13

निम्नलिखित अनुक्रम पर विचार करें:

1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 0, 1, ...

सम अंक 0 से शुरू होते हैं और बढ़ती लंबाई के रन में समूहीकृत होते हैं। उन्हें चक्रीय रूप से व्यवस्थित किया जाता है, जिसका अर्थ है कि वे 8 तक पहुंचने तक आरोही क्रम में क्रमबद्ध होते हैं , और फिर 0 से वापस साइकिल चलाए जाते हैं । 1 अंक के रनों को भी अलग करता है, और यह क्रम भी शुरू करता है। आइए कल्पना करें कि यह क्रम कैसे बनता है:

                 1, 0, 1, 2, 4, 1, 6, 8, 0, 1, 2, 4, 6, 8, 1, 0, 2, 4, 6, 8, 1,  ...

                    -     ----     -------     ----------     -------------
run length:         1      2          3            4                5            ...
position of 1:   X     X        X           X              X                 X   ...
even sequence:      0,    2, 4,    6, 8, 0,    2, 4, 6, 8,    0, 2, 4, 6, 8      ...

स्वीकार्य इनपुट और आउटपुट तरीके:

  • इनपुट के रूप में एक पूर्णांक एन प्राप्त करें और इस अनुक्रम के एन वें शब्द को आउटपुट करें ।

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

  • क्रम को अनिश्चित काल के लिए प्रिंट करें।

आप पहले दो तरीकों के लिए या तो 0 या 1-इंडेक्सिंग चुन सकते हैं।

आप मानक इनपुट और आउटपुट विधियों का उपयोग करते हुए, किसी भी प्रोग्रामिंग भाषा में प्रतिस्पर्धा कर सकते हैं । मानक खामियों को मना किया जाता है। यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है।

code-golf  math  number  sequence 
— मिस्टर एक्सकोडर
स्रोत
इस चुनौती को सैंडबॉक्स किया गया है ।
— श्री एक्सकोडर

जवाबों:

8

हास्केल , 50 46 बाइट्स

1#cycle[0,2..8]
n#r=1:take n r++(n+1)#drop n r

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

1#cycle[0,2..8] अनुक्रम को अनंत सूची के रूप में लौटाता है।

-4 बाइट्स धन्यवाद अर्जन जोहान्सन के लिए!

— Laikoni
स्रोत
1
आप #सिर्फ एक नंबर का पहला तर्क देकर चार बाइट्स बचा सकते हैं । इसे ऑनलाइन आज़माएं!
— अर्जन जोहान्सन
7

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

5ḶḤṁR€1pFḣ

अनुक्रम के पहले n आइटम देता है ।

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

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

5ḶḤṁR€1pFḣ  Main libk. Argument: n

5           Set the return value to 5.
 Ḷ          Unlength; yield [0, 1, 2, 3, 4].
  Ḥ         Unhalve; yield [0, 2, 4, 6, 8].
    R€      Range each; yield [[1], [1, 2], [1, 2, 3], ..., [1, ..., n]].
   ṁ        Mold; in the result to the left, replace [1] with [0], [1, 2] with
            [2, 4], [1, 2, 3] with [6, 8, 0], and so forth.
      1p    Take the Cartesian product of [1] and the result.
        F   Flatten the result.
         ḣ  Head; take the first n items of the result.
— डेनिस
स्रोत
2
Is_ UnhalveIs ... कि बस नहीं है Double?
— बजे मिस्टर एक्सकोडर
4
यह सिर्फ एक महामारी है। Hहै Halve , इसलिए Ḥहै unhalve । ÆAहै कोटिकोज्या , इसलिए ÆẠहै unarccosine ।
— डेनिस
6

भूसी , 12 11 10 बाइट्स

ṁ:1CN¢mDŀ5

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

अनुक्रम को अनिश्चित काल तक प्रिंट करता है।

वैकल्पिक रूप से:

J1CΘN¢mDŀ5

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

व्याख्या

        ŀ5   Start from [0, 1, 2, 3, 4]
      mD     Double each value to get [0, 2, 4, 6, 8]
     ¢       Repeat this list indefinitely, [0, 2, 4, 6, 8, 0, 2, ...]
   CN        Cut it into chunks of increasing lengths, 
             [[0], [2, 4], [6, 8, 0], ...]
ṁ:1          Prepend 1 to each sublist and concate the resulting lists.

वैकल्पिक समाधान के लिए:

     ¢mDŀ5   Again, get [0, 2, 4, 6, 8, 0, 2, ...].
  CΘN        This time we prepend a zero to the natural numbers, which
             prepends an empty list to the resulting chunks.
J1           Join all the sublists with 1.

हम यह भी कर सकते हैं ...ΘCN..., क्योंकि Θ"डिफ़ॉल्ट तत्व को प्रीपेंड करता है", जो पूर्णांकों की सूचियों के लिए एक शून्य और सूचियों की सूची के लिए एक खाली सूची बनाता है।

— मार्टिन एंडर
स्रोत
2

एपीएल, 25 बाइट्स

नौवां कार्यकाल लौटाता है।

1,(⌽n↑⌽(+/⍳n←⎕)⍴0,2×⍳4),1

व्याख्या

n←⎕     Prompts for screen input of integer
+/⍳      Creates a vector of integers of 1 to n and sums
⍴0,2×⍳4  Creates a vector by replicating 0 2 4 6 8 to the length of sum
⌽n↑⌽   Rotates the vector, selects first n elements and rotates result
        (selects last n elements}    
1,...,1 Concatenates 1s in front and behind result
— ग्राहम
स्रोत
2

एपीएल (डायलॉग यूनिकोड) , 52 59 56 बाइट्स

r←c k
r←~n←0
:For j :In ⍳k
n+←j-1
r,←1,⍨j⍴n⌽0,2×⍳4
:End
r←k⍴r

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

यह एक परंपरा है ( पारंपरिक itional f unctio n ) एक तर्क लेने kऔर kअनुक्रम की पहली वस्तुओं को वापस करने के लिए।

समारोह में त्रुटि की ओर इशारा करने के लिए @GalenIvanov को धन्यवाद। 3 बाइट्स के लिए @ Adám को धन्यवाद।

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

r←c k             ⍝ The function c takes the argument k and results in r
r n←1 0           ⍝ Initializing the variables r and n, and setting them to 1 and 0, respectively.
:For j :In ⍳k     ⍝ For loop. ⍳k yields [1, 2, 3, ..., k], and j is the control variable.
n+←j-1            ⍝ Accumulates j-1 into n, so it follows the progression (0, 1, 3, 6, 10, 15...)
r,←1,⍨j⍴n⌽0,2×⍳4  ⍝ This line is explained below.
:End              ⍝ Ends the loop
r←k⍴r             ⍝ return the first k items of r.
                  ⍝ ⍴ actually reshapes the vector r to the shape of k;
                  ⍝ since k is a scalar, ⍴ reshapes r to a vector with k items.
            2×⍳4  ⍝ APL is 1-indexed by default, so this yields the vector 2 4 6 8
          0,      ⍝ Prepend a 0 to it. We now have 0 2 4 6 8
        n⌽        ⍝ Rotate the vector n times to the left.
      j⍴          ⍝ Reshape it to have j items, which cycles the vector.
   1,⍨            ⍝ Append a 1, then
r,←               ⍝ Append everything to r.

नीचे एक Dfn( d irect f unctio n ) और एक टैसिट फ़ंक्शन है जो चुनौती को भी हल करता है, दोनों ही @ Mám द्वारा प्रदान किए जाते हैं।

— जे। सल्ल
स्रोत
मुझे टैसिट वेसरियन के स्पष्टीकरण में दिलचस्पी है। धन्यवाद!
— गेलन इवानोव
@GalenIvanov मैं आज एक बाद में जोड़ूंगा।
— २०:५२ पर जे। सेले
मैंने देखा कि 3 फ़ंक्शन गलत उत्तर देते हैं - परवर्ती हमेशा 1 के बाद 0 से शुरू होती हैं - उन्हें पिछले ईवेंट के अंतिम अंक से भी जारी रखना चाहिए।
— गेलन इवानोव
@GalenIvanov तुम सही हो। मैं देखूंगा कि क्या मैं इसे ठीक कर सकता हूं और आज स्पष्टीकरण जोड़ सकता हूं।
— जे। सल्ल।
1

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

0, अनुक्रमित के एन वें शब्द को लौटाता है।

n=>(g=e=>n--?g(e+=k++<l?2:k=!++l):k<l?e%10:1)(k=l=0)

डेमो

कोड स्निपेट दिखाएं

— Arnauld
स्रोत
1

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

i;j;f(){for(i=1;;i++){printf("%d ",1);for(j=0;j<i;)printf("%d ",(2*j+++i*i-i)%10);}}

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

एक फ़ंक्शन ( f()) जो अनुक्रम को अनंत रूप से प्रिंट करता है, रिक्त स्थान द्वारा अलग किया जाता है।

i वर्तमान समान अवधि की लंबाई है।

j वर्तमान में भी सूचकांक सूचकांक है

(2*j+++i*i-i)%10 सही संख्या भी देता है, दिया गया i और j (और वेतन वृद्धि j), ((j + Tr (i))% 5) * 2 के बराबर, जहाँ Tr (x) x त्रिकोणीय संख्या है (जो कि सम संख्या है) संख्या जो वर्तमान से पहले भी मुद्रित हो चुकी है;

— pizzapants184
स्रोत
— सीलिंगकैट
1

जावा 8, 96 बाइट्स

v->{for(int i=0,j=-2,k;;i++,System.out.println(1))for(k=0;k++<i;System.out.println(j%=10))j+=2;}

अनिश्चित काल तक प्रिंट करता है, एक नई लाइन पर प्रत्येक संख्या।

स्पष्टीकरण:

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

v->{                               // Method with empty unused parameter and no return-type
  for(int i=0,                     //  Index integer, starting at 1
          j=-2,                    //  Even index integer, starting at -2
          k;                       //  Inner index integer
      ;                            //  Loop (1) indefinitely
                                   //    After every iteration:
       i++,                        //     Increase index `i` by 1
       System.out.println(1))      //     And print a 1
    for(k=0;                       //   Reset index `k` to 0
        k++<i;                     //   Inner loop (2) from 0 to `i`
                                   //     After every iteration:
       System.out.println(j%=10))  //      Set `j` to `j` modulo-10, and print it
      j+=2;                        //    Increase `j` by 2
                                   //   End of inner loop (2) (implicit / single-line body)
                                   //  End of loop (1) (implicit / single-line body)
}                                  // End of method
— केविन क्रूज़सेन
स्रोत
1

बैच, 85 बाइट्स

@set/an=%2+1,t=n*-~n/2
@if %t% lss %1 %0 %1 %n%
@cmd/cset/a(%1-n)%%5*2*!!(t-=%1)+!t

अनुक्रम के Nth शब्द को आउटपुट करता है। अगले त्रिकोणीय संख्या की गणना करके काम करता है।

— नील
स्रोत
1

जे , 46 42 40 बाइट्स

-6 बाइट्स कोल के लिए धन्यवाद

{.({.[:;[:#:&.>2^i.);@(1,&.><;.1)10|2*i.

इस क्रम के पहले N शब्द को आउटपुट करता है।

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

10|[:+:i. - 0 2 4 6 8 0 2 4 की लंबाई N की सूची बनाता है ... यह केवल 0 से शुरू होने वाले पूर्णांक की सूची के दोगुने आइटम के mod 10 लेता है।

[:;[:#:&.>2^i. - उपरोक्त सूची में कटौती के लिए थोड़ा सा मुखौटा उत्पन्न करता है।

(1 का मतलब प्रारंभ): 1 1 0 1 0 0 0 0 0 1 0 0 0 0 1 0 0 0 0 ... यह लगातार गैर-नकारात्मक पूर्णांक की शक्ति को 2 पाता है, उन्हें द्विआधारी में परिवर्तित करता है, समतल करता है। सूची और केवल पहले N आइटम लेता है, ताकि दोनों सूचियों की लंबाई समान हो।

;@(1,&.><;.1) - विभाजन (कटौती) लोगों और शून्य के नक्शे को उदात्त करने के लिए सम अंकों की सूची, सबलिस्ट को 1 में जोड़ता है और अंत में परिणामी सूची को समतल करता है।

]{. - केवल 1 एन आइटम लेता है, अतिरिक्त 1s की वजह से सूची में अतिरिक्त संख्या से छुटकारा पा रहा है।

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

— गैलेन इवानोव
स्रोत
1
42 बाइट्स {.({.[:;[:#:&.>2^i.);@(1,&.><;.1)(10|2*i.):। मैंने जो बदलाव किए, वह कांटे का उपयोग करने के लिए कांटे का सही इस्तेमाल करने के लिए हुक और रिफ्लेक्टर का उपयोग करने के लिए थे। मुझे 2^i.तरकीब पसंद है । मैं अब कांटे के बाईं ओर काम करने की कोशिश कर रहा हूं।
— कोल
@ धन्यवाद, मुझे कांटे का बेहतर उपयोग करना सीखना होगा। जाहिरा तौर पर कांटा 2 * i। कैप्ड हुक से बेहतर है [: +: i
— गैलेन इवानोव
1
आप परिणीति को दाहिने टाइन पर भी गिरा सकते हैं (10|2*i.)->10|2*i.
— कोल
0

प्रोटॉन , 55 बाइट्स

i=0 j=-2while1{for k:0..i print(j=(j+2)%10)print(1)i++}

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

अनुक्रम को अनिश्चित काल तक प्रिंट करता है

— HyperNeutrino
स्रोत
Is_ is वह क्या है, नया वाक्यविन्यास? : पी i=0 j=-2while1{...
— श्री Xcoder
@ Mr.Xcoder: P -2whileसिर्फ पायथन की तरह है और while1इसलिए कि मैंने पहचानकर्ताओं को एक नंबर के बाद एक कीवर्ड बनाने में सक्षम नहीं बनाया है
— HyperNeutrino
0

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

1 अनुक्रमित:

f=(x,t=0,p=0)=>p<x?f(x-1,t+1,p+t):x-p?x%5*2:1

0 अनुक्रमित:

g=(x,p=0)=>p<x?g(x-1,p?++t+p:t=1):x-p?x%5*2:1

कोड स्निपेट दिखाएं

— TSH
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.