Plus One Python

Given a non-empty array of digits representing a non-negative integer, plus one to the integer.
The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit.
You may assume the integer does not contain any leading zero, except the number 0 itself.
Example 1:
Input: [1,2,3]
Output: [1,2,4]
Explanation: The array represents the integer 123.
Example 2:
Input: [4,3,2,1]
Output: [4,3,2,2]
Explanation: The array represents the integer 4321.
class Solution:
    def plusOne(self, digits: List[int]) -> List[int]:
        for i in range(1,len(digits)+1):
            if digits[-i] < 9:
                digits[-i] +=1
                return digits
            digits[-i] = 0
        return [1] + digits
                
        
Time Complexity : O(n)
Space Complexity : O(1) when no 9 digits entirely O(N) if all elements are 9.
By at No comments:
Labels:

Fizz Buzz - Python

Write a program that outputs the string representation of numbers from 1 to n.
But for multiples of three it should output “Fizz” instead of the number and for the multiples of five output “Buzz”. For numbers which are multiples of both three and five output “FizzBuzz”.
Example:
n = 15,

Return:
[
    "1",
    "2",
    "Fizz",
    "4",
    "Buzz",
    "Fizz",
    "7",
    "8",
    "Fizz",
    "Buzz",
    "11",
    "Fizz",
    "13",
    "14",
    "FizzBuzz"
]
Python Solution :
class Solution:
    def fizzBuzz(self, n: int) -> List[str]:
        liststr = []
        if n == 0:
            return 0
        for i in range(1,n+1):
            if i % 15 == 0:
                liststr.append("FizzBuzz")
            elif i % 3 == 0:
                liststr.append('Fizz')
            elif i % 5 == 0: 
                liststr.append('Buzz') 
            else:
                liststr.append(str(i))
        return liststr
        
Time Complexity : O(n)
Space Complexity : O(n)

By at No comments:

Middle of the Linked List Python

Given a non-empty, singly linked list with head node head, return a middle node of linked list.
If there are two middle nodes, return the second middle node.

