소개

숫자 의 부호 는 0이 아닌 모든 정수에 대해 +a 또는 a -입니다. 제로 자체는 무의미합니다 ( +0와 동일 -0). 다음 순서에서는 양의 부호 , 제로 및 음의 부호 사이를 번갈아 가면서 살펴 보겠습니다 . 순서는로 시작 1하므로1 0으로 양수 부호 (이것은 이상하지만 숫자에 0을 곱함)와 음수 부호로 .

1, 0, -1

다음 숫자는 2입니다. 다시 같은 일을합니다.

2, 0, -2

순서는 다음과 같습니다.

1, 0, -1, 2, 0, -2, 3, 0, -3, 4, 0, -4, 5, 0, -5, 6, 0, -6, 7, 0, -7, ...

또는 더 읽기 쉬운 형태 :

a(0) = 1
a(1) = 0
a(2) = -1
a(3) = 2
a(4) = 0
a(5) = -2
a(6) = 3
a(7) = 0
a(8) = -3
a(9) = 4
...

작업

음수가 아닌 정수 n이 주어지면 위 시퀀스 의 n ^번째 항을 출력하십시오 . 인덱스가 없거나 인덱스가없는 버전 을 사용할지 선택할 수 있습니다 .

테스트 사례 :

제로 인덱스 :

a(0) = 1
a(11) = -4
a(76) = 0
a(134) = -45
a(296) = -99

또는 단일 색인을 선호하는 경우 :

a(1) = 1
a(12) = -4
a(77) = 0
a(135) = -45
a(297) = -99

이것은 code-golf 이므로 바이트 수가 가장 적은 제출이 승리합니다!

젤리, 7 바이트

+6d3’PN

인덱스가 0입니다. 여기에서 테스트 사례.

설명:

+6      Add 6:     x+6
d3      Divmod:    [(x+6)/3, (x+6)%3]
’       Decrement: [(x+6)/3-1, (x+6)%3-1]
P       Product    ((x+6)/3-1) * ((x+6)%3-1)

자바 스크립트 ES6, 18 바이트

n=>-~(n/3)*(1-n%3)

@LeakyNun의 답변과 매우 비슷하지만 내 게시물을 게시하기 전까지는 보지 못했습니다.

설명과 언 골프

-~의 약자 Math.ceil또는 반올림 :

n =>               // input in var `n`
    Math.ceil(n/3) // Get every 3rd number 1,1,1,2,2,2, etc.
    *
    (1-n%3)        // 1, 0, -1, 1, 0, -1, ...

function f(n){n=i.value;o.value=-~(n/3)*(1-n%3);}

Input: <input id=i oninput="f()"/><br /><br />
Output: <input id=o readable/>

MarioLANG, 93 81 바이트

한 인덱스

온라인 시도

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

설명 :

우리는 대담을 시작으로 시작

;

우리에게 줘

          v
... 0 0 input 0 0 ...

그런 다음 왼쪽 바이트를 줄이고 오른쪽 바이트를 늘리십시오.

