Ce défi de chaînage des réponses est officiellement terminé, entraînant la victoire de Wheat Wizard , avec un total de 7 réponses. Toute autre réponse est la bienvenue, mais elle n'influencera pas la réponse acceptée pour ce défi, ni le gagnant.

Tâche:

Imprime tous les diviseurs positifs d'un nombre xpris en entrée.

Contribution:

Un nombre unique xqui est le nombre (en base 10) dont les diviseurs positifs doivent être calculés.

Production:

Tous les diviseurs positifs de x. Tous les formats sont permis, y compris \n, ,, ;et les espaces comme séparateurs, aussi longtemps qu'il est compréhensible. La sortie peut également être un tableau d'entiers ou de chaînes (par exemple:) [1, 2, 3, 5, 30]. Vous pouvez sortir les diviseurs vers stdout, console ou l'équivalent dans votre langue ou ils peuvent être renvoyés depuis une fonction .

Règles

• Un utilisateur ne peut pas répondre deux fois de suite
• Votre réponse peut supprimer, ajouter ou remplacer au plus 15 caractères de la réponse précédente (les espaces ne comptent pas), en plus de la réponse 2 qui peut "transformer" jusqu'à 20 caractères pour commencer.
• Vous n'êtes pas autorisé à publier une réponse dans un langage de programmation qui a déjà une réponse, l'exception étant une version complètement différente de ce langage (par exemple: si je poste une réponse en Python 2.7, vous pouvez en soumettre une en Python 3, mais pas en Python 2.6)
• Les échappatoires standard ne sont pas autorisées
• Vous n'êtes pas autorisé à utiliser les fonctions intégrées pour obtenir des diviseurs , pour ce défi
• Vous devez inclure le numéro de la réponse et le nom de la langue dans le titre de la question et le nombre de caractères modifiés par rapport à la réponse précédente

Notation

L'utilisateur avec le plus de soumissions une fois les choses réglées gagne. En cas d'égalité, l'utilisateur avec le score le plus élevé sur l'une de ses réponses l'emporte. S'il y a également égalité au score, l'utilisateur avec la soumission la plus ancienne (la réponse la plus ancienne la plus élevée) sera déclaré vainqueur.

Remarque: "régler" <=> 7 3 jours se sont écoulés depuis la soumission de la dernière réponse

Exemples:

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]

Ou toute autre sortie équivalente satisfaisant aux conditions mentionnées.

Note finale : Cette question est meilleure si vous triez les réponses par les plus anciennes. Je publierai la première réponse en Python 2.7, vous devriez donc publier la deuxième réponse en fonction de celle-ci. Bonne chance et amusez-vous bien!

Classement:

Cette liste peut être obsolète, n'hésitez pas à la modifier:

1) Wheat Wizard [Current Leader 🏆] : 7 réponses - Python 1.6 , 05AB1E , en fait , Del | m | t , WSF , Brain-Flak , Lenguage

2) Riley: 3 réponses - Sérieusement , CJam , 2sable

3) Jonathan Allan: 2 réponses - Python 3 , Jelly

3) Productions ETH: 2 réponses - Japt , Pyth

3) Mistah Figgins: 2 réponses - Befunge-98 , Brain-Flak Classic

6) Riker: 1 réponse - MATL

6) dzaima: 1 réponse - SOGL 0.8.2

6) LegionMammal978: 1 réponse - Whitespace

6) Nick Clifford: 1 réponse - Ohm

6) Lynn: 1 réponse - GolfScript

6) MickyT: 1 réponse - Cubix

Calculateur de distance

Vous pouvez utiliser cet extrait de code pour calculer la distance entre deux entrées:

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>

Réponse 20, Brain-Flak , 11

Je voudrais juste prendre le temps de remercier tous ceux qui ont contribué à atteindre cet objectif:

• Riley, 20 octets

• LegionMammal, 15 octets

• ETHproductions, 11 octets

• Lynn, 1 octet

Les utilisateurs suivants n'ont pas pu contribuer directement en octets, mais ont apporté leur aide par d'autres moyens:

• Mistah Figgins

• DJMcMayhem

• feersum

Merci à tous d'avoir rendu cela possible!

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

Essayez-le en ligne!

Réponse 3: MATL, Distance 15

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

