Esse desafio de encadeamento de respostas terminou oficialmente, resultando na vitória do Assistente de Trigo , com um total de 7 respostas. Qualquer outra resposta é bem-vinda, mas não influenciará a resposta aceita para esse desafio, nem o vencedor.

Tarefa:

Imprima todos os divisores positivos de um número xobtido como entrada.

Entrada:

Um único número xque é o número (na base 10) cujos divisores positivos devem ser calculados.

Resultado:

Todos os divisores positivos de x. Qualquer formato é permitido, incluindo \n, ,, ;e espaços em branco como separadores, contanto que é compreensível. A saída também pode ser uma matriz de números inteiros ou seqüências de caracteres (por exemplo:) [1, 2, 3, 5, 30]. Você pode enviar os divisores para stdout, console ou equivalente no seu idioma ou eles podem ser retornados de uma função .

Regras

• Um usuário não pode responder duas vezes seguidas
• Sua resposta pode remover, adicionar ou substituir no máximo 15 caracteres da resposta anterior (o espaço em branco não conta), além da resposta 2, que pode "transformar" até 20 caracteres para começar.
• Você não tem permissão para postar uma resposta em uma linguagem de programação que já tenha uma resposta, a exceção sendo uma versão completamente diferente dessa linguagem (por exemplo: se eu postar uma resposta em Python 2.7, você pode enviá-la Python 3, mas não em Python 2.6)
• Não são permitidas brechas padrão
• Você não tem permissão para usar built-ins para obter divisores , por causa deste desafio
• Você deve incluir o número da resposta e o nome do idioma no título da pergunta e o número de caracteres alterados em relação à resposta anterior.

Pontuação

O usuário com o maior número de envios assim que as coisas resolvem vence. Em caso de empate, o usuário com a maior pontuação em uma das respostas ganha. Se também houver um empate na pontuação, o usuário com o envio mais antigo (resposta mais antiga com pontuação mais alta) será declarado vencedor.

Nota: "liquidar" <=> 7 3 dias se passaram desde que a última resposta foi enviada

Exemplos:

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 qualquer outra saída equivalente que satisfaça as condições mencionadas.

Nota final : Essa pergunta é melhor se você classificar as respostas pelas mais antigas. Vou postar a primeira resposta no Python 2.7, então você deve postar a segunda resposta, dependendo dessa. Boa sorte e divirta-se!

Entre os melhores:

Esta lista pode estar desatualizada, fique à vontade para editá-la:

1) Assistente de Trigo [Líder Atual 🏆] : 7 respostas - Python 1.6 , 05AB1E , Na verdade , Del | m | t , FSM , FSM , Brain-Flak , Lenguage

2) Riley: 3 respostas - Sério , CJam , 2sable

3) Jonathan Allan: 2 respostas - Python 3 , geléia

3) ETHproductions: 2 respostas - Japt , Pyth

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

6) Riker: 1 resposta - MATL

6) dzaima: 1 resposta - SOGL 0.8.2

6) LegionMammal978: 1 answer - Espaço em branco

6) Nick Clifford: 1 resposta - Ohm

6) Lynn: 1 resposta - GolfScript

6) MickyT: 1 resposta - Cubix

Calculadora de distâncias

Você pode usar esse snippet para calcular a distância entre duas 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>

Resposta 20, Flacidez Cerebral , 11

Gostaria de agradecer a todos que ajudaram a contribuir para esse objetivo:

• Riley, 20 bytes

• LegionMammal, 15 bytes

• ETHproductions, 11 bytes

• Lynn, 1 byte

Os seguintes usuários não foram capazes de contribuir com bytes diretamente, mas ajudaram de outras maneiras:

• Mistah Figgins

• DJMcMayhem

• feersum

Obrigado a todos por tornar isso possível!

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

Experimente online!

Resposta 3: MATL, Distância 15

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

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

Experimente online!

