ऊपर और नीचे, ऊपर और नीचे

Question

चुनौती:

एक सकारात्मक पूर्णांक इनपुट n को देखते हुए , इस पैटर्न का अनुसरण करने वाला एक वेक्टर बनाएं:

0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4 -3 -2 -1 ... ±(n-1) ±n

या, शब्दों के साथ समझाया गया: वेक्टर शुरू होता है 0, और 1जब तक यह सबसे छोटा धनात्मक पूर्णांक जो अनुक्रम का हिस्सा नहीं होता है, तब तक वृद्धि करता है, तब यह घटता बनाता है जब तक कि यह सबसे छोटे (परिमाण में) नकारात्मक पूर्णांक तक नहीं पहुँचता अनुक्रम का हिस्सा नहीं है। यह इस तरह से जारी है जब तक nकि पहुंच नहीं गया। nयदि nयह विषम है, तो अनुक्रम सकारात्मक पर समाप्त होगा और nयदि नकारात्मक है तो nभी।

आउटपुट स्वरूप लचीला है।

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

n = 1
0  1
-----------
n = 2
0  1  0 -1 -2
-----------
n = 3
0  1  0 -1 -2 -1  0  1  2  3
-----------
n = 4
0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4
-----------
n = 5
0  1  0 -1 -2 -1  0  1  2  3  2  1  0 -1 -2 -3 -4 -3 -2 -1  0  1  2  3  4  5

आप n शून्य अनुक्रमित लेने के लिए चुन सकते हैं । n = 1फिर देना होगा 0 1 0 -1 -2।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे छोटा कोड जीतता है! स्पष्टीकरण हमेशा की तरह प्रोत्साहित किया जाता है!

Comments

प्रासंगिक: OEIS A196199 ।

— श्री एक्सकोडर

Answer 1

आर , 58 54 50 48 43 बाइट्स

-2 बाइट्स मिकीटी के लिए धन्यवाद

function(n)diffinv(rep(1:n%%2*2-1,1:n*2-1))

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

function(n)
 diffinv(                           # take cumulative sum, starting at 0 of
             1:n%%2*2-1,            # a vector of alternating 1,-1
         rep(                       # repeated
                        1:n*2-1))   # 1, 3, 5, etc. times

Answer 2

पर्ल 6 ,  60  26 बाइट्स

{flat {((1,-*...*)ZX*(-$++...0...$++)xx$_)}(),$_*($_%2||-1)}

कोशिश करो

{[...] (-1,-*...*)Z*0..$_}

कोशिश करो

विस्तारित:

{  # bare block lambda with implicit parameter $_

  [...]  # reduce using &infix:«...» (sequence generator)

          ( -1, -* ... * ) # (-1, 1, -1, 1 ... *)

      Z*                   # zip multiplied with

          0 .. $_          # range up to and including input
}

(-1,-*...*)Z*0..$_ अनुक्रम उत्पन्न करता है 0 1 -2 3 -4 5

Answer 3

पायथन 2 , 69 57 56 बाइट्स

f=lambda n:[0][n:]or f(n-1)+range(-n,n+1)[::n%2*2-1][2:]

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

प्रत्येक के लिए n अप करने के लिए (सम्मिलित) गणना की जाती है, उल्टे जब सम संख्या है, (उलट के बाद) मुट्ठी दो नंबर है हटा दिया, और फिर उत्पादन के साथ जोड़ दिया।inputrange(-n,n)n

Answer 4

05AB1E , 9 7 बाइट्स

2 बाइट्स @Emigna की बदौलत सहेजे गए

Ýā®sm*Ÿ

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

मेरा पहला 05AB1E उत्तर (मुझे लगता है), इसलिए मुझे कुछ ट्रिक्स याद आ रही हैं ...

व्याख्या

Ý         # push range [0 ... n]   stack: [[0 ... n]]
 ā        # push range [1 ... len(prev)]  [[0 ... n], [1 ... n+1]]
  ®       # push value of register        [[0 ... n], [1 ... n+1], -1]
   s      # swap top two values           [[0 ... n], -1, [1 ... n+1]]
    m     # power                         [[0 ... n], [-1, 1, -1, 1, ...]]
     *    # multiply                      [[0, 1, -2, 3, -4, 5, ...]]
      Ÿ   # range interpolation           [[0, 1, 0, -1, -2, -1, ...]]

के मूल उपयोग के लिए मुझे @ डेनिस को धन्यवाद देना होगाŸ , अन्यथा मैं नहीं हो सकता है शायद इसके बारे में कभी नहीं होगा में जाना जाता है ...

Comments

अच्छा :)! मैं ÝεDÈi®*}}Ÿजाँच के बिना है, ā®smपागल स्मार्ट haha ​​है।

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

Answer 5

05AB1E , 15 14 बाइट्स

ÝDÉ·<*Ý€û˜ÔsF¨

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

व्याख्या

Ý                # push range [0 ... n]
 D               # duplicate
  É·<            # (x % 2 == 1)*2-1 for each
     *           # multiply
      Ý          # range [0 ... a] for each
       €û        # palendromize each
         ˜       # flatten
          Ô      # connected uniqueified
           sF¨   # remove the last n elements

Answer 6

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

f=(n,b=d=1,k=0)=>[k,...k-d*n?f(n,k-b?b:(d=-d)-b,k+d):[]]

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

टिप्पणी की गई

f = (               // f = recursive function taking:
  n,                //   n = input
  b =               //   b = boundary value, initialized to 1
  d = 1,            //   d = current direction, initialized to 1
  k = 0             //   k = current sequence value, initialized to 0
) =>                //
  [                 // update the sequence:
    k,              //   append the current value
    ...k - d * n ?  //   if |k| is not equal to |n|:
      f(            //     append the (spread) result of a recursive call:
        n,          //       use the original input
        k - b ?     //       if k has not reached the boundary value:
          b         //         leave b unchanged
        :           //       else:
          (d = -d)  //         reverse the direction
          - b,      //         and use a boundary of higher amplitude and opposite sign
        k + d       //       update k
      )             //     end of recursive call
    :               //   else:
      []            //     stop recursion and append nothing
  ]                 // end of sequence update

Answer 7

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

f n=scanl(-)0[(-1)^k|k<-[1..n],_<-[2..2*k]]

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

सूची के नकारात्मक संचयी योगों की गणना करता है [(-1)^k|k<-[1..n],_<-[2..2*k]], जो की पहली nपंक्तियाँ हैं

