La fourmi prime

50

La "fourmi" est un animal obstiné qui navigue dans les entiers et les divise jusqu'à ce qu'il ne reste plus que des nombres premiers!

Au départ, nous avons un tableau infini A contenant tous les entiers> = 2: [2,3,4,5,6,.. ]

Soit pla position de la fourmi sur le tableau. Initialement, p = 0(tableau est indexé par 0)

À chaque tour, la fourmi se déplace comme suit:

  • si A[p]est premier, la fourmi passe à la position suivante:p ← p+1
  • sinon, si A[p]est un nombre composé, qsoit son plus petit diviseur> 1. Nous divisons A[p]par q, et nous ajoutons qà A[p-1]. La fourmi se déplace à la position précédente:p ← p-1

Voici les premiers mouvements de la fourmi:

 2  3  4  5  6  7  8  9  ... 
 ^
 2  3  4  5  6  7  8  9  ... 
    ^
 2  3  4  5  6  7  8  9  ... 
       ^
 2  5  2  5  6  7  8  9  ... 
    ^
 2  5  2  5  6  7  8  9  ... 
       ^
 2  5  2  5  6  7  8  9  ... 
          ^
 2  5  2  5  6  7  8  9  ... 
             ^
 2  5  2  7  3  7  8  9  ... 
          ^

Votre programme doit afficher la position de la fourmi après les ndéplacements. (vous pouvez supposer n <= 10000)

Cas de test:

0 => 0
10 => 6
47 => 9
4734 => 274
10000 => 512

Modifier. vous pouvez également utiliser des listes à 1 index, il est acceptable d'afficher les résultats 1, 7, 10, 275, 513 pour le scénario de test ci-dessus.

C'est du code-golf, donc le code avec le code le plus court en octets gagne.

