Сразу прикинул, что с использованием примитивов или оборачиванием в типы из стандартной библиотеки — будет портяночно. Поэтому — отдельный класс с логикой:

public class Card {
    private static final Predicate<String> EMPTY = s -> " ".equals(s) || "".equals(s);
    Integer cardN, winCnt;
    Set<Integer> win, have;
    List<Card> nextCards = new ArrayList<>(); // added for part 2
    public Card(String cardN, String[] win, String[] have) {
        this.cardN = Integer.parseInt(cardN.replaceAll("^Card\\s+", ""));
        this.win = parseNums(win);
        this.have = parseNums(have);
        this.winCnt = (int) this.have.stream().filter(h -> this.win.contains(h)).count();
    }
    void addNext(List<Card> nextCards) { // added for part 2
        this.nextCards.addAll(nextCards);
    }
    Stream<Card> flat() { // added for part 2
        return Stream.concat(Stream.of(this),
                this.nextCards.stream().flatMap(Card::flat));
    }
    private static Set<Integer> parseNums(String[] nums) {
        return Arrays.stream(nums).filter(not(EMPTY)).map(Integer::parseInt)
                .collect(Collectors.toSet());
    }
};

И короткое решение с его помощью:

static void day4(String puzzleInputUri) throws IOException, InterruptedException {
    var cards = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(it -> it.split(":", 2))
            .map(it -> Map.entry(it[0], it[1].split("\\|", 2)))
            .map(it -> new Card(it.getKey(), it.getValue()[0].split(" "),
                    it.getValue()[1].split(" ")))
            .toList();

    var answer1 = cards.stream()
            .filter(card -> card.winCnt > 0)
            .mapToInt(card -> card.winCnt)
            .mapToDouble(win -> Math.pow(2, (win - 1)))
            .reduce(Double::sum).orElseThrow();
    System.out.println(answer1); // 20117

    var answer2 = IntStream.iterate(cards.size() - 1, i -> i >= 0, i -> i - 1)
            .mapToObj(cards::get)
            .peek(card -> card.addNext(cards.subList(card.cardN, card.cardN + card.winCnt)))
            .flatMap(card -> card.flat())
            .count();
    System.out.println(answer2); // 13768818
}

https://adventofcode.com/2023/day/4

Следующим шагом на пути окунания в пучины многословия — стало создание контейнеров для упаковки данных со «схемы двигателя». Вот они:

public record Coord(Integer row, Integer column){};
public record Cell(Coord coord, Integer codePoint){
    Set<Coord> border() {return Set.of(
            new Coord(coord.row(), coord.column() - 1), // left
            new Coord(coord.row() - 1, coord.column() - 1), // top-left
            new Coord(coord.row() - 1, coord.column()), // top
            new Coord(coord.row() - 1, coord.column() + 1), // top-right
            new Coord(coord.row(), coord.column() + 1), // right
            new Coord(coord.row() + 1, coord.column() + 1), // bot-right
            new Coord(coord.row() + 1, coord.column()), // bottom
            new Coord(coord.row() + 1, coord.column() - 1) // bot-left
    );}
};
public record Part(List<Cell> cells){
    public Part {
        cells = List.copyOf(cells);
    }
    Set<Coord> border() {
        return cells.stream()
            .flatMap(c -> c.border().stream())
            .filter(bCoord -> cells.stream()
                    .noneMatch(c -> bCoord.equals(c.coord())))
            .collect(Collectors.toSet());
    }
    Integer value() {
        return Integer.parseInt(cells.stream()
                .map(c -> Character.toChars(c.codePoint()))
                .map(String::new).collect(Collectors.joining()));
    }
};

У меня было три штуки рекордов, несколько методов с регулярно вычисляющей одно и то же логикой внутри них и россыпь операций по упаковке простого содержимого в сложные формы. Не то, чтобы всё это было нужно в решении задачи, но раз начал коллекционировать объекты, то иди в своём увлечении до конца.

static void day3(String puzzleInputUri) throws IOException, InterruptedException {
    Integer emptyCell = (int) '.';
    Integer gearCell = (int) '*';
    List<List<Integer>> scheme = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(line -> line.chars().boxed().collect(Collectors.toCollection(ArrayList::new)))
            .peek(chars -> chars.addFirst(emptyCell))
            .peek(chars -> chars.addLast(emptyCell))
            .collect(Collectors.toCollection(ArrayList::new));
    scheme.addFirst(Collections.nCopies(scheme.getFirst().size(), emptyCell));
    scheme.addLast(Collections.nCopies(scheme.getFirst().size(), emptyCell));

    List<Part> parts = new ArrayList<>();
    List<Cell> gears = new ArrayList<>();
    List<Cell> partDigit = new ArrayList<>();
    boolean prevIsDigit = false;
    for (int row = 1; row < scheme.size() - 1; row++) {
        for (int column = 1; column < scheme.get(row).size() - 1; column++) {
            Integer cellValue = scheme.get(row).get(column);
            if (Character.isDigit(cellValue)) {
                partDigit.add(new Cell(new Coord(row, column), cellValue));
                prevIsDigit = true;
            } else if (prevIsDigit) {
                parts.add(new Part(partDigit));
                partDigit.clear();
                prevIsDigit = false;
            }
            if (gearCell.equals(cellValue)) {
                gears.add(new Cell(new Coord(row, column), cellValue));
            }
        }
    }
    var validParts = parts.stream()
            .filter(part -> part.border().stream().anyMatch(
                    c -> !emptyCell.equals(scheme.get(c.row()).get(c.column()))
            )).toList();

    var answer1 = validParts.stream()
            .mapToInt(part -> part.value())
            .sum();
    System.out.println(answer1);

    var answer2 = gears.stream()
            .map(gear -> Map.entry(gear,
                validParts.stream().filter(part -> part.border().contains(gear.coord())).toList()
            ))
            .filter(gearParts -> gearParts.getValue().size() == 2)
            .map(Map.Entry::getValue)
            .mapToInt(gearParts -> gearParts.getFirst().value() * gearParts.getLast().value())
            .sum();
    System.out.println(answer2);
}

Это очень опасное предприятие закончилось благополучно! Длинная подготовка вылилась в достаточно короткие решения. Пришло удивительное, вселенское ощущение правильности всего того, что я делал.

static void printScheme(List<List<Integer>> scheme) {
    scheme.forEach(row -> {
        StringBuilder sb = new StringBuilder();
        row.forEach(sb::appendCodePoint);
        System.out.println(sb);
    });
}

https://adventofcode.com/2023/day/3

Немного почистить после, или сразу докрутить регулярку, чтобы не захватывала разделители. Сложить в хэш. И закончить кучей циклов в итоге

С другой стороны — и возня с java Matcher не вдохновляла, и описывать структуру в виде POJO — для чисто скриптового решения — зачем.

split — дёшево и сердито, fastpath бонусом. К счастью — ввод был одинаков для обеих частей загадки.

// Game 1: 3 blue, 4 red; 1 red, 2 green, 6 blue; 2 green
static void day2(String puzzleInputUri) throws IOException, InterruptedException {
    Map<String, Integer> bagOfCubes = Map.of("red", 12, "green", 13, "blue", 14);
    var games = client.send(request.uri((URI.create(puzzleInputUri))).build(),
                    HttpResponse.BodyHandlers.ofLines()).body()
            .map(game -> game.split(":", 2))
            .map(idAndResults -> Map.entry(
                    idAndResults[0].split(" ", 2)[1], // game id
                    idAndResults[1] // results string
            ))
            .map(idAndResults -> Map.entry(idAndResults.getKey(), idAndResults.getValue().split(";")))
            .map(idAndResults -> {
                List<Map<String, Integer>> parsedResults = new ArrayList<>();
                for (String s : idAndResults.getValue()) {
                    Map<String, Integer> cubesCount = new HashMap<>();
                    for (String s1 : s.split(",")) {
                        String[] cubeCount = s1.trim().split(" ", 2);
                        cubesCount.put(cubeCount[1].trim(), Integer.parseInt(cubeCount[0].trim()));
                    }
                    parsedResults.add(cubesCount);
                }
                return Map.entry(idAndResults.getKey(), parsedResults);
            })
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

    var answer1 = games.entrySet().stream()
            .filter(idAndResults -> idAndResults.getValue().stream()
                .flatMap(it -> it.entrySet().stream())
                .noneMatch(result -> result.getValue() > bagOfCubes.get(result.getKey()))
            )
            .mapToInt(idAndResults -> Integer.parseInt(idAndResults.getKey()))
            .sum();

    var answer2 = games.entrySet().stream()
            .map(idAndResults -> Map.entry(
                idAndResults.getKey(),
                idAndResults.getValue().stream()
                    .reduce((m1, m2) -> {
                        Map<String, Integer> minRequired = new HashMap<>();
                        bagOfCubes.keySet().forEach(cube -> minRequired.put(cube,
                            Math.max(m1.getOrDefault(cube, 0),
                                    m2.getOrDefault(cube, 0))
                        ));
                        return minRequired;
                    }).orElseThrow()
                )
            )
            .mapToInt(idAndMinRequired -> idAndMinRequired.getValue().values().stream()
                    .reduce((v1, v2) -> v1 * v2).orElseThrow() // v != 0 ? v : 1
            )
            .sum();

    System.out.println(answer1);
    System.out.println(answer2);
}

