Advent of Code 2020 Solution Megathread - Day 10: Adapter Array

data=""
with open("input9.txt","r") as infile:
    data=infile.read().strip()
numbers=list(map(int, data.split("\n")))
numbers=sorted(numbers)
diff3=0
diff1=0
numbers.append(numbers[-1]+3)
numbers=[0]+numbers
memory=[1]
def no_of_paths(n):
    s=0
    for x in range(n-1,-1,-1):
        if(numbers[n]-numbers[x]<=3):s+=memory[x]
        else:   break
    return s
for x in range(1,len(numbers)):
    memory.append(no_of_paths(x))
    diff=numbers[x]-numbers[x-1]
    if(diff==1):diff1+=1
    elif(diff==3):diff3+=1
print("1. ans = ",diff3*diff1)
print("2. ans =",memory[-1])

defmodule Adapters do
  def getSortedAdapters() do
    {:ok, text} = File.read("10.txt")
    lines = String.split(text, "\n")
    lines = List.delete_at(lines, length(lines)-1) # remove empty line
    joltages = Enum.map(lines, &String.to_integer/1)
    Enum.sort(joltages)
  end

  def round1() do
    adapters = getSortedAdapters()
    {ones, threes, _prev} = Enum.reduce(adapters, {0, 0, 0}, fn (x, {ones, threes, prev}) ->
      cond do
        (x - prev) == 1 ->
          {ones + 1, threes, x}
        (x - prev) == 3 ->
          {ones, threes + 1, x}
        true ->
          {ones, threes, x}
      end
    end)
    threes = threes + 1 # hop from the last adapter to the built-in one
    IO.puts("#{ones} * #{threes} = #{ones * threes}")
  end

  def count_connections_upto(current, sofar) do
    IO.puts(current)
    sofar
      |> Enum.take_while(fn {adapter, _ways} -> adapter >= (current - 3) end)
      |> Enum.map(fn {_adapter, ways} -> ways end )
      |> Enum.sum()
  end

  def count_connections(adapters, sofar) do
    [current | remaining] = adapters

    n = count_connections_upto(current, sofar)
    if length(remaining) > 0 do
      count_connections(remaining, [{current, n} | sofar])
    else
      n
    end
  end

  def round2() do
    adapters = getSortedAdapters()
    IO.puts(count_connections(adapters, [{0, 1}]))
  end
end

Adapters.round2()

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;

namespace AdventOfCode2020
{
    static class Day10
    {

        static int counterDif1 = 0;
        static int counterDif3 = 0;
        static List<int> input;

        public static void Execute()
        {
            input = File.ReadAllLines("//inputfile.txt").Select(r=> int.Parse(r)).ToList();

            //Added a imer just for fun
            var timer = new Stopwatch();
            timer.Start();

            input.Insert(0, 0);
            input.Sort();
            for (int i = input.Count-1; i >= 1; i--)
            {
                var dif = input[i] - input[i-1];
                if (dif == 1)
                    counterDif1++;
                else if (dif == 3)
                    counterDif3++;
                else
                    throw new Exception($"{dif}");
            }
            //Finally add the last adapter to your device
            counterDif3++;

            timer.Stop();
            Console.WriteLine($"1 jolts difference: {counterDif1} ");
            Console.WriteLine($"3 jolts difference: {counterDif3} ");
            Console.WriteLine($"1-jolts multiplied by 3-jolts: {counterDif1 * counterDif3}");
            Console.WriteLine($"Executed in: {timer.ElapsedMilliseconds} milliseconds, {timer.ElapsedTicks} ticks");
        }


    }
}

        public override long SampleAnswer => 220;

        public override IEnumerable<int> ParseInput(string rawInput)
            => rawInput
                .Split(Environment.NewLine)
                .Where(line => line.Length > 0)
                .Select(line => int.Parse(line));

        public override long Solve(IEnumerable<int> input)
        {
            var deltas = GetDeltas(input.OrderBy(x => x).ToArray());
            return deltas.Count(x => x == 1) * deltas.Count(x => x == 3);
        }

        protected int[] GetDeltas(int[] values)
        {
            var deltas = new int[values.Length + 1];
            for (var i = 1; i < values.Length; i++)
            {
                deltas[i] = values[i] - values[i - 1];
            }

            deltas[0] = values[0];        // joltage between outlet and first adapter.
            deltas[values.Length] = 3;    // joltage between last adapter and device.

            return deltas;
        }

    public class Part2 : Part1
    {
        public override long SampleAnswer => 19208;

        public override long Solve(IEnumerable<int> input)
        {
            int[] deltas = GetDeltas(input.OrderBy(x => x).ToArray());

            return  GetContiguousOnesCounts(deltas)
                .Aggregate(1L, (sum, cur) => sum *= PossibleCombinations(cur));
        }

        IEnumerable<int> GetContiguousOnesCounts(IEnumerable<int> deltas)
        {
            int contiguousOnes = 0;
            foreach(var delta in deltas)
            {
                if (delta == 1)
                {
                    contiguousOnes++;
                    continue;
                }

                if (contiguousOnes == 0)
                {
                    continue;
                }

                yield return contiguousOnes;
                contiguousOnes = 0;
            }
        }

        long PossibleCombinations(int seqLength)
            => seqLength switch
            {
                1 => 1,
                2 => 2,
                3 => 4,
                4 => 7,
                5 => 13,
                6 => 22,
                _ => 0
            };
    }

