第 67 题：随机生成一个长度为 10 的整数类型的数组

Question

随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下 [[2, 3, 4, 5], [10, 11], [20]]。

Answer 1

/**
@title题目：随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。

@methods思路: 10以下为一组 10以上1开头为一组,2一组，依次。。。
*/

   function create() {
        let arr = [];
        for(let i = 0; i< 10; i++) {
            arr.push(Math.floor(Math.random() * 100))
        }        
        arr = [...new Set(arr)]
        arr = arr.sort(function(a,b){return a-b})
        return arr;
   }    
   function sort(arr) {
    let newArr = [];
    let dict = {};
    let length = 0;
    let keyArr = [];
    arr.forEach((ele) => {
        let key = Math.floor(ele/10)
        keyArr = [];
        for(let i in dict) {
            keyArr.push(i * 1)
        }   
        if(keyArr.indexOf(key) > -1) {            
            newArr[dict[key]].push(ele)
        } else {            
            newArr[length] = [ele]
            dict[key] = length
            length ++;
        }
    })
    return newArr;
   }
   function transform() {
        let arr = create();
        let sortArr = sort(arr)
        return sortArr;
   }
   console.log(transform())

Answer 2

// 随机生成长度为 10 的整数
let arr = function randomArray() {
  let arr = []
  for(let i = 0; i < 10; i++) {
    arr.push(Math.floor(Math.random() * 100))
  }
  return arr
}()

// 排序
arr.sort((a,b) => a-b )

// 去重
arr = [...new Set(arr)]

// 连续值存一个数组，不连续的单独存一个数组
let resultArr = [],  newArr = [arr[0]],  index = 0                  
for(let i = 1; i < arr.length; i++) {
  if(arr[i] == arr[i -1] + 1) {
    newArr.push(arr[i])
  } else {
    resultArr.push(newArr)
    newArr = [arr[i]]
    index++
  }
}

console.log(arr)           // [36, 37, 44, 50, 57, 61, 62, 78, 79]
console.log(resultArr)     // [[36, 37], [44], [50], [57], [61, 62]]

代码测试地址

Answer 3

let arr = [20, 10, 11, 10, 2, 3, 1, 1];
        console.log(
            Object.values(
                [...new Set(arr)].sort((a, b) => a - b).reduce((obj, val) => {
                    let key = parseInt(val / 10);
                    Array.isArray(obj[key]) ? obj[key].push(val) : obj[key] = [val]
                    return obj
                }, {})
            )
        )    //[[1,2,3],[10,11],[20]]

菜鸟见解，轻喷

Answer 4

const randomArr = [];
while (randomArr.length<10) {
let num = parseInt(Math.random()*100);
if(randomArr.indexOf(num)==-1){
randomArr.push(num)
}
}
const sortArr = randomArr.sort((a,b)=>a-b);
//生成数组
console.log(sortArr)
const obj = {};
sortArr.forEach(el=>{
let cur = el+'';
if(cur.length==1){
if(!obj[0]){
obj[0] = [];
}
obj[0].push(el)
}else{
if(!obj[cur[0]]){
obj[cur[0]] = []
}
obj[cur[0]].push(el)
}
})
console.log(obj)
const arr = [];
for (const k in obj) {
arr.push(obj[k])
};
//输出结果
console.log(arr)

Answer 5

function randomNumber(len) {
    const max = 20;
    const arr = [];
    for (let i = 0; i < len; i++) {
        arr.push(Math.floor(Math.random() * max));
    }

    const sorted = [...new Set(arr)].sort((a, b) => a - b); // 去重排序
    return sorted;
}

function sort(arr) {
    let dict = {};
    let length = 0;
    arr.forEach(i => {
        let key = Math.floor(i / 10);
        if (Reflect.has(dict, key)) {
            dict[key].push(i);
        } else {
            dict[key] = [i];
            length++;
        }
    });
    dict.length = length;
    return Array.from(dict);
}

const res = randomNumber(10);
console.log(sort(res));

Answer 6

function test(len, range) {
    let test = [];

    for (let i = 0; i < len; i++) {
      test.push(Math.round(Math.random() * range));
    }

    test =  Array.from(new Set(test)).sort((a, b) => a - b);

    let arr1 = [];

    for (let i = 0, len = parseInt(Math.max(...test) / 10) + 1; i < len; i++) {
      arr1.push([]);
    }

    test = test.map(item => {
      const section = parseInt(item / 10);
      arr1[section].push(item);
    })

    console.log(arr1);
  }


test(10, 20);

Answer 7

const arr = Array.from({
        length: 10
      }, () => ~~(Math.random() * 50)) //创建数据
      .sort((a, b) => a - b), //排序
      arr1 = [...new Set(arr.map(i => ~~(i / 10)))] //划分区域
      .map(i => arr.filter(a => ~~(a / 10) === i)) //数据划分

Answer 8

// 生成随机数组
function createNum() {
var arr = []
for(var i =0; i<10; i++) {
var num = Math.floor(Math.random()*100)
arr .indexOf(num)!=-1?i--:arr .push(num)
}
arr.sort((a,b) => { return a-b } )
return arr
}

// 生成map
function createMap () {
var map = {}
createNum().forEach(item => {
if(map[Math.floor(item/10)]) {
map[Math.floor(item/10)].push(item)
} else {
map[Math.floor(item/10)] = [item]
}
})
return map
}

// 结果
var numMap = createMap()
var newArr = []
for(var o in numMap ) {
newArr.push(numMap [o])
}

Answer 9

/**
题目：随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。

理解：把连续的数字从小到大放到一个数组中
*/

//生成随机数
let arr = Array.from({length:10},()=>~~(Math.random()*20));
//[2, 10, 3, 4, 5, 11, 10, 11, 20]
[...new Set(arr)].sort((a,b)=>a-b).reduce((a,b)=>{
  var l= a.slice(-1)[0]; 
  l&& l.slice(-1)[0] + 1 == b ? l.push(b) : a.push([b]);
  return a;
},[]) // [[2,3,4,5],[10,11],[20]]

Answer 10

比较通俗的解法~

function createRandomArray(length = 10) {
    var arr = [];
    for(var i = 0; i < length; i++) {
        arr.push(parseInt(Math.random() * 100))
    }
    return arr;
}

function sort(arr) {
    return arr.sort((a, b) => a - b)
}

function part(arr) {
    var length = arr.length;
    var map = {};
    for(var i = 0; i < length; i++) {
        var tp = parseInt(arr[i]/10);
        if(map[tp]) {
            map[tp].push(arr[i])
        }else {
            var value = [];
            map[tp] = [...value, arr[i]]
        }
    }
    return map
}

function genArray(map) {
    var arr = []
    for(var key in map) {
        arr.push(map[key])
    }
    return arr;
}

var randomArray = createRandomArray();
var sortedRandomArray = sort(randomArray);
var partMap = part(sortedRandomArray);
var result = genArray(partMap);
console.log(result);

Answer 11

  let arr = [2, 10, 3, 4, 5, 11, 10, 11, 20];

  arr = Array.from(new Set(arr)).sort((a, b) => a - b);

  let start = 0;
  for(let i = 0; i < arr.length - 1; i ++){
    if (arr[i + 1] - arr[i] > 1) {
      console.log(arr.slice(start,i + 1));
      start = i + 1;
    }
  }
  console.log(arr.slice(start,arr.length));

以为求连续 + 1

Answer 12

const arr = Array.from({
        length: 10
      }, () => ~~(Math.random() * 50)) //创建数据
      .sort((a, b) => a - b), //排序
      arr1 = [...new Set(arr.map(i => ~~(i / 10)))] //划分区域
      .map(i => arr.filter(a => ~~(a / 10) === i)) //数据划分

arr没有去重

Answer 13

// 随机生成长度为 10 的整数
let arr = function randomArray() {
  let arr = []
  for(let i = 0; i < 10; i++) {
    arr.push(Math.floor(Math.random() * 100))
  }
  return arr
}()

// 排序
arr.sort((a,b) => a-b )

// 去重
arr = [...new Set(arr)]

// 连续值存一个数组，不连续的单独存一个数组
let resultArr = [],  newArr = [arr[0]],  index = 0                  
for(let i = 1; i < arr.length; i++) {
  if(arr[i] == arr[i -1] + 1) {
    newArr.push(arr[i])
  } else {
    resultArr.push(newArr)
    newArr = [arr[i]]
    index++
  }
}

console.log(arr)           // [36, 37, 44, 50, 57, 61, 62, 78, 79]
console.log(resultArr)     // [[36, 37], [44], [50], [57], [61, 62]]

代码测试地址

你这个数组最后一个值是没有放到结果数组里面去的？

Answer 14

// 生成随机数组
const randomArr = (n = 10, range = { min: 1, max: 20 }) => {
  let arr = new Array(n).fill(0);
  arr = arr.map(val => {
    val = Math.floor(Math.random() * (range.max - range.min) + range.min);
    return val;
  });
  return arr;
};

let arr = randomArr();

// 数组去重
arr = Array.from(new Set(arr));
// 数组排序
arr = arr.sort((a, b) => a - b);
console.log(arr);

let newArr = [[arr[0]]];
let k = 0; // 已经标记已经计算过的子组
for (let i = 1, l = arr.length; i < l; i++) {
  for (let j = k; j < newArr.length; j++) {
    let len = newArr[j].length;
    if (arr[i] === newArr[j][len - 1] + 1) {
      // 如果与子组的最后一位相邻，就压入
      newArr[j].push(arr[i]);
    } else {
      // 如果与子组的最后一位不相邻，就压入新子组
      newArr.push([arr[i]]);
      // 已经标记已经计算过的子组
      k++;
      break;
    }
  }
}
console.log(newArr);
``

Answer 15

/**
 * 返回 min 到 max 之间的随机整数，包括 min 和 max
 */
function getRandomInt(min, max) {
  const MIN = Math.ceil(min);
  const MAX = Math.floor(max);
  return Math.floor(Math.random() * (MAX - MIN + 1)) + MIN;
}

/**
 * 返回指定长度的数组，数组元素为[0, 99]的随机整数
 */
function getRandomArray(length) {
  return Array.from({ length }, item => getRandomInt(0, 99));
}

/**
 * 返回处理后的数组，包括排序、去重和分类
 */
function getProcessedArray(array) {
  const sortedArray = [...array].sort((a, b) => a - b);
  const uniqueSortedArray = [...(new Set(sortedArray))];
  const hash = {};
  let result = [];
  uniqueSortedArray.forEach((val, i) => {
    const key = Math.floor(val / 10);
    if (!hash[key]) {
      hash[key] = [uniqueSortedArray[i]];
    }
    else {
      hash[key].push(uniqueSortedArray[i]);
    }
  })
  for (let key in hash) {
    result.push(hash[key]);
  }
  return result;
}

