Bizarrement même, positivement négatif

36

Étant donné N, sortir le Nième terme de cette séquence infinie:

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ... etc.

N peut être indexé 0 ou 1 comme vous le souhaitez.

Par exemple, si 0-indexés puis entrées 0, 1, 2, 3, 4devrait produire des sorties respectives -1, 2, -2, 1, -3.

Si l' index 1 entrées puis 1, 2, 3, 4, 5devrait produire des sorties respectives -1, 2, -2, 1, -3.

Pour être clair, cette séquence est générée en prenant la séquence d’entiers positifs répétés deux fois

1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 11 12 12 ...

et réarranger chaque paire de nombres impairs pour entourer les nombres pairs juste au-dessus

1 2 2 1 3 4 4 3 5 6 6 5 7 8 8 7 9 10 10 9 11 12 12 11 ...

et finalement nier tous les autres termes, en commençant par le premier

-1 2 -2 1 -3 4 -4 3 -5 6 -6 5 -7 8 -8 7 -9 10 -10 9 -11 12 -12 11 ...

Le code le plus court en octets gagne.

Les passe-temps de Calvin
la source
A001057 sans le zéro non significatif ?
devRicher
@devRicher Non, les valeurs absolues y vont, 1,1,2,2,3,3,4,4,...mais ici c'est 1,2,2,1,3,4,4,3,....
Martin Ender
6
Pourriez-vous fournir un formulaire fermé pour cette séquence ou au moins quelque chose d'un peu plus spécifique que les premiers termes
0 '20
Cette équation pour le nième terme n'évalue jamais à une valeur négative ... quelque chose ne va pas avec elle.
Magic Octopus Urn
1
@ 0 'J'ai ajouté ce que je pense de manière intuitive, mais pas sous une forme fermée. Une partie du défi consiste à déterminer le modèle et à le traduire en mathématiques et en code.
Hobbies de Calvin

Réponses:

32

Python 2 , 23 octets

lambda n:~n/2+n%2*(n|2)

Les entrées impaires donnent à peu près les n/2mêmes -n/2. Donc, j'ai commencé -n/2+n%2*net modifié à partir de là.

Essayez-le en ligne!

Xnor
la source
1
Explication? :)
MildlyMilquetoast
17

Mathematica, 29 octets

