The push_swap algorithm,
rewritten in Rust — 3114 507 lines. L'algorithme push_swap,
réécrit en Rust — 3114 507 lignes.

① Stack operation sa (swap first two of A) ① Opération de pile sa (échange les deux premiers de A)

C does pop(); pop(); push(); push() — four pointer ops and a print. Rust does a[0] ↔ a[1] — two index assignments. Both produce one "sa" on stdout. Le C fait pop(); pop(); push(); push() — quatre opérations sur pointeur et une impression. Rust fait a[0] ↔ a[1] — deux assignations. Les deux produisent un "sa" sur stdout.

int sab(t_pile **p, char *str, int op)
{
    int tmp, tmp2;
    if (*p && (*p)->next) {
        ft_putstr(str);
        tmp  = (*p)->x;
        tmp2 = (*p)->next->x;
        pop(p);
        pop(p);
        push(p, tmp);
        push(p, tmp2);
    }
    return (1);
}

pub fn sa(
    a: &mut VecDeque<i32>,
    ops: &mut Vec<String>,
    verbose: bool,
) {
    if a.len() >= 2 {
        let (first, second) = (a[0], a[1]);
        a[0] = second;
        a[1] = first;
        print_op("sa", ops, verbose);
    }
}

② Input validation (5 C functions → 1 Rust function) ② Validation d'entrée (5 fonctions C → 1 fonction Rust)

The C version needs is_num, is_dup, duplicates, islarger, and valid_input — 170 lines across two files. Rust uses i32::parse (rejects non-numbers and overflow) and a HashSet (rejects duplicates in O(1)). La version C nécessite is_num, is_dup, duplicates, islarger et valid_input — 170 lignes sur deux fichiers. Rust utilise i32::parse (rejette non-nombres et débordements) et un HashSet (rejette les doublons en O(1)).

/* 5 separate functions: */

int is_num(char *str) {
    int i = 0;
    if (str[0] == '-' || str[0] == '+')
        i++;
    if (!str[i]) return (0);
    while (str[i])
        if (!ft_isdigit(str[i++]))
            return (0);
    return (1);
}

int islarger(char *nb) {
    /* 22-line INT_MAX/INT_MIN check */
    ...
}

int duplicates(int ac, char **strs) {
    /* nested for loop with ft_atoi */
    ...
}

int valid_input(int ac, char **strs) {
    int i = 0;
    while (i < ac) {
        if (!is_num(strs[i])
         || islarger(strs[i]))
            return (0);
        i++;
    }
    return (!duplicates(ac, strs));
}

use std::collections::HashSet;

/// Parse string arguments into validated i32 numbers.
/// Returns Err with message if: non-numeric,
/// duplicates, or overflow.
pub fn parse_args(
    args: &[&str]
) -> Result<Vec<i32>, String> {
    let mut nums = Vec::with_capacity(args.len());
    let mut seen = HashSet::new();

    for s in args {
        // i32::parse rejects non-numeric AND overflow
        let n: i32 = s.parse()
            .map_err(|_| format!("Invalid: {}", s))?;
        nums.push(n);

        // HashSet::insert returns false if dup
        if !seen.insert(n) {
            return Err(format!("Duplicate: {}", n));
        }
    }
    Ok(nums)
}

③ Checker: read stdin line by line ③ Checker : lire stdin ligne par ligne

C uses the libft's get_next_line in a while loop, frees the line and a "pitcher" buffer each iteration, and calls ft_strcmp against every possible command. Rust iterates stdin.lock().lines() and dispatches via match. No buffers to free, no leaks possible. Le C utilise get_next_line de la libft dans une boucle while, libère la ligne et un buffer « pitcher » à chaque itération, et appelle ft_strcmp pour chaque commande. Rust itère stdin.lock().lines() et dispatche via match. Aucun buffer à libérer, aucune fuite possible.

char *line;
char *pitcher;

