Multiparadigme


[Initiation Python] www.multiparadigme.org, menu: [Vidéos de cours d'informatique] [Vidéos de cours de maths] [Parlons musique] [Retour à l'entrée du site] [Cours particuliers] [Images calculées]


Cette page présente la liste des cours vidéo de programmation informatique publiés sur Youtube par Jacques-Olivier Lapeyre. L'accès à ces vidéos est libre et gratuit. Le code source de cette page web a lui-même été écrit à l'occasion du tournage d'une vidéo de cours (la vidéo numéro 20 de l'Unité 1).




Cours hors série sur les algorithmes de compression

  1. Algorithmes de compression : introduction.
  2. Compression : algorithme de Huffman, partie 1.
  3. Compression : algorithme de Huffman, partie 2.
  4. Compression : algorithme de Huffman, partie 3.

Unité 5 > Programmation de jeux 2D

  1. Unité 5, le défi qui rend fou.
  2. Logiciel de dessin et undo illimité.
  3. Arbres fractals et autres détails.
  4. Création d'un jeu vidéo : rendu de texte.
  5. Les premières lignes de code de mon jeu. Gestion d'erreur.
  6. Algorithmes du jeu Nullotron.
  7. Ajout d'un nouveau monstre dans Nullotron.
  8. Les champs de bits.
  9. De la programmation des shmups.
  10. Qualité du code, partie 1.
  11. Représenter l'ensemble de Mandelbrot.
  12. Quelques mesures de performances.
  13. Quand doit-on se préoccuper de l'endianness ?
  14. Pointeurs, partie 4 : de la superiorité des langages avec pointeurs.
  15. De la programmation événementielle, partie 1.
  16. Comment j'ai programmé le jeu Memiro.
  17. Modification de la représentation des maps.
  18. Comment je programme le jeu Nullotron II, partie 1.
  19. Comment je programme le jeu Nullotron II, partie 2 : représentation des sprites. [sources]
  20. Comment je programme le jeu Nullotron II, partie 3 : déroulement du temps. [sources]
  21. Comment je programme le jeu Nullotron II, partie 4 : les événements.
  22. Comment je programme le jeu Nullotron II, partie 5 : les collisions.
  23. Enregistrer des graphes et des floats.
  24. On explique le code de Full Blast.
  25. Programmer un Tetris comme premier jeu.
  26. J'ai programmé un jeu d'aventure.
  27. Conquérir le monde !.
  28. Conquérir le monde : les modules.
  29. Conquérir le monde : le loader et les items.
  30. Conquérir le monde : les personnages et les lieux.
  31. Conquérir le monde : les combattants.
  32. Conquérir le monde : les combats.
  33. Conquérir le monde : les commandes.
  34. Conquérir le monde : les parties sauvegardées.
  35. Conquérir le monde : j'implémente une idée proposée par un abonné.
  36. Conquérir le monde : j'implémente une idée proposée par un abonné (suite).
  37. TO BE CONTINUED...

