Tâche:

Étant donné l'indice d'échantillon, x, calculez la valeur d'échantillon f (x) de l'onde triangulaire, avec une période de 4 échantillons et une amplitude 1. Le décalage peut être négatif et la valeur d'échantillon peut être soit {0, 1, -1}.

Cas de test:

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

Personnellement, je connais deux approches en C - la première utilise une table de recherche, la seconde utilise des instructions conditionnelles. Pour les points brownie, pourriez-vous m'impressionner avec une approche "mathématique" pure? (Je veux dire une approche fonctionnelle pure, par exemple ne pas utiliser d'instructions conditionnelles ou utiliser de la mémoire pour LUT.) Mais ce n'est pas une restriction. Si vous ne le pouvez pas ou que votre langue ne le prend pas en charge, il vous suffit de poster une solution

Mathematica, 8 octets

Im[I^#]&

Explication

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

TI-Basic, 7 5 4 octets

sin(90Ans

(Mode degrés) -1 octet de @immibis de mon ancienne réponse.

Ancienne réponse

imag(i^Ans

Approche mathématique pure sur une calculatrice. :)

Juste pour le plaisir, voici une autre solution pure-math (ish) pour 9 octets (en mode radian) ou 8 octets (mode degré)

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

Python 2 , 20 octets

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

Essayez-le en ligne!

J'exécute une recherche par force brute pour des expressions arithmétiques ou au niveau du bit plus courtes, je vais voir si quelque chose se présente. Celui-ci, je l'ai trouvé à la main.

Julia 0,5 , 12 octets

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

J'aime cette approche car il est peu probable qu'elle soit la plus courte dans une autre langue.

Essayez-le en ligne!

Comment ça fonctionne

La priorité des opérateurs de Julia est un peu inhabituelle: contrairement à la plupart des autres langues, les opérateurs au niveau du bit ont la même priorité que leurs homologues arithmétiques, donc &(multiplication au niveau du bit) a la même priorité que *.

Tout d'abord, n&3prend le module d'entrée 4 , avec signe positif.

Le résultat - 0 , 1 , 2 ou 3 - est ensuite soustrait de 2 , ce qui donne 2 , 1 , 0 ou -1 .

Enfin, nous prenons le reste signé de la division par 2 , retournant 0 , 1 , 0 ou -1 .

Gelée , 3 octets

ı*Ċ

Essayez-le en ligne!

Comment ça fonctionne

ı*Ċ  Main link. Argument: n

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

dc, 13

Vous ne savez pas si vous comptez l' %opérateur modulo comme "mathématiques pures":

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

Essayez-le en ligne . Notez que dcutilise _au lieu de- pour indiquer des nombres négatifs.

Explication

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

Notez que dcl' %opérateur mod est la version standard "CPU" qui mappe les valeurs négatives aux valeurs négatives.

brainfuck , 136 octets

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

Essayez-le en ligne!

Il y a probablement une réponse plus triviale, mais cela utilise essentiellement une table de valeurs. Bien que brainfuck accepte les entrées sous forme de caractères ASCII avec des valeurs positives de 0 à 127, cela fonctionne toujours comme s'il était capable d'accepter des valeurs négatives (pour tester, remplacer le ,par une nquantité de- caractères).

Comment ça fonctionne

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

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

-2 octets grâce à ValueInk pour s'être rendu compte que la méthode mathématique est en fait plus longue que l'approche triviale: P
-3 octets merci à Dennis d'avoir souligné que je n'ai pas besoin de la int(...), ce qui raccourcit donc :)

Python , 20 octets

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

Une fonction sans nom qui renvoie le résultat.

Essayez-le en ligne!

Mathematica, 18 octets

#~JacobiSymbol~46&

Pari / GP , 12 octets

n->imag(I^n)

Essayez-le en ligne!

PHP, 20 octets

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

Haskell , 19 octets

La solution Julia de Port of Dennis, juste parce qu'il a dit qu'elle ne serait pas la plus courte dans une autre langue. (Quelqu'un pourrait encore me prouver que c'est le plus court à Haskell.)

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

Essayez-le en ligne!

Haskell a deux fonctions de reste différentes, l'une ( rem) fonctionne comme la Julia, tandis que l'autre ( mod) donne un résultat positif même lorsque le premier argument est négatif, et convient donc à la traduction &3. (Le réel & , appelé .&., de Haskell nécessite hélas un import Data.Bits.)

Octave , 22 octets

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

Essayez-le en ligne!

Ruby, 20 octets

Simple et propre.

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

C99, 27 octets

En supposant que vous voulez que l'onde soit centrée à l'origine:

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

sinon f(n){return cpow(1i,n);}fera l'affaire. J'avais à l'origine une cimagentrée là-dedans, mais apparemment, j'essaie de récupérer une partie intde _Complex intla partie réelle, alors je l'ai utilisée. C'est logique, mais ce n'est rien que j'aurais prévu. Le comportement est le même dans gccetclang

05AB1E , 5 octets

4%<Ä<

Essayez-le en ligne!

La sortie est inversée, mais d'après ce que j'ai compris, cela est autorisé:

+1 octet pour multiplier la sortie par -1 en utilisant (.

   -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 octets (éventuellement 6)

ta2%tQ4

Essayez-le

Si la phase de l'onde n'est pas importante, 6 octets:

ta2%Q4

Essayez-le

Explication:

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 octets

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

Essayez-le en ligne!

Il s'agit d'une approche alternative utilisant des fonctions trigonométriques sans l'opérateur de module.

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

Essayez-le en ligne!

Javascript ES6, 18 17 octets

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

Tout d'abord, vérifiez si l'entrée est paire ou impaire et retournez 0 pour toutes les valeurs paires. Pour toutes les entrées impaires, incrémentez et au niveau du bit avec 0b10pour supprimer tous les bits qui ne nous intéressent pas, puis renvoyez la réponse avec un décalage.

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 octets

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

Bitwise et 3 est équivalent à modulo 4 sauf sans la règle bizarre sur les modules de nombres négatifs de JavaScript. J'ai d'abord fait une régression polynomiale sur les quatre premiers points, mais j'ai ensuite réalisé que j'étais stupide parce que (1, 1), (2, 0) et (3, -1) ne sont que 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 octets

function(n)Im(1i^n)

Essayez-le en ligne!

Un port de la réponse Mathematica de JungHwan Min .