############### Commentaires généraux ############### Le rapport PDF doit décrire le fonctionnement des algorithmes (quand c'est un algorithme connu il suffit d'en rappeler les grandes lignes) et les différents choix d'implémentation comme les structures de données utilisées. Il est aussi pertinent de décrire le formatage de la sortie du programme. Quelles sont les clefs de la table ? À quoi correspondent-elles ? Quel est le contenu de la table ? Donnez le sens de remplissage de la table (en biais vs en ligne, ou autre). Certains ont trop tendance à se focaliser sur des exemples, sans penser à aussi généraliser. Comme il est très rare de prendre un exemple qui arrive à rendre compte de toutes les subtilités du problème ou de l'algorithme étudié, il est souvent (voire toujours) indispensable de généraliser. Ce n'est pas indispensable, mais il est une bonne idée de prendre l'habitude d'écrire les rapports en LaTeX (il suffit de s'y mettre, c'est laborieux la première fois mais ça devient très pratique par la suite — de toute façon vous risquez d'être obligés de vous y mettre bientôt). Les graphiques accompagnant les explications ont été très appréciés. Si votre code utilise une hypothèse non spécificiée dans l'énoncé (par exemple « les terminaux sont des lettres minuscules »), il est impératif de le préciser dans le rapport PDF. Ceci dit, il est très peu probable que vous ayez vraiment besoin d'une telle hypothèse supplémentaire. Commentez abondamment votre code, en expliquant la signification des variables importantes ainsi que les indices de chaque boucle. Soyez concis. Vérifiez que tous les tests ont effectivement un sens. Astuce : quand on a un dictionnaire Python t, la méthode t.get(i, []) renvoie t[i] si cet élément existe, ou [] sinon. Ceci aurait pu être utile à beaucoup de monde (ça permet de s'épargner de mettre des [] dans les cases vides ou de faire certains tests durant les algorithmes - certains d'entre vous ont des bugs à cause de ça, alors que j'avais donné cette commande au tableau). ############### Notes et commentaires individuels ############### Remarque : les remarques que j'ai mis pour certains s'appliquent aussi souvent à d'autres, donc n'hésitez pas à regarder les commentaires de toute la classe pour mieux comprendre votre note. Benballa : 13 — Il y a des petites choses inutiles, comme par exemple la boucle sur les règles de la grammaire dans la fonction intepretation qui n'est pas nécessaire (il suffit de vérifier que, dans la bonne case de la table, il y a une règle de partie gauche l'axiome, sans s'occuper de la partie droite). — affiche_arbre me parait excessivement compliquée, les explications ne sont pas assez claires et l'algorithme n'est pas correct. On le voit sur l'exemple suivant : g = [("S", "c"), ("A", "SA"), ("S", "SA"), ("S", "b"), ("A", "a")]; w = "baa"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; qui renvoie « S --> SA --> SAA --> SAAA --> bAAA --> baAA --> baaA » — De plus, la fonction n'affiche pas vraiment un arbre mais une suite de proto-mots. Il faudrait expliquer comment retrouver l'arbre à partir de cette suite. Benichou : 16.5 — L'idée de l'initialisation est de traiter les règles unaires/lexicales (elles ne sont pas censées être un cas spécial dans la boucle de remplissage). — La sortie pourrait être plus lisible (même si toutes les informations sont là). — Le rapport manque d'explication. — Manque de commentaires dans le code. Benisty : 7.5 — Pas de rapport PDF. — Erreur lors de l'execution ; c'est dommage, c'est une toute petite erreur (à part un petit détail, les algorithmes de remplissage de la table sont bons). — Code incomplet. Boyomo : 14 — Efforts sur le rendu. — Il manque par contre des commentaires dans le code. — Efforts sur le formatage la sortie du code (peut-être un peu trop verbeux par contre). — Votre code considère que les terminaux sont des lettres minuscules et que les non terminaux sont des lettres majuscules. Cette hypothèse est non seulement injustifiée, mais n'apparait nulle part dans votre rapport PDF. — Vous parlez d'ambiguïtés et retirez certains éléments dans la table, qui n'est donc plus la table CYK. Le pire c'est que du coup l'algorithme n'est pas bon ! On le voit sur l'exemple suivant : g = [("S", "AB"), ("A", "AB"), ("A", "a"), ("B", "b")]; w = "ab"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre2(T, w, g); else: print "pas ok"; Chailloux : 13 — Les explications sont trop succintes. Que représente le tableau ? Comment le rempli-t-on ? etc — Manque de commentaires (que représentent les indices des boucles, notamment). — L'algorithme ne marche pas (il y a une erreur dans la fonction boucle). Par exemple avec : g = [("S", "SA"), ("A", "AB"), ("S", "AA"), ("B", "b"), ("A", "a")]; w = "aaab"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; — Bonne représentation des arbres. Cordova : 16.5 — Il est très bien d'avoir décrit dans le rapport PDF les différentes structures, mais il manque encore des choses (ex : les valeurs de T sont des règles, mais lesquelles ?). — Il manque des explications sur le fonctionnement de la fonction boucle. — Il manque des commentaires dans le code. — À quoi sert z dans boucle ? (à mon avis à rien) Kerboeuf : 11  — Travail rendu en retard — Les explications du rapport sont trop succintes. — Il y a des commentaires intéressants dans le code, mais il en manque décrivant le contenu des variables. — affiche_arbre n'est absolument pas juste du tout. On le voit d'ailleurs sur l'exemple suivant : g = [("S", "AB"), ("A", "AB"), ("A", "a"), ("B", "b")]; w = "ab"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; Laudrin : 19 — Sortie agréable. — Code bien commenté et structuré. — Il manque quelques explications. Par exemple dire que le paramètre children des items distingue ici les éléments "terminaux", correspondant aux règles lexicales, de ceux associés aux règles binaires (ce n'est pas évident car on peut très bien s'en sortir sans jamais utiliser un tel paramètre children), ou expliciter dans quel ordre on remplit la table. Leveque : 11 — Le rapport PDF est quasiment vide, alors qu'il est censé décrire le fonctionnement des algorithmes et les différents choix d'implémentation comme les structures de données utilisées (c'est justement lui qui donne « plus de précision » ou « plus de détails » que le code). — Il manque aussi des commentaires dans le code (sur les indices des boucles, par exemple). — Malgré ce que vous m'avez dit, je doute que le code soit en Python 3.5, car il s'execute correctement avec python 2.7 mais pas avec 3.4. De toute façon ce serait typiquement le genre de choses à mettre dans le rapport PDF et pas ailleurs. — Le code ne s'exécute pas à cause d'une mention à g3 oubliée par erreur (la moindre des choses est quand même d'exécuter le code avant me l'envoyer). — Il y a des choses inutiles ; par exemple dans "if len(droite) == 1 and self.mot[i]==droite:" le premier test ne sert à rien (et ça obscurcit le code). Je pense aussi que retournerGrammaire ne sert à rien du tout (et vous ne l'expliquez pas). — Le programme n'arrive pas à reconstruire correctement l'arbre. Par exemple avec : g = [("S", "AB"), ("A", "AB"), ("A", "a"), ("B", "b")]; w = "ab"; cykParsing = CYK(w,g) if cykParsing.interpretation(): print("Le mot << {0} >> est généré par la grammaire.".format(w)) cykParsing.affiche_arbre() else: print("Le mot << {0} >> N'est PAS généré par la grammaire.".format(w)) Li : 19 — Les explications des algorithmes sont bonnes. — Il manque des détails sur les structures de données (quelle structure est utilisée pour représenter la table, et quelles structures contient-elle ?). — Le code pourrait être plus commenté (il est normal que les commentaires refletent ce qui est dit dans le rapport). — Code simple, clair et efficace (très bien). Martinez : 12 — rapport PDF trop succint. — Code peu suffisamment commenté. — L'alorithme de construction de l'arbre n'est pas bon. Par exemple avec : g = [("S", "c"), ("A", "SA"), ("S", "SA"), ("S", "b"), ("A", "a")]; w = "baa"; print "mot " + w + " :"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; Messeguem : 11 — Bon effort sur les explications, même si elles ne sont pas toujours exactes, et parfois pas assez « haut-niveau » (c'est-à-dire axées sur le fonctionnement global des algorithmes). — Attention, on n'a aucune raison de supposer que l'axiome est toujours 'S' (d'où la fonction axiome(gr) donnée dans le canevas) ; au pire il faudrait explicitement dire que l'on fait cette hypothèse. — Il y a un problème dans la fonction interpretation, du coup le résultat est faux, pour par exemple : g = [("S", "AB"), ("A", "AB"), ("A", "a"), ("B", "b")]; w = "ab"; print "mot " + w + " :"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; — La reconstruction de l'arbre n'est pas implémentée. Michard : 0 — Rien n'est fait (sauf quelques lignes dans la fonction init, mais qui n'est pas correcte). Narciso Viegas : 14 — Efforts sur l'explications, même si elles collent un peu trop à un exemple donné (il aurait été préférable de généraliser), et qu'elles manquent parfois de précision. — Il manque les explications sur la construction de l'arbre. — Code plutôt bien commenté. — Le code a un petit bug (la variable "chaine" a été remplacé sans raison apparente par un "s" dans affiche_arbre) (il aurait fallu s'assurer que le code est exécutable avant me l'envoyer). — L'algorithme d'affichage de l'arbre n'est pas bon. Par exemple avec : g = [("S", "SA"), ("A", "AB"), ("S", "AA"), ("B", "b"), ("A", "a")]; w = "aaab"; print "mot " + w + " :"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; Sabino : 12 — Rapport PDF bien présenté, mais incomplet. — Les explications sont assez vagues et ambiguës. Par exemple, quand vous dites « la lettre » ou « une case », de quelle lettre ou de quelle case s'agit-il ? De la même manière, quand vous parlez des trois indices y, i et j, c'est trop vague. — Vous n'expliquez pas comment on remplit la table. — Idem pour la reconstruction de l'arbre syntaxique. — Le code n'est pas correctement commenté. — L'algorithme d'affichage de l'arbre n'est pas bon. Par exemple avec : g = [("S", "SA"), ("A", "AB"), ("S", "AA"), ("B", "b"), ("A", "a")]; w = "aaab"; print "mot " + w + " :"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; Segonne : 12 — Les explications sont parfois incomplètes (Ex : dans 2.1, il y a des règles dans les cases, mais lesquelles ? et que sont les adresses mentionnées ?). — Le code manque aussi de commentaires. — Attention, on n'a aucune raison de supposer que l'axiome est toujours 'S' (d'où la fonction axiome(gr) donnée dans le canevas) ; au pire il faudrait explicitement dire que l'on fait cette hypothèse. — Dommage qu'il n'y ait pas la construction de l'arbre. — La fonction interpretation ne marche pas. Par exemple avec : g = [("S", "c"), ("A", "SA"), ("S", "SA"), ("S", "b"), ("A", "a")]; w = "baa"; print "mot " + w + " :"; T = parsing(w, g); print T; if interpretation(T, w): print "ok"; else: print "pas ok"; Sung : 0 Tieberghien : 13.5 — Les explications sont incomplètes et manquent de généralité. — Manque de détails lié à l'implémentation. — Code bien commenté. — La construction de l'arbre n'est pas vraiment expliquée ; d'ailleurs la sortie est une liste de règles (donc a priori pas un arbre). De plus l'algorithme n'est pas correct ! (Si A --> BC, on ne doit pas chercher B et C indépendamment l'un de l'autre.) Pour preuve, on a un résultat bizarre avec : g = [("S", "SA"), ("A", "AB"), ("S", "AA"), ("B", "b"), ("A", "a")]; w = "aaab"; T = parsing(w, g); if interpretation(T, w, g): print "ok"; affiche_arbre(T, w, g); else: print "pas ok"; Zhao : 14.5 — Dommage que le code rendu ne soit pas commenté ! Il est normal que les commentaires du code reflètent les explications du rapport. — L'initialisation bizarre des cases n'est pas des plus élégantes (mais ce n'est pas très grave pour ce cours). — Les explications sont bonnes. — Dommage pour la construction de l'arbre (il ne faut notamment pas oublier que si on a A --> BC c'est qu'il existe un indice k qui sépare le sous-mot engendré par B et celui engendré par C).