Beispiel #1
0
 public ShuffleModel(CharMatrix matrix, WordDFA dfa)
 {
     _dfa        = dfa;
     MatrixWords = new List <MatrixWord>();
     Matrix      = matrix;
     FindAllWords();
 }
Beispiel #2
0
        public ShuffleModel GetNextModel(char[,] matrix)
        {
            _matrix = new CharMatrix(_words, matrix);
            var model = new ShuffleModel(_matrix, _dfa);

            return(model);
        }
Beispiel #3
0
 public CharMatrix(CharMatrix orig) : this(modshogunPINVOKE.new_CharMatrix__SWIG_5(CharMatrix.getCPtr(orig)), true)
 {
     if (modshogunPINVOKE.SWIGPendingException.Pending)
     {
         throw modshogunPINVOKE.SWIGPendingException.Retrieve();
     }
 }
        public void Test9()
        {
            var actual = CharMatrix.Create($"1{Environment.NewLine}2".Pastel(Color.Red), 0, 0, 1, 2);

            Assert.AreEqual(BeginRed + '1', actual[0, 0]);
            Assert.AreEqual(BeginRed + '2', actual[0, 1]);
        }
Beispiel #5
0
        public ShuffleModel GetNextModel()
        {
            _matrix = new CharMatrix(_size, _words, _longwords);
            var model = new ShuffleModel(_matrix, _dfa);

            return(model);
        }
Beispiel #6
0
        static void Main(string[] args)
        {
            Tile.Test();
            long part1 = 0;

            Tile[] tiledPicture = null;
            int    dim          = 0;

            Performance.TimeRun("Part1", () => (part1, tiledPicture, dim) = Part1("input.txt"), 5, 10, 5);
            Console.WriteLine($"Part 1: {part1}");

            int             part2 = 0;
            Matrix2D <char> chart = null;

            Performance.TimeRun("Part2", () => (part2, chart) = Part2(tiledPicture, dim), 2, 1000, 5);

            Console.WriteLine($"Part 2: {part2}");
            var colormap = CharMatrix.DefaultColorMap();

            colormap['*'] = ConsoleColor.White;
            colormap['.'] = ConsoleColor.DarkBlue;
            colormap['#'] = ConsoleColor.Blue;
            colormap['O'] = ConsoleColor.Green;
            chart.DumpColor(colormap);
        }
Beispiel #7
0
        public void Test7()
        {
            var cm1 = CharMatrix.Create($"####{Environment.NewLine}#  #{Environment.NewLine}####", 0, 0, 4, 3);
            var cm2 = CharMatrix.Create($"?".Pastel(Color.Green), 1, 1, 1, 1);
            var cms = new CharMatrixStack(2);

            cms.Add(cm1);
            cms.Add(cm2);
            Assert.AreEqual(cms.X, 0);
            Assert.AreEqual(cms.Y, 0);
            Assert.AreEqual(cms.W, 4);
            Assert.AreEqual(cms.H, 3);

            Assert.AreEqual(ColoredStringExt.End + '#', cms[0, 0]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[1, 0]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[2, 0]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[3, 0]);

            Assert.AreEqual(ColoredStringExt.End + '#', cms[0, 1]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginGreen + '?', cms[1, 1]);
            Assert.AreEqual(ColoredStringExt.End + ' ', cms[2, 1]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[3, 1]);

            Assert.AreEqual(ColoredStringExt.End + '#', cms[0, 2]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[1, 2]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[2, 2]);
            Assert.AreEqual(ColoredStringExt.End + '#', cms[3, 2]);
        }
