Objetivo : dado un entero positivo n:

• Si nes impar, muestre la lista de nnúmeros más cercanos 0en orden creciente
• Si nes par, genera un valor de Falsey.

Casos de prueba :

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

Implementación de referencia

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

Pruébalo en línea.

Cómo funciona

            (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

¡Gracias a @Dennis por -2 bytes!

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

Este es un tren monádico que proporciona una matriz vacía para una entrada uniforme. A continuación se muestra el diagrama:

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

Primero, ⊢×2|⊢le da a la entrada veces su mod 2; es decir, las probabilidades se darán a sí mismas, y las pares darán 0. Usamos ⍳para crear una lista de números de 1 a eso ( ⍳0da la matriz vacía), y luego restamos la mitad de la entrada y el piso.

Mathematica, 32 30 24 bytes

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

Truco de golf de código: el último argumento para Andno tiene que ser un booleano.

PowerShell, 50 52 bytes

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

Oof Respuesta bastante detallada. Toma entrada $a, luego establece una nueva variable $bcomo el "piso" de $a/2. Genera un nuevo rango de números desde (0-$b)hasta $b, luego joins el rango con espacios, y lo tiene como el segundo elemento de una matriz de dos elementos (el primer elemento es 0). Luego se utiliza $a%2para indexar en esa matriz para la salida.

Versión alternativa que usa un flujo if / else más "tradicional", a 54 bytes:

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

_{Editar: necesario para agregar algo de lógica para generar un valor falsey si la entrada es uniforme}

Haskell, 37 36 31 bytes

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

Desequilibrado se indica mediante la lista vacía. Ejemplo de uso: g 7-> [-3,-2,-1,0,1,2,3].

@xnor encontró 5 bytes. ¡Gracias!

JavaScript (ES6), 44 43 42 41 bytes

^{tachado 44 sigue siendo regular 44; (}

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

Para entradas impares, devuelve una matriz entera de longitud x, centrada en 0; para incluso, devuelve 0. Creo que esto es lo más corto posible. (¡Ahorré un par de bytes gracias a @ edc65 y @ ן nɟuɐɯɹɐ ן oɯ!)

Alternativa ES6: (42 bytes, gracias a @intrepidcoder)

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

Sugerencias bienvenidas!

Minkolang 0.10 , 18 bytes

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

Explicación

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&|

Este es un verbo monádico que devuelve 0(falso) para números pares. Pruébelo en línea con J.js .

Prueba de funcionamiento

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

Cómo funciona

              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.

Lambda anónima. Uso:

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

Explicación

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

En este momento no estoy seguro si puedo generar lo que quiera si no está equilibrado, por lo que actualmente esto solo devuelve una lista vacía en el caso de una base desequilibrada. Es una función lambda anónima, así que dale un nombre para usarla.

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

CJam, 13 12 bytes

{_2md@,@f-*}

Esta es una función anónima que saca un número entero de la pila y empuja una matriz de dígitos (base impar) o una matriz vacía (base par) a cambio. Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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

Vitsy, 27 25 bytes

Mañana jugaré golf, pero realmente debería irme a la cama ahora.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Duplicar la entrada.
 2M) [& 1] Si la entrada es par (entrada% 2 = 0) genera una nueva pila
                              y presiona 1 hacia él.
        D Duplique el valor superior; si no fuera uniforme, esta será la entrada. De lo contrario, es uno.
         1- Resta uno (para equilibrar alrededor de cero)
           i * Invertir aditivamente
             } Cambiar sobre un elemento en la pila: esto asegura que
                              Tenemos la entrada o una en la parte superior.
              \ [] Repita los tiempos de entrada.
                D2 / N Duplicar el elemento superior e imprimirlo.
                    aO Newline (estoy bastante seguro de que esta es una separación válida)
                      2+ Agregue uno al elemento superior de la pila.

TeaScript , 16 bytes 18

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

