Advent of Code 2021 - Day 3

///usr/bin/env jbang "$0" "$@" ; exit $?


import static java.lang.System.*;

import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;

public class Day3 {


    static class BitCount {
        final int p;
        final Predicate<Integer> t;
        int c0;
        int c1;

        BitCount(final int p) {
            this.p = p;
            t = i -> (i & p) == p;
        }


        void add(int i) {
            if (t.test(i)) c1++; else c0++;
        }

        void combine(BitCount bc) {
            c0 = c0 + bc.c0;
            c1 = c1 + bc.c1;
        }

        int epsilon() {
            return c1 < c0 ? p : 0;
        }

        int gamma() {
            return c1 > c0 ? p : 0;
        }

        Predicate<Integer> oxygen() {
            return c1 >= c0 ? t: t.negate();
        }

        Predicate<Integer> scrubber() {
            return oxygen().negate();
        }
    }

    static class Count {
        List<Integer> values = new ArrayList<>();

        BitCount b12 = new BitCount((int) Math.pow(2, 11));
        BitCount b11 = new BitCount((int) Math.pow(2, 10));
        BitCount b10 = new BitCount((int) Math.pow(2, 9));
        BitCount b09 = new BitCount((int) Math.pow(2, 8));
        BitCount b08 = new BitCount((int) Math.pow(2, 7));
        BitCount b07 = new BitCount((int) Math.pow(2, 6));
        BitCount b06 = new BitCount((int) Math.pow(2, 5));
        BitCount b05 = new BitCount((int) Math.pow(2, 4));
        BitCount b04 = new BitCount((int) Math.pow(2, 3));
        BitCount b03 = new BitCount((int) Math.pow(2, 2));
        BitCount b02 = new BitCount((int) Math.pow(2, 1));
        BitCount b01 = new BitCount((int) Math.pow(2, 0));

        void add(int i) {
            b12.add(i);
            b11.add(i);
            b10.add(i);
            b09.add(i);
            b08.add(i);
            b07.add(i);
            b06.add(i);
            b05.add(i);
            b04.add(i);
            b03.add(i);
            b02.add(i);
            b01.add(i);

            values.add(i);
        }

        void combine(Count c) {
            b12.combine(c.b12);
            b11.combine(c.b11);
            b10.combine(c.b10);
            b09.combine(c.b09);
            b08.combine(c.b08);
            b07.combine(c.b07);
            b06.combine(c.b06);
            b05.combine(c.b05);
            b04.combine(c.b04);
            b03.combine(c.b03);
            b02.combine(c.b02);
            b01.combine(c.b01);

            values.addAll(c.values);
        }

        int gamma() {
            return 0
                + b12.gamma()
                + b11.gamma()
                + b10.gamma()
                + b09.gamma()
                + b08.gamma()
                + b07.gamma()
                + b06.gamma()
                + b05.gamma()
                + b04.gamma()
                + b03.gamma()
                + b02.gamma()
                + b01.gamma()
                ;
        }

        int epsilon() {
            return 0
                + b12.epsilon()
                + b11.epsilon()
                + b10.epsilon()
                + b09.epsilon()
                + b08.epsilon()
                + b07.epsilon()
                + b06.epsilon()
                + b05.epsilon()
                + b04.epsilon()
                + b03.epsilon()
                + b02.epsilon()
                + b01.epsilon()
                ;
        }

        int consumption() {
            return epsilon() * gamma();
        }

        Predicate<Integer> oxygen(int i) {
            return switch (i) {
                case 12 -> b12.oxygen();
                case 11 -> b11.oxygen();
                case 10 -> b10.oxygen();
                case 9 -> b09.oxygen();
                case 8 -> b08.oxygen();
                case 7 -> b07.oxygen();
                case 6 -> b06.oxygen();
                case 5 -> b05.oxygen();
                case 4 -> b04.oxygen();
                case 3 -> b03.oxygen();
                case 2 -> b02.oxygen();
                case 1 -> b01.oxygen();
                default -> throw new RuntimeException();
            };
        }

        Predicate<Integer> scrubber(int i) {
            return switch (i) {
                case 12 -> b12.scrubber();
                case 11 -> b11.scrubber();
                case 10 -> b10.scrubber();
                case 9 -> b09.scrubber();
                case 8 -> b08.scrubber();
                case 7 -> b07.scrubber();
                case 6 -> b06.scrubber();
                case 5 -> b05.scrubber();
                case 4 -> b04.scrubber();
                case 3 -> b03.scrubber();
                case 2 -> b02.scrubber();
                case 1 -> b01.scrubber();
                default -> throw new RuntimeException();
            };
        }

    }

    static List<Integer> lines() {
        try  {
            return Files.readAllLines(Paths.get("input.txt")).stream().map(s -> Integer.parseInt(s, 2)).toList();
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        throw new RuntimeException();
    }


    static Count count(List<Integer> lines) {
        return lines.stream().collect(Count::new, Count::add, Count::combine);
    }


    static int oxygen(Count bc) {
        return oxygen(bc, 12);
    }

    static int oxygen(Count bc, int b) {
        final Predicate<Integer> filter = bc.oxygen(b);
        final Count nbc = count(bc.values.stream().filter(filter).toList());

        if (nbc.values.size() == 1)
            return nbc.values.get(0);

        return oxygen(nbc, --b);
    }

    static int scrubber(Count bc) {
        return scrubber(bc, 12);
    }

    static int scrubber(Count bc, int b) {
        final Predicate<Integer> filter = bc.scrubber(b);
        final Count nbc = count(bc.values.stream().filter(filter).toList());

        if (nbc.values.size() == 1)
            return nbc.values.get(0);

        return scrubber(nbc, --b);
    }


    public static void main(String... args) {
        final List<Integer> lines = lines();
        final Count bc = count(lines);
        out.println(bc.consumption());

        int oxygen = oxygen(bc);
        int scrubber = scrubber(bc);

        out.println(oxygen * scrubber);

    }
}