Objectif : étant donné un entier positif n:

• Si nest impair, affichez la liste des nnombres les plus proches de 0dans l'ordre croissant
• Si nest pair, sortez une valeur Falsey.

Cas de test :

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

Implémentation de référence

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 octets

*-R/Q2Q%Q2

Essayez-le en ligne.

Comment ça fonctionne

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

Merci à @Dennis pour -2 octets!

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

Il s'agit d'un train monadique qui donne un tableau vide pour une entrée uniforme. Voici le schéma:

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

Tout d'abord, ⊢×2|⊢donne aux temps d'entrée son mod 2; c'est-à-dire que les cotes se donneront et les evens donneront 0. Nous utilisons ⍳pour créer une liste de nombres de 1 à celui ( ⍳0donne le tableau vide), puis nous soustrayons la moitié de l'entrée et du plancher.

Mathematica, 32 30 24 octets

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

Astuce de code-golf: le dernier argument à Andne doit pas nécessairement être un booléen.

PowerShell, 50 52 octets

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

Oof. Réponse assez verbeuse. Prend l'entrée $a, puis définit une nouvelle variable $bcomme le «plancher» de $a/2. Génère une nouvelle plage de nombres de (0-$b)à $b, puis joins la plage avec des espaces, et l'a comme deuxième élément d'un tableau à deux éléments (le premier élément est 0). Utilise ensuite $a%2pour indexer dans ce tableau pour la sortie.

Version alternative utilisant un flux if / else plus "traditionnel", à 54 octets:

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

_{Modifier - Nécessaire pour ajouter une logique pour sortir une valeur de falsey si l'entrée est régulière}

Haskell, 37 36 31 octets

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

Unbalanced est indiqué par la liste vide. Exemple d'utilisation: g 7-> [-3,-2,-1,0,1,2,3].

@xnor a trouvé 5 octets. Merci!

JavaScript (ES6), 44 43 42 41 octets

^{barré 44 est toujours régulier 44;}

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

Pour les entrées impaires, renvoie un tableau entier de longueur x, centré sur 0; pour even, renvoie 0. Je pense que c'est aussi court que possible. (Sauvegardé quelques octets grâce à @ edc65 et @ ן nɟuɐɯɹɐ ן oɯ!)

Alternative ES6: (42 octets, merci à @intrepidcoder)

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

Suggestions bienvenues!

Minkolang 0,10 , 18 octets

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

Explication

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 octets

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

Il s'agit d'un verbe monadique qui renvoie 0(fausse) pour les nombres pairs. Essayez en ligne avec J.js .

Essai

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

Comment ça fonctionne

              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 octets

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

Try it here.

Lambda anonyme. Usage:

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

Explication

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

Pour le moment, je ne sais pas si je peux produire ce que je veux s'il n'est pas équilibré, donc cela ne renvoie actuellement qu'une liste vide dans le cas d'une base à déséquilibre. C'est une fonction lambda anonyme, alors donnez-lui un nom pour l'utiliser.

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

CJam, 13 12 octets

{_2md@,@f-*}

Il s'agit d'une fonction anonyme qui extrait un entier de la pile et envoie en retour un tableau de chiffres (base impaire) ou vide (base même). Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

_          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

Démo en direct.

Vitsy, 27 25 octets

Je vais jouer au golf demain, mais je dois vraiment me coucher maintenant.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D Dupliquez l'entrée.
 2M) [& 1] Si l'entrée est paire (entrée% 2 = 0) générer une nouvelle pile
                              et poussez-y 1.
        D Dupliquez la valeur supérieure - si ce n'est pas pair, ce sera l'entrée. Sinon, c'est un.
         1- Soustrayez un (pour équilibrer autour de zéro)
           i * Inverser additivement
             } Déplacer un élément de la pile - cela garantit que
                              nous avons soit l'entrée, soit une en haut.
              \ [] Répéter les heures de saisie.
                D2 / N Dupliquez l'élément supérieur et imprimez-le.
                    aO Newline (je suis sûr que c'est une séparation valide)
                      2+ Ajoutez-en un au premier élément de la pile.

TeaScript , 16 octets 18

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

Assez simple. Les caractères spéciaux ne sont en fait que des "abréviations" pour des séquences de code plus longues.

Je n'ai toujours pas fait de permaliens, vous devrez donc copier-coller dans l' interpréteur

Explication

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
)