Beispiel #8
0
        public static void MyMain(string[] args)
        {
            var grille = new CharMatrix();

            grille.SetSize(8, 8);
            grille.ReadValues();
            var points = new Dictionary <char, int>();

            points.Add('J', 0);
            points.Add('R', 0);
            for (var dir = 0; dir < 2; dir++)
            {
                for (var y = 0; y < 8; y++)
                {
                    var  x        = 0;
                    char color    = '0';
                    var  longueur = 0;
                    while (x < 8)
                    {
                        var next = dir == 0 ? grille.Get(x, y) : grille.Get(y, x);
                        if (next == color)
                        {
                            longueur++;
                        }
                        else
                        {
                            if (longueur >= 4)
                            {
                                points[color] += longueur - 3;
                            }
                            longueur = 1;
                            color    = next;
                        }

                        x++;
                    }
                    if (longueur >= 4)
                    {
                        points[color] += longueur - 3;
                    }
                }
            }


            if (points['R'] > points['J'])
            {
                Console.WriteLine("R");
            }
            else if (points['R'] < points['J'])
            {
                Console.WriteLine("J");
            }
            else
            {
                Console.WriteLine("NOBODY");
            }
        }
Beispiel #9
0
        private void FindAllWords()
        {
            var allCoordinates = CharMatrix.GetAllCoordinates(Matrix.Size);

            foreach (var coord in allCoordinates)
            {
                FindWords(coord);
            }
        }
Beispiel #10
0
        private static bool TryParseMessage(Point[] points, out string message)
        {
            // Don't "parse" as such, but just do a crude check for well-known
            // message patterns.
            var(minx, maxx)    = (points.Min(p => p.X), points.Max(p => p.X));
            var(miny, maxy)    = (points.Min(p => p.Y), points.Max(p => p.Y));
            var(width, height) = (maxx - minx + 1, maxy - miny + 1);
            var map = CharMatrix.Create(width, height, ' ');

            foreach (var p in points)
            {
                map[p.X - minx, p.Y - miny] = '#';
            }
            //map.ConsoleWrite();
            var parseable = new Dictionary <string, char[, ]>
            {
                {
                    "HI",
                    new string[]
                    {
                        "#   #  ###",
                        "#   #   # ",
                        "#   #   # ",
                        "#####   # ",
                        "#   #   # ",
                        "#   #   # ",
                        "#   #   # ",
                        "#   #  ###",
                    }.ToCharMatrix()
                },
                {
                    "PHLGRNFK",
                    new string[]
                    {
                        "#####   #    #  #        ####   #####   #    #  ######  #    #",
                        "#    #  #    #  #       #    #  #    #  ##   #  #       #   # ",
                        "#    #  #    #  #       #       #    #  ##   #  #       #  #  ",
                        "#    #  #    #  #       #       #    #  # #  #  #       # #   ",
                        "#####   ######  #       #       #####   # #  #  #####   ##    ",
                        "#       #    #  #       #  ###  #  #    #  # #  #       ##    ",
                        "#       #    #  #       #    #  #   #   #  # #  #       # #   ",
                        "#       #    #  #       #    #  #   #   #   ##  #       #  #  ",
                        "#       #    #  #       #   ##  #    #  #   ##  #       #   # ",
                        "#       #    #  ######   ### #  #    #  #    #  #       #    #"
                    }.ToCharMatrix()
                }
            };

            message = parseable
                      .Where(p => map.Match(p.Value))
                      .Select(x => x.Key)
                      .FirstOrDefault();
            return(message != null);
        }
        public void Test11()
        {
            var cm = CharMatrix.Create("!", 1, 1, 1, 1);

            Assert.AreEqual(cm.X, 1);
            Assert.AreEqual(cm.Y, 1);
            Assert.AreEqual(cm.W, 1);
            Assert.AreEqual(cm.H, 1);

            Assert.AreEqual(End + '!', cm[1, 1]);
        }
        public void Test2()
        {
            var cm = CharMatrix.Create("!", 0, 0, 2, 1);

            Assert.AreEqual(cm.X, 0);
            Assert.AreEqual(cm.Y, 0);
            Assert.AreEqual(cm.W, 2);
            Assert.AreEqual(cm.H, 1);

            Assert.AreEqual(End + '!', cm[0, 0]);
            Assert.AreEqual(End + ' ', cm[1, 0]);
        }
Beispiel #13
0
        public Matrix2D <char> GetTransformedMatrix()
        {
            bool rotate, hflip, vflip;

            (rotate, hflip, vflip) = DecodeTransform(CurrentOrientation);
            List <string> lines = new List <string>();

            for (int y = 0; y < (rotate ? Width : Height); y++)
            {
                lines.Add(new string(GetTransformedLine(y, true)));
            }
            return(CharMatrix.Build(lines));
        }
