On ajoute habituellement qu'être fainéant, ça demande un peu de travail pour s'organiser.
Ca me faisait penser au montage d'un meuble Ikea. Un débutant va vider toutes les pièces en vrac, pourquoi s'embêter je suis pas un pro du montage, lol, et s'apercevoir plus tard qu'il n'y a pas le bon nombre de vis de la bonne taille à une étape, parce qu'il a confondu avec les plus petites et les a utilisé à autre chose sans faire gaffe.
Si on s'y prend bien, on déballe, on fait des petits tas qui correspondent à la notice, et APRES, on monte. Ca demande un peu de travail de préparation, mais c'est rentabilisé très rapidement, parce que démonter pour remonter, c'est beaucoup plus de boulot. Les petits tas au début, c'est pas pour faire joli.
Le pire est que dans les faits, j'ai été confronté à un problème similaire. Je n'avais pas le mode d'emploi pour le montage. J'ai fait comme tu as dit. J'ai séparé les pièces et je les ai compté. Il faut réfléchir à ce dont on dispose et ce dont on a besoin et ne pas se lancer tête baissée. Écrire du pseudo-code ou tout simplement des phrase pour expliquer ce qu'on veut faire aide grandement. Faire des schéma ou des dessins est très bon également. Autrefois, on nous faisait dessiner des organigrammes avec des triangles, des rectangles, et des losanges. Pas besoin d'aller aussi loin. L'important est d'utiliser un mode de représentation avec lequel on est confortable et qui correspond à notre mode de pensée.t
Le Tout est souvent plus grand que la somme de ses parties.
J'ai refait tout le cours dès le début, oui j'aime bien souffrir mdr, je comprends pas trop pourquoi autant de message pour prévenir que les pointeurs sont un concept super difficile à assimiler, parce que personnellement je ne l'ai pas trouvé plus difficile que d'autre chapitre, par contre dès le chapitre des tableaux, là ça se complique clairement, enfin encore une fois pour moi qui débute.
D'ailleurs j'ai essayé de refaire les exercices sur les tableaux, j'ai réussi à refaire pour obtenir la somme sans revenir voir ici sur le forum, donc c'est déjà ça lol.
Par contre pour la moyenne j'ai écrit une fonction, elle renvoie bien la moyenne, mais les chiffres après la virgule sont toujours des 0... sûrement une erreur idiote de ma part mais bon j'arrive pas à savoir laquelle, je mets le code, j'ai mis directement pourquoi j'ai écrit telle ou telle ligne dans les commentaires du code.
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "main.h"
double moyenneTableau(int tableau[], int tailleTableau);
int main(int argc, char *argv[])
{
int tableau[4] = {8,42,61,845}; //initialisation tableau
printf("%f%", moyenneTableau(tableau, 4)); //affiche resultat
return 0;
}
double moyenneTableau(int tableau[], int tailleTableau) {
int i; somme = 0; /*j'initialise la variable i et la somme car
j'en ai besoin pour faire la moyenne*/
double moyenne = 0.0; //j'initialise la variable moyenne
for (i = 0; i < tailleTableau; i++) {
somme = somme + tableau[i];
} //boucle pour faire la somme de tous les valeurs du tableau
moyenne = somme / tailleTableau; // calcul de la moyenne
return moyenne;
}
Encore une fois, c'est possible que pour vous, j'ai écrit des horreurs lol, mais je fais quasiment tout en autodidacte avec le cours du site, je n'ai aucune formation là-dedans ni rien.
Comme on m'a dit j'aurai pu partir de ma fonction "sommeTableau", ça simplifierai grandement les chose, mais j'essaie de refaire en partant de rien pour m'entrainer à réfléchir, justement. Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple.
EDIT : bon je crois avoir trouvé finalement mdr, fallait juste que somme soit un type "double" aussi (je crois....)
- Edité par SébastienTellier 15 juin 2021 à 16:14:45
Et quand tu divises un entier par un entier le résultat et forcement un entier et donc il est tronqué en entier.
donc l'entier 3 converti en double ça fait 3.0000
Effectivement pour que le résultat soit un double, il faut que au moins une des deux opérande soit un double. (si ce sont des entiers, il y a la possibilité de faire un transtypage (cast) sur une des deux opérandes).
> m'entrainer à réfléchir, justement. Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple. Comme je l'ai dit, un bon programmeur est fainéant (pas nécessairement vrai ...) Il faut t'entrainer à réfléchir sur les moyens d'écrire le moins de code possible et utiliser du code qui fonctionne. En utilisant une fonction déjà écrite et supposée correcte, tu réduis le risque de faire de nouveaux bugs. Si ta fonction a un bug, tu le corrige à un seul endroit.
Le Tout est souvent plus grand que la somme de ses parties.
C'est super dur de réorganiser toutes les valeurs par ordre croissants sans indication autre que le prototype de la fonction...
Bienvenu dans le monde merveilleux de l'informatique et de l'algorithmique
La première question que l'on doit se poser est : comment est-ce que je le ferais à la main ? comment faire si on a des cartes numérotées devant soi et qu'on doive les trier ?
C'est super dur de réorganiser toutes les valeurs par ordre croissants sans indication autre que le prototype de la fonction...
Oui en fait cet exercice arrive trop vite dans le cours, avant d'avoir consolidé, par une brouette d'exercices, les notions de
parcours "bête" d'un tableau d'un bout à un autre.
découpage d'un problème en fonctions, passage de paramètres.
La difficulté prématurée sur la moyenne vient aussi d'un exercice mal conçu : si l'exercice précédent avait demandé de faire la somme d'un tableau de réels et non d'entiers, on ne s'embrouillerait pas dans un problème annexe.
Le cours a été fait par quelqu'un qui ne connaissait pas très bien C, et qui n'avait jamais eu le bonheur d'enseigner pour constater les trucs stupides qui causent des difficultés aux débutants au mauvais moment.
> Parce que si chaque fois je copie-colle les codes du site ou du forum, c'est un peu trop simple.
Et surtout ça ne t'apprend rien. Copier-coller tu savais, quant à apprendre à programmer, c'est comme apprendre à jouer de la guitare en regardant les autres faire sans pratiquer. Et quand on te demande de jouer un petit morceau, t'es mal.
Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).
Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...
je sais pas si je suis très clair désolé, j'ai tenté un truc avec des "tableau[i] et tableau[i+1]" mais je crois pas que ça soit faisable de cette façon lol
Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).
Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...
je sais pas si je suis très clair désolé, j'ai tenté un truc avec des "tableau[i] et tableau[i+1]" mais je crois pas que ça soit faisable de cette façon lol
Alors d'un point de vue algorithmique ( = la manière de procéder) avec des cartes face cachée tu pourrais par exemple :
retourner chaque carte l'une après l'autre et te souvenir où se trouve la plus grande ;
une fois toutes les cartes parcourues, échanger la plus grande avec celle en dernière position ;
Quand tu as fais ça tu es certain d'avoir la plus grande carte à la fin
Il faut donc recommencer cette procédure entre la première carte et l'avant-dernière.
Ensuite tu fais ça tant que tu as des cartes à retourner.
Est-ce que tu comprends comment faire ? est-ce que cela te convainc qu'à la fin tu auras quelque chose de trié ?
Oui sauf que je sais où est la carte la plus petite au premier coup d'oeil pour commencer par la mettre en premier (ordre croissant).
Là c'est comme si les cartes étaient de dos et que je ne puisse pas les voir, car si je veux une fonction qui marche pour tous les tableaux, je sais pas où est situé la valeur la plus petite à l'avance...
On le sait pas à l'avance, mais on peut le trouver.
Pour trouver la carte la plus petite, c'est pas tout à fait d'un seul coup d'oeil, puisqu'il faut les regarder TOUTES.
Et pour les regarder toutes, on fait une [......].
----
Maintenant qu'on sait trouver la plus petite, on peut l'amener au debut du tableau, en première position.
Mais alors qu'est-ce que qu'on fait de ce qui était en première position ?
----
Maintenant qu'on a placé le premier au bon endroit, qu'est-ce qu'on fait pour le second ?
----
Plus généralement, quand on en a placé un certain nombre, comment en fait pour le suivant ?
Et donc pour les placer toutes on fait une [......].
---
les histoires de tableau[i] et tableau[i+1], tu as vu ça dans l'algorithme que tout le monde recopie bêtement, qui s'appelle le tri à bulles. Qui est un mauvais algorithme de plus.
Laisse tomber, et construit ton programme à partir d'un RAISONNEMENT, pas en bricolant des bouts de code chopés ici ou là.
Pas du tout j'ai chopé aucun code nul part, d'ailleurs je sais même pas si on trouve ce genre de code quelque part. Mais c'est le premier truc qui m'est venu lol.
Je réessaierai l'exercice ce soir avec vos explications
Alors, White Crow et michelbillaud, ne repartez pas votre petite guéguerre ... White Crow préconise de trouver le plus grand et le placer en dernier. michelbillaud préconise de trouver le plus petit et de le placer en premier. OK, pour moi, pas de problème. Mais pour un débutant, est-ce que ça embrouille? Et pour information, ça s'appelle un tri par sélection, et on peut en trouver plusieurs versions sur le web ...
Le Tout est souvent plus grand que la somme de ses parties.
J'ai beau réfléchir (bon certes j'ai pas réfléchi 2 jours ni 2 semaines, depuis tout à l'heure..) mais je vois même pas un début de comment faire...
Ça me semble évident de passer par une boucle "for", qui revient à retourner les cartes si on reprends la même image, mais je vois pas comment celle-ci me permet de mettre la plus petite valeur "de côté" pour la déplacer en première
EDIT : on est d'accord que j'ai besoin de condition "if" (sinon c'est que je suis vraiment à côté de la plaque lol)
- Edité par SébastienTellier 15 juin 2021 à 18:33:01
Alors, White Crow et michelbillaud, ne repartez pas votre petite guéguerre ...
rhôôôôô, nous n'avons jamais été en guéguerre, nous avons juste discuté avec passion.
PierrotLeFou a écrit:
[...] OK, pour moi, pas de problème. Mais pour un débutant, est-ce que ça embrouille? Et pour information, ça s'appelle un tri par sélection, et on peut en trouver plusieurs versions sur le web ...
Bonne question … je ne sais pas et je ne suis pas pédagogue pour un sou (pour trois ptêt ). Disons que je pense que le plus simple pour comprendre tout ça c'est de le faire réellement à la main avant, quitte à découper de petits cartons (ou utiliser un jeu de cartes).
Edit:
SébastienTellier a écrit:
[...]
Ça me semble évident de passer par une boucle "for", qui revient à retourner les cartes si on reprends la même image, mais je vois pas comment celle-ci me permet de mettre la plus petite valeur "de côté" pour la déplacer en première
Il faut te souvenir où elle se trouve pour ensuite pouvoir l'échanger …
se souvenir de ⇒ créer une variable qui va contenir la position du minimum …
D'ailleurs ça aussi ça embrouille.... je sais pas si le C est très facile comme premier langage lol
définitivement non. D'autres langages sont plus accessibles au débutant (comme python par exemple).
SébastienTellier a écrit:
[...]
EDIT : je vois déjà pas comment déterminer quel est la plus petite de tous le tableau, difficile de mettre sa position en mémoire....
- Edité par SébastienTellier il y a 3 minutes
C'est ce qu'on appelle un algorithme classique. On présente souvent les algorithmes sous forme de ce qu'on appelle du pseudo-code, c'est un mélange entre le français (ou l'anglais) et un langage de programmation. Par exemple :
algo Recherche_Minimum( T : tableau d'entiers, n : entier qui est la taille du tableau ) ⇒ l'indice du plus petit élément
début
indice_du_minimum = 0
pour i de 1 à n-1 faire
si T[i]<T[indice_du_minimum] alors
indice_du_minimum = i
renvoyer indice_du_minimum
fin.
Ici l'idée est simple : pour un tableau qui contient au moins un élément, on commence au début du tableau et a priori le premier élément du tableau est le plus petit rencontré jusque là. Ensuite on parcourt le reste du tableau et si pendant le parcourt on trouve un élément plus petit que le plus petit rencontré jusque là alors on se souviens de la nouvelle position.
L'algorithme est le même quel que soit le langage que tu choisis par la suite.
La taille telle que définiepour ce tableau ne devrait pas être une variable (pas conseillé). Mais si tu passes la taille à une fonction, ça peut être une variable et tu peux la vérifier. Essaies une boucle du début jusqu'à la fin et conserve l'indice de l'élément le plus grand Mais comment je sais quel est le plus grand au départ? Je suppose que le plus grand est le premier (indice=0) et je commence à chercher à partir du deuxième (indice=1) Commence par ça.
Le Tout est souvent plus grand que la somme de ses parties.
J'ai absolument rien compris, j'imagine que c'est pas facile et clairement j'aurai sûrement pas fait mieux si j'étais l'auteur du cours (ça c'est sûr d'ailleurs lol) mais bon là pour le coup c'est totalement raté, on a absolument pas le niveau de faire ça en suivant juste le cours.
Et ce même en réfléchissant 2 ans, l'idée va pas me venir comme par miracle, j'ai écrit plein de truc mais j'ai l'impression que ce sont des aberrations.
En tous cas pour moi faut forcément à un moment ou un autre que j'écrive des choses genre "tableau[tailleTableau]", etc... ce que je n'ai pas le droit de faire si j'en crois le cours
PierrotLeFou: désolé je n'ai vu ton message que après avoir écrit ça
Soyons fou, je vais quand même mettre mon horrible code ici lol (je pense) parce que de toutes façons je vois pas comment faire donc je n'ai rien à perdre :
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include "main.h"
void ordonnerTableau(int tableau[], int tailleTableau);
int main(int argc, char *argv[])
{
int i;
int tableau[3] = {7,3,5};
for (i = 0; i < 3; i++) {
printf("%d\n", tableau[i]);
}
printf("\n\n");
ordonnerTableau(tableau, 3);
for (i = 0; i < 3; i++) {
printf("%d\n", tableau[i]);
}
return 0;
}
void ordonnerTableau(int tableau[], int tailleTableau) {
int i, derniere_valeur = 0;
derniere_valeur = tableau[tailleTableau-1];
for (i = 0; i < tailleTableau; i++) {
if (tableau[0] > tableau[i]) {
tableau[tailleTableau-1] = tableau[0];
tableau[0] = derniere_valeur;
}
}
}
Si je dis pas de bêtise, ce code va bien mettre la premiere valeur du tableau en derniere position si c'est la plus grande valeur, et la premiere valeur sera remplacée par la dernière (ici 5), parce qu'il faut bien que je la conserve cette valeur, mais bon voilà, après je vois pas comment faire
- Edité par SébastienTellier 15 juin 2021 à 19:25:57
Concernant la taille des tableaux, tu dois comprendre qu'il y a deux tailles :
la taille du tableau en mémoire, qui est constante ;
la taille réellement utilisée par les éléments, qui est variable, et toujours inférieur ou égale à la taille en mémoire.
Exemple : j'ai besoin d'un tableau pour stocker les notes d'un élève.
Taille en mémoire : 50, car je suis certain qu'ils n'auront jamais plus de 50 notes dans l'année.
Taille utilisée : au début de l'année ce sera 0, puis cette taille sera incrémentée à chaque note. À la fin de l'année, elle vaudra peut-être 18, quelque chose comme ça.
Déclaration :
float tab_notes[50] ; // taille 50 : une constante littérale
int nombre_notes = 0 ; // nombre de notes, au début 0
Important : il faut stocker le nombre de notes dans une variable entière à côté du tableau et mettre à jour cette variable. (La notion de structure donne un moyen plus pratique de faire ça, ce sera pour un prochain chapitre...)
Pour calculer la moyenne, ce n'est pas par 50 qu'il faut diviser la somme des notes, mais par nombre_notes.
Pour ajouter une note, il faut la mettre à l'indice nombre_notes (à condition que ce soit < 50) puis incrémenter nombre_notes. Par exemple s'il y avait 3 notes, aux indices 0, 1, 2, on met la 4ème à l'indice 3, et on dit qu'il y a désormais 4 notes. Taille en mémoire : 50, taille utilisée : 4.
Est-ce que ça m'aide pour l'exercice ? Ou c'est plutôt une information ?
Parce que perso je ne vois toujours pas comment faire pour l'exercice du coup, j'ai réussi tous les autres, avec votre aide, mais pour celui-là, j'y arrive tellement pas que je me demande si l'auteur a bien les "yeux en face des trous" quand il dit que c'est faisable avec ce qu'on sait jusqu'ici mdr...
EDIT : est-ce que je peux mettre un "for" dans un autre "for", j'y avais pensé mais je me suis dit que c'était nul lol, et j'ai quand même fait une recherche rapide dans google, premier code je vois ça... c'est une bonne idée selon vous ?
- Edité par SébastienTellier 15 juin 2021 à 21:38:00
Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^
Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?
D'après ceux qui l'ont lu ? Ou est-ce que c'est même pas la peine ? Parce que perso j'aurai bien aimé réussir quand même avant de poursuivre.
- Edité par SébastienTellier 15 juin 2021 à 22:07:45
Pour commencer doucement, je te propose ces exercices progressifs, qui serviront à écrire le tri final.
Il s'agit d'écrire des fonctions qui lisent un tableau déclaré dans le 'main'. Exemple :
int tab[] = {2, 4, -1, 10, -3, 5}
Voici les prototypes des fonctions à écrire :
1)
void affiche(int tab[], int n);
// Affiche les n éléments du tableau tab
// Cette fonction devra être utilisée pour contrôler
// tous les résultats des autres fonctions
2)
void permute(int tab[], int n, int i, int j);
// Permute les éléments d'indice i et j du tableau tab ayant n éléments.
3)
int chercheminimum(int tab[], int n);
// Retourne l'indice du plus petit élément du tableau
// tab contenant n éléments.
4)
void deplaceminimum(int tab[], int n);
// Cherche le plus petit élément du tableau tab qui contient
// n éléments, et le place en première position du tableau
// après avoir permuté avec l'ancien premier élément.
// Ex : {2, 4, -1, 10, -3, 5} devient {-3, 4, -1, 10, 2, 5}
// ^ le plus petit
5)
void deplaceminimum_2(int tab[], int n, int a, int b);
// Comme précédemment, mais en se limitant au sous-tableau
// compris entre les indices a et b.
// Exemple : {2, 4, -1, 10, -3, 5}. Si a = 2 et b = 4, on
// appliquera la fonction précédente seulement au sous-tableau
// {-1, 10, -3} (éléments n°2, 3, 4).
// Résultat : {-3, 10, -1}
L'algorithme courant pour ordonner un tableau utilise ces fonctionnalités (pour trouver le k-ème plus petit élément, on cherche le plus petit du sous-tableau k à n et on permute pour le placer en position k, et ainsi de suite). [En fait, comme les indices commencent à 0, il faut remplacer les positions k par k-1 et n par n-1.]
Il faut cliquer sur le lien … sinon il n'y a rien qui se passe.
SébastienTellier a écrit:
Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^
Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?
D'après ceux qui l'ont lu ? Ou est-ce que c'est même pas la peine ? Parce que perso j'aurai bien aimé réussir quand même avant de poursuivre.
- Edité par SébastienTellier il y a 10 minutes
C'est pas que c'est impossible. Mais c'est clair qu'il faudrait quelques bases en algo.
J'ai trouvé un code sur le net, bon j'avoue ça aurait clairement été mieux de chercher et trouver moi-même mais bon je suis en partie rassuré sur le fait que mon idée de mettre un "For" dans un autre "For" n'était visiblement pas mauvaise.
Bon perso je comprends pas pourquoi il fonctionne le code, mais je vais regarder pour essayer de comprendre.
Merci pour les exercices, je vais regarder aussi.
Je comprends mieux pourquoi les solutions ne sont pas données ni expliquées dans le cours...
Ce code fonctionne mais bon, je me demande bien pourquoi :
void ordonnerTableau(int tableau[], int tailleTableau) {
int i, j, c = 0;
for (i = 0; i < tailleTableau-1; i++) {
for (j = i + 1; j < tailleTableau; j++) {
if (tableau[i] > tableau[j]) {
c = tableau[i];
tableau[i] = tableau[j];
tableau[j] = c;
}
}
En fait je me demande s'il n'y a pas assez de détail dans le cours pour mieux comprendre analyses les algorithmes, où si je comprends juste rien à rien.
- Edité par SébastienTellier 15 juin 2021 à 22:44:10
Je peux toujours espérer que la nuit porte conseil mais j'y crois pas trop^^
Bref du coup vu que l'exercice est impossible avec ce qu'on sait à ce moment, visiblement... est-ce qu'on peut poursuivre le cours sans savoir faire ça ?
La programmation ça consiste à, de temps en temps, inventer des solutions à des problèmes. Pas seulement appliquer ce qu'on sait déjà faire.
C'est pour ça que ça ne sert pas à grand chose de montrer les solutions. Se faire déposer sur une montagne par hélicoptère, ça n'apprend pas à escalader.
Le probleme c'est que la marche à grimper est plus ou moins haute. Un algo de tri, c'est pas impossible mais c'est un peu beaucoup pour un débutant qui est encore encombré par des petits soucis.
Pour les deux boucles imbriquées, l'idée est en effet excellente.
Dans la solution que je soufflais, qui est le tri par sélection (Un classique, forcement) il y a une boucle qui consiste à mettre dans la première case le plus petit élément, dans la 2ieme le plus petit de ce qui reste, dans le 3ieme pareil etc.
Et ça fait appel à une autre boucle dont le rôle est de regarder à chaque etape qui est le plus petit de ce qui reste.
Si tu n'as pas peur de mettre des printf() dans ton code, je te suggère ceci: + d'abord, fais un test de tri avec un petit tableau, disons 3 ou 4 éléments seulement. + dans un premier temps, fais un printf de i et tableau[i] avant la boucle sur j + dans un second temps, fais un printf de i, tableau[i], j, tableau[j] juste avant le test Pour te simplifier la tache, voici une petite fonction qui te permettra d'afficher tout le tableau sur une seule ligne: - void affiche(int tableau[], int taille) { // Ça tient sur une ligne si les nombres sont petits et la taille est petite. printf("tableau[%d] = { ", taille); // Début de la ligne. for(int i = 0; i < taille; i++) { printf("%d ", tableau[i]); // Ne pas oublier l'espace après le %d } printf("}\n"); // Fin de la ligne. } - Tu n'as qu'à appeler cette fonction où tu veux dans les boucles, je te suggère après la boucle sur j (entre les deux } )
Le Tout est souvent plus grand que la somme de ses parties.
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.
Le Tout est souvent plus grand que la somme de ses parties.