50

"Asal karınca", tam sayılar arasında dolaşan ve yalnızca bir tane kalan primerler olana kadar onları bölen obstinat bir hayvandır!

Başlangıçta,>> 2 tam sayılarını içeren sonsuz bir A dizisine sahibiz: [2,3,4,5,6,.. ]

pDizideki karınca pozisyonu olsun . Başlangıçta, p = 0(dizi 0 dizinli)

Her turda, karınca aşağıdaki gibi hareket eder:

eğer A[p]asal sonraki pozisyona karınca hamle:p ← p+1
eğer başka, A[p]kompozit sayıdır, let qBiz bölmek daha küçük bölen> 1. olmak A[p]tarafından qve biz eklemek qiçin A[p-1]. Karınca önceki pozisyonuna hareket eder:p ← p-1

İşte karınca için ilk hamle:

 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  ... 
          ^

Programınız nhamlelerin ardından karınca pozisyonunu vermeli (varsayabilirsin n <= 10000)

Test durumları:

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

Düzenle. 1 indeksli listeleri de kullanabilirsiniz, yukarıdaki test durumu için 1, 7, 10, 275, 513 sonuçlarının gösterilmesi kabul edilebilir.

Bu kod-golf, yani bayt cinsinden en kısa kod olan kod kazanır.

code-golf sequence primes

— Arnaud
kaynak

32

Dürüst olmak gerekirse, bunu Sıcak Ağ Soruları'nda gördüğümde ekranımda bir karınca olduğunu düşündüm.

— Kodos Johnson,

14

Dizinin keyfi büyüklükte iyi tanımlanıp tanımlanmadığını merak ediyorum n(veya kompozit durumun karıncaları başlangıçtaki sola itebilir mi 2).

— Martin Ender

1

@ SuperChafouin böylece test vakalarının çıktıları olabilir: 1,7,10,275,5131-indexing belirtilmişse? Yoksa yine de çıktılarına uymaları gerekecek.

— Tom Carpenter,

12

@MartinEnder Bir başka açık soru, 7'den büyük bir maddenin eninde sonunda geride bırakılıp bırakılamayacağıdır.

— Arnauld

2

