Neetcode-150 on avni.sh

Reorder Linked Lists

Thu, 15 Feb 2024 00:00:00 +0000

Problem Statement

We have to implement the reorderList function that takes the head node of a linked list as input and reorders its nodes in the format specified below.

Given an input list like the following:

$$Node_0 \rightarrow Node_1 \rightarrow Node_2 \rightarrow \dots \rightarrow Node_{(n-2)} \rightarrow Node_{(n-1)} \rightarrow Node_n$$

the reorderList function should reorder its nodes as:

$$Node_0 \rightarrow Node_n \rightarrow Node_1 \rightarrow Node_{(n-1)} \rightarrow Node_2 \rightarrow Node_{(n-2)} \rightarrow \dots$$

Brute Force Solution

To solve this problem we use two iterators: one starting from the head of the input list and another starting from the head of the reversed input list.

We pick values alternatively from both iterators and create a new linked list. The loop will continue until the length of the length of the new linked list is equal to the length of the input list. The nodes in the new linked list will be ordered as specified in the problem statement.

Psuedo-code for the Brute Force Solution

reversed_linked_list = reverseList(linked_list)
forward_iter = linked_list.head
reverse_iter = reversed_linked_list.head
reorderedLinkedList = LinkedList()

while(length(reorderedLinkedList)!=length(linked_list)){
  reorderedLinkedList.insert(forward_iter)
  if(length(reorderedLinkedList)==length(linked_list))
    break

  reorderedLinkedList.insert(reverse_iter)
  if(length(reorderedLinkedList)==length(linked_list))
    break

  forward_iter=forward_iter.next
  reversed_linked_list=reverse_iter.next
}

return reorderedLinkedList

Time Complexity Analysis

Best Case Scenario

With this brute-force solution, we have to iterate over the complete linked list, even in the best-case scenario. The time complexity of the brute-force solution will be $O(n)$ (for iterating over the reorderedList) times $O(n)$ (for calculating the current length of reorderedList) which will result in the total time complexity of $O(n^2)$.

Worst Case Scenario

The time complexity of the worst-case scenario will also be $O(n^2)$.

Space Complexity Analysis

The brute-force solution is using additional $O(2n)$ memory space to store the reversed and reordered linked list.

Code for Brute Force Solution

package main

import "fmt"

type ListNode struct {
    Val int
    Next *ListNode
}

func Display(ln *ListNode){
    temp := ln
    for(temp!=nil){
        fmt.Printf("%d->", temp.Val)
        temp=temp.Next
    }
    fmt.Println()
}

func Length(ln *ListNode)(int){

    // Since this function iterates the complete linked list 
    // the time complexity of this function is O(n)
    // where n is the length of the linked list
    temp := ln
    length := 0
    for(temp!=nil){
        length += 1
        temp=temp.Next
    }
    return length
}

func insertAtFront(ln *ListNode, value int)(*ListNode){

    // Time complexity of inserting a value at the head of the 
    // linked list is O(1)
    newNode := &(ListNode{Val: value})
    newNode.Next = ln
    return newNode
}

func insertAtEnd(ln *ListNode, value int)(*ListNode){

    // Time complexity of inserting a value at the end of the 
    // linked list is O(n)
    if(ln==nil){
        ln = &(ListNode{Val: value})
    } else {
        temp := ln
        for(temp.Next!=nil){
            temp = temp.Next
        }
        temp.Next = &(ListNode{Val: value})
    }
    return ln
}

func reverseList(ln *ListNode)(*ListNode){

    // Time complexity of reversing a linked list is O(n)
    // where n is the length of the linked list
    var reversedList *ListNode
    temp := ln
    for(temp!=nil){
        reversedList = insertAtFront(reversedList, temp.Val)
        temp=temp.Next
    }
    return reversedList
}

func reorderList(head *ListNode){
    forwardIter := head
    reverseIter := reverseList(head)
    inputListLength := Length(head)
    var reorderedList *ListNode
    
    // The following loop will be executed n times
    // where n is the length of the linked list
    for(Length(reorderedList)!=inputListLength){

        // Inserting a value at the end of a linked list will take O(n) time
        reorderedList = insertAtEnd(reorderedList, forwardIter.Val)

        // Validating the length of a linked list will take O(n) time as well
        if(Length(reorderedList)==inputListLength){
            break
        }
        
        // Time Complexity: O(n)
        reorderedList = insertAtEnd(reorderedList, reverseIter.Val)

        // Time Complexity: O(n)
        if(Length(reorderedList)==inputListLength){
            break
        }
        
        forwardIter = forwardIter.Next
        reverseIter = reverseIter.Next
    }
    
    // Copying the values of reorderedList to the input linked list
    for(head!=nil){
        head.Val = reorderedList.Val
        head=head.Next
        reorderedList=reorderedList.Next
    }
}

func main(){
    var ln *ListNode
    ln = insertAtEnd(ln, 1)
    ln = insertAtEnd(ln, 2)
    ln = insertAtEnd(ln, 3)
    ln = insertAtEnd(ln, 4)
    ln = insertAtEnd(ln, 5)
    fmt.Println("Input Linked List:")
    Display(ln)

    reorderList(ln)
    fmt.Println("Reordered Linked List:")
    Display(ln)
}

// Output
// Input Linked List:
// 1->2->3->4->5->
// Reordered Linked List:
// 1->5->2->4->3->

Optimized Solution

To solve this problem in linear time while also reducing the space complexity (by performing operations in-place) we have to switch to the Fast-Slow Pointer Approach.

We have to break the input linked list from the middle (or the middle.Next node in the case of an odd number of nodes). Then we will insert the nodes from the second half of the linked list in between the nodes of the first half. However, the second half of the linked list has to be reversed to achieve the reordering format specified in the problem statement.

First, we will iterate over the input linked list using the fast and slow pointers.

At the end of the iteration, the fast pointer will be at the end of the linked list and the slow pointer will be at the middle node.

Then we will break the input linked list into two halves from the slow.Next node.

Since the reordering form requires the last node to be placed in between the first and second node of the list we have to reverse the second half of the input linked list.

Finally, we will iterate over the first half of the input linked list while also inserting the nodes from the second half (reversed) in between.

Psuedo code for the Optimized Solution

fast = linked_list.head
slow = linked_list.head
while(fast.next!=nil or fast!=nil){
  fast = fast.next.next
  slow = slow.next
}

temp = slow.next
slow.next = nil
slow = temp

reversed_half_list = reverse(slow)

temp = linked_list.head
reverse_temp = reversed_half_list.head
while(temp!=nil){
  temp2 = temp.next
  temp.next = reverse_temp
  reverse_temp.next = temp2
  temp = temp2
}
return linked_list.head

Time Complexity Analysis

Best Case Scenario

The time complexity of iterating over the input linked list using fast and slow pointers will be $O(n/2)$ (where $n$ is the size of the linked list) because the fast pointer will skip over every other node.

Reversing the second half of the input linked list will also take $O(n/2)$ time.

Since we are iterating over only the first half of the linked list in the last loop its time complexity will also be $O(n/2)$.

So the total time complexity of the optimized solution in the best-case scenario is $O(3n/2)$ which could be generalized to $O(n)$.

Worst Case Scenario

All the steps in the optimized solution will be executed regardless of the characteristics of the input linked list. So the time complexity for the worst-case scenario will also be $O(n)$.

Space Complexity Analysis

Since we are performing operations in place on the input linked list, no additional memory space is required by the optimized solution. Thus, the total space complexity of the optimized solution is $O(1)$.

Code for Optimized Solution

package main

import "fmt"

type ListNode struct {
    Val int
    Next *ListNode
}

func Display(ln *ListNode){
    temp := ln
    for(temp!=nil){
        fmt.Printf("%d->", temp.Val)
        temp = temp.Next
    }
    fmt.Println()
}

func insertAtFront(ln *ListNode, value int)(*ListNode){
    newNode := &(ListNode{Val: value})
    newNode.Next = ln
    return newNode
}

func insertAtEnd(ln *ListNode, value int)(*ListNode){
    if(ln==nil){
        ln = &(ListNode{Val: value})
    } else {
        temp := ln
        for(temp.Next!=nil){
            temp=temp.Next
        }
        temp.Next = &(ListNode{Val: value})
    }
    return ln
}

func reverseList(ln *ListNode)(*ListNode){
    var reverseList *ListNode
    temp := ln
    for(temp!=nil){
        reverseList = insertAtFront(reverseList, temp.Val)
        temp=temp.Next
    }
    return reverseList
}
    
func reorderList(head *ListNode){

    // Iterating over the input linked list
    // using the fast and slow pointer
    // Time Complexity: O(n/2) since the fast pointer 
    // will skip over every other node
    fast := head
    slow := head
    for(fast.Next!=nil){
        if(fast.Next.Next!=nil){

            // When the fast pointer finishes iteration 
            // the slow pointer will be at the middle node
            fast = fast.Next.Next
            slow = slow.Next
        } else {
            break
        }
    }
  
    // Breaking the input linked list 
    // after the middle node
    temp := slow.Next
    slow.Next = nil
    slow = temp

    // Reversing the 2nd half of the linked list 
    // Time Complexity: O(n/2), where n is the size 
    // of the input linked list
    reversedSecond := reverseList(slow)

    // Iterating over the 1st half of the linked list 
    // and inserting nodes from the reversed 2nd half
    // Time Complexity: O(n/2)
    temp = head
    for(reversedSecond!=nil){

        // Storing next values of temp and reversedSecond 
        // in temporary variables
        temp2 := temp.Next
        tempReversedSlow := reversedSecond.Next
  
        // Reassigning Next nodes of temp and reversedSecond
        temp.Next = reversedSecond
        reversedSecond.Next = temp2
   
        temp = temp2
        reversedSecond = tempReversedSlow
    }
}

func main(){
    var ln *ListNode
    ln = insertAtEnd(ln, 1)
    ln = insertAtEnd(ln, 2)
    ln = insertAtEnd(ln, 3)
    ln = insertAtEnd(ln, 4)
    ln = insertAtEnd(ln, 5)
    fmt.Println("Input Linked List:")
    Display(ln)

    reorderList(ln)
    fmt.Println("Reordered Linked List:")
    Display(ln)
}

// Output
// Input Linked List:
// 1->2->3->4->5->
// Reordered Linked List:
// 1->5->2->4->3->

Resources

143. Reorder List
Linkedin Interview Question - Reorder List - Leetcode 143 - Python

Merge Two Sorted Linked Lists

Mon, 29 Jan 2024 00:00:00 +0000

Problem Statement

We have to implement the mergeTwoLists function that takes the head nodes of two sorted linked lists as input and returns the head node of the merged linked list as the output.

Optimal Solution

To merge both linked lists we can use the two-pointer approach by maintaining an iterator on both linked lists and comparing their values. The smaller value will be selected and inserted at the end of a new list. The result would be a merged sorted linked list.

If all the values from any one of the linked lists are added then the other linked list will be joined at the end of the merged linked list.

Psuedo-code for the Optimal Solution

if(linked_list2==nil){
  return linked_list1
} else if(linked_list1==nil){
  return linked_list2
}

temp1 = linked_list1.head
temp2 = linked_list2.head
mergedLinkedList = LinkedList()
while(temp1!=nil and temp2!=nil){
 if (temp1.value < temp2.value){
  mergedLinkedList.insertAtEnd(temp1.value)  
  temp1=temp1.next
 } else {
  mergedLinkedList.insertAtEnd(temp2.value) 
  temp2=temp2.next
 } 
}

if(temp1!=nil){
  mergedLinkedList.Add(temp1)
} else if(temp2!=nil){
  mergedLinkedList.Add(temp2)
}

return mergedLinkedList

Time Complexity Analysis

Best Case Scenario

For the best case input i.e. either the first or second linked list is empty, the time complexity of the solution is $O(1)$ because we are returning the non-empty linked list as the result.

Worst Case Scenario

In the worst-case scenario, we have to iterate over both the linked lists completely. But since we are iterating them together using two pointers the time complexity will be determined by the length of the larger linked list.

So the total time complexity of the solution in the worst-case scenario will be $O(n)$ where $n$ is the size of the larger linked list.

Space Complexity Analysis

The merged linked list will contain all the elements from both input lists (with repetition). If the length of both linked lists is $m$ and $n$, the additional memory space required by the solution will be $O(m+n)$.

Code for the Optimal Solution

package main

import "fmt"

type ListNode struct {
    Val int
    Next *ListNode
}

func Display(ln *ListNode){
    temp := ln
    for(temp!=nil){
        fmt.Printf("%d->", temp.Val)
        temp=temp.Next
    }
    fmt.Println()
}

func InsertAtEnd(list *ListNode, value int)(*ListNode){
    if list==nil{
        list = &(ListNode{Val:value})
    } else {
        temp := list
        for(temp.Next!=nil){
            temp=temp.Next
        }
        temp.Next = &(ListNode{Val:value})
    }
    return list
}

func JoinLists(list1 *ListNode, list2 *ListNode)(*ListNode){
    // Joins list1 with list2 by the last node
    temp := list1
    for(temp.Next!=nil){
        temp=temp.Next
    }
    temp.Next = list2
    return list1
}

func mergeTwoLists(list1 *ListNode, list2 *ListNode)(*ListNode){
    // Checking if any of the input lists are empty
    if(list1==nil){
        return list2
    } else if(list2==nil) {
        return list1
    }

    temp1 := list1
    temp2 := list2
    var mergedList *ListNode
    
    // Loop over both linked lists until one of them/both
    // are empty
    for((temp1!=nil)&&(temp2!=nil)){
        
        // If the current value in the first list is smaller
        // then add it to the merged linked list and vice versa
        if(temp1.Val<temp2.Val){
            mergedList = InsertAtEnd(mergedList, temp1.Val)
            temp1=temp1.Next
        } else {
            mergedList = InsertAtEnd(mergedList, temp2.Val)
            temp2=temp2.Next
        }
    }
    
    // If any one of the linked list is not empty
    // add it to the merged linked list
    if(temp1!=nil){
        mergedList = JoinLists(mergedList, temp1)
    } else if(temp2!=nil){
        mergedList = JoinLists(mergedList, temp2)
    }
    return mergedList
}

func main(){
    var ln *ListNode
    ln = InsertAtEnd(ln, 5)
    ln = InsertAtEnd(ln, 7)
    ln = InsertAtEnd(ln, 20)
    ln = InsertAtEnd(ln, 34)
    ln = InsertAtEnd(ln, 42)
    fmt.Println("Input Linked List 1:")
    Display(ln)

    var ln2 *ListNode
    ln2 = InsertAtEnd(ln2, 2)
    ln2 = InsertAtEnd(ln2, 4)
    ln2 = InsertAtEnd(ln2, 6)
    ln2 = InsertAtEnd(ln2, 14)
    ln2 = InsertAtEnd(ln2, 66)
    fmt.Println("Input Linked List 2:")
    Display(ln2)
    
    fmt.Println("Merged Linked List:")
    Display(mergeTwoLists(ln, ln2))
}

// Output
// Input Linked List 1:
// 5->7->20->34->42->
// Input Linked List 2:
// 2->4->6->14->66->
// Merged Linked List:
// 2->4->5->6->7->14->20->34->42->66->

Resources

21. Merge Two Sorted Lists
Merge Two Sorted Lists - Leetcode 21 - Python

Reversing Linked Lists

Fri, 26 Jan 2024 00:00:00 +0000

Problem Statement

We have to implement the reverseList function that takes the head node of a linked list as an input and returns the head node of the reversed linked list in the output.

Brute Force Solution

If we iterate over the input linked list and insert its value at the beginning of a new list the result would be a reversed linked list.

Psuedo-code for the Brute Force Solution

reversedLinkedList = LinkedList()
temp = linked_list.head
while(temp!=nil){
  reversedLinkedList.insertAtStart(temp.value)
  temp = temp.next
}
return reversedLinkedList

Time Complexity Analysis

Best Case Scenario

In the best-case scenario, the time complexity of the brute force solution will be $O(n)$ as it requires a loop over the input linked list.

Worst Case Scenario

The time complexity worst-case scenario for the brute force solution is the same as the best-case scenario i.e. $O(n)$.

Space Complexity Analysis

The brute-force solution assumes that we have enough memory space to store the input linked list and the reversed linked list in the memory at the same time. Thus, the space complexity of the brute force solution will scale linearly ($O(2n)$) to the size of the input data.

Code for Brute Force Solution

package main

import "fmt"

type ListNode struct {
    Val int
    Next *ListNode
}

func Display(ln *ListNode){
    temp := ln
    for(temp!=nil){
        fmt.Printf("%d->", temp.Val)
        temp=temp.Next
    }
    fmt.Println()
}

func insertAtStart(ln *ListNode, value int)(*ListNode){
    tempNode := &(ListNode{Val:value, Next:ln})
    return tempNode
}

func reverseList(ln *ListNode)(*ListNode){

    // Creating a new linked list to store nodes in 
    // the reverse order
    var reversedList *ListNode
    temp := ln
    for(temp!=nil){

        // Inserting values at the start of the reversed
        // linked list
        reversedList = insertAtStart(reversedList, temp.Val)
        temp=temp.Next
    }
    return reversedList
}

func main(){
    ln := &(ListNode{Val:5})
    ln.Next = &(ListNode{Val:2})
    ln.Next.Next = &(ListNode{Val:3})
    ln.Next.Next.Next = &(ListNode{Val:7})
    ln.Next.Next.Next.Next = &(ListNode{Val:4})
    fmt.Println("Input Linked List:")
    Display(ln)
    
    fmt.Println("Reversed Linked List:")
    Display(reverseList(ln))
}

// Output
// Input Linked List:
// 5->2->3->7->4->
// Reversed Linked List:
// 4->7->3->2->5->

Optimized Solution

Since reversing a linked list will require traversal of all the nodes, the time complexity of the solution could not be improved from $O(n)$. But if we could reverse the next node reference in place for each node the space complexity would be reduced to $O(n)$.

We will use the two-pointer approach to maintain references to nodes current and previous. The current pointer will start from the head node and iterate till the nil at the end. Whereas, the previous pointer will be one step behind the current.

At the end of the iteration, the previous pointer will be pointing to the head of the reversed linked list.

Psuedo code for the Optimized Solution

previous = none
current = head
while(current!=none){
  temp = current.next
  current.next = previous
  previous = current
  current = temp
}
return previous

Time Complexity Analysis

Best Case Scenario

We are iterating over the complete linked list so the time complexity is the same as the brute force solution i.e. $O(n)$.

Worst Case Scenario

The time complexity of the optimized solution for the worst-case scenario will also be $O(n)$.

Space Complexity Analysis

Unlike brute-force solution we are performing operations on the input linked list directly so we don’t need additional memory space and the space complexity will be $O(1)$.

Code for Optimized Solution

package main

import "fmt"

type ListNode struct {
    Val int
    Next *ListNode
}

func Display(ln *ListNode){
    temp := ln
    for(temp!=nil){
        fmt.Printf("%d->", temp.Val)
        temp=temp.Next
    }
    fmt.Println()
}

func reverseList(ln *ListNode)(*ListNode){
    var prev *ListNode
    curr := ln
    for(curr!=nil){

        // Storing the location of the node 
        // next to the current pointer
        temp := curr.Next

        // Changing next for the current node to 
        // the node pointed by the previous pointer
        curr.Next = prev

        // Moving the previous pointer one node forward
        prev = curr

        // Resetting current to the next node 
        // in iteration
        curr = temp
    }
    return prev
}

func main(){
    ln := &(ListNode{Val:5})
    ln.Next = &(ListNode{Val:2})
    ln.Next.Next = &(ListNode{Val:3})
    ln.Next.Next.Next = &(ListNode{Val:7})
    ln.Next.Next.Next.Next = &(ListNode{Val:4})
    fmt.Println("Input Linked List:")
    Display(ln)
    
    fmt.Println("Reversed Linked List:")
    Display(reverseList(ln))
}

Resources

206. Reverse Linked List
Reverse Linked List - Iterative AND Recursive - Leetcode 206 - Python

Finding the Longest Consecutive Sequence in an Array

Thu, 09 Nov 2023 00:00:00 +0000

Problem Statement

We have to implement the longestConsecutive function that takes an integer array as input and returns the length of the longest sequence of consecutive integers.

For example, in array [4, 2, 7, 8, 1, 5, 6, 0] we have two sequences of consecutive integers: [0, 1, 2] and [4, 5, 6, 7, 8]. The longest sequence ([4, 5, 6, 7, 8]) has length 5.

Brute Force Solution

It would be easier to find consecutive sequences if the input array is sorted.

Once we have the sorted array we can iterate over it and find the longest sequence.

Psuedo-code for the Brute Force Solution

sortedInputArray = sort(inputArray)

longest_sequence_length = 0
sequence_length = 1
loop index in from 1 to len(sortedInputArray)
  if sortedInputArray[index] - sortedInputArray[index-1]==1:
    sequence_length += 1
  else if sortedInputArray[index]==sortedInputArray[index-1]:
    pass
  else
    sequence_length = 1
	
  longest_sequence_length = max(longest_sequence_length, sequence_length)

Time Complexity Analysis

Best Case Scenario

For the best-case input, the brute-force solution will return the result in $O(n) + O(n \log(n))$ time. Since the time complexity of the best sorting algorithm will be $O(n \log(n))$ and the time complexity of iterating over the array is $O(n)$. We can simplify the total time complexity of the brute-force solution to $O(n \log(n))$.

Worst Case Scenario

In the worst-case scenario, the time complexity of the brute-force solution will be the same i.e. $O(n \log(n))$.

Space Complexity Analysis

We are assuming that the sorting operation is done in place for the elements in the input array. Thus, the space complexity of brute-force solution is constant i.e. $O(1)$.

Code for Brute Force Solution

package main

import (
    "fmt"
    "sort"
    "math"
)

func longestConsecutive(nums []int)(int){
    
    // For an empty input array the length of
    // longest consecutive sequence will be 0
    if len(nums)==0{
        return 0
    }
    
    // The best sorting algorithm will sort in
    // O(nlog(n)) time
    sort.Ints(nums)
    
    // This variable will contain the length
    // of longest consecutive sequence
    longestSequenceLength := 1
    
    // Temporary variable to store the length
    // of the current sequence
    sequenceLength := 1
    
    for index:=1;index<len(nums);index++{
        if ((nums[index]-nums[index-1])==1){
            
            // If the values at index and index-1
            // are consecutive then increment the current
            // sequence length by 1
            sequenceLength+=1
            
        } else if (nums[index]==nums[index-1]){

            // If the values at index and index-1
            // are the same then don't increment the current
            // sequence length
            sequenceLength+=0
            
        } else {
            
            // If the consecutive sequence is broken
            // then reset the current sequence length to 1
            sequenceLength=1
            
        }
        
        // On every iteration check if the length
        // of the current sequence is greater than
        // the value stored in longestSequenceLength
        longestSequenceLength = int(math.Max(float64(sequenceLength), 
                                float64(longestSequenceLength)))
    }
    
    return longestSequenceLength
}

func main(){
    inputArray := []int{100, 4, 200, 1, 3, 2}
    fmt.Println("Length of Longest Consecutive Sequence:", 
                longestConsecutive(inputArray))
                
    inputArray = []int{4, 2, 7, 8, 1, 5, 6, 0}
    fmt.Println("Length of Longest Consecutive Sequence:", 
                longestConsecutive(inputArray))
}

// Output
// Length of Longest Consecutive Sequence: 4
// Length of Longest Consecutive Sequence: 5

Optimized Solution

In terms of time complexity of the brute-force solution sorting is the most expensive operation ($O(n \log(n))$). We can eliminate it if we create a hashmap of elements in the array.

If the value is the first element in a consecutive sequence, it implies that value-1 does not exist in the inputArray. So we can iterate over all the elements in inputArray and identify the first elements of consecutive sequences by searching for inputArray[index]-1 in the hashmap.

Once we have found the first element of consecutive sequence we can keep looking for the next value in the hashmap until the sequence is broken.

During the second iteration we can utilize the hashmap to avoid duplicate values in the input array.

Psuedo code for the Optimized Solution

hashmap = HashMap()
loop value in inputArray
	if not hashmap[value]
		hashmap[value] = 1

longest_sequence = 0
sequence = 0
loop key in hashmap.keys()
	if not hashmap[key-1]
		while hashmap[key+1]
			sequence += 1
			value+=1
	else
		sequence = 1
	longest_sequence = max(sequence, longest_sequence)

Time Complexity Analysis

Best Case Scenario

The loop executed to fill the hashmap has a fixed time complexity of $O(n)$.

If the input for the optimized solution contains only the sequences of length 1 then the nested while loop will not be executed. Thus, the total time complexity of the optimized solution in the best-case scenario will be $O(n) + O(n)$ or simply $O(n)$.

Worst Case Scenario

The check for hashmap[value-1] ensures that we are only looking for consecutive numbers upon encountering the first value. Thus, the total complexity of the worst-case scenario is also $O(n)$.

Space Complexity Analysis

The space complexity of the optimized solution is worse than the brute-force solution because it takes extra $O(n)$ space to store the hashmap.

Code for Optimized Solution

package main

import (
    "fmt"
)

func longestConsecutive(nums []int)(int){
    
    // Return 0 for the empty nums array
    if len(nums)==0{
        return 0
    }
    
    // Create a hashmap of all values in the nums array
    hashmap := make(map[int]int)
    for index:=0;index<len(nums);index++{
        _, key_exists := hashmap[nums[index]]
        if !key_exists{
            hashmap[nums[index]] = 1
        }
    }
    
    maxSeqLen := 1
    for value, _ := range hashmap {
        seqLen := 1

        // If value-1 does not exist in the hashmap
        // it is the start of a sequence
        _, found := hashmap[value-1]

        if !found {
            for {

                // Increment the value and sequence length
                // until we can't find value+1 in the hashmap
                value++
                _, found = hashmap[value]
                if found {
                    seqLen++
                } else {
                    break
                }

            }
        }

        // Reset the value of longestSequence to the maximum
        // of current sequence and the current value of 
        // the longestSequence
        if seqLen > maxSeqLen {
            maxSeqLen = seqLen
        }
    }
    
    return maxSeqLen
}

func main(){
    inputArray := []int{100, 4, 200, 1, 3, 2}
    fmt.Println("Length of Longest Consecutive Sequence:", 
                longestConsecutive(inputArray))
                
    inputArray = []int{4, 2, 7, 8, 1, 5, 6, 0}
    fmt.Println("Length of Longest Consecutive Sequence:", 
                longestConsecutive(inputArray))
}

// Output
// Length of Longest Consecutive Sequence: 4
// Length of Longest Consecutive Sequence: 5

Resources

128. Longest Consecutive Sequence
Leetcode 128 - LONGEST CONSECUTIVE SEQUENCE

Encoding and Decoding Functions for Strings

Mon, 06 Nov 2023 00:00:00 +0000

Problem Statement

We have to implement an encode function that takes a list of string values as input and returns a single encoded string that could be transmitted over a network. On the other side of the network, the decode function will take the encoded string as input and return the original list of string values as output.

A delimiter could be used to differentiate between words. For example, ["Hello", "World"] could be encoded with comma delimiter (,) to "Hello,World".

Brute Force Solution

In the brute-force approach to solving this problem, we can execute a loop over the input list appending each string with some special character as a delimiter.

If the special character is a part of the string itself (for example "Hello,") then we can add an escape character before it, such that it is easier to differentiate from the delimiter during decoding.

Psuedo-code for the Brute Force Solution

func encode(array)
  delimiter = ","
  encodedString = ""
	
  loop index on array
    string = array[index]
    new_string = ""
		
    loop index2 on string

      if string[index2] is delimiter or "\"
        new_string.append("\")

      new_string.append(string[index2])

    if encodedString is not empty
      encodedString.append(delimiter)
			
    encodedString.append(new_string)
	
  return encodedString

func decode(encodedString)
  delimiter=","
  decodedList = []
  string = ""
	
  loop index on encodedString

    if encodedString[index] is "\"
      string.append(encodedString[index+1])
      index++

    else if encodedString[index] is delimiter
      decodedList.append(string)
      string = ""

    else
      string.append(encodedString[index])

  decodedList.append(string)

  return decodedList

Time Complexity Analysis

Best Case Scenario

The best-case input for the brute force solution would be a string full of delimiters since the decoding process will finish earlier (the index is incremented by 2 while encountering the escape character \).

The time complexity of encoding and decoding in the best-case scenario would be $O(k \times n)$ where $k$ is the average size of the string and $n$ is the size of the input array.

Worst Case Scenario

For the worst-case time complexity of the brute-force solution, the input should not contain the delimiter or escape characters. The time complexity of encoding and decoding would still be $O(k \times n)$.

Space Complexity Analysis

The additional space required to store the encodedString and decodedList will be $O(kn)$.

Code for the Brute Force Solution

package main

import "fmt"

func encode(inputArray []string)(string){
    delimiter := ","
    encodedString := ""

    for index:=0;index<len(inputArray);index++{
        str := string(inputArray[index])
        updatedStr := ""
        
        for index2:=0;index2<len(str);index2++{
            char := string(str[index2])

            // If the delimiter or "\" is within the string
            // add an extra escape character (\))
            if char==delimiter || char=="\\"{
                updatedStr += "\\"
            }

            updatedStr += char
        }
        
        if len(encodedString)!=0{
            encodedString += delimiter
        }
        encodedString += updatedStr
    }
    
    return encodedString
}

func decode(encodedString string)([]string){
    delimiter := ","
    decodedList := []string{}
    str := ""

    for index:=0;index<len(encodedString);index++{
        char := string(encodedString[index])
        if char == "\\"{

            // If we encounter an escape character in the encoded string
            // Add the next character to the string
            // and increment the index by 1
            str += string(encodedString[index+1])
            index += 1

        } else if char==delimiter{

            // If we encounter the delimiter
            // Add the current string to decodedList
            // and reset its values
            decodedList = append(decodedList, str)
            str = ""

        } else {

            // Add the string to decodedList
            str += char

        }
    }

    decodedList = append(decodedList, str)
    
    return decodedList
}

func main(){
    inputArray := []string{"Hello", "World"}
    encodedString := encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))

    inputArray = []string{"Hel,lo", "World"}
    encodedString = encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))
    
    inputArray = []string{"Hel\\,\\lo", "World"}
    encodedString = encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))
}

// Output
// Input Array [Hello World]
// Encoded String: Hello,World
// Decoded String: [Hello World]
// Input Array [Hel,lo World]
// Encoded String: Hel\,lo,World
// Decoded String: [Hel,lo World]
// Input Array [Hel\,\lo World]
// Encoded String: Hel\\\,\\lo,World
// Decoded String: [Hel\,\lo World]

Optimized Solution

We can improve the time complexity of the brute-force solution if we can somehow omit the loop over each string.

If the length of the string could be used as a delimiter then we can avoid iteration over individual strings because the length function len(string) has $O(1)$ time complexity. But, this presents two more challenges

if the length of a string is greater than 9 (double digits)
if the string contains numbers, they could be confused with the length of the strings

To improve on this we can use a special character with the length of the string as delimiters, for example, ["Hello", "World"] could be encoded to 5;Hello5;World.

Psuedo code for the Optimized Solution

func encode(array)
  delimiter = ","
  encodedString = ""
  loop each element in array
    encodedString.append(len(element), delimiter, element)

  return encodedString

func decode(encodedString)
  delimiter = ","
  decodedList = []

  index = 0
  while index    index2 = index
    while encodedString[index2] is not delimiter
      index2++

    stringLen = toInt(encodedString[index:index2])

    string_start = index2+1
    string_end = index2+stringLen+1
    string = encodedString[string_start:string_end]
    decodedList.append(string)

    index += string_end

  return decodedList

Time Complexity Analysis

Best Case Scenario

The best-case input for the optimized solution will contain strings with length < 9.

The time complexity of the encoding loop will be $O(n)$ because it will iterate over all the elements in the array.

For the decoding loop, the time complexity appears to be $O(kn)$ but we are incrementing the index by the length of string value ($k$) on every iteration. Thus, the time complexity of decoding is also $O({kn \over k}) = O(n)$.

Worst Case Scenario

The worst-case time complexity of encoding is the same as the best-case i.e. $O(n)$.

The time complexity of the decoding function will depend on the number of digits (in the length of the largest string). For example: If the length of the largest individual string is 199990 then the time complexity of decoding the string will be $O(6 \times n)$ (because 199990 has 6 digits).

Space Complexity Analysis

The space complexity of the optimized solution will be the same as the brute force solution ($O(kn)$) as no additional data structures are used.

