Skip to main content
AI EducademyAIEducademy
🌳

Fondations IA

🌱
AI Seeds

Alphabétisation de l'IA pour le monde réel

🌿
AI Sprouts

Les fondements des systèmes intelligents

🌳
AI Branches

Construisez avec les capacités d’IA d’aujourd’hui

🏕️
AI Canopy

Ingénieur de systèmes GenAI fiables

🌲
AI Forest

Expédier les produits d’IA de manière responsable

🔨

Maîtrise IA

✏️
AI Sketch

Bases d'ingénierie pour les constructeurs d'IA

🪨
AI Chisel

Modèles pour résoudre des problèmes plus difficiles

⚒️
AI Craft

Concevoir des systèmes qui font évoluer l'IA

💎
AI Polish

Communiquer et diriger à l’ère de l’IA

🏆
AI Masterpiece

Votre pierre angulaire de l'IA de production

🚀

Prêt pour la Carrière

🚀
Rampe de lancement entretien

Naviguez sur le marché du travail en ingénierie de l'IA

🌟
Maîtrise comportementale

Racontez l'histoire de la façon dont vous créez un impact

💻
Entretiens techniques

Résoudre, concevoir et communiquer sous pression

🤖
Entretiens IA et ML

Préparez-vous aux entretiens modernes ML et GenAI

🏆
Offre et au-delà

Faites un prochain pas en toute confiance et en connaissance de cause

Voir tous les programmes→

Laboratoire

7 expériences chargées
🧠Terrain de jeu neuronal🤖IA ou humain ?💬Labo de prompts🎨Generateur d'images😊Analyseur de sentiment💡Constructeur de chatbot⚖️Simulateur d'ethique
🎯Entretien simuléEntrer dans le labo→
ParcoursBlogue
🎯
À propos

Rendre l’éducation à l’IA accessible à tous, partout

❓
Questions fréquentes

Réponses aux questions courantes

🧰
Outils IA

Une sélection d'outils que nous utilisons et recommandons

✉️
Contacter

Contactez-nous

⭐
Open source

Construit publiquement sur GitHub

Tarifs
Commencer
AI EducademyAIEducademy

© 2026 AI Educademy. Tous droits réservés.

Apprendre

  • Programmes
  • Leçons
  • Labo
  • Kit de démarrage IA
  • Tarifs

Communauté

  • GitHub
  • Contribuer
  • Code de conduite
  • À propos
  • Questions fréquentes

Soutien

  • Offrez-moi un café ☕
  • Conditions d'utilisation
  • Politique de confidentialité
  • Contacter
  • Sitemap
Programmes d'IA et d'ingénierie›🪨 AI Chisel›Leçons›Two Pointers et Sliding Window - Comment l'IA analyse les données efficacement
👆
AI Chisel • Intermédiaire⏱️ 15 min de lecture

Two Pointers et Sliding Window - Comment l'IA analyse les données efficacement

Pourquoi un parcours intelligent est important

Imaginez une IA surveillant un flux vidéo en direct pour détecter des activités suspectes. Elle ne peut pas revisionner l'intégralité de l'enregistrement chaque seconde - elle doit faire glisser une fenêtre d'attention sur le flux, en conservant juste assez de contexte. C'est exactement ce que font les patterns two pointers et sliding window pour les données séquentielles.

Ces deux techniques transforment des parcours brute-force en O(n²) en élégants parcours en O(n).

Deux pointeurs convergeant depuis les extrémités d'un tableau et une fenêtre glissante se déplaçant sur un flux de données
Les two pointers réduisent l'espace de recherche ; la sliding window maintient une vue glissante.

La technique Two Pointers

Placez deux références dans une séquence et déplacez-les selon une règle. Il existe deux variantes principales.

Pointeurs convergents

Placez un pointeur à chaque extrémité et déplacez-les vers l'intérieur. Idéal pour les données triées.

Problème classique - Pair Sum : Étant donné un tableau trié, trouvez deux nombres dont la somme correspond à une cible.

function pairSum(arr, target):
    left = 0
    right = arr.length - 1
    while left < right:
        sum = arr[left] + arr[right]
        if sum == target: return (left, right)
        if sum < target: left += 1
        else: right -= 1
    return null

Comme le tableau est trié, déplacer left vers la droite augmente la somme, et déplacer right vers la gauche la diminue - garantissant qu'aucune paire valide n'est manquée.

Pointeurs dans la même direction

