Cours avec Coddy

Choisis ce que tu veux apprendre : Coddy, t'écrit le cours en direct, avec des exemples de programmes à copier et à tester. Tu avances à ton rythme, et tu peux faire une pause quand tu veux.

100

Cours

Thèmes

Intelligence artificielle

Coddy En ligne

Partager le cours

Coddy a besoin de JavaScript pour écrire ses cours en direct. Voici le contenu du cours sous forme de texte.

Premiers pas : afficher — Écrire ses premiers programmes : afficher du texte et des nombres, l'ordre des instructions, les commentaires.

Les variables et les types — Déclarer une variable avec son type, lui donner une valeur, la modifier : nombre, texte, booléen.

Calculs, comparaisons et constantes — Les opérateurs de calcul, le reste de la division, les comparaisons, et, ou, non, et les constantes.

Dialoguer avec l'utilisateur — Poser une question avec demande, proposer un menu avec choisir, et rendre un programme interactif.

Les conditions — Faire des choix dans un programme : si, alors, sinon si, sinon, et la sélection multiple avec selon.

Les boucles — Répéter des instructions : répète, pour, tant que, et comment sortir d'une boucle.

Le hasard — Tirer un nombre ou un mot au hasard, lancer des dés, mélanger une liste : le hasard rend les programmes vivants.

Soigner l'affichage : couleurs et titres — Colorer un texte dans la console avec couleur, ajouter des titres et des listes avec html.

Les fonctions mathématiques — Racine, puissance, arrondis, minimum, maximum : les fonctions de calcul toutes prêtes de CoddyRun.

Trouver et corriger ses erreurs — Une méthode pour corriger un programme qui ne marche pas : déboguer, exécution pas à pas, points d'arrêt.

Les booléens et la logique — Vrai ou faux : ranger une condition dans une variable, combiner avec et, ou, non, et simplifier ses tests.

Écrire un code clair — Des noms qui ont du sens, une indentation régulière, des commentaires utiles, des constantes : un code que l'on comprend.

Les dix erreurs du débutant — Les pièges dans lesquels tout le monde tombe en débutant avec CoddyRun, et comment les éviter.

Les boucles imbriquées — Une boucle dans une boucle : dessiner des motifs, afficher toutes les tables, parcourir toutes les combinaisons.

Faire attendre le programme — Mettre des pauses pour rythmer l'affichage : compte à rebours, barre de progression, suspense.

Créer un programme à menu — Proposer plusieurs actions, exécuter celle qui est choisie et revenir au menu jusqu'à ce que l'utilisateur quitte.

Calculer avec les pourcentages — Réductions, augmentations, TVA, taux de réussite : programmer les calculs de pourcentage sans se tromper.

Comparer des textes — Tester si deux textes sont égaux, ignorer les majuscules et les espaces, classer des mots par ordre alphabétique.

Les conditions imbriquées — Une condition dans une autre condition : construire un arbre de décision et savoir quand le simplifier.

Lire une série de valeurs — Saisir des valeurs jusqu'à un signal d'arrêt, les compter, les additionner, garder la plus grande : la boucle de saisie.

Travailler avec les textes — Longueur, majuscules, extraire un morceau, chercher, remplacer, découper un texte : les outils du texte.

Les tableaux — Ranger plusieurs valeurs dans une seule variable : ajouter, lire par index, parcourir, calculer.

Les dictionnaires — Associer des clés à des valeurs : un répertoire, des scores par joueur, des traductions.

Les enregistrements — Regrouper les informations d'une même chose sous un seul nom, avec des champs : eleve.nom, eleve.age.

La boîte à outils des tableaux — Trier, mélanger, retirer les doublons, chercher une valeur, calculer une somme ou une moyenne : les fonctions prêtes à l'emploi.

Les tableaux à deux dimensions — Représenter une grille avec des lignes et des colonnes : plateau de jeu, table de multiplication, carte.

Convertir et tester les types — Passer d'un texte à un nombre et inversement, vérifier le type d'une valeur, choisir entre deux valeurs avec sialors.

Analyser une phrase — Découper une phrase en mots, trouver le plus long, fabriquer un sigle, inverser l'ordre des mots.

Gérer une liste de fiches — Garder plusieurs informations par élément avec des tableaux parallèles : afficher, chercher, ajouter, supprimer, trier.

Compter avec un dictionnaire — Dépouiller un vote, compter les lettres d'un texte, trouver l'élément le plus fréquent : le dictionnaire comme compteur.

Les piles et les files — Deux façons d'organiser des données : dernier arrivé, premier sorti (pile) ou premier arrivé, premier sorti (file).

Chercher et remplacer dans un texte — Trouver où se cache un morceau de texte, découper autour, remplacer ou retirer des caractères, remplir un modèle.

Un inventaire avec un dictionnaire — Tenir un stock à jour : ajouter, retirer, vérifier la disponibilité, lister, calculer une valeur totale.

