People Whose List of Favorite Companies Is Not a Subset of Another List

// Accepted solution for LeetCode #1452: People Whose List of Favorite Companies Is Not a Subset of Another List
class Solution {
    public List<Integer> peopleIndexes(List<List<String>> favoriteCompanies) {
        int n = favoriteCompanies.size();
        Map<String, Integer> d = new HashMap<>();
        int idx = 0;
        Set<Integer>[] nums = new Set[n];
        Arrays.setAll(nums, i -> new HashSet<>());
        for (int i = 0; i < n; ++i) {
            var ss = favoriteCompanies.get(i);
            for (var s : ss) {
                if (!d.containsKey(s)) {
                    d.put(s, idx++);
                }
                nums[i].add(d.get(s));
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < n; ++i) {
            boolean ok = true;
            for (int j = 0; j < n && ok; ++j) {
                if (i != j && nums[j].containsAll(nums[i])) {
                    ok = false;
                }
            }
            if (ok) {
                ans.add(i);
            }
        }
        return ans;
    }
}

// Accepted solution for LeetCode #1452: People Whose List of Favorite Companies Is Not a Subset of Another List
func peopleIndexes(favoriteCompanies [][]string) (ans []int) {
	n := len(favoriteCompanies)
	d := make(map[string]int)
	idx := 0
	nums := make([]map[int]struct{}, n)

	for i := 0; i < n; i++ {
		nums[i] = make(map[int]struct{})
		for _, s := range favoriteCompanies[i] {
			if _, ok := d[s]; !ok {
				d[s] = idx
				idx++
			}
			nums[i][d[s]] = struct{}{}
		}
	}

	check := func(a, b map[int]struct{}) bool {
		for x := range a {
			if _, ok := b[x]; !ok {
				return false
			}
		}
		return true
	}
	for i := 0; i < n; i++ {
		ok := true
		for j := 0; j < n && ok; j++ {
			if i != j && check(nums[i], nums[j]) {
				ok = false
			}
		}
		if ok {
			ans = append(ans, i)
		}
	}

	return
}

# Accepted solution for LeetCode #1452: People Whose List of Favorite Companies Is Not a Subset of Another List
class Solution:
    def peopleIndexes(self, favoriteCompanies: List[List[str]]) -> List[int]:
        idx = 0
        d = {}
        n = len(favoriteCompanies)
        nums = [set() for _ in range(n)]
        for i, ss in enumerate(favoriteCompanies):
            for s in ss:
                if s not in d:
                    d[s] = idx
                    idx += 1
                nums[i].add(d[s])
        ans = []
        for i in range(n):
            if not any(i != j and (nums[i] & nums[j]) == nums[i] for j in range(n)):
                ans.append(i)
        return ans

// Accepted solution for LeetCode #1452: People Whose List of Favorite Companies Is Not a Subset of Another List
struct Solution;
use std::collections::HashSet;

impl Solution {
    fn people_indexes(favorite_companies: Vec<Vec<String>>) -> Vec<i32> {
        let people: Vec<HashSet<String>> = favorite_companies
            .into_iter()
            .map(|v| v.into_iter().collect())
            .collect();
        let n = people.len();
        let mut res = vec![];
        'outer: for i in 0..n {
            for j in 0..n {
                if i != j && people[i].is_subset(&people[j]) {
                    continue 'outer;
                }
            }
            res.push(i as i32);
        }
        res
    }
}

#[test]
fn test() {
    let favorite_companies = vec_vec_string![
        ["leetcode", "google", "facebook"],
        ["google", "microsoft"],
        ["google", "facebook"],
        ["google"],
        ["amazon"]
    ];
    let res = vec![0, 1, 4];
    assert_eq!(Solution::people_indexes(favorite_companies), res);
    let favorite_companies = vec_vec_string![
        ["leetcode", "google", "facebook"],
        ["leetcode", "amazon"],
        ["facebook", "google"]
    ];
    let res = vec![0, 1];
    assert_eq!(Solution::people_indexes(favorite_companies), res);
    let favorite_companies = vec_vec_string![["leetcode"], ["google"], ["facebook"], ["amazon"]];
    let res = vec![0, 1, 2, 3];
    assert_eq!(Solution::people_indexes(favorite_companies), res);
}

// Accepted solution for LeetCode #1452: People Whose List of Favorite Companies Is Not a Subset of Another List
function peopleIndexes(favoriteCompanies: string[][]): number[] {
    const n = favoriteCompanies.length;
    const d: Map<string, number> = new Map();
    let idx = 0;
    const nums: Set<number>[] = Array.from({ length: n }, () => new Set<number>());

    for (let i = 0; i < n; i++) {
        for (const s of favoriteCompanies[i]) {
            if (!d.has(s)) {
                d.set(s, idx++);
            }
            nums[i].add(d.get(s)!);
        }
    }

    const check = (a: Set<number>, b: Set<number>): boolean => {
        for (const x of a) {
            if (!b.has(x)) {
                return false;
            }
        }
        return true;
    };

    const ans: number[] = [];
    for (let i = 0; i < n; i++) {
        let ok = true;
        for (let j = 0; j < n && ok; j++) {
            if (i !== j && check(nums[i], nums[j])) {
                ok = false;
            }
        }
        if (ok) {
            ans.push(i);
        }
    }

    return ans;
}