C# Online Compiler | .NET Fiddle

<no name> by Anonymous

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

public class Program
{
	public static List<List<int>> ReadTriangleFromFile(string filePath)
	{
		var triangle = new List<List<int>>();
		using (var reader = new StreamReader(filePath))
		{
			string line;
			while ((line = reader.ReadLine()) != null)
			{
				triangle.Add(line.Split(' ').Select(int.Parse).ToList());
			}
		}

		return triangle;
	}

	static int[][] ReadPyramidFromFile(string filePath)
	{
		List<int[]> pyramidList = new List<int[]>();
		string[] lines = File.ReadAllLines(filePath);
		foreach (string line in lines)
		{
			string[] parts = line.Split(' ');
			int[] row = Array.ConvertAll(parts, int.Parse);
			pyramidList.Add(row);
		}

		int[][] pyramid = pyramidList.ToArray();
		return pyramid;
	}

	public static int MaxSumPathDP(List<List<int>> triangle)
	{
		int n = triangle.Count;
		int[, ] dp = new int[n, n];
		// Initialize the bottom row numbwers first
		for (int i = 0; i < n; i++)
		{
			dp[n - 1, i] = IsPrime(triangle[n - 1][i]) ? int.MinValue : triangle[n - 1][i];
		}

		// Fill the dp table from bottom to top
		for (int i = n - 2; i >= 0; i--)
		{
			for (int j = 0; j <= i; j++)
			{
				int down = IsPrime(triangle[i + 1][j]) ? int.MinValue : dp[i + 1, j];
				int diagRight = (j + 1 <= i + 1 && !IsPrime(triangle[i + 1][j + 1])) ? dp[i + 1, j + 1] : int.MinValue;
				int diagLeft = (j - 1 >= 0 && !IsPrime(triangle[i + 1][j - 1])) ? dp[i + 1, j - 1] : int.MinValue;
				dp[i, j] = triangle[i][j] + Math.Max(down, Math.Max(diagRight, diagLeft));
			}
		}

		return dp[0, 0];
	}

	static int FindMaxSum(int[][] pyramid, int row, int col)
	{
		if (row >= pyramid.Length || col < 0 || col >= pyramid[row].Length) // col might be lower than zero or higher than total number if the current number is on the edge
		{
			return 0;
		}

		int currentValue = pyramid[row][col];
		if (IsPrime(currentValue))
		{
			return int.MinValue; // I have to treat primes as invalid paths
		}

		int maxSum = currentValue + Math.Max(Math.Max(FindMaxSum(pyramid, row + 1, col - 1), // bottom-left number
 FindMaxSum(pyramid, row + 1, col)), // bottom number
 FindMaxSum(pyramid, row + 1, col + 1)); // bottom-right number
		return maxSum;
	}

	static bool IsPrime(int number)
	{
		if (number <= 1)
			return false;
		if (number == 2)
			return true;
		for (int i = 2; i <= Math.Sqrt(number); i++)
		{
			if (number % i == 0)
				return false;
		}

		return true;
	}

	public static void Main()
	{
		string filePath = "fileName.txt";
		int[][] triangle = ReadPyramidFromFile(filePath);
		List<List<int>> triangleDp = ReadTriangleFromFile(filePath);
		int maxSumDp = MaxSumPathDP(triangleDp);
		Console.WriteLine("Maximum sum of non-prime numbers with dynamic programming: " + maxSumDp);
		int maxSum = FindMaxSum(triangle, 0, 0);
		Console.WriteLine("Maximum sum of non-prime numbers with recursive(from file): " + maxSum);
		int[][] pyramid = new int[][]
		{
			new int[]
			{
				215
			},
			new int[]
			{
				193,
				124
			},
			new int[]
			{
				117,
				237,
				442
			},
			new int[]
			{
				218,
				935,
				347,
				235
			},
			new int[]
			{
				320,
				804,
				522,
				417,
				345
			},
			new int[]
			{
				229,
				601,
				723,
				835,
				133,
				124
			},
			new int[]
			{
				248,
				202,
				277,
				433,
				207,
				263,
				257
			},
			new int[]
			{
				359,
				464,
				504,
				528,
				516,
				716,
				871,
				182
			},
			new int[]
			{
				461,
				441,
				426,
				656,
				863,
				560,
				380,
				171,
				923
			},
			new int[]
			{
				381,
				348,
				573,
				533,
				447,
				632,
				387,
				176,
				975,
				449
			},
			new int[]
			{
				223,
				711,
				445,
				645,
				245,
				543,
				931,
				532,
				937,
				541,
				444
			},
			new int[]
			{
				330,
				131,
				333,
				928,
				377,
				733,
				17,
				778,
				839,
				168,
				197,
				197
			},
			new int[]
			{
				131,
				171,
				522,
				137,
				217,
				224,
				291,
				413,
				528,
				520,
				227,
				229,
				928
			},
			new int[]
			{
				223,
				626,
				34,
				683,
				839,
				53,
				627,
				310,
				713,
				999,
				629,
				817,
				410,
				121
			},
			new int[]
			{
				924,
				622,
				911,
				233,
				325,
				139,
				721,
				218,
				253,
				223,
				107,
				233,
				230,
				124,
				233
			}
		};
		int maxSumStatic = FindMaxSum(pyramid, 0, 0);
		Console.WriteLine("Maximum sum of non-prime numbers with recursive: " + maxSum);
	}
}

