Ziel : Bei einer positiven Ganzzahl n:

• Wenn dies nungerade ist, geben Sie die Liste der nZahlen aus, die 0in aufsteigender Reihenfolge am nächsten liegen
• Wenn ngerade, geben Sie einen Falsey-Wert aus.

Testfälle :

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

Referenzimplementierung

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 Bytes

*-R/Q2Q%Q2

Probieren Sie es online aus.

Wie es funktioniert

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

Danke an @Dennis für -2 Bytes!

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

Dies ist ein monadischer Zug, der ein leeres Array für gleichmäßige Eingaben liefert. Unten ist das Diagramm:

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

Erstens ⊢×2|⊢gibt die Eingabe mal ihren Mod 2; Das heißt, die Gewinnchancen geben sich von selbst und die Gleichgewichte geben 0. Wir ⍳erstellen eine Liste von Zahlen von 1 bis 1 ( ⍳0geben das leere Array an) und subtrahieren dann die Hälfte der Eingabe und des Bodens.

Mathematica, 32 30 24 Bytes

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

Code-Golf-Trick: Das letzte Argument Andmuss kein Boolescher sein.

PowerShell, 50 52 Byte

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

Uff. Ziemlich ausführliche Antwort. Nimmt Eingaben vor $aund legt dann eine neue Variable $bals "Etage" von fest $a/2. Erzeugt einen neuen Zahlenbereich von (0-$b)bis $b, dann joins den Bereich mit Leerzeichen und hat diesen als zweites Element eines Arrays mit zwei Elementen (das erste Element ist 0). Verwendet dann, $a%2um in dieses Array für die Ausgabe zu indizieren.

Alternative Version mit mehr "traditionellem" if / else-Fluss bei 54 Bytes:

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

_{Bearbeiten - Muss eine Logik hinzufügen, um einen Falsey-Wert auszugeben, wenn die Eingabe gerade ist}

Haskell, 37 36 31 Bytes

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

Unausgeglichen wird durch die leere Liste angezeigt. Anwendungsbeispiel: g 7-> [-3,-2,-1,0,1,2,3].

@xnor hat 5 Bytes gefunden. Vielen Dank!

JavaScript (ES6), 44 43 42 41 Byte

^{durchgestrichen 44 ist immer noch regulär 44; (}

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

Gibt bei ungeraden Eingaben ein ganzzahliges Array mit einer Länge zurück x, das auf zentriert ist 0. für gerade, gibt 0 zurück. Ich denke, das ist so kurz wie es nur geht. (Ein paar Bytes dank @ edc65 und @ ן nɟuɐɯɹɐ ן oɯ gespeichert!)

ES6-Alternative: (42 Bytes dank @intrepidcoder)

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

Vorschläge willkommen!

Minkolang 0,10 , 18 Bytes

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

Erläuterung

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 Bytes

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

Dies ist ein monadisches Verb, das 0für gerade Zahlen zurückgibt (falsch). Versuchen Sie es online mit J.js .

Testlauf

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

Wie es funktioniert

              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 Bytes

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

Try it here.

Anonymes Lambda. Verwendungszweck:

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

Erläuterung

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

Im Moment bin ich mir nicht sicher, ob ich ausgeben kann, was ich will, wenn es nicht ausgeglichen ist. Derzeit wird nur eine leere Liste zurückgegeben, wenn die Basis nicht ausgeglichen ist. Es ist eine anonyme Lambda-Funktion, geben Sie ihr also einen Namen, um sie zu verwenden.

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

CJam, 13 12 Bytes

{_2md@,@f-*}

Dies ist eine anonyme Funktion, die eine Ganzzahl aus dem Stapel entfernt und im Gegenzug ein Ziffernarray (ungerade Basis) oder ein leeres Array (gerade Basis) verschiebt. Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

_          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

Live-Demo.

Vitsy, 27 25 Bytes

Ich werde morgen Golf spielen, aber ich sollte jetzt wirklich ins Bett gehen.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Duplizieren Sie die Eingabe.
 2M) [& 1] Wenn die Eingabe gerade ist (Eingabe% 2 = 0), wird ein neuer Stapel generiert
                              und drücke 1 dazu.
        D Duplizieren Sie den Spitzenwert - wenn er nicht gerade ist, ist dies die Eingabe. Ansonsten ist es eins.
         1- Subtrahiere eins (um um Null zu balancieren)
           i * Additiv invertieren
             } Verschieben Sie über ein Element im Stapel - dies stellt dies sicher
                              Wir haben entweder den Eingang oder einen oben.
              \ [] Eingabezeiten wiederholen.
                D2 / N Dupliziere das oberste Element und drucke es aus.
                    aO Newline (Ich bin mir ziemlich sicher, dass dies eine gültige Trennung ist)
                      2+ Fügen Sie eine zum obersten Element des Stapels hinzu.

TeaScript , 16 Bytes 18

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

Ziemlich einfach. Die Sonderzeichen sind eigentlich nur "Abkürzungen" für längere Codesequenzen.

