如果我有一个数组：

int[,] mainArray = new int[10,10,3];

我怎样才能得到一个子数组：

int[] sub = mainArray[0,1]; // Unfortunately this doesn't work

sub将包含3个元素

sub[0] = mainArray[0,1,0];
sub[1] = mainArray[0,1];
sub[2] = mainArray[0,2];

编写一个方法来做这个很容易,但有没有内置的方法来做到这一点？

我想你可以使用这样的扩展方法：

public static class MyExtensions
{
    public static int[] GetValues(this Array source,int x,int y)
    {
        var length = source.GetUpperBound(2);
        var values = new int[length+1];
        for (int i = 0; i < length+1; i++)
        {
            values[i] = (int)source.GetValue(x,y,i);
        }
        return values;
    }
}

用法：

int[,3];
int[] sub = mainArray.GetValues(0,1);

我有一个2D阵列阵列.例如,它就像：

{{{0,1},{1,0}}
{{0,3},{2,1,2},2,{3,7},6},{6,3,{7,0}}}

但如果我写

int [,][] arrays={{{0,0}}
                  {{0,0}}};

编译器会抱怨“;预期”.

如果我写

int [,][] arrays={new int[,] {{0,0}}
                  new int[,0}}};

编译器会抱怨

“A nested array initializer is expected”.

那么为什么会这样发生,什么是正确的初始化方法？

您正在尝试创建锯齿状阵列.你的数组有n行,所以你的第一个Square应该是[]不是[,].每行中的元素(n的索引)是2D数组,因此您需要使用[,].最后,您可以通过将int [,] []更改为int [] [,]来解决问题.

int[][,] arrays = {
    new int[,0}},new int[,0}}
};

我有一个由两列表示为数组的“表”.第一列是1到20的数字,它们是标签,第二列是相应的值(秒)：

my_array = [ [ 3,4,5,3,2 ],[ 12,14,16,11,12,10,20 ] ];

我需要每个标签的平均值(平均值)：

my_mean_array = [ [ 2,5 ],[ 20/1,(12+11)/2,(14+12)/2,(16+10)/2 ] ];
// edit: The mean should be a float - the notion above is just for clarification.
// Also the number 'labels' should remain as numbers/integers.

我的尝试：

var a = my_array[0];
var b = my_array[1];
m = [];
n = [];
for( var i = 0; a.length; i++){
    m[ a[i] ] += b[i]; // accumulate the values in the corresponding place
    n[ a[i] ] += 1; // count the occurences
}
var o = [];
var p = [];
o = m / n;
p.push(n);
p.push(o);

怎么样(原生JS,不会破坏旧版浏览器)：

function arrayMean(ary) {
  var index = {},i,label,value,result = [[],[]];

  for (i = 0; i < ary[0].length; i++) {
    label = ary[0][i];
    value = ary[1][i];
    if (!(label in index)) {
      index[label] = {sum: 0,occur: 0};
    }
    index[label].sum += value;
    index[label].occur++;
  }
  for (i in index) {
    if (index.hasOwnProperty(i)) {
      result[0].push(parseInt(i,10));
      result[1].push(index[i].occur > 0 ? index[i].sum / index[i].occur : 0);
    }
  }
  return result;
}

FWIW,如果你想要花哨我已经创造了一些其他方法来做到这一点.它们依赖于外部库,并且很可能比原生解决方案慢一个数量级.但他们看起来更好.

看起来像这样,用underscore.js：

function arrayMeanUnderscore(ary) {
  return _.chain(ary[0])
    .zip(ary[1])
    .groupBy(function (item) { return item[0]; })
    .reduce(function(memo,items) {
      var values = _.pluck(items,1),toSum = function (a,b) { return a + b; };

      memo[0].push(items[0][0]);
      memo[1].push(_(values).reduce(toSum) / values.length);
      return memo;
    },[[],[]])
    .value();
}

// --------------------------------------------

arrayMeanUnderscore([[3,2],[12,20]]);
// -> [[2,5],[20,11.5,13,13]]

或者像这样,真正伟大的linq.js(我用过v2.2)：

function arrayMeanLinq(ary) {
  return Enumerable.From(ary[0])
    .Zip(ary[1],"[$,$$]")
    .GroupBy("$[0]")
    .Aggregate([[],[]],function (result,item) {
      result[0].push(item.Key());
      result[1].push(item.Average("$[1]"));
      return result;
    });
}

// --------------------------------------------

arrayMeanLinq([[3,20]]);
// -> [[3,[11.5,20]]

正如所怀疑的那样,“花哨”实现比本机实现慢一个数量级：jsperf comparison.