Master algorithms for clean Java code

Définir ce qu'est un algorithme et identifier ses composantes (entrée, traitement, sortie).

Identifier et utiliser les types de données de base (entier, réel, caractère, booléen).

Déclarer des variables, leur assigner des valeurs et comprendre leur rôle en pseudo-code.

Écrire des expressions arithmétiques et logiques en utilisant les opérateurs appropriés.

Tracer manuellement l'exécution d'un algorithme simple pour en suivre le déroulement.

Concevoir un algorithme séquentiel simple pour résoudre un problème de calcul (ex: calcul d'une moyenne).

Utiliser la structure 'Si...Alors...Sinon' pour exécuter du code en fonction d'une condition.

Imbriquer des structures conditionnelles ('Si...SinonSi...Sinon') pour gérer des cas multiples.

Combiner plusieurs conditions en utilisant les opérateurs logiques (ET, OU, NON).

Résoudre un problème pratique dont la logique repose sur des choix (ex: déterminer si une année est bissextile).

Appliquer des conditions pour résoudre un problème de calcul (ex: calculer un prix après remise).

Utiliser une boucle 'Pour' afin de répéter une action un nombre de fois prédéterminé.

Utiliser une boucle 'Tant que' pour répéter une action tant qu'une condition est vraie.

Choisir le type de boucle le plus approprié (Pour, Tant que) en fonction du problème.

Manipuler des compteurs et des accumulateurs à l'intérieur d'une boucle pour calculer des sommes ou des totaux.

Imbriquer des boucles pour traiter des données à deux dimensions (ex: afficher une table de multiplication).

Identifier la cause d'une boucle infinie et la corriger.

Résoudre un problème de calcul de série en utilisant une boucle (ex: factorielle, suite de Fibonacci).

Déclarer un tableau à une dimension et accéder à ses éléments via leur index.

Parcourir un tableau avec une boucle pour lire, modifier ou traiter ses éléments.

Calculer la somme et la moyenne des éléments d'un tableau.

Trouver la valeur minimale et maximale dans un tableau.

Manipuler une chaîne de caractères comme un tableau de caractères pour en extraire des informations (longueur, caractère à un index).

Construire une nouvelle chaîne par concaténation de caractères ou de sous-chaînes.

Parcourir une chaîne de caractères pour résoudre un problème (ex: compter les voyelles, vérifier un palindrome).

Définir une fonction (ou procédure) avec des paramètres pour encapsuler une tâche spécifique.

Appeler une fonction et utiliser sa valeur de retour dans l'algorithme principal.

Distinguer la portée des variables locales (à une fonction) et globales.

Expliquer la différence entre le passage de paramètres par valeur et par référence.

Appliquer la modularité pour concevoir un programme simple (ex: conversion de devises avec des fonctions pour la saisie, le calcul et l'affichage).

Déclarer et manipuler un tableau à deux dimensions (matrice) en accédant aux éléments par leurs indices (ligne, colonne).

Définir le concept de Pile (Stack, LIFO) et ses opérations fondamentales (empiler, dépiler).

Utiliser une pile pour résoudre un problème simple (ex: inverser une chaîne de caractères).

Définir le concept de File (Queue, FIFO) et ses opérations fondamentales (enfiler, défiler).

Utiliser une file pour simuler un scénario de file d'attente simple.

Définir le concept de récursivité (une fonction qui s'appelle elle-même).

Écrire une fonction récursive simple pour résoudre un problème mathématique (ex: calcul de la factorielle).

Tracer l'exécution d'une fonction récursive simple à l'aide de la pile d'appels.

Comparer la solution récursive et la solution itérative (avec une boucle) pour un même problème.

Comprendre le risque de 'stack overflow' (dépassement de la pile) dans une récursivité mal contrôlée.

Implémenter l'algorithme de recherche linéaire pour trouver un élément dans un tableau non trié.

Expliquer pourquoi un tableau doit être trié avant d'utiliser la recherche dichotomique.

Implémenter l'algorithme de recherche dichotomique dans un tableau trié.

Implémenter l'algorithme du tri par sélection et tracer son exécution.

Implémenter l'algorithme du tri à bulles et tracer son exécution.

Implémenter l'algorithme du tri par insertion et tracer son exécution.

Comparer intuitivement l'efficacité des algorithmes de recherche (linéaire vs dichotomique) et de tri simple.

Définir la complexité temporelle et son importance pour évaluer l'efficacité d'un algorithme.

Identifier les opérations élémentaires d'un algorithme pour en estimer le coût.

Définir la notation Big O (O) pour décrire la croissance du temps d'exécution.

Classer des algorithmes par ordre d'efficacité en se basant sur leur complexité Big O.

Évaluer l'impact de la taille des données d'entrée sur le temps d'exécution d'un algorithme.

Expliquer le principe 'Diviser pour Régner' comme stratégie algorithmique.

Implémenter l'algorithme du tri fusion (Merge Sort) en utilisant une approche récursive.

Analyser la complexité du tri fusion (O(n log n)) et la comparer à celle des tris simples.

Définir le concept de liste chaînée (nœud, pointeur/référence) et son avantage par rapport aux tableaux pour l'insertion/suppression.

Décrire les opérations d'ajout et de suppression d'un élément dans une liste chaînée.

Choisir entre un tableau et une liste chaînée en fonction des contraintes d'un problème.

Définir le concept d'arbre binaire de recherche et expliquer comment il permet une recherche efficace.

Appliquer une méthode structurée pour analyser un problème : identifier les entrées, les sorties et les contraintes.

Choisir une stratégie algorithmique pertinente (parcours, tri, recherche, récursivité, diviser pour régner).

Concevoir des cas de test pour valider un algorithme, en incluant les cas nominaux et les cas limites.

Identifier une solution 'brute-force' à un problème et évaluer sa complexité.

Appliquer une technique d'optimisation (ex: tri préalable des données) pour améliorer un algorithme inefficace.

Analyser le gain en complexité obtenu après optimisation d'un algorithme.

Analyser un cahier des charges complet et le décomposer en sous-problèmes et fonctionnalités.

Modéliser les données du problème en choisissant les structures de données appropriées et en justifiant ses choix.

Concevoir l'architecture modulaire du programme en définissant les fonctions nécessaires et leurs interactions.

Écrire en pseudo-code l'algorithme complet, en implémentant toutes les fonctions définies.

Valider la logique de l'algorithme en le traçant manuellement avec un jeu de données de test.

Rédiger une documentation claire de la solution, expliquant le pseudo-code et les choix de conception.

Présenter et justifier oralement sa solution algorithmique.