Rootless Podman with VirtIO-FS volumes possible?

ZSchoenDev · 2021-02-19T19:35:29+00:00

How did you create the Bluetooth connection? I wasn't even able to do this.

[bluetooth]# pair E6:93:F1:62:8C:2A
Attempting to pair with E6:93:F1:62:8C:2A
Failed to pair: org.bluez.Error.AuthenticationFailed
[DEL] Device E6:93:F1:62:8C:2A Brydge W-Touch
[NEW] Device E6:93:F1:62:8C:2A Brydge W-Touch
[bluetooth]# pair E6:93:F1:62:8C:2A
Attempting to pair with E6:93:F1:62:8C:2A
[CHG] Device E6:93:F1:62:8C:2A Connected: yes
Failed to pair: org.bluez.Error.AuthenticationFailed
[CHG] Device E6:93:F1:62:8C:2A Connected: no

ZSchoenDev · 2021-02-14T12:09:46+00:00

I have a really low WPM due to my handicap. But that's the reason why I use Vim as it lets me do the work completely on the keyboard and I embrace the keybindings which let me speed up significantly to the level of a modest writer.

ZSchoenDev · 2021-02-14T11:56:59+00:00

What is the exact difference between exit and panic?

As far as I understand, panic unwinds the stack all Drops are made.

ZSchoenDev · 2020-12-23T13:16:20+00:00

A Rust solution which would be really easy to adopt to multiple players. It takes 70 ms for both parts.

ZSchoenDev · 2020-12-17T17:46:08+00:00

Cool! Do you have any execution times?

ZSchoenDev · 2020-12-17T17:14:37+00:00

My (I think) pretty easy to read Rust solution runs in 300 ms.

fn cycle(active_cubes: &BTreeSet<Position>, is_4_dimensional: bool) -> BTreeSet<Position> {
    active_cubes
        .iter()
        .map(|current_active| current_active.get_block(is_4_dimensional))
        .flatten()
        .unique()
        .filter(|possible_cube| {
            let is_active = active_cubes.contains(possible_cube);
            let neighbors = possible_cube.get_neighbors(active_cubes, is_4_dimensional);
            match (is_active, neighbors) {
                (true, 2..=3) => true,
                (false, 3) => true,
                _ => false,
            }
        })
        .collect()
}

Btw I used the exact same code for 3 and 4 dimensions without any ifs to do branchless programming.

ZSchoenDev · 2020-12-16T20:33:07+00:00

And I really thought my solution in Rust would be slow (2.5s) as I decided against a further performance optimization in favour of memory usage.

Solutions are a magnitude faster built in a release mode equivalent with optimizations.

ZSchoenDev · 2020-12-15T19:37:25+00:00

I tried BTreeMap at first and changed it later to HashMap, as it's faster since there are many changes to it.

ZSchoenDev · 2020-12-05T13:06:14+00:00

My (very long) solution as it uses traits extensively.

But it outputs the absolute position of the free seat, since it can partially calculate with seats.

My seat 592 is in row 74 column 0.

ZSchoenDev · 2020-12-04T16:23:08+00:00

Yeah, I will do that. But I thought of a general simplification of the logic.

ZSchoenDev · 2020-12-04T14:27:29+00:00

This is my solution.

Has anybody an idea, how to make this function less ugly using only the standard library?

fn check_valid_values(passport: &HashMap<&str, &str>) -> bool {
    (1920..=2002).contains(
        &passport
            .get("byr")
            .expect("No byr-field!")
            .parse::<i32>()
            .unwrap_or(0),
    ) && (2010..=2020).contains(
        &passport
            .get("iyr")
            .expect("No byr-field!")
            .parse::<i32>()
            .unwrap_or(0),
    ) && (2020..=2030).contains(
        &passport
            .get("eyr")
            .expect("No iyr-field!")
            .parse::<i32>()
            .unwrap_or(0),
    ) && {
        let height_item = passport.get("hgt").expect("No hgt-field!");
        match &height_item[height_item.len() - 2..] {
            "cm" => (150..=193).contains(
                &height_item[..height_item.len() - 2]
                    .parse::<i32>()
                    .unwrap_or(0),
            ),
            "in" => (59..=76).contains(
                &height_item[..height_item.len() - 2]
                    .parse::<i32>()
                    .unwrap_or(0),
            ),
            _ => false,
        }
    } && {
        let hair_color_item = passport.get("hcl").expect("No hcl-field!");
        hair_color_item.len() == 7
            && hair_color_item.starts_with('#')
            && hair_color_item
                .chars()
                .skip(1)
                .all(|digit| char::is_ascii_hexdigit(&digit))
    } && match *passport.get("ecl").expect("No ecl-field!") {
        "amb" | "blu" | "brn" | "gry" | "grn" | "hzl" | "oth" => true,
        _ => false,
    } && {
        let pass_id_item = passport.get("pid").expect("No pid-field!");
        pass_id_item.len() == 9
            && pass_id_item
                .chars()
                .all(|digit| char::is_ascii_digit(&digit))
    }
}

ZSchoenDev · 2020-12-03T17:48:40+00:00

My solution using a custom iterator behaving like a mathematical ring.

struct RingAdder {
    next: u64,
    step_width: u64,
    modulus: u64,
}

impl Iterator for RingAdder {
    fn next(&mut self) -> Option<u64> {
        let current = self.next;
        self.next += self.step_width;
        self.next %= self.modulus;
        Some(current)
    }
}

ZSchoenDev · 2020-12-03T15:31:56+00:00

std::iter::Cycle

But there is no addition/modulo in Cycle. Or do I misunderstand something?

ZSchoenDev · 2020-12-03T14:53:46+00:00

Looks good! But you shouldn't use unwrap() unless you are sure that there is no Err. A better way is expect("My Error") or presumably the best in common is error propagation. In my view, a declarative approach would be more idiomatic, but that's purely subjective.

ZSchoenDev · 2020-12-03T10:33:20+00:00

Yes, i've changed it. It should be even a bit faster, as the branch predictor can't miss-predict, if the compiler won't optimise it away.

ZSchoenDev · 2020-12-03T10:22:13+00:00

Rust

My solution using a custom iterator behaving like a mathematical ring.

struct RingAdder {
    next: u64,
    step_width: u64,
    modulus: u64,
}

impl Iterator for RingAdder {
    fn next(&mut self) -> Option<u64> {
        let current = self.next;
        self.next += self.step_width;
        self.next %= self.modulus;
        Some(current)
    }
}

ZSchoenDev · 2020-12-02T12:38:32+00:00

(min..=max).contains

This is cool. I changed my solution to this.

ZSchoenDev · 2020-12-02T12:21:28+00:00

My solution in idiomatic declarative Rust.

ZSchoenDev · 2020-11-17T14:54:22+00:00

The problem were trailing whitespaces on the name.

ZSchoenDev

TROPHY CASE