RÉPONSES BRUTES · NIVEAU 1
LANXAS Code — 30 réponses brutes
10 épreuves × 3 passes. Pour chacune : la question intégrale, la réponse brute non retouchée, la note des correcteurs v1 (scellé) et v2 (corrigé), et l'empreinte SHA-256 recalculable.
A1 · passe 1
note v1 : réussinote v2 : réussibug-pythonQuestion
Cette fonction Python contient un bug : elle oublie le dernier element de la liste. Corrige-la et renvoie la fonction complete, avec la meme signature `somme(lst)`.
```python
def somme(lst):
total = 0
for i in range(len(lst) - 1):
total += lst[i]
return total
```
Réponse brute (non retouchée)
## Diagnostic
La boucle utilise `range(len(lst) - 1)` : le dernier indice (`len(lst) - 1`) n'est jamais atteint. C'est l'erreur classique "off-by-one" en Python.
## Correction
```python
def somme(lst):
total = 0
for i in range(len(lst)):
total += lst[i]
return total
```
## Variante plus pythonique (recommandée)
```python
def somme(lst):
return sum(lst)
```
## Vérification
```python
assert somme([1, 2, 3, 4]) == 10 # ancien code : 6 (oubli du 4)
assert somme([5]) == 5
assert somme([]) == 0
```
Note : la fonction intégrée `sum()` gère nativement le cas de la liste vide sans initialiser `total`, et est plus rapide que la boucle manuelle.
A1 · passe 2
note v1 : réussinote v2 : réussibug-pythonQuestion
Cette fonction Python contient un bug : elle oublie le dernier element de la liste. Corrige-la et renvoie la fonction complete, avec la meme signature `somme(lst)`.
```python
def somme(lst):
total = 0
for i in range(len(lst) - 1):
total += lst[i]
return total
```
Réponse brute (non retouchée)
```python
def somme(lst):
total = 0
for i in range(len(lst)):
total += lst[i]
return total
```
**Diagnostic** : `range(len(lst) - 1)` produit les indices `0` à `len(lst) - 2`, donc le **dernier élément** (`lst[-1]`) n'est jamais additionné. C'est un classique off-by-one.
**Correctif** : remplacer par `range(len(lst))` pour itérer sur tous les indices.
Vérification rapide : `somme([1, 2, 3, 4])` → avant : `1+2+3 = 6` (manque 4). Après : `1+2+3+4 = 10` ✓.
**Variante plus pythonique** (si tu veux moderniser) :
```python
def somme(lst):
return sum(lst)
```
Mais si la contrainte est de garder la boucle `for`, la version corrigée ci-dessus respecte exactement la signature d'origine.
A1 · passe 3
note v1 : réussinote v2 : réussibug-pythonQuestion
Cette fonction Python contient un bug : elle oublie le dernier element de la liste. Corrige-la et renvoie la fonction complete, avec la meme signature `somme(lst)`.
```python
def somme(lst):
total = 0
for i in range(len(lst) - 1):
total += lst[i]
return total
```
Réponse brute (non retouchée)
## Diagnostic
Le bug est clair : `range(len(lst) - 1)` itère de `0` à `len(lst) - 2` inclus, donc le **dernier élément** (`lst[-1]`) n'est jamais additionné. Quand `lst` est vide, en plus, `range(-1)` produit une liste vide (ok), mais le vrai problème apparaît dès que `lst` contient au moins 1 élément.
## Correction
```python
def somme(lst):
if not isinstance(lst, (list, tuple)):
raise TypeError("somme() attend une liste ou un tuple")
total = 0
for x in lst:
total += x
return total
```
Trois corrections :
1. **Itération directe sur `lst`** au lieu d'un `range(len(...))` indexé → impossible désormais d'oublier un élément.
2. **Validation du type** en entrée → évite un `TypeError` cryptique si on passe autre chose qu'un itérable de nombres.
3. Le reste de la signature (`somme(lst)`) et le comportement (retourner la somme, `0` pour liste vide) sont préservés.
## Vérification rapide
```python
assert somme([]) == 0
assert somme([5]) == 5
assert somme([1, 2, 3, 4]) == 10
assert somme([10, -2, 5]) == 13
print("OK")
```
Note : si tu veux une version encore plus pythonique et performante, `return sum(lst)` fait exactement la même chose en une ligne — mais la version ci-dessus garde la boucle explicite pour rester proche de ta structure d'origine.
A2 · passe 1
note v1 : réussinote v2 : réussibug-jsQuestion
Ce code JavaScript a un bug : il utilise une comparaison laxiste. Corrige-le pour que `estIdentique(a, b)` renvoie true UNIQUEMENT si a et b ont le meme type ET la meme valeur. Renvoie la fonction complete `estIdentique(a, b)`.
```js
function estIdentique(a, b) {
return a == b;
}
```
Réponse brute (non retouchée)
```js
function estIdentique(a, b) {
return a === b;
}
```
A2 · passe 2
note v1 : réussinote v2 : réussibug-jsQuestion
Ce code JavaScript a un bug : il utilise une comparaison laxiste. Corrige-le pour que `estIdentique(a, b)` renvoie true UNIQUEMENT si a et b ont le meme type ET la meme valeur. Renvoie la fonction complete `estIdentique(a, b)`.
```js
function estIdentique(a, b) {
return a == b;
}
```
Réponse brute (non retouchée)
```js
function estIdentique(a, b) {
return a === b;
}
```
**Diagnostic** : l'opérateur `==` effectue une coercion de type (ex: `0 == false` → `true`, `null == undefined` → `true`), ce qui masque des différences réelles entre les valeurs.
**Correction** : remplacer `==` par `===` (égalité stricte) qui vérifie que le type ET la valeur sont identiques, sans aucune coercion.
```js
estIdentique(5, 5); // true
estIdentique(5, "5"); // false (number !== string)
estIdentique(null, undefined); // false (types différents)
estIdentique(0, false); // false (number !== boolean)
```
A2 · passe 3
note v1 : réussinote v2 : réussibug-jsQuestion
Ce code JavaScript a un bug : il utilise une comparaison laxiste. Corrige-le pour que `estIdentique(a, b)` renvoie true UNIQUEMENT si a et b ont le meme type ET la meme valeur. Renvoie la fonction complete `estIdentique(a, b)`.
```js
function estIdentique(a, b) {
return a == b;
}
```
Réponse brute (non retouchée)
Diagnostic : le `==` effectue une coercition de type (ex. `"5" == 5` -> `true`, `null == undefined` -> `true`, `0 == false` -> `true`). On le remplace par `===` qui exige identité de type ET de valeur.
```js
function estIdentique(a, b) {
if (typeof a !== typeof b) {
return false;
}
return a === b;
}
```
Vérifications clés :
- `estIdentique(5, 5)` -> `true`
- `estIdentique("5", 5)` -> `false` (types différents)
- `estIdentique(null, undefined)` -> `false`
- `estIdentique(NaN, NaN)` -> `true` (`NaN === NaN` est `true` en `===`, contrairement à `==`)
Note : pour un cas NaN-safe renforcé, on peut ajouter `Number.isNaN(a) && Number.isNaN(b)`, mais ici le `===` suffit car `NaN === NaN` retourne bien `true` en JavaScript.
B2 · passe 1
note v1 : réussinote v2 : réussialgoQuestion
Ecris un programme Python qui affiche FizzBuzz de 1 a 50, un resultat par ligne. Multiples de 3 -> Fizz, multiples de 5 -> Buzz, multiples de 15 -> FizzBuzz, sinon le nombre lui-meme.
Réponse brute (non retouchée)
```python
for n in range(1, 51):
if n % 15 == 0:
print("FizzBuzz")
elif n % 3 == 0:
print("Fizz")
elif n % 5 == 0:
print("Buzz")
else:
print(n)
```
B2 · passe 2
note v1 : réussinote v2 : réussialgoQuestion
Ecris un programme Python qui affiche FizzBuzz de 1 a 50, un resultat par ligne. Multiples de 3 -> Fizz, multiples de 5 -> Buzz, multiples de 15 -> FizzBuzz, sinon le nombre lui-meme.
Réponse brute (non retouchée)
```python
def fizzbuzz(n: int) -> str:
if n % 15 == 0:
return "FizzBuzz"
if n % 3 == 0:
return "Fizz"
if n % 5 == 0:
return "Buzz"
return str(n)
if __name__ == "__main__":
for i in range(1, 51):
print(fizzbuzz(i))
```
Sortie (extrait) :
```
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
...
```
Note : l'ordre des tests compte - on vérifie `n % 15` en premier pour que les multiples de 15 (donc de 3 et de 5) soient étiquetés `FizzBuzz` au lieu de tomber dans les branches `Fizz` ou `Buzz`.
B2 · passe 3
note v1 : réussinote v2 : réussialgoQuestion
Ecris un programme Python qui affiche FizzBuzz de 1 a 50, un resultat par ligne. Multiples de 3 -> Fizz, multiples de 5 -> Buzz, multiples de 15 -> FizzBuzz, sinon le nombre lui-meme.
Réponse brute (non retouchée)
```python
for n in range(1, 51):
if n % 15 == 0:
print("FizzBuzz")
elif n % 3 == 0:
print("Fizz")
elif n % 5 == 0:
print("Buzz")
else:
print(n)
```
Note : l'ordre des conditions est important — `n % 15 == 0` doit être testé **avant** `n % 3 == 0` et `n % 5 == 0`, sinon les multiples de 15 seraient capturés en premier par Fizz ou Buzz.
B4 · passe 1
note v1 : échecnote v2 : réussialgoQuestion
Ecris une fonction Python `dedup(lst)` qui supprime les doublons d'une liste tout en conservant l'ordre de premiere apparition.
Réponse brute (non retouchée)
Voici une fonction `dedup` propre et performante qui préserve l'ordre de première apparition.
```python
def dedup(lst):
"""
Supprime les doublons d'une liste en conservant l'ordre de première apparition.
Args:
lst (list): La liste d'entrée (les éléments doivent être hashables).
Returns:
list: Une nouvelle liste sans doublons, dans l'ordre d'apparition initial.
"""
seen = set()
result = []
for item in lst:
if item not in seen:
seen.add(item)
result.append(item)
return result
```
Quelques points d'implémentation :
- **Complexité O(n)** : un seul parcours de la liste grâce au `set` pour les tests d'appartenance en O(1).
- **Ordre préservé** : on itère dans l'ordre et on ajoute à `result` à la première rencontre.
- **Prérequis** : les éléments doivent être *hashables* (strings, nombres, tuples, etc.). Pour des objets non hashables (listes, dicts), une version avec clé de conversion est nécessaire.
Variante pour éléments non hashables :
```python
def dedup_unhashable(lst, key=None):
"""Version tolérant les éléments non hashables (listes, dicts...)."""
seen = set()
result = []
for item in lst:
k = key(item) if key else _make_hashable(item)
if k not in seen:
seen.add(k)
result.append(item)
return result
def _make_hashable(item):
"""Convertit récursivement un objet en une forme hashable pour la dédup."""
if isinstance(item, dict):
return tuple(sorted((k, _make_hashable(v)) for k, v in item.items()))
if isinstance(item, (list, tuple, set)):
return tuple(_make_hashable(x) for x in item)
try:
hash(item)
return item
except TypeError:
return repr(item)
```
Exemple rapide :
```python
>>> dedup([3, 1, 4, 1, 5, 9, 2, 6, 5, 3])
[3, 1, 4, 5, 9, 2, 6]
>>> dedup(['a', 'b', 'a', 'c', 'b'])
['a', 'b', 'c']
```
Note : si l'objectif est simplement de dédupliquer sans contrainte d'ordre, on peut écrire `list(dict.fromkeys(lst))` (Python 3.7+) — solution courte et idiomatique qui préserve aussi l'ordre d'insertion.
B4 · passe 2
note v1 : échecnote v2 : réussialgoQuestion
Ecris une fonction Python `dedup(lst)` qui supprime les doublons d'une liste tout en conservant l'ordre de premiere apparition.
Réponse brute (non retouchée)
# `dedup` — Suppression des doublons en préservant l'ordre
Voici la version la plus propre et la plus rapide (O(n), une seule passe) :
```python
def dedup(lst):
"""
Supprime les doublons de lst en conservant l'ordre de premiere apparition.
>>> dedup([1, 2, 2, 3, 4, 3, 5])
[1, 2, 3, 4, 5]
>>> dedup([])
[]
>>> dedup(['a', 'b', 'a', 'c'])
['a', 'b', 'c']
"""
vus = set()
resultat = []
for x in lst:
if x not in vus:
vus.add(x)
resultat.append(x)
return resultat
```
## Variantes utiles
**Non-hashable** (listes, dicts, objets) — O(n²) :
```python
def dedup_unhashable(lst):
vus, resultat = [], []
for x in lst:
if x not in vus: # 'in' sur liste = O(n)
vus.append(x)
resultat.append(x)
return resultat
```
**Paresseux** (générateur, zéro copie intermédiaire) :
```python
def dedup_iter(lst):
vus = set()
for x in lst:
if x not in vus:
vus.add(x)
yield x
```
**Une ligne avec `dict.fromkeys`** (Python ≥ 3.7, dict ordonné) :
```python
def dedup(lst):
return list(dict.fromkeys(lst))
```
## Tests rapides
```python
assert dedup([1, 2, 2, 3, 4, 3, 5]) == [1, 2, 3, 4, 5]
assert dedup([]) == []
assert dedup(['a', 'b', 'a', 'c']) == ['a', 'b', 'c']
assert dedup([1, 1, 1, 1]) == [1]
assert dedunhashable := dedup_unhashable([[1], [1], [2], [1]]) == [[1], [2]] # noqa
```
**Recommandation** : garde la première version avec `set` pour les données hashables (99% des cas). Elle est plus rapide que `dict.fromkeys` quand les doublons sont fréquents, car elle évite de matérialiser un dict complet avant la conversion en liste.
B4 · passe 3
note v1 : échecnote v2 : réussialgoQuestion
Ecris une fonction Python `dedup(lst)` qui supprime les doublons d'une liste tout en conservant l'ordre de premiere apparition.
Réponse brute (non retouchée)
Voici la fonction `dedup(lst)` :
```python
def dedup(lst):
"""Supprime les doublons tout en conservant l'ordre de première apparition."""
seen = set()
result = []
for item in lst:
if item not in seen:
seen.add(item)
result.append(item)
return result
```
**Explication :**
- `seen` (set) : enregistre les éléments déjà rencontrés, pour une vérification en O(1).
- `result` (list) : reconstruit la liste en ne gardant que la première occurrence de chaque élément.
- Parcours linéaire : complexité temporelle **O(n)** et spatiale **O(n)**.
**Tests rapides :**
```python
assert dedup([1, 2, 2, 3, 4, 1, 5]) == [1, 2, 3, 4, 5]
assert dedup(["a", "b", "a", "c", "b"]) == ["a", "b", "c"]
assert dedup([]) == []
assert dedup([1, 1, 1, 1]) == [1]
assert dedup([True, False, True, 1, 0]) == [True, False, 1, 0] # distincts via identité/égalité
```
Note : si tu dois dédupliquer en **préservant l'ordre d'apparition d'un grand flux** sans tout stocker en mémoire, préfère une variante itérable paresseuse avec un générateur :
```python
def dedup_iter(lst):
seen = set()
for item in lst:
if item not in seen:
seen.add(item)
yield item
```
Si tu utilises déjà Python 3.7+, la garantie d'ordre des `dict` permet aussi une version ultra-courte :
```python
def dedup(lst):
return list(dict.fromkeys(lst))
```
Les éléments doivent simplement être *hashables* (ce qui est déjà requis par la version `set`).
C1 · passe 1
note v1 : réussinote v2 : réussiwebQuestion
Ecris une page HTML complete et autonome (aucune bibliotheque externe, aucun CDN) contenant un bouton qui, au clic, change la couleur de fond de la page.
Réponse brute (non retouchée)
```html
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<title>Changement de couleur</title>
<style>
html, body {
height: 100%;
margin: 0;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
transition: background-color 0.4s ease;
}
body {
display: flex;
align-items: center;
justify-content: center;
}
.container {
text-align: center;
padding: 2rem;
border-radius: 12px;
background: rgba(255, 255, 255, 0.85);
box-shadow: 0 10px 30px rgba(0, 0, 0, 0.15);
}
h1 {
margin: 0 0 1rem;
font-size: 1.5rem;
}
button {
padding: 0.75rem 1.5rem;
font-size: 1rem;
border: none;
border-radius: 8px;
background: #2563eb;
color: #fff;
cursor: pointer;
transition: transform 0.1s ease, background 0.2s ease;
}
button:hover { background: #1d4ed8; }
button:active { transform: scale(0.97); }
button:focus-visible {
outline: 3px solid #93c5fd;
outline-offset: 2px;
}
#colorLabel {
margin-top: 1rem;
font-family: monospace;
color: #374151;
}
</style>
</head>
<body>
<div class="container">
<h1>Clique pour changer la couleur</h1>
<button id="colorBtn" type="button">Changer la couleur</button>
<div id="colorLabel"></div>
</div>
<script>
(function () {
var COLORS = [
"#ef4444", "#f59e0b", "#10b981",
"#3b82f6", "#8b5cf6", "#ec4899",
"#14b8a6", "#f97316", "#64748b"
];
var btn = document.getElementById("colorBtn");
var label = document.getElementById("colorLabel");
var index = 0;
btn.addEventListener("click", function () {
index = (index + 1) % COLORS.length;
var color = COLORS[index];
document.body.style.backgroundColor = color;
label.textContent = "Couleur actuelle : " + color;
});
})();
</script>
</body>
</html>
```
C1 · passe 2
note v1 : réussinote v2 : réussiwebQuestion
Ecris une page HTML complete et autonome (aucune bibliotheque externe, aucun CDN) contenant un bouton qui, au clic, change la couleur de fond de la page.
Réponse brute (non retouchée)
```html
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Changeur de couleur</title>
<style>
* {
margin: 0;
padding: 0;
box-sizing: border-box;
}
body {
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, sans-serif;
min-height: 100vh;
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
transition: background-color 0.5s ease;
background-color: #f0f0f0;
}
.container {
text-align: center;
padding: 2rem;
background: rgba(255, 255, 255, 0.9);
border-radius: 12px;
box-shadow: 0 4px 20px rgba(0, 0, 0, 0.1);
max-width: 500px;
width: 90%;
}
h1 {
color: #333;
margin-bottom: 1rem;
font-size: 1.8rem;
}
p {
color: #666;
margin-bottom: 2rem;
font-size: 1rem;
}
#colorButton {
background-color: #4a90e2;
color: white;
border: none;
padding: 12px 32px;
font-size: 1rem;
font-weight: 600;
border-radius: 8px;
cursor: pointer;
transition: transform 0.2s ease, background-color 0.3s ease;
}
#colorButton:hover {
background-color: #357abd;
transform: translateY(-2px);
}
#colorButton:active {
transform: translateY(0);
}
.color-display {
margin-top: 1.5rem;
font-family: "Courier New", monospace;
color: #444;
font-size: 0.9rem;
}
</style>
</head>
<body>
<div class="container">
<h1>Changeur de couleur de fond</h1>
<p>Cliquez sur le bouton pour changer aleatoirement la couleur de fond de la page.</p>
<button id="colorButton" type="button">Changer la couleur</button>
<div class="color-display" id="colorDisplay">Couleur actuelle : #f0f0f0</div>
</div>
<script>
(function () {
var button = document.getElementById('colorButton');
var display = document.getElementById('colorDisplay');
var body = document.body;
function getRandomColor() {
// Genere une couleur hexadecimale aleatoire
var letters = '0123456789ABCDEF';
var color = '#';
for (var i = 0; i < 6; i++) {
color += letters.charAt(Math.floor(Math.random() * 16));
}
return color;
}
function toHex(value) {
var hex = value.toString(16);
return hex.length === 1 ? '0' + hex : hex;
}
function rgbToHex(r, g, b) {
return '#' + toHex(r) + toHex(g) + toHex(b);
}
function handleClick() {
var newColor = getRandomColor();
body.style.backgroundColor = newColor;
display.textContent = 'Couleur actuelle : ' + newColor;
}
if (button) {
button.addEventListener('click', handleClick);
}
})();
</script>
</body>
</html>
```
Page HTML autonome, aucun CDN, aucune bibliotheque externe. Le bouton genere une couleur hexadecimale aleatoire et l'applique au `background-color` du `body` avec une transition CSS de 0.5s pour un rendu fluide. La couleur courante est affichee sous le bouton. Le JavaScript est encapsule dans une IIFE pour eviter de polluer la portee globale.
C1 · passe 3
note v1 : réussinote v2 : réussiwebQuestion
Ecris une page HTML complete et autonome (aucune bibliotheque externe, aucun CDN) contenant un bouton qui, au clic, change la couleur de fond de la page.
Réponse brute (non retouchée)
```html
<!DOCTYPE html>
<html lang="fr">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Changeur de couleur de fond</title>
<style>
* {
box-sizing: border-box;
margin: 0;
padding: 0;
}
html, body {
height: 100%;
font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,
Helvetica, Arial, sans-serif;
}
body {
display: flex;
flex-direction: column;
align-items: center;
justify-content: center;
gap: 1.5rem;
padding: 2rem;
background-color: #f5f5f5;
color: #222;
transition: background-color 0.4s ease, color 0.4s ease;
}
h1 {
font-size: clamp(1.4rem, 3vw, 2.2rem);
text-align: center;
}
p {
max-width: 38rem;
text-align: center;
line-height: 1.5;
opacity: 0.85;
}
.controls {
display: flex;
flex-wrap: wrap;
gap: 0.75rem;
justify-content: center;
}
button {
font: inherit;
cursor: pointer;
padding: 0.75rem 1.5rem;
border: 2px solid currentColor;
border-radius: 8px;
background: transparent;
color: inherit;
transition: transform 0.15s ease, background-color 0.15s ease;
}
button:hover {
transform: translateY(-1px);
}
button:active {
transform: translateY(0);
}
button:focus-visible {
outline: 3px solid #4a90e2;
outline-offset: 2px;
}
.swatch {
display: inline-block;
width: 0.9em;
height: 0.9em;
border: 1px solid rgba(0, 0, 0, 0.25);
border-radius: 3px;
vertical-align: middle;
margin-right: 0.4em;
}
.current {
margin-top: 0.5rem;
font-variant-numeric: tabular-nums;
font-size: 0.95rem;
opacity: 0.8;
}
</style>
</head>
<body>
<h1>Changeur de couleur de fond</h1>
<p>
Cliquez sur le bouton pour appliquer une couleur aleatoire au fond de la page.
Le texte s ajuste automatiquement pour rester lisible.
</p>
<div class="controls">
<button id="changeBtn" type="button" aria-label="Changer la couleur de fond">
Changer la couleur
</button>
<button id="resetBtn" type="button" aria-label="Reinitialiser la couleur">
Reinitialiser
</button>
</div>
<div class="current" aria-live="polite">
Couleur actuelle :
<span class="swatch" id="swatch"></span>
<span id="hexLabel">#f5f5f5</span>
</div>
<script>
(function () {
"use strict";
var DEFAULT_COLOR = "#f5f5f5";
var body = document.body;
var btn = document.getElementById("changeBtn");
var resetBtn = document.getElementById("resetBtn");
var swatch = document.getElementById("swatch");
var hexLabel = document.getElementById("hexLabel");
function toHex(value) {
var hex = value.toString(16);
return hex.length === 1 ? "0" + hex : hex;
}
function randomHexColor() {
// Evite le noir et le blanc purs pour garder un contraste acceptable.
var r = Math.floor(Math.random() * 230) + 12; // 12..241
var g = Math.floor(Math.random() * 230) + 12;
var b = Math.floor(Math.random() * 230) + 12;
return "#" + toHex(r) + toHex(g) + toHex(b);
}
function luminance(r, g, b) {
// Luminosite relative selon WCAG (sRGB -> linear approx).
var channel = function (c) {
c = c / 255;
return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
};
return 0.2126 * channel(r) + 0.7152 * channel(g) + 0.0722 * channel(b);
}
function parseHex(hex) {
var h = hex.replace("#", "");
if (h.length === 3) {
h = h.split("").map(function (c) { return c + c; }).join("");
}
var num = parseInt(h, 16);
return {
r: (num >> 16) & 255,
g: (num >> 8) & 255,
b: num & 255
};
}
function applyColor(hex) {
body.style.backgroundColor = hex;
var rgb = parseHex(hex);
body.style.color = luminance(rgb.r, rgb.g, rgb.b) > 0.5 ? "#222" : "#fff";
swatch.style.backgroundColor = hex;
hexLabel.textContent = hex.toUpperCase();
}
btn.addEventListener("click", function () {
applyColor(randomHexColor());
});
resetBtn.addEventListener("click", function () {
applyColor(DEFAULT_COLOR);
});
// Initialisation : reflete la couleur par defaut dans les etiquettes.
applyColor(DEFAULT_COLOR);
})();
</script>
</body>
</html>
```
Quelques points cles du code :
- **Aucun CDN ni bibliotheque externe** : tout est en HTML, CSS et JavaScript natifs.
- **Aleatoire securise** : `randomHexColor()` genere une couleur en evitant le noir et le blanc purs, pour garder un contraste lisible.
- **Contraste automatique du texte** : `luminance()` suit la formule WCAG (sRGB -> lineaire) ; au-dessus de 0.5 le texte devient sombre, sinon clair.
- **Accessibilite** : `aria-label` sur les boutons, `aria-live="polite"` sur l'indicateur de couleur, `:focus-visible` bien defini, bouton "Reinitialiser" fourni.
- **Robustesse** : le code est encapsule dans une IIFE en `"use strict"`, gere les formats hex courts et longs, et met a jour le texte ainsi que le petit swatch en synchro.
Pour l'utiliser, copiez le contenu dans un fichier `index.html` et ouvrez-le directement dans un navigateur.
C3 · passe 1
note v1 : échecnote v2 : réussiwebQuestion
Ecris une fonction JavaScript asynchrone `chargerDonnees(url)` qui : fait un fetch de l'url, verifie que la reponse est OK (sinon leve une erreur), parse le JSON et le renvoie. En cas d'erreur (reseau ou statut HTTP non OK), elle attrape l'erreur avec try/catch et renvoie null.
Réponse brute (non retouchée)
Voici la fonction demandée :
```javascript
/**
* Charge des données JSON depuis une URL.
* @param {string} url - L'URL à interroger.
* @returns {Promise<object|null>} Les données JSON parsées, ou null en cas d'erreur.
*/
async function chargerDonnees(url) {
try {
const reponse = await fetch(url);
if (!reponse.ok) {
throw new Error(`Erreur HTTP ${reponse.status} : ${reponse.statusText}`);
}
const donnees = await reponse.json();
return donnees;
} catch (erreur) {
console.error(`Échec du chargement depuis ${url} :`, erreur.message);
return null;
}
}
```
**Points clés :**
- **`reponse.ok`** : propriété booléenne à `true` uniquement si le statut HTTP est entre 200 et 299. Toute erreur réseau (DNS, CORS, timeout) tombe directement dans le `catch` car `fetch` rejette la promesse.
- **Distinction des erreurs** : un statut HTTP non-OK est levé manuellement via `throw` pour être traité dans le même `catch` que les erreurs réseau — un seul point de sortie vers `null`.
- **Contrat respecté** : la fonction ne jette jamais, elle retourne toujours soit les données, soit `null`.
**Exemples d'utilisation :**
```javascript
// Succès
const utilisateurs = await chargerDonnees('/api/utilisateurs');
if (utilisateurs) {
console.table(utilisateurs);
}
// Erreur 404
const donnees = await chargerDonnees('/api/inexistant');
console.log(donnees); // null
// Erreur réseau (mauvais host)
const ko = await chargerDonnees('https://host-inexistant.test/data');
console.log(ko); // null
```
**Variante plus stricte** (si tu veux distinguer « pas de données » de « erreur ») :
```javascript
async function chargerDonneesStrict(url) {
try {
const r = await fetch(url);
if (!r.ok) throw new Error(`HTTP ${r.status}`);
return { ok: true, data: await r.json() };
} catch (e) {
return { ok: false, erreur: e.message };
}
}
```
La première version suffit si ton seul besoin est « données ou `null` ». Veux-tu que je l'intègre dans un fichier de ton projet ?
C3 · passe 2
note v1 : réussinote v2 : réussiwebQuestion
Ecris une fonction JavaScript asynchrone `chargerDonnees(url)` qui : fait un fetch de l'url, verifie que la reponse est OK (sinon leve une erreur), parse le JSON et le renvoie. En cas d'erreur (reseau ou statut HTTP non OK), elle attrape l'erreur avec try/catch et renvoie null.
Réponse brute (non retouchée)
```javascript
async function chargerDonnees(url) {
try {
const reponse = await fetch(url);
if (!reponse.ok) {
throw new Error(`Erreur HTTP ${reponse.status} : ${reponse.statusText}`);
}
const donnees = await reponse.json();
return donnees;
} catch (erreur) {
console.error(`chargerDonnees(${url}) a échoué :`, erreur.message);
return null;
}
}
```
Notes :
- `reponse.ok` couvre les statuts 200-299 et lève une erreur explicite pour 4xx/5xx avec un message précis (utile pour le debug).
- Le `try/catch` capture à la fois les erreurs réseau (DNS, offline, CORS) et les erreurs HTTP non-OK, conformément à la consigne.
- Erreur de parsing JSON également couverte (un JSON invalide fait échouer `reponse.json()` qui throw).
- On retourne `null` au lieu de propager pour respecter la signature demandée, mais on logge l'erreur côté console — si tu préfères un comportement strict (propage l'erreur), remplace le `catch` par un rethrow.
C3 · passe 3
note v1 : échecnote v2 : réussiwebQuestion
Ecris une fonction JavaScript asynchrone `chargerDonnees(url)` qui : fait un fetch de l'url, verifie que la reponse est OK (sinon leve une erreur), parse le JSON et le renvoie. En cas d'erreur (reseau ou statut HTTP non OK), elle attrape l'erreur avec try/catch et renvoie null.
Réponse brute (non retouchée)
Voici une implémentation propre, sécurisée et prête à l'emploi :
```javascript
/**
* Charge des données JSON depuis une URL.
* @param {string} url - URL de la ressource à récupérer.
* @returns {Promise<object|null>} Les données JSON parsées, ou null en cas d'erreur.
*/
async function chargerDonnees(url) {
// Validation de l'entrée : évite de lancer un fetch invalide (ex: undefined)
if (typeof url !== 'string' || url.trim() === '') {
console.error('chargerDonnees : URL invalide.');
return null;
}
try {
const reponse = await fetch(url, {
headers: { Accept: 'application/json' },
});
// Statut HTTP non OK (4xx, 5xx) -> on lève une erreur explicite
if (!reponse.ok) {
throw new Error(`Erreur HTTP ${reponse.status} : ${reponse.statusText}`);
}
// Parse JSON sécurisé : si le body n'est pas du JSON valide, SyntaxError -> catch
const donnees = await reponse.json();
return donnees;
} catch (erreur) {
// Couvre : erreur réseau, URL mal formée, statut non OK, JSON invalide
console.error(`chargerDonnees a échoué pour "${url}" :`, erreur.message);
return null;
}
}
```
**Points clés**
- **Validation préalable** de `url` : évite un crash sur `fetch(undefined)` et retourne `null` proprement.
- **Header `Accept: application/json`** : signale au serveur le format attendu (certains serveurs renvoient du HTML sur erreur).
- **`reponse.ok`** couvre tous les statuts 200–299 ; tout le reste (404, 500…) lève une erreur claire avec code et message HTTP.
- **Parse JSON dans le `try`** : si le serveur répond `200 OK` mais avec du HTML ou un corps vide, `reponse.json()` jette `SyntaxError` -> capturé.
- **`catch` unifié** : réseau, HTTP, JSON invalide, CORS, URL malformée — tout renvoie `null` comme demandé.
- **Aucun throw remonté** : l'API publique de la fonction est strictement `T | null`, simple à consommer côté appelant.
**Exemple d'utilisation**
```javascript
const utilisateurs = await chargerDonnees('/api/utilisateurs');
if (utilisateurs === null) {
afficherMessageErreur('Impossible de charger les utilisateurs.');
return;
}
utilisateurs.forEach(u => console.log(u.nom));
```
Note : si tu veux distinguer "erreur réseau" de "ressource introuvable (404)", remplace le `return null` final par un `throw` ou expose un objet `{ data, erreur }` — dis-le-moi et j'adapte.
D3 · passe 1
note v1 : réussinote v2 : réussisqlQuestion
Sur une table `commandes(id, client, montant)`, ecris une requete SQL qui renvoie, pour chaque client, le nombre de commandes, triee par nombre decroissant. Les deux colonnes du resultat doivent s'appeler exactement `client` et `nb`.
Réponse brute (non retouchée)
```sql
SELECT client, COUNT(*) AS nb
FROM commandes
GROUP BY client
ORDER BY nb DESC;
```
D3 · passe 2
note v1 : réussinote v2 : réussisqlQuestion
Sur une table `commandes(id, client, montant)`, ecris une requete SQL qui renvoie, pour chaque client, le nombre de commandes, triee par nombre decroissant. Les deux colonnes du resultat doivent s'appeler exactement `client` et `nb`.
Réponse brute (non retouchée)
Requête SQL :
```sql
SELECT client, COUNT(*) AS nb
FROM commandes
GROUP BY client
ORDER BY nb DESC;
```
Notes :
- `COUNT(*)` compte toutes les lignes du groupe (équivalent ici à `COUNT(id)` puisque `id` est probablement non nul).
- `GROUP BY client` agrège par client ; toutes les colonnes du `SELECT` hors agrégation doivent apparaître dans le `GROUP BY` — ici c'est le cas.
- `ORDER BY nb DESC` trie par nombre décroissant (l'alias `nb` est utilisable dans `ORDER BY` selon le standard SQL et supporté par tous les SGBD courants : PostgreSQL, MySQL, SQLite, SQL Server, Oracle).
- Si un client peut apparaître avec des `NULL` dans la colonne `client`, ils seront regroupés dans un même groupe (le `NULL` est traité comme une valeur unique). Si tu veux les exclure : `WHERE client IS NOT NULL` avant le `GROUP BY`.
- En cas d'égalité sur `nb`, l'ordre entre clients est indéterminé ; pour le rendre déterministe ajoute un second critère : `ORDER BY nb DESC, client ASC`.
D3 · passe 3
note v1 : réussinote v2 : réussisqlQuestion
Sur une table `commandes(id, client, montant)`, ecris une requete SQL qui renvoie, pour chaque client, le nombre de commandes, triee par nombre decroissant. Les deux colonnes du resultat doivent s'appeler exactement `client` et `nb`.
Réponse brute (non retouchée)
```sql
SELECT client, COUNT(*) AS nb
FROM commandes
GROUP BY client
ORDER BY nb DESC;
```
Variante si tu veux garder les clients sans commande hors du resultat (ils ne sont de toute façon pas dans la table `commandes`, donc l'effet est le même ici) :
```sql
SELECT client, COUNT(*) AS nb
FROM commandes
GROUP BY client
ORDER BY nb DESC, client ASC;
```
Note : `COUNT(*)` compte toutes les lignes, y compris les commandes à 0 €. Si tu veux ignorer les montants nuls ou invalides, utilise plutôt `COUNT(montant)` ou `COUNT(DISTINCT id)` selon ton besoin métier.
E1 · passe 1
note v1 : réussinote v2 : réussimathsQuestion
Une facture a un montant HT de 250,00 EUR. Avec une TVA a 20 %, quel est le montant TTC ? Donne le resultat numerique.
Réponse brute (non retouchée)
250,00 EUR HT × (1 + 20 %) = 250,00 × 1,20 = **300,00 EUR TTC**.
E1 · passe 2
note v1 : réussinote v2 : réussimathsQuestion
Une facture a un montant HT de 250,00 EUR. Avec une TVA a 20 %, quel est le montant TTC ? Donne le resultat numerique.
Réponse brute (non retouchée)
Montant TTC : **300,00 EUR**
Calcul : 250,00 × 1,20 = 300,00 EUR (TVA = 50,00 EUR).
E1 · passe 3
note v1 : réussinote v2 : réussimathsQuestion
Une facture a un montant HT de 250,00 EUR. Avec une TVA a 20 %, quel est le montant TTC ? Donne le resultat numerique.
Réponse brute (non retouchée)
250,00 EUR HT × 1,20 = **300,00 EUR TTC**.
Détails du calcul :
- TVA (20 %) : 250,00 × 0,20 = 50,00 EUR
- TTC : 250,00 + 50,00 = **300,00 EUR**
F1 · passe 1
note v1 : réussinote v2 : réussiconnaissances-liensQuestion
Comment connaitre la derniere version LTS de Node.js ? Donne aussi le lien officiel cliquable vers la page de telechargement / versions de Node.js.
Réponse brute (non retouchée)
# Dernière version LTS de Node.js
## Comment la connaître
La version LTS (Long Term Support) actuelle de Node.js suit le calendrier de sortie officiel. Voici comment la vérifier toi-même, à jour :
**Méthode officielle Node.js :**
Le projet Node.js suit un calendrier de release publié et mis à jour sur GitHub. Le fichier `schedule.json` (source de vérité) est consultable ici :
- [Calendrier des releases Node.js (schedule.json)](https://raw.githubusercontent.com/nodejs/Release/main/schedule.json)
**Méthode rapide en ligne de commande** (si Node est déjà installé) :
```bash
# Affiche la version installée et indique si elle est LTS
node --version
# Via le gestionnaire de version n (recommandé)
n lts
# Ou avec fnm
fnm list --lts
```
**Vérification en temps réel :**
- [Page des releases GitHub](https://github.com/nodejs/node/releases) — la release LTS active est toujours la première marquée `vXX.Y.Z (LTS)`.
- [API dist.nodejs.org](https://api.github.com/repos/nodejs/node/releases) — JSON exploitable par script.
## Cycle de release (rappel)
Node.js publie :
- **Current** : nouvelle version tous les 6 mois (avril, octobre) — odd-numbered (ex: v23)
- **Active LTS** : entre dans ce statut juste après la sortie de la version suivante
- **Maintenance LTS** : quand une nouvelle LTS entre en maintenance (≈ 18 mois après la mise en LTS)
- **End-of-Life** : fin de support
Les versions **even-numbered** (20, 22, 24…) sont les versions LTS.
## Liens officiels
- [Page de téléchargement Node.js (toutes plateformes)](https://nodejs.org/en/download)
- [Page des téléchargements LTS](https://nodejs.org/en/download)
- [Index complet des versions (dist)](https://nodejs.org/dist/)
- [Calendrier des releases](https://github.com/nodejs/release)
- [Politique de support à long terme](https://nodejs.org/en/about/previous-releases)
## Pour un serveur de production
Toujours privilégier la dernière version **Active LTS** (ex: v22.x) plutôt que Current. Active LTS reçoit les nouvelles fonctionnalités, corrections de bugs et correctifs de sécurité pendant ~12 mois supplémentaires avant de basculer en Maintenance LTS.
```bash
# Exemple : installer la dernière LTS via n (Linux/macOS)
npm install -g n
n lts
```
Si tu veux, je peux écrire un script qui interroge l'API GitHub et affiche la dernière LTS avec sa date de fin de support — dis-moi simplement.
F1 · passe 2
note v1 : réussinote v2 : réussiconnaissances-liensQuestion
Comment connaitre la derniere version LTS de Node.js ? Donne aussi le lien officiel cliquable vers la page de telechargement / versions de Node.js.
Réponse brute (non retouchée)
La dernière version LTS de Node.js est la **v22** (Nom de code : "Jod"). C'est la version LTS active depuis octobre 2024 et restera supportée jusqu'en avril 2027 (maintenance LTS) puis octobre 2027 (security maintenance).
Liens officiels :
- Page des téléchargements : [Node.js Downloads](https://nodejs.org/en/download)
- Index complet de toutes les versions : [Node.js Releases](https://nodejs.org/en/about/previous-releases)
- Calendrier de support LTS : [Node.js Release Schedule](https://nodejs.org/en/about/previous-releases#release-schedule)
- Distributions précompilées par version : [nodejs.org/dist](https://nodejs.org/dist)
Si tu veux connaître la version exacte la plus récente (par exemple la dernière patch 22.x), lance ces deux commandes :
```bash
# Version LTS recommandée
node -e "console.log(process.versions.node)"
# Ou pour interroger directement l'API officielle
curl -s https://nodejs.org/dist/index.json | python -c "import json,sys; data=json.load(sys.stdin); lts=[v for v in data if v.get('lts')]; print('Latest LTS:', lts[0]['version'], '-', lts[0]['lts'])"
```
Note pratique : Node.js publie deux lignes LTS en parallèle — la LTS active (Jod 22.x) et la LTS de maintenance (Iron 20.x). Pour un nouveau projet, privilégie la v22 ; pour rester sur la 20, prends la dernière 20.x sur la page des releases.
F1 · passe 3
note v1 : réussinote v2 : réussiconnaissances-liensQuestion
Comment connaitre la derniere version LTS de Node.js ? Donne aussi le lien officiel cliquable vers la page de telechargement / versions de Node.js.
Réponse brute (non retouchée)
Bonjour Aurelie,
Bonne nouvelle : la derniere version LTS de Node.js est **Node.js 22 "Jod"** (Active LTS depuis le 29 octobre 2024, maintenance prevue jusqu avril 2027, puis LTS Maintenance jusqu avril 2028).
Liens officiels cliquables :
- Page de telechargement principale : [https://nodejs.org/en/download](https://nodejs.org/en/download)
- Index de toutes les versions : [https://nodejs.org/en/download/releases](https://nodejs.org/en/download/releases)
- Plan de release officiel (calendrier LTS / EOL) : [https://nodejs.org/en/about/previous-releases](https://nodejs.org/en/about/previous-releases)
- Annonce de l entree LTS de v22 (blog officiel) : [https://nodejs.org/en/blog/announcements/v22-release-announce](https://nodejs.org/en/blog/announcements/v22-release-announce)
Comment verifier toi-meme a tout moment (3 methodes, de la plus sure a la plus rapide) :
1) Ligne de commande (instantanable)
```bash
# Affiche la derniere version stable disponible sur le site officiel
curl -s https://nodejs.org/dist/index.json | node -e "let d='';process.stdin.on('data',c=>d+=c).on('end',()=>{const j=JSON.parse(d);const lts=j.find(v=>v.lts);console.log('Latest LTS :',lts.version,'(',lts.lts,')');console.log('Date :',lts.date);});"
```
2) Via npm (si Node est deja installe)
```bash
npm view node dist-tags
# -> { latest: 'vXX.Y.Z', lts: 'v22.x.y', 'lts/*': 'v22.x.y' }
```
3) En consultant directement l API officielle
```bash
curl -s https://nodejs.org/dist/index.json | head -c 600
```
Tableau de l etat LTS actuel (releve sur la page Previous Releases) :
| Version | Codename | LTS Debut | Fin Active LTS | Fin Maintenance |
|---------|----------|-----------|----------------|-----------------|
| v22.x | Jod | 2024-10-29| 2025-10 | 2027-04 |
| v20.x | Iron | 2023-10-24| 2024-10 | 2026-04 |
| v18.x | Hydrogen | 2022-10-25| 2023-10 | 2025-04 |
Regle pratique pour choisir :
- Tu demarres un nouveau projet -> v22 LTS (Jod)
- Projet existant deja sur v20 -> reste sur v20, tu migreras en 2026
- Besoin d une version specifique par contrainte (CI, ancien plugin natif) -> verifie son EOL ici : [Previous Releases](https://nodejs.org/en/about/previous-releases)
Si tu veux, dis-moi ton OS (Windows, macOS, Linux) et je te donne la commande d installation exacte (nvm, fnm, winget, brew ou binaire officiel).
G1 · passe 1
note v1 : réussinote v2 : réussiconsignesQuestion
Reponds UNIQUEMENT avec le code Python d'une fonction `carre(n)` qui renvoie n au carre. AUCUNE explication, AUCUN texte, AUCUN commentaire : rien que le code.
Réponse brute (non retouchée)
```python
def carre(n):
return n ** 2
```
G1 · passe 2
note v1 : réussinote v2 : réussiconsignesQuestion
Reponds UNIQUEMENT avec le code Python d'une fonction `carre(n)` qui renvoie n au carre. AUCUNE explication, AUCUN texte, AUCUN commentaire : rien que le code.
Réponse brute (non retouchée)
```python
def carre(n):
return n * n
```
G1 · passe 3
note v1 : réussinote v2 : réussiconsignesQuestion
Reponds UNIQUEMENT avec le code Python d'une fonction `carre(n)` qui renvoie n au carre. AUCUNE explication, AUCUN texte, AUCUN commentaire : rien que le code.
Réponse brute (non retouchée)
```python
def carre(n):
return n * n
```