Le défi:

Écrivez un programme ou une fonction qui entre un nombre positif et renvoie sa factorielle .

^{Remarque: Il s'agit d'une question de contrôle de code . Veuillez ne pas prendre la question et / ou les réponses au sérieux. Plus d'informations ici . Chaque question de code-trolling est également une question de concours de popularité , donc la réponse la plus votée gagne.}

Il s'agit d'un problème de calcul numérique très simple que nous pouvons résoudre avec l'approximation de Stirling :

Comme vous pouvez le voir, cette formule comporte une racine carrée, dont nous aurons également besoin d'un moyen d'approximation. Nous choisirons la soi-disant "méthode babylonienne" pour cela car c'est sans doute la plus simple:

Notez que le calcul de la racine carrée de cette façon est un bon exemple de récursivité.

Tout rassembler dans un programme Python nous donne la solution suivante à votre problème:

def sqrt(x, n): # not the same n as below
    return .5 * (sqrt(x, n - 1) + x / sqrt(x, n - 1)) if n > 0 else x

n = float(raw_input())
print (n / 2.718) ** n * sqrt(2 * 3.141 * n, 10)

Avec une simple modification, le programme ci-dessus peut produire une table soignée de factorielles:

1! =    0.92215
2! =    1.91922
3! =    5.83747
4! =   23.51371
5! =  118.06923
6! =  710.45304
7! = 4983.54173
8! = 39931.74015
9! = 359838.58817

Cette méthode doit être suffisamment précise pour la plupart des applications.

C #

Désolé, mais je déteste la fonction récursive.

public string Factorial(uint n) {
    return n + "!";
}

Java

public int factorial ( int n ) {
switch(n){
case 0: return 1;
case 1: return 1;
case 2: return 2;
case 3: return 6;
case 4: return 24;
case 5: return 120;
case 6: return 720;
case 7: return 5040;
case 8: return 40320;
case 9: return 362880;
case 10: return 3628800;
case 11: return 39916800;
case 12: return 479001600;
default : throw new IllegalArgumentException();
}
}

Python

Bien sûr, la meilleure façon de résoudre tout problème est d'utiliser des expressions régulières:

import re

# adapted from http://stackoverflow.com/q/15175142/1333025
def multiple_replace(dict, text):
  # Create a regular expression  from the dictionary keys
  regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
  # Repeat while any replacements are made.
  count = -1
  while count != 0:
    # For each match, look-up corresponding value in dictionary.
    (text, count) = regex.subn(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
  return text

fdict = {
    'A': '@',
    'B': 'AA',
    'C': 'BBB',
    'D': 'CCCC',
    'E': 'DDDDD',
    'F': 'EEEEEE',
    'G': 'FFFFFFF',
    'H': 'GGGGGGGG',
    'I': 'HHHHHHHHH',
    'J': 'IIIIIIIIII',
    'K': 'JJJJJJJJJJJ',
    'L': 'KKKKKKKKKKKK',
    'M': 'LLLLLLLLLLLLL',
    'N': 'MMMMMMMMMMMMMM',
    'O': 'NNNNNNNNNNNNNNN',
    'P': 'OOOOOOOOOOOOOOOO',
    'Q': 'PPPPPPPPPPPPPPPPP',
    'R': 'QQQQQQQQQQQQQQQQQQ',
    'S': 'RRRRRRRRRRRRRRRRRRR',
    'T': 'SSSSSSSSSSSSSSSSSSSS',
    'U': 'TTTTTTTTTTTTTTTTTTTTT',
    'V': 'UUUUUUUUUUUUUUUUUUUUUU',
    'W': 'VVVVVVVVVVVVVVVVVVVVVVV',
    'X': 'WWWWWWWWWWWWWWWWWWWWWWWW',
    'Y': 'XXXXXXXXXXXXXXXXXXXXXXXXX',
    'Z': 'YYYYYYYYYYYYYYYYYYYYYYYYYY'}

def fact(n):
    return len(multiple_replace(fdict, chr(64 + n)))

if __name__ == "__main__":
    print fact(7)

Haskell

Le code court est un code efficace, alors essayez ceci.

fac = length . permutations . flip take [1..]

Pourquoi c'est à la traîne:

Je ris de tout codeur qui a écrit ça ... L'inefficacité est magnifique. Également probablement incompréhensible pour tout programmeur Haskell qui ne peut pas réellement écrire une fonction factorielle.

Edit: J'ai posté cela il y a un moment maintenant, mais je pensais clarifier pour les futures personnes et les personnes qui ne peuvent pas lire Haskell.

Le code ici prend la liste des nombres 1 à n, crée la liste de toutes les permutations de cette liste et renvoie la longueur de cette liste. Sur ma machine, cela prend environ 20 minutes pour 13!. Et puis cela devrait prendre quatre heures pour 14! puis deux jours et demi pour 15!. Sauf qu'à un moment donné, vous manquez de mémoire.

Edit 2: En fait, vous ne manquerez probablement pas de mémoire car il s'agit de Haskell (voir le commentaire ci-dessous). Vous pourriez être en mesure de le forcer à évaluer la liste et à la garder en mémoire d'une manière ou d'une autre, mais je ne connais pas suffisamment l'optimisation (et l'optimisation) de Haskell pour savoir exactement comment faire cela.

C #

Comme il s'agit d'un problème mathématique, il est logique d'utiliser une application spécialement conçue pour résoudre les problèmes mathématiques pour effectuer ce calcul ...

Étape 1:

Installez MATLAB. Un essai fonctionnera, je pense, mais ce problème super compliqué est probablement suffisamment important pour mériter l'achat de la version complète de l'application.

Étape 2:

Incluez le composant MATLAB COM dans votre application.

Étape 3:

public string Factorial(uint n) {
    MLApp.MLApp matlab = new MLApp.MLApp();
    return matlab.Execute(String.Format("factorial({0})", n);
}

C #

Les factorielles sont une opération mathématique de niveau supérieur qui peut être difficile à digérer d'un seul coup. La meilleure solution dans des problèmes de programmation comme celui-ci est de décomposer une tâche importante en tâches plus petites.

Maintenant, n! est défini comme 1 * 2 * ... * n, donc, essentiellement une multiplication répétée, et la multiplication n'est rien d'autre que l'addition répétée. Donc, avec cela à l'esprit, ce qui suit résout ce problème:

long Factorial(int n)
{
    if(n==0)
    {
        return 1;
    }

    Stack<long> s = new Stack<long>();
    for(var i=1;i<=n;i++)
    {
        s.Push(i);
    }
    var items = new List<long>();
    var n2 = s.Pop();
    while(s.Count >0)
    {
        var n3 = s.Pop();
        items.AddRange(FactorialPart(n2,n3));
        n2 = items.Sum();
    }
    return items.Sum()/(n-1);
}

IEnumerable<long> FactorialPart(long n1, long n2)
{
    for(var i=0;i<n2;i++){
        yield return n1;
    }
}

#include <math.h>

int factorial(int n)
{
    const double g = 7;
    static const double p[] = { 0.99999999999980993, 676.5203681218851,
                                -1259.1392167224028, 771.32342877765313,
                                -176.61502916214059, 12.507343278686905,
                                -0.13857109526572012, 9.9843695780195716e-6,
                                1.5056327351493116e-7 };
    double z = n - 1 + 1;
    double x = p[0];
    int i;
    for ( i = 1; i < sizeof(p)/sizeof(p[0]); ++i )
        x += p[i] / (z + i);
    return sqrt(2 * M_PI) * pow(z + g + 0.5, z + 0.5)  * exp(-z -g -0.5) * x + 0.5;
}

Trolls:

• Une méthode 100% correcte de calcul factoriel qui rate complètement le point de le faire de manière itérative ou récursive.
• Vous ne savez pas pourquoi cela fonctionne et ne pouvez pas le généraliser pour faire autre chose.
• Plus coûteux que de simplement le calculer avec des mathématiques entières.
• Le code ( z = n - 1 + 1) sous-optimal le plus évident ( ) est en fait auto-documenté si vous savez ce qui se passe.
• Pour plus de pêche à la traîne, je devrais calculer en p[]utilisant un calcul récursif des coefficients de série!

(C'est l' approximation de Lanczos de la fonction gamma )

Nous savons tous de l'université que la façon la plus efficace de calculer une multiplication est d'utiliser des logarithmes. Après tout, pourquoi les gens utiliseraient-ils des tables de logarithmes pendant des centaines d'années?

Donc, à partir de l'identité, a*b=e^(log(a)+log(b))nous formons le code Python suivant:

from math import log,exp

def fac_you(x):
    return round(exp(sum(map(log,range(1,x+1)))))

for i in range(1,99):
    print i,":",fac_you(i)

Il crée une liste de nombres de 1à x, (le +1est nécessaire parce que Python aspire) calcule le logarithme de chacun, additionne les nombres, élève le e à la puissance de la somme et arrondit finalement la valeur à l'entier le plus proche (parce que Python aspire) . Python a une fonction intégrée pour calculer les factorielles, mais il ne fonctionne que pour les entiers, donc il ne peut pas produire de grands nombres (parce que Python craint). C'est pourquoi la fonction ci-dessus est nécessaire.

Btw, un conseil général pour les étudiants est que si quelque chose ne fonctionne pas comme prévu, c'est probablement parce que la langue est nulle.

Malheureusement, Javascript n'a pas de méthode intégrée pour calculer la factorielle. Mais, vous pouvez utiliser sa signification en combinatoire pour déterminer la valeur néanmoins:

La factorielle d'un nombre n est le nombre de permutations d'une liste de cette taille.

Ainsi, nous pouvons générer chaque liste de nombres à n chiffres, vérifier s'il s'agit d'une permutation, et si oui, incrémenter un compteur:

window.factorial = function($nb_number) {
  $nb_trials = 1
  for($i = 0; $i < $nb_number; $i++) $nb_trials *= $nb_number
  $nb_successes = 0
  __trying__:
  for($nb_trial = 0; $nb_trial < $nb_trials; $nb_trial++){
    $a_trial_split = new Array
    $nb_tmp = $nb_trial
    for ($nb_digit = 0; $nb_digit < $nb_number; $nb_digit++){
      $a_trial_split[$nb_digit] = $nb_tmp - $nb_number * Math.floor($nb_tmp / $nb_number)
      $nb_tmp = Math.floor($nb_tmp / $nb_number)
    }
    for($i = 0; $i < $nb_number; $i++)
      for($j = 0; $j < $nb_number; $j++)
        if($i != $j)
          if($a_trial_split[$i] == $a_trial_split[$j])
            continue __trying__
    $nb_successes += 1
  }
  return $nb_successes
}

alert("input a number")
document.open()
document.write("<input type = text onblur = alert(factorial(parseInt(this.value))))>")
document.close()

Trolls:

• Types de notation hongroise, snake_case et sigils inutiles . Comment est-ce mal?
• J'ai inventé ma propre convention pour les étiquettes de saut, incompatible avec l'utilisation actuelle de cette convention.
• Chaque variable possible est accidentellement globale.
• La solution n'est pas O(n), non O(n!), mais O(n^n). Cela seul aurait suffi pour se qualifier ici.
• Incrémenter un nombre puis convertir en base-n est une mauvaise façon de générer une liste de séquences. Même si nous voulions des doublons. Une rupture mystérieuse pour n> 13 n'est pas la seule raison.
• Bien sûr, nous aurions pu utiliser number.toString(base), mais cela ne fonctionne pas pour les bases supérieures à 36. Oui, je sais 36! c'est beaucoup , mais quand même ...
• Ai-je mentionné que Javascript avait l'opérateur de module? OuMath.pow ? Non? Tant pis.
• Refuser d'utiliser en ++dehors de for-loops le rend encore plus mystérieux. Aussi, ==c'est mauvais.
• Constructions en boucle sans renfort profondément imbriquées. En outre, les conditions imbriquées au lieu de ET. De plus, la condition extérieure aurait pu être évitée en terminant la boucle intérieure à $i.
• Les fonctions new Array, document.write(avec des amis) et alert(au lieu d'une invite ou d'une étiquette d'entrée) forment un trifecta complet de péchés de choix de fonction. Pourquoi l'entrée est-elle ajoutée dynamiquement après tout?
• Gestionnaires d'événements en ligne. Oh, et la tuyauterie profonde est un enfer à déboguer.
• Les attributs non cotés sont amusants et les espaces autour les =rendent encore plus difficiles à lire.
• Ai-je déjà mentionné que je déteste les points-virgules?

Ruby et WolframAlpha

Cette solution utilise l'API REST WolframAlpha pour calculer la factorielle, avec RestClient pour récupérer la solution et Nokogiri pour l'analyser. Il ne réinvente aucune roue et utilise des technologies bien testées et populaires pour obtenir le résultat de la manière la plus moderne possible.

require 'rest-client'
require 'nokogiri'

n = gets.chomp.to_i
response = Nokogiri::XML(RestClient.get("http://api.wolframalpha.com/v2/query?input=#{n}!&format=moutput&appid=YOUR_APP_KEY"))
puts response.xpath("//*/moutput/text()").text

Javascript

Javascript est un langage de programmation fonctionnel, cela signifie que vous devez utiliser des fonctions pour tout car c'est plus rapide.

function fac(n){
    var r = 1,
        a = Array.apply(null, Array(n)).map(Number.call, Number).map(function(n){r = r * (n + 1);});
    return r;
}

Utilisation de Bogo-Sort en Java

public class Factorial {
    public static void main(String[] args) {
        //take the factorial of the integers from 0 to 7:
        for(int i = 0; i < 8; i++) {
            System.out.println(i + ": " + accurate_factorial(i));
        }
    }

    //takes the average over many tries
    public static long accurate_factorial(int n) {
        double sum = 0;
        for(int i = 0; i < 10000; i++) {
            sum += factorial(n);
        }
        return Math.round(sum / 10000);
    }

    public static long factorial(int n) {
        //n! = number of ways to sort n
        //bogo-sort has O(n!) time, a good approximation for n!
        //for best results, average over several passes

        //create the list {1, 2, ..., n}
        int[] list = new int[n];
        for(int i = 0; i < n; i++)
            list[i] = i;

        //mess up list once before we begin
        randomize(list);

        long guesses = 1;

        while(!isSorted(list)) {
            randomize(list);
            guesses++;
        }

        return guesses;
    }

    public static void randomize(int[] list) {
        for(int i = 0; i < list.length; i++) {
            int j = (int) (Math.random() * list.length);

            //super-efficient way of swapping 2 elements without temp variables
            if(i != j) {
                list[i] ^= list[j];
                list[j] ^= list[i];
                list[i] ^= list[j];
            }
        }
    }

    public static boolean isSorted(int[] list) {
        for(int i = 1; i < list.length; i++) {
            if(list[i - 1] > list[i])
                return false;
        }
        return true;
    }
}

Cela fonctionne en fait, très lentement, et ce n'est pas exact pour des nombres plus élevés.

PERL

Le factoriel peut être un problème difficile. Une technique de type carte / réduction - tout comme Google utilise - peut diviser les calculs en interrompant un tas de processus et en collectant les résultats. Cela fera bon usage de tous ces cœurs ou processeurs dans votre système par une froide nuit d'hiver.

Enregistrez sous f.perl et chmod 755 pour vous assurer que vous pouvez l'exécuter. Vous avez installé la liste des déchets pathologiquement éclectiques, n'est-ce pas?

#!/usr/bin/perl -w                                                              
use strict;
use bigint;
die "usage: f.perl N (outputs N!)" unless ($ARGV[0] > 1);
print STDOUT &main::rangeProduct(1,$ARGV[0])."\n";
sub main::rangeProduct {
    my($l, $h) = @_;
    return $l    if ($l==$h);
    return $l*$h if ($l==($h-1));
    # arghhh - multiplying more than 2 numbers at a time is too much work       
    # find the midpoint and split the work up :-)                               
    my $m = int(($h+$l)/2);
    my $pid = open(my $KID, "-|");
      if ($pid){ # parent                                                       
        my $X = &main::rangeProduct($l,$m);
        my $Y = <$KID>;
        chomp($Y);
        close($KID);
        die "kid failed" unless defined $Y;
        return $X*$Y;
      } else {
        # kid                                                                   
        print STDOUT &main::rangeProduct($m+1,$h)."\n";
        exit(0);
    }
}

Trolls:

• fourches O (log2 (N)) processus
• ne vérifie pas le nombre de processeurs ou de cœurs dont vous disposez
• Masque de nombreuses conversions bigint / texte qui se produisent dans chaque processus
• Une boucle for est souvent plus rapide que ce code

Python

Juste un algorithme O (n! * N ^ 2) pour trouver la factorielle. Cas de base traité. Pas de débordements.

def divide(n,i):
    res=0
    while n>=i:
         res+=1
         n=n-i
    return res

def isdivisible(n,numbers):
    for i in numbers:
         if n%i!=0:
             return 0
         n=divide(n,i)
    return 1

def factorial(n):
    res = 1
    if n==0: return 1 #Handling the base case
    while not isdivisible(res,range(1,n+1)):
         res+=1
    return res

Eh bien, il existe une solution simple dans Golfscript. Vous pouvez utiliser un interpréteur Golfscript et exécuter ce code:

.!+,1\{)}%{*}/

Facile hein :) Bonne chance!

Mathematica

factorial[n_] := Length[Permutations[Table[k, {k, 1, n}]]]

Cela ne semble pas fonctionner pour des nombres supérieurs à 11, et le factoriel [11] a gelé mon ordinateur.

Rubis

f=->(n) { return 1 if n.zero?; t=0; t+=1 until t/n == f[n-1]; t }

Le one-liner le plus lent que je puisse imaginer. Il faut 2 minutes sur un processeur i7 pour calculer 6!.

L'approche correcte pour ces problèmes mathématiques difficiles est une DSL. Je vais donc modéliser cela en termes de langage simple

data DSL b a = Var x (b -> a)
             | Mult DSL DSL (b -> a)
             | Plus DSL DSL (b -> a)
             | Const Integer (b -> a) 

Pour bien écrire notre DSL, il est utile de le voir comme une monade gratuite générée par le foncteur algébrique

F X = X + F (DSL b (F X)) -- Informally define + to be the disjoint sum of two sets

Nous pourrions écrire ceci dans Haskell comme

Free b a = Pure a
         | Free (DSL b (Free b a))

Je laisse au lecteur le soin de tirer la mise en œuvre triviale de

join   :: Free b (Free b a) -> Free b a
return :: a -> Free b a
liftF  :: DSL b a -> Free b a

Maintenant, nous pouvons décrire une opération pour modéliser une factorielle dans cette DSL

factorial :: Integer -> Free Integer Integer
factorial 0 = liftF $ Const 1 id
factorial n = do
  fact' <- factorial (n - 1)
  liftF $ Mult fact' n id

Maintenant que nous avons modélisé cela, nous avons juste besoin de fournir une fonction d'interprétation réelle pour notre monade libre.

denote :: Free Integer Integer -> Integer
denote (Pure a) = a
denote (Free (Const 0 rest)) = denote $ rest 0
...

Et je laisse le reste de la dénotation au lecteur.

Pour améliorer la lisibilité, il est parfois utile de présenter un AST concret du formulaire

data AST = ConstE Integer
         | PlusE AST AST
         | MultE AST AST

puis à droite une réflexion triviale

reify :: Free b Integer -> AST

puis il est simple d'évaluer récursivement l'AST.

Python

Voici donc le code: la getDigitsfonction divise une chaîne représentant un nombre en ses chiffres, donc "1234" devient [ 4, 3, 2, 1 ](l'ordre inverse rend simplement les fonctions increaseet multiplyplus simples). La increasefonction prend une telle liste et l'augmente d'une unité. Comme son nom l'indique, la multiplyfonction se multiplie, par exemple multiply([2, 1], [3])retourne [ 6, 3 ]parce que 12 fois 3 est 36. Cela fonctionne de la même manière que vous multiplieriez quelque chose avec un stylo et du papier.

Enfin, la factorialfonction utilise ces fonctions d'aide pour calculer la factorielle réelle, par exemple factorial("9")donne "362880"comme sortie.

import copy

def getDigits(n):
    digits = []
    for c in n:
        digits.append(ord(c) - ord('0'))

    digits.reverse()
    return digits

def increase(d):
    d[0] += 1
    i = 0
    while d[i] >= 10:
        if i == len(d)-1:
            d.append(0)

        d[i] -= 10
        d[i+1] += 1
        i += 1

def multiply(a, b):
    subs = [ ]
    s0 = [ ]
    for bi in b:

        s = copy.copy(s0)
        carry = 0
        for ai in a:
            m = ai * bi + carry
            s.append(m%10)
            carry = m//10

        if carry != 0:
            s.append(carry)

        subs.append(s)
        s0.append(0)

    done = False
    res = [ ]
    termsum = 0
    pos = 0
    while not done:
        found = False
        for s in subs:
            if pos < len(s):
                found = True
                termsum += s[pos]

        if not found:
            if termsum != 0:
                res.append(termsum%10)
                termsum = termsum//10
            done = True
        else:
            res.append(termsum%10)
            termsum = termsum//10
            pos += 1

    while termsum != 0:
        res.append(termsum%10)
        termsum = termsum//10

    return res

def factorial(x):
    if x.strip() == "0" or x.strip() == "1":
        return "1"

    factorial = [ 1 ]
    done = False
    number = [ 1 ]
    stopNumber = getDigits(x)
    while not done:
        if number == stopNumber:
            done = True

        factorial = multiply(factorial, number)
        increase(number)

    factorial.reverse()

    result = ""
    for c in factorial:
        result += chr(c + ord('0'))

    return result

print factorial("9")

Remarques

En python, un entier n'a pas de limite, donc si vous souhaitez le faire manuellement, vous pouvez simplement le faire

fac = 1
for i in range(2,n+1): 
    fac *= i

Il y a aussi le très pratique math.factorial(n) fonction .

Cette solution est évidemment beaucoup plus complexe qu'elle ne devrait l'être, mais elle fonctionne et en fait, elle illustre comment vous pouvez calculer la factorielle au cas où vous seriez limité à 32 ou 64 bits. Donc, même si personne ne croira que c'est la solution que vous avez trouvée pour ce problème simple (au moins en Python), vous pouvez réellement apprendre quelque chose.

Python

La solution la plus raisonnable est clairement de vérifier tous les nombres jusqu'à ce que vous trouviez celui qui est la factorielle du nombre donné.

print('Enter the number')
n=int(input())
x=1
while True:
    x+=1
    tempx=int(str(x))
    d=True
    for i in range(1, n+1):
        if tempx/i!=round(tempx/i):
            d=False
        else:
            tempx/=i
    if d:
        print(x)
        break

Une solution récursive la plus élégante en C

Chacun sait que les solutions les plus élégantes aux factorielles sont récursives.

Factorielle:

0! = 1
1! = 1
n! = n * (n - 1)!

Mais la multiplication peut également être définie récursivement comme des ajouts successifs.

Multiplication:

n * 0 = 0
n * 1 = n
n * m = n + n * (m - 1)

Et il en va de même pour les incrémentations successives.

Une addition:

n + 0 = n
n + 1 = (n + 1)
n + m = (n + 1) + (m - 1)

Dans C, nous pouvons utiliser ++xet --xgérer les primitives (x + 1)et (x - 1)respectivement, nous avons donc tout défini.

#include <stdlib.h>
#include <stdio.h>

// For more elegance, use T for the type
typedef unsigned long T;

// For even more elegance, functions are small enough to fit on one line

// Addition
T A(T n, T m) { return (m > 0)? A(++n, --m) : n; }

// Multiplication
T M(T n, T m) { return (m > 1)? A(n, M(n, --m)): (m? n: 0); }

// Factorial
T F(T n) { T m = n; return (m > 1)? M(n, F(--m)): 1; }

int main(int argc, char **argv)
{
    if (argc != 2)
        return 1;

    printf("%lu\n", F(atol(argv[1])));

    return 0;
}

Essayons-le:

$ ./factorial 0
1
$ ./factorial 1
1
$ ./factorial 2
2
$ ./factorial 3
6
$ ./factorial 4
24
$ ./factorial 5
120
$ ./factorial 6
720
$ ./factorial 7
5040
$ ./factorial 8
40320

Parfait, bien que 8! a pris beaucoup de temps pour une raison quelconque. Eh bien, les solutions les plus élégantes ne sont pas toujours les plus rapides. Nous allons continuer:

$ ./factorial 9

Hmm, je vous préviendrai quand il reviendra ...

Python

Comme l'indique la réponse de @ Matt_Sieker, les factorielles peuvent être divisées en plus - pourquoi, la répartition des tâches est l'essence de la programmation. Mais, nous pouvons décomposer cela en addition par 1!

def complicatedfactorial(n):
    def addby1(num):
        return num + 1
    def addnumbers(a,b):
        copy = b
        cp2 = a
        while b != 0:
            cp2 = addby1(cp2)
            b -= 1
    def multiply(a,b):
        copy = b
        cp2 = a
        while b != 0:
            cp2 = addnumbers(cp2,cp2)
    if n == 0:
        return 1
    else:
        return multiply(complicatedfactorial(n-1),n)

Je pense que ce code garantit une erreur SO, car

1. Récursion - réchauffe

2. Chaque couche génère des appels à se multiplier

3. qui génère des appels vers des numéros supplémentaires

4. qui génère des appels à addby1!

Trop de fonctions, non?

Accédez simplement à Google et saisissez votre factorielle:

5!

http://lmgtfy.com/?q=5!

TI-Basic 84

:yumtcInputdrtb@gmail And:cReturnbunchojunk@Yahoo A!op:sEnd:theemailaddressIS Crazy ANSWER LOL

Ça marche vraiment :)

Javascript

De toute évidence, le travail d'un programmeur est de faire le moins de travail possible et d'utiliser autant de bibliothèques que possible. Nous voulons donc importer jQuery et math.js . Maintenant, la tâche est simple comme ceci:

$.alert=function(message){
    alert(message);
}$.factorial=function(number){
    alert(math.eval(number+"!"));
    return math.eval(number+"!");
}
$.factorial(10);

Python

Avec juste une légère modification de l'implémentation factorielle récursive standard, elle devient intolérablement lente pour n> 10.

def factorial(n):
    if n in (0, 1):
        return 1
    else:
        result = 0
        for i in range(n):
            result += factorial(n - 1)
        return result

Frapper

#! /bin/bash

function fact {
    if [[ ${1} -le 1 ]]; then
        return 1
    fi;

    fact $((${1} - 1))
    START=$(date +%s)
    for i in $(seq 1 $?); do sleep ${1}; done
    END=$(date +%s)
    RESULT=$(($END - $START))
    return $RESULT
}

fact ${1}
echo $?

Essayons de le faire par la méthode Monte Carlo . Nous savons tous que la probabilité que deux n- permutations aléatoires soient égales est exactement de 1 / n! . Par conséquent, nous pouvons simplement vérifier combien de tests sont nécessaires (appelons ce numéro b ) jusqu'à ce que nous obtenions c hits. Alors, n! ~ b / c .

Sage, devrait aussi fonctionner en Python

def RandomPermutation(n) :           
    t = range(0,n)                   
    for i in xrange(n-1,0,-1):       
        x = t[i]                     
        r = randint(0,i)             
        t[i] = t[r]                  
        t[r] = x                     
    return t                         

def MonteCarloFactorial(n,c) :   
    a = 0                            
    b = 0                            
    t = RandomPermutation(n)         
    while a < c :                
        t2 = list(t)                 
        t = RandomPermutation(n)     
        if t == t2 :                 
            a += 1                   
        b += 1                       
    return round(b/c)            

MonteCarloFactorial(5,1000)
# returns an estimate of 5!

frapper

Les factorielles sont facilement déterminées avec des outils de ligne de commande bien connus de bash.

read -p "Enter number: " $n
seq 1 $n | xargs echo | tr ' ' '*' | bc

Comme @Aaron Davies l'a mentionné dans les commentaires, cela semble beaucoup plus ordonné et nous voulons tous un programme agréable et bien rangé, n'est-ce pas?

read -p "Enter number: " $n
seq 1 $n | paste -sd\* | bc