N이 주어지면이 무한 시퀀스의 N 번째 항을 출력하십시오.

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N은 원하는대로 0- 인덱싱되거나 1- 인덱싱 될 수 있습니다.

입력 후 0 인덱싱 된 경우, 예를 들어, 0, 1, 2, 3, 4각각의 출력을 생성한다 -1, 2, -2, 1, -3.

투입 후 1 인덱싱하면 1, 2, 3, 4, 5각각의 출력을 생성한다 -1, 2, -2, 1, -3.

분명히하기 위해이 시퀀스는 양의 정수 시퀀스를 두 번 반복하여 생성됩니다.

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

홀수의 각 쌍을 재정렬하여 바로 위의 짝수를 둘러 쌉니다.

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

마지막으로 첫 번째로 시작하여 다른 모든 용어를 부정

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

바이트 단위의 가장 짧은 코드가 이깁니다.

파이썬 2 , 23 바이트

lambda n:~n/2+n%2*(n|2)

홀수 입력은 대충 입력 n/2합니다 -n/2. 그래서 나는 -n/2+n%2*n그곳에서 시작해서 조정했습니다.

온라인으로 사용해보십시오!

매스 매 티카, 29 바이트

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

1 인덱스 입력을 취하는 순수한 기능. 대체 부호 이외의 (-1)^#시퀀스의 두 배는 입력에 가까우며 차이는 주기적으로 1, 2, 1, -2입니다. #~GCD~4입력의 최대 공약수 4는 1, 2, 1, 4이며 주기적으로 좋습니다 . 우리는 수동으로 교체 4->-2하고 하루 만 호출합니다. 나는 많은 문자 Mathematica 명령을 피하기 때문에이 접근법을 좋아합니다.

핍 , 24 22 바이트

v**a*YaBA2|1+:--a//4*2

명령 행 인수로 1 색인 입력을받습니다. 온라인으로 시도 하거나 1-20을 확인 하십시오 .

설명

하나의 인덱스가 0 인 인덱스와 다른 하나의 인덱스가있는 세 개의 다른 시퀀스를 조합하여 시퀀스를 얻을 수 있습니다.

• 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(0 인덱스)로 시작하십시오 .
• Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, 여기서 BAAND는 비트 AND |이며 논리 OR (1 인덱스)입니다.
• 합계에 -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(1- 인덱스)를 곱하십시오 .

a1 인덱싱으로 시작하면 먼저 1 인덱싱 된 부품을 계산하고 (왼쪽에서 오른쪽으로 식을 읽음) a0 인덱싱 된 부품에 대해 감소 시킬 수 있습니다. 내장 변수를 사용하여 v=-1, 우리는 도착