Bastante simple. Los caracteres especiales son en realidad "abreviaturas" para secuencias de código más largas.

Todavía no he hecho enlaces permanentes, así que tendrás que copiar y pegar en el intérprete

Explicación

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
)

_{Esta respuesta no es competitiva.}

F #, 38 bytes

El resultado falsey es una lista vacía.

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

𝔼𝕊𝕄𝕚𝕟, 21 caracteres / 37 bytes

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

Try it here (Firefox only).

Aquí hay una respuesta de 20 caracteres / 35 bytes (no competitiva, ya que la respuesta utiliza cambios implementados después de que se hizo la pregunta):

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

Try it here (Firefox only).

Japt, 21 19 bytes

Japt es una versión abreviada de Ja vaScri pt .

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

Para entradas impares, devuelve una matriz entera de longitud x, centrada en 0; para par, devuelve 0. Traducción aproximada de JS:

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

donde x.range(y)crea una lista de enteros de xa y. ¡Pruébalo en línea!

En Japt moderno, esto es solo 11 bytes:

u ©Uo-U/2-½

Pruébalo en línea!

R, 30 bytes

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

A grandes rasgos, x:-xdevuelve los números enteros de xa -x, donde hice xa (1-n)/2. También utilizo el factor módulo 2 n%%2en la definición de xforzar xa cero cuando nes par, en cuyo caso, 0:0retornos 0(falsey).

Perl, 36 bytes

Tengo la sensación de que esto se puede acortar:

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

El rango trata los flotantes como enteros, por lo que, por ejemplo, 5/2 = 2.5 se convierte silenciosamente en 2.

(Si el formato no importa, elimínelo $,=$";por un total de 30 bytes).

Powershell, 49 bytes

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

Números pares evaluados $falseya que proporcionan una salida de línea vacía.

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

Los números impares generan la cadena de referencia exacta. Puede guardar 4 bytes más (ahora 45) quitando el []de la cadena de salida.

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)

Esto tiene el mismo resultado falsey pero genera la lista de números separados por nuevas líneas:

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

La expresión lambda más corta que se me ocurrió que genera una lista en lugar de un rango es:

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

Pruebas:

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

Esto aprovecha el hecho de que Perl 6 trata el número 0como un valor falso. Si la salida tuvo que ser exactamente Falsepodría reemplazar $_%2con $_!%%2.

05AB1E , 8 bytes (no competitivos)

El lenguaje es posterior al desafío y, por lo tanto, no es competitivo. Código:

È#¹;D(ŸR

Pruébalo en línea!

Explicación:

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

Utiliza la codificación CP-1252 .

PHP, 50 bytes

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

programa, toma la entrada de STDIN, imprime la _lista delimitada o 0.

o

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

La función toma argumento, devuelve matriz o 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);}}}

Explicación: Lo siento, sé que esto es realmente largo. No vi una respuesta para Java, así que decidí poner una. Avíseme si necesito escribir la función principal (no estoy seguro de si esa es la política o no). Básicamente divide el número por dos y lo multiplica por -1 para el límite inferior y para el límite superior solo usa el número dividido por dos. Soy un poco nuevo en esta página, así que si no formateé nada correctamente, avíseme. Además, sé que las respuestas se pueden acortar con las funciones lambda, pero no sé cómo usarlas y no estoy seguro de si Java las admite.

Aquí hay una versión más legible que es menos 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);
    }
}
}

Rubí, 25 bytes.

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

Rubí, 27 bytes

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

Crea una función lambda anónima que devolverá la matriz de nnúmeros más cercana a 0 si n es impar y, de lo contrario, devuelve nil (un valor falsey en rubí).

Ruby redondea su división entera hacia -infinito, pero 0-n/2es más corta que -n/2+1(ya que el signo menos está ahí de todos modos), y debido a que n ahora se considera positivo, el redondeo funciona a mi favor.

Versión anterior (28 bytes)

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