Javascript 以交替的正方形填充二维阵列

如果有一个值n，它将确定二维数组或表的维度。然后您应该从外层到中间填充数组或表格，一次填充1，一次填充0，直到没有其他元素可写入为止

n=5

n=6

已经尝试了很长一段时间了，非常感谢您的帮助。我只会填补边界

我的最新代码：

function fillArray(n) {
    var exArray = [];
    var html = '';
    for (var i = 0; i < n; i++) {
        html+= '<tr>';
        exArray[i] = [];
        for (var j = 0; j < n; j++) {
            exArray[i][j] = 0;
            if(i%(n-1)==0 || j%(n-1)==0) {
                exArray[i][j] = 1;
            }
            html+='<td class="text-center">'+exArray[i][j]+' ['+i+','+j+']</td>';
        };
        html+= '</tr>';
    };
    return html;
}

函数填充数组（n）{
var exArray=[]；
var html=''；
对于（变量i=0；i

我认为最简单的方法是只考虑左上象限，并通过对称填充其他象限：

var-arr=Array（n）；
对于（var i=0；i而言，虽然不那么简洁，但很有效：

var n = 10;

function isMiddleIndex(middleIdx, rowIndex, cellIndex) {
    return middleIdx.indexOf(rowIndex) != -1 && middleIdx.indexOf(cellIndex) != -1;
}

function isBoundaryIndex(n, boundsIdx, i, j) {
    return boundsIdx.indexOf(i) > -1 || boundsIdx.indexOf(j) > -1;
}

function fillArray(n) {
    var num,
        html = '',
        nMid = n / 2,
        middleIdx = n % 2 == 1 ? [(n - 1) / 2] : [Math.floor(nMid) - 1, Math.ceil(nMid)],
        boundsIdx = [0, n - 1];
    for (var i = 0; i < n; i++) {
        html += '<tr>';
        for (var j = 0; j < n; j++) {
            num = isMiddleIndex(middleIdx, i, j) || isBoundaryIndex(n, boundsIdx, i, j) ? 1 : 0;
            html += '<td class="text-center">' + num + '</td>';
        };
        html += '</tr>';
    };
    return html;
}

$('table').html(fillArray(n));

var n=10；
函数isMiddleIndex（middledx、rowIndex、cellIndex）{
返回middledx.indexOf（rowIndex）！=-1&&middledx.indexOf（cellIndex）！=-1；
}
函数isBoundaryIndex（n，boundsIdx，i，j）{
返回boundsIdx.indexOf（i）>-1 | | boundsIdx.indexOf（j）>-1；
}
函数填充数组（n）{
var num，
html=“”，
nMid=n/2，
middleIdx=n%2==1？[（n-1）/2]：[Math.floor（nMid）-1，Math.ceil（nMid）]，其中，
boundsIdx=[0，n-1]；
对于（变量i=0；i

更具可读性的方式

    function fillArray(n) {
    var exArray = [];
    for (var i = 0; i < n; i++) {
        exArray[i] = [];
        for (var j = 0; j < n; j++) {
            exArray[i][j] = 0;
            if(i < j) {
                if(n - j - 1 > i) {
                    if(i % 2 == 0) {
                        exArray[i][j] = 1;
                    }
                }
                else {
                    if((n - j - 1) % 2 == 0) {
                        exArray[i][j] = 1;
                    }
                }
            }
            else {
                if(j > n - i - 1) {
                    if((n - i - 1) % 2 == 0) {
                        exArray[i][j] = 1;
                    }
                }
                else {
                    if(j % 2 == 0) {
                        exArray[i][j] = 1;
                    }
                }
            }
        };
    };
}

函数填充数组（n）{
var exArray=[]；
对于（变量i=0；ii）{
如果（i%2==0）{
exArray[i][j]=1；
}
}
否则{
如果（（n-j-1）%2==0）{
exArray[i][j]=1；
}
}
}
否则{
如果（j>n-i-1）{
如果（（n-i-1）%2==0）{
exArray[i][j]=1；
}
}
否则{
如果（j%2==0）{
exArray[i][j]=1；
}
}
}
};
};
}

和。
请发布一些不适用于正常工作的代码…否则，对预期结果的解释需要进一步澄清。如ref表所示，它需要不断填充交替的方块，直到到达中心。只有奇数的
n
…对偶数的
n
应该怎么做？你知道吗可以在参考图中看到。n=6，中间4个单元格得到1。每个交替的正方形都将被1填充，直到你到达中心。我想我误解了较大表格上的预期结果…前提是只有外部和内部得到零