Un petit coup de Gparted devrait te montrer si tu as encore une partition Windows (faut noter qu'il y a certains cas ou Windows est encore là mais n'apparait pas au Grub... ça arrive).
C'est vrai que fdisk est bien fichu aussi mais bon, ça vaut toujours le coup d'installer Gparted, l'interface graphique est plutôt bien fichu et on peut faire simplement et rapidement pas mal d'opérations sur nos partoches.
(ceci dit avec fdisk au moins on est prêt à parer toute les situations sur presque toutes les distributions)

Normalement la documentation d'ubuntu-fr devrait te donner suffisament d'indications pour résoudre ton problème de Wifi.

Tu utilises Ubuntu 8.04 ou Ubuntu 8.10 ? La 8.10 intègre un nouvel outil pour gérer les connexions Wifi il me semble, cherche du côté de ton l'applet Network Manager dans la barre de tâches.
Est-ce que tu n'as pas honte d'avoir choisis Ubuntu ? (histoire de troller un coup)

  Bonsoir tout le monde !

Voilà mon problème.
J'ai passé mon après-midi a écrire un programme et j'ai le plaisir d'annoncer qu'il marche très bien et compile sans warning. Le problème, c'est que là ou je suis, dans nos Makefile nous devons mettre une règle OBJ sous la forme :

OBJ = $(SRC:.o=.c)

Et quand la règle all dépend de celle-ci, plus rien ne va... à partir de ce moment là, mes fichiers headers ne sont plus inclus...
Et comme j'aime faire un code beau et propre, j'aime bien regrouper toutes les déclarations dans seulement quelques fichiers. Je ne peux donc pas y renoncer.

Voici mon Makefile :

NAME    =       bsq
CC      =       gcc
CFLAGS  =       -W -Wall -ansi -pedantic
SRC     =       main.c \
                build_tab.c \
                find_square.c \
                my_functions.c \
                draw_tab.c
HEADERS =       -I./headers/
OBJ     =       $(SRC:.c=.o)
RM      =       rm -rf

all: $(OBJ)
        $(CC) $(CFLAGS) -o $(NAME) $(SRC) $(HEADERS)

fclean:
        $(RM) *.o

clean:  fclean
        $(RM) bsq

.phony: all clean fclean

