36

N को देखते हुए, इस अनंत क्रम के Nth शब्द को आउटपुट करें:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N आपकी इच्छा के अनुसार 0-अनुक्रमित या 1-अनुक्रमित हो सकता है।

उदाहरण के लिए, यदि आदानों 0 अनुक्रमित तो 0, 1, 2, 3, 4संबंधित outputs का उत्पादन करना चाहिए -1, 2, -2, 1, -3।

1 अनुक्रमित तो आदानों हैं 1, 2, 3, 4, 5संबंधित outputs का उत्पादन करना चाहिए -1, 2, -2, 1, -3।

स्पष्ट होने के लिए, यह अनुक्रम दो बार दोहराए गए सकारात्मक पूर्णांक के अनुक्रम को लेने से उत्पन्न होता है

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

और विषम संख्याओं के प्रत्येक जोड़े को इसके ठीक ऊपर सम संख्याओं को घेरने के लिए

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

और अंत में हर दूसरे शब्द को नकारना, पहले से शुरू करना

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

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

— केल्विन के शौक
स्रोत

प्रमुख शून्य के बिना A001057 ?

— devRicher

@devRicher नहीं, पूर्ण मान वहाँ जाते हैं 1,1,2,2,3,3,4,4,...लेकिन यहाँ है 1,2,2,1,3,4,4,3,...।

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

6

क्या आप इस क्रम के लिए एक बंद रूप प्रदान कर सकते हैं या कम से कम कुछ पहले के कुछ शब्दों की तुलना में कुछ अधिक विशिष्ट हो सकता है

— ० '

Nth शब्द के लिए यह समीकरण कभी भी ऋणात्मक मान का मूल्यांकन नहीं करता है ... इसके साथ कुछ गलत है।

— मैजिक ऑक्टोपस यूरन

1

@ 0 'मैंने वह जोड़ा है जो मैं इसे देखने के सहज तरीके से सोचता हूं, हालांकि यह एक बंद रूप नहीं है। चुनौती का एक हिस्सा यह समझ रहा है कि पैटर्न क्या है और इसे गणित और कोड में कैसे अनुवाद किया जाए।

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

32

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

lambda n:~n/2+n%2*(n|2)

विषम इनपुट मोटे तौर पर n/2, यहां तक कि मोटे तौर पर भी देते हैं -n/2। इसलिए, मैंने शुरुआत की -n/2+n%2*nऔर वहां से ट्विक किया।

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

— XNOR
स्रोत

1

स्पष्टीकरण? :)

— मिल्डलीकेटवॉस्ट

17

गणितज्ञ, 29 बाइट्स

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

1-अनुक्रमित इनपुट लेने वाला शुद्ध कार्य। प्रत्यावर्ती संकेतों के अलावा (-1)^#, दो बार अनुक्रम इनपुट के करीब है, अंतर 1, 2, 1, -2 चक्रवाती रूप से हो रहा है। यह अच्छा है कि #~GCD~4, इनपुट का सबसे बड़ा सामान्य भाजक और 4, 1, 2, 1, 4 चक्रीय रूप से है; इसलिए हम 4->-2इसे मैन्युअल रूप से प्रतिस्थापित करते हैं और इसे एक दिन कहते हैं। मुझे यह दृष्टिकोण पसंद है क्योंकि यह कई-चरित्र वाले गणितज्ञों के अधिकांश आदेशों से बचता है।

— ग्रेग मार्टिन
स्रोत

9

पिप , 24 22 बाइट्स

v**a*YaBA2|1+:--a//4*2

कमांड-लाइन तर्क के रूप में, 1-अनुक्रमित इनपुट लेता है। इसे ऑनलाइन आज़माएं या 1-20 सत्यापित करें ।

व्याख्या

निरीक्षण करें कि अनुक्रम को तीन अन्य अनुक्रमों, एक शून्य-अनुक्रमित और अन्य एक-अनुक्रमित के संयोजन से प्राप्त किया जा सकता है:

के साथ शुरू 0 0 0 0 2 2 2 2 4 4 4 4 = a//4*2(0-अनुक्रमित);
जोड़ 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, जहाँBA बिटवाइज़ और, और |तार्किक OR (1-अनुक्रमित) है;
-1 1 -1 1 -1 1 -1 1 -1 1 -1 1= से गुणा करें(-1)**a (1-अनुक्रमित) से ।

यदि हम a1-अनुक्रमित के साथ शुरू करते हैं , तो हम पहले 1-अनुक्रमित भागों की गणना कर सकते हैं (अभिव्यक्ति को दाएं से बाएं पढ़ रहे हैं) और फिर अपघटनa 0-अनुक्रमित भाग के लिए । अंतर्निहित चर का उपयोग करना v=-1, हमें मिलता है

v**a*((aBA2|1)+--a//4*2)

दो और बाइट्स शेव करने के लिए, हमें कुछ पूर्ववर्ती-हेरफेर चाल का उपयोग करना होगा। हम बदल कर भीतरी कोष्ठक समाप्त कर सकते हैं +साथ+: (के बराबर) के+= भाषाओं का एक बहुत में)। कोई भी कम्प्यूट-एंड-असाइन ऑपरेटर बहुत कम पूर्वता का है, इसलिए aBA2|1+:--a//4*2बराबर है (aBA2|1)+:(--a//4*2)। पिप ऐसी चीज को असाइन करने के बारे में चेतावनी देगा, जो वैरिएबल नहीं है, लेकिन केवल तभी जब हमारे पास चेतावनियां सक्षम हों।

केवल एक ही चीज़ :है Y, जो यार्क ऑपरेटर की तुलना में कम है । * यह अपने ऑपरेंड के मान को असाइन करता हैy चर के और इसे अपरिवर्तित से गुजरता है; इसलिए हम बाहरी कोष्ठकों को समाप्त कर सकते हैं और साथ ही साथ इसे समतुल्य करने के बजाय मूल्य को समाप्त कर सकते हैं:YaBA2|1+:--a//4*2 :।

_{* Print और Output में ak की तरह एक ही मिसाल है Y, लेकिन यहाँ उपयोगी नहीं हैं।}

— DLosc
स्रोत

9

जेली , 8 7 बाइट्स

H^Ḃ~N⁸¡

यह मेरे पायथन उत्तर से एल्गोरिथ्म का उपयोग करता है , जिसे @ जीबी द्वारा काफी सुधार किया गया था ।

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

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

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

— डेनिस
स्रोत

मुझे लगता है कि यह सबसे मानक ASCII वर्ण है जिसे मैंने जेली प्रस्तुत करने में देखा है। मैं केवल दो पात्रों को देखता हूं जो मुझे परेशान करेंगे (गिनती नहीं ¡)

— एगलैंगिंग फ्रूट

google.com/…

— डेनिस

9

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

n->~(n/2)+n%2*(n|2)

जावा 7, 47 37 बाइट्स

int c(int n){return~(n/2)+n%2*(n|2);}

पहली बार जावा (8) वास्तव में प्रतिस्पर्धा करता है और कुछ अन्य उत्तरों की तुलना में कम है। अभी भी जेली और एक जैसे वास्तविक गोल्फिंग भाषाओं को नहीं हरा सकते हैं, हालांकि (दुहु .. क्या एक सर्वोच्च ..>>>!);

0-अनुक्रमित
पोर्ट @Xnor के पायथन 2 उत्तर से ।
-10 बाइट्स @GB के लिए धन्यवाद

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

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

2

यदि आपको कोष्ठक में (n / 2) डालते हैं तो आपको टर्नरी चेक की आवश्यकता नहीं है।

— जीबी

1

@ जीबी आह, तो यह मुद्दा था .. धन्यवाद। मैं थोड़े बेवकूफ लग रहा हूँ ..>।>

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

ओह, हमें जावा के लिए सिर्फ फ़ंक्शन परिभाषाएँ दी गई हैं?

— क्रंचर

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

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

1

@EricDuminil डिफ़ॉल्ट प्रोग्राम या फ़ंक्शन है , जब तक कि चुनौती अन्यथा न बताए।

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

8

जेली , 15 12 11 बाइट्स

Ḷ^1‘ż@N€Fị@

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

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

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

— डेनिस
स्रोत

मुझे पता था कि एक जेली जवाब लगभग 10 वहाँ होगा

— क्रंचर

वहाँ भी 7 पर एक जेली का जवाब है ;)

— डेनिस

