前200道题中的简单题

Author: princewen

easy/141_Linked List Cycle.py

@@ -0,0 +1,36 @@
+"""
+
+Given a linked list, determine if it has a cycle in it.
+
+Follow up:
+Can you solve it without using extra space?
+
+"""
+
+"""判断列表中是否有环，只需设置两个指针，一个跑的快，一个跑的慢，当跑的快的追上跑的慢的的时候，肯定就又环，如果碰到next不存在的情况，
+抛出异常，肯定没有环
+"""
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def hasCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
+        if not head:
+            return False
+        walker = head
+        runner = head.next
+        try:
+            while walker != runner:
+                walker = walker.next
+                runner = runner.next.next
+            return True
+        except:
+            return False

easy/155_Min Stack.py

@@ -0,0 +1,42 @@
+"""
+
+Design a stack that supports push, pop, top, and retrieving the minimum element in constant time.
+
+push(x) -- Push element x onto stack.
+pop() -- Removes the element on top of the stack.
+top() -- Get the top element.
+getMin() -- Retrieve the minimum element in the stack.
+
+
+"""
+
+
+class MinStack(object):
+    def __init__(self):
+        self.q = []
+
+    # @param x, an integer
+    # @return an integer
+    def push(self, x):
+        curMin = self.getMin()
+        if curMin == None or x < curMin:
+            curMin = x
+        self.q.append((x, curMin));
+
+    # @return nothing
+    def pop(self):
+        self.q.pop()
+
+    # @return an integer
+    def top(self):
+        if len(self.q) == 0:
+            return None
+        else:
+            return self.q[len(self.q) - 1][0]
+
+    # @return an integer
+    def getMin(self):
+        if len(self.q) == 0:
+            return None
+        else:
+            return self.q[len(self.q) - 1][1]

easy/160_Intersection of Two Linked Lists.py

@@ -0,0 +1,53 @@
+"""
+
+Write a program to find the node at which the intersection of two singly linked lists begins.
+
+
+For example, the following two linked lists:
+
+A:          a1 → a2
+                   ↘
+                     c1 → c2 → c3
+                   ↗            
+B:     b1 → b2 → b3
+begin to intersect at node c1.
+
+
+Notes:
+
+If the two linked lists have no intersection at all, return null.
+The linked lists must retain their original structure after the function returns.
+You may assume there are no cycles anywhere in the entire linked structure.
+Your code should preferably run in O(n) time and use only O(1) memory.
+Credits:
+Special thanks to @stellari for adding this problem and creating all test cases.
+
+"""
+
+"""两个指针，如果两个链表有交集的话，肯定会跑到同一个节点，没有交集，则最后的pa和pb都是None，都是None也能跳出循环
+长度差异也考虑进去了
+"""
+
+
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def getIntersectionNode(self, headA, headB):
+        """
+        :type head1, head1: ListNode
+        :rtype: ListNode
+        """
+        if not headA or not headB:
+            return None
+
+        else:
+            pa = headA
+            pb = headB
+            while pa is not pb:
+                pa = headB if pa == None else pa.next
+                pb = headA if pb == None else pb.next
+            return pa

easy/167_Two Sum II - Input array is sorted.py

