Цей виклик, пов'язаний з ланцюжком відповідей, офіційно закінчився, в результаті чого перемогла майстер пшениці , що отримала 7 відповідей. Будь-яка інша відповідь вітається, але вона не впливатиме на прийняту відповідь на цей виклик, ні на переможця.

Завдання:

Роздрукуйте всі позитивні дільники числа, xвзятого як вхідне.

Вхід:

Єдине число, xяке є числом (у базі 10), чиї позитивні дільники повинні бути обчислені.

Вихід:

Всі позитивні подільники x. Будь-який формат допускається, в тому числі \n, ,, ;і прогалини в якості роздільників, до тих пір , як це зрозуміло. Вихідним може бути також масив Integers або Strings (наприклад:) [1, 2, 3, 5, 30]. Ви можете виводити дільники на stdout, консоль або їх аналог на вашій мові, або вони можуть бути повернуті з функції .

Правила

• Користувач може не відповідати двічі поспіль
• Ваша відповідь може видалити, додати або замінити максимум 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, тож ви повинні опублікувати другу відповідь залежно від цієї. Хай щастить!

Табло:

Цей список може бути застарілим, його можна редагувати:

1) Пшеничний майстер [Поточний лідер 🏆] : 7 відповідей - Python 1.6 , 05AB1E , насправді , Del | m | t , WSF , Brain-Flak , Lenguage

2) Райлі: 3 відповіді - серйозно , CJam , 2able

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

3) ETHproductions: 2 відповіді - Japt , Pyth

3) Міста Фіггінс: 2 відповіді - Befunge-98 , Brain-Flak Classic

6) Рікер: 1 відповідь - MATL

6) dzaima: 1 відповідь - SOGL 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, Мозг-Флак , 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 додаткових символів до мети зробити відповідь «Мозок-Флак». Я міг би додати 6, але на жаль, я забув, що пробіл не зараховується до бальної точки.

Поки що ми маємо:

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

Відповідь 13, Піт , 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)повертає значення truthy. У цьому випадку Fце функція, яка повертає логічний НЕ Q%T, а Aє SQ, що створює діапазон [1...Q]. Це має ефект фільтрації тільки цілі числа , Tв [1...Q]якому Q%T == 0.

Щоб уникнути розбору решти коду, вся справа загортається в рядок, потім |Q"...повертається логічний АБО 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, Lє 0x0A і 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, за винятком того, що він використовує пробіл замість звичного набору операторів. Ось код, декомпільований у brainfuck:

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

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

Прогрес у напрямку Brain-Flak

Оскільки WSF - це лише пробіл, я зміг додати ще 15 символів на код Brain-Flak. Це ставить нас на відстані 15 від відповіді, тому сміливо публікуйте її.

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

Оскільки я не збираюся самостійно розміщувати відповідь «Мозковий спалах», я подумав, що просто знайду час, щоб подякувати всім, хто допоміг сприяти досягненню цієї мети:

• Райлі, 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

Нарешті вдалося це вписати :) На щастя, це було після того, як відповідь «Мозг-Флак» була зроблена, тому що я думаю, я б заважав цьому. Потрібно було повних 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 також працював би) і збільшує значення
% ?Отримайте мод та тест. Якщо 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.

Якщо boolean був помилковим, у нас є додаткове значення, яке потрібно викорінити, тому ми пригадуємо булеве значення, яке ми зберігали у просторі -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, тому цього разу не було змін у «Мозковій кришці».

Моя основна стратегія для цього полягала в тому, щоб пересилати 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 - Python 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, Lenguage , 15

Lenguage - це езоланг, який піклується лише про те, наскільки тривала програма не про її зміст. Таким чином, ми можемо створити будь-яку програму для продовження завдань, доповнивши останню програму належною кількістю пробілів. Ленгуаг складається в мозковий епізод, тому ми повторно використаємо програму «мозковий ебан», про яку я писав деякий час тому

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

Я вніс кілька змін до основної програми, щоб полегшити подальші відповіді, але кінцевий результат виглядає так:

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

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