// 测试
const array = getRandomArray(10);
console.log(array);
console.log(getProcessedArray(array)); // 纯函数
console.log(array); // 不改变原数组

Answer 16

既然用到了sort就不用set去重了，双reduce搞定

const arrange = arr => {
  return arr
    .sort((a, b) => a - b)
    .reduce(
      (acc, cur) => (acc[acc.length - 1] === cur ? acc : acc.concat([cur])),
      [],
    )
    .reduce(
      (acc, cur) => {
        return ~~(acc[acc.length - 1][0] / 10) === ~~(cur / 10)
          ? (acc[acc.length - 1].push(cur), acc)
          : (acc.push([cur]), acc);
      },
      [[]],
    );
};

Answer 17

// 生成10个随机整数数组
function gen(length) {
return new Array(length || 10).fill(0).map(() => Math.round(Math.random() * 100));
}
// 处理
function resolve(nums) {
let ans = [];
// 排序
nums.sort((a, b) => a - b);
// 遍历
let index = 0;
for (let i = 0; i < nums.length; i++) {
if (!ans[index]) {
ans[index] = [nums[i]];
} else {
// 填充
if (nums[i] < 10) {
ans[index].push(nums[i]);
} else if (nums[i].toString()[0] === nums[i - 1].toString()[0]) {
ans[index].push(nums[i]);
} else {
i--;
index++;
}
}
}
return ans;
}
console.info('处理结果：', resolve(gen(50)));

Answer 18

用�hash来存区间

/**
 * 随机生成一个长度为 10 的整数类型的数组，
 * 例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]
 * 将其排列成一个新数组，要求新数组形式如下，
 * 例如 [[2, 3, 4, 5], [10, 11], [20]]。
 */

/**  得到一个两数之间的随机整数，包括两个数在内 */
const getRandomIntInclusive = (min, max) =>
  Math.floor(Math.random() * (max - min + 1) + min);

// 生成数组
let arr = Array.from({ length: 10 }, () => getRandomIntInclusive(0, 20));
// 排序
arr = arr.sort((a, b) => a - b);

const intArr = Array.from(new Set([...arr]));
const map = new Map();
intArr.map((i) => {
  const index = Math.floor(i / 10);
  map.has(index) ? map.set(index, [...map.get(index), i]) : map.set(index, [i]);
});

let resArr = [];
for (const [k, v] of map) {
  resArr.push(v);
}
console.log('resArr: ', resArr);

Answer 19

连续元素分类

// 得到一个两数之间的随机整数，包括两个数在内
function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
}
// 随机生成10个整数数组, 排序, 去重
let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 99) });
initArr.sort((a, b) => { return a - b });
initArr = [...(new Set(initArr))];

// 连续元素分类放入数组
let continueArr = [], tempArr = [];
initArr.map((e, index) => {
    tempArr.push(e);
    if (initArr[index+1] !== ++e) {
        continueArr.push(tempArr);
        tempArr = [];
    }
});
console.log(continueArr);

学到了 Array.from 竟然还有第二个参数

Answer 20

/**
 * @param {*} min 生成随机数最小范围
 * @param {*} max 生成随机数最大范围
 * @param {*} arrLength 生成数组长度
 */
const randomArr = (min, max, arrLength) => {
  //区间取整
  min = Math.ceil(min)
  max = Math.floor(max)
  //Array.from() 可以通过以下方式来创建数组对象：
  //伪数组对象（拥有一个 length 属性和若干索引属性的任意对象）
  //可迭代对象（可以获取对象中的元素,如 Map和 Set 等）
  //Aarray 第二个参数：如果指定了该参数，新数组中的每个元素会执行该回调函数。
  return Array.from(
    { length: arrLength },
    () => Math.floor(Math.random() * (max - min + 1)) + min
  ) //含最大值，含最小值
}

// 排列数组函数
const arrConvert = arr => {
  // 去重 排序
  arr = Array.from(new Set(arr)).sort((a, b) => a - b)
  let index = 0
  //作为临时数组
  let tep = []
  //结果数组
  const result = []
  // 先推进去第一个数
  tep.push(arr[index])
  while (index < arr.length) {
    if (arr[index + 1] - arr[index] === 1) {
      tep.push(arr[index + 1])
    } else {
      result.push(tep)
      tep = [arr[index + 1]]
    }
    index++
  }
  return result
}

// console.log(arrConvert(data))
console.log(arrConvert(randomArr(0, 100, 10)))

随机函数借鉴了楼上前辈的（Array.from 第二个参数学到了！）
不知道我这样写行不行，望前辈们指点

Answer 21

遍历的次数有点多

function order(arr) {
  const map = arr.reduce((pre, cur, i) => {
    if (!pre[arr[i]] && !arr.some(item => item === arr[i] - 1)) {
      pre[arr[i]] = [arr[i]]
    }
    return pre
  }, {})

  Object.keys(map).forEach(key => {
    const current = map[key]
    arr.forEach(item => {
      if (item === current[current.length - 1] + 1) {
        current.push(item)
      }
    })
  })

  return Object.keys(map).reduce((pre, cur) => {
    pre.push(map[cur])
    return pre
  }, [])
}

Answer 22

// 随机数字数组
let randomArr = [2, 10, 3, 4, 5, 11, 10, 11, 20];
// 去重 排序
let arr = Array.from(new Set(randomArr)).sort((n1, n2) => {
return +n1 < +n2 ? -1 : 1;
});
let arr1 = [];
// 标记 不连续处标记‘XX’ 结果存放在arr1
for (let index = 1; index < arr.length; index++) {
let prev = arr[index - 1];
let current = arr[index];
arr1.push(prev)
if (current !== prev + 1) {
arr1.push('XX')
}
}
arr1.push(arr[arr.length - 1])
// 转为字符串处理
let result = arr1.join(',').split('XX').map(item => {
// 去掉多余的','，转为整数数组
return item.replace(/^,|,$/g, '').split(',').map(i => +i)
})
console.info(result)

Answer 23

const arr = [2, 10, 3, 4, 5, 11, 10, 11, 20, 55];
let res = [];
arr.sort((a, b) => a - b);
arr.forEach((n) => {
const index = (n / 10) | 0;
(res[index] || (res[index] = [])).push(n);
});
res = res.filter(Boolean);
console.log('res', res)

Answer 24

// 1.连续形式
      var a = [2, 10, 3, 4, 5, 11, 10, 11, 20];
      function fn(arr) {
        let res = [],
          idx = 0;
        let arrSort = [...new Set(arr.sort((a, b) => a - b))];
        arrSort.forEach((item, index) => {
          if (index) {
            if (item - arrSort[index - 1] > 1) {
              ++idx;
            }
          }
          if (!res[idx]) {
            res[idx] = [];
          }
          res[idx].push(item);
        });
        return res;
      }

//2. 0～9，10～19形式
      function fn(arr) {
        let res = [],
          start = (idx = 0);
        let arrSort = [...new Set(arr.sort((a, b) => a - b))];
        arrSort.forEach(item => {
          if (item >= start + 10) {
            ++idx;
            start += 10;
          }
          if (!res[idx]) {
            res[idx] = [];
          }
          res[idx].push(item);
        });
        return res;
      }

Answer 25

// 获取随机数
const randomArr = [...new Array(10)].map(item => +(Math.random() * 20).toFixed())

// 连续值(区间那个就不写了,区间的难度应该小点?)
let setArr = [...new Set(randomArr)].sort((a, b) => a - b)
let result = []
do {
let first = setArr[0]
const brother = setArr.filter(f => ((first + 1) == f) && (++first))
result.push(setArr.splice(0, brother.length + 1))
} while (setArr.length);

console.log(result); // 得到结果

Answer 26

function handleRandom(count) { // count 数据的大小
  const arr = Array.from({length: 10}, () => Math.ceil(Math.random() * count));
  const dealArr = [...new Set(arr)].sort((a, b) => a - b);
  const map = {};
  dealArr.forEach(ele => {
    const key = Math.floor(ele/10);
    map[key] = map[key] || [];
    map[key].push(ele);
  })
  return Object.values(map);
}
console.log(handleRandom(100))

Answer 27

比较简洁的写法，双指针。

function bar(nums) {
  nums = Array.from(new Set(nums)).sort((a, b) => a - b);

  let p1 = 0;
  let p2 = 0;

  const res = [];
  while (p2 < nums.length) {
    if (nums[p2] === nums[p2 + 1] - 1) {
      // 如果是连续递增，则p2 指针前进
      p2++;
    } else {
      // 不再连续，切分出子数组
      res.push(nums.slice(p1, ++p2));
     // 把p1 移动到p2的位置上
      p1 = p2;
    }
  }
  return res;
}

Answer 28

连续元素分类

// 得到一个两数之间的随机整数，包括两个数在内
function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
}
// 随机生成10个整数数组, 排序, 去重
let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 99) });
initArr.sort((a, b) => { return a - b });
initArr = [...(new Set(initArr))];

// 连续元素分类放入数组
let continueArr = [], tempArr = [];
initArr.map((e, index) => {
    tempArr.push(e);
    if (initArr[index+1] !== ++e) {
        continueArr.push(tempArr);
        tempArr = [];
    }
});
console.log(continueArr);

学到了 Array.from 竟然还有第二个参数

还有第三个参数，哈哈哈哈哈

Answer 29

function randomArrByNum(num, min, max) {
  return Array(num).fill(null).map(() => Math.floor(Math.random() * (max - min + 1) + min));
}

function sortByOrder() {
  let arr = randomArrByNum(10, 1, 20);
  arr.sort((a, v) => a - v);
  console.log(arr);
  let temp = [], result = [];
  while (arr.length > 0) {
    const cur = arr.shift();
    if (temp.length === 0) {
      temp.push(cur);
      continue;
    }
    if (cur - temp[temp.length - 1] > 1) {
      result.push(temp);
      temp = [];
      temp.push(cur);
    } else {
      temp.push(cur);
    }
  }
  if (temp.length !== 0) result.push(temp);
  return result;
}

Answer 30

const random = (min, max) => {
	return Math.floor(Math.random() * (max - min + 1) + min)
}
const getArr = () => {
	const result = []
	for (let index = 0; index < 10; index++) {
		result.push(random(0, 20))
	}
	return result
}
const newArray = () => {
	const arr = getArr();
	console.log('原数组',arr)
	const result = [];
	return arr.reduce((total, item) => {
		const new_index = Math.floor(item / 10);
		if (total[new_index]) {
			total[new_index].push(item)
		} else {
			total[new_index] = [item]
		}
		return total;
	}, [])
}
console.log(newArray())

