Question

我试图将此表中的数据转换为二维数组。 desc

这是我到目前为止的代码

int[,] distanceArray = new int[10, 10];
        int[] chicago = new int[] { 1004, 921, 1230, 272, 2716, 860, 1307, 2820, 2887 };
        int[] dallas = new int[] { 1753, 1780, 1899, 2570, 1858, 1494, 2734, 571 };
        int[] lasVegas = new int[] { 2752, 2048, 1343, 1732, 2523, 3447, 1099 };
        int[] losAngeles = new int[] { 3017, 1397, 517, 2251, 1278, 1057 };
        int[] miami = new int[] { 1520, 919, 1435, 1322, 2646 };
        int[] newOrleans = new int[] { 1507, 515, 2234, 2420 };
        int[] toronto = new int[] { 609, 2176, 1307 };
        int[] vancouver = new int[] { 3155, 709 };
        int washingtonDC = 448;

        int counter = 10;
        for (int i = 0; i < counter; i++)
        {
            for (int y = 0; y < counter; y++)
            {
                if (counter == 9)
                {
                    distanceArray[(y + 1), y] = chicago[y];
                    distanceArray[y, (y + 1)] = chicago[y];
                }
                if (counter == 8)
                {
                    distanceArray[(y + 2), y] = dallas[y];
                    distanceArray[y, (y + 2)] = dallas[y];
                }
                if (counter == 7)
                {
                    distanceArray[(y + 3), y] = lasVegas[y];
                    distanceArray[y, (y + 3)] = lasVegas[y];
                }
                if (counter == 6)
                {
                    distanceArray[(y + 4), y] = losAngeles[y];
                    distanceArray[y, (y + 4)] = losAngeles[y];
                }
                if (counter == 5)
                {
                    distanceArray[(y + 5), y] = miami[y];
                    distanceArray[y, (y + 5)] = miami[y];
                }
                if (counter == 4)
                {
                    distanceArray[(y + 6), y] = newOrleans[y];
                    distanceArray[y, (y + 6)] = newOrleans[y];
                }
                if (counter == 3)
                {
                    distanceArray[(y + 7), y] = toronto[y];
                    distanceArray[y, (y + 7)] = toronto[y];
                }
                if (counter == 2)
                {
                    distanceArray[(y + 8), y] = vancouver[y];
                    distanceArray[y, (y + 8)] = vancouver[y];
                }
                if (counter == 1)
                {
                    distanceArray[(y + 9), y] = washingtonDC;
                    distanceArray[y, (y + 9)] = washingtonDC;
                }

            }

            counter--;
        }


        for (int i = 0; i < 10; i++)
        {
            for (int y = 0; y < 10; y++)
            {
                Console.Write(distanceArray[i, y] + "\t");
            }
            Console.Write("\n");
        }
        Console.ReadKey();

但是我得到了这个输出 out

由于某种原因，未应用最终值。我究竟做错了什么？有没有更有效的方法来实现这一目标？

Answer 1

对网格中的每个值使用初始值设定项。是的，距离网格中存在对称性，但您要求一种有效的方法！

val  breakdownByProfession = professionColumn.groupBy().count().collect()

Answer 2

我不清楚为什么要按照你的方式初始化数组。每个城市数组中的值似乎与您在表中显示的值无关。例如，chicago数组中的第三个值似乎是达拉斯和拉斯维加斯之间的距离（即芝加哥和其他城市之间不）。我也不清楚为什么如果你想要一个单独的distance数组，你不只是硬编码的值。我也不清楚你为什么在嵌套循环中有counter变量。

换句话说，你发布的代码对我来说很有意义。但是，基本目标似乎很清楚。以下是我的方法（仅显示四个城市的示例......我假设您可以采用基本示例并将其扩展到您拥有的所有城市）：

enum City
{
    Boston,
    Chicago,
    Dallas,
    LasVegas,
}

static class CityDistance
{
    private static int[][] _distances =
    {
        new [] { 1004, 1753, 2752 },
        new [] { 921, 1780 },
        new [] { 1230 },
    };

    public static int GetDistance(City city1, City city2)
    {
        if (city1 == city2)
        {
            return 0;
        }

        if (city1 > city2)
        {
            City cityT = city1;
            city1 = city2;
            city2 = cityT;
        }

        int cityIndex1 = (int)city1, cityIndex2 = (int)city2 - (cityIndex1 + 1);

        return _distances[cityIndex1][cityIndex2];
    }
}