pitcher = ft_strnew(0);
while (get_next_line(0, &line, &pitcher) == 1)
{
    if (!is_cmd(&p1, &p2, line, 0))
    {
        free_pile(&p1);
        free_pile(&p2);
        free(line);
        free(pitcher);
        ft_putendl("Error");
        return (0);
    }
    free(line);
}
free(pitcher);

fn apply_op(
    a: &mut VecDeque<i32>,
    b: &mut VecDeque<i32>,
    op: &str,
) -> bool {
    match op.trim() {
        "sa" => { if a.len() >= 2 { let t = a[0]; a[0] = a[1]; a[1] = t; } true }
        "pa" => { if let Some(v) = b.pop_front() { a.push_front(v); } true }
        "pb" => { if let Some(v) = a.pop_front() { b.push_front(v); } true }
        "ra" => { if let Some(v) = a.pop_front() { a.push_back(v); } true }
        "rra" => { if let Some(v) = a.pop_back() { a.push_front(v); } true }
        // ... ss, sb, rb, rr, rrb, rrr ...
        ""  => true,
        _    => false,
    }
}

// main loop:
for line in stdin.lock().lines() {
    let line = line.unwrap();
    if !apply_op(&mut a, &mut b, &line) {
        println!("Error");
        return;
    }
}

④ The sort itself — same algorithm, fewer lines ④ Le tri lui-même — même algorithme, moins de lignes

sort.rs (179 lines) is a 1:1 translation of sort_two.c (313 lines). The cost-based insertion sort — pick the cheapest element in B to push back to A, considering both rotations — is byte-for-byte equivalent. The 134-line gap is pure boilerplate: in C, every pb needs a pop + push + error check; in Rust, it's a one-liner. sort.rs (179 lignes) est une traduction 1:1 de sort_two.c (313 lignes). Le tri par insertion à coût — choisir l'élément le moins coûteux de B à renvoyer vers A, en considérant les deux rotations — est équivalent octet pour octet. Les 134 lignes d'écart sont du pur boilerplate : en C, chaque pb nécessite un pop + push + vérification ; en Rust, c'est une seule ligne.

/* For each element in B, compute cost to insert into A */
while (are_left(pile_b))
{
    i = 0;
    while (i < pile_len(pile_b))
    {
        tmp = pass_pile(pile_b, i);
        pos_a = find_insert_pos(pile_a, tmp);
        cost = compute_cost(i, pos_a,
                            pile_len(pile_a),
                            pile_len(pile_b));
        if (cost < best) {
            best = cost;
            best_idx = i;
            best_pos = pos_a;
        }
        i++;
    }
    execute_strategy(pile_a, pile_b,
                       best_idx, best_pos);
    pab(pile_a, pile_b, "pa", 1);
}

// For each element in B, compute cost to insert into A
while !b.is_empty() {
    let (mut best, mut best_idx, mut best_pos)
        = (i32::MAX, 0, 0);

    for i in 0..b.len() {
        let tmp = b[i];
        let pos_a = find_insert_pos(&a, tmp);
        let cost = compute_cost(
            i, pos_a, a.len(), b.len(),
        );
        if cost < best {
            best     = cost;
            best_idx = i;
            best_pos = pos_a;
        }
    }

    execute_strategy(
        &mut a, &mut b, best_idx, best_pos,
        &mut ops, verbose,
    );
    pa(&mut a, &mut b, &mut ops, verbose);
}

🗑️ Files eliminated (414 C lines deleted) 🗑️ Fichiers supprimés (414 lignes C supprimées)

📦 The libft elimination (~2000 lines deleted) 📦 L'élimination de la libft (~2000 lignes supprimées)

The C version links a personal libft — about 30 reimplemented libc functions, ~2000 lines. None of it is push_swap-specific; it's pure infrastructure. Rust's standard library replaces every single function: La version C lie une libft personnelle — environ 30 fonctions libc réécrites, ~2000 lignes. Rien de spécifique à push_swap ; c'est de la pure infrastructure. La bibliothèque standard de Rust remplace chaque fonction :

