Einführung

Das Vorzeichen einer Zahl ist entweder a +oder a -für jede Ganzzahl ungleich Null. Null selbst ist vorzeichenlos ( +0ist dasselbe wie -0). In der folgenden Sequenz werden wir zwischen dem positiven Vorzeichen , der Null und dem negativen Vorzeichen wechseln . Die Sequenz beginnt mit 1, also schreiben wir 1mit einem positiven Vorzeichen, mit Null (dieses ist seltsam, aber wir multiplizieren nur die Zahl mit 0) und dem negativen Vorzeichen:

1, 0, -1

Die nächste Nummer ist 2, und wir machen das Gleiche noch einmal:

2, 0, -2

Die Reihenfolge ist schließlich:

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

Oder eine besser lesbare Form:

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

Die Aufgabe

Bei einer nicht negativen ganzen Zahl n wird der n- ^te Term der obigen Sequenz ausgegeben . Sie können wählen , ob Sie die verwenden Null-indizierte oder eine indizierte Version.

Testfälle:

Nullindexiert:

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

Oder wenn Sie einseitig indiziert bevorzugen:

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

Das ist Code-Golf , also gewinnt die Einsendung mit der geringsten Anzahl von Bytes!

Gelee, 7 Bytes

+6d3’PN

Null indexiert. Testfälle hier.

Erläuterung:

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

Es stellte sich heraus, dass es der Antwort von @ LeakyNun sehr ähnlich war, aber ich habe seine erst gesehen, nachdem ich meine gepostet hatte.

Erklärung und Ungolfed

-~steht für Math.ceiloder rundet auf:

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

einseitig indiziert

Probieren Sie es online

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

Erklärung:

Wir fangen mit der Eingabe an

;

die uns geben

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

Wir dekrementieren dann das linke Byte und inkrementieren das rechte Byte mit

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

wir landen mit

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

Dann haben wir die Schleife aufgebaut

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

Die Schleife wird fortgesetzt, bis der Speicher wie folgt aussieht

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

wir brauchen dann nur noch das ergebnis auszugeben

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

Python 2, 24 Bytes

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

Volles Programm:

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

Dies verwendet eine einseitige Indizierung.

Probieren Sie es online! oder Testfälle verifizieren

Erläuterung:

    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)

Etwas interessantere 28-Byte-Lösung:

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

(Beide sind 0indiziert)

MATL , 8 Bytes

:t~y_vG)

Das Ergebnis ist 1-basiert.

Probieren Sie es online!

Erläuterung

Dadurch wird das 2D-Array erstellt

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

und verwendet dann die lineare Indizierung, um den gewünschten Term zu extrahieren. Linear Indexierungsmittel Index nach unten, dann über (so in der obigen Anordnung der ersten Einträge in linearer Reihenfolge ist 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 plus eins für -p:

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

Verwendet 1-basierte Indizierung.

Erläuterung:

-pSetzt die Variable $_gleich der Eingabe. Der Code setzt es dann gleich dem $_%3durch 3 geteilten Element der 0-basierten Liste (-$_,$_+2)(wobei %modulo ist). Beachten Sie, dass $_%3es kein solches Element gibt , wenn es zwei gibt, und die nachfolgende Division durch 3 das undefinierte Element mit 0 nummeriert. -pAnschließend wird gedruckt $_.

Bash, 28 25 Bytes

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

Perl 6 ,  26  23 Bytes

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

(Die kürzere wurde aus anderen Antworten übersetzt)

Erklärung (der ersten):

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

Prüfung:

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

Vermutlich muss das weiter golfen ...

1-indiziert.

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

Dabei >>bedeutet Eingabe (STDIN) und <<bedeutet Ausgabe (STDOUT).

Pyke, 8 7 Bytes (alte Version)

3.DeRt*

Probieren Sie es hier aus! - Beachten Sie, dass der Link wahrscheinlich nicht lange hält

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

Neueste Version

3.DhRt*_

Probieren Sie es hier aus!

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

J, 27 Bytes

Obwohl es nicht das Golfspiel ist, gefällt es mir besser, da es eine Agenda verwendet.

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

Hier ist die Baumzerlegung davon:

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

Dies ist Kennys J-Antwort sehr ähnlich, da es die Größe und das Vorzeichen wählt, aber es unterscheidet sich darin, dass ich eine Agenda verwende, um das Vorzeichen zu wählen.

MATL, 8 Bytes

_3&\wq*_

Diese Lösung verwendet eine 1-basierte Indizierung in der Sequenz.

Probieren Sie es online

Geänderte Version mit allen Testfällen

Erläuterung

        % 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

Probieren Sie es online!

Erläuterung:

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

Anmerkung: Ich habe die nullindizierte Sequenz angenommen.

Eigentlich 10 Bytes

3@│\u)%1-*