v**a*((aBA2|1)+--a//4*2)

2 바이트를 더 줄이려면 우선 순위 조작 트릭을 사용해야합니다. ( 많은 언어에서 +와 +:동일)로 대체하여 내부 괄호를 제거 할 수 있습니다 +=. 계산 및 할당 연산자는 우선 순위가 매우 낮으므로 aBA2|1+:--a//4*2와 같습니다 (aBA2|1)+:(--a//4*2). Pip은 변수가 아닌 것에 할당하는 것에 대한 경고를 내 보냅니다. 그러나 경고가 활성화 된 경우에만 가능합니다.

보다 낮은 우선 순위의 유일 :IS Y는 십중팔구 연산자 * 그것은 그것의 연산 값을 할당한다. y변수 변경을 통해 전달한다; 따라서 괄호 대신 값을 잡아 당겨서 외부 괄호를 제거 할 수 있습니다 YaBA2|1+:--a//4*2.

_{* PRINT 및 Output은 같은 우선 순위가 YANK,하지만 여기에 유용하지 않다.}

젤리 , 8 7 바이트

H^Ḃ~N⁸¡

이것은 @GB에 의해 크게 개선 된 Python 답변 의 알고리즘을 사용합니다 .

온라인으로 사용해보십시오!

작동 원리

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.

자바 8, 19 바이트

n->~(n/2)+n%2*(n|2)

자바 7, 47 37 바이트

int c(int n){return~(n/2)+n%2*(n|2);}

Java (8)가 실제로 경쟁하고 다른 답변보다 짧습니다. 그래도 Jelly와 같은 실제 골프 언어를 여전히 능가 할 수는 없습니다. (duhuh .. 무슨 놀라운 일입니까 ..>.>; P)

@Xnor 의 Python 2 답변
에서 0 인덱싱 된 포트 . @GB 덕분에 -10 바이트

여기에서 시도하십시오.

젤리 , 15 12 11 바이트

Ḷ^1‘ż@N€Fị@

온라인으로 사용해보십시오!

작동 원리

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.

RProgN 2 , 31 25 22 바이트

nx=x2÷1x4%{+$-1x^*}#-?

설명

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

온라인으로 사용해보십시오!

루비, 26 23 18 바이트

->n{~n/2+n%2*n|=2}

0 기반

-3 바이트는 Greg Martin , Dennis 및 다른 누군가 의 -1 ^ n 아이디어를 훔친 다음 -5 바이트는 xnor 에서 n | 2 아이디어를 훔칩니다 .

스택 형 , 30 28 바이트

:2%([:2/\4%2=tmo+][1+2/_])\#

온라인으로 사용해보십시오! 메타 합의에 따라 허용되는 함수를 반환합니다 . . 스택 맨 위에서 입력을받습니다.

RProgN 2 답변 과 동일한 접근 방식을 사용합니다 .

또는 46 바이트입니다. 온라인으로 사용해보십시오! :

{!()1[::1+,:rev,\srev\,\2+]n*@.n 1-#n 2%tmo*_}

이것은 범위를 생성하고 적절하게 멤버를 선택하고 무효화합니다.

파이썬 2 ,  44  33 27 바이트

lambda n:(-1)**n*~(n/2^n%2)

6 바이트를 골라 낸 @GB 덕분에!

온라인으로 사용해보십시오!

05AB1E, 8 바이트

2‰`^±¹F(

온라인으로 사용해보십시오

설명

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate

젤리 , 9 8 바이트

|2×Ḃ+H~$

온라인으로 사용해보십시오!

Dennis 에게 -1 감사합니다 . 부동 소수점 변환.

@xnor의 Python 2 접근 방식을 사용합니다.

편집 : > _>

CJam , 16 바이트

{_(_1&)^2/)W@#*}

1 기반 입력.

온라인으로 사용해보십시오!

설명

여기서, 각 입력에 대한 스택의 값을 사용하여 코드의 내역 1으로는 4. 처음 몇 명령은 n-1이후 의 두 개의 최하위 비트에만 영향을 미칩니다. 4이 물건은 절반으로 주기적으로 반복되며 결과는 절반으로 인해 2 씩 증가합니다.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]

펄 6 ,  55 27 24  22 바이트

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(하스켈 zipWith답변에서 영감을 얻었습니다 )
사용해보십시오

{+^($_ div 2)+$_%2*($_+|2)}

(몇 가지 답변에서 영감을 얻었습니다)
사용해보십시오

{+^($_+>1)+$_%2*($_+|2)}

시도 해봐

{+^$_+>1+$_%2*($_+|2)}

시도 해봐

넓히는:

{  # bare block lambda with implicit parameter ｢$_｣

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(모두 0 기반)

하스켈 , 37 36 바이트

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

온라인으로 사용해보십시오! 이것은 하나의 숫자 n를 인수 n로 사용하여 시퀀스 의 th 요소를 0으로 색인화 하는 익명 함수입니다 .

하스켈, 56 바이트

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 인덱스

Perl 5 47 + 1 (플래그 용) = 48 바이트

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

이전 제출물 82 바이트

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

다음과 같이 실행하십시오.

perl -n <name of file storing script>  <<<  n

자바 스크립트 (ES7), 28 바이트

n=>(n+2>>2)*2*(-1)**n-!(n&2)

1- 색인. 나는 아직 다른 답변을 보지 않았으므로 이것이 최고의 알고리즘인지는 알지 못하지만 의심하지는 않습니다.

자바 스크립트, 28 22 바이트

6 바이트 오프 골프를위한 @ETHproductions 감사합니다

x=>x%2?~x>>1:x%4+x/2-1

온라인으로 사용해보십시오!

dc , 98 바이트

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

어이, 이것은 가장 긴 대답입니다. 주로 다음 재귀 공식에 따라 시퀀스의 각 요소의 절대 값을 하나씩 생성하는 경로를 갔기 때문입니다.

그런 다음 '번째 요소를 (-1)^n * a_n직접 계산하지 않고 출력 n합니다. 어쨌든 이것은 1인덱스입니다.

온라인으로 사용해보십시오!

R, 38 바이트

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

설명

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)

TI 기본 (TI-84 Plus CE), 31 바이트

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic은 토큰 화 된 언어이며 여기에서 사용되는 각 토큰은 1 바이트 remainder(입니다.

이것은 1 인덱스 버전을 사용합니다.

설명:

4 개의 숫자마다 반복되는 패턴이 있습니다. 1 인덱스 버전에서 입력 값 x의 경우-(x + 1) / 2, (x + 1) / 2,-(x + 1) / 2, (x-1) / 2입니다. 이것은 부분적으로 정의 된 함수로 표현 될 수 있습니다.

x x 1 mod 4 인 경우 f (x) =-(x + 1) / 2; x x 2 mod 4 인 경우 (x + 1) / 2; x ≡ 3 mod 4 인 경우-(x + 1) / 2; (x-1) / 2이면 x ≡ 0 mod 4

"x ≡ 1 mod 4"와 "x ≡ 3 mod 4"부분은 동일하기 때문에 "x ≡ 1 mod 2"로 결합 할 수 있습니다.

이제 조각 별 기능은 다음과 같습니다.

x x 1 mod 2 인 경우 f (x) =-(x + 1) / 2; x x 2 mod 4 인 경우 (x + 2) / 2; (x-2) / 2이면 x ≡ 0 mod 4

이것은 실제 명령으로 나누기 시작하는 곳입니다. 값은 짝수 인덱스에 대해 양수이고 홀수 인덱스에 대해서는 음수이므로 (-1) ^ x를 사용할 수 있습니다. 그러나 TI-Basic에서는 i^(2X(5 바이트)가 (-1)^Ans(6 바이트) 보다 짧습니다 . 작업 순서에 따라 괄호가 필요합니다.

이제 홀수 입력을 방해하지 않는 방법이 있으므로 모드로 넘어갑니다 (나중에 다시 부정을 추가 함). 홀수 입력의 경우를 기본값으로 설정 했으므로로 시작합니다 .5(Ans+1).

짝수 입력의 경우를 수정하려면 x ≡ 0 mod 2 일 때만 괄호 안의 숫자에 1을 추가하십시오. 이것은 .5(Ans+1+remainder(Ans+1,2))또는 로 표현 될 수 .5(Ans+1+not(remainder(Ans,2)))있지만 바이트 수는 동일하므로 어느 것이 중요하지 않습니다.

4의 배수 입력의 경우를 고치려면 괄호 안의 숫자에서 3을 빼야하지만, 4의 모든 배수가 짝수이므로 이전 단계에서 1을 더하기 때문에 또 다른 1을 빼야 .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))합니다.

이제 부호 결정 부분을 끝까지 밀어서 전체 프로그램을 얻으십시오.

Befunge 93, 25 바이트

제로 인덱스

&4/2*1+&4%3%!!+&2%2*1-*.@

온라인으로 사용해보십시오!

숫자는 ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

QBIC , 53 바이트

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

설명:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.

와이즈 , 19 바이트

::>!:><^^~![!-!-~]|

온라인으로 사용해보십시오!

이것은 Wise에 대한 @Dennis의 Jelly 답변 포트입니다 .

Q, 52 바이트

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

인덱스 솔루션 0 개.

1. 블록 번호를 가져옵니다. 시퀀스 내의 어느 [-x x + 1-(x + 1) x] 블록은 인덱스를 포함한다.
2. 전체 시퀀스 내 값의 인덱스를 기반으로 블록 내 값의 인덱스를 가져옵니다.
3. 블록을 만듭니다.
4. 2 단계에서 파생 된 색인을 통해 색인을 생성합니다.