50

"Простий мурашник" - це вперта тварина, яка орієнтується цілими числами та ділить їх, поки не залишиться лише праймес!

Спочатку ми маємо нескінченний масив A, що містить усі цілі числа> = 2: [2,3,4,5,6,.. ]

Нехай pбуде положення мурашки на масиві. Спочатку,p = 0 (масив 0-індексується)

Кожного повороту мураха рухатиметься наступним чином:

якщо A[p]прайм, мураха переходить у наступне положення:p ← p+1
інакше, якщо A[p]це складене число, нехай qбуде його меншим дільником> 1. Ділимо A[p]на q, і додаємо qдо A[p-1]. Мураха рухається до попереднього положення:p ← p-1

Ось перші кроки для мурашки:

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

Ваша програма повинна виводити положення мурашки після nрухів. (можна припустити n <= 10000)

Тестові приклади:

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

Редагувати. ви також можете використовувати 1-індексовані списки, прийнятно відображати результати 1, 7, 10, 275, 513 для вищевказаного тестового випадку.

Це код-гольф, тому виграє код з найкоротшим кодом у байтах.

code-golf sequence primes

— Арно
джерело

32

Я чесно подумав, що на моєму екрані з’явився мураш, коли побачив це у «Гарячих запитаннях до мережі».

— Кодос Джонсон

14

Цікаво, чи чітко визначена послідовність для довільно великої кількості n(чи може складений випадок коли-небудь відсунути мураш ліворуч від початкової 2).

— Мартін Ендер

1

@SuperChafouin, то виходи для тестових випадків можуть бути: 1,7,10,275,513якщо вказано 1-індексування? Або вони все ще повинні відповідати вашим результатам.

— Том Карпентер

12

@MartinEnder Іншим відкритим питанням є те, чи може прем'єр> 7 врешті-решт залишитися назавжди

— Арнольд

2

@Arnauld Наскільки рухається n = 1 000 000 000 (де p = 17156661), зв'язок між n і p дуже близький до p = n / (ln (n) * ln (ln (n))).

— Penguino

11

Аліса , 45 байт

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

Спробуйте в Інтернеті!

Переважно просто реалізація.

nЧаси циклічного циклу в Алісі зазвичай проводяться шляхом натискання n-1разів на зворотну адресу , а потім повернення в кінці кожної ітерації k. В останній раз через цикл kінструкція нікуди повертатися, і виконання триває вперед.

Ця програма використовує ту саму kінструкцію, щоб зупинитися рано, коли число просте. Як результат, остаточна ітерація завжди перемістить мурашник вліво. Щоб компенсувати цю помилку, ми робимо n+1ітерації на 1-індексованому масиві, який дає саме той результат, який ми хочемо (і надає справу n=0безкоштовно).

— Нітродон
джерело

7

Python 2 , 120 байт

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

Спробуйте в Інтернеті!

Ах, рідкісна for- elseпетля! elseУмова виконується тільки в тому випадку , якщо forтіло НЕ виходили через break. У нашому випадку це означає, що ми перевірили всі qs та не знайшли жодного з них для поділу p.

— Лінн
джерело

7

Октава , 109 103 101 94 байт

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

Спробуйте в Інтернеті!

Цей код виводить позицію в 1-індексації, тож виведеннями для тестових випадків є:

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

Ця версія використовує деякі оптимізації Octave, тому не сумісна з MATLAB. Код нижче - версія, сумісна з MATLAB.

MATLAB, 130 123 118 117 байт

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

Використовується 1-індексація, як і у версії Octave. Я перевірив його на всіх тестових випадках у MATLAB. Як приклад, вихід на 100000 становить 3675 (одноіндексація).

Коментована версія вищевказаного коду:

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

Цікаво, що це положення мурашок проти кількості ітерацій перших 10000 значень n.

Здається, що мураха, ймовірно, буде схильний до нескінченності, але хто знає, погляд може обманювати.

MATLAB: Збережено 6 байт із forзамість whileта видалення дужок із if- Дякую @Giuseppe
MATLAB: Збережіть 2 байти - Дякую @Sanchises
Octave: збережіть 10 байт за допомогою Octave \=та+= операцій - Дякую @Giuseppe
Октава: Збережіть 2 байти за допомогою i++і i--- Дякую @LuisMendo
Октава: Збережіть 7 байт - спасибі @Sanchises

— Том Карпентер
джерело

Щоб змусити його працювати над TIO, я думаю, вам потрібно endвідповідати підпису функції

— Джузеппе

@Giuseppe Ага, гаразд. У MATLAB трейлінг endнеобов’язковий.

— Том Карпентер

ви можете зробити анонімну функцію, використовуючи @ (n) на початку, замість того, щоб використовувати функцію i = a (n)

— Міхтан

