Cycle arithmétique


13

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

1
Je ne pouvais pas le trouver sur oeis.org , vous voudrez peut-être le soumettre ici. C'est une séquence intéressante, je suis surpris que personne ne l'ait enregistrée.
pipe

1
@pipe il semble assez arbitraire
qwr

Réponses:


20

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 .


2
Parce que la plupart des réponses sont des ports de cette solution, je veux ajouter que j'ai vérifié que c'est prouvable.
Erik the Outgolfer


Ah, fous, j'ai été distrait par le travail en travaillant sur quelque chose de très similaire. +1
Shaggy

Par curiosité, y a-t-il une raison de préférer "n & 3" à "n% 4"?
IanF1

2
@ IanF1 Je suppose que ce n'est qu'une habitude de programmation de bas niveau (calculer un bit ET ET en assemblage est plus facile et plus rapide que calculer un modulo). Mais cela n'a pas beaucoup de sens ici et j'étais en fait à moitié tenté de le changer par la n%4suite pour qu'il fonctionne avec des nombres supérieurs à 32 bits.
Arnauld

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]



3

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 .

2

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!


Vous pouvez exactement diviser par deux votre nombre d'octets (31 octets) en créant un port d' OlivierGrégoire la réponse Java : f(n){n=n%2>0?n*(2-n%4):n%4/-2;}je l'ajouterais cependant comme deuxième réponse, car j'aime aussi votre approche récursive. :)
Kevin Cruijssen

@KevinCruijssen J'ai vu leur solution Java 10 et j'ai remarqué sa brièveté, même si je ne voulais pas simplement copier leur solution, car les syntaxes arithmétiques des deux langages sont trop similaires.
Jonathan Frech



1

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


1

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

1

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.


2
Belle tentative! Quelques remarques: 1) Vous pouvez remplacer (0,⍵,¯1,-⍵)par (0⍵¯1,-⍵). 2) Vous pouvez supprimer le 1+en supposant que la ⎕IOvariable système est affectée à 0(oui, c'est autorisé). 3) Nous ne comptons généralement pas la f←pièce lors de la soumission des fonctions. 4) Vous pouvez utiliser la fonction au lieu de l' []indexation. Tous ces éléments forment ceci: ⎕IO←0(ne comptez pas){(4|⍵)⊃0⍵¯1,-⍵}
Erik the Outgolfer

@Erik the Outgolfer Merci!
Galen Ivanov

2
Plus le golf de pointe basée sur cette approche: 4∘|⊃0,⊢,¯1,-.
Erik the Outgolfer

1
@Erik the Outgolfer - Oui, en effet! Je pense que 4∘|⊃0,⊢,¯1,- c'est exactement à quoi ressemblerait ma solution J 4&|{0,],_1,-dans APL. Merci encore!
Galen Ivanov

1
En fait, J est une variante APL, bien que plus éloignée que d'autres plus APL comme Dyalog et NARS2000.
Erik the Outgolfer le

1

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.


0

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.

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.