javascript - js处理数组?

Question

arr数组最小长度是4最大是8
let num = 600；暂时写死600，这个数自定义输入的

麻烦各位大佬帮忙看看

Answer 1

示例代码

// 原始数据
const arr = [
    { id: 1, test: 5 },
    { id: 2, test: 4 },
    { id: 3, test: 5 },
    { id: 4, test: 6 },
];
const sum = 600;

// 计算行最大值，为了补齐矩阵
const max = arr.reduce((max, { test }) => Math.max(max, test), 0);
// 计算列数
const size = arr.length;
const matrix = arr
    // 产生矩阵
    .flatMap(({ id, test }) => [...Array(test).fill(id), ...Array(max - test).fill(0)])
    // 转置
    .map((_, i, arr) => arr[(i % size) * max + ~~(i / size)])
    // 去掉 0 值
    .filter(n => n);

// 计算随机数范围 Step
const trunk = sum / matrix.length;
// 计算随机数或范围
const result = matrix.map((col, i) => `第 ${col} 列：${i * trunk + 1} ~ ${(i + 1) * trunk}`);

console.log(result);

结果

第 1 列：1 ~ 30
第 2 列：31 ~ 60
第 3 列：61 ~ 90
第 4 列：91 ~ 120
第 1 列：121 ~ 150
第 2 列：151 ~ 180
第 3 列：181 ~ 210
第 4 列：211 ~ 240
第 1 列：241 ~ 270
第 2 列：271 ~ 300
第 3 列：301 ~ 330
第 4 列：331 ~ 360
第 1 列：361 ~ 390
第 2 列：391 ~ 420
第 3 列：421 ~ 450
第 4 列：451 ~ 480
第 1 列：481 ~ 510
第 3 列：511 ~ 540
第 4 列：541 ~ 570
第 4 列：571 ~ 600

注1：这里 result 中每项给的是字符串，也可以处理成结构化数据或其他需要的数据类型。
注2：如果需要按列，可以对 result 按列号分组再展开即可。

Answer 2

横向计算

function createListData(list, num = 600) {
    let count = list.reduce((n, i) => n + i.test, 0)
    let step = num / count | 0 // 不一定能整除，这里向下取整
    let data = list.map((item, index) => {
        return Array.from({length: item.test}).map(citem => {
            return {
                min: 0,
                max: 0
            }
        })
    })

    let max = Math.max(...list.map(i => i.test))
    let value = 0
    for (let index = 0; index < max; index++) {
        data.forEach(item => {
            if(item[index]){
                item[index].min = value + 1
                value += step
                item[index].max = num < value + step ? num : value
            }
        })
    }
    
    return data
}

let data = createListData(arr, 605)

竖向计算

function createListData(list, num = 600) {
    let count = list.reduce((n, i) => n + i.test, 0)
    let step = num / count | 0 // 不一定能整除，这里向下取整
    let value = 0
    let data = list.map((item, index) => {
        return Array.from({length: item.test}).map(citem => {
            let start = value
            value += step
            return {
                min: start + 1,
                max: num < value + step ? num : value
            }
        })
    })

    return data
}