Code for the Optimized Solution

package main

import (
    "fmt"
    "strconv"
)

func encode(inputArray []string)(string){
    encodedString := ""
    for index:=0;index<len(inputArray);index++{
        
        // For each string append
        // the string length
        encodedString += strconv.Itoa(len(inputArray[index]))

        // "#" delimiter
        encodedString += "#"

        // the string itself
        encodedString += inputArray[index]
    }
    return encodedString
}

func decode(encodedString string)([]string){
    decodedList := []string{}
    index := 0
    for ;index<len(encodedString);{
        index2:=index
        for ;string(encodedString[index2])!="#";{
            // Exit loop upon encountering the delimiter
            index2+=1
        }

        // The length of individual string would be parsed
        lenString, _ := strconv.Atoi(encodedString[index:index2])

        // Extract the string from the encodedString
        str := string(encodedString[index2+1:index2+lenString+1])

        // Append the string to decodedList 
        decodedList = append(decodedList, str)

        // Increment index, moving it to the next string length
        index += index2+lenString+1
    }
    
    return decodedList
}

func main(){
    inputArray := []string{"Hello", "World"}
    encodedString := encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))

    inputArray = []string{"Hel,lo", "World"}
    encodedString = encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))
    
    inputArray = []string{"Hel\\,\\lo", "World"}
    encodedString = encode(inputArray)
    fmt.Println("Input Array", inputArray)
    fmt.Println("Encoded String:", encodedString)
    fmt.Println("Decoded String:", decode(encodedString))
}

// Output
// Input Array [Hello World]
// Encoded String: 5#Hello5#World
// Decoded String: [Hello World]
// Input Array [Hel,lo World]
// Encoded String: 6#Hel,lo5#World
// Decoded String: [Hel,lo World]
// Input Array [Hel\,\lo World]
// Encoded String: 8#Hel\,\lo5#World
// Decoded String: [Hel\,\lo World]

Resources

659 · Encode and Decode Strings
Encode and Decode Strings - Leetcode 271 - Python

Checking the Validity of a Sudoku Grid

Thu, 02 Nov 2023 00:00:00 +0000

Problem Statement

We have to implement an isValidSudoku function that takes a 9x9 matrix (representing a Sudoku grid) as input and returns true if the grid is valid and false otherwise.

Sudoku Grid

A Sudoku grid is valid if

Every row contains digits from 1 to 9 without repetition.

Rows in a Sudoku Grid

Every column contains digits from 1 to 9 without repetition.

Columns in a Sudoku Grid

Every 3x3 sub-matrix contains digits from 1 to 9 without repetition.

Sub-Matrices in a Sudoku Grid

The input Sudoku table could be incomplete where “.” will represent an empty cell.

Optimal Solution

The time complexity of validating a single row or column for repetition using a hashmap (like in containsDuplicate) will be $O(9)$. Repeating this process for every row and column in the input matrix will result in total time complexity of $9 \times O(9) + 9 \times O(9)$.

To validate all 3x3 sub-matrices we have to iterate over every 3rd row and column of the Sudoku grid. On each iteration, we will start from the top-left corner of the 3x3 grid and reach the bottom-right corner using nested loops. The total time complexity of validating each 3x3 submatrix will be $9 \times O(3) \times O(3)$.

Since the total time complexity of this solution will be constant for all inputs (because the Sudoku grid has a constant size of 9x9) this is the optimal solution.

Psuedo code for the Optimal Solution

loop row_index from 0 to 9
  row_hashmap = Hashmap()
  sudoku_row = sudoku_grid[row_index]
  loop column_index from 0 to 9
    if row_hashmap[sudoku_row[column_index]]
      return false
    else
      row_hashmap[sudoku_row[column_index]] = 1

loop column_index from 0 to 9
  column_hashmap = Hashmap()
  loop row_index from 0 to 9
    value = sudoku_grid[row_index][column_index]
    if column_hashmap[value]
      return false
    else 
      column_hashmap[value] = 1

loop row_index from 0 to 6 with step 3
  loop column_index from 0 to 6 with step 3
    sub_matrix_hashmap = Hashmap()
    loop sm_row_index from 0 to 2
      loop sm_column_index from 0 to 2
        r_value = row_index+sm_row_index
        c_value = column_index+sm_column_index
        if sub_matrix_hashmap[r_value][c_value]
          return false
        else
          sub_matrix_hashmap[r_value][c_value] = 1

Time Complexity Analysis

Best Case Scenario

The best-case input for the optimal solution will be a completed Sudoku grid. The time taken to return the result will be $9 \times O(9) + 9 \times O(9) + O(81)$ which could be simplified to $O(1)$.

Worst Case Scenario

In the worst-case scenario, the input will be an invalid Sudoku grid. The time taken to produce the result will be the same as the best-case scenario i.e. O(1).

Space Complexity Analysis

The space complexity for the optimal solution will be the sum of memory space required by the row_hashmap, column_hashmap, and sub_matrix_hashmap i.e. $O(9)+O(9)+O(9)$ which could be simplified to $O(1)$.

Code for the Optimal Solution

First, we will implement the validCellValue function to check if the value in a cell is within 1 to 9.

func validCellValue(inputValue byte)(bool){
    // Converting byte value to integer
    // to validate if inputValue lies between 1-len(board)
    
    intInputValue, _ := strconv.Atoi(string(inputValue))
    if ((intInputValue<10) && (intInputValue>0)){
        return true
    }
    return false
}

To validate each row we can create a function called checkRowValidity.

func checkRowValidity(board [][]byte)(bool){
    // Iterating over each row
    // The length of the board could be hard coded to 9
    for rowIndex:=0;rowIndex<len(board);rowIndex++{
        
        // The rowHashMap would be used to check for
        // repeating values in the row
        rowHashMap:=make(map[byte]int)
        
        // Iterating over each column in the row
        for colIndex:=0;colIndex<len(board);colIndex++{
            cellValue := board[rowIndex][colIndex]
            
            // If the value of the cell isn't blank i.e. "."
            if(string(cellValue) != "."){
                
                // If the cell value is within 1-9
                if(validCellValue(cellValue)){
                    
                    // Check for value in rowHashMap
                    _, key_exists := rowHashMap[cellValue]
                    if key_exists{
                        
                        // Exit the function if we
                        // encountered a repeating value
                        // in the current row
                        return false
                    } else {
                        
                        // If value isn't present
                        // then add it the the hashmap
                        rowHashMap[cellValue] = 1
                    }
                } else {
                    
                    // Exit the function if we
                    // encountered a value that's not
                    // within range 1-9
                    return false
                }
            }
        }
    }
    
    return true
}

We can implement a similar function checkColumnValidity to validate columns.

func checkColValidity(board [][]byte)(bool){
    // Iterating over each column
    for colIndex:=0;colIndex<len(board);colIndex++{

        // The colHashMap would be used to check for
        // repeating values in the column
        colHashMap:=make(map[byte]int)

        // Iterating over each row in the column
        for rowIndex:=0;rowIndex<len(board);rowIndex++{
            cellValue := board[rowIndex][colIndex]

            // If the value of the cell isn't blank i.e. "."
            if(string(cellValue)!="."){

                // If the cell value is within 1-9
                if(validCellValue(cellValue)){

                    // Check for value in colHashMap
                    _, key_exists := colHashMap[cellValue]
                    if key_exists{

                        // Exit the function if we
                        // encountered a repeating value
                        // in the current column
                        return false
                    } else {

                        // If value isn't present
                        // then add it the the hashmap
                        colHashMap[cellValue] = 1
                    }
                } else {

                    // Exit the function if we
                    // encountered a value that's not
                    // within range 1-9
                    return false
                }
            }
        }
    }
    
    return true
}

For validating every 3x3 sub-matrix we can implement checkSubMatrixValidity.

func checkSubMatrixValidity(board [][]byte)(bool){
    // Iterating over every 3rd row
    for rowIndex:=0;rowIndex<len(board);rowIndex+=3{
        
        // Iterating over every 3rd column
        for colIndex:=0;colIndex<len(board);colIndex+=3{
            
            // The subMatrixHashMap would be used to check for
            // repeating values in the 3x3 sub-matrix
            subMatrixHashMap := make(map[byte]int)
            
            // Iterate over every row in the sub-matrix
            for i:=0;i<3;i++{

                // Iterate over every column in the sub-matrix
                for j:=0;j<3;j++{
                    cellValue := board[rowIndex+i][colIndex+j]
                    
                    // If the value of the cell isn't blank i.e. "."
                    if(string(cellValue)!="."){

                        // If the cell value is within 1-9
                        if(validCellValue(cellValue)){
                            
                            // Check for value in subMatrixHashMap
                            _, key_exists := subMatrixHashMap[cellValue]
                            if key_exists{

                                // Exit the function if we
                                // encountered a repeating value
                                // in the current sub-matrix
                                return false
                            } else {

                                // If value isn't present
                                // then add it the the hashmap
                                subMatrixHashMap[cellValue] = 1 
                            }
                        } else {

                            // Exit the function if we
                            // encountered a value that's not
                            // within range 1-9
                            return false
                        }
                    }
                }
            }
        }
    }
    
    return true
}

The isvalidSudoku function will validate the board by calling checkRowValidity, checkColumnValidity, and checkSubMatrixValidity and if all three functions return true then the input Sudoku board is valid.

func isValidSudoku(board [][]byte)(bool){
    if(checkRowValidity(board) && 
        checkColValidity(board) && 
        checkSubMatrixValidity(board)){
        return true
    }
    return false
}

Complete Code for the Optimal Solution

package main

import (
    "fmt"
    "strconv"
)

func validCellValue(inputValue byte)(bool){
    // Converting byte value to integer
    // to validate if inputValue lies between 1-len(board)
    
    intInputValue, _ := strconv.Atoi(string(inputValue))
    if ((intInputValue<10) && (intInputValue>0)){
        return true
    }
    return false
}

func checkRowValidity(board [][]byte)(bool){
    // Iterating over each row
    // The length of board the could be hard coded to 9
    for rowIndex:=0;rowIndex<len(board);rowIndex++{
        
        // The rowHashMap would be used to check for
        // repeating values in the row
        rowHashMap:=make(map[byte]int)
        
        // Iterating over each column in the row
        for colIndex:=0;colIndex<len(board);colIndex++{
            cellValue := board[rowIndex][colIndex]
            
            // If the value of the cell isn't blank i.e. "."
            if(string(cellValue) != "."){
                
                // If the cell value is within 1-9
                if(validCellValue(cellValue)){
                    
                    // Check for value in rowHashMap
                    _, key_exists := rowHashMap[cellValue]
                    if key_exists{
                        
                        // Exit the function if we
                        // encountered a repeating value
                        // in the current row
                        return false
                    } else {
                        
                        // If value isn't present
                        // then add it the the hashmap
                        rowHashMap[cellValue] = 1
                    }
                } else {
                    
                    // Exit the function if we
                    // encountered a value that's not
                    // within range 1-9
                    return false
                }
            }
        }
    }
    
    return true
}

func checkColValidity(board [][]byte)(bool){
    // Iterating over each column
    for colIndex:=0;colIndex<len(board);colIndex++{

        // The colHashMap would be used to check for
        // repeating values in the column
        colHashMap:=make(map[byte]int)

        // Iterating over each row in the column
        for rowIndex:=0;rowIndex<len(board);rowIndex++{
            cellValue := board[rowIndex][colIndex]

            // If the value of the cell isn't blank i.e. "."
            if(string(cellValue)!="."){

                // If the cell value is within 1-9
                if(validCellValue(cellValue)){

                    // Check for value in colHashMap
                    _, key_exists := colHashMap[cellValue]
                    if key_exists{

                        // Exit the function if we
                        // encountered a repeating value
                        // in the current column
                        return false
                    } else {

                        // If value isn't present
                        // then add it the the hashmap
                        colHashMap[cellValue] = 1
                    }
                } else {

                    // Exit the function if we
                    // encountered a value that's not
                    // within range 1-9
                    return false
                }
            }
        }
    }
    
    return true
}

func checkSubMatrixValidity(board [][]byte)(bool){
    // Iterating over every 3rd row
    for rowIndex:=0;rowIndex<len(board);rowIndex+=3{
        
        // Iterating over every 3rd column
        for colIndex:=0;colIndex<len(board);colIndex+=3{
            
            // The subMatrixHashMap would be used to check for
            // repeating values in the 3x3 sub-matrix
            subMatrixHashMap := make(map[byte]int)
            
            // Iterate over every row in the sub-matrix
            for i:=0;i<3;i++{

                // Iterate over every column in the sub-matrix
                for j:=0;j<3;j++{
                    cellValue := board[rowIndex+i][colIndex+j]
                    
                    // If the value of the cell isn't blank i.e. "."
                    if(string(cellValue)!="."){

                        // If the cell value is within 1-9
                        if(validCellValue(cellValue)){
                            
                            // Check for value in subMatrixHashMap
                            _, key_exists := subMatrixHashMap[cellValue]
                            if key_exists{

                                // Exit the function if we
                                // encountered a repeating value
                                // in the current sub-matrix
                                return false
                            } else {

                                // If value isn't present
                                // then add it the the hashmap
                                subMatrixHashMap[cellValue] = 1 
                            }
                        } else {

                            // Exit the function if we
                            // encountered a value that's not
                            // within range 1-9
                            return false
                        }
                    }
                }
            }
        }
    }
    
    return true
}

func isValidSudoku(board [][]byte)(bool){
    if(checkRowValidity(board) && 
        checkColValidity(board) && 
        checkSubMatrixValidity(board)){
        return true
    }
    return false
}

func main(){
    // A valid sudoku grid
    // inputBoard := [][]string{
    //     {"5", "3", ".", ".", "7", ".", ".", ".", "."},
    //     {"6", ".", ".", "1", "9", "5", ".", ".", "."},
    //     {".", "9", "8", ".", ".", ".", ".", "6", "."},
    //     {"8", ".", ".", ".", "6", ".", ".", ".", "3"},
    //     {"4", ".", ".", "8", ".", "3", ".", ".", "1"},
    //     {"7", ".", ".", ".", "2", ".", ".", ".", "6"},
    //     {".", "6", ".", ".", ".", ".", "2", "8", "."},
    //     {".", ".", ".", "4", "1", "9", ".", ".", "5"},
    //     {".", ".", ".", ".", "8", ".", ".", "7", "9"},
    // }
    inputBoard := [][]byte{
        {53,51,46,46,55,46,46,46,46}, 
        {54,46,46,49,57,53,46,46,46}, 
        {46,57,56,46,46,46,46,54,46},
        {56,46,46,46,54,46,46,46,51}, 
        {52,46,46,56,46,51,46,46,49}, 
        {55,46,46,46,50,46,46,46,54},
        {46,54,46,46,46,46,50,56,46},
        {46,46,46,52,49,57,46,46,53},
        {46,46,46,46,56,46,46,55,57}}
    fmt.Println("Validitity of sudoku grid:", isValidSudoku(inputBoard))

    // An invalid sudoku grid (Repeating 8s in first column)
    // inputBoard := [][]string{
    //     {"8", "3", ".", ".", "7", ".", ".", ".", "."},
    //     {"6", ".", ".", "1", "9", "5", ".", ".", "."},
    //     {".", "9", "8", ".", ".", ".", ".", "6", "."},
    //     {"8", ".", ".", ".", "6", ".", ".", ".", "3"},
    //     {"4", ".", ".", "8", ".", "3", ".", ".", "1"},
    //     {"7", ".", ".", ".", "2", ".", ".", ".", "6"},
    //     {".", "6", ".", ".", ".", ".", "2", "8", "."},
    //     {".", ".", ".", "4", "1", "9", ".", ".", "5"},
    //     {".", ".", ".", ".", "8", ".", ".", "7", "9"},
    // }
    inputBoard = [][]byte{
        {56,51,46,46,55,46,46,46,46}, 
        {54,46,46,49,57,53,46,46,46}, 
        {46,57,56,46,46,46,46,54,46},
        {56,46,46,46,54,46,46,46,51}, 
        {52,46,46,56,46,51,46,46,49}, 
        {55,46,46,46,50,46,46,46,54},
        {46,54,46,46,46,46,50,56,46},
        {46,46,46,52,49,57,46,46,53},
        {46,46,46,46,56,46,46,55,57}}
    fmt.Println("Validitity of sudoku grid:", isValidSudoku(inputBoard))

    // An invalid sudoku grid (Repeating 8s in the first 3x3 submatrix)
    // inputBoard := [][]string{
    //     {"5", "3", ".", ".", "7", ".", ".", ".", "."},
    //     {"6", "8", ".", "1", "9", "5", ".", ".", "."},
    //     {".", "9", "8", ".", ".", ".", ".", "6", "."},
    //     {"8", ".", ".", ".", "6", ".", ".", ".", "3"},
    //     {"4", ".", ".", "8", ".", "3", ".", ".", "1"},
    //     {"7", ".", ".", ".", "2", ".", ".", ".", "6"},
    //     {".", "6", ".", ".", ".", ".", "2", "8", "."},
    //     {".", ".", ".", "4", "1", "9", ".", ".", "5"},
    //     {".", ".", ".", ".", "8", ".", ".", "7", "9"},
    // }
    inputBoard = [][]byte{
        {53,51,46,46,55,46,46,46,46}, 
        {54,56,46,49,57,53,46,46,46}, 
        {46,57,56,46,46,46,46,54,46},
        {56,46,46,46,54,46,46,46,51}, 
        {52,46,46,56,46,51,46,46,49}, 
        {55,46,46,46,50,46,46,46,54},
        {46,54,46,46,46,46,50,56,46},
        {46,46,46,52,49,57,46,46,53},
        {46,46,46,46,56,46,46,55,57}}
    fmt.Println("Validitity of sudoku grid:", isValidSudoku(inputBoard))
}

// Output
// Validitity of sudoku grid: true
// Validitity of sudoku grid: false
// Validitity of sudoku grid: false

Resources

How to Play Sudoku?
36. Valid Sudoku
Valid Sudoku - Amazon Interview Question - Leetcode 36 - Python

Building a Product Array without the Element Itself

Sat, 28 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement a productExceptSelf function that takes an integer array nums as input and returns another array answer as output. The element answer[i] will be the product of all elements in inputArray except inputArray[i].

The implementation should not contain a division (/) operation because the answer array could also be created by iterating over all elements in inputArray and dividing them from the product of the complete array.

Brute Force Solution

The brute-force solution to this problem could be implemented using nested loops. Where the first loop will select an element from the array and the second loop will be used to calculate the product without the element from the first loop.

Psuedo-code for the Brute Force Solution

answer = []
loop index on nums
	product = 1
	loop index2 on nums
		if index!=index2
			product *= nums[index2]

	answer.append(product)
return answer

Time Complexity Analysis

Best Case Scenario

The brute-force solution will return the answer array in $O(n^2)$ time for the best-case input. Since both the loops will iterate completely over the nums array.

Worst Case Scenario

The worst-case scenario will also take $O(n^2)$ to return the solution.

Space Complexity Analysis

The answer array will require additional $O(n)$ memory.

Code for the Brute Force Solution

package main

import "fmt"

func productExceptSelf(nums []int)([]int){
    answer := []int{}
    for index:=0;index<len(nums);index++{
        product := 1
        for index2:=0;index2<len(nums);index2++{

            // Skip the element selected by the outer loop
            if index!=index2{
                product *= nums[index2]
            }
        }
        answer = append(answer, product)
    }
    return answer
}

func main(){
    nums := []int{1, 2, 3, 4}
    fmt.Println("Product Except Self:", productExceptSelf(nums))

    nums = []int{45, 34, 67, 86, 23}
    fmt.Println("Product Except Self:", productExceptSelf(nums))
}

// Output
// Product Except Self: [24 12 8 6]
// Product Except Self: [4505884 5963670 3026340 2357730 8815860]

Optimized Solution

If we have to improve the time complexity of brute-force solution then we have to think of something other than nested loops.

The “product except self” for an element nums[i] refers to the product of all elements before and after nums[i] i.e. answer[i] = nums[0:i-1] * nums[i+1:]. Thus, we can implement the productExceptSelf function with $O(n)$ time complexity if we calculate two arrays prefix and suffix where

prefix[i] is the product of all elements before nums[i]

suffix[i] is the product of all elements after nums[i]

and multiply them to create the answer array.

Psuedo code for the Optimized Solution

prefix = []
loop index on nums
	prefixProduct = 1
	prefix.append(prefixProduct)
	prefixProduct *= nums[index]

suffix = []
loop index from length(nums)-1 to 0
	suffixProduct = 1
	suffix.append_at_start(suffixProduct)
	suffixProduct *= nums[index]

answer = []
loop index on prefix
	answer.append(prefix[index]*suffix[index])

 return answer

Time Complexity Analysis

Best Case Scenario

The optimized solution will return the answer array in $O(n)$ time (generalized from $O(3n)$) since the time complexity of iterating over all three arrays (prefix, suffix, and answer) is $O(n)$.

Worst Case Scenario

The time complexity of iterating over arrays in worst-case input is the same as in the best-case scenario. Thus, the total time complexity of the function remains the same i.e. $O(n)$.

Space Complexity Analysis

To store the prefix, suffix, and answer array we will need additional $O(3n)$ memory. We can improve the space complexity if we use a single array for storing the products of prefix and suffix and return it as the answer.

Code for the Optimized Solution

package main

import "fmt"

func productExceptSelf(nums []int)([]int){
    prefix := []int{}
    prefixProduct := 1
    for index:=0;index<len(nums);index++{
        prefix = append(prefix, prefixProduct)
        prefixProduct *= nums[index]
    }

    suffix := []int{}
    suffixProduct := 1

    // Loop over the nums array in reverse
    // starting from the last element

    for index:=(len(nums)-1);index>(-1);index--{
        // Append the element at the start
        // rather than at the end
        suffix = append([]int{suffixProduct}, suffix...)
        suffixProduct *= nums[index]
    }

    answer := []int{}
    for index:=0;index<len(prefix);index++{
        // Multiply prefix and suffix elements
        // to create the answer array
        answer = append(answer, prefix[index]*suffix[index])
    }

    return answer
}

