【每日一题】- 2019-08-05 - 数据格式转化问题 about fe-interview HOT 13 CLOSED

function setOfUsersWithSimillarSkills(userToSkill) {
    const userToSkillEntries = Object.entries(userToSkill);
    return userToSkillEntries.reduce((prevSkillToUser, [user, skills]) => {
        skills.forEach((skill) => {
            if (prevSkillToUser.hasOwnProperty(skill)) {
                prevSkillToUser[skill].push(user);
            } else {
                prevSkillToUser[skill] = [user];
            }
        });
        return prevSkillToUser;
    }, {});
}

function transform(userToSkill) {
  const skillToUser = {};
  for (const k in userToSkill) {
    userToSkill[k].forEach(skill => {
      if (skillToUser[skill] === void 0) {
        skillToUser[skill] = [k];
      } else {
        skillToUser[skill].push(k);
      }
    });
  }

  return skillToUser;
}

function backtrack(list, tempList, nums, start) {
  list.push(intersect(...tempList));
  for(let i = start; i < nums.length; i++) {
      tempList.push(nums[i]);
      backtrack(list, tempList, nums, i + 1);
      tempList.pop();
  }
}
/**
* @param {number[]} nums
* @return {number[][]}
*/
function subsets(nums) {
  const list = [];
  backtrack(list, [], nums, 0);
  return list;
};

function intersect(arr1, ...rest) { 
  const set = new Set();
  if (rest.length === 0) return set;
  const s1 = new Set(arr1);
  const restSet = rest.map(a => new Set(a));
  for (const x of s1) {
    if (restSet.every(s => s.has(x))) {
      set.add(x);
    }
  }
  return set;
}
function maxByLength(list) {
  let max = 0;
  let maxIndex = 0;

  for(let i = 0; i < list.length; i++) {
    if (list.length > max) {
      max = list.length;
      maxIndex = i;
    }
  }
  return list[maxIndex];
}

function setOfUsersWithSimillarSkills(userToSkill) {
  const mapper = transform(userToSkill);
  const sets = subsets(Object.values(mapper).filter(q => q.length > 1));
  const list = sets.map(set => Array.from(set)).filter(q => q.length);
  return maxByLength(list)
}

function demo(userToSkill) {
    let obj = {}
    for(let item in userToSkill) {
        userToSkill[item].forEach(i => {
            if(obj[i]) {
                obj[i].push(item)
            }else {
                obj[i] = [item]
            }
        })
    }
	return obj
}

function setOfUsersWithSimillarSkills(userToSkill) {
   const skillToUser ={};
   const keylist = Object.entries(userToSkill);
   
   keylist.foreach(item=>{
     let [key,value] = item;
     value.foreach(obj=>{
      skillToUser[obj]?skillToUser[obj].push(key):skillToUser[obj]=[key]
     })
   })
   return skillToUser
}

function setUserToSkill(userToSkill){
	let skillToUser = {};
	for (let [key,value] of Object.entries(userToSkill)) {
		value.forEach(skill=>{
			skill in skillToUser ?  skillToUser[skill].push(key) : skillToUser[skill] = Array.of(key);
        });
    }
  return skillToUser;
}

const transform = userToSkill => 
  Object.entries(userToSkill).reduce((skillToUser, [user, skills]) => 
    skills.reduce((skillToUser, skill) =>({
      ...skillToUser,
      [skill]: skillToUser[skill] ? skillToUser[skill].concat(user) : [skill]
    }), skillToUser), {})