DEV Community: Petra

Advent of Code - 2021: Day 6

Petra — Thu, 23 Dec 2021 11:44:30 +0000

Puzzle

--- Day 6: Lanternfish ---

The sea floor is getting steeper. Maybe the sleigh keys got carried this way?

A massive school of glowing lanternfish swims past. They must spawn quickly to reach such large numbers - maybe exponentially quickly? You should model their growth rate to be sure.

Although you know nothing about this specific species of lanternfish, you make some guesses about their attributes. Surely, each lanternfish creates a new lanternfish once every 7 days.

However, this process isn't necessarily synchronized between every lanternfish - one lanternfish might have 2 days left until it creates another lanternfish, while another might have 4. So, you can model each fish as a single number that represents the number of days until it creates a new lanternfish.

Furthermore, you reason, a new lanternfish would surely need slightly longer before it's capable of producing more lanternfish: two more days for its first cycle.

So, suppose you have a lanternfish with an internal timer value of 3:

After one day, its internal timer would become 2.
After another day, its internal timer would become 1.
After another day, its internal timer would become 0.
After another day, its internal timer would reset to 6, and it would create a new lanternfish with an internal timer of 8.
After another day, the first lanternfish would have an internal timer of 5, and the second lanternfish would have an internal timer of 7.
A lanternfish that creates a new fish resets its timer to 6, not 7 (because 0 is included as a valid timer value). The new lanternfish starts with an internal timer of 8 and does not start counting down until the next day.

Realizing what you're trying to do, the submarine automatically produces a list of the ages of several hundred nearby lanternfish (your puzzle input). For example, suppose you were given the following list:

3,4,3,1,2
This list means that the first fish has an internal timer of 3, the second fish has an internal timer of 4, and so on until the fifth fish, which has an internal timer of 2. Simulating these fish over several days would proceed as follows:

Initial state: 3,4,3,1,2
After 1 day: 2,3,2,0,1
After 2 days: 1,2,1,6,0,8
After 3 days: 0,1,0,5,6,7,8
After 4 days: 6,0,6,4,5,6,7,8,8
After 5 days: 5,6,5,3,4,5,6,7,7,8
After 6 days: 4,5,4,2,3,4,5,6,6,7
After 7 days: 3,4,3,1,2,3,4,5,5,6
After 8 days: 2,3,2,0,1,2,3,4,4,5
After 9 days: 1,2,1,6,0,1,2,3,3,4,8
After 10 days: 0,1,0,5,6,0,1,2,2,3,7,8
After 11 days: 6,0,6,4,5,6,0,1,1,2,6,7,8,8,8
After 12 days: 5,6,5,3,4,5,6,0,0,1,5,6,7,7,7,8,8
After 13 days: 4,5,4,2,3,4,5,6,6,0,4,5,6,6,6,7,7,8,8
After 14 days: 3,4,3,1,2,3,4,5,5,6,3,4,5,5,5,6,6,7,7,8
After 15 days: 2,3,2,0,1,2,3,4,4,5,2,3,4,4,4,5,5,6,6,7
After 16 days: 1,2,1,6,0,1,2,3,3,4,1,2,3,3,3,4,4,5,5,6,8
After 17 days: 0,1,0,5,6,0,1,2,2,3,0,1,2,2,2,3,3,4,4,5,7,8
After 18 days: 6,0,6,4,5,6,0,1,1,2,6,0,1,1,1,2,2,3,3,4,6,7,8,8,8,8
Each day, a 0 becomes a 6 and adds a new 8 to the end of the list, while each other number decreases by 1 if it was present at the start of the day.

In this example, after 18 days, there are a total of 26 fish. After 80 days, there would be a total of 5934.

Find a way to simulate lanternfish. How many lanternfish would there be after 80 days?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<List<Integer>> lanternFish = new ArrayList<List<Integer>>();
    StringBuilder initialString = new StringBuilder();

    while (scanner.hasNextLine()) {
      initialString.append(scanner.nextLine());
    }

    String[] stringArray = initialString.toString().split(",");
    List<String> stringList = new ArrayList<String>();
    stringList = Arrays.asList(stringArray);
    List<Integer> initialValues = new ArrayList<>();
    for (int i = 0; i < stringList.size(); i++) {
      initialValues.add(Integer.parseInt(stringList.get(i)));
    }
    lanternFish.add(initialValues);

    for (int i = 1; i < 81; i++) {
      List<Integer> day = new ArrayList<>();
      int numberOfSixDigits = 0;

      for (int k = 0; k < lanternFish.get(i - 1).size(); k++) {
        if (lanternFish.get(i - 1).get(k) > 0) {
          day.add((lanternFish.get(i - 1).get(k) - 1));
        } else if (lanternFish.get(i - 1).get(k) == 0) {
          numberOfSixDigits++;
          day.add(6);
        }
      }
      for (int j = 0; j < numberOfSixDigits; j++) {
        day.add(8);
      }
      lanternFish.add(day);
    }
    System.out.println(lanternFish.get(lanternFish.size() - 1).size());
  }
}

