Questa sfida di concatenazione di risposte è ufficialmente terminata, portando alla vittoria di Wheat Wizard , con un totale di 7 risposte. Qualsiasi altra risposta è benvenuta, ma non influenzerà la risposta accettata per questa sfida, né il vincitore.

Compito:

Stampa tutti i divisori positivi di un numero xpreso come input.

Ingresso:

Un singolo numero xche è il numero (nella base 10) i cui divisori positivi devono essere calcolati.

Produzione:

Tutti i divisori positivi di x. Ogni formato è consentito, tra cui \n, ,, ;e gli spazi come separatori, finché è comprensibile. L'output può essere anche un array di numeri interi o stringhe (ad esempio:) [1, 2, 3, 5, 30]. È possibile inviare i divisori su stdout, console o equivalenti nella propria lingua oppure possono essere restituiti da una funzione .

Regole

• Un utente potrebbe non rispondere due volte di seguito
• La tua risposta può rimuovere, aggiungere o sostituire al massimo 15 caratteri dalla risposta precedente (gli spazi bianchi non contano), oltre alla Risposta 2 che può "trasformare" fino a 20 caratteri per iniziare le cose
• Non ti è consentito pubblicare una risposta in un linguaggio di programmazione che ha già una risposta, l'eccezione è una versione completamente diversa di quel linguaggio (ad esempio: se inserisco una risposta Python 2.7, puoi inviarne una Python 3, ma non in Python 2.6)
• Non sono ammesse scappatoie standard
• Non è consentito utilizzare i built-in per ottenere divisori , per il bene di questa sfida
• È necessario includere il numero della risposta e il nome della lingua nel titolo della domanda e il numero di caratteri modificati rispetto alla risposta precedente

punteggio

L'utente con il maggior numero di invii una volta risolte le cose vince. In caso di pareggio, vince l'utente con il punteggio più alto in una delle sue risposte. In caso di pareggio anche nel punteggio, l'utente con la presentazione più vecchia (la risposta con il punteggio più alto più vecchio) verrà dichiarato vincitore.

Nota: "liquidare" <=> 7 Sono trascorsi 3 giorni dall'ultima risposta inviata

Esempi:

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 qualsiasi altra uscita equivalente che soddisfi le condizioni menzionate.

Nota finale : questa domanda è migliore se si ordinano le risposte in base al più vecchio. Pubblicherò la prima risposta in Python 2.7, quindi dovresti pubblicare la seconda risposta a seconda di quella. Buona fortuna e buon divertimento!

Classifica:

Questo elenco potrebbe essere obsoleto, non disponibile per modificarlo:

1) Wheat Wizard [Current Leader 🏆] : 7 risposte - Python 1.6 , 05AB1E , In realtà , Del | m | t , WSF , Brain-Flak , Lenguage

2) Riley: 3 risposte - Seriamente , CJam , 2sable

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

3) ETHproductions: 2 risposte - Japt , Pyth

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

6) Riker: 1 risposta - MATL

6) dzaima: 1 risposta - SOGL 0.8.2

6) LegionMammal978: 1 risposta - Spazio bianco

6) Nick Clifford: 1 risposta - Ohm

6) Lynn: 1 risposta - GolfScript

6) MickyT: 1 risposta - Cubix

Calcolatore di distanza

Puoi utilizzare questo frammento per calcolare la distanza tra due voci:

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>

Risposta 20, Brain-Flak , 11

Vorrei solo prendermi il tempo per ringraziare tutti coloro che hanno contribuito a contribuire a questo obiettivo:

• Riley, 20 byte

• LegionMammal, 15 byte

• ETHproductions, 11 byte

• Lynn, 1 byte

I seguenti utenti non sono stati in grado di contribuire direttamente con i byte, ma hanno aiutato in altri modi:

• Mistah Figgins

• DJMcMayhem

• feersum

Grazie a tutti per aver reso possibile tutto ciò!

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

Provalo online!

Risposta 3: MATL, distanza 15

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

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

Provalo online!

Modificato #b∫I:b;\?tin ò f!vU(10 punti) e aggiunto altro codice Brain-Flak cambiando ~(()in ((()<>))(5 punti). Credo che il codice a cui stiamo lavorando sia

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