Вид этой портянки мне не особо мил, особенно for внутри (mapMulti взамен?). Но и как-то значимо «облагородить» её не удалось с ходу — получалась куча менее понятных map, происходящее в которых сложно осознать уже через пару десятков минут.
А часики тикают, задачи требуют решений — и пора двигаться дальше!

https://adventofcode.com/2023/day/2

Обвязка для загрузки условий задачи — та же, что для AoC-2022. Тег для задачек 2023 года — adventofcode-2023 (или раздел Problem Solving).

Первая часть загадки первого дня

Достаточно простое и короткое получилось решение, отлично сработало для первой части пазла — и практически никак не подошло для второй. Оставляю «для истории».

// Only part 1 solution
static void day1(String puzzleInputUri) throws IOException, InterruptedException {
    var result = client.send(request.uri((URI.create(puzzleInputUri))).build(), HttpResponse.BodyHandlers.ofLines()).body()
            .map(String::chars)
            .map(IntStream::boxed)
            .map(codePoints -> {
                List<String> digits = codePoints
                        .filter(Character::isDigit)
                        .map(Character::toString)
                        .toList();
                return digits.getFirst() + digits.getLast();
            })
            .mapToInt(Integer::parseInt)
            .sum();
    System.out.println(result);
}

Часть вторая и универсальное решение

Но совсем бесполезным решение для первой части назвать нельзя — оно легло в основу универсального решения.

// Universal solution
static void day1(String puzzleInputUri) throws IOException, InterruptedException {
    Map<String, String> digits = Map.of(
            "1", "one",
            "2", "two",
            "3", "three",
            "4", "four",
            "5", "five",
            "6", "six",
            "7", "seven",
            "8", "eight",
            "9", "nine"
    );
    TreeMap<Integer, String> firstLast = new TreeMap<>();
    var result = client.send(request.uri((URI.create(puzzleInputUri))).build(), HttpResponse.BodyHandlers.ofLines()).body()
            .map(string -> {
                firstLast.clear();
                digits.forEach((digit, numeric) -> {
                        firstLast.put(string.indexOf(digit), digit);
                        firstLast.put(string.lastIndexOf(digit), digit);
                        firstLast.put(string.indexOf(numeric), digit);
                        firstLast.put(string.lastIndexOf(numeric), digit);
                    }
                );
                firstLast.remove(-1); // not matched substrings index
                return firstLast.firstEntry().getValue() + firstLast.lastEntry().getValue();
            })
            .mapToInt(Integer::parseInt)
            .sum();
    System.out.println(result);
}

Жаль, что (для экономии буковок) — не удалось отыскать где-нибудь в недрах стандартной библиотеки готовых привязок цифр к числительным. Хотя и ожидаемо.

Загадка первого дня была не слишком сложной, но поначалу пошла туговато на фоне повседневного «перекладывания жысонов«.

Тем полезней переключаться! Участвуй!

https://adventofcode.com/2023/day/1

Комментировать в TELEGRAM

Да нормально жил, но утомлялся точно больше. Не скажу даже вот так сразу, какой из них полезней. Остановлюсь на каждом чуть подробней.

RoboPOJOGenerator

Пожалуй, всё же — генератор классов POJO из JSON.

Копипастишь прямо из документации — ВЖУХ! И ни фига! Сначала надо засунуть в insomnia (ну или postman, или http клиент в идее — кому что привычней) и проверить, что json не кривой. Зато потом — магия срабатывает в полный рост.

Все эти тысячи полей, вложенных структур — уже не надо сидеть, уныло создавая и перенося руками. Чуть подправить там да сям разные мелочи в конце.

POJO to JSON

Обратный генератор POJO в JSON пригождается реже, но когда пригождается — очень удобен.

Он может набить json случайными данными с нужными типами. Дальше можно сразу сунуть готовый json в запрос, или скинуть на обсуждение.

Теперь это в прошлом —

копирование полей по одному из документации в DTO и сочинение примеров запросов.

Слава роботам!

Комментировать в телеге

