Obiettivo : dato un numero intero positivo n:

• Se nè dispari, visualizza l'elenco dei nnumeri più vicini all'ordine 0crescente
• Se nè pari, genera un valore Falsey.

Casi di prova :

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

Implementazione di riferimento

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 byte

*-R/Q2Q%Q2

Provalo online.

Come funziona

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

Grazie a @Dennis per -2 byte!

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

Questo è un treno monadico che fornisce un array vuoto per un input uniforme. Di seguito è riportato il diagramma:

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

Innanzitutto, ⊢×2|⊢dà ai tempi di input la sua mod 2; vale a dire, le probabilità si daranno e le pari daranno 0. Usiamo ⍳per creare un elenco di numeri da 1 a quello ( ⍳0dà l'array vuoto), e quindi sottraggiamo metà dell'input e del floor.

Mathematica, 32 30 24 byte

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

Il trucco del code-golf: l'ultimo argomento a Andnon deve essere un booleano.

PowerShell, 50 52 byte

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

Oof. Risposta piuttosto dettagliata. Accetta input $a, quindi imposta una nuova variabile $bcome "floor" di $a/2. Genera un nuovo intervallo di numeri da (0-$b)a $b, quindi joins l'intervallo con spazi e lo ha come secondo elemento di una matrice a due elementi (il primo elemento è 0). Quindi utilizza $a%2per indicizzare quell'array per l'output.

Versione alternativa che utilizza un flusso if / else più "tradizionale", a 54 byte:

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

_{Modifica - Necessario per aggiungere un po 'di logica per generare un valore di falso se l'input è pari}

Haskell, 37 36 31 byte

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

Sbilanciato è indicato dalla lista vuota. Esempio di utilizzo: g 7-> [-3,-2,-1,0,1,2,3].

@xnor ha trovato 5 byte. Grazie!

JavaScript (ES6), 44 43 42 41 byte

^{barrato 44 è ancora regolare 44;}

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

Per input dispari, restituisce un array intero di lunghezza x, centrato a0 ; per pari, restituisce 0. Penso che questo sia il più breve possibile. (Salvato un paio di byte grazie a @ edc65 e @ ן nɟuɐɯɹɐ ן oɯ!)

Alternativa ES6: (42 byte, grazie a @intrepidcoder)

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

Suggerimenti benvenuti!

Minkolang 0,10 , 18 byte

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

Spiegazione

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 byte

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

Questo è un verbo monadico che ritorna 0 (falsa) per numeri pari. Provalo online con J.js .

Prova

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

Come funziona

              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 byte

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

Try it here.

Lambda anonimo. Uso:

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

Spiegazione

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

In questo momento non sono sicuro di poter produrre tutto ciò che voglio se non è bilanciato, quindi al momento questo restituisce solo un elenco vuoto nel caso di una base non bilanciata. È una funzione lambda anonima, quindi dagli un nome per usarla.

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

CJam, 13 12 byte

{_2md@,@f-*}

Questa è una funzione anonima che estrae un numero intero dallo stack e invia in cambio una matrice di cifre (base dispari) o una matrice vuota (base pari). Provalo online nell'interprete CJam .

Come funziona

_          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

Dimostrazione dal vivo.

Vitsy, 27 25 byte

Domani giocherò a golf, ma adesso dovrei davvero andare a letto.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Duplicare l'ingresso.
 2M) [& 1] Se l'ingresso è pari (input% 2 = 0) genera un nuovo stack
                              e premi 1 su di esso.
        D Duplica il valore più alto - se non fosse pari, questo sarà l'input. Altrimenti, è uno.
         1- Sottrai uno (per bilanciare intorno a zero)
           * Inverti in modo additivo
             } Sposta sopra un oggetto nello stack - questo lo assicura
                              abbiamo l'input o uno in cima.
              \ [] Ripeti i tempi di input.
                D2 / N Duplica l'elemento in alto e stampalo.
                    aO Newline (sono abbastanza sicuro che si tratti di una separazione valida)
                      2+ Aggiungine uno all'elemento in cima alla pila.