Les deux pointeurs avancent, mais à des vitesses différentes. Utile pour le partitionnement ou la détection de cycles.

Exemple - Supprimer les doublons en place : Un pointeur lent marque la position d'écriture ; un pointeur rapide parcourt en avance.

function removeDuplicates(arr):
    slow = 0
    for fast in 1..arr.length - 1:
        if arr[fast] != arr[slow]:
            slow += 1
            arr[slow] = arr[fast]
    return slow + 1
Leçon 1 de 100% terminé
←Retour au programme
Continuer : Arbres et recherche binaire - Comment l'IA prend des décisions rapides→

Discussion

Connectez-vous pour rejoindre la discussion

Suggérer une modification de cette leçon
🧠Vérification rapide

Dans la technique two pointers convergents sur un tableau trié, que faut-il faire lorsque la somme actuelle est inférieure à la cible ?

Le pattern Sliding Window

Une sliding window maintient une sous-séquence contiguë de taille k (fixe) ou de longueur variable, en mettant à jour les agrégats de manière incrémentale plutôt que de les recalculer entièrement.

Fenêtre de taille fixe

Faites glisser une fenêtre de exactement k éléments sur le tableau.

Exemple - Somme maximale de k éléments consécutifs :

function maxSubarraySum(arr, k):
    windowSum = sum(arr[0..k-1])
    best = windowSum
    for i in k..arr.length - 1:
        windowSum += arr[i] - arr[i - k]
        best = max(best, windowSum)
    return best

À chaque étape, on ajoute le nouvel élément entrant dans la fenêtre et on soustrait celui qui en sort - O(1) par déplacement.

Fenêtre de taille variable

Élargissez la fenêtre pour inclure plus de données, puis réduisez-la lorsqu'une contrainte est violée.

Exemple - Plus longue sous-chaîne sans caractères répétés :

function longestUnique(s):
    seen = {}
    left = 0
    best = 0
    for right in 0..s.length - 1:
        if s[right] in seen and seen[s[right]] >= left:
            left = seen[s[right]] + 1
        seen[s[right]] = right
        best = max(best, right - left + 1)
    return best
🤯
Les plateformes de streaming analytics comme Apache Flink utilisent les fenêtres glissantes et les fenêtres à bascule comme primitives de premier ordre - le même concept appliqué à des millions d'événements par seconde.

Applications en IA

| Pattern | Cas d'usage en IA | |---------|------------------| | Fenêtre fixe | Détection d'anomalies sur les k dernières lectures de capteurs | | Fenêtre variable | Trouver le plus court extrait de texte contenant tous les mots-clés d'une requête (moteurs de recherche) | | Pointeurs convergents | Vérifications efficaces du plus proche voisin dans des dimensions d'embeddings triées | | Pointeurs même direction | Fusion de listes de résultats triées provenant de multiples modèles de retrieval |

🤔
Think about it:Un assistant vocal met en tampon les 3 dernières secondes d'audio pour détecter un mot d'activation. De quel pattern s'agit-il - fenêtre fixe ou fenêtre variable ? Que se passe-t-il si le mot d'activation est plus long que le tampon ?

Quand utiliser quel pattern

  • Two pointers (convergents) : entrée triée, recherche de paires/triplets, vérification de palindromes.
  • Two pointers (même direction) : modifications en place, problèmes de coureur rapide/lent.
  • Fixed sliding window : agrégat sur une taille de fenêtre connue.
  • Variable sliding window : trouver la plus petite ou la plus grande fenêtre satisfaisant une condition.
🧠Vérification rapide

Quel pattern choisiriez-vous pour trouver le plus petit sous-tableau dont la somme dépasse une valeur donnée ?

🤔
Think about it:Pourriez-vous combiner two pointers avec une sliding window ? Pensez à des problèmes où il faut trouver une paire dans une fenêtre glissante de données - par exemple, détecter des transactions en double dans une fenêtre de cinq minutes.

Points clés à retenir

  1. Les two pointers éliminent les boucles imbriquées en exploitant l'ordre ou le partitionnement.
  2. Les sliding windows maintiennent un état courant pour que chaque élément soit traité au plus deux fois.
  3. Les deux patterns sont fondamentaux dans les pipelines IA en temps réel - de la détection d'anomalies au classement des résultats de recherche.
🧠Vérification rapide

Quelle est la complexité temporelle typique obtenue en convertissant une boucle imbriquée brute-force en solution two pointers ou sliding window ?