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.