Spiegazione

ò           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

Risposta 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

Provalo online!

Spiegazione

Fortunatamente 05AB1E ha un interprete Python incorporato (di sorta). Per fare questo correre spingiamo

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

come una stringa all'inizio della pila. Dobbiamo usare i valori letterali delle stringhe invece dei commenti perché a 05AB1E in realtà non piacciono i commenti nel suo codice Python. Dobbiamo anche sbarazzarci di "nel codice originale perché causa la fine prematura della stringa.

Una volta che la stringa è stata spinta, la usiamo .eper eseguirla come codice Python.

Lavora verso Brain-Flak

Sono stato in grado di aggiungere 5 personaggi extra verso l'obiettivo di dare una risposta Brain-Flak. Sarei stato in grado di aggiungere 6, ma purtroppo ho dimenticato che lo spazio bianco non conta per il punteggio.

Finora abbiamo:

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

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

Provalo online!

Spiegazione

Quindi non conosco molto Pyth, ma quello che so è che il codice sorgente è sotto forma di un albero, ogni comando prende un numero specifico di argomenti alla sua destra. L'albero del programma divisore che ho scritto è simile al seguente:

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

Qè l'input. fprende due argomenti, Fe A, e restituisce gli elementi Tin Acui F(T)restituisce un valore truthy. In questo caso, Fè una funzione che restituisce il NOT logico di Q%T, ed Aè SQ, che crea l'intervallo [1...Q]. Ciò ha l'effetto di filtrare solo gli interi Tin [1...Q]cui Q%T == 0.

Per evitare di analizzare il resto del codice, l'intera cosa è racchiusa in una stringa, quindi |Q"...restituisce l'OR logico di Qe la stringa. Poiché Qè sempre positivo, è sempre vero, e quindi viene sempre restituito dall'OR logico.

Lavora verso Brain-Flak

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

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

Provalo online!

Ho aggiunto ~:␤),(;{␤\%!},p#, usando newline come nome di una variabile per adattarsi al vincolo di dimensione, e ho ridimensionato l'intero programma su una riga per commentarlo. Questa era la distanza 14. Poi, l'ho aggiunto {prima }printdivper Brain-Flak.

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

Lavora verso Brain-Flak

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

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

Provalo 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

Lavora verso Brain-Flak (30 per andare)

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

Risposta 4 - Jelly , 4

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

Provalo online!

Codice pertinente:

Rḍ⁸T

La )agisce come una pausa tra i link per quanto riguarda il parser è interessato (credo).

Il built-in sarebbe ÆD, invece, questo crea un intervallo 1dall'input con R, controlla la divisibilità dall'input con ḍ⁸, quindi restituisce un elenco degli indici con una sola verità con T.

Risposta 9, Spazio bianco, 15

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

Dove <SPACES>è sostituito dalla seguente stringa, dove Tè 0x09, Lè 0x0A ed Sè 0x20:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

Newline letterale aggiunto per chiarezza. Si è notato che le regole specificano solo caratteri non bianchi. No, non ho potuto fare a meno di me stesso.

Lavora verso Brain-Flak

Non ho idea di cosa stesse succedendo prima, quindi ora abbiamo:

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

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

(Questo richiede input e output tramite codice carattere)

Spiegazione

WSF è essenzialmente Brainfuck ad eccezione del fatto che utilizza spazi bianchi invece del solito set di operatori di Brainfuck. Ecco il codice decompilato in brainfuck:

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

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

Progressi verso Brain-Flak

Dato che WSF è solo uno spazio bianco, sono stato in grado di aggiungere altri 15 caratteri al codice Brain-Flak. Questo ci mette a 15 di distanza dalla risposta, quindi sentiti libero di pubblicarlo.

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

Dal momento che non ho intenzione di pubblicare da solo la risposta di Brain-flak, ho pensato di prendere il tempo per ringraziare tutti coloro che hanno contribuito a raggiungere questo obiettivo:

• Riley, 16 byte

• LegionMammal, 15 byte

• ETHproductions, 11 byte

• Lynn, 1 byte

I seguenti utenti non sono stati in grado di contribuire direttamente con i byte, ma hanno aiutato in altri modi:

• Mistah Figgins

