Ta odpowiedź-łańcuchowym wyzwaniem jest oficjalnie ponad, co skutkuje wygraną Pszenica kreatora , w sumie 7 odpowiedzi. Każda inna odpowiedź jest mile widziana, ale nie wpłynie ona na zaakceptowaną odpowiedź na to wyzwanie ani na zwycięzcę.

Zadanie:

Wydrukuj wszystkie dodatnie dzielniki liczby xpodanej jako dane wejściowe.

Wejście:

Pojedyncza liczba, xktóra jest liczbą (w podstawie 10), której dodatnie dzielniki należy obliczyć.

Wynik:

Wszystkie pozytywne dzielniki x. Każdy format jest dozwolone, w tym \n, ,, ;i spacji jako separatory, tak długo, jak jest to zrozumiałe. Wyjściem może być również tablica liczb całkowitych lub ciągów (np [1, 2, 3, 5, 30]. :) . Możesz wypisać dzielniki na standardowe wyjście, konsolę lub odpowiednik w swoim języku lub można je zwrócić z funkcji .

Zasady

• Użytkownik może nie odpowiadać dwa razy z rzędu
• Twoja odpowiedź może usunąć, dodać lub zastąpić najwyżej 15 znaków z poprzedniej odpowiedzi (białe znaki nie liczą się), oprócz odpowiedzi 2, która może „przekształcić” do 20 znaków, aby rozpocząć.
• Nie możesz opublikować odpowiedzi w języku programowania, który już ma odpowiedź, wyjątkiem jest zupełnie inna wersja tego języka (np .: jeśli opublikuję odpowiedź w Python 2.7, możesz przesłać odpowiedź w Python 3, ale nie w Python 2.6)
• Standardowe luki są niedozwolone
• Teraz nie wolno używać Zabudowy dla dzielników uzyskiwanie , przez wzgląd na to wyzwanie
• Państwo musi zawierać numer odpowiedź i nazwy języka w tytule pytanie, a tym samym liczbę znaków zmieniły się od czasu poprzedniej odpowiedzi

Punktacja

Użytkownik z największą liczbą zgłoszeń wygrywa. W przypadku remisu wygrywa użytkownik z najwyższym wynikiem na jednej z odpowiedzi. Jeśli wynik również jest remisowy, zwycięzcą zostanie ogłoszony użytkownik z najstarszym zgłoszeniem (najstarsza odpowiedź o najwyższym wyniku).

Uwaga: „osiedlić się” <=> 7 minęły 3 dni od przesłania ostatniej odpowiedzi

Przykłady:

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]

Lub jakikolwiek inny równoważny wynik spełniający wspomniane warunki.

Uwaga końcowa : To pytanie jest lepsze, jeśli posortujesz odpowiedzi według najstarszych. Opublikuję pierwszą odpowiedź w Pythonie 2.7, więc powinieneś opublikować drugą odpowiedź w zależności od tej. Powodzenia i miłej zabawy!

Tabela liderów:

Ta lista może być nieaktualna, możesz ją swobodnie edytować:

1) Pszenica Kreator [Current Leader 🏆] : 7 Odpowiedzi - Python 1.6 , 05AB1E , Faktycznie , Del | m | t , WSF , Brain-Flak , lenguage

2) Riley: 3 odpowiedzi - Poważnie , CJam , 2sable

3) Jonathan Allan: 2 odpowiedzi - Python 3 , Galaretka

3) ETHprodukcje: 2 odpowiedzi - Japt , Pyth

3) Mistah Figgins: 2 odpowiedzi - Befunge-98 , Brain-Flak Classic

6) Riker: 1 odpowiedź - MATL

6) dzaima: 1 odpowiedź - SOGL 0.8.2

6) LegionMammal978: 1 odpowiedź - Biała spacja

6) Nick Clifford: 1 odpowiedź - Ohm

6) Lynn: 1 odpowiedź - GolfScript

6) MickyT: 1 odpowiedź - Cubix

Kalkulator odległości

Za pomocą tego fragmentu kodu możesz obliczyć odległość między dwoma wpisami:

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>

Odpowiedź 20, Flak mózgu , 11

Chciałbym tylko poświęcić czas, aby podziękować wszystkim, którzy przyczynili się do osiągnięcia tego celu:

• Riley, 20 bajtów

• LegionMammal, 15 bajtów

• Produkcje ETH, 11 bajtów

• Lynn, 1 bajt

Następujący użytkownicy nie mogli przekazać bajtów bezpośrednio, ale pomogli w inny sposób:

• Mistah Figgins

• DJMcMayhem

• feersum

Dziękujemy wszystkim za umożliwienie tego!

"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%_Ï,

Wypróbuj online!

Odpowiedź 3: MATL, dystans 15

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

Odpowiedź 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”

Wypróbuj online!

