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

[zeroone001]

[swchenxixi]

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

[benzhemin]

我起的早, 我先来吧

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

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)}`);

[ryanZiegler]

区间分类

// 得到一个两数之间的随机整数，包括两个数在内
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);

[zhuzhh]

// 生产随机数
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))

[douchaoyang]

// 随机生成一个长度为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);

[sgzhm4444]

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);

[YouziXR]

我发现楼上的朋友们和我想的不太一样啊，我理解的题目意思是把连续的元素组成一个数组，比如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)

[schaoss]

// 隨機生成 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)

[swchenxixi]

我发现楼上的朋友们和我想的不太一样啊，我理解的题目意思是把连续的元素组成一个数组，比如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)

是的就是这个操作

[ryanZiegler]

连续元素分类

// 得到一个两数之间的随机整数，包括两个数在内
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);

[FounderIsShadowWalker]

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;

}

[TheCrookedMan]

[...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('')])

[JonathonChen]

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

[GuoYuFu123]

/**
@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())

[Nolaaaaa]

// 随机生成长度为 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]]

代码测试地址

[XianHuiDeDiZhongHai]

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]]

菜鸟见解，轻喷

[fuqianxi]

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)

[Ray-56]

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));

[susiwen8]

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);

[Forx-Js]

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)) //数据划分

[zengfan0605]

// 生成随机数组 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]) }

[wubetter]

/**
题目：随机生成一个长度为 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]]

[arronf2e]

比较通俗的解法~

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);

[master-kolan]

  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

[XianHuiDeDiZhongHai]

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没有去重

[Vera1128]

// 随机生成长度为 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]]

代码测试地址

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

[ouxuwen]

// 生成随机数组
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);
``

[LiuMengzhou]

/**
 * 返回 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); // 不改变原数组

[IWANABETHATGUY]

既然用到了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);
      },
      [[]],
    );
};

[lhyt]

[2, 10, 3, 4, 5, 11, 10, 11, 20]
  .sort((a, b) => a - b)
  .reduce((res, cur) => {
    const { answer, cursor, pre } = res;
    const current = answer[cursor] || [];
    if (!current.length || (pre !== undefined && cur === pre + 1)) {
      current.push(cur);
    } else {
      answer.push([]);
      res.cursor ++;
    }
    res.pre = cur;
    res.answer[cursor] = current;
    return res;
  }, { answer: [], cursor: 0, pre: undefined }).answer;

[kingstone3]

function f(arr) {
	return arr.reduce((acc, curr) => {
		acc[Math.floor(curr / 10)] = acc[Math.floor(curr / 10)] || [];
		acc[Math.floor(curr / 10)].push(curr);
		return acc;
	}, [])
}

[dreamHeroK]

function foo(arr){
  arr.sort((a,b)=>(a-b))
  let arr2=[...new Set(arr)]
  let arr3=[]
  let i=0
  while([...new Set(arr3)].flat().length<arr2.length){
        arr3=[...arr3,arr2.filter(item=>item>=i*10&&item<(i+1)*10)]
      i++
    }
  return arr3
}

[yeyan1996]

function createArr(length,maxRange) {
  return  Array.from(Array(length)).map(_ => Math.floor(Math.random() * maxRange))
}

function transform(arr) {
    let res = [];
    [...new Set(arr)].forEach(item => (res[Math.floor(item / 10)] || (res[Math.floor(item / 10)] = [])).push(item))
    return Array.from(res.map(item => item.sort((a, b) => a - b))).filter(Boolean)
}
console.log(transform(createArr(50,200)))

这个思路是通过除以 10 取余获得放入的下标位置，然后通过 Array.from 配合 filter 过滤掉空单元，比较讨巧，楼上有些思路太复杂了

[dingLeiOnly]

哦，应该是0-9，10-19。。。

[dorseysen]

该题未指定随机数范围，在数值很大时，按10作为间隔分组基本上得到的就是所有数各自为政。

const createTargetArray = len => {

    //  100000改成100比较明显
    let arr = Array.from({length: len}, item => Math.floor(Math.random() * 100000));

    arr.sort();
    console.log(arr);
    let res = [], map = {}, index = 0;

    for(let i = 0; i < arr.length; i ++) {

        let key = Math.floor(arr[i] / 10);

        'undefined' !== typeof map[key] ? res[map[key]].push(arr[i]) : (map[key] = index ++, res.push([arr[i]]));
    }
    return res;
}
console.log(createTargetArray(10));

[zhouzuchuan]

const splitArray = arr =>
    arr.reduce((r, v) => {
        const idx = Math.floor(v / 10)

        if (!r[idx]) {
            r[idx] = []
        }

        r[idx].push(v)

        return r
    }, []).filter(v => v)

console.log(splitArray([2, 10, 3, 4, 5, 11, 10, 11, 20]))

[bentelblack]

function random10Array () {
  let array = []
  for (let index = 0; index < 10; index++) {
    array.push(Math.floor(Math.random() * 100))
  }
  return array
}
function balabala (arr) {
  let a1 = Array.from(new Set(arr.sort((a, b) => a - b)))
  let result = []
  a1.forEach(item => {
    const index = Math.floor(item / 10)
    if (result[index]) {
      result[index].push(item)
    } else {
      result[index] = [item]
    }
  })
  result = result.filter(item => item.toString())
  return result
}
const a1 = random10Array()
const dealArray = balabala(a1)
console.log(JSON.stringify(dealArray));

[hudie09143672]

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

function sortArr(arr) {
    var arr0 = []
    var min = arr.reduce(function (n, m) {
        return Math.min(n, m)
    }, Infinity);
    var max = arr.reduce(function (n, m) {
        return Math.max(n, m)
    }, -Infinity);
    arr0.push(min);
    var i = arr.indexOf(min)
    arr.splice(i, 1);
    while (arr.indexOf(min) >= 0) {
        arr.splice(arr.indexOf(min), 1)
    }
    var next = null;
    for (var k = min + 1; k < max; k++) {
        if (arr.indexOf(k) >= 0) {
            arr0.push(k);
            arr.splice(arr.indexOf(k), 1)
            while (arr.indexOf(k) >= 0) {
                arr.splice(arr.indexOf(k), 1)
            }
        } else {
            next = k;
            break;
        }
    }
    resultArr.push(arr0);
    if (arr.length > 0) {
        sortArr(arr);
    }
}

sortArr(arr);
console.log(resultArr);

[linguowei]

贡献一个，有问题请指出

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

function test(arr) {
  let res = [];
  for(let i = 0; i < arr.length; i++) {
    let index = Math.floor(arr[i] / 10);
    if (!res[index]) {
      res[index] = [];
      if (!res[index].includes(arr[i])) {
        res[index].push(arr[i])
      }
    } else {
      if (!res[index].includes(arr[i])) {
        res[index].push(arr[i])
      }
    }
  }
  return res;
}

console.log(test(arr));

[zhdanny]

随机生成10位整数，并放入数组中
var a = [];
for(let i=0;i<10;i++){
    a.push(Math.round(Math.random()*100))
}
console.log(a)
//[71, 66, 45, 20, 71, 48, 85, 95, 12, 46]

对数组进行排序
a.sort((a,b)=>{
    return a-b;
});
// [12, 20, 45, 46, 48, 66, 71, 71, 85, 95]

重新排列组合成新的数组,里面含有empty
var b = [];
a.map(i=>{
    var q = Math.floor(i/10);
    if(!b[q]){
        b[q]=[];
    }
    b[q].push(i);
    return i;
});
console.log(b);

***(10) [empty, Array(1), Array(1), empty, Array(3), empty, Array(1), Array(2), Array(1), Array(1)]
1: [12]
2: [20]
4: (3) [45, 46, 48]
6: [66]
7: (2) [71, 71]
8: [85]
9: [95]***

去掉empty
b = b.filter(i=>i)
console.log(b);
***(7) [Array(1), Array(1), Array(3), Array(1), Array(2), Array(1), Array(1)]
0: [12]
1: [20]
2: (3) [45, 46, 48]
3: [66]
4: (2) [71, 71]
5: [85]
6: [95]***

[linlinyang]

/* * 题目：随机生成一个长度为 10 的整数类型的数组，例如 [2, 10, 3, 4, 5, 11, 10, 11, 20]，将其排列成一个新数组，要求新数组形式如下，例如 [[2, 3, 4, 5], [10, 11], [20]]。 * * 理解：去重后把连续的数字组成一个数组，最后组成二维数组 */

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

    function sort(arr){
        var sortArr = Array.from(new Set(arr)).sort((a,b) => a - b),
            ret = [],
            len = sortArr.length,
            start = end = 0;
        while(end < len){
            if(sortArr[end +1] - sortArr[end] !== 1){
                ret.push(sortArr.slice(start,end + 1));
                start = ++end;
            }else{
                end++
            }
        }
        return ret;
    }
    console.log(sort(arr));

[revonia]

/**
 * 生成 n 个 0 - 99 的随机数
 * @param n
 * @returns {number[]}
 */
function randomIntArray (n) {
  return Array.from({length: n}).map(() => parseInt(Math.random() * 100))
}

/**
 * 去重，并对 input 内连续的整数进行分组
 * @param {array} input
 * @returns {array[]}
 */
function groupIntegers (input) {
  let last = null
  return Array.from(new Set(input))
    .sort((a, b) => a - b)
    .reduce((acc, n) => {
      if (last === null || last + 1 !== n) {
        acc.push([])
      }

      last = n

      acc[acc.length - 1].push(n)

      return acc
    }, [])
}

[Kelier]

const x = [2, 10, 3, 4, 5, 11, 10, 11, 20];
x.sort((a,b)=>{return a-b;});
const y = new Set(x);
let z = [];
[...y].forEach(item=>{
	let index = Math.floor(item/10);
	if(z[index]){
		z[index].push(item);
	} else {
		z[index] = [item];
	}
});
console.log(z);

[qieqie7]

;(function (arr) { const obj = {}; [...new Set(arr)].sort((a, b) => a - b).forEach(el => { const key = Math.floor(el / 10) if(obj[key]){ obj[key].push(el) } else { obj[key] = [el] } }) return Object.values(obj) })([2,10,3,4,5,11,10,20]);

[Hunterang]

function format(arr) { let result = [] let newArr = [...new Set(arr)].sort((a,b) => a-b) let num = Math.floor(newArr[0]/10) let children = [] for (var i = 0; i < newArr.length; i++) { if (Math.floor(newArr[i]/10) === num) { children.push(newArr[i]) }else { num = Math.floor(newArr[i]/10) result.push(children) children = [] children.push(newArr[i]) } } result.push(children) return result }

[YufJi]

function format(length) {
  const newarr = [];
  const arr = Array.from({length: length}, (v, k) => Math.floor(Math.random()*length))
  for (let i = 0; i < arr.length; i++) {
    const key = Math.floor(arr[i]/10)
    if(!newarr[key]) {
      newarr[key] = []
    }
    newarr[key] = Array.from(new Set([...newarr[key], arr[i]])).sort((a, b) => a - b)
  }
  return newarr.filter(Boolean);
}

[CHristopherkeith]

关键点

1. 排序
2. 去重
3. 分组

const makeArrayRange = (data)=>{
	return data.sort((a,b)=>{return a-b}).reduce((acc, cVal, index)=>{
		let loc = Math.floor(cVal/10);
		!acc[loc]&&(acc[loc] = []);
		acc[loc].indexOf(cVal) === -1 && acc[loc].push(cVal);
		return acc;
	}, [])
}
let data = [2, 10, 3, 4, 5, 11, 10, 11, 20];
let newData = makeArrayRange(data);

[sailei1]

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

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

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

[xiaowuhero666]

var arr =[2, 10, 3, 4, 5, 11, 10, 11, 20]; arr = Array.from(new Set(arr.sort((a,b)=> a-b))); var arr2 = []; arr.forEach(function (val) { if(arr2.length>0){ if(val.toString().length > arr2[arr2.length-1][0].toString().length){ arr2.push([]) arr2[arr2.length-1].push(Number(val)); }else{ arr2[arr2.length-1].push(Number(val)); } }else{ arr2.push([]) arr2[0].push(Number(val)); } }) `console.log(arr2)

