N numbers closest to zero staying balanced

Question

Objective: Given a positive integer n:

• If n is odd, output the list of n numbers closest to 0 in increasing order
• If n is even, output a Falsey value.

Test cases:

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

---

Reference implementation

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>

Answer 1

Pyth, 10 bytes

*-R/Q2Q%Q2

Try it online.

How it works

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

Answer 2

APL, 16 15 13 bytes

Thanks to @Dennis for -2 bytes!

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

This is a monadic train that gives an empty array for even input. Below is the diagram:

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

First, ⊢×2|⊢ gives the input times its mod 2; that is, odds will give themselves, and evens give 0. We use ⍳ to create a list of numbers from 1 to that (⍳0 gives the empty array), and then we subtract half the input and floor.

Answer 3

Mathematica, 32 30 24 bytes

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

Code-golfing trick: The last argument to And doesn't have to be a boolean.

Answer 4

Brachylog, 9 bytes

%₂1&~l≠≜o

Try it online!

Explanation

An interesting (ab)use of Brachylog's backtracking algorithm:

%₂1        First, assert that the input mod 2 is 1 (if not, the predicate fails)
   &       Then, the input
    ~l      is the length of some list
      ≠     in which all elements are different
       ≜   Generate a list that matches those conditions
           Brachylog will try to fill the array with integers, starting from 0 and
            increasing in absolute value; since they all have to be different, the result
            will be of the form [0, 1, -1, 2, -2, ...]
        o  Sort ascending

Answer 5

PowerShell, 50 52 Bytes

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

Oof. Pretty verbose answer. Takes input $a, then sets a new variable $b as the "floor" of $a/2. Generates a new number range from (0-$b) to $b, then joins the range with spaces, and has that as the second element of a two-element array (the first element is 0). Then uses $a%2 to index into that array for output.

Alternate version using more "traditional" if/else flow, at 54 bytes:

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

_{Edit - Needed to add some logic to output a falsey value if the input is even}

Answer 6

Haskell, 37 36 31 bytes

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

Unbalanced is indicated by the empty list. Usage example: g 7 -> [-3,-2,-1,0,1,2,3].

@xnor found 5 bytes. Thanks!

Answer 7

J, 12 bytes

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

This is a monadic verb that returns 0 (falsy) for even numbers. Try it online with J.js.

Test run

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

How it works

              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).

Answer 8

JavaScript (ES6), 44 43 42 41 bytes

^{crossed out 44 is still regular 44 ;(}

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

For odd inputs, returns a integer array of length x, centered at 0; for even, returns 0. I think this is as short as it can get. (Saved a couple bytes thanks to @edc65 and @ןnɟuɐɯɹɐןoɯ!)

ES6 alternative: (42 bytes, thanks to @intrepidcoder)

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

Suggestions welcome!

Answer 9

Python 2, 34 32 Bytes

Right now I'm not sure if I can output whatever I want if it's not balanced, so currently this just returns an empty list in the case of an unbalance-able base. It's an anonymous lambda function, so give it a name to use it.

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

Answer 10

Minkolang 0.10, 18 bytes

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

Explanation

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

Answer 11

DUP, 31 bytes

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

Try it here.

Anonymous lambda. Usage:

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

Explanation

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

Answer 12

Vyxal, 8 bytes

∷$½:N$ṡ∧

Try it Online!

Explanation

∷$½:N$ṡ∧
∷          Parity
 $         Swap (putting the input on top again)
  ½        Half
   :       Duplicate
    N      Negate
     $     Swap
      ṡ    Range from a to b
       ∧   Logical AND

Answer 13

CJam, 13 12 bytes

{_2md@,@f-*}

This is an anonymous function that pops an integer from the stack and pushes a digit array (odd base) or an empty array (even base) in return. Try it online in the CJam interpreter.

How it works

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

Answer 14

O, 18

M(.e\2/.@{_}dmrr]p

Live demo.

Answer 15

Vitsy, 27 25 Bytes

I'm gonna golf this down tomorrow, but I really ought to go to bed now.

D2M)[&1]D1-i*}\[D2/NaO2+]
D                             Duplicate the input.
 2M)[&1]                      If the input is even (input%2=0) generate a new stack
                              and push 1 to it.
        D                     Duplicate the top value - if it wasn't even, this will be the input. Otherwise, it's one.
         1-                   Subtract one (to balance around zero)
           i*                 Additively invert
             }                Shift over an item in the stack - this ensures that
                              we have either the input or one on top.
              \[        ]     Repeat input times.
                D2/N          Duplicate the top item and print it out.
                    aO        Newline (I'm pretty sure this is valid separation)
                      2+      Add one to the top item of the stack.

Answer 16

R, 30 bytes

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

Roughly, x:-x returns the integers from x to -x, where I set x to (1-n)/2. I also use the modulo-2 factor n%%2 in the definition of x to force x to zero when n is even, in which case, 0:0 returns 0 (falsey).

Answer 17

TeaScript, 16 bytes 18

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

Pretty simple. The special characters are actually just "abbreviations" for longer code sequences.

I still haven't made permalinks so you'll have to copy paste into the interpreter

Explanation

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
)

