[Swift]LeetCode609. 在系统中查找重复文件 | Find Duplicate File in System

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址：https://www.cnblogs.com/strengthen/p/10467726.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

热烈欢迎，请直接点击！！！

进入博主App Store主页，下载使用各个作品！！！

注：博主将坚持每月上线一个新app！！！

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.

A group of duplicate files consists of at least two files that have exactly the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt ... fn.txt with content f1_content, f2_content ... fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

"directory_path/file_name.txt"

Example 1:

Input:
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
Output:  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]

Note:

1. No order is required for the final output.
2. You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
3. The number of files given is in the range of [1,20000].
4. You may assume no files or directories share the same name in the same directory.
5. You may assume each given directory info represents a unique directory. Directory path and file info are separated by a single blank space. 

Follow-up beyond contest:

1. Imagine you are given a real file system, how will you search files? DFS or BFS?
2. If the file content is very large (GB level), how will you modify your solution?
3. If you can only read the file by 1kb each time, how will you modify your solution?
4. What is the time complexity of your modified solution? What is the most time-consuming part and memory consuming part of it? How to optimize?
5. How to make sure the duplicated files you find are not false positive?

---

给定一个目录信息列表，包括目录路径，以及该目录中的所有包含内容的文件，您需要找到文件系统中的所有重复文件组的路径。一组重复的文件至少包括二个具有完全相同内容的文件。

输入列表中的单个目录信息字符串的格式如下：

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

这意味着有 n 个文件（f1.txt, f2.txt ... fn.txt 的内容分别是 f1_content, f2_content ... fn_content）在目录 root/d1/d2/.../dm 下。注意：n>=1 且 m>=0。如果 m=0，则表示该目录是根目录。

该输出是重复文件路径组的列表。对于每个组，它包含具有相同内容的文件的所有文件路径。文件路径是具有下列格式的字符串：

"directory_path/file_name.txt"

示例 1：

输入：
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
输出：  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]] 

注：

1. 最终输出不需要顺序。
2. 您可以假设目录名、文件名和文件内容只有字母和数字，并且文件内容的长度在 [1，50] 的范围内。
3. 给定的文件数量在 [1，20000] 个范围内。
4. 您可以假设在同一目录中没有任何文件或目录共享相同的名称。
5. 您可以假设每个给定的目录信息代表一个唯一的目录。目录路径和文件信息用一个空格分隔。

超越竞赛的后续行动：

1. 假设您有一个真正的文件系统，您将如何搜索文件？广度搜索还是宽度搜索？
2. 如果文件内容非常大（GB级别），您将如何修改您的解决方案？
3. 如果每次只能读取 1 kb 的文件，您将如何修改解决方案？
4. 修改后的解决方案的时间复杂度是多少？其中最耗时的部分和消耗内存的部分是什么？如何优化？
5. 如何确保您发现的重复文件不是误报？

---

584ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var ctp = [String: [String]]()
        for path in paths {
            let comps = path.split(separator: " ")
            let dir = comps[0]
            for file in comps[1...] {
                let (fullPath, contents) = analyzeFile(file, dir)
                ctp[contents, default: []].append(fullPath)
            }
        }
        return Array(ctp.values).filter { $0.count > 1 }
    }
    
    private func analyzeFile(_ file: String.SubSequence, _ dir: String.SubSequence) -> (String, String) {
        let startIndex = file.index(of: "(")!
        let endIndex = file.index(before: file.endIndex)
        let contents = String(file[file.index(after: startIndex)..<endIndex])
        let path = String(file[file.startIndex..<startIndex])
        return ("\(dir)/\(path)", contents)
    }
}

---

700ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var map = [String: [String]]()
        for path in paths {
            let contents = extractContent(path)
            for content in contents {
                map[content[1], default: [String]()].append(content[0])
            }
        }
        var result = [[String]]()
        for key in map.keys {
            if let tmpPaths = map[key] {
                if tmpPaths.count > 1 {
                    result.append(tmpPaths)
                }
            }
        }
        return result
    }
    
    private func extractContent(_ str: String) -> [[String]] {
        let arr = str.split(separator: " ")
        let root = arr[0]
        var result = [[String]]()
        for i in 1 ..< arr.count {
            let str = arr[i]
            let left = str.firstIndex(of: "(")!
            let right = str.lastIndex(of: ")")!
            let filename = String(str[..<left])
            let content = String(str[left ... right])
            result.append(["\(root)/\(filename)", content])
        }
        return result
    }
}

---

908ms

class Solution {
    
    typealias Content = String
    typealias FilePath = String
    typealias ExtractedContentPath = (content: Content, filepath: FilePath)
    
    func findDuplicate(_ paths: [String]) -> [[String]] {
        
        let contentFileTable: [Content: [FilePath]] = paths.lazy
            .flatMap { self.extractedContentPaths($0) }
            .reduce(into: [Content: [FilePath]]()){ (dict: inout [Content: [FilePath]], extractedContentPath: ExtractedContentPath) in
                dict[extractedContentPath.content, default: [FilePath]()].append(extractedContentPath.filepath)
        }
        
        return contentFileTable.values.filter { $0.count > 1 }
        
    }
    
    private func extractedContentPaths(_ input: String) -> [ExtractedContentPath] {
        let tokens = input.components(separatedBy: .whitespaces)
        let directory = tokens.first!
        return tokens.indices.dropFirst()
            .lazy.map { extractedContentPath(from: tokens[$0], directory: directory) }
    }
    
