[Swift]LeetCode1169. 查询无效交易 | Invalid Transactions

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

A transaction is possibly invalid if:

• the amount exceeds $1000, or;
• if it occurs within (and including) 60 minutes of another transaction with the same name in a different city.

Each transaction string transactions[i] consists of comma separated values representing the name, time (in minutes), amount, and city of the transaction.

Given a list of transactions, return a list of transactions that are possibly invalid.  You may return the answer in any order.

Example 1:

Input: transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
Output: ["alice,20,800,mtv","alice,50,100,beijing"]
Explanation: The first transaction is invalid because the second transaction occurs within a difference of 60 minutes, have the same name and is in a different city. Similarly the second one is invalid too.

Example 2:

Input: transactions = ["alice,20,800,mtv","alice,50,1200,mtv"]
Output: ["alice,50,1200,mtv"]

Example 3:

Input: transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]
Output: ["bob,50,1200,mtv"]

Constraints:

• transactions.length <= 1000
• Each transactions[i] takes the form "{name},{time},{amount},{city}"
• Each {name} and {city} consist of lowercase English letters, and have lengths between 1 and 10.
• Each {time} consist of digits, and represent an integer between 0 and 1000.
• Each {amount} consist of digits, and represent an integer between 0 and 2000.

---

如果出现下述两种情况，交易 可能无效：

• 交易金额超过 ¥1000
• 或者，它和另一个城市中同名的另一笔交易相隔不超过 60 分钟（包含 60 分钟整）

每个交易字符串 transactions[i] 由一些用逗号分隔的值组成，这些值分别表示交易的名称，时间（以分钟计），金额以及城市。

给你一份交易清单 transactions，返回可能无效的交易列表。你可以按任何顺序返回答案。

示例 1：

输入：transactions = ["alice,20,800,mtv","alice,50,100,beijing"]
输出：["alice,20,800,mtv","alice,50,100,beijing"]
解释：第一笔交易是无效的，因为第二笔交易和它间隔不超过 60 分钟、名称相同且发生在不同的城市。同样，第二笔交易也是无效的。

示例 2：

输入：transactions = ["alice,20,800,mtv","alice,50,1200,mtv"]
输出：["alice,50,1200,mtv"]

示例 3：

输入：transactions = ["alice,20,800,mtv","bob,50,1200,mtv"]
输出：["bob,50,1200,mtv"]

提示：

• transactions.length <= 1000
• 每笔交易 transactions[i] 按 "{name},{time},{amount},{city}" 的格式进行记录
• 每个交易名称 {name} 和城市 {city} 都由小写英文字母组成，长度在 1 到 10 之间
• 每个交易时间 {time} 由一些数字组成，表示一个 0 到 1000 之间的整数
• 每笔交易金额 {amount} 由一些数字组成，表示一个 0 到 2000 之间的整数

---

188ms

class Solution {
    
    struct  Transation: Hashable {
        var name: String
        var time: Int
        var price: Int
        var city: String
        
        func toString() -> String {
            return "(name),(time),(price),(city)"
        }
    }
    
    func invalidTransactions(_ transactions: [String]) -> [String] {
//        var ans = [String]()
        var mapNameToTransation = [String:[Transation]]()
        for tran in transactions {
            let componnent = tran.components(separatedBy: ",")
            let trans = Transation(name: componnent[0], time: Int(componnent[1])!, price: Int(componnent[2])!, city: componnent[3])
            if mapNameToTransation[trans.name] == nil {
                mapNameToTransation[trans.name] = [Transation]()
            }
            mapNameToTransation[trans.name]?.append(trans)
        }

        var set = Set<Transation>()
        for (_,transations2) in mapNameToTransation {
            if transations2.count == 1 {
                if transations2[0].price > 1000 {
                    set.insert(transations2[0])
                }
            } else {
                let length = transations2.count
                for i in 0..<length {
                    let first  = transations2[i]
                    if first.price > 1000 {
                        set.insert(first)
                    }
                    for j in (i + 1)..<length {
                        let second = transations2[j]
                        if  first.city != second.city {
                            if abs(first.time - second.time) <= 60 {
                                set.insert(first)
                                set.insert(second)
                            }
                        }
                    }
                }
            }
        }
        
        return set.map({ (tran) -> String in
            tran.toString()
        })
    }
}

---

192ms