Answer 31

const arr = Array.from({
        length: 10
      }, () => ~~(Math.random() * 50)) //创建数据
      .sort((a, b) => a - b), //排序
      arr1 = [...new Set(arr.map(i => ~~(i / 10)))] //划分区域
      .map(i => arr.filter(a => ~~(a / 10) === i)) //数据划分

你这操作有点6

Answer 32

var gs = [];
Array.from({ length: 10 }, tmp => ~~(Math.random() * 100))
  .sort((n1,n2)=>n1-n2) // 一次性排序
  .forEach(n=>{
    const b = ~~(n / 10);   // 取分组（0~9被氛围一组，10~19被分为一组，可见基数为10）
    const g = gs[b] || (gs[b] = []);  // 获取分组，没有就创建
    if (!g.includes(n)) g.push(n);    // 去重，没用set，因为set还得转
  });

console.log(JSON.stringify(gs));
结果: [null,[18],null,[30,36],[46],[55],[66],[74],[80,81]]
// 不想保留准确的index([70,78]=>7)，可以再filter一下

Answer 33

function pushNum(arr) {
    let arr_sort = arr.sort((a,b)=>{
        return a-b
    })
    var set = new Set(arr_sort)
    arr_sort = [...set]
    let list = []
    let num = 0
    let num_fake = 0
    arr_sort.forEach(ele => {
        if(num >= Math.floor(ele / 10)) {
            if(!(typeof(list[num_fake]) === "object"))  list[num_fake] = []
            list[num_fake].push(ele)
        } 
        else {
            if(!(typeof(list[++num_fake]) === "object"))  list[num_fake] = []
            list[num_fake].push(ele)
            num = Math.floor(ele / 10)
        }
    });
    return list
}
let array = new Array(10)
for(var i = 0; i < array.length; i++) {
    array[i] = Math.floor(Math.random() * 100)
}
console.log(pushNum(array))

一般通过 还能优化

Answer 34

let nums = [2, 10, 3, 4, 5, 11, 10, 11, 20];
let res = []

nums.forEach(i => {
let posi = Math.floor(i / 10);

if(res[posi] && res[posi].length) {
    res[posi].push(i)
} else {
    res[posi] = []
    res[posi].push(i)
}

})

console.log('res===',res);

Answer 35

const getRandomArray = (max = 100) => {
  return Array.from(new Array(10)).map(() => Math.floor(Math.random() * max));
};
const solution = (arr) => {
  const res = [];
  const collection = new Map();

  arr.forEach((element) => {
    const k = Math.floor(element / 10);
    const v = collection.get(k);
    if (!v) {
      collection.set(k, new Set([element]));
    } else {
      v.add(element);
    }
  });
  for (let [k, v] of collection) {
    res.push({
      order: k,
      values: Array.from(v)
    });
  }
  return res
    .sort((a, b) => a.order - b.order)
    .reduce((res, v) => {
      const { values } = v;
      res.push(values);
      return res;
    }, []);
};

Answer 36

function test() {
    let arr = Array.from({ length: 10 }).map(key => Math.ceil(Math.random() * 10));
    arr = Array.from(new Set(arr)).sort((a, b) => a - b);
    let i = 0, len = arr.length, result = [], temp = [];
    while (i < len) {
        if (temp.length) {
            if (arr[i] === (+temp.slice(-1) + 1)) {
                temp.push(arr[i]);
            } else {
                result.push(temp);
                temp = [arr[i]];
            }
        } else {
            temp.push(arr[i])
        }
        if (i === len - 1) {
            result.push(temp);
        }
        i++;
    }
    return result;
}

Answer 37

function fn(arr) {
arr = [...new Set(arr)].sort((a, b) => a - b)
let result = []
let offset = arr[0]
let temp = []
for (let i = 0; i < arr.length; i++) {
if (arr[i] !== i + offset) {
result.push(temp)
temp = [arr[i]]
offset = arr[i] - i
} else {
temp.push(arr[i])
}
}
return result
}

Answer 38

function randAry(len = 10, base = 100) {
        const res = []
        for (let i = 0; i < len; i++) {
            // 不包含100
            res.push(Math.floor(Math.random() * base))
        }
        return res
    }
    const baseAry = randAry()
    console.log(baseAry);

    function select(ary) {
        const res = []
            // 去重
        ary = [...new Set(ary)]
        for (const val of ary) {
            // const curInx = val < 10 ? ('0' + val)[0] : (val + '')[0] || 0
            const curInx = Math.floor(val / 100)
            if (!res[curInx]) {
                res[curInx] = []
            }
            res[curInx].push(val)
        }
        return res
    }

    console.log(select(baseAry));

Answer 39

// ---------------------------------以相邻数值为一组----------------------------------
let random = (min, max) => {
  return Math.floor(Math.random() * (max - min)) + min
}
// 随机生成10条数组
let data =  Array.from({length: 10}).map(x => random(1, 100));
// 数组去重
data = [...new Set([...data])];
// 数组排序
data.sort((a, b)=> a - b);