_{This answer is non-competing}

Answer 18

F#, 38 bytes

The falsey result is an empty list.

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

Answer 19

𝔼𝕊𝕄𝕚𝕟, 21 chars / 37 bytes

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

Try it here (Firefox only).

Here's a 20-char / 35-byte answer (non-competing, since the answer uses changes implemented after the question was asked):

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

Try it here (Firefox only).

Answer 20

Japt, 21 19 bytes

Japt is a shortened version of JavaScript.

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

For odd inputs, returns a integer array of length x, centered at 0; for even, returns 0. Rough JS translation:

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

where x.range(y) creates a list of integers from x to y. Test it online!

---

In modern Japt, this is only 11 bytes:

u ©Uo-U/2-½

Try it online!

Answer 21

R, 26 bytes

a=scan();-(i=a%/%2*a%%2):i

Try it online!

Integer-divide input by 2, and multiply by input modulo 2 (so it becomes zero if input is even). Then output the range of integers from negative to positive of this value.

(for a fairer comparison with the previous (half-decade-old!) R answer, the approach here would be 28 bytes as a function).

Answer 22

MathGolf, 6 (or 4?) bytes

½k¥¿╤<

Outputs 0 as falsey output.

Try it online.

If we're allowed to output [0] as falsey output, even though \$n=1\$ results in [0] as truthy output as well, this could be 4 bytes instead:

¥*½╤

Try it online.

Explanation:

½       # Integer-divide the (implicit) input-integer by 2
 k      # Push the input-integer again
  ¥     # Modulo-2
   ¿    # If input%2 is truthy / 1 / odd:
    ╤   #  Pop the input//2 and push a list in the range [-input//2, input//2]
        # Else (it's falsey / 0 / even instead):
     <  #  Check if the (implicit) input is smaller than input//2, which is falsey / 0
        # (after which the entire stack joined together is output implicitly as result)

¥       # Modulo-2 on the (implicit) input-integer (1 if odd; 0 if even)
 *      # Multiply that by the (implicit) input-integer
  ½     # Integer-divide it by 2
   ╤    # Pop and push a list in the range [-(input%2*input//2), input%2*input//2]
        # (after which the entire stack joined together is output implicitly as result)

Answer 23

Python 3.8 (pre-release), 37 bytes

lambda x:x%2*[*range(-x//2+1,x//2+1)]

Try it online!

Answer 24

Perl, 36 bytes

I have a feeling this can be shortened:

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

Range treats floats as integers, so, e.g. 5/2 = 2.5 gets silently converted to 2.

(If formatting doesn't matter, then remove $,=$"; for a total of 30 bytes).

Answer 25

Powershell, 49 bytes

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

Even numbers evaluated to $false since they provide an empty line output.

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

Odd numbers output the exact reference string. You can save 4 more bytes (now 45) by removing the [] from the output string.

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)

This has the same falsey result but outputs the list of numbers separated by newlines:

PS> .\balanced-newline.ps1 4

PS> .\balanced-newline.ps1 1
0

PS> .\balanced-newline.ps1 5
-2
-1
0
1
2

PS>

Answer 26

Perl 6, 25 bytes

The shortest lambda expression I could come up with that outputs a list rather than a range is:

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

Testing:

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

This takes advantage of the fact that Perl 6 treats the number 0 as a false value. If the output had to be exactly False you could replace $_%2 with $_!%%2.

Answer 27

Jelly, 6 5 bytes

HŒRxḂ

Try it online!

Explanation

HŒRxḂ   Main monadic link
H       Halve
 ŒR     Balanced range
   x    Repeat
    Ḃ    parity of n

-1 byte by finding out there's almost a builtin for this

Answer 28

Risky, 10 bytes

0?+0*:?\2__?+0-_?/2

Try it online!

Explanation

0     range
?         input
+       +
0         0
*   repeat
:     0 ≠
?         input
\       mod
2         2
_ map
_
?         item
+       +
0         0
-   -
_
?         input
/       /
2         2

Answer 29

05AB1E, 8 bytes

Code:

È#¹;D(ŸR

Try it online!

Explanation:

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

Uses CP-1252 encoding.

Answer 30

PHP, 50 bytes

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

program, takes input from STDIN, prints _ delimited list or 0.

or

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

function takes argument, returns array or 0.