AI EducademyAIEducademy
🌳

Fondations IA

🌱
AI Seeds

Partez de zéro

🌿
AI Sprouts

Construisez les fondations

🌳
AI Branches

Mettez en pratique

🏕️
AI Canopy

Approfondissez

🌲
AI Forest

Maîtrisez l'IA

🔨

Maîtrise IA

✏️
AI Sketch

Partez de zéro

🪨
AI Chisel

Construisez les fondations

⚒️
AI Craft

Mettez en pratique

💎
AI Polish

Approfondissez

🏆
AI Masterpiece

Maîtrisez l'IA

🚀

Prêt pour la Carrière

🚀
Rampe de lancement entretien

Commencez votre parcours

🌟
Maîtrise comportementale

Maîtrisez les compétences relationnelles

💻
Entretiens techniques

Réussissez l'épreuve de code

🤖
Entretiens IA et ML

Maîtrisez l'entretien ML

🏆
Offre et au-delà

Décrochez la meilleure offre

Voir tous les programmes→

Labo

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→
ParcoursBlog
🎯
À propos

Rendre l'éducation en IA accessible à tous, partout

❓
FAQ

Common questions answered

✉️
Contact

Get in touch with us

⭐
Open Source

Construit publiquement sur GitHub

Commencer gratuitement
AI EducademyAIEducademy

Licence MIT. Open Source

Apprendre

  • Programmes
  • Leçons
  • Labo

Communauté

  • GitHub
  • Contribuer
  • Code de conduite
  • À propos
  • FAQ

Soutien

  • Offrez-moi un café ☕
  • Conditions d'utilisation
  • Politique de confidentialité
  • Contact
Programmes d'IA et d'ingénierie›🪨 AI Chisel›Leçons›Deux pointeurs et fenêtre glissante
👆
AI Chisel • Intermédiaire⏱️ 15 min de lecture

Deux pointeurs et fenêtre glissante

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 sur 100% terminé
←Retour au programme

Discussion

Sign in to join the 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 ?