@N = 1.000.000.000 (burada p = 17156661), n ve p arasındaki ilişki p = n / (ln (n) * ln (ln (n)) 'e çok yakındır.

— Penguino

11

Alice , 45 bayt

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

Çevrimiçi deneyin!

Çoğunlukla basit uygulama.

nAlice'teki ilmek süreleri tipik olarak bir geri adres adresi n-1sürmek, ardından her yinelemenin sonunda geri dönmek suretiyle yapılır k. Döngü boyunca son kez, kkomutun geri döneceği hiçbir yeri yoktur ve yürütme ilerler.

Bu program k, sayı asal olduğunda erken durmak için aynı komutu kullanır . Sonuç olarak, son yineleme her zaman karınca sola hareket edecektir. Bu hatayı telafi etmek için n+1, tam olarak istediğimiz sonucu veren (ve vakayı n=0ücretsiz olarak veren) 1 indeksli bir dizide yinelemeler yapıyoruz .

— Nitrodon
kaynak

7

Python 2 , 120 bayt

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

Çevrimiçi deneyin!

Ah, nadir for- elsedöngü! elseEğer Madde sadece yürütür forbedeni olmayan üzerinden kapatılmalıdır break. Bizim durumumuzda bu, qs nin hepsini kontrol ettik ve bölünecek hiçbirisini bulamadığımız anlamına gelir p.

— Lynn
kaynak

7

Octave , 109 103 101 94 bayt

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

Çevrimiçi deneyin!

Bu kod pozisyonu 1 indekslemede gösterecektir, bu nedenle test durumları için çıktılar:

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

Bu sürüm bazı Octave optimizasyonlarını kullanıyor, bu yüzden MATLAB ile uyumlu değil. Aşağıdaki kod MATLAB uyumlu bir versiyondur.

MATLAB, 130 123 118 117 bayt

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

Octave versiyonunda olduğu gibi 1 indekslemeyi kullanır. MATLAB’daki tüm test vakalarına karşı test ettim. Örnek olarak 100000'deki çıktı 3675'tir (bir indeksleme).

Yukarıdaki kodun yorumlanmış bir sürümü:

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

İlgi konusu olarak, bu, karınca konumlarının n'nin ilk 10000 değeri için yineleme sayısına karşı sayılarıdır.

Karınca muhtemelen sonsuz olmaya meyilli görünüyor, ama kim bilir, aldatıcı olabilir.

MATLAB: Köşeli parantezler foryerine 6 byte'lık tasarruf sağlandıwhileif
MATLAB: 2 bayt kaydet - Teşekkürler @Sanchises
Octave: Octave \=ve +=işlemleri kullanarak 10 bayt kazanın - Thanks @Giuseppe
Octave: i++ve ile 2 bayt kazanın i--- Thanks @LuisMendo
Octave: 7 byte tasarruf edin - Thanks @Sanchises

— Tom Carpenter
kaynak

TIO'da çalışmasını sağlamak endiçin, işlev imzasına uymanız gerektiğini düşünüyorum

— Giuseppe

@Giuseppe Ah, tamam. MATLAB'da takip endisteğe bağlıdır.

— Tom Carpenter,

Eğer ben bir (n) = başlangıcında @ (n) kullanılarak yerine işlevini kullanarak anonim işlev yapabilir

— Michthan

@Michthan bunu MATLAB'da yapamaz. Octave'da döngüleri olduğu gibi mümkün olduğunu sanmıyorum.

— Tom Carpenter,

1

Sondaki endçok Octave isteğe bağlıdır. Burada sadece ihtiyaç var çünkü fonksiyondan sonra kodunuz var

— Luis Mendo

6

JavaScript (ES6), 91 bayt

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

gösteri

Not: Tüm test durumlarını geçmesi için motorunuzun varsayılan yığın boyutunu arttırmanız gerekebilir.

Çevrimiçi deneyin!

— Arnauld
kaynak

6

Haskell , 108 106 94 bayt

([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

Çevrimiçi deneyin! Örnek kullanım: ([0]#[2..]!!) 10verimler 6(0 indeksli).

İşlev #, dizinin ters çevrilmiş ön tarafı [p-1, p-2, ..., 1]ve dizinin sonsuz kalan kısmı olmak üzere iki listede çalışır [p, p+1, p+2, ...]. nBir girdi verildiğinde , inci konumunun döndürüldüğü sonsuz bir konum listesi oluşturur n.

Desen , karıncanın mevcut pozisyonunun değerine ve önceki pozisyonun a değerine ((a:b)#(p:q))bağlanır . dizinin 1'den pozisyona kadar olan ve pozisyondan başlayarak sonsuz kalan önek .pabp-2qp+1

Aşağıdaki şekilde yinelemeli aramalar listesini oluşturmak: Her bölen bakmak darasında p(bir daha büyük ve daha küçük olan partan sırayla ve ekleme) b#(a+d:div p d:q)her biri için, bu akım değeri pbölünür dve karınca hamle sola bir adım deklenir a. Daha sonra (p:a:b)#qbu listenin sonuna ekleriz ; bu, karıncanın bir adım sağa hareket ettiğini gösterir.

Ardından listeden bu özyinelemeli aramalardan ilki alırız ve önek listesinin uzunluğuna denk gelen mevcut pozisyonu hazırlarız b. Bölenler artan sırada olduğundan, özyinelemeli çağrılar listesinden ilkini seçmek en küçüğümüzü kullanmamızı sağlar. Ek olarak, (p:a:b)#qlistenin sonuna eklendiğinden, yalnızca bölenler yoksa ve pdolayısıyla birinci sınıfsa seçilir .

Düzenlemeler:
-2 bayt, işlev listesini azalandan artan düzeye değiştirerek.
-12 bayt Zgarb'ın sayaç kullanmak yerine sonsuz bir listeye endeksleme ve 0-endekslemeye geçme fikri sayesinde.

— Laikoni
kaynak

2

Tezgahın etrafını taşımak yerine sonsuz bir liste oluşturarak ve dizin oluşturarak 96 bayt .

— Zgarb

1

@Zgarb Çok teşekkürler! 0 indekslemeye geçerken sadece 94 bayt bile.

— Laikoni

5

TI-BASIC, 108 103 102 98 bayt

Giriş ve çıkış içinde saklanır Ans. Çıktı 1 dizinli.

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
kaynak

Sen kapalı bir bayt alabilir fPart(∟A(P)/F:ile fPart(F¹∟A(P:. Bir sonraki satırda aynı şey.

— Scott Milner

@ScottMilner Bu her zaman işe yaramaz. not(fPart(7⁻¹70'dır, ancak not(fPart(7/71'dir

— kamoroso94

5

MATL , 41 bayt

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

Çıktı 1 tabanlıdır. Program çevrimiçi tercümandaki son test durumu için zaman aşımına uğradı.

Çevrimiçi deneyin!

açıklama

Program mücadelede anlatılan prosedürü uygular. Bunu yapmak için, MATL'nin manuel ve otomatik panolarını alışılmadık derecede ağır kullanıyor.

En küçük bölen, ana faktör ayrışmasına ilk giriş olarak elde edilir.

"Divide" güncellemesi, A dizisinin ilgili girişinin üzerine yazılarak yapılır . "Ekle" güncellemesi, A'ya istenen konum dışında sıfır içeren bir dizi ekleyerek, öğe şeklinde yapılır .

: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
kaynak

3

Pyth - 44 bayt

Basit prosedürel uygulama.

K}2hhQVQJ@KZIP_J=hZ).?=GhPJ XKZ/JG=tZ XZKG;Z

Test Takımı .

— Maltysen
kaynak

3

PARI / GP, 87 bayt

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

Oldukça kendini açıklayıcı (çok golf-ish değil). Parçayı saymazsanız f(n)=, bu 82 bayttır. Ayrıca n->(85 bayt) ile başlayabilirsiniz .

Bu 1 indeksli bir dildir.

Düzenleme: Değişiklik 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++)), karıncanın yürüyüşünün bir resmini (yeterince geniş bir terminal verildiğinde) basacaktır. Örneğin illustrate(150,25), 25 sütuna ilk 150 adımı verecek, şunun gibi:

  > 2 <3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2> 3 <4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 3> 4 <5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2> 5 <2 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5> 2 <5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2> 5 <6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 5> 6 <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> 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 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26
   2 5 2 7> 6 <3 4 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 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 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 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> 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 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 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 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 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 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 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 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 2 5> 4 <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 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 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 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 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 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 2 7 2 11 3> 21 <10 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 11> 6 <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 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 2 7 2 13 3> 9 <5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2 13> 6 <3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 2> 15 <3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7> 5 <5 3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5> 5 <3 3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5> 3 <3 5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 3 <5 21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 3> 5 <21 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 3 5> 21 <22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 3> 8 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 5 <4 7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 5> 4 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 7 <2 7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7> 2 <7 22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 2> 7 <22 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 2 7> 22 <23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 2> 9 <11 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7> 5 <3 11 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 3 <11 23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3> 11 <23 24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3 11> 23 <24 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3 11 23> 24 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3 11> 25 <12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 3> 16 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 5 <8 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 5> 8 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 7 <4 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5 7> 4 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7 5> 9 <2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3 7> 8 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5 3> 9 <4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 5> 6 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5> 7 <3 3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7> 3 <3 4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3> 3 <4 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 3> 4 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3> 5 <2 3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5> 2 <3 2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2> 3 <2 5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3> 2 <5 12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2> 5 <12 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2 5> 12 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2> 7 <6 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2 7> 6 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 2> 9 <3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3> 5 <3 3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5> 3 <3 25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5 3> 3 <25 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5 3 3> 25 <26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5 3> 8 <5 26
   2 5 5 5 3 3 2 3 5 3 3 5 2 7 5 7 3 5 2 3 5> 5 <4 5 26

— Jeppe Stig Nielsen
kaynak

2

Python 2 , 142 127 bayt

Sherlock9 sayesinde on beş bayt kurtarıldı .

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

Çevrimiçi deneyin!

— Jonathan Frech
kaynak

Kullanmazsanız 127 baytP(n)

— Sherlock9

126 bayt

— Felipe Nardi Batista

@FelipeNardiBatista Ne yazık ki, öneriniz test durumları için uygun görünmüyorn<=4

— Sherlock9

2

Mathematica, 118 103 bayt

(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)&

Çevrimiçi deneyin!

Martin Ender 15 bayt kurtardı

— J42161217
kaynak

Önünde başıboş bir Divisorsyeriniz vardı, bunun için infix notasyonu kullanabilirsiniz Dove (1-sonuç) tyerine sadece geri dönebilirsiniz t-1.

— Martin Ender

2

Python 3 , 158 149 133 bayt

Bu, kodun tüm test durumları için çalıştığından emin olmak için bir veya iki tuhaflık içeren basit bir prosedür uygulamasıdır. Kullandığım [*range(2,n+9)](haricinde bir büyüklükte olduğundan emin olmak için n<3, n+9fazlasıyla yeterli). elseFıkra eski böler A[p]tarafından dazaltmakta pve ardından ekler dyeniye A[p]kesinlikle kötü kodlama uygulaması olan. Aksi takdirde, oldukça basit. Golf önerileri hoş geldiniz!

Düzenleme: -9 byte olmadan sympyHalvard Hummel. Felipe Nardi Batista'dan -14 bayt, Jonathan Frech'in Python 2 cevabından bazı ipuçlarından -6 bayt

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)

Çevrimiçi deneyin!

— Sherlock9
kaynak

145 bayt

— Halvard Hummel

148 bayt tam bir program haline getirerek

— Felipe Nardi Batista

if d-m:A[p]...ve else:p+=1bir bayt kurtarmak için

— Felipe Nardi Batista

143 bayt kaldırarak elseaçıklama

— Felipe Nardi Batista

elseifadeyi kaldırdıktan sonra , işlev sürümünde bayt olarak bir fark yoktur

— Felipe Nardi Batista

2

PHP, 102 + 1 bayt

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

Pipe ile çalıştırın -Rveya çevrimiçi deneyin .

Giriş için boş çıktı 0; insert +sonra echobir hazır için0

veya bu 1 indeksli versiyonu kullanın (103 + 1 bayt):

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
kaynak

2

R , 123 bayt

Basit bir uygulama. Hareket sayısını giriş olarak alan ve p konumunu veren bir fonksiyon olarak sağlanır.

Dizinin üzerine dolanır ve işaretçiyi kurallara göre ileri ve geri hareket ettirir. Çıktı 0 tabanlıdır.

Bir not: x sayısının en küçük asal çarpanını bulmak için, 0 ile x arasındaki tüm tamsayılara göre x modülünü hesaplar. Daha sonra, her zaman [0,1, ..., x] olan, 0'a eşit olan modül sayıları çıkarır. Eğer bu tür üçüncü sayı x değilse, o zaman x'in en küçük asal çarpanıdır.

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}

Çevrimiçi deneyin!

— NofP
kaynak

2

C (gcc), 152 148 bayt

küçültülmüş

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;}

Bazı yorumlar ile oluşturulmuş

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;
}

Test için ana işlev

#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;
}

Her adımı göstermek için

Ekranı () f () içinde bildir

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");
  }
  ...

