目标：给定一个正整数n：

• 如果n是奇数，输出列表中n最接近的数字来0递增的顺序
• 如果n是偶数，则输出Falsey值。

测试用例：

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

参考实施

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个字节

*-R/Q2Q%Q2

在线尝试。

怎么运行的

            (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字节

感谢@Dennis提供-2个字节！

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

这是一串单子串火车，它为偶数输入提供了一个空数组。下图是：

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

首先，⊢×2|⊢给输入时间取模2；也就是说，赔率将给自己，偶数将给0。我们使用⍳创建一个从1到该数字的列表（⍳0给出空数组），然后减去输入和下限的一半。

Mathematica，32 30 24字节

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

代码搜寻技巧：的最后一个参数And不必是布尔值。

PowerShell，50 52字节

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

钱币。非常详细的答案。接受输入$a，然后将一个新变量设置$b为的“ floor” $a/2。生成一个新的数字范围，从(0-$b)到$b，然后join使用空格将其设置为s，并将其作为双元素数组的第二个元素（第一个元素是0）。然后用于$a%2索引该数组以进行输出。

使用更多“传统” if / else流的备用版本，为54个字节：

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

_{编辑-如果输入是偶数，则需要添加一些逻辑以输出假值}

Haskell，37 36 31字节

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

空列表表示不平衡。用法示例：g 7-> [-3,-2,-1,0,1,2,3]。

@xnor找到5个字节。谢谢！

JavaScript（ES6），44 43 42 41字节

^{划掉44仍然是常规44;（}

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

对于奇数输入，返回以in x为中心的length的整数数组0。甚至返回0。我认为这是可以得到的。（由于@ edc65和@ןnɟuɐɯɹɐןoɯ，节省了几个字节！）

ES6替代：（42个字节，感谢@intrepidcoder）

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

建议欢迎！

Minkolang 0.10，18字节

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

说明

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个字节

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

这是一个单数动词，0对于偶数返回（虚假）。使用J.js在线尝试。

测试运行

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

怎么运行的

              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个字节

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

Try it here.

匿名lambda。用法：

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

说明

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

现在，我不确定如果不平衡时是否可以输出我想要的任何东西，因此当前在基础不平衡的情况下只返回一个空列表。这是一个匿名的lambda函数，因此请给它命名以使用它。

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

CJam，13 12个字节

{_2md@,@f-*}

这是一个匿名函数，该函数从堆栈中弹出一个整数，然后返回一个数字数组（奇数基）或空数组（偶数基）。在CJam解释器中在线尝试。

怎么运行的

_          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

现场演示。

Vitsy，27 25字节

我明天要打高尔夫球，但是我现在应该去睡觉了。

D2M）[＆1] D1-i *} \ [D2 / NaO2 +]
D复制输入。
 2M）[＆1]如果输入为偶数（input％2 = 0），则生成一个新堆栈
                              并按1。
        D复制最高值-如果不相等，将作为输入。否则，它是一个。
         1-减一（在零附近​​平衡）
           i *加法反转
             移至堆栈中的一个项目上-这可确保
                              我们要么输入，要么输入一个。
              \ []重复输入时间。
                D2 / N复制最上面的项目并打印出来。
                    换行符（我很确定这是有效的分隔）
                      2+将一个添加到堆栈的顶部。

TeaScript，16字节18

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

很简单 特殊字符实际上只是较长代码序列的“缩写”。

我仍然没有固定链接，因此您必须将粘贴复制到解释器中

说明

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
)

_{这个答案是非竞争性的}

F＃，38个字节

错误的结果是一个空列表。

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

𝔼𝕊𝕄𝕚𝕟，21个字符/ 37个字节

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

Try it here (Firefox only).

这是20个字符/ 35字节的答案（非竞争性，因为答案使用在提出问题后实施的更改）：

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

Try it here (Firefox only).

Japt，21个 19字节

Japt是Ja vaScri pt的缩写。

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

对于奇数输入，返回以in x为中心的length的整数数组0。甚至返回0。粗糙的JS翻译：

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

在其中x.range(y)创建从x到的整数列表y。在线测试！

在现代Japt中，这只有11个字节：

u ©Uo-U/2-½

在线尝试！

R，30个字节

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

粗略地，x:-x返回从x到-x我设置x为的整数(1-n)/2。我还在偶数n%%2的定义中使用模2因子x强制x将n偶数强制为零，在这种情况下，0:0返回0（falsey）。

Perl，36个字节

我觉得这可以缩短：

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

Range将浮点数视为整数，因此，例如5/2 = 2.5会静默转换为2。

（如果格式化无关紧要，则删除$,=$";总共30个字节）。

Powershell，49个字节

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

$false由于偶数提供空行输出，因此对偶数求值。

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

奇数输出精确的参考字符串。45通过[]从输出字符串中删除，您可以再保存4个字节（现在）。

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字节

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

这具有相同的错误结果，但输出以换行符分隔的数字列表：

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字节

我能想到的最短的lambda表达式输出的是列表而不是范围：

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

测试：

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

这利用了Perl 6将数字0视为错误值的事实。如果输出必须准确False，则可以替换$_%2为$_!%%2。

05AB1E，8个字节（非竞争）

语言是挑战的最早发布日期，因此是非竞争性的。码：

È#¹;D(ŸR

在线尝试！

说明：

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

使用CP-1252编码。

PHP，50个字节

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

程序，从STDIN接收输入，打印_定界列表或0。

要么

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

函数接受参数，返回数组或0。

Java，145个字节

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

说明：对不起，我知道这真的很长。我没有看到Java的答案，所以我决定放一个。让我知道是否需要编写main函数（不知道这是否是策略）。基本上，它会将数字除以2，然后将其乘以-1来获得下限，而对于上限，它只使用数字除以2。我是此页面的新手，所以如果我没有正确格式化任何内容，请告诉我。另外，我知道可以使用lambda函数来缩短答案，但是我不知道如何使用它们，而且我不确定Java是否支持它们。

这是一个更具可读性的版本，它不那么受欢迎：

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个字节

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

Ruby，27个字节

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

创建一个匿名lambda函数，n如果n为奇数，该函数将返回最接近0 的数字数组，否则返回nil（红宝石中的false值）。

Ruby将其整数除法四舍五入为-infinity，但0-n/2比-n/2+1（由于负号始终存在）短，并且由于n现在被视为正数，因此四舍五入对我有利。

旧版本（28个字节）

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