Amaç : Pozitif bir tam sayı verildiğinde n:

• Eğer ngarip ise, artan sırayla nen yakın sayıların listesini çıkar0
• Eğer nçıkışı Falsey değeri, hatta olduğunu.

Test senaryoları :

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

Referans uygulaması

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>

Pyth, 10 bayt

*-R/Q2Q%Q2

Çevrimiçi deneyin.

Nasıl çalışır

            (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.

APL, 16 15 13 bayt

@Dennis'e -2 bayt için teşekkürler!

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

Bu, çift giriş için boş bir dizi veren monadik bir trendir. Aşağıdaki diyagram:

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

İlk olarak, ⊢×2|⊢girdi zamanlarına mod 2'yi verir; yani, oranlar kendilerini verir ve eşitler 0 verir. ⍳1'den buna bir sayı listesi oluşturmak için kullanırız ( ⍳0boş diziyi verir) ve sonra giriş ve katın yarısını çıkarırız.

Mathematica, 32 30 24 bayt

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

Kod golf hilesi: Son argüman Andboolean olmak zorunda değil.

PowerShell, 50 52 Bayt

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

Oof. Oldukça ayrıntılı cevap. Girdi alır $a, sonra $b"kat" olarak yeni bir değişken ayarlar $a/2. Yeni bir sayı aralığı oluşturur (0-$b)için $b, daha sonra joinboşluklu aralığı s, ve bir iki elemanlı bir dizinin ikinci eleman olarak (birinci eleman olduğunu var 0). Daha sonra $a%2çıktı için bu dizinin dizinini kullanır .

54 baytta daha "geleneksel" if / else akışı kullanan alternatif sürüm:

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

_{Düzenle - Giriş eşitse, bir falsey değeri çıktısı almak için bazı mantık eklemek gerekir}

Haskell, 37 36 31 bayt

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

Dengesiz, boş listeyle gösterilir. Kullanım örneği: g 7-> [-3,-2,-1,0,1,2,3].

@xnor 5 bayt buldu. Teşekkürler!

JavaScript (ES6), 44 43 42 41 bayt

^{çarpı işareti 44 hala düzenli 44; (}

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

Tek girişler için x, ortalanmış bir tamsayı uzunluk dizisi döndürür 0; Hatta 0 döndürür. Bence bu mümkün olduğu kadar kısa. (@ Edc65 ve @ ן nɟuɐɯɹɐ ן oɯ sayesinde birkaç bayt kaydedildi!)

ES6 alternatifi: (@intrepidcoder sayesinde 42 bayt)

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

Öneriler hoş geldiniz!

Minkolang 0.10 , 18 bayt

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

açıklama

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

J, 12 bayt

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

Bu, 0çift ​​sayılar için (falsy) dönen monadik bir fiildir . J.js ile çevrimiçi deneyin .

Test sürüşü

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

Nasıl çalışır

              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).

DUP , 31 bayt

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

Try it here.

Anonim lambda. Kullanımı:

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

açıklama

[                             ] {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}

Python 2, 34 32 Bayt

Şu anda, dengeli değilse, istediğim her şeyi çıkarabileceğimden emin değilim, bu yüzden şu anda dengesiz bir baz durumunda boş bir liste döndürüyor. Anonim bir lambda işlevi, bu yüzden onu kullanmak için bir ad verin.

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

CJam, 13 12 bayt

{_2md@,@f-*}

Bu, yığından bir tamsayı açan ve karşılığında bir rakam dizisini (tek taban) veya boş bir diziyi (çift taban) iten anonim bir işlevdir. CJam yorumlayıcısında çevrimiçi deneyin .

Nasıl çalışır

_          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.

O, 18

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

Canlı demo.

Vitsy, 27 25 Bayt

Bunu yarın golf oynayacağım ama şimdi yatağa gitmeliyim.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Girişi çoğaltın.
 2M) [& 1] Giriş eşitse (% 2 = 0 girişi) yeni bir yığın oluşturun
                              ve 1'i ona itin.
        D En üst değeri çoğaltın - eğer eşit değilse, bu girdi olacaktır. Aksi takdirde, bu birdir.
         1- Çıkarın (sıfır civarında dengelemek için)
           i * Katkı olarak ters çevir
             } Yığındaki bir öğenin üzerine kaydır - bu,
                              girdimiz veya üstte bir tane var.
              \ [] Giriş zamanlarını tekrarlayın.
                D2 / N Üst öğeyi kopyalayın ve yazdırın.
                    aO Newline (Bunun geçerli bir ayrım olduğundan eminim)
                      2+ Yığının en üst öğesine bir tane ekleyin.

TeaScript , 16 bayt 18

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

Gayet basit. Özel karakterler aslında daha uzun kod dizileri için "kısaltmalar" dır.