Çağrı ekranı()
```
  A[i] = i + 2;
display();
```
Çağrı ekranı()
```
  }
  display();
}
```

— user285259
kaynak

A'yı bir dizi olarak bildirerek ve döngü kontrollerinizi mümkün olduğunda döngülerden önce başlatarak düzeltebilirsiniz , değil mi?

— Monica'yı

1

Clojure, 185 bayt

#(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))))

Ah, "devlet" düzenleme Clojure'de ideal değildir. Daha büyük girdiler için üssü arttırmanız gerekir.

— NikoNyrh
kaynak

Neden desen eşleştirmeyi kullandınız loop? Bu olmadan birkaç byte kaybedebilmelisiniz.

— clismique

Ayrıca, firstşeyi bir somecümleyle değiştirebilirsin.

— clismique

Desen eşleştirmesi olmadan recur, her if-letdal için bir kere olmak üzere iki kez tekrarlamak zorunda kaldım . Ayrıca (dec i)çoğaltılabilir. someBir tahmine ihtiyacı var, +sayılarla uğraşırken kullanabileceğim bir şey ama bu daha uzun bir karakter first. CMIIW

— NikoNyrh

1

Java 8, 138 135 bayt

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;}

Açıklama:

Burada dene.

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
kaynak

1

Clojure, 198 193 191 bayt

Bu ciddi bir şekilde golf oynamalı ...

#(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 : değiştirerek 5 bayt Kaydedilen (first(filter ...))için(some ...)

Golf 2 : değiştirerek 2 bayt Kaydedilen (zero? ...)için(= ... 0)

Kullanımı:

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

Ungolfed kod:

(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
kaynak