Réponse 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”

Essayez-le en ligne!

Changé #b∫I:b;\?ten ò f!vU(10 points) et ajouté un peu plus de code Brain-Flak en changeant ~(()en ((()<>))(5 points). Je crois que le code vers lequel nous travaillons est

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

Explication

ò           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

Réponse 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

Essayez-le en ligne!

Explication

Heureusement, 05AB1E a un interpréteur Python intégré (en quelque sorte). Afin de faire cette course, nous poussons

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

sous forme de chaîne en haut de la pile. Nous devons utiliser des chaînes de caractères au lieu de commentaires ici car 05AB1E n'aime vraiment pas les commentaires dans son code Python. Nous devons également nous débarrasser de "dans le code d'origine car cela provoque la fin prématurée de la chaîne.

Une fois la chaîne poussée, nous l' .eexécutons en tant que code python.

Travailler vers Brain-Flak

J'ai pu ajouter 5 caractères supplémentaires dans le but de faire une réponse Brain-Flak. J'aurais pu ajouter 6 mais hélas j'ai oublié les blancs ne comptent pas pour le score de points.

Jusqu'à présent, nous avons:

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

Réponse 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∩

Essayez-le en ligne!

Explication

Je ne connais donc pas beaucoup Pyth, mais ce que je sais, c'est que le code source est sous la forme d'un arbre, chaque commande prenant un nombre spécifique d'arguments à sa droite. L'arbre du programme de diviseur que j'ai écrit ressemble à ceci:

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

Qest l'entrée. fprend deux arguments, Fet A, et renvoie les éléments Tdans Alesquels F(T)renvoie une valeur véridique. Dans ce cas, Fest une fonction qui renvoie le NON logique de Q%T, et Aest SQ, qui crée la plage [1...Q]. Cela a pour effet de filtrer uniquement les entiers Tdans [1...Q]où Q%T == 0.

Afin d'éviter d'analyser le reste du code, le tout est encapsulé dans une chaîne, puis |Q"...retourne le OU logique de Qet la chaîne. Puisque Qest toujours positif, il est toujours véridique et est donc toujours renvoyé par le OU logique.

Travailler vers Brain-Flak

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

Réponse 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∩\

Essayez-le en ligne!

J'ai ajouté ~:␤),(;{␤\%!},p#, en utilisant la nouvelle ligne comme nom de variable pour s'adapter à la contrainte de taille, et j'ai replié le programme entier sur une seule ligne pour le commenter. C'était la distance 14. Ensuite, j'ai ajouté {avant }printdivpour Brain-Flak.

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

Travailler vers Brain-Flak

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

Réponse 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∩\

Essayez-le en ligne!

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

Travailler vers Brain-Flak (30 à faire)

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

Réponse 4 - Gelée , 4

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

Essayez-le en ligne!

Code pertinent:

Rḍ⁸T

le ) d'une rupture entre les liens en ce qui concerne l'analyseur (je crois).

Le intégré serait ÆD, au lieu de cela, cela crée une plage de 1à l'entrée avecR , vérifie la divisibilité par l'entrée avec ḍ⁸, puis retourne une liste des index basés sur un véridique avec T.

Réponse 9, Espace blanc, 15

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

Où <SPACES>est remplacé par la chaîne suivante, où Test 0x09, Lest 0x0A etS est 0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Ajout d'une nouvelle ligne littérale pour plus de clarté. A remarqué que les règles ne spécifient que des caractères non blancs. Non, je ne pouvais pas m'en empêcher.

Travailler vers Brain-Flak

Je n'ai aucune idée de ce qui se passait plus tôt, nous avons donc maintenant:

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

Réponse 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∩\

