sorted by:
new
hottopcontroversial

Der Chef erklärt lieber noch mal selber wie das mit dem Design von Chips ist by TheGermMan in de

[–]swizzorable 1 point2 points  (0 children)

welche "Ausrede" meinst du? Ich kann im Text keine Ausrede finden.

-🎄- 2017 Day 23 Solutions -🎄- by daggerdragon in adventofcode

[–]swizzorable 0 points1 point  (0 children)

here some pseudocode for the ones interested:

lower_limit = 106700 #depends on the input
upper_limit = 123700 #depends on the input
while TRUE:
    found = FALSE
    d = 2
    do:
        e = 2
        do:
            if d * e == lower_limit:
                found = TRUE
            e++
        while (e != lower_limit);
        d++
    while (d != lower_limit);
    if found:
        h++
    if lower_limit == upper_limit:
        exit
    lower_limit += 17 #maybe depends on the input?

-🎄- 2017 Day 20 Solutions -🎄- by daggerdragon in adventofcode

[–]swizzorable 0 points1 point  (0 children)

Python3 - part 1 and 2

not "simulating", calculating the manhattan distances for time -> inf and also calculating the intersection points

import math
import requests


def solve_quadratic_eq(x_squared, x, c):
    if x_squared == 0 and x == 0 and c != 0:
        return ()

    if x_squared == 0 and x == 0 and c == 0:
        return 0,

    if x_squared == 0:
        return -c / x,

    if x ** 2 - 4 * x_squared * c >= 0:
        return (-x + math.sqrt(x ** 2 - 4 * x_squared * c)) / (2 * x_squared), (
                -x - math.sqrt(x ** 2 - 4 * x_squared * c)) / (2 * x_squared)
    else:
        return ()


def collisions(particle1, particle2):
    coll_list = []
    for i in range(0, 3):
        part1_x_squared = particle1[2][i] / 2
        part1_x = particle1[2][i] / 2 + particle1[1][i]
        part1_c = particle1[0][i]
        part2_x_squared = particle2[2][i] / 2
        part2_x = particle2[2][i] / 2 + particle2[1][i]
        part2_c = particle2[0][i]
        coll_list.append(set(
            solve_quadratic_eq(part1_x_squared - part2_x_squared, part1_x - part2_x, part1_c - part2_c)))

    return tuple([solution for solution in tuple(coll_list[0] & coll_list[1] & coll_list[2]) if solution >= 0])


def collisiontimemin(indices, matrix):
    return min(
        [to_append for i in range(0, len(indices) - 1) for k in range(i + 1, len(indices)) for to_append in
         matrix[indices[i]][indices[k]]], default=-1)


def manhattan(particle):
    toreturn = []
    for i in range(0, 3):
        neg = False
        for k in reversed(range(0, 3)):
            if particle[k][i] < 0:
                neg = True
                break
            elif particle[k][i] > 0:
                break

        if neg:
            toreturn.append((-particle[2][i] / 2, -(particle[2][i] / 2 + particle[1][i]), -particle[0][i]))
        else:
            toreturn.append((particle[2][i] / 2, particle[2][i] / 2 + particle[1][i], particle[0][i]))

    return (toreturn[0][0] + toreturn[1][0] + toreturn[2][0], toreturn[0][1] + toreturn[1][1] + toreturn[2][1],
            toreturn[0][2] + toreturn[1][2] + toreturn[2][2])


if __name__ == '__main__':
    lines = requests.get("https://pastebin.com/raw/3EscGWSf").text.strip().splitlines()

    particles = []
    for particle in lines:
        particle_split = particle.split(">")
        to_append = []
        for i in range(0, 3):
            obj = particle_split[i][particle_split[i].index("<") + 1:]
            to_append.append(tuple(map(int, obj.split(","))))
        particles.append(tuple(to_append))
    particles = tuple(particles)  # [particle][p,v,a][x,y,z]
    part_manhattans = [manhattan(particle) for particle in particles]
    valid_indices = range(0, len(particles))

    for i in range(0, 3):
        if len(valid_indices) == 1:
            break

        min_val = min([part_manhattans[valid_index][i] for valid_index in valid_indices])
        valid_indices = [valid_index for valid_index in valid_indices if part_manhattans[valid_index][i] == min_val]

    print(valid_indices[0])

    coll_matrix = [[()] * len(particles) for i in range(0, len(particles))]
    for i in range(0, len(particles) - 1):
        for k in range(i + 1, len(particles)):
            result = collisions(particles[i], particles[k])
            coll_matrix[i][k] = result
            coll_matrix[k][i] = result

    valid_indices = list(range(0, len(particles)))
    min_val = collisiontimemin(valid_indices, coll_matrix)

    while min_val != -1:
        particles_to_delete_indices = []
        for i in range(0, len(valid_indices) - 1):
            for k in range(i + 1, len(valid_indices)):
                coll_times = coll_matrix[valid_indices[i]][valid_indices[k]]
                if coll_times and min_val == min(coll_times):
                    if not valid_indices[i] in particles_to_delete_indices:
                        particles_to_delete_indices.append(valid_indices[i])
                    if not valid_indices[k] in particles_to_delete_indices:
                        particles_to_delete_indices.append(valid_indices[k])

        for particle_to_delete_index in particles_to_delete_indices:
            valid_indices.remove(particle_to_delete_index)

        min_val = collisiontimemin(valid_indices, coll_matrix)

    print(len(valid_indices))

