उद्देश्य : एक सकारात्मक पूर्णांक को देखते हुए n:

यदि nविषम है, तो बढ़ते क्रम में nनिकटतम संख्याओं की सूची को आउटपुट करें0
यदि nहै, तो भी एक फाल्सी मूल्य का उत्पादन करें।

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

5 -> [-2,-1,0,1,2]
4 -> false (or any Falsey value)
1 -> [0]

संदर्भ कार्यान्वयन

function update(){
  var num = +document.getElementById("yield").value;
  if(num){
    var out = document.getElementById("output");
    if(num % 2 == 1){
      // base is balanced
      var baseArr = [];
      for(var i=0;i<num;i++){
        baseArr.push(i-Math.floor(num/2));
      }
      out.innerHTML = baseArr.join(" ");
    } else {
      out.innerHTML = "false";
    }
  } else {
    out.innerHTML = "<i>enter input</i>";
  }
}

setInterval(update,1);

* {
  font-family: "Constantia", "Consolas", monospace;
}

[type="number"] {
  width: 10px;
  width: 2em;
}

#output {
  font-family: "Consolas", monospace;
}

Input: <input type="number" id="yield" value="3"> is <span id="output"><i>enter input</i></span>

स्निपेट का विस्तार करें

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

क्या सूची के बजाय आउटपुट एक रेंज ऑब्जेक्ट हो सकता है?

— ब्रैड गिल्बर्ट b2gills

@ BradGilbertb2gills क्षमा करें, एक श्रेणी ऑब्जेक्ट एक अमान्य आउटपुट है।

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

खाली सूची हमेशा गलत नहीं होती है।

— सुपरजेडिए 224

@ SuperJedi224 किस संदर्भ में है?

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

भाषाएँ (IE जावास्क्रिप्ट) हैं जिसमें खाली सूची को एक सत्य मान माना जाता है।

— SuperJedi224 21

4

अजगर, 10 बाइट्स

*-R/Q2Q%Q2

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

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

            (implicit) Store the input in Q.
   /Q2      Calculate Q/2 (integer division).
 -R   Q     Subtract that value (-R) from each element in [0, ..., Q-1] (Q).
*      %Q2  Repeat the resulting array Q%2 times.

— डेनिस
स्रोत

5

एपीएल, 16 15 13 बाइट्स

-2 बाइट्स के लिए @ डेनिस को धन्यवाद!

⌊(⍳⊢×2|⊢)-÷∘2

यह एक मोनडिक ट्रेन है जो इनपुट के लिए एक खाली सरणी देती है। नीचे चित्र है:

┌────┴─────┐   
⌊ ┌────────┼─┐ 
┌─┴─┐      - ∘ 
⍳ ┌─┼───┐   ┌┴┐
  ⊢ × ┌─┼─┐ ÷ 2
      2 | ⊢

सबसे पहले, ⊢×2|⊢इनपुट समय को इसके मॉड 2 देता है; यानी, ऑड्स खुद देंगे, और evens give 0. हम ⍳1 से उस तक संख्याओं की एक सूची बनाने के लिए उपयोग करते हैं ( ⍳0खाली सरणी देता है), और फिर हम आधे इनपुट और फर्श को घटाते हैं।

— lirtosiast
स्रोत

5

गणितज्ञ, ३२ ३० २४ बाइट्स

OddQ@#&&Range@#-(#+1)/2&

कोड-गोल्फ चाल: अंतिम तर्क के लिए Andबूलियन होना जरूरी नहीं है।

— LegionMammal978
स्रोत

आप यूनिकोड कोष्ठक का उपयोग करके एक बाइट को बचा सकते हैं Floor।

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

इसके अलावा, Range[-a,a=...]एक और बाइट को बचाने के लिए काम करने लगता है।

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

OddQ@#&&Range@#-(#+1)/2&

— ngenisis

4

पॉवरशेल, 50 52 बाइट्स

param($a)$b=$a/2-.5;(0,((0-$b)..$b-join' '))[($a%2)]

ऊफ। सुंदर वाचाल उत्तर। इनपुट लेता है $a, फिर $b"मंजिल" के रूप में एक नया चर सेट करता है $a/2। से एक नई संख्या सीमा बनाता (0-$b)है $b, फिर joinरिक्त स्थान के साथ सीमा है, और है कि दो तत्व सरणी के दूसरे तत्व के रूप में (पहला तत्व है 0)। फिर $a%2आउटपुट के लिए उस एरे में इंडेक्स का उपयोग करता है।

