Este desafío de encadenamiento de respuestas ha terminado oficialmente, lo que resulta en la victoria de Wheat Wizard , con un total de 7 respuestas. Cualquier otra respuesta es bienvenida, pero no influirá en la respuesta aceptada para este desafío, ni en el ganador.

Tarea:

Imprima todos los divisores positivos de un número xtomado como entrada.

Entrada:

Un número único xque es el número (en base 10) cuyos divisores positivos deben calcularse.

Salida:

Todos los divisores positivos de x. Se permite cualquier formato, incluyendo \n, ,, ;y un espacio en blanco como separadores, siempre y cuando que es comprensible. La salida también puede ser una matriz de enteros o cadenas (por ejemplo:) [1, 2, 3, 5, 30]. Puede generar los divisores en stdout, consola o el equivalente en su idioma o pueden ser devueltos desde una función .

Reglas

• Un usuario no puede responder dos veces seguidas
• Su respuesta puede eliminar, agregar o reemplazar como máximo 15 caracteres de la respuesta anterior (el espacio en blanco no cuenta), además de la Respuesta 2, que puede "transformar" hasta 20 caracteres para comenzar
• No está permitido publicar una respuesta en un lenguaje de programación que ya tenga una respuesta, la excepción es una versión completamente diferente de ese idioma (por ejemplo: si publico una respuesta en Python 2.7, puede enviar una en Python 3, pero no en Python 2.6)
• Las lagunas estándar no están permitidas
• No está permitido usar elementos integrados para obtener divisores , por el bien de este desafío
• Usted debe incluir el número de la respuesta y el nombre del idioma en el título de la pregunta y el número de caracteres cambiado desde la anterior respuesta

Puntuación

El usuario con la mayor cantidad de envíos una vez que las cosas se resuelven gana. En caso de empate, gana el usuario con la puntuación más alta en una de sus respuestas. Si también hay un empate en el puntaje, entonces el usuario con el envío más antiguo (la respuesta con el puntaje más alto) será declarado ganador.

Nota: "liquidar" <=> 7 han pasado 3 días desde que se envió la última respuesta

Ejemplos:

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]

O cualquier otro resultado equivalente que satisfaga las condiciones mencionadas.

Nota final : esta pregunta es mejor si ordena las respuestas por las más antiguas. Publicaré la primera respuesta en Python 2.7, por lo que debe publicar la segunda respuesta dependiendo de esa. ¡Buena suerte y diviertete!

Tabla de clasificación:

Esta lista puede estar desactualizada, puede editarla:

1) Asistente de trigo [Líder actual 🏆] : 7 respuestas - Python 1.6 , 05AB1E , En realidad , Del | m | t , WSF , Brain-Flak , Lenguage

2) Riley: 3 respuestas - En serio , CJam , 2sable

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

3) ETHproductions: 2 respuestas - Japt , Pyth

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

6) Riker: 1 respuesta - MATL

6) dzaima: 1 respuesta - SOGL 0.8.2

6) LegionMammal978: 1 respuesta - Espacio en blanco

6) Nick Clifford: 1 respuesta - Ohm

6) Lynn: 1 respuesta - GolfScript

6) MickyT: 1 respuesta - Cubix

Calculadora de distancia

Puede usar este fragmento para calcular la distancia entre dos entradas:

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>

Respuesta 20, Brain-Flak , 11

Me gustaría tomar el tiempo para agradecer a todos los que han ayudado a contribuir a este objetivo:

• Riley, 20 bytes

• LegionMammal, 15 bytes

• ETHproductions, 11 bytes

• Lynn, 1 byte

Los siguientes usuarios no pudieron contribuir bytes directamente pero ayudaron de otras maneras:

• Mistah Figgins

• DJMcMayhem

• Feersum

¡Gracias a todos por hacer esto posible!

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

Pruébalo en línea!

Respuesta 3: MATL, Distancia 15

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

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

Pruébalo en línea!

Cambió #b∫I:b;\?ta ò f!vU(10 puntos) y agregó un poco más de código Brain-Flak cambiando ~(()a ((()<>))(5 puntos). Creo que el código en el que estamos trabajando es

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

