Cel : Biorąc pod uwagę dodatnią liczbę całkowitą n:

• Jeśli njest nieparzyste, wypisz listę nliczb najbliższych 0w porządku rosnącym
• Jeśli njest parzysty, wypisz wartość Falsey.

Przypadki testowe :

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

Realizacja referencyjna

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 bajtów

*-R/Q2Q%Q2

Wypróbuj online.

Jak to działa

            (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 bajtów

Dzięki @Dennis za -2 bajty!

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

Jest to monadyczny ciąg, który daje pustą tablicę do równomiernego wprowadzania. Poniżej znajduje się schemat:

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

Po pierwsze, ⊢×2|⊢podaje czasy wejściowe jego mod 2; oznacza to, że szanse same się dadzą, a wyrównanie daje 0. Używamy ⍳do tworzenia listy liczb od 1 do tego ( ⍳0daje pustą tablicę), a następnie odejmujemy połowę wartości wejściowej i dolnej.

Mathematica, 32 30 24 bajtów

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

Sztuczka do gry w golfa: Ostatni argument Andnie musi być logiczny.

PowerShell, 50 52 bajtów

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

Nie. Całkiem szczegółowa odpowiedź. Pobiera dane wejściowe $a, a następnie ustawia nową zmienną $bjako „floor” parametru $a/2. Generuje nowy zakres liczb od (0-$b)do $b, następnie joins zakres ze spacjami i ma go jako drugi element tablicy dwuelementowej (pierwszy element to 0). Następnie używa $a%2do indeksowania do tej tablicy w celu uzyskania danych wyjściowych.

Alternatywna wersja wykorzystująca bardziej „tradycyjny” przepływ if / else, o 54 bajtach:

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

_{Edycja - Konieczne było dodanie logiki do wyświetlania wartości falsey, jeśli dane wejściowe są parzyste}

Haskell, 37 36 31 bajtów

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

Niezrównoważony jest wskazywany przez pustą listę. Przykład użycia: g 7-> [-3,-2,-1,0,1,2,3].

@ xnor znalazł 5 bajtów. Dzięki!

JavaScript (ES6), 44 43 42 41 bajtów

^{przekreślone 44 jest nadal regularne 44; (}

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

Dla nieparzystych danych wejściowych zwraca tablicę liczb całkowitych o długości x, wyśrodkowaną na 0; nawet, zwraca 0. Myślę, że jest to tak krótkie, jak to tylko możliwe. (Zapisano kilka bajtów dzięki @ edc65 i @ ן nɟuɐɯɹɐ ן oɯ!)

Alternatywa ES6: (42 bajty, dzięki @intrepidcoder)

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

Sugestie mile widziane!

Minkolang 0,10 , 18 bajtów

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

Wyjaśnienie

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 bajtów

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

Jest to czasownik monadyczny, który zwraca 0(fałsz) liczby parzyste. Spróbuj go online z J.js .

Testowe uruchomienie

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

Jak to działa

              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 bajtów

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

Try it here.

Anonimowa lambda. Stosowanie:

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

Wyjaśnienie

[                             ] {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 bajtów

W tej chwili nie jestem pewien, czy mogę wyprowadzić cokolwiek chcę, jeśli nie jest zbalansowane, więc obecnie to po prostu zwraca pustą listę w przypadku podstawy niezrównoważonej. Jest to anonimowa funkcja lambda, więc nadaj jej nazwę, aby z niej korzystać.

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

CJam, 13 12 bajtów

{_2md@,@f-*}

Jest to anonimowa funkcja, która wyrzuca liczbę całkowitą ze stosu i w zamian wypycha tablicę cyfr (podstawa nieparzysta) lub pustą tablicę (podstawa parzysta). Wypróbuj online w interpretatorze CJam .

Jak to działa

_          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

Demo na żywo.

Vitsy, 27 25 bajtów

Jutro zagram w golfa, ale naprawdę powinienem teraz iść spać.

D2M) [i 1] D1-i *} \ [D2 / NaO2 +]
D Zduplikuj dane wejściowe.
 2M) [i 1] Jeśli dane wejściowe są parzyste (% 2 = 0), wygeneruj nowy stos
                              i wciśnij 1.
        D Zduplikuj najwyższą wartość - jeśli nie była parzysta, będzie to wejście. W przeciwnym razie to jeden.
         1- Odejmij jeden (aby zrównoważyć około zera)
           i * Dodatkowo odwracaj
             } Przesuń na przedmiot na stosie - to zapewni
                              mamy wejście lub jedno na górze.
              \ [] Powtórz czasy wprowadzania.
                D2 / N Zduplikuj najwyższy element i wydrukuj go.
                    aO Newline (jestem prawie pewien, że to jest poprawna separacja)
                      2+ Dodaj jeden do najwyższego elementu stosu.

