Prog 6 - Tableaux & Listes | Stocker plusieurs valeurs

Interactif

L'indexation commence à 0

Chaque case a un index. Le premier élément est à l'index 0, pas 1 ! Déplace le curseur pour sélectionner fruits[i].

i = 0

Tableau de 6 fruits → indices valides : 0 à 5 (longueur − 1)

1

C'est quoi un tableau ?

Un tableau (ou liste) c'est comme un casier avec plusieurs cases numérotées :

fruits = ["🍎", "🍌", "🍊", "🍇", "🍓"]

🍎 [0]

🍌 [1]

🍊 [2]

🍇 [3]

🍓 [4]

Cliqué : fruits[0] = "🍎"

⚠️ Important : Les indices commencent à 0, pas à 1 !

2

Créer un tableau

# Créer une liste
fruits = ["pomme", "banane", "orange"]
nombres = [1, 2, 3, 4, 5]
mixte = [42, "hello", True]  # Types mélangés OK

# Liste vide
vide = []

# Longueur
print(len(fruits))  # 3

// Créer un tableau
const fruits = ["pomme", "banane", "orange"];
const nombres = [1, 2, 3, 4, 5];
const mixte = [42, "hello", true];  // Types mélangés OK

// Tableau vide
const vide = [];

// Longueur
console.log(fruits.length);  // 3

// Tableau fixe
String[] fruits = {"pomme", "banane", "orange"};
int[] nombres = {1, 2, 3, 4, 5};

// ArrayList (taille dynamique)
ArrayList<String> liste = new ArrayList<>();
liste.add("pomme");

// Longueur
System.out.println(fruits.length);  // 3
System.out.println(liste.size());   // 1

// Tableau fixe
string[] fruits = {"pomme", "banane", "orange"};
int[] nombres = {1, 2, 3, 4, 5};

// List (taille dynamique)
List<string> liste = new List<string>();
liste.Add("pomme");

// Longueur
Console.WriteLine(fruits.Length);  // 3
Console.WriteLine(liste.Count);    // 1

// Tableau fixe
std::string fruits[] = {"pomme", "banane", "orange"};
int nombres[] = {1, 2, 3, 4, 5};

// Vector (taille dynamique)
std::vector<std::string> liste;
liste.push_back("pomme");

// Longueur
std::cout << sizeof(fruits)/sizeof(fruits[0]);  // 3
std::cout << liste.size();  // 1

# R est FAIT pour les vecteurs !
fruits <- c("pomme", "banane", "orange")
nombres <- c(1, 2, 3, 4, 5)
nombres <- 1:5  # Raccourci !

# Vecteur vide
vide <- c()

# Longueur
length(fruits)  # 3

# Operations vectorisees (pas besoin de boucle !)
nombres * 2  # 2, 4, 6, 8, 10

3

Accéder aux éléments

fruits = ["pomme", "banane", "orange"]

# Par index
print(fruits[0])   # "pomme"
print(fruits[2])   # "orange"

# Index négatif (depuis la fin)
print(fruits[-1])  # "orange" (dernier)
print(fruits[-2])  # "banane"

# Modifier
fruits[0] = "kiwi"
print(fruits)  # ["kiwi", "banane", "orange"]

# Slicing (sous-liste)
print(fruits[0:2])  # ["kiwi", "banane"]

const fruits = ["pomme", "banane", "orange"];

// Par index
console.log(fruits[0]);   // "pomme"
console.log(fruits[2]);   // "orange"

// Dernier élément
console.log(fruits[fruits.length - 1]);  // "orange"
console.log(fruits.at(-1));  // "orange" (ES2022)

// Modifier
fruits[0] = "kiwi";
console.log(fruits);  // ["kiwi", "banane", "orange"]

// Slice (sous-tableau)
console.log(fruits.slice(0, 2));  // ["kiwi", "banane"]

String[] fruits = {"pomme", "banane", "orange"};

// Par index
System.out.println(fruits[0]);   // "pomme"
System.out.println(fruits[2]);   // "orange"

// Dernier élément
System.out.println(fruits[fruits.length - 1]);  // "orange"

// Modifier
fruits[0] = "kiwi";
// ["kiwi", "banane", "orange"]

// Sous-tableau
String[] sub = Arrays.copyOfRange(fruits, 0, 2);
// ["kiwi", "banane"]

4

Opérations courantes

append / push

Ajouter à la fin

insert

Ajouter à un index

remove / pop

Supprimer

sort

Trier

fruits = ["pomme", "banane"]

# Ajouter
fruits.append("orange")      # À la fin
fruits.insert(0, "kiwi")    # À l'index 0

# Supprimer
fruits.remove("banane")     # Par valeur
dernier = fruits.pop()       # Enlève et retourne le dernier
del fruits[0]                # Par index

# Rechercher
if "pomme" in fruits:
    print("Trouvé !")

# Trier
fruits.sort()                # Modifie la liste
triee = sorted(fruits)       # Retourne une copie triée

const fruits = ["pomme", "banane"];

// Ajouter
fruits.push("orange");       // À la fin
fruits.unshift("kiwi");     // Au début

// Supprimer
const index = fruits.indexOf("banane");
if (index > -1) fruits.splice(index, 1);  // Par valeur
const dernier = fruits.pop();           // Dernier
const premier = fruits.shift();         // Premier

// Rechercher
if (fruits.includes("pomme")) {
    console.log("Trouvé !");
}

// Trier
fruits.sort();              // Modifie le tableau
const triee = [...fruits].sort();  // Copie triée