Explicación

ò           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

Respuesta 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

Pruébalo en línea!

Explicación

Afortunadamente, 05AB1E tiene un intérprete de Python incorporado (más o menos). Para hacer esta carrera empujamos

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

como una cuerda a la cima de la pila. Tenemos que usar literales de cadena en lugar de comentarios aquí porque 05AB1E realmente no le gustan los comentarios en su código de Python. También tenemos que deshacernos del "código original porque hace que la cadena finalice prematuramente.

Una vez que la cadena ha sido empujada, la usamos .epara ejecutarla como código python.

Trabajar hacia Brain-Flak

Pude agregar 5 caracteres adicionales para el objetivo de hacer una respuesta Brain-Flak. Hubiera podido agregar 6 pero, por desgracia, olvidé que los espacios en blanco no cuentan para el puntaje.

Hasta ahora tenemos:

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

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

Pruébalo en línea!

Explicación

Por lo tanto, no sé mucho sobre Pyth, pero lo que sí sé es que el código fuente tiene la forma de un árbol, cada comando lleva un número específico de argumentos a su derecha. El árbol del programa divisor que escribí se ve así:

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

Qes la entrada ftoma dos argumentos, Fy A, y devuelve los artículos Ten Adonde F(T)devuelve un valor Truthy. En este caso, Fes una función que devuelve el NOT lógico de Q%T, y Aes SQ, que crea el rango [1...Q]. Esto tiene el efecto de filtrar solo a los enteros Ten [1...Q]dónde Q%T == 0.

Para evitar analizar el resto del código, todo está envuelto en una cadena, luego |Q"...devuelve el OR lógico de Qy la cadena. Como Qsiempre es positivo, siempre es verdadero y, por lo tanto, siempre regresa del OR lógico.

Trabajar hacia Brain-Flak

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

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

Pruébalo en línea!

Agregué ~:␤),(;{␤\%!},p#, usando nueva línea como un nombre de variable para ajustarse a la restricción de tamaño, y aplasté todo el programa nuevamente en una línea para comentarlo. Esta fue la distancia 14. Luego, agregué {antes }printdivpara Brain-Flak.

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

Trabajar hacia Brain-Flak

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

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

Pruébalo en línea!

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

Trabajar para Brain-Flak (quedan 30)

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

Respuesta 4 - Gelatina , 4

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

Pruébalo en línea!

Código relevante:

Rḍ⁸T

El )actúa como un descanso entre los enlaces en lo que se refiere al programa de análisis (creo).

Lo integrado sería ÆD, en su lugar, esto crea un rango desde 1la entrada con R, comprueba la divisibilidad por la entrada con ḍ⁸, luego devuelve una lista de los índices basados ​​en uno verdadero con T.

Respuesta 9, espacios en blanco, 15

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

Donde <SPACES>se reemplaza por la siguiente cadena, donde Tes 0x09, Les 0x0A y Ses 0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Nueva línea literal añadida para mayor claridad. Notó que las reglas solo especifican caracteres que no son espacios en blanco. No, no pude evitarlo.

Trabajar hacia Brain-Flak

No tengo idea de lo que estaba pasando antes, así que ahora tenemos:

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

Respuesta 18, FSM , 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∩\

(Esto toma entrada y salida a través del código de caracteres)

Explicación

El FSM es esencialmente un ataque mental, excepto que utiliza espacios en blanco en lugar del conjunto habitual de operadores de ataque mental. Aquí está el código descompilado en brainfuck:

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

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

Progreso hacia Brain-Flak

Como WSF es solo un espacio en blanco, pude agregar 15 caracteres más al código Brain-Flak. Esto nos pone a 15 de distancia de la respuesta, así que siéntase libre de publicarla.

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

Como no voy a poder publicar la respuesta Brain-flak, pensé que me tomaría el tiempo para agradecer a todos los que han ayudado a contribuir a este objetivo:

• Riley, 16 bytes

• LegionMammal, 15 bytes

• ETHproductions, 11 bytes