let setArray1 = (data) => {
  let newArr = [data[0]];
  let result = [];
  for (let i = 1; i < data.length; i++) {
    // 当前数值等于前一个数值+1
    if (data[i] == data[i - 1] + 1) {
      newArr.push(data[i]);
    } else {
      result.push(newArr)
      newArr = [data[i]];
    }
    // 最后一条也要加进去
    if(i == data.length -1) {
      result.push(newArr)
    }
  }
  return result
}

let setArray2 = (data) => {
  let newArr = [data[0]];
  let result = [];
  for (let i = 1; i < data.length; i++) {
    // 判断数组中有没有当前数值-1
    if(newArr.includes(data[i] - 1)){
      newArr.push(data[i]);
    } else {
      result.push(newArr)
      newArr = [data[i]];
    }
    // 最后一条也要加进去
    if(i == data.length - 1) {
      result.push(newArr)
    }
  }
  return result
}

console.log(data);  // [41, 45, 47, 48, 55, 65, 75, 76, 85, 98]
console.log(setArray1(data)); // [[41], [45], [47, 48], [55], [65], [75, 76], [85], [98]]
console.log(setArray2(data)); // [[41], [45], [47, 48], [55], [65], [75, 76], [85], [98]]


// ---------------------------------以[1-9]、[10-19]、[20-29] ... 为一组----------------------------------

let setArray3 = (data) =>{
  let obj = {}
  let result = []
  for (let i = 0; i < data.length; i++) {
    let num = Math.floor(data[i]/10);
    if(obj[num]) {
      obj[num].push(data[i])
    } else {
      obj[num] = [data[i]]
    }
  }
  for (const key in obj) {
    result.push(obj[key])
  }
  return result
}

console.log(setArray3(data)); // [[41, 45, 47, 48], [55], [65], [75, 76], [85], [98]]

Answer 40

const arr = Array.from({ length: 10 }, () => Math.floor(Math.random() * 100)).sort((a, b) => a - b)

function fn(arr) {
    const result = {}
    arr.forEach(n => {
        const key = Math.floor(n / 10)
        result[key] ? result[key].push(n) : result[key] = [n]
    });
    return Object.values(result)
}

fn(arr)

Answer 41

看了前几个写的，随机生成的数组都是有重复值的，去重会减少数组长度不可取

const list = randInt(20, 10); // 1-20随机生成10个不重复的整数
group(list);

function randInt(max, num) {
  const map = [];
  for (let i = 1; i <= max; i++) {
    map.push(i);
  }

  const res = [];
  for (let i = 0; i < num; i++) {
    const randIndex = Math.random() * (map.length - 1) + 1;
    res.push(map.splice(~~randIndex, 1)[0]);
  }

  return res;
}

function group(arr) {
  arr.sort(function (a, b) {
    return a - b;
  });

  const res = [];
  for (const item of arr) {
    const index = ~~(item / 10);
    if (!res[index]) {
      res.push([]);
    }

    res[index].push(item);
  }

  return res;
}

Answer 42

const radomList = []
// 生成随机数组
for(let i = 0;i<10;i++){
radomList.push(Math.floor(Math.radomi10))
}

// 去重+排序
const unique = Array.from(new Set(...radomList)).sort((a, b) => {return a-b})

// 归类
const obj = {}
unique.forEach((item, index) => {
const t = Math.floor(item/10)
if(!obj[t]){
obj[t] = []
}
obj[t].push(item)
})

//对象转数组
const finallList = []
for(const key in obj){
finallList.push(obj[key])
}

Answer 43

function method(arr) {
  arr = Array.from(new Set(arr.sort((a, b) => a - b)))
  const result = []
  const len = arr[arr.length - 1] / 10 + 1
  let current = 0
  for (let i = 1; i <= len; i++) {
    console.log(i)
    let min = (i - 1) * 10
    let max = 10 * i
    const temp = []
    for (let j = current; j < arr.length; j++) {
      if (arr[j] >= min && arr[j] < max) {
        temp.push(arr[j])
        if (j === arr.length - 1) {
          result.push(temp)
        }
      } else {
        if (temp.length > 0) {
          current = j
          result.push(temp)
        }
        break
      }
    }
  }
  return result
}
function randomMethod() {
  const arr = []
  arr.length = 10
  for (let i = 0; i < arr.length; i++) {
    arr[i] = Math.floor(Math.random() * 100)
  }
  return arr
}
console.log(method(randomMethod()))

Answer 44

/* 
	思路: 
	(1) 先去重并升序排序 --> [2, 3, 4, 5, 10, 11, 20]
	(2) 区间划分[0,9] [10,19] [20,29 ...
*/
// 二分查找 
// 参数说明: arr --> 数组 target --> 查找目标 lo --> 查找起始下标 默认为0
function binSearch(arr, target, lo = 0) {
    let hi = arr.length // 查找最大长度
    let mid // 中点下标
    while (lo < hi) {
        mid = (lo + hi) >> 1
        target < arr[mid] ? hi = mid : lo = mid + 1
    }
    
    return --lo // 返回不超过target的最大下标
}

function getArr(arr) {
    arr = [...new Set(arr)].sort((a,b) => a - b) // 去重并升序排序
    let result = []
    let start = 0 // 起点
    while (start < arr.length) { // 起点未越界表示处理并未全部完成
        let temp = (arr[start] + 10) - (arr[start] + 10)%10 // 取整 (2+10) - 12%2 = 10
        let index = binSearch(arr,temp - 1, start) // 循环第一次是查找9
        result.push(arr.slice(start,index+1))
        start = index + 1 // 更新起始点 很重要 
    }
    
    return result
}