54 बाइट्स में अधिक "पारंपरिक" यदि / और प्रवाह का उपयोग करते हुए वैकल्पिक संस्करण:

param($a)$b=$a/2-.5;if($a%2){(0-$b)..$b-join' ';exit}0

_{संपादित करें - यदि कोई इनपुट है, तो एक गलत मूल्य को आउटपुट करने के लिए कुछ तर्क जोड़ने की आवश्यकता है}

— AdmBorkBork
स्रोत

(0-$b)सिर्फ बदलने के लिए 3 बाइट्स सहेजें -$b। इसके अलावा, बस से गुणा करने से *0एक अशक्त स्ट्रिंग (मूल्यांकन में झूठी के लिए मूल्यांकन) का उत्पादन होगा। (देखें: codegolf.stackexchange.com/a/63005/45925 )

— जोनाथन लीच-पेपिन

4

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

g n=take(n*mod n 2)[-div n 2..]

खाली सूची से असंतुलित होने का संकेत मिलता है। प्रयोग उदाहरण: g 7-> [-3,-2,-1,0,1,2,3]।

@xnor को 5 बाइट्स मिले। धन्यवाद!

— nimi
स्रोत

क्या खाली सूची के मामले को स्थिति बनाने का कोई तरीका नहीं है? करना g n=[x|x<-[-div n 2..(n+1)/2],odd n]भी उतना ही लंबा है।

— 21

34:g n=[1|odd n]>>[-div n 2..div n 2]

— xnor

आपको इसे संपादित करना चाहिए, यह एक छोटा बदलाव है।

— 21

g n=[1|odd n]>>take n[-div n 2..]एक चार भी बचाता है।

— 21

1

@ xnor: आप इसे तेजी से नीचे गिरा रहे हैं, जिससे मैं अपने पोस्ट संपादित कर सकता हूं।

— नीमी

4

जावास्क्रिप्ट (ईएस 6), 44 43 42 41 बाइट्स

^{पार किया 44 अभी भी नियमित है 44 ;;}

n=>[...Array(n&1&&n--)].map((x,i)=>i-n/2)

विषम सूचनाओं के लिए, लंबाई का एक पूर्णांक सरणी देता है, जिस xपर केंद्रित है 0; यहां तक कि, रिटर्न 0. मुझे लगता है कि यह उतना ही कम है जितना इसे मिल सकता है। (@ Edc65 और @ ɟ nɐɯɹɐuן a oɯ!) की बदौलत एक युगल बाइट को बचाया!

ES6 विकल्प: (42 बाइट्स, @intrepidcoder को धन्यवाद)

x=>x%2&&[for(y of Array(x--).keys())y-x/2]

सुझावों का स्वागत है!

— ETHproductions
स्रोत

