introduzione

Il segno di un numero è a +, o a -per ogni numero intero diverso da zero. Zero stesso è senza segno ( +0è uguale a -0). Nella sequenza seguente, alterneremo il segno positivo , lo zero e il segno negativo . La sequenza inizia con 1, quindi scriviamo 1con un segno positivo, con zero (questo è strano, ma moltiplichiamo il numero per 0) e il segno negativo:

1, 0, -1

Il prossimo numero è 2e facciamo di nuovo la stessa cosa:

2, 0, -2

La sequenza alla fine è:

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

O un modulo più leggibile:

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

L'obiettivo

Dato un intero non negativo n , uscita n ^esimo termine della sequenza sopra. Puoi scegliere se utilizzare la versione con indicizzazione zero o con un indice .

Casi test:

Zero-indicizzato:

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

O se preferisci uno indicizzato:

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

Questo è code-golf , quindi vince l'invio con il minor numero di byte!

Gelatina, 7 byte

+6d3’PN

Zero indicizzati. Casi di prova qui.

Spiegazione:

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

È risultato molto simile alla risposta di @ LeakyNun ma non ho visto la sua fino a quando non ho pubblicato la mia.

Spiegazione e Ungolfed

-~è una scorciatoia Math.ceilo un arrotondamento per eccesso:

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

one-indicizzato

Provalo online

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

Spiegazione :

iniziamo prendendo l'imput

;

che ci danno

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

quindi decrementiamo il byte sinistro e incrementiamo il byte destro con

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

finiamo con

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

quindi impostiamo il loop

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

il ciclo andrà avanti fino a quando non appare la memoria

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

abbiamo quindi solo bisogno di produrre il risultato

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

Python 2, 24 byte

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

Programma completo:

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

Questo utilizza un'indicizzazione basata.

Provalo online! o verifica i casi di test

Spiegazione:

    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)

Soluzione leggermente più interessante a 28 byte:

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

(Entrambi sono 0indicizzati)

MATL , 8 byte

:t~y_vG)

Il risultato è basato su 1.

Provalo online!

Spiegazione

Questo crea l'array 2D

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

e quindi utilizza l'indicizzazione lineare per estrarre il termine desiderato. Lineare mezzi indicizzatori indice verso il basso, poi attraverso (quindi nella matrice sopra le prime voci in ordine lineare sono 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 più uno per -p:

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

Utilizza l'indicizzazione basata su 1.

Spiegazione:

-pimposta la variabile $_uguale all'input. Il codice quindi lo imposta uguale $_%3all'elemento th, diviso per 3, dell'elenco basato su 0 (-$_,$_+2)(dove %è modulo). Si noti che se $_%3è due, allora non esiste tale elemento e la divisione successiva per 3 numera il non definito a 0. -pquindi stampa $_.

Bash, 28 25 byte

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

Perl 6 ,  26  23 byte

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

(Il più breve è stato tradotto da altre risposte)

Spiegazione (della prima):

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

Test:

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

Probabilmente hai bisogno di giocare a golf ulteriormente ...

1-indicizzati.

Ungolfed:

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

Dove >>significa input (STDIN) e <<output (STDOUT).

Pyke, 8 7 byte (vecchia versione)

3.DeRt*

Provalo qui! - Nota che probabilmente il link non durerà a lungo

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

Ultima versione

3.DhRt*_

Provalo qui!

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

J, 27 byte

Sebbene non sia il più golfistico, mi piace di più, poiché utilizza un programma.

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

Ecco la decomposizione dell'albero di esso:

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

Questo è molto simile alla risposta J di Kenny, in quanto sceglie la grandezza e il segno, ma è diverso in quanto uso un ordine del giorno per scegliere il segno.

MATL, 8 byte

_3&\wq*_

Questa soluzione utilizza l'indicizzazione basata su 1 nella sequenza.

Provalo online

Versione modificata che mostra tutti i casi di test

Spiegazione

        % 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

Provalo online!

Spiegazione:

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

Nota: ho assunto la sequenza indicizzata zero.

In realtà, 10 byte

3@│\u)%1-*

Provalo online!

Spiegazione:

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

Codice:

(3‰`<*(

Ha spiegato:

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

dove n è uno indicizzato.

Spiegazione:

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

Non è necessario generare tutte le terzine {n, 0, -n}, ma è più breve della scrittura ceil(n/3)o qualcosa del genere. Nota che ndeve essere definito per creare questo oggetto (se non è definito al momento dell'esecuzione, GeoGebra ti chiederà di creare un cursore per n).

Labirinto , 17 15 14 byte

Ho salvato 3 byte usando l'idea di Sok di usare 1-(n%3)invece di ~(n%3-2).

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

Il programma termina con un errore (divisione per zero), ma il messaggio di errore passa a STDERR.

Provalo online!

Spiegazione

Il programma è completamente lineare, anche se alla fine un codice viene eseguito al contrario.

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.

Il puntatore dell'istruzione ora colpisce un vicolo cieco e si gira, quindi inizia a eseguire il codice dalla fine:

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

Purtroppo Erlang non ha un operatore '%' modulo e 'rem' richiede gli spazi, anche prima del 3.

Esagonia , 25 byte

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

Oppure, in formato non minimizzato:

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

Provalo online!

La mia prima incursione in Hexagony, quindi sono certo di non averlo fatto da nessuna parte nel modo più efficiente possibile ...

Calcola -(n%3 - 1)su un bordo di memoria, n/3 + 1su uno adiacente, quindi li moltiplica insieme.

R, 28 byte

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

Sembra che questa sia una variazione della maggior parte delle risposte qui. Basato su zero.

   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

La cosa bella è che gestisce più 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
> 

Inizialmente volevo fare quanto segue, ma non potevo tagliare i byte extra.

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

Usa rbindper aggiungere 0 e negativi a un intervallo di 1 per npoi restituire il ntermine (uno basato).

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

Questo programma viene eseguito Alternate.bat ndove si ntrova il numero su cui si desidera chiamare la funzione.

APL, 12 caratteri

-×/1-0 3⊤6+⎕

0 3⊤è di APL divmod 3.

Java 7, 38 37 36 byte

Il mio primo golf, sii gentile

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

Provalo qui!(casi di test inclusi)

Modifica: ho contato male e ho anche eliminato un altro personaggio sostituendolo (-i%3+1)con (1-i%3).

Retina, 45 byte

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

Provalo online!

Suite di test.

Accetta input / output in base-dieci. 1-indicizzati.

Input unario, output base-dieci, 1 indicizzato: 40 byte

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

Provalo online!

Suite di test.

MATLAB / Octave, 27 byte

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

Questo crea una funzione anonima che può essere chiamata usando ans(n) . Questa soluzione utilizza l'indicizzazione basata su 1.

Tutti i casi di test

Mathematica 26 byte

Con 4 byte salvati grazie a Martin Ender.

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

Utilizza lo stesso approccio di Suever.

Ottava, 23 byte

Senza mod contro ...

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

Utilizza la magia di indicizzazione basata su 1.

Spiegazione

Crea una funzione anonima che:

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

Dopo la fase di moltiplicazione avremo una matrice 3xn in questo modo (per 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

Fare ncolonne è eccessivo, ma è un numero conveniente che è garantito per essere abbastanza grande. L'indicizzazione lineare conta ogni colonna da sinistra a destra, quindi l'elemento sull'indice lineare 4sarebbe 2.

Tutti i casi di test su ideone .

dc, 10

?2+3~1r-*p

Utilizza l'indicizzazione basata su 1.

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