Votre défi aujourd'hui est de produire un terme donné d'une séquence énumérant tous les entiers. La séquence est la suivante: si nous avons une fonction indexée sur 0 qui génère la séquence f(n)et ceil(x)est la fonction plafond, alors f(0) = 0; abs(f(n)) = ceil(n/2); sign(f(n))est positif lorsque net ceil(n/2)sont à la fois pairs ou impairs.

Pour aider à comprendre cette séquence, les premiers termes sont les suivants: 0 1 -1 -2 2 3 -3 -4 4 5 -5 -6 6 7 -7...

Votre tâche consiste à écrire un programme qui prend un entier net génère le ne terme de la séquence. L'entrée peut être indexée 0 ou 1 uniquement.

Cas de test (indexés 0):

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

C'est du code-golf , le moins d'octets gagne!

SOGL V0.12 , 8 6 octets

I».»⌡±

Essayez-le ici! ou essayez les premiers numéros de couple (un peu modifiés pour que cela fonctionne)
indexés 0.

Explication:

I       increment the input
 »      floor divide by 2
  .     push the original input
   »    floor divide by 2
    ⌡   that many times
     ±    negate

Ou plus simple:

(input + 1) // 2 negated input // 2 times
        I     »     ±      .     »    ⌡

Python 2 , 26 24 octets

lambda x:-~x/2/(1-(x&2))

Essayez-le en ligne!

JavaScript (ES6), 18 octets

1 indexé.

n=>n/(++n&2||-2)|0

Démo

let f =

n=>n/(++n&2||-2)|0

for(n = 1; n < 20; n++) {
  console.log(n + ' --> ' + f(n))
}

C, 25 octets

f(n){return~n/2*~-(n&2);}

Haskell , 26 octets

f x=div(x+1)2*(-1)^div x 2

Essayez-le en ligne!

Les autres réponses de Haskell semblent être trop compliquées… ^^

Pyke , 6 octets

heQeV_

Essayez-le ici!

Utilise l'approche de dzaima ... Beats Ties Jelly!

Explication

h      - Increment the input, which is implicit at the beginning.
 e     - Floor halve.
  Q    - Push the input.
   e   - Floor halve.
    V_ - Apply repeatedly (V), ^ times, using negation (_).
       - Output implicitly.

Les octets hexagonaux codés équivalents seraient: 68 65 51 65 56 5F.

Gelée , 6 octets

HµĊN⁸¡

Essayez-le en ligne!

Utilise l'algorithme de dzaima.

-1 merci à Jonathan Allan .

Python 2 , 21 octets

lambda x:-x/2*~-(x&2)

Essayez-le en ligne!

Mathematica, 24 octets

