Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
Code "corrigé"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 80
typedef char tchaine[MAX];
char *lire(char *chaine)
{
//les variables de même type sur la même ligne.
int i=0;
int test = 0;//nom de variable pas explicite, soit tu donne un meilleur nom, soit tu commentes
int fn; //pareil
int n; //on suppose que 'n' est une variable de 'parcours' (comme i et j), mais précise
int lg=strlen(chaine); // nom de variable ..
//tu utilises 'i' dans la boucle while, mais la valeur de 'i' ne change jamais
// soit c'est une erreur, soit tu peux remplacer 'i' par sa valeur (qui est fixe et n'a pas changé)
// depuis sa déclaration -> 0.
while(chaine[i]==' ')
{
n=i;
while(chaine[n]!='\0')
{
chaine[n]=chaine[n+1];
n++;
}
}
// la longueur de la chaine a changé quand tu arrives ici. Vu que tu as bien updaté
// la valeur de lg après le for, mais que ça doit être fait plusieurs fois, je te propose simplement
// d'utiliser strlen(chaine) au lieu de stocker dans lg (vu que cette valeur est succeptible de changer à chaque tour
// de boucle). Du coup tu notes par exemple for(i=0; i<=strlen(chaine); i++)
for (i=0;i<=lg;i++)
{
if (test==1)
{
i=i-1;
test=0;
}
if((chaine[i]==' ') && (chaine[i+1]==' '))
{
n=i;
while(chaine[n]!='\0')
{
chaine[n]=chaine[n+1];
n++;
test=1;
}
}
}
lg = strlen(chaine);
if (chaine[lg-1]==' ') // peut faire plus court
{
chaine[lg-1]=chaine[lg];//pas très cool, si ce que tu veux faire c'est mettre un '\0', alors mets le
//chaine[strlen(chaine)] = '\0'
}
return chaine;
}
int strpos(char * m, char *chaine)
{
// les variables en dessous sont de même type, y'a moyen de tout écrire sur une ligne
int lg = strlen(chaine); //nom de variable pas explicite
int lgm = strlen(m); //là non plus
int i;
int n;
for (i = 0; i < lg; i++)
{
for(n=0; chaine[i+n] == m[n]; n++)
{
if(n==lgm-1) //moyen de faire plus court
{
return i;
}
}
}
return -1;
}
char *strmin(char *chaine)
{
int i=0;
for (i = 0; chaine[i] != '\0'; i ++)// c'est que de la rigueur, mais pas d'espace entre i et ++
{
if (chaine[i] >= 65 && chaine[i]<=90) //possibilité de faire plus court
{
chaine[i] = chaine[i] + 32; //possibilité de faire plus court
}
}
return chaine;
}
int VIDE(char *chaine) // à remplacer par un macro de préprocesseur
{
if(chaine[0]=='\0') //plus court
{
printf("la chaine est vide\n");// jamais demandé d'afficher le résultat
}
else
{
printf("la chaine n'est pas vide\n"); //idem
}
//Il manque une valeur de retour ! Type de fonction -> int !
}
int EGAL(char *chaine, char *chaine2) //à remplacer par un macro de préprocesseur
{
//Je commente quand même, même si la fonction va disparaître
//même nom de var
int i=0;
int j=0;
int test = 0;
while(chaine[i] != '\0')
{
if (chaine[i] != chaine2[j]) //possibilité de faire + court
{
test = 1;
}
i++; //pourquoi 2 variables différentes alors qu'elles ont la même valeur tout le temps ?
j++;
}
if (test == 0)//on peut faire plus court
{
printf("les deux chaines sont identiques.\n"); // mais on a jamais demandé d'afficher le résultat
}
else
{
printf("les deux chaines ne sont pas identiques.\n"); //idem
}
//Il manque une valeur de retour ! -> le type de la fonction est int
}
char* premier(char* ch)
{
int i;
// On a définit MAX = 80 dans les directives de préprocesseur, c'est pour éviter
// de devoir changer tous les 80 si jamais t'as envie de changer le max.
// Donc on évite les valeurs comme ça. (mets plutôt MAX)
char premier[80]; //char premier[MAX];
for (i = 0; ch[i] != ' '; ++i) //plus court ET que se passe t'il s'il n'y a pas d'espace ??? ... boucle infinie
{
premier[i] = ch[i];
}
return premier;
}
int main()
{
tchaine chaine,m; //Pourquoi 2 lignes pour le même type ?
tchaine chaine2;
printf("rentrer une chaine de caractère : \n");
// Ci dessous, y'a moyen de condenser un peu. le nom "lire()" sous-entend que la chaine n'a pas encore été lue
// C'est très bien sauf que tu lui passes une chaine déjà lue. Donc à première vue (même si le code est bon)
// on peut penser que ton code est faux car il va lire 2 fois une chaine.
// Pourquoi ne pas simplement intégrer gets à ta fonction lire ?
gets(chaine);
lire(chaine);
printf("la chaine apres la fonction lire est :%s.\n",chaine); //pas très clair, préférer "la chaine nettoyée"
printf("quelle mot rechercher vous ?\n");
//pourquoi ne pas appliquer la fonction lire sur le mot 'm' ? au moins tu es sûr que cette chaine 'm' est "clean"
// (nettoyée des espaces indésirables)
gets(m);
printf("premier caractère de votre mot est en %d position \n",strpos(m,chaine));
strmin(chaine);
printf("Le remplacement des caractères en majuscules par des minuscules nous donne : %s\n",chaine);
VIDE(chaine);
printf("rentrer une chaine de caractère : ");
gets(chaine2);
EGAL(chaine, chaine2);
printf("Le premier mot de la chaine est : %s\n", premier(chaine));
; //il doit se faire chier tout seul non ?
//même pas un return pour lui tenir compagnie
}
/*
C'est globalement pas mal, et ça marche (malgré qq problèmes mais ça arrive)
Ce qu'il faut que tu fasses, c'est faire tout le tuto et lire tout de A à Z et faire tous les exos
du tuto OpenClassroom sur le C !
Surtout la partie sur les variables, les fonctions, les pointeurs, les conditions, les boucles, et les tableaux (oui je sais à peu près tout en fait)
Pour améliorer ton code, sache que
if(bidule) {
une seule instruction;
}
peut se réduire en
if(bidule)
une seule instruction;
mais pas
if(bidule) {
une instruction;
une autre instruction;
}
c'est que si y'a qu'une instruction
ça marche aussi avec le else, le for, et le while
ensuite
int a;
int b;
int c;
peut se réduire en
int a,b,c;
pareil si
int a = strlen(chaine);
int b = 0;
int c;
ça équivaut à
int a = strlen(chaine), b = 0, c;
Par contre :
int* a;
int* b;
int* c;
ne se réduit pas en
int* a,b,c;
mais en
int *a, *b, *c; (signe pointeur devant chaque variable);
ensuite
une fonction de type X renvoie une valeur de type X dans TOUS LES CAS.
Tu dois prévoir chaque cas et chaque cas doit renvoyer une valeur du type de la fonction. (void = pas de type, donc pas de renvoie de valeur)
ensuite
une condition vaut 1 si elle est vraie, 0 si elle est fausse, ET PAS SEULEMENT DANS UN IF, WHILE, etc
donc si tu marques
int a = 54, b = 54, c;
c = (a==b);
c vaut 1
Si tu mets
int a = 12, b = 54, c;
c = (a==b);
c vaut 0
DONC
marquer
if (chaine[i] != chaine2[j])
{
test = 1;
}
revient à faire
test = (chaine[i] != chaine2[j])
puis qu'on ne fait rien d'autre que test=1 si la condition est vrai
Je sais pas si j'ai fait le tour de tout, mais corrige déjà ça, ce sera pas mal ;)
*/
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.