_{Cette réponse n'est pas concurrente}

F #, 38 octets

Le résultat de falsey est une liste vide.

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

𝔼𝕊𝕄𝕚𝕟, 21 caractères / 37 octets

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

Try it here (Firefox only).

Voici une réponse de 20 caractères / 35 octets (non concurrente, car la réponse utilise les modifications mises en œuvre après la question):

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

Try it here (Firefox only).

Japt, 21 19 octets

Japt est une version abrégée de Ja vaScri pt .

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

Pour les entrées impaires, renvoie un tableau entier de longueur x, centré sur 0; pour pair, renvoie 0. Traduction JS approximative:

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

où x.range(y)crée une liste d'entiers de xà y. Testez-le en ligne!

Dans Japt moderne, cela ne fait que 11 octets:

u ©Uo-U/2-½

Essayez-le en ligne!

R, 30 octets

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

En gros, x:-xretourne les entiers de xà -x, où je mets xà (1-n)/2. J'utilise également le facteur modulo-2 n%%2dans la définition de xforcer xà zéro quand nest pair, auquel cas 0:0retourne 0(falsey).

Perl, 36 octets

J'ai le sentiment que cela peut être raccourci:

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

La plage traite les flottants comme des nombres entiers, par exemple, 5/2 = 2,5 est converti silencieusement en 2.

(Si le formatage n'a pas d'importance, supprimez-le $,=$";pour un total de 30 octets).

Powershell, 49 octets

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

Les nombres pairs sont évalués $falsecar ils fournissent une sortie de ligne vide.

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

Les nombres impairs génèrent la chaîne de référence exacte. Vous pouvez enregistrer 4 octets supplémentaires (maintenant 45) en supprimant le []de la chaîne de sortie.

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 octets

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

Cela a le même résultat falsey mais affiche la liste des nombres séparés par des retours à la ligne:

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 octets

L'expression lambda la plus courte que j'ai pu trouver et qui génère une liste plutôt qu'une plage est:

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

Essai:

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

Cela profite du fait que Perl 6 traite le nombre 0comme une fausse valeur. Si la sortie devait être exacte, Falsevous pouvez la remplacer $_%2par $_!%%2.

05AB1E , 8 octets (non concurrents)

La langue est postérieure au défi et n'est donc pas compétitive. Code:

È#¹;D(ŸR

Essayez-le en ligne!

Explication:

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

Utilise l' encodage CP-1252 .

PHP, 50 octets

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

programme, prend l'entrée de STDIN, imprime la _liste délimitée ou 0.

ou

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

La fonction prend un argument, retourne un tableau ou 0.

Java, 145 octets

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

Explication: Désolé, je sais que c'est vraiment long. Je n'ai pas vu de réponse pour Java, j'ai donc décidé d'en mettre une. Faites-moi savoir si j'ai besoin d'écrire la fonction principale (je ne sais pas si c'est la politique ou non). Fondamentalement, il divise le nombre par deux et le multiplie par -1 pour la borne inférieure et pour la borne supérieure, il utilise simplement le nombre divisé par deux. Je suis un peu nouveau sur cette page, donc si je n'ai rien mis en forme correctement, faites le moi savoir. De plus, je sais que les réponses peuvent être raccourcies avec des fonctions lambda mais je ne sais pas comment les utiliser et je ne sais pas si Java les prend en charge.

Voici une version plus lisible et moins golfée:

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

Rubis, 25 octets

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

Rubis, 27 octets

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

Crée une fonction lambda anonyme qui renverra le tableau de nnombres le plus proche de 0 si n est impair, et renvoie nil (une valeur de falsey en ruby) sinon.

Ruby arrondit sa division entière vers -infinity, mais 0-n/2est plus court que -n/2+1(puisque le signe moins est là de toute façon), et parce que n est maintenant considéré comme positif, l'arrondi fonctionne en ma faveur.

Ancienne version (28 octets)

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