scala的intersect的一种应用场景

最近看到一道Google的面试题中的一个问题

 题目

面试题目是这样子的：

两个单词如果包含相同的字母，次序不同，则称为字母易位词(anagram)。例如，“silent”和“listen”是字母易位词，而“apple”和“aplee”不是易位词。请定义函数检查两个单词是否是字母易位词。可以假设两个单词字母均为小写。要求算法复杂度尽量低。

看到这个题目，你的思路是什么？

思路一

首先，最基本的思路，便是检测字符串s1中的字符是否都出现在s2中（在s1和s2长度一样的前提下）。为了解决“apple”和“aplee”不是易位词的这种情况，不能仅仅判断出现在s2中就可以了，还需要做个标记。这里可以考虑将字符串转换为list，对于比较过的便设置为None。算法代码设计如下：
def anagramSolution1(s1,s2):

    if len(s1) != len(s2):
        return False

    alist = list(s2)

    pos1 = 0
    stillOK = True

    while pos1 < len(s1) and stillOK:
        pos2 = 0
        found = False
        while pos2 < len(alist) and not found:
            if s1[pos1] == alist[pos2]:
                found = True
            else:
                pos2 = pos2 + 1

        if found:
            alist[pos2] = None
        else:
            stillOK = False
            break

        pos1 = pos1 + 1

    return stillOK

print(anagramSolution1('abcd','dcba'))
让我们考虑一下算法复杂度。可以从字符串s2来考虑，对于s2中的每个元素，s1都会从头开始进行遍历一次，所以算法的复杂度为：

 
即算法的复杂度为O(n^2)。

有没有算法复杂度更低的思路呢？思考一下。

思路二

通过题目，我们可以想到，字母易位词即为各个字母的数目相同，而顺序不一致。因而，如果对字符串按照字母顺序排序后，那么两个字符串应该完全一致。这样算法复杂度是否更低？

先看一下代码实现如下：
def anagramSolution2(s1,s2):

    if len(s1) != len(s2):
        return False

    alist1 = list(s1)
    alist2 = list(s2)

    alist1.sort()
    alist2.sort()

    pos = 0
    matches = True

    while pos < len(s1) and matches:
        if alist1[pos]==alist2[pos]:
            pos = pos + 1
        else:
            matches = False
            break

    return matches

print(anagramSolution2('abcde','edcba'))
这样算法复杂度是否是O(n)了呢？因为仅仅进行了n次比较啊。当然不是，为什么呢？因为事先先对两个字符串进行了排序，而排序的复杂度并未计入。所以，此种算法的复杂度即为O(n*logn+n)，为O(n*logn)。复杂度比思路一的复杂度降低了。

有没有复杂度更低的算法呢？

思路三

思路二利用了字母易位词即为各个字母的数目相同，而顺序不一致。我们从另外一个角度思考，字母一共有多少个？很明显，只有26个（只考虑小写字母）。那么，我们可以为字符串s1和s2分别设置26个计数器，然后判断这对应位置的计数是否相等，如果对应计数完全相等，则为字母易位词。算法代码实现如下：

def anagramSolution3(s1,s2):
    c1 = [0]*26
    c2 = [0]*26

    for i in range(len(s1)):
        pos = ord(s1[i])-ord('a')
        c1[pos] = c1[pos] + 1

    for i in range(len(s2)):
        pos = ord(s2[i])-ord('a')
        c2[pos] = c2[pos] + 1

    j = 0
    stillOK = True
    while j<26 and stillOK:
        if c1[j]==c2[j]:
            j = j + 1
        else:
            stillOK = False
            break

    return stillOK

print(anagramSolution3('apple','plepa'))
算法的复杂度为O(n + n + 26) ，即为O(n)，为线性复杂度的算法。

前几天，一直在跟同事讨论怎么面试考察思维反应能力，这个题目给出了答案，能够一步步深入下去的，必定需要一定的思维反应能力。 

然后最近在学习scala，发现里面的一个方法intersect正好可以解决这个问题

if("Hello".intersect("olbeH")=="Hello") true else false，如果返回为真。