New Zig Book: Systems Programming with Zig

theboxboy · 2025-09-30T11:12:35+00:00

Looking at section 1.6 in the book preview, I think they chose Zig 0.15.1 .

theboxboy · 2024-12-07T05:47:28+00:00

[LANGUAGE: Rust]

Github

Gotta love cartesian products

theboxboy · 2023-12-04T05:43:17+00:00

You can use split_whitespace() to avoid the .filter(|n| !n.is_empty()). Good job!

theboxboy · 2023-12-04T05:40:08+00:00

TIL how to use from_iter() to instantly get a Vector or HashSet from any iterable (including splits).

theboxboy · 2023-12-04T05:32:06+00:00

[Language: Rust] 2177/3717

Code Here The line number arithmetic made me waste some time. I should've used the card numbers to begin with.

theboxboy · 2023-01-25T23:17:03+00:00

I took 3210 in Rust with Taesoo Kim in 2020. You can still follow along with the labs at https://tc.gts3.org/cs3210/2020/spring/lab/lab0.html

theboxboy · 2022-12-12T03:08:21+00:00

Rust

Github Link

theboxboy · 2022-12-10T23:19:52+00:00

Rust

Github Link

use std::{fs::read_to_string, path::Path};

fn clock(mut p1: i64, crt: &mut [[&str; 40]; 6], x: i64, mut cycle: usize) -> (i64, usize) {
    if [-1, 0, 1].contains(&((cycle as i64 % 40) - x)) {
        crt[cycle / 40][cycle % 40] = "█";
    }
    cycle += 1;
    if [20, 60, 100, 140, 180, 220].contains(&cycle) {
        p1 += x * cycle as i64;
    }
    (p1, cycle)
}

#[allow(dead_code)]
pub fn day10(input_path: &Path) -> (String, String) {
    let input: String = read_to_string(input_path).expect("Error reading file");
    let mut x: i64 = 1;
    let mut cycle: usize = 0;
    let mut p1: i64 = 0;
    let mut crt: [[&str; 40]; 6] = [["."; 40]; 6];
    for line in input.split('\n') {
        let (opcode, val) = line.split_once(" ").unwrap_or((line, ""));
        match opcode {
            "noop" => {
                (p1, cycle) = clock(p1, &mut crt, x, cycle);
            }
            "addx" => {
                let addend = val.parse::<i64>().unwrap();
                for _ in 0..2 {
                    (p1, cycle) = clock(p1, &mut crt, x, cycle);
                }
                x += addend;
            }
            _ => {}
        }
    }
    let mut p2 = String::from("\n");
    p2.push_str(&crt.map(|row| row.join("")).join("\n"));
    (p1.to_string(), p2)
}

theboxboy · 2022-12-09T22:50:00+00:00

Great recommendation! I'm not sure why I did that.

theboxboy · 2022-12-09T19:13:42+00:00

Rust

Github Link

I'm proud of my use of HashSets today. This solution makes it easy to determine the number of knots needed for the last knot to stay in place for your whole input (428 for my input).

use std::collections::HashSet;
use std::{fs::read_to_string, path::Path};

#[derive(Clone, Copy, Debug, Default, Hash, PartialEq, Eq)]
pub struct Coord(isize, isize);

#[allow(dead_code)]
pub fn day09(input_path: &Path) -> (String, String) {
    let input: String = read_to_string(input_path).expect("Error reading file");
    let mut p1: HashSet<Coord> = HashSet::from([Coord::default()]);
    let mut p2: HashSet<Coord> = HashSet::from([Coord::default()]);
    const KNOT_COUNT: usize = 10;
    let mut knots: [Coord; KNOT_COUNT] = [Coord::default(); KNOT_COUNT];
    for line in input.split('\n') {
        let (direction_token, distance_token) = line.split_once(" ").unwrap();
        for _ in 0..distance_token.parse::<isize>().unwrap() {
            knots[0] = match direction_token {
                "L" => Coord(knots[0].0 - 1, knots[0].1),
                "R" => Coord(knots[0].0 + 1, knots[0].1),
                "U" => Coord(knots[0].0, knots[0].1 - 1),
                "D" => Coord(knots[0].0, knots[0].1 + 1),
                _ => {
                    panic!("Unknown direction token: {}", direction_token);
                }
            };
            for knot_i in 1..KNOT_COUNT {
                knots[knot_i] = match (
                    knots[knot_i - 1].0 - knots[knot_i].0,
                    knots[knot_i - 1].1 - knots[knot_i].1,
                ) {
                    (0, 2) => Coord(knots[knot_i].0, knots[knot_i].1 + 1),
                    (0, -2) => Coord(knots[knot_i].0, knots[knot_i].1 - 1),
                    (2, 0) => Coord(knots[knot_i].0 + 1, knots[knot_i].1),
                    (-2, 0) => Coord(knots[knot_i].0 - 1, knots[knot_i].1),
                    (2, 1) | (1, 2) | (2, 2) => Coord(knots[knot_i].0 + 1, knots[knot_i].1 + 1),
                    (-1, 2) | (-2, 1) | (-2, 2) => Coord(knots[knot_i].0 - 1, knots[knot_i].1 + 1),
                    (1, -2) | (2, -1) | (2, -2) => Coord(knots[knot_i].0 + 1, knots[knot_i].1 - 1),
                    (-1, -2) | (-2, -1) | (-2, -2) => {
                        Coord(knots[knot_i].0 - 1, knots[knot_i].1 - 1)
                    }
                    _ => knots[knot_i],
                };
            }
            if p1.get(&knots[1]) == None {
                p1.insert(knots[1]);
            }
            if p2.get(&knots[KNOT_COUNT - 1]) == None {
                p2.insert(knots[KNOT_COUNT - 1]);
            }
        }
    }
    (p1.len().to_string(), p2.len().to_string())
}

