Diese Herausforderung in Bezug auf die Verkettung der Antworten ist offiziell beendet und führt zum Gewinn von Wheat Wizard mit insgesamt 7 Antworten. Jede andere Antwort ist willkommen, hat jedoch keinen Einfluss auf die akzeptierte Antwort für diese Herausforderung und auch nicht auf den Gewinner.

Aufgabe:

Gibt alle positiven Teiler einer xeingegebenen Zahl aus.

Eingang:

Eine einzelne Zahl, xdie die Zahl (in Basis 10) ist, deren positive Teiler berechnet werden sollen.

Ausgabe:

Alle positiven Teiler von x. Jedes Format ist erlaubt, einschließlich \n, ,, ;und Leerzeichen als Trennzeichen , solange es ist verständlich. Die Ausgabe kann auch ein Array von Ganzzahlen oder Strings sein (zB:) [1, 2, 3, 5, 30]. Sie können die Divisoren in Ihrer Sprache als stdout, console oder gleichwertig ausgeben oder sie können von einer Funktion zurückgegeben werden .

Regeln

• Ein Benutzer darf nicht zweimal hintereinander antworten
• Ihre Antwort darf höchstens 15 Zeichen aus der vorherigen Antwort entfernen, hinzufügen oder ersetzen (Leerzeichen zählen nicht), außer für Antwort 2, die bis zu 20 Zeichen "transformieren" kann , um den Anfang zu machen
• Sie sind nicht eine Antwort auf Beitrag in einer Programmiersprache erlaubt , dass bereits eine Antwort hat, die Ausnahme ein Wesen völlig andere Version dieser Sprache (zB: Wenn ich eine Antwort in der Post Python 2.7, können Sie in einreichen Python 3, aber nicht in Python 2.6)
• Standardlücken sind nicht erlaubt
• Um diese Herausforderung zu bewältigen, dürfen Sie keine integrierten Funktionen zum Abrufen von Divisoren verwenden
• Sie müssen die Nummer der Antwort und den Namen der Sprache in den Titel der Frage einfügen und die Anzahl der Zeichen, die sich gegenüber der vorherigen Antwort geändert haben

Wertung

Der Benutzer mit den meisten Einsendungen, sobald sich die Dinge erledigt haben, gewinnt. Bei einem Gleichstand gewinnt der Benutzer mit der höchsten Punktzahl bei einer seiner Antworten. Wenn es auch bei der Punktzahl einen Gleichstand gibt, wird der Benutzer mit der ältesten Einreichung (älteste Antwort mit der höchsten Punktzahl) zum Gewinner erklärt.

Hinweis: "Abwickeln" <=> 7 3 Tage sind vergangen, seit die letzte Antwort gesendet wurde

Beispiele:

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]

Oder eine andere äquivalente Leistung, die die genannten Bedingungen erfüllt.

Letzte Anmerkung : Diese Frage ist besser, wenn Sie die Antworten nach den ältesten sortieren. Ich werde die erste Antwort in Python 2.7 veröffentlichen, daher sollten Sie die zweite Antwort abhängig von dieser Antwort veröffentlichen. Viel Glück und hab Spaß!

Bestenliste:

Diese Liste ist möglicherweise veraltet und kann bearbeitet werden:

1) Weizen Wizard [Aktuelle Spitzenreiter 🏆] : 7 Antworten - Python 1.6 , 05AB1E , Eigentlich , Del | m | t , WSF , Brain-Flak , Lenguage

2) Riley: 3 Antworten - Im Ernst , CJam , 2sable

3) Jonathan Allan: 2 Antworten - Python 3 , Jelly

3) ETHproductions: 2 Antworten - Japt , Pyth

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

6) Riker: 1 Antwort - MATL

6) dzaima: 1 Antwort - SOGL 0.8.2

6) LegionMammal978: 1 Antwort - Leerzeichen

6) Nick Clifford: 1 Antwort - Ohm

6) Lynn: 1 Antwort - GolfScript

6) MickyT: 1 Antwort - Cubix

Entfernungsrechner

Mit diesem Snippet können Sie den Abstand zwischen zwei Einträgen berechnen:

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>

Antwort 20, Brain-Flak , 11

Ich möchte mir nur die Zeit nehmen, um allen zu danken, die zu diesem Ziel beigetragen haben:

• Riley, 20 Bytes

• LegionMammal, 15 Bytes

• ETHproductions, 11 Bytes

• Lynn, 1 Byte

Die folgenden Benutzer konnten keine direkten Bytes beisteuern, haben aber auf andere Weise geholfen:

• Mistah Figgins

• DJMcMayhem

• Feersum

Vielen Dank an alle, die dies möglich gemacht haben!

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

Probieren Sie es online!

Antwort 3: MATL, Abstand 15

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

Antwort 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”

Probieren Sie es online!

Geändert #b∫I:b;\?tzu ò f!vU(10 Punkte) und durch Ändern ~(()zu ((()<>))(5 Punkte) etwas mehr Brain-Flak-Code hinzugefügt . Ich glaube, der Code, auf den wir hinarbeiten, ist

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

Erläuterung

ò           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

Antwort 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

Probieren Sie es online!

Erläuterung

Zum Glück hat 05AB1E einen eingebauten Python-Interpreter (von Art). Um diesen Lauf zu machen, pushen wir

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

als Zeichenfolge an die Spitze des Stapels. Wir müssen hier Zeichenfolgenliterale anstelle von Kommentaren verwenden, da 05AB1E Kommentare in seinem Python-Code wirklich nicht mag. Wir müssen auch den "im Originalcode enthaltenen Code entfernen, da er dazu führt, dass die Zeichenfolge vorzeitig endet.

Sobald der String gepusht wurde, führen wir .eihn als Python-Code aus.

Arbeiten Sie in Richtung Brain-Flak

Ich konnte dem Ziel, eine Brain-Flak-Antwort zu geben, 5 zusätzliche Charaktere hinzufügen. Ich hätte 6 addieren können, aber leider habe ich vergessen, dass Whitespace nicht für die Punktzahl zählt.

Bisher haben wir:

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

Antwort 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∩

Probieren Sie es online!

Erläuterung

Ich kenne nicht viel Pyth, aber ich weiß, dass der Quellcode die Form eines Baums hat, wobei jeder Befehl eine bestimmte Anzahl von Argumenten rechts davon enthält. Der Baum des Divisor-Programms, das ich geschrieben habe, sieht folgendermaßen aus:

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

Qist der Eingang. Nimmt fzwei Argumente Fund Aund gibt die Elemente zurück, Tin Adenen F(T)ein wahrer Wert zurückgegeben wird. In diesem Fall Fist eine Funktion , die die logischen NICHT von zurückgibt Q%T, und Aist SQ, was den Bereich schafft [1...Q]. Dies hat den Effekt, dass nur die Ganzzahlen Tin [1...Q]where gefiltert werden Q%T == 0.

Um zu vermeiden, dass der Rest des Codes analysiert wird, wird das gesamte Objekt in eine Zeichenfolge eingeschlossen und anschließend |Q"...das logische ODER von Qund die Zeichenfolge zurückgegeben. Da Qes immer positiv ist, ist es immer wahr und wird daher immer vom logischen ODER zurückgegeben.

Arbeite auf Brain-Flak zu

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

Antwort 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∩\

Probieren Sie es online!

Ich fügte hinzu ~:␤),(;{␤\%!},p#, wobei ich newline als Variablennamen verwendete, um der Größenbeschränkung zu entsprechen, und quetschte das gesamte Programm zurück auf eine Zeile, um es auszukommentieren. Das war Abstand 14. Dann habe ich {vorher }printdivfür Brain-Flak hinzugefügt .

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

Arbeiten Sie in Richtung Brain-Flak

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

Antwort 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∩\

Probieren Sie es 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

Arbeite auf Brain-Flak zu (noch 30)

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

Antwort 4 - Gelee , 4

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

Probieren Sie es online!

Relevanter Code:

Rḍ⁸T

Das ) den Parser ist das ein Bruch zwischen den Links (glaube ich).

Das eingebaute wäre ÆD, stattdessen erzeugt dies einen Bereich von 1bis zur Eingabe mit R, prüft die Teilbarkeit durch die Eingabe mit ḍ⁸und gibt dann eine Liste der wahrheitsgemäßen einbasierten Indizes mit zurück T.

Antwort 9, Leerzeichen, 15

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

Wobei <SPACES>durch die folgende Zeichenfolge ersetzt wird, wobei T0x09, L0x0A und S0x20 ist:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Literal Newline hinzugefügt für Klarheit. Es wurde festgestellt, dass in den Regeln nur Zeichen ohne Leerzeichen angegeben werden. Nein, konnte mir nicht helfen.

Arbeiten Sie in Richtung Brain-Flak

Ich habe keine Ahnung, was früher los war, also haben wir jetzt:

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

Antwort 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∩\

(Eingabe und Ausgabe erfolgt über Zeichencode)

Erläuterung

WSF ist im Wesentlichen Brainfuck, außer dass anstelle der üblichen Operatoren von Brainfuck Whitespace verwendet wird. Hier ist der Code in Brainfuck dekompiliert:

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

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

Fortschritte in Richtung Brain-Flak

Da es sich bei WSF nur um Leerzeichen handelt, konnte ich dem Brain-Flak-Code 15 weitere Zeichen hinzufügen. Dies versetzt uns um 15 von der Antwort entfernt, also zögern Sie nicht, sie zu posten.

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

Da ich die Brain-Flak-Antwort nicht selbst veröffentlichen werde, dachte ich, ich würde mir einfach die Zeit nehmen, um allen zu danken, die zu diesem Ziel beigetragen haben:

• Riley, 16 Bytes

• LegionMammal, 15 Bytes

• ETHproductions, 11 Bytes

• Lynn, 1 Byte

Die folgenden Benutzer konnten keine direkten Bytes beisteuern, haben aber auf andere Weise geholfen:

• Mistah Figgins

Vielen Dank an alle, die dies möglich gemacht haben!

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

Probieren Sie es online!

Ich entfernte das zusätzliche Leerzeichen und wickelte alles, was vorher existierte, in eine Zeichenkette ein. Dann:

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

Antwort 21, Cubix , 15

Endlich ist es gelungen, dies zu korrigieren :) Zum Glück ist es nach der Brain-Flak-Antwort geschehen, denn ich glaube, ich hätte es behindert. Benötigte die vollen 15 zu implementieren.

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

Dies ist dem folgenden Würfel zugeordnet

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

Sie können es hier ausprobieren , aber du musst es einfügen. Ich vermute, dass einige der Specials Probleme für den Permalink verursachen.

Der Code besteht im Wesentlichen aus 2 Zeilen. Die wichtigen Teile sind:

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

I s )Dies holt die Eingabe, tauscht den oberen Teil des Stapels aus (0 hätte auch funktioniert) und inkrementiert
% ?den Mod und test. Wenn 0 weiter geht oder zum Redirect runter geht,
; O N olösche die Mod-Ergebnisse und gib die Nummer gefolgt von einem Newline-
uU in der Zeile darunter aus.
Folgend ist in der Reihenfolge ausgeführt.
; - ! @ Entferne die 10 vom Stack, subtrahiere die Nummer von der Eingabe, teste und beende sie, wenn sie Null ist
< ; uLeiten Sie das Ziel für den ersten Test um. Entferne die Oberseite des Stapels (entweder Mod oder subtrahiere das Ergebnis) und drehe dich wieder um, um es zu erhöhen

Antwort 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”

Ich habe das entfernt % Symbole entfernt und die erste und ein bisschen die letzte Zeile auskommentiert. Allein das hat mich 10 meiner 15 Punkte gekostet. Ich war jedoch noch nicht fertig; da Python 1 nicht benötigt wird, musste +=ich es ersetzen i+=1und i=i+1kostete mich zusätzliche 3 Punkte. Da ich noch 2 übrig hatte, habe ich auch ((am Anfang hinzugefügt . Ich habe vor, mich später in Brain-Flak zu melden, und ich brauche Parens.

Antwort 10, Ohm , Abstand 5

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

...wo <SPACES> wird durch diese monströse Zeichenfolge aus der Whitespace- Antwort ersetzt.

Eine etwas freche Antwort, da alles andere nur ein Draht ist, der nicht ausgeführt wird.

Antwort 12: Ernsthaft , 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∩

Probieren Sie es online!

Der einzige Unterschied zur tatsächlichen Antwort besteht darin, dass Seriously Backticks verwendet, um eine Funktion zu markieren, bei der Actually ⌠and verwendet, ⌡und wir die zusätzlichen Zeichen einfach in eine Zeichenfolge umwandeln, diese dann platzieren und verwerfen.

Arbeiten Sie in Richtung Brain-Flak

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

Antwort 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∩

Probieren Sie es online!

Erläuterung

Ich fange wirklich an, die Tatsache zu missbrauchen, dass Leerzeichen hier nicht zum Unterschied gezählt werden. Del | m | t ist es eigentlich egal, welche Zeichen Sie haben, so dass der größte Teil des Codes eine Folge von Leerzeichen und Zeilenumbrüchen am Anfang des Programms ist. Die tatsächlich sichtbaren Teile des Codes werden überhaupt nicht ausgeführt.

Hier ist der Code in eine "vernünftigere" Weise umgeschrieben:

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

Probieren Sie es online!

Wie es auf niedrigem Niveau funktioniert

Zu Beginn O R ^ V dient dies dazu, Eingaben in die erste Schleife zu übernehmen und arbeitet alle anderen Male als No-Op.

Wir Omachen dann eine Kopie der Eingabe für später.

@ A K Truft die in Speicherposition -1 gespeicherte Variable auf (am Anfang des Programms ist dies 0) und A Jerhöht sie. O @ A K USpeichert den jetzt inkrementierten Wert in Speicherposition -1 für unsere nächste Schleife zurück.

Nberechnet den Mod der Kopie der Eingabe, die wir vor einiger Zeit gemacht haben, und den Wert, der gerade aus dem Speicher abgerufen wurde, und Rnegiert ihn.

Zusammen N Reine boolean erstellen, ob die unser Eingang zeigt durch die TOS teilbar ist.

Wir speichern eine Kopie dieses Booleschen O @ B K UWerts im Speicherbereich -2 mit und rufen den Wert aus dem Speicherbereich -2 mit auf @ A K T.

Wir tauschen die beiden obersten Elemente mit aus, Qum sicherzustellen, dass der Boolesche Wert oben ist, und geben den Wert aus, wenn der Boolesche Wert mit true ist ^ X.

Wenn der Boolesche Wert falsch war, muss ein zusätzlicher Wert gelöscht werden, damit wir uns an den Booleschen Wert erinnern, den wir in Raum -2 gespeichert haben, @ B K Tund einen Wert einfügen, wenn er falsch ist R ^ P.

Wir duplizieren den Eingabewert mit Ound subtrahieren den Wert im Speicher -1 mit @ A K T K. Wenn dies Null ist, verlassen wir R ^ _.

Zuletzt haben wir @ ^dies übersprungen, was auch immer der nächste Wert ist. Wir brauchen das, weil es eine Menge Müll gibt (eigentlich nur ein @Symbol), der durch den sichtbaren Teil des Codes erzeugt wird.

Sobald es das Ende erreicht, kehrt es zum Anfang zurück.

Wie es auf hohem Niveau funktioniert

Die Grundidee ist, dass wir einen Wert haben, der hauptsächlich an der Speicherstelle -1 gespeichert ist und der bei jeder Schleife erhöht wird. Wenn dieser Wert unsere Eingabe teilt, geben wir ihn aus, und wenn beide gleich sind, beenden wir die Ausführung.

Fortschritte in Richtung Brain-Flak

Da Whitespace nicht zum Unterschied zählt, konnte ich den Code ändern, ohne meine 15 Punkte auszugeben, und daher wurden alle in den Brain-Flak-Code investiert.

Hier ist unser aktueller Stand.

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

Antwort 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∩
\

Probieren Sie es online!

(Es gibt wahrscheinlich viele unnötige Whitespaces, aber ich kann mich momentan nicht darum kümmern, Golf zu spielen.)

Ich habe alle 15 für das Befunge-Programm verwendet, also diesmal keine Änderungen am Brain-Flak.

Meine Hauptstrategie bestand darin, die IP vertikal zu senden und mit Leerzeichen bestimmte Zeichen aus dem bereits vorhandenen Code auszuführen.

Erläuterung:

Der Code, der für das Befunge-Programm von Bedeutung ist, lautet wie folgt:

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

Welches ist gleichbedeutend mit:

&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

Antwort 2 - Python 3 , 5

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

Probieren Sie es online!

Antwort 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”

Erläuterung:

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

Hinweis: Der Interpreter muss derzeit durch das \ns ersetzt ¶werden, damit es nicht als Eingabe gezählt wird. Der Parser selbst betrachtet beide als austauschbar.

Antwort 11, Eigentlich 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∩

Probieren Sie es online!

Erläuterung

Hat eigentlich ein schönes eingebautes ÷ um die Faktoren einer Zahl zu finden, jedoch dürfen wir solche Builtins nicht verwenden.

Ich beginne damit, die Eingabe in den Registern zu speichern, damit sie von dem, was kommen wird, unbeschadet bleibt. Ich mache das mit╩ aber ich hätte genauso gut einen der anderen verfügbaren Befehle verwenden können.

Dann füge ich den Code ein, den wir bereits hatten (ich habe das gesamte Leerzeichen entfernt, weil es ärgerlich war, damit zu arbeiten, ich kann das tun, weil "Leerzeichen nicht zählen"). Zum Glück macht dies eine ganze Menge nichts, wenn der Stapel leer ist.

Dann haben wir den Rest des Programms

╜   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

Arbeiten Sie in Richtung Brain-Flak

All das hat funktioniert und ich konnte nur eine zusätzliche Paren bekommen.

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

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

Ursprünglich hatte @Wheat Wizard den Brain-Flak-Classic-Code wie in Antwort 22 gepostet:

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

Das sind 17 Zeichen weniger. Allerdings konnte ich diese komprimieren, indem ich einfach {})den vorgeschlagenen Code weiter nach rechts bewegte , um sie zu bekommen

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

Welches ist nur 13 Zeichen aus! Also habe ich nur Klammern hinzugefügt / entfernt, um den vorgeschlagenen Code zu erhalten.

Der ursprüngliche Code, den ich gepostet habe, war ein Tippfehler, er wurde behoben. ( Danke @WheatWizard! )

Antwort 1 - Python 2.7

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

Entfernung: NA - Erste Antwort

Probieren Sie es online!

22, Sprache , 15

Lenguage ist ein Esolang, der sich nur darum kümmert, wie lange sich das Programm nicht um den Inhalt kümmert. So können wir jedes gewünschte Sprachenprogramm erstellen, indem wir das letzte Programm mit dem richtigen Leerzeichen auffüllen. Die Sprache ist in Brainfuck kompiliert, daher werden wir das vor einiger Zeit geschriebene Brainfuck-Programm wiederverwenden

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

Ich habe einige Änderungen am Hauptprogramm vorgenommen, um spätere Antworten zu erleichtern, aber das Endergebnis sieht so aus:

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

wo <SPACES> steht 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 Leerzeichen.

Missbrauche ich das Leerzeichen, zählt die Regel nicht? Vielleicht.

Arbeiten Sie in Richtung Brain-Flak Classic

Wir hatten alle diese Parens schon da, also dachte ich, ich würde uns auf den Weg in Richtung Brain-Flak Classic machen.

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