Console
Clique sur « Exécuter » pour lancer le programme.
Aucune exécutionCtrl+Entrée : exécuter · Échap : arrêter
Code CoddyRun
// ------------------------------------------------------------
// DIMENSIONS
// ------------------------------------------------------------
N est un nombre
N vaut 6
t est un nombre
t vaut 60
espace est un nombre
espace vaut 16
margeG est un nombre
margeG vaut 40
// Y de la rangée source (haut) et de la rangée triée (bas)
ySource est un nombre
ySource vaut 90
yTrie est un nombre
yTrie vaut 320
LARG est un nombre
LARG vaut margeG * 2 + N * t + (N - 1) * espace
HAUT est un nombre
HAUT vaut 430
// ------------------------------------------------------------
// ÉTAT
// ------------------------------------------------------------
// source[i] : valeur de la boîte i en haut, ou -1 si déjà prélevée
// trie[i] : valeur de la boîte i en bas, ou -1 si case encore vide
source est un tableau
trie est un tableau
// Toutes les images de l'animation
sequence est un tableau
// ------------------------------------------------------------
// POSITION EN X de la colonne d'index i (0..N-1)
// ------------------------------------------------------------
fonction posCase(i)
retourne margeG + i * (t + espace)
fin fonction
// ------------------------------------------------------------
// COULEUR d'une valeur (10..99 -> dégradé bleu->orange)
// ------------------------------------------------------------
fonction couleurValeur(v)
f est un nombre
f vaut (v - 10) / 89
r est un nombre
r vaut arrondi(40 + f * 200)
vert est un nombre
vert vaut arrondi(120 + f * 60)
b est un nombre
b vaut arrondi(220 - f * 160)
retourne rgb(r, vert, b)
fin fonction
// ------------------------------------------------------------
// DESSINE UNE BOÎTE numérotée
// ------------------------------------------------------------
procédure dessinerBoite(g, x, y, v, surligne)
coul est un texte
coul vaut couleurValeur(v)
rectangle_arrondi(g, x, y, t, t, 10, coul)
si surligne alors
contour(g, #ffd43b, 4)
rectangle_arrondi(g, x, y, t, t, 10, coul)
contour(g, #0)
fin si
rectangle_arrondi(g, x, y, t, 12, 6, #ffff33)
tx est un nombre
tx vaut x + t / 2 - 15
ty est un nombre
ty vaut y + t / 2 + 8
label(g, tx, ty, convertir_texte(v), #ffffff, 24)
fin procédure
// ------------------------------------------------------------
// DESSINE UN EMPLACEMENT VIDE (contour pointillé simulé)
// ------------------------------------------------------------
procédure dessinerEmplacement(g, x, y)
rectangle_arrondi(g, x, y, t, t, 10, #ffff14)
fin procédure
// ------------------------------------------------------------
// DESSINE LA PINCE
// ------------------------------------------------------------
procédure dessinerPince(g, cx, brasY, ouverte)
rectangle(g, cx - 3, 0, 6, brasY, #495057)
rectangle_arrondi(g, cx - 20, brasY, 40, 22, 5, #343a40)
rectangle(g, cx - 14, brasY + 5, 28, 6, #ffd43b)
ecart est un nombre
si ouverte alors
ecart vaut 26
sinon
ecart vaut 12
fin si
baseY est un nombre
baseY vaut brasY + 22
ligne(g, cx, baseY, cx - ecart, baseY + 24, #495057, 7)
ligne(g, cx - ecart, baseY + 24, cx - ecart, baseY + 38, #495057, 7)
ligne(g, cx, baseY, cx + ecart, baseY + 24, #495057, 7)
ligne(g, cx + ecart, baseY + 24, cx + ecart, baseY + 38, #495057, 7)
fin procédure
// ------------------------------------------------------------
// DESSINE TOUTE LA SCÈNE : décor + zone source + zone triée
// trouSource : index d'une boîte source portée par la pince
// (on ne la dessine pas au sol pendant le transport)
// surSource / surTrie : index à surligner dans chaque zone (-1 = aucun)
// ------------------------------------------------------------
procédure dessinerScene(g, trouSource, surSource, surTrie)
degrade(g, [#1a1a2e, #16213e])
// Séparateur + libellés de zones (dessinés en formes, pas en sortie texte)
ligne(g, 0, 210, LARG, 210, #533483, 3)
// pastille "source" (barre à gauche) et "trié" : simples repères colorés
rectangle(g, 0, 60, 8, 100, #4ecdc4)
rectangle(g, 0, 290, 8, 100, #51cf66)
// --- Zone source (haut) ---
i est un nombre
i vaut 0
tant que i < N
x est un nombre
x vaut posCase(i)
si source[i] = -1 alors
appelle dessinerEmplacement(g, x, ySource)
sinon si i <> trouSource alors
surl est un booléen
surl vaut i = surSource
appelle dessinerBoite(g, x, ySource, source[i], surl)
fin si
i vaut i + 1
fin tant que
// --- Zone triée (bas) ---
j est un nombre
j vaut 0
tant que j < N
x2 est un nombre
x2 vaut posCase(j)
si trie[j] = -1 alors
appelle dessinerEmplacement(g, x2, yTrie)
sinon
surl2 est un booléen
surl2 vaut j = surTrie
appelle dessinerBoite(g, x2, yTrie, trie[j], surl2)
fin si
j vaut j + 1
fin tant que
fin procédure
// ------------------------------------------------------------
// AJOUTE les images d'un mouvement vertical de la pince
// sur une colonne, à une hauteur cible yCible.
// descendre = vrai : la pince descend (aller chercher)
// descendre = faux : la pince remonte (après avoir lâché)
// Si porte = vrai, une boîte "v" est dessinée accrochée.
// ------------------------------------------------------------
procédure vertical(indexCol, yCible, v, descendre, porte, trouS, surS, surT)
nbPas est un nombre
nbPas vaut 8
x est un nombre
x vaut posCase(indexCol)
cx est un nombre
cx vaut x + t / 2
brasHaut est un nombre
brasHaut vaut 20
brasBas est un nombre
brasBas vaut yCible - 60
etape est un nombre
etape vaut 0
tant que etape <= nbPas
g est une toile
dimension(g, LARG, HAUT)
frac est un nombre
si descendre alors
frac vaut etape / nbPas
sinon
frac vaut (nbPas - etape) / nbPas
fin si
brasY est un nombre
brasY vaut brasHaut + (brasBas - brasHaut) * frac
appelle dessinerScene(g, trouS, surS, surT)
ouverte est un booléen
si porte alors
ouverte vaut faux
sinon
ouverte vaut frac < 0,7
fin si
si porte alors
carY est un nombre
carY vaut brasY + 62
appelle dessinerBoite(g, x, carY, v, vrai)
fin si
appelle dessinerPince(g, cx, brasY, ouverte)
sequence ajoute g
etape vaut etape + 1
fin tant que
fin procédure
// ------------------------------------------------------------
// AJOUTE les images d'un déplacement horizontal (boîte portée
// en haut) de la colonne colDep vers la colonne colArr.
// ------------------------------------------------------------
procédure deplacementHaut(colDep, colArr, v, trouS, surS, surT)
xDep est un nombre
xDep vaut posCase(colDep)
xArr est un nombre
xArr vaut posCase(colArr)
nbPas est un nombre
nbPas vaut 10
etape est un nombre
etape vaut 0
tant que etape <= nbPas
g est une toile
dimension(g, LARG, HAUT)
appelle dessinerScene(g, trouS, surS, surT)
cx est un nombre
cx vaut xDep + (xArr - xDep) * etape / nbPas + t / 2
carX est un nombre
carX vaut cx - t / 2
appelle dessinerBoite(g, carX, 82, v, vrai)
appelle dessinerPince(g, cx, 20, faux)
sequence ajoute g
etape vaut etape + 1
fin tant que
fin procédure
// ------------------------------------------------------------
// PAUSE : ajoute nb images statiques (pince ouverte au centre)
// ------------------------------------------------------------
procédure sleep(nb, surS, surT)
k est un nombre
k vaut 0
tant que k < nb
g est une toile
dimension(g, LARG, HAUT)
appelle dessinerScene(g, -1, surS, surT)
appelle dessinerPince(g, LARG / 2, 20, vrai)
sequence ajoute g
k vaut k + 1
fin tant que
fin procédure
// ------------------------------------------------------------
// PRÉLEVER la boîte source d'index "col" et la POSER dans la
// case triée d'index "dest".
// ------------------------------------------------------------
procédure prelever(col, dest)
v est un nombre
v vaut source[col]
// 1) la pince descend sur la boîte source (surligne cette colonne)
appelle vertical(col, ySource, v, vrai, faux, -1, col, -1)
// la boîte quitte la source
source[col] vaut -1
// 2) elle remonte en portant la boîte
appelle vertical(col, ySource, v, faux, vrai, col, -1, -1)
// 3) déplacement horizontal jusqu'à la colonne de destination
appelle deplacementHaut(col, dest, v, col, -1, -1)
// 4) descente dans la zone triée puis lâcher
appelle vertical(dest, yTrie, v, vrai, vrai, -1, -1, -1)
// la boîte est posée
trie[dest] vaut v
// 5) la pince remonte à vide
appelle vertical(dest, yTrie, v, faux, faux, -1, -1, dest)
fin procédure
// ------------------------------------------------------------
// INDEX du MINIMUM restant dans la source (cases <> -1)
// ------------------------------------------------------------
fonction indexMinSource()
iMin est un nombre
iMin vaut -1
i est un nombre
i vaut 0
tant que i < N
si source[i] <> -1 alors
si iMin = -1 alors
iMin vaut i
sinon si source[i] < source[iMin] alors
iMin vaut i
fin si
fin si
i vaut i + 1
fin tant que
retourne iMin
fin fonction
// ============================================================
// PROGRAMME PRINCIPAL — animation seule, deux zones
// ============================================================
// N valeurs distinctes entre 10 et 99 (intervalle mélangé)
pool est un tableau
pool vaut intervalle(10, 99)
pool vaut melanger(pool)
idx est un nombre
idx vaut 0
tant que idx < N
source ajoute pool[idx]
idx vaut idx + 1
fin tant que
// zone triée initialement vide (toutes cases à -1)
z est un nombre
z vaut 0
tant que z < N
trie ajoute -1
z vaut z + 1
fin tant que
// Images de départ
appelle sleep(6, -1, -1)
// Tri par sélection : à chaque tour, prélever le min restant
dest est un nombre
dest vaut 0
tant que dest < N
col est un nombre
col vaut indexMinSource()
appelle prelever(col, dest)
dest vaut dest + 1
fin tant que
// Images finales : la scène triée reste affichée un instant
fbis est un nombre
fbis vaut 0
tant que fbis < 12
g est une toile
dimension(g, LARG, HAUT)
appelle dessinerScene(g, -1, -1, -1)
sequence ajoute g
fbis vaut fbis + 1
fin tant que
// Lecture unique de toute l'animation
animation(sequence, 45)