第 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())