code-golf  sequence  primes 
— Arnaud
source
32
Honnêtement, je pensais qu'il y avait une fourmi sur mon écran lorsque j'ai vu cela dans Hot Network Questions.
— Kodos Johnson
14
Je me demande si la séquence est bien définie pour une longueur arbitrairement grande n(ou si le cas composite pourrait jamais pousser la fourmi à gauche de l'initiale 2).
— Martin Ender
1
@SuperChafouin donc les résultats pour les cas de test peuvent être: 1,7,10,275,513si 1-indexation déclarée? Ou auraient-ils encore besoin de correspondre à vos sorties.
— Tom Carpenter
12
@MartinEnder Une autre question ouverte est de savoir si un nombre premier> 7 peut éventuellement être laissé pour compte.
— Arnauld
2
@Arnauld Out autant que n = 1 000 000 000 (où p = 17156661), la relation entre n et p est très proche de p = n / (ln (n) * ln (ln (n))).
— Penguino

Réponses:

11

Alice , 45 octets

/o
\i@/.&wqh!]k.&[&w;;?c]dt.n$k&;[.?~:![?+!kq

Essayez-le en ligne!

Implémentation plutôt simple.

Les ntemps de bouclage dans Alice se font généralement en poussant une adresse de retour n-1, puis en revenant à la fin de chaque itération avec k. La dernière fois dans la boucle, l' kinstruction n'a nulle part où retourner et l'exécution continue.

Ce programme utilise la même kinstruction pour arrêter tôt lorsque le nombre est premier. En conséquence, l'itération finale déplacera toujours la fourmi à gauche. Pour compenser ce bogue, nous effectuons des n+1itérations sur un tableau à 1 index, ce qui donne exactement le résultat souhaité (et donne le cas n=0gratuitement).

— Nitrodon
source
7

Python 2 , 120 octets

p=0
A=range(2,input()+2)
for _ in A:
 for q in range(2,A[p]):
	if A[p]%q<1:A[p]/=q;p-=1;A[p]+=q;break
 else:p+=1
print p

Essayez-le en ligne!

Ah, la rare for- elseboucle! La elseclause ne s'exécute que si le forcorps n'est pas quitté via break. Dans notre cas, cela signifie que nous avons vérifié tous les qs et n’avons trouvé aucun d’entre eux à diviser p.

— Lynn
source
7

Octave , 109 103 101 94 octets

function i=a(n)i=1;for l=z=2:n+1
if nnz(q=factor(z(i)))>1
z(i--)/=p=q(1);z(i--)+=p;end
i++;end

Essayez-le en ligne!

Ce code affichera la position dans 1-indexation, ainsi les sorties pour les cas de test sont:

0 => 1
10 => 7
47 => 10
4734 => 275
10000 => 513

Cette version utilise certaines optimisations Octave, elle n'est donc pas compatible avec MATLAB. Le code ci-dessous est une version compatible MATLAB.

MATLAB, 130 123 118 117 octets

function i=a(n)
z=2:n+1;i=1;for l=z
q=factor(z(i));if nnz(q)>1
z(i)=z(i)/q(1);i=i-1;z(i)=z(i)+q(1);else
i=i+1;end
end

Utilise 1-indexing comme avec la version Octave. Je l'ai testé par rapport à tous les cas de test dans MATLAB. Par exemple, la sortie sur 100000 est 3675 (index unique).

Une version commentée du code ci-dessus:

function i=a(n)
    z=2:n+1;                %Create our field of numbers
    i=1;                    %Start of at index of 1 (MATLAB uses 1-indexing)
    for l=1:n               %For the required number of iterations
        q=factor(z(i));     %Calculate the prime factors of the current element
        if nnz(q)>1         %If there are more than one, then not prime
            z(i)=z(i)/q(1); %So divide current by the minimum
            i=i-1;          %Move back a step
            z(i)=z(i)+q(1); %And add on the minimum to the previous.
        else
            i=i+1;          %Otherwise we move to the next step
        end
    end

Ce qui est intéressant, c’est la position des fourmis par rapport au nombre d’itérations pour les 10000 premières valeurs de n.

Position de la fourmi

Il semble probable que la fourmi tendra probablement à l'infini, mais qui sait, les apparences peuvent être trompeuses.

  • MATLAB: Sauvegardé 6 octets au forlieu de whileet suppression des crochets de if- Merci @Giuseppe
  • MATLAB: Économisez 2 octets - Merci @Sanchises
  • Octave: Économisez 10 octets en utilisant Octave \=et ses +=opérations - Merci @Giuseppe
  • Octave: économisez 2 octets avec i++et i--- Merci @LuisMendo
  • Octave: Économisez 7 octets - Merci @Sanchises
— Tom Carpenter
source
Pour que cela fonctionne sur TIO, je pense que vous devez endcorrespondre à la signature de la fonction
— Giuseppe
@ Giuseppe Ah, d'accord. Dans MATLAB, la fin endest optionnelle.
— Tom Carpenter
vous pouvez créer une fonction anonyme en utilisant @ (n) au début au lieu d'utiliser la fonction i = a (n)
— Michthan
@Michthan ne peut pas faire ça dans MATLAB. Je ne pense pas que ce soit possible dans Octave non plus car il a des boucles?
— Tom Carpenter
1
La fin endest également facultative dans Octave. Ici, c'est seulement nécessaire parce que vous avez le code après la fonction
— Luis Mendo
6

JavaScript (ES6), 91 octets

f=(n,a=[p=0])=>n--?f(n,a,(P=n=>++x<n?n%x?P(n):a[a[p]/=x,--p]+=x:p++)(a[p]=a[p]||p+2,x=1)):p

Démo

NB: Vous devrez peut-être augmenter la taille de pile par défaut de votre moteur pour qu'il réussisse tous les tests.

Essayez-le en ligne!

— Arnauld
source
6

Haskell , 108 106 94 octets

([0]#[2..]!!)
(a:b)#(p:q)=length b:([b#(a+d:div p d:q)|d<-[2..p-1],mod p d<1]++[(p:a:b)#q])!!0

Essayez-le en ligne! Exemple d'utilisation: ([0]#[2..]!!) 10rendements 6(indexé sur 0).

La fonction #opère sur deux listes, l'avant inversé du tableau [p-1, p-2, ..., 1]et le reste infini du tableau [p, p+1, p+2, ...]. Il construit une liste infinie de positions, à partir de laquelle la nposition th est renvoyée avec une entrée n.

Le modèle ((a:b)#(p:q))se lie pà la valeur de la position actuelle de la fourmi et aà la valeur de la position précédente. best le préfixe du tableau de la position 1 à p-2et qle repos infini à partir de la position p+1.

Nous construisons une liste d'appels récursifs de la manière suivante: Nous examinons chaque diviseur dde p(qui est supérieur à un et inférieur à p) dans l'ordre croissant et ajoutons b#(a+d:div p d:q)pour chacun d'eux que la valeur actuelle pest divisée par det que la fourmi se déplace un pas à gauche où dest ajouté à a. Ensuite, nous ajoutons (p:a:b)#qà la fin de cette liste, qui indique la fourmi se déplaçant un pas à droite.

Nous prenons ensuite le premier de ces appels récursifs de la liste et ajoutons la position actuelle, qui coïncide avec la longueur de la liste de préfixes b. Comme les diviseurs sont dans l’ordre croissant, choisir le premier de la liste des appels récursifs garantit l’utilisation du plus petit. De plus, étant donné qu’il (p:a:b)#qest ajouté à la fin de la liste, il n’est sélectionné que s’il n’ya pas de diviseur et pest donc premier.

Modifications:
-2 octets en basculant la liste des fonctions d’ordre décroissant à croissant.
-12 octets grâce à l'idée de Zgarb d'indexer dans une liste infinie au lieu de gérer un compteur et de passer à l'indexation 0.

— Laikoni
source
2
96 octets en construisant une liste infinie et en indexant, au lieu de transporter le compteur.
— Zgarb
1
@Zgarb Merci beaucoup! Il n’ya même que 94 octets lors du passage à l’indexation 0.
— Laikoni 10/10
5

TI-BASIC, 108 103 102 98 octets

L'entrée et la sortie sont stockées dans Ans. La sortie est 1 indexée.

Ans→N
seq(X,X,2,9³→A
1→P
For(I,1,N
1→X:∟A(P→V
For(F,2,√(V
If X and not(fPart(V/F:Then
DelVar XV/F→∟A(P
P-1→P
F+∟A(P→∟A(P
End
End
P+X→P
End
— kamoroso94
source
Vous pouvez enlever un octet fPart(∟A(P)/F:avec fPart(F¹∟A(P:. Même chose à la ligne suivante.
— Scott Milner
@ScottMilner Cela ne fonctionne pas toujours. not(fPart(7⁻¹7est 0 mais not(fPart(7/7est 1.
— kamoroso94
5

MATL , 41 octets

:Q1y"XHyw)Zp?5MQ}1MtYf1)/H(8MyfHq=*+9M]]&

La sortie est basée sur 1. Le programme expire pour le dernier cas de test dans l'interprète en ligne.

Essayez-le en ligne!

Explication

Le programme applique la procédure décrite dans le challenge. Pour ce faire, il utilise de manière inhabituellement lourde les presse-papiers automatiques et manuels de MATL.

Le plus petit diviseur est obtenu en tant que première entrée de la décomposition en facteurs premiers.

La mise à jour de « fracture » se fait en écrasant l'entrée correspondante de la matrice A . La mise à jour "add" est effectuée par élément en ajoutant à A un tableau contenant des zéros sauf à la position souhaitée.

:Q        % Implicitly input n. Push array [2 3 ... n+1]. This is the initial array A. 
          % It contains all required positions. Some values will be overwritten
1         % Push 1. This is the initial value for p
y         % Duplicate from below
"         % For each loop. This executes the following n times.
          %   STACK (contents whosn bottom to top): A, p
  XH      %   Copy p into clipboard H
  y       %   Duplicate from below. STACK: A, p, A
  w       %   Swap. STACK: A, A, p
  )       %   Reference indexing. STACK: A, A[p]
  Zp      %   Isprime. STACK: A, false/true
  ?       %   If true (that is, if A[p] is prime)
    5M    %     Push p from automatic clipboard. STACK: A, p
    Q     %     Add 1. STACK: A, p+1
  }       %   Else (that is, if A[p] is not prime)
    1M    %     Push A[p] from automatic clipboard. STACK: A, A[p]
    t     %     Duplicate. STACK: A, A[p], A[p]
    Yf    %     Prime factors, with repetitions. STACK: A, A[p], prime factors of A[p]
    1)    %     Get first element, d. STACK: A, A[p], d
    /     %     Divide. STACK: A, A[p]/d
    H     %     Push p from clipboard H. STACK: A, A[p]/d, p
    (     %     Assignment indexing: write value. STACK: A with A[p] updated
    8M    %     Push d from automatic clipboard.
    y     %     Duplicate from below. STACK: A with A[p] updated, d, A with A[p] updated
    f     %     Find: push indices of nonzero entries.
          %     STACK: A with A[p] updated, d, [1 2 ... n]
    Hq    %     Push p from clipboard H, subtract 1.
          %     STACK: A with A[p] updated, d, [1 2 ... n], p-1
    =     %     Test for equality, element-wise.
          %     STACK: A with A[p] updated, d, [0 ... 0 1 0 ... 0]
    *     %     Multiply, element-wise. STACK: A with A[p] updated, [0 ... 0 d 0 ... 0]
    +     %     Add, element-wise. STACK: A with A[p-1] and A[p] updated
    9M    %     Push p-1 from automatic clipboard.
          %     STACK: A with A[p-1] and A[p] updated, p-1
  ]       %   End if. The stack contains the updated array and index
]         % End for each. Process the next iteration
&         % Specify that the following implicit display function should display only
          % the top of the stack. Implicitly display
— Luis Mendo
source
3

PARI / GP, 87 octets

f(n)=A=[2..9^5];p=1;for(i=1,n,q=factor(A[p])[1,1];if(A[p]-q,A[p]/=q;p--;A[p]+=q,p++));p

Assez explicite (pas si golf-ish). Si vous ne comptez pas la f(n)=partie, vous obtenez 82 octets. Vous pouvez également commencer par n->(85 octets).

C'est un langage indexé 1.

Edit: La modification illustrate(n,m)=A=[2..m+1];p=1;for(i=1,n,for(j=1,m,printf("%5s",if(j==p,Str(">",A[j],"<"),Str(A[j]," "))));print();q=factor(A[p])[1,1];if(A[p]!=q,A[p]/=q;p--;A[p]+=q,p++))imprimera une illustration de la marche de la fourmi (avec un terminal suffisamment large). Par exemple illustrate(150,25)donnera les 150 premiers pas sur 25 colonnes, comme ceci:

  > 2 <3 4 5 6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2> 3 <4 5 6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 3> 4 <5 6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2> 5 <2 5 6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5> 2 <5 6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5 2> 5 <6 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5 2 5> 6 <7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5 2> 7 <3 7 8 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5 2 7> 3 <7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3> 7 <8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3 7> 8 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7 3> 9 <4 9 10 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7> 6 <3 4 9 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2> 9 <3 3 4 9 10 11 12 14 14 16 16 18 18 20 20 22 22 23 24 25 26
   2 5> 5 <3 3 3 9 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5> 3 <3 3 4 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3> 3 <3 4 9 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 3 <4 9 10 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 3> 4 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 5 <2 9 10 10 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 2 <9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 2> 9 <10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 5 <3 10 11 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 3 <10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 3> 10 <11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 5 <5 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5> 5 <11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 11 <12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5 5 11> 12 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 13 <6 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5 13> 6 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5 5> 15 <3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 5> 8 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 7 <4 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5 7> 4 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5 5> 9 <2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 5> 8 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 7 <4 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3 7> 4 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3 3> 9 <2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 3> 6 <3 2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5> 5 <3 3 2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5> 3 <3 2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3> 3 <2 3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3> 2 <3 2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2> 3 <2 5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3> 2 <5 3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 5 <3 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5> 3 <13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5 3> 13 <14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5 3 13> 14 <15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5 3> 15 <7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 5> 6 <5 7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 7 <3 5 7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7> 3 <5 7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3> 5 <7 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 5> 7 <15 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 5 7> 15 <16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 5> 10 <5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3> 7 <5 5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7> 5 <5 16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5> 5 <16 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5 5> 16 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5> 7 <8 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5 7> 8 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7 5> 9 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3 7> 8 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7 3> 9 <4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2 7> 6 <3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 2> 9 <3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3> 5 <3 3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5> 3 <3 3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3> 3 <3 4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3> 3 <4 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 3> 4 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3> 5 <2 3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5> 2 <3 4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2> 3 <4 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 3> 4 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2> 5 <2 17 17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 5> 2 <17 18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2> 17 <18 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2 17> 18 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2> 19 <9 19 20 20 22 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2 19> 9 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 5 2> 22 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 5> 4 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5> 7 <2 11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7> 2 <11 3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2> 11 <3 19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 11> 3 <19 20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 11 3> 19 <20 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11 3 19> 20 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 11 3> 21 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 11> 6 <7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2> 13 <3 7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 13> 3 <7 10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13 3> 7 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13 3 7> 10 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2 13 3> 9 <5 21 22 23 23 25 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13> 6 <3 5 21 22 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 2> 15 <3 3 5 21 22 23 23 25 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7> 5 <5 3 3 5 21 22 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5> 5 <3 3 5 21 22 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5> 3 <3 5 21 22 23 23 25 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3> 3 <5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 3> 5 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 3 5> 21 <22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 3> 8 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3> 5 <4 7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 5> 4 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 3> 7 <2 7 22 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 7> 2 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 2> 7 <22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 2 7> 22 <23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 2> 9 <11 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7> 5 <3 11 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5> 3 <11 ​​23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5 3> 11 <23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5 3 11> 23 <24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 7 5 3 11 23> 24 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 7 5 3 11> 25 <12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 7 5 3> 16 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5> 5 <8 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5 5> 8 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5> 7 <4 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3 7 5 7> 4 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7 5> 9 <2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5 3 7> 8 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 5 3> 9 <4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 5 5> 6 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5> 7 <3 3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7> 3 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3> 3 <4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 3> 4 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3> 5 <2 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5> 2 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2> 3 <2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3> 2 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 2> 5 <12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 2 5> 12 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 2> 7 <6 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 2 7> 6 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 2> 9 <3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3> 5 <3 3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 5> 3 <3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 5 3> 3 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 5 3 3> 25 <26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 5 3> 8 <5 26
   2 5 5 5 3 3 2 3 5 3 3 5 5 7 7 5 7 3 5 2 3 5> 5 <4 5 26
— Jeppe Stig Nielsen
source
2

Mathematica, 118 103 octets

(s=Range[2,5^6];t=1;Do[If[PrimeQ@s[[t]],t++,s[[t]]/=(k=#2&@@ Divisors@s[[t]]);s[[t-1]]+=k;t--],#];t-1)&


Essayez-le en ligne!

Martin Ender a enregistré 15 octets

— J42161217
source
Vous avez un espace perdu devant Divisors, vous pouvez utiliser la notation infixe pour Doet vous pouvez simplement retourner à la tplace de t-1(résultat basé sur 1).
— Martin Ender
2

Python 3 , 158 149 133 octets

Il s’agit d’une implémentation procédurale simple avec un ou deux défauts pour s’assurer que le code fonctionne pour tous les cas de test. Je l' utilise [*range(2,n+9)]pour faire en sorte que A est assez grand (sauf n<3, n+9est plus que suffisant). La elseclause divise l'ancien A[p]par d, décrémente p, puis ajoute dau nouveau A[p], ce qui est définitivement une mauvaise pratique de codage. Sinon, assez simple. Suggestions de golf bienvenues!

Edit: -9 octets sans sympymerci à Halvard Hummel. -14 octets de Felipe Nardi Batista, -6 octets de quelques signaux de la réponse de Jonathan Frech à Python 2

p,_,*A=range(int(input())+2)
for _ in A:
 m=A[p];d=min(k for k in range(2,m+1)if m%k<1);p+=1
 if d<m:A[p-1]//=d;p-=2;A[p]+=d
print(p)

Essayez-le en ligne!

— Sherlock9
source
— Halvard Hummel
148 octets en en faisant un programme complet
— Felipe Nardi Batista
if d-m:A[p]...et else:p+=1pour sauver un octet
— Felipe Nardi Batista
143 octets en supprimant la elsedéclaration
— Felipe Nardi Batista
après suppression de la elsedéclaration, il n'y a plus de différence en octets avec la version de la fonction
— Felipe Nardi Batista
2

PHP, 102 + 1 octets

for($a=range(2,$argn);$argn--;$d<$a[+$p]?$a[$p--]/=$d+!$a[$p]+=$d:$p++)for($d=1;$a[+$p]%++$d;);echo$p;

Exécuter en pipe -Rou essayer en ligne .

Sortie vide pour l'entrée 0; insérer +après echopour un littéral0

ou utilisez cette version à 1 index (103 + 1 octets):

for($a=range($p=1,$argn);$argn--;$d<$a[$p]?$a[$p--]/=$d+!$a[$p]+=$d:$p++)for($d=1;$a[$p]%++$d;);echo$p;
— Titus
source
2

R , 123 octets

Une implémentation simple. Il est fourni sous forme de fonction qui prend en entrée le nombre de coups et renvoie la position p.

Il boucle sur la séquence et déplace le pointeur d'avant en arrière selon les règles. La sortie est basée sur 0.

Remarque: afin de trouver le plus petit facteur premier d'un nombre x, il calcule le module de x par rapport à tous les entiers compris entre 0 et x. Il extrait ensuite les nombres de module égal à 0, toujours [0,1, ..., x]. Si le troisième nombre n'est pas x, il s'agit du plus petit facteur premier de x.

p=function(l){w=0:l;v=w+1;j=1;for(i in w){y=v[j];x=w[!y%%w][3]
if(x%in%c(NA,y))j=j+1
else{v[j]=y/x;j=j-1;v[j]=v[j]+x}}
j-2}

Essayez-le en ligne!

— NofP
source
2

C (gcc), 152 148 octets

Minified

int f(int n){int*A=malloc(++n*4),p=0,i,q;for(i=0;i<n;i++)A[i]=i+2;for(i=1;i<n;i++){for(q=2;A[p]%q;q++);if(A[p++]>q){A[--p]/=q;A[--p]+=q;}}return p;}

Formé avec quelques commentaires

int f(int n) {
  int *A = malloc(++n * 4), p = 0, i, q;
  // Initialize array A
  for (i = 0; i < n; i++)
    A[i] = i + 2;
  // Do n step (remember n was incremented)
  for (i = 1; i < n; i++) {
    // Find smallest divisor
    for (q = 2; A[p] % q; q++)
      ;
    if (A[p++] > q) {
      A[--p] /= q;
      A[--p] += q;
    }
  }
  return p;
}

Fonction principale pour les tests

#include <stdlib.h>
#include <stdio.h>
int main(int argc, char **argv) {
  if (argc != 2)
    return 2;
  int n = atoi(argv[1]);
  int p = f(n);
  printf("%d => %d\n", n, p);
  return 0;
}

Pour montrer chaque étape

  1. Déclarez display () dans f ()

    int f(int n) {
  int *A = malloc(++n * 4), p = 0, i, q;
  void display(void) {
    for (int i=0; i < p; i++) {
      printf(" %d", A[i]);
    }
    printf(" \033[1;31m%d\033[m", A[p]);
    if (p+1 < n)
      printf(" %d", A[p+1]);
    printf("\n");
  }
  ...

  2. Afficheur ()

      A[i] = i + 2;
display();

  3. Afficheur ()

      }
  display();
}
— utilisateur285259
source
Vous pouvez supprimer quelques octets en déclarant A comme un tableau et en initialisant vos contrôles de boucle avant les boucles, si possible, n'est-ce pas?
— Réintégrer Monica le
1

Clojure, 185 octets

#(loop[[n p][(vec(range 2 1e3))0]i %](if(= i 0)p(recur(if-let[q(first(for[i(range 2(n p)):when(=(mod(n p)i)0)]i))][(assoc n p(/(n p)q)(dec p)(+(n(dec p))q))(dec p)][n(inc p)])(dec i))))

Aïe, éditer un "état" n'est pas idéal dans Clojure. Vous devrez augmenter l'exposant pour des entrées plus importantes.

— NikoNyrh
source
Pourquoi avez-vous utilisé la correspondance de motif dans le loopfichier? Vous devriez pouvoir perdre quelques octets sans cela.
— Clismique
En outre, vous pourriez être en mesure de changer la firstchose en une somedéclaration.
— Clismique
Sans correspondance de motif, je devais répéter recurdeux fois, une pour chaque if-letbranche. Aussi (dec i)serait dupliqué. somebesoin d’un prédicat, je pourrais utiliser +car nous avons affaire à des nombres mais c’est un caractère plus long que first. CMIIW
— NikoNyrh
1

Java 8, 138 135 octets

n->{int a[]=new int[++n],s=0,p=0,j=0;for(;j<n;a[j++]=j+1);for(;++s<n;p++)for(j=1;++j<a[p];)if(a[p]%j<1){a[p--]/=j;a[p--]+=j;}return p;}

Explication:

Essayez ici.

n->{                     // Method with integer as both parameter and return-type
  int a[]=new int[++n],  //  Integer-array with a length of `n+1`
      s=0,               //  Steps-counter (starting at 0)
      p=0,               //  Current position (starting at 0)
      j=0;               //  Index integer (starting at 0)
  for(;j<n;              //  Loop (1) from 0 to the input (inclusive due to `++n` above)
    a[j++]=j+1           //   And fill the array with 2 through `n+2`
  );                     //  End of loop (1)
  for(;++s<n;            //  Loop (2) `n` amount of steps:
      p++)               //    And after every iteration: increase position `p` by 1
    for(j=1;             //   Reset `j` to 1
        ++j<a[p];)       //   Inner loop (3) from 2 to `a[p]` (the current item)
      if(a[p]%j<1){      //    If the current item is divisible by `j`:
        a[p--]/=j;       //     Divide the current item by `j`
        a[p--]+=j;}      //     And increase the previous item by `j`
                         //     And set position `p` two steps back (with both `p--`)
                         //   End of inner loop (3) (implicit / single-line body)
                         //  End of loop (2) (implicit / single-line body)
  return p;              //  Return the resulting position `p`
}                        // End of method
— Kevin Cruijssen
source
1

Clojure, 198 193 191 octets

Cela doit être sévèrement joué au golf ...

#(loop[i(vec(range 2(+ % 9)))c 0 p 0](if(= % c)p(let[d(dec p)u(i p)f(some(fn[n](if(=(mod u n)0)n))(range 2(inc u)))e(= u f)](recur(if e i(assoc i d(+(i d)f)p(/ u f)))(inc c)(if e(inc p)d)))))

Golf 1 : 5 octets enregistrés en changeant (first(filter ...))de(some ...)

Golf 2 : 2 octets enregistrés en changeant (zero? ...)de(= ... 0)

Usage:

(#(...) 10000) => 512

Code non golfé:

(defn prime-ant [n]
  (loop [counter 0
         pos 0
         items (vec (range 2 (+ n 9)))]
    (if (= n counter) pos
      (let [cur-item (nth items pos)
            prime-factor
            (some #(if (zero? (mod cur-item %)) %)
              (range 2 (inc cur-item)))
            equals? (= cur-item prime-factor)]
        (recur
          (inc counter)
          (if equals? (inc pos) (dec pos))
          (if equals? items
            (assoc items
              (dec pos) (+ (items (dec pos)) prime-factor)
              pos (/ cur-item prime-factor))))))))
— clismique
source
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.