Rust Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

fn main() {
    println!("Hello, world!");
}

Run the program:

cargo run

This is the normal Rust entry point. println! is a macro that writes formatted output to the terminal.

Variables

Variables are immutable by default. Use mut when the value should change.

let language = "Rust";
let mut count = 1;
count += 1;

Rust values are immutable unless you mark them with mut, which makes state changes explicit.

Add

Mon, 01 Jan 0001 00:00:00 +0000

Rust Add

fn add(param1: i64, param2: i64) -> i64 {
    param1 + param2
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

Rust Add Border

fn add_border(picture: &[String]) -> Vec<String> {
    let width = picture[0].len();
    let border = "*".repeat(width + 2);

    let mut result = Vec::with_capacity(picture.len() + 2);
    result.push(border.clone());
    for row in picture {
        result.push(format!("*{row}*"));
    }
    result.push(border);

    result
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

Rust Adjacent Elements Product

fn adjacent_elements_product(input_array: &[i64]) -> i64 {
    input_array
        .windows(2)
        .map(|w| w[0] * w[1])
        .max()
        .unwrap_or(i64::MIN)
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

Rust Almost Magic Square

fn almost_magic_square(a: &[i64]) -> Vec<i64> {
    let mut grid: Vec<Vec<i64>> = a.chunks(3).map(|c| c.to_vec()).collect();
    let mut row_sum = [0i64; 3];
    let mut col_sum = [0i64; 3];

    for i in 0..3 {
        for j in 0..3 {
            row_sum[i] += grid[i][j];
            col_sum[i] += grid[j][i];
        }
    }

    let mut max_sum = 0;
    for k in 0..3 {
        max_sum = max_sum.max(row_sum[k]);
        max_sum = max_sum.max(col_sum[k]);
    }

    let (mut i, mut j) = (0usize, 0usize);
    while i < 3 && j < 3 {
        let diff = (max_sum - row_sum[i]).min(max_sum - col_sum[j]);
        grid[i][j] += diff;
        row_sum[i] += diff;
        col_sum[j] += diff;

        if row_sum[i] == max_sum {
            i += 1;
        }
        if col_sum[j] == max_sum {
            j += 1;
        }
    }

    grid.into_iter().flatten().collect()
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

Rust Are Equally Strong

fn are_equally_strong(your_left: i64, your_right: i64, friends_left: i64, friends_right: i64) -> bool {
    your_right.max(your_left) == friends_left.max(friends_right)
        && your_left.min(your_right) == friends_right.min(friends_left)
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

Rust Array Change

fn array_change(mut a: Vec<i64>) -> i64 {
    let mut min = 0;
    for k in 0..a.len().saturating_sub(1) {
        if a[k] >= a[k + 1] {
            let dif = a[k] - a[k + 1] + 1;
            a[k + 1] += dif;
            min += dif;
        }
    }

    min
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

Rust Array Maximal Adjacement Difference

fn array_maximal_adjacent_difference(a: &[i64]) -> i64 {
    let mut dif = 0;
    for i in 1..a.len().saturating_sub(1) {
        dif = dif.max((a[i] - a[i - 1]).abs()).max((a[i] - a[i + 1]).abs());
    }

    dif
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

Rust Binary Gap

fn binary_gap(n: i64) -> i64 {
    let bits = format!("{n:b}");
    let trimmed = bits.trim_matches('0');

    trimmed
        .split('1')
        .map(|zeroes| zeroes.len() as i64)
        .max()
        .unwrap_or(0)
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

Rust Bracket

fn bracket(s: &str) -> i64 {
    let mut stack = Vec::new();
    for c in s.chars() {
        match c {
            ')' => {
                if stack.pop() != Some('(') {
                    return 0;
                }
            }
            ']' => {
                if stack.pop() != Some('[') {
                    return 0;
                }
            }
            '}' => {
                if stack.pop() != Some('{') {
                    return 0;
                }
            }
            _ => stack.push(c),
        }
    }

    if stack.is_empty() { 1 } else { 0 }
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

Rust Century From Year

fn century_from_year(year: i64) -> i64 {
    (year as f64 / 100.0).ceil() as i64
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

Rust Check Palindrome

fn check_palindrome(input_string: &str) -> bool {
    input_string.chars().rev().collect::<String>() == input_string
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

Rust Chocolates By Numbers

fn gcd(n: i64, m: i64) -> i64 {
    if n % m == 0 { m } else { gcd(m, n % m) }
}

fn chocolates_by_numbers(n: i64, m: i64) -> i64 {
    (n * m) / gcd(n, m) / m
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

Rust Common Prime Divisors

fn gcd(n: i64, m: i64) -> i64 {
    if n % m == 0 { m } else { gcd(m, n % m) }
}

fn remove_common_prime_divisors(mut n: i64, m: i64) -> i64 {
    while n != 1 {
        let d = gcd(n, m);
        if d == 1 {
            break;
        }
        n /= d;
    }

    n
}

fn common_prime_divisors(a: &[i64], b: &[i64]) -> i64 {
    let mut counter = 0;
    for i in 0..a.len() {
        let x = a[i];
        let y = b[i];
        let d = gcd(x, y);

        let x = remove_common_prime_divisors(x, d);
        if x != 1 {
            continue;
        }

        let y = remove_common_prime_divisors(y, d);
        if y == 1 {
            counter += 1;
        }
    }

    counter
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Div

fn count_div(a: i64, b: i64, k: i64) -> i64 {
    let first_div = if a % k == 0 { a } else { a + (k - a % k) };
    let last_div = b - b % k;

    (last_div - first_div) / k + 1
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Factors

fn count_factors(n: i64) -> i64 {
    let mut count = 0;
    let mut i = 1i64;
    while i * i < n {
        if n % i == 0 {
            count += 2;
        }
        i += 1;
    }
    if i * i == n {
        count += 1;
    }

    count
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Non Divisible

fn count_non_divisible(a: &[i64]) -> Vec<i64> {
    let size = a.len();
    let max_val = *a.iter().max().unwrap() as usize;
    let mut occurrences = vec![0i64; max_val + 1];

    for &v in a {
        occurrences[v as usize] += 1;
    }

    let mut nondivisor = vec![0i64; size];
    for (k, &v) in a.iter().enumerate() {
        let mut count = 0;
        let mut i = 1i64;
        while i * i <= v {
            if v % i == 0 {
                count += occurrences[i as usize];
                if v / i != i {
                    count += occurrences[(v / i) as usize];
                }
            }
            i += 1;
        }
        nondivisor[k] = size as i64 - count;
    }

    nondivisor
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

Rust Count Semi Primes

fn count_semi_primes(n: usize, p: &[usize], q: &[usize]) -> Vec<i64> {
    let mut is_prime = vec![true; n + 1];
    let mut semi_primes = vec![0i64; n + 1];

    let mut i = 2;
    while i * i <= n {
        if is_prime[i] {
            let mut k = i * i;
            while k <= n {
                is_prime[k] = false;
                k += i;
            }
        }
        i += 1;
    }

    let mut k = 2;
    while k * k <= n {
        if is_prime[k] {
            let mut i = 2;
            while i * k <= n {
                if is_prime[i] {
                    semi_primes[k * i] = 1;
                }
                i += 1;
            }
        }
        k += 1;
    }

    for i in 1..=n {
        semi_primes[i] += semi_primes[i - 1];
    }

    p.iter()
        .zip(q.iter())
        .map(|(&pi, &qi)| semi_primes[qi] - semi_primes[pi - 1])
        .collect()
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

Rust Cyclic Rotation

fn cyclic_rotation(mut a: Vec<i64>, k: i64) -> Vec<i64> {
    let len = a.len();
    if len > 0 && k > 0 {
        let k = (k as usize) % len;
        a.rotate_right(k);
    }

    a
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

Rust Distinct

use std::collections::HashSet;

fn distinct(a: &[i64]) -> i64 {
    let set: HashSet<_> = a.iter().collect();
    set.len() as i64
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

Rust Dominator

fn dominator(a: &[i64]) -> i64 {
    let mut size = 0i64;
    let mut value = 0;
    let mut index: i64 = 0;

    for (k, &v) in a.iter().enumerate() {
        if size == 0 {
            size += 1;
            value = v;
            index = k as i64;
        } else if value != v {
            size -= 1;
        } else {
            size += 1;
        }
    }

    let candidate = if size > 0 { value } else { -1 };

    let count = a.iter().filter(|&&v| v == candidate).count() as i64;
    if count <= a.len() as i64 / 2 {
        index = -1;
    }

    index
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

Rust Equi Leader

fn equi_leader(a: &[i64]) -> i64 {
    let mut leader_size = 0i64;
    let mut value = 0;
    for &v in a {
        if leader_size == 0 {
            leader_size += 1;
            value = v;
        } else if value != v {
            leader_size -= 1;
        } else {
            leader_size += 1;
        }
    }
    let candidate = if leader_size > 0 { value } else { -1 };

    let leader_count = a.iter().filter(|&&v| v == candidate).count() as i64;
    let leader = if leader_count > a.len() as i64 / 2 { candidate } else { -1 };

    let count = a.len() as i64;
    let mut l_leader_count = 0i64;
    let mut equi_leaders = 0i64;

    for (k, &v) in a.iter().enumerate() {
        let k = k as i64;
        let left_half = (k + 1) / 2;
        let right_half = (count - k - 1) / 2;
        if v == leader {
            l_leader_count += 1;
        }

        let r_leader_count = leader_count - l_leader_count;
        if l_leader_count > left_half && r_leader_count > right_half {
            equi_leaders += 1;
        }
    }

    equi_leaders
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

Rust Fib Frog

use std::collections::VecDeque;

fn fib_frog(a: &[i64]) -> i64 {
    let size = a.len() as i64;

    let mut fib = vec![0i64, 1];
    let mut i = 1;
    while fib[i] <= size {
        i += 1;
        fib.push(fib[i - 1] + fib[i - 2]);
    }

    let mut paths: VecDeque<(i64, i64)> = VecDeque::new();
    paths.push_back((-1, 0));

    let mut steps = vec![false; size as usize];

    while let Some((idx, jmp)) = paths.pop_front() {
        for f in (2..fib.len()).rev() {
            let next_idx = idx + fib[f];
            if next_idx == size {
                return jmp + 1;
            }
            if next_idx > size || steps[next_idx as usize] || a[next_idx as usize] == 0 {
                continue;
            }
            if a[next_idx as usize] == 1 {
                steps[next_idx as usize] = true;
                paths.push_back((next_idx, jmp + 1));
            }
        }
    }

    -1
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

Rust Fish

fn fish(a: &[i64], b: &[i64]) -> i64 {
    let size = a.len();
    let mut dead = 0i64;
    let mut fish: Vec<i64> = Vec::new();

    for i in 0..size {
        if b[i] == 1 {
            fish.push(a[i]);
        } else if !fish.is_empty() {
            while let Some(&last) = fish.last() {
                dead += 1;
                if a[i] > last {
                    fish.pop();
                } else {
                    break;
                }
            }
        }
    }

    size as i64 - dead
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

Rust Flags

fn flags(a: &[i64]) -> i64 {
    let size = a.len();
    let mut peaks = vec![false; size];
    for i in 1..size {
        let next = a.get(i + 1).copied().unwrap_or(0);
        peaks[i] = a[i - 1] < a[i] && a[i] > next;
    }

    let mut next_peak = vec![-1i64; size];
    if size > 0 {
        next_peak[size - 1] = -1;
        for i in (0..size - 1).rev() {
            next_peak[i] = if peaks[i] { i as i64 } else { next_peak[i + 1] };
        }
    }

    let mut i = 1i64;
    let mut result = 0i64;
    while i * (i - 1) <= size as i64 {
        let mut pos = 0i64;
        let mut num = 0i64;
        while pos < size as i64 && num < i {
            pos = next_peak[pos as usize];
            if pos == -1 {
                break;
            }
            num += 1;
            pos += i;
        }
        i += 1;
        result = result.max(num);
    }

    result
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

Rust Frog Jmp

fn frog_jmp(x: i64, y: i64, d: i64) -> i64 {
    let dist = y - x;
    (dist + d - 1) / d
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

Rust Frog River One

use std::collections::HashSet;

fn frog_river_one(x: i64, a: &[i64]) -> i64 {
    let mut existing: HashSet<i64> = HashSet::new();
    for (k, &i) in a.iter().enumerate() {
        if i <= x && existing.insert(i) && existing.len() as i64 == x {
            return k as i64;
        }
    }

    -1
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

Rust Genomic Range Query

fn genomic_range_query(s: &str, p: &[usize], q: &[usize]) -> Vec<i64> {
    let chars: Vec<char> = s.chars().collect();
    p.iter()
        .zip(q.iter())
        .map(|(&pi, &qi)| {
            let sub = &chars[pi..=qi];
            if sub.contains(&'A') {
                1
            } else if sub.contains(&'C') {
                2
            } else if sub.contains(&'G') {
                3
            } else {
                4
            }
        })
        .collect()
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

Rust Is Ipv 4 Adress

fn is_ipv_4_adress(input_string: &str) -> bool {
    let parts: Vec<&str> = input_string.split('.').collect();
    if parts.len() != 4 {
        return false;
    }

    for part in &parts {
        match part.parse::<i64>() {
            Ok(n) => {
                if n > 255 || part.to_string() != n.to_string() {
                    return false;
                }
            }
            Err(_) => return false,
        }
    }

    true
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

Rust Ladder

fn ladder(a: &[i64], b: &[i64]) -> Vec<i64> {
    let size = a.len();
    let mut r = vec![0i64; size];

    let max_b = *b.iter().max().unwrap();
    let mod_mask = (1i64 << max_b) - 1;

    let max_a = *a.iter().max().unwrap();
    let mut fib = vec![0i64, 1];
    for i in 2..(max_a as usize + 2) {
        fib.push((fib[i - 1] + fib[i - 2]) & mod_mask);
    }

    for i in 0..size {
        r[i] = fib[(a[i] + 1) as usize] & ((1i64 << b[i]) - 1);
    }

    r
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

Rust Largest String

fn largest_string(s: &str) -> String {
    let mut bytes: Vec<u8> = s.bytes().collect();
    let len = bytes.len() as i64;
    let mut cur: Vec<u8> = Vec::new();

    let mut i = len - 1;
    while i >= 0 {
        cur.insert(0, bytes[i as usize]);

        if cur.len() == 3 {
            if cur == b"abb" {
                bytes[i as usize] = b'b';
                bytes[i as usize + 1] = b'a';
                bytes[i as usize + 2] = b'a';

                if bytes.get(i as usize + 4) == Some(&b'b') {
                    i += 4 + 1;
                } else if bytes.get(i as usize + 3) == Some(&b'b') {
                    i += 3 + 1;
                } else if bytes.get(i as usize + 2) == Some(&b'b') {
                    i += 2 + 1;
                }
            }
            if bytes.get(i as usize + 1) == Some(&b'b') {
                i += 1 + 1;
            } else {
                i += 1;
            }
            cur.clear();
        }

        i -= 1;
    }

    String::from_utf8(bytes).unwrap()
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Counters

fn max_counters(n: i64, a: &[i64]) -> Vec<i64> {
    let mut counters = vec![0i64; n as usize];
    let mut max_counter = 0i64;
    let mut last_update = 0i64;
    let condition = n + 1;

    for &v in a {
        if v <= n {
            let index = (v - 1) as usize;
            if counters[index] < last_update {
                counters[index] = last_update;
            }
            counters[index] += 1;
            max_counter = max_counter.max(counters[index]);
        }
        if v == condition {
            last_update = max_counter;
        }
    }

    for c in counters.iter_mut() {
        if *c < last_update {
            *c = last_update;
        }
    }

    counters
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Double Slice Sum

fn max_double_slice_sum(a: &[i64]) -> i64 {
    let size = a.len();
    if size < 3 {
        return 0;
    }

    let mut p1 = vec![0i64; size];
    let mut p2 = vec![0i64; size];

    for i in 2..size - 1 {
        p1[i] = 0.max(p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = 0.max(p2[size - i] + a[size - i]);
    }

    let mut sum = p1[1] + p2[1];
    for i in 1..size - 1 {
        sum = sum.max(p1[i] + p2[i]);
    }

    sum
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Product Of Three

fn max_product_of_three(mut a: Vec<i64>) -> i64 {
    a.sort();
    let c = a.len();

    (a[c - 1] * a[c - 2] * a[c - 3]).max(a[0] * a[1] * a[c - 1])
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Profit

fn max_profit(a: &[i64]) -> i64 {
    let mut price = a[0];
    let mut profit = 0i64;
    for &v in a {
        price = price.min(v);
        profit = profit.max(v - price);
    }

    profit
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

Rust Max Slice Sum

fn max_slice_sum(a: &[i64]) -> i64 {
    let mut tmp = a[0];
    let mut max = a[0];

    for &v in &a[1..] {
        tmp = (tmp + v).max(v);
        max = max.max(tmp);
    }

    max
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

Rust Min Avg Two Slice

fn min_avg_two_slice(a: &[i64]) -> i64 {
    let mut idx = 0i64;
    let mut min = (a[0] + a[1]) as f64 / 2.0;

    for i in 0..a.len() - 1 {
        let mut cur = (a[i] + a[i + 1]) as f64 / 2.0;
        if i + 2 < a.len() {
            let three = (a[i] + a[i + 1] + a[i + 2]) as f64 / 3.0;
            cur = cur.min(three);
        }
        if cur < min {
            min = cur;
            idx = i as i64;
        }
    }

    idx
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

Rust Min Perimeter Rectangle

fn min_perimeter_rectangle(n: i64) -> i64 {
    let mut i = 1i64;
    let mut min = i64::MAX;
    while i * i < n {
        if n % i == 0 {
            min = min.min(2 * (i + n / i));
        }
        i += 1;
    }

    min
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

Rust Missing Integer

use std::collections::HashSet;

fn missing_integer(a: &[i64]) -> i64 {
    let mut vals: Vec<i64> = a.iter().copied().collect::<HashSet<_>>().into_iter().collect();
    vals.sort();

    let mut min = 1i64;
    for v in vals {
        if v > 0 {
            if min != v {
                break;
            }
            min += 1;
        }
    }

    min
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

Rust Nesting

fn nesting(s: &str) -> i64 {
    if s.is_empty() {
        return 1;
    }

    let mut stack = Vec::new();
    for c in s.chars() {
        if c == ')' {
            if stack.pop() != Some('(') {
                return 0;
            }
        } else {
            stack.push(c);
        }
    }

    if stack.is_empty() { 1 } else { 0 }
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

Rust Number Of Disc Intersections

fn number_of_disc_intersections(a: &[i64]) -> i64 {
    let c = a.len();
    let mut start = vec![0i64; c];
    let mut end = vec![0i64; c];

    for (k, &v) in a.iter().enumerate() {
        let k = k as i64;
        let key = if k < v { 0 } else { (k - v) as usize };
        start[key] += 1;

        let key = if k + v >= c as i64 { c - 1 } else { (k + v) as usize };
        end[key] += 1;
    }

    let mut sum = 0i64;
    let mut active = 0i64;
    for k in 0..c {
        sum += active * start[k] + (start[k] * (start[k] - 1)) / 2;
        active += start[k] - end[k];
        if sum > 10_000_000 {
            return -1;
        }
    }

    sum
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

Rust Odd Occurrences In Array

use std::collections::HashMap;

fn odd_occurrences_in_array(a: &[i64]) -> Option<i64> {
    let mut count: HashMap<i64, bool> = HashMap::new();
    for &value in a {
        if count.contains_key(&value) {
            count.remove(&value);
        } else {
            count.insert(value, true);
        }
    }

    count.keys().next().copied()
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

Rust Palindrome Rearranging

use std::collections::HashMap;

fn palindrome_rearranging(input_string: &str) -> bool {
    let mut counts: HashMap<char, i64> = HashMap::new();
    for c in input_string.chars() {
        *counts.entry(c).or_insert(0) += 1;
    }

    counts.values().filter(|&&v| v % 2 != 0).count() <= 1
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

Rust Passing Cars

fn passing_cars(a: &[i64]) -> i64 {
    let mut passing_cars = 0i64;
    let mut multiply = 0i64;
    for &i in a {
        if i == 0 {
            multiply += 1;
        } else if multiply > 0 {
            passing_cars += multiply;
            if passing_cars > 1_000_000_000 {
                return -1;
            }
        }
    }

    passing_cars
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

Rust Peaks

fn peaks(a: &[i64]) -> i64 {
    let n = a.len();
    if n <= 2 {
        return 0;
    }

    let mut sum = vec![0i64; n];
    let mut last: i64 = -1;
    let mut dist: i64 = 0;

    for i in 1..n - 1 {
        sum[i] = sum[i - 1];
        if a[i] > a[i - 1] && a[i] > a[i + 1] {
            dist = dist.max(i as i64 - last);
            last = i as i64;
            sum[i] += 1;
        }
    }

    sum[n - 1] = sum[n - 2];
    if sum[n - 1] == 0 {
        return 0;
    }

    dist = dist.max(n as i64 - last);

    let mut i = (dist >> 1) + 1;
    while i < dist {
        if n as i64 % i == 0 {
            let mut last_sum = 0i64;
            let mut j = i;
            while j <= n as i64 {
                if sum[(j - 1) as usize] <= last_sum {
                    break;
                }
                last_sum = sum[(j - 1) as usize];
                j += i;
            }
            if j > n as i64 {
                return n as i64 / i;
            }
        }
        i += 1;
    }

    let mut last_final = dist;
    while n as i64 % last_final != 0 {
        last_final += 1;
    }

    n as i64 / last_final
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

Rust Perm Check

fn perm_check(mut a: Vec<i64>) -> i64 {
    a.sort();

    for (k, &i) in a.iter().enumerate() {
        if k + 1 < a.len() && i != k as i64 + 1 {
            return 0;
        }
    }

    1
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

Rust Perm Missing Element

fn perm_missing_element(mut a: Vec<i64>) -> i64 {
    a.sort();

    for (k, &v) in a.iter().enumerate() {
        if v != k as i64 + 1 {
            return k as i64 + 1;
        }
    }

    a.len() as i64 + 1
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

Rust Plagiarism Check

use std::collections::HashMap;

fn tokenize(s: &str) -> Vec<String> {
    let mut tokens = Vec::new();
    let mut current = String::new();
    for c in s.chars() {
        if c.is_alphanumeric() || c == '_' {
            current.push(c);
        } else if !current.is_empty() {
            tokens.push(std::mem::take(&mut current));
        }
    }
    if !current.is_empty() {
        tokens.push(current);
    }

    tokens
}

fn is_numeric_token(s: &str) -> bool {
    s.parse::<f64>().is_ok()
}

fn plagiarism_check(code1: &[String], code2: &[String]) -> bool {
    let c1 = code1.join(" ");
    let c2 = code2.join(" ");
    if c1 == c2 {
        return false;
    }

    let d1 = tokenize(&c1);
    let d2 = tokenize(&c2);

    let mut r_cand: HashMap<String, String> = HashMap::new();
    for (v, w) in d1.iter().zip(d2.iter()) {
        if v != w && !is_numeric_token(v) {
            r_cand.insert(v.clone(), w.clone());
        }
    }

    let renamed: Vec<String> = d1
        .iter()
        .map(|t| r_cand.get(t).cloned().unwrap_or_else(|| t.clone()))
        .collect();

    renamed == d2
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

Rust Shape Area

fn shape_area(n: i64) -> i64 {
    if n > 1 {
        shape_area(n - 1) + 4 * (n - 1)
    } else {
        1
    }
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

Rust Stone Blocks

fn stone_blocks(h: &[i64]) -> i64 {
    let mut height: Vec<i64> = Vec::new();
    let mut blocks = 0i64;

    for &i in h {
        while let Some(&last) = height.last() {
            if last > i {
                height.pop();
            } else {
                break;
            }
        }
        if let Some(&last) = height.last() {
            if last == i {
                continue;
            }
        }

        height.push(i);
        blocks += 1;
    }

    blocks
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

Rust Tape Equilibrium

fn tape_equilibrium(a: &[i64]) -> i64 {
    let mut first_part = 0i64;
    let mut second_part: i64 = a.iter().sum();
    let mut min = i64::MAX;

    for i in 0..a.len() - 1 {
        first_part += i as i64;
        second_part -= i as i64;
        let difference = (first_part - second_part).abs();
        min = min.min(difference);
    }

    min
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

Rust Triangle

fn triangle(mut a: Vec<i64>) -> i64 {
    a.sort();
    let c = a.len();
    if c < 3 {
        return 0;
    }

    for i in 0..c - 2 {
        if a[i] > 0 && a[i] > a[i + 2] - a[i + 1] {
            return 1;
        }
    }

    0
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.