Antwortverkettung - Positive Teiler einer Zahl

13

Diese Herausforderung in die 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>

Mr. Xcoder
quelle
15 werden funktionieren, 10 ist jedoch Standard. Ich würde allerdings sagen, dass es bei 15 bleiben soll, da dies schwieriger ist als die meisten anderen.
9.
2
Ich hoffe, es macht dir nichts aus, aber ich habe einen Entfernungsrechner am Ende des Beitrags hinzugefügt :-)
ETHproductions
2
Diese Zusammenarbeit in Richtung Brainfuck ist wunderschön :)
Walfrat
6
WICHTIG: Bitte bearbeiten Sie die Bestenliste, wenn Sie einen
Beitrag einreichen,
2
Es ist großartig zu sehen, wie die Leute die Antworten von Python zu Brain-Flak bringen, mit einer großartigen Zusammenarbeit, von einer weit verbreiteten Sprache zu einer der dunkelsten Programmiersprachen, die jemals erstellt wurden. Vielen Dank an alle, die das möglich gemacht haben! Jetzt bin ich wirklich gespannt, was mit dieser Herausforderung passiert, da DjMcMayhem ein Kopfgeld darauf ausgesetzt hat.
Mr. Xcoder

Antworten:

12

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!

Post Rock Garf Hunter
quelle
6
Endlich Brain Flak! Vielen Dank an alle, die zur Erreichung dieses Ziels beigetragen haben! Wir gratulieren Wheat Wizard zum Benutzer mit den meisten Antworten und zu der großartigen Arbeit und Zeit, die er für diese Herausforderung aufgewendet hat!
Mr. Xcoder
7

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)
Rɪᴋᴇʀ
quelle
2
MATLs %machen es wirklich schwer, fortzufahren. Viel Glück für andere und ich hoffe wirklich, dass diese Herausforderung hier nicht "stirbt"!
Mr. Xcoder
Ist das nicht mit einem eingebauten?
Jonathan Allan
@ JonathanAllan Nein, definitiv nicht. Der eingebaute Teiler für Divisoren ist Z\. Der relevante Code hier ist der :tGw\~)(den ich im Chat geschrieben habe, kein eingebauter)
DJMcMayhem
In der Tat gibt es keine eingebauten
Mr. Xcoder
1
@ JonathanAllan Die Tabelle kann ein wenig verwirrend sein. Z\ist nicht \"Teiler". Die Überschrift in den letzten drei Spalten zeigt das Präfix ( X, Yoder Z). \an sich ist die erste Spalte, dh "mod"
Luis Mendo
7

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
ETHproductions
quelle
6

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:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Post Rock Garf Hunter
quelle
6

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

((({})<>)){((({}[()] (({})(<>))      ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
ETHproductions
quelle
Wirklich neugierig zu sehen, wer die Brain-Flak-Antwort einreichen wird, falls es jemals passiert.
Mr. Xcoder
Wir kommen näher. Wir sollten dort mit Antwort 20 sein (wenn nicht früher)
CalculatorFeline
Wir haben noch 54 Zeichen vor uns ...
ETHproductions
Nun, wir sind ungefähr auf halbem Weg, und das steht bei Antwort 8, also sollten wir gegen 18 fertig sein.
CalculatorFeline
6

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

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          ) {})}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Lynn
quelle
6

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)

)({}((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{            )   )  {(          ) {})}{}
 (  (( {})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Riley
quelle
Wir sind eigentlich nur 30 weg. statt die zusätzlichen 4 Zeichen Weglassen Sie transformieren können , )({}(((um ()({})((auf Kosten von nur zwei, das ist nicht das genaue Programm , das wir im Sinne hatten , aber ()und ({})sind beide nicht-ops in diesem Zusammenhang.
Post Rock Garf Hunter
@ WheatWizard Schön! Ich habe den eigentlichen Code nicht angesehen, sondern nur den Entfernungsmesser in der Frage durchlaufen.
Riley
5

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.

Jonathan Allan
quelle
5

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:

((({})<>)){((({}     ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
LegionMammal978
quelle
5

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!

Post Rock Garf Hunter
quelle
5

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
Riley
quelle
5

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

MickyT
quelle
4

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.

Post Rock Garf Hunter
quelle
1
+1 auch nachdem OP sagte, dass Python fertig war, anscheinend nicht ....
HyperNeutrino
4

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.

Nick Clifford
quelle
Irgendeine Arbeit in Richtung Brain-Flak hier?
CalculatorFeline
@ CalculatorFeline Angst nicht.
Nick Clifford
Schade. 10 Zeichen in Richtung Brainflak! Wenn nur.
CalculatorFeline
4

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

((({})<>)){((({}[()] ((  )   )       ((             <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Riley
quelle
+1 bringt den Wettbewerb einen Schritt näher an Brain-Flak. Nur eine Frage: Kennen Sie eine Programmiersprache, die Seriously sehr ähnlich ist?
Mr. Xcoder
Anders als eigentlich.
Mr. Xcoder
@ Mr.Xcoder habe ich noch nicht benutzt. Ich wusste nur, dass Seriously so ähnlich ist, weil Actually nur Seriously Version 2.0 ist
Riley
4

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.

((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}     <>                 )   )  {(          )  })}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Post Rock Garf Hunter
quelle
Bitte aktualisieren Sie die Bestenliste jedes Mal, wenn Sie eine Antwort senden.
Mr. Xcoder
Nur noch 39 Zeichen für die Brain-Flak-Antwort! :) Das heißt, wir brauchen noch mindestens 3 Antworten ...
HyperNeutrino
4

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
MilderMilquetoast
quelle
3

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!

Jonathan Allan
quelle
Jetzt haben Sie die Antwortliste in Python geschlossen. Gut!
Mr. Xcoder
@ Mr.Xcoder Was ist, wenn jemand Python 3.5 verwendet und das asyncoder die awaiteingebauten Programme verwendet ? Wäre das eine ganz andere Sprache?
HyperNeutrino
3

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.

dzaima
quelle
3

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.

((({})<>)){((({}   ] ((  )   )       (              <              )           (          )   )}{}
((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{(<{}<>{}<>>)}{})}{}
Post Rock Garf Hunter
quelle
Weißt du, wenn wir den Brain-Flak-Code in []uns aufnehmen, können wir den Brainfcuk-Code danach haben. Könnte Möglichkeiten eröffnen.
CalculatorFeline
@CalculatorFeline Ich glaube nicht, dass wir es tun. Brain-Flak allein macht im Brainfuck so gut wie nichts. Einreichen in Brainfuck wäre sehr schwierig, aber ich glaube nicht, dass Brain-Flak es schaden wird.
Post Rock Garf Hunter
Nun, Brainfuck-Planung wäre zu diesem Zeitpunkt eine gute Idee. Bytes, die nicht in Richtung Flak gehen können, können in andere Planungen (wie BF, Syms oder herkömmliche Sprachen) eingefügt werden.
CalculatorFeline
@CalculatorFeline Die Sache ist, dass es so gut wie keine Bytes gibt, die nicht in Richtung Brain-Flak gehen können. Sofern eine Sprache keine ziemlich seltsamen Regeln für Parens hat (in diesem Fall ist sie wahrscheinlich bereits unbrauchbar), können wir zusätzliche Bytes zum Einfügen von Parens verwenden.
Post Rock Garf Hunter
Warum gibt Ihr Code eine zusätzliche 0 vor dem Array aus?
Mr. Xcoder
3

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! )

MilderMilquetoast
quelle
3

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!

Mr. Xcoder
quelle
1

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.

()({})((({})<>)){((({}[()]<(({})(<>))><>)<{(({})){({}[()])<>}{}}{}<>({<({}[]         {})><>)<>{(<{}<>{}<>>)}{})}{}
()({})((({})<>)){((({}[  ]<(({})(<>))><>)<{(({})){({}[  ])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{(<{}<>{}<>>)}{})}{}
Post Rock Garf Hunter
quelle
Ein weiteres Ziel ... Das ist Wahnsinn. Ich mag das!
Mr. Xcoder
Also haben wir die obere Reihe von Brain-Flak Classic und die untere brauchen wir?
MildlyMilquetoast
@ MistahFiggins yes
Post Rock Garf Hunter
1
Tada! Brain-Flak Classic ist näher, weil ich einige Parens
verschoben habe