Ich habe noch keine Permalinks erstellt, daher müssen Sie das Einfügen in den Interpreter kopieren

Erläuterung

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
)

_{Diese Antwort ist nicht konkurrierend}

F #, 38 Bytes

Das falsche Ergebnis ist eine leere Liste.

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

𝔼𝕊𝕄𝕚𝕟 21 Zeichen / 37 Bytes

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

Try it here (Firefox only).

Hier ist eine 20-Zeichen / 35-Byte-Antwort (nicht konkurrierend, da die Antwort Änderungen verwendet, die nach dem Stellen der Frage implementiert wurden):

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

Try it here (Firefox only).

Japt, 21 19 Bytes

Japt ist eine verkürzte Version von Ja vaScri pt .

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

Gibt bei ungeraden Eingaben ein ganzzahliges Array mit einer Länge zurück x, das auf zentriert ist 0. für gerade, gibt 0 zurück. Grobe JS-Übersetzung:

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

Dabei x.range(y)wird eine Liste von Ganzzahlen von xbis erstellt y. Testen Sie es online!

Im modernen Japt sind dies nur 11 Bytes:

u ©Uo-U/2-½

Probieren Sie es online aus!

R, 30 Bytes

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

Gibt ungefähr x:-xdie ganzen Zahlen von xbis zurück -x, auf die ich gesetzt xhabe (1-n)/2. Ich verwende auch den Modulo-2-Faktor n%%2in der Definition von x, um xauf Null zu zwingen , wenn gerade nist, und in diesem Fall 0:0zurückkehrt 0(falsey).

Perl, 36 Bytes

Ich habe das Gefühl, dass dies verkürzt werden kann:

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

Range behandelt Floats als Ganzzahlen, z. B. wird 5/2 = 2,5 stillschweigend in 2 konvertiert.

(Wenn die Formatierung keine Rolle spielt, entfernen Sie sie $,=$";für insgesamt 30 Byte.)

Powershell, 49 Bytes

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

$falseGerade Zahlen werden ausgewertet, da sie eine Leerzeilenausgabe liefern.

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

Ungerade Zahlen geben die genaue Referenzzeichenfolge aus. Sie können (jetzt 45) 4 weitere Bytes speichern, indem Sie die []aus der Ausgabezeichenfolge entfernen .

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 Bytes

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

Dies hat das gleiche falsche Ergebnis, gibt jedoch die Liste der durch Zeilenumbrüche getrennten Zahlen aus:

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 Bytes

Der kürzeste Lambda-Ausdruck, den ich finden könnte, der eine Liste anstelle eines Bereichs ausgibt, ist:

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

Testen:

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

Dies nutzt die Tatsache aus, dass Perl 6 die Zahl 0als falschen Wert behandelt. Wenn die Ausgabe genau sein musste Falsekönnten Sie ersetzen $_%2mit $_!%%2.

05AB1E , 8 Bytes (nicht konkurrierend)

Die Sprache datiert die Herausforderung nach und ist daher nicht konkurrierend. Code:

È#¹;D(ŸR

Probieren Sie es online aus!

Erläuterung:

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

Verwendet die CP-1252- Codierung.

PHP, 50 Bytes

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

Programm, nimmt Eingaben von STDIN entgegen, druckt eine _begrenzte Liste oder 0.

oder

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

Funktion nimmt Argument, gibt Array oder zurück 0.

Java, 145 Bytes

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

Erklärung: Entschuldigung, ich weiß, das ist wirklich lang. Ich habe keine Antwort für Java gesehen, also habe ich beschlossen, eine einzutragen. Lassen Sie mich wissen, ob ich die Hauptfunktion schreiben muss (ich bin mir nicht sicher, ob das die Richtlinie ist oder nicht). Grundsätzlich teilt es die Zahl durch zwei und multipliziert sie mit -1 für die Untergrenze und für die Obergrenze verwendet es nur die durch zwei geteilte Zahl. Ich bin ein bisschen neu auf dieser Seite. Wenn ich also nichts richtig formatiert habe, lass es mich wissen. Ich weiß auch, dass Antworten mit Lambda-Funktionen verkürzt werden können, aber ich weiß nicht, wie ich sie verwenden soll, und ich bin mir nicht sicher, ob Java sie unterstützt.

Hier ist eine besser lesbare Version, die weniger Golf spielt:

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

Ruby, 25 Bytes

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

Ruby, 27 Bytes

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

Erstellt eine anonyme Lambda-Funktion, die das Array von nZahlen zurückgibt, das 0 am nächsten kommt, wenn n ungerade ist, und andernfalls nil (ein Falsey-Wert in Ruby) zurückgibt.

Ruby rundet seine ganzzahlige Division in Richtung -Infinity ab, aber 0-n/2 kürzer als-n/2+1 (da das Minuszeichen sowieso vorhanden ist), und da n jetzt als positiv angesehen wird, wirkt die Rundung zu meinen Gunsten.

Alte Version (28 Bytes)

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