TeaScript , 16 byte 18

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

Abbastanza semplice. I caratteri speciali sono in realtà solo "abbreviazioni" per sequenze di codici più lunghe.

Non ho ancora creato permalink, quindi dovrai copiare la copia nell'interprete

Spiegazione

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
)

_{Questa risposta è non competitiva}

F #, 38 byte

Il risultato della falsità è un elenco vuoto.

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

𝔼𝕊𝕄𝕚𝕟, 21 caratteri / 37 byte

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

Try it here (Firefox only).

Ecco una risposta di 20 caratteri / 35 byte (non competitiva, poiché la risposta utilizza le modifiche implementate dopo che è stata posta la domanda):

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

Try it here (Firefox only).

Japt, 21 19 byte

Japt è una versione abbreviata di Ja vaScri pt .

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

Per input dispari, restituisce un array intero di lunghezza x, centrato a 0; per pari, restituisce 0. Traduzione JS approssimativa:

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

dove x.range(y)crea un elenco di numeri interi da xa y. Provalo online!

Nel moderno Japt, questo è solo 11 byte:

u ©Uo-U/2-½

Provalo online!

R, 30 byte

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

Approssimativamente, x:-xrestituisce gli interi da xa -x, dove ho impostato xa (1-n)/2. Uso anche il fattore modulo-2 n%%2nella definizione di xforzare xa zero quando nè pari, nel qual caso, 0:0ritorna 0(falso).

Perl, 36 byte

Sento che questo può essere abbreviato:

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

L'intervallo tratta i numeri fluttuanti come numeri interi, quindi ad esempio 5/2 = 2.5 viene convertito silenziosamente in 2.

(Se la formattazione non ha importanza, rimuovila $,=$";per un totale di 30 byte).

Powershell, 49 byte

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

Numeri pari valutati $falsepoiché forniscono un output di riga vuota.

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

I numeri dispari producono la stringa di riferimento esatta. È possibile salvare altri 4 byte (ora 45) rimuovendo []dalla stringa di output.

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 byte

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

Questo ha lo stesso risultato di falsità ma restituisce l'elenco di numeri separati da newline:

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 byte

L'espressione lambda più breve che ho potuto inventare che genera un elenco anziché un intervallo è:

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

test:

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

Ciò sfrutta il fatto che Perl 6 considera il numero 0come un valore falso. Se l'output dovesse essere esattamente Falsepuoi sostituirlo $_%2con $_!%%2.

05AB1E , 8 byte (non concorrenti)

Il linguaggio postdatizza la sfida ed è quindi non competitivo. Codice:

È#¹;D(ŸR

Provalo online!

Spiegazione:

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

Utilizza la codifica CP-1252 .

PHP, 50 byte

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

programma, accetta input da STDIN, stampa l' _elenco delimitato o 0.

o

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

La funzione accetta argomenti, restituisce array o 0.

Java, 145 byte

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

Spiegazione: Mi dispiace, lo so che è molto lungo. Non ho visto una risposta per java, quindi ho deciso di inserirne una. Fammi sapere se devo scrivere la funzione principale (non sono sicuro che sia la politica o meno). Fondamentalmente divide il numero per due e lo moltiplica per -1 per il limite inferiore e per il limite superiore utilizza solo il numero diviso per due. Sono un po 'nuovo in questa pagina, quindi se non ho formattato nulla nel modo giusto fammelo sapere. Inoltre, so che le risposte possono essere abbreviate con le funzioni lambda, ma non so come usarle e non sono sicuro che Java le supporti.

Ecco una versione più leggibile che è meno giocata a golf:

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

Rubino, 25 byte

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

Rubino, 27 byte

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

Crea una funzione lambda anonima che restituirà l'array di n numeri più vicino a 0 se n è dispari e restituisce nil (un valore false in ruby) in caso contrario.

Ruby arrotonda la sua divisione intera verso -infinito, ma 0-n/2è più breve di-n/2+1 (poiché il segno meno è presente comunque) e poiché n è ora considerato positivo, l'arrotondamento funziona a mio favore.

Vecchia versione (28 byte)

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