@@ -0,0 +1,29 @@
+"""
+
+Given an array of integers that is already sorted in ascending order, find two numbers such that they add up to a specific target number.
+
+The function twoSum should return indices of the two numbers such that they add up to the target, where index1 must be less than index2. Please note that your returned answers (both index1 and index2) are not zero-based.
+
+You may assume that each input would have exactly one solution and you may not use the same element twice.
+
+Input: numbers={2, 7, 11, 15}, target=9
+Output: index1=1, index2=2
+
+"""
+
+"""仍然是字典的思路"""
+class Solution(object):
+    def twoSum(self, numbers, target):
+        """
+        :type numbers: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        res = dict()
+        for i in range(0,len(numbers)):
+            sub = target - numbers[i]
+            if sub in res.keys():
+                return [res[sub]+1,i+1]
+            else:
+                res[numbers[i]] = i
+        return []

easy/168_Excel Sheet Column Title.py

@@ -0,0 +1,31 @@
+"""
+
+Given a positive integer, return its corresponding column title as appear in an Excel sheet.
+
+For example:
+
+    1 -> A
+    2 -> B
+    3 -> C
+    ...
+    26 -> Z
+    27 -> AA
+    28 -> AB 
+
+
+"""
+"""
+my solution，这里要注意，不能直接除或者余26，首先要减一，举个例子就可以知道
+"""
+
+class Solution(object):
+    def convertToTitle(self, n):
+        """
+        :type n: int
+        :rtype: str
+        """
+        res = ''
+        while n:
+            res = chr((n - 1) % 26 + 65) + res
+            n = (n - 1) / 26
+        return res

easy/169_Majority Element.py

@@ -0,0 +1,49 @@
+"""
+
+Given an array of size n, find the majority element. The majority element is the element that appears more than ⌊ n/2 ⌋ times.
+
+You may assume that the array is non-empty and the majority element always exist in the array.
+
+"""
+
+"""
+my solution ：使用一个字典
+"""
+
+class Solution(object):
+    def majorityElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        res = dict()
+        for i in nums:
+            if i in res.keys():
+                res[i] = res[i]+1
+            else:
+                res[i] = 1
+            if res[i] > len(nums)/2:
+                return i
+
+
+"""other solution
+常数级的空间复杂度，因为最多的元素超过一半，所以该元素的count值减去其他所有元素的count值一定大于0，所以最后的cand一定是出现次数最多的元素
+"""
+
+class Solution(object):
+    def majorityElement(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        cand = nums[0]
+        count = 1
+        for i in nums[1:]:
+            if count == 0:
+                cand,count = i,1
+            else:
+                if i == cand:
+                    count = count + 1
+                else:
+                    count = count - 1
+        return cand

easy/171_Excel Sheet Column Number.py

@@ -0,0 +1,38 @@
+"""
+
+Related to question Excel Sheet Column Title
+
+Given a column title as appear in an Excel sheet, return its corresponding column number.
+
+For example:
+
+    A -> 1
+    B -> 2
+    C -> 3
+    ...
+    Z -> 26
+    AA -> 27
+    AB -> 28 
+
+"""
+
+"""
+my solution
+"""
+
+
+class Solution(object):
+    def titleToNumber(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        count = 0
+        for i in s:
+            count = count * 26 + (ord(i) - 65) % 26 + 1
+        return count
+
+"""other solution : 1 line"""
+
+def titleToNumber(self, s):
+    return reduce(lambda x,y:x*26+y,map(lambda x:ord(x)-ord('A')+1,s))

easy/172_Factorial Trailing Zeroes.py

@@ -0,0 +1,20 @@
+"""
+
+Given an integer n, return the number of trailing zeroes in n!.
+
+Note: Your solution should be in logarithmic time complexity.
+
+Credits:
+Special thanks to @ts for adding this problem and creating all test cases.
+
+"""
+
+
+class Solution(object):
+    def trailingZeroes(self, n):
+        zeroCnt = 0
+        while n > 0:
+            n = n / 5;
+            zeroCnt += n
+
+        return zeroCnt

easy/189_Rotate Array.py

@@ -0,0 +1,31 @@
+"""
+
+Rotate an array of n elements to the right by k steps.
+
+For example, with n = 7 and k = 3, the array [1,2,3,4,5,6,7] is rotated to [5,6,7,1,2,3,4].
+
+Note:
+Try to come up as many solutions as you can, there are at least 3 different ways to solve this problem.
+
+[show hint]
+
+Hint:
+Could you do it in-place with O(1) extra space?
+Related problem: Reverse Words in a String II
+
+"""
+
+"""my solution"""
+
+
+class Solution(object):
+    def rotate(self, nums, k):
+        """
+        :type nums: List[int]
+        :type k: int
+        :rtype: void Do not return anything, modify nums in-place instead.
+        """
+        n = len(nums)
+        nums[:] = nums[n - k:] + nums[:n - k]
+
+

easy/190_Reverse Bits.py

@@ -0,0 +1,31 @@
+"""
+
+Reverse bits of a given 32 bits unsigned integer.
+
+For example, given input 43261596 (represented in binary as 00000010100101000001111010011100), return 964176192 (represented in binary as 00111001011110000010100101000000).
+
+Follow up:
+If this function is called many times, how would you optimize it?
+
+Related problem: Reverse Integer
+
+"""
+
+"""
+my solution
+
+"""
+
+class Solution:
+    # @param n, an integer
+    # @return an integer
+    def reverseBits(self, n):
+        stack = []
+        while n:
+            stack.append(n%2)
+            n /= 2
+        while(len(stack)<32):
+            stack.append(0)
+        for i in range(0,len(stack)):
+            n = n*2+stack[i]
+        return n