将锯齿字符[] []转换为字符[，]？

Question

我昨天开始做的一个'我该死的'项目是一个Befunge口译员。除了边缘情况外，我大部分都在工作。

我偷懒，并决定在befunge程序与此阅读：

char[][] program = File.ReadAllLines(args[0]).Select(x => x.ToCharArray()).ToArray(); 

我知道我是为自己以后创造更多的工作，但我希望去其他地方，并留在这一点。现在它晚了，我需要修复program不是矩形的事实。比方说，我有这个befunge程序：

v v < 
    @ 
>  ^

第1和第3行9个字符长，但2号线仅5中，我有我befunge解释设置方式，我会得到一个IndexOutOfBoundsException前该程序终止，因为在将^解释为方向改变之后，我将尝试访问program[1][8]并且program[1]仅为5长。我怎样才能用program创建一个char[,]并用空格填充多余的字符？

我知道我可以确定最长行的长度，行数，用这些字符创建char [，]并复制它们，但我希望稍微简单一些，更优雅。如果一种新方法更好，我完全可以抛出上面的线。

Answer 1

而不是重新创建整个参差不齐的数组（假设它可能相当大），你可以为它创建一个包装。该包装将能够进行边界检查并返回一些默认值，如果它超出界限而不是错误。

public class Matrix<T> 
{ 
    public T[][] UnderlyingCollection {get;set;} //should probably be readonly and set in the constructor 

    public T DefaultValue {get;set;} 

    public T this[int i, int j] 
    { 
    get 
    { 
     if(UnderlyingCollection.Length > i && UnderlyingCollection[i].Length > j) 
     return UnderlyingCollection[i][j]; 
     else 
     return DefaultValue; 
    } 
    set 
    { /*TODO implement*/ } 

    } 
} 

Answer 2

男人，我不知道如果这是你在找什么，但检查了这一点：

public static class CharArrayExtension 
{ 
    public static char[,] FormatMatrix(this char[][] matrix) 
    { 
     int TotalColumns = matrix.Length; 
     int TotalLines = 0; 

     //Get the longest line of the current matrix 
     for (int column = 0; column < TotalColumns; column++) 
     { 
      int line = matrix[column].Length; 

      if (line > TotalLines) 
       TotalLines = line; 
     } 

     //Instantiate the resulting matrix 
     char[,] Return = new char[TotalColumns, TotalLines]; 

     Return.Initialize(); 

     //Retrieve values from the current matrix 
     for (int CurrentColumn = 0; CurrentColumn < TotalColumns; CurrentColumn++) 
     { 
      int MaxLines = matrix[CurrentColumn].Length; 

      for (int CurrentLine = 0; CurrentLine < MaxLines; CurrentLine++) 
      { 
       Return[CurrentColumn, CurrentLine] = matrix[CurrentColumn][CurrentLine]; 
      } 
     } 

     return Return; 
    } 
} 

用法：

 char[] Length5 = new char[]{ 'a', 'b', 'c', 'd', 'e'}; 
     char[] Length10 = new char[10]; 

     char[][] Matrix = new char[2][]; 
     Matrix[0] = Length5; 
     Matrix[1] = Length10; 

     char[,] FormattedMatrix = Matrix.FormatMatrix(); 

任何反馈将不胜感激。

---

UPDATE

尼古拉斯指出的性能问题。我很好奇，所以我做了如下的微弱的标杆：

 char[] Length5 = new char[]{ 'a', 'b', 'c', 'd', 'e'}; 
     char[] Length10 = new char[10]; 

     char[][] Matrix = new char[2][]; 
     Matrix[0] = Length5; 
     Matrix[1] = Length10; 

     Stopwatch stopWatch = new Stopwatch(); 

     stopWatch.Start(); 

     for (int i = 0; i < 5000; i++) 
     { 
      char[,] FormattedMatrix = Matrix.FormatMatrix(); 
     } 

     stopWatch.Stop(); 

     Console.WriteLine(string.Format("Andre Calil: {0} ms", stopWatch.ElapsedMilliseconds)); 

     stopWatch.Reset(); 

     stopWatch.Start(); 

     for (int i = 0; i < 5000; i++) 
     { 
      char[,] FormattedMatrix = RectArrayFromJagged<char>(Matrix); 
     } 

     stopWatch.Stop(); 

     Console.WriteLine(string.Format("Nicholas Carey: {0} ms", stopWatch.ElapsedMilliseconds)); 

     Console.ReadLine(); 

我已经多次运行它，平均结果是：

Andre Calil: 3 ms 
Nicholas Carey: 5 ms 

我知道那这不是一个适当的基准测试，但像我的解决方案一样，在性能方面并没有那么糟糕。

Answer 3

基于@ AndreCalil之前的回答，这可能会更高效，特别是对于大型原始类型的数组。原始类型的数组可以被视为字节的缓冲区平，可在这样的工作是有用的（如果你有使用汇编或C经验）：

static void Main(string[] args) 
{ 
    string[][] jagged = new string[][] { new string[] { "alpha" ,            } , 
              new string[] { "bravo" , "charlie" ,         } , 
              new string[] { "delta" , "echo" , "foxtrot" ,      } , 
              new string[] { "golf" , "hotel" , "india" , "juliet" ,   } , 
              new string[] { "kilo" , "lima" , "mike" , "nancy" , "oscar" , } , 
             } ; 
    string[,] rectangular = RectArrayFromJagged<string>(jagged) ; 

    return; 
} 

public static T[,] RectArrayFromJagged<T>(T[][] a) 
{ 
    int rows = a.Length; 
    int cols = a.Max(x => x.Length); 
    T[,] value = new T[ rows , cols ] ; 

    value.Initialize() ; 

    if (typeof(T).IsPrimitive) 
    { 
     int elementSizeInOctets = Buffer.ByteLength(value)/value.Length ; 
     for (int i = 0 ; i < rows ; ++i) 
     { 
      int rowOffsetInOctets = i * cols * elementSizeInOctets ; 
      int rowLengthInOctets = a[i].Length * elementSizeInOctets ; 
      Buffer.BlockCopy(a[i] , 0 , value , rowOffsetInOctets , rowLengthInOctets) ; 
     } 
    } 
    else 
    { 
     for (int i = 0 ; i < rows ; ++i) 
     { 
      int rowLength = a[i].Length ; 
      for (int j = 0 ; j < rowLength ; ++j) 
      { 
       value[i,j] = a[i][j] ; 
      } 
     } 
    } 
    return value ; 
}