07/01/18 6:46 pm

sk-g · sk-g · commit c88b5400e20d · 2018-01-07T18:46:58.000-06:00
diff --git a/README.md b/README.md
@@ -1,10 +1,10 @@
-# Leetcode
-My solutions for problems on Leetcode
-Currently most solutions will be in Python
-and I will try to write out solutions in C/C++ as well.
-
-I will probably do a weekly update with more than one approach to problems.
-If help was taken from some other source, I will post links in the comments of the code, be sure to check them out.
-
-
-If you would like to contribute create an issue/pull request.
+# Leetcode
+My solutions for problems on Leetcode
+Currently most solutions will be in Python
+and I will try to write out solutions in C/C++ as well.
+
+I will probably do a weekly update with more than one approach to problems.
+If help was taken from some other source, I will post links in the comments of the code, be sure to check them out.
+
+
+If you would like to contribute create an issue/pull request.
diff --git a/python/Palindrome Number.py b/python/Palindrome Number.py
@@ -0,0 +1,46 @@
+#9 Palindrome Number
+# simple and straight forward
+# only trick in this question
+# is to check if the number is divisible
+# by 10 so that 100 becomes 1 instead of
+# 001 which is not a palindrome
+# this also might reduce submission time
+
+
+
+class Solution(object):
+    def isPalindrome(self, x):
+        """
+        :type x: int
+        :rtype: bool
+        """
+        g=x # storing number for later use
+        if x<0: # handling some end cases as usual
+            return False
+        elif x<=9:  # single digit case
+            return True
+        elif x%10==0:   # i
+            return False
+        elif x==11: # most numbers divisible by 11 are palindrome
+                    # but not all, so we can try to handle some cases
+            return True
+        elif x==111:
+            return True
+        else:
+            a=0 # temporary variable for multiplication
+            t=0 # temporary variable to build reverse
+            while x:
+                t=a*10+x%10
+                if t/10!=a:
+                    return 0
+                a=t
+                x=x/10
+            
+            if a==g:
+                
+                return True
+            else:
+                
+                return False
+                
+                
diff --git a/python/Reverse Integer.py b/python/Reverse Integer.py
@@ -1,32 +1,32 @@
-#7 Reverse Integer
-# https://leetcode.com/problems/reverse-integer/
-
-class Solution:
-    def reverse(self, x):
-        """
-        :type x: int
-        :rtype: int
-        """
-        
-        INT_MAX = 2**31 -1 # for integer overflow
-        #INT_MIN = -(2**31 -1)
-        if abs(x) < 10:   return x # if the integer is single digit,
-        						   # we can just return the same number.
-        if x < 0:				   # checking if the number is negative
-            r = -int(str(-x)[::-1])# python strings are not mutable, 
-            					   # so create a new string with slicing trick
-        if x > 0:
-            r = int(str(x)[::-1])
-        if abs(r) > INT_MAX: #or r < INT_MIN: # check for overflow, using abs() we can
-        				 	 # we can skip the extra check for MIN overflow, runs a bit faster
-            return 0		 # if overflow occurs after reversing, return 0
-        else:
-            return r
-        """
-        if x>=0:
-            n = int(str(abs(x))[::-1])
-        else:
-            n = -int(str(abs(-x))[::-1])
-        return n if n.bit_length() < 32 else 0 # same trick but, 
-        									   # using inbuilt function to check for overflow
+#7 Reverse Integer
+# https://leetcode.com/problems/reverse-integer/
+
+class Solution:
+    def reverse(self, x):
+        """
+        :type x: int
+        :rtype: int
+        """
+        
+        INT_MAX = 2**31 -1 # for integer overflow
+        #INT_MIN = -(2**31 -1)
+        if abs(x) < 10:   return x # if the integer is single digit,
+        						   # we can just return the same number.
+        if x < 0:				   # checking if the number is negative
+            r = -int(str(-x)[::-1])# python strings are not mutable, 
+            					   # so create a new string with slicing trick
+        if x > 0:
+            r = int(str(x)[::-1])
+        if abs(r) > INT_MAX: #or r < INT_MIN: # check for overflow, using abs() we can
+        				 	 # we can skip the extra check for MIN overflow, runs a bit faster
+            return 0		 # if overflow occurs after reversing, return 0
+        else:
+            return r
+        """
+        if x>=0:
+            n = int(str(abs(x))[::-1])
+        else:
+            n = -int(str(abs(-x))[::-1])
+        return n if n.bit_length() < 32 else 0 # same trick but, 
+        									   # using inbuilt function to check for overflow
         """
diff --git a/python/two sum.py b/python/two sum.py
@@ -1,37 +1,37 @@
-class Solution:
-    def twoSum(self, nums, target):
-        """
-        :type nums: List[int]
-        :type target: int
-        :rtype: List[int]
-        """
-        # probably the most common question and the easiest to start with
-        # I know of two solutions: 
-            # First using dictionary (one pass and two pass)
-            # The other using binary search (log(n))
-        
-        """ 
-        One pass (O(n)) solution using dictionary
-
-        if len(nums) <2: # handling some end cases quickly
-            return
-        if nums[0]+nums[1] == target:   return[0,1] # just checking if 
-                                                    # we get lucky with first two numbers
-        else:
-            a = {} #empty dictionary
-            for i in range(len(nums)):
-                if nums[i] in a:    #if the current number found in dictionary
-                    return([i,a[nums[i]]]) #return the poisition from list and dict
-                else: # or 
-                    a[target - nums[i]] = i # dictionary key with target - current value
-                                            # and value as the poisition
-                    
-        """
-        # same as above but without the fancy checks
-        a = {}
-        for i in range(len(nums)):
-            if nums[i] in a:
-                return([i,a[nums[i]]])
-            else:
-                a[target - nums[i]] = i
+class Solution:
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        # probably the most common question and the easiest to start with
+        # I know of two solutions: 
+            # First using dictionary (one pass and two pass)
+            # The other using binary search (log(n))
+        
+        """ 
+        One pass (O(n)) solution using dictionary
+
+        if len(nums) <2: # handling some end cases quickly
+            return
+        if nums[0]+nums[1] == target:   return[0,1] # just checking if 
+                                                    # we get lucky with first two numbers
+        else:
+            a = {} #empty dictionary
+            for i in range(len(nums)):
+                if nums[i] in a:    #if the current number found in dictionary
+                    return([i,a[nums[i]]]) #return the poisition from list and dict
+                else: # or 
+                    a[target - nums[i]] = i # dictionary key with target - current value
+                                            # and value as the poisition
+                    
+        """
+        # same as above but without the fancy checks
+        a = {}
+        for i in range(len(nums)):
+            if nums[i] in a:
+                return([i,a[nums[i]]])
+            else:
+                a[target - nums[i]] = i
         