Современная постановка сделана по пьесе конца XIX века, а та, в свою очередь, написана по произведению века XVII (или начала XVIII, тут мнения расходятся).

И вот прямо так интересно оказалось всё это вместе:

• И факт старинности основы спектакля (русский театр, всё же, в массе известен века с двадцатого).
• И подход, который нашёл постановщик к подаче действа — сцена в виде этакой балаганной карусели — здорово добавляет антуража.
• И костюмы проработаны, и игра цепляет, и «осовремененено» совсем каплю и в меру — «виной» тому, видимо, этнографичность и историчность театра

Тем более, что у себя, в Питере, я подобного сочетания не обнаружил, да и в принципе постановок по этой пьесе не встретил. Рекомендую!

Но есть же git — ведь он поможет? Ведь поможет, да?

Git поможет!

Возникла тривиальная идея — вытащить эту информацию из гит-лога. Первый и последний коммиты — плюс-минус дадут требуемые рамки. Достаточно найти все коммиты определённого автора (в данном случае — себя) и взять первый+последний.

Git alias для поиска по автору

Чтобы не запоминать (или не искать в истории) довольно длинную команду — её удобно запихать в пользовательский alias (именно гита, не оболочки). Например — в ~/.gitconfig прописать (в секции [alias]):

[alias]
	first-last-by-author = "!f() { \
	 LOG=$(git log --pretty=format:\"%h%x09%an%x09%ad%x09%s\" --date=short --author=\"${1}\"); \
	 FIRST=$(echo \"${LOG}\" | head --lines=1); \
	 LAST=$(echo \"${LOG}\" | tail --lines=1); \
	 echo \"${FIRST}\"; echo \"${LAST}\"; \
	}; f"

В частном случае — это уже работает достаточно удобно и выглядит примерно так:

user@host:~/single-repo$ git first-last-by-author dmitry

f887e8aa55      Dmitry        2022-06-26
6f7a97ded7      Dmitry        2021-04-08

Когда репозиторий для поиска — один. Или парочка. Или… Нет, когда их парочка сотен — становится грустно. Идея явно требует развития!

One Function to find them all

Для решения задачи поиска по набору репозиториев — пришлось воспользоваться функциями оболочки. Они у меня сложены в отдельном файле ~/.config/bash/bash_functions.

На базе команды для обновления репозиториев и приведённого выше гит-алиаса для поиска по автору — сделал такую вот bash-функцию:

git-first-last-commit-by-author() {
	export GIT_SEARCH_AUTHOR_NAME="${1}"
	LOG=$(find . -type d -name '.git' | xargs -n1 -- \
	 sh -c 'cd "${0}/.." && git first-last-by-author "${GIT_SEARCH_AUTHOR_NAME}" | sed "/^[[:space:]]*$/d"' \
	 | sort --key=4,4 \
	)
	unset GIT_SEARCH_AUTHOR_NAME
	echo "${LOG}" | head --lines=1
	echo "${LOG}" | tail --lines=1
}

Теперь поиск работает и в общем случае (в каталоге multi-repo лежит куча git-репозиториев):

user@host:~/multi-repo$ git-first-last-commit-by-author dmitry

8f1d4ae         Dmitry        2022-08-16
83a8f89c        Dmitry        2023-02-15

Видно, что здесь порядок сортировки по датам — прямой. Мне так удобней, но всегда можно использовать ключ --reverse для sort внутри git-first-last-commit-by-author().

Хотя — теоретическим можно было бы помучиться с BigInteger и арифметикой… И посмотреть, какое время займёт поиск решения.

import java.util.Scanner;

public class Solution {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int t = in.nextInt();
        for (int a0 = 0; a0 < t; a0++) {
            long n = in.nextLong();
            String result = counterGame(n - 1);
            System.out.println(result);
        }
        in.close();
    }

    private static String counterGame(long n) {
        //long mask = 0x8000000000000000L; //2^63 in hex //W
        //eq:
        //long mask = -9223372036854775808L; //2^63 //W
        long mask;
        int step = 0;
        for (int i = 63; i >= 0; i--) {
            mask = 1L << i;
            //compare with 2 power i
            if ((n & mask) != 0) {
                //we max 2^i
                //step++;
                step = step ^ 1;
            }
            n -= mask;
            //mask >>>= 1;
        }

        return ((step & 1) != 0) ? "Louise" : "Richard";
    }

}

Традиционно — решение на Гитхабе.

https://www.hackerrank.com/challenges/counter-game/problem