DEV Community: Antonio Perrone

Advent of Code 2023 - DAY 11

Antonio Perrone — Wed, 03 Jan 2024 15:17:10 +0000

Problem Day 11: Cosmic Expansion

Here the day 11 problem statement: https://adventofcode.com/2023/day/11

Solution Part 1

pub fn build_galaxies(input: &str) -> Vec<(usize, usize)> {
    let mut galaxies: Vec<(usize, usize)> = Vec::new();

    for (i, row) in input.lines().enumerate() {
        for (j, col) in row.chars().enumerate() {
            if col.eq(&'#') {
                galaxies.push((i, j))
            }
        }
    }
    galaxies
}

pub fn extract_empty_rows(galaxies: &mut Vec<(usize, usize)>) -> Vec<usize> {
    let mut empty_rows: Vec<usize> = Vec::new();

    galaxies.sort_by(|a, b| a.0.cmp(&b.0));

    for i in 0..galaxies.len() - 1 {
        if galaxies[i + 1].0 - galaxies[i].0 > 1 {
            for j in galaxies[i].0 + 1..galaxies[i + 1].0 {
                empty_rows.push(j);
            }
        }
    }

    empty_rows
}

pub fn extract_empty_cols(galaxies: &mut Vec<(usize, usize)>) -> Vec<usize> {
    let mut empty_cols: Vec<usize> = Vec::new();

    galaxies.sort_by(|a, b| a.1.cmp(&b.1));

    for i in 0..galaxies.len() - 1 {
        if galaxies[i + 1].1 - galaxies[i].1 > 1 {
            for j in galaxies[i].1 + 1..galaxies[i + 1].1 {
                empty_cols.push(j);
            }
        }
    }

    empty_cols
}

pub fn expand_galaxies(
    galaxies: &mut [(usize, usize)],
    empty_rows: &[usize],
    empty_cols: &[usize],
    rate: usize,
) {
    for galaxy in galaxies {
        let num_step_x = empty_rows.iter().filter(|r| **r < galaxy.0).count() as usize;
        let num_step_y = empty_cols.iter().filter(|c| **c < galaxy.1).count() as usize;

        galaxy.0 += (num_step_x * (rate - 1)) as usize;
        galaxy.1 += (num_step_y * (rate - 1)) as usize;
    }
}

pub fn solve(input: &str, rate: usize) -> usize {
    let mut galaxies: Vec<(usize, usize)> = build_galaxies(input);
    let empty_rows: Vec<usize> = extract_empty_rows(&mut galaxies);
    let empty_cols: Vec<usize> = extract_empty_cols(&mut galaxies);

    expand_galaxies(&mut galaxies, &empty_rows, &empty_cols, rate);

    let mut distances_sum: usize = 0;
    for i in 0..galaxies.len() {
        for j in i + 1..galaxies.len() {
            let distance = (galaxies[i].0 as i32 - galaxies[j].0 as i32).abs()
                + (galaxies[i].1 as i32 - galaxies[j].1 as i32).abs();

            distances_sum += distance as usize;
        }
    }

    distances_sum
}

pub fn part1(input: &str) -> usize {
    solve(input, 2)
}

Solution Part 2

pub fn part2(input: &str) -> usize {
    solve(input, 1_000_000)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 9

Antonio Perrone — Mon, 18 Dec 2023 14:14:07 +0000

Problem Day 9: Mirage Maintenance

Here the day 9 problem statement: https://adventofcode.com/2023/day/9

Solution Part 1

pub fn part_one(input: &str) -> Option<i32> {
    let histories = input
        .lines()
        .map(|line| {
            let values = line
                .split_ascii_whitespace()
                .map(|x| x.parse::<i32>().unwrap())
                .collect::<Vec<i32>>();
            values
        })
        .collect::<Vec<_>>();
    let mut sum = 0;

    for history in histories {
        let mut current = history.clone();
        let mut last: Vec<i32> = Vec::new();
        loop {
            if current.iter().sum::<i32>() == 0 {
                last.push(current.last().unwrap().clone());
                break;
            }

            last.push(current.last().unwrap().clone());

            let mut app: Vec<i32> = Vec::new();
            for i in 0..current.len() - 1 {
                app.push(current[i + 1] - current[i])
            }

            current = app;
        }
        last.reverse();
        for i in 1..last.len() {
            last[i] += last[i - 1];
        }
        sum += last.last().unwrap();
    }
    Some(sum)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<i32> {
    let histories = input
        .lines()
        .map(|line| {
            let values = line
                .split_ascii_whitespace()
                .map(|x| x.parse::<i32>().unwrap())
                .collect::<Vec<i32>>();
            values
        })
        .collect::<Vec<_>>();
    let mut sum = 0;

    for history in histories {
        let mut current = history.clone();
        let mut first: Vec<i32> = Vec::new();
        loop {
            if current.iter().sum::<i32>() == 0 {
                first.push(current.last().unwrap().clone());
                break;
            }

            first.push(current.first().unwrap().clone());

            let mut app: Vec<i32> = Vec::new();
            for i in 0..current.len() - 1 {
                app.push(current[i + 1] - current[i])
            }

            current = app;
        }
        first.reverse();

        for i in 1..first.len() {
            first[i] -= first[i - 1];
        }

        sum += first.last().unwrap();
    }

    Some(sum)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 8

Antonio Perrone — Fri, 15 Dec 2023 11:53:25 +0000

Problem Day 8: Haunted Wasteland

Here the day 8 problem statement: https://adventofcode.com/2023/day/8

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let commands = input.lines().next().unwrap();

    let mut network: HashMap<&str, (&str, &str)> = HashMap::new();

    input.lines().skip(2).for_each(|line| {
        let parts: Vec<&str> = line.split(" = ").collect();
        let key = parts[0];
        let value = parts[1]
            .strip_prefix('(')
            .unwrap()
            .strip_suffix(')')
            .unwrap()
            .split_once(", ")
            .unwrap();
        network.insert(key, value);
    });

    let mut step = network.get("AAA").unwrap();
    let mut counter = 0;

    for command in commands.chars().cycle() {
        counter += 1;
        if command == 'L' {
            if step.0 == "ZZZ" {
                return Some(counter);
            }
            let next = network.get(step.0).unwrap();

            step = next;
        } else if command == 'R' {
            if step.1 == "ZZZ" {
                return Some(counter);
            }
            let next = network.get(step.1).unwrap();
            step = next;
        }
    }

    Some(counter)
}

Solution Part 2

fn lcm(nums: &[usize]) -> usize {
    let mut result = 1;
    for &num in nums {
        result = num * result / gcd(num, result);
    }
    result
}

fn gcd(a: usize, b: usize) -> usize {
    if b == 0 {
        return a;
    }

    gcd(b, a % b)
}

pub fn part_two(input: &str) -> Option<usize> {
     let commands = input.lines().next().unwrap();

    let mut network: HashMap<&str, (&str, &str)> = HashMap::new();

    input.lines().skip(2).for_each(|line| {
        let parts: Vec<&str> = line.split(" = ").collect();
        let key = parts[0];
        let value = parts[1]
            .strip_prefix('(')
            .unwrap()
            .strip_suffix(')')
            .unwrap()
            .split_once(", ")
            .unwrap();
        network.insert(key, value);
    });

    let start_nodes: Vec<_> = network.iter().filter(|x| x.0.ends_with('A')).collect();

    let mut end_counts = HashMap::<&str, usize>::new();

    for start in start_nodes.iter() {
        let mut current_node_name = *start.0;
        let mut count = 0;
        let mut commands_list = commands.chars().cycle();

        while !current_node_name.ends_with('Z') {
            let command = commands_list.next().unwrap();
            let current_node = network.get(current_node_name).unwrap();

            let next_node_name = match command {
                'L' => current_node.0,
                'R' => current_node.1,
                _ => unreachable!(),
            };

            current_node_name = next_node_name;
            count += 1;
        }

        end_counts.insert(start.0, count);
    }

    let counts = end_counts.values().cloned().collect::<Vec<_>>();

    let lcm = lcm(&counts);

    Some(lcm)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 7

Antonio Perrone — Thu, 14 Dec 2023 13:59:41 +0000

Problem Day 7: Camel Cards

Here the day 7 problem statement: https://adventofcode.com/2023/day/7

Solution Part 1

enum HandType {
    FiveOfAKind,
    FourOfAKind,
    FullHouse,
    ThreeOfAKind,
    TwoPairs,
    OnePair,
    HighCard,
}

fn card_to_rank(card: char) -> usize {
    match card {
        '2' => 0,
        '3' => 1,
        '4' => 2,
        '5' => 3,
        '6' => 4,
        '7' => 5,
        '8' => 6,
        '9' => 7,
        'T' => 8,
        'J' => 9,
        'Q' => 10,
        'K' => 11,
        'A' => 12,
        _ => panic!("bad"),
    }
}

fn get_hand_type(hand: Hand) -> HandType {
    let mut sorted_hand = hand.ranks;
    sorted_hand.sort_by(|a, b| b.cmp(a));
    match sorted_hand[0] {
        5 => HandType::FiveOfAKind,
        4 => HandType::FourOfAKind,
        3 => {
            if sorted_hand[1] == 2 {
                HandType::FullHouse
            } else {
                HandType::ThreeOfAKind
            }
        }

        2 => {
            if sorted_hand[1] == 2 {
                HandType::TwoPairs
            } else {
                HandType::OnePair
            }
        }
        1 | 0 => HandType::HighCard,

        _ => panic!("Invalid Hand"),
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Hand {
    cards: [usize; 5],
    score: u32,
    ranks: [u8; 13],
}

impl Hand {
    fn new(hand: &str, score: u32) -> Self {
        let mut ranks = [0; 13];
        let mut cards = [0; 5];

        for (i, card) in hand.chars().enumerate() {
            ranks[card_to_rank(card)] += 1;
            cards[i] = card_to_rank(card);
        }

        Self {
            cards,
            score,
            ranks,
        }
    }
}

impl PartialOrd for Hand {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match get_hand_type(*self).cmp(&get_hand_type(*other)) {
            Ordering::Equal => Some(self.cards.cmp(&other.cards).reverse()),
            ord => Some(ord),
        }
    }
}
impl Ord for Hand {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

pub fn part_one(input: &str) -> Option<u32> {
    let mut hands: Vec<Hand> = input
        .lines()
        .map(|line| {
            let (hand, score) = line.split(' ').collect_tuple().unwrap();
            Hand::new(hand, score.parse().unwrap())
        })
        .collect();

    hands.sort_by(|h1, h2| h2.cmp(h1));
    let score: u32 = hands
        .iter()
        .enumerate()
        .map(|(idx, hand)| (idx as u32 + 1) * hand.score)
        .sum();

    Some(score)
}

Solution Part 2

enum HandType {
    FiveOfAKind,
    FourOfAKind,
    FullHouse,
    ThreeOfAKind,
    TwoPairs,
    OnePair,
    HighCard,
}

fn card_to_rank_2(card: char) -> usize {
    match card {
        'J' => 0,
        '2' => 1,
        '3' => 2,
        '4' => 3,
        '5' => 4,
        '6' => 5,
        '7' => 6,
        '8' => 7,
        '9' => 8,
        'T' => 9,
        'Q' => 10,
        'K' => 11,
        'A' => 12,
        _ => panic!("bad"),
    }
}

fn get_hand_type_2(hand: Hand2) -> HandType {
    let mut sorted_hand = hand.ranks;
    sorted_hand.sort_by(|a, b| b.cmp(a));
    match sorted_hand[0] {
        5 => HandType::FiveOfAKind,
        4 => HandType::FourOfAKind,
        3 => {
            if sorted_hand[1] == 2 {
                HandType::FullHouse
            } else {
                HandType::ThreeOfAKind
            }
        }

        2 => {
            if sorted_hand[1] == 2 {
                HandType::TwoPairs
            } else {
                HandType::OnePair
            }
        }
        1 | 0 => HandType::HighCard,

        _ => panic!("Invalid Hand"),
    }
}

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Hand2 {
    cards: [usize; 5],
    score: u32,
    ranks: [u8; 13],
}

impl Hand2 {
    fn new(hand: &str, score: u32) -> Self {
        let mut ranks = [0; 13];
        let mut cards = [0; 5];

        for (i, card) in hand.chars().enumerate() {
            ranks[card_to_rank_2(card)] += 1;
            cards[i] = card_to_rank_2(card);
        }

        Self {
            cards,
            score,
            ranks,
        }
    }
}

impl PartialOrd for Hand2 {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match get_hand_type_2(*self).cmp(&get_hand_type_2(*other)) {
            Ordering::Equal => Some(self.cards.cmp(&other.cards).reverse()),
            ord => Some(ord),
        }
    }
}
impl Ord for Hand2 {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

fn apply_j(hand: &mut Hand2) {
    let j = hand.ranks[0];

    match get_hand_type_2(*hand) {
        HandType::FiveOfAKind => {
            hand.ranks[0] = 0;
            hand.ranks[12] = 5;
        }
        HandType::FourOfAKind => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }
            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] = 5;
        }
        HandType::FullHouse => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }
            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] += j;
        }
        HandType::ThreeOfAKind => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }
            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] += j;
        }
        HandType::TwoPairs => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }
            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] += j;
        }
        HandType::OnePair => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }

            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] += j;
        }
        HandType::HighCard => {
            let mut max_rank_index = 1;
            for i in 1..13 {
                if hand.ranks[i] >= hand.ranks[max_rank_index] {
                    max_rank_index = i
                }
            }
            hand.ranks[0] = 0;
            hand.ranks[max_rank_index] += j;
        }
    }
}

pub fn part_two(input: &str) -> Option<u32> {
    let mut hands: Vec<Hand2> = input
        .lines()
        .map(|line| {
            let (hand, score) = line.split(' ').collect_tuple().unwrap();
            Hand2::new(hand, score.parse().unwrap())
        })
        .collect();

    hands.iter_mut().for_each(|h| {
        if h.ranks[0] > 0 {
            apply_j(h)
        }
    });

    hands.sort_by(|h1, h2| h2.cmp(h1));
    let score: u32 = hands
        .iter()
        .enumerate()
        .map(|(idx, hand)| (idx as u32 + 1) * hand.score)
        .sum();

    Some(score)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 6

Antonio Perrone — Tue, 12 Dec 2023 18:43:34 +0000

Problem Day 6: Wait For It

Here the day 6 problem statement: https://adventofcode.com/2023/day/6

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let lines = input.split('\n').collect::<Vec<_>>();
    let times = lines[0].split(':').collect::<Vec<_>>()[1]
        .split(' ')
        .filter(|c| !c.is_empty())
        .collect::<Vec<_>>();
    let distances = lines[1].split(':').collect::<Vec<_>>()[1]
        .split(' ')
        .filter(|c| !c.is_empty())
        .collect::<Vec<_>>();

    let mut total = 1;

    for i in 0..times.len() {
        let mut winning = 0;

        let time = times[i].parse::<u32>().unwrap();

        for j in 0..=time {
            let distance = j * (time - j);
            if distance > distances[i].parse::<u32>().unwrap() {
                winning += 1;
            }
        }

        total *= winning;
    }

    Some(total)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<u32> {
    let lines = input.split('\n').collect::<Vec<_>>();
    let time = lines[0].split(':').collect::<Vec<_>>()[1]
        .split(' ')
        .filter(|c| !c.is_empty())
        .collect::<Vec<_>>()
        .join("")
        .parse::<f64>()
        .unwrap();
    let distance = lines[1].split(':').collect::<Vec<_>>()[1]
        .split(' ')
        .filter(|c| !c.is_empty())
        .collect::<Vec<_>>()
        .join("")
        .parse::<f64>()
        .unwrap();

    let min = (time - (time.powf(2.0) - 4.0 * distance).sqrt()) / 2.0;
    let max = (time + (time.powf(2.0) - 4.0 * distance).sqrt()) / 2.0;

    Some((max - min + 1.0) as u32)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 5

Antonio Perrone — Tue, 12 Dec 2023 18:35:24 +0000

Problem Day 5: If You Give A Seed A Fertilizer

Here the day 5 problem statement: https://adventofcode.com/2023/day/5

Solution Part 1

pub fn part_one(input: &str) -> Option<i64> {
    let sections = input.split("\n\n").collect::<Vec<_>>();

    let seeds = sections[0].split(": ").collect::<Vec<_>>()[1]
        .split(' ')
        .collect::<Vec<_>>();

    let mut maps: Vec<Vec<Vec<i64>>> = Vec::new();

    for section in sections.iter().skip(1) {
        let mut map: Vec<Vec<i64>> = Vec::new();
        for line in section.lines().skip(1) {
            map.push(line.split(' ').map(|x| x.parse::<i64>().unwrap()).collect());
        }
        maps.push(map);
    }

    let mut lowest_location: i64 = 0;
    let mut first = true;
    for seed in seeds {
        let mut src = seed.parse::<i64>().unwrap();
        for map in maps.iter() {
            for row in map {
                if src >= row[1] && src <= row[1] + row[2] {
                    src = row[0] + (src - row[1]);
                    break;
                }
            }
        }

        if first {
            lowest_location = src;
            first = false;
        }

        if src < lowest_location {
            lowest_location = src;
        }
    }

    Some(lowest_location as i64)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<i64> {
    let sections = input.split("\n\n").collect::<Vec<_>>();

    let mut seed_ranges = sections[0].split(": ").collect::<Vec<_>>()[1]
        .split(' ')
        .map(|s| s.parse::<i64>().unwrap())
        .collect::<Vec<_>>()
        .chunks(2)
        .map(|chunk| (chunk[0], chunk[0] + chunk[1]))
        .collect::<Vec<_>>();

    let mut maps: Vec<Vec<Vec<i64>>> = Vec::new();

    for section in sections.iter().skip(1) {
        let mut map: Vec<Vec<i64>> = Vec::new();
        for line in section.lines().skip(1) {
            map.push(line.split(' ').map(|x| x.parse::<i64>().unwrap()).collect());
        }

        maps.push(map);
    }

    for map in maps {
        let mut ranges: Vec<(i64, i64)> = Vec::new();

        while !seed_ranges.is_empty() {
            let mut overlap = false;
            let seed = seed_ranges.pop().unwrap();
            for row in map.iter() {
                let overlap_start = cmp::max(seed.0, row[1]);
                let overlap_end = cmp::min(seed.1, row[1] + row[2]);
                if overlap_start < overlap_end {
                    ranges.push((
                        overlap_start - row[1] + row[0],
                        overlap_end - row[1] + row[0],
                    ));
                    if overlap_start > seed.0 {
                        seed_ranges.push((seed.0, overlap_start));
                    }
                    if seed.1 > overlap_end {
                        seed_ranges.push((overlap_end, seed.1));
                    }
                    overlap = true;
                    break;
                }
            }
            if !overlap {
                ranges.push(seed);
            }
        }
        seed_ranges = ranges;
    }

    let lowest_location: i64 = seed_ranges.iter().map(|x: &(i64, i64)| x.0).min().unwrap();
    Some(lowest_location)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 4

Antonio Perrone — Mon, 04 Dec 2023 11:09:10 +0000

Problem Day 4: Scratchcards

Here the day 4 problem statement: https://adventofcode.com/2023/day/4

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let cards = input.split('\n').collect::<Vec<&str>>();
    let mut total = 0;
    for card in cards {
        let mut points = 0;
        let (_, cards_line) = card.split_once(": ").unwrap();
        let (winning_cards, my_cards) = cards_line.split_once(" | ").unwrap();

        let winning = winning_cards
            .split(' ')
            .filter(|&x| x.ne(""))
            .collect::<Vec<&str>>();

        let mine: Vec<&str> = my_cards
            .split(' ')
            .filter(|&x| x.ne(""))
            .collect::<Vec<&str>>();

        for card in mine {
            if winning.contains(&card) {
                if points == 0 {
                    points = 1;
                } else {
                    points *= 2;
                }
            }
        }
        total += points;
    }

    Some(total)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<u32> {
    let cards = input.split('\n').collect::<Vec<&str>>();
    let mut n_winning = vec![0u32; cards.len()];
    let mut copies = vec![1u32; cards.len()];

    for (i, card) in cards.iter().enumerate() {
        let (_, cards_line) = card.split_once(": ").unwrap();
        let (winning_cards, my_cards) = cards_line.split_once(" | ").unwrap();

        let winning = winning_cards
            .split(' ')
            .filter(|&x| x.ne(""))
            .collect::<Vec<&str>>();

        let mine: Vec<&str> = my_cards
            .split(' ')
            .filter(|&x| x.ne(""))
            .collect::<Vec<&str>>();

        for card in mine {
            if winning.contains(&card) {
                n_winning[i] += 1;
            }
        }
    }

    for i in 0..n_winning.len() {
        for j in i + 1..=i + n_winning[i] as usize {
            copies[j] += copies[i] as u32;
        }
    }

    Some(copies.iter().sum())
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 3

Antonio Perrone — Sun, 03 Dec 2023 09:45:59 +0000

Problem Day 3: Gear Ratios

Here the day 3 problem statement: https://adventofcode.com/2023/day/3

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let grid = input.split('\n').collect::<Vec<&str>>();

    let mut coordinates: HashSet<[usize; 2]> = HashSet::new();

    for (r, line) in grid.iter().enumerate() {
        for (c, ch) in line.chars().enumerate() {
            if ch.is_numeric() || ch == '.' {
                continue;
            }

            for i in r - 1..r + 2 {
                for j in c - 1..c + 2 {
                    if i >= grid.len()
                        || j >= grid[i].len()
                        || !(grid[i].chars().nth(j).unwrap().is_numeric())
                    {
                        continue;
                    }
                    let mut k = j;
                    while k > 0 && grid[i].chars().nth(k - 1).unwrap().is_numeric() {
                        k -= 1;
                    }

                    coordinates.insert([i, k]);
                }
            }
        }
    }

    let mut result = 0;

    for c in coordinates.iter() {
        let mut digits: Vec<String> = vec![];

        let mut col = c[1];
        while col < grid[c[0]].len() && grid[c[0]].chars().nth(col).unwrap().is_numeric() {
            digits.push(grid[c[0]].chars().nth(col).unwrap().to_string());
            col += 1
        }

        result += digits.join("").parse::<u32>().unwrap();
    }
    Some(result)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<u32> {
    let grid = input.split('\n').collect::<Vec<&str>>();
    let mut result = 0;

    for (r, line) in grid.iter().enumerate() {
        for (c, ch) in line.chars().enumerate() {
            if ch != '*' {
                continue;
            }

            let mut coordinates: HashSet<[usize; 2]> = HashSet::new();

            for i in r - 1..r + 2 {
                for j in c - 1..c + 2 {
                    if i >= grid.len()
                        || j >= grid[i].len()
                        || !(grid[i].chars().nth(j).unwrap().is_numeric())
                    {
                        continue;
                    }
                    let mut k = j;
                    while k > 0 && grid[i].chars().nth(k - 1).unwrap().is_numeric() {
                        k -= 1;
                    }

                    coordinates.insert([i, k]);
                }
            }

            if coordinates.len() != 2 {
                continue;
            }

            let mut product = 1;

            for c in coordinates.iter() {
                let mut digits: Vec<String> = vec![];

                let mut col = c[1];
                while col < grid[c[0]].len() && grid[c[0]].chars().nth(col).unwrap().is_numeric() {
                    digits.push(grid[c[0]].chars().nth(col).unwrap().to_string());
                    col += 1
                }

                product *= digits.join("").parse::<u32>().unwrap();
            }

            result += product;
        }
    }

    Some(result)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 2

Antonio Perrone — Sat, 02 Dec 2023 11:48:06 +0000

Problem Day 2: Cube Conundrum

Here the day 2 problem statement: https://adventofcode.com/2023/day/2

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let bag = HashMap::from([("red", 12), ("green", 13), ("blue", 14)]);
    let games = input.split('\n').collect::<Vec<&str>>();
    let mut results = vec![true; games.len()];

    for (idx, game) in games.iter().enumerate() {
        if game.is_empty() {
            continue;
        }
        let rounds = game
            .split(": ")
            .collect::<Vec<&str>>()
            .get(1)
            .unwrap()
            .split("; ")
            .collect::<Vec<&str>>();

        for round in rounds {
            let cubes = round.split(", ").collect::<Vec<&str>>();
            cubes.iter().for_each(|cube| {
                let mut parts = cube.split(' ');
                let value = parts.next().unwrap().parse::<i32>().unwrap();
                let key = parts.next().unwrap();

                if *bag.get(key).unwrap() < value {
                    results[idx] = false;
                }
            });
        }
    }

    let mut result = 0_u32;
    for (idx, r) in results.iter().enumerate() {
        if *r {
            result += (idx + 1) as u32;
        }
    }
    Some(result)
}

Solution Part 2

pub fn part_two(input: &str) -> Option<u32> {
    let games = input.split('\n').collect::<Vec<&str>>();
    let mut result = 0;

    for game in games {
        let mut red = 0;
        let mut green = 0;
        let mut blue = 0;

        if game.is_empty() {
            continue;
        }
        let rounds = game
            .split(": ")
            .collect::<Vec<&str>>()
            .get(1)
            .unwrap()
            .split("; ")
            .collect::<Vec<&str>>();

        for round in rounds {
            let cubes = round.split(", ").collect::<Vec<&str>>();
            cubes.iter().for_each(|cube| {
                let mut parts = cube.split(' ');
                let value = parts.next().unwrap().parse::<i32>().unwrap();
                let key = parts.next().unwrap();

                match key {
                    "red" => {
                        if red < value {
                            red = value
                        }
                    }
                    "green" => {
                        if green < value {
                            green = value
                        }
                    }
                    "blue" => {
                        if blue < value {
                            blue = value
                        }
                    }
                    _ => {}
                }
            });
        }

        result += red * green * blue;
    }

    Some(result as u32)
}

Here the repository with all puzzle solutions.

Advent of Code 2023 - DAY 1

Antonio Perrone — Fri, 01 Dec 2023 16:13:36 +0000

It's Christmas time and time for Advent of Code 2023 edition.
Starting from today I will try to solve puzzles in Rust and publish a post a day in which I tell my solution.
My goal is not to climb the leaderboard but to use the problems to practice writing Rust code and improve my language knowledge. Copilot yes or Copilot not? It's for learning so Copilot definitely not.
The solutions will be available at the following git repository, as I don't have much time to write a template from scratch, I will use the starter template available here.

Problem Day 1: Trebuchet?!

Here the day 1 problem statement: https://adventofcode.com/2023/day/1

Solution Part 1

pub fn part_one(input: &str) -> Option<u32> {
    let lines = input.split('\n').collect::<Vec<&str>>();
    let mut sum_calibration = 0;

    for line in lines {
        if line.is_empty() {
            continue;
        }
        let mut first = false;
        let mut calibration: Vec<String> = vec!["0".to_string(), "0".to_string()];
        for c in line.chars() {
            if c.is_numeric() {
                if !first {
                    first = true;
                    calibration[0] = c.to_string();
                }
                calibration[1] = c.to_string();
            }
        }
        let calibration_num: String = calibration.join("");

        let calib: i32 = calibration_num.parse().unwrap();
        sum_calibration += calib;
    }

    Some(sum_calibration as u32)
}

The solution is quite simple and easy to understand: input variable contains all the file rows, we split the input line by line and loop over each line char by char finding the first and the last digit.
At the end of each line loop we join the digits, cast them to number and sum on a counter variable.

Solution Part 2

pub fn part_two(input: &str) -> Option<u32> {
    const NUM: [&str; 9] = [
        "one", "two", "three", "four", "five", "six", "seven", "eight", "nine",
    ];

    let lines = input.split('\n').collect::<Vec<&str>>();
    let mut sum_calibration = 0;

    for line in lines {
        if line.is_empty() {
            continue;
        }
        let mut first = false;
        let mut calibration: Vec<String> = vec!["0".to_string(), "0".to_string()];
        for (i, c) in line.chars().enumerate() {
            if c.is_numeric() {
                if !first {
                    first = true;
                    calibration[0] = c.to_string();
                }
                calibration[1] = c.to_string();
            }

            for (x, elem) in NUM.iter().enumerate() {
                if line[i..].starts_with(elem) {
                    if !first {
                        first = true;
                        calibration[0] = (x + 1).to_string();
                    }
                    calibration[1] = (x + 1).to_string();
                }
            }
        }
        let calibration_num: String = calibration.join("");

        let calib: i32 = calibration_num.parse().unwrap();
        sum_calibration += calib;
    }

    Some(sum_calibration as u32)
}

The solution evolves as part 1 with only one addition: when we check if each line char is a digit, we also check if the char is the beginning of a digit spelled out with letters. If so, we get it numeric representation.

A Weekly Rust🦀 Pill #5

Antonio Perrone — Wed, 30 Aug 2023 12:26:49 +0000

A Weekly Rust🦀 Pill is a post series where on a weekly base, I share some implementations of the most popular algorithms and data structures to share my learnings on Rust 🦀.

Breadth-First Search

Graphs are fundamental data structures used to represent relationships between various entities. They find applications in various fields, from social networks and transportation systems to computer networks and recommendation systems. One of the most essential algorithms for traversing graphs is the Breadth-First Search (BFS) algorithm. In this blog post, we'll delve into the BFS, understanding how it works and analysing a Rust implementation.

Understanding BFS

Breadth-First Search (BFS) is a graph traversal algorithm that explores a graph by visiting all its nodes in breadth-first order. Unlike depth-first traversal, which goes as deep as possible before backtracking, BFS explores nodes level by level, starting from the root (or a chosen starting node). The algorithm ensures that all nodes at a given depth level are visited before proceeding to the next depth level.

Step-by-Step Walkthrough

Start with an initial node and mark it as visited.
Enqueue the initial node into a queue (FIFO data structure).
While the queue is not empty:
a. Dequeue a node from the front of the queue.
b. Process the node (e.g., print its value).
c. Enqueue all unvisited neighbours of the current node into the queue and mark them as visited.
Repeat step 3 until the queue becomes empty.

Applications of BFS

Shortest Path and Distance Calculation: BFS can be used to find the shortest path between two nodes in an unweighted graph. By systematically exploring nodes layer by layer, BFS guarantees that the shortest path is found when the destination node is reached.
Connectivity and Component Analysis: BFS helps identify connected components within a graph. It is particularly useful in determining whether a graph is connected or not.
Web Crawling: BFS can be employed to crawl web pages, exploring websites and their links in a systematic and organised manner.
Social Network Analysis: BFS assists in analysing social networks by identifying friends and connections within a certain distance from a given individual.

Implementation

Here's a sample implementation

struct Graph {
    size: usize,
    adj_matrix: Vec<Vec<bool>>,
}

impl Graph {
    fn new(size: usize) -> Graph {
        Graph {
            size,
            adj_matrix: vec![vec![false; size]; size],
        }
    }

    fn add_edge(&mut self, v: usize, w: usize) {
        self.adj_matrix[v][w] = true;
    }

    fn bfs(&self, start: usize) -> Vec<usize> {
        let mut visited: Vec<bool> = vec![false; self.size];
        let mut queue: VecDeque<usize> = VecDeque::new();
        let mut path: Vec<usize> = vec![];

        visited[start] = true;
        path.push(start);
        queue.push_back(start);
        while !queue.is_empty() {
            let node = queue.pop_front();

            let node_adj = &self.adj_matrix[node.unwrap() as usize];
            for i in 0..node_adj.len() {
                if visited[i] == false && node_adj[i] {
                    visited[i] = true;
                    queue.push_back(i);

                    path.push(i);
                }
            }
        }

        path
    }
}

The provided code snippet defines a Rust struct called Graph along with its implementation, which includes methods for creating a new graph, adding edges, and performing Breadth-First Search (BFS) traversal on the graph.

Let's break down the code and its components:

Struct Definition:

   struct Graph {
       size: usize,
       adj_matrix: Vec<Vec<bool>>,
   }

The Graph struct represents a graph with an adjacency matrix.
size represents the number of nodes in the graph.
adj_matrix is a 2D vector (a vector of vectors) that stores the adjacency matrix of the graph. It uses boolean values to indicate whether there is an edge between two nodes. If adj_matrix[i][j] is true, it means there is an edge from node i to node j.

Implementation:

   impl Graph {
       // Method to create a new graph
       fn new(size: usize) -> Graph { ... }

       // Method to add an edge between two nodes
       fn add_edge(&mut self, v: usize, w: usize) { ... }

       // Method to perform BFS traversal
       fn bfs(&self, start: usize) -> Vec<usize> { ... }
   }

new Method:

   fn new(size: usize) -> Graph {
       Graph {
           size,
           adj_matrix: vec![vec![false; size]; size],
       }
   }

The new method creates a new instance of the Graph struct with the specified size.
It initialises the adjacency matrix with size rows and columns, filled with false values to indicate no edges initially.

add_edge Method:

   fn add_edge(&mut self, v: usize, w: usize) {
       self.adj_matrix[v][w] = true;
   }

The add_edge method adds an edge between nodes v and w by setting the corresponding entry in the adjacency matrix to true.

bfs Method:

   fn bfs(&self, start: usize) -> Vec<usize> { ... }

The bfs method performs BFS traversal on the graph starting from the specified start node.
It initialises data structures for tracking visited nodes (visited), nodes to visit (queue), and the traversal path (path).
The method uses a loop that continues until the queue is empty.
Within the loop, it dequeues a node from the front of the queue and explores its neighbours, adding them to the queue and updating the visited and path data structures.
The method returns the traversal path as a vector of node indices.

Sample application

The following code is a sample usage of BFS algorithm

fn main() {
    let mut g = Graph::new(6);

    g.add_edge(0, 1);
    g.add_edge(0, 2);
    g.add_edge(1, 2);
    g.add_edge(2, 0);
    g.add_edge(2, 3);
    g.add_edge(3, 3);

    let result = g.bfs(0);
    println!(
        "Following is Breadth First Traversal (starting from vertex 0): {:?}",
        result
    )
}

Generate AI-based Images with Quarkus and OpenAI DALL.E

Antonio Perrone — Mon, 21 Aug 2023 08:35:01 +0000

(Originally published on https://foojay.io/today/images-generation-with-quarkus-and-openai/)

Introduction

In this article, we explore how to integrate OpenAI API with Quarkus. We will create a Quarkus application using the new REST Client Reactive to invoke the OpenAI DALL.E API

OpenAI API Overview

Before jumping into the code, let’s explore the OpenAI Create Image API and how it works.

Create Image Request

The body request is made of the following parameters:

prompt: the only required parameter is the description of the desired image (max 1000 characters)
n: number of desired images (from 1 to 10)
size: the size of a generated image (default 1024x1024, also admitted 256x256, 512x512)

other parameters are:

response_format: to specify the response image format (default url, also admitted b64_json)
user: identifier to track user activities.

To authenticate with the API, we'll generate an API key. We'll set this key in the Authorization header while calling the API.

Here is a sample API request:

curl https://api.openai.com/v1/images/generations \
-H "Content-Type: application/json" \
-H "Authorization: Bearer $OPENAI\_API\_KEY" \
-d '{
   "prompt": "A cute baby sea otter",
   "n": 2,
   "size": "1024x1024"
}'

Create Image Response

The response will be a JSON object with created and data fields. The data field will be an array of objects. Each object will have a url field containing the response to the prompt.

The number of objects in the data array will equal the optional n parameter in the request. If the n parameter is not specified, the data array will contain a single object.

Here is a sample API response:

{
"created": 1589478378,
"data": [
   {
      "url": "https://..."
   },
   {
      "url": "https://..."
   }
]
}

Setting up the Quarkus Application

To startup our application, go to https://code.quarkus.io and configure it by selecting the following extensions:

RESTEasy Reactive Jackson
RESTEasy Reactive
REST Client Reactive
REST Client Reactive Jackson

Or using maven with the following command:

mvn io.quarkus.platform:quarkus-maven-plugin:3.2.3.Final:create \
-DprojectGroupId=com.foojay.openai \
-DprojectArtifactId=quarkus-openai-app \
-Dextensions='resteasy-reactive-jackson,rest-client-reactive-jackson,resteasy-reactive' \
-DnoCode

After creating the project, add your OpenAI API Key with the following line inside the application.properties file.

# OpenAI properties
openai.api.key=$OPENAI_API_KEY

The Model

Now starting from what we have seen before, we create a class to model the API request body of OpenAI Image Generation API:

public class CreateImageRequest {

    @JsonProperty("prompt")
    private String prompt;

    @JsonProperty("n")
    private int n;

    @JsonProperty("size")
    private String size;

    public CreateImageRequest() {
    }

    public String getPrompt() {
        return prompt;
    }

    public void setPrompt(String prompt) {
        this.prompt = prompt;
    }

    public int getN() {
        return n;
    }

    public void setN(int n) {
        this.n = n;
    }

    public String getSize() {
        return size;
    }

    public void setSize(String size) {
        this.size = size;
    }
}

Let\'s define the API response class:

public class CreateImageResponse {

    @JsonProperty("created")
    private Integer created;

    @JsonProperty("data")
    private List<Item> urls;

    public List<Item> getUrls() {
        return urls;
    }

    public void setUrls(List<Item> urls) {
        this.urls = urls;
    }

    public Integer getCreated() {
        return created;
    }

    public void setCreated(Integer created) {
        this.created = created;
    }
}

And finally, the Item class

public class Item {
    @JsonProperty("url")
    private String url;

    public String getUrl() {
        return url;
    }

    public void setUrl(String url) {
        this.url = url;
    }
}

REST Client

To invoke the OpenAI API we define our REST client using the new REST Client Reactive, which allows a declarative way to define the API to be invoked using the new Jakarta EE and Microprofile annotations.

@RegisterRestClient(baseUri = "https://api.openai.com")
@Path("/v1")
public interface OpenAIRestClient {


        @GET
        @Path("/models")
        @ClientHeaderParam(name = "Authorization", value = "Bearer ${openai.api.key}")
        ModelResponse getModels();

        @POST
        @Path("/images/generations")
        @ClientHeaderParam(name = "Authorization", value = "Bearer ${openai.api.key}")
        CreateImageResponse generateImage(CreateImageRequest createImageRequest);

}

The @RegisterRestClient allows Quarkus to know that this interface should be available for CDI injection as a REST Client, the baseUri properties define the url the client point to. @Path, @POST are standard Jakarta REST annotations defining how to access the API.

To manage API auth, as we have seen before, we need to pass the API KEY inside the header of the request. To do this in our client, we use the @ClientHeaderParam passing the name and the value of the entries. In this case, we read the key from the application.properties using the notation ${opena.ai.key} that allows injecting the properties' value directly.

Testing the client

To test our client, let\'s define a REST resource that we will call from out browser.

@Path("/quarkus-openai")
public class OpenAIEndpoint {

    @RestClient
    private OpenAIRestClient openAIRestClient;

    @GET
    @Path("/generate-image")
    @Produces(MediaType.APPLICATION_JSON)
    public Response generateImage(@QueryParam("description") String description,
            @DefaultValue("1") @QueryParam("n") int n,
            @DefaultValue("1024x1024") @QueryParam("size") String size) {

        final CreateImageRequest createImageRequest = new CreateImageRequest();
        createImageRequest.setPrompt(description);
        createImageRequest.setN(n);
        createImageRequest.setSize(size);

        URI uri;
        try {
            uri = new URI(
                    openAIRestClient.generateImage(createImageRequest).getUrls().get(0).getUrl());
        } catch (URISyntaxException e) {
            return Response.noContent().build();
        }
        return Response.seeOther(uri).build();
    }
}

We define OpenAIEndpoint and inject the REST client using @RestClient annotation. Then we create the API generateImage that accepts the prompt and optionally the number of images and their size.

Inside the method, we build the request and pass it to our client; calling the method generateImage, we get the result and perform a redirect to the first URL of the response payload.

To see the result let\'s start our project with the command:

quarkus dev

and point the browser to this example url passing our prompt as the value of description parameters:

http://localhost:8080/quarkus-openai/generate-image?description=a%20photo%20of%20a%20happy%20corgi%20puppy%20sitting%20and%20facing%20forward,%20studio%20light,%20longshot

Try with other prompts and enjoy the results.

Conclusion

This article we explored how to use the OpenAI DALL.E API to generate images from prompts. We created a Quarkus application that calls the API using the new REST Client Reactive and manage the result.

The code examples for this tutorial are available on GitHub.

DEV Community: Antonio Perrone

Advent of Code 2023 - DAY 11

Problem Day 11: Cosmic Expansion

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 9

Problem Day 9: Mirage Maintenance

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 8

Problem Day 8: Haunted Wasteland

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 7

Problem Day 7: Camel Cards

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 6

Problem Day 6: Wait For It

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 5

Problem Day 5: If You Give A Seed A Fertilizer

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 4

Problem Day 4: Scratchcards

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 3

Problem Day 3: Gear Ratios

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 2

Problem Day 2: Cube Conundrum

Solution Part 1

Solution Part 2

Advent of Code 2023 - DAY 1

Problem Day 1: Trebuchet?!

Solution Part 1

Solution Part 2

A Weekly Rust🦀 Pill #5

Breadth-First Search

Understanding BFS

Step-by-Step Walkthrough

Applications of BFS

Implementation

Sample application

Generate AI-based Images with Quarkus and OpenAI DALL.E

Introduction

OpenAI API Overview

Create Image Request

Create Image Response

Setting up the Quarkus Application

The Model

REST Client

Testing the client

Conclusion

References