java and python学习——第三周leetcode刷题

    本周仍旧是按照顺序做leetcode上的题目，可能是因为不经常用这两种语言，所以在编题的时候稍微有点生疏。所以下个星期我准备再返回头好好看一下我自学的java和python的内容，再回头看一下前两周做过的题目。将基础的每一步都做得扎实一点，学以后的东西就会事半功倍，否则我怕会越来越困难。当然，每周做的题目都会比上一周难一点，但是不会难太多，我都是按照难易顺序一道一道刷的，下面就是本周做的五道题目。

171. Excel Sheet Column Number

    第一道题，这道题的本意就是让我们建立一种新的进制，26进制。并且二十六个大写字母代表着1~26个数字，所以A就是1，AA就是1*26+1=27。依次类推，我们可以得到一个递推公式来算出整个字符串所代表的数字到底是多少。

java版本：

    在java中要特别注意，首先要全部转换为大写字母，而且要转换为字符数组。递推公式很容易想到，即为循环体内的公式。

public class Solution 
{
    public int titleToNumber(String s) 
    {
        String ss=s.toUpperCase();
        char[] sss=ss.toCharArray();
        int len=s.length()-1;
        int answer=0;
        for(int i=0;i<=len;i++)
        {
            answer=answer*26+sss[i]-'A'+1;
        }
        return answer;
    }
}

python版本：

    在python中一定要注意，不能像java和c++中那样用字符串中的元素直接与数字相加减，要用函数ord()函数。

class Solution(object):
    def titleToNumber(self, s):
        """
        :type s: str
        :rtype: int
        """
        answer=0;
        for i in s:
            answer=answer*26+ord(i)-ord('A')+1;
        return answer

242. Valid Anagram

    这道题挺简单的，提议是给我们两个字符串，让我们判断这两个字符串是否是互相排列组合而成的。我最开始的时候想用位运算来计算这道题，即两个字符串分别进行异或运算，如果运算之后结果相等，就可以判断两个字符串是相等的。但是，我没有考虑到的是，如果第一个字符串中出现两个相同字符，第二个字符串中也出现两个相同字符，但是这两个字符不相同，但是我们得到的结果是true而不是正确的false。所以后来我就选择了分别统计每个字符串中字符的种类和数量，然后再比较两个字符串中统计的结果是否相同。代码如下：

java版本：

    在第一个字符串中统计，没出现就相应加一，在第二个字符串中出现就相应减一。

public class Solution 
{
    public boolean isAnagram(String s, String t) 
    {
        char[] ss=s.toCharArray();
        char[] tt=t.toCharArray();
        int[] pp=new int[26];
        for(int i=0;i<=ss.length-1;i++)
        {
            pp[ss[i]-'a']++;
        }
        for(int j=0;j<=tt.length-1;j++)
        {
            pp[tt[j]-'a']--;
        }
        for(int ii=0;ii<=25;ii++) 
        {
            if(pp[ii]!=0) 
            {
                return false;
            }
        }
        return true;
    }
}

python版本：

    因为在python中可以直接比较两个序列，所以我们直接用两个序列统计完进行比较就可以了。

class Solution(object):
    def isAnagram(self, s, t):
        """
        :type s: str
        :type t: str
        :rtype: bool
        """
        aa=[0]*26
        bb=[0]*26
        for i in s:
            aa[ord(i)-ord('a')]+=1
        for j in t:
            bb[ord(j)-ord('a')]+=1
        if(aa==bb):
            return True
        else:
            return False
            

387. First Unique Character in a String

        这道题的意思就是，给定一个字符串，返回第一个只出现了一次的字符。这道题怎么做呢？当然我们仍然需要做一次统计，统计出每个字符的数量。但是，我们需要注意的是，怎么返回第一个只出现一次的字符呢。可能有的人会想到标记元素，给他们打上出现顺序的标签。但是，其实我们只需要再次从头遍历字符串，找到第一个数量为1的元素，返回其位置即可。

java版本：

public class Solution 
{
    public int firstUniqChar(String s) 
    {
        char[] ss=s.toCharArray();
        int [] aa=new int[26];
        for(int i=0;i<ss.length;i++)
        {
            aa[ss[i]-'a']++;
        }
        for(int j=0;j<ss.length;j++)
        {
            if(aa[ss[j]-'a']==1) return j;
        }
        return -1;
    }
}

python版本：

class Solution(object):
    def firstUniqChar(self, s):
        """
        :type s: str
        :rtype: int
        """
        aa=[0]*26;
        for i in s:
            aa[ord(i)-ord('a')]+=1
        bb=0
        for j in s:
            bb+=1
            if aa[ord(j)-ord('a')]==1:
                return bb-1
        return -1

217. Contains Duplicate

    这道题的意思是，给定我们一个数组，如果有一个元素出现至少两次，我们就返回true，否则返回false。其实我们可以同样使用遍历统计来统计每个元素的数量，随后查看统计结果就可以了。但是我觉得这种做法可能是最笨的，也是最容易想到的。所以我又想到了，先做一个排序，这样相同的元素就都挨到了一起。然后我们再挨个比较前一个和后一个元素是否相等，如果相等我们就不用再继续遍历下去，返回true即可。

java版本：

public class Solution 
{
    public boolean containsDuplicate(int[] nums) 
    {
        Arrays.sort(nums);
        for(int i=1;i<nums.length;i++)
        {
            if(nums[i]==nums[i-1]) return true;
        }
        return false;
    }
}

python版本：

    我们在python中要注意，如果我们用在循环中要用index，我们就要用到range(begin，end)来作为index的范围。

class Solution(object):
    def containsDuplicate(self, nums):
        """
        :type nums: List[int]
        :rtype: bool
        """
        nums.sort();
        for i in range(0,len(nums)-1):
            if nums[i]==nums[i+1]:
                return True
        return False

350. Intersection of Two Arrays II

    这道题是我以前做过一道题的变种，前面做过的那道题是不允许出现重复元素，而这道题是可以考虑到重复元素。这样我们的算法就比较好想到了，因为我们避免了判断重复元素的步骤。所以我们先对两个数组做排序，然后让两个指针指向数组的开头，比较两个元素大小，如果相等就加到答案的数组中，如果不相等，就把小的那个元素指针向前加一。这样我们就可以将相同的元素完全添加到答案数组中，不会有遗漏。其实选择元素的过程，也就相当于将两个数组合并排序的过程，且复杂度为O(N)。

java版本：

    我们要注意到的是，java中开辟数组一定要有一个固定的大小。所以我选择了动态数组来做这道题，但是动态数组麻烦的是它里面元素都是类类型，我们怎么把它里面的元素再转换为int整型并且保存到一个整型数组当中这就是一个问题。我上网学习了一下动态数组转换数组的方法，发现直接转换的方法是适用于string类。而整型的我就选择了使用遍历，每个元素逐个转变的做法，要用到函数ArrayList.get()函数，来强制转换为int型。

public class Solution 
{
    public int[] intersect(int[] nums1, int[] nums2) 
    {
        Arrays.sort(nums1);
        Arrays.sort(nums2);
        ArrayList intList=new ArrayList();
        int i=0,j=0;
        while(i<nums1.length&&j<nums2.length)
        {
            if(nums1[i]==nums2[j])
            {
                intList.add(nums1[i]);
                i++;j++;
            }
            else if(nums1[i]<nums2[j]) i++;
            else j++;
        }
        int[] answer=new int[intList.size()];
        for(int ii=0;ii<intList.size();ii++) answer[ii]=(int)intList.get(ii);
        
        return answer;
    }
}

python版本：

    在python当中就不会有这个问题，因为python当中的序列是动态的，是可以随着元素的添加改变大小的。所以我们只需要事先声明一个空序列然后添加元素进去就可以了，不用最后再进行转换。

class Solution(object):
    def intersect(self, nums1, nums2):
        """
        :type nums1: List[int]
        :type nums2: List[int]
        :rtype: List[int]
        """
        answer=[]
        nums1.sort()
        nums2.sort()
        i=0 
        j=0
        while i<len(nums1) and j<len(nums2):
            if nums1[i]==nums2[j]:
                answer.append(nums1[i])
                i+=1
                j+=1
            elif nums1[i] < nums2[j]:
                i+=1
            else:
                j+=1
        return answer