(Cela prend l'entrée et la sortie via le code de caractère)

Explication

WSF est essentiellement brainfuck, sauf qu'il utilise des espaces au lieu de l'ensemble d'opérateurs habituel de brainfuck. Voici le code décompilé en brainfuck:

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

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

Progrès vers Brain-Flak

Étant donné que WSF n'est qu'un espace blanc, j'ai pu ajouter 15 caractères supplémentaires au code Brain-Flak. Cela nous place à 15 de la réponse, alors n'hésitez pas à la poster.

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

Comme je ne vais pas pouvoir publier moi-même la réponse de Brain-flak, j'ai pensé que je prendrais juste le temps de remercier tous ceux qui ont contribué à cet objectif:

• Riley, 16 octets

• LegionMammal, 15 octets

• ETHproductions, 11 octets

• Lynn, 1 octet

Les utilisateurs suivants n'ont pas pu contribuer directement en octets, mais ont apporté leur aide par d'autres moyens:

• Mistah Figgins

Merci à tous d'avoir rendu cela possible!

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

Essayez-le en ligne!

J'ai supprimé l'espace blanc supplémentaire, enveloppé tout ce qui existait auparavant dans une chaîne, puis:

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

Réponse 21, Cubix , 15

Enfin réussi à intégrer cela :) Heureusement, c'est après que la réponse de Brain-Flak a été faite, parce que je pense que j'aurais gêné. J'avais besoin des 15 pour mettre en œuvre.

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

Cela correspond au cube suivant

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

Vous pouvez l'essayer ici , mais vous devrez le coller. Je soupçonne que certaines des offres spéciales causent des problèmes pour le permalien.

Le code est essentiellement sur 2 lignes. Les parties importantes sont:

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

I s )Cela obtient l'entrée, échange le haut de la pile (0 aurait aussi bien fonctionné) et incrémente
% ?Obtenez le mod et testez. Si 0 carry sur l' avant ou descendre à la redirection
; O N obaisse des résultats mod et de sortie le nombre suivi d'un saut de ligne
udemi - tour sur la ligne ci - dessous
suivant est en ordre exécuté
; - ! @ Retirez le 10 de la pile, le numéro Soustraire de l' entrée, le test et fin si nul
< ; uRediriger la cible pour le premier test. Supprimer le haut de la pile (mod ou soustraire le résultat) et revenir en arrière pour incrémenter

Réponse 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”