Filtrer et transformer un tableau — Fabriquer un nouveau tableau à partir d'un autre : ne garder que certains éléments, les modifier tous, supprimer sans se tromper.

Présenter des résultats — Aligner des colonnes, tracer des lignes de séparation, arrondir les nombres : des affichages nets et lisibles.

Les caractères et leurs codes — Chaque caractère a un numéro : fabriquer l'alphabet avec une boucle, passer des majuscules aux minuscules, reconnaître lettres et chiffres.

Les fonctions — Créer ses propres fonctions : paramètres, retourne, variables locales, et renvoyer plusieurs valeurs.

Les procédures — Regrouper des instructions sous un nom et les lancer avec appelle : découper un programme en morceaux.

Les classes et les objets — Définir une classe, créer plusieurs objets, écrire des fonctions et des procédures de classe (CoddyRun v4.3).

Gérer les erreurs — Lire un message d'erreur, protéger un programme avec essayer / attraper, vérifier une saisie.

La récursivité — Une fonction qui s'appelle elle-même : le cas d'arrêt, la factorielle, la suite de Fibonacci et les tours de Hanoï.

Garder des données d'une exécution à l'autre — Mémoriser un meilleur score, un réglage ou un prénom entre deux lancements du programme avec la fonction paramètre.

Découper un programme en morceaux — Transformer un long programme en petites fonctions et procédures bien nommées : la méthode pour s'y retrouver.

Vérifier les saisies — Des fonctions qui répondent vrai ou faux pour contrôler une saisie, et une fonction qui redemande tant que la réponse est incorrecte.

Tester ses fonctions — Vérifier qu'une fonction donne les bons résultats avec des tests : cas normaux, cas limites, et la chasse aux bugs.

Des fonctions qui s'appellent entre elles — Construire de grandes fonctions avec de petites : chaque fonction s'appuie sur les précédentes, comme des briques.

Les classes en pratique : une boutique — Mettre les classes au travail sur un cas concret : plusieurs produits, des fonctions de classe pour calculer et afficher.

Variables locales et globales — Où une variable existe-t-elle ? Variables du programme principal, variables d'une fonction, paramètres : éviter les mauvaises surprises.

Écrire des fonctions solides — Prévoir le tableau vide, la division par zéro et l'index impossible : des fonctions qui ne plantent pas dans les cas difficiles.

Du brouillon au programme propre — Améliorer pas à pas un programme qui marche : supprimer les répétitions avec une boucle, une fonction, puis des constantes.

Qu'est-ce qu'un algorithme ? — Comprendre ce qu'est un algorithme, ses trois briques (séquence, choix, répétition) et passer d'une idée à un programme.

Compteurs, accumulateurs et drapeaux — Les trois techniques de base de l'algorithmique avec une boucle : compter, accumuler, signaler.

Chercher dans un tableau — Trouver le maximum, chercher une valeur, et la recherche par dichotomie dans un tableau trié.

Trier un tableau — Comprendre comment on range des valeurs dans l'ordre : l'échange de deux cases et le tri par sélection.

Diviseurs et nombres premiers — Trouver les diviseurs d'un nombre, tester s'il est premier, et rendre l'algorithme beaucoup plus rapide.

Le PGCD et l'algorithme d'Euclide — Le plus ancien algorithme encore utilisé : trouver le plus grand diviseur commun et simplifier une fraction.

Compter en binaire — Comment un ordinateur écrit les nombres avec seulement des 0 et des 1, et les algorithmes de conversion.

Le chiffrement de César — Écrire un message secret en décalant les lettres de l'alphabet, puis le déchiffrer : une première approche de la cryptographie.

Le tri à bulles — Un deuxième algorithme de tri, très visuel : comparer les voisins et les échanger, jusqu'à ce que tout soit en ordre.

Calculer des statistiques — Minimum, maximum, étendue, moyenne, valeurs au-dessus de la moyenne, deuxième meilleur : résumer une série de nombres.

Les suites de nombres — Somme des entiers, suite de Fibonacci avec une boucle, conjecture de Syracuse : calculer des suites terme après terme.

Multiples et crible d'Ératosthène — Le jeu du Fizz Buzz, puis une méthode vieille de 2 200 ans pour trouver tous les nombres premiers d'un coup.

Rendre la monnaie : un algorithme glouton — Rendre une somme avec le moins de pièces possible en prenant toujours la plus grosse : la stratégie gloutonne et ses limites.

Quotient, reste et conversions — Convertir des secondes en heures et minutes, des jours en semaines, extraire les chiffres d'un nombre : la division entière.

Simuler le hasard — Répéter une expérience des milliers de fois pour estimer une probabilité, et même calculer une valeur approchée de pi.

Le tri par insertion — Trier comme on range ses cartes en main : prendre chaque valeur et la glisser à sa place parmi celles déjà triées.

L'ordinateur devine ton nombre — Inverser les rôles du jeu du plus ou moins : en coupant l'intervalle en deux à chaque question, l'ordinateur trouve en 7 coups.