Grazie a tutti per aver reso possibile tutto ciò!

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

Provalo online!

Ho rimosso lo spazio extra, ho avvolto tutto ciò che esisteva prima in una stringa, quindi:

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

Risposta 21, Cubix , 15

Finalmente sono riuscito a adattarmi a questo :) Per fortuna è dopo che la risposta Brain-Flak è stata fatta, perché penso che avrei ostacolato. Necessari i 15 completi da implementare.

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

Questo è mappato al cubo seguente

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

Puoi provarlo qui , ma dovrai incollarlo. Ho il sospetto che alcune delle offerte speciali stiano causando problemi al permalink.

Il codice è essenzialmente su 2 righe. Le parti importanti sono:

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

I s )Questo ottiene l'input, scambia la parte superiore dello stack (anche 0 avrebbe funzionato) e incrementi
% ?Ottieni mod e test. Se 0 prosegui o scendi verso il reindirizzamento
; O N oRilascia i risultati della mod ed emetti il ​​numero seguito da una nuova riga
uU gira sulla riga sottostante Il
seguente è nell'ordine eseguito
; - ! @ Rimuovi i 10 dallo stack, sottrai il numero dall'input, prova e termina se zero
< ; u Reindirizza target per il primo test. Rimuovi la parte superiore dello stack (mod o sottrai il risultato) e torna indietro per aumentare

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

