Introducción

El signo de un número es a +, o a -para cada entero distinto de cero. El cero en sí mismo no tiene signos ( +0es lo mismo que -0). En la siguiente secuencia, vamos a alternar entre el signo positivo , el cero y el signo negativo . La secuencia comienza con 1, así que escribimos 1con un signo positivo, con cero (este es extraño, pero simplemente multiplicamos el número por 0) y el signo negativo:

1, 0, -1

El siguiente número es 2, y hacemos lo mismo otra vez:

2, 0, -2

La secuencia finalmente es:

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

O una forma más legible:

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

La tarea

Dado un número entero no negativo n , salida de la n ^º término de la secuencia anterior. Puede elegir si utiliza la versión indexada a cero o indexada a una .

Casos de prueba:

Indexado a cero:

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

O si prefiere un índice:

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

Este es el código de golf , por lo que gana el envío con el menor número de bytes.

Jalea, 7 bytes

+6d3’PN

Indexado a cero. Prueba casos aquí.

Explicación:

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

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

Resultó muy similar a la respuesta de @ LeakyNun, pero no vi la suya hasta que publiqué la mía.

Explicación y Ungolfed

-~es la abreviatura de Math.ceil, o redondeando:

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 bytes

un índice

Pruébalo en línea

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

Explicacion:

comenzamos tomando la entrada

;

que nos dan

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

luego disminuimos el byte izquierdo e incrementamos el byte derecho con

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

terminamos con

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

luego configuramos el bucle

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

el bucle irá hasta que la memoria parezca

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

entonces solo necesitamos dar salida al resultado

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

Python 2, 24 bytes

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

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

3/XkG3X\2-*_

Esto utiliza una indexación basada.

Pruébalo en línea! o verificar casos de prueba

Explicación:

    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 bytes

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

Solución un poco más interesante de 28 bytes:

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

(Ambos están 0indexados)

MATL , 8 bytes

:t~y_vG)

El resultado está basado en 1.

Pruébalo en línea!

Explicación

Esto construye la matriz 2D

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

y luego usa indexación lineal para extraer el término deseado. Linear medios de indexación índice hacia abajo, a continuación, a través de (por lo que en la matriz por encima de las primeras entradas de orden lineal son 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 bytes

21 más uno para -p:

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

Utiliza indexación basada en 1.

Explicación:

-pestablece la variable $_igual a la entrada. El código luego lo establece igual al $_%3elemento th, dividido por 3, de la lista basada en 0 (-$_,$_+2)(donde% es módulo). Tenga en cuenta que si $_%3es dos, entonces no existe tal elemento, y la división posterior por 3 numera lo indefinido a 0. -pluego imprime $_.

Bash, 28 25 bytes

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

Perl 6 ,  26  23 bytes

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

(El más corto fue traducido de otras respuestas)

Explicación (de la primera):

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

Prueba:

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

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

Probablemente necesites jugar más golf ...

1 indexado.

Sin golf:

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

Donde >>significa entrada (STDIN) y <<salida (STDOUT).

Pyke, 8 7 bytes (versión anterior)

3.DeRt*

Pruébalo aquí! - Tenga en cuenta que el enlace probablemente no durará mucho

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

Versión más nueva

3.DhRt*_

Pruébalo aquí!

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

J, 27 bytes

Aunque no es el más golfista, me gusta más, ya que utiliza una agenda.

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

Aquí está la descomposición del árbol:

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

Esto es muy similar a la respuesta J de Kenny, ya que elige la magnitud y el signo, pero es diferente porque uso una agenda para elegir el signo.

MATL, 8 bytes

_3&\wq*_

Esta solución utiliza indexación basada en 1 en la secuencia.

Pruébalo en línea

Versión modificada que muestra todos los casos de prueba.

Explicación

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

*h/Q3-1%Q3

Pruébalo en línea!

Explicación:

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

Nota: He asumido la secuencia de índice cero.

En realidad, 10 bytes

3@│\u)%1-*

Pruébalo en línea!

Explicación:

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

Código:

(3‰`<*(

Explicado:

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

dónde n está indexado

Explicación:

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

No es necesario generar todos los tripletes {n, 0, -n}, pero es más corto que escribir ceil(n/3)o algo así. Tenga en cuenta que ndebe definirse para crear este objeto (si no está definido en el momento en que se ejecuta, GeoGebra le pedirá que cree un control deslizante para n).

Laberinto , 17 15 14 bytes

Guardado 3 bytes usando la idea de Sok de usar en 1-(n%3)lugar de ~(n%3-2).

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

El programa termina con un error (división por cero), pero el mensaje de error va a STDERR.

Pruébalo en línea!

Explicación

El programa es completamente lineal, aunque algunos códigos se ejecutan a la inversa al final.

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.

El puntero de instrucciones ahora llega a un callejón sin salida y gira, por lo que comienza a ejecutar el código desde el final:

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

Lamentablemente, Erlang no tiene un operador de módulo '%' y 'rem' requiere espacios, incluso antes del 3.

Hexagonía , 25 bytes.

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

O, en formato no minificado:

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

Pruébalo en línea!

Mi primera incursión en Hexagony, así que estoy seguro de que no he hecho esto de manera tan eficiente como podría hacerse ...

Calcula -(n%3 - 1)en un borde de memoria, n/3 + 1en uno adyacente, luego los multiplica.

R, 28 bytes

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

Parece que esta es una variación de la mayoría de las respuestas aquí. Basado en cero.

   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

Lo bueno de esto es que maneja múltiples entradas

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

Originalmente quería hacer lo siguiente, pero no pude recortar los bytes adicionales.

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

Utiliza rbindpara agregar 0 y negativos a un rango de 1 para nluego devolver el ntérmino 'th (basado en uno).

# 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

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

Este programa se ejecuta como Alternate.bat ndónde nestá el número al que desea llamar la función.

APL, 12 caracteres

-×/1-0 3⊤6+⎕

0 3⊤es de APL divmod 3.

Java 7, 38 37 36 bytes

Mi primer golf, se gentil

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

Pruébalo aquí! (casos de prueba incluidos)

Editar: conté mal y también eliminé un personaje más al reemplazarlo (-i%3+1)por (1-i%3).

Retina, 45 bytes

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

Pruébalo en línea!

Banco de pruebas.

Toma entrada / salida en base diez. 1 indexado.

Entrada unaria, salida de base diez, indexada 1: 40 bytes

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

Pruébalo en línea!

Banco de pruebas.

MATLAB / Octava, 27 bytes

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

Esto crea una función anónima que se puede llamar usando ans(n). Esta solución utiliza indexación basada en 1.

Todos los casos de prueba

Mathematica 26 bytes

Con 4 bytes guardados gracias a Martin Ender.

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

Utiliza el mismo enfoque que Suever.

Octava, 23 bytes

Sin contras mod ...

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

Utiliza magia de indexación basada en 1.

Explicación

Crea una función anónima que:

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

Después del paso de multiplicación tendremos una matriz 3xn como esta (para 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

Hacer ncolumnas es excesivo, pero es un número conveniente que se garantiza que es lo suficientemente grande. La indexación lineal cuenta hacia atrás cada columna de izquierda a derecha, por lo que el elemento en el índice lineal 4sería 2.

Todos los casos de prueba en ideona .

dc, 10

?2+3~1r-*p

Utiliza indexación basada en 1.

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