Hala kalıcı bağlantı yapmadım, bu yüzden yapıştırıcıyı tercümana kopyalamanız gerekecek

açıklama

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
)

_{Bu cevap rakip değil}

F #, 38 bayt

Falsey sonucu boş bir listedir.

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

𝔼𝕊𝕄𝕚𝕟, 21 karakter / 37 bayt

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

Try it here (Firefox only).

İşte 20 karakterlik / 35 baytlık bir yanıt (rakip olmayan, çünkü soru sorulduktan sonra uygulanan değişiklikleri kullandığından):

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

Try it here (Firefox only).

Japt, 21 19 bayt

Japt kısaltılmış versiyonudur Ja vaScri nk .

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

Tek girişler için x, ortalanmış bir tamsayı uzunluk dizisi döndürür 0; çift ​​için 0 döndürür. Kaba JS çevirisi:

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

nerede x.range(y)arasındaki tam sayıların listesini oluşturur xiçin y. Çevrimiçi test edin!

Modern Japt'te bu sadece 11 bayttır:

u ©Uo-U/2-½

Çevrimiçi deneyin!

R, 30 bayt

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

Kabaca, x:-xgelen tamsayılar döndüren xiçin -xbelirlediğim yere, xiçin (1-n)/2. Ayrıca Modülo-2 faktör kullanmak n%%2tanımında xkuvvetine xsıfıra n, hatta bu durumda, 0:0döner 0(Falsey).

Perl, 36 bayt

Bunun kısaltılabileceğini hissediyorum:

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

Aralık, şamandıraları tamsayı olarak ele alır, örneğin 5/2 = 2,5 sessizce 2'ye dönüştürülür.

(Biçimlendirme önemli değilse, $,=$";toplam 30 bayt için kaldırın ).

Powershell, 49 bayt

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

$falseBoş satır çıktısı sağladığından sayılar bile değerlendirilir .

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

Tek sayılar, tam referans dizesini verir. Çıkış dizesinden 45kaldırarak 4 bayt (şimdi ) kaydedebilirsiniz [].

PS> .\balanced.ps1 4


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

PS> .\balanced.ps1 0


PS> .\balanced.ps1 1
[0]

PS> 

Powershell, 36 Bayt

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

Bu aynı falsey sonucuna sahiptir, ancak yeni satırlarla ayrılmış sayıların listesini çıkarır:

PS> .\balanced-newline.ps1 4

PS> .\balanced-newline.ps1 1
0

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

PS>

Perl 6, 25 bayt

Ben bir aralık yerine bir liste çıktı bu ile gelebilir en kısa lambda ifade:

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

Test yapmak:

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

Bu, Perl 6'nın sayıyı 0yanlış bir değer olarak ele almasından yararlanır . Çıkış olmak olsaydı tam Falsesize yerini alabilir $_%2ile $_!%%2.

05AB1E , 8 bayt (rakip olmayan)

Dil bu mücadeleden sonra gelir ve bu nedenle rekabet etmez. Kod:

È#¹;D(ŸR

Çevrimiçi deneyin!

Açıklama:

È#        # 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 kodlamasını kullanır .

PHP, 50 bayt

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

programı, STDIN'den girdi alır, _sınırlandırılmış liste veya yazdırır 0.

veya

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

işlevi argüman alır, dizi veya döndürür 0.

Java, 145 bayt

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);}}}

Açıklama: Üzgünüm, bunun çok uzun olduğunu biliyorum. Java için bir cevap görmedim bu yüzden bir koymak karar verdi. Ana işlevi yazmak gerekip gerekmediğini bana bildirin (bu politika olup olmadığını emin değilim). Temel olarak sayıyı ikiye böler ve alt sınır için -1 ile çarpar ve üst sınır için sadece ikiye bölünen sayıyı kullanır. Bu sayfa için biraz yeniyim, bu yüzden doğru bir şey biçimlendirmediysem bana bildirin. Ayrıca, cevapların lambda fonksiyonları ile kısaltılabileceğini biliyorum, ancak bunları nasıl kullanacağımı bilmiyorum ve Java'nın bunları destekleyip desteklemediğinden emin değilim.

İşte daha az golf olan daha okunabilir bir versiyon:

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);
    }
}
}

Yakut, 25 bayt

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

Yakut, 27 bayt

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

nN garip ise 0'a en yakın sayı dizisini döndürecek anonim bir lambda işlevi oluşturur ve aksi takdirde nil (ruby'de bir falsey değeri) döndürür.

Ruby tamsayı bölümünü sonsuzluğa doğru yuvarlar, ancak (eksi işareti zaten orada olduğu için) ' 0-n/2den daha kısadır -n/2+1ve n şimdi pozitif kabul edildiğinden, yuvarlama benim lehime çalışır.

Eski Sürüm (28 bayt)

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