Question

我需要编写一个接受3个数组并返回字符串的函数

Answer 1

建议的解决方案的time complexity是指数的。使用对象跟踪元素的数量可以解决线性时空问题。换句话说，您只需要访问一次每个数组中的每个元素，而不是 n ³ 次，其中 n 是元素数在您的三个输入数组中。

const getDupes = (a, b, c) => {
  const seen = {};

  a.concat(b).concat(c).forEach(e => {
    if (!(e in seen)) { seen[e] = 0; }
    seen[e]++;
  });

  return Object.keys(seen)
    .filter(e => seen[e] > 1)
    .map(e => e.toLowerCase())
    .sort()
    .join(",");
};

console.log(getDupes([1, 2, 3, 'd'], [5, 3, 0, 'd'], ['A', 'd', 9]));

Answer 2

这是trackClones解决方案：

只需遍历这三个数组并将每个遇到的新项目存储在一个对象中。如果该项目已经在对象中，则将其推入数组。

最后，join数组和lowerCase生成的字符串，然后将其返回。

代码段：

function trackClones(a, b, c) {
  let track = {};
  let clones = [];
  
  [a, b, c].forEach(arr => arr.forEach(item => {
    if (track[item] && !~clones.indexOf(item)) clones.push(item);
    else track[item] = true;
  }));
  
  return clones.sort().join(",").toLowerCase();
}

console.log(trackClones([1, 2, 3, 3, 'd'], [5, 3, 0, 'a'], ['A', 'd', 9]));

您也可以使用Set代替对象。通过使用set.has(item)和set.add(item)可以更容易理解。

代码段：

function trackClones(a, b, c) {
  let track = new Set();
  let clones = [];
  
  [a, b, c].forEach(arr => arr.forEach(item => {
    if (track.has(item) && !~clones.indexOf(item)) clones.push(item);
    else track.add(item);
  }));
  
  return clones.sort().join(",").toLowerCase();
}

console.log(trackClones([1, 2, 3, 'd'], [5, 3, 0, 'a'], ['A', 'd', 9]));

Answer 3

波纹管解决方案应该适用于n个数组，并且也可以按要求进行小写和升序。

ES6解决方案：

function sortByNumberOfClonesPureJS(...args) {
        let flatten = [].concat(...args)
        return Object.keys(flatten.reduce((result, value, index, arr) => {
            let numberOfHits = arr.filter((v) => v === value).length
            if(numberOfHits > 1)
                result = Object.assign({ [value.toString().toLowerCase()]: numberOfHits }, result)
            return result
        }, {}))
    }

    console.log(sortByNumberOfClonesPureJS([3, 3, 3], [5, 5, 1], ['A', 'D', 'D', 'D'], [ 2, 3, 3, 3,'c','c']))

    // returns ["3", "5", "c", "d"]

Lodash / FP：

let _ = require("lodash/fp")

const sortArray = (arr) => _.keys(_.pickBy((value) => value > 1, _.countBy((a) => _.indexOf(a, arr) >= 0 ? a.toString().toLowerCase(): 0, arr)))

function sortByNumberOfClones(...args) {
    return _.flow([
        _.flatten,
        sortArray
    ])([...args])
}

console.log(sortByNumberOfClones([3, 3, 3], [5, 5, 1], ['A', 'D', 'D'], [ 2, 3, 3, 3,'c','c']))

// returns ["3", "5", "d", "c"]

查看/测试=> RunKit：https://runkit.com/akrion/sort-by-number-of-clones

Answer 4

function x(...args) {
  let c = [].concat.apply([], args);
  return c.reduce((acc,el) => {
    return (c.filter(e=>e===el).length>1 && 
        !acc.some(e=>e===el))                                        
          ? acc.concat(el)
          : acc
         }, [])
    .map(e=>(e+'').toLowerCase())
    .sort((a,b)=>a>b?1:-1)
    .join()
    .toLowerCase()
}

需要帮助来编写一个函数，该函数接受3个数组并以升序返回一串重复的元素

4 个答案: