Il tuo obiettivo è quello di scrivere un programma che accetta un input e, quando incatenato insieme Nvolte, esegue una "moltiplicazione sequenziale". Cos'è la moltiplicazione sequenziale, potresti chiedere? È una sequenza con un seme adefinito così:

f(0) = a
f(n+1) = f(n)*(f(n)-1)

Quindi, lascia a = 5. Così, f(0) = 5, f(1) = f(0)*(f(0)-1) = 5*4 = 20, e f(2) = f(1)*(f(1)-1) = 20*19 = 380.

Se il tuo programma era ABC, allora ABCdovrebbe prendere input ae output f(1). Il programma ABCABCdovrebbe essere emesso f(2), ecc. Le tue serie di programmi dovrebbero ricevere input solo una volta e solo una volta.

Questo è un code-golf quindi vince il programma più breve in byte. Le scappatoie standard sono vietate.

Gelatina, 3 byte

×’$

Provalo online!

Come funziona

×’$    Main link (or part thereof). Argument (initially input): n

 ’     Compute n - 1.
×      Multiply n by (n - 1).
  $    Combine the previous two atoms into a monadic quicklink.

La ripetizione dello snippet n volte lo eseguirà n volte, ottenendo l'output desiderato.

Scherzi a parte, 4 byte

,;D*

Spiegazione:

,;D*
,     push input (NOP once input is exhausted)
 ;D   dupe and push n-1
   *  multiply
      (implicit output at EOF)

Proprio come nella risposta Jelly di Dennis , ripetere i ntempi di questo programma comporterà ntempi di esecuzione . Questo è uno dei molti vantaggi dei linguaggi imperativi basati su stack.

Provalo online!

MATL, 3 byte

tq*

Puoi provarlo online! Fondamentalmente simile alle risposte Seriously e Jelly. Innanzitutto, duplica la parte superiore dello stack (input di get la prima volta quando lo stack è vuoto). Riduce la parte superiore dello stack e moltiplica i due elementi per fornire l'input o il risultato successivo.

Python 3, 56 byte

+1if 0else 0
try:n
except:n=int(input())
n*=n-1
print(n)

Volevo solo una soluzione senza ingannare l'output. La mancanza di una nuova riga finale è importante.

CJam, 5 byte

r~_(*

Provalo online!

Come funziona

r     e# Read a whitespace-separated token from STDIN.
      e# This pushes the input (when called for the first time) or an empty string.
 ~    e# Evaluate.
      e# This turns the input into an integer or discards an empty string.
  _   e# Copy the top of the stack.
   (  e# Decrement.
    * e# Multiply.

pl, 5 byte

_▼•=_

Provalo online.

Sarebbe 4 byte se non fossi stato pigro e non implementato "Assegna a _" ...

Spiegazione

_▼•=_

_       push _ (input var)
 ▼      decrement last used var (_)
  •     multiply, since it is off by one it auto-adds _ to the arg list
   =_   assign result to _

05AB1E , 3 byte

Codice:

D<*

Spiegazione:

D    # Duplicate top of the stack, or input when empty
 <   # Decrement on top item
  *  # Multiply

Provalo online!

GolfScript, 5 byte

~.(*`

Provalo online.

De-golf e commentato:

~    # Eval the input to turn it from a string into a number.
.    # Duplicate the number.
(    # Decrement one of the copies by one.
*    # Multiply the copies together.
`    # Un-eval the number, turning it back into a string.

L'interprete GolfScript legge automaticamente l'input e lo posiziona nello stack, ma come una stringa, non come un numero. Pertanto, abbiamo bisogno di trasformare l'input in un numero con ~, e poi di stringerlo nuovamente con `. Alla fine, l'interprete stamperà automaticamente il numero rigoroso nella pila.

(Ora, se la sfida era stata quella di iterare f(n+1) = f(n)*(-f(n)-1), ho potuto ho fatto che in 4 byte con ~.~*. Capire come e perché che le opere è lasciato come esercizio. :)

REPL JavaScript, 25 20 byte

a=prompt();
a*=a-1//

Lavorerà per eliminare un REPL

Lua, 35 18 byte

È qualcosa che Lua può fare abbastanza facilmente per una volta!

Modifica: ho scoperto molte cose in Lua da quando l'ho fatto, quindi lo sto aggiornando :)

print(...*(...-1))

...contiene l'argomento della riga di comando decompresso, in linea di principio userà il suo primo valore in questo caso in quanto non sarà permesso di spendere, con conseguente solo stampa n*(n-1).

Y , 7 byte

jzC:t*!

Provalo qui!

Funziona così: jaccetta input numerici. zattiva la stampa implicita. Cinizia un nuovo collegamento. :duplica il valore nello stack e lo tdiminuisce, lasciandoci con [a a-1]. Quindi, arriviamo [a*a-a]da *. !salta il comando successivo; su EOF, non fa nulla. Quando incatenato insieme, salta il comando di input e il processo ricomincia.

Jolf, 6 byte

Provalo qui!

oj*jwj

Spiegazione

oj*jwj
oj      set j to
  *jwj  j times j-1
        implicit output

𝔼𝕊𝕄𝕚𝕟, 5 caratteri / 7 byte

ïׇï;

Try it here (Firefox only).

Devo davvero spiegarlo? Oh bene, ecco qui ...

Spiegazione

Fondamentalmente valuta input*=--input;in JS.

Perl, 23 byte

l;$_|=<>;$_*=~-$_;print

Versione alternativa, 10 byte

$_*=~-$_;

Ciò richiede il -ppassaggio. Non sono sicuro che si tratti di un gioco corretto in una domanda di layout di origine .

Haskell, 14 11 byte

(*)=<<pred$

Esempio di utilizzo

Prelude> (*)=<<pred$5
20
Prelude> (*)=<<pred$(*)=<<pred$5
380
Prelude> (*)=<<pred$(*)=<<pred$(*)=<<pred$5
144020

Forse questa non è una funzione adeguata. Se stai facendo il nitpicking puoi andare con (*)=<<pred$id(<-s'è uno spazio alla fine) per 14 byte.

Modifica: @Zgarb ha riscritto la funzione usando la funzione monade e salvato 3 byte. Grazie!

Bash puro (nessuna utility), 40

((a=a?a:$1,a*=a-1))
trap 'echo $a' exit

TI-Basic, 6 5 byte

Funziona con calcolatrici TI-83/84

:Ans²-Ans

Questo programma funziona a causa del fatto che un'espressione sull'ultima riga di un programma viene stampata al posto del Donetesto normale .

Mathcad, 39 "byte"

Dal punto di vista dell'utente, Mathcad è effettivamente una lavagna 2D, con espressioni valutate da sinistra a destra, dall'alto verso il basso. Mathcad non supporta un input di "testo" convenzionale, ma utilizza invece una combinazione di testo e tasti speciali / barra degli strumenti / voci di menu per inserire un'espressione, testo, trama o componente. Ad esempio, digitare ":" per inserire l'operatore di definizione (mostrato sullo schermo come ": ="), "[" per inserire un indice di array o "ctl-]" per inserire un operatore ciclo while (inclusivo di segnaposto per il condizione di controllo ed espressione di un solo corpo). Quello che vedi nell'immagine sopra è esattamente ciò che appare nell'interfaccia utente e come "digitato" in.

Ai fini del golf, il conteggio dei "byte" è il numero equivalente di operazioni da tastiera richieste per inserire un'espressione.

Una cosa di cui sono ancora meno sicuro (dal punto di vista dell'equivalenza "byte") è come contare la creazione di una nuova regione (ad es. A: = 5 o k: = 0..n-1). Ho identificato ogni spostamento in una nuova regione come uguale a una nuova riga, e quindi 1 byte (in pratica, utilizzo il mouse per fare clic dove voglio la regione).

Ho incluso solo le istruzioni attive e non i commenti e ho incluso 2 byte ciascuno per gli input a e n ma non i valori stessi (5 e 7 nell'esempio).

Haskell, 72 byte

Questa sfida non è amichevole con Haskell. Tuttavia, quanto segue funziona se l'input è unario e il codice viene eseguito in GHCI:

(\x->if odd x then let y=until((>x).(10^))(+1)0 in y*(y-1)else x*(x-1))$

Spiegazione:

Unario è sempre dispari, quindi la prima applicazione verrà convertita in decimale. x*(x-1)è sempre pari, quindi altrimenti ritorna x*(x-1), dov'è xl'input. Poiché Haskell è fortemente tipizzato e i simboli "speciali" non possono essere chiamati come &1, credo che questo sia praticamente l'unico modo per completarlo in Haskell, a meno che non si utilizzino variabili globali o un modulo di input ancora più strano.

C ++ (gcc) , 173/176 byte

Entrambe le versioni hanno una linea cruciale alla fine.

Versione macro, 173 byte

#ifndef M
#define M(a,b)a##b
#define W(z,x)M(z,x)
#define B int W(m,__LINE__)=x++
#include<iostream>
int x,n;int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B;

Provalo online!

Versione modello, 176 byte

Un po 'più di C ++ ish:

#ifndef B
#define B template
#include<iostream>
int x,n;B<int N>struct A{static int i;};int main(){for(std::cin>>n;x--;)n*=n-1;std::cout<<n;}
#endif
B<>int A<__LINE__>::i=x++;

Provalo online!

Burlesque - 5 byte

J?d?*

blsq ) 5 J?d?*
20
blsq ) 5 J?d?* J?d?*
380
blsq ) 5 J?d?* J?d?* J?d?*
144020