Programme des cours 2019-2020
BINV1010-1  
Algorithmique
  • Théorie
  • Exercices
Durée :
Théorie : 24h Th
Exercices : 48h Pr
Nombre de crédits :
Bachelier en informatique de gestion6
Nom du professeur :
Théorie : Grégory SERONT
Exercices : Grégory SERONT
Coordinateur(s) :
Emmeline LECONTE, Grégory SERONT
Langue(s) de l'unité d'enseignement :
Langue française
Organisation et évaluation :
Enseignement au premier quadrimestre, examen en janvier
Unités d'enseignement prérequises et corequises :
Les unités prérequises ou corequises sont présentées au sein de chaque programme
Contenus de l'unité d'enseignement :
Apprendre les fondements de la programmation structurée:


  • variables
  • alternatives
  • boucles
  • tableaux
Développer un raisonnement logique et algorithmique.   Voir quelques algorithmes incontournables.   La programmtion orientée objet sera utilisée, mais ses fondements seront présentés dans une autre UE.   Le langage utilisé sera le Java.
Théorie
- Les notions de base : programme, input, output, variable, ... - Les méthodes - Les alternatives - Les répétitives - Les tableaux à une dimension - Les algorithmes classiques sur les tables - Les algorithmes de tri - Les tableaux à plusieurs dimensions
Exercices
Cf. BINV1010 A - Théorie.
Acquis d'apprentissage (objectifs d'apprentissage) de l'unité d'enseignement :
  • Fournir du code correct, performant, lisible et qui correspond exactement à ce qui est demandé dans un énoncé donné en français.
  • Tester son code en constituant un jeu de tests pertinents.
  • Choisir de façon pertinente le nom des variables, méthodes et classes pour obtenir du code auto-commenté.
  • Choisir le type des répétitives de façon adaptée au contexte.
  • Lire du code manipulant des variables : initialisation, assignation, utilisation dans une expression et en déduire l'état de ces différentes variables suite à son exécution.
  • Ecrire du code manipulant des variables : initialisation, assignation, utilisation dans une expression de façon à répondre à un problème exprimé en français.
  • Construire une expression booléenne correspondant à une condition exprimée en français.
  • Lire du code contenant une ou plusieurs alternatives (imbriquées ou pas) :
  •                - Déduire quelle branche sera exécutée                - Déduire l'état des différentes variables  Construire de façon correcte et claire une alternative et pouvoir les imbriquer :
  •                - Trouver la/les conditions booléennes correspondantes au problème                                exprimé en français                - Pouvoir écrire la condition inverse  Ecrire une séquence d'instructions de façon à résoudre un problème exprimé en français.
  • Lire du code contenant une ou plusieurs répétitives (imbriquées ou pas) :
            - Déduire quand le corps de l'alternative sera exécuté et quand on en sortira             - Exprimer dans les cas simples la condition à l'intérieur de la boucle (invariant)             - Exprimer dans les cas simples la condition à la sortie de la boucle (post condition)  
  • Construire de façon correcte et claire une répétitive et pouvoir les imbriquer :
             - Déduire à partir d'un énoncé en français              - Trouver la/les conditions booléennes correspondantes              - Les initialisations de variable à effectuer avant d'entrer dans la boucle              - Le traitement à effectuer dans le corps de la boucle  
  • Lire du code mettant en œuvre le mécanisme d'appel de méthode : passage de paramètres, variables locales, valeur de retour :
             - Déduire les valeurs des variables lors de l'appel              - Déduire les valeurs des variables après l'appel              - Détecter les cas d'erreurs  
  • Mettre en œuvre le mécanisme d'appel de méthode : passage de paramètres, variables locales, valeur de retour.
  •             - A partir d'un énoncé en français             - Subdiviser un problème en sous-problèmes             - Associer chacun de ces sous problèmes à une méthode             - Identifier les paramètres à passer aux méthodes             - Identifier ce que doivent retourner les méthodes             - Ecrire chaque méthode  
  • Lire du code manipulant des tableaux : initialisation, assignation, utilisation dans une expression et en déduire l'état de ces différentes variables suite à son exécution.
  • Ecrire du code manipulant des tableaux : initialisation, assignation, utilisation dans une expression de façon à répondre à un problème exprimé en français.
  • Comprendre et adapter les algorithmes donnés sur les tableaux non triés afin de répondre à un énoncé en français :
             - Recherche d'un élément              - Insertion d'un élément              - Suppression d'un élément              - Calculs simples (moyenne etc)  
  • Comprendre et adapter les algorithmes donnés sur les tableaux triés afin de répondre à un énoncé en français :
           - Algorithme de tri            - Recherche d'un élément            - Insertion d'un élément            - Suppression d'un élément  
  • Trouver soi-même des algorithmes efficaces sur les tables.