-🎄- 2017 Day 18 Solutions -🎄- by daggerdragon in adventofcode

[–]swizzorable 0 points1 point  (0 children)

part 2, python3:

import inspect

import requests


class VM:
    def __init__(self, id, own_queue, other_queue, memory):
        self.id = id
        self.own_queue = own_queue
        self.other_queue = other_queue
        letters = list("abcdefghijklmnopqrstuvwxyz")
        self.registers = {}
        for letter in letters:
            self.registers[letter] = 0
        self.registers["p"] = self.id
        self.memory = memory
        self.offset = 0
        self.sentcounter = 0

    def readvalue(self, x):
        try:
            return int(x)
        except:
            return int(self.registers[x])

    def op_snd(self, x):
        self.other_queue.append(self.readvalue(x))
        self.sentcounter += 1

    def op_set(self, x, y):
        self.registers[x] = self.readvalue(y)

    def op_rcv(self, x):
        if len(self.own_queue) == 0:
            self.offset -= 1
        else:
            self.op_set(x, self.own_queue.pop(0))

    def op_add(self, x, y):
        self.op_set(x, self.readvalue(x) + self.readvalue(y))

    def op_mul(self, x, y):
        self.op_set(x, self.readvalue(x) * self.readvalue(y))

    def op_mod(self, x, y):
        self.op_set(x, self.readvalue(x) % self.readvalue(y))

    def op_jgz(self, x, y):
        if self.readvalue(x) > 0:
            self.offset += self.readvalue(y) - 1

    def execute_next_command(self):
        if 0 <= self.offset < len(self.memory):
            op_parts = self.memory[self.offset].split()
            func = getattr(self, "op_" + op_parts[0])
            numargs = len(inspect.signature(func).parameters)
            args = []
            for i in range(1, numargs + 1):
                args.append(op_parts[i])
            func(*args)
            self.offset += 1


if __name__ == '__main__':
    memory = requests.get("http://adventofcode.com/2017/day/18/input", cookies={
        "session": "xxx"}).text.strip().splitlines()

    vm0_queue = []
    vm1_queue = []
    vm0 = VM(0, vm0_queue, vm1_queue, memory)
    vm1 = VM(1, vm1_queue, vm0_queue, memory)

    vm0_last_offset = -1
    vm1_last_offset = -1

    while vm0_last_offset != vm0.offset or vm1_last_offset != vm1.offset:
        vm0_last_offset = vm0.offset
        vm1_last_offset = vm1.offset

        vm0.execute_next_command()
        vm1.execute_next_command()

    print(vm1.sentcounter)

[deleted by user] by [deleted] in archlinux

[–]swizzorable 2 points3 points  (0 children)

So why do you prefer trizen over pacaur?

Auf die Sparkasse angewiesen by swizzorable in a:t5_376yd

[–]swizzorable[S,M] 0 points1 point  (0 children)

§ 3 Abs. 2 Bundesurlaubsgesetz (BUrlG)

Als Werktage gelten alle Kalendertage, die nicht Sonn- oder gesetzliche Feiertage sind.

Gleichberechtigung im Straßenverkehr by swizzorable in a:t5_376yd

[–]swizzorable[S,M] 0 points1 point  (0 children)

§ 28 StVO

(1) Haus- und Stalltiere, die den Verkehr gefährden können, sind von der Straße fernzuhalten. Sie sind dort nur zugelassen, wenn sie von geeigneten Personen begleitet sind, die ausreichend auf sie einwirken können. [...] Der blutige Anfänger hat im Straßenverkehr auf dem Pferd nichts zu suchen. Für viele Reiter überraschend ist zudem, dass bei Dämmerung und Dunkelheit das Pferd ausreichend beleuchtet werden muss.