Цель : учитывая положительное целое число 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диапазон с пробелами, и имеет его в качестве второго элемента двухэлементного массива (первый элемент - 0). Затем использует $a%2для индексации в этот массив для вывода.

Альтернативная версия, использующая более «традиционный» поток if / else, на 54 байта:

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

_{Edit - необходимо добавить логику для вывода значения Falsey, если ввод четный}

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)

Для нечетных входных данных возвращает целочисленный массив длины с xцентром в 0; для четного, возвращает 0. Я думаю, что это так коротко, как может. (Сохранено пару байтов благодаря @ edc65 и @ ן nɟuɐɯɹɐ ן oɯ!)

Альтернатива ES6: (42 байта, благодаря @intrepidcoder)

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

Предложения приветствуются!

Минколанг 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.

Анонимная лямбда. Применение:

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

О, 18

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

Живая демоверсия.

Витси, 27 25 Байт

Завтра я собираюсь сыграть в гольф, но мне действительно пора идти спать.

D2m) [& 1] D1-я *} \ [D2 / NaO2 +]
D Дублируйте ввод.
 2M) [& 1] Если вход четный (вход% 2 = 0), создайте новый стек
                              и нажмите 1 к нему.
        D Дублируйте верхнее значение - если оно не было четным, это будет ввод. В противном случае, это один.
         1- вычесть один (чтобы сбалансировать около нуля)
           я * аддитивно инвертировать
             } Перемещение элемента в стеке - это гарантирует, что
                              у нас есть либо вход, либо один сверху.
              \ [] Повторите ввод времени.
                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

Для нечетных входных данных возвращает целочисленный массив длины с xцентром в 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 . Я также использую фактор modulo-2 n%%2в определении, xчтобы принудительно xобнулить, когда nчетное, и в этом случае 0:0возврат 0(фальси).

Perl, 36 байт

У меня такое ощущение, что это можно сократить:

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

Диапазон обрабатывает числа с плавающей точкой как целые числа, поэтому, например, 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

Нечетные числа выводят точную справочную строку. Вы можете сохранить еще 4 байта (сейчас 45), удалив []из выходной строки.

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 байт

Самое короткое лямбда-выражение, которое я мог придумать, которое выводит список, а не диапазон:

{$_%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, поэтому решил вставить его. Дайте мне знать, если мне нужно написать основную функцию (я не уверен, является ли это политикой или нет). По сути, он делит число на два и умножает его на -1 для нижней границы, а для верхней границы он просто использует число, деленное на два. Я немного новичок на этой странице, так что, если я ничего не отформатировал, дайте мне знать. Кроме того, я знаю, что ответы можно сократить с помощью лямбда-функций, но я не знаю, как их использовать, и я не уверен, поддерживает ли их 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);
    }
}
}

Рубин, 25 байт

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

Рубин, 27 байт

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

Создает анонимную лямбда-функцию, которая будет возвращать массив n чисел, ближайший к 0, если n нечетно, и возвращает nil (значение Falsey в ruby) в противном случае.

Рубин округляет свое целочисленное деление в сторону -infinity, но 0-n/2 оно короче -n/2+1(поскольку знак минус в любом случае есть), и поскольку n теперь считается положительным, округление работает в мою пользу.

Старая версия (28 байт)

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