Tarefa:

Dado o índice amostral, x, calcule o valor amostral f (x) da onda triangular, com período de 4 amostras e amplitude 1. O deslocamento pode ser negativo e o valor da amostra pode ser {0, 1, -1}.

Casos de teste:

   -5 -> -1
   -4 -> 0
   -3 -> 1
   -2 -> 0
   -1 -> -1
    0 -> 0
    1 -> 1
    2 -> 0
    3 -> -1
    4 -> 0
    5 -> 1

Pessoalmente, conheço duas abordagens em C - a primeira está usando a tabela de pesquisa, a segunda está usando instruções condicionais. Para pontos brownie, você poderia me impressionar com uma abordagem "matemática" pura? (Quero dizer uma abordagem funcional pura, por exemplo, não usar instruções condicionais ou usar memória para LUT.) Mas isso não é uma restrição. Se você não pode, ou o seu idioma não o suporta - basta postar qualquer solução

Mathematica, 8 bytes

Im[I^#]&

Explicação

Im[I^#]&
   I^#    (* Raise the imaginary unit to the input power *)
Im[   ]   (* Take the imaginary part *)

TI-Básico, 7 5 4 bytes

sin(90Ans

(Modo Grau) -1 byte de @immibis da minha resposta antiga.

Resposta antiga

imag(i^Ans

Abordagem de matemática pura em uma calculadora. :)

Apenas por diversão, aqui está outra solução de matemática pura (ish) para 9 bytes (no modo radiano) ou 8 bytes (modo Grau)

2/πsin-1sin(πAns/2 # Radians
90-1sin-1sin(90Ans # Degrees

Python 2 , 20 bytes

lambda n:n%2-n%4/3*2

Experimente online!

Estou executando uma pesquisa de força bruta por expressões aritméticas ou bit a bit mais curtas, vou ver se algo aparece. Este eu encontrei à mão.

Julia 0,5 , 12 bytes

!n=(2-n&3)%2

Eu gosto dessa abordagem porque é improvável que seja a mais curta em qualquer outro idioma.

Experimente online!

Como funciona

A precedência do operador de Julia é um pouco incomum: ao contrário da maioria dos outros idiomas, os operadores bit a bit têm a mesma precedência que suas contrapartes aritméticas, portanto &(multiplicação por bit) tem a mesma precedência que *.

Primeiro, n&3pega o módulo de entrada 4 , com sinal positivo.

O resultado - 0 , 1 , 2 ou 3 - é subtraído de 2 , produzindo 2 , 1 , 0 ou -1 .

Finalmente, pegamos o restante assinado da divisão por 2 , retornando 0 , 1 , 0 ou -1 .

Gelatina , 3 bytes

ı*Ċ

Experimente online!

Como funciona

ı*Ċ  Main link. Argument: n

ı*   Elevate i, the imaginary unit, to the n-th power.
  Ċ  Take the imaginary part of the result.

dc, 13

Não tenho certeza se você considera o %operador módulo como "matemática pura":

?1+d*v4%1-2%p

Experimente online . Observe que dcusa em _vez de -para indicar números negativos.

Explicação

?              # read input
 1+            # add 1
   d*v         # duplicate, multiply, square root (poor-mans abs())
      4%       # mod 4
        1-     # subtract 1
          2%   # mod 2
            p  # print

Observe que dco %operador mod é a versão "CPU" padrão que mapeia valores negativos para valores negativos.

brainfuck , 136 bytes

>,>++++<[>->+<[>]>[<+>-]<<[<]>-]>>>>-[>+<-----]>--[-<+>>>+>>>+>>>+<<<<<<<<]<->>>>>>->--[>+<++++++]>++<<<<<<<<<<[[->>>+<<<]>>>-]>[.[-]]>.

Experimente online!

Provavelmente há uma resposta mais trivial, mas isso essencialmente usa uma tabela de valores. Embora brainfuck leva entrada como caracteres ASCII com valores positivos de 0 a 127, ele ainda funciona como se fosse capaz de aceitar valores negativos (para teste, substitua o ,com nquantidade de -caracteres).

Como funciona

>,                                   take input (X)
>++++<                               take second input for modulo (4)
[>->+<[>]>[<+>-]<<[<]>-]             calculate X mod 4
>>>>-[>+<-----]>--                   create initial '1' character
[-<+>>>+>>>+>>>+<<<<<<<<]            duplicate '1' four times as 1,1,1,1
<->>>>>>->--[>+<++++++]>++<<<<<<<<<< change 1,1,1,1 to 0,1,0,-1 
[[->>>+<<<]>>>-]>[.[-]]>.            move to the right X%4 * 3 times, then print the following two characters ( 0, 1, 0,-1)

Python, 26 24 21 bytes

lambda x:(1j**x).imag

-2 bytes graças ao ValueInk por perceber que o método matemático é realmente mais longo do que a abordagem trivial: P
-3 bytes graças a Dennis por apontar que não preciso do int(...), tornando assim mais curto :)

Python , 20 bytes

lambda n:n%2*(2-n%4)

Uma função sem nome que retorna o resultado.

Experimente online!

Mathematica, 18 bytes

#~JacobiSymbol~46&

Pari / GP , 12 bytes

n->imag(I^n)

Experimente online!

PHP, 20 bytes

<?=2<=>($argn&3?:2);

Haskell , 19 bytes

A solução Julia do Porto da Dennis, só porque ele disse que não seria o mais curto em nenhum outro idioma. (Alguém ainda pode me provar que é o menor em Haskell.)

f n=rem(2-n`mod`4)2

Experimente online!

Haskell tem duas funções remanescentes diferentes, uma ( rem) funciona como a Julia, enquanto a outra ( mod) fornece um resultado positivo mesmo quando o primeiro argumento é negativo e, portanto, é adequado para a tradução &3. (De Haskell reais & , chamados .&., infelizmente requer uma import Data.Bits.)

Oitava , 22 bytes

@(x)round(sin(x*pi/2))

Experimente online!

Ruby, 20 bytes

Simples e limpo.

->x{[0,1,0,-1][x%4]}

C99, 27 bytes

Supondo que você queira que a onda seja centralizada na origem:

f(n){return cpow(1i,n)/1i;}

caso contrário f(n){return cpow(1i,n);}, fará. Eu originalmente tinha um cimaglá, mas aparentemente tentando retornar um intde um _Complex intproduz a parte real, então usei isso. Faz sentido, mas não é nada que eu tenha previsto. O comportamento é o mesmo gcceclang

05AB1E , 5 bytes

4%<Ä<

Experimente online!

A saída é invertida, mas pelo que entendi isso é permitido:

+1 byte para multiplicar a saída por -1 usando (.

   -5 -> 1
   -4 -> 0
   -3 -> -1
   -2 -> 0
   -1 -> 1
    0 -> 0
    1 -> -1
    2 -> 0
    3 -> 1
    4 -> 0
    5 -> -1

4%    # Amplitude of 4...
  <   # Period of 1...
   Ä  # Absolute value...
    < # Period of 1 centered at 0...

Pitão - 7 bytes (possivelmente 6)

ta2%tQ4

Tente

Se a fase da onda não for importante, 6 bytes:

ta2%Q4

Tente

Explicação:

ta2%tQ4
     Q    # The input
    t     # Subtract 1 to get the phase right (might not be necessary)
   %  4   # Take mod 4
 a2       # Absolute value of the result - 2
t         # Subtract 1 so the result is in [-1,0,1]

AWK , 26 bytes

{$0=(sqrt(($0%4)^2)-2)%2}1

Experimente online!

Essa é uma abordagem alternativa usando funções trigonométricas sem o operador de módulo.

{$0=int(sin($0*atan2(0,-1)/2))}1

Experimente online!

Javascript ES6, 18 17 bytes

n=>n&1&&(++n&2)-1

Primeiro, verifique se a entrada é par ou ímpar e retorne 0 para todos os valores pares. Para todas as entradas ímpares, incremente e bit a bit com 0b10para remover os bits que não nos interessam e, em seguida, retorne a resposta com um deslocamento.

const f = n=>n&1&&(++n&2)-1;

for (let i = -5; i < 6; i++) {
  document.body.appendChild(document.createElement('pre')).innerHTML = `f(${i}) => ${f(i)}`;
}

JavaScript, 15 bytes

n=>n&3&&2-(n&3)

Bitwise e 3 é equivalente ao módulo 4, exceto sem a regra estranha dos módulos de números negativos do JavaScript. Fiz uma regressão polinomial nos quatro primeiros pontos no início, mas depois percebi que estava sendo burro porque (1, 1), (2, 0) e (3, -1) são apenas 2-n.

a=n=>n&1&&2-(n&3);
console.log([a(-5), a(-4), a(-3), a(-2), a(-1), a(0), a(1), a(2), a(3), a(4), a(5)])

R , 19 bytes

function(n)Im(1i^n)

Experimente online!

Um porto da resposta Mathematica de JungHwan Min .