Seu objetivo é escrever um programa que receba uma entrada e, quando encadeado Nvezes, execute "multiplicação sequencial". O que é multiplicação sequencial, você pode perguntar? É uma sequência com uma semente adefinida da seguinte forma:

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

Então vamos a = 5. Assim, 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 o seu programa foi ABC, ABCdeve receber entrada ae saída f(1). O programa ABCABCdeve sair f(2), etc. Sua série de programas deve receber apenas uma vez e somente uma vez.

Este é um código de golfe, portanto o programa mais curto em bytes vence. As brechas padrão são proibidas.

Geléia, 3 bytes

×’$

Experimente online!

Como 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.

Repetir o trecho n vezes o executará n vezes, resultando na saída desejada.

Sério, 4 bytes

,;D*

Explicação:

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

Assim como na resposta de Dennis's Jelly , repetir os ntempos deste programa resultará em ntempos de execução . Essa é uma das muitas vantagens de linguagens imperativas baseadas em pilha.

Experimente online!

MATL, 3 bytes

tq*

Você pode experimentá-lo online! Basicamente semelhante às respostas Seriously and Jelly. Primeiro, ele duplica a parte superior da pilha (a entrada de get é a primeira vez que a pilha está vazia). Decrementa a parte superior da pilha e multiplica os dois elementos para fornecer a próxima entrada ou resultado.

Python 3, 56 bytes

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

Só queria uma solução sem truques de substituição de saída. A falta de uma nova linha final é importante.

CJam, 5 bytes

r~_(*

Experimente online!

Como 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

_▼•=_

Experimente online.

Seria 4 bytes se eu não tivesse sido preguiçoso e não implementado "atribuir a _" ...

Explicação

_▼•=_

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

Explicação:

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

Experimente online!

GolfScript, 5 bytes

~.(*`

Experimente online.

De-golfe e comentou:

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

O intérprete GolfScript lê automaticamente a entrada e a coloca na pilha, mas como uma sequência, não como um número. Portanto, precisamos transformar a entrada em um número com ~e, depois, novamente com string `. No final, o intérprete imprimirá automaticamente o número estrito na pilha.

(Agora, se o desafio fosse repetir f(n+1) = f(n)*(-f(n)-1), eu poderia ter feito isso em 4 bytes com ~.~*. Descobrir como e por que isso funciona é deixado como um exercício. :)

JavaScript REPL, 25 20 bytes

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

Trabalhará na eliminação de um REPL

Lua, 35 18 bytes

É algo que Lua pode fazer facilmente pela primeira vez!

Edit: Eu descobri muitas coisas em Lua desde que fiz isso, então estou atualizando :)

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

...contém o argumento da linha de comando descompactado, destacando que ele usará seu primeiro valor nesse caso, pois não será permitido gastar, resultando apenas em impressão n*(n-1).

Y , 7 bytes

jzC:t*!

Experimente aqui!

É assim que funciona: jrecebe entrada numérica. zativa a impressão implícita. Cinicia um novo link. :duplica o valor na pilha e o tdiminui, deixando-nos com [a a-1]. Então, temos [a*a-a]de *. !pula o próximo comando; no EOF, não faz nada. Quando encadeados, eles pulam o comando de entrada e o processo começa novamente.

Jolf, 6 bytes

Experimente aqui!

oj*jwj

Explicação

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

, 5 caracteres / 7 bytes

ïׇï;

Try it here (Firefox only).

Devo realmente explicar isso? Oh bem, aqui vai ...

Explicação

É basicamente avaliado input*=--input;em JS.

Perl, 23 bytes

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

Versão alternativa, 10 bytes

$_*=~-$_;

Isso requer a -ptroca. Não tenho certeza se é um jogo justo em uma questão de layout de fonte .

Haskell, 14 11 bytes

(*)=<<pred$

Exemplo de uso

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

Talvez essa não seja uma função adequada. Se você estiver escolhendo, poderá usar (*)=<<pred$id(<- há um espaço no final) por 14 bytes.

Edit: @Zgarb reescreveu a função usando a função mônada e salvou 3 bytes. Obrigado!

Pure bash (sem utilitários), 40

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

TI-Basic, 6 5 bytes

Executa em calculadoras TI-83/84

:Ans²-Ans

Este programa funciona devido ao fato de uma expressão na última linha de um programa ser impressa em vez do Donetexto comum .

Mathcad, 39 "bytes"

Da perspectiva do usuário, o Mathcad é efetivamente um quadro branco 2D, com expressões avaliadas da esquerda para a direita, de cima para baixo. O Mathcad não suporta uma entrada convencional de "texto", mas utiliza uma combinação de texto e teclas especiais / barra de ferramentas / itens de menu para inserir uma expressão, texto, plotagem ou componente. Por exemplo, digite ":" para inserir o operador de definição (mostrado na tela como ": ="), "[" para inserir um índice de matriz ou "ctl-]" para inserir um operador de loop while (incluindo espaços reservados para o condição de controle e uma expressão corporal). O que você vê na imagem acima é exatamente o que aparece na interface do usuário e como "digitado".

Para fins de golfe, a contagem de "bytes" é o número equivalente de operações do teclado necessárias para inserir uma expressão.

Uma coisa que tenho ainda menos certeza (do ponto de vista da equivalência de "bytes") é como contar criando uma nova região (por exemplo, a: = 5 ou k: = 0..n-1). Eu igualei cada movimento a uma nova região como sendo igual a uma nova linha e, portanto, 1 byte (na prática, eu uso o mouse para clicar onde eu quero a região).

Eu incluí apenas as declarações ativas e não os comentários, e incluí 2 bytes cada para as entradas a e n, mas não os valores em si (5 e 7 no exemplo).

Haskell, 72 bytes

Esse desafio não é amigável para Haskell. No entanto, o seguinte funciona se a entrada estiver unária e o código for executado no GHCI:

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

Explicação:

Unário é sempre ímpar, portanto o primeiro aplicativo será convertido em decimal. x*(x-1)é sempre par; caso contrário, retorna x*(x-1)onde xestá a entrada. Como Haskell é fortemente digitado e símbolos 'especiais' não podem ser chamados assim &1, acredito que essa é a única maneira de concluir isso em Haskell, a menos que alguém use variáveis ​​globais ou um formulário de entrada ainda mais estranho.

C ++ (gcc) , 173/176 bytes

Ambas as versões têm uma nova linha crucial no final.

Versão 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;

Experimente online!

Versão do modelo, 176 bytes

Um pouco mais de 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++;

Experimente online!

Burlesco - 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