Alterou #b∫I:b;\?tpara ò f!vU(10 pontos) e adicionou um pouco mais de código Brain-Flak alterando ~(()para ((()<>))(5 pontos). Acredito que o código para o qual estamos trabalhando é

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

Explicação

ò           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

Resposta 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

Experimente online!

Explicação

Felizmente, o 05AB1E possui um interpretador Python interno (das sortes). Para fazer essa corrida, empurramos

'ò 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 uma string no topo da pilha. Temos que usar literais de string em vez de comentários aqui, porque 05AB1E realmente não gosta de comentários em seu código Python. Também precisamos nos livrar do "código original, pois isso faz com que a string termine prematuramente.

Depois que a string é pressionada, usamos .epara executá-la como código python.

Trabalhe em direção ao Brain-Flak

Consegui adicionar 5 caracteres extras para o objetivo de fazer uma resposta Brain-Flak. Eu seria capaz de adicionar 6, mas infelizmente esqueci que o espaço em branco não conta para a pontuação.

Até agora, temos:

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

Resposta 13, Pitão , 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∩

Experimente online!

Explicação

Portanto, não conheço muito Pyth, mas o que sei é que o código-fonte está na forma de uma árvore, cada comando levando um número específico de argumentos à sua direita. A árvore do programa divisor que escrevi se parece com isso:

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

Qé a entrada. frecebe dois argumentos, Fe A, e retorna os itens Tem Aque F(T)retorna um valor truthy. Nesse caso, Fé uma função que retorna o NOT lógico de Q%Te Aé SQ, que cria o intervalo [1...Q]. Isso tem o efeito de filtrar apenas os números inteiros Tem [1...Q]onde Q%T == 0.

Para evitar a análise do restante do código, a coisa toda é agrupada em uma sequência de caracteres e, em seguida, |Q"...retorna o OR lógico Qe a sequência de caracteres. Como Qsempre é positivo, é sempre verdade e, portanto, sempre é retornado do OR lógico.

Trabalhe em direção ao Brain-Flak

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

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

Experimente online!

Eu adicionei ~:␤),(;{␤\%!},p#, usando newline como um nome de variável para ajustar a restrição de tamanho, e agrupei o programa inteiro de volta em uma linha para comentar. Essa era a distância 14. Então, eu adicionei {antes }printdivpara o Brain-Flak.

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

Trabalhe em direção ao Brain-Flak

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

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

Experimente 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

Trabalhe em direção ao Brain-Flak (falta 30)

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

Resposta 4 - Geléia , 4

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

Experimente online!

Código relevante:

Rḍ⁸T

A )atua como uma pausa entre as ligações, tanto quanto o analisador está em causa (eu acredito).

O interno seria ÆD, em vez disso, isso cria um intervalo da 1entrada com R, verifica a divisibilidade pela entrada com e ḍ⁸, em seguida, retorna uma lista dos verdadeiros índices baseados em T.

Resposta 9, Espaço em branco, 15

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

Onde <SPACES>é substituído pela seguinte cadeia, onde Té 0x09, Lé 0x0A e Sé 0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Nova linha literal adicionada para maior clareza. Observe que as regras especificam apenas caracteres que não são de espaço em branco. Não, não pude evitar.

Trabalhe em direção ao Brain-Flak

Não tenho ideia do que estava acontecendo antes, então agora temos:

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

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

(Isso recebe entrada e saída via código de caractere)

Explicação

O FSM é essencialmente um cérebro, exceto que usa espaço em branco em vez do conjunto usual de operadores do cérebro. Aqui está o código descompilado em brainfuck:

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

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

Progresso em direção ao Brain-Flak

Como o FSM é apenas espaço em branco, pude adicionar mais 15 caracteres ao código Brain-Flak. Isso nos coloca a 15 minutos da resposta, então fique à vontade para publicá-la.

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

Como não vou postar a resposta do Brain-flak, pensei em agradecer a todos que ajudaram a contribuir para esse objetivo:

• Riley, 16 bytes

• LegionMammal, 15 bytes

• ETHproductions, 11 bytes

• Lynn, 1 byte

Os seguintes usuários não foram capazes de contribuir com bytes diretamente, mas ajudaram de outras maneiras:

• Mistah Figgins

Obrigado a todos por tornar isso possível!

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

Experimente online!

Eu removi o espaço em branco extra, envolvi tudo o que existia antes em uma string e, em seguida:

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

Resposta 21, Cubix , 15

Finalmente consegui encaixar isso :) Felizmente, foi depois que a resposta Brain-Flak foi feita, porque eu acho que teria dificultado. Precisava dos 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%_Ï,

Isso mapeia para o seguinte 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 % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

Você pode experimentá-lo aqui , mas precisará colá-lo. Suspeito que algumas das promoções estejam causando problemas para o link permanente.

O código é essencialmente mais de 2 linhas. As partes importantes são:

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

I s )Isso recebe a entrada, troca a parte superior da pilha (0 também teria funcionado) e incrementos
% ?Obtenha o mod e teste. Se 0 continuar em frente ou descer para o redirecionamento
; O N oSolte os resultados do mod e produza o número seguido por uma nova linha
uU vire para a linha abaixo A
seguir está em ordem executada
; - ! @ Remova os 10 da pilha, subtraia o número da entrada, teste e encerre se zero
< ; uRedirecione o alvo para o primeiro teste. Remova a parte superior da pilha (resultado de modificação ou subtração) e volte a girar para aumentar

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