*Source:https://adventofcode.com/2021/day/6

Advent of Code 2021: Day 9

Petra — Thu, 23 Dec 2021 11:44:12 +0000

Puzzle

--- Day 9: Smoke Basin ---

These caves seem to be lava tubes. Parts are even still volcanically active; small hydrothermal vents release smoke into the caves that slowly settles like rain.

If you can model how the smoke flows through the caves, you might be able to avoid it and be that much safer. The submarine generates a heightmap of the floor of the nearby caves for you (your puzzle input).

Smoke flows to the lowest point of the area it's in. For example, consider the following heightmap:

2199943210
3987894921
9856789892
8767896789
9899965678
Each number corresponds to the height of a particular location, where 9 is the highest and 0 is the lowest a location can be.

Your first goal is to find the low points - the locations that are lower than any of its adjacent locations. Most locations have four adjacent locations (up, down, left, and right); locations on the edge or corner of the map have three or two adjacent locations, respectively. (Diagonal locations do not count as adjacent.)

In the above example, there are four low points, all highlighted: two are in the first row (a 1 and a 0), one is in the third row (a 5), and one is in the bottom row (also a 5). All other locations on the heightmap have some lower adjacent location, and so are not low points.

The risk level of a low point is 1 plus its height. In the above example, the risk levels of the low points are 2, 1, 6, and 6. The sum of the risk levels of all low points in the heightmap is therefore 15.

