Énumération entière étourdie

25

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!

code-golf  sequence  integer 
— Pavel
source
— sergiol
Cela semble être l'inverse d'une fonction de pliage
— sergiol

Réponses:

8

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     »     ±      .     »    ⌡
— dzaima
source
3
IL N'A PAS PRIS UNE SEULE MINUTE!
— NieDzejkob
6
Je ».»suis au téléphone I».»⌡±.
— Jonathan Allan
@JonathanAllan Je ne comprends pas ._.
— Pavel
4

C, 25 octets

f(n){return~n/2*~-(n&2);}
— orlp
source
Vous pouvez économiser 4 octets en affectant votre valeur de retour au premier paramètre au lieu d'utiliser le mot-clé return. f(n){n=~n/2*~-(n&2);}
— cleblanc
5
@cleblanc Ce n'est pas ainsi que C fonctionne.
— orlp
2
gcc -O0pour x86-64 arrive à compiler la version de @ cleblanc avec des instructions qui laissent le résultat multiplier dans eax( godbolt.org/g/dztKPV ), mais alors ce serait une x86-64 gcc -O0réponse, pas une réponse C. Je ne vote pas les réponses C qui rompent avec l'optimisation activée, en particulier pas cette dernière expression stupide comme merde de valeur de retour. Même si c'est comme ça que gcc fonctionne, ce n'est pas comme ça que C fonctionne.
— Peter Cordes
Faites un pointeur. Vous n'avez pas besoin d'optimisations si les valeurs d'origine et finales ne sont pas sur la pile.
— mreff555
1
@ mreff555 Ce serait une méthode d'E / S non standard (bien qu'acceptable), et ne serait pas plus courte.
— orlp
3

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.

— M. Xcoder
source
3

Mathematica, 24 octets

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

-14 octets de @Misha Lavrov

— J42161217
source
1
Utiliser Booleet OddQa pour effet de convertir les nombres impairs en 1 et les nombres pairs en 0, mais vous n'en avez pas besoin ici: les puissances de -1 vous donnent quand même la bonne réponse pour tous les nombres impairs. Vous pouvez donc réduire cette étape à (-1)^Tr@{#,s}ou simplement (-1)^(#+s).
— Misha Lavrov
2

Lot, 29 octets

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

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
Développer l'extrait

0 indexé.

— Neil
source
2

Javascript, 17 octets

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

Afficher l'extrait de code

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

— récursif
source
2

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
— user202729
source
2

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
— pizzapants184
source
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!

— cab404
source
2

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
— Kevin Cruijssen
source
2

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.

<>{}{<>([{}])(<>)}<>
— Assistant de blé
source
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
— steenbergh
source
1

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))
— Bob Jarvis - Réintégrer Monica
source
1

Excel VBA 32 bits, 39 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)

— Taylor Scott
source
L'espace entre (-1)et est-il ^[Intnécessaire?
— Pavel
@ Pavel au moins pour la version 64 bits d'Excel VBA, oui; Mais cela dit, je jure que ce n'est pas le cas pour la version 32 bits, mais hélas, je ne peux pas tester cela sur le matériel que j'ai en main
— Taylor Scott
@ Pavel - Je l'ai regardé sous un système 32 bits (spécification d'installation par défaut) et sous ce système, l'espace n'est pas nécessaire - j'ai limité la solution à 32 bits pour en profiter
— Taylor Scott
1
Cool! Vous avez cependant oublié d'ajouter le nombre d'octets corrigé.
— Pavel
Oups, merci @ Pavel - C'est résolu maintenant
— Taylor Scott
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.