    private func extractedContentPath(from fileAndContent: String, directory: String) -> ExtractedContentPath {
        let tokens = fileAndContent.dropLast().components(separatedBy: "(")
        return ExtractedContentPath(content: tokens.last!, filepath: "\(directory)/\(tokens.first!)")
    }
}

---

992ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var groups = [String: Array<String>]()
        
        for info in paths {
            let list = parse(info: info)
            
            for file in list {
                groups[file.1, default: Array<String>()].append(file.0)
            }
        }
        
        var result = [[String]]()
        
        for group in Array(groups.values) {
            if group.count > 1 {
                result.append(group)
            }
        }
        
        return result
    }
    
    func parse(info: String) -> [(String, String)] {
        var components = info.components(separatedBy: " ")
        let path = components.removeFirst()
        
        var result = [(String, String)]()
        
        let splitCharSet = CharacterSet(charactersIn: "()")
        while !components.isEmpty {
            
            let entry = components.removeFirst()
            let parts = entry.components(separatedBy: splitCharSet)
            
            let file = "\(path)/\(parts[0])" 
            let contents = parts[1]
            
            result.append((file, contents))
        }
        
        return result
    }
}

---

1232ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var fileMapPaths = [String: [String]]()
        paths.forEach { (str) in
            let arrStrs = str.split(separator: " ")
            let dir = arrStrs[0]
            for i in 1..<arrStrs.count {
                let fileInfo = arrStrs[i]
                let subArrStr = fileInfo.split(separator: "(")
                let md5 = String(subArrStr[1])
                let file = String(subArrStr[0].prefix(subArrStr[0].count))
                let filePath = dir + "/" + file
                var mapPaths = fileMapPaths[md5] ?? [String]()
                mapPaths.append(filePath)
                fileMapPaths[md5] = mapPaths
            }
        }
        let ans = fileMapPaths.values.filter { $0.count > 1}
        return ans        
    }
}

---

1264ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        //create a dictionary with [content: [filepath]], output the value count which is equal and greater than 2
        var contentToFiles = [String: [String]]()
        for path in paths {
            let params = path.split(separator: " ")
            guard let dir = params.first else {
                continue
            }
            for i in 1 ..< params.count {
                let fileParams = params[i].split(separator: "(")
                guard let fileName = fileParams.first, let fileContentWithExtraInfo = fileParams.last else {
                    continue
                }
                let fileContent = String(describing: fileContentWithExtraInfo.dropLast())
                let filePath = String(describing:dir) + "/" + String(describing: fileName )
                contentToFiles[fileContent] = contentToFiles[fileContent, default:[]] + [filePath]  
            }
        }
        return contentToFiles.values.filter{$0.count >= 2}

    }
}

---

Runtime: 1324 ms

Memory Usage: 26.4 MB

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var ans:[[String]] = [[String]]()
        var map:[String:[String]] = [String:[String]]()
        for path in paths
        {
            var temp:[String] = path.components(separatedBy:" ")
            var root:String = temp[0]
            for str in temp
            {
                var begin:Int = str.findLast("(")
                var end:Int = str.findFirst(")")
                if begin + 1 < end
                {
                    var name:String = str.subString(begin+1,end)
                    var s:String = root + "/" + str.subStringTo(begin - 1)
                    if map[name] == nil
                    {
                        map[name] = [s]
                    }
                    else
                    {
                        map[name]!.append(s)
                    }
                }               
            } 
        }
        for val in map.values
        {
            if val.count > 1
            {
                ans.append(val)
            }
        }
        return ans        
    }
}

//String扩展
extension String {    
    // 截取字符串：从起始处到index
    // - Parameter index: 结束索引
    // - Returns: 子字符串
    func subStringTo(_ index: Int) -> String {
        let theIndex = self.index(self.startIndex,offsetBy:min(self.count,index))
        return String(self[startIndex...theIndex])
    }
    
    // 截取字符串：指定索引和字符数
    // - begin: 开始截取处索引
    // - count: 截取的字符数量
    func subString(_ begin:Int,_ count:Int) -> String {
        let start = self.index(self.startIndex, offsetBy: max(0, begin))
        let end = self.index(self.startIndex, offsetBy:  min(self.count, begin + count))
        return String(self[start..<end]) 
    }
    
    //从0索引处开始查找是否包含指定的字符串，返回Int类型的索引
    //返回第一次出现的指定子字符串在此字符串中的索引
    func findFirst(_ sub:String)->Int {
        var pos = -1
        if let range = range(of:sub, options: .literal ) {
            if !range.isEmpty {
                pos = self.distance(from:startIndex, to:range.lowerBound)
            }
        }
        return pos
    }

    //从0索引处开始查找是否包含指定的字符串，返回Int类型的索引
    //返回最后出现的指定子字符串在此字符串中的索引
    func findLast(_ sub:String)->Int {
        var pos = -1
        if let range = range(of:sub, options: .backwards ) {
            if !range.isEmpty {
                pos = self.distance(from:startIndex, to:range.lowerBound)
            }
        }
        return pos
    }
}

---

1344ms

class Solution {
    func findDuplicate(_ paths: [String]) -> [[String]] {
        var mapping = [String: [String]]()
        for i in 0..<paths.count {
            let arr = paths[i].components(separatedBy: " ")
            let base = arr[0] + "/"
            for j in 1..<arr.count {
                let arrSplit = arr[j].components(separatedBy: "(")
                mapping[arrSplit[1], default:[String]()].append(base + arrSplit[0])
            }
        }
        return Array(mapping.values).filter{$0.count > 1}
    }
}