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

— Arnaud
источник

32

Я честно думал, что на моем экране был муравей, когда я увидел это в Hot Network Questions.

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

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бесплатно).

— Nitrodon
источник

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.

Кажется вероятным, что Муравей, вероятно, будет стремиться к бесконечности, но кто знает, внешность может быть обманчива.

МАТЛАБ: Сохранено 6 байтов forвместо whileи без скобок if- Спасибо @Giuseppe
MATLAB: сэкономьте 2 байта - спасибо @Sanchises
Octave: сохраняйте 10 байтов с помощью Octave \=и +=операций - Спасибо @Giuseppe
Октава: Сохранить 2 байта с i++и i--- Спасибо @LuisMendo
Octave: сэкономьте 7 байтов - спасибо @Sanchises

— Том Карпентер
источник

Чтобы заставить его работать на TIO, я думаю, что вам нужно, endчтобы соответствовать сигнатуре функции

— Джузеппе

@ Джузеппе Ах, хорошо. В MATLAB трейлинг endне обязателен.

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

Вы можете создать анонимную функцию, используя @ (n) в начале вместо функции i = a (n)

— Michthan

@Michthan не может сделать это в MATLAB. Я не думаю, что это возможно в Октаве, так как она имеет петли?

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

1

Трейлинг endнеобязателен и в Октаве. Здесь это нужно только потому, что у вас есть код после функции

— Луис Мендо

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

демонстрация

NB. Возможно, вам придется увеличить размер стека вашего движка по умолчанию, чтобы он прошел все тестовые случаи.

Попробуйте онлайн!

— Arnauld
источник

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-индексирование.

— Laikoni
источник

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

— kamoroso94
источник

Вы можете снять байт fPart(∟A(P)/F:с fPart(F¹∟A(P:. То же самое в следующей строке.

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

@ScottMilner Это не всегда работает. not(fPart(7⁻¹70, но not(fPart(7/71.

— kamoroso94

5

MATL , 41 байт

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

Выход основан на 1. Программа истекает для последнего теста в онлайн-переводчике.

Попробуйте онлайн!

объяснение

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

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

«Разрыв» обновление осуществляется путем перезаписи соответствующей записи из массива A . Обновление «add» выполняется поэлементным добавлением в 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

Тестовый пакет .

— Maltysen
источник

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 байт

Благодаря Шерлоку9 сохранено пятнадцать байтов .

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

Mathematica, 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)]чтобы убедиться, что A достаточно большой (за исключением n<3, n+9более чем достаточно). Предложение elseделит старое A[p]на d, уменьшает pи затем добавляет dновое A[p], что, безусловно, является плохой практикой кодирования. В остальном, довольно просто. Предложения по игре в гольф приветствуются!

Изменить: -9 байт без sympyблагодарности Халварда Хаммела. -14 байтов от Фелипе Нарди Батисты, -6 байтов от некоторых подсказок от Jathathan Frech's Python 2 answer

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)

Попробуйте онлайн!

— Sherlock9
источник

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;

— Titus
источник

2

R , 123 байта

Простая реализация. Он предоставляется как функция, которая принимает количество ходов в качестве входных данных и возвращает позицию p.

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

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

Для показа каждого шага

Объявите display () внутри 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();
}
```

— user285259
источник

Вы можете сбрить некоторые байты , объявив 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 ...)

Golf 2 : Сохраненный 2 байтами путем изменения (zero? ...)в(= ... 0)

Использование:

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

Ungolfed код:

(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
источник

Главный муравей 🐜

Алиса , 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 байт

Mathematica, 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 байт

Использование:

Ungolfed код: