pengantar

The tanda nomor adalah baik +, atau -untuk setiap non-nol bilangan bulat. Nol itu sendiri tidak bertanda ( +0sama dengan -0). Dalam urutan berikut, kita akan bergantian antara tanda positif , nol dan tanda negatif . Urutannya dimulai dengan 1, jadi kami menulis 1dengan tanda positif, dengan nol (yang ini aneh, tapi kami hanya mengalikan angka dengan 0) dan tanda negatif:

1, 0, -1

Nomor berikutnya adalah 2, dan kami melakukan hal yang sama lagi:

2, 0, -2

Urutan akhirnya adalah:

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

Atau bentuk yang lebih mudah dibaca:

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

Tugas

Diberikan bilangan bulat n -negatif , menghasilkan istilah ^ke- n dari urutan di atas. Anda dapat memilih apakah Anda menggunakan versi tanpa indeks atau satu indeks .

Kasus uji:

Diindeks nol:

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

Atau jika Anda lebih suka satu-diindeks:

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

Ini adalah kode-golf , jadi pengiriman dengan jumlah byte terkecil menang!

Jelly, 7 byte

+6d3’PN

Diindeks nol. Uji kasus di sini.

Penjelasan:

+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)

JavaScript ES6, 18 byte

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

Ternyata sangat mirip dengan jawaban @ LeakyNun tapi saya tidak melihatnya sampai setelah saya memposting milik saya.

Penjelasan dan Tidak Disatukan

-~adalah singkatan Math.ceil, atau pembulatan:

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 byte

satu-diindeks

Cobalah secara Online

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

Penjelasan:

kita mulai dengan mengambil imput

;

yang memberi kita

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

kita kemudian mengurangi byte kiri dan menambah byte kanan dengan

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

kita berakhir dengan

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

kami kemudian mengatur loop

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

loop akan pergi hingga memori terlihat seperti

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

maka kita hanya perlu menampilkan hasilnya

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

Python 2, 24 byte

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

Program lengkap:

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 byte

3/XkG3X\2-*_

Ini menggunakan pengindeksan berbasis satu.

Cobalah online!atau memverifikasi kasus uji

Penjelasan:

    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

Haskell, 27 byte

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

Solusi 28 byte yang sedikit lebih menarik:

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

(Keduanya 0-indeks)

MATL , 8 byte

:t~y_vG)

Hasilnya berbasis 1.

Cobalah online!

Penjelasan

Ini membangun array 2D

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

dan kemudian menggunakan pengindeksan linear untuk mengekstrak istilah yang diinginkan. Linear pengindeksan berarti indeks turun, kemudian di (sehingga dalam array di atas entri pertama dalam rangka linear adalah 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

Perl 5, 22 byte

21 plus satu untuk -p:

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

Menggunakan pengindeksan berbasis 1.

Penjelasan:

-pmengatur variabel $_sama dengan input. Kode kemudian set sama dengan $_%3elemen th, dibagi 3, dari daftar berbasis 0 (-$_,$_+2)(di mana %modulo). Perhatikan bahwa jika $_%3dua, maka tidak ada elemen tersebut, dan pembagian berikutnya dengan 3 menandakan undefined menjadi 0. -plalu mencetak $_.

Bash, 28 25 Bytes

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

Perl 6 ,  26  23 byte

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

(Yang lebih pendek diterjemahkan dari jawaban lain)

Penjelasan (dari yang pertama):

{ # 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)
}

Uji:

#! /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 byte

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

Mungkin perlu bermain golf lebih jauh ...

1-diindeks.

Tidak Terkumpul:

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

Di mana >>berarti input (STDIN) dan <<berarti output (STDOUT).

Pyke, 8 7 byte (versi lama)

3.DeRt*

Coba di sini! - Perhatikan bahwa tautan mungkin tidak akan bertahan lama

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

Versi terbaru

3.DhRt*_

Coba di sini!

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

J, 27 byte

Meskipun bukan golf, saya lebih menyukainya, karena menggunakan agenda.

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

Ini adalah dekomposisi pohonnya:

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

Ini sangat mirip dengan jawaban J Kenny, karena ia memilih besarnya dan tanda, tetapi berbeda karena saya menggunakan agenda untuk memilih tanda.

MATL, 8 byte

_3&\wq*_

Solusi ini menggunakan pengindeksan berbasis 1 ke dalam urutan.

Cobalah secara Online

Versi modifikasi menunjukkan semua kasus uji

Penjelasan

        % 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 byte

*h/Q3-1%Q3

Cobalah online!

Penjelasan:

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

Catatan: Saya telah mengasumsikan urutan tanpa indeks.

Sebenarnya 10 byte

3@│\u)%1-*

Cobalah online!

Penjelasan:

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 byte

Kode:

(3‰`<*(

Dijelaskan:

(           # 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 byte

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

di mana nsatu-diindeks.

Penjelasan:

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

Tidak perlu untuk menghasilkan semua kembar tiga melalui {n, 0, -n}, tetapi lebih pendek daripada menulis ceil(n/3)atau sesuatu untuk efek itu. Catatan yang nharus didefinisikan untuk membuat objek ini (jika tidak ditentukan pada saat ini dijalankan, GeoGebra akan meminta Anda untuk membuat slider untuk n).

Labirin , 17 15 14 byte

Disimpan 3 byte menggunakan ide Sok menggunakan 1-(n%3)bukan ~(n%3-2).

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

Program berakhir dengan kesalahan (pembagian dengan nol), tetapi pesan kesalahan pergi ke STDERR.

Cobalah online!

Penjelasan

Program ini sepenuhnya linier, meskipun beberapa kode dijalankan terbalik pada akhirnya.

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.

Penunjuk instruksi sekarang menyentuh jalan buntu dan berbalik, sehingga mulai menjalankan kode dari ujung:

*     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 byte

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

Sayangnya Erlang tidak memiliki operator modulo '%' dan 'rem' membutuhkan spasi, bahkan sebelum 3.

Hexagony , 25 byte

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

Atau, dalam format yang tidak diperkecil:

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

Cobalah online!

Perampokan pertama saya ke Hexagony, jadi saya yakin saya belum melakukan ini sedekat seefisien mungkin ...

Hitung -(n%3 - 1)pada satu tepi memori, n/3 + 1pada sisi yang berdekatan, lalu gandakan bersama.

R, 28 byte

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

Sepertinya ini adalah variasi dari sebagian besar jawaban di sini. Berbasis nol.

   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

Yang menyenangkan tentang ini adalah ia menangani banyak input

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

Awalnya saya ingin melakukan hal berikut, tetapi tidak bisa memotong byte tambahan.

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

Menggunakan rbinduntuk menambahkan 0 dan negatif ke kisaran 1 untuk nkemudian mengembalikan istilah n'th (berbasis satu).

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

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%

Program ini dijalankan di Alternate.bat nmana nnomor yang ingin Anda panggil fungsi.

APL, 12 karakter

-×/1-0 3⊤6+⎕

0 3⊤adalah APL divmod 3.

Java 7, 38 37 36 byte

Golf pertamaku, bersikaplah lembut

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

Coba di sini! (termasuk kasus uji)

Sunting: Saya salah hitung, dan juga bermain satu karakter lagi dengan mengganti (-i%3+1)dengan (1-i%3).

Retina, 45 byte

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

Cobalah online!

Suite uji.

Mengambil input / output dalam basis-sepuluh. 1-diindeks.

Input unary, output basis-sepuluh, 1-diindeks: 40 byte

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

Cobalah online!

Suite uji.

MATLAB / Oktaf, 27 byte

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

Ini menciptakan fungsi anonim yang dapat dipanggil menggunakan ans(n). Solusi ini menggunakan pengindeksan berbasis 1.

Semua uji kasus

Mathematica 26 byte

Dengan 4 byte disimpan berkat Martin Ender.

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

Menggunakan pendekatan yang sama dengan Suever.

Oktaf, 23 byte

Tanpa mod kontra ...

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

Menggunakan sihir pengindeksan berbasis 1.

Penjelasan

Menciptakan fungsi anonim yang akan:

(-[-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

Setelah langkah multiplikasi kita akan memiliki matriks 3xn seperti itu (untuk 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

Membuat nkolom terlalu banyak, tetapi jumlah yang nyaman yang dijamin cukup besar. Pengindeksan linear menghitung mundur setiap kolom dari kiri ke kanan, sehingga elemen pada indeks linier 4akan 2.

Semua uji kasus pada ideone .

dc, 10

?2+3~1r-*p

Menggunakan pengindeksan berbasis 1.

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