((#~GCD~4/. 4->-2)+#)/2(-1)^#&

Fonction pure prenant une entrée à 1 index. Hormis les signes alternants (-1)^#, la séquence double est proche de l’entrée, les différences étant de 1, 2, 1, -2 de manière cyclique. C'est bien que #~GCD~4, le plus grand commun diviseur de l'entrée et 4, soit 1, 2, 1, 4 cycliquement; donc nous venons de remplacer manuellement 4->-2et appelons un jour. J'aime cette approche car elle évite la plupart des commandes Mathematica comportant de nombreux caractères.

Greg Martin
la source
9

Pip , 24 22 octets

v**a*YaBA2|1+:--a//4*2

Prend l'entrée, indexé 1, comme argument de ligne de commande. Essayez-le en ligne ou vérifiez-le 1-20 .

Explication

Observez que la séquence peut être obtenue en combinant trois autres séquences, l’une indexée à zéro et l’autre indexée:

  • Commencez avec 0 0 0 0 2 2 2 2 4 4 4 4= a//4*2(indexé sur 0);
  • Add 1 2 2 1 1 2 2 1 1 2 2 1= aBA2|1, où BAest bitwise AND et |est logique OU (indexé 1);
  • Multipliez la somme par -1 1 -1 1 -1 1 -1 1 -1 1 -1 1= (-1)**a(indexé 1).

Si nous commençons avec a1-indexé, nous pouvons d'abord calculer les parties 1-indexées (en lisant l'expression de gauche à droite), puis les décrémenter apour la partie 0-indexée. En utilisant la variable intégrée v=-1, nous obtenons

v**a*((aBA2|1)+--a//4*2)

Pour supprimer deux octets supplémentaires, nous devons utiliser des astuces de manipulation de priorité. Nous pouvons éliminer les parenthèses internes en les remplaçant +par +:(équivalent à +=dans beaucoup de langues). Tout opérateur de calcul et d’affectation a une très faible priorité, aBA2|1+:--a//4*2est donc équivalent à (aBA2|1)+:(--a//4*2). Pip émettra un avertissement sur l'affectation de quelque chose qui n'est pas une variable, mais uniquement si les avertissements sont activés.

La seule chose qui est prioritaire sur la :est - Y, l'opérateur de Yank * Il attribue sa valeur d'opérande à la. yVariable et passe sans modification; afin que nous puissions éliminer les parenthèses extérieures ainsi que par la valeur plutôt l' accroche alors que ce parenthèse: YaBA2|1+:--a//4*2.

* rint Pet Output ont la même priorité que Yank, mais ne sont pas utiles ici.

DLosc
la source
9

Gelée , 8 7 octets

H^Ḃ~N⁸¡

Cela utilise l'algorithme de ma réponse Python , qui a été amélioré de manière significative par @GB .

Essayez-le en ligne!

Comment ça marche

H^Ḃ~N⁸¡  Main link. Argument: n

H        Halve; yield n/2. This returns a float, but ^ will cast it to int.
  Ḃ      Bit; yield n%2.
 ^       Apply bitwise XOR to both results.
   ~     Take the bitwise NOT.
    N⁸¡  Negate the result n times.
Dennis
la source
Je pense que ce sont les caractères ASCII les plus standard que j'ai vus dans une soumission Jelly. Je ne vois que deux personnages qui m'ennuieraient (sans compter ¡)
Esolanging Fruit
9

Java 8, 19 octets

n->~(n/2)+n%2*(n|2)

Java 7, 47 37 octets

int c(int n){return~(n/2)+n%2*(n|2);}

La première fois, Java (8) est en concurrence et est plus court que d’autres réponses. Vous ne pouvez toujours pas battre les langues de golf réelles comme Jelly et autres, cependant (duhuh .. quelle surprise.>.>; P)


Port 0 indexé de la réponse Python 2 de @Xnor .
-10 octets grâce à @GB

Essayez ici.

Kevin Cruijssen
la source
2
Vous n'avez pas besoin du chèque ternaire si vous mettez (n / 2) entre parenthèses.
GB
1
@GB Ah, alors c'était ça le problème .. Merci. Je me sens un peu stupide maintenant ..>.>
Kevin Cruijssen
Oh, on nous autorise seulement les définitions de fonctions pour Java?
Cruncher
@Cruncher Sauf indication contraire de la question, le programme ou la fonction complet est utilisé par défaut . Donc oui, il est permis de simplement poster une méthode en Java, ou un lambda en Java 8 (j'ai ajouté l'équivalent Java 8 dans ma réponse ci-dessus).
Kevin Cruijssen
1
@EricDuminil La valeur par défaut est programme ou fonction , sauf indication contraire du défi.
Kevin Cruijssen
8

Jelly , 15 12 11 octets

Ḷ^1‘ż@N€Fị@

Essayez-le en ligne!

Comment ça marche

Ḷ^1‘ż@N€Fị@  Main link. Argument: n

Ḷ            Unlength; yield [0, 1, 2, 3, ..., n-1].
 ^1          Bitwise XOR 1; yield [1, 0, 3, 2, ..., n-1^1].
   ‘         Increment; yield [2, 1, 4, 3, ..., (n-1^1)+1].
      N€     Negate each; yield [-1, -2, -3, -4, ..., -n].
    ż@       Zip with swapped arguments; 
             yield [[-1, 2], [-2, 1], [-3, 4], [-4, 3], ..., [-n, (n-1^1)+1]].
        F    Flatten, yield [-1, 2, -2, 1, -3, 4, -4, 3, ..., -n, (n-1^1)+1].
         ị@  At-index with swapped arguments; select the item at index n.
Dennis
la source
Je savais qu'il y aurait une réponse de gelée autour de 10
Cruncher
Je l'ai vu juste après avoir posté ce commentaire lol. J'ai vraiment besoin d'apprendre Jelly un de ces jours ... C'est drôle si on regarde l'historique des questions sur cette SE. Autrefois, tout était GolfScript, puis CJam a pris le relais et maintenant, c'est Jelly.
Cruncher
6

RProgN 2 , 31 25 22 octets

nx=x2÷1x4%{+$-1x^*}#-?

A expliqué

nx=                         # Convert the input to a number, set x to it.
   x2÷                      # Floor divide x by 2.
      1                     # Place a 1 on the stack.
       x4%{       }#-?      # If x%4 is 0, subtract 1 from x//2, otherwise...
           +                # Add the 1 and the x together.
            $-1             # Push -1
               x^           # To the power of x.
                 *          # Multiply x//2+1 by -1^x. (Invert if odd, do nothing if even)

Essayez-le en ligne!

ATaco
la source
Belle approche! +1
R. Kap
6

Ruby, 26 23 18 octets

->n{~n/2+n%2*n|=2}

Basé sur 0

-3 octets volant l'idée -1 ^ n de Greg Martin , Dennis et peut-être quelqu'un d'autre, puis -5 octets dérivant l' idée n | 2 de xnor .

GB
la source
5

Python 2 ,  44  33 27 octets

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

Merci à @GB d'avoir joué 6 octets au golf!

Essayez-le en ligne!

Dennis
la source
4

05AB1E, 8 octets

2‰`^±¹F(

Essayez-le en ligne

Explication

2‰          divmod by 2
  `         flatten list
   ^        XOR
    ±       NOT
     ¹F(    Push 1st argument, loop N times, negate
mbomb007
la source
Wow, je l'aime, mais ¹F(semble cher pour "si étrange, nie".
Urne Magic Octopus
@carusocomputing C'est le cas, mais c'est le plus court que je connaisse. La réponse similaire de Dennis dans Jelly a également 3 octets pour cette partie. C'est toujours plus court que dupliquer, pousser la parité, si, nier.
mbomb007
J'ai essayé pendant 15 minutes de le battre, la seule chose qui se rapprochait était une autre solution à 3 octets de la puissance de n, à la puissance de 1/n.
Urne Magique Octopus
4

Gelée , 9 à 8 octets

|2×Ḃ+H~$

Essayez-le en ligne!

-1 merci à Dennis . Duh float conversions.

Utilise l'approche Python 2 de @ xnor.

EDIT : > _>

Erik le golfeur
la source
3
Juste quand vous pensez que vous gagnez, Dennis viendra vous battre.
HyperNeutrino
|2×Ḃ+H~$enregistre un octet. tio.run/nexus/jelly#AR0A4v//fDLDl@G4gitIfiT/…
Dennis
@ Dennis, j'ai pensé que cela provoquerait une erreur.
Erik l'Outgolfer
3

CJam , 16 octets

{_(_1&)^2/)W@#*}

Entrée basée sur 1.

Essayez-le en ligne!

Explication

Voici une ventilation du code avec les valeurs sur la pile pour chaque entrée de 1à 4. Les premières commandes n'affectent que les deux bits les moins significatifs de n-1so after 4, ce truc ne se répète que de manière cyclique, les résultats étant incrémentés de 2, en raison de la réduction de moitié.

Cmd             Stack: [1]       [2]       [3]       [4]
_    Duplicate.        [1 1]     [2 2]     [3 3]     [4 4]
(    Decrement.        [1 0]     [2 1]     [3 2]     [4 3]
_    Duplicate.        [1 0 0]   [2 1 1]   [3 2 2]   [4 3 3]
1&   AND 1.            [1 0 0]   [2 1 1]   [3 2 0]   [4 3 1]
)    Increment.        [1 0 1]   [2 1 2]   [3 2 1]   [4 3 2]
^    XOR.              [1 1]     [2 3]     [3 3]     [4 1]
2/   Halve.            [1 0]     [2 1]     [3 1]     [4 0]
)    Increment.        [1 1]     [2 2]     [3 2]     [4 1]
W    Push -1.          [1 1 -1]  [2 2 -1]  [3 2 -1]  [4 1 -1]
@    Rotate.           [1 -1 1]  [2 -1 2]  [2 -1 3]  [1 -1 4]
#    -1^n.             [1 -1]    [2 1]     [2 -1]    [1 1]
*    Multiply.         [-1]      [2]       [-2]      [1]
Martin Ender
la source
2

Perl 6 ,  55 27 24  22 octets

{(-1,2,-2,1,{|($^a,$^b,$^c,$^d Z+ -2,2,-2,2)}...*)[$_]}

(Inspiré par la zipWithréponse de Haskell )
Essayez-le

{+^($_ div 2)+$_%2*($_+|2)}

(Inspiré par plusieurs réponses)
Essayez-le

{+^($_+>1)+$_%2*($_+|2)}

L'essayer

{+^$_+>1+$_%2*($_+|2)}

L'essayer

Étendu:

{  # bare block lambda with implicit parameter 「$_」

    +^          # numeric binary invert the following
      $_ +> 1   # numeric bit shift right by one
  +
      $_ % 2    # the input modulo 2
    *
      ($_ +| 2) # numeric binary inclusive or 2
}

(Tous sont basés sur 0)

Brad Gilbert b2gills
la source
Belle soumission!
CraigR8806
2

Haskell , 37 36 octets

(([1,3..]>>= \x->[-x,x+1,-x-1,x])!!)

Essayez-le en ligne! Il s'agit d'une fonction anonyme qui prend un nombre nen argument et renvoie 0 le index nth de la séquence.

Laikoni
la source
1

Haskell, 56 octets

f n=concat(iterate(zipWith(+)[-2,2,-2,2])[-1,2,-2,1])!!n

0 indexé

Blex
la source
1

Perl 5 47 + 1 (pour drapeau) = 48 octets

print(((sin$_%4>.5)+1+2*int$_/4)*($_%4&1?1:-1))

Ancienne soumission 82 octets

@f=(sub{-$_[0]},sub{$_[0]+1},sub{-$_[0]-1},sub{$_[0]});print$f[$_%4](1+2*int$_/4)

Courez comme si:

perl -n <name of file storing script>  <<<  n
CraigR8806
la source
Vous pouvez enregistrer un octet en utilisant print +((et en supprimant le dernier ). Et deux autres en utilisant sayet -E. Et aussi un de plus en faisant à la ($_%4&1||-1)place du ternaire.
simbabque
1

JavaScript (ES7), 28 octets

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

1 indexé. Je n'ai pas encore étudié d'autres réponses, donc je ne sais pas s'il s'agit du meilleur algorithme, mais je suppose que non.

ETHproductions
la source
1

JavaScript, 28 22 octets

Merci @ETHproductions pour le golf 6 octets

x=>x%2?~x>>1:x%4+x/2-1

Essayez-le en ligne!

fəˈnɛtɪk
la source
Hmm ... ça f=x=>x%2?~x>>1:x/2+x%4-1marcherait?
ETHproductions
Pour une raison quelconque, j'avais quitté le f = devant la fonction anonyme: P
fəˈnɛtɪk
1

dc , 98 octets

?sa0sb1sq[lq1+dsqla!<i3Q]sf[lb1-lfx]su[lblfx]sx[lb1+dsblfx]sj[lqdd4%d0=u1=j2%1=xljxlfx]dsix_1la^*p

Mon Dieu, c'est la réponse la plus longue ici, principalement parce que j'ai choisi de générer la valeur absolue de chaque élément de la séquence un par un en utilisant la formule récursive suivante:

enter image description here

puis la sortie (-1)^n * a_n, plutôt que de calculer directement lan ième élément. Quoi qu'il en soit, c'est 1-indexed.

Essayez-le en ligne!

R. Kap
la source
1

R, 38 octets

function(n)floor(n/2+1-2*!n%%4)*(-1)^n

Explication

floor(n/2+1)                ->  1 2  2 3  3 4  4 5...
floor(n/2+1-2*!n%%4)        ->  1 2  2 1  3 4  4 3... (subtract 2 where n%%4 == 0)
floor(n/2+1-2*!n%%4)*(-1)^n -> -1 2 -2 1 -3 4 -4 3... (multiply odd n by -1)
utilisateur2390246
la source
1

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

.5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4)))i^(2Ans

TI-Basic est un langage à jetons et chaque jeton utilisé ici est un octet, sauf remainder(deux.

Ceci utilise la version 1-indexée.

Explication:

Il existe un modèle qui se répète tous les quatre chiffres. Dans la version 1-indexée, il s'agit de: - (x + 1) / 2, (x + 1) / 2, - (x + 1) / 2, (x-1) / 2 pour la valeur d'entrée x. Ceci peut être représenté comme une fonction définie par morceaux.

f (x) = - (x + 1) / 2 si x ≡ 1 mod 4; (x + 1) / 2 si x 2 mod 4; - (x + 1) / 2 si x 3 mod 4; (x-1) / 2 si x 0 mod 4

Les parties "x ≡ 1 mod 4" et "x 3 mod 4" étant identiques, nous pouvons les combiner en "x 1 mod 2".

Maintenant, la fonction par morceaux est:

f (x) = - (x + 1) / 2 si x ≡ 1 mod 2; (x + 2) / 2 si x 2 mod 4; (x-2) / 2 si x 0 mod 4

C'est là que je commence à le diviser en commandes réelles. Puisque la valeur est positive pour les indices pairs et négative pour les impairs, nous pouvons utiliser (-1) ^ x. Cependant, dans TI-Basic i^(2X(5 octets), sa longueur est inférieure à(-1)^Ans (6 octets). Notez que les parenthèses sont obligatoires en raison de l'ordre des opérations.

Maintenant que nous avons le moyen de supprimer les entrées impaires, nous passons aux mods (ajout de la négation plus tard). J'ai fait le cas d'une entrée impaire la valeur par défaut, nous allons donc commencer par.5(Ans+1) .

Pour résoudre le cas d'une entrée paire, ajoutez simplement un au nombre entre parenthèses, mais uniquement lorsque x 0 mod 2. Cela peut être représenté par .5(Ans+1+remainder(Ans+1,2))ou.5(Ans+1+not(remainder(Ans,2))) , mais ils ont le même nombre d'octets, donc peu importe lequel.

Pour résoudre le cas d'une entrée multiple de 4, nous devons soustraire 3 du nombre entre parenthèses, mais également un autre 1 car tous les multiples de 4 sont pairs, ce qui en ajouterait un de notre étape précédente, nous avons donc maintenant .5(Ans+1+remainder(Ans+1,2)-4not(remainder(Ans,4))) .

Maintenant, il suffit de clouer sur la partie déterminant la signalisation pour obtenir le programme complet.

pizzapants184
la source
0

Befunge 93, 25 octets

Indexé à zéro

&4/2*1+&4%3%!!+&2%2*1-*.@

Essayez-le en ligne!

Le numéro est donné par ((2(n / 4) + 1) + !!((n % 4) % 3)) * (2(n % 2) - 1)

MildlyMilquetoast
la source
0

QBIC , 53 octets

b=1:{[b,b+3|~b=a|_x(-(b%2)*2+1)*(q+(b%4>1)*-1)]]q=q+2

Explication:

b=1     Set b to a starting value of 1
        QBIC would usually use the pre-initialised variable q, but that is already in use
:       Get an input number from the cmd-line, our term to find
{       Start an infinite loop
[b,b+3| FOR-loop: this runs in groups of 4, incrementing its own bounds between runs
~b=a|   If we've reached the term requested
_x      QUIT the program and print:

(-(b%2)*2+1)   The b%2 gives a 1 or a 0, times 2 (2,0), negged (-2,0) and plus one (-1,1)
*              That gives us the sign of our term. Now the value:
(q+(b%4>1)*-1) This is q + 1 if the inner loop counter MOD 4 (1,2,3,0...) is 2 or 3.
]       Close the IF that checks the term
]       Close the FOR-loop
q=q+2   And raise q by 2 for the next iteration of the DO-loop.
Steenbergh
la source
0

Q, 52 octets

{(1 rotate(,/){x,(-)x}each 1_((_)x%4)+til 3)x mod 4}

0 solution indexée.

  1. Obtient le numéro de bloc c'est-à-dire. lequel bloc [-x x + 1 - (x + 1) x] de la séquence contient l'index.
  2. Obtient l'index de la valeur dans le bloc en fonction de l'index de la valeur dans la séquence entière.
  3. Crée le bloc.
  4. Indexe par l’index dérivé de l’étape 2.
Daniel Plainview
la source