@Michthan не може цього зробити в MATLAB. Я не думаю, що це можливо і в Octave, оскільки він має петлі?

— Том Карпентер

1

Запис не endє обов'язковим і для Octave. Тут він потрібен лише тому, що ви маєте код після функції

— Луїс Мендо

6

JavaScript (ES6), 91 байт

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

Демо

Примітка. Можливо, вам доведеться збільшити розмір стека за замовчуванням вашого двигуна, щоб він міг пройти всі тестові випадки.

Спробуйте в Інтернеті!

— Арнольд
джерело

6

Haskell , 108 106 94 байт

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

Спробуйте в Інтернеті! Приклад використання: ([0]#[2..]!!) 10врожайність 6(0-індексується).

Функція #працює за двома списками, переверненою передньою частиною масиву [p-1, p-2, ..., 1]та нескінченною рештою масиву [p, p+1, p+2, ...]. Він будує нескінченний перелік позицій, з яких nповертається перша позиція, отримуючи вхід n.

Візерунок ((a:b)#(p:q))пов'язується pзі значенням поточного положення мурашки і aзі значенням попереднього положення. bце префікс масиву від позиції 1 до p-2і qнескінченного спокою , починаючи з позиції p+1.

Побудуємо список рекурсивних викликів наступним чином: Ми розглянемо кожен дільник dз p(який більше одиниці і менше p) в порядку зростання і додати b#(a+d:div p d:q)для кожного з них, тобто поточне значення pділиться dі мураха рухається один крок зліва, куди dдодано a. Потім ми додаємо (p:a:b)#qдо кінця цього списку, який вказує, що мураха рухається на один крок вправо.

Потім ми приймаємо перший із цих рекурсивних дзвінків зі списку і додаємо поточну позицію, яка збігається з довжиною списку префіксів b. Оскільки дільники перебувають у порядку зростання, вибір першого зі списку рекурсивних викликів гарантує, що ми використовуємо найменший. Крім того, оскільки (p:a:b)#qвін додається до кінця списку, він вибирається лише у тому випадку, якщо дільників немає, і pтаким чином є простим.

Редагування:
-2 байти шляхом переключення списку функцій від спадання до порядку зростання.
-12 байт завдяки ідеї Згарба індексувати у нескінченний список замість обробки лічильника та переходу на 0-індексацію.

— Лайконі
джерело

2

96 байт , будуючи нескінченний список і індексуючи замість того, щоб переносити лічильник.

— Згарб

1

@Zgarb Дякую велике! Це навіть 94 байти при переході на 0-індексацію.

— Лайконі

5

TI-BASIC, 108 103 102 98 байт

Вхід і вихід зберігаються в Ans. Вихід 1-індексований.

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

— каморосо94
джерело

Ви можете зняти байт fPart(∟A(P)/F:з fPart(F¹∟A(P:. Те саме в наступному рядку.

— Скотт Мілнер

@ScottMilner Це не завжди працює. not(fPart(7⁻¹7є 0, але not(fPart(7/7є 1.

— kamoroso94

5

MATL , 41 байт

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

Результат 1-базований. Програма вичерпується для останнього тестового випадку в онлайн-перекладачі.

Спробуйте в Інтернеті!

Пояснення

Програма застосовує процедуру, описану в виклику. Для цього він користується незвичайно великим використанням посібників та автоматичних буферів MATL.

Найменший дільник отримується як перший запис при розкладі основного фактора.

«Розрив» оновлення виконується шляхом перезапису відповідного запису з масиву A . Оновлення "додати" проводиться шляхом додавання до A масиву, що містить нулі, за винятком потрібного положення.

: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

— Луїс Мендо
джерело

3

Pyth - 44 байти

Безпосередня процедурна реалізація.

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

Тестовий сюїт .

— Малтісен
джерело

3

PARI / GP, 87 байт

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

Досить зрозуміла (не така вже й гольф-іш). Якщо ви не рахуєте f(n)=частини, це 82 байти. Ви також можете почати з n->(85 байт).

Це 1-індексована мова.

Редагувати: Модифікація 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++))надрукує ілюстрацію прогулянки мурашок (надається достатньо широкий термінал). Наприклад illustrate(150,25), наведемо перші 150 кроків на 25 стовпцях, як це:

  > 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

— Джеппе Стіг Нільсен
джерело

2

Python 2 , 142 127 байт

Збережено п'ятнадцять байтів завдяки Sherlock9 .

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

Спробуйте в Інтернеті!

— Джонатан Фрех
джерело

127 байт, якщо ви не використовуєтеP(n)

— Sherlock9

126 байт

— Феліпе Нарді Батіста

@FelipeNardiBatista На жаль, ваша пропозиція, здається, не працює в тестових випадкахn<=4

— Sherlock9

2

Математика, 118 103 байт

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

Спробуйте в Інтернеті!

Мартін Ендер врятував 15 байт

— J42161217
джерело

Перед Divisorsвами заблокований простір , ви можете використовувати позначення інфіксації Do, а ви можете просто повернутися tзамість t-1(результат на основі 1).

— Мартін Ендер

2

Python 3 , 158 149 133 байт

Це проста процедурна реалізація з однією або двома химерностями, щоб переконатися, що код працює для всіх тестових випадків. Я використовую [*range(2,n+9)]для того, щоб А був достатньо великим (крім n<3, n+9більш ніж достатнього). elseПоложення ділить старий A[p]на d, декремент p, а потім додає dдо новогоA[p] , яка, безумовно , погана практика кодування. Інакше досить прямо. Пропозиції з гольфу вітаються!

Редагувати: -9 байтів без sympyвдячності від Halvard Hummel. -14 байт від Феліпе Нарді Батіста, -6 байтів із сигналу відповіді Джонатана Фреха з 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)

Спробуйте в Інтернеті!

— Шерлок9
джерело

145 байт

— Халвард Гуммель

148 байт , перетворивши його на повну програму

— Феліпе Нарді Батіста

if d-m:A[p]...і else:p+=1зберегти байт

— Феліпе Нарді Батіста

143 байти , видаливши elseвислів

— Феліпе Нарді Батіста

після вилучення elseоператора немає різниці в байтах до версії функції

— Felipe Nardi Batista

2

PHP, 102 + 1 байт

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

Запустіть як трубу -Rабо спробуйте в Інтернеті .

Порожній вихід для введення 0; вставити +після echoдля буквального0

або використовувати цю 1-індексовану версію (103 + 1 байт):

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;

— Тіт
джерело

2

R , 123 байт

Відверта реалізація. Він надається як функція, яка приймає кількість рухів як вхід і повертає позицію p.

Він перетинає послідовність і переміщує вказівник вперед і назад відповідно до правил. Вихід заснований на 0.

Примітка: щоб знайти найменший простий множник числа x, він обчислює модуль x відносно всіх цілих чисел від 0 до x. Потім він витягує числа з модулем, рівним 0, які завжди [0,1, ..., x]. Якщо третє таке число не x, то це найменший простий коефіцієнт 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}

Спробуйте в Інтернеті!

— NofP
джерело

2

C (gcc), 152 148 байт

Укорочений

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

Сформовано з деякими коментарями

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

Основна функція тестування

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

Для показу кожного кроку

Оголосити показ () всередині 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");
  }
  ...

Дисплей виклику ()
```
  A[i] = i + 2;
display();
```
Дисплей виклику ()
```
  }
  display();
}
```

— користувач285259
джерело

Ви можете відшарувати деякі байти , оголосивши A як масив та ініціалізуючи свої елементи керування циклом перед циклами, де це можливо, правда?

— Відновіть Моніку

1

Clojure, 185 байт

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

Так, редагування "стану" не є ідеальним в Clojure. Вам потрібно буде збільшити показник для більшого введення.

— NikoNyrh
джерело

Чому ви використовували відповідність шаблонів у loop? Ви повинні мати можливість втратити кілька байтів без цього.

— clismique

Також ви можете змінити firstріч на someзаяву.

— clismique

Без відповідності шаблону я повинен був повторити recurдвічі, по одному для кожної if-letгілки. Також (dec i)буде дублюватися. someпотрібен предикат, я міг би використовувати, +як ми маємо справу з числами, але це один символ довше, ніж first. CMIIW

— NikoNyrh

1

Java 8, 138 135 байт

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

Пояснення:

Спробуйте тут.

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

— Кевін Круїссен
джерело

1

Clojure, 198 193 191 байт

Це потрібно сильно гольфувати ...

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

Гольф 1 : Збережено 5 байт, змінивши (first(filter ...))на(some ...)

Гольф 2 : збережено 2 байти, змінивши (zero? ...)на(= ... 0)

Використання:

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

Невикористаний код:

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

— клісмік
джерело

Простий мурашник 🐜

Аліса , 45 байт

Python 2 , 120 байт

Октава , 109 103 101 94 байт

MATLAB, 130 123 118 117 байт

JavaScript (ES6), 91 байт

Демо

Haskell , 108 106 94 байт

TI-BASIC, 108 103 102 98 байт

MATL , 41 байт

Пояснення

Pyth - 44 байти

PARI / GP, 87 байт

Python 2 , 142 127 байт

Математика, 118 103 байт

Python 3 , 158 149 133 байт

PHP, 102 + 1 байт

R , 123 байт

C (gcc), 152 148 байт

Укорочений

Сформовано з деякими коментарями

Основна функція тестування

Для показу кожного кроку

Clojure, 185 байт

Java 8, 138 135 байт

Clojure, 198 193 191 байт

Використання:

Невикористаний код: