20 — Ressources : plateformes, outils et visualisations

Ce chapitre est une carte des ressources pour continuer l'apprentissage après la formation. Il distingue les plateformes selon l'objectif (entretien, compétition, mathématiques, mentorat), détaille leurs fonctionnalités clés et propose une méthodologie d'utilisation.

---

Sommaire

1. Catégoriser son objectif
2. Plateformes d'entretien
3. Plateformes de compétition
4. Mathématiques et théorie des nombres
5. Pratique guidée avec mentorat
6. Cheat sheets : Big-O et références
7. Visualisations interactives
8. Outils de développement
9. Plan d'entraînement type
10. Sélection de problèmes par thème
11. Journal de bord d'entraînement

---

1. Catégoriser son objectif

Conseil : mélangez au moins une plateforme « entretien » et une « compétition ». Elles renforcent deux muscles différents : la rigueur sur les patterns, et la rapidité de raisonnement.

---

2. Plateformes d'entretien

LeetCode

• URL : https://leetcode.com
• Atout : le référentiel des problèmes d'entretien (format FAANG).
• Fonctionnalités clés :
  • Filtres par thème (arrays, DP, graphs…) et par difficulté.
  • Daily Challenge : un problème par jour pour la régularité.
  • LeetCode Study Plans : parcours structurés (ex. Algorithm I).
  • Contests hebdomadaires (Weekly 401, biweekly…).
  • Discuss et Editorials : solutions officielles expliquées.
• Méthode : suivre la Blind 75 ou le Grind 75 puis refaire les problèmes difficiles de mémoire.

HackerRank

• URL : https://www.hackerrank.com
• Atout : découpage très pédagogique par compétence.
• Fonctionnalités clés :
  • Tracks par domaine (Algorithms, Data Structures, AI, SQL…).
  • Évaluations par subdomain (ex. Sorting, Warmup, Greedy).
  • Classement par pays.
• Méthode : faire les tracks "Algorithms" et "Data Structures" dans l'ordre, en visant le badge gold.

---

3. Plateformes de compétition

Codeforces

• URL : https://codeforces.com
• Atout : la référence internationale de la compétition (rating Elo).
• Fonctionnalités clés :
  • Contests Div. 1/2/3/4 selon le niveau (rating).
  • Div. 4 : idéal pour débuter en compétition.
  • Editorials systématiques après chaque contest.
  • Problem set avec filtres par rating (800 → 3500).
• Méthode : cibler les problèmes de rating 800 → 1200 → 1600 progressivement. Toujours lire l'editorial après un blocage de 30 min.

AtCoder

• URL : https://atcoder.jp
• Atout : contests très pédagogiques, editorials excellents, problèmes bien rédigés.
• Fonctionnalités clés :
  • AtCoder Beginner Contest (ABC) : 7 problèmes de difficulté progressive — idéal pour apprendre.
  • Regular Contest (ARC) : niveau intermédiaire.
  • Grand Contest (AGC) : niveau expert.
  • AtCoder Library (ACL) : implémentations officielles C++ de référence.
• Méthode : faire les ABC en entier puis lire les editorials, en parallèle d'un outil de suivi comme AtCoder Problems.

---

4. Mathématiques et théorie des nombres

Project Euler

• URL : https://projecteuler.net
• Atout : 800+ problèmes de mathématiques et d'optimisation en énoncés courts.
• Fonctionnalités clés :
  • Problèmes séquentiels : résoudre le 1 débloque le 2, etc.
  • Progress et forum par problème (discussions des approches).
  • Exigence : résultats numériques — impossible de tricher par hasard.
• Méthode : 2-3 problèmes par semaine, en cherchant toujours la solution la plus optimale (pas juste correcte). Excellent complément au chapitre 14 (Mathématiques).

---

5. Pratique guidée avec mentorat

Exercism

• URL : https://exercism.org
• Atout : 60+ langages, exercices progressifs et mentorat humain.
• Fonctionnalités clés :
  • Parcours par langage avec difficulté graduée.
  • Code review par des mentors bénévoles.
  • Concept exercises : un concept par exercice.
• Méthode : choisir un langage (Python recommandé), faire le track d'algorithmique, soumettre les solutions pour revue.

---

6. Cheat sheets : Big-O et références

Big-O cheat sheet

• URL : https://www.bigocheatsheet.com
• Contenu :
  • Complexités de toutes les structures de données (recherche, insertion, suppression, accès).
  • Complexités de tous les tris (meilleur, moyen, pire, mémoire, stable).
  • Comparaisons graphiques (n, log n, n log n, n², 2^n).
• Usage : imprimer ou garder en onglet pendant les révisions ; le chapitre 23 en donne une version complète en français.

CP-Algorithms

• URL : https://cp-algorithms.com
• Contenu : encyclopédie des algorithmes classiques avec implémentations C++ (math modulaire, graphes, strings, géométrie).
• Usage : source de référence quand un corrigé n'est pas clair.

GeeksforGeeks

• URL : https://www.geeksforgeeks.org
• Contenu : explications pas-à-pas de la plupart des algorithmes, en plusieurs langages.
• Usage : complément de lecture, vérifier les approches alternatives.

---

7. Visualisations interactives

VisuAlgo

• URL : https://visualgo.net
• Atout : LE site de visualisation d'algorithmes, créé à l'université NUS.
• Contenu :
  • Tris, structures (listes, hash, BST, AVL, heap, graph traversal).
  • Graphes (BFS, DFS, MST, Dijkstra, Bellman-Ford, Floyd-Warshall).
  • Strings (KMP, Rabin-Karp, suffix array, Trie).
  • Géométrie (convex hull) et DP.
• Fonctionnalités : animation pas-à-pas, vitesse réglable, affichage de la complexité, quiz intégrés.
• Usage : avant de coder un algorithme, le visualiser sur un petit exemple ; pendant le cours, pour déboguer une compréhension erronée.

Autres visualisations

• Algorithm Visualizer : https://algorithm-visualizer.org — visualisation avec code synchrone.
• Pathfinding Visualizer (Clément Mihailescu) : BFS/DFS/Dijkstra/A* sur grille interactive.
• Sorting Algorithms Visualized : galerie vidéo des tris (Sleepless Software).
• CSV Visualizations (Sam Gavis-Hughson) : visualisations YouTube des problèmes classiques.

---

8. Outils de développement

Comment mesurer une complexité empiriquement

1. Générer des entrées croissantes (n = 10³, 10⁴, 10⁵, 10⁶).
2. Mesurer le temps avec timeit (plusieurs répétitions, médiane).
3. Tracer log(temps) en fonction de log(n) : la pente ≈ l'exposant de la complexité.
   • Pente ≈ 1 → O(n) · pente ≈ 2 → O(n²) · pente ≈ 1,5 → O(n√n).
4. Vérifier la mémoire avec memory-profiler (lignes individuelles).

Exemple de script de benchmark (Python)

import timeit, math

def bench(fn, sizes=(10_000, 100_000, 1_000_000)):
    for n in sizes:
        data = list(range(n, 0, -1))          # pire cas pour certains tris
        t = timeit.timeit(lambda: fn(data), number=3)
        print(f"n={n:>10,}  temps={t:.4f}s  ratio="
              f"{t / (n * math.log(n)):.3e}")

Bonnes pratiques de benchmark

• Chauffer (warm-up) avant de mesurer.
• Prendre la médiane, pas la moyenne (robuste aux pics).
• Fixer le seed aléatoire pour des entrées reproductibles.
• Vérifier que les données ne sont pas accidentellement triées (cas favorable).

---

9. Plan d'entraînement type

Semaine-type (entretien + compétition)

Points de passage

• Mois 1–2 : niveau facile + AtCoder ABC A-C. Objectif : 50 problèmes résolus.
• Mois 3–4 : niveau moyen + Codeforces Div. 4/3. Objectif : 100 problèmes résolus.
• Mois 5–6 : niveau difficile + AtCoder ABC D-F. Objectif : 150 problèmes résolus.
• Mois 7+ : entretiens simulés (mock interviews) + problèmes experts.

---

10. Sélection de problèmes par thème

Une feuille de route classique pour les plateformes (les intitulés sont les mêmes sur LeetCode et HackerRank). Résoudre chaque liste dans l'ordre, en complétant par les exercices du chapitre 17.

Arrays & Hashing

1. Contains Duplicate — hash set.
2. Two Sum — hash map (cf. E17-21).
3. Valid Anagram — comptage de lettres.
4. Group Anagrams — signature par tri/comptes.
5. Top K Frequent Elements — compteur + tas.
6. Product of Array Except Self — prefix/suffix products.
7. Maximum Subarray — Kadane (cf. E17-37).
8. Merge Intervals — tri + fusion (cf. E17-40).
9. Longest Consecutive Sequence — hash set, séquences par tête.
10. Trapping Rain Water — deux pointeurs (cf. E17-47).

Two Pointers & Sliding Window

11. Valid Palindrome — deux pointeurs.
12. 3Sum — tri + deux pointeurs.
13. Container With Most Water — deux pointeurs.
14. Longest Substring Without Repeating Characters — fenêtre + set.
15. Minimum Window Substring — fenêtre + compteurs (cf. E17-49).

Trees & Graphs

16. Invert Binary Tree — DFS.
17. Maximum Depth — récursion.
18. Validate BST — plage (min, max) (cf. E17-32).
19. Binary Tree Level Order Traversal — BFS (cf. E17-33).
20. Number of Islands — BFS/DFS (cf. E17-34).
21. Course Schedule — détection de cycle + tri topologique.
22. Number of Connected Components — union-find.
23. Clone Graph — BFS/DFS + hash map.
24. Word Search — backtracking.

DP

25. Climbing Stairs — Fibonacci (cf. E17-14).
26. House Robber — DP 1D.
27. Longest Palindromic Substring — expansion autour du centre.
28. Coin Change — DP (cf. E17-63).
29. Longest Increasing Subsequence — O(n log n) (cf. E17-36).
30. Unique Paths — DP grille (cf. E17-38).

Greedy & Backtracking

31. Subsets / Permutations — backtracking.
32. Combination Sum — backtracking (cf. E17-42).
33. Generate Parentheses — backtracking (cf. E17-41).
34. Jump Game — greedy portée maximale (cf. E17-65).
35. Task Scheduler — comptage + cooldown.

Tips d'utilisation

• Ne jamais passer plus de 45 minutes sur un problème sans regarder l'editorial.
• Après l'editorial, codez la solution optimale de mémoire.
• Ajoutez le problème à votre journal de bord (section suivante).

---

11. Journal de bord d'entraînement

Un tableau à tenir à jour après chaque session. C'est le meilleur levier de progression.

Règles du journal

1. Une ligne par problème — pas de détails inutiles.
2. Colonne « leçon » obligatoire : c'est ce que vous réutiliserez.
3. Relecture hebdomadaire : le dimanche, parcourez les leçons de la semaine.
4. Ré-essais programmés : les problèmes ✗ doivent revenir dans le planning sous 48 h.

Critères de passage à la vitesse supérieure

• 10 problèmes ✓ d'affilée dans un thème → passer à la difficulté suivante.
• 3 ✗ sur le même pattern → revoir le chapitre correspondant de la formation (00-16).
• Taux de réussite ≥ 80 % sur 2 semaines → augmenter le volume ou la difficulté.

Prochaine étape : approfondir avec les livres de référence du chapitre 21, puis s'entraîner aux entretiens du chapitre 22.