The C pop function — and what Rust does instead La fonction C pop — et ce que Rust fait à la place

This is the C version's pop: free the head node, advance the pointer. If you forget the free, you leak. If you free twice, you crash. Rust's VecDeque::pop_front returns Option<i32> and the memory is reclaimed when the VecDeque is dropped. Voici le pop de la version C : libérer le nœud de tête, avancer le pointeur. Si vous oubliez le free, vous fuyez. Si vous free deux fois, vous crash. Le VecDeque::pop_front de Rust retourne Option<i32> et la mémoire est récupérée quand le VecDeque est droppé.

int pop(t_pile **p)
{
    t_pile *tmp;
    int     x;

    if (!*p)
        return (0);          /* silent failure */
    tmp = *p;
    x   = (*p)->x;
    *p   = (*p)->next;
    free(tmp);          /* forget me = leak */
    return (x);
}

void free_pile(t_pile **p)
{
    while (*p)
        pop(p);
    /* if you forget to call me → grade 0 */
}

// VecDeque::pop_front returns Option<i32>.
// No free() needed — Drop handles it.
// No null check — Option forces the match.

pub fn pa(
    a: &mut VecDeque<i32>,
    b: &mut VecDeque<i32>,
    ops: &mut Vec<String>,
    verbose: bool,
) {
    if let Some(val) = b.pop_front() {
        a.push_front(val);
        print_op("pa", ops, verbose);
    }
}

// No free_pile() equivalent exists.
// When `a` and `b` go out of scope in main(),
// their Drop impls free everything.

① Build the binaries ① Compiler les binaires

# Build both binaries in release mode (optimized)
$ cargo build --release
   Compiling push_swap_rust v1.0.0 (/home/z/push-swap-rust)
    Finished release [optimized] target(s) in 0.42s

# Binaries are now in target/release/
$ ls -la target/release/
-rwxr-xr-x  push_swap
-rwxr-xr-x  checker

# (Debug build for development)
$ cargo build

② Run push_swap on 100 random numbers ② Lancer push_swap sur 100 nombres aléatoires

# Generate 100 unique numbers, run push_swap, count ops
$ ARG=$(shuf -i 1-1000 -n 100 | tr '\n' ' ')
$ ./target/release/push_swap "$ARG" | wc -l
594

# Verify the result with the checker
$ ./target/release/push_swap "$ARG" | ./target/release/checker "$ARG"
OK

# Verbose mode (prints each op to stderr as it executes)
$ ./target/release/push_swap -v "3 1 2"
sa
ra

③ Run the test suite ③ Lancer la suite de tests

# Unit tests for parser, operations, sort
$ cargo test
   Compiling push_swap_rust v1.0.0
    Finished test [unoptimized + debuginfo] target(s)
     Running unittests
...
test result: ok. 24 passed; 0 failed; 0 ignored

# Lint with clippy (Rust's strict linter)
$ cargo clippy -- -D warnings
    Finished
No warnings. Clean.

# Format check
$ cargo fmt --check
(no output = formatted correctly)

④ Benchmark against the 42 grading thresholds ④ Tester contre les seuils de notation 42

# Run 1000 tests with 100 numbers, report average
$ total=0; for i in $(seq 1 1000); do
    ARG=$(shuf -i 1-1000 -n 100 | tr '\n' ' ')
    ops=$(./target/release/push_swap "$ARG" | wc -l)
    total=$((total + ops))
done; echo "avg: $((total / 1000)) ops"
avg: 594 ops  # well under 700 → 5/5

# Same for 500 numbers
$ total=0; for i in $(seq 1 1000); do
    ARG=$(shuf -i 1-5000 -n 500 | tr '\n' ' ')
    ops=$(./target/release/push_swap "$ARG" | wc -l)
    total=$((total + ops))
done; echo "avg: $((total / 1000)) ops"
avg: 5231 ops # well under 5500 → 5/5