Crie o programa ou a função mais curta que encontre o fatorial de um número inteiro não negativo.

O fatorial, representado por, !é definido como tal

Em inglês simples, o fatorial de 0 é 1 e o fatorial de n, onde n é maior que 0 é n vezes o fatorial de um menor que n.

Seu código deve executar entrada e saída usando métodos padrão.

Requisitos:

• Não usa bibliotecas internas que possam calcular o fatorial (isso inclui qualquer forma de eval)
• Pode calcular fatoriais para números de até 125
• Pode calcular o fatorial para o número 0 (igual a 1)
• Conclui em menos de um minuto para números de até 125

A finalização mais curta vence, no caso de empate, a resposta com mais votos no momento vence.

Golfscript - 12 caracteres

{,1\{)*}/}:f

Introdução ao Golfscript - Fatorial passo a passo

Aqui está algo para as pessoas que estão tentando aprender golfe. O pré-requisito é um entendimento básico do golfscript e a capacidade de ler a documentação do golfscript.

Então, queremos experimentar nossa nova ferramenta golfscript . É sempre bom começar com algo simples, então estamos começando com fatorial. Aqui está uma tentativa inicial, baseada em um simples pseudocódigo imperativo:

# pseudocode: f(n){c=1;while(n>1){c*=n;n--};return c}
{:n;1:c;{n 1>}{n c*:c;n 1-:n;}while c}:f

Espaço em branco é muito raramente usado no golfe. O truque mais fácil para se livrar do espaço em branco é usar diferentes nomes de variáveis. Cada token pode ser usado como uma variável (consulte a página de sintaxe ). Fichas úteis para usar como variáveis são caracteres especiais como |, &, ?- geralmente não qualquer coisa usada em outras partes do código. Estes são sempre analisados ​​como tokens de caracteres únicos. Por outro lado, variáveis ​​como nexigirão um espaço para empurrar um número para a pilha depois. Os números são essencialmente variáveis ​​pré-inicializadas.

Como sempre, haverá declarações que podemos mudar, sem afetar o resultado final. Em golfscript, tudo é avaliada como verdadeira, exceto 0, [], ""e {}(ver este ). Aqui, podemos alterar a condição de saída do loop para simplesmente {n}(fazemos um loop adicional e terminamos quando n = 0).

Como no golfe em qualquer idioma, ajuda a conhecer as funções disponíveis. Felizmente, a lista é muito curta para o golfscript. Nós podemos mudar 1-para (salvar outro personagem. No momento, o código se parece com o seguinte: (poderíamos estar usando em 1vez de |aqui, se quiséssemos, o que eliminaria a inicialização.)

{:n;1:|;{n}{n|*:|;n(:n;}while|}:f

É importante usar bem a pilha para obter as soluções mais curtas (praticar praticar praticar). Geralmente, se os valores forem usados ​​apenas em um pequeno segmento de código, talvez não seja necessário armazená-los em variáveis. Ao remover a variável de produto em execução e simplesmente usar a pilha, podemos salvar muitos caracteres.

{:n;1{n}{n*n(:n;}while}:f

Aqui está outra coisa para pensar. Estamos removendo a variável nda pilha no final do corpo do loop, mas depois a pressionamos imediatamente. De fato, antes do início do loop, também o removemos da pilha. Em vez disso, devemos deixá-lo na pilha e podemos manter a condição do loop em branco.

{1\:n{}{n*n(:n}while}:f

Talvez possamos até eliminar completamente a variável. Para fazer isso, precisaremos manter a variável na pilha o tempo todo. Isso significa que precisamos de duas cópias da variável na pilha no final da verificação de condição para não perdê-la após a verificação. O que significa que teremos um redundante 0na pilha após o término do loop, mas isso é fácil de corrigir.

Isso nos leva à nossa whilesolução ideal de loop!

{1\{.}{.@*\(}while;}:f

Agora ainda queremos tornar isso mais curto. O alvo óbvio deve ser a palavra while. Olhando para a documentação, existem duas alternativas viáveis ​​- desdobrar e fazer . Quando você pode escolher diferentes rotas a seguir, tente pesar os benefícios de ambas. Desdobrar é 'praticamente um loop while', portanto, como uma estimativa, reduziremos o caractere 5 whileem 4 /. Quanto a doisso, cortamos while3 caracteres e fundimos os dois blocos, o que pode salvar outro ou dois caracteres.

Na verdade, há uma grande desvantagem em usar um doloop. Como a verificação da condição é feita depois que o corpo é executado uma vez, o valor de 0estará errado, portanto, podemos precisar de uma instrução if. Vou lhe dizer agora que o desdobramento é mais curto (algumas soluções dosão fornecidas no final). Vá em frente e tente, o código que já temos exige alterações mínimas.

{1\{}{.@*\(}/;}:f

Ótimo! Nossa solução agora é super curta e terminamos aqui, certo? Não. São 17 caracteres e J possui 12 caracteres. Nunca admita derrota!

Agora você está pensando com ... recursão

Usar recursão significa que devemos usar uma estrutura de ramificação. Lamentável, mas como fatorial pode ser expresso de forma tão sucinta e recursivamente, isso parece ser uma alternativa viável à iteração.

# pseudocode: f(n){return n==0?n*f(n-1):1}
{:n{n.(f*}1if}:f # taking advantage of the tokeniser

Bem, isso foi fácil - se tivéssemos tentado a recursão antes, talvez nem tivéssemos olhado usando um whileloop! Ainda assim, temos apenas 16 caracteres.

Matrizes

Matrizes geralmente são criadas de duas maneiras - usando os caracteres [e ], ou com a ,função Se executado com um número inteiro no topo da pilha, ,retorna uma matriz desse comprimento com arr [i] = i.

Para iterar sobre matrizes, temos três opções:

1. {block}/: empurrar, bloquear, empurrar, bloquear, ...
2. {block}%: [push, block, push, block, ...] (isso tem algumas nuances, por exemplo, valores intermediários são removidos da pilha antes de cada push)
3. {block}*: empurrar, empurrar, bloquear, empurrar, bloquear, ...

A documentação do golfscript tem um exemplo de uso {+}*para somar o conteúdo de uma matriz. Isso sugere que podemos usar {*}*para obter o produto de uma matriz.

{,{*}*}:f

Infelizmente, não é tão simples assim. Todos os elementos estão desativados por um (em [0 1 2]vez de [1 2 3]). Podemos usar {)}%para corrigir esse problema.

{,{)}%{*}*}:f

Bem, não exatamente. Isso não lida com zero corretamente. Podemos calcular (n + 1)! / (N + 1) para corrigir isso, embora isso custe demais.

{).,{)}%{*}*\/}:f

Também podemos tentar manipular n = 0 no mesmo bloco que n = 1. Isso é extremamente curto, tente e trabalhe o mais curto possível.

Não tão boa é a classificação, a 7 caracteres: [1\]$1=. Observe que essa técnica de classificação tem objetivos úteis, como impor limites a um número (por exemplo, `[0 \ 100] $ 1 =)
Aqui está o vencedor, com apenas 3 caracteres:.! +

Se queremos ter o incremento e a multiplicação no mesmo bloco, devemos iterar todos os elementos da matriz. Como não estamos construindo uma matriz, isso significa que devemos usá-la {)*}/, o que nos leva à implementação mais curta do fatorial! Com 12 caracteres, isso está associado a J!

{,1\{)*}/}:f

Soluções bônus

Começando com uma ifsolução direta para um doloop:

{.{1\{.@*\(.}do;}{)}if}:f

Podemos extrair mais alguns disso. Um pouco complicado, então você terá que se convencer de que esses funcionam. Certifique-se de entender tudo isso.

{1\.!!{{.@*\(.}do}*+}:f
{.!{1\{.@*\(.}do}or+}:f
{.{1\{.@*\(.}do}1if+}:f

Uma alternativa melhor é calcular (n + 1)! / (N + 1), o que elimina a necessidade de uma ifestrutura.

{).1\{.@*\(.}do;\/}:f

Mas a dosolução mais curta aqui leva alguns caracteres para mapear de 0 a 1 e tudo o mais para si - portanto, não precisamos de nenhuma ramificação. Esse tipo de otimização é extremamente fácil de perder.

{.!+1\{.@*\(.}do;}:f

Para qualquer pessoa interessada, são fornecidas aqui algumas soluções recursivas alternativas com o mesmo comprimento acima:

{.!{.)f*0}or+}:f
{.{.)f*0}1if+}:f
{.{.(f*}{)}if}:f

* Nota: Na verdade, eu não testei muitos dos trechos de código neste post, portanto, fique à vontade para informar se há erros.

Haskell, 17

f n=product[1..n]

Python - 27

Simplesmente:

f=lambda x:0**x or x*f(x-1)

APL (4)

×/∘⍳

Funciona como uma função anônima:

    ×/∘⍳ 5
120

Se você quiser dar um nome, 6 caracteres:

f←×/∘⍳

J (12)

Uma definição padrão em J:

f=:*/@:>:@i.

Menos de 1 segundo para 125!

Por exemplo:

 f 0
 1
 f 5
 120
  f 125x
 1882677176888926099743767702491600857595403
 6487149242588759823150835315633161359886688
 2932889495923133646405445930057740630161919
 3413805978188834575585470555243263755650071
 31770880000000000000000000000000000000

Golfscript - 13 caracteres (SYM)

define a função !

{),()\{*}/}:!             # happy robot version \{*}/ 

versão alternativa de 13 caracteres

{),()+{*}*}:! 

a versão completa do programa é de 10 caracteres

~),()+{*}*

os casos de teste levam menos de 1/10 de segundo:

entrada:

0!

resultado

1

entrada

125!

resultado

188267717688892609974376770249160085759540364871492425887598231508353156331613598866882932889495923133646405445930057740630161919341380597818883457558547055524326375565007131770880000000000000000000000000000000

Caracteres do Perl 6: 13

$f={[*]1..$_}

[*]é o mesmo que Haskell producte 1..$_é uma contagem de 1 a $_, o argumento.

Matlab, 15

f=@(x)prod(1:x)

Casos de teste

>> f(0)
ans =
     1
>> f(4)
ans =
    24
>> tic,f(125),toc
ans =
  1.8827e+209
Elapsed time is 0.000380 seconds.

Python, 28 bytes

f=lambda x:x/~x+1or x*f(x-1)

(com base na solução da Alexandru)

MATL , 2 bytes

:p

Explicado:

:    % generate list 1,2,3,...,i, where i is an implicit input
p    % calculate the product of of all the list entries (works on an empty list too)

Experimente online!

Ruby - 21 caracteres

f=->n{n>1?n*f[n-1]:1}

Teste

irb(main):009:0> f=->n{n>1?n*f[n-1]:1}
=> #<Proc:0x25a6d48@(irb):9 (lambda)>
irb(main):010:0> f[125]
=> 18826771768889260997437677024916008575954036487149242588759823150835315633161
35988668829328894959231336464054459300577406301619193413805978188834575585470555
24326375565007131770880000000000000000000000000000000

Java, 85 caracteres

BigInteger f(int n){return n<2?BigInteger.ONE:new BigInteger(""+n).multiply(f(n-1));}

PostScript, 26 caracteres

/f{1 exch -1 1{mul}for}def

Exemplo:

GS> 0 f =
1
GS> 1 f =
1
GS> 8 f =
40320

A função em si tem apenas 21 caracteres; o resto é vinculá-lo a uma variável. Para salvar um byte, também é possível vinculá-lo a um dígito, assim:

GS> 0{1 exch -1 1{mul}for}def
GS> 8 0 load exec =
40320

JavaScript, 25

function f(n)!n||n*f(n-1)

CoffeeScript, 19

f=(n)->!n||n*f(n-1)

Retorna trueno caso de n = 0, mas o JavaScript coagirá esse tipo para 1 de qualquer maneira.

Ruby - 30 29 caracteres

def f(n)(1..n).inject 1,:*end

Teste

f(0) -> 1
f(5) -> 120

F #: 26 caracteres

Não há função de produto embutida em F #, mas você pode criar uma com uma dobra

let f n=Seq.fold(*)1{1..n}

C #, 20 ou 39 caracteres, dependendo do seu ponto de vista

Como um método de instância tradicional (39 caracteres; testado aqui ):

double f(int x){return 2>x?1:x*f(x-1);}

Como uma expressão lambda (20 caracteres, mas veja o aviso de isenção de responsabilidade; testado aqui ):

f=x=>2>x?1:x*f(x-1);

Temos que usar doubleporque 125! == 1,88 * 10 ²⁰⁹ , que é muito maior que ulong.MaxValue.

Isenção de responsabilidade sobre a contagem de caracteres da versão lambda:

Se você recursionar em um C # lambda, obviamente precisará armazenar o lambda em uma variável nomeada para que ela possa se chamar. Porém, diferente do JavaScript (por exemplo), um lambda auto-referente deve ter sido declarado e inicializado em uma linha anterior. Você não pode chamar a função na mesma instrução na qual declara e / ou inicializa a variável.

Em outras palavras, isso não funciona :

Func<int,double> f=x=>2>x?1:x*f(x-1); //Error: Use of unassigned local variable 'f'

Mas isso faz :

Func<int,double> f=null;            
f=x=>2>x?1:x*f(x-1);  

Não há uma boa razão para essa restrição, pois fnunca pode ser desassociada no momento em que é executada. A necessidade da Func<int,double> f=null;linha é uma peculiaridade de C #. Se isso faz com que seja justo ignorá-lo na contagem de caracteres, depende do leitor.

CoffeeScript, 21 19 caracteres de verdade

f=(x)->+!x||x*f x-1

Testado aqui: http://jsfiddle.net/0xjdm971/

Braquilog , 7 6 bytes

Fazendo um intervalo e multiplicando-o

Tanques de -1 byte a ovs, com a ideia de usar a função max ()

;1⌉⟦₁×

Explicação

;1          --  If n<1, use n=1 instead (zero case)
  ⟦₁        --      Construct the range [1,n]
    ×       --      return the product of said range

Experimente online!

Braquilog , 10 9 bytes

recursão

≤1|-₁↰;?×

Explicação

            --f(n):
≤1          --  if n ≤ 1: return 1
|           --  else:
 -₁↰        --      f(n-1)
    ;?×     --            *n

Experimente online!

C (39 caracteres)

double f(int n){return n<2?1:n*f(n-1);}

D: 45 caracteres

T f(T)(T n){return n < 2 ? 1 : n * f(n - 1);}

Mais legível:

T f(T)(T n)
{
    return n < 2 ? 1 : n * f(n - 1);
}

Um cooler (embora versão mais longa) é o modelo que faz tudo em tempo de compilação ( 64 caracteres ):

template F(int n){static if(n<2)enum F=1;else enum F=n*F!(n-1);}

Mais legível:

template F(int n)
{
    static if(n < 2)
        enum F = 1;
    else
        enum F = n * F!(n - 1);
}

Os modelos de mesmo nome são bastante detalhados, portanto, você não pode realmente usá-los muito bem no código golf. D já é detalhado o suficiente em termos de contagem de caracteres para ser bastante ruim para o código de golfe (embora realmente seja muito bom em reduzir o tamanho geral do programa para programas maiores). É a minha linguagem favorita, portanto, acho que é melhor tentar ver como é possível fazê-lo no código do golfe, mesmo se pessoas como o GolfScript quiserem usá-lo.

PowerShell - 36

Ingênuo:

filter f{if($_){$_*(--$_|f}else{1}}

Teste:

> 0,5,125|f
1
120
1,88267717688893E+209

Scala, 39 caracteres

def f(x:BigInt)=(BigInt(1)to x).product

A maioria dos caracteres garante que BigInts sejam usados ​​para que os requisitos de valores até 125 sejam atendidos.

Javascript, ES6 17

f=n=>n?n*f(n-1):1

ES6:

• Função de seta

PowerShell, 42 bytes

(salvou 2 caracteres usando filtro em vez de função )

filter f($x){if(!$x){1}else{$x*(f($x-1))}}

Resultado:

PS C:\> f 0
1
PS C:\> f 5
120
PS C:\> f 1
1
PS C:\> f 125
1.88267717688893E+209

Raquete (esquema) 40 35 29 bytes

Calcula 0! para ser 1 e calcula 125! em 0 segundos de acordo com o temporizador. Abordagem recursiva regular

(define(f n)(if(= n 0)1(* n(f(- n 1)))))

Nova versão para vencer o lisp comum: multiplica todos os elementos de uma lista (o mesmo que a solução Haskell)

(λ(n)(apply *(build-list n add1)))

Versão mais recente para superar a outra solução de esquema e matemática a outra solução de raquete usando foldl em vez de aplicar e usando range em vez de buildlist

(λ(n)(foldl * n(range 1 n)))

Mornington Crescent , 1827 1698 caracteres

Eu estava com vontade de aprender um novo idioma hoje, e foi nisso que eu pousei ... (Por que eu faço isso comigo mesmo?) Essa entrada não ganhará nenhum prêmio, mas será melhor que todas as outras 0 respostas até agora usando o mesmo idioma!

Take Northern Line to Bank
Take Central Line to Holborn
Take Piccadilly Line to Heathrow Terminals 1, 2, 3
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Acton Town
Take District Line to Hammersmith
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Parsons Green
Take District Line to Notting Hill Gate
Take Circle Line to Notting Hill Gate
Take Circle Line to Bank
Take Circle Line to Temple
Take Circle Line to Aldgate
Take Circle Line to Aldgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Aldgate
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take District Line to Upney
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upney
Take District Line to Bank
Take Circle Line to Embankment
Take Circle Line to Embankment
Take Northern Line to Angel
Take Northern Line to Moorgate
Take Metropolitan Line to Chalfont & Latimer
Take Metropolitan Line to Moorgate
Take Circle Line to Moorgate
Take Northern Line to Mornington Crescent

Experimente online!

Qualquer pessoa que viajou por Londres entenderá isso instantaneamente, é claro, então tenho certeza de que não preciso dar uma explicação completa.

A maior parte do trabalho no início é no tratamento do caso 0. Após inicializar o produto em 1, posso usá-lo para calcular o máximo (entrada, 1) para obter a nova entrada, aproveitando o fato de que 0! = 1! Então o loop principal pode começar.

(EDIT: Um monte de viagens foram salvas removendo o 1 dos "Terminais 1, 2, 3 de Heathrow" em vez de gerá-lo dividindo 7 (Irmãs) por si só. Também uso um método mais barato para gerar -1 em o próximo passo.)

Decrementar é caro em Mornington Crescent (embora seja menos caro que o próprio metrô). Para tornar as coisas mais eficientes, eu gero um -1 pegando o NOT de um 0 analisado e o armazeno em Hammersmith durante grande parte do loop.

Befunge - 2x20 = 40 caracteres

0\:#v_# 1#<\$v *\<
    >:1-:#^_$>\:#^_$

Essa é uma função, pois é um bloco de código independente que não utiliza a envolvente. Você deve colocar o argumento no topo da pilha e, em seguida, digite a partir do canto superior esquerdo, indo para a direita; a função sairá do canto inferior direito, indo para a direita, com o resultado no topo da pilha.

Por exemplo, para calcular o fatorial de 125

555**   0\:#v_# 1#<\$v *\<
            >:1-:#^_$>\:#^_$    .@

Teste 0

0   0\:#v_# 1#<\$v *\<
        >:1-:#^_$>\:#^_$    .@

J - 6 caracteres

*/>:i.

Isso conta? Eu sei que é muito parecido com o exemplo anterior de J, mas é um pouco mais curto :)

Sou iniciante com J, mas até agora é muito divertido!

Em C (23 caracteres)

Isso abusa do "recurso" do GCC que faz com que a última atribuição conte como retorno, se nenhum retorno for especificado.

f(a){a=a>0?f(a-1)*a:1;}

Em C adequado, 28 caracteres

f(a){return a>0?f(a-1)*a:1;}

Kona ( 11 6)

*/1.+!

K funciona da direita para a esquerda (na maior parte), por isso enumeramos x(fazemos uma lista / matriz de números de 0até x-1), adicionamos 1a ela (a faixa varia 0de x) e multiplicamos todos os números juntos. Se não fosse necessário calcular 125!, eu poderia economizar mais 1 byte, eliminando .próximo a 1. De qualquer forma, 125! é calculado em meros milissegundos:

  */1.+!125.
1.882677e+209