将表示神经网络的锯齿状数组转换为表示其神经通路的二维数组 C#

Question

What is an example of a C# algorithm to convert the Jagged Array "Network" to the 2D Array "Paths"?

Rules:

1. The network will always have a minimum of 3 layers. Input, Hidden1, Output.
2. There is no predefined maximum amount of hidden layers.
3. Hidden layers can have different numbers of neurons.

4. There is no predefined maximum amount of neurons in a layer.

    Int[4][ ] Network I H1 H2 O [0] {1,2,3,4} [1] {1,2,3,4,5,6} 1 1 [2] {1,2,3,4,5,6} 1 2 2 [3] {1,2} 2 3 3 1 3 4 4 2 4 5 5 6 6 **Convert this to this ** Int[288,4] Paths I H1 H2 O n=1 1 1 1 1 n=2 2 1 1 1 n=3 3 1 1 1 n=4 4 1 1 1 n=5 1 2 1 1 n=6 2 2 1 1 n=7 3 2 1 1 n=8 4 2 1 1 … … … … … n=288 4 6 6 2

Answer 1

Best I could do on short notice...

 static void Main(string[] args)
 {
     int[][] jagged = new int[4][];
     jagged[0] = new int[] { 1, 2, 3, 4 };
     jagged[1] = new int[] { 1, 2, 3, 4, 5, 6 };
     jagged[2] = new int[] { 1, 2, 3, 4, 5, 6 };
     jagged[3] = new int[] { 1, 2 };
     int[,] array2D = Jaggedto2D(jagged);
     for(int i = 0; i < array2D.GetLength(0); i++)
     {
         Console.WriteLine(String.Format("n={0}  {1} {2} {3} {4}", i + 1, array2D[i, 0], array2D[i, 1], array2D[i, 2], array2D[i, 3]));
     }
 }
 private static int Fill(int[,] array2D, int k, int[] indices, int[][] jagged)
 {
      if(indices.Length == array2D.GetLength(1))
      {
          for(int i = 0; i < indices.Length; ++i)
          {
                array2D[k, i] = jagged[i][indices[i]];
          }
          k++;
      }
      else
      {
           int j = indices.Length;
           int[] indices1 = new int[j + 1];
           Array.Copy(indices, indices1, j);
           for(int l = 0; l < jagged[j].Length; ++l)
           {
               indices1[j] = l;
               k = Fill(array2D, k, indices1, jagged);
           }
       }
       return k;
  }

  private static int[,] Jaggedto2D(int[][] jagged)
  {
       int width = jagged.Length;
       int length = 1;
       for (int i = 0; i < width; i++)
            length *= jagged[i].Length;
       int[,] array2D = new int[length, width];
       int k = 0;
       Fill(array2D, k, new int[0], jagged);
       return array2D;
   }

Produces...