[PNfeather]

  let orageArr = [2, 10, 3, 4, 5, 11, 10, 11, 20]; // 原始数组
  let group = (paramArr) => { // 获取结果数组方法
    let arr = [...new Set(paramArr)].sort((a, b) => { // 原始数组去重排序
      return a - b;
    });
    let dataCatch = {}; // 缓存变量
    let result = []; // 结果数组变量
    arr.forEach((item) => { // 已去重排序数组，去掉个位数后归类到缓存对象中
      let key = Math.floor(item / 10);
      !dataCatch[key] && (dataCatch[key] = []);
      dataCatch[key].push(item);
    });
    for (let key in dataCatch) { // 将缓存对象的单元值push到结果数组中
      result.push(dataCatch[key]);
    }
    return result; // 函数输出结果
  };
  console.log(group(orageArr));

[silencyXiao]

function toGroup (arr) {
  let data = [...new Set(arr)].sort((a, b) => a - b) // 数组去重并排序
  let result = data.reduce((acc, val) => {
    // 除以10进行分组
    let key = Math.floor(val / 10)
    if (acc[key]) {
      acc[key].push(val)
    } else {
      acc[key] = []
      acc[key].push(val)
    }
    return acc
  }, {})
  return Object.values(result)
}
console.log(toGroup([2, 10, 3, 4, 5, 11, 10, 11, 20]))