class Program
{
    static void Main(string[] args)
    {
        foreach (City city1 in Enum.GetValues(typeof(City)))
        {
            foreach (City city2 in Enum.GetValues(typeof(City)))
            {
                Console.Write("{0,4}   ", CityDistance.GetDistance(city1, city2));
            }
            Console.WriteLine();
        }
    }
}

注意：

我介绍了使用enum类型来表示实际城市。这比依赖硬编码的整数值要好得多。
我已将逻辑抽象为CityDistances类，其中数据可以封装，以及一种方法，可以将“一对城市之间的距离”的基本查询映射到访问所需的逻辑存储的数据，无需调用者关心数据的存储方式。

使用此方法，您可以尝试不同的数据表示，并且调用GetDistance()方法的代码不必更改。在这种情况下，我存储的数据与您在示例中尝试的似乎的方式类似，即没有重复数据。这意味着GetDistance()方法需要将0长度场景作为一种特殊情况处理，并且需要对输入的城市值进行标准化，以便可以使用数据的对称性。

Answer 3

这是一个生成给定表格的完整示例。问题是代码中提到的数组值小于表中提到的值。

  class Program
{
    public static int w = 0;
    public static int y = 1;

    static void Main(string[] args)
    {

        int[,] twodimention = new int[10, 10];
        int[] boston = new int[] { 0, 1004, 1753, 2752,3017 ,1520 , 1507, 609, 3155,448 };
        int[] chicago = new int[] { 1004, 0, 921, 1780, 2048, 1397, 919, 515, 2176,709 };
        int[] dallas = new int[] { 1753, 921, 0, 1230, 1399, 1343, 517, 1435,2234,1307 };
        int[] lasVegas = new int[] { 2752, 1708, 1230, 0, 272, 2570, 1732,2251,1322,2420 };
        int[] losAngeles = new int[] { 3017, 2048, 1399, 272,0, 2716,1858,2523,1278,2646 };
        int[] miami = new int[] { 1520, 1397, 1343, 2570, 2716,0,860,1494,3447,1057 };
        int[] newOrleans = new int[] { 1507, 919, 517, 1732,1858,860,0,1307,2734,1099 };
        int[] toronto = new int[] { 609, 515, 1435,2251,2523,1494,1307,0,2820,571 };
        int[] vancouver = new int[] { 3155,2176,2234,1322,1278,3447,2734,2820,0,2887 };
        int[] washington = new int[] { 448, 709, 1307, 2420, 2646, 1057, 1099, 571, 2887,0 };
        int x = 9;

        for (int row = 0; row <= x; row++)
        {
            for (int col = 0; col <=9; col++)
            {
                if (w == 0)
                {
                    if (col ==boston.Length - 1 || col < boston.Length - 1)
                    {
                        twodimention[row, col] = boston[col];

                    }
                }
                if (w==1)
                {
                    if(col==chicago.Length-1 || col<chicago.Length - 1)
                    {
                        twodimention[row, col] = chicago[col];

                    }
                }
                if (w == 2)
                {
                    if (col == dallas.Length - 1 || col < dallas.Length - 1)
                    {


                        twodimention[row, col] = dallas[col];
                    }
                }
                if (w == 3)
                {
                    if (col == lasVegas.Length - 1 || col < lasVegas.Length - 1)
                    {

                        twodimention[row, col] = lasVegas[col];
                    }
                }
                if (w == 4)
                {
                    if (col == losAngeles.Length - 1 || col < losAngeles.Length - 1)
                    {
                        twodimention[row, col] = losAngeles[col];
                    }
                }
                if (w == 5)
                {
                    if (col == miami.Length - 1 || col < miami.Length - 1)
                    {
                        twodimention[row, col] = miami[col];
                    }

                }
                if (w == 6)
                {
                    if (col == newOrleans.Length - 1 || col < newOrleans.Length - 1)
                    {
                        twodimention[row, col] = newOrleans[col];
                    }
                }
                if (w == 7)
                {
                    if (col == toronto.Length - 1 || col < toronto.Length - 1)
                    {
                        twodimention[row, col] = toronto[col];
                    }
                }
                if (w == 8)
                {
                    if (col == vancouver.Length - 1 || col < vancouver.Length - 1)
                    {
                        twodimention[row, col] = vancouver[col];
                    }
                }
                if (w == 9)
                {
                    if (col == washington.Length - 1 || col < washington.Length - 1)
                    {
                        twodimention[row, col] = washington[col];
                    }
                }

            }


            w = w + 1;
        }
        Console.WriteLine();

        for (int row = 0; row <= x; row++)
        {
            for (int col = 0; col <= 9; col++)
            {
           Console.Write(twodimention[row, col]+"\t");

            }



        }

    }
}

具有许多值的二维数组

3 个答案: