Эта задача с цепочкой ответов официально завершена, в результате чего победитель Wheat Wizard получил 7 ответов. Любой другой ответ приветствуется, но он не повлияет ни на принятый ответ на этот вызов, ни на победителя.

Задача:

Выведите все положительные делители числа, xвзятые в качестве входных данных.

Входные данные:

Единственное число, xкоторое является числом (в базе 10), положительные делители которого должны быть вычислены.

Выход:

Все положительные делители x. Любой формат допускается, в том числе \n, ,, ;и пробелы в качестве разделителей, до тех пор , как это понятно. Выходными данными также может быть массив целых чисел или строк (например:) [1, 2, 3, 5, 30]. Вы можете вывести делители на стандартный вывод, консоль или аналог на вашем языке, или они могут быть возвращены из функции .

правила

• Пользователь не может ответить дважды
• Ваш ответ может удалить, добавить или заменить не более 15 символов из предыдущего ответа (пробелы не учитываются), кроме того, для ответа 2, который может «преобразовать» до 20 символов, чтобы начать работу
• Вам не разрешается публиковать ответ на языке программирования, на котором уже есть ответ, за исключением того, что это совершенно другая версия этого языка (например, если я отправляю ответ Python 2.7, вы можете отправить его на Python 3, но не на Python 2.6)
• Стандартные лазейки не допускаются
• Вы не можете использовать встроенные модули для получения делителей , ради этого вызова
• Вы должны указать номер ответа и название языка в заголовке вопроса и количество символов, измененных по сравнению с предыдущим ответом.

счет

Пользователь с наибольшим количеством представлений, как только вещи улаживаются, побеждает. В случае ничьей побеждает пользователь с наибольшим количеством баллов по одному из своих ответов. Если в счете также есть ничья, то победителем будет объявлен пользователь с самой старой отправкой (самый старый ответ с наибольшим количеством очков).

Примечание: "примириться" <=> 7 После того , как был отправлен последний ответ, прошло 3 дня

Примеры:

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

Или любой другой эквивалентный выход, удовлетворяющий указанным условиям.

Последнее замечание : этот вопрос лучше, если вы сортируете ответы по самым старым. Я отправлю первый ответ в Python 2.7, поэтому вы должны опубликовать второй ответ в зависимости от этого. Удачи и приятного времяпровождения!

Leaderboard:

Этот список может быть устаревшим, свободно редактировать его:

1) Мастер Пшеницы [Текущий Лидер 7] : 7 ответов - Python 1.6 , 05AB1E , На самом деле , Del | m | t , WSF , Brain-Flak , Lenguage

2) Райли: 3 ответа - Серьезно , CJam , 2sable

3) Джонатан Аллан: 2 ответа - Python 3 , Jelly

3) ETHproductions: 2 ответа - Джапт , Пиф

3) Mistah Figgins: 2 ответа - Befunge-98 , Brain-Flak Classic

6) Райкер: 1 ответ - MATL

6) Дзайма: 1 ответ - СОГЛ 0.8.2

6) LegionMammal978: 1 ответ - Пробелы

6) Ник Клиффорд: 1 ответ - Ом

6) Линн: 1 ответ - GolfScript

6) MickyT: 1 ответ - Cubix

Калькулятор расстояния

Вы можете использовать этот фрагмент для вычисления расстояния между двумя записями:

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}

<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>

Ответ 20, Brain-Flak , 11

Я хотел бы просто поблагодарить всех, кто способствовал достижению этой цели:

• Райли, 20 байт

• LegionMammal, 15 байт

• ETHproductions, 11 байтов

• Линн, 1 байт

Следующие пользователи не могли напрямую вносить байты, но помогали другими способами:

• Миста Фиггинс

• DJMcMayhem

• feersum

Спасибо всем за то, что сделали это возможным!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

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

Ответ 3: MATL, расстояние 15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

Ответ 7, Japt, 15

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

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