[Gemiry]

let arr = [2, 10, 3, 4, 5, 11, 10, 11, 20, 33 , 22, 44, 34, 39, 89] let left = 0 let temp = 0 arr.filter((item,index,self) => self.indexOf(item) === index).sort((a,b)=>a-b).reduce((total,item,index,self)=>{ if(Math.floor(item/10)>0&&temp != Math.floor(item/10)){ total.push(self.slice(left,index)) left = index temp = Math.floor(item/10) } if(index == self.length-1){ total.push(self.slice(left,self.length)) } return total },[]) 这样可以否？就是用太多循环了o(╥﹏╥)o

[francisZimo]

let arr=Array.from({length:10},()=>{return Math.floor(Math.random()100)}) console.log(arr) let setArr=new Set(arr); let originalData=[...setArr]; let maxNum=Math.max(...originalData); let minNum=Math.min(...originalData); let minInit=parseInt(minNum/10) ; let maxInit=parseInt(maxNum/10); let temp=[]; for(let i=minInit;i<maxInit+1;i++){ let _min=i10; let _max=_min+10; let _ary=originalData.filter(item=>_min<=item&&item<_max); if(_ary.length>0){ temp.push(_ary) } } console.log(temp);

[HuangYongXuan]

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

array = array.sort((a,b) => a-b);
let set = new Set(array);

array = Array.from(set);

console.info(array);

let newArray = [];
let tem = [];

array.forEach((item, key) => {
    tem.push(item);
    if (tem.length > 0 && item + 1 !== array[key + 1]) {
        newArray.push(tem);
        tem = [];
    }
});

console.info(newArray);

[Qymh]

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

const arrTrans = [...new Set(arr)].sort((a, b) => a - b).reduce((acc, val) => {
  const index = Math.floor(val / 10);
  (acc[index] || (acc[index] = [])).push(val);
  return acc
}, [])

[sunhanA]

// 连续的为一组
    function group(arr) {
      let groupArr = []
      let sortArr = Array.from(arr)
      sortArr.sort((a, b) => a - b)
      groupArr.push([sortArr[0]])
      for(let i = 0, len = sortArr.length; i < len - 1; i++) {
        if(sortArr[i + 1] - sortArr[i] === 1) {
          groupArr[groupArr.length - 1].push(sortArr[i + 1])
        } 
        else {
          groupArr.push([sortArr[i + 1]])
        }
      }
      return groupArr
    } 
  
    //生成一个最大长度为20的无重复的数组
    let arr2 = new Set(Array(Math.floor(Math.random() * 20)).fill(0).map(() => Math.floor(Math.random() * 10)))
    arr2 = Array.from(arr2)

    console.log(arr2)  //[3, 5, 2, 8, 0, 7, 9, 1, 4]
    console.log(group(arr2))  //[[0, 1, 2, 3, 4, 5], [7, 8, 9]]

[bWhirring]

function trans(arr) {
  let res = [];
  const newArr = [...new Set(arr.sort((a, b) => a - b))]; // 数组排序
  for (let i = 0; i < newArr.length; ) {
    let cur = newArr[i];
    let arr = [];
    while (cur + 1 === newArr[i + 1]) {  
      arr.push(cur);
      i++;
      cur = newArr[i];
    }
    arr.push(cur);
    res.push(arr);
    i++;
  }
  console.log(res);
  return res;
}

[Travis-hjs]

const list = [2, 10, 3, 4, 5, 11, 10, 11, 20];
const result = [];
const range = 10;
for (let i = 0; i < list.length; i++) {
    const item = list[i];
    const index = Math.floor(item / range);
    if (!result[index] || !Array.isArray(result[index])) {
        result[index] = [];
    }
    result[index].push(item);
}
console.log(result);

for 循环的应该是性能比较高的吧，支持向上增加数组

[SpengF]

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

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

    obj[key]=group
  });
  return Object.values(obj);
}

[jjsnc]

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

[WSQ233]

var a = [2, 10, 1, 3, 4, 5, 11, 10, 11, 20, 40]
var b = []
a.filter((item, index, arr) => arr.indexOf(item) === index)
    .sort((a, b) => a - b)
    .map(i => {
        if (typeof b[parseInt(i / 10)] === 'object') {
            b[parseInt(i / 10)].push(i)
        } else {
            b[parseInt(i / 10)] = []
            b[parseInt(i / 10)].push(i)
        }
    })
b = b.filter(i => !!i)
console.log(b)

[zjjjjjjjjjjd]

es6写法

function format(arr) {
  const res = {};
  while(arr.length > 0) {
    const item = arr.shift();
    const key = Math.floor(item / 10);
    if(!res[key]) {
      res[key] = new Set();
    }
    res[key].add(item);
  }
  return Object.keys(res).sort().map(item => Array.from(res[item]).sort());
}

[GoodLuckAlien]

function unFlat(pre=[[]]){
     Array.from(new Set(Array.from({length:10}).map(()=>Math.floor(Math.random() * 100)))).sort((a,b)=>a-b).forEach(item=> item === pre[pre.length-1][pre[pre.length-1].length-1] + 1 ? pre[pre.length-1].push(item)  : pre.push([item]))
     return pre.slice(1)
}

[fyZhang66]

function createArr(num){
  var dd = []
  for(let i=0;i<10;i++){
    dd[i] = Math.floor(Math.random()*num)
  }
  console.log(dd)
  let res = [...new Set(dd)].sort((a,b)=>{return a-b})
  var tmp = res[0]
  var result = []
  res.forEach((value,index)=>{
    if(value+1 !== res[index+1]){
      if(value !== tmp){
        let arr2 = Array.from(new Array(value + 1).keys()).slice(tmp)
        result.push(arr2)
      }else{
        result.push(value)
      }
      tmp = res[index+1]
    }
    
  })
  return result
}
console.log(createArr(20))

[Matchaa]

let arr = []
for (let i = 0; i < 10; i++) {
  arr.push(parseInt(Math.random() * 100))
}
let newarr = [...new Set(arr)].sort((a, b) => {
  return a - b
})
let obj = {}
newarr.forEach(item => {
  const index=parseInt(item / 10)
  if (!obj[index]) {
    obj[index] = []
  }
  obj[index].push(item)
})
newarr = []
for (let i in obj) {
  newarr.push(obj[i])
}
console.log(newarr)

[helloyoucan]

function random(){
	return Array.from({length:10}).map(()=>parseInt(Math.random()*100))
}
function insert(arr,value){
	const _arr = [].concat([],arr);
	for(let i = 0, l = arr.length;i<l;i++){
		if(_arr[i]>value){
			_arr.splice(i,0,value);
			break;
		}
	}
	if(_arr.length===arr.length){
		_arr.push(value)
	}
	return _arr
}
var nums = [...new Set(random())];
var array = new Array();
for(let i=0,l=nums.length;i<l;i++){
	let num = nums[i];
	let numStr = num.toString();
	if(numStr.length===1){
		if(array[0]){
			array[0] = insert(array[0],num)
		}else{
			array[0] = [num];
		}
	}else if(numStr.length===2){
		const index = numStr.slice(0,1);
		if(array[index]){
			array[index] = insert(array[index],num)
		}else{
			array[index] = [num]
		}
	}
}
console.log(JSON.stringify(array.filter(item=>item)))

[liuliudaren]

这道题有点歧义呀 我怎么第一时间理解为 K平均值的聚类

还有最重要的一点 [2, 10, 3, 4, 5, 11, 10, 11, 20] 这个数组的长度不是10是9

[ypeusksk]

  const arr = [2, 10, 3, 4, 5, 11, 10, 11, 20, 1600, 90, 88, 130]
  function change(arr) {
    arr = arr.sort((a, b) => a - b)
    const newArr = []
    while (arr.length) {
      const type = parseInt(arr[0] / 10)
      let i = 1
      for (; i < arr.length; i++) {
        if (type != parseInt(arr[i] / 10)) break
      }
      newArr.push(arr.splice(0, i))
    }
    return newArr
  }
  console.log(change(arr))

[Leo-July]

 // 得到一个两数之间的随机整数，包括两个数在内
    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 = initArr.sort((a, b) => a - b)
    console.log("TCL: initArr", initArr)
    // 去重
    const tempSet = [...new Set(initArr)]
    let isSame = -1 // -1 初始状态  0 没有相同状态下   1 相同状态下
    let result = []
    // 迭代判断
    while (tempSet[0]) {
      const temp = tempSet[0]
      tempSet.splice(0, 1)
      initArr.splice(initArr.indexOf(temp), 1)
      const hasTemp = initArr.includes(temp)
      switch (isSame) {
        case 0:
          if (hasTemp) {
            result.push([temp])
            isSame = 1
          } else {
            result[result.length - 1].push(temp)
          }
          break
        case 1:
          if (hasTemp) {
            result[result.length - 1].push(temp)
          } else {
            result.push([temp])
            isSame = 0
          }
          break
        case -1:
        default:
          result.push([temp])
          hasTemp ? (isSame = 1) : (isSame = 0)
      }
    }
    console.log("TCL: result", result)

[yangxinSamsara]

    let randomArr = [];
    //生成长度为10的整数类型数组
    for (let i = 0; i < 10; i++) {
        randomArr.push(Math.floor(Math.random() * i * 10))
    }
    //排序
    let sortArr = randomArr.sort((a, b) => {
        return a - b
    })
    //去重
    let uniqueArr = Array.from(new Set(sortArr));
    //利用对象key的唯一性分组
    let obj = {}
    uniqueArr.forEach(element => {
        const num = Math.floor(element / 10);
        if (!obj[num]) {
            obj[num] = []
        }
        obj[num].push(element)
    });
    //将分好组的对象转化为数组
    let resultArr = [];
    for (const key in obj) {
        resultArr.push(obj[key])
    }
    console.log(resultArr);

[catbea]

这个题目出的有歧义：理解一，把现有数组按区间来分，以10位位单位区分，比如10以内的一组，10-20之间的一组，20-30之间的一组； 理解二：把现有数组如果是连续的放一组，不连续的单独放。

[monan19920722]

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

秀儿快坐下

[cyy000]

一斤牛批

[monan19920722]

function group(arr) { const res = []; [...new Set(arr)].sort((a, b) => a - b).forEach((d) => { const index = parseInt(d / 10); if (!res[index]) { res[index] = [] } res[index].push(d); }); return res.filter(d => Array.isArray(d)); }

[hastings-95]

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

打卡一斤

[1045598742]

let newa = [2, 10, 3, 4, 5, 11, 10, 11, 20,101,202]; let sort = [...new Set(newa)].sort((n1,n2)=>n1-n2) ; let max = Math.floor(Math.max(...sort)/10)+1; let newarr = []; for(var i=1;i<=max;i++){ let cdr = sort.filter(e=>e<i*10&&e>=(i-1)*10) if(cdr.length>0){ newarr.push(cdr) } } console.log(newarr);

[leonwens]

// 题目描述的不是很清楚，如果三位数以上数组该如何分配？所以代码先按照100以内的数字来说
// 随机生成一个长度为count最大值为max的数组
function random(count=10, max=100){
  return new Array(count).fill().map((item) => {
    return Math.floor(Math.random() * max)
  })
}
function trans(array){
  const mapping = array.sort((a,b) => a-b).reduce((result, cur) => {
    let key = cur < 10 ? '0' : String(cur).charCodeAt(0);
    result[key] ? result[key].push(cur) : result[key] = [cur];
    return result
  }, {})
  return Object.keys(mapping).reduce((result, cur) => {
    result.push(mapping[cur])
    return result
  }, [])
}
console.log(trans(random()))

[1045598742]

// 题目描述的不是很清楚，如果三位数以上数组该如何分配？所以代码先按照100以内的数字来说
// 随机生成一个长度为count最大值为max的数组
function random(count=10, max=100){
  return new Array(count).fill().map((item) => {
    return Math.floor(Math.random() * max)
  })
}
function trans(array){
  const mapping = array.sort((a,b) => a-b).reduce((result, cur) => {
    let key = cur < 10 ? '0' : String(cur).charCodeAt(0);
    result[key] ? result[key].push(cur) : result[key] = [cur];
    return result
  }, {})
  return Object.keys(mapping).reduce((result, cur) => {
    result.push(mapping[cur])
    return result
  }, [])
}
console.log(trans(random()))

多谢提醒 我把空数组去掉了优化一下 哈哈

[tengwei30]

// 先生成随机数 const getRandomInt(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min)) + min }

// 生成一个10位数不重复的整数 const arrRandom = Array.from({length: 10}, () => { getRandomInt(0, 99) }).sort((a,b) => a - b)

// 进行分组 const group = (arr, obj = {}) => { if (typeof arr !== 'object ') return arr.map(item => { const v = Number(item) / 10 if (!obj[v]) obj = [] obj[v].push(item) }) return [...Object.values(obj)] } group(arrRandom)

[yuwanli]

function selfDefinetSort(arr) {
    const res = []
    let tagIndex = 0;// 游标
    arr.sort((a,b) => a - b); //先排序
    
    while(tagIndex < arr.length){
        const current = arr[tagIndex]
        const start = (parseInt(current/10))*10
        const end = (parseInt(current/10) + 1)*10
        const valid = arr.filter((val) => {
            return val >= start && val < end
        })
        tagIndex += valid.length
        res.push(valid)
    }
    return res
}

selfDefinetSort([2, 10, 3, 4, 5, 11, 10, 11, 20])
// [[2, 3, 4, 5], [10, 11], [20]]

通过打标的形式遍历

[zjkblade]

    let randomNumber = (min, max) => {
        return Math.floor(Math.random() * (max - min + 1)) + min;
    };
    let randomArray = (length, min, max) => {
        return Array.from({length: length}).map(() => randomNumber(min, max));
    };
    Array.prototype.last = function () {
        return this[this.length - 1];
    };
    let test = (arr) => {
        return Array.from(new Set(arr)).sort((a, b) => a - b).reduce((c, n, i) => {
            let cLast = c.last();
            let ccLast = cLast.last();
            if (i === 0 || ccLast && ccLast + 1 === n) {
                cLast.push(n);
            } else {
                c.push([n]);
            }
            return c;
        }, [[]]);
    };

    console.info(JSON.stringify(test(randomArray(50, 100, 120))));

[lvzhiyi]

你们的太复杂了：关键点是元素除以10的取整数作为新数组的index就OK了：

function transformArr(arr){
    let resArr = [];
    arr.forEach((item, index) => {
        let key = parseInt(item / 10);
        if( Array.isArray(resArr[key])){
            if(!resArr[key].includes(item)){
                resArr[key].push(item)
            }
        }else{
            resArr[key] = [item]
        }
    })
    return resArr.filter(Boolean);
}

[daiyunchao]

//定义变量
var arr=[];
var obj={};

//生成10个随机数
for(let i=0;i<10;i++){
	let rNum=Math.floor(Math.random()*100);
	arr.push(rNum)
}
//去重:
arr=[...new Set(arr)];

//排序
arr.sort((a,b)=>a-b);
//console.log("arr==>",arr);

//将元素进行归类
for(let i=0;i<arr.length;i++){
	let key=Math.floor(arr[i]/10);
	if(!obj[key]){
		obj[key]=[];
	}
	obj[key].push(arr[i]);
}

//console.log("obj==>",obj);

//构建二维数组
let newArr=[];
for(let key in obj){
	newArr.push(obj[key])
}
console.log(newArr);

[Linkontoask]

随机彩票生成代码，娱乐

const chalk = require('chalk') // 安装chalk

let num = process.argv.filter(item => /^[0-9]+$/.test(+item))
num = num.length === 1 ? num[0] : 20

function p (c) {
	return new Promise((resolve) => {
		setTimeout(() => {
			resolve(Math.random() * c + 1 | 0)
		}, Math.random() * 500 | 0)
	})
}

async function auto(num, ps) {
	const r = await p(ps)
	if (this.includes(r)) {
		this.pop()
	} else {
		this.push(r)
	}
	if (this.length < num) await auto.call(this, num, ps)
}

+async function fn(argument) {
	let all = []
	for (let j = 0; j < num; j++) {
		let red = [], blue = []
		await auto.call(red, 5, 35)
		await auto.call(blue, 2, 12)
		all.push({
			red,
			blue
		})
	}
	
	all.forEach(item => {
		console.log(`红色：`, chalk.red(item.red.sort((a,b) => a - b).join('，')))
		console.log(`蓝色：`, chalk.blue(item.blue.sort((a,b) => a - b).join('，')))
		console.log()
	})
}()

[fnlearner]

    var arr= [2, 10, 3, 4, 5, 11, 10, 11, 20];
    let tempArr=[...new Set(arr)].sort((a,b)=>{
        return a-b;
    })//[ 2, 3, 4, 5, 10, 10, 11, 11, 20 ]
    let map = new Map();
    for(let num of tempArr){
        let count =1;
        let tempNum = num ;
        while(Math.floor(tempNum)>=10){
            tempNum /=10;
            ++count;
        }
        const flag =num<10?0:Math.floor(tempNum);
        if(!!map.has(`${count}_${flag}`)){
            const temp = map.get(`${count}_${flag}`);
            temp.push(num);
            map.set(`${count}_${flag}`,temp)
        }else{
            map.set(`${count}_${flag}`,[num]);
        }
    }
    let result = [];
    for(let item of map.values()){
        result.push(item);
    }
    console.log(result);

[luyaoLee]

function getRandom (min, max) {
  return Math.floor(Math.random() * (max - min + 1)) + min
}

function deRepeat (arr) {
  return [...new Set(arr)]
}

function test () {
  const arr = deRepeat(Array(10).fill().map(() => this.getRandom(1, 20))).sort((a, b) => a - b)
  const obj = {}
  arr.map(item => {
    const key = Math.floor(item / 10)
    if (!obj[key]) obj[key] = []
    obj[key].push(item)
  })
  return Object.values(obj)
}

console.log(test())

[JackFGreen]

// [ [ 3, 4, 5 ], [ 10, 11 ], [ 20 ], [ 92 ] ]
const arr = [92, 10, 3, 4, 5, 11, 10, 11, 20]
const result = orderArr(arr)
console.log(result)

function orderArr (arr) {
  const map = {}
  arr.forEach(n => {
    const t = getTen(n)
    map[t] = map[t] || []
    if (!map[t].includes(n)) map[t].push(n)
  })
  return Object.values(map)
}

function getTen (s) {
  return Math.floor(s/10)
}

[wxGoldking]

function handle(arr){
    let result = [], wei = 0;
    [...new Set(arr)].sort((a,b)=> a - b).forEach(item=>{
        if(item >= 10*wei && item < 10 * (wei+1)){
            result[wei] ? result[wei].push(item) : (result[wei] = [item])
        }else{
            wei++;
            result[wei] = [item];
        }    
    })
    return result;
}

[fengshenhai-0727]

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

//随机生成一个min到max之间的随机数
function getArr(l, min, max) {
  const res = [];
  for (let i = 0; i < l; i++) {
    res.push(Math.floor(Math.random() * (max - min + 1) + min));
  }
  return res;
}
function arrangeArr(arr) {
  const res = [];
  arr.sort((a, b) => a - b);
  const sum = [];
  arr.reduce((pre, cur, index) => {
    if (cur - pre === 1) {
      sum.push(pre);
    } else if (cur - pre !== 0) {
      sum.push(pre);
      res.push(sum.splice(0));
    }
    if (index === arr.length - 1) {
      if (cur !== pre) {
        res.push([cur]);
      } else {
        res.push(sum);
      }
    }
    return cur;
  });
  return res;
}

console.log(arrangeArr(getArr(10, 55, 99)));

[gongtiexin]

const getArr = (n = 10) => new Array(n).fill(0).map(_ => Math.floor(Math.random() * 100));

const computedArr = () => {
  const arr = [];
  getArr().forEach(item => {
    const idx = Math.floor(item / 10);
    if (arr[idx]) {
      arr[idx].push(item);
    } else {
      arr[idx] = [item];
    }
  });
  return arr;
};

[xiaoqisha]

   let arr = function randomArr() {
        let arr = []
        for (let i = 0; i < 10; i++) {
            arr.push(Math.floor(Math.random() * 100))
        }
        return arr
    }()

    let r = {}
    arr.sort((a, b) => a - b).map(v => { return { v, k: parseInt(v / 10) } }).forEach(v => {
        !r[v.k] ? r[v.k] = [v.v] : r[v.k].indexOf(v.v) === -1 ? r[v.k].push(v.v) : ''
    })
    console.log(Object.values(r))