Zmieniono #b∫I:b;\?tna ò f!vU(10 punktów) i dodano trochę kodu Brain-Flak, zmieniając ~(()na ((()<>))(5 punktów). Uważam, że kod, nad którym pracujemy, jest

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

Wyjaśnienie

ò           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

Odpowiedź 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

Wypróbuj online!

Wyjaśnienie

Na szczęście 05AB1E ma wbudowany interpreter Pythona (swego rodzaju). Aby wykonać ten bieg, pchamy

'ò 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”'

jako ciąg na górę stosu. Musimy tutaj używać literałów łańcuchowych zamiast komentarzy, ponieważ 05AB1E naprawdę nie lubi komentarzy w kodzie Pythona. Musimy także pozbyć się "oryginalnego kodu, ponieważ powoduje to przedwczesne zakończenie łańcucha.

Po wypchnięciu łańcucha używamy go .edo wykonania jako kod Pythona.

Pracuj w kierunku Brain-Flak

Byłem w stanie dodać 5 dodatkowych postaci w celu uzyskania odpowiedzi Brain-Flak. Byłbym w stanie dodać 6, ale niestety zapomniałem, że białe znaki nie liczą się do wyniku punktowego.

Do tej pory mamy:

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

Odpowiedź 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∩

Wypróbuj online!

Wyjaśnienie

Więc nie znam dużo Pytha, ale wiem, że kod źródłowy ma postać drzewa, a każde polecenie ma określoną liczbę argumentów po swojej prawej stronie. Drzewo programu dzielnika, który napisałem, wygląda następująco:

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

Qjest wejściem. fprzyjmuje dwa argumenty, Fi A, i zwraca pozycje Tw Aktórym F(T)zwraca wartość truthy. W tym przypadku Fjest funkcją, która zwraca logiczne NIE Q%T, i Ajest SQ, co tworzy zakres [1...Q]. To powoduje filtrowanie tylko do liczb całkowitych, Tw [1...Q]których Q%T == 0.

Aby uniknąć parsowania reszty kodu, cała rzecz jest zawijana w łańcuch, a następnie |Q"...zwraca logiczną operację LUB Qłańcucha. Ponieważ Qjest zawsze pozytywne, zawsze jest zgodne z prawdą, a zatem zawsze wraca z logicznej OR.

Pracuj w kierunku Brain-Flak

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

Odpowiedź 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∩\

Wypróbuj online!

Dodałem ~:␤),(;{␤\%!},p#, używając nowej linii jako nazwy zmiennej w celu dopasowania do ograniczenia rozmiaru, i wyciąłem cały program z powrotem w jednym wierszu, aby go skomentować. To była odległość 14. Potem dodałem {wcześniej }printdivdla Brain-Flak.

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

Pracuj w kierunku Brain-Flak

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

Odpowiedź 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∩\

Wypróbuj online!

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

Pracuj w kierunku Brain-Flak (30 do przejścia)

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

Odpowiedź 4 - Galaretka , 4

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

Wypróbuj online!

Odpowiedni kod:

Rḍ⁸T

)Działa jako przerwy między linkami miarę parser jest zaniepokojony (wierzę).

Wbudowane byłoby ÆD, zamiast tego tworzy zakres od 1do danych wejściowych z R, sprawdza podzielność przez dane wejściowe za pomocą ḍ⁸, a następnie zwraca listę prawdziwych indeksów opartych na jednym T.

Odpowiedź 9, Biała spacja, 15

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

Gdzie <SPACES>jest zastąpiony następującym ciągiem, gdzie Tjest 0x09, Lto 0x0A i S0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Dosłowna nowa linia dodana dla przejrzystości. Zauważono, że reguły określają tylko znaki niebiałe. Nie, nie mogłem się powstrzymać.

Pracuj w kierunku Brain-Flak

Nie mam pojęcia, co się działo wcześniej, więc teraz mamy:

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

Odpowiedź 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∩\

(To pobiera dane wejściowe i wyjściowe za pomocą kodu znaków)

Wyjaśnienie

WSF jest w zasadzie pieprzony od mózgu, tyle że używa białych znaków zamiast zwykłego zestawu operatorów. Oto kod zdekompilowany do pieprzenia mózgu:

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

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

Postęp w kierunku Flak mózgu

Ponieważ WSF to tylko białe znaki, mogłem dodać 15 dodatkowych znaków do kodu Brain-Flak. To stawia nas w odległości 15 od odpowiedzi, więc możesz ją opublikować.

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

Ponieważ sam nie zamierzam publikować odpowiedzi na pytanie o móżdżek, pomyślałem, że poświęcę trochę czasu, aby podziękować wszystkim, którzy pomogli w osiągnięciu tego celu:

• Riley, 16 bajtów

• LegionMammal, 15 bajtów

• Produkcje ETH, 11 bajtów

• Lynn, 1 bajt

Następujący użytkownicy nie mogli przekazać bajtów bezpośrednio, ale pomogli w inny sposób:

• Mistah Figgins

Dziękujemy wszystkim za umożliwienie tego!

Odpowiedź 19, 2sable , 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%_Ï,

Wypróbuj online!

Usunąłem dodatkowe białe znaki, zawinąłem wszystko, co istniało wcześniej w ciąg, a następnie:

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

Odpowiedź 21, Cubix , 15

W końcu udało mi się to dopasować :) Na szczęście jest to po tym, jak odpowiedź Brain-Flak została wykonana, ponieważ myślę, że bym przeszkodził. Potrzebne było pełne 15 do wdrożenia.

"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%_Ï,

Odwzorowuje to na następujący moduł

              " 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 % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

Możesz go wypróbować tutaj , ale musisz go wkleić. Podejrzewam, że niektóre promocje powodują problemy z połączeniem bezpośrednim.

Kod składa się zasadniczo z 2 wierszy. Ważne części to:

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

I s )To pobiera dane wejściowe, zamienia górną część stosu (0 też by działało) i zwiększa
% ?Get mod i test. Jeśli 0 kontynuuje lub upuszcza do przekierowania
; O N oUpuść wyniki modu i wypisz numer, a następnie znak nowej linii
uU skręć w linię poniżej
Kolejność jest wykonywana
; - ! @ Usuń 10 ze stosu, odejmij liczbę od wejścia, przetestuj i zakończ, jeśli zero
< ; uPrzekieruj cel do pierwszego testu. Usuń górną część stosu (albo modyfikuj, albo odejmij wynik) i odwróć w górę, aby zwiększyć

Odpowiedź 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”

Usunąłem %symbole i skomentowałem pierwszą linię i trochę ostatniej linii. Już samo to kosztowało mnie 10 z 15 punktów. Jednak jeszcze nie skończyłem; ponieważ Python 1 nie +=musiałem wymienić i+=1z i=i+1kosztowało mnie dodatkowe 3 punkty. Ponieważ pozostały mi 2, dodałem też ((na początek. Planuję złożyć zgłoszenie w Brain-Flak później i potrzebuję parens.

Odpowiedź 10, Ohm , odległość 5

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

... gdzie <SPACES>zastępuje ten monstrualny ciąg z odpowiedzi na Białą Przestrzeń .

Trochę bezczelna odpowiedź, ponieważ wszystko inne jest tylko drutem, który leży niewykonany.

Odpowiedź 12, Poważnie , 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∩

Wypróbuj online!

Jedyna różnica w stosunku do Właściwie odpowiedź jest taka, że Poważnie wykorzystuje odwrócone, pojedyncze apostrofy, aby zaznaczyć funkcję, gdzie nie używa ⌠, a ⌡i my po prostu wprowadzić dodatkowe znaki na ciąg następnie pop i wyrzucić ją.

Pracuj w kierunku Flak mózgu

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

Odpowiedź 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∩

Wypróbuj online!

Wyjaśnienie

Naprawdę zaczynam nadużywać faktu, że białe znaki nie są tutaj wliczane do różnicy. Del | m | t tak naprawdę nie dba o to, jakie znaki ci się należy, więc zdecydowana większość kodu to sekwencja spacji i znaków powrotu karetki na początku programu. Rzeczywiste widoczne części kodu wcale nie są wykonywane.

Oto kod przepisany w bardziej „rozsądny” sposób:

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 ^ _ @ ^ @

Wypróbuj online!

Jak to działa na niskim poziomie

Na początek mamy O R ^ V to do pobrania danych z pierwszej pętli i działa jako no-op przez cały czas.

Następnie Owykonujemy kopię danych wejściowych na później.

@ A K Tprzywołuje zmienną zapisaną w pozycji pamięci -1 (na początku programu jest to 0) i A Jzwiększa ją. O @ A K UPrzechowuje teraz zwiększoną wartość z powrotem w pozycji pamięci -1 dla naszej następnej pętli.

Noblicza mod kopii danych, które zrobiliśmy jakiś czas temu, a wartość właśnie przywołana z pamięci i Rneguje ją.

Razem N Rstworzymy wartość logiczną, która wskazuje, czy nasze dane wejściowe są podzielne przez warunki świadczenia usługi.

Przechowujemy kopię tego boolean do pamięci -2 za pomocą O @ B K Ui przywołujemy wartość z pamięci -2 za pomocą @ A K T.

Zamieniamy dwa górne elementy, Qaby upewnić się, że wartość logiczna jest na górze, i wyświetlamy wartość, jeśli wartość logiczna jest prawdziwa, używając ^ X.

Jeśli wartość logiczna była fałszywa, mamy dodatkową wartość, którą należy wyeliminować, dlatego przywołujemy wartość logiczną, którą zapisaliśmy w przestrzeni -2, @ B K Ti wpisujemy wartość, jeśli jest fałszywa R ^ P.

Powielamy wartość wejściową za pomocą Oi odejmujemy wartość w pamięci -1 za pomocą @ A K T K. Jeśli jest to zero, wychodzimy R ^ _.

Na koniec @ ^pomijamy tę wartość niezależnie od następnej wartości. Potrzebujemy tego, ponieważ istnieje @widoczna część śmieci (właściwie tylko symbol) generowanych przez widoczną część kodu.

Gdy osiągnie koniec, zapętla się z powrotem do początku.

Jak to działa na wysokim poziomie

Podstawową ideą jest to, że mamy wartość przechowywaną głównie w pamięci -1, która jest zwiększana za każdym razem, gdy zapętlamy. Jeśli ta wartość dzieli nasze dane wejściowe, generujemy je, a gdy te dwie wartości są równe, kończymy wykonywanie.

Postęp w kierunku Flak mózgu

Ponieważ białe znaki nie liczą się do różnicy, mogłem zmienić kod nie wydając żadnego z moich 15 punktów, a zatem wszystkie zostały zainwestowane w kod Brain-Flak.

Oto nasza obecna pozycja.

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

Odpowiedź 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∩
\

Wypróbuj online!

(Prawdopodobnie jest wiele niepotrzebnych białych znaków, ale nie mogę teraz zawracać sobie głowy golfem)

Użyłem wszystkich 15 do programu Befunge, więc tym razem bez zmian w Mózgu.

Moją główną strategią było wysyłanie adresu IP w pionie i używanie białych znaków do wykonywania niektórych znaków z istniejącego kodu.

Wyjaśnienie:

Kod, który ma znaczenie dla programu Befunge, jest następujący:

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

Co odpowiada:

&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

Odpowiedź 2 - Python 3 , 5

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

Wypróbuj online!

Odpowiedź 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”

Wyjaśnienie:

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"]

Uwaga: interpreter wymaga obecnie \nzastąpienia s ¶, aby nie liczyć go jako danych wejściowych, ale sam parser uważa oba wymienne.

Odpowiedź 11, właściwie 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∩

Wypróbuj online!

Wyjaśnienie

W rzeczywistości ma ładne wbudowane narzędzie ÷do wyszukiwania czynników liczby, jednak nie wolno nam używać takich wbudowanych funkcji.

Zaczynam od przechowywania danych wejściowych do rejestrów, aby nie miało to wpływu na to, co nadejdzie. Robię to za pomocą, ╩ale równie łatwo mogę użyć jednego z innych dostępnych poleceń.

Następnie wklejam kod, który już mieliśmy (usunąłem wszystkie białe znaki, ponieważ praca z nimi była denerwująca, mogę to zrobić, ponieważ „białe znaki się nie liczą”). Na szczęście to nic nie robi, gdy stos jest pusty.

Następnie mamy resztę programu

╜   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

Pracuj w kierunku Flak mózgu

Cała ta praca i mogłem dostać tylko jednego dodatkowego parena.

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

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%_Ï,

Początkowo @Wheat Wizard opublikował klasyczny kod typu flak mózgu, tak jak w odpowiedzi na 22:

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

To jest 17 znaków. Byłem jednak w stanie to skompresować, po prostu przesuwając {})dalej w prawo w proponowanym kodzie, aby uzyskać

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

To jest tylko 13 znaków! Więc wszystko, co zrobiłem, to dodawanie / usuwanie nawiasów, aby uzyskać proponowany kod.

Oryginalny kod, który opublikowałem, miał literówkę, teraz jest naprawiony. ( Dzięki @WheatWizard! )

Odpowiedź 1 - Python 2.7

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

Odległość: NA - pierwsza odpowiedź

Wypróbuj online!

22, Lenguage , 15

Lenguage to esolang, który dba tylko o to, jak długo program nie dotyczy jego zawartości. Możemy więc stworzyć dowolny program lenguage, który chcemy, wypełniając ostatni program odpowiednią ilością białych znaków. Lenguage jest wkompilowany w pieprzenie mózgu, więc użyjemy ponownie tego programu, który napisałem jakiś czas temu

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

Wprowadziłem kilka zmian w programie głównym, aby ułatwić późniejsze odpowiedzi, ale efekt końcowy wygląda następująco:

<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%_Ï,

gdzie <SPACES>reprezentuje 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 znaków spacji.

Czy nadużywam białych znaków nie liczy się zasada? Być może.

Pracuj w kierunku Brain-Flak Classic

Mieliśmy już wszystkie te pareny, więc pomyślałem, że zacznę od drogi w kierunku Brain-Flak Classic.

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