Katzenmann

joined 2 months ago
[–] Katzenmann 2 points 1 week ago (1 children)

I actually did this. It did not end up being any faster than the brute-force solution since it seems to only catch the easy cases

[–] Katzenmann 36 points 1 week ago (1 children)

You're using the meme wrong. The "at home" needs to be worse than the "mom can we get?"

[–] Katzenmann 4 points 2 weeks ago (1 children)

Weiß ja nicht. Alles was ich von Staiy mitbekommen habe ist, dass er sich oft über dinge aufregt. Aber das kann sich ja auch geändert haben

[–] Katzenmann 1 points 2 weeks ago

Rust

Pretty happy with my solution today. I took my time today as it was a bit of a slow day and did it in Rust instead of python. Having proper Vec2 types is very nice.

Tap for spoiler

use std::{collections::HashMap, error::Error, io::Read};

use glam::{IVec2, Vec2};

fn permutations_of_size_two(antennas: &[Vec2]) -> Vec<[&Vec2; 2]> {
    let mut permutations = vec![];
    for (i, antenna) in antennas.iter().enumerate() {
        for j in 0..antennas.len() {
            if i == j {
                continue;
            }
            permutations.push([antenna, &antennas[j]])
        }
    }
    permutations
}

fn main() -> Result<(), Box<dyn Error>> {
    let mut input = String::new();
    std::io::stdin().read_to_string(&mut input)?;

    let height = input.lines().count() as i32;
    let width = input.lines().next().unwrap().len() as i32;

    let antenna_positions = input
        .lines()
        .enumerate()
        .flat_map(|(y, l)| 
            l.chars().enumerate().map(move |(x, c)| (Vec2::new(x as f32, y as f32), c))
        )
        .filter(|(_v, c)| *c != '.')
        .fold(HashMap::new(), |mut acc: HashMap<char, Vec<_>> , current| {
            acc.entry(current.1).or_default().push(current.0);
            acc
        });

    let mut antinodes = vec![];
    for (_c, antennas) in antenna_positions {
        let perms = permutations_of_size_two(&antennas);
        for [first, second] in perms {
            let mut i = 1.;
            loop {
                let antinode = (first + (second-first) * i).round();
                if (0..height).contains(&(antinode.x as i32)) &&
                    (0..width).contains(&(antinode.y as i32)) {
                        antinodes.push(antinode);
                } else {
                    break;
                }
                i += 1.;
            }
        }
    }

    let mut antinode_count = 0;
    let map = input
        .lines()
        .enumerate()
        .map(|(y, l)| 
            l.chars().enumerate().map(|(x, c)| {
                if antinodes.contains(&Vec2::new(x as f32, y as f32)) {
                    println!("({x},{y})");
                    antinode_count += 1;
                    return '#';
                }
                c
            }).collect::<String>()
        )
        .collect::<Vec<_>>()
        .join("\n");

    println!("{map}");
    println!("{antinode_count}");

    Ok(())
}

[–] Katzenmann 1 points 3 weeks ago* (last edited 3 weeks ago)

My initial comment was a bit harsh, I'm sorry for that. It was meant to be a bit of a joke. Anyway here's my code. Do note that I don't do the challenges timed so I have a bit more time to name my variables accordingly. Takes 35 seconds to run on a pc with a AMD Ryzen 5 5600

import sys
from tqdm import tqdm


input = sys.stdin.read()

def all_operator_permutations(operator_count):
    if operator_count == 0:
        return [[]]

    smaller_permutations = all_operator_permutations(operator_count-1)
    return [
            *[['+', *ops] for ops in smaller_permutations],
            *[['*', *ops] for ops in smaller_permutations],
            *[['||', *ops] for ops in smaller_permutations],
            ]

def test_operators(ops, values):
    res = values.pop(0)
    for op in ops:
        match op:
            case '*':
                res *= values.pop(0)
            case '+':
                res += values.pop(0)
            case '||':
                res = int(f"{res}{values.pop(0)}")
    return res


total_calibration_result = 0

for line in tqdm(input.splitlines()[:]):
    target, *tail = line.split(':')
    target = int(target)
    values = [int(val) for val in tail[0].split()]

    all_perms = all_operator_permutations(len(values) - 1)
    ops = all_perms.pop()
    while True:
        res = test_operators(ops, values.copy())
        if res == target:
            total_calibration_result += target
            break
        if not all_perms:
            break
        ops = all_perms.pop()

print(total_calibration_result)
[–] Katzenmann 1 points 3 weeks ago (3 children)

What a horrible way to name variables

[–] Katzenmann 10 points 3 weeks ago (1 children)

Weil er überlebt hat

[–] Katzenmann 12 points 3 weeks ago (5 children)

Do these cards have good open-source Linux drivers?

[–] Katzenmann 2 points 3 weeks ago

Gnome is very different than xfce and has a different workflow. I find the workflow of xfce very nice and like the modularity of it

[–] Katzenmann 3 points 1 month ago

It's pretty good. No justifying his behaviour tho

[–] Katzenmann 1 points 1 month ago (1 children)

Tja. Einfach in einem der Erfas aktiv sein, dann bekommt man auch so einen Voucher ;)

 

So with the recent drama it looks like bcachefs isn't going to stay in the kernel for too long. What do I do now? I have my root filesystem as bcachefs on multiple devices. Is it possible to migrate to btrfs or ext4?

 

Hi. Manchmal wenn ich mit meinen etwas weniger linken Freunden über Politik rede und es auf das Thema Vermögenssteuer kommt, bekomme ich "Wenn man die Reichen besteuert ziehen die weg" als Antwort.

Ich glaube nicht, dass das der Fall ist, habe allerdings nicht so richtig eine Antwort darauf. Was sagt ihr dazu?

[–] Katzenmann 1 points 1 month ago

I just have all my active projects under $HOME/projects/ and projects from other people in $HOME/bin/

 

Does a Kodi addon for YouTube exits, that doesn't need an API key? I don't want to create a google account. So is there an addon for Kodi that uses either yt-dlp or NewPipe Extractor to work?

view more: next ›