Beispiel #14
0
        public void Test1()
        {
            var cm  = CharMatrix.Create("!", 0, 0, 1, 1);
            var cms = new CharMatrixStack(1);

            cms.Add(cm);
            Assert.AreEqual(cms.X, 0);
            Assert.AreEqual(cms.Y, 0);
            Assert.AreEqual(cms.W, 1);
            Assert.AreEqual(cms.H, 1);

            Assert.AreEqual(ColoredStringExt.End + '!', cms[0, 0]);
        }
Beispiel #15
0
 static void Cipher()
 {
     CipherText = new StringBuilder();
     foreach (var next in CipherOrder)
     {
         int n = int.Parse(next);
         n--;
         for (int i = 0; i < CharMatrix.GetLength(0); i++)
         {
             CipherText.Append(CharMatrix[i, n]);
         }
     }
 }
        public void Test4()
        {
            var cm = CharMatrix.Create("!".Pastel(Color.Red), 0, 0, 2, 2);

            Assert.AreEqual(cm.X, 0);
            Assert.AreEqual(cm.Y, 0);
            Assert.AreEqual(cm.W, 2);
            Assert.AreEqual(cm.H, 2);

            Assert.AreEqual(BeginRed + '!', cm[0, 0]);
            Assert.AreEqual(End + ' ', cm[1, 0]);
            Assert.AreEqual(End + ' ', cm[0, 1]);
            Assert.AreEqual(End + ' ', cm[1, 1]);
        }
        private void CanvasControlOnDraw(CanvasControl sender, CanvasDrawEventArgs args)
        {
            for (var y = 0; y < CharMatrix.GetUpperBound(1); y++)
            {
                var finalY = (float)(y * CharHeight);

                for (var x = 0; x < CharMatrix.GetUpperBound(0); x++)
                {
                    var text = new String(CharMatrix[x, y], 1);
                    var position = new Vector2((float)(x * CharWidth), finalY);
                    args.DrawingSession.DrawText(text, position, TextColor);
                }
            }
        }
        public void Test5()
        {
            var cm = CharMatrix.Create($"12{Environment.NewLine}34".Pastel(Color.Red), 0, 0, 2, 2);

            Assert.AreEqual(cm.X, 0);
            Assert.AreEqual(cm.Y, 0);
            Assert.AreEqual(cm.W, 2);
            Assert.AreEqual(cm.H, 2);

            Assert.AreEqual(BeginRed + '1', cm[0, 0]);
            Assert.AreEqual(BeginRed + '2', cm[1, 0]);
            Assert.AreEqual(BeginRed + '3', cm[0, 1]);
            Assert.AreEqual(BeginRed + '4', cm[1, 1]);
        }
Beispiel #19
0
        public void Test3()
        {
            var cm1 = CharMatrix.Create("\0!", 0, 0, 2, 1);
            var cm2 = CharMatrix.Create("?\0", 0, 0, 2, 1);
            var cms = new CharMatrixStack(2);

            cms.Add(cm1);
            cms.Add(cm2);
            Assert.AreEqual(cms.X, 0);
            Assert.AreEqual(cms.Y, 0);
            Assert.AreEqual(cms.W, 2);
            Assert.AreEqual(cms.H, 1);

            Assert.AreEqual(ColoredStringExt.End + '?', cms[0, 0]);
            Assert.AreEqual(ColoredStringExt.End + '!', cms[1, 0]);
        }
        public void Test6()
        {
            var cm = CharMatrix.Create("0" + $"12{Environment.NewLine}34".Pastel(Color.Red) + "0", 0, 0, 3, 2);

            Assert.AreEqual(cm.X, 0);
            Assert.AreEqual(cm.Y, 0);
            Assert.AreEqual(cm.W, 3);
            Assert.AreEqual(cm.H, 2);

            Assert.AreEqual(End + '0', cm[0, 0]);
            Assert.AreEqual(BeginRed + '1', cm[1, 0]);
            Assert.AreEqual(BeginRed + '2', cm[2, 0]);
            Assert.AreEqual(BeginRed + '3', cm[0, 1]);
            Assert.AreEqual(BeginRed + '4', cm[1, 1]);
            Assert.AreEqual(End + '0', cm[2, 1]);
        }
