Получить массив sub из массива jagged

Question

Вход в мою рутину - это зубчатый массив (к сожалению, мне нужно жить с ним). Он представляет собой таблицу данных (строки и ячейки).

Теперь я должен вывести еще один зубчатый массив, являющийся вспомогательным массивом данного ввода, то есть я хочу иметь строки 500-1000.

Есть ли хороший способ сделать это? Может быть, даже что-то вроде вид поверх существующих данных?

Я до сих пор реализовал сценарий наихудшего случая: создав второй зазубренный массив и скопировав под него массив.

Надежда есть лучший способ, вы можете сказать мне :-)

Answer 1

Если я правильно понял, то может быть это?

var subArray = yourArray.Skip(500).Take(500).ToArray(); 

Answer 2

Например, вы можете попробовать этот подход, используя ключевое слово yield.

public IEnumerable<T[]> GetRowRange<T>(T[][] jaggedArray, int rowStart, int rowEnd) 
    { 
     for(var idx = rowStart; idx <= rowEnd; idx ++) 
     { 
      yield return GetRowValues(jaggedArray, idx).ToArray(); 
     } 
    } 

    public IEnumerable<T> GetRowValues<T>(T[][] jaggedArray, int row) 
    { 
     for (var col = 0; col < jaggedArray.Length; col++) 
     { 
      yield return jaggedArray[row][col]; 
     } 
    } 

и это использование:

var rowRange = GetRowRange(jaggedArray, 2, 3); 
foreach(var row in rowRange) 
{ 
    //do something 
} 

Answer 3

Я думаю, что вы имеете в виду с помощью LINQ

public double[][] GetSubMatrix(int row, int col, int row_count, int col_count) 
{ 
    return elements.Skip(row).Take(row_count).Select(
     (each_row) => each_row.Skip(col).Take(col_count).ToArray()).ToArray(); 
} 

Мои предпочтения для матричных структур использовать неровные массивы без LINQ. Вы не можете легко устанавливать значения в массиве с помощью LINQ, и команды становятся довольно длинными и глупыми через некоторое время.

Я использую Array.Copy как можно больше вместо внутренних петель.

Попробуйте Matrix общий образец класса:

public class Matrix<T> 
{ 
    readonly int rows, cols; 
    readonly T[][] elements; 

    public Matrix(int rows, int cols) 
    { 
     this.rows=rows; 
     this.cols=cols; 
     this.elements=new T[rows][]; 
     for(int i = 0; i<rows; i++) 
     { 
      elements[i]=new T[cols]; 
     } 
    } 
    public int Rows { get { return rows; } } 
    public int Columns { get { return cols; } } 
    public T this[int row, int col] 
    { 
     get { return elements[row][col]; } 
     set { elements[row][col]=value; } 
    } 
    public T[] GetRow(int row) { return elements[row]; } // This is fast 
    public T[] GetColumn(int col) // This is slow 
    { 
     T[] column = new T[rows]; 
     for(int i = 0; i<rows; i++) 
     { 
      column[i]=elements[i][col]; 
     } 
     return column; 
    } 

    public T[][] GetSubMatrix(int row, int col, int row_count, int col_count) 
    { 
     T[][] result = new T[row_count][]; 
     for(int i = 0; i<row_count; i++) 
     { 
      // This is fast 
      Array.Copy(elements[row+i], col, result[i], 0, col_count); 
     } 
     return result; 
    } 

    public void SetSubMatrix(int row, int col, T[][] matrix) 
    { 
     int row_count = matrix.Length; 
     int col_count = row_count>0 ? matrix[0].Length : 0; 
     for(int i = 0; i<row_count; i++) 
     { 
      // This is fast 
      Array.Copy(matrix[i], 0, elements[row+i], col, col_count); 
     } 
    } 
}