Unité 4 > Programmation orientée objet (POO)

  1. Du C au C++, partie 1.
  2. Du C au C++, partie 2.
  3. POO, partie 1 : fonctions membres.
  4. POO, partie 2 : des structs aux classes.
  5. POO, partie 3 : passage par référence ; operator_chevron_chevron.
  6. POO, partie 4 : héritage public.
  7. Les tas en C++, sources du module intarray version C++.
  8. Les templates en C++, partie 1.
  9. Des classes date, adresse et personne en C++.
  10. Entrées et std::string en C++.
  11. Les templates en C++, partie 2.
  12. Les templates en C++, partie 3 + traitement d'image, sources C++ (sauf module pixmap).
  13. Traitement d'image en C++, partie 1.
  14. Traitement d'image en C++, partie 2.
  15. Traitement d'image en C++, partie 3.
  16. Traitement d'image en C++, partie 4.
  17. Image numérique : fonctions affines et contraste.
  18. Image numérique : de mystérieux filtres....
  19. Image numérique : effets graphiques avec masques, partie 1.
  20. Image numérique : effets graphiques avec masques, partie 2.
  21. Image numérique : effets graphiques avec masques, partie 3.
  22. Image numérique : effets graphiques avec masques, partie 4 + dégradés de couleurs, sources de CPPFUNS, sources de pixmap.
  23. Initiation accidentelle et improvisée à l'analyse d'image.
  24. Fuites de mémoire et autres joies du programmeur C.
  25. Calculs de dégradés en 24 ou 32 bits, sources de CPPFUNS, sources de pixmap.
  26. Algorithme de Floyd-Steinberg.
  27. Calculs de dégradés en 48 ou 64 bits, sources de pixmap.
  28. L'application "Grand Ciel" partie 1, sources version alpha.
  29. "Grand Ciel" version graphique, partie 1, sources version beta.
  30. "Grand Ciel" version graphique, partie 2.
  31. Utilisations du logiciel "Grand Ciel".
  32. Introduction au langage Java.
  33. Une classe "Trinôme" en Java.
  34. Une classe "Polynôme" en Java.
  35. Une classe "Polynôme" en C++.
  36. Polynômes : algorithme de Horner et recherche dichotomique.
  37. Polynômes : racines et surcharge des opérateurs.
  38. Java : classe Object et comparaison avec C++.
  39. Les exceptions en C++, partie 1.
  40. Les exceptions en C++, partie 2.
  41. Les exceptions en C++, partie 3.
  42. Les exceptions en Java.
  43. Les graphes (introduction).
  44. Les graphes : définitions et parcours en largeur.
  45. Les graphes en C++ et matrices d'adjacence.
  46. Les graphes en C et parcours en profondeur.
  47. Graphes : parcours en profondeur en C.

Unité 3 > Applications graphiques et SDL

  1. Introduction à l'image numérique
  2. Affichons un rectangle
  3. Quelques structs de la SDL. Différence entre image true colour et image à palette indexée.
  4. Notre module image, les sources de SDL intro.
  5. Transparence, format TGA, exercices, sources de SDL intro.
  6. Application dust-- : comment supprimer les poussières sur une photo argentique numérisée ?
  7. Filtre médian, sources de Cfuns, sources de SDL intro.
  8. Filtre médian (suite) + un peu de SDL.
  9. Fonctionnement de dust--.
  10. Function putpixel pour SDL.
  11. Ecriture de dust--, partie 1.
  12. Ecriture de dust--, partie 2.
  13. Ecriture de dust--, partie 3, sources de Cfuns, sources de dust--.
  14. Divers : union, dictionnaire (hash table), prochain projet.
  15. Dictionnaires, partie 1.
  16. Dictionnaires, partie 2.
  17. Dictionnaires, partie 3, sources de Cfuns
  18. Dictionnaires, partie 4.
  19. Editeur de sprite, partie 1, sources de spritedit
  20. Editeur de sprite, partie 2, sources de spritedit
  21. Editeur de sprite, partie 3, sources de Cfuns, sources de spritedit.
  22. Editeur de sprite, partie 4.
  23. Editeur de sprite, partie 5, sources de Cfuns, sources de spritedit.
  24. Editeur de sprite, partie 6.
  25. Editeur de sprite, partie 7, sources de Cfuns, sources de spritedit.
  26. Editeur de sprite, partie 8.
  27. Editeur de sprite, partie 9.
  28. Informaticien et pédagogue, sources de Cfuns, sources de spritedit.
  29. Editeur de sprite, partie 10.
  30. Editeur de sprite, partie 11.
  31. Algorithme de Bresenham (pour tracer des segments) + exercices.
  32. Programmation d'un jeu vidéo, partie 1.
  33. Programmation d'un jeu vidéo, partie 2.
  34. Programmation d'un jeu vidéo, partie 3.
  35. Programmation d'un jeu vidéo, partie 4, sources de Cfuns, sources de mole_game.
  36. Programmation d'un jeu vidéo, partie 5.
  37. Programmation d'un jeu vidéo, partie 6, sources de graphics, sources de mole_game, sources de spritedit.
  38. Programmation d'un jeu vidéo, partie 7, sources de mole_game.
  39. Programmation d'un jeu vidéo, partie 8.
  40. Programmation d'un jeu vidéo, partie 9, sources de Borpion, sources de mole_game.
  41. Programmation d'un jeu vidéo, partie 10, sources de Cfuns, sources de graphics, sources de spritedit.
  42. Programmation d'un jeu vidéo, partie 11.
  43. Programmation d'un jeu vidéo, partie 12.
  44. Programmation d'un jeu vidéo, partie 13, sources de mole_game.
  45. Programmation d'un jeu vidéo, partie 14.
  46. Programmation d'un jeu vidéo, partie 15, sources de Cfuns, sources de mole_game.
  47. Programmation d'un jeu vidéo, partie 16 (cours sans parole !), sources de mole_game (VERSION FINALE).