class Solution {
    func invalidTransactions(_ transactions: [String]) -> [String] {
       var tupleDic = [String: [(String, Int, Int, String)]]()
        var sets = Set<String>()
        for str in transactions {
            let arr = str.split(separator: ",")
            let (name, time, amount, city) = (String(arr[0]), Int(arr[1])!, Int(arr[2])!, String(arr[3]))
            var tpls =  tupleDic[name, default: [(String, Int, Int, String)]()]
            tpls.append((name, time, amount, city))
            tupleDic[name] = tpls
        }
        for (name, tpls) in tupleDic {
            for i in tpls.indices {
                let (n, t, a, c) = tpls[i]
                if a >= 1000 { sets.insert(n+","+"(t)"+","+"(a)"+","+c) }
                for j in i+1..<tpls.count {
                    let (n2, t2, a2, c2) = tpls[j]
                    if abs(t-t2) <= 60 && c2 != c {
                        sets.insert(n2+","+"(t2)"+","+"(a2)"+","+c2)
                        sets.insert(n+","+"(t)"+","+"(a)"+","+c)
                    }
                }
            }
        }
        return Array(sets)
    }
}

---

228ms

class Solution {
    struct Transaction {
        var name: String
        var minute: Int
        var amount: Int
        var place: String
        var idx: Int
    }
    
    func invalidTransactions(_ transactions: [String]) -> [String] {
        var res = Set<String>()
        var db = [String : [Transaction]]()
        
        for (idx, transaction) in transactions.enumerated() {
            let detail = transaction.components(separatedBy: ",")
            let t = Transaction(name: detail[0], minute: Int(detail[1]) ?? 0, amount: Int(detail[2]) ?? 0, place: detail[3], idx: idx)
            
            if t.amount > 1000 {
                res.insert(transaction)
            }
            
            var existed = db[t.name, default: [Transaction]()]
            for et in existed where abs(et.minute - t.minute) <= 60 && et.place != t.place {
                res.insert(transaction)
                res.insert(transactions[et.idx])
            }
            existed.append(t)
            db[t.name] = existed
        }
        
        return Array(res)
    }
}

---

312ms

class Solution {
    
    class Transaction {
        var name = ""
        var time = 0
        var amount = 0
        var city = ""
        
        init(_ transaction: String) {
            let components = transaction.components(separatedBy: ",")
            name = components[0]
            time = Int(components[1])!
            amount = Int(components[2])!
            city = components[3]
        }
        
        func toString() -> String {
            return "(name),(time),(amount),(city)"
        }
    }
    func invalidTransactions(_ transactions: [String]) -> [String] {
        var dict: [String: [Transaction]] = [:]
        var invalid: [String] = []
        for transaction in transactions {
            let newElem = Transaction(transaction)
            if let elems = dict[newElem.name] {
                for (index, elem) in elems.enumerated() {
                    if elem.city != newElem.city && abs(elem.time - newElem.time) <= 60 {
                        invalid.append(transaction)
                        invalid.append(elem.toString())
                    }
                }
                dict[newElem.name]!.append(newElem)
            } else {
                dict[newElem.name] = [newElem]
            }
            if newElem.amount > 1000 {
                invalid.append(transaction)
            }
        }
        return Array(Set(invalid))
    }
}

---

Runtime: 328 ms

Memory Usage: 23 MB

class Solution {
    func invalidTransactions(_ transactions: [String]) -> [String] {
        let N:Int = transactions.count
        var t:[Trans] = [Trans](repeating:Trans(),count:N)
        for i in 0..<N
        {
            t[i] = Trans.fromString(transactions[i])
        }
        var lst:[String] = [String]()
        for x in t
        {
            if x.money > 1000 || hasConflict(x, t)
            {
                lst.append(x.orig)
            }
        }
        return lst        
    }
    
    func hasConflict(_ x:Trans,_ t:[Trans]) -> Bool
    {
        for y in t
        {
            if x == y {continue}
            if x.name.isEqual(y.name) && !x.city.isEqual(y.city) && abs(x.time - y.time) <= 60
            {
                return true
            }
        }
        return false        
    }
}

class Trans:Hashable
{
    var name:String = String()
    var city:String = String()
    var orig:String = String()
    var time:Int = 0
    var money:Int = 0
    
    static func == (lhs: Trans, rhs: Trans) -> Bool {
        return lhs.name == rhs.name && lhs.city == rhs.city && lhs.orig == rhs.orig && lhs.time == rhs.time && lhs.money == rhs.money
    }
    
    func hash(into hasher: inout Hasher)
    {
        hasher.combine(name)
        hasher.combine(city)
        hasher.combine(orig)
        hasher.combine(time)
        hasher.combine(money)
    }
    
    static func fromString(_ s:String) -> Trans
    {
        let parts:[String] = s.components(separatedBy:",")
        var t:Trans = Trans()
        t.name = parts[0]
        t.time = Int(parts[1]) ?? 0
        t.money = Int(parts[2]) ?? 0
        t.city = parts[3]
        t.orig = s   
        return t
    }
}