True, true. I am very close to getting a Voyager for that use case, and for experimenting with different switches, etc, since its easier. I also think the QMK-based configuration the Glove uses is more powerful than the Voyager’s system, but harder to use.

Yep, that’s true.

The case came with the Glove80, in fact it was shipped inside it.

Actually, it’s not ronnabyte, it’s ribibyte …

Don’t eat fast food, make your own.

Tiberius slaps Fisherman around a bit with a large trout.

I’m not a materials scientist but you would think the edges of the cut holes are shedding particles in a larger degree than an intact pot. Wouldn’t want that in something you’re planning to ingest. My comment was made largely in jest, but I still think there’s some truth to it, and we will look back on our plastic use with dread in the future.

With infinite microplastics

Are you trying to reach a URL on the same host you’re ssh-ing to? That would create some interesting effects.

Especially since it works the second time it could mean that the second time you’re actually on the host and ssh-ing to the host itself and then curling localhost.

Ah, I see. I guess they get different contexts or something? (Edit: I re-read your post and this does not make any sense :)) What if you chain the ssh command and the curl using &&?

Someone else suggested the env vars arent being expanded correctly inside the $(curl …), which could be the culprit … If a straight up URL works that would indicate that something like that is happening.

That said, I just tried setting an env var called URL=“” and curling it, and curl said exit code 2, no URL specified, so something else is going on here.

Exit code 7 means curl couldn’t connect to the host, so I would try just curling a URL you know is valid directly, not setting it as an env var, to see what happens then.

What exit code so you get from curl?

Elixir

Total noob, but it’s fun to learn.

{left, right} =
  File.read!("./input.txt")
  |> String.split("\n", trim: true)
  |> Enum.map(fn line ->
    String.split(line)
    |> Enum.map(&String.to_integer/1)
    |> List.to_tuple()
  end)
  |> Enum.unzip()
  |> then(fn {left, right} ->
    {Enum.sort(left), Enum.sort(right)}
  end)

diffs =
  Enum.zip(left, right)
  |> Enum.map(fn {l, r} -> abs(l - r) end)
  |> Enum.sum()

freqs =
  Enum.filter(right, fn r -> r in left end)
  |> Enum.frequencies()

freqsum =
  Enum.map(left, fn n ->
    freq = Map.get(freqs, n, 0)
    n * freq
  end)
  |> Enum.sum()

IO.puts("part 1: #{diffs}")
IO.puts("part 2: #{freqsum}")

It was actually a line break that broke the regex. Changing from a “.” to “[\s\S]” fixed it.

Yes, I guess I held myself to too high expectations. I haven’t even studied CS and learned programming on my own… I’ve been trying to do some exercises and a few courses on algorithms but of course that can’t be compared to going to university. Thanks for the tip, I won’t spend hours in frustration in the coming days for sure. Maybe I should post my attempts even though they are incomplete or fail, to spark discussion.

Ah, yes, that’s it. The lazy solution would be to add a “do()” to the end of the input, right? Haha

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

func main() {
	input, _ := os.Open("input.txt")
	defer input.Close()

	left, right := []int{}, []int{}

	scanner := bufio.NewScanner(input)
	for scanner.Scan() {
		line := scanner.Text()
		splitline := strings.Split(line, "   ")
		l, _ := strconv.Atoi(splitline[0])
		r, _ := strconv.Atoi(splitline[1])
		left, right = append(left, l), append(right, r)
	}

	fmt.Printf("part 1 - total diff: %d\n", part1(left, right))
	fmt.Printf("part 2 - new total: %d\n", part2(left, right))
}

func part1(left, right []int) int {
	diff := 0
	sort.Ints(left)
	sort.Ints(right)

	for i, l := range left {
		if l > right[i] {
			diff += (l - right[i])
		} else {
			diff += (right[i] - l)
		}
	}
	return diff
}

func part2(left, right []int) int {
	newTotal := 0

	for _, l := range left {
		matches := 0
		for _, r := range right {
			if l == r {
				matches++
			}
		}
		newTotal += l * matches
	}
	return newTotal
}

Elixir

First time writing Elixir. It’s probably janky af.

I’ve had some help from AI to get some pointers along the way. I’m not competing in any way, just trying to learn and have fun.

~~Part 2 is currently not working, and I can’t figure out why. I’m trying to just remove everything from “don’t()” to “do()” and just pass the rest through the working solution for part 1. Should work, right?

Any pointers?~~

edit; working solution:

defmodule Three do
  def get_input do
    File.read!("./input.txt")
  end

  def extract_operations(input) do
    Regex.scan(~r/mul\((\d{1,3}),(\d{1,3})\)/, input)
    |> Enum.map(fn [_op, num1, num2] ->
      num1 = String.to_integer(num1)
      num2 = String.to_integer(num2)
      [num1 * num2]
    end)
  end

  def sum_products(ops) do
    List.flatten(ops)
    |> Enum.filter(fn x -> is_integer(x) end)
    |> Enum.sum()
  end

  def part1 do
    extract_operations(get_input())
    |> sum_products()
  end

  def part2 do
    String.split(get_input(), ~r/don\'t\(\)[\s\S]*?do\(\)/)
    |> Enum.map(&extract_operations/1)
    |> sum_products()
  end
end

IO.puts("part 1: #{Three.part1()}")
IO.puts("part 2: #{Three.part2()}")

Thanks. I felt very deflated after struggling with something seemingly so simple. I was using Go and couldn’t figure out part 2, at least without nesting loops three layers deep.

Today I decided to try to learn Elixir instead and allowed myself some assistance from Claude.ai, which was much more fun.

I’ve started with Go, but I think I’ve realised AoC isn’t for me. I feel so incredibly dense.