Question

所以，我有一个像这样的二维数组：

double[,] tabel_nilai = new double[,]{{3500, 70, 10, 80, 3000, 36},
                                      {4500, 90, 10, 60, 2500, 48 },
                                      {4000, 80, 9, 90, 2000, 48 },
                                      {4000, 70, 8, 50, 1500, 60 }};

然后，我想在第一列（3500,4500,4000和4000）上形成一个具有最大值的一维数组。但是，另一列的最小值。

我这样做了：

double[] pembagi = new double[kepentingan.Length];
for (int i = 0; i < produk.Length; i++)
{
    for(int j=0; j < kriteria.Length; i++)
    {
        pembagi[i] = Math.Max(tabel_nilai[i,j],tabel_nilai[i,j]);

        Console.WriteLine(pembagi);
    }
}

但是，悲惨地失败了。

如果有人能给我一些关于如何解决这个问题的逻辑，我会很高兴的。感谢

Answer 1

首先，您可以使用jagged arrays获取＆＃34;切片＆＃34;或行。

然后使用delegate您可以根据要求应用功能，例如：

delegate double maxMin(IEnumerable<double> arr);
public static void GetData()
{
            double[][] tableData = new double[][]{
                                    new double[] {3500, 70, 10, 80, 3000, 36},
                                    new double[] {4500, 90, 10, 60, 2500, 48 },
                                    new double[] {4000, 80, 9, 90, 2000, 48 },
                                    new double[] {4000, 70, 8, 50, 1500, 60 }
                                  };

            int length = tableData.Length;
            double[] requiredValues = new double[length];

            maxMin maxMinObj;
            for (int i = 0; i < length; i++)
            {
                if (i == 0)
                    maxMinObj = x => x.Max();
                else
                    maxMinObj = x => x.Min();

                requiredValues[i] = maxMinObj(tableData[i]);

                Console.WriteLine(requiredValues[i]);
            }
}

Answer 2

在这种情况下，您可以使用LINQ，它可以提供最短和最简单的代码来解决这个问题，而无需明确使用任何嵌套循环。

double[,] tabel_nilai = new double[,]{   {3500, 70, 10, 80, 3000, 36},
                                         {4500, 90, 10, 60, 2500, 48 },
                                         {4000, 80, 9, 90, 2000, 48 },
                                         {4000, 70, 8, 50, 1500, 60 }};

 double[] oneDimensionalArray = tabel_nilai.Cast<double>().Select((x, i) => new { x, index = i / tabel_nilai.GetLength(1) })  
                                        .GroupBy(x=>x.index)                                   
                                        .Select(x=>x.Select(s=>s.x).ToList().Max())                  
                                        .ToArray();

它的作用是将2D数组转换为列表，然后按行分组，最后计算该行的最大值。您也可以使用它来获取Min，只需将Max()替换为Min()即可。此外，如果您需要使用相同的表达式，它可以帮助您执行许多其他措施。

我希望它有所帮助。

Answer 3

假设每列交替的最大/最小值是对代码的更正。您的代码有多个问题，因此我只是发布代码并进行所有更正：

using System;

public class Program
{
    public static void Main()
    {
        double[,] tabel_nilai = new double[,]{   {3500, 70, 10, 80, 3000, 36},
                                                    {4500, 90, 10, 60, 2500, 48 },
                                                    {4000, 80, 9, 90, 2000, 48 },
                                                    {4000, 70, 8, 50, 1500, 60 }};  

        for (int j = tabel_nilai.GetLowerBound(1); j <= tabel_nilai.GetUpperBound(1); j++)
        {
            var seekingMax = ((j - tabel_nilai.GetLowerBound(1)) % 2) == 0;
            var maxmin = tabel_nilai[0, j];

            for(int i = tabel_nilai.GetLowerBound(0) + 1; i <= tabel_nilai.GetUpperBound(0); i++)
            {
                if (seekingMax)
                {
                    maxmin = Math.Max(maxmin,tabel_nilai[i, j]);
                }
                else
                {
                    maxmin = Math.Min(maxmin,tabel_nilai[i, j]);
                }
            }

            Console.WriteLine("{0}: {1}", seekingMax ? "Max" : "Min", maxmin);
        }
    }
}

从二维数组的一部分的最大值形成数组

3 个答案: