Advent of Code 2022: no pato edition

#include <iostream>
#include <algorithm>
#include <vector>
#include <sstream>

int main(int argc, char **argv) {
  int part = std::stoi(argv[1]);
  std::string s;
  std::vector< std::vector< char > > buckets;
  int num_buckets = 0;
  while(std::getline(std::cin, s) && s[1] != '1') {
    if (num_buckets == 0) {
      num_buckets = int(s.size() + 1) / 4;
      buckets = std::vector< std::vector< char > >(num_buckets, std::vector< char >());
    }
    for (int i = 0; i < num_buckets; ++i) {
      if (s[4 * i + 1] != ' ') {
        buckets[i].push_back(s[4 * i + 1]);
      }
    }
  }

  for(auto& bucket: buckets) {
    std::reverse(bucket.begin(), bucket.end());
  }

  std::getline(std::cin, s);

  while (std::getline(std::cin, s)) {
    std::string _;
    int k, from, to;
    std::istringstream iss(s);
    iss >> _ >> k >> _ >> from >> _ >> to;
    --from, --to;
    for (int i = 0; i < k; ++i) {
      buckets[to].push_back(buckets[from].back());
      buckets[from].pop_back();
    }
    if (part == 2) {
      std::reverse(buckets[to].end() - k, buckets[to].end());
    }
  }

  for(auto v: buckets) {
    std::cout << v.back();
  }

  std::cout << std::endl;
}

Es una opción, otra es ver la entrada como una matriz con elementos separados por espacios. Un elemento puede ser tres espacios o algo de la forma [z] con z = una letra en mayúscula. Si te fijas los strings tienen todos la misma longitud, con espacios a la derecha.

Eso significa que las letras están en la posición 1, 5, 9, etc, o dicho de otra forma, en la posición 4 * k + 1, con k = indice del elemento empezando por 0

public static async Task<string> GetPart2()
        {
            string[] input = await File.ReadAllLinesAsync("day5/input");

        const int CRATE_COUNT = 9;
        Stack<string>[] crates = new Stack<string>[CRATE_COUNT];
        for (int i = 0; i < CRATE_COUNT; i++)
            crates[i] = new Stack<string>();

        var pendingCrates = new Stack<string>();
        foreach (string line in input)
        {
            if (line.StartsWith('['))
                pendingCrates.Push(line);

            if (string.IsNullOrWhiteSpace(line))
            {
                foreach (var crateLine in pendingCrates)
                {
                    for (int i = 0; i < CRATE_COUNT; i++)
                    {
                        int charIndex = i * 4 + 1;
                        string crate = crateLine.Substring(charIndex, 1);
                        if (!string.IsNullOrWhiteSpace(crate))
                            crates[i].Push(crate);
                    }
                }
            }

            if (line.StartsWith("move"))
            {
                var numbers = line.Split(' ');
                var quantity = int.Parse(numbers[1].Trim());
                var from = int.Parse(numbers[3].Trim());
                var to = int.Parse(numbers[5].Trim());

                if (quantity == 1)
                {
                    string item = crates[from - 1].Pop();
                    crates[to - 1].Push(item);
                }
                else
                {
                    var group = new Stack<string>();
                    for (int i = 0; i < quantity; i++)
                    {
                        string item = crates[from - 1].Pop();
                        group.Push(item);
                    }

                    for (int i = 0; i < quantity; i++)
                        crates[to - 1].Push(group.Pop());
                }
            }

        }

        var solution = new StringBuilder();
        for (int i = 0; i < CRATE_COUNT; i++)
            solution.Append(crates[i].Pop());

        return solution.ToString();
    }

const fs = require("fs");
const path = require("path");

let cargo;

const splitLine = (line) => {
  return line.length
    ? [line.slice(0, 3).trim(), ...splitLine(line.substring(4, line.length))]
    : [];
};

const getResult = (model) => {
  fs.readFileSync(path.resolve(__dirname, "input.txt"), "utf8")
    .split("\n")
    .forEach((line, index) => {
      if (line.match(/\[\w\]/)) {
        const parsedLine = splitLine(line);
        if (index === 0) {
          cargo = new Array(parsedLine.length).fill([]);
        }
        parsedLine.forEach((crate, crateIndex) => {
          if (crate) {
            cargo[crateIndex] = [crate, ...cargo[crateIndex]];
          }
        });
      }
      const result = line.match(/move (\d+) from (\d+) to (\d+)/);
      if (result) {
        const [_, n, from, to] = result;
        const movedFrom = cargo[from - 1].splice(cargo[from - 1].length - n, n);
        const craneModels = {
          CM9000: () => movedFrom.reverse(),
          CM9001: () => movedFrom,
        };
        cargo[to - 1] = [...cargo[to - 1], ...craneModels[model]()];
      }
    });

  return cargo.reduce((acc, crate) => {
    if (crate[crate.length - 1]) {
      acc += crate[crate.length - 1].substring(1, 2);
    }
    return acc;
  }, "");
};

console.log(getResult("CM9000"), getResult("CM9001"));

Cambiad 4 por 14 y ya tenéis el problema 2 también

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

const getStartMarkerIndex = (datastream, markerLength) => {
  for (let i = 0; i < datastream.length; i++) {
    const startMarkerCandidate = datastream.substring(i, i + markerLength);
    if (new Set(startMarkerCandidate).size === markerLength) {
      return i + markerLength;
    }
  }
};

const main = async () => {
  const datastream = await fs.readFile('input.txt', 'utf-8');
  console.log(getStartMarkerIndex(datastream, 4));
};

main();

int main() 
{   

    string input;
    int score = 0;
    list<char> marker;

cin >> input;
for (char& c:input){
    score+=1;
    marker.push_front(c);
    if (marker.size() == 4){
        unordered_set<char> distinct(marker.begin(), marker.end());
        if (distinct.size() == 4) break;
        marker.pop_back();
    }
}  
cout << score << endl;
}

árbol