Compito:

Dato indice del campione, x, calcola il valore del campione f (x) dell'onda triangolare, con un periodo di 4 campioni e ampiezza 1. L'offset può essere negativo e il valore del campione può essere {0, 1, -1}.

Casi test:

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

Personalmente conosco due approcci in C: il primo utilizza la tabella di ricerca, il secondo utilizza le istruzioni condizionali. Per quanto riguarda i punti brownie, potresti impressionarmi con un approccio "matematico" puro? (Intendo un approccio funzionale puro, ad esempio non usare istruzioni condizionali o usare la memoria per LUT.) Ma questa non è una restrizione. Se non puoi, o la tua lingua non lo supporta, pubblica semplicemente una soluzione

Mathematica, 8 byte

Im[I^#]&

Spiegazione

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

TI-Basic, 7 5 4 byte

sin(90Ans

(Modalità laurea) -1 byte da @immibis dalla mia vecchia risposta.

Vecchia risposta

imag(i^Ans

Approccio di matematica pura su una calcolatrice. :)

Solo per divertimento, ecco un'altra soluzione di matematica pura (ish) per 9 byte (in modalità radiante) o 8 byte (modalità gradi)

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

Python 2 , 20 byte

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

Provalo online!

Sto eseguendo una ricerca della forza bruta per espressioni aritmetiche più brevi o bit a bit, vedrò se qualcosa si presenta. Questo l'ho trovato a mano.

Julia 0,5 , 12 byte

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

Mi piace questo approccio perché è improbabile che sia il più breve in qualsiasi altra lingua.

Provalo online!

Come funziona

La precedenza degli operatori di Julia è un po 'insolita: a differenza della maggior parte delle altre lingue, gli operatori bit a bit hanno la stessa precedenza delle loro controparti aritmetiche, quindi &(la moltiplicazione a bit) ha la stessa precedenza di *.

Innanzitutto, n&3accetta l'input modulo 4 , con segno positivo.

Il risultato - 0 , 1 , 2 o 3 - viene quindi sottratto da 2 , producendo 2 , 1 , 0 o -1 .

Infine, prendiamo il resto della divisione firmato per 2 , restituendo 0 , 1 , 0 o -1 .

Gelatina , 3 byte

ı*Ċ

Provalo online!

Come funziona

ı*Ċ  Main link. Argument: n

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

dc, 13

Non sono sicuro se si considera l' %operatore modulo come "matematica pura":

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

Provalo online . Si noti che dcutilizza _invece di -indicare numeri negativi.

Spiegazione

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

Si noti che dcl' %operatore mod è la versione standard "CPU" che mappa i valori negativi a valori negativi.

Brainfuck , 136 byte

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

Provalo online!

Probabilmente c'è una risposta più banale, ma essenzialmente utilizza una tabella di valori. Anche se brainfuck accetta input come caratteri ASCII con valori positivi da 0 a 127, funziona comunque come se fosse in grado di accettare valori negativi (per testare, sostituire il ,con la nquantità di -caratteri).

Come funziona

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

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

-2 byte grazie a ValueInk per rendersi conto che il metodo matematico è in realtà più lungo dell'approccio banale: P
-3 byte grazie a Dennis per aver sottolineato che non ho bisogno di int(...), rendendo così più breve :)

Python , 20 byte

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

Una funzione senza nome che restituisce il risultato.

Provalo online!

Mathematica, 18 byte

#~JacobiSymbol~46&

Pari / GP , 12 byte

n->imag(I^n)

Provalo online!

PHP, 20 byte

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

Haskell , 19 byte

La soluzione Julia di Port of Dennis, solo perché ha detto che non sarebbe stata la più breve in qualsiasi altra lingua. (Qualcuno potrebbe ancora dimostrarmi che ho torto che è più breve in Haskell.)

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

Provalo online!

Haskell ha due diverse funzioni di resto, una ( rem) funziona come una Julia, mentre l'altra ( mod) dà un risultato positivo anche quando il primo argomento è negativo, e quindi è adatto per la traduzione &3. (Haskell è reale & , chiamato .&., purtroppo richiede un import Data.Bits.)

Ottava , 22 byte

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

Provalo online!

Rubino, 20 byte

Semplice e pulito.

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

C99, 27 byte

Supponendo che si desideri che l'onda sia centrata sull'origine:

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

altrimenti f(n){return cpow(1i,n);}lo farà. Inizialmente avevo un cimaglì dentro, ma apparentemente cercavo di restituire un intda un _Complex intrendimento la parte reale, quindi l'ho usato. Ha senso, ma non avevo previsto nulla. Il comportamento è lo stesso in gcceclang

05AB1E , 5 byte

4%<Ä<

Provalo online!

L'output è invertito, ma da quello che ho capito è permesso:

+1 byte per moltiplicare l'output per -1 utilizzando (.

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

Pyth - 7 byte (possibilmente 6)

ta2%tQ4

Provalo

Se la fase dell'onda non è importante, 6 byte:

ta2%Q4

Provalo

Spiegazione:

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 byte

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

Provalo online!

Questo è un approccio alternativo che utilizza le funzioni di trigger senza l'operatore del modulo.

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

Provalo online!

Javascript ES6, 18 17 byte

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

Innanzitutto, controlla se l'ingresso è pari o dispari e restituisce 0 per tutti i valori pari. Per tutti gli input dispari, incrementare e bit a bit con 0b10per rimuovere eventuali bit che non ci interessano, quindi restituire la risposta con un offset.

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 byte

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

Bitwise e 3 equivalgono a modulo 4, tranne senza la strana regola sui moduli di numeri negativi di JavaScript. All'inizio ho fatto una regressione polinomiale sui primi quattro punti, ma poi ho capito che ero stupido perché (1, 1), (2, 0) e (3, -1) sono solo 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 byte

function(n)Im(1i^n)

Provalo online!

Un porto della risposta Mathematica di JungHwan Min .