let arr = [2, 3, 4, 5, 10, 11, 20]
console.log(getArr(arr))

Answer 45

function fun() {
    // 获取非重复的随机整数数
  let getRandom = (()=>{
    let set=new Set()
    return ()=>{
      let random = Math.floor(Math.random()*100)+1
      while (set.has(random)) {
        random = Math.floor(Math.random()*100)+1
      }
      set.add(random)
      return random
    }
  })()

  // 生成随机整数数组
  let arr = Array.from({length:10},function (item,index) {
    return getRandom()
  })

  // 数组升序排序
  let ascArr = arr.sort((a,b)=>{
    return a-b
  })

  // 根据元素/10的商将数组元素存在到finArr指定坐标内
  let finArr = []
  ascArr.forEach((item)=>{
    // 坐标 0 ：小于10的值。
    // 坐标 1 ：小于20的值。
    // 坐标 2 ：小于30的值。
    // ....
    let index = Math.floor(item/10)
    Array.isArray(finArr[index])? finArr[index].push(item):finArr[index]=[item]
  })

  // 删除为empty的元素
  let res = finArr.filter((item)=>{
    return Array.isArray(item)
  })

  return res
}

Answer 46

连续元素分类

// 得到一个两数之间的随机整数，包括两个数在内
function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
}
// 随机生成10个整数数组, 排序, 去重
let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 99) });
initArr.sort((a, b) => { return a - b });
initArr = [...(new Set(initArr))];

// 连续元素分类放入数组
let continueArr = [], tempArr = [];
initArr.map((e, index) => {
    tempArr.push(e);
    if (initArr[index+1] !== ++e) {
        continueArr.push(tempArr);
        tempArr = [];
    }
});
console.log(continueArr);

Answer 47

function Test(){

let a = Array.from(new Set(new Array(10).fill(1).map(_ => Math.ceil(Math.random() * 10)))).sort((a, b) => a - b);

let result = [[a[0]]];

if(a.length === 1){
return result;

}

a.reduce((prev, next) => {

if(next - prev === 1){

result[result.length - 1].push(next);

}else{

result.push([next]);
}

return next;

})
return result;

}

Answer 48

[...new Set([...Array(10)].map(x = >parseInt(Math.random() * 10)))].sort((x, y) = >x - y).reduce(function(acc, cur, index, source) {
if (cur - acc[acc.length - 1] !== 1 && acc.length > 0) {
acc.push('-')
}
acc.push(cur) return acc
},
[]).toString().replace(/,/g, '').split('-').map((x) = >[x.split('')])

Answer 49

去重后还要保证数组的长度是不是10...

Answer 50

// 隨機生成 Array
function randomArray(length = 10, max = 100) {
  return Array.from({ length }, () => ~~(Math.random() * max))
}

// 10位分組
function newArray(array) {
  return array
    .reduce((acc, c) => {
      let i = ~~(c / 10)
      if (!acc[i]) acc[i] = []
      acc[i].push(c)
      return acc
    }, [])
    .filter(c => !!c)
    .map(arr => Array.from(new Set(arr)).sort())
}

// 連續數列分組
function continueArray(array) {
  return Array.from(new Set(array))
    .sort((a, b) => a - b)
    .reduce(
      (acc, c, i, arr) => {
        if (i === 0) acc[0].push(c)
        else {
          if (arr[i - 1] !== c - 1) acc.push([])
          acc[acc.length - 1].push(c)
        }
        return acc
      },
      [[]]
    )
}

let a = randomArray(10, 20)
newArray(a)
continueArray(a)

Answer 51

我发现楼上的朋友们和我想的不太一样啊，我理解的题目意思是把连续的元素组成一个数组，比如1,2,3,4组成一个数组，7,8,9,10组成一个数组，楼上的做法基本是把0-9,10-19这样的区间组成一个数组。姑且也贴一个我的理解的解法。

// 第 67 题：随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。

// 随机生成数组
const randomAry = (n = 10, range = { min: 1, max: 20 }) => {
  let ary = new Array(n).fill(0)
  ary = ary.map((val) => {
    val = Math.floor(Math.random() * (range.max - range.min + 1) + range.min)
    return val
  })
  console.log('random: ', ary)
  return ary
}
let ary = randomAry()
// 去重
ary = Array.from(new Set(ary))
// 排序
ary.sort((a, b) => a - b)
console.log('sorted: ', ary)
// 保存结果
let newAry = []
for (let i = 0; i < ary.length; i++) {
  let tmpAry = [ary[i]]
  // index用于跳过已经处理过的数组元素
  let index = ary.length
  for (let j = i + 1, count = 1; j < ary.length; j++, count++) {
    if (ary[i] + count === ary[j]) {
      tmpAry.push(ary[j])
    } else {
      index = j - 1
      break
    }
  }
  i = index
  // debugger
  newAry.push(tmpAry)
}
console.log('result', newAry)

是的就是这个操作

Answer 52

我发现楼上的朋友们和我想的不太一样啊，我理解的题目意思是把连续的元素组成一个数组，比如1,2,3,4组成一个数组，7,8,9,10组成一个数组，楼上的做法基本是把0-9,10-19这样的区间组成一个数组。姑且也贴一个我的理解的解法。

// 第 67 题：随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。