​x
 
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
​
public class Program
{
    public static List<List<int>> ReadTriangleFromFile(string filePath)
    {
        var triangle = new List<List<int>>();
        using (var reader = new StreamReader(filePath))
        {
            string line;
            while ((line = reader.ReadLine()) != null)
            {
                triangle.Add(line.Split(' ').Select(int.Parse).ToList());
            }
        }
​
        return triangle;
    }
​
    static int[][] ReadPyramidFromFile(string filePath)
    {
        List<int[]> pyramidList = new List<int[]>();
        string[] lines = File.ReadAllLines(filePath);
        foreach (string line in lines)
        {
            string[] parts = line.Split(' ');
            int[] row = Array.ConvertAll(parts, int.Parse);
            pyramidList.Add(row);
        }
​
        int[][] pyramid = pyramidList.ToArray();
        return pyramid;
    }
​
    public static int MaxSumPathDP(List<List<int>> triangle)
    {
        int n = triangle.Count;
        int[, ] dp = new int[n, n];
        // Initialize the bottom row numbwers first
        for (int i = 0; i < n; i++)
        {
            dp[n - 1, i] = IsPrime(triangle[n - 1][i]) ? int.MinValue : triangle[n - 1][i];
        }
​
        // Fill the dp table from bottom to top
        for (int i = n - 2; i >= 0; i--)
        {
            for (int j = 0; j <= i; j++)
            {
                int down = IsPrime(triangle[i + 1][j]) ? int.MinValue : dp[i + 1, j];
                int diagRight = (j + 1 <= i + 1 && !IsPrime(triangle[i + 1][j + 1])) ? dp[i + 1, j + 1] : int.MinValue;
                int diagLeft = (j - 1 >= 0 && !IsPrime(triangle[i + 1][j - 1])) ? dp[i + 1, j - 1] : int.MinValue;
                dp[i, j] = triangle[i][j] + Math.Max(down, Math.Max(diagRight, diagLeft));
            }
        }
​
        return dp[0, 0];
    }
​
    static int FindMaxSum(int[][] pyramid, int row, int col)
    {
        if (row >= pyramid.Length || col < 0 || col >= pyramid[row].Length) // col might be lower than zero or higher than total number if the current number is on the edge
        {
            return 0;
        }
​
        int currentValue = pyramid[row][col];
        if (IsPrime(currentValue))
        {
            return int.MinValue; // I have to treat primes as invalid paths
        }
​
        int maxSum = currentValue + Math.Max(Math.Max(FindMaxSum(pyramid, row + 1, col - 1), // bottom-left number
 FindMaxSum(pyramid, row + 1, col)), // bottom number
 FindMaxSum(pyramid, row + 1, col + 1)); // bottom-right number
        return maxSum;
    }
​
    static bool IsPrime(int number)
    {
        if (number <= 1)
            return false;
        if (number == 2)
            return true;
        for (int i = 2; i <= Math.Sqrt(number); i++)
        {
            if (number % i == 0)
                return false;
        }
​
        return true;
    }
​
    public static void Main()
    {
        string filePath = "fileName.txt";
        int[][] triangle = ReadPyramidFromFile(filePath);
        List<List<int>> triangleDp = ReadTriangleFromFile(filePath);
        int maxSumDp = MaxSumPathDP(triangleDp);
        Console.WriteLine("Maximum sum of non-prime numbers with dynamic programming: " + maxSumDp);
        int maxSum = FindMaxSum(triangle, 0, 0);
        Console.WriteLine("Maximum sum of non-prime numbers with recursive(from file): " + maxSum);
        int[][] pyramid = new int[][]
        {
            new int[]
            {
                215
            },
            new int[]
            {
                193,
                124
            },
            new int[]
            {
                117,
                237,
                442
            },
            new int[]
            {
                218,
                935,
                347,
                235
            },
            new int[]
            {
                320,
                804,
                522,
                417,
                345
            },
            new int[]
            {
                229,
                601,
                723,
                835,
                133,
                124
            },
            new int[]
            {
                248,
                202,
                277,
                433,
                207,
                263,
                257
            },
            new int[]
            {
                359,
                464,
                504,
                528,
                516,
                716,
                871,
                182
            },
            new int[]
            {
                461,
                441,
                426,
                656,
                863,
                560,
                380,
                171,
                923
            },
            new int[]
            {
                381,
                348,
                573,
                533,
                447,
                632,
                387,
                176,
                975,
                449
            },
            new int[]
            {
                223,
                711,
                445,
                645,
                245,
                543,
                931,
                532,
                937,
                541,
                444
            },
            new int[]
            {
                330,
                131,
                333,
                928,
                377,
                733,
                17,
                778,
                839,
                168,
                197,
                197
            },
            new int[]
            {
                131,
                171,
                522,
                137,
                217,
                224,
                291,
                413,
                528,
                520,
                227,
                229,
                928
            },
            new int[]
            {
                223,
                626,
                34,
                683,
                839,
                53,
                627,
                310,
                713,
                999,
                629,
                817,
                410,
                121
            },
            new int[]
            {
                924,
                622,
                911,
                233,
                325,
                139,
                721,
                218,
                253,
                223,
                107,
                233,
                230,
                124,
                233
            }
        };
        int maxSumStatic = FindMaxSum(pyramid, 0, 0);
        Console.WriteLine("Maximum sum of non-prime numbers with recursive: " + maxSum);
    }
}

Introduza o numero do mês:

Cached Result
Last Run:	7:37:18 am
Compile:	0.095s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code