Advent of Code 2024 - Luke 8

Full kode finner du her.

Main metode

For alle oppgavene i 2024 bruker jeg Java, og dette vil være metoden jeg bruker for å hente input for de ulike oppgavene. Input blir lagret i en txt fil og hentes via denne metoden.

Oppgave 1 (og 2)

Oppgave 1, luke 8. Antenner. Vi skal finne ut hvor antinodes vil forekomme basert på ulike antenner i en grid. Enkelt nok. For hver antenne der 2 er like vil det forekommme antinodes på samme linje som antennene. Vanskelig å forklare, lett å se i praksis. Dersom antenner ved navn A finnes på linje 3 og 5, vil antinodes finnes på linje 1 og 7. Altså distansen mellom de to antennene i hver retning. Oppgaven går ut på å finne antall unike lokasjoner for antinodes som havner innenfor vår grid. I likhet med luke 7 har jeg her også valgt å gjennbruke metoden for oppgave 1 for oppgave 2 også. Med eneste skille at vi nå skal returnere flere antinodes per antenne ettersom hele linjen de to antennene former skal fylles, ikke kun 2 lokasjoner per linje som i eksempelet over. For å gi nytt eksempel vil det si at dersom antenner ved navn A finnes på 3 og 4, vil vi ha antinodes på 1, 2, 3, 4, 5, 6, 7. Dersom vi sender inn True for variabelen all så vil vi returnere alle antinodes, dersom False vil vi kun returnere 2 antinodes per linje.

private static int findAntinodes(List<String> lines, boolean all) {
    Map<Character, List<String>> antennas = new HashMap<>();
    Set<String> antinodes = new HashSet<>();

    for (int y = 0; y < lines.size(); y++) {
        String line = lines.get(y);
        for (int x = 0; x < line.length(); x++) {
            char c = line.charAt(x);
            if (c == '.') continue;

            List<String> positions = antennas.computeIfAbsent(c, k -> new ArrayList<>());
            for (String prev : positions) {
                String[] coords = prev.split(",");
                int prevY = parseInt(coords[0]);
                int prevX = parseInt(coords[1]);

                int diffX = x - prevX;
                int diffY = y - prevY;

                int antinodeY1 = prevY - diffY;
                int antinodeX1 = prevX - diffX;

                int antinodeY2 = y + diffY;
                int antinodeX2 = x + diffX;

                if(all){
                    antinodes.add(y + "," + x);
                    antinodes.add(prevY + "," + prevX);
                }

                while(antinodeX1 >= 0 && antinodeY1 >= 0 && antinodeX1 < line.length() && antinodeY1 < lines.size()){
                    antinodes.add(antinodeY1 + "," + antinodeX1);
                    if(!all) break;
                    antinodeX1 -= diffX;
                    antinodeY1 -= diffY;
                }

                while(antinodeX2 >= 0 && antinodeY2 >= 0 && antinodeX2 < line.length() && antinodeY2 < lines.size()){
                    antinodes.add(antinodeY2 + "," + antinodeX2);
                    if(!all) break;
                    antinodeX2 += diffX;
                    antinodeY2 += diffY;
                }
            }

            positions.add(y + "," + x);
        }
    }
    return antinodes.size();
}