AdventOfCode/2018_08/Program.cs

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

namespace _2018_08
{
    class Program
    {
        static void Main(string[] args)
        {
            bool own = false;
            int y = 0;
            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(' '); own = true;
            int[] numbers = new int[resTab.Length];
            for (int i = 0; i < resTab.Length; i++)
            {
                numbers[i] = int.Parse(resTab[i]);
            }
            if (own)
            {
                for (int z = 1; z < 25; z++)
                {
                    y += z;
                }
            }

            Write($"Antal värden = {resTab.Length}");
            if (own)
            {
                WriteLine($" svar = {y}");
            }
            else WriteLine();

            ReadKey();

            var pgm = new Program();

            int x = pgm.CalcMetaData(numbers);

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

         private int CalcMetaData(int[] nums)
        {
            int metaSum = 0;
            TreeNode tnStart = new TreeNode(nums, null);
            TreeNode tnTmp = tnStart;
            TreeNode tnAkt = tnStart;
            while (true)
            {
                tnAkt = new TreeNode(nums, tnTmp);
                tnTmp = tnAkt;
                if (tnAkt.LC.Level < 0)
                    break;
            }

            ReadKey();

            tnTmp = tnStart;
            while (tnTmp!=null)
            {
                tnTmp.PrepMetatab(tnTmp.NodeEnd);
                WriteLine(tnTmp.ToString());
                metaSum += tnTmp.MetaValueSum();
                tnTmp = tnTmp.Next;
            }

            ReadKey();

            return metaSum;
        }

    }

    public class TreeNode
    {
        public int ObjNr { get; set; }
        public int HeaderStart { get; set; }
        public int AntChilds { get; set; }
        public int ChildNo { get; set; }
        public int AntMetaEntries { get; set; }
        public int[] MetaTab { get; set; }
        public int NodeEnd { get; set; }
        public int[] NumberTab { get; set; }
        public TreeNode Previous { get; set; }
        public TreeNode Next { get; set; }
        public LevelCount LC { get; set; }
        static int nr;
        int treeNodeStart = 0;

        public TreeNode(int[] NumTab, TreeNode tnPrev)
        {
            TreeNode.nr++;
            ObjNr = TreeNode.nr;
            NumberTab = NumTab;
            LC = new LevelCount();
            Previous = tnPrev;
            if (Previous != null)
            {
                Previous.Next = this;
            }
            else
            {
                LC.Level = 0;
                treeNodeStart = 0;
            }
            Next = null;
            SetLevel();

            if (LC.Level > -1)
            {
                HeaderStart = treeNodeStart;
                AntChilds = NumberTab[HeaderStart];
                AntMetaEntries = NumberTab[HeaderStart + 1];
                NodeEnd = HeaderStart + 2 + AntMetaEntries;
                WriteLine(this.ToString());
            }

        }

        private void SetLevel()
        {
            TreeNode wrkTmp = this;

            if (Previous != null)
            {
                if (Previous.AntChilds > 0)
                {
                    LC.Level = Previous.LC.Level + 1;
                    LC.Nodes = Previous.AntChilds;
                    ChildNo = 1;
                    treeNodeStart = Previous.HeaderStart + 2;
                }
                else
                {
                    if (Previous.ChildNo < Previous.LC.Nodes)
                    {
                        LC.Level = Previous.LC.Level;
                        LC.Nodes = Previous.LC.Nodes;
                        ChildNo = Previous.ChildNo + 1;
                        treeNodeStart = Previous.NodeEnd;
                    }
                    else
                    {
                        LC.Level = Previous.LC.Level - 1;

                        if (FindStartOfObject(wrkTmp).ChildNo < FindStartOfObject(wrkTmp).LC.Nodes)
                        {
                            FindStartOfObject(wrkTmp).PrepMetatab(wrkTmp.Previous.NodeEnd + FindStartOfObject(wrkTmp).AntMetaEntries);
                            treeNodeStart = FindStartOfObject(wrkTmp).NodeEnd;
                            wrkTmp.ChildNo = FindStartOfObject(wrkTmp).ChildNo + 1;
                            wrkTmp.LC.Nodes = FindHeadOfStartOfObject(wrkTmp).AntChilds;
                        }
                        else
                        {
                            int chld = FindStartOfObject(wrkTmp).ChildNo;
                            int ndss = FindStartOfObject(wrkTmp).LC.Nodes;
                            treeNodeStart = wrkTmp.Previous.NodeEnd;

                            while (FindStartOfObject(wrkTmp).ChildNo == FindStartOfObject(wrkTmp).LC.Nodes && LC.Level > -1)
                            {

                                FindStartOfObject(wrkTmp).PrepMetatab(treeNodeStart + FindStartOfObject(wrkTmp).AntMetaEntries);
                                treeNodeStart = FindStartOfObject(wrkTmp).NodeEnd;

                                LC.Level = LC.Level - 1;

                                chld = FindStartOfObject(wrkTmp).ChildNo;
                                ndss = FindStartOfObject(wrkTmp).LC.Nodes;

                            }
                            if (LC.Level <= 0)
                            {
                                if (treeNodeStart >= NumberTab.Length)
                                {
                                    Previous.Next = null;
                                }
                                else
                                {
                                    LC.Level = 0;
                                }
                            }
                        }
                    }
                }
            }
        }

        private TreeNode FindStartOfObject(TreeNode xTree)
        {
            TreeNode jmfTmp = this;
            TreeNode srchTmp = Previous;

            if (xTree != null)
            {
                jmfTmp = xTree;
                srchTmp = xTree.Previous;
            }
            while (srchTmp.LC.Level > jmfTmp.LC.Level && srchTmp.Previous != null)
            {
                srchTmp = srchTmp.Previous;
            }
            return srchTmp;
        }

        private TreeNode FindHeadOfStartOfObject(TreeNode xTree)
        {
            TreeNode jmfTmp = this;
            TreeNode srchTmp = Previous;
            if (xTree != null)
            {
                jmfTmp = xTree;
                srchTmp = xTree.Previous;
            }

            while (srchTmp.LC.Level >= this.LC.Level && srchTmp.Previous != null)
            {
                srchTmp = srchTmp.Previous;
            }
            return srchTmp;
        }

        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];
            }
        }

        public int MetaValueSum()
        {
            int tmpMetas = 0;
            if (MetaTab != null)
            {
                for (int y = 0; y < AntMetaEntries; y++)
                {
                    tmpMetas += MetaTab[y];
                }
            }
            else tmpMetas = -1;
            return tmpMetas;
        }

        public override string ToString()
        {
            string retStr = $"Nr: {ObjNr}, Level: {LC.Level}, Child: {ChildNo} Start: {HeaderStart}, Subobj: {AntChilds}, Metafält: {AntMetaEntries}, Nodend: {NodeEnd}";
            if (MetaTab != null)
            {
                for (int x = 0; x < AntMetaEntries; x++)
                {
                    retStr += $" meta[{x}]: {MetaTab[x]}";
                }
            }
            return retStr;
        }

    }

    public class LevelCount
    {
        public int Level { get; set; }
        public int Nodes { get; set; }
        public LevelCount()
        {
            Level = 0;
            Nodes = 0;
        }
    }
}