[SoftwareEngineerPalace]

我的方法只适用于 被10除 商是0,1,2的三种数

var list = [2, 10, 3, 5, 3, 10, 11, 20]
list = [...new Set(list)]
var prev = list.reduce((prev, next) => {
  var quotient = Math.floor(next / 10)
  prev[quotient].push(next);
  return prev
}, [[], [], []])

[aeolusheath]

// 分割成连续的数组

    function allay(arr) {
      let res = [[]]
      arr.sort((a, b) => a - b)
      arr = [...new Set(arr)]
      res[0].push(arr[0])
      for (let i = 1; i < arr.length; i++) {
        let len = res.length - 1
        let innerLen = res[len].length - 1
        let cur = arr[i]
        if (cur == res[len][innerLen] + 1) {
          res[len].push(cur)
        } else {
          res.push([])
          res[res.length -1].push(cur)
        }
      }
      return res
    }

[legendyxc]

    let valueOld = -1;
    let list = []
    let arr = []
    //生成10位随机整数数组并排序去重
    const result = [...new Set(Array.from({length: 10}, () => (Math.random(1) * 20).toFixed()).sort((a, b) => a - b))]
    //遍历生成所需结果
    result.forEach((value) => {
        if (Math.floor(value / 10) !== valueOld && valueOld !== -1) {
            arr.push(list)
            list = []
        }
        list.push(value)
        valueOld = Math.floor(value / 10)
    })
    arr.push(list)
    console.log(arr)

[ZhChen7]

我理解是：去重排序数组后，分类连续数列。

let initArr = Array.from({ length: 10 }, (v) => { return getRandomIntInclusive(0, 20) }) // 得到一个两数之间的随机整数，包括两个数在内 function getRandomIntInclusive(min, max) { min = Math.ceil(min); max = Math.floor(max); return Math.floor(Math.random() * (max - min + 1)) + min; //含最大值，含最小值 }

function GetArr(arr) { var newarr = Array.from(new Set(arr)).sort((a, b) => a - b ) var pre = 0, cur = 1 var count = 1 var xarr = [newarr[0]] var Finllyarr = [] while (cur <= newarr.length) { if (newarr[cur] - newarr[pre] === count) { xarr.push(newarr[cur]) } else { pre = cur count = 0 Finllyarr.push(xarr) xarr = [newarr[pre]] } cur++ count++ } return Finllyarr } console.log(GetArr(initArr))

[huxiaocheng]

挑战最少代码实现 [...new Set(arr.flat(Infinity))].forEach(v => { const index = Math.floor(v / 10); (ret[index] || (ret[index] = [])).push(v); })

[huangjieqiu]

简单易懂
let arr = [2, 10, 3, 4, 5, 11, 10, 11, 20] arr = [...new Set(arr)].sort((a, b) => a - b) let length = arr.length let result = '' for (let i = 0 ; i < length; i++) { let cur = arr[i] let pre = arr[i - 1] if (i === 0) { result += cur } else if (cur - pre === 1) { result += ',' + cur } else { result += '|' + cur } } result = result.split('|').map(item => item.split(',')) console.log(result)

[ChandlerCao]

在座的各位都是垃圾

const arr = Array.from(new Set(new Array(10).fill(null).map(() => Math.floor(Math.random() * 100)))).sort().reduce((prev, item) => {
    prev[item >= 10 ? parseInt((item + '')[0]) : 0].push(item)
    return prev
}, new Array(10).fill(null).map(() => [])).filter(item => item.length)

console.log(arr)

[yzw7489757]

/**
 * 可能存在无必要的 [1,999999] 区间
 * @param {*} arr Array
 * @param {number} [section=10] 区间
 * @returns Array<Array<number>>
 */
function separate(arr, section = 10) {
	const array = [...new Set(arr)].sort((a, b) => a - b)
	const result = []
	const max = Math.max(...array)

	while (array.length) {
		const len = array.length

		// 本次区间
		const sectionEnd = Math.floor(array[0] / section) * section + section

		if(max < sectionEnd) { // [101,109] 皆小于 110的情况
			result.push(array.splice(0))
			break
		}

		for (let i = 0; i < len; i++) {
			if (array[i] >= sectionEnd) {
				result.push(array.splice(0, i))
				break
			}
		}
	}
	return result
}
var nums = Array.from({ length: 100 }).map(() => Math.ceil(Math.random() * 110))

console.log(separate(nums))
console.log(separate(nums,30))
console.log(separate([1,999999]))

[Jmingzi]

最简洁

let num = 4;
const result = [];
while (num > 0) {
  result.push(
    Array.from(new Array(num)).map(() => Math.ceil(Math.random() * 100))
  );
  num = Math.log2(num);
}