Sol
Many solutions use only bitmasks for the skills (at most 16), but a mask can be used for the people involved as well, as there are at most 60 people (uint64).\n
Many solutions use only [bitmasks](https://en.wikipedia.org/wiki/Mask_(computing)) for the skills (at most 16), but a mask can be used for the people involved as well, as there are at most 60 people (`uint64`).\n\nAnother optimization that can be done is a quick determination of which people are redundant, that is, they bring no skills or redundant skills that another person already brings.\n\n```\nfunc smallestSufficientTeam(req_skills []string, people [][]string) []int {\n    // Convert the skills of each person into a mask\n    peopleSkillBitmask, completedBitmask := buildPeopleSkillMasks(req_skills, people)\n\n    // Optimization: Determine which people have skills that are already covered by other people\n    // as there are at most 16 skills, we have the chance that some people\n    // are already covered by someone else (e.g. two javascript developers is redundant)\n    redundantPeople := findRedundantPeople(peopleSkillBitmask)\n\n    // Use backtracking to determine which people are required\n    // Optimization: We\'ll keep track of the people involved using a bitmask\n    // rather than an array\n    minimumPeopleRequired := len(people)\n    minimumPeopleBitmask := uint64(0)\n    var backtrack func (int, int, int, uint64)\n    backtrack = func (currentPerson, skillBitmask, peopleRequired int, peopleBitmask uint64) {\n        // the current solution has too many people already, stop recursing\n        if peopleRequired >= minimumPeopleRequired {\n            return\n        }\n        // we found a solution, stop recursing\n        if skillBitmask == completedBitmask {\n            minimumPeopleRequired = peopleRequired\n            minimumPeopleBitmask = peopleBitmask\n            return\n        }\n        // no solution found after using all people\n        if currentPerson == len(people) {\n            return\n        }\n\n        // include this person\n        // only consider this person if they\'re not redundant\n        if !redundantPeople[currentPerson] {\n            // only include this person if they have a skill we don\'t already have\n            newBitmask := skillBitmask | peopleSkillBitmask[currentPerson]\n            if newBitmask != skillBitmask {\n                backtrack(\n                    currentPerson + 1,\n                    newBitmask,\n                    peopleRequired + 1,\n                    peopleBitmask | (1 << currentPerson),\n                )\n            }\n        }\n        // exclude this person\n        backtrack(\n            currentPerson + 1,\n            skillBitmask,\n            peopleRequired,\n            peopleBitmask,\n        )\n    }\n\n    // begin looking for a solution\n    backtrack(0, 0, 0, 0)\n\n    // convert the solution we found into the format of the expected answer\n    return convertPeopleMaskToIndexes(len(people), minimumPeopleBitmask)\n}\n\nfunc buildPeopleSkillMasks(req_skills []string, people [][]string) ([]int, int) {\n    skillMap := make(map[string]int, 16)\n    completedBitmask := 0\n    bit := 1\n    for i := 0; i < len(req_skills); i++ {\n        skillMap[req_skills[i]] = bit\n        completedBitmask |= bit\n        bit <<= 1\n    }\n    \n    peopleSkillBitmask := make([]int, len(people))\n    for i := 0; i < len(people); i++ {\n        bitmask := 0\n        for j := 0; j < len(people[i]); j++ {\n            bitmask |= skillMap[people[i][j]]\n        }\n        peopleSkillBitmask[i] = bitmask\n    }\n\n    return peopleSkillBitmask, completedBitmask\n}\n\nfunc findRedundantPeople(peopleSkillBitmask []int) []bool {\n    redundantPeople := make([]bool, len(peopleSkillBitmask))\n    for i := 0; i < len(peopleSkillBitmask); i++ {\n        if peopleSkillBitmask[i] == 0 {\n            redundantPeople[i] = true\n            continue\n        }\n        for j := i + 1; j < len(peopleSkillBitmask); j++ {\n            inCommon := peopleSkillBitmask[i] & peopleSkillBitmask[j]\n            if inCommon == peopleSkillBitmask[j] {\n                redundantPeople[j] = true\n            } else if inCommon == peopleSkillBitmask[i] {\n                redundantPeople[i] = true\n            }\n        }\n    }\n    return redundantPeople\n}\n\nfunc convertPeopleMaskToIndexes(people int, minimumPeopleBitmask uint64) []int {\n    answer := make([]int, bits.OnesCount64(minimumPeopleBitmask))\n    currentIndex := 0\n    bit := uint64(1)\n    for i := 0; i < people; i++ {\n        if minimumPeopleBitmask & bit > 0 {\n            answer[currentIndex] = i\n            currentIndex++\n        }\n        bit <<= 1\n    }\n    return answer\n}\n```
['Go']