Find Duplicate File in System

// Accepted solution for LeetCode #609: Find Duplicate File in System
class Solution {
    public List<List<String>> findDuplicate(String[] paths) {
        Map<String, List<String>> d = new HashMap<>();
        for (String p : paths) {
            String[] ps = p.split(" ");
            for (int i = 1; i < ps.length; ++i) {
                int j = ps[i].indexOf('(');
                String content = ps[i].substring(j + 1, ps[i].length() - 1);
                String name = ps[0] + '/' + ps[i].substring(0, j);
                d.computeIfAbsent(content, k -> new ArrayList<>()).add(name);
            }
        }
        List<List<String>> ans = new ArrayList<>();
        for (var e : d.values()) {
            if (e.size() > 1) {
                ans.add(e);
            }
        }
        return ans;
    }
}

// Accepted solution for LeetCode #609: Find Duplicate File in System
func findDuplicate(paths []string) [][]string {
	d := map[string][]string{}
	for _, p := range paths {
		ps := strings.Split(p, " ")
		for i := 1; i < len(ps); i++ {
			j := strings.IndexByte(ps[i], '(')
			content := ps[i][j+1 : len(ps[i])-1]
			name := ps[0] + "/" + ps[i][:j]
			d[content] = append(d[content], name)
		}
	}
	ans := [][]string{}
	for _, e := range d {
		if len(e) > 1 {
			ans = append(ans, e)
		}
	}
	return ans
}

# Accepted solution for LeetCode #609: Find Duplicate File in System
class Solution:
    def findDuplicate(self, paths: List[str]) -> List[List[str]]:
        d = defaultdict(list)
        for p in paths:
            ps = p.split()
            for f in ps[1:]:
                i = f.find('(')
                name, content = f[:i], f[i + 1 : -1]
                d[content].append(ps[0] + '/' + name)
        return [v for v in d.values() if len(v) > 1]

// Accepted solution for LeetCode #609: Find Duplicate File in System
struct Solution;
use std::collections::HashMap;

impl Solution {
    fn find_duplicate(paths: Vec<String>) -> Vec<Vec<String>> {
        let mut hm: HashMap<String, Vec<String>> = HashMap::new();
        for s in paths {
            let mut s_iter = s.split_whitespace();
            let dir: &str = s_iter.next().unwrap();
            for f in s_iter {
                let mut f_iter = f.chars();
                let name: String = f_iter.by_ref().take_while(|&c| c != '(').collect();
                let content: String = f_iter.by_ref().take_while(|&c| c != ')').collect();
                hm.entry(content)
                    .or_default()
                    .push(format!("{}/{}", dir, name))
            }
        }
        hm.into_iter()
            .filter_map(|(_, v)| if v.len() > 1 { Some(v) } else { None })
            .collect()
    }
}

#[test]
fn test() {
    let paths: Vec<String> = vec_string![
        "root/a 1.txt(abcd) 2.txt(efgh)",
        "root/c 3.txt(abcd)",
        "root/c/d 4.txt(efgh)",
        "root 4.txt(efgh)"
    ];
    let mut res: Vec<Vec<String>> = vec_vec_string![
        ["root/a/2.txt", "root/c/d/4.txt", "root/4.txt"],
        ["root/a/1.txt", "root/c/3.txt"]
    ];
    let mut ans = Solution::find_duplicate(paths);
    res.sort();
    ans.sort();
    assert_eq!(ans, res);
}

// Accepted solution for LeetCode #609: Find Duplicate File in System
function findDuplicate(paths: string[]): string[][] {
    const d = new Map<string, string[]>();
    for (const p of paths) {
        const [root, ...fs] = p.split(' ');
        for (const f of fs) {
            const [name, content] = f.split(/\(|\)/g).filter(Boolean);
            const t = d.get(content) ?? [];
            t.push(root + '/' + name);
            d.set(content, t);
        }
    }
    return [...d.values()].filter(e => e.length > 1);
}