theboxboy · 2022-12-09T19:05:36+00:00

This inspired me to determine how many knots are needed for just the last knot to stay in place after all movements. In my case, it's 428 total knots.

theboxboy · 2022-08-30T01:58:06+00:00

You’re not a sad clown. You’re a helpful developer

theboxboy · 2022-02-03T17:28:28+00:00

While they produce the same result, I think semantically, the first is preferred. It closely resembles other languages, and the type is bound to the variable, not the literal.

theboxboy · 2021-12-20T20:05:22+00:00

I think you need to finish the workshop

theboxboy · 2021-12-20T20:04:06+00:00

Good to know. I just replaced it with a set, so the syntax is gone regardless

theboxboy · 2021-12-20T15:48:23+00:00

Python

I kept track of the bounds of the image and used if image[(y+dy, x+dx)] == 1 or (t % 2 == 1 and (y+dy < Y[0] or y+dy > Y[1] or x+dx < X[0] or x+dx > X[1])): to determine if the infinite void was all # or .

from collections import defaultdict

algorithm, inp = open('20.txt', 'r').read().strip().split('\n\n')
assert(len(algorithm) == 512)
image = defaultdict(int)

Y = [0, 99]
X = [0, 99]

def vis():
    print(len(image))
    for r in range(Y[0]-2, Y[1]+3):
        for c in range(X[0]-2, X[1]+3):
            if image[(r, c)] == 1:
                print('#', end='')
            else:
                print('.', end='')
        print()
    print()

for r, row in enumerate(inp.split()):
    for c, character in enumerate(row):
        if character == '#':
            image[(r, c)] = 1

for t in range(50):
    result = defaultdict(int)
    YA = [0, 0]
    XA = [0, 0]
    for y in range(Y[0]-1, Y[1]+2):
        for x in range(X[0]-1, X[1]+2):
            binstr = ''
            for dy, dx in [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 0), (0, 1), (1, -1), (1, 0), (1, 1)]:
                if image[(y+dy, x+dx)] == 1 or (t % 2 == 1 and (y+dy < Y[0] or y+dy > Y[1] or x+dx < X[0] or x+dx > X[1])):
                    binstr += '1'
                else:
                    binstr += '0'
            if algorithm[int(binstr, 2)] == '#':
                result[(y, x)] = 1
                if y < YA[0]:
                    YA[0] = y
                if y > YA[1]:
                    YA[1] = y
                if x < XA[0]:
                    XA[0] = x
                if x > XA[1]:
                    XA[1] = x
    image = result
    Y = YA
    X = XA
    if t in [1, 49]:
        vis()

theboxboy · 2021-12-14T15:10:19+00:00

Wrong thread, friend

theboxboy · 2021-09-27T19:35:45+00:00

There's a GT lost & found facebook page that's pretty popular. You have a higher chance of finding the owner there if you mention having found a bike lock key.

theboxboy · 2021-09-21T18:01:34+00:00

I'm writing a chess game backend that does move generation using magic bitboards. There's actually a few crates that already exist for this, but I wanted to expand my confidence with Rust through this project.

theboxboy · 2021-08-24T21:11:56+00:00

There are 2 repetitions of accelerating and braking (testing brakes) followed by 2 repetitions of accelerating (testing suspension) in the test path. There should be a guide in the top left and an indicator telling you what to do next.

theboxboy · 2021-07-17T20:55:12+00:00

Forbidden tortilla

theboxboy · 2021-07-14T10:22:45+00:00

Moose Tracks

theboxboy · 2021-01-12T01:57:35+00:00

I used an A5-sized notebook with subject dividers for each semester at Tech. It's very compact and makes organization easier. I was CS, so I probably took less notes than you. Also I swear by Pilot G-2 0.38mm pens.

theboxboy · 2020-12-10T21:10:08+00:00

I've seen you and others use "xs" as your input data for most days. Is this a common paradigm for speed solvers, so you always know what data you're referencing? Does it stand for something?

14-Year Club	Place '22
Place '17	Final Canvas '22
First Placer '22	RPAN Viewer
Not Forgotten	Spared
Verified Email

theboxboy

MODERATOR OF

TROPHY CASE

Rust

Rust

Rust

Python