n=e=$Input;
a=0;
w=While[{m=Modulo[$e];Not[m[1]];}];
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
Do[$w];
Provalo online!
Era ora che usassi di nuovo Rutger. Sfortunatamente, potrebbe non essere la lingua migliore per l'attività, in quanto non ha alcuna forma eval, costringendomi a usare quattro istruzioni if
Come funziona
Come funziona Rutger
Una breve premessa su come funziona la lingua: tutto è o un compito o una funzione, e ogni funzione accetta esattamente un argomento. Per le operazioni che richiedono più di un argomento (ad es. Moltiplicazione), la prima chiamata restituisce una funzione parziale che, quando richiamata con il secondo argomento, restituisce il risultato atteso. Per esempio:
left = Times[5];
Print[left[6]];
stamperà 30: provalo online! . Mentre di solito è più lungo della solita alternativa, a volte può salvare byte, se una funzione viene chiamata ripetutamente con un argomento costante e un argomento che cambia, ad esempio quando si stampano le tabelle dei tempi.
Questa regola con un argomento si applica a tutto ciò che non è una costante o una variabile, inclusi loop e condizionali. Tuttavia, loop e condizionali ( For, Each, While, DoWhile, Ife IfElse) sono fattibile , il che significa che al fine di effettivamente eseguito, il Dofunzione deve essere chiamato (vedi l'ultima riga nella risposta). Ancora una volta, questo può salvare byte quando si esegue ripetutamente lo stesso loop o consentire l'esecuzione di codice arbitrario tra la definizione e l'esecuzione di loop.
Infine, ci sono tre modi per fare riferimento alle variabili, tutte utilizzate in questo programma. Il primo è il riferimento diretto , in cui il nome della variabile è preceduto da un $simbolo. Questo accede direttamente al valore della variabile e lo restituisce. Il secondo è il riferimento funzionale , che non ha un carattere prefisso. Ciò consente al codice di distinguere tra funzioni (potenzialmente parziali) assegnate alle variabili e variabili effettive contenenti un valore specifico. Infine, il riferimento indiretto , preceduto da un @simbolo, crea una variabile (se non esiste già) e restituisce l'oggetto variabile all'interno di un determinato ambito. Questo consente di creare una variabile di ciclo (ad esempio iin for i in range(...)).
Come funziona la soluzione attuale
Ecco il codice ungolfed:
n = elem = $Input;
var = 0;
while = While[{
mod = Modulo[$elem];
Not[mod[1]];
}];
while = while[{
for = For[4];
for = for[@index];
for = for[{
Print[$elem];
equal = Equal[$index];
if = If[{ equal[1]; }];
if = if[{ func = Times[$elem]; }];
Do[$if];
if = If[{ equal[2];}];
if = if[{ func = Add[$elem];}];
Do[$if];
if = If[{ equal[3];}];
if = if[{ func = Subtract[$elem];}];
Do[$if];
if=If[{ equal[4];}];
if=if[{ func = Divide[$elem];}];
Do[$if];
elem = func[var = Increment[$var]];
}];
Do[$for];
}];
Do[$while];
Provalo online!
Come si può vedere, inizia assegnando le tre variabili n, ee a, che rappresentano rispettivamente l'ingresso, l'elemento cambia nella sequenza, e il numero di modifica per ogni nuovo elemento. Quindi creiamo un ciclo while:
w=While[{m=Modulo[$e];Not[m[1]];}];
{}me % m100 → 1n → 0 , n ≠ 0
Successivamente arriviamo all'assoluta mostruosità costituita dal corpo del ciclo while:
w=w[{f=For[4];f=f[@x];f=f[{Print[$e];q=Equal[$x];i=If[{q[1];}];i=i[{k=Times[$e];}];Do[$i];i=If[{q[2];}];i=i[{k=Add[$e];}];Do[$i];i=If[{q[3];}];i=i[{k=Subtract[$e];}];Do[$i];i=If[{q[4];}];i=i[{k=Divide[$e];}];Do[$i];e=k[a=Increment[$a]];}];Do[$f];}];
4x
Print[$e];
q=Equal[$x];
i=If[{q[1];}];i=i[{k=Times[$e] ;}];Do[$i];
i=If[{q[2];}];i=i[{k=Add[$e] ;}];Do[$i];
i=If[{q[3];}];i=i[{k=Subtract[$e] ;}];Do[$i];
i=If[{q[4];}];i=i[{k=Divide[$e] ;}];Do[$i];
e=k[a=Increment[$a]];
La prima istruzione stampa ogni iterazione della sequenza prima di modificarla. Quindi creiamo una funzione parziale per verificare l'uguaglianza con la variabile loop xe riscontriamo quattro istruzioni if. Ogni affermazione verifica sex è uguale a 1, 2, 3 o 4, rispettivamente, e poi assegna ka ciascuna funzione *, +, -e /, quindi fa in una funzione parziale ecome argomento. Infine, assegniamo el' kesecuzione con ail secondo argomento e l'incremento a.