Unité 2 > Algorithmique et structures de données

  1. Algorithmique et structures de données (intro) [Ancienne version]
  2. Langage algorithmique [Ancienne version]
  3. Calcul de a puissance b [Ancienne version]
  4. Introduction à la complexité algorithmique [Ancienne version différente]
  5. Complexité algorithmique (suite) [Ancienne version], sources
  6. Tri et complexité quadratique [Ancienne version]
  7. Tableaux à deux dimensions, partie 1 [Ancienne version], sources
  8. Tableaux à deux dimensions, partie 2 [Ancienne version], sources
  9. Tableaux à deux dimensions, partie 3 [Ancienne vesion], sources
  10. Primitives géométriques optimisées [Ancienne version différente], sources
  11. Un morpion amélioré [Ancienne version différente]
  12. Les fichiers, partie 1 [Ancienne version différente], sources de Cfuns, sources de projet_jv
  13. Les fichiers, partie 2 [Ancienne version différente], sources de Cfuns, sources de projet_jv.
  14. Les fichiers, partie 3 : on écrit notre propre module [Ancienne version différente], sources de Cfuns, sources de projet_jv.
  15. Les fichiers, partie 4 [Ancienne version différente]
  16. Les fichiers, partie 5 : gestion d'erreurs [Ancienne version différente]
  17. Le bazard qu'est la création d'un format de fichier [Ancienne version différente]
  18. Les fichiers texte ne sont pas plus simples [Ancienne version différente], sources de Cfuns.
  19. Nos premiers pas en image numérique [Ancienne version différente], sources de Cfuns.
  20. Chargement d'une image .ppm [Ancienne version différente].
  21. Cours d'algorithmique 16. Jeu de la vie, partie 5, sources de Cfuns, sources de projet jv.
  22. Cours d'algorithmique 17. Les tas. Le tri par tas., sources de Cfuns.
  23. Cours d'algorithmique 18. Les tableaux génériques. Les pointeurs de fonctions.
  24. Cours d'algorithmique 19. Jeu de la vie, partie 6
  25. Cours d'algorithmique 20. Jeu de la vie, partie 7, sources de Cfuns, sources de projet jv.
  26. Cours d'algorithmique 21. Jeu de la vie, partie 8. Saisie robuste d'entiers et de chaînes.
  27. Cours d'algorithmique 22. Jeu de la vie, partie 9.
  28. Cours d'algorithmique 23. Fonctions, partie 2 : la récursivité et la récursivité terminale.
  29. Cours d'algorithmique 24. Jeu de la vie, partie 10 (dernière partie !), sources de Cfuns, sources de jv.
  30. Cours d'algorithmique 25. Listes doublement chaînées, partie 1, sources de projet_list.
  31. Cours d'algorithmique 26. Listes doublement chaînées, partie 2, sources de projet_list, sources de Cfuns.
  32. Cours d'algorithmique 27. Listes doublement chaînées, partie 3, sources de projet_list, sources de Cfuns.
  33. Cours d'algorithmique 28. Listes doublement chaînées, partie 4 : listes et tri par tas. Fonction filter, sources de Cfuns, sources de projet_list, sources de projet_jv, VERSION FINALE.
  34. Cours d'algorithmique 29. Listes doublement chaînées, partie 5 : premier test de performance, sources de projet_list.
  35. Pointeurs, partie 3 : casts et arithmétique des pointeurs. Fonctionnement d'un memory pool.
  36. Cours d'algorithmique 30. Memory pool, partie 1, sources de projet_list.
  37. Cours d'algorithmique 31. Memory pool, partie 2, sources de projet_list.
  38. Cours d'algorithmique 32. Recherche par dichotomie, sources de Cfuns.
  39. Numération hexadécimale.
  40. Improvisation non artistique.
  41. Cours d'algorithmique 33. Piles, files et files de priorité.
  42. Cours d'algorithmique 34. Arbres, partie 1 : arbres binaires et tri par dichotomie.
  43. Cours d'algorithmique 35. Arbres, partie 2 : parcours d'arbres binaires..
  44. Petit détour par les listes simplement chaînées, sources de Cfuns.
  45. Cours d'algorithmique 36. Arbres, partie 3 : le module btree.
  46. Cours d'algorithmique 37. Arbres, partie 4 : parcours en largeur et en profondeur, sources de Cfuns.
  47. Cours d'algotithmique 38. Arbres, partie 5 : tri par dichotomie, sources de Cfuns.



