using System;

using System.Linq;

using System.Text.RegularExpressions;

public static class Program

{

    /*

        You will have an orthogonal triangle input from a file and you need to find the maximum sum of the numbers according to given rules below;

​

        1. You will start from the top and move downwards to an adjacent number as in below.

        2. You are only allowed to walk downwards and diagonally.

        3. You can only walk over NON PRIME NUMBERS.

        4. You have to reach at the end of the pyramid as much as possible.

        5. You have to treat your input as pyramid.

​

        According to above rules the maximum sum of the numbers from top to bottom in below example is 24.

​

              *1

             *8 4

            2 *6 9

           8 5 *9 3

​

        As you can see this has several paths that fits the rule of NOT PRIME NUMBERS; 1>8>6>9, 1>4>6>9, 1>4>9>9

        1 + 8 + 6 + 9 = 24.  As you see 1, 8, 6, 9 are all NOT PRIME NUMBERS and walking over these yields the maximum sum.

    */

​

    public static void Main()

    {

        DisplayResult();

    }

​

    private static void DisplayResult()

    {

        var randInput = GetInput();

        var convertedInput = ConvertDimension(randInput);

        var freeArray = ReplaceNumbers(convertedInput);

        var finaleSum = TraversingArrayForMaximum(freeArray);

        Console.WriteLine("Pyramid Input :\n");

        PrintPyramid(randInput);

        Console.WriteLine($"\nMaximum Sum of Random Input :  {finaleSum}");

    }

    private static string[] GetInput()

    {

        var inputTr = new string[55]; 

​

        Random randNum = new Random((int)DateTime.Now.Ticks);

        for (int i = 0; i < inputTr.Length; i++)

        {

            inputTr[i] = randNum.Next(0, 100).ToString();

        }

        return inputTr;

    }

    private static int[,] ConvertDimension(string[] splittedStringArray)

    {

        var twoDimensionalArray = new int[splittedStringArray.Length, splittedStringArray.Length + 1];

        var rowIndex=0;

        foreach (var row in splittedStringArray)

        {

            var integerArray = row.ConvertStringToIntegerArray();

             var columnIndex=0;

            foreach (var integer in integerArray)

            {

                twoDimensionalArray[rowIndex, columnIndex] = integer;

                columnIndex++;

            }

            rowIndex++;

        }

        return twoDimensionalArray;

    }

​

    private static int[] ConvertStringToIntegerArray(this string rows)

    {

        return

            Regex

                .Matches(rows, "[0-9]+")

                .Cast<Match>()

                .Select(m => int.Parse(m.Value)).ToArray();

    }

​

    private static int[,] ReplaceNumbers(int[,] twoDimensionalArray)

    {

        var length = twoDimensionalArray.GetLength(0);

        for (var i = 0; i < length; i++)

        {

            for (var j = 0; j < length; j++)

            {

                if (twoDimensionalArray[i, j] == 0) continue;

                if (IsPrime(twoDimensionalArray[i, j]))

                    twoDimensionalArray[i, j] = 0;

            }

        }

        return twoDimensionalArray;

    }

​

    private static int TraversingArrayForMaximum(int[,] twoDimensionalArray)

    {

        var data = twoDimensionalArray;

        var length = twoDimensionalArray.GetLength(0);

​

         for (var i = length - 2; i >= 0; i--)

        {

            for (var j = 0; j < length; j++)

            {

                var c = data[i, j];

                var a = data[i + 1, j];

                var b = data[i + 1, j + 1];

                if ((!IsPrime(c) && !IsPrime(a)) || (!IsPrime(c) && !IsPrime(b)))

                    twoDimensionalArray[i, j] = c + Math.Max(a, b);

            }

        }

        return twoDimensionalArray[0, 0];

    }

​

      public static bool IsPrime(int number)

    {    if(number==0 || number==1) return false;

        return  Enumerable.Range(2, (int)Math.Sqrt(number) - 1).

                All(divisor => number % divisor != 0);

    }

    public static void PrintPyramid(String[] numbers)

    {

        int n = numbers.Length;

        int idx = 0;

        int numRows = 0;

​

        while(idx < n){

            numRows++; 

            for(int numInRow=0; numInRow<numRows; numInRow++){

                idx++;

            }

        }

        idx = 0;

        for(int i=1; i <= numRows && idx < n; i++){

            for(int j=0; j < (numRows-i) ; j++){

                Console.Write(" ");

            }

​

            for(int j=0; j<i; j++){

                Console.Write(numbers[idx++] +" ");

                if(idx >= n){

                    break;

                }

            }

            Console.WriteLine();

        }

    }

}