मैंने इस टिप्पणी को पोस्ट करने के बाद इसे सही देखा। मुझे वास्तव में इन दिनों में से एक जेली सीखने की आवश्यकता है ... यदि आप इस एसई पर प्रश्नों के इतिहास को देखें तो यह हास्यास्पद है। सभी GolfScript हुआ करते थे, फिर CJam ने इसे संभाला और अब यह जेली है।

— क्रंचर

6

RProgN 2 , 31 25 22 बाइट्स

nx=x2÷1x4%{+$-1x^*}#-?

व्याख्या की

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

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

— Ataco
स्रोत

अच्छा तरीका! +1

— आर। कप

6

रूबी, 26 23 18 बाइट्स

->n{~n/2+n%2*n|=2}

0-आधारित

ग्रेग मार्टिन , डेनिस और शायद किसी और से -1 ^ एन विचार चोरी -3 बाइट्स , तो -5 बाइट्स चोरी n | 2 विचार xnor से ।

— जीबी
स्रोत

5

स्टैक्ड , 30 28 बाइट्स

:2%([:2/\4%2=tmo+][1+2/_])\#

इसे ऑनलाइन आज़माएं! एक फ़ंक्शन लौटाता है, जिसे प्रति मेटा सहमति के अनुसार अनुमति दी जाती है ।। स्टैक के ऊपर से इनपुट लेता है।

RProgN 2 उत्तर के समान दृष्टिकोण का उपयोग करना ।

वैकल्पिक रूप से, 46 बाइट्स। इसे ऑनलाइन आज़माएं! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

यह एक सीमा उत्पन्न करता है और फिर सदस्य को उपयुक्त के रूप में चुनता है और नकारता है।

— कोनोर ओ ब्रायन
स्रोत

5

पायथन 2 , 44 33 27 बाइट्स

lambda n:(-1)**n*~(n/2^n%2)

6 बाइट से गोल्फिंग के लिए @GB का धन्यवाद!

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

— डेनिस
स्रोत

4

05AB1E, 8 बाइट्स