• Lynn, 1 byte

Los siguientes usuarios no pudieron contribuir bytes directamente pero ayudaron de otras maneras:

• Mistah Figgins

¡Gracias a todos por hacer esto posible!

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

Pruébalo en línea!

Eliminé el espacio en blanco adicional, envolví todo lo que existía antes en una cadena, luego:

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

Respuesta 21, Cubix , 15

Finalmente logré encajar esto :) Afortunadamente es después de que la respuesta de Brain-Flak se hizo, porque creo que habría obstaculizado. Necesitaba los 15 completos para implementar.

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

Esto se asigna al siguiente cubo

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

Puede probarlo aquí , pero deberá pegarlo. Sospecho que algunos de los especiales están causando problemas para el enlace permanente.

El código es esencialmente más de 2 líneas. Las partes importantes son:

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

I s )Esto obtiene la entrada, intercambia la parte superior de la pila (0 habría funcionado también) e incrementa
% ?Obtener el mod y probar. Si 0 continúa adelante o baja a la redirección
; O N o gota los resultados mod y la salida el número seguido de una nueva línea
ugiro en U en la línea de abajo
Siguiendo está en orden ejecutada
; - ! @ Quitar el 10 de pila, el número de resta de la entrada, prueba y terminará si cero
< ; uRedireccionar objetivo para la primera prueba. Retire la parte superior de la pila (ya sea mod o resta el resultado) y gire en U hacia atrás para aumentar

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