(s=⌈#/2⌉)(-1)^(#+s)&  

-14 octets de @Misha Lavrov

Haskell , 25 43 42 octets

((do a<-[0..];[[-a,a],[a,-a]]!!mod a 2)!!)

Essayez-le en ligne! 1 indexé.

Modifier: La version précédente avait les signes dans un mauvais ordre, merci à @ Potato44 pour l'avoir signalé. Fixé pour 18 octets ...

Edit 2: Merci à BMO pour -1 octet!

Python 3 , 29 octets

lambda n:-~n//2*(-1)**(n%4>1)

Essayez-le en ligne!

Pyth , 9 octets

_F/hQ2/Q2

Essayez-le ici!

Utilise l'approche de dzaima .

Haskell, 36 octets

g x=x: -x:g(-x-signum x)
((0:g 1)!!)

Essayez-le en ligne!

05AB1E , 6 octets

;DîsF(

Essayez-le en ligne!

Utilise l'algorithme de dzaima.

Lot, 29 octets

@cmd/cset/a"%1/2^(%1<<30>>30)

JavaScript (ES6), 18 octets

f=
n=>n/2^(n<<30>>30)

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

0 indexé.

Javascript, 17 octets

n=>~n/2*~-(n&2)^0

f=
n=>~n/2*~-(n&2)^0

<input type=number min=0 value=0 oninput=o.textContent=f(this.value)><pre id=o>0

Celui-ci est indexé 0. C'est une supercherie entièrement au niveau du bit.

Cubiquement , 23 octets

(1 index)

FDF'$:7+8/0_0*0-8*7/0%6

Essayez-le en ligne!

La principale difficulté lors de l'écriture de code en cubique est:

• Il n'y a qu'une seule variable en écriture et
• Obtenir des constantes est difficile.

Donc, cette solution calcule

((((n+1)/2)%2)*2-1)*n/2

où /désigne une division entière. Cela n'a besoin que d'une variable temporaire et des constantes 1 et 2.

Explication:

FDF'$:7+8/0_0*0-8*7/0%6
FDF'                      Set face value of face 0 to 2, and value of memory index 8 (cube is unsolved) to 1 (true = unsolved)
    $                     Read input
     :7                                 input
       +8                                + 1
         /0                        (        ) /2
           _0                     (             ) %2
             *0                  (                  ) *2
               -8                                        -1
                 *7             (                          ) *n
                   /0                                          /2
                     %6   Print

TI-Basic (TI-84 Plus CE), 20 octets

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2

Un programme complet qui s'appelle comme 5:prgmNAME.

TI-Basic est une langue à jetons , tous les jetons utilisés ici sont d'un octet, sauf remainder(deux. ‾représente le jeton régatif, qui est tapé avec la (-)clé.

Exemples:

0:prgmNAME
 => 0
1:prgmNAME
 => 1
2:prgmNAME
 => -1
#etc

Explication:

‾int(‾Ans/2)(1-2remainder(int(Ans/2),2
‾int(‾Ans/2)                           # -int(-X) is ciel(X), so ciel(Ans/2)
                          int(Ans/2)   # int(X) is floor(X), so floor(Ans/2)
                remainder(int(Ans/2),2 # 1 if floor(Ans/2) is odd else 0
            (1-2remainder(int(Ans/2),2 # -1 if floor(Ans/2) is odd, else 1
_int(_Ans/2)(1-2remainder(int(Ans/2),2 # -ciel(Ans/2) if floor(Ans/2) is odd, else ciel(Ans/2)

Même formule qu'une fonction Y-var:

Y1= ‾int(‾X/2)(1-2remainder(int(X/2),2

dc , 16 octets

1+d2~+2%2*1-r2/*

Je suis sûr qu'il existe un moyen de raccourcir de 0..1 à -1..1 en courant continu, mais aucune idée pour l'instant.

Essayez-le en ligne!

Java 8, 15 octets

n->~n/2*~-(n&2)

EDIT: Java est-il vraiment le plus court des langages non-golfeurs?! o.Ô

Explication:

Essayez-le ici.

Je vais utiliser le tableau ci-dessous comme référence de ce qui se passe.

1. ~nest égal à -n-1.
2. Étant donné que la division des nombres entiers en Java se fonde automatiquement sur les nombres entiers positifs et les plafonds sur les nombres entiers négatifs, ~n/2entraînera la séquence0,-1,-1,-2,-2,-3,-3,-4,-4,-5,-5,...
3. n&2entraînera soit 0ou 2, dans la séquence0,0,2,2,0,0,2,2,0,0,2,...
4. ~-xest égal à (x-1), donc ~-(n&2)( ((n&2)-1)) entraîne la séquence-1,-1,1,1,-1,-1,1,1,-1,-1,1,...
5. La multiplication des deux séquences de ~n/2et ~-(n&2)donne est la séquence correcte demandée dans le défi:0,1,-1,-2,2,3,-3,-4,4,5,-5,...

Tableau de synthèse:

n       ~n      ~n/2    n&2     ~-(n&2)     ~n/2*~-(n&2)
0       -1      0       0       -1          0
1       -2      -1      0       -1          1
2       -3      -1      2       1           -1
3       -4      -2      2       1           -2
4       -5      -2      0       -1          2
5       -6      -3      0       -1          3
6       -7      -3      2       1           -3
7       -8      -4      2       1           -4
8       -9      -4      0       -1          4
9       -10     -5      0       -1          5
10      -11     -5      2       1           -5

Brain-Flak , 86 74 72 70 octets

{({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}<>{}{<>([{}])(<>)}<>

Essayez-le en ligne!

Explication

Ce code comporte deux parties. La première partie

({}[()]<({}<>([({})]{(<{}([{}]())>)}{}())<>)>)}{}

fait le muscle du calcul. Il détermine ceil(n/2)et annule ou non la sortie.

Pour expliquer comment cela fonctionne, je vais d'abord expliquer comment on calculerait ceil(n/2). Cela pourrait être fait avec le code suivant

{({}[()]<({}([{}]()))>)}{}

Cela décompte à partir de n chaque fois qu'il effectue un not ( ([{}]())) sur un compteur et ajoute le compteur à un résultat. Étant donné que le compteur est égal à zéro la moitié du temps, nous n'incrémentons que tous les autres cycles en commençant par le premier.

Maintenant, je veux aussi calculer le signe de nos résultats. Pour ce faire, nous démarrons un autre compteur. Ce compteur ne change d'état que si le premier compteur est éteint. De cette façon, nous obtenons le motif souhaité. Nous mettons ces deux compteurs sur la pile off pour faciliter leur déplacement le moment venu.

Maintenant, une fois que nous avons terminé ce calcul, notre pile ressemble à ceci

          parity(n)
ceil(n/2) sign

Nous devons donc faire un certain travail pour obtenir le résultat escompté dans cette deuxième partie.

<>{}{<>([{}])(<>)}<>

Perl 5 , 32 + 1 ( -p) = 33 octets

$_='-'x(($_+++($b=0|$_/2))%2).$b

Essayez-le en ligne!

Proton , 23 octets

n=>-~n//2//(-1)**(n//2)

Essayez-le en ligne!

Solution du port de Halvard .

Proton , 23 octets

n=>-~n//2*(-1)**(n%4>1)

Essayez-le en ligne!

Solution du port de Leaky .

Un peu plus protonique, 24 octets:

n=>-~n//2*(**)(-1,n%4>1)

QBIC , 27 26 octets

g=(:+1)'\2`~(a-g)%2|?-g\?g

Explication

g=          set worker var 'g' to
(:+1)           our index (plus one for the ceil() bit)
'\2`            integer divided by 2 (the int div needs a code literal: '..`
~(a-g)%2    IF index - temp result is odd (index 2 minus result 1 = 1)
|?-g        THEN PRINT g negated
\?g         ELSE PRINT g

Clojure 122 octets

Verbeux, même au golf. Je vais pour le vote de sympathie ici ... :-)

Golfé:

(defn d[n](let[x(int(Math/ceil(/ n 2)))y(cond(or(and(even? n)(even? x))(and(odd? n)(odd? x)))(Math/abs x):else(- 0 x))]y))

Non golfé:

(defn dizzy-integer [n]
  (let [x   (int (Math/ceil (/ n 2)))
        y   (cond
                (or (and (even? n) (even? x))
                    (and (odd? n)  (odd? x))) (Math/abs x)
                :else (- 0 x)) ]
    y))

Excel VBA 32 bits, ₃₉ 37 octets

Fonction de fenêtre immédiate VBE anonyme qui prend les entrées de la cellule A1et les sorties vers la fenêtre immédiate VBE

?[Sign((-1)^Int(A1/2))*Int((A1+1)/2)]

Limité à 32 bits car A^Bnon valide en 64 bits ( A ^Best aussi proche que possible)

Julia 0,6 , 16 octets

C'est juste la solution java sauf que j'ai besoin ÷d'une division entière.

n->~n÷2*~-(n&2)

Essayez-le en ligne!