2‰`^±¹F(

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

व्याख्या

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

— mbomb007
स्रोत

वाह, मैं इसे प्यार करता हूं, लेकिन ¹F("यदि विषम, नकारात्मक" के लिए महंगा लगता है।

— मैजिक ऑक्टोपस Urn

@carusocomputing यह करता है, लेकिन यह सबसे कम मुझे पता है। जेली में डेनिस के समान उत्तर में भी उस भाग के लिए 3 बाइट्स हैं। यह अभी भी डुप्लिकेट से छोटा है, समता को धक्का दें, यदि, नकारात्मक।

— mbomb007

मैं 15 मिनट के लिए करने की कोशिश की यह हरा, केवल बात यह है कि करीब की शक्ति के लिए की एक और 3 बाइट समाधान आया था nकी शक्ति के लिए, 1/n।

— मैजिक ऑक्टोपस Urn

4

जेली , ९ by बाइट्स

|2×Ḃ+H~$

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

-1 डेनिस को धन्यवाद । दुह फ्लोट रूपांतरण।

@ Xnor के पायथन 2 दृष्टिकोण का उपयोग करता है।

संपादित करें : > _>

— आउटग्रॉफर को एरिक करें
स्रोत

3

बस जब आपको लगता है कि आप जीत रहे हैं, तो डेनिस आपके साथ आएंगे और आपको हराएंगे।

— हाइपरनेत्रिनो

|2×Ḃ+H~$एक बाइट बचाता है। tio.run/nexus/jelly#AR0A4v//fDLDl@G4gitIfiT/...

— डेनिस

@ डेनिस ने सोचा कि मुझसे कोई त्रुटि होगी।

— आउटगोल्फर

3

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

{_(_1&)^2/)W@#*}

1-आधारित इनपुट।

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

व्याख्या

यहां प्रत्येक इनपुट के लिए स्टैक पर मानों के साथ कोड का टूटना है 1 है 4। पहले कुछ आदेश केवल दो कम से कम महत्वपूर्ण बिट्स को प्रभावित करते हैं n-1इसके बाद 4, यह सामान केवल चक्रीय रूप से दोहराता है, जिसके परिणाम 2 से बढ़े हुए हैं, जो कि रुकने के कारण है।

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

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

2

पर्ल 6 , 55 27 24 22 बाइट्स

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(हास्केल zipWithउत्तर से प्रेरित )
इसे आज़माएँ

{+^($_ div 2)+$_%2*($_+|2)}

(कई उत्तरों से प्रेरित)
इसे आज़माएँ

{+^($_+>1)+$_%2*($_+|2)}

कोशिश करो

{+^$_+>1+$_%2*($_+|2)}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(सभी 0 आधारित हैं)

— ब्रैड गिल्बर्ट b2gills
स्रोत

अच्छा प्रस्तुत!

— CraigR8806

2

हास्केल , 37 36 बाइट्स

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

इसे ऑनलाइन आज़माएं! यह एक अनाम फ़ंक्शन है जो एक संख्या nको तर्क के रूप में लेता है और nअनुक्रम के वें तत्व को 0-अनुक्रमित करता है।

— Laikoni
स्रोत

1

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

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 अनुक्रमित

— Blex
स्रोत

1

पर्ल 5 47 + 1 (ध्वज के लिए) = 48 बाइट्स

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

पुरानी सबमिशन 82 बाइट्स

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

ऐसे चलाएं:

perl -n <name of file storing script>  <<<  n

— CraigR8806
स्रोत

आप print +((फाइनल का उपयोग करके और हटाकर एक बाइट बचा सकते हैं )। और दो का उपयोग करके sayऔर -E। और एक और भी ($_%4&1||-1)टर्नरी के बजाय।

— सिमबाक

1

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

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1 अनुक्रमित। मैंने अभी तक किसी अन्य उत्तर को नहीं देखा है इसलिए मुझे नहीं पता कि यह सबसे अच्छा एल्गोरिथ्म है, लेकिन मुझे संदेह नहीं है।

— ETHproductions
स्रोत

1

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

6 बाइट बंद करने के लिए धन्यवाद @ETHproductions

x=>x%2?~x>>1:x%4+x/2-1

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

— fənɛtɪk
स्रोत

हम्म ... f=x=>x%2?~x>>1:x/2+x%4-1काम करेगा ?

— ETHproductions

किसी कारण से मैं अनाम फ़ंक्शन के सामने f = छोड़ दिया था: P

— fɛnɪtɪk

1

डीसी , 98 बाइट्स

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

गोश, यह यहां का सबसे लंबा जवाब है, मुख्यतः क्योंकि मैं निम्नलिखित पुनरावर्ती सूत्र के आधार पर एक-एक करके अनुक्रम के प्रत्येक तत्व के निरपेक्ष मूल्य को उत्पन्न करने का मार्ग प्रशस्त करता था:

इसके बाद आउटपुट (-1)^n * a_n, सीधे n'वें तत्व की गणना करने के बजाय । वैसे भी, यह 1-indexed है।

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

— आर। कप
स्रोत

1

आर, 38 बाइट्स

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

व्याख्या

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

— user2390246
स्रोत

1

टीआई-बेसिक (TI-84 Plus CE), 31 बाइट्स

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

टीआई-बेसिक एक टोकन भाषा है और यहां इस्तेमाल किया जाने वाला प्रत्येक टोकन एक बाइट है, सिवाय remainder(दो के।

यह 1-अनुक्रमित संस्करण का उपयोग करता है।

स्पष्टीकरण:

एक पैटर्न है जो हर चार संख्याओं को दोहराता है। 1-अनुक्रमित संस्करण में, यह है: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 इनपुट मूल्य x के लिए। इसे एक टुकड़ा-परिभाषित फ़ंक्शन के रूप में दर्शाया जा सकता है।

f (x) = - (x + 1) / 2 यदि x 4 1 mod 4; (x + 1) / २ यदि x + 2 mod 4; - (x + 1) / 2 यदि x 4 3 mod 4; (x-1) / 2 यदि x-0 mod 4

क्योंकि "x mod 1 mod 4" और "x 4 3 mod 4" भाग समान हैं, हम उन्हें "x" 1 mod 2 "में जोड़ सकते हैं।

अब टुकड़ा करने की क्रिया है:

f (x) = - (x + 1) / 2 यदि x 2 1 mod 2; (x + 2) / २ यदि x + 2 mod 4; (x-2) / 2 यदि x-0 mod 4

यह वह जगह है जहां मैं इसे वास्तविक आदेशों में तोड़ना शुरू करता हूं। चूँकि मान भी अनुक्रमित के लिए सकारात्मक है और विषम के लिए ऋणात्मक है, इसलिए हम (-1) ^ x का उपयोग कर सकते हैं। हालांकि, टीआई-बेसिक मेंi^(2X (5 बाइट्स) से कम है(-1)^Ans (6 बाइट्स) । ध्यान दें कि संचालन के आदेश के कारण कोष्ठक की आवश्यकता होती है।

अब जब हमारे पास विषम इनपुट को नकारने का तरीका है, हम मॉड्स पर जाते हैं (बाद में नेगेटिंग को वापस जोड़ते हुए)। मैंने एक अजीब इनपुट के मामले को डिफ़ॉल्ट बना दिया है, इसलिए हम इसके साथ शुरू करते हैं.5(Ans+1) ।

यहां तक कि इनपुट के मामले को ठीक करने के लिए, कोष्ठक में केवल एक संख्या जोड़ें, लेकिन केवल जब x mod 0 mod 2। इसे इस रूप में प्रस्तुत किया जा सकता है .5(Ans+1+remainder(Ans+1,2)) या के.5(Ans+1+not(remainder(Ans,2))) , लेकिन उनके पास एक ही बाइट गिनती है, इसलिए यह कोई फर्क नहीं पड़ता।

मल्टीपल ऑफ़ -4 इनपुट के मामले को ठीक करने के लिए, हमें कोष्ठकों में संख्या से 3 घटाना होगा, लेकिन एक और 1 भी क्योंकि 4 के सभी गुणक सम हैं, जो हमारे पिछले चरण से एक जोड़ देगा, इसलिए अब हमारे पास है .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) ।

अब, पूर्ण कार्यक्रम प्राप्त करने के लिए केवल साइन-निर्धारण वाले भाग से अंत तक का सामना करें।

— pizzapants184
स्रोत

0

बेफुज 93, 25 बाइट्स

शून्य अनुक्रमित

&4/2*1+&4%3%!!+&2%2*1-*.@

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

नंबर द्वारा दिया गया है ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

— MildlyMilquetoast
स्रोत

0

QBIC , 53 बाइट्स

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

स्पष्टीकरण:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

— steenbergh
स्रोत

0

समझदार , 19 बाइट्स

::>!:><^^~![!-!-~]|

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

यह समझदार के लिए @Dennis 'जेली जवाब का सिर्फ एक बंदरगाह है ।

— MildlyMilquetoast
स्रोत

0

क्यू, 52 बाइट्स

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 अनुक्रमित समाधान।

ब्लॉक नंबर हो जाता है यानी। जो [-x x + 1 - (x + 1) x] अनुक्रम के भीतर ब्लॉक में सूचकांक होता है।
पूरे अनुक्रम के भीतर मूल्य के सूचकांक के आधार पर ब्लॉक के भीतर मूल्य के सूचकांक हो जाता है।
ब्लॉक बनाता है।
चरण 2 में प्राप्त सूचकांक के माध्यम से इसमें अनुक्रमित करता है।

— डैनियल प्लेनव्यू
स्रोत

विचित्र रूप से भी, सकारात्मक रूप से नकारात्मक

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

गणितज्ञ, 29 बाइट्स

पिप , 24 22 बाइट्स

व्याख्या

जेली , 8 7 बाइट्स

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

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

जावा 7, 47 37 बाइट्स

जेली , 15 12 11 बाइट्स

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

RProgN 2 , 31 25 22 बाइट्स

व्याख्या की

रूबी, 26 23 18 बाइट्स

स्टैक्ड , 30 28 बाइट्स

पायथन 2 , 44 33 27 बाइट्स

05AB1E, 8 बाइट्स

जेली , ९ by बाइट्स

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

व्याख्या

पर्ल 6 , 55 27 24 22 बाइट्स

विस्तारित:

हास्केल , 37 36 बाइट्स

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

पर्ल 5 47 + 1 (ध्वज के लिए) = 48 बाइट्स

पुरानी सबमिशन 82 बाइट्स

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

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

डीसी , 98 बाइट्स

आर, 38 बाइट्स

टीआई-बेसिक (TI-84 Plus CE), 31 बाइट्स

बेफुज 93, 25 बाइट्स

QBIC , 53 बाइट्स

समझदार , 19 बाइट्स

क्यू, 52 बाइट्स