Contribution:

Entier nqui est >=0ou >=1( f(0)est facultatif)

Production:

Le n«e numéro dans la séquence ci-dessous, OU la séquence jusqu'au et incluant le n« e numéro.

Séquence:

(0),1,-1,-3,0,5,-1,-7,0,9,-1,-11,0,13,-1,-15,0,17,-1,-19,0,21,-1,-23,0,25,-1,-27,0,29,-1,-31,0,33,-1,-35,0,37,-1,-39,0,41,-1,-43,0,45,-1,-47,0,49,-1,-51,0,53,-1,-55,0,57,-1,-59,0,61,-1,-63,0,65,-1,-67,0,69,-1,-71,0,73,-1,-75,0,77,-1,-79,0,81,-1,-83,0,85,-1,-87,0,89,-1,-91,0,93,-1,-95,0,97,-1,-99

Comment est construite cette séquence?

f(n=0) = 0(facultatif)
f(n=1) = f(0) + nou f(n=1) = 1
f(n=2) = f(1) - n
f(n=3) = f(2) * n
f(n=4) = f(3) / n
f(n=5) = f(4) + n
etc.

Ou en pseudo-code:

function f(integer n){
  Integer result = 0
  Integer i = 1
  Loop as long as i is smaller than or equal to n
  {
    if i modulo-4 is 1:
      result = result plus i
    if i modulo-4 is 2 instead:
      result = result minus i
    if i modulo-4 is 3 instead:
      result = result multiplied with i
    if i modulo-4 is 0 instead:
      result = result integer/floor-divided with i
    i = i plus 1
  }
  return result
}

Mais comme vous l'avez peut-être remarqué, la séquence comporte deux modèles:

0, ,-1,  ,0, ,-1,  ,0, ,-1,   ,0,  ,-1,   ,0,  ,-1,   ,...
 ,1,  ,-3, ,5,  ,-7, ,9,  ,-11, ,13,  ,-15, ,17,  ,-19,...

de sorte que toutes les autres approches aboutissant à la même séquence sont bien entendu parfaitement correctes également.

Règles du défi:

• Les entrées indexées 0 et indexées 1 donneront le même résultat (c'est pourquoi l' f(0)option est facultative pour les entrées indexées 0 si vous souhaitez l'inclure).
• Vous êtes autorisé à sortir le n'ème numéro de cette séquence. Ou la séquence entière en haut et y compris le nnuméro e. (Il f(5)peut donc en résulter soit5 ou 0,1,-1,-3,0,5.)
  • Si vous choisissez de sortir la séquence jusqu'au nnuméro e inclus , le format de sortie est flexible. Peut être une liste / tableau, une virgule / espace / une chaîne délimitée par une nouvelle ligne ou être imprimé sur STDOUT, etc.
• La division ( /) est une division entier / étage, qui arrondit vers 0 (et non vers l'infini négatif comme c'est le cas dans certaines langues).

Règles générales:

• C'est le code-golf , donc la réponse la plus courte en octets l'emporte.
  Ne laissez pas les langues de golf de code vous décourager de publier des réponses avec des langues non-golfeur de code. Essayez de trouver une réponse aussi courte que possible pour «n'importe quel» langage de programmation.
• Des règles standard s'appliquent à votre réponse, vous êtes donc autorisé à utiliser STDIN / STDOUT, des fonctions / méthodes avec les paramètres appropriés et des programmes complets de type retour. Ton appel.
• Les failles par défaut sont interdites.
• Si possible, veuillez ajouter un lien avec un test pour votre code.
• Veuillez également ajouter une explication si nécessaire.

Cas de test supplémentaires ci n=100- dessus :

Input     Output

1000      0
100000    0
123       -123
1234      -1
12345     12345
123456    0

JavaScript (ES6), 19 octets

n=>[0,n,-1,-n][n&3]

Essayez-le en ligne!

Preuve

Supposons que nous avons les relations suivantes pour un n multiple de 4. Ces relations sont vérifiées trivialement pour les premiers termes de la séquence.

f(n)   = 0
f(n+1) = n+1
f(n+2) = -1
f(n+3) = -(n+3)

Et soit N = n + 4 . Ensuite, par définition:

f(N)   = f(n+4) = f(n+3) // (n+4) = -(n+3) // (n+4) = 0
f(N+1) = f(n+5) = f(n+4) + (n+5)  = 0 + (n+5)       = N+1
f(N+2) = f(n+6) = f(n+5) - (n+6)  = (n+5) - (n+6)   = -1
f(N+3) = f(n+7) = f(n+6) * (n+7)  = -1 * (n+7)      = -(N+3)

Ce qui, par induction mathématique, prouve que les relations sont valables pour tout multiple de N de 4 .

05AB1E , 8 octets

Sort le nthnombre

ÎD(®s)sè

Essayez-le en ligne!

05AB1E , 14 octets

Affiche une liste de nombres jusqu'à N en utilisant les modèles de la séquence

ÅÉāÉ·<*āÉ<‚øí˜

Essayez-le en ligne!

Explication

Exemple utilisant N = 7

ÅÉ               # List of odd numbers upto N
                 # STACK: [1,3,5,7]
  ā              # Enumerate 1-based
   É             # is odd?
                 # STACK: [1,3,5,7],[1,0,1,0]
    ·<           # double and decrement
                 # STACK: [1,3,5,7],[1,-1,1,-1]
      *          # multiply
                 # STACK: [1,-3,5,-7]
       āÉ<       # enumerate, isOdd, decrement
                 # STACK: [1,-3,5,-7],[0,-1,0,-1]
          ‚ø     # zip
                 # STACK: [[1, 0], [-3, -1], [5, 0], [-7, -1]]
            í    # reverse each
             ˜   # flatten
                 # RESULT: [0, 1, -1, -3, 0, 5, -1, -7]

Python 2 , 25 octets

Réponse du port d'Arnauld:

lambda n:[0,n,-1,-n][n%4]

Essayez-le en ligne!

Solutions naïves:

Python 3 , 50 49 octets

lambda n:n and eval('int(f(n-1)%sn)'%'/+-*'[n%4])

Essayez-le en ligne!

Python 2 , 78 77 76 58 57 53 52 octets

lambda n:n and eval('int(1.*f(n-1)%sn)'%'/+-*'[n%4])

Essayez-le en ligne!

Utilisé un tas d'octets int, car le sol en python se divise, et non vers 0, comme dans la question.

J , 12 octets

Réponse du port d'Arnauld:

4&|{0,],_1,-

Essayez-le en ligne!

J , 28 octets

Solution naïve:

{(0 _1$~]),@,.(_1^i.)*1+2*i.

Sort le nième nombre

Essayez-le en ligne!

TIS -n 2 1 , 123 octets

Sort le nnuméro e pour 0 <= n <= 999. (La limite supérieure est due aux limitations linguistiques).

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
JRO -5
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY
HCF

Essayez-le en ligne!

TIS -n 2 1 , 124 octets

Sort le nnuméro e pour 0 <= n <= 999. (La limite supérieure est due aux limitations linguistiques). Plusieurs npeuvent être fournis, séparés par des espaces.

@0
MOV UP ACC
MOV ACC ANY
L:SUB 4
JGZ L
JEZ L
ADD 5
MOV ACC ANY
@1
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

Essayez-le en ligne!

TIS -n 3 1 , 192 octets

Génère les valeurs de 0..npour 0 <= n <= 999. (La limite supérieure est due aux limitations linguistiques).

@0
MOV UP ACC
ADD 1
MOV ACC ANY
JRO -1
@1
SUB UP
JLZ C
HCF
C:ADD UP
MOV ACC ANY
ADD 1
SWP
ADD 1
MOV ACC ANY
SUB 4
JEZ W
ADD 4
W:SWP
@2
MOV UP ACC
JRO UP
SUB ACC
JRO 3
MOV 1 ACC
NEG
MOV ACC ANY

Essayez-le en ligne!

Tous utilisent des E / S numériques (le -n drapeau). Les deux premières solutions utilisent deux nœuds de calcul, l'un positionné au-dessus de l'autre. Le troisième a une pile de trois nœuds.

Pour les deux premières solutions, le nœud supérieur lit l'entrée, envoie le nombre d'origine, puis soustrait à plusieurs reprises 4 jusqu'à ce que nous devenions négatifs, puis ajoute 5 à l'index de notre table de saut. C'est équivalent à (n % 4) + 1.

La troisième solution a divisé cette tâche sur deux nœuds; celui du haut ne fait que répéter la limite jusqu'à la fin des temps, et le nœud du milieu compte en parallèle l'indice (par rapport à cette limite) et le modulo comme ci-dessus.

Le nœud inférieur des trois solutions est le même; il a une table de saut, et c'est là que la magie opère. Nous enregistrons le nombre original ACC, puis JRO(probablement J ump R élatif O ffset) vers l' avant par 1, 2, 3ou 4, selon ce que le nœud dit ci - dessus.

Travail en arrière:

• 4sera a ) NEGmangé ACC, et b ) ACCdescendra pour la sortie.
• 3va mettre 1en ACC, puis effectuez les étapes 4a et 4b .
• 2passera directement à l'étape 4b .
• 1va SUBtracter ACChors lui - même ( la mise à zéro de manière efficace ACC), puis faire étape 2, qui saute à 4b .

C (gcc) , 62 octets

f(n,k){k=~-n;n=n?n%4?k%4?n-2&3?f(k)*n:f(k)-n:f(k)+n:f(k)/n:0;}

Essayez-le en ligne!

Gelée , 8 octets