func main(){
    nums := []int{4, 2, 3, 7}
    fmt.Println("Product Except Self:", productExceptSelf(nums))

    nums = []int{45, 34, 67, 86, 23}
    fmt.Println("Product Except Self:", productExceptSelf(nums))
}

// Output
// Product Except Self: [42 84 56 24]
// Product Except Self: [4505884 5963670 3026340 2357730 8815860]

Code for the Optimized Solution (Constant Space Complexity)

Assuming the memory space required by the answer array is constant i.e. $O(1)$.

package main

import "fmt"

func productExceptSelf(nums []int)([]int){
    answer := []int{}

    // Fill up the answer array with prefixes
    prefixProduct := 1
    for index:=0;index<len(nums);index++{
        answer = append(answer, prefixProduct)
        prefixProduct *= nums[index]
    }


    // Multiply suffixes with the existing
    // values in the answer array i.e. prefixes
    suffixProduct := 1
    for index:=(len(nums)-1);index>(-1);index--{
        answer[index] *= suffixProduct
        suffixProduct *= nums[index]
    }

    return answer
}

func main(){
    nums := []int{4, 2, 3, 7}
    fmt.Println("Product Except Self:", productExceptSelf(nums))

    nums = []int{45, 34, 67, 86, 23}
    fmt.Println("Product Except Self:", productExceptSelf(nums))
}

// Output
// Product Except Self: [42 84 56 24]
// Product Except Self: [4505884 5963670 3026340 2357730 8815860]

Resources

238. Product of Array Except Self
Product of Array Except Self - Leetcode 238 - Python

Finding Most Frequent Elements in an Array

Thu, 26 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement a topKFrequent function that takes an integer array and a value k as input and returns the k most frequent elements in the input array. For example, topKFrequent({1, 1, 2, 2, 3, 5, 2}, 2) will return the top 2 most frequent elements in the array i.e. {2, 1}.

If multiple elements have the same frequency, then any of them could be returned in the solution as long as its length is k.

Brute Force Solution

First, we have to gather the data for the frequency of array elements inside a hashmap. We have to group elements with the same frequency, so we’ll invert the key and values in the hashmap from element -> count to count -> [elements].

We can also extract a list of frequencies from this hashmap which will be sorted in descending order to extract the top k elements.

Psuedo-code for the Brute Force Solution

counter = HashMap()
loop index on array
  if counter[array[index]]
    counter[array[index]]+=1
  else
    counter[array[index]]=1

reverseCounter = HashMap()
freq = []
loop key, value in counter
  if reverseCounter[value]
    reverseCounter[value].append(key)
  else
    reverseCounter[value] = [key]
  freq.append(value)

sort(freq, descending=True)

topKElements = []
loop index on freq
  value = reverseCounter[freq[index]]
  for fq in value
    topKElements.append(fq)

    if len(topKElements)==k
      return topKElements

Time Complexity Analysis

Best Case Scenario

The first loop over the array has $O(n)$ time complexity, where $n$ is the size of the input array.

Let’s assume that the second loop also has $O(n)$ time complexity (length(counter) == length(reverseCounter)). In the best-case scenario, there will be only one key in reverseCounter i.e. all elements have the same frequency, which decreases the time complexity of this loop to $O(1)$.

The fastest sorting algorithm will sort the freq array in $O(n \log(n))$ time.

The final loop (over freq) will execute k times. On each iteration, it will also loop over the list stored in reverseCounter[freq[index]]. Since the loop will exit as soon as the length of the result array reaches k its time complexity could be generalized to $O(k)$.

Thus, the total time complexity of the best-case scenario for brute force solution will be $O(n) + O(1) + O(n \log(n)) + O(k)$, which could be generalized to $O(n \log n)$.

Worst Case Scenario

In the worst-case scenario, all the elements in the input array will have distinct frequencies. Thus, the length of counter and reverseCounter will be the same resulting in total time complexity $O(n) + O(n) + O(n \log(n)) + O(k)$, which could also be generalized to $O(n \log n)$.

Space Complexity Analysis

The memory space used by counter and reverseCounter will be $O(n)+O(n)$. We are assuming that the freq array is sorted in place so it won’t require additional memory space. Finally, the space complexity of the topKElements array will be $O(n)$ if k=length(nums). Thus, the total space complexity of the brute-force solution could be simplified to $O(n)$.

Code for the Brute Force Solution

package main

import (
    "fmt"
    "sort"
)

func topKElements(nums []int, k int)([]int){

  // counter hashmap for storing frequency data
  // of elements in nums
  // Time Complexity: O(n)
  counter := make(map[int]int)
  for index:=0;index<len(nums);index++{
      _, key_exists := counter[nums[index]]
      if key_exists{
          counter[nums[index]] += 1
      } else {
          counter[nums[index]] = 1
      }
  }

  // freq array for storing different frequencies
  var freq []int

  // reverseCounter maps frequencies to elements of
  // nums
  // Time Complexity: O(n)
  reverseCounter := make(map[int][]int)
  for key, value := range counter{
      _, key_exists := reverseCounter[value]
      if key_exists{
          reverseCounter[value] = append(reverseCounter[value], key)
      } else {
          reverseCounter[value] = []int{key}
      }
      freq = append(freq, value)
  }

  // Sorting freq in descending order
  // Time Complexity: O(nlog(n))
  sort.Sort(sort.Reverse(sort.IntSlice(freq)))

  // Creating topKElements from the top k
  // elements in sorted freq array
  // Time Complexity: O(k)
  var topKElements []int
  for index:=0;index<len(freq);index++{
      value := reverseCounter[freq[index]]
      for index2:=0;index2<len(value);index2++{
          topKElements = append(topKElements, value[index2])
          if len(topKElements)==k{
              return topKElements
          }
      }
  }
  return topKElements
}

func main(){
  nums := []int{1, 1, 1, 2, 2, 3, 3, 4}
  k := 3
  fmt.Println("Top", k, "elements in nums:", topKElements(nums, k))

  nums = []int{1, 2}
  k = 2
  fmt.Println("Top", k, "elements in nums:", topKElements(nums, k))
}

// Output
// Top 3 elements in nums: [1 2 3]
// Top 2 elements in nums: [1 2]

Optimized Solution

The sorting operation on the frequency array has the highest time complexity ($O(n \log(n))$).

The highest frequency an element can achieve in an array is the length of the array (all the elements are the same) and the lowest frequency for an element is 1 (a single element in the array). Thus, instead of sorting frequencies, we can loop over the known range of frequencies and return the top k elements.

Psuedo code for the Optimized Solution

counter = HashMap()
loop index on array
  if counter[array[index]]
    counter[array[index]] += 1
  else
    counter[array[index]] = 1

reverseCounter = HashMap()
loop key, value on counter
  if reverseCounter[value]
    reverseCounter[value].append(key)
  else
    reverseCounter[value] = [key]

topKElements = []
loop index from (len(nums), 1)
  if reverseCounter[index]
    for value in reverseCounter[index]
      topKElements.append(value)

      if len(topKElements) == k
        return topKElements

return topKElements

Time Complexity Analysis

Best Case Scenario

In the best-case scenario (all elements have the same frequency), the time complexity of all loops except the one on reverseCounter will be $O(n)$ which sums up to $O(2n)$ for the complete function (could also be generalized to $O(n)$).

Worst Case Scenario

For the worst-case scenario, where all elements have distinct frequencies, the time complexity of every loop is $O(n)$ resulting in $O(3n)$ (generalized to $O(n)$) time complexity for the complete function.

Space Complexity Analysis

The additional memory required by the optimized solution to store counter, reverseCounter, and topKElements will be $O(n)$.

Code for the Optimized Solution

package main

import "fmt"

func topKElements(nums []int, k int)([]int){
    counter := make(map[int]int)
    for index:=0;index<len(nums);index++{
        _, key_exists := counter[nums[index]]
        if key_exists{
            counter[nums[index]] += 1
        } else {
            counter[nums[index]] = 1
        }
    }

    reverseCounter := make(map[int][]int)
    for key, value := range counter{
        _, key_exists := reverseCounter[value]
        if key_exists{
            reverseCounter[value] = append(reverseCounter[value], key)
        } else {
            reverseCounter[value] = []int{key}
        }
    }

    // Instead of sorting the list of frequencies
    // We can loop over range (len(nums), 1)
    // and check if the value is present in
    // reverseCounter
    var topKElements []int
    for freq:=len(nums);freq>0;freq--{
        value, key_exists := reverseCounter[freq]
        if key_exists{
            for _, val := range value{
                topKElements = append(topKElements, val)
                if len(topKElements) == k{
                    return topKElements
                }
            }
        }

    }

    return topKElements
}

func main(){
    nums := []int{1, 1, 1, 2, 2, 3, 3, 4}
    k := 3
    fmt.Println("Top", k, "elements in nums:", topKElements(nums, k))

    nums = []int{1, 2}
    k = 2
    fmt.Println("Top", k, "elements in nums:", topKElements(nums, k))
}

Resources

347. Top K Frequent Elements
Top K Frequent Elements - Bucket Sort - Leetcode 347 - Python

Group Anagrams in an Array

Sun, 22 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement a groupAnagram function that takes an array of strings as input and returns a new array with anagrams grouped.

The input string array is assumed to be composed entirely of lowercase English characters.

Brute Force Solution

If two strings are anagrams then their sorted order will be the same. Thus, anagrams could be grouped under their sorted order.

The brute-force implementation of groupAnagram uses a hashmap for grouping. In this hashmap the sorted string will be the key and the original strings will be the values (stored in an array). At the end of the function, we can iterate over the hashmap and create an array of grouped anagrams.

Psuedo-code for the Brute Force Solution

hashmap = HashMap()
loop index in stringArray
  stringValue = stringArray[index]
  sortedString = string(sort(stringValue))
  if hashmap[sortedString]
    hashmap[sortedString].append(stringValue)
  else
    hashmap[sortedString] = [stringValue]

returnedList = []
loop key, value in hashmap
  returnedList.append(value)

return returnedList

Time Complexity Analysis

Best Case Scenario

The time taken to sort individual strings is assumed to be $O(k \log(k))$ (the time complexity of the best sorting algorithm) where $k$ is the size of the string. Since we have to perform this operation on every element the sorting operation will be repeated $n$ time, where $n$ is the size of the array, resulting in $O(n \times k \log(k))$ time.

The best-case input will contain just a single set of anagrams i.e. the hashmap will contain just one key. The loop over hashmap values will be executed only once. Thus, the total time complexity of grouping anagrams will be $O(n \times k \log(k))$.

Worst Case Scenario

