Generate the list [1, 0, -1, 0, 1, 0, -1, 0, ...]

Question

In the spirit of a question on math.se: given an integer n, return the integer in position n of the sequence [1, 0, -1, 0, 1, 0, -1, 0, ...]. Assume n >= 0.

Rules:

1. You may only use the operations -x, x+y, x-y, x*y, x/y, and x^y, whatever their representations are in the language you choose.
2. Your function must be called a.
3. Your function must run in constant time for all n.

Example:

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

Non-example (uses list subscripting operation and modulo operator):

a=lambda n:[1,0,-1,0][n%4]

Non-example (uses cos operation):

from math import *;a=lambda n:int(cos(n*pi/2))

Non-example (does not run in constant time and uses if operation):

a=lambda n:-a(n-2) if n>1 else 0 if n>0 else 1

Clarifications: Both integer and float division are allowed. Your solution may return either an integer or a float (or complex number, I suppose, since some answers already used it). If your solution returns a float: your solution should, if it were to theoretically be carried out to infinite precision, give the exact answer.

Answer 1

Ruby, 26 characters

a=->n{1-(k=n-n/4*4)+k/3*2}

Example:

> p (0..10).map{|n| a[n]}
[1, 0, -1, 0, 1, 0, -1, 0, 1, 0, -1]

Note: This solution assumes that integer division / is an allowed operation.

Answer 2

Python, 29 chars

a=lambda n:(1j**n+(-1j)**n)/2

Kind of cheating, but fun.

Edit:

Now that we can return complex numbers, this is competitive and no longer cheating (with Howard's suggestion).

Answer 3

C, 36 chars

a(n){return(1-n+n/2*2)*(1-n+n/4*4);}

The same function used by Peter Taylor.

Answer 4

Python, 36 chars

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

Answer 5

J, 18 characters

a=:[:{.[:+._1^2%~]

Works, but is probably cheating by the rules set out above.

Calculates -1 to the power of the given integer divided by 2 which gives 0j1 for any odd number. The {. and the +. return the real part so that the odd numbers give 0.

Usage:

   a 1
0
   a 6
_1

Edit: After feeling a bit smug about this I've just looked properly at Keith's answers and realized I've done essentially the same thing.

Answer 6

GolfScript (20 19 chars)

{.4/4*-.3/2*)\-}:a;

This is a port of Howard's solution.

If, in addition to division, the remainder operation were permitted, this could be improved substantially (by 6 5 chars):

{.2%(\4%(*}:b;

Mathematically that's

x => (x%2 - 1) (x%4 - 1)

I can't see any logic behind excluding remainder, since it's defined in terms of permitted operations.

Answer 7

Python, 34 chars

Poor man's modulus... saves a whopping 2 chars over Keith Randall's solution. Take that! ;)

a=lambda n:(n-1-n/2*2)*(n-1-n/4*4)

edit: on reading others' solutions, this is the same as Peter Taylor's

Answer 8

TI-Basic, 12 bytes

i^Ans+i^-Ans
Ans/2

Store in prgmA and run with 5:prgmA, with the input in place of 5.

TI-Basic implicitly returns the last evaluated value.

Answer 9

Python 2, 28 bytes

a=lambda n:(n/2*2-n+1)*1j**n

Try it online!

Proof of validity for those who don't know Python:

The expression is (n/2*2-n+1)*1j**n. If you add parentheses, it becomes ((((n/2)*2)-n)+1)*(1j**n). / is integer division, since both n and 2 are integers in this case, * is multiplication, - is subtraction, + is addition and ** is exponentiation.

Answer 10

Java 8, 21 bytes

n->1-(n-=n/4*4)+n/3*2

Port of @Howard's Ruby answer.

Try it online.

Answer 11

bc: 28 chars

echo 'a=4;(1-a+a/2*2)*(1-a+a/4*4)' | bc

Answer 12

Python, 49 chars

a=lambda n:(lambda x:(x**3-3*x*x-x+3)/3)(n-n/4*4)

Note: In Python3 you'll have to replace n/4 with n//4 at the end.

Answer 13

8086 Assembler (14 bytes of machine code):

 ; ax holds the index into the sequence
 ; returns the sequence value in ax
 a: inc al
    shl al,6
    sar al,6
    cbw
    xor al,ah
    add al,ah
    cbw                     
    ret