Objetivo : Dado um número inteiro positivo n:

• Se nfor ímpar, imprima a lista de nnúmeros mais próximos 0em ordem crescente
• Se nfor par, imprima um valor Falsey.

Casos de teste :

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

Implementação de referência

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>

Pitão, 10 bytes

*-R/Q2Q%Q2

Experimente online.

Como 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

Obrigado a @Dennis por -2 bytes!

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

Este é um trem monádico que fornece uma matriz vazia para uma entrada uniforme. Abaixo está o diagrama:

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

Primeiro, ⊢×2|⊢fornece aos tempos de entrada seu mod 2; isto é, as probabilidades se dão e os pares dão 0. Usamos ⍳para criar uma lista de números de 1 a isso ( ⍳0fornece a matriz vazia) e depois subtraímos metade da entrada e do piso.

Mathematica, 32 30 24 bytes

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

Truque de código de golfe: o último argumento para Andnão precisa ser um booleano.

PowerShell, 50 52 bytes

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

Oof. Resposta bastante detalhada. Recebe entrada $ae define uma nova variável $bcomo o "piso" de $a/2. Gera um novo intervalo de números a partir (0-$b)de $b, em seguida,join é o intervalo com espaços e o possui como o segundo elemento de uma matriz de dois elementos (o primeiro elemento é 0). Em seguida, usa $a%2para indexar nessa matriz para saída.

Versão alternativa usando fluxo if / else mais "tradicional", a 54 bytes:

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

_{Editar - Necessário adicionar alguma lógica para gerar um valor falsey se a entrada for uniforme}

Haskell, 37 36 31 bytes

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

Desequilibrado é indicado pela lista vazia. Exemplo de uso: g 7-> [-3,-2,-1,0,1,2,3].

@xnor encontrado 5 bytes. Obrigado!

JavaScript (ES6), 44 43 42 41 bytes

^{riscado 44 ainda é regular 44;}

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

Para entradas ímpares, retorna uma matriz inteira de comprimento x , centralizada em 0; para pares, retorna 0. Acho que é o mais curto possível. (Salvou alguns bytes graças a @ edc65 e @ ן nɟuɐɯɹɐ ן oɯ!)

Alternativa ES6: (42 bytes, graças a @intrepidcoder)

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

Sugestões são bem-vindas!

Minkolang 0.10 , 18 bytes

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

Explicação

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 é um verbo monádico que retorna 0 (falsy) para números pares. Experimente online com J.js .

Execução de teste

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

Como 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ônimo. Uso:

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

Explicação

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

No momento, não tenho certeza se posso produzir o que quiser, se não estiver equilibrado; portanto, atualmente, isso retorna uma lista vazia no caso de uma base desequilibrável. É uma função lambda anônima, portanto, dê um nome para usá-la.

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

CJam, 13 12 bytes

{_2md@,@f-*}

Essa é uma função anônima que exibe um número inteiro da pilha e empurra uma matriz de dígitos (base ímpar) ou uma matriz vazia (base par) em troca. Experimente on-line no intérprete CJam .

Como 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

Demonstração ao vivo.

Vitsy, 27 25 bytes

Amanhã vou jogar golfe, mas preciso ir para a cama agora.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Duplique a entrada.
 2M) [& 1] Se a entrada for par (entrada% 2 = 0) gere uma nova pilha
                              e pressione 1 para ele.
        D Duplique o valor superior - se não for uniforme, essa será a entrada. Caso contrário, é um.
         1- Subtraia um (para equilibrar em torno de zero)
           i * Inverter de forma aditiva
             } Passe o mouse sobre um item na pilha - isso garante que
                              temos a entrada ou uma no topo.
              \ [] Repita os tempos de entrada.
                D2 / N Duplique o item superior e imprima-o.
                    aO Newline (tenho certeza de que essa separação é válida)
                      2+ Adicione um ao item superior da pilha.

TeaScript , 16 bytes 18

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

Bem simples. Os caracteres especiais são na verdade apenas "abreviações" para sequências de código mais longas.

Ainda não fiz permalinks, então você terá que copiar e colar no intérprete

Explicação

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 resposta não é competitiva}

F #, 38 bytes

O resultado falsey é uma lista vazia.

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

, 21 caracteres / 37 bytes

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

Try it here (Firefox only).

Aqui está uma resposta de 20 caracteres / 35 bytes (não concorrente, pois a resposta usa as alterações implementadas após a pergunta):

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

Try it here (Firefox only).

Japonês, 21 19 bytes

Japt é uma versão abreviada do Ja vaScri pt .

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

Para entradas ímpares, retorna uma matriz inteira de comprimento x, centralizada em 0; para par, retorna 0. Tradução JS aproximada:

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

onde x.range(y)cria uma lista de números inteiros de xpara y. Teste online!

No Japão moderno, são apenas 11 bytes:

u ©Uo-U/2-½

Experimente online!

R, 30 bytes

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

Grosso modo, x:-xretorna os números inteiros de xpara -x, onde eu defini xcomo (1-n)/2. Também uso o fator modulo-2 n%%2na definição de xforçar xa zero quando né par; nesse caso, 0:0retorna 0(falsey).

Perl, 36 bytes

Sinto que isso pode ser reduzido:

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

O intervalo trata flutuadores como números inteiros; portanto, por exemplo, 5/2 = 2,5 é convertido silenciosamente em 2.

(Se a formatação não importar, remova $,=$";para um total de 30 bytes).

PowerShell, 49 bytes

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

Números pares avaliados até $falseporque fornecem uma saída de linha vazia.

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

Os números ímpares emitem a string de referência exata. Você pode salvar mais 4 bytes (agora 45) removendo o []da string de saída.

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)

Isso tem o mesmo resultado falsey, mas gera a lista de números separados por novas linhas:

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

A expressão lambda mais curta que eu poderia criar que gera uma lista em vez de um intervalo é:

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

Teste:

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

Isso tira vantagem do fato de o Perl 6 tratar o número 0como um valor falso. Se a saída tivesse que ser exatamente, Falsevocê poderia substituir $_%2por $_!%%2.

05AB1E , 8 bytes (não concorrente)

O idioma é posterior ao desafio e, portanto, não é competitivo. Código:

È#¹;D(ŸR

Experimente online!

Explicação:

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

Usa a codificação CP-1252 .

PHP, 50 bytes

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

programa, recebe informações de STDIN, imprime _lista delimitada ou 0.

ou

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

A função aceita argumento, retorna matriz ou 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);}}}

Explicação: Desculpe, eu sei que isso é realmente longo. Como não vi uma resposta para java, resolvi colocar uma. Informe-me se preciso escrever a função principal (não tenho certeza se essa é a política ou não). Basicamente, ele divide o número por dois e o multiplica por -1 para o limite inferior e, para o limite superior, apenas usa o número dividido por dois. Sou meio novo nesta página, então se não formatar nada certo, avise-me. Além disso, sei que as respostas podem ser abreviadas com funções lambda, mas não sei como usá-las e não tenho certeza se o Java as suporta.

Aqui está uma versão mais legível e com menos golfe:

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?}

Cria uma função lambda anônima que retornará a matriz de nnúmeros mais próxima de 0 se n for ímpar e retornará nil (um valor de falsey em ruby).

O Ruby arredonda sua divisão inteira para -in infinito, mas 0-n/2é menor que -n/2+1(já que o sinal de menos está lá de qualquer maneira) e, como agora o n é considerado positivo, o arredondamento funciona a meu favor.

Versão antiga (28 bytes)

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