The worst-case input array will contain zero anagrams and the hashmap will contain a key for each array element i.e. $n$ keys. Thus, the total time complexity of the function in the worst-case scenario will be $O(n + n \times k \log(k))$, which could be simplified to $O(n \times k \log(k))$.

Space Complexity Analysis

The additional space required to store the hashmap and returnedList will be $O(n)+O(n)$ or simply $O(n)$.

Code for the Brute Force Solution

package main

import (
    "fmt"
    "sort"
    "strings"
)

func sortString(inputString string)(string){
    listInputString := strings.Split(inputString, "")
    sort.Strings(listInputString)
    return strings.Join(listInputString, "")
}

func groupAnagrams(strs []string)([][]string){
    hashmap := make(map[string][]string)
    
    // Loop over the strs and sort every string element
    for index:=0;index<len(strs);index++{
        
        // The time complexity of the sorting operation
        // is assumed to be O(nlog(n))
        // where n is the size of the string
        sortedString := sortString(strs[index])
        
        // Group elements by their sorted order 
        _, key_exists := hashmap[sortedString]
        if key_exists{
            hashmap[sortedString] = append(hashmap[sortedString], 
                                           strs[index])
        } else {
            hashmap[sortedString] = []string{strs[index]}
        }
    }
    
    var groupedAnagrams [][]string
    
    // Loop over hashmap and create a grouped anagrams list
    for _, value := range hashmap{
        groupedAnagrams = append(groupedAnagrams, value)
    }
    
    return groupedAnagrams
}

func main(){
    anagramList := []string{"cat", "bat", "tan", "nat"}
    fmt.Println("Grouping anagrams in list:", anagramList)
    fmt.Println(groupAnagrams(anagramList))
}

// Output
// Grouping anagrams in list: [cat bat tan nat]
// [[cat] [bat] [tan nat]]

Optimized Solution

The time complexity of sorting a single string is $O(k \log(k))$. Instead of sorting, we can load the string into a countHashmap (maps characters to their count) and reduce the time complexity to $O(k)$.

The countHashMap will be initialized with lowercase English characters (a-z) mapped to 0 (default count). The load function will iterate over the characters in the input string and increment their count, for example, countHashMap.load("mat") will increment the value of m, a, and t keys to 1.

As we have to use countHashMap as a key to another hashmap, we can simplify its data to a single string of non-zero count characters and their value, for example, baseball => {a:2, b:2, c:0, d:0, e:1, ..., l:2, ..., s:1, ..., z:0} => a2b2e1l2s1

Psuedo code for the Optimized Solution

anagramHashmap = HashMap()
loop index in stringArray
  countHashmap = HashMap[a-z, 0-0]
  countHashmap.load(stringArray[index])

  if anagramHashmap[countHashMap]
    anagramHashmap[countHashMap].append(stringArray[index])
  else
    anagramHashmap[countHashMap] = [stringArray[index]]

returnedList = []
for key, value in anagramHashmap
  returnedList.append(value)

return returnedList

Time Complexity Analysis

Best Case Scenario

The best-case input will contain only one set of anagrams. Thus the total time complexity of the function will be $O(n \times k)$.

Worst Case Scenario

For the worst-case input (none of the strings are anagrams) the loop over anagramHashMap will take $O(n)$ time. Hence, the time complexity of the function will be $O(n \times k)$ (generalized from $O(n + n \times k)$).

Space Complexity Analysis

The size of countHashMap is constant i.e. $O(26)$. After adding the space required by anagramHashMap and returnedList, the total space complexity of the optimized solution will be $O(n)+O(n)+O(26)$, which could be simplified to $O(n)$.

Code for the Optimized Solution

First, we have to implement a generateCountHashMap function that will return a hashmap with keys ranging from a to z mapped to their initial count i.e. 0.

func generateCountHashMap()(map[string]int){
    countHashMap := make(map[string]int)

    // The time complexity of this function will
    // be constant (O(1)) since the loop will 
    // execute only 26 times on every function call
    for r:='a';r<='z';r++{
        countHashMap[string(r)] = 0
    }
    return countHashMap
}

To simplify the presentation of data in countHashMap we have to convert it into an equivalent string using the loadStringValue function.

func loadStringValue(countHashMap map[string]int, 
                     inputString string)(string){

    // Assuming the size of inputString is k
    // the time complexity of executing this loop
    // will be O(k)
    for i:=0;i<len(inputString);i++{
        countHashMap[string(inputString[i])] += 1
    }
    
    var returnString []string

    // This loop has constant time complexity (O(1))
    for r:='a';r<='z';r++{
        // Add non-zero count characters and their value
        // to the returnString
        if countHashMap[string(r)]>0{
            returnString = append(returnString, 
                                  string(r), 
                                  strconv.Itoa(countHashMap[string(r)]))
        }
    }
    
    return strings.Join(returnString, "")
}

Finally, we use generateCountHashMap and loadStringValue to implement the groupAnagrams function.

func groupAnagrams(strs []string)([][]string){
  anagramHashMap := make(map[string][]string)

  for index:=0;index<len(strs);index++{
    stringValue := strs[index]

    // Constant time complexity
    countHashMap := generateCountHashMap()

    // The time complexity of this operation will be
    // O(k) where k is the size of stringValue
    countHashMapStr := loadStringValue(countHashMap, stringValue)

    _, key_exists := anagramHashMap[countHashMapStr]

    // Group elements by countHashMapStr
    if key_exists{
      anagramHashMap[countHashMapStr] = append(
                        anagramHashMap[countHashMapStr], 
                        stringValue)
    } else {
      anagramHashMap[countHashMapStr] = []string{stringValue}
    }
  }
    
  var groupedAnagrams [][]string
  for _, value := range anagramHashMap{
      groupedAnagrams = append(groupedAnagrams, value)
  }
    
  return groupedAnagrams
}

Complete Code

package main

import (
    "fmt"
    "strings"
    "strconv"
)

func generateCountHashMap()(map[string]int){
    countHashMap := make(map[string]int)

    // The time complexity of this function will
    // be constant (O(1)) since the loop will 
    // execute only 26 times on every function call
    for r:='a';r<='z';r++{
        countHashMap[string(r)] = 0
    }
    return countHashMap
}

func loadStringValue(countHashMap map[string]int, 
                     inputString string)(string){

    // Assuming the size of inputString is k
    // the time complexity of executing this loop
    // will be O(k)
    for i:=0;i<len(inputString);i++{
        countHashMap[string(inputString[i])] += 1
    }
    
    var returnString []string

    // This loop has constant time complexity (O(1))
    for r:='a';r<='z';r++{
        // Add non-zero count characters and their value
        // to the returnString
        if countHashMap[string(r)]>0{
            returnString = append(returnString, 
                                  string(r), 
                                  strconv.Itoa(countHashMap[string(r)]))
        }
    }
    
    return strings.Join(returnString, "")
}

func groupAnagrams(strs []string)([][]string){
  anagramHashMap := make(map[string][]string)
  
  for index:=0;index<len(strs);index++{
    stringValue := strs[index]

    // Constant time complexity
    countHashMap := generateCountHashMap()

    // The time complexity of this operation will be
    // O(k) where k is the size of stringValue
    countHashMapStr := loadStringValue(countHashMap, stringValue)

    _, key_exists := anagramHashMap[countHashMapStr]

    // Group elements by countHashMapStr
    if key_exists{
      anagramHashMap[countHashMapStr] = append(
                        anagramHashMap[countHashMapStr], 
                        stringValue)
    } else {
      anagramHashMap[countHashMapStr] = []string{stringValue}
    }
  }
    
  var groupedAnagrams [][]string
  for _, value := range anagramHashMap{
      groupedAnagrams = append(groupedAnagrams, value)
  }
    
  return groupedAnagrams
}

func main(){
    anagramList := []string{"cat", "bat", "tan", "nat"}
    fmt.Println("Grouping anagrams in list:", anagramList)
    fmt.Println(groupAnagrams(anagramList))
}

// Output
// Grouping anagrams in list: [cat bat tan nat]
// [[tan nat] [cat] [bat]]

Resources

49. Group Anagrams
Group Anagrams - Categorize Strings by Count - Leetcode 49

Finding Elements in an Array that Sum Up to a Target Value

Sun, 15 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement a twoSums() function that takes an integer array and a target value as inputs. It returns the indexes of two elements in the input array which could be summed up to the target value.

It is assumed that the input array contains only one valid pair of elements that sum up to the target value.

Brute Force Solution

The brute-force solution will find the sum of all element pairs in the array using nested loops.

Psuedo-code for the Brute Force Solution

loop index1 in array
    loop index2 in array
        sum_value = array[index1]+array[index2]
        if index1!=index2 and sum_value==target:
            return index1, index2
return none, none

Time Complexity Analysis

Best Case Scenario

If the sum of the first and second elements in the input array is equal to the target value, that would be the best-case runtime scenario. Since the inner and outer loop will be executed only once the time complexity will be $O(1)$.

Worst Case Scenario

In the worst-case scenario, the input array won’t contain any valid pair of elements. Thus, both loops will be executed completely resulting in $O(n^2)$ time complexity, where $n$ is the size of the input array.

Space Complexity Analysis

There isn’t any additional memory used by the brute-force solution. Thus, the total space complexity will be $O(1)$.

Code for the Brute Force Solution

package main

import "fmt"

func twoSums(nums []int, target int)([]int){
    for i:=0;i<len(nums);i++{
        for j:=0;j<len(nums);j++{
            sumValue := nums[i] + nums[j]
            if i!=j && sumValue==target{
                return []int{i, j}
            } 
        }
    }
    
    return []int{}
}

func main(){
    nums := []int{2, 5, 54, 1, 657, 123}
    target := 125
    indices := twoSums(nums, target)
    if len(indices)==0{
        fmt.Println("No elements in nums that sum up to", target)
    } else {
        fmt.Println("twoSum() for", target, 
        "in nums are", indices)
    }
    
    target = 34
    indices = twoSums(nums, target)
    if len(indices)==0{
        fmt.Println("No elements in nums that sum up to", target)
    } else {
        fmt.Println("twoSum() for", target, 
        "in nums are", indices)
    }
}

// Output
// twoSum() for 125 in nums are [0 5]
// No elements in nums that sum up to 34

Optimized Solution

We can find both elements with a single loop and a hashmap that will store the elements mapped to their index.

The loop will iterate over the elements in the array, if the difference (target - element) is present in the hashmap the loop will exit otherwise the element will be added to the hashmap.

Psuedo-code for the Optimized Solution

hashmap = HashMap()
loop index in array
    difference = target - array[index]
    if difference in hashmap
        return hashmap[difference], index
    else
        hashmap[array[index]] = index
return none, none

Time Complexity Analysis

Best Case Scenario

For the best-case scenario inputs i.e. the first and second elements sum up to the target value, the solution will finish in $O(1)$ time as the loop will always finish after iterating over the first two values.

Worst Case Scenario

In the worst-case scenario, the loop will iterate over all elements to conclude that none of the element pairs sum up to the target value, finishing in $O(n)$ time.

