用for循环创建和填充多个数组

Question

我正在学习编写代码。我正在使用Unity和C＃，我发现尝试通过for循环创建和填充多个数组存在一些困难。

在其他语言中，你可以做这样的事情：

for (int j = 0; j <= 3; j++) 
    { 
    scenes[j] = new float[2] {test[j], test2[j] }; 
    } 

但显然我不能做在C＃中类似的东西。是对的吗？

那我该怎么办？

我需要像这样创造一些东西：

scenes1 = {x1, y1} 
scenes2 = {x2, y2} 

等等...

Answer 1

的多维数组可以给你一个解决问题的办法，所有的你的数据可以进入一个单个数组，在你的情况下，你可能会使用类似场景的结构['index或position'，'test'，'test2']，我对C＃不太熟悉（不幸），但是你可以看到更多here。希望这可以帮助。

Answer 2

根据你在评论中的回答，我仍然不明白你到底需要什么。 AFAIU你有两件数据：场景和高度;并且您想要生成复合（场景，高度）元素的排列。我认为你要么需要：

1. 生成所有可能的permuations的恰好一次

2. 随机列表随机生成不同permuations

长（可能是无限的）流所以在这里是一些可能有用的代码。

首先让我们定义一些样板：

public class Scene 
    { 
     public readonly string Something; 

     public Scene(string something) 
     { 
      Something = something; 
     } 

     // something else 
    } 

    public struct CompoundSceneData 
    { 
     public readonly Scene Scene; 
     public readonly float Height; 

     public CompoundSceneData(Scene scene, float height) 
     { 
      Scene = scene; 
      Height = height; 
     } 
    } 

当然你Scene类是最有可能更为复杂。 CompoundSceneData是一个表示场景+高度的单个项目的结构。

＃1生成所有可能的permuations随机列出恰好一次：

// Fisher–Yates shuffle of indices 0..size 
    int[] GenerateRandomIndicesPermutation(int size) 
    { 
     int[] permutation = Enumerable.Range(0, size).ToArray(); 
     Random rnd = new Random(); 
     for (int cur = size; cur >= 2; cur--) 
     { 
      int swapPos = rnd.Next(cur); 
      int tmp = permutation[swapPos]; 
      permutation[swapPos] = permutation[cur - 1]; 
      permutation[cur - 1] = tmp; 
     } 

     return permutation; 
    } 

    List<CompoundSceneData> GenerateAllRandomPermutationsOnce(Scene[] scenes, float[] heights) 
    { 
     int scenesCount = scenes.Length; 
     int heightsCount = heights.Length; 
     int totalCount = scenesCount * heightsCount; 
     List<CompoundSceneData> permutations = new List<CompoundSceneData>(totalCount); 
     foreach (var compoundIndex in GenerateRandomIndicesPermutation(totalCount)) 
     { 
      int sceneIndex = compoundIndex % scenesCount; 
      int heightIndex = compoundIndex/scenesCount; 
      permutations.Add(new CompoundSceneData(scenes[sceneIndex], heights[heightIndex])); 
     } 
     return permutations; 
    } 


    void TestUsageAllOnce() 
    { 
     Scene[] scenes = new Scene[] { new Scene("Scene #1"), new Scene("Scene #2") }; 
     float[] heights = new float[] { 0.1f, 0.2f, 0.3f }; 

     // this is effectively endless loop 
     foreach (CompoundSceneData sceneData in GenerateAllRandomPermutationsOnce(scenes, heights)) 
     { 
      // will be called excactly 2*3 = 6 times 
      DrawScene(sceneData); 
     } 
    } 

有几个关键概念有：

• 如果我们有N个场景和M的高度有将是N M置换，并给定范围[0，N M-1]中的数字，您可以选择一对。例如，2 * N + 5表示第5个场景+第2个高度（在基于0的索引（！）中）。

• 因此，如果我们想要生成N个场景和M个高度的不同对的序列，那么足以生成数字[0，N * M-1]的随机序列并将其用作指数序列

• 有一个众所周知的Fisher–Yates shuffle算法来创建一个随机排列。

＃2随机生成不同permuations无限流：

IEnumerable<CompoundSceneData> GenerateInfiniteRandomStream(Scene[] scenes, float[] heights) 
    { 
     Random rnd = new Random(); 
     while (true) 
     { 
      int sceneIndex = rnd.Next(scenes.Length); 
      int heightIndex = rnd.Next(heights.Length); 
      yield return new CompoundSceneData(scenes[sceneIndex], heights[heightIndex]); 
     } 
    } 


    void TestUsageInfinite() 
    { 
     Scene[] scenes = new Scene[] { new Scene("Scene #1"), new Scene("Scene #2") }; 
     float[] heights = new float[] { 0.1f, 0.2f, 0.3f }; 

     // this is effectively endless loop 
     foreach (CompoundSceneData sceneData in GenerateInfiniteRandomStream(scenes, heights)) 
     { 
      DrawScene(sceneData); 

      // this is the only thing that will stop the loop 
      if (IsEndOfGame) 
       break; 
     } 
    } 

    void TestUsageInfinite2() 
    { 
     Scene[] scenes = new Scene[] { new Scene("Scene #1"), new Scene("Scene #2") }; 
     float[] heights = new float[] { 0.1f, 0.2f, 0.3f }; 

     List<CompoundSceneData> fixedSizeList = GenerateInfiniteRandomStream(scenes, heights).Take(100).ToList(); 
     foreach (CompoundSceneData sceneData in fixedSizeList) 
     { 
      // this will be called 100 times (as specified in Take) 
      DrawScene(sceneData); 
     } 
    } 

这里唯一有趣的事情是一个C＃的特征yield return的使用。该功能允许从看起来顺序的代码创建数据流（IEnumerable）。

请注意，对于解决方案＃2，不能保证每个组合（场景+数据）只会出现一次（N * M）个项目。它只是生成随机组合，只有长期运行才具有良好的统计特性。也有可能实现这种保证，但它使代码显着复杂化，并且用户可能不会注意到。