Alright so im going to force myself to create a post for this daily and maybe this will help force me to actually learn Elixir this year.

Please use Spoiler tags for your code snippets if they reveal answers.

Day 1 was interesting. Elixir is different, but it kinda reminds me of doing functional JavaScript but is wayyyyy nicer. It has so many tools to do stuff and the pattern matching is very powerful.

If anyone else wants me to tag them I can do that but I think @Enjoyer_of_Games@hexbear.net was the only one.

Heres my solution for Part 1:

spoiler 
"input"    
    |> File.read!()
    |> String.split("\n")
    |> Enum.map(&String.split/1)
    |> Enum.filter(fn list -> length(list) == 2 end)
    |> Enum.map(fn [a, b] -> {String.to_integer(a), String.to_integer(b)} end)
    |> Enum.unzip()
    |> Tuple.to_list()
    |> Enum.map(&Enum.sort/1)
    |> Enum.zip()
    |> Enum.map(fn {a, b} -> abs(a - b) end)
    |> Enum.sum()

Ill post Part 2 later if I get time. I had time, heres part 2:

spoiler 
"input"    
    |> File.read!()
    |> String.split("\n")
    |> Enum.map(&String.split/1)
    |> Enum.filter(fn list -> length(list) == 2 end)
    |> Enum.map(fn [a, b] -> {String.to_integer(a), String.to_integer(b)} end)
    |> Enum.unzip()
    |> Tuple.to_list()
    |> Enum.map(&Enum.sort/1)
    |> (fn [list1, list2] -> {list1, Enum.frequencies(list2)} end).()
    |> (fn {list1, freqs} ->
          list1
          |> Enum.map(&{&1, Map.get(freqs, &1, 0)})
          |> Enum.filter(fn {_, count} -> count != 0 end)
          |> Enum.map(fn {value, count} -> value * count end)
        end).()
    |> Enum.sum()
  • kota [he/him]
    ·
    1 day ago

    Guess I'm a bit late on day one. Wound up doing mine in go, but maybe if I'm motivated I'll use something cooler later. Those elixir solutions are rad!

    part 1 
    func main() {
	b, err := os.ReadFile("input.txt")
	if err != nil {
		log.Fatalln(err)
	}

	d, err := distance(string(b))
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println(d)
}

func distance(input string) (int, error) {
	var left []int
	var right []int
	for _, line := range strings.Split(input, "\n") {
		fields := strings.Fields(line)
		if len(fields) != 2 {
			continue
		}

		l, err := strconv.Atoi(fields[0])
		if err != nil {
			return 0, err
		}
		left = append(left, l)

		r, err := strconv.Atoi(fields[1])
		if err != nil {
			return 0, err
		}
		right = append(right, r)
	}

	slices.Sort(left)
	slices.Sort(right)

	var total int
	for i := 0; i < len(left); i++ {
		total += int(math.Abs(float64(left[i] - right[i])))
	}

	return total, nil
}
    part 2 
    func main() {
	b, err := os.ReadFile("input.txt")
	if err != nil {
		log.Fatalln(err)
	}

	s, err := similarity(string(b))
	if err != nil {
		log.Fatalln(err)
	}
	fmt.Println(s)
}

func similarity(input string) (int, error) {
	collisions := make(map[int]int)
	var left []int
	var right []int
	for _, line := range strings.Split(input, "\n") {
		fields := strings.Fields(line)
		if len(fields) != 2 {
			continue
		}

		l, err := strconv.Atoi(fields[0])
		if err != nil {
			return 0, err
		}
		left = append(left, l)
		collisions[l] = 0

		r, err := strconv.Atoi(fields[1])
		if err != nil {
			return 0, err
		}
		right = append(right, r)
	}

	for _, r := range right {
		c := collisions[r]
		collisions[r] = c + 1
	}

	var total int
	for _, l := range left {
		v := collisions[l]
		total += l * v
	}

	return total, nil
}
  • iByteABit [comrade/them]
    ·
    2 days ago

    Started mine on Rust, there's this really cool Github template for it too that automates a lot of stuff and provides you with a sort of scaffolding for each challenge.

  • Speaker [e/em/eir]
    ·
    2 days ago

    Currently writing an implementation of cryptographic secret Santa, so I'm getting a late start on Advent, but would not mind being tagged so I remember to post them when I get to them.