,-;N;0⁸ị

Essayez-le en ligne!

-1 merci à Lynn .

Ce que font les autres (port de la solution d'Arnauld), prend en charge 0.

Gelée , 17 octets

A:A}××Ṡ¥
R_×ç+4ƭ/

Essayez-le en ligne!

0 n'est pas pris en charge.

Java (JDK 10) , 25 octets

n->n%2>0?n*(2-n%4):n%4/-2

Essayez-le en ligne!

Plus court que l'algorithme de contender dans d'autres langues avec 28 octets

n->new int[]{0,n,-1,-n}[n%4]

Essayez-le en ligne!

Rétine , 46 octets

.+
*
r`(____)*$
_$.=
____
-
___.*
-1
__

_.*
0

Essayez-le en ligne! Explication:

.+
*

Convertissez en unaire.

r`(____)*$
_$.=

Reconvertissez en décimal, mais laissez des n%4+1soulignements.

____
-

Dans le cas où c'est 4, le résultat est -n.

___.*
-1

Cas 3: -1

__

Cas 2: n

_.*
0

Cas 1: 0

Haskell , 50 octets

f 0=0
f n=([(+),(-),(*),quot]!!mod(n-1)4)(f(n-1))n

Essayez-le en ligne!

La solution d'Arnauld, portée sur Haskell, est de 23 octets:

z n=cycle[0,n,-1,-n]!!n

APL (Dyalog Classic) , 22 12 octets

Épargne massive de 10 octets grâce aux remarques d'Erik l'Outgolfer. Je vous remercie!

4∘|⊃0,⊢,¯1,-

Essayez-le en ligne!

Sort le nième nombre

Je ne connais pas APL, j'ai juste essayé de faire fonctionner mon port J de la solution d'Arnauld dans Dyalog APL.

Cubix , 20 19 octets

Iun:^>s1ns:u@Ota3s0

Essayez-le en ligne!

Ports la même approche de cubix.

Sur un cube:

    I u
    n :
^ > s 1 n s : u
@ O t a 3 s 0 .
    . .
    . .

Le premier bit ^Iu:n>s1ns:u0scrée la pile, puis 3atcopie l'élément approprié dans TOS, puis Osort et @termine le programme.

Espace, 84 83 octets

[S S S N
_Push_0][S N
S _Duplicate_0][T   T   S _Store][S S S T   S N
_Push_2][S S T  T   N
_Push_-1][T T   S _Store][S S S T   N
_Push_1][S N
S _Duplicate_1][T   N
T   T   _Read_STDIN_as_integer][S S S T T   N
_Push_3][S S S T    N
_Push_1][T  T   T   ][S S T T   N
_Push_-1][T S S N
_Multiply][T    T   S _Store][T T   T   _Retrieve_input][S S S T    S S N
_Push_4][T  S T T   _Modulo][T  T   T   _Retrieve_result][T N
S T _Print_as_integer]

Lettres S(espace), T(tabulation) et N(nouvelle ligne) ajoutées uniquement en surbrillance.
[..._some_action]ajouté à titre d'explication uniquement.

Essayez-le en ligne (avec des espaces bruts, des tabulations et des nouvelles lignes uniquement).

Réponse JavaScript du port de @Arnauld .

Explication (exemple d'entrée n=7):

Command   Explanation         Stack        Heap                  STDIN   STDOUT   STDERR

SSSN      Push 0              [0]
SNS       Duplicate top (0)   [0,0]
TTS       Store               []           {0:0}
SSSTSN    Push 2              [2]          {0:0}
SSTTN     Push -1             [2,-1]       {0:0}
TTS       Store               []           {0:0,2:-1}
SSSTN     Push 1              [1]          {0:0,2:-1}
SNS       Duplicate top (1)   [1,1]        {0:0,2:-1}
TNTT      Read STDIN as nr    [1]          {0:0,1:7,2:-1}        7
SSSTTN    Push 3              [1,3]        {0:0,1:7,2:-1}
SSSTN     Push 1              [1,3,1]      {0:0,1:7,2:-1}
TTT       Retrieve input      [1,3,7]      {0:0,1:7,2:-1}
SSTTN     Push -1             [1,3,7,-1]   {0:0,1:7,2:-1}
TSSN      Multiply (-1*7)     [1,3,-7]     {0:0,1:7,2:-1}
TTS       Store               [1]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve input      [7]          {0:0,1:7,2:-1,3:-7}
SSSTSSN   Push 4              [7,4]        {0:0,1:7,2:-1,3:-7}
TSST      Modulo (7%4)        [3]          {0:0,1:7,2:-1,3:-7}
TTT       Retrieve            [-7]         {0:0,1:7,2:-1,3:-7}
TNST      Print as integer    []           {0:0,1:7,2:-1,3:-7}           -7
                                                                                  error

Arrête avec erreur: sortie non définie.