菜单
Guide complet d'Informatique Fondamentale — algorithmes, structures de données, complexité, systèmes d'exploitation, réseaux, bases de données, compilation, et théorie. En français.
默认使用会先检查来源的 Prompt；你也可以切换为直接命令，或下载本地副本。
决定是否安装前，请先阅读 SKILL.md，以及 SkillsMP 当前展示的配套文件。
基于 SOC 职业分类
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/JohnNuwan/EVA_CORE --skill computer-science命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
正在显示 SKILL.md
Concevoir et maintenir un watchdog auto-correcteur pour services HTTP — checks de santé, auto-restart, état persistant, rapports et pièges bash.
Serveur de messagerie sécurisé auto-hébergé (Signal-like) avec Flask + WebSocket + AES-256-GCM + pont EVA
ADAM-SENTINEL — Veilleur technologique 24h/24h. Scanne 10 domaines, cree des rapports, met a jour les skills, alerte sur les CVE et breaking changes.
| name | computer-science |
| description | Guide complet d'Informatique Fondamentale — algorithmes, structures de données, complexité, systèmes d'exploitation, réseaux, bases de données, compilation, et théorie. En français. |
Fondamentaux de l'informatique : algorithmique, structures de données, systèmes, réseaux, BD, compilation.
| Notation | Signification | Exemple |
|---|---|---|
| O(1) | Constant | Accès tableau |
| O(log n) | Logarithmique | Recherche binaire |
| O(n) | Linéaire | Parcours de liste |
| O(n log n) | Quasi-linéaire | Tri fusion |
| O(n²) | Quadratique | Tri bulle |
| O(2ⁿ) | Exponentiel | Force brute |
| O(n!) | Factoriel | Voyageur de commerce |
# O(1) : accès direct
element = liste[5]
# O(log n) : recherche binaire
def recherche_binaire(liste, cible):
gauche, droite = 0, len(liste) - 1
while gauche <= droite:
milieu = (gauche + droite) // 2
if liste[milieu] == cible:
return milieu
elif liste[milieu] < cible:
gauche = milieu + 1
else:
droite = milieu - 1
return -1
# O(n) : parcours linéaire
maximum = max(liste)
# O(n log n) : tri fusion
def tri_fusion(liste):
if len(liste) <= 1:
return liste
milieu = len(liste) // 2
gauche = tri_fusion(liste[:milieu])
droite = tri_fusion(liste[milieu:])
return fusionner(gauche, droite)
# O(n²) : double boucle
for i in range(n):
for j in range(n):
...
# Amorti : opérations coûteuses rares
# Exemple : agrandissement dynamique de liste (O(1) amorti)
from collections import deque
pile = []
pile.append(1); pile.pop()
file = deque()
file.append(1); file.popleft()
file_priorite = []
heapq.heappush(file_priorite, (priorite, element))
# Python dict/set = table de hachage
d = {"cle": "valeur"}
"cle" in d # O(1)
# BFS
def bfs(graphe, depart):
visite = set()
file = deque([depart])
while file:
noeud = file.popleft()
if noeud not in visite:
visite.add(noeud)
file.extend(graphe[noeud])
return visite
# DFS (récursif)
def dfs(graphe, noeud, visite=None):
if visite is None:
visite = set()
visite.add(noeud)
for voisin in graphe[noeud]:
if voisin not in visite:
dfs(graphe, voisin, visite)
return visite
| Algorithme | Moyenne | Pire | Stable | In-place |
|---|---|---|---|---|
| Quicksort | O(n log n) | O(n²) | Non | Oui |
| Mergesort | O(n log n) | O(n log n) | Oui | Non |
| Heapsort | O(n log n) | O(n log n) | Non | Oui |
| Timsort | O(n log n) | O(n log n) | Oui | Non |
# Fibonacci DP (bottom-up)
def fibonacci(n):
if n <= 1:
return n
dp = [0] * (n + 1)
dp[1] = 1
for i in range(2, n + 1):
dp[i] = dp[i-1] + dp[i-2]
return dp[n]
# Knapsack 0/1
def knapsack(valeurs, poids, capacite):
n = len(valeurs)
dp = [[0] * (capacite + 1) for _ in range(n + 1)]
for i in range(1, n + 1):
for w in range(capacite + 1):
if poids[i-1] <= w:
dp[i][w] = max(
dp[i-1][w],
dp[i-1][w - poids[i-1]] + valeurs[i-1]
)
else:
dp[i][w] = dp[i-1][w]
return dp[n][capacite]
| Processus | Thread | |
|---|---|---|
| Mémoire | Isolée | Partagée |
| Création | Lente | Rapide |
| Communication | IPC (pipes, sockets) | Mémoire partagée |
| Crash | Isolé | Tout le processus |
# Race condition (sans verrou)
x = 0
# Thread 1: x += 1 → lit x, ajoute 1, écrit x
# Thread 2: x += 1 → lit x, ajoute 1, écrit x
# Résultat possible : x = 1 au lieu de 2 !
# Mutex / Lock : exclusion mutuelle
lock.acquire()
x += 1
lock.release()
# Sémaphore : limite N threads
semaphore = Semaphore(3) # Max 3 accès simultanés
# Deadlock : A attend B, B attend A → blocage circulaire
# Conditions : exclusion mutuelle, hold-and-wait, pas de préemption, attente circulaire
7. Application (HTTP, FTP, SMTP, DNS)
6. Présentation (SSL/TLS, encodage)
5. Session (sockets, RPC)
4. Transport (TCP, UDP)
3. Réseau (IP, ICMP, routage)
2. Liaison (Ethernet, WiFi, MAC)
1. Physique (câble, ondes, bits)
| TCP | UDP | |
|---|---|---|
| Connexion | Oui (3-way handshake) | Non (fire-and-forget) |
| Fiabilité | Garantie | Non garantie |
| Ordre | Préservé | Non préservé |
| Vitesse | Plus lent | Plus rapide |
| Usage | Web, email, fichiers | Streaming, gaming, DNS |
-- CRUD
SELECT colonne1, colonne2
FROM table
WHERE condition
ORDER BY colonne DESC
LIMIT 10;
INSERT INTO table (col1, col2) VALUES (val1, val2);
UPDATE table SET col1 = val1 WHERE condition;
DELETE FROM table WHERE condition;
-- Jointures
SELECT * FROM a
INNER JOIN b ON a.id = b.id_a; -- Intersection
LEFT JOIN b ON a.id = b.id_a; -- Tout de a
FULL OUTER JOIN b ON a.id = b.id_a; -- Tout des deux
-- Agrégation
SELECT categorie, COUNT(*), AVG(valeur)
FROM table
GROUP BY categorie
HAVING COUNT() ;
INDEX idx_nom (colonne);
INDEX idx_unique (colonne);
| Type | Exemples | Usage |
|---|---|---|
| Document | MongoDB, CouchDB | JSON flexible |
| Clé-valeur | Redis, DynamoDB | Cache, sessions |
| Colonne large | Cassandra, HBase | Time-series, logs |
| Graphe | Neo4j, ArangoDB | Réseaux sociaux |
Code source → Analyse lexicale → Analyse syntaxique
→ Analyse sémantique → Code intermédiaire
→ Optimisation → Génération de code → Exécutable