Beispiel #21
0
        public void Test5()
        {
            var cm1 = CharMatrix.Create("!!!".Pastel(Color.Red), 0, 0, 3, 1);
            var cm2 = CharMatrix.Create("\0?\0".Pastel(Color.Green), 0, 0, 3, 1);
            var cms = new CharMatrixStack(2);

            cms.Add(cm1);
            cms.Add(cm2);
            Assert.AreEqual(cms.X, 0);
            Assert.AreEqual(cms.Y, 0);
            Assert.AreEqual(cms.W, 3);
            Assert.AreEqual(cms.H, 1);

            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[0, 0]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginGreen + '?', cms[1, 0]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[2, 0]);
        }
Beispiel #22
0
        static void Main(string[] args)
        {
            int count1 = 0;
            int iter1  = 0;
            int count2 = 0;
            int iter2  = 0;

            Performance.TimeRun("part1 + 2 (with IO)", () =>
            {
                var input       = TextFile.ReadStringList("input.txt");
                var matrix      = CharMatrix.Build(input);
                var original    = matrix.Clone();
                (count1, iter1) = SimulateWithAdjecency(matrix);
                (count2, iter2) = SimulateWithAdjecency(original, adjacencyFunc: FindClosestSeats, crowdedThreshold: 5);
            }, 10, 10);
            Console.WriteLine($"Part1: {count1} seats end up occupied ({iter1} iterations)");
            Console.WriteLine($"Part2: {count2} seats end up occupied ({iter2} iterations)");
        }
Beispiel #23
0
        static void Main(string[] args)
        {
            Console.WriteLine("podaj sciezke do pliku, ktory ma zostac zaszyfrowany");
            var path = Console.ReadLine();

            using (StreamReader sr = new StreamReader(path))
            {
                PlainText = sr.ReadToEnd();
            }


            Console.WriteLine("podaj ilosc kolumn macierzy");
            int columns = int.Parse(Console.ReadLine());

            CreateCharMatrix(columns);

            bool correctOrder;

            do
            {
                Console.WriteLine("podaj kolejnosc kolumn, numery kolumn powinny oddzielone '-', np. 3-1-2");
                SetColumnOrder(Console.ReadLine());
                correctOrder = CipherOrder.Length != CharMatrix.GetLength(1);
                if (correctOrder)
                {
                    Console.WriteLine("ilosc kolumn podana w kolejnosci nie zgadza sie z rozmiarem macierzy");
                }
            } while (correctOrder);

            Cipher();
            Console.WriteLine(CipherText);

            Console.WriteLine("czy zapisac szyfr do pliku? (y/n)");
            var write = Console.ReadLine();

            if (write == "y")
            {
                System.IO.StreamWriter file = new System.IO.StreamWriter(path, true);
                file.WriteLine(Environment.NewLine + "wiadomosc zaszyfrowana: " + Environment.NewLine + CipherText);

                file.Close();
            }
        }
Beispiel #24
0
        static (int, Matrix2D <char>) Part2(Tile[] tiledPicture, int dim)
        {
            var chart = CombineTiles(tiledPicture, dim);

            var seaMonsterLines = new List <string>()
            {
                "                  # ",
                "#    ##    ##    ###",
                " #  #  #  #  #  #   ",
            };
            var seaMonster = CharMatrix.Build(seaMonsterLines);

            bool            found            = false;
            Matrix2D <char> transformedChart = null;

            for (int orientation = 0; orientation < 8; orientation++)
            {
                chart.CurrentOrientation = orientation;
                transformedChart         = chart.GetTransformedMatrix();

                for (int y = 0; y < transformedChart.Height - seaMonster.Height; y++)
                {
                    for (int x = 0; x < transformedChart.Width - seaMonster.Width; x++)
                    {
                        if (HasAllPixels(transformedChart, seaMonster, x, y))
                        {
                            found = true;
                            StampValue(transformedChart, seaMonster, x, y, 'O');
                        }
                    }
                }
                if (found)
                {
                    break;
                }
            }

            if (!found)
            {
                throw new ArgumentException("No sea monsters in image!");
            }
            return(transformedChart.Array.Count(c => c == '#'), transformedChart);
        }
