Su objetivo es escribir un programa que tome una entrada y, cuando se encadenan juntos N, realice una "multiplicación secuencial". ¿Qué es la multiplicación secuencial, puedes preguntar? Es una secuencia con una semilla adefinida así:

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

Entonces, deja a = 5. Por lo tanto, f(0) = 5, f(1) = f(0)*(f(0)-1) = 5*4 = 20, y f(2) = f(1)*(f(1)-1) = 20*19 = 380.

Si su programa era ABC, entonces ABCdebería tomar entrada ay salida f(1). El programa ABCABCdebe salir f(2), etc. La serie de su programa solo debe recibir una vez y solo una vez.

Este es un código de golf, por lo que gana el programa más corto en bytes. Las lagunas estándar están prohibidas.

Jalea, 3 bytes

×’$

Pruébalo en línea!

Cómo funciona

×’$    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 repetición del fragmento n veces lo ejecutará n veces, dando como resultado la salida deseada.

En serio, 4 bytes

,;D*

Explicación:

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

Al igual que en la respuesta de Dennis's Jelly , repetir los ntiempos de este programa dará como resultado ntiempos de ejecución . Esa es una de las muchas ventajas de los lenguajes imperativos basados ​​en pila.

Pruébalo en línea!

MATL, 3 bytes

tq*

¡Puedes probarlo en línea! Básicamente similar a las respuestas Seriously and Jelly. Primero, duplica la parte superior de la pila (obtener la entrada por primera vez cuando la pila está vacía). Disminuye la parte superior de la pila y multiplica los dos elementos para dar la siguiente entrada o resultado.

Python 3, 56 bytes

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

Solo quería una solución sin trucos de sobrescritura de salida. La falta de una nueva línea final es importante.

CJam, 5 bytes

r~_(*

Pruébalo en línea!

Cómo funciona

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 bytes

_▼•=_

Pruébalo en línea.

Sería de 4 bytes si no hubiera sido flojo y no implementado "asignar a _" ...

Explicación

_▼•=_

_       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 bytes

Código:

D<*

Explicación:

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

Pruébalo en línea!

GolfScript, 5 bytes

~.(*`

Pruébalo en línea.

De golf y comentado:

~    # 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.

El intérprete de GolfScript lee automáticamente la entrada y la coloca en la pila, pero como una cadena, no como un número. Por lo tanto, tenemos que convertir la entrada en un número con ~, y luego volver a clasificarla con string `. Al final, el intérprete imprimirá automáticamente el número en cadena en la pila.

(Ahora, si el desafío hubiera sido iterar f(n+1) = f(n)*(-f(n)-1), podría haberlo hecho en 4 bytes con ~.~*. Descubrir cómo y por qué eso funciona se deja como ejercicio. :)

JavaScript REPL, 25 20 bytes

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

Trabajará para eliminar un REPL

Lua, 35 18 bytes

¡Es algo que Lua puede hacer con bastante facilidad por una vez!

Editar: he descubierto muchas cosas en Lua desde que hice esto, así que lo estoy actualizando :)

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

...contiene el argumento de la línea de comandos desempaquetado, indicando que usará su primer valor en este caso, ya que no se le permitirá gastar, lo que solo se imprimirá n*(n-1).

Y , 7 bytes

jzC:t*!

Pruébalo aquí!

Así es como funciona: jtoma entrada numérica. zactiva la impresión implícita. Ccomienza un nuevo enlace. :duplica el valor en la pila y lo tdisminuye, dejándonos con [a a-1]. Entonces, salimos [a*a-a]de *. !omite el siguiente comando; en EOF, no hace nada. Cuando se encadenan juntos, omite el comando de entrada y el proceso comienza nuevamente.

Jolf, 6 bytes

Pruébalo aquí!

oj*jwj

Explicación

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

𝔼𝕊𝕄𝕚𝕟, 5 caracteres / 7 bytes

ïׇï;

Try it here (Firefox only).

¿Debo realmente explicar esto? Oh bueno, aquí va ...

Explicación

Básicamente se evalúa input*=--input;en JS.

Perl, 23 bytes

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

Versión alternativa, 10 bytes.

$_*=~-$_;

Esto requiere el -pcambio. No estoy seguro de si es un juego justo en una pregunta de diseño de fuente .

Haskell, 14 11 bytes

(*)=<<pred$

Ejemplo de uso

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

Quizás esta no sea una función adecuada. Si estás haciendo trampas, puedes ir con (*)=<<pred$id(<-hay un espacio al final) para 14 bytes.

Editar: @Zgarb reescribió la función usando la función mónada y guardó 3 bytes. ¡Gracias!

Pure bash (sin utilidades), 40

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

TI-Basic, 6 5 bytes

Se ejecuta en calculadoras TI-83/84

:Ans²-Ans

Este programa funciona debido al hecho de que se imprime una expresión en la última línea de un programa en lugar del Donetexto normal .

Mathcad, 39 "bytes"

Desde la perspectiva del usuario, Mathcad es efectivamente una pizarra en 2D, con expresiones evaluadas de izquierda a derecha, de arriba a abajo. Mathcad no admite una entrada de "texto" convencional, sino que utiliza una combinación de texto y teclas especiales / barra de herramientas / elementos de menú para insertar una expresión, texto, diagrama o componente. Por ejemplo, escriba ":" para ingresar el operador de definición (que se muestra en la pantalla como ": ="), "[" para ingresar un índice de matriz o "ctl-]" para ingresar un operador de bucle while (incluidos los marcadores de posición para el condición de control y una expresión corporal). Lo que ves en la imagen de arriba es exactamente lo que aparece en la interfaz de usuario y como "tipeado".

Para fines de golf, el recuento de "bytes" es el número equivalente de operaciones de teclado requeridas para ingresar una expresión.

Una cosa de la que estoy aún menos seguro (desde un punto de vista de equivalencia de "byte") es cómo contar la creación de una nueva región (por ejemplo, a: = 5 o k: = 0..n-1). He equiparado cada movimiento a una nueva región como igual a una nueva línea y, por lo tanto, 1 byte (en la práctica, uso el mouse para hacer clic donde quiero la región).

Solo he incluido las declaraciones activas y no los comentarios, y he incluido 2 bytes cada uno para las entradas ayn, pero no los valores en sí (5 y 7 en el ejemplo).

Haskell, 72 bytes

Este desafío no es amigable para Haskell. Sin embargo, lo siguiente funciona si la entrada es unaria y el código se ejecuta en GHCI:

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

Explicación:

Unary siempre es impar, por lo que la primera aplicación se convertirá a decimal. x*(x-1)siempre es par, de lo contrario vuelve x*(x-1), donde xestá la entrada. Debido a que Haskell está fuertemente tipado y los símbolos 'especiales' no se pueden llamar así &1, creo que esta es prácticamente la única forma de completar esto en Haskell, a menos que uno use variables globales o un formulario de entrada aún más extraño.

C ++ (gcc) , 173/176 bytes

Ambas versiones tienen una nueva línea crucial al final.

Versión macro, 173 bytes

#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;

Pruébalo en línea!

Versión de plantilla, 176 bytes

Algo más 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++;

Pruébalo en línea!

Burlesque - 5 bytes

J?d?*

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