// 随机生成数组
const randomAry = (n = 10, range = { min: 1, max: 20 }) => {
  let ary = new Array(n).fill(0)
  ary = ary.map((val) => {
    val = Math.floor(Math.random() * (range.max - range.min + 1) + range.min)
    return val
  })
  console.log('random: ', ary)
  return ary
}
let ary = randomAry()
// 去重
ary = Array.from(new Set(ary))
// 排序
ary.sort((a, b) => a - b)
console.log('sorted: ', ary)
// 保存结果
let newAry = []
for (let i = 0; i < ary.length; i++) {
  let tmpAry = [ary[i]]
  // index用于跳过已经处理过的数组元素
  let index = ary.length
  for (let j = i + 1, count = 1; j < ary.length; j++, count++) {
    if (ary[i] + count === ary[j]) {
      tmpAry.push(ary[j])
    } else {
      index = j - 1
      break
    }
  }
  i = index
  // debugger
  newAry.push(tmpAry)
}
console.log('result', newAry)

Answer 53

var arr = [2, 10, 3, 4, 5, 11, 10, 11, 20];
arr.sort(function(a, b) {
	return a - b
});
arr = [...new Set(arr)];
var result = [];
arr.forEach(function(val) {
	let index = parseInt(val / 10);
	if (!result[index]) {
		result[index] = [];
	}
	result[index].push(val);
})
result = result.filter(arr => arr.length > 0);
console.log(result);

Answer 54

// 随机生成一个长度为10的数组
function buildArr() {
	var _arr = [];
	for(var i=0; i<10; i++) {
		_arr.push(Math.floor(Math.random() * 20))
	}
	return _arr;
}

// 排序去重
function sortArr(a) {
	var _arr = [];
	for(var i=0; i<a.length; i++) {
		if(_arr.indexOf(a[i]) < 0) {
			_arr.push(a[i]);
		}
	}
	_arr.sort(function(item1, item2) {
		return item1 - item2;
	});
	return _arr;
}

// 整合
function intoArr(a) {
	if(a.length < 0)
		return [];
	var _arr = [];
	var _idx = 0;
	function p(item) {
		if(!_arr[_idx]) {
			_arr[_idx] = [];
		}
		_arr[_idx].push(item);
	}
	for(var i=0; i<a.length; i++) {
		if(i == 0 || a[i] - a[i-1] == 0 || a[i] - a[i-1] == 1) {
			p(a[i]);
		}
		else {
			_idx++;
			p(a[i]);
		}
	}
	return _arr;
}

var arr = buildArr(); // 生成长度为10的数组
console.log('生成数组', arr);
arr = sortArr(arr); // 排序去重
console.log('排序去重', arr);
arr = intoArr(arr); // 整合
console.log('整合数组', arr);

Answer 55

// 生产随机数
var arr = (function(len){
    var a = []
    for(var i = 0; i < len; i++) {
        a.push(Math.floor(Math.random() * 100))
    }
    return a
})(20)

// 排序
arr.sort(function(a, b) {
    return a - b
})
// 去重 (arr 转 set 然后 set 转 arr)
arr = [...(new Set([...arr]))]

var subArr = []

// 用 map 存储
var map = {}
arr.forEach(item => {
    var key = Math.floor(item / 10)
    if(!map[key]) {
        map[key] = []
    }
    map[key].push(item)
})

// map 转 数组
for(var key in map) {
    subArr.push(map[key])
}

console.log(JSON.stringify(subArr))

Answer 56

区间分类

// 得到一个两数之间的随机整数，包括两个数在内
function getRandomIntInclusive(min, max) {
    min = Math.ceil(min);
    max = Math.floor(max);
    return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 
}
// 随机生成10个整数数组, 排序, 去重
let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 99) });
initArr.sort((a,b) => { return a - b });
initArr = [...(new Set(initArr))];

// 放入hash表
let obj = {};
initArr.map((i) => {
    const intNum = Math.floor(i/10);
    if (!obj[intNum]) obj[intNum] = [];
    obj[intNum].push(i);
})

// 输出结果
const resArr = [];
for(let i in obj) {
    resArr.push(obj[i]);
}
console.log(resArr);

Answer 57

我起的早, 我先来吧

受思维惯性, 以为是求连续, 好吧, 修改了一波

function formArray(arr: any[]) {
  const sortedArr = Array.from(new Set(arr)).sort((a, b) => a - b);

  const map = new Map();

  sortedArr.forEach((v) => {
    const key = Math.floor(v / 10);
    const group = map.get(key) || [];
    group.push(v);

    map.set(key, group);
  });

  return [...map.values()];
}

// 求连续的版本
function formArray1(arr: any[]) {
  const sortedArr = Array.from(new Set(arr)).sort((a, b) => a - b);

  return sortedArr.reduce((acc, cur) => {
    const lastArr = acc.slice().pop() || [];

    const lastVal = lastArr.slice().pop();
    if (lastVal!=null && cur-lastVal === 1) {
      lastArr.push(cur);
    } else {
      acc.push([cur]);
    }

    return acc;
  }, []);
}

function genNumArray(num: number, base = 100) {
  return Array.from({length: num}, () => Math.floor(Math.random()*base));
}

const arr = genNumArray(10, 20); //[2, 10, 3, 4, 5, 11, 10, 11, 20];
const res = formArray(arr);

console.log(`res ${JSON.stringify(res)}`);

Answer 58

我眉头一皱，又不会…………