;(-))+(
=======

우리는 결국

           v
... 0 -1 input +1 0 ...

그런 다음 루프를 설정합니다

;(-))+(-
"============<
>  ![< ![<  ![
   #=" #="  #=
!  < !-< !- <
#==" #=" #=="

메모리는 다음과 같이 보일 때까지 루프가 진행됩니다.

         v 
... 0 -X 0 +X 0 ...

그런 다음 결과 만 출력하면됩니다.

;(-))+(-
"============<
>:(![<:![<:)![
 !=#="!#="!=#=
!  < !-< !- <
#==" #=" #=="

파이썬 2, 24 바이트

lambda n:(n/3+1)*(1-n%3)

전체 프로그램 :

a=lambda n:(n/3+1)*(1-n%3)

print(a(0))   #   1
print(a(11))  #  -4
print(a(76))  #   0
print(a(134)) # -45
print(a(296)) # -99

MATL, 15 12 바이트

3/XkG3X\2-*_

이것은 하나의 기반 인덱싱을 사용합니다.

온라인으로 사용해보십시오! 또는 테스트 사례를 확인

설명:

    G          #Input
     3X\       #Modulus, except multiples of 3 give 3 instead of 0
        2-     #Subtract 2, giving -1, 0 or 1
3/Xk           #Ceiling of input divided by 3.
          *    #Multiply 
           _   #Negate

하스켈, 27 바이트

f x=div(x+3)3*(1-mod(x+3)3)

약간 더 흥미로운 28 바이트 솔루션 :

(((\i->[i,0,-i])=<<[1..])!!)

(둘 다 0색인화 됨)

MATL , 8 바이트

:t~y_vG)

결과는 1을 기준으로합니다.

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

설명

이것은 2D 배열을 만듭니다

 1  2  3  4  5 ...
 0  0  0  0  0 ...
-1 -2 -3 -4 -5 ...

그런 다음 선형 색인을 사용하여 원하는 항을 추출합니다. 선형 인덱싱 수단 인덱스 아래로 다음에 걸쳐 (따라서 상기 선형 배열 순서에서 첫번째 엔트리되어 1, 0, -1, 2, 0, ...)

:     % Vector [1 2 ... N], where N is implicit input
t~    % Duplicate and logical negate: vector of zeros
y_    % Duplicate array below the top and negate: vector [-1 -2 ... -N]
v     % Concatenate all stack contents vertically
G)    % Index with input. Implicit display

펄 5, 22 바이트

21 + 1 -p:

$_=(-$_,$_+2)[$_%3]/3

1 기반 인덱싱을 사용합니다.

설명:

-p변수 $_를 입력과 동일하게 설정합니다 . 그런 다음 코드 $_%3는이를 0 기반 목록 (-$_,$_+2)(여기서 %모듈로) 의 th 요소를 3으로 나눈 값과 동일하게 설정합니다 . $_%32 인 경우 해당 요소가 없으며 이후 3으로 나눈 값은 undefined를 0으로 숫자 화 -p한 다음 인쇄합니다 $_.

배쉬, 28 25 바이트

echo $[(1+$1/3)*(1-$1%3)]

펄 6 ,  26  23 바이트

{({|(++$,0,--$)}...*)[$_]}
{($_ div 3+1)*(1-$_%3)}

(짧은 것은 다른 답변에서 번역되었습니다)

설명 (첫 번째 설명) :

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

    # start of sequence generator

    { # bare block
      |(  # slip ( so that it flattens into the outer sequence )
        ++$, # incrementing anon state var =>  1, 2, 3, 4, 5, 6
        0,   # 0                           =>  0, 0, 0, 0, 0, 0
        --$  # decrementing anon state var => -1,-2,-3,-4,-5,-6
      )
    }
    ...  # repeat
    *    # indefinitely

    # end of sequence generator

  )[ $_ ] # get the nth one (zero based)
}

테스트:

#! /usr/bin/env perl6
use v6.c;
use Test;

# store it lexically
my &alt-seq-sign = {({|(++$,0,--$)}...*)[$_]}
my &short-one = {($_ div 3+1)*(1-$_%3)}

my @tests = (
    0 =>   1,
   11 =>  -4,
   76 =>   0,
  134 => -45,
  296 => -99,
  15..^30  => (6,0,-6,7,0,-7,8,0,-8,9,0,-9,10,0,-10)
);

plan @tests * 2 - 1;

for @tests {
  is alt-seq-sign( .key ), .value, 'alt-seq-sign  ' ~ .gist;

  next if .key ~~ Range; # doesn't support Range as an input
  is short-one(    .key ), .value, 'short-one     ' ~ .gist;
}

1..11
ok 1 - alt-seq-sign  0 => 1
ok 2 - short-one     0 => 1
ok 3 - alt-seq-sign  11 => -4
ok 4 - short-one     11 => -4
ok 5 - alt-seq-sign  76 => 0
ok 6 - short-one     76 => 0
ok 7 - alt-seq-sign  134 => -45
ok 8 - short-one     134 => -45
ok 9 - alt-seq-sign  296 => -99
ok 10 - short-one     296 => -99
ok 11 - alt-seq-sign  15..^30 => (6 0 -6 7 0 -7 8 0 -8 9 0 -9 10 0 -10)

J, 19 15 바이트

>.@(%&3)*1-3|<:

아마도 이것을 더 골프화해야 할 것입니다 ...

1- 색인.

언 골프 드 :

>> choose_sign      =: 1-3|<:      NB. 1-((n-1)%3)
>> choose_magnitude =: >.@(%&3)    NB. ceil(n/3)
>> f                =: choose_sign * choose_magnitude
>> f 1 12 77
<< 1 _4 0

여기서 >>입력 (STDIN)을 <<의미하고 출력 (STDOUT)을 의미합니다.

파이크, 8 7 바이트 (이전 버전)

3.DeRt*

여기 사용해보십시오! -링크가 오래 지속되지 않을 수 있습니다.

3.D      - a,b = divmod(input, 3)
   e     - a = ~a -(a+1)
     t   - b -= 1
      *  - a = a*b
         - implicit output a

최신 버전

3.DhRt*_

여기 사용해보십시오!

3.D      - a,b = divmod(input, 3)
   h     - a+=1
     t   - b-=1
      *  - a = a*b
       _ - a = -a
         - implicit output a

J, 27 바이트

가장 골치 아픈 것은 아니지만, 의제를 사용하기 때문에 더 좋아합니다.

>.@(>:%3:)*1:`0:`_1:@.(3|])

여기에 트리 분해가 있습니다.

         ┌─ >.      
  ┌─ @ ──┤    ┌─ >: 
  │      └────┼─ %  
  │           └─ 3: 
  ├─ *              
──┤           ┌─ 1: 
  │      ┌────┼─ 0: 
  │      │    └─ _1:
  └─ @. ─┤          
         │    ┌─ 3  
         └────┼─ |  
              └─ ]  

이것은 Kenny의 J 답변과 매우 유사합니다. 크기와 부호를 선택한다는 점에서 부호를 선택하기 위해 의제를 사용한다는 점이 다릅니다.

MATL, 8 바이트

_3&\wq*_

이 솔루션은 시퀀스에 1 기반 색인을 사용합니다.

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

모든 테스트 사례를 보여주는 수정 된 버전

설명

        % Implicitly grab the input
_       % Negate the input
3&\     % Compute the modulus with 3. The second output is floor(N/3). Because we negated
        % the input, this is the equivalent of ceil(input/3)
w       % Flip the order of the outputs
q       % Subtract 1 from the result of mod to turn [0 1 2] into [-1 0 1]
*       % Take the product with ceil(input/3)
_       % Negate the result so that the sequence goes [N 0 -N] instead of [-N 0 N]
        % Implicitly display the result

Pyth, 10 바이트

*h/Q3-1%Q3

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

설명:

*     : Multiply following two arguments
h/Q3  : 1 + Input/3
-1%Q3 : 1 - Input%3

참고 : 인덱스가 0 인 시퀀스를 가정했습니다.

실제로 10 바이트

3@│\u)%1-*

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