3 - 3 (e.g. 4, 7, 10) => only 1 possible configuration
3 - 1 - 3 (e.g. 4, 7, 8, 11) => only 1 possible configuration
3 - 1 - 1 - 3 (e.g. 4, 7, 8, 9, 12) => 2 possible configurations (drop the middle number or don't)
3 - 1 - 1 - 1 - 3 (e.g. 4, 7, 8, 9, 10, 13) => 4 possible configurations (2 each for 8 and 9)
3 - 1 - 1 - 1 - 1 - 3 (e.g. 4, 7, 8, 9, 10, 11, 14) => 7 possible configurations (at least one of 8, 9, 10 must be present, so 2^3 - 1 since dropping all 3 not an option)

#include "Day10.h"

#include <stdio.h>

#include "parsing.h"

/// Day 10: Adapter Array
///
/// Use power adapters to calculate "joltage" jumps from connection
/// to connection.

/// In a sorted array of adapters, return the number of jumps of size 1
/// multiplied by the jumps of size 3.

/// Parse the input file, one number per line into a list of integers.
static int* parse(const char* filename, int* count) {
  FILE* fp;
  fp = fopen(filename, "r");
  if (fp == NULL) {
    printf("Couldn't open file.\n");
    exit(EXIT_FAILURE);
  }

  *count = count_lines(fp);

  // It's going to be easier if we manually attach our outlet and device
  *count += 2;
  int* numbers = (int*)malloc(sizeof(int) * *count);

  numbers[0] = 0;
  numbers[*count - 1] = 4 * *count; // Something so huge goes to the end.
  for (int i = 1; i < *count - 1; i++) {
    char buf[5] = {0};
    fgets(buf, 5, fp);
    numbers[i] = atoi(buf);
  }

  fclose(fp);
  return numbers;
}

/// Integer comparison function for qsort.
int cmp(const void* a, const void* b) {
  return (*(int*)a - *(int*)b);
}

int part1(const char* filename) {
  int count = 0;
  int* numbers = parse(filename, &count);

  qsort(numbers, count, sizeof(int), cmp);
  numbers[count - 1] = numbers[count - 2] + 3;

  int ones = 0;
  int threes = 0;

  for (int i = 1; i < count; i++) {
    int jump = numbers[i] - numbers[i - 1];
    if (jump == 1) ones++;
    else if (jump == 3) threes++;
  }

  free(numbers);
  return ones * threes;
}

/// How many possibilities does a group of continuous ones yield?
static int pattern_to_variants(int ones) {
  switch (ones) {
    case 0: return 1;
    case 1: return 1;
    case 2: return 2;
    case 3: return 4;
    case 4: return 7;
    default:
      printf("Crap, didn't account for > 4 ones.\n");
      exit(EXIT_FAILURE);
  }
}

/// Count the number of distinct arrangements of adapters that
/// would still work.
long long int part2(const char* filename) {
  int count = 0;
  int* numbers = parse(filename, &count);

  qsort(numbers, count, sizeof(int), cmp);
  numbers[count - 1] = numbers[count - 2] + 3;

  int ones = 0;
  long long int product = 1;

  for (int i = 1; i < count; i++) {  
    int jump = numbers[i] - numbers[i - 1];
    if (jump == 1) {
      ones++;
    } else if (jump == 3) {
      product *= pattern_to_variants(ones);
      ones = 0;
    } else {
      printf("Crap, this doesn't work for jumps of 2.\n");
      exit(EXIT_FAILURE);
    }
  }
  return product;
}

/// Run both parts.
int day10() {
  printf("====== Day 10 ======\n");
  printf("Part 1: %d\n", part1("data/day10.txt"));
  printf("Part 2: %lli\n", part2("data/day10.txt"));
  return EXIT_SUCCESS;
}

   IDENTIFICATION DIVISION.
   PROGRAM-ID. AOC-2020-10-1.
   AUTHOR ANNA KOSIERADZKA.

   ENVIRONMENT DIVISION.
   INPUT-OUTPUT SECTION.
   FILE-CONTROL.
       SELECT INPUTFILE ASSIGN TO "d10.input"
       ORGANIZATION IS LINE SEQUENTIAL.

   DATA DIVISION.
   FILE SECTION.
     FD INPUTFILE
     RECORD IS VARYING IN SIZE FROM 1 to 99
     DEPENDING ON REC-LEN.
     01 INPUTRECORD PIC X(99).

   WORKING-STORAGE SECTION.
     01 FILE-STATUS PIC 9 VALUE 0.
     01 REC-LEN PIC 9(2) COMP.
     01 WS-ARR-LEN PIC 9(2) VALUE 95.
     01 WS-ARRAY OCCURS 11 TO 99 DEPENDING ON WS-ARR-LEN.
       05 WS-ARR-I PIC 9(3).

   LOCAL-STORAGE SECTION.
     01 RESULT UNSIGNED-INT VALUE 0.
     01 I UNSIGNED-INT VALUE 1.
     01 DIFF-1 UNSIGNED-INT VALUE 0. 
     01 DIFF-3 UNSIGNED-INT VALUE 0.
     01 DIFF UNSIGNED-INT VALUE 0.

   PROCEDURE DIVISION.
   001-MAIN.
       OPEN INPUT INPUTFILE.
       MOVE 0 TO WS-ARR-I(1).
       ADD 1 TO I.
       PERFORM 002-READ UNTIL FILE-STATUS = 1.
       CLOSE INPUTFILE.
       SORT WS-ARRAY ON ASCENDING KEY WS-ARR-I.
       PERFORM 004-SHIFT-ARRAY.
       COMPUTE WS-ARR-I(WS-ARR-LEN) = WS-ARR-I(WS-ARR-LEN - 1) + 3.
       PERFORM 005-USE-ADAPTERS.
       COMPUTE RESULT = DIFF-1 * DIFF-3.
       DISPLAY RESULT.
       STOP RUN.

   002-READ.
        READ INPUTFILE
            AT END MOVE 1 TO FILE-STATUS
            NOT AT END PERFORM 003-PROCESS-RECORD
        END-READ.

   003-PROCESS-RECORD.
       MOVE INPUTRECORD TO WS-ARR-I(I).
       ADD 1 TO I.

   004-SHIFT-ARRAY.
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > WS-ARR-LEN - 1
          MOVE WS-ARR-I(I + 1) TO WS-ARR-I(I)
       END-PERFORM.

   005-USE-ADAPTERS.
       PERFORM VARYING I FROM 1 BY 1 UNTIL I > WS-ARR-LEN - 1
          COMPUTE DIFF = WS-ARR-I(I + 1) - WS-ARR-I(I)
          IF DIFF = 1 THEN
             ADD 1 TO DIFF-1
          END-IF
          IF DIFF = 3 THEN
             ADD 1 TO DIFF-3
          END-IF
       END-PERFORM.

const fs = require('fs').promises;
const path = require('path');

const main = async () => {
  const input = await fs.readFile(path.join(__dirname, './10.txt'), 'utf-8');
  let lines = input.split('\n').map((x) => parseInt(x));
  const cache = {};

  lines.push(0, Math.max(...lines) + 3);
  lines = lines.sort((a, b) => a - b);

  const dp = (n) => {
    if (n === lines.length - 1) {
      return 1;
    }
    if (n in cache) {
      return cache[n];
    }
    let ans = 0;
    for (let i = n + 1; i < lines.length; i++) {
      if (lines[i] - lines[n] <= 3) {
        ans += dp(i);
      }
    }
    cache[n] = ans;
    return ans;
  };

  console.log(dp(0));
};

main();

#[aoc(day10, part1)]
fn the_path(input: &Vec<usize>) -> usize {
    let mut one_count = 0;
    let mut three_count = 0;
    for (i, v) in input[..input.len() - 1].iter().enumerate() {
        let diff = ((*v) as i32 - (input[i + 1]) as i32).abs() as usize;
        if diff == 1 {
            one_count += 1;
        } else if diff == 3 {
            three_count += 1;
        }
    }
    one_count * three_count
}

#[aoc(day10, part2)]
fn all_combinations(input: &Vec<usize>) -> usize {
    let mut the_ways = HashMap::new();
    // Only one way to get to 0 or 1
    the_ways.insert(0, 1);
    the_ways.insert(1, 1);
    for &v in &input[2..] {
        let mut val = the_ways.get(&(v - 1)).unwrap_or(&0) + the_ways.get(&(v - 2)).unwrap_or(&0);
        if v > 2 {
            val += the_ways.get(&(v - 3)).unwrap_or(&0);
        }
        the_ways.insert(v, val);
    }
    *the_ways.get(input.last().unwrap()).unwrap()
}