Palindromes et anagrammes — Reconnaître un mot qui se lit dans les deux sens, une phrase palindrome, et deux mots faits des mêmes lettres.

Les calculs du calendrier — Année bissextile, nombre de jours d'un mois, numéro du jour dans l'année, date valide : des règles précises à traduire en fonctions.

Mesurer l'efficacité d'un algorithme — Compter les opérations et chronométrer : pourquoi certains algorithmes restent rapides quand les données grossissent, et d'autres non.

Dessiner sur une toile — Créer une toile, placer des formes avec des coordonnées, des couleurs, du texte, et dessiner avec des boucles.

Animer et créer un mini-jeu — Faire bouger un dessin avec pause et effacer, réagir au clavier et à la souris sans bloquer le programme.

Dates et heures — Obtenir la date du jour, la mettre en forme, calculer avec les dates, et mesurer une durée avec chrono.

Les processus — Faire tourner une tâche en arrière-plan pendant que le programme principal continue : processus, suspendre, reprendre.

Cliquer sur une toile : créer des boutons — Attendre un clic sur une toile, savoir où l'utilisateur a cliqué et fabriquer de vrais boutons.

Tracer un graphique — Transformer des nombres en image : un diagramme en barres tout prêt, puis construit soi-même avec une boucle.

Dessiner des motifs avec des boucles — Frises, damiers, cercles concentriques, rosaces : quand les boucles et un peu de calcul dessinent à ta place.

Jouer avec les couleurs — Comprendre un code de couleur, fabriquer ses couleurs avec rgb et tls, utiliser la transparence et les dégradés.

Un formulaire sur une toile — Placer des zones de saisie et un bouton Valider sur une toile pour créer une vraie petite interface.

Dessiner avec la souris — Suivre la position de la souris en temps réel pour créer un viseur, puis un vrai programme de dessin.

Réutiliser un dessin — Ranger un dessin dans une procédure avec des paramètres pour le reproduire où l'on veut : une forêt, un village, un décor.

Une horloge animée — Lire l'heure du moment, convertir les heures, minutes et secondes en angles, et dessiner une horloge à aiguilles qui tourne vraiment.

Clavier et souris ensemble — L'instruction interagir attend un clic ou une touche : de quoi piloter un programme au clavier et à la souris, tour par tour.

Tracer une courbe mathématique — Construire un repère avec ses axes, passer des coordonnées mathématiques aux pixels, et tracer paraboles et sinusoïdes.

Animer plusieurs objets — Passer d'une balle à douze, puis à cent flocons : des tableaux pour les positions et les vitesses, une boucle pour tout faire bouger.

Écrire sur une toile — Placer du texte avec label, choisir sa taille et sa couleur, le centrer grâce à label_largeur, l'incliner et lui donner une ombre.

Mini-projet : un quiz — Construire pas à pas un jeu de questions à choix : données dans des tableaux, boucle, score et bilan final.

Mini-projet : pierre, feuille, ciseaux — Programmer un jeu contre l'ordinateur : hasard, règles du jeu, manches et score, avec une astuce de calcul.

Mini-projet : le jeu du pendu — Faire deviner un mot lettre par lettre : manipuler les textes, gérer les essais et détecter la victoire.

Mini-projet : une calculatrice — Demander deux nombres et une opération, gérer la division par zéro, enchaîner les calculs : un premier projet complet.

Mini-projet : réviser ses tables — Un entraîneur de tables de multiplication : questions au hasard, score, chronomètre et record à battre.

Mini-projet : un générateur de mots de passe — Fabriquer des mots de passe solides au hasard : lettres, chiffres, symboles, et la garantie d'en avoir de chaque sorte.

Mini-projet : le jeu du cochon — Un jeu de dés contre l'ordinateur où il faut savoir s'arrêter à temps : tours de jeu, prise de risque et stratégie.

Mini-projet : le morpion — Un jeu de morpion à deux joueurs : grille à deux dimensions, coups valides, détection de la victoire et du match nul.

Mini-projet : un jeu de raquette — Une balle qui rebondit, une raquette au clavier, un score qui monte et une balle qui accélère : ton premier jeu d'arcade.

Mini-projet : le plus ou moins complet — Le jeu du nombre mystère en version complète : niveaux de difficulté, essais limités, saisie protégée, record enregistré et rejouer.

Mini-projet : un carnet de contacts — Un vrai petit logiciel : ajouter, chercher, afficher et supprimer des contacts rangés dans un dictionnaire, le tout piloté par un menu.

Mini-projet : le jeu de Nim — 21 allumettes, on en retire 1, 2 ou 3 chacun son tour : programmer le jeu, puis un adversaire qui connaît la stratégie gagnante.

Mini-projet : la bataille navale — Huit bateaux cachés dans une grille, vingt torpilles, et des indices pour les débusquer : un jeu à la souris avec deux grilles en mémoire.

Mini-projet : un jeu de réflexes — Une cible qui apparaît, vingt secondes pour en toucher un maximum : un jeu en temps réel à la souris, avec chronomètre, précision et record.