Quité el % símbolos y comenté la primera línea y un poco de la última línea. Esto solo me costó 10 de mis 15 puntos. Sin embargo, todavía no había terminado; como Python 1 no tiene +=tuve que reemplazari+=1 con un i=i+1costo adicional de 3 puntos. Como me quedaban 2, también agregué ((al principio. Estoy planeando hacer una presentación en Brain-Flak más tarde y necesito padres.

Respuesta 10, ohmios , distancia 5

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

...dónde <SPACES> se reemplaza por esa cadena monstruosa de la respuesta de espacios en blanco .

Una respuesta un poco descarada, ya que todo lo demás es solo un cable que no se ejecuta.

Respuesta 12, en serio , 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∩

Pruébalo en línea!

La única diferencia de la realidad respuesta de es que Gravemente usa backticks para marcar una función donde Actually usa ⌠y⌡ simplemente hacemos los caracteres adicionales en una cadena y luego los sacamos y descartamos.

Trabajar hacia Brain-Flak

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

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

Pruébalo en línea!

Explicación

Realmente estoy empezando a abusar del hecho de que los espacios en blanco no se cuentan para la diferencia aquí. A Del | m | t realmente no le importa mucho qué caracteres tiene, por lo que la gran mayoría del código es una secuencia de espacios y retornos de carro al comienzo del programa. Las partes visibles reales del código no se ejecutan en absoluto.

Aquí está el código transcrito de una manera más "razonable":

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

Pruébalo en línea!

Cómo funciona en el nivel bajo

Para empezar tenemos O R ^ V esto sirve para tomar la entrada en el primer bucle y funciona como no operativo en todas las demás ocasiones.

Luego usamos O para hacer una copia de la entrada para más tarde.

@ A K T recuerda la variable almacenada en la posición de memoria -1 (al comienzo del programa esto es 0) y A J incrementa. O @ A K UAlmacena el valor ahora incrementado nuevamente en la posición de memoria -1 para nuestro próximo ciclo.

Ncalcula el mod de la copia de la entrada que hicimos hace un tiempo y el valor recién recuperado de la memoria y lo Rniega.

Juntos N Rcrean un booleano que indica si nuestra entrada es divisible por los TOS.

Almacenamos una copia de este booleano en el espacio de memoria -2 usando O @ B K U y recuperamos el valor del espacio de memoria -2 usando @ A K T.

Intercambiamos los dos elementos superiores con Q para garantizar que el booleano esté en la parte superior y genere el valor si el booleano es verdadero usando^ X .

Si el booleano era falso, tenemos un valor adicional que debe ser erradicado, por lo que recordamos el booleano que almacenamos en el espacio -2 @ B K Ty sacamos un valor si es falsoR ^ P .

Duplicamos el valor de entrada con Oy restamos el valor en la memoria -1 con @ A K T K. Si esto es cero salimosR ^ _ .

Por último, tenemos @ ^estos saltos sea cual sea el siguiente valor. Necesitamos esto porque hay un montón de basura (en realidad solo un@ símbolo) generada por la parte visible del código.

Una vez que llega al final, vuelve al principio.

Cómo funciona a alto nivel

La idea básica es que tenemos un valor almacenado principalmente en la ubicación de memoria -1 que se incrementa cada vez que hacemos un bucle. Si ese valor divide nuestra entrada, la sacamos y cuando los dos son iguales, finalizamos la ejecución.

Progreso hacia Brain-Flak

Debido a que el espacio en blanco no cuenta para la diferencia, pude cambiar el código sin gastar ninguno de mis 15 puntos y, por lo tanto, todos ellos se invirtieron en el código Brain-Flak.

Aquí está nuestra posición actual.

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

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

Pruébalo en línea!

(Probablemente haya muchos espacios en blanco innecesarios, pero no puedo molestarme en jugar golf ahora mismo)

Usé los 15 para el programa Befunge, por lo que esta vez no hubo cambios en el Brain-flak.

Mi estrategia principal para esto fue enviar la dirección IP verticalmente y usar espacios en blanco para ejecutar ciertos caracteres del código preexistente.

Explicación:

El código que le importa al programa Befunge es este:

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

Lo que es equivalente a:

&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

Respuesta 2 - Python 3 , 5

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

Pruébalo en línea!

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

Explicación:

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

Nota: el intérprete actualmente necesita que \nse reemplace el s ¶para no contarlo como entrada, pero el analizador considera ambos intercambiables.

Respuesta 11, en realidad , 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∩

Pruébalo en línea!

Explicación

En realidad, tiene un buen componente ÷para encontrar los factores de un número, sin embargo, no se nos permite usar dichos componentes.

Comienzo almacenando la entrada en los registros para que no se vea afectada por lo que está por venir. Hago esto usando ╩pero podría haber usado con la misma facilidad uno de los otros comandos disponibles.

Luego pego el código que ya teníamos (eliminé todo el espacio en blanco porque era molesto trabajar con él, puedo hacerlo porque "el espacio en blanco no cuenta"). Afortunadamente, esto no hace nada cuando la pila está vacía.

Luego tenemos el resto del programa.

╜   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

Trabajar hacia Brain-Flak

Todo ese trabajo y solo pude obtener un par extra.

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

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

Originalmente, @Wheat Wizard había publicado el código brain-flak-classic tal como estaba en la respuesta 22:

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

Esto tiene 17 caracteres de descuento. Sin embargo, pude comprimir esto simplemente moviéndome {})más a la derecha en el código propuesto para obtener

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

¡Que solo tiene 13 caracteres! Entonces, todo lo que hice fue agregar / quitar corchetes para obtener el código propuesto.

El código original que publiqué tenía un error tipográfico, ahora está arreglado. (¡ Gracias @WheatWizard! )

Respuesta 1 - Python 2.7

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

Distancia: NA - Primera respuesta

Pruébalo en línea!

22, Lenguage , 15

Lenguage es un esolang que solo se preocupa por cuánto tiempo el programa no se trata de su contenido. Por lo tanto, podemos crear cualquier programa de lenguaje que queramos rellenando el último programa con la cantidad adecuada de espacios en blanco. Lenguage se compila en brainfuck, por lo que reutilizaremos el programa brainfuck que escribí hace un tiempo

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

Hice algunos cambios en el programa principal para facilitar respuestas posteriores, pero el resultado final se ve así:

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

donde <SPACES>representa 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 caracteres de espacio.

¿Estoy abusando del espacio en blanco no cuenta la regla? Quizás.

Trabaja hacia Brain-Flak Classic

Ya teníamos a todos esos padres allí, así que pensé en comenzar en el camino hacia Brain-Flak Classic.

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