您可以在 repo Github 上找到这篇文章中的所有代码。
阵列相关的挑战
数组
/**
* @return {Array}
*/
function arrayOf(arr) {
return [].slice.call(arguments);
}
// Usage example
const array1 = [1, 2, 3];
const array2 = [4, 5, 6];
const combinedArray = arrayOf(array1, array2);
console.log(combinedArray); // => [ [ 1, 2, 3 ], [ 4, 5, 6 ] ]
登录后复制
数组到树
/**
* @param {Array} arr
* @return {Array}
*/
function arrToTree(arr) {
const tree = [];
const hashmap = new Map();
// create nodes and store references
arr.forEach((item) => {
hashmap[item.id] = {
id: item.id,
name: item.name,
children: [],
};
});
// build the tree
arr.forEach((item) => {
if (item.parentId === null) {
tree.push(hashmap[item.id]);
} else {
hashmap[item.parentId].children.push(hashmap[item.id]);
}
});
return tree;
}
// Usage example
const flatArray = [
{ id: 1, name: "Node 1", parentId: null },
{ id: 2, name: "Node 1.1", parentId: 1 },
{ id: 3, name: "Node 1.2", parentId: 1 },
{ id: 4, name: "Node 1.1.1", parentId: 2 },
{ id: 5, name: "Node 2", parentId: null },
{ id: 6, name: "Node 2.1", parentId: 5 },
{ id: 7, name: "Node 2.2", parentId: 5 },
];
const tree = arrToTree(flatArray);
console.log(tree); // => [{ id: 1, name: 'Node 1', children: [ [Object], [Object] ] }, { id: 5, name: 'Node 2', children: [ [Object], [Object] ] }]
登录后复制
数组包装器
class ArrayWrapper {
constructor(arr) {
this._arr = arr;
}
valueOf() {
return this._arr.reduce((sum, num) => sum + num, 0);
}
toString() {
return `[${this._arr.join(",")}]`;
}
}
// Usage example
const obj1 = new ArrayWrapper([1, 2]);
const obj2 = new ArrayWrapper([3, 4]);
console.log(obj1 + obj2); // => 10
console.log(String(obj1)); // => [1,2]
登录后复制
类数组到数组
/**
* @param {any} arrayLike
* @return {Array}
*/
function arrayLikeToArray(arrayLike) {
return Array.from(arrayLike);
}
// Usage example
const arrayLike = {
0: "a",
1: "b",
2: "c",
length: 3,
};
console.log(arrayLikeToArray(arrayLike)); // => ['a', 'b', 'c']
登录后复制
块
/**
* @template T
* @param {Array<T>} arr The array to process.
* @param {number} [size=1] The length of each chunk.
* @returns {Array<Array<T>>} The new array of chunks.
*/
function chunk(arr, size = 1) {
if (!Array.isArray(arr) || size < 1) {
return [];
}
const newArray = [];
for (let i = 0; i < arr.length; i += size) {
const chunk = arr.slice(i, i + size);
newArray.push(chunk);
}
return newArray;
}
// Usage example
console.log(chunk(["a", "b", "c", "d"])); // => [['a'], ['b'], ['c'], ['d']]
console.log(chunk([1, 2, 3, 4], 2)); // => [[1, 2], [3, 4]]
console.log(chunk([1, 2, 3, 4], 3)); // => [[1, 2, 3], [4]]
登录后复制
组合
/**
* @param {array} arrs
* @return {array}
*/
function generateCombinations(arrs) {
const result = [];
function backtrack(start, current) {
if (start === arrs.length) {
result.push(current.join(''));
return;
}
for (const item of arrs[start]) {
current.push(item);
backtrack(start + 1, current);
current.pop();
}
}
backtrack(0, []);
return result;
}
// Usage example
const nestedArray = [['a', 'b'], [1, 2], [3, 4]];
console.log(generateCombinations(nestedArray)); // => ['a13', 'a14', 'a23', 'a24', 'b13', 'b14', 'b23', 'b24']
登录后复制
不同之处
/**
* @param {Array} array
* @param {Array} values
* @return {Array}
*/
function difference(arr, values) {
const newArray = [];
const valueSet = new Set(values);
for (let i = 0; i < arr.length; i += 1) {
const value = arr[i];
if (
!valueSet.has(value) &&
!(value === undefined && !Object.hasOwn(arr, i))
) {
newArray.push(value);
}
}
return newArray;
}
// Usage example
console.log(difference([1, 2, 3], [2, 3])); // => [1]
console.log(difference([1, 2, 3, 4], [2, 3, 1])); // => [4]
console.log(difference([1, 2, 3], [2, 3, 1, 4])); // => []
console.log(difference([1, , 3], [1])); // => [3]
登录后复制
立即下降
/**
* @param {Array} array
* @param {Function} predicate
* @return {Array}
*/
function dropRightWhile(arr, predicate) {
let index = arr.length - 1;
while (index >= 0 && predicate(arr[index], index, arr)) {
index -= 1;
}
return arr.slice(0, index + 1);
}
// Usage example
console.log(dropRightWhile([1, 2, 3, 4, 5], (value) => value > 3)); // => [1, 2, 3]
console.log(dropRightWhile([1, 2, 3], (value) => value < 6)); // => []
console.log(dropRightWhile([1, 2, 3, 4, 5], (value) => value > 6)); // => [1, 2, 3, 4, 5]
登录后复制
掉落时
/**
* @param {Array} array
* @param {Function} predicate
* @return {Array}
*/
function dropWhile(arr, predicate) {
let index = 0;
while (index < arr.length && predicate(arr[index], index, arr)) {
index += 1;
}
return arr.slice(index);
}
// Usage example
dropWhile([1, 2, 3, 4, 5], (value) => value < 3); // => [3, 4, 5]
dropWhile([1, 2, 3], (value) => value < 6); // => []
登录后复制
展平
/**
* @param {Array<*|Array>} value
* @return {Array}
*/
function flatten(arr) {
const newArray = [];
const copy = [...arr];
while (copy.length) {
const item = copy.shift();
if (Array.isArray(item)) {
copy.unshift(...item);
} else {
newArray.push(item);
}
}
return newArray;
}
// Usage example
console.log(flatten([1, 2, 3])); // [1, 2, 3]
// Inner arrays are flattened into a single level.
console.log(flatten([1, [2, 3]])); // [1, 2, 3]
console.log(
flatten([
[1, 2],
[3, 4],
])
); // [1, 2, 3, 4]
// Flattens recursively.
console.log(flatten([1, [2, [3, [4, [5]]]]])); // [1, 2, 3, 4, 5]
登录后复制
生成唯一的随机数组
/**
* @param {number} range
* @param {number} outputCount
* @return {Array}
*/
function generateUniqueRandomArray(range, outputCount) {
const arr = Array.from({ length: range }, (_, i) => i + 1);
const result = [];
for (let i = 0; i < outputCount; i += 1) {
const randomIndex = Math.floor(Math.random() * arr.length);
result.push(arr[randomIndex]);
arr[randomIndex] = arr.at(-1);
arr.pop();
}
return result;
}
// Usage example
const uniqueRandomNumbers = generateUniqueRandomArray(10, 5);
console.log(uniqueRandomNumbers); // => [3, 7, 1, 9, 5]
登录后复制
交叉点
/**
* @param {Function} iteratee
* @param {Array[]} arrays
* @returns {Array}
*/
function intersectionBy(iteratee, ...arrs) {
if (!arrs.length) {
return [];
}
const mappedArrs = arrs.map((arr) => arr.map(iteratee));
let intersectedValues = mappedArrs[0].filter((value) => {
return mappedArrs.every((mappedArr) => mappedArr.includes(value));
});
intersectedValues = intersectedValues.filter((value, index, self) => {
return self.indexOf(value) === index;
});
return intersectedValues.map((value) => {
const index = mappedArrs[0].indexOf(value);
return arrs[0][index];
});
}
// Usage example
const result = intersectionBy(Math.floor, [1.2, 2.4], [2.5, 3.6]); // => [2.4]
console.log(result); // => [2.4]
const result2 = intersectionBy(
(str) => str.toLowerCase(),
["apple", "banana", "ORANGE", "orange"],
["Apple", "Banana", "Orange"]
);
console.log(result2); // => ['apple', 'banana', 'ORANGE']
登录后复制
路口
/**
* @param {Array<unknown>[]} arrays - The arrays to find the intersection of.
* @returns {Array<unknown>} - An array containing the elements common to all input arrays.
*/
function intersectArrays(...arrs) {
if (!arrs.length) {
return [];
}
const set = new Set(arrs[0]);
for (let i = 1; i < arrs.length; i += 1) {
set.forEach((value) => {
if (!arrs[i].includes(value)) {
set.delete(value);
}
});
}
return Array.from(set);
}
// Usage example
console.log(intersectArrays([1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 6])); // => [3, 4]
登录后复制
意思是
/**
* @param {Array} array
* @return {Number}
*/
function mean(arr) {
return arr.reduce((sum, number) => sum + number, 0) / arr.length;
}
// Usage example
console.log(mean([1, 2, 3])); // => 2
console.log(mean([1, 2, 3, 4, 5])); // => 3
登录后复制
删除重复项
/**
* @param {*} arr
*/
function removeDuplicates(arr) {
return Array.from(new Set(arr));
}
// Usage example
const inputArray = [1, 2, 3, 2, 1, 4, 5, 6, 5, 4];
const outputArray = removeDuplicates(inputArray);
console.log(outputArray); // => [1, 2, 3, 4, 5, 6]
登录后复制
随机播放
/**
* @param {any[]} arr
* @returns {void}
*/
function shuffle(arr) {
if (arr.length < 1) {
return [];
}
for (let i = 0; i < arr.length; i += 1) {
const randIdx = Math.floor(Math.random() * (i + 1));
[arr[randIdx], arr[i]] = [arr[i], arr[randIdx]];
}
return arr;
}
// Usage example
console.log(shuffle([1, 2, 3, 4])); // => [*, *, *, *]
登录后复制
排序方式
/**
* @param {Array} arr
* @param {Function} fn
* @return {Array}
*/
function sortBy(arr, fn) {
return arr.sort((a, b) => fn(a) - fn(b));
}
// Usage example
console.log(sortBy([5, 4, 1, 2, 3], (x) => x)); // => [1, 2, 3, 4, 5]
登录后复制
树到数组
/**
* @param {Array} tree
* @param {number} parentId
* @return {Array}
*/
function treeToArr(tree, parentId = null) {
const arr = [];
tree.forEach((node) => {
const { id, name } = node;
arr.push({ id, name, parentId });
// recursive
if (node.children && node.children.length > 0) {
arr.push(...treeToArr(node.children, id));
}
});
return arr;
}
// Usage example
const tree = [
{
id: 1,
name: "Node 1",
children: [
{
id: 2,
name: "Node 1.1",
children: [
{
id: 4,
name: "Node 1.1.1",
children: [],
},
],
},
{
id: 3,
name: "Node 1.2",
children: [],
},
],
},
{
id: 5,
name: "Node 2",
children: [
{
id: 6,
name: "Node 2.1",
children: [],
},
{
id: 7,
name: "Node 2.2",
children: [],
},
],
},
];
const flatArray = treeToArr(tree);
console.log(flatArray);
/*
[
{ id: 1, name: 'Node 1', parentId: null },
{ id: 2, name: 'Node 1.1', parentId: 1 },
{ id: 4, name: 'Node 1.1.1', parentId: 2 },
{ id: 3, name: 'Node 1.2', parentId: 1 },
{ id: 5, name: 'Node 2', parentId: null },
{ id: 6, name: 'Node 2.1', parentId: 5 },
{ id: 7, name: 'Node 2.2', parentId: 5 }
]
*/
登录后复制
参考
- 2695。数组包装器 - LeetCode
- 2677。块数组 - LeetCode
- 2724。排序依据 - LeetCode
- 2625。展平深度嵌套数组 - LeetCode
- 131。实现 _.chunk() - BFE.dev
- 8.你能 shuffle() 一个数组吗？ - BFE.dev
- 384。随机排列数组 - LeetCode
- 138。两个排序数组的交集 - BFE.dev
- 167。未排序数组的交集 - BFE.dev
- 66。从数组中删除重复项 - BFE.dev
以上是数组 - JavaScript 挑战的详细内容。更多信息请关注PHP中文网其他相关文章！
