Salut à tous,

Je suis débutant dans la matiére et je dois coder un petit programme capable de calculer Somme des N premiers nombres entiers positifs le tout en fenêtre dos. J'aurais juste besoin de quelques explications. Il m'est demandé de faire ce programme en 3 versions. Une grâce à la boucle tant que, l'autre avec une boucle pour, et la troisiéme avec répéter jusqu'à.

Je décide par commencer avec la boucle pour. D'aprés mes cours l'instruction FOR coprends trois conditions avant les instructions. Pour les conditions voilà ce que j'ai trouvé for (somme = 0; 0 < n; n--) somme += n;
il semblerai que se soit du C, mais quelq'un pourrait t'il m'expliquer cette ligne? mais je ne comprends pas pourquoi on à n=n-1

<math>\(\sum_{i=0}^{N} i = \frac{N(N+1)}{2}\)</math> permet d'obtenir cette somme.

Que n'arrives tu pas à faire exactement ?

salut,

je te conseil de ne pas commencer d'une part par la boucle for mais plutôt avec while , et d'autre part si tu es débutant ne procède pas avec le n--;
Je ne sais pas si j'ai répondu à ta question si ce n'est pas le cas n'hésite pas à reposer ta question

En fait il m'est demandé de le faire avec la boucle pour. le n-- corespond à n=n-1 non? mais je ne comprends pas pk car sa devrait être n=n+1... et ensuite je ne comprends pas ce que l'instruction somme+=n signifie

Bah tu parts de n, et tu additionnes toutes les valeurs de n en allant de façon décroissante.
Ca fait n+(n-1)+(n-2)+....+(1)

Nanoc >> C'est beau les maths, mais on est en info

tu dois faire une boucle qui contient :
une variable n qui chage à chaque tour de boucle, ce n est un entier naturel qui part de 0 et qui va jusqu'à XXXXXX.
Si tu traduis ta phrase en expression algébrique, ca veut dire que tu dois avoir une deuxième variable, représentant la somme de n=0 à n, qui change à chaque tour de boucle.

en espérant t'avoir répondu
A+

Citation : jujurochedu42

En fait il m'est demandé de le faire avec la boucle pour. le n-- corespond à n=n-1 non? mais je ne comprends pas pk car sa devrait être n=n+1... et ensuite je ne comprends pas ce que l'instruction somme+=n signifie

Il y a des gens qui pensent à l'envers et d'autres qui préfèrent se lancer dans les micro-optimisations avant de s'occuper du plus important -- quand ce ne sont pas les mêmes.
Ne te laisse pas déstabiliser la façon de faire que tu avais vue.

A moins que tu aies un prof/chargé de TD tordu, compter de 1 à N, c'est bien aussi.

EDIT:
a += b; <=> a = a + b; // on préfère le premier
a += 1; <=> ++a <~> a++; // on préfère ++a;

Citation : Davidbrcz

Bah tu parts de n, et tu additionnes toutes les valeurs de n en allant de façon décroissante.
Ca fait n+(n-1)+(n-2)+....+(1)

Nanoc >> C'est beau les maths, mais on est en info

L'informatique dans sa partie résolution d'un problème est analogue à la résolution d'un problème mathématique et à la conception d'un algorithme.
"A force de faire n'importe quoi, en codant n'importe comment, sans poser le problème mathématique, on finit par devenir n'importe quoi...genre programmeur php" (mon prof de math)

Vous avez entièrement raison dans votre raisonnement au sujet de devoir réfléchir avant.

Maintenant, ce n'est pas l'exo qui a été demandé à l'OP. Si son prof ne trouve pas de bon problème qui illustre correctement les boucles, l'OP n'est lui pour rien. Et il devra quand même se plier à l'exercice de style.