Изменено #b∫I:b;\?tна ò f!vU(10 баллов) и добавлено еще немного кода Brain-Flak путем изменения ~(()на ((()<>))(5 баллов). Я считаю, что код, над которым мы работаем,

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

объяснение

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

Ответ 8, 05AB1E , 14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

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

объяснение

К счастью, 05AB1E имеет встроенный интерпретатор Python (своего рода). Чтобы сделать этот прогон, мы нажимаем

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

в виде строки на вершину стека. Здесь мы должны использовать строковые литералы вместо комментариев, потому что 05AB1E действительно не любит комментарии в своем коде Python. Мы также должны избавиться от "исходного кода, потому что это приводит к преждевременному завершению строки.

После того, как строка была нажата, мы используем ее .eдля выполнения в виде кода Python.

Работайте над Brain-Flak

Я смог добавить 5 дополнительных персонажей к цели, чтобы получить ответ Brain-Flak. Я мог бы добавить 6, но, увы, я забыл, что пробелы не учитываются при наборе очков.

Пока что имеем:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 13, Pyth , 15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

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

объяснение

Так что я немного знаю Pyth, но я знаю, что исходный код имеет форму дерева, каждая команда принимает определенное количество аргументов справа от себя. Дерево программы делителя, которую я написал, выглядит так:

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Qэто вход. fпринимает два аргумента, Fи A, и возвращает элементы, Tв Aкоторых F(T)возвращает истинное значение. В этом случае, Fэто функция , которая возвращает логическое отрицание Q%T, и Aесть SQ, что создает диапазон [1...Q]. Это приводит к фильтрации только целых чисел, Tв [1...Q]которыхQ%T == 0 .

Чтобы избежать синтаксического анализа остальной части кода, все это помещается в строку, а затем |Q"...возвращает логическое ИЛИ of Qи строку. Поскольку Qон всегда положителен, он всегда правдив и поэтому всегда возвращается из логического ИЛИ.

Работайте над Brain-Flak

