Bonjour, donc déjà il va falloir que ton algorithme demande les valeurs de n et de k
puis le plus simple est de tester toutes les sommes de n entiers impairs consécutifs. Pour cela il va nous falloir une boucle qui balaye les nombres impairs puis une autre qui additionne n entiers impairs consécutifs et les mets dans une variable S.
puis il faudra tester si S = n^k
si oui il faudra afficher les n entiers impairs en question (avec une nouvelle boucle)
et si non, on continue

C'est pas simple simple comme algorithme, mais pour progresser , il faut se lancer.
Propose quelque chose.

Bonjour,

déja vu sur maths-forum.com mébon
la solution là bas de mathelot ayant été effacée par lui-même ... pour absence de réactivité du demandeur ...

reprenons

on peut faire comme il avait fait et étudier le problème mathématiquement à partir de la relation

"la somme des n premiers entiers impair est égal à n^2" etc ...

ou ... ne pas se poser tant de questions et faire un algorithme "brutal"
qui calcule la somme des n entiers impairs à partir de 2q+1

et faire varier q (dans une boucle "tant que") jusqu'à ce que cette somme devienne égale à n^k qui s'écrit pow(n,k) sous Algobox
(ne pas oublier non plus que sous Algobox 2q+1 s'écrit en écrivant explicitement la multiplication : 2*q+1)

et par sécurité, à moins de prouver mathématiquement que c'est toujours possible, jusqu'à ce que cette somme devienne supérieure ou égale à n^k
(en plus le calcul de n^k par Algobox étant une valeur approchée, vaut mieux faire comme ça avec "tant que <" plutôt que "tant que !=" )

lance toi ...

Bonjour Glapion,
on a en gros la même idée finalement

je te laisse continuer.

Oui, et ton idée de TantQue est une très bonne idée, ça sera mieux qu'une boucle Pour I allant de 1 à ... que l'on ne saura pas bien borner (sauf par n^k mais ça serait dommage)
J'aimerais qu'il propose quelque chose. C'est un défi quand même. Si on se bat pas un peu pour relever un défi, c'est plus un défi.

oui, il n'y a pas suffisamment de détails pour l'instant dans ce qu'on a écrit pour le traduire en algorithme "directement"
il reste pas mal de boulot à faire

(nota : la méthode "purement mathématique" remplace toutes ces boucles par un simple calcul de valeur.
ce n'est pas ce qui est demandé très certainement !
mais le problème (HS) est intéressant de trouver la formule qui donne directement le dernier nombre impair ajouté !)

tiens pendant ce temps, je me suis lancé et j'en ai fait un qui marche. Mais c'est vrai qu'il y a des tas de petits détails à régler. Notamment pour l'affichage.

Evidemment avec des valeurs un peu trop grandes pour n et k on dépasse la capacité d'algobox.
mais ça marche pour des valeurs assez grandes quand même. Par exemple, ça m'a affiché :
12^6=248821+248823+248825+248827+248829+248831+248833+248835+248837+248839+248841+248843

_{si c'est pas du teasing, ça}

oui, j'ai même eu un petit bug qui a récalcitré un bon moment avant le "bon sang mais c'est bien sûr"
(une histoire de bornes justement)

Heuu...d'accord je vais essayé. Mais pour moi les algorithmes sont tellement confus donc je sais au préalable que j'y arriverais pas

Alors faisons l'inverse, essaye de comprendre et de faire marcher celui-là :
_{(tu peux le copier/coller dans algobox en mode éditeur de texte, ou bien directement en ligne dans proglab )}

VARIABLES
  n EST_DU_TYPE NOMBRE
  k EST_DU_TYPE NOMBRE
  S EST_DU_TYPE NOMBRE
  I EST_DU_TYPE NOMBRE
  qb EST_DU_TYPE NOMBRE
  q EST_DU_TYPE NOMBRE
  C EST_DU_TYPE CHAINE
DEBUT_ALGORITHME
  LIRE n
  LIRE k
  S PREND_LA_VALEUR 0
  qb PREND_LA_VALEUR 1
  C PREND_LA_VALEUR ""
  TANT_QUE (S < pow(n,k)) FAIRE
    DEBUT_TANT_QUE
    q PREND_LA_VALEUR qb
    S PREND_LA_VALEUR 0
    POUR I ALLANT_DE 1 A n
      DEBUT_POUR
      S PREND_LA_VALEUR S+q
      q PREND_LA_VALEUR q+2
      FIN_POUR
    SI (S == pow(n,k) ) ALORS
      DEBUT_SI
      C PREND_LA_VALEUR n+"^"+k+"="
      q PREND_LA_VALEUR qb
      POUR I ALLANT_DE 1 A n-1
        DEBUT_POUR
        C PREND_LA_VALEUR C+q+"+"
        q PREND_LA_VALEUR q+2
        FIN_POUR
      C PREND_LA_VALEUR C+q
      FIN_SI
    qb PREND_LA_VALEUR qb+2
    FIN_TANT_QUE
  SI (C =="") ALORS
    DEBUT_SI
    AFFICHER* "je n'ai pas trouvé de décomposition"
    FIN_SI
    SINON
      DEBUT_SINON
      AFFICHER* C
      FIN_SINON
FIN_ALGORITHME

Je suis vraiment désolée, mais je ne comprend pas pourquoi tant de variables sont nécessaires. Je pense que je ne peux pas transmettre à mon professeur quelque chose que je ne comprends mais vraiment pas

Qu'est ce que ça peut faire le nombre de variables ???
ce qui compte dans un algorithme c'est la logique de l'enchainement des calculs

n et k sont obligatoires (énoncé lui-même)
il faut bien une variable S pour calculer la somme de n nombres impairs
et au minimum le 1er nombre impair de la somme qb

les autres variables sont là pour effectuer les calculs :
compteur pour compter n nombres : I
nombre "courant" à ajouter : q

quant à la variable chaine C c'est pour sortir un résultat "esthétique", au lieu d'une simple valeur nue "AFFICHER qb" et c'est tout, 1er nombre impair à ajouter


en fait pour comprendre un algorithme c'est même plus facile si on le fait soi-même que si on "décortique" celui de quelqu'un d'autre.

parce qu'on le construit brique par brique à partir de la logique des calculs que l'on a décidé d'effectuer.
et ça commence pas du tout par un truc tout écrit en Algobox, mais par une description "grossière" en langage naturel du principe.

description que l'on détaille de plus en plus au fur et à mesure de l'avancement de sa conception, toujours en langage naturel

jusqu'à obtenir "les détails", matérialisés au niveau du codage (en langage Algobox par exemple)

ici ça pourrait être :

1 er niveau d'analyse :
"on calcule la somme de n nombres impairs à partir d'un nombre de départ q
en essayant successivement les valeurs de q jusqu'à ce que cette somme soit égale à n^k"
(textuellement comme je viens de l'écrire)
c'est la "méthode" que l'on va utiliser pour résoudre le problème, ce n'est pas la seule, c'est celle qu'on a choisi

puis on "formalise" cela par des boucles "tant que", "pour" etc explicites
des variables explicites etc
en détaillant petit à petit chaque "morceau" de l'algorithme :
- comment calculer la somme de n nombres impairs à partir de q
- comment afficher le résultat
etc ...
en identifiant les "pièges" (destruction d'une variable, et donc nécessité d'une variable "supplémentaire" pour en sauvegarder la valeur etc)

et seulement à la fin (jusqu'ici c'est "en langage naturel") le coder en langage Algobox, ou calculette, ou ce que tu veux

pour plus de clarté, on peut ajouter des commentaires pour identifier chaque "morceau" son but et sa méthode.

essaie d'identifier chaque morceau de l'algorithme de Glapion
voire encore mieux de faire ton propre algorithme sur ce principe. (avec cette même méthode)

D'accord, merci beaucoup pour votre aide.