Ho rimosso i %simboli e commentato la prima riga e un po 'dell'ultima riga. Questo da solo mi è costato 10 dei miei 15 punti. Tuttavia non avevo ancora finito; dal momento che Python 1 non ha dovuto +=sostituire i+=1con i=i+1costandomi 3 punti extra. Da quando ne avevo rimasti 2 ho aggiunto anche ((all'inizio. Ho in programma di presentare una richiesta in seguito a Brain-Flak e ho bisogno di genitori.

Risposta 10, Ohm , distanza 5

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

...dove <SPACES> viene sostituito da quella stringa mostruosa dalla risposta agli spazi bianchi .

Una risposta un po 'sfacciata, dal momento che tutto il resto è solo un filo che non viene eseguito.

Risposta 12, Scherzi a parte , 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∩

Provalo online!

L'unica differenza rispetto alla risposta reale è che utilizza seriamente i backtick per contrassegnare una funzione in cui effettivamente utilizza ⌠e⌡ e noi facciamo semplicemente i caratteri extra in una stringa, quindi pop e la scartiamo.

Lavora verso il cervello-Flak

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

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

Provalo online!

Spiegazione

Sto davvero iniziando ad abusare del fatto che qui gli spazi bianchi non vengono considerati per la differenza. A Del | m | t non importa molto di ciò che ti caratterizza, quindi la stragrande maggioranza del codice è una sequenza di spazi e ritorni a capo all'inizio del programma. Le parti effettivamente visibili del codice non vengono eseguite affatto.

Ecco il codice trascritto in modo più "ragionevole":

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

Provalo online!

Come funziona a basso livello

Per iniziare abbiamo O R ^ V questo serve per prendere input sul primo loop e funziona come no-op tutte le altre volte.

Quindi usiamo O per fare una copia dell'input per dopo.

@ A K Trichiama la variabile memorizzata nella posizione di memoria -1 (all'inizio del programma è 0) e la A Jincrementa. O @ A K UMemorizza il valore ora incrementato nuovamente nella posizione di memoria -1 per il prossimo loop in giro.

Ncalcola la mod della copia dell'input che abbiamo fatto qualche tempo fa e il valore appena richiamato dalla memoria e lo Rannulla.

Insieme, N Rcrea un valore booleano che indica se il nostro input è divisibile o meno per il TOS.

Memorizziamo una copia di questo booleano nello spazio di memoria -2 utilizzando O @ B K Ue richiamiamo il valore dallo spazio di memoria -2 utilizzando @ A K T.

Sostituiamo i due elementi principali con Qper garantire che il valore booleano sia in primo piano e produciamo il valore se il valore booleano è true utilizzando^ X .

Se il valore booleano era falso, abbiamo un valore extra che deve essere sradicato, quindi ricordiamo il valore booleano che abbiamo archiviato nello spazio -2 @ B K Te pop un valore se è falso R ^ P.

Dupliciamo il valore di input con Oe sottraggiamo il valore in memoria -1 con @ A K T K. Se questo è zero usciamo R ^ _.

Infine abbiamo @ ^questo salto qualunque sia il prossimo valore. Ne abbiamo bisogno perché c'è un mucchio di spazzatura (in realtà solo un @simbolo) generato dalla parte visibile del codice.

Una volta raggiunta la fine, ritorna all'inizio.

Come funziona ad alto livello

L'idea di base è che abbiamo un valore memorizzato principalmente nella posizione di memoria -1 che viene incrementato ogni volta che eseguiamo il loop. Se quel valore divide il nostro input, lo emettiamo e quando i due sono uguali, terminiamo l'esecuzione.

Progresso verso il cervello-Flak

Poiché lo spazio bianco non conta per la differenza, sono stato in grado di cambiare il codice senza spendere nessuno dei miei 15 punti e quindi tutti sono stati investiti nel codice Brain-Flak.

Ecco la nostra posizione attuale.

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

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

Provalo online!

(Probabilmente ci sono molti spazi bianchi non necessari, ma non posso preoccuparmi di giocare a golf in questo momento)

Ho usato tutti e 15 per il programma Befunge, quindi questa volta non ho apportato modifiche al Brain-flak.

La mia strategia principale per questo era di inviare l'IP andando verticalmente e usando gli spazi bianchi per eseguire determinati caratteri dal codice preesistente.

Spiegazione:

Il codice che conta per il programma Befunge è questo:

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

Che 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

Risposta 2 - Python 3 , 5

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

Provalo online!

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

Spiegazione:

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: l'interprete deve attualmente \nessere sostituito con s ¶per non contarlo come input, ma lo stesso parser considera entrambi intercambiabili.

Risposta 11, In realtà , 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∩

Provalo online!

Spiegazione

In realtà ha un buon builtin ÷per trovare i fattori di un numero, tuttavia non ci è permesso usare tali builtin.

Comincio memorizzando l'input nei registri in modo che rimanga illeso da ciò che verrà. Lo faccio usando ╩ma avrei potuto usare altrettanto facilmente uno degli altri comandi disponibili.

Quindi incollo il codice che avevamo già (ho rimosso tutto lo spazio bianco perché era noioso lavorare con me, posso farlo perché "lo spazio bianco non conta"). Fortunatamente questo non fa molto quando lo stack è vuoto.

Quindi abbiamo il resto del programma

╜   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

Lavora verso il cervello-Flak

Tutto quel lavoro e sono stato in grado di ottenere solo un paren in più.

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

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

Inizialmente, @Wheat Wizard aveva pubblicato il codice brain-flak-classic come nella risposta 22:

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

Sono presenti 17 caratteri. Tuttavia, sono stato in grado di comprimere semplicemente spostando l' {})ulteriore diritto nel codice proposto per ottenere

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

Che ha solo 13 caratteri! Quindi tutto ciò che ho fatto è stato aggiungere / rimuovere parentesi per ottenere il codice proposto.

Il codice originale che ho pubblicato aveva un refuso, ora è stato corretto. ( Grazie @WheatWizard! )

Risposta 1 - Python 2.7

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

Distanza: NA - Prima risposta

Provalo online!

22, Lenguage , 15

Lenguage è un esolang che si preoccupa solo di quanto tempo il programma non riguarda il suo contenuto. Quindi possiamo creare qualsiasi programma di lingua che vogliamo riempiendo l'ultimo programma con la giusta quantità di spazi bianchi. Lenguage è compilato in Brainfuck, quindi riutilizzeremo il programma Brainfuck che ho scritto qualche tempo fa

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

Ho apportato alcune modifiche al programma principale per facilitare le risposte successive, ma il risultato finale è simile:

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

dove <SPACES>rappresenta 55501429195173976989402130752788553046280971902194531020486729504671367937656404963353269263683332162717880399306 caratteri spazio.

Sto abusando dello spazio bianco non conta la regola? Forse.

Lavora verso Brain-Flak Classic

Avevamo già tutte quelle parentesi lì, quindi ho pensato di iniziare la nostra strada verso Brain-Flak Classic.

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