Unité 1 > Le tout début

  1. Le premier cours [Ancienne version]
  2. Les chaînes de caractères, partie 1 [Ancienne version]
  3. Variables en C [Ancienne version]
  4. Le type char en langage C [Ancienne version]
  5. Le type char en langage C, partie 2 [Ancienne version]
  6. Calcul d'aires et de périmètres de rectangles [Ancienne version]
  7. Boucles, partie 1 [Ancienne version]
  8. Les pointeurs, partie 0 [Ancienne version]
  9. Les pointeurs, partie 1 [Ancienne version]
  10. Simplifications d'écriture, boucles for en C [Ancienne version]
  11. Les boucles imbriquées [Ancienne version]
  12. Tableaux en C (introduction) [Ancienne version]
  13. Installation d'Emacs et revue de code
  14. Numération binaire, partie 1
  15. Les fonctions en C [Ancienne version]
  16. Fichiers et installation de Cygwin
  17. La compilation. La gestion d'erreur. [Ancienne version]
  18. Les modules, partie 1 [Ancienne version]
  19. Allocation mémoire dynamique [Ancienne version]
  20. Initiation au langage HTML
  21. Les modules, partie 2 [Ancienne version]
  22. Les structs en C [Ancienne version]
  23. Programmer proprement, partie 1 [Ancienne version]
  24. Coder factorisé [Ancienne version]
  25. Passage par valeur [Ancienne version]
  26. Tri par sélection [Ancienne version]
  27. Programmer proprement, partie 2 [Ancienne version]
  28. Convertir une chaîne en entier [Ancienne version]
  29. Moyenne et médiane d'un tableau d'entiers [Ancienne version]
  30. Notre deuxième programme intéressant [Ancienne version]
  31. Revue de code [Ancienne version]
  32. Pointeurs de structs [Ancienne version]
  33. Tableaux de taille variable, partie 1 [Ancienne version]
  34. Tableaux de taille variable, partie 2 [Ancienne version]
  35. Jeu du pendu (version texte), partie 1 [Ancienne version : jeu du morpion]
  36. Jeu du pendu (version texte), partie 1 [Ancienne version : jeu du morpion]
  37. De vraies chaînes de caractères en C [Ancienne version]
  38. Algorithmes sur les chaînes de caractères, partie 1 , sources
  39. Algorithmes sur les chaînes de caractères, partie 2 [Ancienne version]
  40. Les pointeurs, partie 2. (pointeurs de pointeurs...) [Ancienne version]
  41. Module stringarray, partie 1 [Ancienne version]
  42. Module stringarray, partie 2 [Ancienne version]
  43. Gestion de la mémoire en C. [Ancienne version]



Contact : profmathsbdx@laposte.net