का उपयोग x%2&&[for(y of...]करके एक बाइट बचाता है।

— intrepidcoder

ES6, 43, n=>Array(n&1&&n--).fill().map((x,i)=>i-n/2)यदि खाली सरणी वापस करने की अनुमति है

— edc65

@intrepidcoder धन्यवाद! मैंने इसे बदल दिया है।

— ETHproductions

@ edc65 साथ ही धन्यवाद! मैंने इसे उत्तर में जोड़ दिया है।

— ETHproductions

x=>x%2&&[for(y of Array(x--).keys())y-x/2]42 है।

— intrepidcoder

3

मिंकोलंग 0.10 , 18 बाइट्स

nd2%?.d2:~r[dN1+].

व्याख्या

n          Take input as integer (k)
d2%?.      Duplicate k and stop if it's even
d2:~       Duplicate k, then divide by 2 and negate to get first number
r          Put k on top
[    ].    Loop k times and then stop
 dN1+      Duplicate, output as integer, and increment

— एलेंडिया स्ट्राटन
स्रोत

3

जे, 12 बाइट्स

i:@%~2&!*2&|

यह एक राक्षसी क्रिया है जो 0सम संख्याओं के लिए रिटर्न (मिथ्या) है। इसे Jjs के साथ ऑनलाइन आज़माएं ।

परीक्षण चालन

   (i:@%~2&!*2&|) 3
_1 0 1
   (i:@%~2&!*2&|) 2
0

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

              Right argument: y
         2&|  Take y modulo 2.
     2&!      Calculate y C 2 = y(y-1)/2.
        *     Multiply the results.
   %~         Divide the product by y.
              This yields (y-1)*(y%2)/2 = (y-1)/2 (y even) | 0 (y odd).
  @           Take the result and...
i:              apply the bilateral index generator z -> (-z ... z).

— डेनिस
स्रोत

3

डीयूपी , 31 बाइट्स

[a:a;2/b:[b;_[$b;<][$1+]#][0]?]

Try it here.

अनाम लम्बा। उपयोग:

5[a:a;2/b:[b;_[$b;<][$1+]#][0]?]!

व्याख्या

[                             ] {lambda}
 a:                             {store input to a}
   a;2/                         {divmod a by 2}
       b:                       {store quotient to b, top of stack is now remainder}
         [               ][ ]?  {conditional}
          b;_                   {if remainder is 1, get b and negate it}
             [    ][   ]#         {while loop}
              $b;<                {while top of stack is less than b}
                    $1+           {duplicate and increment}
                           0    {otherwise, leave falsy value}

— कैट
स्रोत

2

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

अभी मुझे यकीन नहीं है कि अगर मैं संतुलित होने पर जो कुछ भी चाहता हूं उसे आउटपुट कर सकता हूं, इसलिए वर्तमान में यह असंतुलित-सक्षम आधार के मामले में एक खाली सूची देता है। यह एक अनाम मेमने का कार्य है, इसलिए इसे इसे उपयोग करने के लिए एक नाम दें।

lambda k:k%2*range(-k/2+1,-~k/2)

— Kade
स्रोत

यदि आप करते हैं k%2*, तो आप परगनों से बच सकते हैं।

— xnor

2

सीजाम, 13 12 बाइट्स

{_2md@,@f-*}

यह एक अनाम फ़ंक्शन है जो स्टैक से पूर्णांक बनाता है और बदले में एक अंक सरणी (विषम आधार) या एक खाली सरणी (यहां तक कि आधार) को धक्का देता है। CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

_          e# Copy the input (N).
 2md       e# Push N/2 and N%2.
    @      e# Rotate N on top of the stack.
     ,     e# Push [0 ... N-1].
      @    e# Rotate N/2 on top of the stack.
       f-  e# Subtract N/2 from each element of [0 ... N-1].
         * e# Repeat the resulting array N%2 times.

— डेनिस
स्रोत

2

ओ, १ 18

M(.e\2/.@{_}dmrr]p

लाइव डेमो।

— kirbyfan64sos
स्रोत

5

वहाँ अंग्रेजी वर्णमाला में हर पूंजी पत्र के लिए एक भाषा है ?!

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

उन्हें बढ़ते क्रम में सूचीबद्ध किया जाना चाहिए।

— जियोबिट्स

@MickeyT ने तय किया कि 5 बाइट की कीमत पर।

— kirbyfan64sos

@Geobits फिक्स्ड है कि, भी।

— kirbyfan64sos

2

@ C @O'Bʀɪᴇɴ उपलब्ध कुछ

— चरण हैं

2

विट्सी, 27 25 बाइट्स

मैं कल इसे नीचे गोल्फ जा रहा हूँ, लेकिन मैं वास्तव में अब बिस्तर पर जाना चाहिए।

D2M) [& 1] डी 1-i *} \ [डी 2 / NaO2 +]
D इनपुट को डुप्लिकेट करें।
 2M) [और 1] यदि इनपुट सम है (इनपुट% 2 = 0) एक नया स्टैक उत्पन्न करता है
                              और इसे 1 धक्का दें।
        D शीर्ष मान को डुप्लिकेट करें - अगर यह भी नहीं था, तो यह इनपुट होगा। अन्यथा, यह एक है।
         1- एक घटाना (शून्य के आसपास संतुलन के लिए)
           i * Additively उल्टा
             } स्टैक में एक आइटम पर शिफ्ट - यह सुनिश्चित करता है कि
                              हमारे पास या तो इनपुट है या शीर्ष पर एक है।
              \ [] इनपुट समय दोहराएँ।
                D2 / N शीर्ष आइटम को डुप्लिकेट करें और इसे प्रिंट करें।
                    AO Newline (मुझे पूरा यकीन है कि यह वैध अलगाव है)
                      2+ स्टैक के शीर्ष आइटम में एक जोड़ें।

— एडिसन क्रम्प
स्रोत

"अंतिम वैश्विक संस्करण" जो तीव्र लगता है

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

3

यह है तीव्र।

— एडिसन क्रम्प

@ C @O'Bʀɪᴇɴ की तीव्रता तीव्र होती है

— Addison Crump

2

टीस्क्रिप्ट , 16 बाइट्स 18

x%2Þr(xØ)ßl-x/2)

बहुत साधारण। विशेष वर्ण वास्तव में लंबे कोड अनुक्रमों के लिए केवल "संक्षिप्त" हैं।

मैंने अभी भी पर्मलिंक नहीं बनाया है, इसलिए आपको दुभाषिया में पेस्ट कॉपी करना होगा

व्याख्या

x%2 &&    // If x is NOT even return falsy, else...
r(x--)    // Range 0-input. Subtracts one from input
m(#       // Loop through range
  l-      // Current item in loop, minus...
    x/2   // input - 1, divided by two
)

_{यह उत्तर गैर-प्रतिस्पर्धात्मक है}

— Downgoat
स्रोत

मुझे इन विशेष-चार संक्षिप्तियों को जाप में लागू करना चाहिए। :) BTW, क्या आपको यकीन है कि W 1 बाइट है?

— ETHproductions

@ETHproductions Aww :( यह जांचने से पहले कि मैं इसे लागू करना भूल गया हूँ। मैं इसे अगले प्रतिबद्ध में ठीक कर

— दूंगा

1

@ V @ नाह, यह एक अच्छी चुनौती / विचित्रता है जो सामान को दिलचस्प बनाए रखती है। इसके अलावा, अप्रत्याशित वर्ण शांत दिखते हैं।

— मामा फन रोल

4

@ Long n asuɐɯɹɐ ן oɯ जब तक आप वास्तव में उन्हें देख सकते हैं। मेरे फोन पर, आपकी भाषा का नाम भी दिखाई नहीं दे रहा है। : पी

— डेनिस

2

@ डेनिस इसे भाषा की रहस्यमय आभा में जोड़ता है ...

— मामा फन रोल

2

एफ #, 38 बाइट्स

गलत परिणाम एक खाली सूची है।

let O n=if n%2<1 then[]else[-n/2..n/2]

— हाथ-ए-खाना
स्रोत

2

S, 21 चार्ट / 37 बाइट्स

ô[…Ѧ(ï&1⅋ï‡)]ć⇀_-ï/2⸩

Try it here (Firefox only).

यहां 20-चार / 35-बाइट उत्तर (गैर-प्रतिस्पर्धात्मक है, क्योंकि उत्तर प्रश्न के बाद लागू किए गए परिवर्तनों का उपयोग करता है):

ô(ï%2⅋ѨĶ(ï‡)ć⇀$-ï/2⸩

Try it here (Firefox only).

— मामा फन रोल
स्रोत

2

जाप, 21 19 बाइट्स

Japt , Ja vaScri pt का छोटा संस्करण है ।

U%2&&(X=-U/2+K o1-X

विषम सूचनाओं के लिए, लंबाई का एक पूर्णांक सरणी देता है, जिस xपर केंद्रित है 0; यहां तक कि, रिटर्न 0. रफ जेएस अनुवाद:

output(U%2&&(X=-U/2+.5).range(1-X));

जहां x.range(y)से पूर्णांकों की सूची बनाता xहै y। इसे ऑनलाइन टेस्ट करें!

आधुनिक जाप में, यह केवल 11 बाइट्स है:

u ©Uo-U/2-½

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

— ETHproductions
स्रोत

5

जिस किसी ने भी इस उत्तर को अस्वीकार किया है, क्या आप उसे समझा सकते हैं कि क्यों? मैं जानना चाहूंगा कि मैं कहां गलत था इसलिए मैं इसे ठीक कर सकता हूं। धन्यवाद। :-)

— ETHproductions

3

शायद उन्हें भाषा पसंद नहीं है? (मैं भाषा से प्यार करता हूं, हालांकि मैं देख सकता हूं कि अन्य लोग कैसे नहीं हो सकते।)

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

1

आर, 30 बाइट्स

function(n)(x=(1-n)/2*n%%2):-x

मोटे तौर पर, x:-xपूर्णांकों को उस स्थान से लौटाता xहै -x, जहाँ मैं सेट xकरता हूँ (1-n)/2। मैं बल प्रयोग n%%2की परिभाषा में मोडुलो -2 कारक का उपयोग शून्य xपर बल xदेने के nलिए भी करता हूं , इस स्थिति में, 0:0रिटर्न 0(गलत)।

— flodel
स्रोत

1

पर्ल, 36 बाइट्स

मुझे लग रहा है कि इसे छोटा किया जा सकता है:

$,=$";$n=<>;print$n%2?-$n/2..$n/2:0;

रेंज ट्रीट्स पूर्णांक के रूप में तैरता है, इसलिए, जैसे 5/2 = 2.5 चुपचाप 2 में परिवर्तित हो जाता है।

(यदि स्वरूपण से कोई फर्क नहीं पड़ता है, तो $,=$";कुल 30 बाइट के लिए निकालें )।

— ChicagoRedSox
स्रोत

1

पॉवरशेल, 49 बाइट्स

param($a)$b=$a/2-.5;"[$(-$b..$b-join",")]"*($a%2)

यहां तक कि संख्याओं का मूल्यांकन किया जाता है $falseक्योंकि वे एक खाली लाइन आउटपुट प्रदान करते हैं।

("[$(-$b..$b-join",")]"*($a%2))-eq $True ===> False

विषम संख्याएं सटीक संदर्भ स्ट्रिंग का उत्पादन करती हैं। आप आउटपुट स्ट्रिंग से 45हटाकर 4 और बाइट्स (अब ) बचा सकते हैं []।

PS> .\balanced.ps1 4


PS> .\balanced.ps1 5
[-2,-1,0,1,2]

PS> .\balanced.ps1 0


PS> .\balanced.ps1 1
[0]

PS>

पॉवरशेल, 36 बाइट्स

param($a)$b=$a/2-.5;(-$b..$b)*($a%2)

इसका एक ही परिणाम है, लेकिन नई संख्या द्वारा अलग किए गए अंकों की सूची को आउटपुट करता है:

PS> .\balanced-newline.ps1 4

PS> .\balanced-newline.ps1 1
0

PS> .\balanced-newline.ps1 5
-2
-1
0
1
2

PS>

— जोनाथन लीच-पेपिन
स्रोत

1

पर्ल 6, 25 बाइट्स

सबसे छोटा लैंबडा अभिव्यक्ति मैं एक सीमा के बजाय एक सूची के आउटपुट के साथ आ सकता है:

{$_%2&&|((1-$_)/2..$_/2)} # 25

परिक्षण:

for 0..10 -> $a {
  if {$_%2&&|((1-$_)/2..$_/2)}($a) -> $b {
    say "$a.fmt('%5s')  $b"
  } else {
    say "$a.fmt('%5s')  False"
  }
}

    0  False
    1  0
    2  False
    3  -1 0 1
    4  False
    5  -2 -1 0 1 2
    6  False
    7  -3 -2 -1 0 1 2 3
    8  False
    9  -4 -3 -2 -1 0 1 2 3 4
   10  False

यह इस तथ्य का लाभ उठाता है कि पर्ल 6 संख्या 0को गलत मान के रूप में मानता है । अगर उत्पादन होना था वास्तव में Falseआप बदल सकते $_%2के साथ $_!%%2।

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

1

05AB1E , 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

भाषा चुनौती का सामना करती है और इसलिए गैर-प्रतिस्पर्धी है। कोड:

È#¹;D(ŸR

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

स्पष्टीकरण:

È#        # If input % 2 == 0, end the program
  ¹       # Push the first input from the register
   ;      # Halve, push input / 2 rounded down
    D     # Duplicate top of the stack
     (    # Negate
      Ÿ   # Inclusive range, pushes [a .. b]
       R  # Reverse the array

CP-1252 एन्कोडिंग का उपयोग करता है ।

— अदनान
स्रोत

0

PHP, 50 बाइट्स

<?=($n=$argv[1])&1?join(_,range(-$k=$n/2|0,$k)):0;

कार्यक्रम, STDIN से इनपुट लेता है, _सीमांकित सूची प्रिंट करता है या 0।

या

function f($n){return$n&1?range(-$k=$n/2|0,$k):0;}

फ़ंक्शन तर्क लेता है, सरणी देता है या 0।

— टाइटस
स्रोत

0

जावा, 145 बाइट्स

public class c{static void c(int n){for(int i=n/2*-1;i<=n/2;i++){if(n%2==0){System.out.print("false");break;}System.out.print(i);}}}

स्पष्टीकरण: क्षमा करें, मुझे पता है कि यह वास्तव में लंबा है। मुझे जावा के लिए एक उत्तर नहीं मिला, इसलिए मैंने एक को डालने का फैसला किया। मुझे बताएं कि क्या मुझे मुख्य फ़ंक्शन लिखने की ज़रूरत है (मुझे यकीन नहीं है कि नीति या नहीं)। मूल रूप से यह संख्या को दो से विभाजित करता है और इसे निचले बाउंड के लिए -1 से गुणा करता है और ऊपरी बाउंड के लिए यह केवल दो से विभाजित संख्या का उपयोग करता है। मैं इस पृष्ठ के लिए नया हूं, इसलिए यदि मैंने कुछ भी प्रारूपित नहीं किया है तो मुझे बताएं। इसके अलावा, मुझे पता है कि लैम्बडा फ़ंक्शंस के साथ उत्तरों को छोटा किया जा सकता है, लेकिन मुझे नहीं पता कि उनका उपयोग कैसे किया जाए और मुझे यकीन नहीं है कि जावा उनका समर्थन करता है।

यहाँ एक अधिक पठनीय संस्करण है जो कम गोल्फ वाला है:

public class StackOverflow {
static void c(int n){
    for (int i = n/2*-1; i<=n/2; i++){
        if(n%2==0){
            System.out.print("false");
            break;
        }
        System.out.print(" " + i);
    }
}
}

— हेनरी
स्रोत

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

@ ais523 प्रमुख व्हाट्सएप सिर्फ मेरी निजी आदत है और मैंने इसे बाइट की गिनती में शामिल नहीं किया, मुझे लगता है कि मुझे इससे छुटकारा चाहिए। सहायता के लिए धन्यवाद!

— हेनरी

0

रूबी, 25 बाइट्स

->n{n%2>0&&[*(-n/=2)..n]}

— जीबी
स्रोत

0

रूबी, 27 बाइट्स

->n{[*0-n/2..n/2]if n.odd?}

एक अनाम लंबो फ़ंक्शन बनाता है जो nn के विषम होने पर 0 के निकटतम संख्याओं के सरणी को लौटाएगा, और अन्यथा nil (माणिक में एक फ़ासी मूल्य) देता है।

रूबी अपने पूर्णांक विभाजन को -infinity की ओर ले जाती है, लेकिन (जब भी माइनस साइन होता है) की 0-n/2तुलना में छोटा होता -n/2+1है, और क्योंकि n को अब सकारात्मक माना जाता है, गोलाई मेरे पक्ष में काम करता है।

पुराना संस्करण (28 बाइट्स)

->n{[*-n/2+1..n/2]if n.odd?}

— IMP1
स्रोत

संतुलित रहने के लिए शून्य के निकटतम संख्या एन

संदर्भ कार्यान्वयन

अजगर, 10 बाइट्स

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

एपीएल, 16 15 13 बाइट्स

गणितज्ञ, ३२ ३० २४ बाइट्स

पॉवरशेल, 50 52 बाइट्स

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

जावास्क्रिप्ट (ईएस 6), 44 43 42 41 बाइट्स

मिंकोलंग 0.10 , 18 बाइट्स

व्याख्या

जे, 12 बाइट्स

परीक्षण चालन

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

डीयूपी , 31 बाइट्स

व्याख्या

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

सीजाम, 13 12 बाइट्स

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

ओ, १ 18

विट्सी, 27 25 बाइट्स

टीस्क्रिप्ट , 16 बाइट्स 18

व्याख्या

एफ #, 38 बाइट्स

S, 21 चार्ट / 37 बाइट्स

जाप, 21 19 बाइट्स

आर, 30 बाइट्स

पर्ल, 36 बाइट्स

पॉवरशेल, 49 बाइट्स

पॉवरशेल, 36 बाइट्स

पर्ल 6, 25 बाइट्स

05AB1E , 8 बाइट्स (गैर-प्रतिस्पर्धात्मक)

PHP, 50 बाइट्स

जावा, 145 बाइट्स

रूबी, 25 बाइट्स

रूबी, 27 बाइट्स

पुराना संस्करण (28 बाइट्स)