n=1  1 1 1 1
n=2  1 1 1 2
n=3  1 1 2 1
n=4  1 1 2 2
n=5  1 1 3 1
n=6  1 1 3 2
n=7  1 1 4 1
n=8  1 1 4 2
n=9  1 1 5 1
n=10  1 1 5 2
n=11  1 1 6 1
n=12  1 1 6 2
n=13  1 2 1 1
n=14  1 2 1 2
n=15  1 2 2 1
n=16  1 2 2 2
n=17  1 2 3 1
n=18  1 2 3 2
n=19  1 2 4 1
n=20  1 2 4 2
n=21  1 2 5 1
n=22  1 2 5 2
n=23  1 2 6 1
n=24  1 2 6 2
n=25  1 3 1 1
n=26  1 3 1 2
n=27  1 3 2 1
n=28  1 3 2 2
n=29  1 3 3 1
n=30  1 3 3 2
n=31  1 3 4 1
n=32  1 3 4 2
n=33  1 3 5 1
n=34  1 3 5 2
n=35  1 3 6 1
n=36  1 3 6 2
n=37  1 4 1 1
n=38  1 4 1 2
n=39  1 4 2 1
n=40  1 4 2 2
n=41  1 4 3 1
n=42  1 4 3 2
n=43  1 4 4 1
n=44  1 4 4 2
n=45  1 4 5 1
n=46  1 4 5 2
n=47  1 4 6 1
n=48  1 4 6 2
n=49  1 5 1 1
n=50  1 5 1 2
n=51  1 5 2 1
n=52  1 5 2 2
n=53  1 5 3 1
n=54  1 5 3 2
n=55  1 5 4 1
n=56  1 5 4 2
n=57  1 5 5 1
n=58  1 5 5 2
n=59  1 5 6 1
n=60  1 5 6 2
n=61  1 6 1 1
n=62  1 6 1 2
n=63  1 6 2 1
n=64  1 6 2 2
n=65  1 6 3 1
n=66  1 6 3 2
n=67  1 6 4 1
n=68  1 6 4 2
n=69  1 6 5 1
n=70  1 6 5 2
n=71  1 6 6 1
n=72  1 6 6 2
n=73  2 1 1 1
n=74  2 1 1 2
n=75  2 1 2 1
n=76  2 1 2 2
n=77  2 1 3 1
n=78  2 1 3 2
n=79  2 1 4 1
n=80  2 1 4 2
n=81  2 1 5 1
n=82  2 1 5 2
n=83  2 1 6 1
n=84  2 1 6 2
n=85  2 2 1 1
n=86  2 2 1 2
n=87  2 2 2 1
n=88  2 2 2 2
n=89  2 2 3 1
n=90  2 2 3 2
n=91  2 2 4 1
n=92  2 2 4 2
n=93  2 2 5 1
n=94  2 2 5 2
n=95  2 2 6 1
n=96  2 2 6 2
n=97  2 3 1 1
n=98  2 3 1 2
n=99  2 3 2 1
n=100  2 3 2 2
n=101  2 3 3 1
n=102  2 3 3 2
n=103  2 3 4 1
n=104  2 3 4 2
n=105  2 3 5 1
n=106  2 3 5 2
n=107  2 3 6 1
n=108  2 3 6 2
n=109  2 4 1 1
n=110  2 4 1 2
n=111  2 4 2 1
n=112  2 4 2 2
n=113  2 4 3 1
n=114  2 4 3 2
n=115  2 4 4 1
n=116  2 4 4 2
n=117  2 4 5 1
n=118  2 4 5 2
n=119  2 4 6 1
n=120  2 4 6 2
n=121  2 5 1 1
n=122  2 5 1 2
n=123  2 5 2 1
n=124  2 5 2 2
n=125  2 5 3 1
n=126  2 5 3 2
n=127  2 5 4 1
n=128  2 5 4 2
n=129  2 5 5 1
n=130  2 5 5 2
n=131  2 5 6 1
n=132  2 5 6 2
n=133  2 6 1 1
n=134  2 6 1 2
n=135  2 6 2 1
n=136  2 6 2 2
n=137  2 6 3 1
n=138  2 6 3 2
n=139  2 6 4 1
n=140  2 6 4 2
n=141  2 6 5 1
n=142  2 6 5 2
n=143  2 6 6 1
n=144  2 6 6 2
n=145  3 1 1 1
n=146  3 1 1 2
n=147  3 1 2 1
n=148  3 1 2 2
n=149  3 1 3 1
n=150  3 1 3 2
n=151  3 1 4 1
n=152  3 1 4 2
n=153  3 1 5 1
n=154  3 1 5 2
n=155  3 1 6 1
n=156  3 1 6 2
n=157  3 2 1 1
n=158  3 2 1 2
n=159  3 2 2 1
n=160  3 2 2 2
n=161  3 2 3 1
n=162  3 2 3 2
n=163  3 2 4 1
n=164  3 2 4 2
n=165  3 2 5 1
n=166  3 2 5 2
n=167  3 2 6 1
n=168  3 2 6 2
n=169  3 3 1 1
n=170  3 3 1 2
n=171  3 3 2 1
n=172  3 3 2 2
n=173  3 3 3 1
n=174  3 3 3 2
n=175  3 3 4 1
n=176  3 3 4 2
n=177  3 3 5 1
n=178  3 3 5 2
n=179  3 3 6 1
n=180  3 3 6 2
n=181  3 4 1 1
n=182  3 4 1 2
n=183  3 4 2 1
n=184  3 4 2 2
n=185  3 4 3 1
n=186  3 4 3 2
n=187  3 4 4 1
n=188  3 4 4 2
n=189  3 4 5 1
n=190  3 4 5 2
n=191  3 4 6 1
n=192  3 4 6 2
n=193  3 5 1 1
n=194  3 5 1 2
n=195  3 5 2 1
n=196  3 5 2 2
n=197  3 5 3 1
n=198  3 5 3 2
n=199  3 5 4 1
n=200  3 5 4 2
n=201  3 5 5 1
n=202  3 5 5 2
n=203  3 5 6 1
n=204  3 5 6 2
n=205  3 6 1 1
n=206  3 6 1 2
n=207  3 6 2 1
n=208  3 6 2 2
n=209  3 6 3 1
n=210  3 6 3 2
n=211  3 6 4 1
n=212  3 6 4 2
n=213  3 6 5 1
n=214  3 6 5 2
n=215  3 6 6 1
n=216  3 6 6 2
n=217  4 1 1 1
n=218  4 1 1 2
n=219  4 1 2 1
n=220  4 1 2 2
n=221  4 1 3 1
n=222  4 1 3 2
n=223  4 1 4 1
n=224  4 1 4 2
n=225  4 1 5 1
n=226  4 1 5 2
n=227  4 1 6 1
n=228  4 1 6 2
n=229  4 2 1 1
n=230  4 2 1 2
n=231  4 2 2 1
n=232  4 2 2 2
n=233  4 2 3 1
n=234  4 2 3 2
n=235  4 2 4 1
n=236  4 2 4 2
n=237  4 2 5 1
n=238  4 2 5 2
n=239  4 2 6 1
n=240  4 2 6 2
n=241  4 3 1 1
n=242  4 3 1 2
n=243  4 3 2 1
n=244  4 3 2 2
n=245  4 3 3 1
n=246  4 3 3 2
n=247  4 3 4 1
n=248  4 3 4 2
n=249  4 3 5 1
n=250  4 3 5 2
n=251  4 3 6 1
n=252  4 3 6 2
n=253  4 4 1 1
n=254  4 4 1 2
n=255  4 4 2 1
n=256  4 4 2 2
n=257  4 4 3 1
n=258  4 4 3 2
n=259  4 4 4 1
n=260  4 4 4 2
n=261  4 4 5 1
n=262  4 4 5 2
n=263  4 4 6 1
n=264  4 4 6 2
n=265  4 5 1 1
n=266  4 5 1 2
n=267  4 5 2 1
n=268  4 5 2 2
n=269  4 5 3 1
n=270  4 5 3 2
n=271  4 5 4 1
n=272  4 5 4 2
n=273  4 5 5 1
n=274  4 5 5 2
n=275  4 5 6 1
n=276  4 5 6 2
n=277  4 6 1 1
n=278  4 6 1 2
n=279  4 6 2 1
n=280  4 6 2 2
n=281  4 6 3 1
n=282  4 6 3 2
n=283  4 6 4 1
n=284  4 6 4 2
n=285  4 6 5 1
n=286  4 6 5 2
n=287  4 6 6 1
n=288  4 6 6 2