Advent of Code 2023: ChatGPT-4 turbo edition

Me he puesto un poco analizar el tema de los patrones repetitivos y creo que he sacado algunas fórmulas matemáticas. Me las guardaré en mis notas de Obsidian por si en un futuro vuelven a salir patrones repetitivos.

Pero aún así, creo que una de las cosas que más cuesta en estos problemas es definir lo que define a un estado/snapshot (me encantó tu nomenclatura, es menos confuso lo de "snapshot") de tal manera que sea único, es realmente lo que hace de ello un puzzle.

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;

namespace day14
{
    class Program
    {
        

    const char Rock = 'O';
    const char CubeRock = '#';
    const char Empty = '.';

    static void Main(string[] args)
    {
        char[,] platform; //[row, column]

        using (var stream = new StreamReader("Input.txt"))
        {
            List<char[]> platformRows = new List<char[]>();

            while (!stream.EndOfStream)
            {
                var line = stream.ReadLine();
                platformRows.Add(line.ToArray());
            }

            platform = new char[platformRows.Count, platformRows[0].Length];
            for (int i = 0; i < platformRows.Count; i++)
            { 
                for (int j = 0; j < platformRows[i].Length; j++)
                {
                    platform[i,j] = platformRows[i][j];
                }
            }

            List<string> states = new List<string>();
            for (int i = 0; i < 1000000000; i++)
            {
                var weights = "";
                TiltY(platform, true);
                weights += CountWeight(platform);
                TiltX(platform, true);
                weights += CountWeight(platform);
                TiltY(platform, false);
                weights += CountWeight(platform);
                TiltX(platform, false);
                weights += CountWeight(platform);
                if(states.Contains(weights))
                {
                    var indexFirstRepetition = states.IndexOf(weights);
                    var iterationsToRepeat = i - indexFirstRepetition;
                    var pending = 1000000000 - i - 1;
                    var modulo = pending % iterationsToRepeat;
                    for (int j = 0; j < modulo; j++)
                    {
                        TiltY(platform, true);
                        TiltX(platform, true);
                        TiltY(platform, false);
                        TiltX(platform, false);
                    }
                    Console.WriteLine(CountWeight(platform));
                    break;
                }
                states.Add(weights);
            }
            Console.ReadKey();
        }

        void TiltY(char[,] p, bool north)
        {
            var yDownHill = north ? 0 : p.GetLength(1) -1;
            var yUpHill = north ? p.GetLength(1) : -1;
            var dir = north ? -1 : 1;
            for (int i = 0; i < p.GetLength(0); i++)
            {
                var line = new char[p.GetLength(0)];
                var emptySpaces = 0;
                for (int j = yDownHill; j != yUpHill; j+= -dir)
                {
                    line[j] = p[j, i];
                    switch (line[j])
                    {
                        case CubeRock:
                            {
                                emptySpaces = 0;
                                break;
                            }
                        case Empty:
                            {
                                emptySpaces += 1;
                                break;
                            }
                        case Rock:
                            {
                                if (emptySpaces != 0)
                                {
                                    line[j + emptySpaces * dir] = Rock;
                                    line[j] = Empty;
                                }
                                break;
                            }
                        default:
                            break;
                    }
                }
                for (int j = 0; j < line.Length; j++)
                {
                    p[j, i] = line[j];
                }
            }
        }

        void TiltX(char[,] p, bool west)
        {
            var start = west ? 0 : p.GetLength(0) -1;
            var end = west ? p.GetLength(0) : -1;
            var dir = west ? -1 : 1;

            for (int i = 0; i < p.GetLength(0); i++)
            {
                var line = new char[p.GetLength(1)];
                var emptySpaces = 0;
                for (int j = start; j != end; j += -dir)
                {
                    line[j] = p[i, j];
                    switch (line[j])
                    {
                        case CubeRock:
                            {
                                emptySpaces = 0;
                                break;
                            }
                        case Empty:
                            {
                                emptySpaces += dir;
                                break;
                            }
                        case Rock:
                            {
                                if (emptySpaces != 0)
                                {
                                    line[j - emptySpaces*-1] = Rock;
                                    line[j] = Empty;
                                }
                                break;
                            }
                        default:
                            break;
                    }
                }
                for (int j = 0; j < line.Length; j++)
                {
                    p[i, j] = line[j];
                }
            }
        }

        int CountWeight(char[,]p)
        {
            var sum = 0;
            for (int i = 0; i < p.GetLength(0); i++)
            {
                for (int j = 0; j < p.GetLength(1); j++)
                {
                    var rowWeight = p.GetLength(0) - i;
                    if (p[i,j].Equals(Rock))
                    {
                        sum += rowWeight;
                    }
                }
            }
            return sum;
        }
    }
}
}

Para la parte 2 he tirado de una lista enlazada doble y un mapa para buscar los nodos por label en la lista de forma directa, asi podia buscar de en O(1) y tambien borrar nodos intermedios en O(1), eso si, usando mas memoria. Estoy en Python y la lista enlazada doble me ha tocado hacerla a mi, no he visto que exista en la std

el peor caso es n^2, si el tablero estuviese hecho tal que todas las posiciones fuesen el peor caso (menos la parte 1), podria haber un problema. Pero el tablero es pequeño, ahi tienes razon