Discussion :

[mathlooty]

Bonjour je suis nouveau sur votre forum, je suis débutant en programmation (3 semaines) j'ai découvert le forum en tapant sur google 'algorithme factorielle en java. J'en ai retrouvé un, mais il n'y avait pas de méthode main. Je l'ai donc complété.
Je fais encore souvent beuacoup de petites fautes, mais aussi des grosses. Je n'ai pas pu exécuter mon code car je ne sais pas utilisé Eclipse. J'aimerais savoir si ce que j'ai fait est juste ?

Je dois calculer la factorielle de n
Je dois utilisés une boucle for et pas de formule mathématique.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
*import ordinateur.clavier;
*import ordinateur.ecran;
 
 
public class factorielle 
{
	public static void CalculerLaFactorielleden (int n)
	{
	// PRECONDITION : Le nombre entré est un nombre entier (un int), pas de nombre à virgules
	// Le nombre entré est un nombre entier positif (pas de nombre négatif )
	// Invariant : 0!=1
	// 	      (x+1)!=(x+1)*x! (x est un Naturel.)
 
		int fact = 1;
		for (int i=1; i<=n; i++) {
		fact = fact * i;
		}
		return fact;
		}
 
		System.out.println(fact);
	}
 
	// POSTCONDITION : Le résultat est affiché
 
	public static void main (String [] args)
	{
	final int max = m;
	ecran.afficher ("Entrez un Int");
	int n = clavier.lireUnInt();
	}
}

[Jack Sparrow]

Salut,

Dans un premier temps, essaye de compiler le code.
Il y a des erreurs au niveau des accolades.

Et tu as le System.out qui est placé au milieu de nul part.

[slim_java]

salut.
voila une version de ton code corrigé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;
public class factorielle 
 
{
 
	public int CalculerLaFactorielleden (int n)
	{
	// PRECONDITION : Le nombre entré est un nombre entier (un int), pas de nombre à virgules
	// Le nombre entré est un nombre entier positif (pas de nombre négatif )
	// Invariant : 0!=1
	// 	      (x+1)!=(x+1)*x! (x est un Naturel.)
 
		int fact = 1;
		for (int i=1; i<=n; i++) 
		{
		fact = fact * i;
		}		
		return fact;	
	}
 
	// POSTCONDITION : Le résultat est affiché
 
	public static void main (String [] args)
	{	
	System.out.println("donner un entier :");
	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();	
	factorielle objetFact = new factorielle ();
	System.out.println("le factorielle de "+n+" est : "+objetFact.CalculerLaFactorielleden(n));
	}
 
 
}

bonne chance.

[OButterlin]

Sinon, dans un style dépouillé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class Factorielle {
 
    public static void main(String[] args)
    {
        long n = Long.parseLong(args[0]);
        System.out.println("Résultat : " + factorielle(n));
    }
 
    private static long factorielle(long n)
    {
        if (n > 1) return n * factorielle(n-1);
        return n;
    }
}

[Jack Sparrow]

Sinon, dans un style dépouillé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
public class Factorielle {
 
    public static void main(String[] args)
    {
        long n = Long.parseLong(args[0]);
        System.out.println("Résultat : " + factorielle(n));
    }
 
    private static long factorielle(long n)
    {
        if (n > 1) return n * factorielle(n-1);
        return n;
    }
}

C'est bien d'expliqué que dans le cas là. Il y a des appels récursifs, donc que la pile d'appel grossi et il y a un risque (en général) d'avoir un dépassement de mémoire.

Ceci dit, pour la factoriel, il y a un dépassement de la taille des int à peine au huitième appel (à vue de nez), donc pas de risque d'avoir de problème de mémoire

Mais c'est bien d'en être conscient.

[OButterlin]

C'est bien d'expliqué que dans le cas là. Il y a des appels récursifs, donc que la pile d'appel grossi et il y a un risque (en général) d'avoir un dépassement de mémoire.

Ceci dit, pour la factoriel, il y a un dépassement de la taille des int à peine au huitième appel (à vue de nez), donc pas de risque d'avoir de problème de mémoire

Mais c'est bien d'en être conscient.

La capacité d'un int est de 2.147.483.647, on a de la marge, ce n'est certainement pas la factorielle de 9 qui va l'atteindre...
Mais là, l'exemple est en long, donc la limite est de 9.223.372.036.854.775.807... c'est loin...

Pour le reste, effectivement, c'est un appel récursif... la simplification de code n'est pas transcendante pour la factorielle mais ça donne un exemple concret d'une utilisation.
L'exemple fait l'impasse sur la factorielle de 0 et ne traite pas l'exception sur un nombre négatif... bref, il y a de quoi étoffer...

[mathlooty]

salut.
voila une version de ton code corrigé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
import java.util.Scanner;
public class factorielle 
 
{
 
	public int CalculerLaFactorielleden (int n)
	{
	// PRECONDITION : Le nombre entré est un nombre entier (un int), pas de nombre à virgules
	// Le nombre entré est un nombre entier positif (pas de nombre négatif )
	// Invariant : 0!=1
	// 	      (x+1)!=(x+1)*x! (x est un Naturel.)
 
		int fact = 1;
		for (int i=1; i<=n; i++) 
		{
		fact = fact * i;
		}		
		return fact;	
	}
 
	// POSTCONDITION : Le résultat est affiché
 
	public static void main (String [] args)
	{	
	System.out.println("donner un entier :");
	Scanner sc = new Scanner(System.in);
	int n = sc.nextInt();	
	factorielle objetFact = new factorielle ();
	System.out.println("le factorielle de "+n+" est : "+objetFact.CalculerLaFactorielleden(n));
	}
 
 
}

bonne chance.

Merci c'est sympa! mais je n'ai jamais utilisé la class java util scanner, je n'ai pas tout compris

par quoi je peux modifier dans la méthode main les points suivant ?
-scanner sc= new scanner (system.in) ---- > je ne comprends pas
-int n = sc.nextInt(); -----> c'est pour lire le n entré par l'utilisateur ? je peux donc utilisé ma méthode int n= clavier.lireUnInt ?
-factorielle objetFact = new factorielle ();--> çà fait quoi ?

je me sens largué

[guigui5931]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Scanner sc = new Scanner(System.in);

permet de déclarer un objet Scanner qui lira les caractère saisis au clavier dans la console.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
int n = sc.nextInt();

permet de lire l'entier suivant saisie. Je ne sais pas ce que fais ta méthode clavier.lireUnInt donc je ne peux pas te dire si tu peux l'utiliser à la place.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
factorielle objetFact = new factorielle ();

permet de créer un objet de type factorielle sur lequel tu pourra ensuite appeler ta méthode CalculerLaFactorielleden.

[danimo]

Salut,

J'ose te donner cet exemple avec Scanner:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
   import java.util.Scanner;
 
    public class Factoriel
   {
       public static void main (String [] args)
      {
 
      /*
      VALEUR MINI d'un INT.
      >>>>  int mon_int = Integer.MIN_VALUE;
      La valeur minimale d'un int est -2147483648
      
      
      VALEUR MAXI d'un INT.
      >>>>  int mon_int = Integer.MAX_VALUE;
      La valeur maximale d'un int est 2147483647
      
      
      VALEUR MINI d'un LONG
      >>>>  long mon_long = Long.MIN_VALUE;
      La valeur minimale d'un long est -9223372036854775808
      
      
      VALEUR MAXI d'un LONG
      >>>>  long mon_long = Long.MAX_VALUE;
      La valeur maximale d'un long est 9223372036854775807
      */
 
 
         /*int n, i, factoriel = 1; // maxi de n = 13
         int max = 13;
         String lib = "(1 a 13 avec int),";
         String lib2 = "int"; */
 
      	//OU BIEN:
         long n, i, factoriel; // maxi de n = 20
         int max = 20;
         String lib = "(1 a 20 avec long),";
         String lib2 = "long";
/**Mais pas les deux en mème temps
 Compiler avec l'un ou l'autre
 Tel que ci-dessus ce sera avec un long
 Envisager l'utilisation avec Big  Integer ou Decimal je ne sais plus
 pour aller plus loin que 20 ce qui est peu. */
 
         boolean encore = true;
         Scanner sc=new Scanner(System.in);
 
         while(encore) // pour tester plusieurs valeur (sortie en entrant 0)
         {
            factoriel = 1;
            System.out.print("\nSaissisez un entier " + lib + " ou 0 pour terminer: ");
            n = sc.nextInt();
 
            if (n == 0)
               encore = false;
            else
            {
               if (n <= max)
               {
                  for(i=1; i <= n; i++) 
                  {
                     factoriel=factoriel*i;
                     // si on veut la liste de 1 a la valeur entrée
                     System.out.println("\nLa factorielle de " + i + " est " + factoriel); 
                  }
                  // OU BIEN si on ne veut que le résultat de la valeur entrée 
                  //System.out.println("\nLa factorielle de " + n + " est " + factoriel);
               }
               else
               {
                  System.out.println("\nLe maxi pour un " + lib2 + " est " + max);
                  factoriel = 1;
               }
            }
         }
      } 
   }

Cordialement,

Dan