(pour ceux qui connaissent, OUI c'est la BSQ et oui il m'a fallut toute une après-midi pour la faire... m'apprendra à faire la fête toute la nuit...)

Je pense que ce sera pas bien grave si je rend un Makefile sans règle OBJ, mais comme je vais devoir écrire encore maints et maints Makefile, j'aimerais bien comprendre qu'est-ce qui ne va pas et pourquoi

J'ai passé l'après-midi avec mon binôme à chercher sur internet.

Finalement on a laissé tombé et opté pour une solution inatendue qui n'utilise qu'une liste chaînée... mais qui *devrait* marcher (on le saura quand j'aurais adapté le code des opérations pour modifier la façon dont ça supporte les bases.
C'est la solution la plus conne à laquelle j'ai pu penser, mais elle est pas difficile à réaliser même avec la norme, et elle gère tout les cas que j'ai pû imaginer.
Je me contente de créer à partir de la chaîne une liste chaîné contenant nombres, opérateurs et parenthèses, et je boucle jusqu'à ce que toutes les opérations soient résolus : quand il ne reste plus qu'un élément dans ma liste chaînée, le calcul est terminé et je renvois le résultat.

Ca suit ce shéma :
A + B * C + D
A + B *, on touche pas
B * C : on calcule, ça donne N, on modifie le pointeur sur next de A vers N et le pointeur sur next de N pointera sur D : on fait alors un free de B et C, et voilà !
A la suite, le programme rencontrera donc N + D, calculera alors R le résultat de N + D, et à la prochaine boucle calculera A + R. Ne restera plus qu'un élément : la boucle cessera de tourner.

Pour les parenthèses, je me contente de calculer tout ce qu'il y a à l'intérieur des parenthèses, et quand tout les calculs à l'intérieur sont finis, j'ai donc par exemple (15)*(12). Une fonction "clean" nettoie à la fin de chaque boucle et se débarasse des parenthèses superflues.

On aura peut-être pas le programme le plus rapide, mais on aura le plus simplement pensé.
De toute façon, l'important c'est que ça marche et que ça marche bien.

Ca me tracasse quand même de ne pas avoir pu coder "comme tout le monde" avec un arbre binaire... et de pas saisir le concept des piles. Je suppose qu'une pile est censé me permettre de mettre des opérations en attente (résoudre les opérations que je peux résoudre, mettre les autres dans la pile, quelque chose comme ça ?), mais comment réaliser ça, Dieu le sait.

Si on doit construire une pile contenant les nombres, opérateurs et parenthèses dans l'ordre, en quoi est-ce différent de la chaîne donnée au départ ?

Je saisis pas bien la chose. C'est un peu comme ça que je voyais le parser à la base, mais j'ai jamais compris comment réaliser ça au niveau du code.

On lit la chaîne, et quand on peut faire une opération on la fait.
Et si on peut pas la faire, on la met sur une pile en attendant que les autres opérations à faire pour qu'elle devienne réalisables soient réalisés. En gros, le parser fait une sorte de factorisation.
Mais au niveau du code... comment concevoir cette pile ? Ou stocker les résultats et comment lier les parties de l'expression résolues et les parties qui ne le sont pas ?

EDIT
J'ai pensé aussi à résoudre directement depuis la pile.
Je construit une pile à partir de structures contenant des nombres, des opérateurs, ou des parenthèses, et je parcours ma chaîne en résolvant ce qui peut être résolut, jusqu'à ce qu'il n'y ait plus qu'un élément à ma pile.

En gros, après avoir crée ma pile j'ai ces éléments :

-12 + 4 * 56 + 13 * (12 +  5 * 3) / 46

Et je résous en parcourant la pile : en gros au fur et à mesure ma chaîne deviendra :
-12 + 4 * 56 + 13 * (12 +  5 * 3) / 46
-12 + 224 + 13 * (12 + 15) / 46
212 + 13 * (27) / 46
212 + 13 * 27 / 46
212 + 8
220
Plus qu'un seul élément à la plie (dans la structure, les variables previous et next sont toutes deux égales à zéro), on a notre grand gagnant.

Ca devrait être possible non ?

Bien vu je suis pas le seul ici alors !

Je viens de m'enfiler une après-midi de code pour essayer de résoudre via un arbre binaire, mais je vais googler pour la RPN alors.
En somme, je dois réorganiser l'expression en mettant les opérateurs à part : un type m'a dit qu'il avait fait comme ça mais j'avais abaondonné cette piste. Maintenant je vois que j'avais seulement pas du tout compris le principe : c'est vachement intelligent comme concept o_o !
On a 5*(4+7+3), ça donne d'un côté 4 7 3 et de l'autre + + 5* ! Et ça se résout en faisant 4 + 7, le résultat + 3, le résultat *5. C'est ça ?

Ce doit être assez compliqué à mettre en œuvre tout de même, ça me pose toujours le problème de détecter les premières opérations à résoudre.

Je viens de voir la vidéo sur l'intra, j'ai mieux compris le concept (ça m'a vraiment fait revenir en primaire, j'avais complètement oublié qu'on faisait comme ça à l'époque : maintenant j'ai retrouvé toutes les opérations et j'ai bientôt fini).
Pour la division j'ai commencé par la méthode de la potence en effet (ça nous rajeunit pas...). J'ai du mal à voir comment on pourrait résoudre autrement o_o !

Effectivement o_o ça déchire.

Je vais faire boulet mais je me demande encore...
Si la priorité était sur le premier élément : 36 * 21 + (42 - 3) ce serait une toute autre forme non ?

         +
     /        \
    -         *
  /    \     /   \
42   3  36  21

Par exemple. Ca rend la réalisation du code qui crée l'arbre (le parser c'est ça ?) extrêmement compliqué. Il faut vraiment comprendre l'expression avant de la retranscrire, et ça... je me sens franchement pas capable de coder ça après 4 semaines de C...
En fait il faudrait créer les dernières branches (36 * 21 et 42 - 3) en tout dernier et remonter l'arbre petit à petit jusqu'à la dernière opération qui sera la première executée dans notre fonction de résolution récursive.

Que fait le parser...
Il tombe sur l'expression 36 * 21 + 12 * (42 - 56).
Il va lire 36 * 21, et créer un élément 36, un élément 21, et un élément * qui les unis.
Il va lire +, que va-t-il faire ?
Il va lire 12 * (42 - 56). Il va créer un élément 42, un 56, et des éléments 12 et - unis par le *.
Et le plus sera l'élément réunissant les deux parties de l'expression.
Non, en terme de code je ne vois vraiment pas comment réaliser ça... pour des expressions plus complexe ça devient du suicide de s'attaquer à ça.

Je me heurte également au problème des opérations avec les bases les plus louches imaginables...
Comment on pourrait se démerder pour faire les opérations dans des bases non numériques (et même numérique, à partir du moment ou on sort de la base 10, on ne peut plus se fier à nos additions et compagnie en C).
Par exemple, si je bosse sur une base du genre 0è-['"é&=à@ (10 chiffres différents, mais rien numériques) je n'ai pas d'autre choix que de convertir le chiffre en base 10.
Donner des valeurs entre 1 et 255 aux chars (ce qui empêche d'utiliser des bases de plus de 255 nombres donc on est pas si infini que ça) et ensuite calculer sous cette forme en utilisant les opérations normales et la longueur de la base ?

On m'a également dit par rapport à la construction de l'arbre de chercher du côté de la grammaire arithmétique... mais sur Google ça se borne à des problèmes dans le programme des écoliers (et un type qui fait du flex) !

Finalement c'est vrai que le problème ne réside pas tellement là dedans. Cinq fonctions se chargeront vite fait de cette partie du programme.

Maintenant je me pose surtout des questions sur mon arbre binaire... je ne comprend pas vraiment comment on en créer un.

Je suppose bien qu'il me faudra une structure du genre
struct s_btree
{
  char *data;
  struct s_btree  next_left;
  struct s_btree  next_right;
};

Mais je ne sais pas vraiment comment le créer... comment différencier les opérateurs des nombres, etc...
J'ai vu un peu de documentation sur le net mais c'est énoncé de façon très très complexe (en plus de me laisser en plan sur certains problèmes, par exemple je dois gérer des expressions du type : +--+-31*--+42+32--6+---4, l'utilisateur pouvant à loisir improviser des bases et des opérateurs (on peut utiliser un 'z' à la place du '+' par exemple, mais ça c'est une autre histoire du problème autrement plus facile à résoudre).

J'aimerais savoir comment construire un arbre qui permettra à ma fonction résolvant le calcul de respecter les priorités, les parenthèses, etc...
Je ne vois vraiment pas comment construire l'arbre binaire, je n'arrive pas à concevoir, je me demandais si vous pouviez me donner des pistes.

Par exemple, me représenter l'arbre binaire qui servirait à résoudre l'équation suivante : 36 + 21 * (42 - 3) ?
Je n'arrive vraiment pas à voir comment sera constitué l'arbre binaire de ce programme, et c'est assez bloquant pour coder tout le reste.

Dans le principe oui, dans le code pas tant que ça.
Surtout pour la division et le modulo... parce qu'au final en travaillant avec des chars, on doit bosser chiffre par chiffre (ou alors je me plante sur toute la ligne ?).

Pour une addition de tableau de char je veux bien croire que ce soit pas trop compliqué. On peut faire ça simplement, additionnant chaque chiffre entre eux avec une ptite bidouille à côté pour les retenues (étant donné que le nombre doit potentiellement être infini je vois pas vraiment d'autres façon de s'y prendre). Pour la soustraction plus ou moins la même chose dans l'autre sens,
La multipilcation c'est déjà autre chose. Et la division et le modulo sont une histoire beaucoup plus inquiétante.

Ca m'inquiète. Je dois donc vraimenrt faire des opérations directement sur des tableaux de char...

Bonsoir tout le monde !

Je dois programmer une calculatrice avec certaines caractéristiques un peu spéciales...

Pour la petite histoire, c'est une calculatrice complète capable de pas mal de chose. Elle doit gérer n'importe quelle base donnée (hexadecimal, binaire, mais aussi une base improvise si on veut : c'est pas vraiment compliqué ça encore), les parentèses, et les opérations + - / * %.

Le truc c'est que c'est une calculette de "nombre infinis". C'est là que ça me pose problème.
On peut certe écrire un nombre aussi grand que l'on veut dans un tableau de char (dans la limite de la mémoire disponible), mais il faut bien faire des calculs quelque part... et pour ces calculs, il faut travailler avec des int, des long, des ce qu'on veut : et ça implique une limite.
(bon, d'accord, on peut très bien réinventer l'addition de nombres stockés en tableau de char assez facilement, la soustraction aussi, mais pour la multiplication et la division ça va être beaucoup plus horrible, et je ne parle même pas du modulo).

De même, est-ce que je peux prendre des paramètres infinis également ? Par exemple, si je fais trois milliards plus quatre milliards, les trois et quatre milliards devront bien être stocké dans un int à un moment (ou autre chose mais c'est pas grâve : l'essentiel c'est qu'à un moment pour faire le calcul ils devront être dans une variable limitée).
Par conséquent est-il seulement envisageable de gérer des paramètres potentiellement infinis ?

Pour le moment, je n'ai qu'une idée de base : bosser avec des tableaux de chars et un arbre binaire.
Mais je ne vois pas comment manipuler des nombres potentiellements infinis.

Avez-vous une idée de comment ce genre de prouesse peut être réalisé ?

Je compile mon code avec la commande :

gcc -W -Wall -ansi -pedantic *.c

(c'est plutôt une bonne chose ça je suppose, on nous demande de nous démerder pour ne recevoir aucun messages en lançant cette commande).
Je reçoit quand même des erreurs mais rien de bien grâve : une implicit declaration de putchar et le paramètre argc que je n'utilise pas dans le main.

En compilant avec les option g et Wall, je n'ai que la implicit declaration de putchar.
J'ai donc rajouté le prototype de putchar en tête du fichier et je n'ai plus aucun retour de gcc -g -Wall.

Je comprend bien que c'est à cause de ma conception assez médiocre de la chose que je suis obligé de faire des bidouilles et de produire un code tout fratras pour respecter la norme, mais des trois programmes que j'ai écrit pour répondre à la consigne c'est le seul qui fonctionne (enfin... "fonctionne") en respectant la norme.

D'autre part,  syntaxiquement, rien n'interdit de mettre les accolades sur les mêmes lignes que les if ou les else (sauf si tu as comme contrainte de respecter une règle d'indentation

C'est hors-norme en effet, ça tapera à -3 points par ligne du genre.

La segfault à lieu précisemment à cette ligne :
 while (tab[cursor][0] != 0)

Ça ne m'aide pas à comprendre pourquoi dans  mon programme, "nani nana " n'est pas considéré comme identique à "nani nana  "...

Sinon j'ai trouvé GDB comme débuggeur, mais je comprend pas très bien comment ça fonctionne... ni même qu'est-ce que ça fait. Ça dit à quel ligne du programme ça plante, combien de fois il passe par cette ligne, et de regarder des valeurs de variables à un certain moment si j'ai bien compris l'article Wikipédia.

Mais bref, j'ai découvert d'où viens le bug.
Ça se passe lors de l'écriture du caractère signifiant la fin du tableau de tableaux...
Je ne sais ABSOLUMENT pas pourquoi, mais dans le cas et dans l'UNIQUE cas ou l'avant dernier caractère de la chaîne est alphanumérique et le dernier ne l'est pas, je dois écrire à l'emplacement "y" au lieu de "y + 1"...
Me reste plus qu'à trouver comment faire ça en conservant un maximum de 4 paramètres et 25 lignes par fonctions...

Le problème c'est que justement...
J'ai une limite de 80 caractères par lignes (d'où les if (truc) alors if (machin) et pis if (chose)...
Et une limite de 25 lignes par fonction (d'où les accolades en moins... et les paramètres bidons).

C'est assez absurde, mais pour nous faire écrire un code soit-disant lisible, on nous impose des contraintes qui dans certains cas nous font faire de l'illisible.
Si j'avais droit d'attribuer une valeur à certaines variables dès leur déclaration je suis sûr qu'on gagnerait en clarté par exemple...

Et il faudrait qu'on déniche ton bug, pour ton devoir, en se paluchant entièrement le code source ? Ah non, pardon, il faut aussi qu'on réimplémente les bouts qui manquent. Hé ben...

Les bouts qui manquent ?
Ça m'a l'air plutôt complet et fonctionnel... quand j'essaye d'oublier que dans un cas qui me pourrit la vie ça segfault.

Bon. Ça segfault quand j'essaye de lire le tableau de résultat.
C'est la que ça devient curieux. Pourquoi ça ne segfault QUE dans le cas ou la chaine fini par un caractère non alpha-numérique.
Si j'essaye de lire le contenu de ce tableau à l'intérieur de la fonction my_str_do_wordtab, ça fonctionne... dans tout les cas.
Par contre, si j'essaye de lire à l'extérieur de cette fonction, ça fonctionne dans tout les cas mais pas dans celui ou la chaîne fini par un caractère non alpha-numérique.
Par contre, dès qu'il y a PLUSIEURS caractères non alpha-numériques après la chaine (genre "abcd tati tota +|- ") là ça se remet à marcher...

Curieux non ?

Le Tomb Raider 5 n'étais pas si mal non plus Harthorn. En tout cas il partait pas en couille comme le sixième.
Les Legend et Anniversary ne sont pas non plus bien dégueu, c'est un peu nouveau, et c'est difficile aujourd'hui de retrouver les même sensations qu'avant mais... pour passer le temps, pourquoi pas ?

Pandora ma parôle quelle bête de sexe o_o !

Alors pour moi ça donne :

Votre score est de 108 point(s).

Statistiques :
Pourcentage de réponses positives : 32 %
Réponses positives sur les boissons : 60 %
Réponses positives sur les drogues : 50 %
Réponses positives sur le sexe : 16 %

Juste supérieur à la moyenne. Tout ce qu'on peut dire, c'est que vous êtes sorti(e) de chez vous quelques fois !
(Un bon début ! C'est un score juste supérieur à la moyenne ! Ah ah, voila ce que ça fait, la jeunesse décadente )

J'ai bien rigolé à la question "avez-vous déjà uriné à un endroit qui n'était pas prévu à cet effet". Si on nous donnait un point pour chaque fois où on aurait pissé dans un endroit pas prévu à cet effet on en aurait pour des centaines et des centaines de points ^^' !
La semaine dernière c'était par la fenêtre (yavait un capot dans les toilettes)... mais je vous rassure j'ai fait pire o_o !

[1 - wordtab_iznogood]

Bonsoir tout le monde !

Je devais écrire pour hier une fonction qui sépare les mots d'une chaîne passé en paramètres et les stocks dans un tableau (str_to_wordtab) et une autre fonction qui affiche le résultat en séparant chaque mots
A savoir : tout les caractères non-alphanumériques sont considérés comme des séparateurs de mots
Hier soir à 22h30, je teste mon programme avec un main de cette sorte :

int main(int argc, char **argv)
{
  my_show_to_wordtab(my_str_to_wordtab(argv[1]));
  return (0);
}

Et je constate que le programme compilé fonctionne à merveille, et décide de rentrer chez moi !
Cela dit, 23h42, je me prend un zéro aux deux exercices... je fais une petite batterie de test, et me rend compte que mon programme renvoi une segfault pour toutes les chaînes dont le dernier caractère n'est pas alpha-numérique.

Et c'est très rageant. Car j'ai très bien réussi les programmes à finir pour ce soir (qui sont finalement à finir pour lundi soir), mais ils seront comptés comme faux parce que je n'arrive pas à dénicher le bug qui provoque cette segfault...

J'utilise des fonctions tels que my_strlen, car on ne doit utiliser que des fonctions que nous avons codé nous-même, sauf pour write(), malloc() et sizeof().

Le code se divise en six fonctions. Voici d'abord une table des matières, je poste le code juste en bas :
1 - wordtab_iznogood
Vérifie si le caractère envoyé en paramètre est alphanumérique ou non.
Si oui, elle renvoi 1. Sinon 0.

2 - count_words
Compte le nombre de mots dans la chaîne envoyée en paramètre. Pour trouver ou les mots se séparent, elle utilise la fonction wordtqb_iznogood.
En utilisant la variable flag elle supporte ainsi le cas ou deux mots sont séparés par plusieurs espaces ou caractères non-alphanumériques.
Elle renvoi le nombre de mots trouvés.

3. count_char
Compte le nombre de caractères dans un mot.
Au premier caractère séparateur trouvé, elle renvoi le nombre de lettres comptées.

4. my_str_do_wordtab
Elle s'occupe des malloc pour les tableaux contenant les caractères.
Elle inscrit à chaque emplacement la lettre qui lui correspond.
Une fois arrivé à la fin, elle alloue un espace dans le dernier tableau de tableau et écrit simplement 0 pour signifier la fin du tableau.
Elle renvoi le tableau obtenu.

5. my_str_to_wordtab
Elle s'occupe du malloc pour le tableau contenant les tableaux de char.
Elle lance la fonction my_str_do_wordtab une fois la première allocation de mémoire réalisée. Quand le tableau a été rempli avec succès, elle le renvoi.

6. my_show_to_wordtab
Affiche chaque mot contenu dans un tableau sous la forme de celui crée par la fonction my_show_to_wordtab.
Elle utilise les fonctions my_putstr et my_putchar pour afficher le résutlat. my_putchar affiche un caractère, my_putstr une chaine de caractère.

Voici le code des fonctions respectives :
A inclure : stdlib.h , les fonctions my_strlen(), my_putchar() et my_putstr(), les deux premières existent sous la forme strlen et putchar, la troisième je ne sais pas, mais elle est de toute façon très facile à écrire soit-même

int    wordtab_iznogood(char c)
{
  if (c < '0' || c > '9')
    {
      if (c < 'A' || c > 'Z')
    {
      if (c < 'a' || c > 'z')
        return (1);
    }
    }
  return (0);
}

int    count_words(char *str)
{
  int    result;
  int    flag;
  int    cursor;

  cursor = 0;
  result = 0;
  flag = 1;
  while (str[cursor] != '\0')
    {
      if (wordtab_iznogood(str[cursor]) == 1)
      flag = 1;
      else
    {
      if (flag == 1)
        result = result + 1;
      flag = 0;
    }
      cursor = cursor + 1;
    }
  return (result);
}

int    count_chars(char *str)
{
  int    x;
 
  x = 0;
  while (str[ x ] != '\0')
    {
      if (wordtab_iznogood(str[ x ]) == 1)
    return (x);
      x = x + 1;
    }
  return (x);
}

char    **my_str_do_wordtab(char *str, char **result, int z, int x)
{
  int    y;

  y = 0;
  while (str[ x ] != '\0')
    {
      if (z < 1)
        result[y] = malloc(sizeof(char) * (count_chars(&str[ x ])));
      if (wordtab_iznogood(str[ x ]) == 1)
        {
          if (z < 1)
            y = y - 1;
          else
            result[y][z] = 0;
          y = y + 1;
          z = -1;
        }
      else
        result[y][z] = str[ x ];
      x = x + 1;
      z = z + 1;
    }
  result[y + 1] = malloc(sizeof(char));
  result[y + 1][0] = 0;
  return (result);
}

char    **my_str_to_wordtab(char *str)
{
  char    **result;

  result = malloc(sizeof(char*) * count_words(str) + 1);
  result = my_str_do_wordtab(str, result, 0, 0);
  return (result);
}

int     my_show_to_wordtab(char **tab)
{
  int   cursor;
  int   nbr_elem;

  cursor = 0;
  nbr_elem = 0;
  while (tab[cursor][0] != 0)
    {
      nbr_elem = nbr_elem + 1;
      cursor = cursor + 1;
    }
  cursor = 0;
  while (cursor < nbr_elem)
    {
      my_putstr(tab[cursor]);
      my_putchar('\n');
      cursor = cursor + 1;
    }
  return (0);
}

Oui, c'est comme pour nounours ! Le début de la phrase, c'est basique, c'est le premier sens qu'on donne à chacun lorsqu'on lit ce genre de chose...
Par contre il semble que le mot de passe soit beaucoup plus subtile... déjà pour le 2 j'ai galeré, mais google, wikipedia, ce sont nos amis ! Cela dit, même avec les deux solutions possibles, je ne trouve toujours pas... j'ai même essayé de remplacer un peu tout ça mais non, je trouve pas !