설명:

3@│\u)%1-*
3@│         push 3, swap, duplicate entire stack ([n 3 n 3])
   \u)      floor division, increment, move to bottom ([n 3 n//3+1])
      %1-   mod, subtract from 1 ([1-n%3 n//3+1])
         *  multiply ([(1-n%3)*(n//3+1)])

05AB1E, 7 bytes

Code:

(3‰`<*(

Explained:

(           # negate input: 12 -> -12
 3‰         # divmod by 3: [-4, 0]
   `        # flatten array: 0, -4
    <       # decrease the mod-result by 1: -1, -4
     *      # multiply: 4
      (     # negate -4

GeoGebra, 44 bytes

Element[Flatten[Sequence[{t,0,-t},t,1,n]],n]

where n is one-indexed.

Explanation:

Element[                      , n] # Return the nth element of the list                  .
 Flatten[                    ]     # Strip all the unnecessary braces from the list     /|\
  Sequence[{t,0,-t}, t, 1, n]      # Generate a list of lists of the form {t, 0, -t}     |
                             # This list will start with {1,0,-1} and end with {n,0,-n}  |

It is not necessary to generate all triplets through {n, 0, -n}, but it's shorter than writing ceil(n/3) or something to that effect. Note that n must be defined to create this object (if it isn't defined at the time this is run, GeoGebra will prompt you to create a slider for n).

Labyrinth, 17 15 14 bytes

Saved 3 bytes using Sok's idea of using 1-(n%3) instead of ~(n%3-2).

1?:#/)}_3%-{*!

The program terminates with an error (division by zero), but the error message goes to STDERR.

Try it online!

Explanation

The program is completely linear, although some code is executed in reverse at the end.

1     Turn top of stack into 1.
?:    Read input as integer and duplicate.
#     Push stack depth (3).
/)    Divide and increment.
}     Move over to auxiliary stack.
_3%   Take other copy modulo 3.
-     Subtract from 1. This turns 0, 1, 2 into 1, 0, -1, respectively.
{*    Move other value back onto main stack and multiply.
!     Output as integer.

The instruction pointer now hits a dead end and turns around, so it starts to execute the code from the end:

*     Multiply two (implicit) zeros.
{     Pull an (implicit) zero from the auxiliary to the main stack.
-     Subtract two (implicit) zeros from one another.
      Note that these were all effectively no-ops due to the stacks which are
      implicitly filled with zeros.
%     Attempt modulo, which terminates the program due to a division-by-zero error.

Erlang, 40 bytes

F=fun(N)->trunc((N/3+1)*(1-N rem 3))end.

Sadly Erlang has no '%' modulo operator and 'rem' requires the spaces, even before the 3.

Hexagony, 25 bytes

?'+}@/)${':/3$~{3'.%(/'*!

Or, in non-minified format:

    ? ' + }
   @ / ) $ {
  ' : / 3 $ ~
 { 3 ' . % ( /
  ' * ! . . .
   . . . . .
    . . . .

Try it online!

My first foray into Hexagony, so I'm certain I've not done this anywhere near as efficiently as it could be done...

Calculates -(n%3 - 1) on one memory edge, n/3 + 1 on an adjacent one, then multiplies them together.

R, 28 bytes

-((n=scan())%%3-1)*(n%/%3+1)

Looks like this is a variation of most of the answers here. Zero based.

   n=scan()                  # get input from STDIN
  (        )%%3-1            # mod by 3 and shift down (0,1,2) -> (-1,0,1)
-(               )           # negate result (1,0,-1), this handles the alternating signs
                  *(n%/%3+1) # integer division of n by 3, add 1, multiply by previous

The nice thing about it is that it handles multiple inputs

> -((n=scan())%%3-1)*(n%/%3+1)
1: 0 3 6 9 1 4 7 10 2 5 8 11
13: 
Read 12 items
 [1]  1  2  3  4  0  0  0  0 -1 -2 -3 -4
> 

Originally I wanted to do the following, but couldn't trim off the extra bytes.

rbind(I<-1:(n=scan()),0,-I)[n]

Uses rbind to add 0's and negatives to a range of 1 to n then return the n'th term (one based).

# for n = 5
rbind(                    )    # bind rows 
            n=scan()           # get input from STDIN and assign to n
      I<-1:(        )          # build range 1 to n and assign to I
                     ,0        # add a row of zeros (expanded automatically)
                       ,-I     # add a row of negatives
                           [n] # return the n'th term

Batch (Windows), 86 bytes

Alternate.bat

SET /A r=%1%%3
SET /A d=(%1-r)/3+1
IF %r%==0 ECHO %d%
IF %r%==1 ECHO 0
IF %r%==2 ECHO -%d%

This program is run as Alternate.bat n where n is the number you wish to call the function on.

APL, 12 chars

-×/1-0 3⊤6+⎕

0 3⊤ is APL's divmod 3.

Java 7, 38 37 36 bytes

My first golf, be gentle

int a(int i){return(1+i/3)*(1-i%3);}

Try it here! (test cases included)

Edit: I miscounted, and also golfed off one more character by replacing (-i%3+1) with (1-i%3).

Retina, 45 bytes

.+
11$&$*
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

Try it online!

Test suite.

Takes input/output in base-ten. 1-indexed.

Unary input, base-ten output, 1-indexed: 40 bytes

$
11
(111)+(1)*
$#2$#1
T`d`+0-`^.
^0.+
0

Try it online!

Test suite.

MATLAB / Octave, 27 bytes

@(n)ceil(n/3)*(mod(-n,3)-1)

This creates an anonymous function that can be called using ans(n). This solution uses 1-based indexing.

All test cases

Mathematica 26 bytes

With 4 bytes saved thanks to Martin Ender.

⎡#/3⎤(-#~Mod~3-1)&

Uses the same approach as Suever.

Octave, 23 bytes

With no mod cons...

@(n)(-[-1:1]'*[1:n])(n)

Uses 1-based indexing magic.

Explanation

Creates an anonymous function that will:

(-[-1:1]'*[1:n])(n)
  [-1:1]              % make a row vector [-1 0 1]
 -      '             % negate and take its transpose making a column vector
          [1:n]       % make a row vector [1..n], where n is the input
         *            % multiply with singleton expansion
               (n)    % use linear indexing to get the nth value

After the multiplication step we'll have a 3xn matrix like so (for n=12):

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

Making n columns is overkill, but it's a convenient number that is guaranteed to be large enough. Linear indexing counts down each column from left to right, so the element at linear index 4 would be 2.

All test cases on ideone.

dc, 10

?2+3~1r-*p

Uses 1-based indexing.

?              # Push input to stack
 2+            # Add 2
   3~          # divmod by 3
     1r-       # subtract remainder from 1
        *      # multiply by quotient
         p     # print