la touche </> en dessous de ce cadre permet d'écrire du code ...

ensuite il serait bien de te débrouiller toute seule et apprendre par toi-même pour des exercices aussi élémentaires ...

Bonsoir carpediem
Si je n'avais pas du mal à le resoudre biensure je ne l'aurai pas posté ici.


Mais est ce que quelqu'un  pourrait-il me donner une reponse à mon exercice?

c'est d'un compliqué ...

u = 1
i = 1
f = 1
Read n
While i < n
   f = f * i
   u = u^i / f
Write u

On a pas le droit d'utiliser include<maths>

   u = u^i / f 

Bonsoir,
en utilisant des entiers, tu ne peux pas dépasser 2³².
Ce qui veut dire que tu peux calculer au plus 12!.

Pour le programme il me semble judicieux de définir des fonctions pour calculer
   -- l'inverse de la factorielle de n,
   -- a puissance n,
   -- u_n avec une fonction récursive.

Ce n'est sans doute pas optimisé, mais c'est facile à lire et à écrire.

Bonsoirverdurin
On n'a pas encore apris à écrire avec un langage C des fonctions (c'est dans le chapitre suivant)

Bonsoir.

Ma proposition...

#include <stdio.h>

// calcul n!
float fact(int n)
{
	float fact = 1.0 ;
	int i = 1 ;
	for ( ; i <= n ; i++)
	{
		fact *= i ;		
	}
	return(fact) ;
}

// u1 = 1.0
// u2 = 0.5
// u3 = 0,02083333333333333333333333333333
// u4 = 7,8491713284465020576131687242798e-9
// u5 = 2,4827774823649191650393319332055e-43

int main()
{
	int N = 0 ;
	int n = 1 ;
	int i = 0 ;	
	float u_n = 1.0 ;
	float u   = 0.0 ;
	
	do
	{
		printf("veuillez entrer un nombre positif N :\n") ;
		scanf("%d", &N) ;
	} while (N <= 0) ;
	
	for (n = 1 ; n <= N ; n++) 
	{
		// calcul de u = u(n-1)^n
		for (i = 1, u = u_n ; i < n ; i++)
		{
			u *= u_n ;	
		}
		
		u_n = u / fact(n) ;
	}  

	printf("\n u_n = % 20.19g\n", u_n) ;
          
	return(0) ;
}

Salut bbomaths.

Rana @ 23-04-2017 à 18:37

Bonsoirverdurin
On n'a pas encore apris à écrire avec un langage C des fonctions (c'est dans le chapitre suivant)

a
u = 1
f = 1
Lire n
pour i de 1 à n
     f = f / i
     a=1
     pour j de 1 à i
          a=a*u
          fin pour
     u = a * f
     fin pour
Écrire  u

Bonjour,

en fait le problème est ici surtout que il semble que tu apprennes à "bidouiller du C" et pas à programmer (que ce soit en C ou en n'importe quoi d'ailleurs)

la plus mauvaise méthode :
j'écris du code comme ça me vient et je le trafique en corrigeant par ci par là, "pour que ça marche"

c'est le plantage assuré dès que ça devient un petit peu complexe,
et la seule réaction en cas de plantage ou de résultat apparemment aberrant est du genre de la poule qui a trouvé un couteau et qui ne sait pas par quel bout le prendre, et finit par demander "corrigez moi mon programme, c'est bizarre / ça ne marche pas" (rayer la mention inutile)


il ne faut jamais faire comme ça mais construire son programme pas à pas en séparant le problème en sous problèmes plus simples, et en résolvant chaque problème à son tour

1ère étape : la compréhension du problème et le choix d'une méthode générale pour le résoudre (c'est purement des maths)
ici la suite étant définie par récurrence, la méthode va consister à appliquer cette récurrence en calculant chaque terme à partir du précédent jusqu'à atteindre le n^ème terme

déja à cette étape il faut se poser (explicitement) les bonnes questions.
en particulier résoudre la sorte d'incohérence de l'énoncé :

Ecrire un programme qui lit un entier positif n, calcule et affiche Un, sachant que :
U1=1 ;
Un=une certaine fonction de U_n-1 et de n pour n >1

il a ici deux sortes de "n"
un qui est une donnée (en rouge)
et un autre n qui est une variable muette définissant par récurrence les éléments de la suite
ceci est source d'erreurs monstrueuses d'avoir la même lettre pour des choses différentes

on doit donc avant de faire quoi que ce soit modifier cet énoncé en :
Ecrire un programme qui lit un entier positif n, calcule et affiche Un, sachant que :
U1=1 ;
Uk=une certaine fonction de U_k-1 et de k pour k >1

ce travail explicite n'est pas du tout inutile (même si on le fait de tête, ce doit être une démarche mentale consciente)
à ce stade le programme prend déja forme !
Il est écrit volontairement en "langage naturel" (en français courant)

demander n
initialiser U₁ = 1
pour k de 2 à n
calculer U_k en fonction de U_k-1 et de k
fin pour
afficher Uk (en fait Un c'est le dernier calculé)

attention à ne pas confondre une variable U et son contenu U_i (là aussi en être conscient)
cette remarque se traduira par la disparition explicite des indices des U :

demander n
initialiser U = 1 (la valeur de U₁)
pour k de 2 à n
calculer U = une fonction de U et de k
le calcul prend la valeur actuelle (précédente) de la variable U qui est la valeur de l'élément U_k-1 de la suite
le résultat est la valeur de l'élément U_k, que l'on met dans la variable U.
fin pour
afficher U

ce qui est écrit ici restera du point de vue structurel jusqu'à la fin de l'analyse et se traduira par un effectif

"scanf(%n);"
U = 1;
for (k=2; k<=n; k++) {
U = expression avec k et U;
}
"printf(U);"
(entre guillemets détails à résoudre sur le formatage des entrées-sorties, on s'en fiche à ce stade)

la suite de l'analyse consiste à mettre un peu de chair autour de tout ça et régler quelques détails, mais la structure est définitivement celle là.
et déja s'intéresser de plus près à ce calcul de U_k en fonction de U_k-1
la formule fait intervenir une factorielle et on peut calculer à part cette factorielle :

demander n
initialiser U = 1
pour k de 2 à n
calculer F = k!
calculer U = U/F
fin pour
afficher U

comment calculer k! ?

une façon simple est de la calculer explicitement à chaque fois en calculant

initialiser F = 1
pour j de 2 à k
F = F*j;
fin pour

le programme gardant toujours la même structure se développe maintenant en

demander n
initialiser U = 1
pour k de 2 à n
initialiser F = 1
pour j de 2 à k
F = F*j;
fin pour
calculer U = U/F
fin pour
afficher U

j'ai ici remplacé formellement la ligne "calculer k!" par tout le calcul explicite de cette factorielle sans déplacer des lignes ailleurs en dehors de ce "bloc"
c'est du copier-coller intégral.

à comparer avec les emplacements aberrants où tu initialisais ta variable "factoriel" et les calculs sans aucun rapport avec quoi que ce soit utilisant tes P etc ...

ce programme est alors traduit en C sans difficulté (et sans rajouter de calculs absurdes supplémentaires)

amélioration :
on remarque que dans le calcul de F = k! on refait des opérations inutilement et on peut définir la factorielle elle même aussi par récurrence en posant la suite F_k = k! : F₁ = 1! = 1, F_k = k*F_k-1

j'ai maintenant deux suites à calculer dans la même boucle "en parallèle" :

demander n
initialiser U = 1
initialiser F = 1 (factorielle de 1, valeur de F₁)
pour k de 2 à n
calculer F = factorielle de k en fonction de factorielle de k-1 : F = F*k (F_k = k*F_k-1)
calculer U = U/F
fin pour
afficher U

qui conduit au programme proposé par carpediem

cette méthode d'analyse descendante en commençant par la structure générale et en remplaçant chaque sous problème par une analyse générale de ce sous problème etc doit être appliquée systématiquement et explicitement
sinon on ne fait que bidouiller et on risque de galérer sur la mise au point d'un programme qui est en fait aberrant à la base.

   u = u^i / f 

u = 1
i = 1
f = 1
Read n
While i < n
   i = i + 1
   f = f * i
   v = 1
   For j = 1 To i
      v = v * u
   u = v/f
Write u

Rana, bonsoir.

Une question sans arrière-pensée. Depuis quand apprenez-vous la programmation en C ? Est-ce votre premier langage informatique ?

Pour info, il y a une quinzaine d'années, on estimait dans les SSII qu'il fallait entre 1 et 2 ans pour maitriser le langage C.

Je vous conseille de vous entraîner à écrire des petits programmes comme ceux que vous nous avez présenté pour commencer puis petit à petit vous aborderez les parties plus complexes voire d'autres langages comme C++, Java, Python ou des langages plus orientés comme Matlab.

Au fait, qu'avez-vous comme compilateur ? Il y a-t-il un débogueur ?

Bonjour bbomaths
Merci. Mais ce n'est pas pareil à ce que j'ai ecrit ? Pouvez vous juste me dire si c'est juste ce que j'ai ecrit en haut car sur l'ordinateur j'ai eu une valeur pour u₁ et u₂ mais pour u_n telque n>2 j'ai eu 0.

Merci mathafou je n'avais pas vu votre post ,il n'avait pas encore apparut quand j'ai envoyer le message du haut
Et merci pour les conseils!

Merci à vous tous mathafou  
,  bbomaths   , carpediem
Et  verdurin !!

raison de plus pour suivre une méthodologie rigoureuse de construction pas à pas du programme et pas écrire du code en vrac

mes remarques sur tes initialisations mises absolument n'importe où et la structure même du programme qui ne correspond pas à ce qui est demandé sont fondées.

tout ce que j'ai dit est juste en rajoutant le bout oublié :

1ère étape
demander n
initialiser U1 = 1
pour k de 2 à n
calculer Uk en fonction de Uk-1 et de k
fin pour
afficher Uk (en fait Un c'est le dernier calculé)


cette structure doit être celle du programme final, immuablement, quelle que soient les "détails" qui s'ajoutent entre temps
l'énoncé est
"qui lit un entier positif n, calcule et affiche Un"
il affiche un seul U, celui de rang n entré par l'utilisateur.

l'étape intermédiaire où j'ai oublié le "puissance n" se traduit par :
(relire ma phrase sur les deux significations du "n" de l'énoncé)

1ère étape
demander n
initialiser U = 1
pour k de 2 à n
calculer V = U puissance k
calculer F = k!
calculer U = V/F
fin pour
afficher U

et on traduit chacun de ces calculs par un développement de plus en plus explicite
sans mélanger les calculs entre eux.
une bonne pratique est de conserver l'écriture formelle de chaque étape de l'analyse sous forme de commentaires de l'étape plus explicite suivante.

mon message date d'hier !!
tu as une façon bizarre de consulter le site ...
ceci dit sur une durée d'une dizaine de minutes les messages peuvent se croiser
celui où tu dis ne pas avoir vu mon message, que tu as émis pendant que je tapais ma dernière réponse...

Merci pour les conseils.
Et je n'avait pas vu le message car j'ai déjà cette page ouverte sur mon telephone depuis 2 jours donc j'ai tout de suite écrit le premier message sans faire "refresh pour la page" et en le postant j'ai vu  les 5 messages .( le dernier qui etait sur ma page était celui de bbomaths le 23/4/2017 , desolé).

c'est bizarre parce que moi (sur PC) la connexion ne dure jamais deux jours !
le site me déconnecte bien avant avec un message "vous n'avez pas accès à cette fonction, veuillez vous (re)connecter" ou du même genre.

mais pas grave. le principal est que tu lises tout au final.

ouais moi aussi et je trouve ça très chiant : la plupart du temps sans intervention) il y a déconnexion automatique au bout d'une demi-heure environ ...

pour compléter les remarques : avant de te lancer dans l'écriture du programme même il est fondamental d'écrire un algorithme

ici le plus synthétique :

1/ calculer
2/ calculer
3/ calculer (le quotient)

puis on reprend

1/ : on détaille : une boucle
2/ on détaille : une boucle ... ou réflexion plus approfondie : par récurrence
3/ rien à faire

et ainsi de suite de plus en plus finement pour avoir un algorithme complet qu'il n'y aura plus qu'à traduire en programme ...

ce n'est donc plus qu'une question de version pour laquelle il faut bien sur apprendre une langue ou plus précisément un langage et ce quel qu'il soit : python, C, ...

salut,

un traitement possible:

  u:=1.0
  pour k de 1 jusque n faire
    v:=u
    pour j de 2 jusque k faire
      u:=???
    fpour
  fpour

  u:=1.0;L:=[]
  pour k de 1 jusque n faire
    v:=u
    pour j de 2 jusque k faire
      u:=???
    fpour
    L:=append(L,u)
  fpour

Bonjour.

lire mes commentaires...

#include<stdio.h>

int main()
{
   // attention : en règle générale, aérer son code
   //             penser qu'il sera lu par un autre
   int n, i, j ;
   // attention: une factorielle croit très vite
   //            utiliser un flottant ou un double flottant
   //            et ça evite une opération de
   //            cast (float)(factorielle) dans une boucle
   int factoriel = 1 ;
   // attention : utiliser les () ou les [] pour des index
   // P : Un-1 n devrait s'écrire P = U[n-1] * U[n]
   float P = 1.0 ;
   // A est le 1/n!
   float A ;
   // b = Un-1
   // attention : toujours initialiser un flottant avec comme fin ".chiffre(s)"
   float b = 1.0 ;
   // c = Un
   float c ;

   do
   {
      printf("veiller entrer un nombre positive n:\n") ;
      scanf("%d", &n) ;
   } while (n <= 0) ;

   printf("\n") ;

   // attention : aligner les { avec les } de même indentation
   //             plus facile à déboguer

   if (n == 1)
      // attention : garder la même cohérence avec le reste des affichages
      printf("U_n = %f\n", 1.0) ;
   else
   {
      // attention : il faut commenter un minimum
      //             ça permet au programmeur d'éclaircir ses idées sur ce qu'il fait
      //             ça permet à un autre programmeur de comprendre ce qu'a voulu faire l'auteur du programme

      // calcul factorielle
      for (i = 2 ; i <= n; i++)
      {
           for (j = 1 ; j <= i ; j++)
         {
            factoriel *= j ;
            A = 1 / (float)factoriel ;

            printf("(1) n = %d i = %d j = %d F = %d\n", n, i, j, factoriel) ;
            printf("                      A = %20.19f\n\n", A) ;
            }

         // attention : variable I inexistante !!!
         for (j = 2 ; j <= i ; j++)
         {
            // ta déclaration int P = 1 provoque une erreur de calcul (NaN) avec mon compilateur
            P *= b ;
            // en principe, calcul de P = U[n-1] * U[n] ???
            // problème : d'après l'énoncé on calcule U[n] = U[n-1]^n
            printf("(2) n = %d i = %d j = %d P = %20.19f\n\n", n, i, j, P) ;
         }

         c = P * A ;
         printf("(3) n = %d i = %d j = %d c = %20.19f\n", n, i, j, c) ;
         b = c ;
         printf("                      b = %20.19f\n", b) ;
         P = 1 ;
         printf("                      P = %20.19f\n", P) ;
         factoriel = 1 ;

         printf("\n") ;

         // dans une fin de boucle éviter d'initialiser des variables pour l'itération suivante
      }

      printf("U_n = %20.19f\n", c) ;
    }

//   getch() ;

   return(0) ;
}

J'ai "instrumenté" ton code ainsi tu pourras suivre les différentes variables et comprendre ce qui ne va pas...

veiller entrer un nombre positive n:
3

(1) n = 3 i = 2 j = 1 F = 1
                      A = 1.0000000000000000000

(1) n = 3 i = 2 j = 2 F = 2
                      A = 0.5000000000000000000

(2) n = 3 i = 2 j = 2 P = 1.0000000000000000000

(3) n = 3 i = 2 j = 3 c = 0.5000000000000000000
                      b = 0.5000000000000000000
                      P = 1.0000000000000000000

(1) n = 3 i = 3 j = 1 F = 1
                      A = 1.0000000000000000000

(1) n = 3 i = 3 j = 2 F = 2
                      A = 0.5000000000000000000

(1) n = 3 i = 3 j = 3 F = 6
                      A = 0.1666666716337204000

(2) n = 3 i = 3 j = 2 P = 0.5000000000000000000

(2) n = 3 i = 3 j = 3 P = 0.2500000000000000000

(3) n = 3 i = 3 j = 4 c = 0.0416666679084300990
                      b = 0.0416666679084300990
                      P = 1.0000000000000000000

U_n = 0.0416666679084300990

écrire en vrac masque le fait que l'initialisation de la variable "factoriel" est toujours aussi complètement loufoque que dans le 1er message du demandeur.

à la lecture d'un tel code on voit immédiatement que ça n'a pas été fait "par étapes logiques successives" mais du pur bidouillage.

l'étape logique c'est :
on doit à un certain moment calculer une factorielle
pour cela l'algorithme de ce calcul de factorielle est logiquement de façon claire et simple :

factoriel = 1;
for (j= 2; j<=machin; j++) { factoriel *=j; } //inutile de multiplier 1 par 1, on commence à 2

un point c'est tout

il n'y a pas à remettre factoriel à 1 après d'autres trucs
ni à surtout pire ne pas initialiser factoriel avant

et ce morceau là on le copie tel quel là où on doit calculer la factorielle point barre.
précédé et à cet endroit du commentaire
// calcul de factorielle machin

Franchement merci pour les remarques!!

Mathafou, bonsoir.

Je suis d'accord avec vous, le code de Rana est un peu brouillon... mais je pense que son prof d'info à oublié une étape essentielle : l'analyse.

j'ai commencé à programmer en 1979 en code machine (l'assembleur c'était nous) et en Basic (le langage à GOTO). On commençait par un organigramme. Puis lorsque nous en étions sûr () on passait à la programmation.

Même après 40 ans de programmation diverses, il m'arrive encore de modéliser mes algorithmes sous la forme de Réseaux de Pétri...

Je pense que Rana se retrouve à appendre un langage mais on a  oublié de lui dire qu'avant de taper sur un clavier, il faut parfois utiliser une feuille de papier, et crayon et 2 gommes.... Si c'est le cas, c'est dommage...

Bonsoir bbomaths
On nous a juste donner un peu d'algorithme le premier semestre c'etait juste avec le "si" et sinon. On n'avait pas apris les boucles.
Ce semestre on a commencé en langage C .On ecrit tout de suite les programmes sans faire le lien avec les algorithmes , car on avait etudier les algorithmes avec des cas beaucouppp plus facile qu'ici et on n'avais  même  pas vu les boucles.

Avez-vous des bouquins sur le C ?

Non

pour ma part j'ai commencé en 1970 sur une Programma 101 d'Olivetti (une espèce de grosse calculatrice programmable de l'époque qui prenait toute la place sur un bureau)
puis sur PDP8 en langage machine (on entrait son code en binaire avec 12 clés)
puis en Basic, Fortran, en ce qui concerne l'apprentissage à l'école.

je dois avouer que la méthodologie de programmation à l'époque était effectivement de faire un organigramme (ou ordinogramme)
les "goto" provoquaient un gros paquet de nouilles
c'est seulement "récemment" (il y a pas mal d'années tout de même, avec le C, dans le cadre professionnel) que tout ça a été formalisé sous forme de structures de programme.
les boucles for, while et dérivées, le si/sinon systématisés
entrainant la structuration correspondante des programmes lors de leur phase d'analyse.
(écriture "en langage naturel" etc)

côté enseignement, comme on enseigne ça de nos jours en cours "de maths" il est dispensé par des profs ... de maths et pas d'informatique
d'où un certain "flou" dans l'apprentissage d'une méthodologie, voire des concepts mêmes.

il est aussi parfaitement clair que pour l'efficacité de l'apprentissage il faut se frotter rapidement au concret et donc on est amené à passer très (trop ?) vite à la traduction de l'algorithme (description des opérations) en un programme effectif (code en langage spécifique)

voire même de faire l'impasse sur la partie fondamentale d'analyse du problème.
(débrouillez vous, on apprend à programmer en programmant, c'est au pied du mur qu'on voit le maçon etc)
sans nier l'efficacité "pratique" de cette ... mise en pratique immédiate, il ne faut pas négliger la phase d'analyse. au moins lors du corrigé d'un exo !!

et ici lors des aides, autant donner une méthodologie générale saine.

un bouquin qui date pas mal (Cobol, Fortan) est "méthodes de programmation" G.Meyer C.Baudoin chez Eyrolles
avec exercices corrigés, il m'arrive de le consulter encore à l'occasion.
il y a sans doute plus "moderne" ?
Un livre sur le C est trop particulier au langage C et ne parle pas assez de l'organisation et de l'architecture en général des algorithmes.

comme déja dit la programmation c'est la traduction en un langage spécifique d'un algorithme
la traduction c'est avant tout de la syntaxe et du vocabulaire (nom des opérations dans ce langage, où doit on mettre les "signes de ponctuation" etc)

l'algorithme doit être vu d'abord : c'est la description "générique" (valable quel que soit le langage) de l'enchainement logique des opérations à effectuer.

Merci pour la suggestion du bouquin!

Mathafou, à nous deux, nous pourrions faire un musée de la préhistoire de l'informatique  

Rana, si vous voulez quelques bonnes lectures, passez par mon adresse email (voir profil)

Merci bbomaths

je plussoie au propos d emathafou de son post de 18h49 ... et je me permets de copier mon post de .... noyé dans le flot de posts de bbomaths ... qui n'apportent pas grand chose ...

carpediem @ 25-04-2017 à 14:58

ouais moi aussi et je trouve ça très chiant : la plupart du temps sans intervention) il y a déconnexion automatique au bout d'une demi-heure environ ...

pour compléter les remarques : avant de te lancer dans l'écriture du programme même il est fondamental d'écrire un algorithme

ici le plus synthétique :

1/ calculer
2/ calculer
3/ calculer (le quotient)

puis on reprend

1/ : on détaille : une boucle
2/ on détaille : une boucle ... ou réflexion plus approfondie : par récurrence
3/ rien à faire

et ainsi de suite de plus en plus finement pour avoir un algorithme complet qu'il n'y aura plus qu'à traduire en programme ...

ce n'est donc plus qu'une question de version pour laquelle il faut bien sur apprendre une langue ou plus précisément un langage et ce quel qu'il soit : python, C, ...

Si j'ai fait une terminal S , mais je suis en Liban et ici on nous ne donne  pas cela à l'ecole donc c'est la première année que j'etudie cela.

tu n'etais donc pas dans un lycee français ?

Non  ce n'etait pas un programme francais

J'en deduis qu'il faut ecrire ce programme sans boucle ... ?

Non ce semestre j'ai pris les boucles

Carpediem, bonjour.

Pour info:
l'algo de la factorielle (sans obligatoirement la nommer) se fait tres souvent en seconde
celui d'une suite recurrente en premiere
pour celui de ce fil ce serait plutot en termS