Space Complexity Analysis

The hashmap used to store elements from the input array will take $O(n)$ additional memory space.

Code for the Optimized Solution

package main

import "fmt"

func twoSums(nums []int, target int)([]int){
    hashmap := make(map[int]int)
    
    for index:=0;index<len(nums);index++{
        diff := target-nums[index]
        _, key_exists := hashmap[diff]
        if key_exists{
            // Difference exists in the hashmap
            return []int{hashmap[diff], index}
        } else {
            // Difference does not exist in the hashmap
            // Add the element to hashmap
            hashmap[nums[index]] = index
        }
    }
    
    return []int{}
}

func main(){
    nums := []int{2, 5, 54, 1, 657, 123}
    target := 125
    indices := twoSums(nums, target)
    if len(indices)==0{
        fmt.Println("No elements in nums that sum up to", target)
    } else {
        fmt.Println("twoSum() for", target, 
        "in nums are", indices)
    }
    
    target = 34
    indices = twoSums(nums, target)
    if len(indices)==0{
        fmt.Println("No elements in nums that sum up to", target)
    } else {
        fmt.Println("twoSum() for", target, 
        "in nums are", indices)
    }
}

// Output
// twoSum() for 125 in nums are [0 5]
// No elements in nums that sum up to 34

Resources

1. Two Sum
Two Sum - Leetcode 1 - HashMap - Python

Identify Anagrams

Thu, 12 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement an isAnagram() function that takes two strings as input and returns true if they both are anagrams and false otherwise.

Multiple words could be anagrams of each other if they contain the same characters with the same frequency of occurrence.

For word counter:

trounce is an anagram.
trouncee isn’t an anagram, because the character e appears twice in trouncee.
tounce isn’t an anagram, because the character r is missing.

The inputs for the isAnagram() function are assumed to be composed of lowercase English characters including whitespace (" ").

Brute Force Solution

The first solution that comes to mind for this problem would be sorting both strings (using the ASCII value of characters) and then comparing the sorted strings by characters.

We can preemptively exit the function if both strings are of different lengths as they can’t be anagrams.

Psuedo-code for the Brute Force Solution

if length(string1) != length(string2)
	return false
	
string1 = sort(string1)
string2 = sort(string2)

loop index in string1
	if string1[index] != string2[index]
		return false

return true

Time Complexity Analysis

Best Case Scenario

The best time complexity of a sorting function is $O(n \log(n))$, so the total time complexity of sorting operations is $O(s \log(s)) + O(t \log(t))$ where $s$ and $t$ are the sizes of strings. Since both strings are of the same length (for anagrams) we can generalize time complexity to $O(s \log(s))$.

If the inputs are of different lengths (non-anagrams) then the time complexity of the complete function will be: $O(1)$ as the function will exit preemptively.

Even though we have to compare characters in a loop ($O(s)$) the sorting time will scale relatively slower. Thus, the total time complexity of the best-case scenario will be $O(s \log(s))$.

Worst Case Scenario

The worst-case scenario for a brute force solution will compare all the characters in sorted strings to find that they aren’t anagrams. Its total time complexity will be $2*O(s \log(s)) + O(s)$ but we can generalize it to $O(s \log(s))$.

Space Complexity Analysis

The sorting of input strings is performed in-place. Thus, there is no requirement for additional memory space by the brute-force solution and its space complexity will be $O(1)$.

Code for the Brute Force Solution

package main

import (
  "fmt"
  "sort"
  "strings"
)

func sortString(inputString string)(string){
  // The time complexity of this function
  // is assumed to be O(nlog(n))
  // where n is the size of inputString
  
  str := strings.Split(inputString, "")
  sort.Strings(str)
  return strings.Join(str, "")
}

func isAnagram(string1 string, string2 string)(bool){
  if len(string1) != len(string2){
	  return false
  }
  
  string1 = sortString(string1)
  string2 = sortString(string2)

  // This loop will have O(n) time complexity
  // where n is the size of string1/string2
  for i:=0;i<len(string1);i++{
      if string1[i] != string2[i]{
        return false
      }
  }

  return true
}

func main(){
  string1 := "counter"
  string2 := "trounce"
  fmt.Println(string1, "is an Anagram of", 
              string2, ":", isAnagram(string1, string2))

  string2 = "trouncee"
  fmt.Println(string1, "is an Anagram of",
              string2, ":", isAnagram(string1, string2))

  string2 = "trounc"
  fmt.Println(string1, "is an Anagram of", 
              string2, ":", isAnagram(string1, string2))
}

// Output
// counter is an Anagram of trounce : true
// counter is an Anagram of trouncee : false
// counter is an Anagram of trounc : false

Optimized Solution

In the brute force solution, the most expensive operation in terms of time complexity is sorting.

To improve on this we can create a hashmap that stores the count of characters appearing in the first string, then we can iterate over the second string and reduce the count for each character in the same hashmap or delete the key. If the hashmap is empty after the loop has ended, then the strings are anagrams.

Psuedo code for the Optimized Solution

counter = hashmap()

loop char in string1
    if char in counter
        counter[char] += 1
    else
        counter[char] = 1

loop char in string2
    if char in counter
        if counter[char] == 1
            counter.delete(char)
        else
            counter[char] -= 1
    else
        return false

if counter.empty() == true
	return true
else
	return false

Time Complexity Analysis

Best Case Scenario

In the best-case scenario for an optimized solution both strings will be anagram and the time complexity will be $O(s)$ (generalized from $O(s) + O(s)$).

Worst Case Scenario

The time complexity of the worst-case scenario will be the same as the best-case scenario i.e. $O(s)$ but the input strings won’t be anagrams.

Space Complexity Analysis

The counter hashmap will take additional $O(n)$ memory space.

Code for the Optimized Solution

package main

import "fmt"

func isAnagram(inputString1 string, inputString2 string)(bool){
  if len(inputString1) != len(inputString2){
    return false
  }

  counter := make(map[string]int)

  // Both loops will take O(n) time for completion individually
  // where n is the size of inputString1/inputString2

  for i:=0;i<len(inputString1);i++{
    char := string(inputString1[i])
    _, key_exists := counter[char]
    if key_exists{
      counter[char] += 1
    } else {
      counter[char] = 1
    }
  }

  for j:=0;j<len(inputString2);j++{
    char := string(inputString2[j])
    _, key_exists := counter[char]
    if key_exists{
      if counter[char] == 1{
        delete(counter, char)
      } else{
        counter[char] -= 1
      }
    } else {
      return false
    }
  }
  
  return (len(counter)==0)
}

func main(){
  string1 := "counter"
  string2 := "trounce"
  fmt.Println(string1, "is an Anagram of", 
              string2, ":", isAnagram(string1, string2))

  string2 = "trouncee"
  fmt.Println(string1, "is an Anagram of",
              string2, ":", isAnagram(string1, string2))

  string2 = "trounc"
  fmt.Println(string1, "is an Anagram of", 
              string2, ":", isAnagram(string1, string2))
}

// Output
// counter is an Anagram of trounce : true
// counter is an Anagram of trouncee : false
// counter is an Anagram of trounc : false

Resources

242. Valid Anagram
Valid Anagram - Leetcode 242 - Python

Checking an Array for Duplicate Values

Tue, 10 Oct 2023 00:00:00 +0000

Problem Statement

We have to implement a function containsDuplicate() that takes an integer array as input and returns true if an element occurs more than once and false otherwise.

Brute Force Solution

The simplest solution for this problem would be two nested loops, where the first loop will select an element and the second loop will select another element from the array and compare them. On the first occurrence of a duplicate element, the function will exit while returning true.

Psuedo Code for the Brute Force Solution

loop index1 in array
    loop index2 in array
        if index1!=index2 and array[index1]==array[index2]
            return true
return false

Time Complexity Analysis

Best Case Scenario

The best-case scenario for the brute-force solution would be when the first and second elements are duplicated. In this scenario, the outer and inner loop will execute only once so the time complexity will be $O(1)$.

Worst Case Scenario

If all the elements in the array are unique then the brute-force algorithm will take $O(n^2)$ time for completion, where $n$ is the size of the array.

Space Complexity Analysis

Since the brute-force solution does not use any data structures other than the input array, its space complexity will be $O(1)$.

Code for the Brute Force Solution

package main

import "fmt"

func containsDuplicate(nums []int)(bool){
    for i:=0;i<len(nums);i++{
        for j:=0;j<len(nums);j++{
            // Checking if the element selected by index j
            // is not the same as the outer loop
			
            // If the value of both elements is the same
            // then exit the function with the value true 
            if i!=j && nums[i]==nums[j]{
                return true
            }
        }
    }
    return false
}

func main(){
  inputArray := []int{1, 2, 4, 5, 6, 1}
  fmt.Println("Array:", inputArray,
              "containsDuplicate: ", containsDuplicate(inputArray))

  inputArray = []int{1, 2, 3, 4}
  fmt.Println("Array:", inputArray,
              "containsDuplicate: ", containsDuplicate(inputArray))
}

// Output
// Array: [1 2 4 5 6 1] containsDuplicate:  true
// Array: [1 2 3 4] containsDuplicate:  false

Optimized Solution

Instead of iterating the array for each element selected by the outer loop, we can store all the elements inside a HashMap. If the element is already present in HashMap, then we have encountered a duplicate and we can exit the function with the value true.

Psuedo Code for the Optimized Solution

hashmap = {}
loop value in array
    if hashmap.get(value)
        return true
    else
        hashmap[value] = 1
return false

Time Complexity Analysis

Best Case Scenario

The best case scenario for the optimized solution is the same as the brute-force solution i.e. first and second elements are duplicated resulting in constant ($O(1)$) runtime.

Worst Case Scenario

If the input array contains unique elements, then the optimized solution will iterate over the complete array adding each element to HashMap but the time complexity of completing this would still be $O(n)$ which is much better than brute force solution ($O(n^2)$).

Space Complexity Analysis

The hashmap in the optimized solution will use extra $O(n)$ memory space.

Code for the Optimized Solution

package main

import "fmt"

func containsDuplicate(nums []int)(bool){
    hashmap := make(map[int]int)

    for i:=0;i<len(nums);i++{
        // Check if a value at key exists in the hashmap
        value, key_exists := hashmap[nums[i]]

        if key_exists{
            // If the value exists then exit the function
            return true
        } else {
            // If the value does not exist
            // add it to the hashmap
            hashmap[nums[i]] = value
        }
    }
    return false
}

func main(){
  inputArray := []int{1, 2, 4, 5, 6, 1}
  fmt.Println("Array:", inputArray,
              "containsDuplicate: ", containsDuplicate(inputArray))

  inputArray = []int{1, 2, 3, 4}
  fmt.Println("Array:", inputArray,
              "containsDuplicate: ", containsDuplicate(inputArray))
}

// Output
// Array: [1 2 4 5 6 1] containsDuplicate:  true
// Array: [1 2 3 4] containsDuplicate:  false

Resources

217. Contains Duplicate
Contains Duplicate - Leetcode 217 - Python