Leetcode with Python

1. Two Sum

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

class Solution(object):
    def twoSum(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        """
        # create a diction where the key is target-the_current_item and the value is the index of the item
        buff_dict = {}
        for i in range(len(nums)):
            if nums[i] in buff_dict:
                return sorted([i,buff_dict[nums[i]]])
            else:
                buff_dict[target - nums[i]] = i

        # dictionary look-up time is O(1)
        # complexity O(n)

7. Reverse Integer

Given a 32-bit signed integer, reverse digits of an integer.

Example 1:

Input: 123
Output:  321

Example 2:

Input: -123
Output: -321

Example 3:

Input: 120
Output: 21

Note:
Assume we are dealing with an environment which could only hold integers within the 32-bit signed integer range. For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

class Solution(object):
    def reverse(self, x):
        """
        :type x: int
        :rtype: int
        """
        isPos = cmp(x,0)
        rev_num = int(`abs(x)`[::-1])
        return isPos*rev_num*(rev_num<2**31) 

        # backticks makes an object a string, equals to str()
        # [::-1] reverses an string

9. Palindrome Number

Determine whether an integer is a palindrome. Do this without extra space.

click to show spoilers.

Some hints:

Could negative integers be palindromes? (ie, -1)

If you are thinking of converting the integer to string, note the restriction of using extra space.

You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?

There is a more generic way of solving this problem.

class Solution(object):
    def isPalindrome(self, x):
        """
        :type x: int
        :rtype: bool
        """
        return `x` == `x`[::-1]

    # string is comparable using punc "=="
    # negative integers can not be palindromes, et: -1
         

13. Roman to Integer

Given a roman numeral, convert it to an integer.

Input is guaranteed to be within the range from 1 to 3999.

class Solution(object):
    def romanToInt(self, s):
        """
        :type s: str
        :rtype: int
        """

        roman_to_int = {'I':1,'V':5,'X':10,'L':50,'C':100,'D':500,'M':1000}
        res = 0
        pre = 0
        for i in s[::-1]:
            res = res + roman_to_int[i] if roman_to_int[i] >= pre else res - roman_to_int[i]
            pre = roman_to_int[i]
        return res

        # I = 1
        # V = 5
        # X = 10
        # L = 50
        # C = 100
        # D = 500
        # M = 1000
        # travel backword would be much easier because there is only one situation we would use substraction

14. Longest Common Prefix

Write a function to find the longest common prefix string amongst an array of strings.

 class Solution(object):
    def longestCommonPrefix(self, strs):
        """
        :type strs: List[str]
        :rtype: str
        """
        if not strs:
            return ""
        return reduce(self.lcp,strs)
    def lcp(self,str1,str2):
        i=0
        while(i<len(str1) and i<len(str2)):
            if(str1[i]==str2[i]):
                i=i+1
            else:
                break
        return str1[:i]            

    # do not neglect the situation when strs is an empty list
    # lcp is an method of self, it's defined inside the class.

20. Valid Parentheses

Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid.

The brackets must close in the correct order, "()" and "()[]{}" are all valid but "(]" and "([)]" are not.

class Solution(object):
    def isValid(self, s):
        """
        :type s: str
        :rtype: bool
        """
        stack = []
        brackets_dict = {']':'[' , '}':'{', ')':'('}
        for elem in s:
            if elem in brackets_dict.values():
                stack.append(elem)
            elif stack==[] or brackets_dict[elem] != stack.pop():
                    return False
        if stack!=[]:
            return False

        return True

        # consider what returns false:
        #   1. not match
        #   2. an right halve comes when the stack is empty
        #   3. the stack is not empty when s is out of elements

        # always put isEmpty judge at the very begining
        # python is capital sensitive, do not mistake true and false with True and False
        

26. Remove Duplicates from Sorted Array

Given a sorted array, remove the duplicates in-place such that each element appear only once and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example:

Given nums = [1,1,2],

Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively.
It doesn't matter what you leave beyond the new length.

class Solution(object):
    def removeDuplicates(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        if not nums:
            return 0
        end_ind = 0
        for i in range(1,len(nums)):
            if nums[end_ind] != nums[i]:
                end_ind += 1
                nums[end_ind] = nums[i]
        return end_ind+1

    # ++ is illegal but += is not
    # do not neglect the case when nums is an empty array

27. Remove Element

Given an array and a value, remove all instances of that value in-place and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

The order of elements can be changed. It doesn't matter what you leave beyond the new length.

Example:

Given nums = [3,2,2,3], val = 3,

Your function should return length = 2, with the first two elements of nums being 2.

class Solution(object):
    def removeElement(self, nums, val):
        """
        :type nums: List[int]
        :type val: int
        :rtype: int
        """
        if nums == []:
            return 0
        new = 0
        for i in range(len(nums)):
            if(nums[i] != val):
                nums[new] = nums[i]
                new += 1
        return new

    # a plain answer

28. Implement strStr()

Implement strStr().

Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1:

Input: haystack = "hello", needle = "ll"
Output: 2

Example 2:

Input: haystack = "aaaaa", needle = "bba"
Output: -1

class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        if needle == "":
            return 0
        ind = len(haystack)
        while(needle in haystack[:ind]):
            ind -= 1
        return ind+1-len(needle) if ind != len(haystack) else -1

    # if you want the index of the first occurence, you should do the delete_and_check backward

 

35. Search Insert Position

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Example 1:

Input: [1,3,5,6], 5
Output: 2

Example 2:

Input: [1,3,5,6], 2
Output: 1

Example 3:

Input: [1,3,5,6], 7
Output: 4

Example 1:

Input: [1,3,5,6], 0
Output: 0

class Solution(object):
    def searchInsert(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        # one liner
        return len([x for x in nums if x < target])

53. Maximum Subarray

Find the contiguous subarray within an array (containing at least one number) which has the largest sum.

For example, given the array [-2,1,-3,4,-1,2,1,-5,4],
the contiguous subarray [4,-1,2,1] has the largest sum = 6.

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        maxsum=cursum=nums[0]
        for i in nums[1:]:
            cursum = max(cursum+i , i)
            maxsum = max(cursum,maxsum)
        return maxsum

        # treat the group as one element and compare it with the current element
        # the current element would take place the whole group if it is more capable than the sum of the group

58. Length of Last Word

Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word in the string.

If the last word does not exist, return 0.

Note: A word is defined as a character sequence consists of non-space characters only.

Example:

Input: "Hello World"
Output: 5

class Solution(object):
    def lengthOfLastWord(self, s):
        """
        :type s: str
        :rtype: int
        """
        return len(s.strip().split(' ')[-1])
    # always come up with strip method when deal with last whitespace

557. Reverse Words in a String III

Given a string, you need to reverse the order of characters in each word within a sentence while still preserving whitespace and initial word order.

Example 1:

Input: "Let's take LeetCode contest"
Output: "s'teL ekat edoCteeL tsetnoc"

Note: In the string, each word is separated by single space and there will not be any extra space in the string.

class Solution(object):
    def reverseWords(self, s):
        """
        :type s: str
        :rtype: str
        """
        l = s.split(" ")
        res = ""
        for i in l:
            res += i[::-1]+" "
        return res.strip()

        # good solution from Jiale

67. Add Binary

Given two binary strings, return their sum (also a binary string).

For example,
a = "11"
b = "1"
Return "100".

class Solution(object):
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        if (len(a)==0):
            return b
        elif(len(b)==0):
            return a
        if(a[-1]=='1' and b[-1]=='1'):
            return self.addBinary(self.addBinary(a[0:-1],b[0:-1]),'1')+'0'
        elif(a[-1]=='0' and b[-1]=='0'):
            return self.addBinary(a[0:-1],b[0:-1])+'0'
        else:
            return self.addBinary(a[0:-1],b[0:-1])+'1'
        # recursive

69. Sqrt(x)

Implement int sqrt(int x).

Compute and return the square root of x.

x is guaranteed to be a non-negative integer.

Example 1:

Input: 4
Output: 2

Example 2:

Input: 8
Output: 2
Explanation: The square root of 8 is 2.82842..., and since we want to return an integer, the decimal part will be truncated.

什么是牛顿法？

class Solution(object):
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        r = x
        while(r*r>x):
            r = (r+x/r)/2
        return r
    # using Newton method

70. Climbing Stairs

You are climbing a stair case. It takes n steps to reach to the top.

Each time you can either climb 1 or 2 steps. In how many distinct ways can you climb to the top?

Note: Given n will be a positive integer.

Example 1:

Input: 2
Output:  2
Explanation:  There are two ways to climb to the top.

1. 1 step + 1 step
2. 2 steps

Example 2:

Input: 3
Output:  3
Explanation:  There are three ways to climb to the top.

1. 1 step + 1 step + 1 step
2. 1 step + 2 steps
3. 2 steps + 1 step

class Solution(object):
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        n_2 = 1
        n_1 = 2
        if n==1: return 1
        if n==2: return 2
        for i in range(n+1)[4:]:
            n_1 += n_2
            n_2 = n_1 - n_2
        return n_2+n_1

        # iteratively
        # the finale step is either 1 or 2.
        # From the point [n-1], we take one step to reach the point [n].
        # From the point [n-2], we take a two-steps leap to reach the point [n]. 

83. Remove Duplicates from Sorted List

Given a sorted linked list, delete all duplicates such that each element appear only once.

For example,
Given 1->1->2, return 1->2.
Given 1->1->2->3->3, return 1->2->3.

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        root=head
        while(head):
            while(head.next and head.val == head.next.val):
                head.next = head.next.next
            head = head.next
        return root

    # the second while loop will find the first element that is not the same with the current one until you come to the end of the list

88. Merge Sorted Array

Given two sorted integer arrays nums1 and nums2, merge nums2 into nums1 as one sorted array.

Note:
You may assume that nums1 has enough space (size that is greater or equal to m + n) to hold additional elements from nums2. The number of elements initialized in nums1 and nums2 are m and n respectively.

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        while(m>0 and n>0):
            if(nums1[m-1]>=nums2[n-1]):
                nums1[m+n-1] = nums1[m-1]
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
                n -= 1
        if(n>0):
            nums1[0:n] = nums2[0:n]

        return

    # be carefull when using slicing. The right index is not included. so you should just use the number of elements in this list. The slice will stop at the end of the list

136. Single Number

Given an array of integers, every element appears twice except for one. Find that single one.

Note:
Your algorithm should have a linear runtime complexity. Could you implement it without using extra memory?

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        return reduce(lambda x,y: x^y,nums)

    # exclusive OR, namely XOR