TeaScript , 16 bajtów 18

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

Dość proste. Znaki specjalne są w rzeczywistości tylko „skrótami” dla dłuższych sekwencji kodu.

Nadal nie tworzyłem permalinków, więc będziesz musiał skopiować wklej do interpretera

Wyjaśnienie

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
)

_{Ta odpowiedź nie jest konkurencyjna}

F #, 38 bajtów

Wynik falsey to pusta lista.

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

𝔼𝕊𝕄𝕚𝕟, 21 znaków / 37 bajtów

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

Try it here (Firefox only).

Oto 20-znakowa / 35-bajtowa odpowiedź (niekonkurencyjna, ponieważ odpowiedź wykorzystuje zmiany wprowadzone po zadaniu pytania):

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

Try it here (Firefox only).

Japt, 21 19 bajtów

Japt to skrócona wersja Ja vaScri pt .

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

Dla nieparzystych danych wejściowych zwraca tablicę liczb całkowitych o długości x, wyśrodkowaną na 0; dla parzystych zwraca 0. Szorstkie tłumaczenie JS:

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

gdzie x.range(y)tworzy listę liczb całkowitych od xdo y. Przetestuj online!

W nowoczesnym Japt jest to tylko 11 bajtów:

u ©Uo-U/2-½

Wypróbuj online!

R, 30 bajtów

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

Mniej więcej, x:-xzwraca liczby całkowite od xcelu -x, gdzie mogę ustawić xna (1-n)/2. Używam również współczynnika modulo-2 n%%2w definicji xsiły xdo zera, gdy njest parzysta, w którym to przypadku 0:0zwraca 0(falsey).

Perl, 36 bajtów

Mam wrażenie, że można to skrócić:

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

Range traktuje liczby zmiennoprzecinkowe jako liczby całkowite, więc np. 5/2 = 2,5 zostaje po cichu przeliczone na 2.

(Jeśli formatowanie nie ma znaczenia, usuń $,=$";łącznie 30 bajtów).

PowerShell, 49 bajtów

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

Liczby parzyste obliczone do, $falseponieważ zapewniają puste wyjście liniowe.

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

Liczby nieparzyste wyświetlają dokładny ciąg odniesienia. Możesz zapisać jeszcze 4 bajty (teraz 45), usuwając []z ciągu wyjściowego.

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 bajtów

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

Ma to ten sam wynik falsey, ale wyświetla listę liczb oddzielonych znakami nowej linii:

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 bajtów

Najkrótsze wyrażenie lambda, jakie mogłem wymyślić, które wyświetla listę, a nie zakres, to:

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

Testowanie:

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

Wykorzystuje to fakt, że Perl 6 traktuje liczbę 0jako wartość fałszywą. Jeśli wyjście musiał być dokładnie Falsemożna zastąpić $_%2z $_!%%2.

05AB1E , 8 bajtów (niekonkurujące)

Język jest późniejszy od wyzwania i dlatego nie konkuruje. Kod:

È#¹;D(ŸR

Wypróbuj online!

Wyjaśnienie:

È#        # 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

Wykorzystuje kodowanie CP-1252 .

PHP, 50 bajtów

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

program, pobiera dane ze STDIN, drukuje _listę rozdzielaną lub 0.

lub

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

funkcja przyjmuje argument, zwraca tablicę lub 0.

Java, 145 bajtów

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

Wyjaśnienie: Przepraszam, wiem, że to jest naprawdę długie. Nie widziałem odpowiedzi dla java, więc zdecydowałem się ją włożyć. Daj mi znać, czy muszę napisać główną funkcję (nie jestem pewien, czy taka jest polityka, czy nie). Zasadniczo dzieli liczbę przez dwa i mnoży ją przez -1 dla dolnej granicy, a dla górnej granicy po prostu używa liczby podzielonej przez dwa. Jestem trochę nowa na tej stronie, więc jeśli niczego nie sformatowałem, daj mi znać. Wiem też, że odpowiedzi można skracać za pomocą funkcji lambda, ale nie wiem, jak ich używać i nie jestem pewien, czy Java je obsługuje.

Oto bardziej czytelna wersja, która jest mniej golfowa:

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

Rubin, 25 bajtów

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

Rubinowy, 27 bajtów

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

Tworzy anonimową funkcję lambda, która zwróci tablicę nliczb najbliższych 0, jeśli n jest nieparzysta, w przeciwnym razie zwraca zero (wartość falsey w ruby).

Ruby zaokrągla swój podział na liczby całkowite w kierunku-nieskończoności, ale 0-n/2jest krótszy niż -n/2+1(ponieważ i tak jest tam znak minus), a ponieważ n jest teraz uważane za dodatnie, zaokrąglanie działa na moją korzyść.

Stara wersja (28 bajtów)

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