Tirei os %símbolos e comentei a primeira linha e um pouco da última linha. Só isso me custou 10 dos meus 15 pontos. No entanto, eu ainda não havia terminado; desde Python 1 não tem +=eu tive que substituir i+=1com i=i+1me custando um extra de 3 pontos. Desde que eu tinha 2 sobrando, eu também adicionei ((ao começo. Estou planejando fazer uma submissão no Brain-Flak mais tarde e preciso de parênteses.

Resposta 10, Ohm , distância 5

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

... onde <SPACES>é substituído por aquela corda monstruosa do espaço em branco resposta .

Uma resposta um pouco atrevida, já que todo o resto é apenas um fio que não é executado.

Resposta 12, sério , 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∩

Experimente online!

A única diferença em relação à verdade resposta é que usa Sério backticks para marcar uma função onde realmente usa ⌠e ⌡e nós apenas fazer os caracteres extras em uma corda, em seguida, pop e descartá-lo.

Trabalhe em direção ao Brain-Flak

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

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

Experimente online!

Explicação

Estou realmente começando a abusar do fato de que espaço em branco não é considerado a diferença aqui. Del | m | t realmente não se importa tanto com os caracteres que você, então a grande maioria do código é uma sequência de espaços e retornos de carro no início do programa. As partes visíveis reais do código não são executadas.

Aqui está o código transcrito de uma maneira mais "razoável":

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

Experimente online!

Como funciona no nível baixo

Para começar, temos O R ^ V isso serve para receber entrada no primeiro loop e funciona como não operacional todas as outras vezes.

Em seguida, usamos Opara fazer uma cópia da entrada para mais tarde.

@ A K Tchama a variável armazenada na posição de memória -1 (no início do programa é 0) e a A Jincrementa. O @ A K UArmazena o valor agora incrementado de volta na posição de memória -1 para nosso próximo loop.

Ncalcula o mod da cópia da entrada que fizemos um tempo atrás e o valor recuperado da memória e o Rnega.

Juntos, N Rcrie um booleano que indique se a nossa entrada é ou não divisível pelos Termos de Serviço.

Armazenamos uma cópia desse booleano no espaço de memória -2 usando O @ B K Ue recuperamos o valor do espaço de memória -2 usando @ A K T.

Trocamos os dois principais elementos Qpara garantir que o booleano esteja no topo e produzimos o valor se o booleano for verdadeiro usando^ X .

Se o booleano for falso, temos um valor extra que precisa ser erradicado; assim, lembramos do booleano armazenado no espaço -2 @ B K Te exibimos um valor se for falso R ^ P.

Duplicamos o valor de entrada com Oe subtraímos o valor na memória -1 com@ A K T K . Se for zero, sairemos R ^ _.

Por fim, temos @ ^ isso pular qualquer que seja o próximo valor. Precisamos disso porque há um monte de lixo (na verdade, apenas um@ símbolo) gerado pela parte visível do código.

Quando chega ao fim, volta ao início.

Como funciona em alto nível

A idéia básica é que temos um valor armazenado principalmente no local da memória -1, que é incrementado cada vez que fazemos um loop. Se esse valor divide nossa entrada, nós a produzimos e quando os dois são iguais, encerramos a execução.

Progresso em direção à inflamação cerebral

Como o espaço em branco não conta para a diferença, pude alterar o código sem gastar nenhum dos meus 15 pontos e, portanto, todos eles foram investidos no código Brain-Flak.

Aqui está a nossa posição atual.

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

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

Experimente Online!

(Provavelmente há muito espaço em branco desnecessário, mas não posso me preocupar em jogar agora)

Eu usei todos os 15 para o programa Befunge, portanto, nenhuma alteração no Brain-flak desta vez.

Minha principal estratégia para isso foi enviar o IP na vertical e usar espaço em branco para executar certos caracteres do código preexistente.

Explicação:

O código que importa para o programa Befunge é este:

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

O que equivale 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

Resposta 2 - Python 3 , 5

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

Experimente online!

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

Explicação:

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: atualmente o intérprete precisa \nser substituído por s ¶para não contá-lo como entrada, mas o próprio analisador considera os dois intercambiáveis.

Resposta 11, Na verdade , 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∩

Experimente online!

Explicação

Na verdade, possui um bom recurso ÷para encontrar os fatores de um número, no entanto, não podemos usar esses recursos.

Começo armazenando a entrada nos registros, para que não seja prejudicada pelo que está por vir. Eu faço isso usando╩ mas poderia ter usado com a mesma facilidade um dos outros comandos disponíveis.

Depois colo o código que já tínhamos (removi todo o espaço em branco porque era chato trabalhar com isso, posso fazer isso porque "o espaço em branco não conta"). Felizmente, isso não faz muito nada quando a pilha está vazia.

Então nós temos o resto do 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

Trabalhe em direção ao Brain-Flak

Todo esse trabalho e eu só consegui obter um parêntese extra.

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

23, Clássico Brain-Flak, 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 havia postado o código clássico do brain-flak como estava na resposta 22:

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

Isso tem 17 caracteres desativados. No entanto, consegui comprimir isso simplesmente movendo o{}) código mais à direita no código proposto para obter

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

Que tem apenas 13 caracteres! Então, tudo o que fiz foi adicionar / remover colchetes para obter o código proposto.

O código original que eu publiquei tinha um erro de digitação, está corrigido agora. ( Obrigado @WheatWizard! )

Resposta 1 - Python 2.7

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

Distância: NA - Primeira resposta

Experimente online!

22, Lenguage , 15

Lenguage é um esolang que se preocupa apenas com o tempo que o programa não trata do seu conteúdo. Assim, podemos criar qualquer programa de idiomas que desejar, preenchendo o último programa com a quantidade adequada de espaço em branco. O Lenguage é compilado no brainfuck, então vamos reutilizar o programa brainfuck que escrevi há algum tempo

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

Fiz algumas alterações no programa principal para facilitar as respostas posteriores, mas o resultado final se parece com:

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

onde <SPACES>representa 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 caracteres de espaço.

Estou abusando do espaço em branco não conta regra? Possivelmente.

Trabalhe para o Brain-Flak Classic

Já tínhamos todos esses parênteses lá, então pensei em começar o caminho em direção ao Brain-Flak Classic.

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