Class identiteremarquable.java

Soyez le premier à donner votre avis sur cette source.

Vue 5 697 fois - Téléchargée 138 fois

Description

un code simpliste juste pour le fun avec une méthode récursive et itérative.
Dans cette classe vous trouvez le calcul :
- d'une factoriel : n!
- d'une combinaison : C(n,k) tel que n <= k !
- d'une identité remarquable général : (a+b)^n = (b+a)^n

Source / Exemple :


public class IdentiteRemarquable
{
	/**

  • This method enable to calculate factorial
  • @param
  • n - n!
  • /
public static long factoriel(int n) { return n < 1 ? 1 : n * factoriel(--n); } /*
  • This method enable to calculate a combinaison with n <= k
  • C (n,k) = k! / (n!(k-n)!)
  • /
public static long combinaison(int n, int k) { return (factoriel(k) / (factoriel(n) * (factoriel(k-n)))); } /**
  • This method enable to calculate (a+b)^n
  • (a+b)^n = Sum( C(n,k) * a^k * b^(n-k) )
  • /
public static long calculate(int a, int b, int n) { long out = 0; for (int k = 0; k <= n; k++) { out += combinaison(k, n) * Math.pow((double)a, (double)k) * Math.pow((double)b, (double)(n - k)); } return out; } /**
  • Test program
  • /
public static void main(String[] args) { // factoriel int f = 5; long resultF = IdentiteRemarquable.factoriel(f); System.out.println("f(" + f + ") = " + resultF); // fact(5) = 120 // combinaison int n = 3; int k = 17; long c = IdentiteRemarquable.combinaison(n, k); System.out.println("c(" + n + "," + k + ") = " + c); // C (3,17) = 680 // (a+b)^n int a = 5; int b = 2; int n2 = 2; long r = IdentiteRemarquable.calculate(a, b, n2); System.out.println("(" + a + "+" + b + ")^" + n2 + " = " + r); // (5+2)^2 = 49 System.out.println(IdentiteRemarquable.calculate(12, 7, 10)); // (12 + 7)^10 = ... } }

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

itek
Messages postés
3
Date d'inscription
vendredi 8 avril 2005
Statut
Membre
Dernière intervention
16 décembre 2008

voici ma version de la fonction en utilisant tail-rec et Biginteger:

private BigInteger factoriel(BigInteger currentNumber, BigInteger sum) {
if(currentNumber.intValue()== 1) {
return sum;
} else {
return factoriel(currentNumber.subtract(new BigInteger("1")), sum.multiply(currentNumber));
}

}
public BigInteger factoriel( BigInteger n) {
return factoriel(n, new BigInteger("1"));
}

/*
* This method enable to calculate a combinaison with n <= k
* C (n,k) = k! / (n!(k-n)!)
*/
public BigInteger combinaison(String n, String k){
BigInteger Bn = new BigInteger (n);
BigInteger Bk = new BigInteger (k);
return (factoriel(Bk).divide((factoriel(Bn).multiply((factoriel(Bk.subtract(Bn)))))));
}
The Red Man
Messages postés
112
Date d'inscription
vendredi 15 avril 2005
Statut
Membre
Dernière intervention
13 juin 2010
2
ah d'accord eh bien merci pour l'info !
coucou747
Messages postés
12303
Date d'inscription
mardi 10 février 2004
Statut
Modérateur
Dernière intervention
30 juillet 2012
30
la mathode tail-rec, c'est celle que j'ai mise plus haut.
beaucoup de compilateurs s'occupent des fonctions tail-recursives pour les rendre iteratives, ce qui evite de faire exploser la pile.
The Red Man
Messages postés
112
Date d'inscription
vendredi 15 avril 2005
Statut
Membre
Dernière intervention
13 juin 2010
2
salut coucou747,

peux-tu me dire l'intérêt d'utiliser la méthode du "tail-récursive" par rapport à la récursivité pur ?
Chatbour
Messages postés
71
Date d'inscription
jeudi 27 juillet 2006
Statut
Membre
Dernière intervention
12 juillet 2009
4
Salut,

coucou747 -> tu peux donner un exemple sur la méthode tail-récursive ?

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.