목표 : 양의 정수가 주어지면 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 바이트

-2 바이트의 @Dennis에게 감사드립니다!

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

이것은 고른 입력을 위해 빈 배열을 제공하는 모나 딕 열차입니다. 아래는 다이어그램입니다.

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

먼저, ⊢×2|⊢입력 시간에 mod 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)]

돈. 꽤 자세한 답변입니다. input을 가져 와서 $a새 변수 $b를의 "floor"로 설정 $a/2합니다. 에서 (0-$b)까지 새로운 숫자 범위를 생성 한 $b다음 join공백이있는 범위를 생성하고 이를 두 요소 배열의 두 번째 요소 (첫 번째 요소는 0)로 만듭니다. 그런 다음 $a%2출력을 위해 해당 배열에 색인을 작성하는 데 사용 합니다.

54 바이트에서 더 많은 "전통적인"if / else 플로우를 사용하는 대체 버전 :

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

_{편집-입력이 짝수 인 경우 잘못된 값을 출력하기 위해 로직을 추가해야 함}

하스켈, 37 36 31 바이트

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

불균형은 빈 목록으로 표시됩니다. 사용 예 : g 7-> [-3,-2,-1,0,1,2,3].

@xnor가 5 바이트를 찾았습니다. 감사!

자바 스크립트 (ES6), 44 43 42 41 바이트

^{44를 넘어 서면 여전히 규칙적이다.}

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

홀수 입력의 경우 x, 중심에있는 length의 정수 배열을 반환합니다 0. 심지어 0을 반환합니다. 가능한 한 짧다고 생각합니다. (@ edc65와 @ ן nɟuɐɯɹɐ ן oɯ 덕분에 몇 바이트를 절약했습니다!)

ES6 대안 : (@intrepidcoder 덕분에 42 바이트)

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.

익명의 람다. 용법:

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}

파이썬 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.

O, 18

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

라이브 데모.

비츠, 27 25 바이트

내일이 골프를 타러 갈 게요.하지만 지금 자러 가야 해요.

D2M) [& 1] D1-i *} \ [D2 / NaO2 +]
D 입력을 복제합니다.
 2M) [& 1] 입력이 짝수이면 (입력 % 2 = 0) 새 스택을 생성합니다
                              1을 누릅니다.
        D 최고 값을 복제합니다-짝수 인 경우 입력이됩니다. 그렇지 않으면 하나입니다.
         1-1을 빼십시오 (0 주위의 균형을 잡기 위해)
           i * 부가 적으로 반전
             } 스택의 항목 위로 이동-이렇게하면
                              입력 또는 상단에 하나가 있습니다.
              \ [] 입력 시간을 반복하십시오.
                D2 / N 상단 항목을 복제하여 인쇄합니다.
                    aO 줄 바꿈 (이것이 유효한 분리인지 확신합니다)
                      2+ 스택의 맨 위에 하나를 추가하십시오.

티 스크립트 , 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).

apt, 21 19 바이트

Japt 는 Ja vaScri pt 의 단축 버전입니다 .

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

홀수 입력의 경우 x, 중심에있는 length의 정수 배열을 반환합니다 0. 짝수의 경우 0을 반환합니다. 거친 JS 변환 :

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

여기서 ~ x.range(y)까지의 정수 목록을 만듭니다 . 온라인으로 테스트하십시오!xy

현대 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. 또한 짝수 일 때 0 으로 강제 n%%2하는 정의에서 modulo-2 인수 를 사용 합니다 ( 이 경우 반환 ).xxn0:00

펄, 36 바이트

이것이 단축 될 수 있다고 생각합니다.

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

Range는 float를 정수로 취급하므로 5/2 = 2.5는 자동으로 2로 변환됩니다.

서식이 중요하지 않으면 $,=$";총 30 바이트 를 제거하십시오 .

파워 쉘, 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> 

파워 쉘, 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>

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

자바, 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에 대한 답변을 보지 못했기 때문에 하나를 넣기로 결정했습니다. 주요 기능을 작성 해야하는지 알려주십시오 (정책인지 여부는 확실하지 않습니다). 기본적으로 숫자를 2로 나누고 하한의 경우 -1을 곱하고 상한의 경우 숫자를 2로 나눕니다. 이 페이지를 처음 접했으므로 형식을 지정하지 않은 경우 알려주십시오. 또한 람다 함수를 사용하면 답변을 줄일 수 있지만 사용법을 모르고 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?}

nn이 홀수이면 0에 가장 가까운 숫자 배열을 반환하고 그렇지 않으면 nil (루비의 거짓 값)을 반환 하는 익명의 람다 함수를 만듭니다 .

루비는 정수 나누기를 -infinity로 반올림하지만 (마이너스 부호가 있기 때문에) 0-n/2보다 짧습니다 -n/2+1.n이 이제 양수로 간주되기 때문에 반올림이 유리합니다.

이전 버전 (28 바이트)

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