[-1,
 +1, +1, +1,
 -1, -1, -1, -1, -1,
 +1, +1, +1, +1, +1, +1, +1…

Answer 8

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

²Ḷƽ-*0;Ä

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

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

²Ḷƽ-*0;Ä  Main link. Argument: n

²          Square; yield n².
 Ḷ         Unlength; yield [0, ..., n²-1].
  ƽ       Take the integer square root of each k in the range.
    -*     Compute (-1)**r for each integer square root r.
      0;   Prepend a zero.
        Ä  Accumulate; take the sums of all prefixes.

Answer 9

हास्केल , 48 42 बाइट्स

f n=0:[(-1)^i*x|i<-[0..n-1],x<-[1-i..i+1]]

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

के लिए धन्यवाद Οurous के लिए -1 बाइट

यह मसा में स्पष्ट तरह का हालांकि, यह मेरे कुछ समय लिया पहुंचने के लिए पर (-1)^i*xजो है xजब iभी और है -xजब iअजीब है। पिछले पुनरावृत्तियों जहाँ:

(-1)^i*x
x-2*mod i 2*x
(-1)^mod i 2*x
[x,-x]!!mod i 2
(1-sum[2|odd i])*x

Comments

आप का उपयोग करके एक बाइट बचा सकता है 1-iबजाय -i+1में ..अभिव्यक्ति।

— .सुरेश

Answer 10

सी # (.NET कोर) , 300  167 बाइट्स

मैंने इनमें से कोई भी पहले कभी नहीं किया है, लेकिन यह मजेदार लग रहा था। मैं देखता हूं कि लोग उन "गोल्फिंग" भाषाओं का उपयोग क्यों करते हैं क्योंकि 167 अन्य उत्तरों की तुलना में उच्चतर है। लेकिन, आप जानते हैं कि आप क्या जानते हैं।

static int[] f(int n){if (n==1) return new int[]{0,1};var a=f(n-1);return a.Concat(a.Skip(a.Length-(n-1)*2).Select(x=>-x)).Concat(new int[]{(n%2)!=0?n:-n}).ToArray();}

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

// Recursive Worker Function
static public int[] f( int n )
{
    // Start with the simple case
    if ( n == 1 ) return new int[]{0,1};

    // Recusively build off of that
    var a = f(n-1);

    // To be added at the end
    int[] b = { (n%2) !=0 ? n : -n };

    // Skip some based on length
    int s = a.Length - (n-1)*2;

    // With the rest, multiply by -1 and then append to the end
    // And append the part
    return a.Concat( a.Skip(s).Select( x => -x ) ).Concat( b ).ToArray();
}

Comments

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

— .urous

धन्यवाद! आपके सुझाव के लिए धन्यवाद, मैंने TIO साइट के "हेडर" और "पाद" अनुभागों के अर्थ का पता लगाया। कि मेरे प्रस्तुत आकार में कटौती आधा!

— डारिन कुल्लूप

PPCG में आपका स्वागत है! (यह आपकी पहली पोस्ट की तरह दिखता है।) अन्य भाषाओं के बारे में चिंता न करें, बस अपनी भाषा में जितना संभव हो उतना अच्छा बनने की कोशिश करें। / टिप्स: अनावश्यक रिक्त स्थान निकालें। C # में आप प्रतीकों के आसपास के सभी रिक्त स्थान को हटा सकते हैं ( [](){};.) (n-1)*2बस है 2*n-2और कुछ पुनर्व्यवस्था के साथ आप कोष्ठक को हटा सकते हैं।

— user202729

इसके अलावा, !=पूर्वता से कम है %ताकि आप एक जोड़ी पार्स निकाल सकें। और आप >0`! = 0 के बजाय उपयोग कर सकते हैं , एक बाइट बचाता है।

— user202729

मेरे से भी: PPCG में आपका स्वागत है! सी # में गोल्फिंग के लिए टिप्स और सभी भाषाओं में गोल्फ के लिए टिप्स पढ़ने में दिलचस्प हो सकते हैं। :) कुछ गोल्फ टिप्स के लिए के रूप में: static int[] f(int n)बन सकता है f=n=>एक (पुनरावर्ती) लैम्ब्डा का उपयोग करके, और (n-1)*2हो सकता है ~-n*2कोष्टक पर बचाने के लिए। मुझे यह 155 (137 + 18) बाइट्स के लिए मिला है: इसे ऑनलाइन आज़माएं । 18 बाइट्स के लिए हैं using System.Linq;, क्योंकि बाइट-काउंट के लिए आवश्यक आयात अनिवार्य हैं। यहां रहने का आनंद!

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

Answer 11

जम्मू , 25 बाइट्स

-5 बाइट्स FrownyFrog के लिए धन्यवाद!

>:@*:$i.;@(<@i:@*_1&^)@,]

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

जे , 30 बाइट्स

>:@*:{.;@([:(i:@*_1&^)&.>i.,])

स्पष्टीकरण:

i.,] सूची बनाता है। 0. एन

&.> सूची में प्रत्येक संख्या के लिए (...) में क्रिया निष्पादित करें और परिणाम को बॉक्स करें (मुझे मुक्केबाजी की आवश्यकता है क्योंकि परिणाम अलग-अलग लंबाई के हैं)

[:( _1&^)-1 को iवें पावर (-1 या 1) में खोजें

i:@* एक सूची बनाओ -n..n या n ..- n, उपरोक्त के संकेत पर निर्भर करता है

;@ Unbox

>:@*: n ^ 2 + 1 खोजें

}. और सूची से इतने सारे नंबर ले लो

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

Comments

क्या आप उसी कोड को शून्य आधारित nसंस्करण लिखने पर विचार करेंगे ? उदाहरण के लिए *:{.;@([:(i:@*_1&^)&.>i.).. विनिर्देश अनुमति देता है कि

— jayprich

"एन = 1 फिर 0 1 0 -1 -2 देगा"

— फ्रॉन्फ्रोग

@FrownyFrog - हम्म, मैंने इसकी जाँच नहीं की। मैं अपने पहले उपाय पर लौट आया। अवलोकन के लिए धन्यवाद!

— गैलन इवानोव

25$ कट-ऑफ के लिए उपयोग करें , &.>क्योंकि *रैंक -0 के लिए कोई आवश्यकता नहीं है ।

— FrownyFrog

Answer 12

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

r=k=0;exec'print r;r+=1-k**.5//1%2*2;k+=1;'*-~input()**2

आउटपुट स्वरूप थोड़ा बदसूरत है। : /

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

Answer 13

जावा 8, 85 83 79 बाइट्स

n->{for(int p=0,i=0;i<=n*n;p+=1-(int)Math.sqrt(i++)%2*2)System.out.println(p);}

-6 बाइट्स @ OlivierGrégoire को धन्यवाद ।

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

स्पष्टीकरण:

n->{                            // Method with integer parameter and no return-type
  for(int p=0,                  //  Set both `p` to 0
      i=0;i<=n*n;               //  Loop `i` in the range [0, `n*n`]
      p+=                       //    After every iteration, increase `p` by:
         1-                     //     1, minus:
           (int)Math.sqrt(i++)  //     The square-root of `i`, truncated to its integer
           %2*2)                //     Modulo 2, and multiplied by 2
     System.out.println(p);}    //   Print integer `p` with a trailing new-line

Comments

अच्छा तरीका। मैं अभी अपने उत्तर को बेहतर बनाने के लिए इस तरह के दृष्टिकोण पर काम कर रहा था, लेकिन आपने मुझे (अपनी बैठक के बावजूद) अच्छी तरह से हरा दिया! ;-)

— ओलिवियर ग्रिगोइरे

83 बाइट्स (मैं अभी हटा दिया गया j)।

— ओलिवियर ग्रेजायर

79 बाइट्स : मैं iएक अनावश्यक हटाने के लिए नीचे जाने के बजाय ऊपर गया n*n।

— ओलिवियर ग्रेजायर

नमस्ते। यह लिखने के लिए आपको सूचित करना है कि मैं मूल रूप से आपके उत्तर को छोड़ दिया था। (जावास्क्रिप्ट के लिए पोर्ट)। आशा है कि यह ठीक है

— मुहम्मद सलमान

@ मुहम्मदसलमान ज़रूर, np मैं बहुत से अक्सर दूसरों से जवाब पोर्ट। :) जब तक मूल उत्तर का उल्लेख है, जैसे आपने किया, यह मेरे द्वारा ठीक है।

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

Answer 14

आर , 48 46 42 बाइट्स

for(i in 1:scan())F=c(F,-(-1)^i*(2-i):i);F

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

किरिल एल द्वारा रूबी जवाब का एक बंदरगाह - और उसी किरिल एल के लिए 6 बाइट्स को धन्यवाद बचाया! अब ग्यूसेप के घोल से कम ;)

लुइस मेंडो द्वारा इस ऑक्टेव उत्तर का एक बंदरगाह approxकम गोल्फ का उपयोग कर रहा है। n=n^2+1द्वारा प्रतिस्थापित किया जा सकता है ,,n^2+1; या एक ही बाइट गिनती के लिए 0:n^2+1(स्थिति तर्क xout):

आर , 56 बाइट्स

f=function(n)approx((0:n)^2+1,-(-1)^(0:n)*0:n,n=n^2+1)$y

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

Comments

मुझे लगता है कि approxलुइस मेंडो के ऑक्टेव समाधान के समान ही यहां भी काम करेगा।

— ग्यूसेप

@Giuseppe धन्यवाद! हालांकि यह लंबे समय तक काम करता है। मैंने सीखा है diffinvऔर approxइस सवाल से ...

— JayCe

हालाँकि, मैं -1 पावर करने के लिए एक गोल्फर तरीका नहीं जानता (आर ~में एक पूरक ऑपरेटर के रूप में काम नहीं करता है :(), आप अभी भी एक पूर्ण प्रोग्राम पर स्विच करके अन्य 2 बाइट्स बचा सकते हैं ।

— किरिल एल

... और चूँकि यह एक पूर्ण कार्यक्रम है, हम एक पूर्वनिर्मित बिल्ट-इन का भी उपयोग और बिगाड़ सकते हैं: 42 बाइट्स - आखिरकार, ग्यूसेप से कम!

— किरिल एल।

Answer 15

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

+\0,¯1*⍳(/⍨)1+2×⍳

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

एक ट्रेन में परिवर्तित करके @FrownyFrog को धन्यवाद 2 बाइट्स। नीचे दिए गए पुराने उत्तर और इसकी व्याख्या देखें।

---

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

+\0,∊⊢∘-\⍴∘1¨1+2×⍳⎕

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

(उपयोग ⎕IO←0)

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

      +\⍣¯1⊢0  1  0 ¯1 ¯2 ¯1  0  1  2  3  2  1  0 ¯1 ¯2 ¯3 ¯4
0 1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1

^{+\⍣¯1 व्युत्क्रम संचयी योग को दर्शाता है}

1s और a1s का दोहराव पैटर्न है, जहां 1s या +1s के प्रत्येक लगातार अनुक्रम की लंबाई 1 + 2 × n है। और प्रत्येक बाद 1 और ates1 के बीच वैकल्पिक होता है। अब मैं क्या कर सकता हूं 1s और list1s सूची बनाएं, और फिर + द्वारा स्कैन करें

      ⍳4 ⍝ creates range 0..4
0 1 2 3
      2×⍳4
0 2 4 6
      1+2×⍳4
1 3 5 7
      ⍴∘1¨1+2×⍳4 ⍝ for-each create that many 1s
┌─┬─────┬─────────┬─────────────┐
│1│1 1 1│1 1 1 1 1│1 1 1 1 1 1 1│
└─┴─────┴─────────┴─────────────┘
      ⊢∘-\⍴∘1¨1+2×⍳4 ⍝ alternate signs
┌─┬────────┬─────────┬────────────────────┐
│1│¯1 ¯1 ¯1│1 1 1 1 1│¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1│
└─┴────────┴─────────┴────────────────────┘
      ∊⊢∘-\⍴∘1¨1+2×⍳4 ⍝ flatten
1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
      0,∊⊢∘-\⍴∘1¨1+2×⍳4
0 1 ¯1 ¯1 ¯1 1 1 1 1 1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1 ¯1
      +\0,∊⊢∘-\⍴∘1¨1+2×⍳4 ⍝ cumulative sum
0 1 0 ¯1 ¯2 ¯1 0 1 2 3 2 1 0 ¯1 ¯2 ¯3 ¯4

Comments

अन्य उत्तरों की जाँच करते हुए, मुझे कई लोग + \ _ विधि का उपयोग करते हुए देखते हैं, लेकिन 1s और answers1s के अनुक्रम को ⌊1 * ¯.5 * ⍨⍳ × sequence के साथ उत्पन्न करते हैं जो कम से कम 3 बाइट्स छोटा होता है।

— क्रिति लिथोस

+\0,¯1*⍳(/⍨)1+2×⍳है 17

— FrownyFrog

मुझे पता था कि मेरा समाधान लंबे समय तक महसूस किया गया है

— Zacharý

Answer 16

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

(#0)
m#n|m>n=[-n..n]++map(0-)(m#(n+1))|1>0=[-m]

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

Answer 17

जावा (JDK 10) , 98 बाइट्स

n->{var s="0";for(int i=0,r=0,d=1;i++<n;s+=" "+r,d=-d)for(r+=d;r!=i&r!=-i;r+=d)s+=" "+r;return s;}

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

Comments

आह, जब मैं अपनी बैठक में था, तब आपने मुझसे पहले एक उत्तर में चुपके से ..;) मेरा साथ छोड़ देंगे, क्योंकि हम एक पूरी तरह से अलग दृष्टिकोण का उपयोग करते हैं। +1 या तो रास्ता।

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

Answer 18

MATL , 17 15 बाइट्स

लुइस मेंडू के लिए -2 बाइट्स धन्यवाद!

0i:oEqG:EqY"Ysh

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

इसके लिए स्पष्टीकरण n=3:

0		% push 0
 i:		% read input as integer, push range
		% stack: [0, [1 2 3]]
   o		% modulo 2, stack: [0, [1 0 1]]
    Eq		% double and decrement, stack: [0, [1 -1 1]]
      G:	% push input and range again
		% stack: [0, [1 -1 1], [1 2 3]]
        Eq	% double and decrement,
		% stack: [0, [1 -1 1], [1 3 5]]
	  Y"	% run-length decoding
		% stack: [0, [1 -1 -1 -1 1 1 1 1 1]]
	    Ys	% cumulative sum
		% stack: [0, [1  0 -1 -2 -1  0  1  2  3]]
	      h	% horizontally concatenate
		% end of program, automatically print the stack

Answer 19

ऑक्टेव , 44 42 41 बाइट्स

2 बाइट्स @StewGriffin के लिए धन्यवाद हटा दिया , और 1 बाइट आगे @Giuseppe के लिए धन्यवाद हटा दिया!

@(n)interp1((t=0:n).^2,-t.*(-1).^t,0:n^2)

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

Answer 20

रूबी , 52 47 बाइट्स

f=->n{n<1?[0]:f[n-1]+(2-n..n).map{|x|-~0**n*x}}

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

नीचे एक स्पष्टीकरण के साथ मूल 52-बाइट संस्करण है:

f=->n{n<1?[0]:f[n-1]+[(r=*2-n..n).map(&:-@),r][n%2]}

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

पूर्वाभ्यास

f=->n{           #Recursive approach
 n<1?[0]         #Init with 0 if n=0
 :f[n-1]         #else make a recursive call
 +               #and append an array of numbers
 [(r=*2-n..n)    #Init r as splatted range from 2-n to n
 .map(&:-@)      #"-@" is unary minus, so this a fancy way to do map{|x|-x} for -1 byte
                 #For even n use this negated r, e.g. for n=4: [2, 1, 0, -1, -2, -3, -4]
 ,r]             #For odd n use r directly, e.g. for n=3: [-1, 0, 1, 2, 3]
 [n%2]           #Odd/even selector
}

Comments

मैं रूबी को नहीं जानता - क्या आप बता सकते हैं कि यह विशेष रूप से map(&:-@)भाग क्या है?

— JayCe

@JayCe ने एक स्पष्टीकरण जोड़ा। असल में, यह सिर्फ नकार है, आर में बस क्या होगा -r।

— किरिल एल

स्पष्टीकरण के लिए धन्यवाद - इसने मुझे R.

— JayCe

Answer 21

प्रोलॉग (एसडब्ल्यूआई) , 113 बाइट्स

0-I-[0|I].
N-[H|T]-R:-N is -H*(-1)^N,A is N-1,A-[H|T]-R;I is H-(-1)^N,N-[I|[H|T]]-R.
N-O:-X is -N*(-1)^N,N-[X]-O.

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

Answer 22

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

def c(n):print([(-1)**j*(abs(j-i)-j)for j in range(n+1)for i in range(2*j)][:-n+1])

Answer 23

हस्क , 18 17 बाइट्स

:ṁoṡ₁ŀ⁰_₁⁰
*^⁰_1⁰

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

Answer 24

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

Ｆ⊕ＮＩ×∨﹪ι²±¹…·∧ι⁻²ιι

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

  Ｎ                 Input as a number
 ⊕                  Increment
Ｆ                   Loop over implicit range
                ²   Literal 2
                 ι  Current index
               ⁻    Subtract
              ι     Current index
             ∧      Logical And
                  ι Current index
           …·       Inclusive range
       ι            Current index
        ²           Literal 2
      ﹪             Modulo
          ¹         Literal 1
         ±          Negate
     ∨              Logical Or
    ×               Multiply
   Ｉ                Cast to string and implicitly print

वैकल्पिक विवरण:

Ｆ⊕Ｎ

पूर्णांक से 0इनपुट समावेशी पर लूप करें ।

Ｉ

मुद्रण से पहले स्ट्रिंग करने के लिए परिणामों कास्ट करें।

×∨﹪ι²±¹

नेगेट वैकल्पिक परिणामों के सेट।

…·∧ι⁻²ιι

पिछले इंडेक्स को छोड़कर, पिछले इंडेक्स से वर्तमान इंडेक्स तक की सूची तैयार करें।

Answer 25

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

^{बाह, मुझे लगा कि मेरे पास 11 wih हैं _2+ỊrN)N;¥/}

_2+ỊrN×-*$)Ẏ

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

कैसे?

_2+ỊrN×-*$)Ẏ - Main Link: n           e.g. 4
          )  - for x in [1...n]:           1       2          3               4
_2           -   subtract 2 from x        -1       0          1               2
   Ị         -   is x insignificant?       1       0          0               0
  +          -   add                       0       0          1               2
     N       -   negate x                 -1      -2         -3              -4
    r        -   inclusive range          [0,-1]  [0,-1,-2]  [1,0,-1,-2,-3]  [2,1,0,-1,-2,-3,-4]
         $   -   last two links as a monad:
       -     -     minus one              -1      -1         -1              -1
        *    -     raised to the power x  -1       1         -1               1
      ×      -   multiply                 [0,1]   [0,-1,-2]  [-1,0,1,2,3]    [2,1,0,-1,-2,-3,-4]
           Ẏ - tighten                    [0,1,0,-1,-2,-1,0,1,2,3,2,1,0,-1,-2,-3,-4]

Answer 26

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

╗)SΘ█☼₧ΘP(

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

Answer 27

स्काला, 119 बाइट्स

def a(n: Int)={lazy val s:Stream[Int]=0#::Stream.from(0).map{x=>s(x)+1 -2*(Math.sqrt(x).toInt%2)}
s.take(n*n+1).toList}

Ungolfed:

def a(n: Int)={
  lazy val s:Stream[Int]= 0#::Stream.from(0).map //Give the starting point and indexing scheme
  {
    x=>
    {
      val sign = 1-2*(Math.sqrt(x).toInt%2) //Determine whether we are adding or subtracting at the current index
      s(x)+sign
    }
  }
  s.take(n*n+1).toList //Take the desired values
}

यह शायद बहुत बेहतर गोल्फ हो सकता है, लेकिन मैं एक समाधान आलसी धाराओं का उपयोग करना चाहता था।

Answer 28

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

⎕CY'dfns'⋄-0,∘∊1↓¨2to/Sׯ1*S←⍳,⊢

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

आवश्यक है ⎕IO←0

-2 बाइट्स @FrownyFrog की बदौलत

Comments

एक ट्रेन के रूप में 32

— FrownyFrog

Answer 29

स्टैक्ड , 44 बाइट्स

[~>0\:2%\#,2*1-tr[...rep]flatmap,$sumonpref]

इसे ऑनलाइन आज़माएं! स्टैक्ड में प्रोग्राम किए हुए कुछ समय हो गया है, लेकिन मुझे लगता है कि मुझे अभी भी मिल गया है।

वैकल्पिक

73 बाइट्स: [0\|>:2%tmo*2 infixes[:...|>\rev...|>rev#,$#'sortby 1#behead]flatmap 0\,]

यह मेरे अटैच उत्तर में प्रयुक्त "उत्पन्न सूचकांकों से पर्वतमाला" दृष्टिकोण के साथ जाता है । यह बहुत लंबा साबित हुआ, क्योंकि स्टैक्ड के पास उल्टे पर्वतमाला के लिए कोई बिलिन नहीं है और न ही ढहने वाला। (बस यही :...|>\rev...|>rev#,$#'sortby 1#beheadकरता है।)

53 बाइट्स: [0\|>:2%tmo _\tpo#,tr[...rep]flatmap 0\,inits$summap]

... इसलिए मैं एक दृष्टिकोण है जो बजाय संचयी योग (पाता है के लिए जाने का फैसला किया inits$summap) से अधिक 1और -1के रूप में अजीब पूर्णांक के द्वारा बार-बार, आर जवाब ।

46 बाइट्स: [~>0\:2%\#,2*1-tr[...rep]flatmap,inits$summap]

... लेकिन मैंने महसूस किया कि नकारात्मक पूर्णांक और विषम पूर्णांक एक ही बार में बनाए जा सकते हैं, दोनों उत्पन्न सरणियों (रेंज के मॉड 2 मान और रेंज खुद) को 2घटाकर घटाया जा सकता है 1। यह बारी 1एस और-1 पहली सीमा के लिए और दूसरे के लिए विषम पूर्णांक के लिए एस !

44 बाइट्स: [~>0\:2%\#,2*1-tr[...rep]flatmap,$sumonpref]

... और फिर मुझे याद आया कि उपसर्गों की मैपिंग के लिए मेरे पास एक बेसिन था। ^ - ^

Answer 30

जूलिया 0.6 , 44 बाइट्स

n->[(i%2*2-1)*[0:i;(n>i)*~-i:-1:1]for i=1:n]

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

चूंकि ओपी "आउटपुट स्वरूप लचीला है" का उल्लेख करता है, इसलिए यह उप सरणियों के एक सरणी को प्रिंट करता है, जैसे। यू (3) => [[0, 1], [0, -1, -2, -1], [0, 1, 2, 3]]।

i%2*2-1 वर्तमान सबर्रे का संकेत तय करता है - सम संख्याओं के लिए ऋणात्मक, विषम के लिए धनात्मक।

[0:i;(n>i)*~-i:-1:1]दो भागों में है। 0: मैं सीधा हूं, 0 से वर्तमान तक के मूल्यों की सीमा i। अगले भाग में, ~ -i: -1: 1, i-1 से 1. तक की अवरोही सीमा है, लेकिन हम इसे तभी जोड़ना चाहते हैं, जब हम अभी तक अंतिम मूल्य पर नहीं हैं, इसलिए सीमा के ऊपरी छोर को गुणा करें द्वारा (n> i) ताकि जब n == i, तो रेंज 0: -1: 1 होगी जो खाली समाप्त होती है (इसलिए सरणी n पर सही ढंग से रुक जाती है)।

---

और यहाँ एक ऐसा संस्करण है जो यादृच्छिक अभिगम का समर्थन कर सकता है - यहाँ का आंतरिक लंबो अनुक्रम का i'th शब्द लौटाता है, इसके पहले कोई भी शब्द संग्रहीत नहीं है। यह एक एकल साफ सरणी के रूप में भी आउटपुट देता है।

49 47 बाइट्स

n->map(i->((m=isqrt(i))%2*2-1)*(m-i+m^2),0:n^2)

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