ALERTE : besoin d'aide en C (informatique)

Le 20 novembre 2022 à 08:56:09 :
void trivial(int* list, int size) {
int i;
for(i = 0; i < size; i++) {
if(list[i] > 0) {
list[i] = list[i] * 2;
}
else {
list[i] = -1;
}
}
}

void trivial(list* L) {
  list*new = malloc(sizeof(list));
  while{L !=NULL){
    if(L->val > 0) {
      new->val = L->val ;
         (new->next)->val = L->val
             }
       else {  depile(L)}
         L = L->next;
    }
    
      
    
  }
}

Le 20 novembre 2022 à 09:00:32 :

Le 20 novembre 2022 à 08:56:09 :
void trivial(int* list, int size) {
int i;
for(i = 0; i < size; i++) {
if(list[i] > 0) {
list[i] = list[i] * 2;
}
else {
list[i] = -1;
}
}
}

void trivial(list* L) {
  list*new = malloc(sizeof(list));
  while{L !=NULL){
    if(L->val > 0) {
      new->val = L->val ;
         (new->next)->val = L->val
             }
       else {  depile(L)}
         L = L->next;
    }
    
      
    
  }
}

Je suis desole cle messager du demon mais c eclatax ta solution

Le 20 novembre 2022 à 09:01:36 :

Le 20 novembre 2022 à 09:00:32 :

Le 20 novembre 2022 à 08:56:09 :
void trivial(int* list, int size) {
int i;
for(i = 0; i < size; i++) {
if(list[i] > 0) {
list[i] = list[i] * 2;
}
else {
list[i] = -1;
}
}
}

void trivial(list* L) {
  list*new = malloc(sizeof(list));
  while{L !=NULL){
    if(L->val > 0) {
      new->val = L->val ;
         (new->next)->val = L->val
             }
       else {  depile(L)}
         L = L->next;
    }
    
      
    
  }
}

Je suis desole cle messager du demon mais c eclatax ta solution

Ca fait segmentation fault je pense mais merci pour ta solution

Le 20 novembre 2022 à 09:02:46 :

Le 20 novembre 2022 à 09:01:36 :

Le 20 novembre 2022 à 09:00:32 :

Le 20 novembre 2022 à 08:56:09 :
void trivial(int* list, int size) {
int i;
for(i = 0; i < size; i++) {
if(list[i] > 0) {
list[i] = list[i] * 2;
}
else {
list[i] = -1;
}
}
}

void trivial(list* L) {
  list*new = malloc(sizeof(list));
  while{L !=NULL){
    if(L->val > 0) {
      new->val = L->val ;
         (new->next)->val = L->val
             }
       else {  depile(L)}
         L = L->next;
    }
    
      
    
  }
}

Je suis desole cle messager du demon mais c eclatax ta solution

Ca fait segmentation fault je pense mais merci pour ta solution

oui j'ai surement fait de la merde au niveau des types psk j'ai pas fait de C depuis 4 ans mais je pense que ma solution est celle attendue

Le 20 novembre 2022 à 09:04:16 :

Le 20 novembre 2022 à 09:02:46 :

Le 20 novembre 2022 à 09:01:36 :

Le 20 novembre 2022 à 09:00:32 :

Le 20 novembre 2022 à 08:56:09 :
void trivial(int* list, int size) {
int i;
for(i = 0; i < size; i++) {
if(list[i] > 0) {
list[i] = list[i] * 2;
}
else {
list[i] = -1;
}
}
}

void trivial(list* L) {
  list*new = malloc(sizeof(list));
  while{L !=NULL){
    if(L->val > 0) {
      new->val = L->val ;
         (new->next)->val = L->val
             }
       else {  depile(L)}
         L = L->next;
    }
    
      
    
  }
}

Je suis desole cle messager du demon mais c eclatax ta solution

Ca fait segmentation fault je pense mais merci pour ta solution

oui j'ai surement fait de la merde au niveau des types psk j'ai pas fait de C depuis 4 ans mais je pense que ma solution est celle attendue

Osef ca me forcera a m'entraîner sur ca au moins, merci hein en tout cas je me rend compte que je dois me bouger le cul

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct bloc {
    int valeur;
    struct bloc* suivant;
};

struct bloc* exercicedemerdedelop(struct bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct bloc* buf = l->next;
    l->next = malloc(sizeof(struct bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

edit : normalement dans les noms des trucs on met pas de majuscule, on en met seulement sur les typedef

Le 20 novembre 2022 à 09:19:14 :

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct Bloc {
    int valeur;
    struct Bloc* suivant;
};

struct Bloc* exercicedemerdedelop(struct Bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct Bloc* buf = l->next;
    l->next = malloc(sizeof(struct Bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

Merci mec désolé si je tai fait perdre du temps
Je vais rebosser ça et me taper des giga exos en listes chaînées après

Le 20 novembre 2022 à 09:19:14 :

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct bloc {
    int valeur;
    struct bloc* suivant;
};

struct bloc* exercicedemerdedelop(struct bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct bloc* buf = l->next;
    l->next = malloc(sizeof(struct bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

edit : normalement dans les noms des trucs on met pas de majuscule, on en met seulement sur les typedef

Okok c'est noté

Le 20 novembre 2022 à 09:20:31 :

Le 20 novembre 2022 à 09:19:14 :

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct Bloc {
    int valeur;
    struct Bloc* suivant;
};

struct Bloc* exercicedemerdedelop(struct Bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct Bloc* buf = l->next;
    l->next = malloc(sizeof(struct Bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

Merci mec désolé si je tai fait perdre du temps
Je vais rebosser ça et me taper des giga exos en listes chaînées après

nickel

bah si t'es tant chaud que ca repare ma solution parce que acutellement y'a ce qu'on appelle une fuite de memoire, c'est a dire que la memoire que ca occupe va grandir a l'infini
faut rajouter une ligne gl

Le 20 novembre 2022 à 09:22:00 :
Par contre je veux pas finir à pole emploi

je veux pas te faire peur mais ca devient vraiment de plus en plus dur de trouver du taff en info donc devient bon et trouve vite des stages kheyou si tu veux pas que ca t'arrive

Le 20 novembre 2022 à 08:29:11 :
Je dois créer une procédure qui modifie la liste entrante et qui rend une liste en dédoublant les nombres positifs et en enlevant les autres

Vous avez une idée ? :'(

Ex : [1,2,-5,0] -> [1,1,2,2]

Bah tu parcours ton tableau quand tu tombes sur un entier positif tu incrémentes de 2 un compteur initialisé à 0.

Tu crées un tableau de la taille de ton compteur.

Tu parcours ton premier tableau quand tu tombés sur un entier positif tu ajoutés deux fois cet entier dans ton deuxième tableau.

Le 20 novembre 2022 à 09:22:52 :

Le 20 novembre 2022 à 09:20:31 :

Le 20 novembre 2022 à 09:19:14 :

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct Bloc {
    int valeur;
    struct Bloc* suivant;
};

struct Bloc* exercicedemerdedelop(struct Bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct Bloc* buf = l->next;
    l->next = malloc(sizeof(struct Bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

Merci mec désolé si je tai fait perdre du temps
Je vais rebosser ça et me taper des giga exos en listes chaînées après

nickel

bah si t'es tant chaud que ca repare ma solution parce que acutellement y'a ce qu'on appelle une fuite de memoire, c'est a dire que la memoire que ca occupe va grandir a l'infini
faut rajouter une ligne gl

Il faut faire un free de ta liste temporaire non?
Genre un free(buf);

Le 20 novembre 2022 à 09:27:15 :

Le 20 novembre 2022 à 08:29:11 :
Je dois créer une procédure qui modifie la liste entrante et qui rend une liste en dédoublant les nombres positifs et en enlevant les autres

Vous avez une idée ? :'(

Ex : [1,2,-5,0] -> [1,1,2,2]

Bah tu parcours ton tableau quand tu tombes sur un entier positif tu incrémentes de 2 un compteur initialisé à 0.

Tu crées un tableau de la taille de ton compteur.

Tu parcours ton premier tableau quand tu tombés sur un entier positif tu ajoutés deux fois cet entier dans ton deuxième tableau.

Merci khey mais c sur les listes chaînées, sur les tableaux c'est plus évident au début

Le 20 novembre 2022 à 09:33:02 :

Le 20 novembre 2022 à 09:22:52 :

Le 20 novembre 2022 à 09:20:31 :

Le 20 novembre 2022 à 09:19:14 :

Le 20 novembre 2022 à 09:15:41 :

Le 20 novembre 2022 à 09:10:28 :

Le 20 novembre 2022 à 09:06:23 :

Le 20 novembre 2022 à 09:04:59 :
Quand tu dois faire de la recurrence sur des types pense toujours a faire le cas return null etc en premier

Yep c vrai

Donne le type de la liste chainee qu'il y a dans l'enonce

Je pense que ta bon quand meme , c une liste chainee classique regarde

typedef struct Bloc{
int valeur;
struct Bloc* suivant;
}Bloc;

typedef Bloc *Liste;

Pour bien comprendre je te conseille de jeter le typedef qui ne va que t'embrouiller et de ne commencer a l'utiliser plus tard

du coup ca donne ca et je pense que c'est bon

struct Bloc {
    int valeur;
    struct Bloc* suivant;
};

struct Bloc* exercicedemerdedelop(struct Bloc* l){
    if (l == NULL) return NULL;
    if (l->value < 0) return l->next;
    struct Bloc* buf = l->next;
    l->next = malloc(sizeof(struct Bloc));
    l->next->value = l->value;
    l->next->next = exercicedemerdedelop(buf);
    return l;
}

j'ai rearrange pour que ce soit plus clair

le typedef au debut ca t'embrouille parce que ca t'empeche de bien comprendre que "struct Bloc" et un type, comme "int"
commence par bien comreprendre ca et ensuite pour exercice ajoute le typedef bien comme il faut

Merci mec désolé si je tai fait perdre du temps
Je vais rebosser ça et me taper des giga exos en listes chaînées après

nickel

bah si t'es tant chaud que ca repare ma solution parce que acutellement y'a ce qu'on appelle une fuite de memoire, c'est a dire que la memoire que ca occupe va grandir a l'infini
faut rajouter une ligne gl

Il faut faire un free de ta liste temporaire non?
Genre un free(buf);

non cle surtout pas, tu vas tout peter sinon

faut faire un free sur la liste que tu ignores dans le cas ou value est negatif

je te conseille de preparer une liste et d'essayer ta proposition dans ce site https://pythontutor.com/c.html et de voir pourquoi ca pete tout, tu comprendra beaucoup de choses