Example 1:
Input: [1,2,3,4,5]
Output: Node 3 from this list (Serialization: [3,4,5])
The returned node has value 3.  (The judge's serialization of this node is [3,4,5]).
Note that we returned a ListNode object ans, such that:
ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, and ans.next.next.next = NULL.
Example 2:
Input: [1,2,3,4,5,6]
Output: Node 4 from this list (Serialization: [4,5,6])
Since the list has two middle nodes with values 3 and 4, we return the second one.

Note:
  • The number of nodes in the given list will be between 1 and 100.

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

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        pA = head
        if head is None:
            return head
        pA = head
        lA = 0
        while pA:
            lA+=1
            pA =pA.next
        pB = head
        lA = lA//2
        while lA != 0:
            pB = pB.next
            lA -= 1
        return pB if lA % 2 ==0 else pB.next
            
Time Complexity : O(n)
Space Complexity : O(1)


Fast Pointer and Slow Pointer :


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

class Solution:
    def middleNode(self, head: ListNode) -> ListNode:
        slow = fast = head
        while fast and fast.next:
            slow = slow.next
            fast = fast.next.next
        return slow
    
Time Complexity : O(n)
Space Complexity : O(1)           
            
        
        
By at No comments:
Labels:

Backspace String Compare Python

Given two strings S and T, return if they are equal when both are typed into empty text editors. # means a backspace character.
Example 1:
Input: S = "ab#c", T = "ad#c"
Output: true
Explanation: Both S and T become "ac".
Example 2:
Input: S = "ab##", T = "c#d#"
Output: true
Explanation: Both S and T become "".
Example 3:
Input: S = "a##c", T = "#a#c"
Output: true
Explanation: Both S and T become "c".
Example 4:
Input: S = "a#c", T = "b"
Output: false
Explanation: S becomes "c" while T becomes "b".
Note:
  1. 1 <= S.length <= 200
  2. 1 <= T.length <= 200
  3. S and T only contain lowercase letters and '#' characters.
Follow up:
  • Can you solve it in O(N) time and O(1) space?
Using stack :

Time Complexity : O(n) n is larger of both lengths of strings
Space Complexity : O(n)

class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        def build(S):
            stack = []
            for i in S:
                if i == '#' and stack:
                    stack.pop()
                elif i !='#':
                    stack.append(i)
            return ''.join(stack)
        return build(S) == build(T)


 Using Two Pointers:


class Solution:
    def backspaceCompare(self, S: str, T: str) -> bool:
        def F(S):
            skip = 0
            for i in reversed(S):
                if i == '#':
                    skip+=1
                elif skip:
                    skip -=1
                else:
                    yield i
        return all(x == y for x,y in itertools.zip_longest(F(S),F(T)))
    
            
Time Complexity : O(n)
Space Complexity : O(1)
        
By at No comments:

Find Peak Element Python

A peak element is an element that is greater than its neighbors.
Given an input array nums, where nums[i] ≠ nums[i+1], find a peak element and return its index.
The array may contain multiple peaks, in that case return the index to any one of the peaks is fine.
You may imagine that nums[-1] = nums[n] = -∞.
Example 1:
Input: nums = [1,2,3,1]
Output: 2
Explanation: 3 is a peak element and your function should return the index number 2.
Example 2:
Input: nums = [1,2,1,3,5,6,4]
Output: 1 or 5 
Explanation: Your function can return either index number 1 where the peak element is 2, 
             or index number 5 where the peak element is 6.
Note:
Your solution should be in logarithmic complexity.
class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        l = 0
        r = len(nums)-1
        while(l < r):
            mid = l + (r-l) // 2
            if nums[mid] > nums[mid+1]:
                r = mid
            else:
                l = mid+1
        return l
                
        Time Complexity : O(logn)
        Space Complexity : O(1)

By at No comments:

Contains Duplicate Python

Given an array of integers, find if the array contains any duplicates.
Your function should return true if any value appears at least twice in the array, and it should return false if every element is distinct.
Example 1:
Input: [1,2,3,1]
Output: true
Example 2:
Input: [1,2,3,4]
Output: false
Example 3:
Input: [1,1,1,3,3,4,3,2,4,2]
Output: true
class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        uniqueset = set()
        for num in nums:
            if num in uniqueset:
                return True
            else:
                uniqueset.add(num)
        return False
     
Time Complexity : O(n) 
Space Complexity : O(n)
class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        nums.sort()
        for i in range(0,len(nums)-1):
            if nums[i] ==  nums[i+1]:
                return True
        return False
Time Complexity : O(nlogn)
Space Complexity : O(1)
By at No comments:

Counting Elements Python

Given an integer array arr, count element x such that x + 1 is also in arr.
If there're duplicates in arr, count them seperately.

Example 1:
Input: arr = [1,2,3]
Output: 2
Explanation: 1 and 2 are counted cause 2 and 3 are in arr.
Example 2:
Input: arr = [1,1,3,3,5,5,7,7]
Output: 0
Explanation: No numbers are counted, cause there's no 2, 4, 6, or 8 in arr.
Example 3:
Input: arr = [1,3,2,3,5,0]
Output: 3
Explanation: 0, 1 and 2 are counted cause 1, 2 and 3 are in arr.
Example 4:
Input: arr = [1,1,2,2]
Output: 2
Explanation: Two 1s are counted cause 2 is in arr.

Constraints:
  • 1 <= arr.length <= 1000
  • 0 <= arr[i] <= 1000
 Python : Solution 1

class Solution:
    def countElements(self, arr: List[int]) -> int:
        count = 0
        for x in arr:
            if x+1 in arr:
                count+=1
        return count

Time Complexity : O(n*n) because search in entire list
Space Complexity : O(1)

Python : Solution 2

class Solution:
    def countElements(self, arr: List[int]) -> int:
        hash_set = set(arr)
        count = 0
        for x in arr:
            if x+1 in hash_set:
                count+=1
        return count

Time Complexity : O(n) because search in hash set is O(1) 
Space Complexity : O(n)


Python Solution 3

class Solution:
    def countElements(self, arr: List[int]) -> int:
        arr.sort()
        count = 0
        run_length = 1
        for i in range(len(arr)):
            if arr[i-1] != arr[i]:
                if arr[i-1]+1 == arr[i]:
                    count +=run_length
                run_length = 0
            run_length+=1
        return count

Time Complexity : O(nlogn)
Space Complexity : O(n) to O(1)




By at No comments:
Subscribe to: Posts (Atom)

Featured Post

H1B Visa Stamping at US Consulate

  H1B Visa Stamping at US Consulate If you are outside of the US, you need to apply for US Visa at a US Consulate or a US Embassy and get H1...

  • Java quiz 1
    Ques 1 : Which declaration of the main method below would allow a class to be started as a standalone program. (A) public static int main(c...
  • Amazon List of LeetCode Questions
    1.  Two Sum Two Sum Solution 2.  LRU Cache LRU Cache Solution 3.  Number Of Islands 4. Longest Palindromic Substring 5.  Lowest...
  • Amazon Cloud Support Associate Interview Questions
    basics Linux fundamentals like system calls , strace , linux mange memory, shared memory, kernel using, boot process, DNS resolving ( how t...