En fait le problème est mal posé :
- on lui demande ça pour qu'il apprenne à faire une boucle,
- mais pour calculer la somme de N entiers successifs, il faut être un neuneu pour faire une boucle (l'homme avisé utilisera la formule de Nanoc bien évidemment)

Mais bon, l'éducation nationale étant ce qu'elle était, souvenez-vous de vos sujets de dissertation : "que pensez-vous du capitalisme, sachant que le correcteur est un communiste syndicaliste post-68ard barbu, mais dites ce que vous pensez, hein", si on te demande un code de neuneu, fais un code de neuneu.

int somme = 0;
int compteur;
for( compteur = 1; compteur <= maximum; compteur ++ )
somme += compteur;

somme += compteur c'est pour éviter de taper somme = somme + compteur (les programmeurs sont des feignasses)

pour le reste, lis ton manuel XD

MERCI beaucoup pour vos réponses

très juste à propos de la formule de nanoc, mais effectivement on lui demande une boucle !
celle de nanoc demande très peut d'opérations au CPU par rapport à une boucle surtout si on veut utiliser des valeurs très grandes, dignes d'un unsigned long long ^^.
Par contre si on veut afficher par exemple les valeurs à chaque fois qu'on ajoute 1 à n, la il vaut mieux la boucle !

je suis d'accord pour dire que l'exemple est pourri et que la seule réponse à faire au prof est celle ci:

unsigned int smart_sum( unsigned int n)
{
  return n * ( n + 1 ) / 2;
}

unsigned int idiot_sum( unsigned int n)
{
  unsigned int result = 0;
  for( unsigned int i = 1; i<=n; ++i)
    result += i;
  return result;
}

unsigned int foolish_sum( unsigned int n)
{
  unsigned int result = n;
  while (--n)
    result += n;
  return result;
}

const unsigned int values_count = 1<<20; // 1Million
unsigned int values[values_count];

time_t idiot_result;
time_t foolish_result;
time_t smart_result;

int main( int, char** )
{
  // create the same test value to compare performance
  for( int i=0;i<values_count;++i)
    values[i] = rand()%4096; // i know % on rand is evil!!!

  foolish_result = -time( NULL );
  for( int i=0;i<values_count;++i)
    foolish_sum( values[i] );
  foolish_result += time( NULL);
  
  idiot_result = -time( NULL );
  for( int i=0;i<values_count;++i)
    idiot_sum( values[i] );
  idiot_result += time( NULL);
  
  smart_result = -time( NULL );
  for( int i=0;i<values_count;++i)
    smart_sum( values[i] );
  smart_result += time( NULL);
  
  printf("foolish sum takes %ll seconds, idiot one takes %ll seconds and smart one takes %ll second\n"
        , foolish_result, idiot_result, smart_result);

  if ( smart_result< foolish_result && smart_result < idiot_result )
    printf("Please! Take more than 2s to design our training exercices professor\n");

  return 0;
  
}

Il manque le I_do_want_a_cumbersome_sum() qui avait été demandé.

GG galopin

Edit : ton code je le fait tourner il me prend 4 heures et tout le CPU donc bon .... j'arrête avant la fin xD

Citation : hilnius

GG galopin

Edit : ton code je le fait tourner il me prend 4 heures et tout le CPU donc bon .... j'arrête avant la fin xD

car faudrait que je test ce que je poste quand même; car écrire à la va vite, on fait n'imp, remplace juste unsigned int result = n;
while (--n)

par

unsigned int result = 0;
while (n--)

Ca va tout de suite mieux, sur mon pc, j'ai meme du mettre 20millions de valeurs pour avoir du 16, 13 et 0 secondes

Nanoc, la formule que tu as utilisé au début du topic, elle veut dire quoi en bon français ? (je connais pas tout ces signes).

Citation : Chem

Nanoc, la formule que tu as utilisé au début du topic, elle veut dire quoi en bon français ? (je connais pas tout ces signes).

C'est la représentation d'une somme en mathématique. çà dit: "pour i qui va de 0 à N, j'ajoute i"

ok, merci.

bonjour je veux ecrire un programme en c permettant de fais la somme des n nombres premiers

Salut,

Crée un topic pour ça, ne va pas en déterrer un qui date de 2009...

1. La légende dit que c'est Gauss qui a inventé la formule n(n+1)/2 à l'age de 7 ans.  Son prof de maths avait demandé de calculer 1+2+3+...100 pour que la classe lui foute la paix un moment. Raté.

2. Il manque la somme récursive

int rec_sum(int n) {
   return n <= 0   ?  0 
                   :  n + rec_sum(n-1);
}
         

Qui est aussi élégante qu'efficace, pour une version naive, puisque le compilateur  se débrouille comme un chef pour éliminer la récursion terminale. Code généré  sous vos applaudissements  :

rec_sum:
	xorl	%eax, %eax
.L3:
	testl	%edi, %edi
	jle	.L1
	addl	%edi, %eax
	decl	%edi
	jmp	.L3
.L1:
	ret

-
Edité par michelbillaud 13 février 2019 à 11:15:53

2) Je suis presque déçu qu'il ne reconnaisse pas ce qui est fait pour retourner directement n(n+1)/2.

Ah ah. clang y arrive: https://godbolt.org/z/Cgb-fw

int iter_sum(int n) {
    int res = 0;
    for (int i=0 ; i<n ; ++i) {
        res += i;
    }
    return res;
}

int rec_sum(int n) {
   return n <= 0   ?  0
                   :  n + rec_sum(n-1);
}

iter_sum(int):                           # @iter_sum(int)
        test    edi, edi
        jle     .LBB0_1
        lea     eax, [rdi - 1]
        lea     ecx, [rdi - 2]
        imul    rcx, rax
        shr     rcx
        lea     eax, [rcx + rdi]
        add     eax, -1
        ret
.LBB0_1:
        xor     eax, eax
        ret
rec_sum(int):                            # @rec_sum(int)
        test    edi, edi
        jle     .LBB1_1
        lea     ecx, [rdi - 2]
        lea     eax, [rdi - 1]
        imul    rcx, rax
        imul    eax, eax
        shr     rcx
        add     eax, edi
        sub     eax, ecx
        ret
.LBB1_1:
        xor     eax, eax
        ret

Par contre il sèche sur      f(n) =  si  n <= 0   alors  0  sinon   n -f(n-1)

qui donne la suite 0 1 1 2 2 3 3 4 4 .... soit   |(n+1)/2|, ou  (n+1) >> 1 pour les entiers positifs.

M'est avis qu'il y a une bidouille pour reconnaitre uniquement le cas de la somme de gauss.

-
Edité par michelbillaud 13 février 2019 à 13:51:37