Find all of the low points on your heightmap. What is the sum of the risk levels of all low points on your heightmap?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<List<Integer>> values = new ArrayList<List<Integer>>();
    while (scanner.hasNextLine()) {
      String inputLine = scanner.nextLine();
      String[] string = inputLine.split("");
      List<String> str = new ArrayList<String>();
      str = Arrays.asList(string);
      List<Integer> numbers = new ArrayList<>();
      for (int i = 0; i < str.size(); i++) {
        numbers.add(Integer.parseInt(str.get(i)));
      }
      ;
      values.add(numbers);
    }

    List<Integer> lowestValues = new ArrayList<>();

    for (int i = 0; i < values.size(); i++) {
      for (int j = 0; j < values.get(i).size(); j++) {

        if (i == 0 && j == 0) {
          if (values.get(i).get(j) < values.get(i).get(j + 1)
              && values.get(i).get(j) < values.get(i + 1).get(j)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if (i == 0 && j == values.get(i).size() - 1) {
          if (values.get(i).get(j) < values.get(i).get(j - 1)
              && values.get(i).get(j) < values.get(i + 1).get(j)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if (i == 0 && (j < values.get(i).size() - 1 && j > 0)) {
          if (values.get(i).get(j) < values.get(i).get(j - 1)
              && values.get(i).get(j) < values.get(i).get(j + 1)
              && values.get(i).get(j) < values.get(i + 1).get(j)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if (i == values.size() - 1 && j == 0) {
          if (values.get(i).get(j) < values.get(i - 1).get(j)
              && values.get(i).get(j) < values.get(i).get(j + 1)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if ((i == values.size() - 1) && (j == values.get(i).size() - 1)) {
          if (values.get(i).get(j) < values.get(i - 1).get(j)
              && values.get(i).get(j) < values.get(i).get(j - 1)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if (i == values.size() - 1 && (j < values.get(i).size() - 1 && j > 0)) {
          if (values.get(i).get(j) < values.get(i).get(j - 1)
              && values.get(i).get(j) < values.get(i).get(j + 1)
              && values.get(i).get(j) < values.get(i - 1).get(j)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if (i > 0 && i < values.size() - 1 && j == 0) {
          if (values.get(i).get(j) < values.get(i - 1).get(j)
              && values.get(i).get(j) < values.get(i + 1).get(j)
              && values.get(i).get(j) < values.get(i).get(j + 1)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else if ((i > 0 && i < values.size() - 1) && j == values.get(i).size() - 1) {
          if (values.get(i).get(j) < values.get(i - 1).get(j)
              && values.get(i).get(j) < values.get(i + 1).get(j)
              && values.get(i).get(j) < values.get(i).get(j - 1)) {
            lowestValues.add(values.get(i).get(j));
          }
        } else {

          if (values.get(i).get(j) < values.get(i - 1).get(j)
              && values.get(i).get(j) < values.get(i + 1).get(j)
              && values.get(i).get(j) < values.get(i).get(j - 1)
              && values.get(i).get(j) < values.get(i).get(j + 1)) {
            lowestValues.add(values.get(i).get(j));
          }
        }
      }
    }
    for (int k = 0; k < lowestValues.size(); k++) {
      lowestValues.set(k, lowestValues.get(k) + 1);
    }
    int sum = lowestValues.stream().mapToInt(Integer::intValue).sum();

    System.out.println(sum);
  }
}

*Source: https://adventofcode.com/2021/day/9

Advent of Code - Day 7: Puzzle 2

Petra — Tue, 07 Dec 2021 20:15:08 +0000

Puzzle

--- Part Two ---

The crabs don't seem interested in your proposed solution. Perhaps you misunderstand crab engineering?

As it turns out, crab submarine engines don't burn fuel at a constant rate. Instead, each change of 1 step in horizontal position costs 1 more unit of fuel than the last: the first step costs 1, the second step costs 2, the third step costs 3, and so on.

As each crab moves, moving further becomes more expensive. This changes the best horizontal position to align them all on; in the example above, this becomes 5:

Move from 16 to 5: 66 fuel
Move from 1 to 5: 10 fuel
Move from 2 to 5: 6 fuel
Move from 0 to 5: 15 fuel
Move from 4 to 5: 1 fuel
Move from 2 to 5: 6 fuel
Move from 7 to 5: 3 fuel
Move from 1 to 5: 10 fuel
Move from 2 to 5: 6 fuel
Move from 14 to 5: 45 fuel
This costs a total of 168 fuel. This is the new cheapest possible outcome; the old alignment position (2) now costs 206 fuel instead.

Determine the horizontal position that the crabs can align to using the least fuel possible so they can make you an escape route! How much fuel must they spend to align to that position?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {

  public static int calculateSteps(int startIndex, int endIndex) {
    List<Integer> differences = new ArrayList<>();
    int subtotal = 0;

    for (int k = startIndex; k < endIndex; k++) {
      subtotal++;
      differences.add(subtotal);
    }
    return differences.stream().mapToInt(Integer::intValue).sum();
  }

  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<Integer> numbers = new ArrayList<>();
    List<Integer> values = new ArrayList<>();

    while (scanner.hasNext()) {
      String[] arrayOfNumbers = scanner.nextLine().split(",");
      for (String number : arrayOfNumbers) {
        numbers.add(Integer.parseInt(number));
      }
    }

    int total = 0;
    for (int i = 0; i < numbers.size(); i++) {
      total = 0;
      for (Integer number : numbers) {

        if (i > number) {

          int sum = calculateSteps(number, i);
          total += sum;

        } else if (number > i) {

          int sum = calculateSteps(i, number);
          total += sum;
        }
      }
      values.add(total);
    }

    int minValue = Collections.min(values);

    System.out.println(minValue);
  }
}

*Source: https://adventofcode.com/2021/day/7

Advent of Code - Day 7

Petra — Tue, 07 Dec 2021 20:14:59 +0000

Puzzle

--- Day 7: The Treachery of Whales ---

A giant whale has decided your submarine is its next meal, and it's much faster than you are. There's nowhere to run!

Suddenly, a swarm of crabs (each in its own tiny submarine - it's too deep for them otherwise) zooms in to rescue you! They seem to be preparing to blast a hole in the ocean floor; sensors indicate a massive underground cave system just beyond where they're aiming!

The crab submarines all need to be aligned before they'll have enough power to blast a large enough hole for your submarine to get through. However, it doesn't look like they'll be aligned before the whale catches you! Maybe you can help?

There's one major catch - crab submarines can only move horizontally.

You quickly make a list of the horizontal position of each crab (your puzzle input). Crab submarines have limited fuel, so you need to find a way to make all of their horizontal positions match while requiring them to spend as little fuel as possible.

For example, consider the following horizontal positions:

16,1,2,0,4,2,7,1,2,14
This means there's a crab with horizontal position 16, a crab with horizontal position 1, and so on.

Each change of 1 step in horizontal position of a single crab costs 1 fuel. You could choose any horizontal position to align them all on, but the one that costs the least fuel is horizontal position 2:

Move from 16 to 2: 14 fuel
Move from 1 to 2: 1 fuel
Move from 2 to 2: 0 fuel
Move from 0 to 2: 2 fuel
Move from 4 to 2: 2 fuel
Move from 2 to 2: 0 fuel
Move from 7 to 2: 5 fuel
Move from 1 to 2: 1 fuel
Move from 2 to 2: 0 fuel
Move from 14 to 2: 12 fuel
This costs a total of 37 fuel. This is the cheapest possible outcome; more expensive outcomes include aligning at position 1 (41 fuel), position 3 (39 fuel), or position 10 (71 fuel).

Determine the horizontal position that the crabs can align to using the least fuel possible. How much fuel must they spend to align to that position?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<Integer> numbers = new ArrayList<>();
    List<Integer> values = new ArrayList<>();

   while (scanner.hasNext()) {
      String[] arrayOfNumbers = scanner.nextLine().split(",");
      for (String number : arrayOfNumbers) {
        numbers.add(Integer.parseInt(number));
      }
    }

    int total = 0;
    for (int i = 0; i < numbers.size(); i++) {
      total = 0;
      for (int j = 0; j < numbers.size(); j++) {

        if (i > numbers.get(j)) {
          int difference = i - numbers.get(j);
          total += difference;
        } else if (numbers.get(j) > i) {
          int difference = numbers.get(j) - i;
          total += difference;
        } else {
          int difference = i - numbers.get(j);
          total += difference;
        }
      }
      values.add(total);
    }


    int minValue = Collections.min(values);

    System.out.println(minValue);
  }
}

*Source: https://adventofcode.com/2021/day/7

Advent of Code - Day 5 : Puzzle 2

Petra — Tue, 07 Dec 2021 20:14:48 +0000

Puzzle

--- Part Two ---

Unfortunately, considering only horizontal and vertical lines doesn't give you the full picture; you need to also consider diagonal lines.

Because of the limits of the hydrothermal vent mapping system, the lines in your list will only ever be horizontal, vertical, or a diagonal line at exactly 45 degrees. In other words:

An entry like 1,1 -> 3,3 covers points 1,1, 2,2, and 3,3.
An entry like 9,7 -> 7,9 covers points 9,7, 8,8, and 7,9.
Considering all lines from the above example would now produce the following diagram:

1.1....11.
.111...2..
..2.1.111.
...1.2.2..
.112313211
...1.2....
..1...1...
.1.....1..
1.......1.
222111....
You still need to determine the number of points where at least two lines overlap. In the above example, this is still anywhere in the diagram with a 2 or larger - now a total of 12 points.

Consider all of the lines. At how many points do at least two lines overlap?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<String> coordinates = new ArrayList<>();

    while (scanner.hasNextLine()) {
      coordinates.add(scanner.nextLine());
    }

    int minX = 10000000;
    int maxX = 0;

    int minY = 10000000;
    int maxY = 0;

    for (int i = 0; i < coordinates.size(); i++) {

      int firstXValue =
          Integer.parseInt(coordinates.get(i).substring(0, coordinates.get(i).indexOf(",")));
      int secondXValue =
          Integer.parseInt(
              coordinates
                  .get(i)
                  .substring(
                      coordinates.get(i).lastIndexOf(" ") + 1,
                      coordinates.get(i).lastIndexOf(",")));

      int firstYValue =
          Integer.parseInt(
              coordinates
                  .get(i)
                  .substring(coordinates.get(i).indexOf(",") + 1, coordinates.get(i).indexOf(" ")));
      int secondYValue =
          Integer.parseInt(coordinates.get(i).substring(coordinates.get(i).lastIndexOf(",") + 1));

      // calculate X values
      if (firstXValue > maxX) maxX = firstXValue;
      else if (firstXValue < minX) minX = firstXValue;
      else if (secondXValue < minX) minX = firstXValue;
      else if (secondXValue > maxX) maxX = firstXValue;

      // calculate Y values
      if (firstYValue > maxY) maxY = firstYValue;
      else if (firstYValue < minY) minY = firstYValue;
      else if (secondYValue < minX) minX = secondYValue;
      else if (secondYValue > maxX) maxX = secondYValue;
    }

    int[][] table = new int[maxX + 1][maxY + 1];

    // remove elements
    for (int l = 0; l < coordinates.size(); l++) {
      // if X values equal
      int firstXValue =
          Integer.parseInt(coordinates.get(l).substring(0, coordinates.get(l).indexOf(",")));
      int secondXValue =
          Integer.parseInt(
              coordinates
                  .get(l)
                  .substring(
                      coordinates.get(l).lastIndexOf(" ") + 1,
                      coordinates.get(l).lastIndexOf(",")));

      int firstYValue =
          Integer.parseInt(
              coordinates
                  .get(l)
                  .substring(coordinates.get(l).indexOf(",") + 1, coordinates.get(l).indexOf(" ")));
      int secondYValue =
          Integer.parseInt(coordinates.get(l).substring(coordinates.get(l).lastIndexOf(",") + 1));

      if (firstXValue == secondXValue) {
        int startingY = 0;
        int endingY = 0;

        if (firstYValue < secondYValue) {

          startingY = firstYValue;

          endingY = secondYValue;
        } else {
          endingY = firstYValue;
          startingY = secondYValue;
        }

        for (int k = startingY; k < endingY + 1; k++) {

          for (int n = minX; n < table[k].length; n++) {
            if (n == secondXValue) {
              table[k][n]++;
            }
          }
        }
      }

      // if Y values equal
      if (firstYValue == secondYValue) {

        int startingX = 0;
        int endingX = 0;

        if (firstXValue < secondXValue) {
          startingX = firstXValue;
          endingX = secondXValue;
        } else {
          endingX = firstXValue;
          startingX = secondXValue;
        }

        for (int n = startingX; n < endingX + 1; n++) {
          table[secondYValue][n]++;
        }
      }
      // diagonal values
      else if (firstXValue != secondXValue && firstYValue != secondYValue) {
        int startingX = 0;
        int endingX = 0;

        int startingY = 0;
        int endingY = 0;

        if (firstXValue < secondXValue) {
          startingX = firstXValue;
          endingX = secondXValue;
          startingY = firstYValue;
          endingY = secondYValue;
        } else if (firstXValue > secondXValue) {

          endingX = firstXValue;
          startingX = secondXValue;
          endingY = firstYValue;
          startingY = secondYValue;
        }

        if (startingY < endingY) {

          outer:
          for (int a = startingY; a < endingY + 1; a++) {
            for (int b = startingX; b < endingX + 1; b++) {

              table[a][b]++;
              startingX++;
              continue outer;
            }
          }
        } else if (startingY > endingY) {
          outer:
          for (int a = startingY; a > endingY - 1; a--) {
            for (int b = startingX; b < endingX + 1; b++) {

              table[a][b]++;
              startingX++;
              continue outer;
            }
          }
        }
      }
    }

    int total = 0;

    for (int[] ints : table) {
      for (int anInt : ints) {
        if (anInt > 1) total++;
      }
    }
    System.out.println(total);
  }
}

*Source: https://adventofcode.com/2021/day/5

Advent of Code 2021 - Day 5

Petra — Tue, 07 Dec 2021 20:14:36 +0000

Puzzle

--- Day 5: Hydrothermal Venture ---

You come across a field of hydrothermal vents on the ocean floor! These vents constantly produce large, opaque clouds, so it would be best to avoid them if possible.

They tend to form in lines; the submarine helpfully produces a list of nearby lines of vents (your puzzle input) for you to review. For example:

0,9 -> 5,9
8,0 -> 0,8
9,4 -> 3,4
2,2 -> 2,1
7,0 -> 7,4
6,4 -> 2,0
0,9 -> 2,9
3,4 -> 1,4
0,0 -> 8,8
5,5 -> 8,2
Each line of vents is given as a line segment in the format x1,y1 -> x2,y2 where x1,y1 are the coordinates of one end the line segment and x2,y2 are the coordinates of the other end. These line segments include the points at both ends. In other words:

An entry like 1,1 -> 1,3 covers points 1,1, 1,2, and 1,3.
An entry like 9,7 -> 7,7 covers points 9,7, 8,7, and 7,7.
For now, only consider horizontal and vertical lines: lines where either x1 = x2 or y1 = y2.

So, the horizontal and vertical lines from the above list would produce the following diagram:

.......1..
..1....1..
..1....1..
.......1..
.112111211
..........
..........
..........
..........
222111....
In this diagram, the top left corner is 0,0 and the bottom right corner is 9,9. Each position is shown as the number of lines which cover that point or . if no line covers that point. The top-left pair of 1s, for example, comes from 2,2 -> 2,1; the very bottom row is formed by the overlapping lines 0,9 -> 5,9 and 0,9 -> 2,9.

To avoid the most dangerous areas, you need to determine the number of points where at least two lines overlap. In the above example, this is anywhere in the diagram with a 2 or larger - a total of 5 points.

Consider only horizontal and vertical lines. At how many points do at least two lines overlap?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<String> coordinates = new ArrayList<>();

    while (scanner.hasNextLine()) {
      coordinates.add(scanner.nextLine());
    }

    int minX = 10000000;
    int maxX = 0;

    int minY = 10000000;
    int maxY = 0;

    for (int i = 0; i < coordinates.size(); i++) {

      int firstXValue =
          Integer.parseInt(coordinates.get(i).substring(0, coordinates.get(i).indexOf(",")));
      int secondXValue =
          Integer.parseInt(
              coordinates
                  .get(i)
                  .substring(
                      coordinates.get(i).lastIndexOf(" ") + 1,
                      coordinates.get(i).lastIndexOf(",")));

      int firstYValue =
          Integer.parseInt(
              coordinates
                  .get(i)
                  .substring(coordinates.get(i).indexOf(",") + 1, coordinates.get(i).indexOf(" ")));
      int secondYValue =
          Integer.parseInt(coordinates.get(i).substring(coordinates.get(i).lastIndexOf(",") + 1));

      // calculate X values
      if (firstXValue > maxX) maxX = firstXValue;
      else if (firstXValue < minX) minX = firstXValue;
      else if (secondXValue < minX) minX = firstXValue;
      else if (secondXValue > maxX) maxX = firstXValue;

      // calculate Y values
      if (firstYValue > maxY) maxY = firstYValue;
      else if (firstYValue < minY) minY = firstYValue;
      else if (secondYValue < minX) minX = secondYValue;
      else if (secondYValue > maxX) maxX = secondYValue;
    }

    int[][] table = new int[maxX + 1][maxY + 1];

    // remove elements
    for (int l = 0; l < coordinates.size(); l++) {
      // if X values equal
      int firstXValue =
          Integer.parseInt(coordinates.get(l).substring(0, coordinates.get(l).indexOf(",")));
      int secondXValue =
          Integer.parseInt(
              coordinates
                  .get(l)
                  .substring(
                      coordinates.get(l).lastIndexOf(" ") + 1,
                      coordinates.get(l).lastIndexOf(",")));

      int firstYValue =
          Integer.parseInt(
              coordinates
                  .get(l)
                  .substring(coordinates.get(l).indexOf(",") + 1, coordinates.get(l).indexOf(" ")));
      int secondYValue =
          Integer.parseInt(coordinates.get(l).substring(coordinates.get(l).lastIndexOf(",") + 1));

      if (firstXValue == secondXValue) {
        int startingY = 0;
        int endingY = 0;

        if (firstYValue < secondYValue) {

          startingY = firstYValue;

          endingY = secondYValue;
        } else {
          endingY = firstYValue;
          startingY = secondYValue;
        }

        for (int k = startingY; k < endingY + 1; k++) {

          for (int n = minX; n < table[k].length; n++) {
            if (n == secondXValue) {
              table[k][n]++;
            }
          }
        }
      }

      // if Y values equal
      if (firstYValue == secondYValue) {

        int startingX = 0;
        int endingX = 0;

        if (firstXValue < secondXValue) {
          startingX = firstXValue;
          endingX = secondXValue;
        } else {
          endingX = firstXValue;
          startingX = secondXValue;
        }

        for (int n = startingX; n < endingX + 1; n++) {
          table[secondYValue][n]++;
        }
      }
    }

    int total = 0;

    for (int[] ints : table) {
      for (int anInt : ints) {
        if (anInt > 1) total++;
      }
    }
    System.out.println(total);
  }
}

*Source: https://adventofcode.com/2021/day/5

Advent of Code - Day 3 : Puzzle 2

Petra — Tue, 07 Dec 2021 20:14:07 +0000

Puzzle

-- Part Two ---

Next, you should verify the life support rating, which can be determined by multiplying the oxygen generator rating by the CO2 scrubber rating.

Both the oxygen generator rating and the CO2 scrubber rating are values that can be found in your diagnostic report - finding them is the tricky part. Both values are located using a similar process that involves filtering out values until only one remains. Before searching for either rating value, start with the full list of binary numbers from your diagnostic report and consider just the first bit of those numbers. Then:

Keep only numbers selected by the bit criteria for the type of rating value for which you are searching. Discard numbers which do not match the bit criteria.
If you only have one number left, stop; this is the rating value for which you are searching.
Otherwise, repeat the process, considering the next bit to the right.
The bit criteria depends on which type of rating value you want to find:

To find oxygen generator rating, determine the most common value (0 or 1) in the current bit position, and keep only numbers with that bit in that position. If 0 and 1 are equally common, keep values with a 1 in the position being considered.
To find CO2 scrubber rating, determine the least common value (0 or 1) in the current bit position, and keep only numbers with that bit in that position. If 0 and 1 are equally common, keep values with a 0 in the position being considered.
For example, to determine the oxygen generator rating value using the same example diagnostic report from above:

Start with all 12 numbers and consider only the first bit of each number. There are more 1 bits (7) than 0 bits (5), so keep only the 7 numbers with a 1 in the first position: 11110, 10110, 10111, 10101, 11100, 10000, and 11001.
Then, consider the second bit of the 7 remaining numbers: there are more 0 bits (4) than 1 bits (3), so keep only the 4 numbers with a 0 in the second position: 10110, 10111, 10101, and 10000.
In the third position, three of the four numbers have a 1, so keep those three: 10110, 10111, and 10101.
In the fourth position, two of the three numbers have a 1, so keep those two: 10110 and 10111.
In the fifth position, there are an equal number of 0 bits and 1 bits (one each). So, to find the oxygen generator rating, keep the number with a 1 in that position: 10111.
As there is only one number left, stop; the oxygen generator rating is 10111, or 23 in decimal.
Then, to determine the CO2 scrubber rating value from the same example above:

Start again with all 12 numbers and consider only the first bit of each number. There are fewer 0 bits (5) than 1 bits (7), so keep only the 5 numbers with a 0 in the first position: 00100, 01111, 00111, 00010, and 01010.
Then, consider the second bit of the 5 remaining numbers: there are fewer 1 bits (2) than 0 bits (3), so keep only the 2 numbers with a 1 in the second position: 01111 and 01010.
In the third position, there are an equal number of 0 bits and 1 bits (one each). So, to find the CO2 scrubber rating, keep the number with a 0 in that position: 01010.
As there is only one number left, stop; the CO2 scrubber rating is 01010, or 10 in decimal.
Finally, to find the life support rating, multiply the oxygen generator rating (23) by the CO2 scrubber rating (10) to get 230.

Use the binary numbers in your diagnostic report to calculate the oxygen generator rating and CO2 scrubber rating, then multiply them together. What is the life support rating of the submarine? (Be sure to represent your answer in decimal, not binary.)*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {

  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    List<String> highValues = new ArrayList<>();
    List<String> lowValues = new ArrayList<>();

    while (scanner.hasNextLine()) {
      String inputLine = scanner.nextLine();
      highValues.add(inputLine);
      lowValues.add(inputLine);
    }

    for (int i = 0; i < 12; i++) {

      int highValuesListZeros = 0;
      int highValuesListOnes = 0;
      int lowValuesListZeros = 0;
      int lowValuesListOnes = 0;

      for (int j = 0; j < 2; j++) {

        if (j == 0) {

          for (int m = 0; m < highValues.size(); m++) {
            if (highValues.get(m).charAt(i) == '0') highValuesListZeros++;
            else if (highValues.get(m).charAt(i) == '1') highValuesListOnes++;
          }
          for (int n = 0; n < lowValues.size(); n++) {
            if (lowValues.get(n).charAt(i) == '0') lowValuesListZeros++;
            else if (lowValues.get(n).charAt(i) == '1') lowValuesListOnes++;
          }
        }

        if (j == 1) {

          boolean isMoreZeros = false;
          boolean isMoreOnes = false;

          boolean isLessZeros = false;
          boolean isLessOnes = false;

          if (highValuesListZeros > highValuesListOnes) isMoreZeros = true;
          else if (highValuesListOnes > highValuesListZeros) isMoreOnes = true;
          else isMoreOnes = true;

          if (lowValuesListZeros < lowValuesListOnes) isLessZeros = true;
          else if (lowValuesListZeros > lowValuesListOnes) isLessOnes = true;
          else isLessZeros = true;

          for (int k = 0; k < highValues.size(); k++) {

            if (highValues.get(k).charAt(i) == '0' && isMoreOnes) {
              highValues.remove(k);
              k--;
            } else if (highValues.get(k).charAt(i) == '1' && isMoreZeros) {
              highValues.remove(k);
              k--;
            }
          }

          for (int l = 0; l < lowValues.size(); l++) {
            if (lowValues.get(l).charAt(i) == '0' && isLessOnes && lowValues.size() != 1) {
              lowValues.remove(l);
              l--;
            } else if (lowValues.get(l).charAt(i) == '1' && isLessZeros && lowValues.size() != 1) {
              lowValues.remove(l);
              l--;
            }
          }
        }
      }
    }

    int oxygenRate = Integer.parseInt(highValues.get(0), 2);

    int co2Rate = Integer.parseInt(lowValues.get(0), 2);

    System.out.println(oxygenRate * co2Rate);
  }
}

*Source: https://adventofcode.com/2021/day/3

Advent of Code 2021 - Day 3

Petra — Tue, 07 Dec 2021 20:13:51 +0000

Puzzle

--- Day 3: Binary Diagnostic ---

The submarine has been making some odd creaking noises, so you ask it to produce a diagnostic report just in case.

The diagnostic report (your puzzle input) consists of a list of binary numbers which, when decoded properly, can tell you many useful things about the conditions of the submarine. The first parameter to check is the power consumption.

You need to use the binary numbers in the diagnostic report to generate two new binary numbers (called the gamma rate and the epsilon rate). The power consumption can then be found by multiplying the gamma rate by the epsilon rate.

Each bit in the gamma rate can be determined by finding the most common bit in the corresponding position of all numbers in the diagnostic report. For example, given the following diagnostic report:

00100
11110
10110
10111
10101
01111
00111
11100
10000
11001
00010
01010

Considering only the first bit of each number, there are five 0 bits and seven 1 bits. Since the most common bit is 1, the first bit of the gamma rate is 1.

The most common second bit of the numbers in the diagnostic report is 0, so the second bit of the gamma rate is 0.

The most common value of the third, fourth, and fifth bits are 1, 1, and 0, respectively, and so the final three bits of the gamma rate are 110.

So, the gamma rate is the binary number 10110, or 22 in decimal.

The epsilon rate is calculated in a similar way; rather than use the most common bit, the least common bit from each position is used. So, the epsilon rate is 01001, or 9 in decimal. Multiplying the gamma rate (22) by the epsilon rate (9) produces the power consumption, 198.

Use the binary numbers in your diagnostic report to calculate the gamma rate and epsilon rate, then multiply them together. What is the power consumption of the submarine? (Be sure to represent your answer in decimal, not binary.)*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");

    StringBuilder gammaRate = new StringBuilder();
    StringBuilder epsilonRate = new StringBuilder();

    for (int i = 0; i < 12; i++) {
      Scanner scanner = new Scanner(input);
      List<Character> characterZero = new ArrayList<>();
      List<Character> characterOne = new ArrayList<>();

      while (scanner.hasNextLine()) {
        char character = scanner.nextLine().charAt(i);
        switch (character) {
          case '0':
            characterZero.add(character);
            break;
          case '1':
            characterOne.add(character);
        }
      }
      if (characterZero.size() > characterOne.size()) {
        gammaRate.append('0');
        epsilonRate.append('1');
      } else {
        gammaRate.append('1');
        epsilonRate.append('0');
      }
    }
    int gammaInDecimal = Integer.parseInt(gammaRate.toString(), 2);
    int epsilonInDecimal = Integer.parseInt(epsilonRate.toString(), 2);

    System.out.println(gammaInDecimal * epsilonInDecimal);
  }
}

*Source: https://adventofcode.com/2021/day/3

Advent of Code 2021 - Day 2 : Puzzle 2

Petra — Tue, 07 Dec 2021 20:12:48 +0000

Puzzle

--- Part Two ---

Based on your calculations, the planned course doesn't seem to make any sense. You find the submarine manual and discover that the process is actually slightly more complicated.

In addition to horizontal position and depth, you'll also need to track a third value, aim, which also starts at 0. The commands also mean something entirely different than you first thought:

down X increases your aim by X units.
up X decreases your aim by X units.
forward X does two things:
It increases your horizontal position by X units.
It increases your depth by your aim multiplied by X.
Again note that since you're on a submarine, down and up do the opposite of what you might expect: "down" means aiming in the positive direction.

Now, the above example does something different:

forward 5 adds 5 to your horizontal position, a total of 5. Because your aim is 0, your depth does not change.
down 5 adds 5 to your aim, resulting in a value of 5.
forward 8 adds 8 to your horizontal position, a total of 13. Because your aim is 5, your depth increases by 8*5=40.
up 3 decreases your aim by 3, resulting in a value of 2.
down 8 adds 8 to your aim, resulting in a value of 10.
forward 2 adds 2 to your horizontal position, a total of 15. Because your aim is 10, your depth increases by 2*10=20 to a total of 60.
After following these new instructions, you would have a horizontal position of 15 and a depth of 60. (Multiplying these produces 900.)

Using this new interpretation of the commands, calculate the horizontal position and depth you would have after following the planned course. What do you get if you multiply your final horizontal position by your final depth?*

My solution

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) throws Exception {
    File input = new File("/Users/files/input.txt");
    Scanner scanner = new Scanner(input);

    int x = 0;
    int y = 0;
    int aim = 0;

    while (scanner.hasNextLine()) {
      String inputLine = scanner.nextLine();
      int number = Integer.parseInt(inputLine.substring(inputLine.length() - 1));
      if (inputLine.contains("forward")) {
        x += number;
        y += (aim * number);
      } else if (inputLine.contains("down")) aim += number;
      else aim -= number;
    }
    System.out.println(x * y);
  }
}

Source: https://adventofcode.com/2021/day/2

Advent of Code 2021 - Day 2

Petra — Fri, 03 Dec 2021 14:57:18 +0000

Hi Everyone!

My solution of the first puzzle of Day 2!

package main;

import java.io.File;
import java.util.*;

public class Puzzle {
  public static void main(String[] args) {
    try {
      File input = new File("/Users/files/input.txt");
      Scanner sc = new Scanner(input);
      int x = 0;
      int y = 0;
      while (sc.hasNextLine()) {
        String inputLine = sc.nextLine();
        int number = Integer.parseInt(inputLine.substring(inputLine.length() - 1));
        if (inputLine.contains("forward")) x += number;
        else if (inputLine.contains("down")) y += number;
        else y -= number;
      }
      System.out.println(x * y);

    } catch (Exception e) {
      System.out.println("Error!");
    }
  }
}

Advent of Code 2021 - Day 1: Puzzle 2

Petra — Fri, 03 Dec 2021 13:41:57 +0000

Hi all!

Here is my solution of the second puzzle of Advent of Code, Day 1.

package main;

import java.io.File;
import java.util.*;

public class Puzzle {

  public static void main(String[] args) {
    try {
      File input = new File("/Users/files/input.txt");
      Scanner scanner = new Scanner(input);
      List<Integer> numbers = new ArrayList<>();

      while (scanner.hasNextLine()) numbers.add(Integer.parseInt(scanner.nextLine()));

      int count = 0;

      for (int i = 1; i < numbers.size() - 2; i++) {
        int value = numbers.get(i) + numbers.get(i + 1) + numbers.get(i + 2);
        int previousValue = numbers.get(i - 1) + numbers.get(i) + numbers.get(i + 1);
        if (value > previousValue) count++;
      }
      System.out.println(count);
    } catch (Exception e) {
      System.out.println("Exception!");
    }
  }
}

Advent of Code 2021 - Day 1

Petra — Thu, 02 Dec 2021 21:48:39 +0000

Hi all!

This is my solution of the first puzzle of Advent of Code on Day 1, in Java.

package main;

import java.io.File;
import java.util.*;

public class Puzzle {

    public static void main(String[] {
        try {
            File input = new File("/Users/files/input.txt");
            Scanner scanner = new Scanner(input);
            List<Integer> numbers = new ArrayList<>();

            while (scanner.hasNextLine())
                numbers.add(Integer.parseInt(scanner.nextLine()));


            int count = 0;

            for (int i = 1; i < numbers.size(); i++) {
                if (numbers.get(i) > numbers.get(i - 1)) {
                    count++;
                }
            }

            System.out.println(count);
        } catch (Exception e) {
            System.out.println("Exception!");
        }

    }

}