0

我坐在上面超过一个小时，可能是因为迟到了，也可能是我很愚蠢，但我做不到。我有两个数组

a[0] = [['','',''],['','',''],['','','']];
a[1] = [['','',''],['','',''],['','','']];
a[2] = [['','',''],['','',''],['','','']];
a[3] = [['','',''],['','',''],['','','']];

b=['','','','',
'','','','','',
'','','','','',
'','','','','',
'','','','','',
'','','','','',
'','','','','',
'','']

如您所见，它是不同格式的数组，但是数组 a[] 中的每个单元格都引用了数组 b[] 中的他的兄弟

我正在尝试编写一个函数来获取数组 a[] 中的单元格地址，例如计算（3,2,2）并返回数组 b[] 中的单元格地址

这是我到目前为止写的...

function timecalculating(x,y,z) {
    var count =z;

    var prew=y-1;

    for (var i=k; i>-1; i--) {

        for (var j=vocabulary[i].length; j>-1; j--) {



            count+=vocabulary[i][prew].length;
        }
    }
    alert (count) ;
}

但我知道这是不对的..有什么建议吗？

下面是一些例子： INPUT (3,1,1) 这意味着

a[0] = [['','',''],['','',''],['','','']];
a[1] = [['','',''],['','',''],['','','']];
a[2] = [['','',''],['','',''],['','','']];
a[3] = [['','',''],['','HERE',''],['','','']];

所以它应该把所有的都算下来。(2+3)+(3+3+3)+(3+3+3)+(3+3+3)=32 <= 这是数组 b[] 2 中的“地址” - 是 z 3(first ) 是 a[x][y].length 3(second) 是 a[x][y-1].length

等等..

我希望它对不同长度的数组通用）

a[0] = [['','',''],['','',''],['','','']];
a[1] = [['',''],['','','']];
a[2] = [['','',''],[''],['','']];
a[3] = [['','','']];
4

2 回答 2

0

我不确定我是否理解正确，但你的意思是......

function timecalculating(x,y,z) {
    var index = 9 * x + 3 * y + z;
    return b[index];
}

编辑

好的，在看到您编辑的问题后，我更好地理解了它。

广义的解决方案非常棘手，并且涉及递归。

尝试这个 ：

function countUp(arr, stopAt, progress, level) {
    //Initialize level and progress (at level 0).
    level = level || 0;
    if(level == 0) {
        if(!progress) {
            progress = [];
            for(var i=0; i<stopAt.length; i++) progress[i] = 0;
        };
        try {
            var ar = arr, val;
            for(var i=0; i<stopAt.length; i++) {
                val = ar[stopAt[i]];
                if( val == undefined || (i<stopAt.length-1 && !$.isArray(val)) ) {
                    throw('');
                }
                ar = val;
            };
        }
        catch(e) {
            return -1;//return -1 if the requested stopAt position doesn't exist.
        }
    }

    progress[level] = 0;
    var c, stop = false;
    for(var i=0, n=0; i<arr.length; i++, progress[level]++) {
        if($.isArray(arr[i])) {
            c = countUp(arr[i], stopAt, progress, level+1);
            n += c.n;
            stop = c.stop;
        }
        else {
            n += 1;
            stop = arrayCompare(stopAt, progress);
        };
        if(stop) break;
    }
    return (level>0) ? {n:n, 'stop':stop} : n-1;
}

//Utility function for comparing two arrays
function arrayCompare(arr1, arr2) {
    if(arr1.length !== arr2.length) return false;
    for(var i=0; i<arr1.length; i++) {
        if(arr1[i] !== arr2[i]) return false;
    }
    return true;
}

调用函数如下：

var index = countUp(a, [3,1,1]);

其中a是一个数组，第二个参数表示停止位置的索引。

如果请求的停止位置不存在，则函数返回 -1。

演示

于 2013-03-14T22:08:14.880 回答
0

对于相同大小的数组，将多维索引转换为其一维对应物的一般解决方案需要数组每个维度的维度大小，而不是第一个维度，并且取决于您使用的是行优先还是列优先排序.

我将在这里的示例中使用行优先顺序，因为我认为这是您正在寻找的（转换为列优先很容易）。我将使用下面的示例来解释行主索引。考虑以下数组。

var array = [[0, 1, 2],
             [0, 1, 2],
             [0, 1, 2]];

在行主要顺序中，我们正在寻找行的索引，就好像它们一个接一个地组织一样。这就好像每一行都附加到一个数组[0, 1, 2, 0, 1, 2, 0, 1, 2]中。第一行的索引完全相同（0、1 和 2）。对于第二行，我们必须添加第一行的长度，即 3，给我们索引 3、4、5。第一行的长度当然是原始数组的第二维的大小。对于第三行，我们必须添加原始数组的第二维的两倍，得到 6、7、8。这里的模式应该很明显，并在下面的示例中使用。

c通常，对于大小为 2D 的数组，c[height][width]对应于 2D 位置的 1D 索引c[y][x]是y * width + x。

d对于一个大小为 的三维数组，d[depth][height][width]对应位置的一维索引d[z][y][x]为z * (width * height) + y * width + z。

相同的概念可以应用于具有不同大小的多维数组。但是，由于子数组的大小是未知的，因此不可能像我们之前所做的那样在一次计算中得到答案。相反，您必须计算给定目标索引之前的元素数。这很简单，正如您应该在下面的代码中看到的那样，您可以使用这个demo进行测试。

/*  Sums the number of elements in each sub-array of the given array.
    Returns the resulting sum.
    array: the array to count the elements of. */
function countAllElements(array) {
    var elements = 0;

    if (Array.isArray(array)) {
        for (var i = 0; i < array.length; ++i) {
            elements += countAllElements(array[i]);
        }
    }
    else {
        ++elements;
    }

    return elements;
}


/*  Sums the number of elements in each sub-array of the given array up to the given target index.
    Returns the resulting sum.
    array: the array to count the elements of.
    target: the target indices as an array, e.g. [3, 1, 5].
    depth: current depth in the nested arrays. Do not call with this. */
function countElementsBeforeIndex(array, target, depth) {
    var elements = 0;

    depth = depth || 0;

    if (Array.isArray(array)) {
        for (var i = 0; i < target[depth]; ++i) {
            elements += countAllElements(array[i]);
        }

        elements += countElementsBeforeIndex(array[target[depth]], target, depth + 1, i);
    }

    return elements;
}

您将看到我提供了一个函数 ，countAllElements它计算具有任意嵌套级别的数组中的所有元素，另一个，countElementsBeforeIndex，它一直计数，直到它达到提供的索引。后一种方法使用前一种方法。

我希望这有帮助！ （演示）

于 2013-03-14T22:57:47.483 回答