Savoirs et compétences prérequis :
Activités d'apprentissage prévues et méthodes d'enseignement :
Activités        Intitulé de l'activité    Volume horaire BINV1010 A     Théorie                                  24 BINV1010 B     Exercices                               48
Mode d'enseignement (présentiel ; enseignement à distance) :
Un cours théorique de 2h et 2 séances d'exercices de 2h sont prévus chaque semaine (12 semaines au total). 12h de remédiation seront proposées au cours de l'année.   Le cours théorique présente les concepts théoriques. Ceux-ci sont illustrés par un grand nombre d'exemples. Le professeur résout en direct des applications en commentant sa démarche. Les étudiants sont actifs pendant ce cours qui se veut le plus interactif possible. Les exercices se déroulent en salles machines.   La plupart des exercices sont des exercices de programmation. Le langage de programmation est le Java. Les professeurs qui encadrent les exercices ne sont pas là pour donner des solutions à des problèmes. Ils essayent d'amener l'étudiant à trouver lui-même les solutions.
Théorie
Un cours théorique de 1h30 estt prévu chaque semaine (12 semaines au total).   Le cours théorique présente les concepts théoriques. Ceux-ci sont illustrés par un grand nombre d'exemples. Le professeur résout en direct des applications en commentant sa démarche. Les étudiants sont actifs pendant ce cours qui se veut le plus interactif possible. Les exercices se déroulent en salles machines.
Exercices
Deux séances d'exercices de 2h sont prévues chaque semaine (12 semaines au total).   La plupart des exercices sont des exercices de programmation. Le langage de programmation est le Java. Les professeurs qui encadrent les exercices ne sont pas là pour donner des solutions à des problèmes. Ils essayent d'amener l'étudiant à trouver lui-même les solutions.
Lectures recommandées ou obligatoires et notes de cours :
Théorie
Syllabus (indispensable).
Exercices
Syllabus (indispensable)   Fiches d'exercices (indispensable)
Modalités d'évaluation et critères :
Responsable de l'évaluation: SERONT Grégory   Langue de l'évaluation: Français   Mode d'évaluation: Examen écrit, Travail individuel, Travail de groupe Feux rouges/oranges/verts Durant le cours, les professeurs présenteront une série d'erreurs graves qu'un étudiant ayant acquis les compétences de l'UE ne peut absolument pas commettre. Ces erreurs constituent des « feux rouges ». De plus une série d'erreurs moins graves mais montrant tout de même un manque de maîtrise de l'algorithmique seront également relevées. Ces erreurs constituent des « feux oranges.   Evaluation continue (15%)
L'évaluation continue est constituée de 3 composantes : - Les soumissions d'exercices - Les projets - Les interrogations
Soumissions d'exercices Chaque semaine, tous les exercices proposés devront être soumis sur la plateforme d'apprentissage en ligne dans les délais prescrits. Les professeurs corrigeront un échantillon de ces exercices et noteront.
Les correcteurs indiqueront un feu rouge ou orange si l'une des erreurs (moins) graves définies au cours de l'année.
Interrogations Au cours de l'année une ou plusieurs interrogations seront organisées. Celles-ci seront évaluées selon les mêmes modalités que les soumissions.   Projets Durant l'année, plusieurs projet seront proposés. Ceux-ci seront réalisés par groupe de deux étudiants. Chaque projet sera réalisé en séance et la présence sera donc obligatoire.  Une défense individuelle de certains de ces projets pourra être organisée.
Examen (85%) L'examen est un examen écrit sur PC. Il se déroule à livre fermé. Il comporte 2 parties : - Pour la première partie, l'étudiant complète un questionnaire sans pouvoir utiliser le PC. Il peut y avoir plusieurs types de question:
  • compléter des parties de code, donner le résultat suite à l'exécution d'un code, évaluer le coût d'une méthode, trouver une erreur dans un code et la corriger, donner les spécifications d'une méthode. Ces questions sont d'un niveau de complexité relativement simple et font appel uniquement à des notions de bases qui si elles ne sont pas au moins maitrisées passivement empêchent l'étudiant d'écrire un programme correct.
  • Pour la 2ème partie de l'examen, l'étudiant programme en Java sur PC une ou plusieurs (parties d') applications sur base d'un énoncé en français.
Lors de la correction, chaque question sera corrigée séparément. Pour chacune de celles-ci le professeur donnera une cote. En plus de celle-ci les correcteurs indiqueront un feu rouge ou orange si au moins une des erreurs (moins) graves définies au cours de l'année a été commise.   En cas de feu rouge ou d'accumulation de feux oranges la note de l'UE sera automatiquement ramenée à 9,5. Un 9,5 sera délibéré par l'ensemble des intervenants du cours qui décideront de la validation ou non de l'UE.
Stage(s) :
Remarques organisationnelles :
Compétence(s) - Capacité(s): C1 - S'insérer dans son milieu professionnel et s'adapter à son évolution CA1.2 -Collaborer à la résolution de problèmes complexes avec méthode, rigueur, pro activité et créativité C3 - Mobiliser les savoirs et les savoir-faire propres à l'informatique de gestion CA3.1 -Concevoir, implémenter et maintenir des algorithmes répondant aux spécifications et fonctionnalités fournies CA3.4 -Concevoir, implémenter, administrer et utiliser avec maîtrise un ensemble structuré de données C4 - Analyser les données utiles à la réalisation de sa mission en adoptant une démarche systémique CA4.4 -Prendre en compte la problématique de sécurité des applications   Acquis d'apprentissage(s) terminaux visé(s): - Acquis d'apprentissage terminaux : AAT1. Concevoir des solutions informatiques efficaces qui répondent à des problèmes en maitrisant les structures de données véhiculées. C1-CA1.2 ; C3-CA3.1 et CA3.4 ; C4-CA4.4 * PROGRAMMATION ( AAT1) - Acquis d'apprentissage terminaux : AAT5. Se conformer aux bonnes pratiques du métier tout en restant critique. C1-CA1.4 ; C3-CA3.2 et CA3.5 ; C4-CA4.2 et CA4.3 et CA4.5 ; C5-CA5.3; C5-CA5.4 * QUALITE ( AAT5)
 
Evaluation:
L'évaluation de cette U.E. est intégrée et constitue dès lors un tout indécomposable. Celle-ci donne lieu à une seule note ; il n'y a pas d'évaluation d'AcA ni de note pour les AcA. Cela exclut automatiquement : toute dispense partielle issue d'une année antérieure, toute dispense partielle au sein de l'année académique, toute dispense partielle acquise cette année pour les années à venir. De même si une UE est composée d'AcA dont certaines sont intégrées, il n'y a pas de dispense partielle d'une évaluation intégrée.   La note finale de l'UE est délibérée par les professeurs impliqués dans l'évaluation de celle-ci. En cas de lacune importante dans un ou plusieurs acquis d'apprentissage spécifique à l'UE, le jury de délibération se réserve le droit de ne pas valider l'UE ; càd d'attribuer une note d'UE différente de la moyenne mathématique. Cette décision fera l'objet d'une justification de la part des professeurs.  
Information(s) complémentaire(s):
12h de remédiation seront proposées au cours de l'année.
Contacts :