All Micro blogs

So it turns out, It wasn’t that my domain had expired despite being on auto-renew. It was just on another domain with really old billing information (I must have bought a several year lease).
THEN, I encountered a billing bug on cloudflare.

So I made a new cloudflare account, deleted my old account and then encountered the bug again after adding just one domain.

Sooooooo, I guess I’m not using cloudflare dns anymore? 🤷‍♀️

I will make a return to some of my other projects but I’m on a little detour right now doing pixel arty things 🙂

This seemed incredibly simple at first, parse a space delimitated data set apply rules and get the output.

Part one I had one challenge that was my own fault. Part of the rules to apply to the data meant taking a position in the data and comparing that to what comes before and after. The problem I created for myself was thinking I could skip the first and last column in each row to go faster and simplify my logic.
I WAS WRONG.

Part two a new rule is applied that means bad data can be corrected be removing any position from a row. I made this part easy for myself by producing an output that can be much easier re parsed and edited, but I can’t satisfy the game and I’m not sure why, so I’m going to move on.

My advent repo

<?php
//$data = file("example.txt");
$data = file("input.txt");
$parsed = array();
$total_safe = 0;
$total_safe_corrected = 0;
$total_unsafe = 0;

function report_safety($data): array
{
    $last_value = "";
    $direction = "dsc";
    $bad_data = array();
    foreach ($data as $index => $current_value) {
        if (!empty($last_value)) {
            $asc = false;
            $dsc = false;
            if ($index == 1) {
                if ($last_value < $current_value) {
                    $direction = "asc";
                }
            }
            if ($index + 1 < count($data) - 1) {
                $next_value = $data[$index + 1];
                switch ($direction) {
                    case "asc":
                        if ($last_value < $current_value) {
                            if ($current_value - $last_value < 4) {
                                if ($current_value < $next_value) {
                                    if ($next_value - $current_value < 4) {
                                        $asc = true;
                                    }
                                }
                            }
                        }
                        break;
                    default:
                        if ($last_value > $current_value) {
                            if ($last_value - $current_value < 4) {
                                if ($current_value > $next_value) {
                                    if ($current_value - $next_value < 4) {
                                        $dsc = true;
                                    }
                                }
                            }
                        }
                        break;
                }
            } else { //this else is because I originally assumed I could skip the first and last value
                if ($direction == "asc") {
                    if ($last_value < $current_value) {
                        if ($current_value - $last_value < 4) {
                            $asc = true;
                        }
                    }
                } else {
                    if ($last_value > $current_value) {
                        if ($last_value - $current_value < 4) {
                            $dsc = true;
                        }
                    }
                }
            }
            if (!$asc && !$dsc) {
                $bad_data[] = $index;
            }
        }
        $last_value = $current_value;
    }
    if (count($bad_data) > 0) {
        return array("unsafe", $bad_data);
    } else {
        return array("safe", $bad_data);
    }

}

function report_dampener($data, $indexes)
{
    foreach ($indexes as $index) {
        $new_data = $data;
        array_splice($new_data, $index, 1);
        $safety = report_safety($new_data);
        if ($safety[0] == "safe") return $new_data;
    }
    return false;
}


foreach ($data as $index => $line) {
    $line = str_replace("\n", "", $line);
    $data = explode(" ", $line);
    $safety = report_safety($data);
    $dampened = report_dampener($data, $safety[1]);
    $parsed[$index]["dampened_data"] = $dampened;
    $parsed[$index]["bad_data"] = $safety[1];
    $parsed[$index]["result"] = $safety[0];
    $parsed[$index]["data"] = $data;
    if ($safety[0] == "safe") $total_safe++;
    if (!empty($dampened)) $total_safe_corrected++;
    if ($safety[0] == "unsafe") $total_unsafe++;
}

$report = fopen('report.json', 'w');
fwrite($report, json_encode($parsed));
fclose($report);

print("\n=== PART ONE ===\n");
print("Total safe(uncorrected): " . $total_safe . "\n");
print("Total unsafe(uncorrected): " . $total_unsafe . "\n");


print("\n=== PART TWO ===\n");
print("Total safe(corrected): " . $total_safe + $total_safe_corrected . "\n");

after accidentally starting 2022’s advent by mistake, here we are on 2024 day one.

The wording on this one confused the daylights out of me (I suppose part of the point of the challenges).

Part one was to take two columns of numbers sort them and sum the difference at each row.

Part two was to take each row from the left column times that by how often it appears in the right column then sum them together.

My advent repo

<?php
//$list = file("example_list.txt");
$list = file("input.txt");
$left = array();
$right = array();
$total_distance = 0;
$total_similarity = 0;
$part_one = 0;
$part_two = 0;
foreach ($list as $line){
    $line = explode("   ", $line);
    $left[] = $line[0];
    $right[] = $line[1];
}
sort($left);
sort($right);
foreach ($left as $index => $left_val){
    $index_distance = abs($left_val - $right[$index]);
    $total_distance = $total_distance + $index_distance;
    print("Index distance: " . $index_distance . "\n");
    print("Total distance: " . $total_distance . "\n");
    print("\n");
}

$part_one = $total_distance;

print("\npart one: " . $part_one . "\n\n");

foreach ($left as $index => $left_val){
    $similarity = $left_val * count(array_keys($right, $left_val));
    $total_similarity = $total_similarity + $similarity;
    print("Index similarity: " . $similarity . "\n");
    print("Total similarity: " . $total_similarity . "\n");
    print("\n");
}

$part_two = $total_similarity;

print("\npart two: " . $part_two . "\n\n");

turns out I started doing 2022’s advent of code.
should I go back to complete it after catching on this year?

edit: I thought this was 2024, IT IS NOT

Day one we are given a set of data grouped by blank lines.
The task is too parse the data, add the arrays and find the top three values.

My Advent of code Repo

1000
2000
3000

4000

5000
6000

7000
8000
9000

10000

<?php

$puzzle_input = file("day_1.txt");

$elves = array();
$elves_total = array();
$blank = 0;

foreach ($puzzle_input as $line){
    $line = str_replace("\n", "", $line);

    if(empty($line)){
        $blank++;
    }else{
        $schema = "elf_".$blank;

        if(empty($elves[$schema])){
            $elves[$schema][0] = $line;
        }else{
            $elves[$schema][] = $line;
        }
    }
}

foreach ($elves as $elf => $calories){
    $total = 0;
    foreach ($calories as $calorie){
        $total = $total + $calorie;
    }
    $elves_total[$elf] = $total;
}

function sortElves($a, $b)
{
    return $b <=> $a;
}

uasort($elves_total, "sortElves");

print("part one: ".$elves_total[array_keys($elves_total)[0]]);
print("\n");

$top_three_total = $elves_total[array_keys($elves_total)[0]] + $elves_total[array_keys($elves_total)[1]] + $elves_total[array_keys($elves_total)[2]];
print("part two: ".$top_three_total);
print("\n");

The inclusion of the DOM API in PHP 8.4 is the best news ever. being able to traverse incoming html the same way you do in the browser

welcome all to the fascinating world of “islay continues to buy the most obscure and pointless audio equipment”

there is a non-slim chance I post sets here in the future ☺️

fair warn