Probieren Sie es online!

Erläuterung:

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‰`<*(

Erklärt:

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

wo nist einsindiziert.

Erläuterung:

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

Es ist nicht notwendig, alle Drillinge durch zu erzeugen {n, 0, -n}, aber es ist kürzer als das Schreiben ceil(n/3)oder etwas in diesem Sinne. Beachten Sie, dass ndieses Objekt definiert werden muss, um es zu erstellen. (Wenn es zum Zeitpunkt der Ausführung nicht definiert ist, fordert GeoGebra Sie auf, einen Schieberegler für dieses Objekt zu erstellen n.)

Labyrinth , 17 15 14 Bytes

3 Bytes mit der Idee von Sok gespeichert, 1-(n%3)anstelle von ~(n%3-2).

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

Das Programm wird mit einem Fehler (Division durch Null) beendet, die Fehlermeldung geht jedoch an STDERR.

Probieren Sie es online!

Erläuterung

Das Programm ist vollständig linear, obwohl am Ende ein Teil des Codes in umgekehrter Reihenfolge ausgeführt wird.

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.

Der Befehlszeiger stößt jetzt auf eine Sackgasse und dreht sich um, sodass er den Code ab dem Ende ausführt:

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

Leider hat Erlang keinen '%' Modulo-Operator und 'rem' benötigt die Leerzeichen, sogar vor der 3.

Hexagony , 25 Bytes

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

Oder im nicht minimierten Format:

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

Probieren Sie es online!

Mein erster Ausflug in Hexagony, also bin ich mir sicher, dass ich das bei weitem nicht so effizient gemacht habe, wie es nur geht ...

Berechnet -(n%3 - 1)an einer Speicherflanke,n/3 + 1 an einer benachbarten, und multipliziert sie dann miteinander.

R, 28 Bytes

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

Sieht so aus, als wäre dies eine Variation der meisten Antworten hier. Null basiert.

   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

Das Schöne daran ist, dass es mehrere Eingaben verarbeitet

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

Ursprünglich wollte ich Folgendes tun, konnte aber die zusätzlichen Bytes nicht abschneiden.

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

Dient rbindzum Hinzufügen von Nullen und Negativen zu einem Bereich von 1, um ndann den n'ten Term (basierend auf Eins) zurückzugeben.

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

Dieses Programm wird als Alternate.bat nwo nist die Nummer , die Sie wollen auf die Funktion aufzurufen.

APL, 12 Zeichen

-×/1-0 3⊤6+⎕

0 3⊤ist APL divmod 3.

Java 7, 38 37 36 Bytes

Mein erstes Golf, sei sanft

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

Probieren Sie es hier aus!(Testfälle enthalten)

Edit: Ich verzählt, und auch aus einem mehr Charakter golfed durch Ersetzen (-i%3+1)mit (1-i%3).

Netzhaut, 45 Bytes

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

Probieren Sie es online!

Testsuite.

Nimmt Eingabe / Ausgabe in Basis zehn. 1-indiziert.

Unäre Eingabe, Basis-Zehn-Ausgabe, 1-indiziert: 40 Bytes

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

Probieren Sie es online!

Testsuite.

MATLAB / Octave, 27 Bytes

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

Dadurch wird eine anonyme Funktion erstellt, die mit aufgerufen werden kann ans(n). Diese Lösung verwendet eine 1-basierte Indizierung.

Alle Testfälle

Mathematica 26 Bytes

Mit 4 Bytes gespart dank Martin Ender.

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

Verwendet den gleichen Ansatz wie Suever.

Oktave, 23 Bytes

Ohne jeglichen Kom ...

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

Verwendet 1-basierte Indizierungsmagie.

Erläuterung

Erstellt eine anonyme Funktion, die:

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

Nach dem Multiplikationsschritt erhalten wir eine 3xn-Matrix wie folgt (für 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

Das Erstellen von nSpalten ist übertrieben, aber es ist eine praktische Zahl, die garantiert groß genug ist. Bei der linearen Indizierung wird jede Spalte von links nach rechts heruntergezählt, sodass das Element mit dem linearen Index 4angezeigt wird2 .

Alle Testfälle auf ideone .

dc, 10

?2+3~1r-*p

Verwendet 1-basierte Indizierung.

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