((({})<>)){((({}[()] (({})(<>))      ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 16, GolfScript, 15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

Я добавил ~:␤),(;{␤\%!},p#, используя символ новой строки в качестве имени переменной, чтобы соответствовать ограничению размера, и сжал всю программу обратно на одну строку, чтобы закомментировать ее. Это было расстояние 14. Затем я добавил {ранее }printdivдля Brain-Flak.

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

Работайте над Brain-Flak

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          ) {})}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 17, CJam , 15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

Работайте над Brain-Flak (30 вперед)

)({}((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{            )   )  {(          ) {})}{}
 (  (( {})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 4 - Желе , 4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

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

Соответствующий код:

Rḍ⁸T

)Действует как разрыв между ссылками, насколько анализатор обеспокоен (я считаю).

Встроенным было бы ÆD, вместо этого это создает диапазон от 1входа с R, проверяет делимость на вход с помощью ḍ⁸, а затем возвращает список истинных индексов на основе с T.

Ответ 9, Пробел, 15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

Где <SPACES>заменяется следующей строкой, где T0x09, L0x0A и S0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Буквальный перевод строки добавлен для ясности. Заметил, что в правилах указываются только непробельные символы. Нет, не мог с собой поделать.

Работайте над Brain-Flak

Я понятия не имею, что происходило раньше, поэтому теперь мы имеем:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 18, WSF , 15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(Это требует ввода и вывода через код символа)

объяснение

WSF по сути является брейкфеком, за исключением того, что он использует пробелы вместо обычного набора операторов брейкфука. Вот код, декомпилированный в brainfuck:

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

Прогресс в направлении Brain-Flak

Поскольку WSF - это только пробел, я смог добавить еще 15 символов в код Brain-Flak. Это ставит нас в 15 от ответа, поэтому не стесняйтесь размещать его.

()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})>  )  {(          ) {})}{}
()({})(({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Так как я не собираюсь публиковать ответ «Brain-flak» сам, я подумал, что просто потрачу время, чтобы поблагодарить всех, кто помог в достижении этой цели:

• Райли, 16 байт

• LegionMammal, 15 байт

• ETHproductions, 11 байтов

• Линн, 1 байт

Следующие пользователи не могли напрямую вносить байты, но помогали другими способами:

• Миста Фиггинс

Спасибо всем за то, что сделали это возможным!

Ответ 19, 2 соболя , 15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

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

Я удалил лишние пробелы, обернул все, что существовало прежде, в строку, затем:

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

Ответ 21, Cubix , 15

Наконец-то удалось это уладить :) К счастью, это после того, как ответ Brain-Flak был сделан, потому что, думаю, я бы помешал. Требуются полные 15 для реализации.

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Это соответствует следующему кубу

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

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

Код по существу более 2 строк. Важными частями являются:

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )Это получает входные данные, меняет верхнюю часть стека (0 также сработало бы) и увеличивает
% ?Get и мод и тест. Если 0 продолжить или перейти к перенаправлению
; O N o Удалите результаты мода и выведите число, за которым следует символ новой строки
uU, поверните на строку ниже.
Последующее в порядке выполнения.
; - ! @ Удалите 10 из стека, вычтите число из ввода, проверьте и завершите, если ноль
< ; uПеренаправить цель для первого теста. Удалите вершину стека (результат модуляции или вычитания) и поверните обратно вверх, чтобы увеличить

Ответ 6, Python 1.6, 15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

Я удалил %символы и закомментировал первую строку и немного последней строки. Это одно стоило мне 10 из 15 моих очков. Однако я еще не сделал; так как Python 1 не имеет, +=мне пришлось заменить i+=1наi=i+1 стоило мне дополнительные 3 очка. Поскольку у меня осталось 2, я тоже добавил ((в начало. Я планирую сделать представление в Brain-Flak позже, и мне нужны парены.

Ответ 10, Ом , расстояние 5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

...где <SPACES> заменяется эта чудовищная строка из пробела ответа " .

Немного нахальный ответ, так как все остальное - просто провод, который лежит неисполненным.

Ответ 12, Серьезно , 15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

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

Единственное отличие от ответа « Фактически» заключается в том, что Серьезно использует обратные пометки, чтобы отметить функцию, в которой «На самом деле» используется ⌠и⌡ и мы просто сделать дополнительные символы в строку , то выскочить и отбросить его.

Работа к мозгу

((({})<>)){((({}[()] ((  )   )       ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 14, Del | m | t , 15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

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

объяснение

Я действительно начинаю злоупотреблять тем фактом, что пробелы здесь не учитываются. Del | m | t на самом деле все равно, какие символы вы, вы, так что подавляющее большинство кода представляет собой последовательность пробелов и возврат каретки в начале программы. Фактически видимые части кода не выполняются вообще.

Вот код, расшифрованный в более «разумной» форме:

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

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

Как это работает на низком уровне

Для начала у нас есть O R ^ V это служит для ввода данных в первом цикле и работает как неоперативный все остальные времена.

Затем мы используем O чтобы сделать копию ввода для дальнейшего использования.

@ A K T вызывает переменную, сохраненную в позиции памяти -1 (в начале программы это 0) и A J увеличивает ее. O @ A K UСохраняет теперь увеличенное значение обратно в позицию памяти -1 для нашего следующего цикла.

Nвычисляет мод копии входных данных, которые мы сделали некоторое время назад, и значение, только что извлеченное из памяти, и Rотрицает его.

Вместе N R создайте логическое значение, которое указывает, делится ли наш вход делителем TOS.

Мы сохраняем копию этого логического значения в памяти -2, используя O @ B K U и вызываем значение из пространства памяти -2, используя @ A K T.

Мы поменяем два верхних элемента на Q чтобы убедиться, что логическое значение находится сверху, и выведите значение, если логическое значение истинно, используя^ X .

Если логическое значение было ложным, у нас есть дополнительное значение, которое необходимо удалить, поэтому мы вызываем логическое значение, которое мы сохранили в пробеле -2, @ B K Tи извлекаем значение, если оно ложноR ^ P .

Мы дублируем входное значение с Oи вычитаем значение в памяти -1 с @ A K T K. Если это ноль, мы выходимR ^ _ .

Наконец, у нас есть @ ^это пропускает независимо от следующего значения. Нам это нужно, потому что есть куча мусора (фактически только @символ), сгенерированный видимой частью кода.

Как только он достигает конца, он возвращается к началу.

Как это работает на высоком уровне

Основная идея заключается в том, что у нас есть значение, хранящееся в основном в ячейке памяти -1, которое увеличивается каждый раз, когда мы выполняем цикл. Если это значение делит наши входные данные, мы выводим их, а когда они равны, мы заканчиваем выполнение.

Прогресс к мозгу

Поскольку пробелы не учитывают разницу, я смог изменить код, не потратив ни одного из своих 15 пунктов, и, таким образом, все они были вложены в код Brain-Flak.

Вот наше нынешнее положение.

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

Ответ 15, Befunge-98, 15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

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

(Там, вероятно, много лишних пробелов, но я не могу потрудиться играть в гольф прямо сейчас)

Я использовал все 15 для программы Befunge, поэтому на этот раз никаких изменений в Brain-flak не произошло.

Моя основная стратегия для этого заключалась в том, чтобы отправлять IP по вертикали и использовать пробелы для выполнения определенных символов из существующего кода.

Объяснение:

Код, который имеет значение для программы Befunge:

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

Что эквивалентно:

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line

Ответ 2 - Питон 3 , 5

n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

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

Ответ 5 - SOGL 0.8.2 , 9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

Объяснение:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

Примечание: интерпретатор в настоящее время нуждается в \nзамене символов s ¶, чтобы не считать их входными данными, но сам синтаксический анализатор считает, что оба являются взаимозаменяемыми.

Ответ 11, на самом деле , 15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

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

объяснение

На самом деле есть хорошая встроенная функция ÷для нахождения факторов ряда, однако нам не разрешено использовать такие встроенные функции.

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

Затем я вставляю код, который у нас уже был (я удалил все пробелы, потому что работать с ним было неприятно, я могу сделать это, потому что «пробелы не учитываются»). К счастью, это ничего не делает, когда стек пуст.

Тогда у нас есть остальная часть программы

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

Работа к мозгу

Вся эта работа, и я смог получить только одного дополнительного парня.

((({})<>)){((({}   ] ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}

23, Brain-Flak Classic, 13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

Первоначально, @Wheat Wizard опубликовал классический мозговой код, как это было в ответе 22:

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]{})           ><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[]  )>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

Это 17 символов. Тем не менее, я смог сжать это, просто двигая {})дальше вправо в предложенном коде, чтобы получить

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}

Что только 13 символов! Поэтому все, что я сделал, это добавил / убрал скобки, чтобы получить предложенный код.

У исходного кода, который я разместил, была опечатка, теперь она исправлена. ( Спасибо @WheatWizard! )

Ответ 1 - Python 2.7

n=input()
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

Расстояние: NA - Первый ответ

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

22, Ленгуаг , 15

Lenguage - это esolang, который заботится только о том, как долго программа не о ее содержании. Таким образом, мы можем создать любую программу на языке, которую мы хотим, заполнив последнюю программу нужным количеством пробелов. Lenguage скомпилирован в brainfuck, поэтому мы будем использовать программу brainfuck, которую я написал недавно

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

Я внес несколько изменений в основную программу, чтобы облегчить последующие ответы, но конечный результат выглядит следующим образом:

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

где <SPACES>представляет 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 пробелов.

Я злоупотребляю пробелом, не считается правилом? Может быть.

Работайте над Brain-Flak Classic

У нас уже были все эти парены, поэтому я подумал, что отправлю нас по пути к Brain-Flak Classic.

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}