J'ai supprimé les %symboles et commenté la première ligne et un peu de la dernière ligne. Cela seul m'a coûté 10 de mes 15 points. Cependant je n'avais pas encore fini; puisque Python 1 n'a pas, +=je devais remplacer i+=1par i=i+1me coûter 3 points supplémentaires. Comme il m'en restait 2, j'ai également ajouté ((au début. Je prévois de faire une soumission dans Brain-Flak plus tard et j'ai besoin de parens.

Réponse 10, Ohm , distance 5

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

... où <SPACES>est remplacé par cette chaîne monstrueuse du Whitespace réponse .

Une réponse un peu effrontée, car tout le reste n'est qu'un fil qui n'est pas exécuté.

Réponse 12, Sérieusement , 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∩

Essayez-le en ligne!

La seule différence par rapport à la réalité réponse est utilise pour marquer sérieusement des accents graves une fonction qui utilise en fait ⌠et⌡ et nous transformons simplement les caractères supplémentaires en une chaîne, puis nous la .

Travailler vers Brain-Flak

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

Réponse 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∩

Essayez-le en ligne!

Explication

Je commence vraiment à abuser du fait que les espaces blancs ne sont pas pris en compte ici. Del | m | t ne se soucie pas vraiment des caractères qui vous occupent donc la grande majorité du code est une séquence d'espaces et de retours chariot au début du programme. Les parties visibles réelles du code ne sont pas exécutées du tout.

Voici le code transcrit de façon plus "raisonnable":

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

Essayez-le en ligne!

Comment ça marche au bas niveau

Pour commencer, nous avons O R ^ V cela sert à prendre des entrées sur la première boucle et fonctionne comme un no-op toutes les autres fois.

Nous utilisons ensuite Opour faire une copie de l'entrée pour plus tard.

@ A K Trappelle la variable stockée en position mémoire -1 (au début du programme c'est 0) et l' A Jincrémente. O @ A K UStocke la valeur maintenant incrémentée dans la position de mémoire -1 pour notre prochaine boucle.

N calcule le mod de la copie de l'entrée que nous avons effectuée il y a quelque temps et la valeur qui vient d'être rappelée de la mémoire et R nie.

Ensemble N R créez un booléen qui indique si oui ou non notre entrée est divisible par le TOS.

Nous stockons une copie de ce booléen dans l'espace mémoire -2 en utilisant O @ B K Uet rappelons la valeur de l'espace mémoire -2 en utilisant@ A K T .

Nous échangeons les deux premiers éléments avec Qpour nous assurer que le booléen est en haut et émettons la valeur si le booléen est vrai en utilisant^ X .

Si le booléen était faux, nous avons une valeur supplémentaire qui doit être supprimée, nous rappelons donc le booléen que nous avons stocké dans l'espace -2 avec @ B K Tet pop une valeur si elle est fausse R ^ P.

Nous dupliquons la valeur d'entrée avec Oet soustrayons la valeur de la mémoire -1 avec @ A K T K. Si c'est zéro, nous sortons R ^ _.

Enfin, nous avons @ ^ce saut quelle que soit la valeur suivante. Nous en avons besoin car il y a un tas d'ordures (en fait seulement un @symbole) générées par la partie visible du code.

Une fois qu'il a atteint la fin, il revient au début.

Comment ça marche à haut niveau

L'idée de base est que nous avons une valeur principalement stockée à l'emplacement de mémoire -1 qui est incrémentée à chaque boucle. Si cette valeur divise notre entrée, nous la sortons et lorsque les deux sont égales, nous terminons l'exécution.

Progrès vers Brain-Flak

Parce que les espaces blancs ne comptent pas dans la différence, j'ai pu changer le code sans dépenser aucun de mes 15 points et donc tous ont été investis dans le code Brain-Flak.

Voici notre position actuelle.

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

Réponse 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∩
\

Essayez-le en ligne!

(Il y a probablement beaucoup d'espaces inutiles, mais je ne peux pas m'embêter à jouer au golf en ce moment)

J'ai utilisé les 15 pour le programme Befunge, donc pas de changement au Brain-flak cette fois.

Ma stratégie principale pour cela consistait à envoyer l'IP verticalement et à utiliser des espaces pour exécuter certains caractères à partir du code préexistant.

Explication:

Le code qui compte pour le programme Befunge est le suivant:

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

Ce qui équivaut à:

&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

Réponse 2 - Python 3 , 5

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

Essayez-le en ligne!

Réponse 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”

Explication:

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

Remarque: l'interpréteur doit actuellement \nremplacer le s ¶afin de ne pas le compter comme entrée, mais l'analyseur lui-même considère les deux comme interchangeables.

Réponse 11, en fait , 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∩

Essayez-le en ligne!

Explication

A en fait une belle fonction intégrée ÷pour trouver les facteurs d'un nombre, mais nous ne sommes pas autorisés à utiliser de telles fonctions.

Je commence par stocker les entrées dans les registres afin qu'elles ne soient pas endommagées par ce qui va arriver. Je le fais en utilisant, ╩mais j'aurais pu tout aussi facilement utiliser l'une des autres commandes disponibles.

Ensuite, je colle le code que nous avions déjà (j'ai supprimé tous les espaces parce que c'était ennuyeux de travailler avec, je peux le faire parce que "les espaces ne comptent pas"). Heureusement, cela ne fait rien lorsque la pile est vide.

Ensuite, nous avons le reste du programme

╜   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

Travailler vers Brain-Flak

Tout ce travail et je n'ai pu obtenir qu'un seul paren supplémentaire.

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

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

Originally, @Wheat Wizard had posted the brain-flak-classic code as it was on answer 22:

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

This is 17 characters off. However, I was able to compress this by simply moving the {}) further right in the proposed code to get

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

Which is only 13 characters off! So all I did was add/remove brackets to get the proposed code.

The original code I posted had a typo, it's fixed now. (Thanks @WheatWizard!)

Answer 1 - Python 2.7

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

Distance: NA - First answer

Try it online!

22, Lenguage, 15

Lenguage is a esolang that cares only about how long the program is not about its content. So we can create any lenguage program we want by padding the last program with the proper amount of whitespace. Lenguage is compiled into brainfuck so we will reuse the brainfuck program I wrote a while ago

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

I made a few changes to the main program to facilitate later answers, but the end result looks like:

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

where <SPACES> represents 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 space characters.

Am I abusing the whitespace doesn't count rule? Perhaps.

Work towards Brain-Flak Classic

We had all of those parens already there so I thought I would start us along the way towards Brain-Flak Classic.

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