Unique Email Addresses

最新推荐文章于 2019-05-09 22:50:44 发布

原创最新推荐文章于 2019-05-09 22:50:44 发布 · 1.6k 阅读

0 ·

CC 4.0 BY-SA版权

算法同时被 2 个专栏收录

7 篇文章

订阅专栏

leetcode

6 篇文章

订阅专栏

本文探讨了如何处理包含特殊字符的电子邮件地址，通过去除点号和忽略加号后的文本，识别并计算实际接收邮件的不同地址数量。使用Golang实现，对比了两种算法效率，最终采用map数据结构优化解决方案。

Unique Email Addresses

Every email consists of a local name and a domain name, separated by the @ sign.

For example, in alice@leetcode.com, alice is the local name, and leetcode.com is the domain name.

Besides lowercase letters, these emails may contain '.'s or '+'s.

If you add periods (’.’) between some characters in the local name part of an email address, mail sent there will be forwarded to the same address without dots in the local name. For example, "alice.z@leetcode.com" and "alicez@leetcode.com" forward to the same email address. (Note that this rule does not apply for domain names.)

If you add a plus (’+’) in the local name, everything after the first plus sign will be ignored. This allows certain emails to be filtered, for example m.y+name@email.com will be forwarded to my@email.com. (Again, this rule does not apply for domain names.)

It is possible to use both of these rules at the same time.

Given a list of emails, we send one email to each address in the list. How many different addresses actually receive mails?

Example 1:

Input: ["test.email+alex@leetcode.com","test.e.mail+bob.cathy@leetcode.com","testemail+david@lee.tcode.com"]
Output: 2
Explanation: "testemail@leetcode.com" and "testemail@lee.tcode.com" actually receive mails

Note:

1 <= emails[i].length <= 100
1 <= emails.length <= 100
Each emails[i] contains exactly one ‘@’ character.

问题剖析

上述问题本质上是对字符串的处理问题，需要用到字符串的分割，合并，替换等操作。难度本身不大，只是为了熟悉字符串操作而已。所以本人首先了一个效率不怎么高的解法，拆分字符串数组，对每个"邮箱地址"进行处理。代码如下所示：

func numUniqueEmails(emails []string) int {
    
    if emails == nil {
        return 0
    }
    
    actual := make([]string, 0)
    
    for _, email := range emails {
        
        local := strings.Split(email, "@")[0]
        domain := strings.Split(email, "@")[1]
        
        if strings.Index(local, "+") != -1 {
            local = strings.Split(local, "+")[0]
        }
        
        local = strings.Replace(local, ".", "", -1)
        
        newEmail := fmt.Sprintf("%s@%s", local, domain)
        
        if !isInActual(actual, newEmail) {
            actual = append(actual, newEmail)
        }
    }
    
    return len(actual)
}

func isInActual(actual []string, str string) bool {
    isIn := false
    
    for _, item := range actual {
        if item == str {
            isIn = true
        }
    }
    return isIn
}

这个解法虽然搞定了需求，但是有很多多余的操作，比如判断是否是重复的字符串的时候，其实没必要通过函数调用isInActual，去一次次的遍历整个列表。这样的操作是O(n^2)时间复杂度。而golang本身提供了map这样的数据结构可以去重，所以代码可以再次简化：

func numUniqueEmails(emails []string) int {
    
    if emails == nil {
        return 0
    }
    
    e_map := make(map[string]int)
    
    for idx, email := range emails {
        
        local  := strings.Split(email, "@")[0]
        domain := strings.Split(email, "@")[1]
        if strings.Index(local, "+") != -1 {
            local = strings.Split(local, "+")[0]
        }
        
        local = strings.Replace(local, ".", "", -1)
        
        newEmail := fmt.Sprintf("%s@%s", local, domain)
        
        if _, ok:= e_map[newEmail]; !ok {
            e_map[newEmail] = idx
        }
    }

    return len(e_map)
}

整个解法比上个解法整整快了一倍，时间比较如下：
在这里插入图片描述
欢迎大家进行改进，希望得到更快的解法。

leetcode上有个哥们用了比较复杂的表达式进行切分，也得到了结果。代码比较简短。但是可读性不太好，而且比我的第二个解法还慢了一些。代码示例如下：

func numUniqueEmails(emails []string) int {
	m := make(map[string]int)
	for i := 0; i < len(emails); i++ {
		parsedEmail := strings.Join(strings.Split(emails[i][0:strings.Index(emails[i], "+")-1], "."), "") + emails[i][strings.Index(emails[i], "@"):]
		if _, ok := m[parsedEmail]; ok {
			continue
		}
		m[parsedEmail] = i
	}
	result := len(m)
	return result
}