ArrayList<String> fruits = new ArrayList<>();
fruits.add("pomme");
fruits.add("banane");

// Ajouter
fruits.add("orange");        // À la fin
fruits.add(0, "kiwi");       // À l'index 0

// Supprimer
fruits.remove("banane");    // Par valeur
fruits.remove(0);           // Par index

// Rechercher
if (fruits.contains("pomme")) {
    System.out.println("Trouvé !");
}

// Trier
Collections.sort(fruits);

5

Map, Filter, Reduce

Transformer des tableaux de manière fonctionnelle

⚡ C'est quoi une lambda / fonction anonyme ?

Une lambda est une fonction sans nom, écrite sur une seule ligne. On l'utilise quand on a besoin d'une fonction rapide, juste pour une opération.

🐍 Python

lambda x: x * 2

→ "prend x, retourne x * 2"

🟨 JavaScript

x => x * 2

→ "arrow function" (flèche)

💡 On passe cette fonction à map/filter/reduce qui l'applique à chaque élément. C'est un callback !

🔄

map

Transformer chaque élément

🔍

filter

Garder certains éléments

📊

reduce

Réduire à une valeur

nombres = [1, 2, 3, 4, 5]

# map : doubler chaque nombre
doubles = list(map(lambda x: x * 2, nombres))
# [2, 4, 6, 8, 10]

# List comprehension (plus pythonique)
doubles = [x * 2 for x in nombres]

# filter : garder les pairs
pairs = list(filter(lambda x: x % 2 == 0, nombres))
# [2, 4]

# List comprehension
pairs = [x for x in nombres if x % 2 == 0]

# reduce : somme totale
from functools import reduce
total = reduce(lambda a, b: a + b, nombres)
# 15

# Plus simple
total = sum(nombres)  # 15

const nombres = [1, 2, 3, 4, 5];

// map : doubler chaque nombre
const doubles = nombres.map(x => x * 2);
// [2, 4, 6, 8, 10]
// x => x * 2 est une lambda (fonction anonyme)

// filter : garder les pairs
const pairs = nombres.filter(x => x % 2 === 0);
// [2, 4]

// reduce : somme totale
const total = nombres.reduce((acc, x) => acc + x, 0);
// 15  (0 = valeur initiale de l'accumulateur)

// Chaînage : enchaîner les opérations
const result = nombres
    .filter(x => x > 2)         // [3, 4, 5]
    .map(x => x * 2)             // [6, 8, 10]
    .reduce((a, b) => a + b, 0);  // 24

💡 Pourquoi utiliser ça ? Plus lisible que des boucles for, et on ne modifie jamais le tableau original (pas d'effets de bord). C'est le style "fonctionnel" !

6

Tableaux 2D (matrices)

Tableaux de tableaux (lignes et colonnes)

matrice[ligne][colonne]

[0,0]

[0,1]

[0,2]

[0,3]

[1,0]

[1,1]

[1,2]

[1,3]

[2,0]

[2,1]

[2,2]

[2,3]

# Matrice 3x3
matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

# Accès : matrice[ligne][colonne]
print(matrice[0][0])  # 1 (première ligne, première colonne)
print(matrice[1][2])  # 6 (deuxième ligne, troisième colonne)

# Parcourir
for ligne in matrice:
    for val in ligne:
        print(val, end=" ")
    print()

// Matrice 3x3
const matrice = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
];

// Accès : matrice[ligne][colonne]
console.log(matrice[0][0]);  // 1
console.log(matrice[1][2]);  // 6

// Parcourir
for (const ligne of matrice) {
    for (const val of ligne) {
        process.stdout.write(val + " ");
    }
    console.log();
}

// Matrice 3x3
int[][] matrice = {
    {1, 2, 3},
    {4, 5, 6},
    {7, 8, 9}
};

// Accès : matrice[ligne][colonne]
System.out.println(matrice[0][0]);  // 1
System.out.println(matrice[1][2]);  // 6

// Parcourir avec boucle classique
for (int i = 0; i < matrice.length; i++) {
    for (int j = 0; j < matrice[i].length; j++) {
        System.out.print(matrice[i][j] + " ");
    }
    System.out.println();
}

// Ou avec for-each
for (int[] ligne : matrice) {
    for (int val : ligne) {
        System.out.print(val + " ");
    }
    System.out.println();
}

# Matrice 3x3 avec matrix()
matrice <- matrix(
    c(1, 2, 3,
      4, 5, 6,
      7, 8, 9),
    nrow = 3, byrow = TRUE
)

# Accès : matrice[ligne, colonne] (commence à 1!)
print(matrice[1, 1])  # 1
print(matrice[2, 3])  # 6

# Ligne entière
print(matrice[1, ])   # [1] 1 2 3

# Colonne entière
print(matrice[, 2])   # [1] 2 5 8

# Afficher proprement
print(matrice)
#      [,1] [,2] [,3]
# [1,]    1    2    3
# [2,]    4    5    6
# [3,]    7    8    9

🎯

Quiz Mode Survie

1 erreur = Game Over

📦

Tableaux & Listes

10 questions aleatoires - Mode Survie

Tableaux & Listes

L'indexation commence à 0

C'est quoi un tableau ?

Créer un tableau

Accéder aux éléments

Opérations courantes

Map, Filter, Reduce

⚡ C'est quoi une lambda / fonction anonyme ?

Tableaux 2D (matrices)

📝 Ce qu'il faut retenir

Quiz Mode Survie

Tableaux & Listes

Pour aller plus loin