AdventOfCode/2018_08/Program.cs

using System.Collections.Generic;
using static System.Console;

namespace _2018_08
{
    class Program
    {
        static void Main(string[] args)
        {
            //string[] resTab = File.ReadAllText(@"..\..\..\Data\Adventofcode_181208\2018_08_data.txt").Split(' ');
            //string[] resTab = @"2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2 2 3 0 3 10 11 12 1 1 0 1 99 2 1 1 2".Split(' ');
            string[] resTab = @"2 3 2 1 2 3 1 1 0 2 1 2 3 0 3 4 5 6 7 8 9 0 4 10 11 12 13 14 2 2 0 3 15 16 17 0 2 18 19 20 21 22 23 24".Split(' ');
            int[] numbers = new int[resTab.Length];
            for (int i = 0; i < resTab.Length; i++)
            {
                numbers[i] = int.Parse(resTab[i]);
            }
            int y = 0;
            for(int z = 1; z < 25; z++)
            {
                y += z;
            }

            WriteLine($"Antal värden = {resTab.Length} svar = {y}");
            ReadKey();

            var pgm = new Program();
            int x = pgm.CalculateMetaData(numbers);

            WriteLine();
            WriteLine($"summa = {x}");
            ReadKey();
        }


        private int CalculateMetaData(int[] numbers)
        {
            int tempSum = 0;
            int omgStart = 0;
            LinkedList<TreeNode> llT = new LinkedList<TreeNode>();
            while (omgStart < numbers.Length)
            {
                TreeNode strtNode = new TreeNode(omgStart, numbers);
                llT.AddLast(strtNode);
                int headEnd = 0;
                int firstAnt = strtNode.AntChilds;

                TreeNode nxt = new TreeNode(strtNode.HeaderStart + 2, numbers);

                for (int i = 0; i < firstAnt; i++)
                {
                    headEnd = this.SubProc(nxt, numbers, llT);
                    if (i < firstAnt - 1)
                    {
                        nxt = new TreeNode(headEnd, numbers);
                        //llT.AddLast(nxt);
                    }
                }
                Write($"start: {strtNode.HeaderStart}, init. end: {strtNode.NodeEnd}, ant. Metas: {strtNode.AntMetaEntries}, ");
                strtNode.PrepMetatab(headEnd - strtNode.NodeEnd + strtNode.AntMetaEntries);
                WriteLine($" fakt. slut {strtNode.NodeEnd}");

                omgStart = strtNode.NodeEnd;

                for (int i = omgStart; i < omgStart + 5; i++)
                {
                    Write($"numbers[{i}]:{numbers[i]}, ");
                }
                WriteLine();
                Write(" ");
            }

            WriteLine();
            foreach (var ll in llT)
            {
                Write($"Obj Nr: {ll.ObjNr} ({ll.HeaderStart},{ll.NodeEnd});");
                foreach (int x in ll.MetaTab)
                {
                    Write($"{x}, ");
                    tempSum += x;
                }
                WriteLine();
            }

            return tempSum;
        }

        private int SubProc(TreeNode tn, int[] numbers, LinkedList<TreeNode> ll)
        {
            ll.AddLast(tn);
            int nEnd = 0;

            if (tn.AntChilds > 0)
            {
                var tnx = new TreeNode(tn.HeaderStart + 2, numbers);
                nEnd = SubProc(tnx, numbers, ll) - tnx.HeaderStart;
            }

            tn.PrepMetatab(nEnd);
            return tn.NodeEnd;
        }

    }

    public class TreeNode
    {
        public int ObjNr { get; set; }
        public int HeaderStart { get; set; }
        public int AntChilds { get; set; }
        public int AntMetaEntries { get; set; }
        public int[] MetaTab { get; set; }
        public int NodeEnd { get; set; }
        public int[] NumberTab { get; set; }

        static int nr;
        public TreeNode(int treeNodeStart, int[] NumTab)
        {
            TreeNode.nr++;
            ObjNr = TreeNode.nr;
            NumberTab = NumTab;
            HeaderStart = treeNodeStart;
            AntChilds = NumberTab[HeaderStart];
            AntMetaEntries = NumberTab[HeaderStart + 1];
            NodeEnd = HeaderStart + 2 + AntMetaEntries;
        }

        public void PrepMetatab(int subLen)
        {
            NodeEnd += subLen;
            MetaTab = new int[AntMetaEntries];
            for (int i = 0, j = NodeEnd - AntMetaEntries; j < NodeEnd; j++, i++)
            {
                MetaTab[i] = NumberTab[j];
            }
        }

    }
}