Beispiel #25
0
        public void Test6()
        {
            var cm1 = CharMatrix.Create($"!!!{Environment.NewLine}!!!".Pastel(Color.Red), 0, 0, 3, 2);
            var cm2 = CharMatrix.Create($"\0?\0{Environment.NewLine}\0?\0".Pastel(Color.Green), 0, 0, 3, 2);
            var cms = new CharMatrixStack(2);

            cms.Add(cm1);
            cms.Add(cm2);
            Assert.AreEqual(cms.X, 0);
            Assert.AreEqual(cms.Y, 0);
            Assert.AreEqual(cms.W, 3);
            Assert.AreEqual(cms.H, 2);

            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[0, 0]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginGreen + '?', cms[1, 0]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[2, 0]);

            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[0, 1]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginGreen + '?', cms[1, 1]);
            Assert.AreEqual(EnumerateWithColorInfoTests.BeginRed + '!', cms[2, 1]);
        }
Beispiel #26
0
 public Tile(int tileNo, List <string> lines, bool calculateEdges = true)
 {
     TileNo = tileNo;
     matrix = CharMatrix.Build(lines);
     Width  = matrix.Width;
     Height = matrix.Height;
     if (calculateEdges)
     {
         //cache edges for all orientations:
         for (int i = 0; i < 8; i++)
         {
             bool rotate, hflip, vflip;
             (rotate, hflip, vflip) = DecodeTransform(i);
             int[] edges = new int[4];
             for (int e = 0; e < 4; e++)
             {
                 Edge edge = (Edge)e;
                 edges[e] = ToInt(GetTransformedEdge(edge, rotate, hflip, vflip));
             }
             orientedEdges[i] = edges;
         }
     }
 }
Beispiel #27
0
        private static char[,] ReadScreen(string[] input)
        {
            var screen = CharMatrix.Create(Width, Height, ' ');

            foreach (var line in input)
            {
                // rect 49x1
                // rotate row y=2 by 34
                // rotate column x=44 by 1
                if (line.IsRxMatch("rect %dx%d", out var captures))
                {
                    var(w, h) = captures.Get <int, int>();
                    for (var x = 0; x < w; x++)
                    {
                        for (var y = 0; y < h; y++)
                        {
                            screen[x, y] = '#';
                        }
                    }
                }
                else if (line.IsRxMatch("rotate row y=%d by %d", out captures))
                {
                    var(row, dx) = captures.Get <int, int>();
                    screen.ShiftRowRight(row, dx);
                }
                else if (line.IsRxMatch("rotate column x=%d by %d", out captures))
                {
                    var(col, dy) = captures.Get <int, int>();
                    screen.ShiftColDown(col, dy);
                }
                else
                {
                    throw new Exception($"Unhandled line '{line}'");
                }
            }
            return(screen);
        }
Beispiel #28
0
 public CharMatrix(CharMatrix orig) : this(modshogunPINVOKE.new_CharMatrix__SWIG_5(CharMatrix.getCPtr(orig)), true) {
   if (modshogunPINVOKE.SWIGPendingException.Pending) throw modshogunPINVOKE.SWIGPendingException.Retrieve();
 }
Beispiel #29
0
 internal static HandleRef getCPtr(CharMatrix obj)
 {
     return((obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr);
 }
 protected internal override ICharMatrix GetCharMatrix(string value)
 {
     return(CharMatrix.Create(Value.Trim(), GetX(), GetY(), GetWidth(), GetHeight()));
 }
Beispiel #31
0
 internal static HandleRef getCPtr(CharMatrix obj) {
   return (obj == null) ? new HandleRef(null, IntPtr.Zero) : obj.swigCPtr;
 }
 public void Test8()
 {
     var actual = CharMatrix.Create("!".Pastel(Color.Red), 0, 0, 2, 1);
     Assert.AreEqual(BeginRed + '!', actual[0, 0]);
     Assert.AreEqual(End + ' ', actual[1, 0]);
 }