Data Structures and Algorithms 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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


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

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


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

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118


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->

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108


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->

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

1
2
3
4
5
6
7


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57


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

1
2
3
4
5
6
7
8
9


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


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))
}

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

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

Two-Pointer Approach

Tue, 23 Jan 2024 00:00:00 +0000

To solve problems like Two Sums, Product Except Self, or Contains Duplicate we have to access multiple values at the same time from a sequential data structure (for example, a Linked List or an Array).

The initial instinct while solving these problems is to use nested loops where each layer of the loop will maintain a different iterator on the data structure. But this approach does not scale well with the size of input as a single order of nested loops has $O(n^2)$ worst-case time complexity.

To implement a scalable solution we have to avoid nesting and access multiple values in a single loop by maintaining two iterators. We can use this two-pointer approach to solve the Two Sums problem (assuming the input is sorted).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


startPointer = 0
endPointer = length(array)-1

while(startPointer  sumValue = array
  if(sumValue==target){
    return (startPointer, endPointer)
  }
  else if (sumValue
    // Since the sumValue is small we have
    // to increment the startPointer to a 
    // larger value
    startPointer += 1

  } else {

    // Since the sumValue is larger we have
    // to decrement the endPointer to a 
    // smaller value
    endPointer -= 1

  }
}

return none, none

Unlike the brute-force solution to two sums problem which uses nested loops to return results in quadratic time ($O(n^2)$), this approach will return results in linear time ($O(1)$) while also maintaining a constant space complexity.

Fast-Slow Pointers

The pointers can also iterate the data structure at an independent pace. For example, a fast pointer can iterate over two or more values at a time whereas a slow pointer can iterate over a single value at a time.

Finding the middle node of a Linked List

Assume that we have to find the middle node of a Linked List. The Linked List is a dynamically allocated data structure so its size could not be determined without iterating it once completely. So a loop with $O(n)$ time complexity will be executed on the linked list to determine its length $n$, then a second loop with $O(n/2)$ time complexity will be executed to fetch the middle node. This will result in the total time complexity of $O(n) + O(n/2)$ in the worst-case scenario.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Finding the length of the linked list
linked_list_length = 1
temp = linked_list.head
while(temp.next != nil){
 temp = temp.next 
 linked_list_length += 1
}

// Iterating over the linked list until
// the middle node
middle_node_location = linked_list_length/2 
temp = linked_list.head
i=0
while(i  temp=temp.next
  i+=1
}

return temp

But we can reduce the time complexity of the solution to just $O(n)$ if we use a fast and a slow pointer to iterate over the linked list simultaneously. The slow pointer will iterate over every node in the linked list whereas the fast pointer will skip over every other node.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


fast = linked_list.head
slow = linked_list.head

while(fast!=nil) or (fast.next!=nil){
  // fast will skip over every other node
  fast = fast.next.next

  // slow will iterate the linked list
  // one node at a time
  slow = slow.next
}

return slow

Since the fast pointer covers twice the distance as the slow pointer in the same number of iterations when it reaches the end of the linked list the slow pointer would be at the middle node.

Sliding Window

Some problems require analysis of sub-sequences of a data structure. Instead of iterating the data structure one value at a time, we can define a window and move it by one value on every iteration i.e. value/pattern identified from the previous window would be reused with the new element to analyze the current window, eliminating redundancy.

Depending on the problem, the window size could be static (constant on every iteration) or dynamic (variable on every iteration).

Static Window Size

If the subsequence size defined in the problem is static then the sliding window size will also be constant.

Calculating Moving Average

The Moving Average / Rolling Mean is the mean calculated over a window of values with a constant size.

For example, 30 days moving average, 5 months moving average, etc.

$$Mean(a_1, a_2, a_3, a_4, a_5)={(a_1+a_2+a_3+a_4+a_5) \over 5}$$ $$Mean_{Rolling}(a_1, a_2, a_3, \dots , a_n, 3)=Mean(a_1, a_2, a_3),\ Mean(a_2, a_3, a_4),\newline Mean(a_3, a_4, a_5),\ \dots,\ Mean(a_{n-2}, a_{n-1}, a_{n})$$

If we have to calculate the moving average of values over the data provided in the form of an array. We can implement a brute force solution that will use a nested loop of window size $k$ and calculate the individual averages.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


func calculate_moving_average(array, k)
  moving_averages = []

  for index in array
    moving_sum = 0

    for index2 in range(0, k)
      // Calculating the sum of the current window
      moving_sum += array[index+index2]

    // Appending the average from the current window 
    // to the moving average list 
    moving_averages.append(moving_sum/k)
  
  return moving_averages

This approach will result in the total time complexity of $O(kn)$ where $k$ is the size of the window and $n$ is the number of elements in the array.

By using a sliding window of size $k$ (the moving average window size) we can eliminate the nested loop from the solution and decrease the total time complexity to $O(n)$.

We know the formula for calculating the mean over the window of the first 3 values is $$Mean(a_1, a_2, a_3)={(a_1+a_2+a_3) \over 3}$$

Instead of calculating the next rolling mean from scratch, we can use the value of $Mean(a_1, a_2, a_3)$ by adding the value of the element introduced in this window and subtracting the value of the element from the previous window (divided by the window size).

$$Mean(a_2, a_3, a_4) = {{a_2 + a_3 + a_4} \over 3}$$ $$Mean(a_2, a_3, a_4) = {{a_2 + a_3 + a_4 + a_1 - a_1} \over 3}$$ $$Mean(a_2, a_3, a_4) = {{a_1 + a_2 + a_3} \over 3} + {a_4 \over 3} - {a_1 \over 3}$$ $$Mean(a_2, a_3, a_4) = {{a_1 + a_2 + a_3} \over 3} + {{a_4 - a_1} \over 3}$$ $$Mean(a_2, a_3, a_4) = Mean(a_1, a_2, a_3) + {{a_4 - a_1} \over 3}$$

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20


func average(values)
  return sum(values)/length(values)

func calculate_moving_average(array, k)
  moving_averages = []

  // Calculating the average value of the 
  // first window
  temp_average = average(array[:k])
  moving_averages.append(temp_average)

  for index in range(k, length(array))

    // Using the average value from the 
    // previous window to calculate the average 
    // value of the current window
    temp_average = temp_average + (array[index] + array[index-k])/k
    moving_averages.append(temp_average)
  
  return moving_averages

Dynamic Window Size

Finding the largest/smallest subsequence satisfying a particular condition inside an array or string requires us to work with an unknown window size. In such cases, to apply the sliding window approach we have to maintain a start and an end pointer, updated dynamically while iterating over the data structure.

Finding the sub-array that sum up to a target value

Given a sorted array of positive integers as input, we have to find the first sub-array that sums up to a target value.

Since the length of the sub-array is unknown we have to create a dynamically sized window and calculate the sum of its elements. If the sum is smaller than the target value then we will increase the window size from the end and if the window sum is larger than the target value then we decrease its size from the beginning. This cycle will be repeated until we have found the sub-array.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


func calculate_sum(array, start, end)
  sum = 0
  for index in [start, end]
    sum += array[index]
  return sum

func find_subarray(array, target)
  start = 0 
  end = 0
  while(end    window_sum = calculate_sum(array, start, end)
    if window_sum < target:

      // If the sum of the current window
      // is smaller than the target value
      // then increase the window size from 
      // the end
      end += 1
    else if window_sum > target:

      // If the sum of the current window
      // is larger than the target value
      // then decrease the window size from 
      // the start
      start += 1
    else:
      return start, end

  return nil, nil

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

Two Pointers
Sliding Window
Moving Average
Solve subarray problems FASTER (using Sliding Windows)

Linked Lists

Fri, 17 Nov 2023 00:00:00 +0000

The linked list data structure is used to store sequential data using nodes. A node contains a value and the memory address of the next node.

Memory for a new node is allocated dynamically i.e. nodes are stored in the next available memory location. Unlike arrays where contiguous blocks of memory are allocated during declaration.

The first element in a linked list is marked by its head pointer.

Here is an implementation of Linked List in Go

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


type Node struct{
  // Integer value
  value int
    
  // Pointer to the next node
  next *Node
}

type LinkedList struct{
  // Pointer to the head node
  head *Node
}

Linked List Operations

Accessing a Value

In arrays, we can access an element using its index. For linked lists we have to iterate over all the previous elements to reach the element specified by the index, so to access the 7th element in a linked list we have to iterate over the first 6 elements.

This operation has linear time complexity ($O(n)$) in the worst-case scenario (accessing the last element).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


package main

import "fmt"

type Node struct{
  value int
  next *Node
}

type LinkedList struct{
  head *Node
}

func main(){
    // Creating a LinkedList and its head node
    var linkedList LinkedList
    linkedList.head = &(Node{value:2, next:nil})
    
    // Accessing the head of LinkedList
    fmt.Println("Head node of the linked list:", *(linkedList.head))
    
    // Adding a new nodes after head
    linkedList.head.next = &(Node{value:7, next:nil})
    linkedList.head.next.next = &(Node{value:8, next:nil})
    linkedList.head.next.next.next = &(Node{value:9, next:nil})
    
    // Accessing the node at a specific location
    index := 3
    
    // Iterator variable to store the current node
    var temp *Node
    
    // Starting from head
    temp = linkedList.head
    
    // Until the value of the index is 0
    // increment the temp to the next node
    for ;index>0;index--{
        temp = temp.next
    }
    
    // Display the value at the index
    fmt.Println("Value at index", index, "is:", temp.value)
}

Inserting an Element

Before we insert an element in a linked list, we have to allocate memory for the new node.

Inserting an Element (at the beginning)

The first element in a linked list is decided by the value of the head pointer. So we can reassign the head to point to a new node containing the value to be inserted.

Since we are only modifying the head of the linked list, this is a constant time complexity ($O(1)$) operation.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51


package main

import "fmt"

type Node struct{
  value int
  next *Node
}

type LinkedList struct{
  head *Node
}

func (ll *LinkedList) insertAtBeginning(input int){
    // Create a new node with the input value
    newNode := &(Node{value: input, next:nil})
    
    // Set the current head of the linked list 
    // as the next node
    newNode.next = (ll.head)
    
    // Point the head to newNode
    ll.head = newNode
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value:2, next:nil})
    linkedList.head.next = &(Node{value:7, next:nil})
    linkedList.head.next.next = &(Node{value:8, next:nil})
    linkedList.head.next.next.next = &(Node{value:9, next:nil})
    
    fmt.Println("Head node of the linked list:", *(linkedList.head))
    fmt.Println("2nd node of the linked list:", *(linkedList.head.next))
    fmt.Println("3rd node of the linked list:", *(linkedList.head.next.next))
    
    linkedList.insertAtBeginning(90)
    fmt.Println("After inserting a new element at the start of the Linked List")
    fmt.Println("Head node of the linked list:", *(linkedList.head))
    fmt.Println("2nd node of the linked list:", *(linkedList.head.next))
    fmt.Println("3rd node of the linked list:", *(linkedList.head.next.next))
}

// Output
// Head node of the linked list: {2 0xc00009e240}
// 2nd node of the linked list: {7 0xc00009e250}
// 3rd node of the linked list: {8 0xc00009e260}
// After inserting a new element at the start of the Linked List
// Head node of the linked list: {90 0xc00009e230}
// 2nd node of the linked list: {2 0xc00009e240}
// 3rd node of the linked list: {7 0xc00009e250}

Inserting an Element (at the end)

To insert an element at the end of a linked list we first have to find the last element. For that, we have to iterate over the complete list, which will take $O(n)$ time.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


package main

import "fmt"

type Node struct{
  value int
  next *Node
}

type LinkedList struct{
  head *Node
}

func (ll *LinkedList) insertAtEnd(input int){
    // Assigning a temp pointer to the head of the linked list
    temp := ll.head
    
    // Until we reach the node with no next value
    for ;temp.next!=nil;{
        
        // Increment temp to the next node in the linked list
        temp=temp.next
    }
    
    // Add a new node to the linked list
    temp.next = &Node{value: input, next:nil}
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value:2, next:nil})
    linkedList.head.next = &(Node{value:7, next:nil})
    
    fmt.Println("Head node:", *(linkedList.head))
    fmt.Println("2nd node:", *(linkedList.head.next))
    
    linkedList.insertAtEnd(90)
    fmt.Println("After inserting a new element at the end of the Linked List")
    fmt.Println("Head node:", *(linkedList.head))
    fmt.Println("2nd node:", *(linkedList.head.next))
    fmt.Println("3rd node:", *(linkedList.head.next.next))
    
    linkedList.insertAtEnd(91)
    fmt.Println("4th node:", *(linkedList.head.next.next.next))
}

// Output
// Head node: {2 0xc000014270}
// 2nd node: {7 }
// After inserting a new element at the end of the Linked List
// Head node: {2 0xc000014270}
// 2nd node: {7 0xc0000142a0}
// 3rd node: {90 }
// 4th node: {91 }

If we modify the LinkedList data structure to add a tail pointer (to store the address of the last node), the time taken to complete this operation will be reduced to $O(1)$.

Inserting an Element (at a specific location)

To insert an element at a specific location in a linked list, we can use the same approach as insertAtEnd but we have to stop the loop just before we reach the specified location.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


package main

import "fmt"

type Node struct{
  value int
  next *Node
}

type LinkedList struct{
  head *Node
}

func (ll *LinkedList) insertAtIndex(input int, index int){
    // Creating a new node with the input value
    newNode := &(Node{value:input, next:nil})
    
    if index==0{
        // Same as inserting a new node at the beginning
        newNode.next = ll.head
        ll.head = newNode
        
    } else {
        // Starting temp iterator from the head of the linked list
        temp := ll.head
        
        // While temp is not at the end 
        // AND i is smaller than the index
        // Increment the temp to the next node
        for i:=1;i<index && temp.next!=nil;i++{
            temp = temp.next
        }
        
        // Insert newNode in between temp and temp.next
        // temp -> newNode -> temp.next
        newNode.next = temp.next
        temp.next = newNode
    }
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value:2, next:nil})
    linkedList.head.next = &(Node{value:7, next:nil})
    
    fmt.Println("Head node:", *(linkedList.head))
    fmt.Println("2nd node:", *(linkedList.head.next))
    
    linkedList.insertAtIndex(90, 0)
    fmt.Println("After inserting a new element at 0th index")
    fmt.Println("Head node:", *(linkedList.head))
    
    linkedList.insertAtIndex(91, 1)
    fmt.Println("After inserting a new element at 1st index")
    fmt.Println("Head node:", *(linkedList.head))
    fmt.Println("2nd node:", *(linkedList.head.next))
    fmt.Println("3rd node:", *(linkedList.head.next.next))
    fmt.Println("4th node:", *(linkedList.head.next.next.next))
}

// Output
// Head node: {2 0xc000014280}
// 2nd node: {7 }
// After inserting a new element at 0th index
// Head node: {90 0xc000014270}
// After inserting a new element at 1st index
// Head node: {90 0xc0000142d0}
// 2nd node: {91 0xc000014270}
// 3rd node: {2 0xc000014280}
// 4th node: {7 }

The worst-case time complexity of this operation is $O(n)$.

Deleting an Element

We can remove an element from the linked list if we just reassign the pointers storing its location.

Deleting an Element (from the beginning)

To delete an element from the beginning we can just change the address stored in the head pointer to the next node.

The time taken to complete this operation is independent of the size of the linked list, thus the time complexity will be $O(1)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import "fmt"

type Node struct {
  value int
  next *Node
}

type LinkedList struct {
  head *Node
}

func (ll *LinkedList) deleteFromStart(){
    // Linked List's head will now point to the next node
    ll.head = ll.head.next
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value: 2, next:nil})
    linkedList.head.next = &(Node{value:3, next:nil})
    
    fmt.Println("Head node:", *linkedList.head)
    fmt.Println("Second node:", *linkedList.head.next)
    
    linkedList.deleteFromStart()
    fmt.Println("After deleting element from the start")
    fmt.Println("Head node:", *linkedList.head)
}

// Output
// Head node: {2 0xc00009e230}
// Second node: {3 }
// After deleting element from the start
// Head node: {3 }

Deleting an Element (from the end)

To delete an element from the end of a linked list we have to iterate over all the preceding elements. This will result in the worst-case time complexity of $O(n)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


package main

import "fmt"

type Node struct {
    value int
    next *Node
}

type LinkedList struct {
    head *Node
}

func (ll *LinkedList) deleteFromEnd(){
    temp := ll.head
    
    if temp.next == nil {
        
        // If the linked list contains only one element
        // Set the value of the head to nil
        ll.head = nil
        
    } else {
        
        // Iterate over the linked list until you reach
        // the second last element
        for ;temp.next.next!=nil;{
            temp = temp.next
        }
        
        // Set the next value of the second last element to nil
        temp.next = nil
    }
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value: 2, next:nil})
    linkedList.head.next = &(Node{value:3, next:nil})
    
    fmt.Println("Head node:", linkedList.head)
    fmt.Println("Second node:", linkedList.head.next)
    
    linkedList.deleteFromEnd()
    fmt.Println("After deleting element from the end")
    fmt.Println("Head node:", linkedList.head)
    fmt.Println("Second node:", linkedList.head.next)
}

// Output
// Head node: &{2 0xc000014280}
// Second node: &{3 }
// After deleting element from the end
// Head node: &{2 }
// Second node: 

Deleting an Element (from a specific location)

Similar to insertAtIndex we will iterate over the linked list and stop just before the specified location to change the references for its next pointer.

In the worst-case scenario for this operation, we have to remove the last element, resulting in $O(n)$ time complexity.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75


package main

import "fmt"

type Node struct {
    value int
    next *Node
}

type LinkedList struct {
    head *Node
}

func (ll *LinkedList) deleteFromIndex(index int){
    temp := ll.head
    if index == 0{
        
        // If we have to remove the first node (head)
        // then change its reference to the next node
        ll.head = ll.head.next
        
    } else {
        
        // Exit the loop at the second last element or 
        // at index-1
        for i:=1;i<index && temp.next.next!=nil;i++{
            temp = temp.next
        }
        
        // Change the reference of the next pointer 
        // to skip the node located at index
        temp.next = temp.next.next
    }
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value: 2, next:nil})
    linkedList.head.next = &(Node{value:3, next:nil})
    linkedList.head.next.next = &(Node{value: 5, next:nil})
    linkedList.head.next.next.next = &(Node{value: 9, next:nil})
    
    fmt.Println("Head node:", linkedList.head)
    fmt.Println("Second node:", linkedList.head.next)
    fmt.Println("Third node:", linkedList.head.next.next)
    fmt.Println("Fourth node:", linkedList.head.next.next.next)
    
    removalIndex := 2
    linkedList.deleteFromIndex(removalIndex)
    fmt.Println("After deleting element from index:", removalIndex)
    fmt.Println("Head node:", linkedList.head)
    fmt.Println("Second node:", linkedList.head.next)
    fmt.Println("Third node:", linkedList.head.next.next)
    fmt.Println("Fourth node:", linkedList.head.next.next.next)

    removalIndex = 0
    linkedList.deleteFromIndex(removalIndex)
    fmt.Println("After deleting element from index:", removalIndex)
    fmt.Println("Head node:", linkedList.head)
    fmt.Println("Second node:", linkedList.head.next)
}

// Output
// Head node: &{2 0xc00009e240}
// Second node: &{3 0xc00009e250}
// Third node: &{5 0xc00009e260}
// Fourth node: &{9 }
// After deleting element from index: 2
// Head node: &{2 0xc00009e240}
// Second node: &{3 0xc00009e260}
// Third node: &{9 }
// Fourth node: 
// After deleting element from index: 0
// Head node: &{3 0xc00009e260}
// Second node: &{9 }

Displaying Linked List

We have to iterate over all the elements in a linked list to display them in the output.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38


package main

import "fmt"

type Node struct {
    value int
    next *Node
}

type LinkedList struct {
    head *Node
}

func (ll *LinkedList) display(){
    temp := ll.head
    
    // Since we have to reach the last element itself
    // we will stop the loop only when the temp is nil
    for ;temp!=nil;{
        fmt.Printf("%d->", temp.value)
        temp = temp.next
    }
    
    fmt.Println()
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value: 2, next:nil})
    linkedList.head.next = &(Node{value:3, next:nil})
    linkedList.head.next.next = &(Node{value: 5, next:nil})
    linkedList.head.next.next.next = &(Node{value: 9, next:nil})
    
    linkedList.display()
}

// Output
// 2->3->5->9->

Variations of a Linked List

Doubly Linked List

We can add a prev pointer in the linked list node to store the address of the previous node. Although it increases the memory space allocated for each node, the time complexity of iterating in reverse (from any particular node) will be improved.

1
2
3
4
5
6
7
8
9


type Node struct{
    prev *Node
    value int
    next *Node
}

type DoublyLinkedList struct{
    head *Node
}

Circular Linked List

In a circular linked list, a node is referenced two or more times. Iterating over a circular linked list results in an infinite loop.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44


package main

import "fmt"

type Node struct {
    value int
    next *Node
}

type LinkedList struct {
    head *Node
}

func (ll *LinkedList) display(limit int){
    temp := ll.head
    
    // Loop will end upon reaching the last element
    // or hitting the limit of elements
    for ;limit>0 && temp!=nil;limit--{
        fmt.Printf("%d->", temp.value)
        temp = temp.next
    }
    
    fmt.Println()
}

func main(){
    var linkedList LinkedList
    linkedList.head = &(Node{value: 2, next:nil})
    linkedList.head.next = &(Node{value:3, next:nil})
    
    newNode := Node{value:99, next:nil}
    
    linkedList.head.next.next = &newNode
    newNode.next = &(Node{value: 9, next:nil})
    
    linkedList.head.next.next.next = &(Node{value:6, next:nil})
    linkedList.head.next.next.next.next = &newNode
    
    linkedList.display(10)
}

// Output
// 2->3->99->6->99->6->99->6->99->6->

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

How Does a Linked List Work? A Beginner’s Guide to Linked Lists

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70


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

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80


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]

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53


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.

1
2
3
4
5
6
7
8


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

Complete Code for the Optimal Solution

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252


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

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

1
2
3
4
5
6
7
8
9


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46


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)$.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37


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]

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55


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))
}

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


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.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88


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]]

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

1
2
3
4
5
6


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41


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

1
2
3
4
5
6
7
8


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47


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

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


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

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

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

1
2
3
4
5


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33


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

1
2
3
4
5
6
7


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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


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

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

217. Contains Duplicate
Contains Duplicate - Leetcode 217 - Python

Rabin-Karp Substring Search

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

Searching contents on a website for a specific keyword, code search in text editors & IDEs, and information retrieval systems used in libraries and archives are use cases for an algorithm that searches a string within another string.

Unlike searching for a single character, searching for a complete string could be challenging.

If we search string ION in DICTIONARY. For each character in DICTIONARY, we have to look for I, O, and N in the same order.

Throughout this article, I’ll be referring to the two strings as the following

search string: The string upon which the search is executed. Example: DICTIONARY
input string: The string being searched. Example: ION

Brute Force Solution

A brute force solution of substring search will loop over characters in the search string and for each character, it will perform another loop over characters in the input string to check for equality.

Psuedo Code for the Brute Force Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


loop(index1 in search_string)
    matchFlag = true
    
    loop(index2 in input_string)
        if search_string[index1 + index2] != input_string[index2]
            matchFlag = false
            break
            
    if matchFlag == true
        return True

return False

Best Case Scenario

The best performance scenario for this algorithm will be when we have to search a string within itself.

Since the outer loop (over search string) is executed only once the resulting time complexity is $O(m)$, where $m$ is the size of the input string.

The result will also be the same if the search string has characters after ION (like IONIZED, IONIC, etc.) because the algorithm will exit on the first match.

Worst Case Scenario

The worst-case scenario in terms of performance will be when the input string is not present in the search string.

The algorithm will loop over all characters in the search string and for each character, it will also loop over every character in the input string. The worst-case time complexity will be $O((n-m) m)$ where $n$ and $m$ are lengths of the search string and input string respectively.

Code for Brute Force Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48


package main

import "fmt"

func bruteForceSubstringSearch(inputString string, 
                                searchString string)(bool){

    // Looping over characters in searchString, time complexity: O(n)
    for indexN:=0;indexN<len(searchString)-len(inputString);indexN++{
        matchFlag := true

        // Looping over characters in inputString, time complexity: O(m)
        for indexM:=0;indexM<len(inputString);indexM++{
            if searchString[indexN+indexM] != inputString[indexM]{
                matchFlag = false
            } 
        }

        // Exit function if a match is found
        if matchFlag == true{
            return true
        }
    }

    return false
}

func main(){
  searchString := "DICTIONARY"

  inputString := "ION"
  fmt.Println("String",
              inputString,
              "is present in",
              searchString, ":", 
              bruteForceSubstringSearch(inputString, searchString)) 

  searchString = "FOOTBALL"
  fmt.Println("String",
              inputString,
              "is present in",
              searchString, ":", 
              bruteForceSubstringSearch(inputString, searchString)) 
}

// Output
// String ION is present in DICTIONARY : true
// String ION is present in FOOTBALL : false

Optimized Solution

The major contributor to the time complexity of brute-force solution is the recurring inner loop ($O(m)$). If we can somehow reduce it to constant time, then the total time complexity of the program will be $O(n)$.

Rabin-Karp Substring Search

The Rabin-Karp substring search algorithm was presented by Michael O. Rabin and Richard M. Karp in their research paper Efficient randomized pattern-matching algorithms published in March 1987.

In this algorithm, we calculate a rolling hash for all characters in the search string like the following

then we use the same hashing function on the input string.

The hash value of the input string is searched within rolling hashes of the search string. If a match is found then the characters of both strings are compared to confirm the match, as different strings could have the same hash value due to hash collisions.

The hash function could be defined like following

$$hash(input) = code(input[0])*128^{(n-1)} + code(input[1])*128^{(n-2)}+ \dots + code(input[n-1])*128^{0}$$

$input$ is a set of characters for which the hash value is going to be calculated.
$code()$ function converts characters to their ASCII values.
$n$ is the length of $input$.
The base is selected as $128$ to prevent hash collisions.

Applying this hash function on string ION, we get

$$hash(ION) = code(I)*128^{2} + code(O)*128^{1} + code(N)*128^{0}$$ $$hash(ION) = 73 \times 16384 + 79 \times 128 + 78 \times 1$$ $$hash(ION) = 1206222$$

Using arithmetic we can save the computation cost of calculating rolling hashes.

We can calculate the hash of the first 3 characters (because the size of the search string ION is 3).

$$ hash(DIC) = code(D)*128^2 + code(I)*128^1 + code(C)*128^0 $$

We can derive the value of the next rolling hash, $hash(ICT)$ from the hash of the first three characters, $hash(DIC)$ by performing the following operations

$$ hash(ICT) = code(I)*128^2 + code(C)*128^1 + code(T)*128^0 $$ $$ hash(ICT) = (code(I)*128^1 + code(C)*128^0)*128 + code(T)*128^0 $$ $$ hash(ICT) = (hash(DIC) - code(D)*128)*128 + code(T)*128^0 $$

We can repeat this operation to calculate all rolling hash values.

Psuedo Code for Rabin-Karp Substring Search

1
2
3
4
5


loop (index in M)
	if rollingHash[index] == rollingHash(N):
		if match(M[index:index+len(N)], N):
			return True
return False

Best Case Scenario

The best case scenario for the Rabin-Karp algorithm is the same as the brute-force algorithm i.e. the input string is the same as the search string or present at the start of the search string.

Since we are going to match the string only once the time complexity of the best case will be $O(n+m)$ where $n$ and $m$ are the sizes of the input string and search string respectively.

Worst Case Scenario

The worst-case search string will have multiple substrings with the same rolling hash value as the input string while also having different characters i.e. we have to match characters for almost every character in the search string.

This is the same as running the brute-force algorithm. So the worst case time complexity is $O((n-m)n)$.

Code for Optimized Solution

We can start with the implementation of the calculateHash() function that takes a string and a base value (2, 4, 8, etc.) as input and returns a hash value as output.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


func calculateHash(inputString string, base int)(int){
  hashValue := 0
  
  // The time complexity of this function is O(m)
  // where m is the size of inputString
  
  for i:=0;i<len(inputString);i++{
    multiple := math.Pow(float64(base), float64(len(inputString)-i-1))
    hashValue += int(inputString[i])*int(multiple)
  }
  
  return hashValue
}

Now using this function we can also implement a calculateRollingHash() function to use on the search string.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


func calculateRollingHash(searchString string, lenInputString int, base int)([]int){
  tempHash := calculateHash(searchString[:lenInputString], base)

  var rollingHashes []int
  rollingHashes = append(rollingHashes, tempHash)

  // The time complexity of this function is O(n)
  // where n is the size of searchString
  for i:=1;i<len(searchString)-lenInputString+1;i++{
    removedChar := searchString[i-1]
    addedChar := searchString[i-1+lenInputString]
    
    // Reusing tempHash to calculate values of subsequent hashes
    tempHash = tempHash - int(removedChar)*int(math.Pow(float64(base),
                                              float64(lenInputString-1)))
    tempHash = tempHash*base + int(addedChar) 

    rollingHashes = append(rollingHashes, tempHash)
  }

  return rollingHashes
}

A match() function for verifying the character match between the input string and search string.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


func match(string1 string, string2 string)(bool){
    
  // Matching characters in string1 to characters in string2
  // Length of both strings is assumed to be equal
  for i:=0;i<len(string1);i++{
    if string1[i]!=string2[i]{
      return false
    }
  }
  
  return true
}

Using the helper functions implemented above we can finally implement the rabinKarpSearch() function that returns a boolean value representing the presence of an input string in the search string.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


func rabinKarpSearch(inputString string, searchString string, base int)(bool){
  // Calculate all rolling hashes for searchString
  rollingHashes := calculateRollingHash(searchString, len(inputString), base)
  
  // Calculate the hash value of inputString
  inputStringHash := calculateHash(inputString, base)

  for i:=0;i<len(rollingHashes);i++{
    matchFlag := false
    
    if inputStringHash == rollingHashes[i]{
      // Match both strings using characters
      matchFlag = match(inputString, searchString[i:i+len(inputString)])
    }

    if matchFlag == true{
      // Exit function on the first match
      return true
    }
  }

  return false
}

Complete Code

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130


package main

import (
  "fmt"
  "math"
)

func calculateHash(inputString string, base int)(int){
  hashValue := 0
  
  // The time complexity of this function is O(m)
  // where m is the size of inputString
  
  for i:=0;i<len(inputString);i++{
    multiple := math.Pow(float64(base), float64(len(inputString)-i-1))
    hashValue += int(inputString[i])*int(multiple)
  }
  
  return hashValue
}

func calculateRollingHash(searchString string, lenInputString int, base int)([]int){
  tempHash := calculateHash(searchString[:lenInputString], base)

  var rollingHashes []int
  rollingHashes = append(rollingHashes, tempHash)

  // The time complexity of this function is O(n)
  // where n is the size of searchString
  for i:=1;i<len(searchString)-lenInputString+1;i++{
    removedChar := searchString[i-1]
    addedChar := searchString[i-1+lenInputString]
    
    // Reusing tempHash to calculate values of subsequent hashes
    tempHash = tempHash - int(removedChar)*int(math.Pow(float64(base),
                                              float64(lenInputString-1)))
    tempHash = tempHash*base + int(addedChar) 

    rollingHashes = append(rollingHashes, tempHash)
  }

  return rollingHashes
}

func match(string1 string, string2 string)(bool){
    
  // Matching characters in string1 to characters in string2
  // Length of both strings is assumed to be equal
  for i:=0;i<len(string1);i++{
    if string1[i]!=string2[i]{
      return false
    }
  }
  
  return true
}

func rabinKarpSearch(inputString string, searchString string, base int)(bool){
  // Calculate all rolling hashes for searchString
  rollingHashes := calculateRollingHash(searchString, len(inputString), base)
  
  // Calculate the hash value of inputString
  inputStringHash := calculateHash(inputString, base)

  for i:=0;i<len(rollingHashes);i++{
    matchFlag := false
    
    if inputStringHash == rollingHashes[i]{
      // Match both strings using characters
      matchFlag = match(inputString, searchString[i:i+len(inputString)])
    }

    if matchFlag == true{
      // Exit function on the first match
      return true
    }
  }

  return false
}

func main(){
  inputString := "ION"
  searchString := "DICTIONARY"
  fmt.Println("rabinKarpSearch",
               inputString,
               "in",
               searchString,
               "result:",
               rabinKarpSearch(inputString, searchString, 2))

  searchString = "FOOTBALL"
  fmt.Println("rabinKarpSearch",
               inputString,
               "in",
               searchString,
               "result:",
               rabinKarpSearch(inputString, searchString, 2))

  searchString = "UNION"
  fmt.Println("rabinKarpSearch",
               inputString,
               "in",
               searchString,
               "result:",
               rabinKarpSearch(inputString, searchString, 2))

  searchString = "IONIC"
  fmt.Println("rabinKarpSearch",
               inputString,
               "in",
               searchString,
               "result:",
               rabinKarpSearch(inputString, searchString, 2))

  searchString = "ION"
  fmt.Println("rabinKarpSearch",
               inputString,
               "in",
               searchString,
               "result:",
               rabinKarpSearch(inputString, searchString, 2))
}

// Output
// rabinKarpSearch ION in DICTIONARY result: true
// rabinKarpSearch ION in FOOTBALL result: false
// rabinKarpSearch ION in UNION result: true
// rabinKarpSearch ION in IONIC result: true
// rabinKarpSearch ION in ION result: true

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

Efficient randomized pattern-matching algorithms
Michael O. Rabin
Richard M. Karp

Arrays, Strings, and HashMaps

Fri, 29 Sep 2023 00:00:00 +0000

Data structures like arrays, strings, and hashmaps are available by default in most programming languages. They facilitate storage of large amounts of data in an efficient format which makes it easier (and sometimes relatively faster) to access during runtime.

Arrays

An array is a sequential store of data (referred to as elements).

In languages like Python, an array can store elements with multiple data types, like, [1, "Hello, World", True] but for languages like Go, C++, and Java an array can store elements of a singular data type.

Iterating over an array using indexes

An index is assigned to each element based on its location in the array. The value stored at the index could be extracted using [ ] brackets with the array’s variable name, for example, arrayExample[index].

We can iterate over values stored in an array by defining a loop starting from 0 (index of the first element in the Go Programming Language) till len(arrayExample)-1 (index of last element).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


package main

import "fmt"

func main(){
  arrayExample := []int{12, 3, 2, 1, 3123, 78}
  for i:=0;i<len(arrayExample);i++{
    fmt.Println("Element at index", i, "is:", arrayExample[i])
  }
}

// Output
// Element at index 0 is: 12
// Element at index 1 is: 3
// Element at index 2 is: 2
// Element at index 3 is: 1
// Element at index 4 is: 3123
// Element at index 5 is: 78

The time complexity of this loop is $O(n)$ where $n$ is the size of arrayExample.

Nested Arrays

A simple array will store data in just one dimension but we can nest arrays to store multidimensional data like matrices.

1
2
3
4


nestedArrayExample := [][]int{
                        {1, 123, 123, 234},
                        {456, 345, 3457, 5},
                        }

To iterate over the elements in a nested array we have to define multiple nested loops. The time complexity of fetching all the elements from a nested array will be $O(n^m)$ where $n$ is the size of individual arrays and $m$ is the order of nesting (to iterate over all the elements we have to define $m$ nested loops each of length $n$).

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


package main

import "fmt"

func main(){
  nestedArrayExample := [][]int{
    {1, 123, 123, 234},
    {456, 345, 3457, 5},
  }

  for i:=0;i<len(nestedArrayExample);i++{
    fmt.Println("Nested Array at index:", i)
    for j:=0;j<len(nestedArrayExample[i]);j++{
      fmt.Printf("Element at index[%d][%d]: %d \n", i, j, nestedArrayExample[i][j])
    }
  }
}

// Output
// Nested Array at index: 0
// Element at index[0][0]: 1 
// Element at index[0][1]: 123 
// Element at index[0][2]: 123 
// Element at index[0][3]: 234 
// Nested Array at index: 1
// Element at index[1][0]: 456 
// Element at index[1][1]: 345 
// Element at index[1][2]: 3457 
// Element at index[1][3]: 5

In the example above an array is nested inside another array ($m=2$), to traverse it we have to define a loop nested inside another loop. Thus, the time complexity of the program is $O(n^2)$.

ArrayList

ArrayList data structure is similar to an array but it doubles in size when it runs out of space. It is ideal for scenarios with limited memory space for program execution.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


package main

import "fmt"

type ArrayList struct{
  capacity int
  array []int 
}

func (al *ArrayList) insert(x int){
  if(al.capacity==0){
    // If ArrayList is at full capacity
    // then create a new temporary ArrayList
    // twice the size of the existing one

    fmt.Println("Resizing ArrayList")
    var newArray []int

    // Copy all the elements from existing
    // ArrayList to the new ArrayList
	// This will take O(n) time
	// where n is the size of al.array
    for i:=0;i<len(al.array);i++ {
      newArray = append(newArray, al.array[i])
    }

    // Insert the element in the new ArrayList
    newArray = append(newArray, x)

    // Increase the capacity of ArrayList
    al.capacity = len(al.array)-1

    // Replace the old ArrayList with a new one
    al.array = newArray

  } else{

    // Insert the element into the existing ArrayList
    al.array = append(al.array, x)

    // Decrement the capacity by 1
    al.capacity -= 1
  }
}

func main(){
  al := ArrayList{capacity:1, array: []int{}} 
  al.insert(12)
  al.insert(3)
  al.insert(2)
  al.insert(1)
  al.insert(3123)
  fmt.Println("ArrayList after all elements are inserted:", al.array)
}

// Output
// Resizing ArrayList
// Resizing ArrayList
// Resizing ArrayList
// ArrayList after all elements are inserted: [12 3 2 1 3123]

The time complexity of inserting a new element in ArrayList is assumed to be $O(1)$, but if the list is already at max capacity then the time complexity will be $O(n)$ where $n$ is the number of existing elements.

Strings

A string is like an array of characters. It is defined as a separate datatype, but most array operations like loop, slice, and indexing are interoperable.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


package main

import "fmt"

func main(){
  stringExample := "Hello, World"
  fmt.Println("First character is:", stringExample[0])
  fmt.Println("Last character is:", stringExample[len(stringExample)-1])
  fmt.Println("Slice of string:", stringExample[2:4])

  for i:=0;i<len(stringExample);i++{
    fmt.Printf("Character at index: %d is: %c \n", i, stringExample[i])
  }
}

// Output
// First character is: H
// Last character is: d
// Slice of string: ll
// Character at index: 0 is: H 
// Character at index: 1 is: e 
// Character at index: 2 is: l 
// Character at index: 3 is: l 
// Character at index: 4 is: o 
// Character at index: 5 is: , 
// Character at index: 6 is:   
// Character at index: 7 is: W 
// Character at index: 8 is: o 
// Character at index: 9 is: r 
// Character at index: 10 is: l 
// Character at index: 11 is: d

Concatenation of Strings

A program that concatenates two strings of size $m$ and $n$, has time complexity $O(m + n)$ or $O(2n)$ if both strings are of equal length.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36


package main

import (
  "fmt"
  "strings"
)

func concat(stringA string, stringB string)(string){

  // Create a new list of strings
  // to store the concatenated string
  var newString []string

  // Copy stringA
  for i:=0;i<len(stringA);i++{
      newString = append(newString, string(stringA[i]))
  }

  // Copy stringB
  for j:=0;j<len(stringB);j++{
      newString = append(newString, string(stringB[j]))
  }

  // Join the list of strings to create a new string
  return strings.Join(newString, "")
}

func main(){
  stringA := "Hello"
  stringB := "World"
  fmt.Printf("Concatenation of %s and %s is: %s \n", stringA, stringB, 
                concat(stringA, stringB))
}

// Output
// Concatenation of Hello and World is: HelloWorld 

StringBuilder

Using StringBuilder (a dynamically sized array similar to ArrayList) we can reduce the time complexity of operations performed on a string.

Upon initialization, the StringBuilder will load the characters of a string into an array. If we have to concatenate another string of length $n$, the array will be resized with time complexity $O(n)$. Once all operations are performed, the array in StringBuilder can be converted back to a string.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49


package main

import (
  "fmt"
  "strings"
)

type StringBuilder struct{
  array []string
}

func (sb *StringBuilder) load(value string){
  // We assume the time complexity of this function
  // to be O(1)

  sb.array = strings.Split(value, "")
}

func (sb *StringBuilder) concat(value string){
  // Time complexity of concatenating a string of
  // length m will be O(m)

  for i:=0;i<len(value);i++{
    sb.array = append(sb.array, string(value[i]))
  }
}

func (sb *StringBuilder) unload()(string){
  // Just like load() method the time complexity of
  // unloading an array to string will be assumed as O(1)

  return strings.Join(sb.array, "")
}

func main(){
  sb := StringBuilder{array: []string{}}
  sb.load("Hello")
  fmt.Println("Instance of StringBuilder:", sb)

  sb.concat("World")
  fmt.Println("StringBuilder array after concatenation:", sb.array)

  fmt.Println("Unloaded String:", sb.unload())
}

// Output
// Instance of StringBuilder: {[H e l l o]}
// StringBuilder array after concatenation: [H e l l o W o r l d]
// Unloaded String: HelloWorld

HashMaps

A HashMap is a data structure that stores values mapped to keys. It is generally used to store values that require frequent access, as the time complexity of accessing/searching an element in HashMap is $O(1)$.

The Map in Go, is an implementation of the HashMap data structure.

Hash Function

While inserting a value in HashMap, a Hash Function calculates a hash from the input value and allocates a location to store the value.

A HashMap collision occurs when two values have the same hash or they are allocated the same storage location. In the case of collision, multiple values could be stored in the same location using an array or LinkedList.

An ideal hash function will produce the least collisions, resulting in $O(1)$ lookup time. But in the worst-case scenario (all values are inserted in the same location) the lookup time will increase to $O(n)$, same as an array.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62


package main

import "fmt"

type HashMap struct{
  table map[int][]int
}

func calculateHash(value int)(int){
  return value%10
}

func (hm *HashMap) insert(insertValue int){
  // Calculate hash value from insertValue
  hash := calculateHash(insertValue)

  // Append the insertValue to the array 
  // present at "hash" key
  hm.table[hash] = append(hm.table[hash], insertValue)
}

func (hm *HashMap) search(searchValue int)(bool){
  
  // Narrow down the search to the array stored 
  // at the "hash" key
  searchSpace := hm.table[calculateHash(searchValue)]

  // Search for searchValue in the array stored 
  // at "hash" key
  for i:=0;i<len(searchSpace);i++{
    if (searchValue == searchSpace[i]){
      return true
    }
  }

  return false
}

func main(){
  hm := HashMap{table: make(map[int][]int)}
  hm.insert(1)
  hm.insert(12)
  hm.insert(23)
  hm.insert(65)
  hm.insert(67)
  hm.insert(55)

  fmt.Println("HashMap:", hm.table)

  searchValue1 := 55
  fmt.Println("Searching for", searchValue1, "in HashMap:",
                hm.search(searchValue1))

  searchValue2 := 2
  fmt.Println("Searching for", searchValue2, "in HashMap:",
                hm.search(searchValue2))
}

// Output
// HashMap: map[1:[1] 2:[12] 3:[23] 5:[65 55] 7:[67]]
// Searching for 55 in HashMap: true
// Searching for 2 in HashMap: false

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

Hash Table Explained: What it Is and How to Implement It
Java List Methods Tutorial – Util List API Example
How to Work with Strings in JavaScript – Tips for Efficient String Concatenation

Time Complexity

Fri, 22 Sep 2023 00:00:00 +0000

While programming allows us to create virtually anything, the true test of performance arises when we deploy the same code on a significantly larger scale.

Time Complexity ($T(n)$) is a function that estimates the execution time of an algorithm given the amount of data to be processed as its input ($n$). It is a common benchmark used to measure an algorithm’s performance.

Bounds of Time Complexity

The output of the time complexity function will be a close estimate of an algorithm’s runtime given the size of its input but it does not consider other characteristics of the input that could affect its runtime.

Some algorithms perform best when the input data is sorted in ascending order and worst when sorted in descending order or vice versa. That’s why we have bounds on the time complexity function, a range starting from best-case to worst-case execution time for the same input size.

Upper Bound ($O$)

The “big O” ($O$) represents the upper bound (worst-case scenario) on the time complexity function i.e. for an input of size $n$ the algorithm can’t take more than $O(n)$ time to provide the solution.

Lower Bound ($\Omega$)

The “big Omega” ($\Omega$) represents the lower bound (best-case scenario) on the time complexity function i.e. for an input of size $n$ the algorithm can’t take less than $O(n)$ time to provide the solution.

Expected Case ($\Theta$)

The “big Theta” ($\Theta$) represents the case where both upper and lower bounds are at the same point (expected case scenario) i.e. for an input of size $n$ the algorithm’s time complexity couldn’t get better or worse than $\Theta(n)$.

Big $O$ is the preferred time complexity function for an algorithm’s runtime analysis because it provides a conservative estimate and its result is independent of factors like hardware performance, characteristics of data, compiler optimization, etc.

While choosing among different algorithms to perform a task we aim for the lowest worst-case time complexity.

Common Time Complexity Functions

The runtime of recurring patterns in programming could be represented by common time complexity functions. This helps us estimate the time complexity of the entire program.

Constant Time Complexity $O(1)$

Scaling an Algorithm with Constant Time Complexity

An algorithm has constant time complexity when its runtime isn’t affected by the amount of data passed as input. An example would be a function that performs addition on its two inputs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


package main

import "fmt"

func addition(x int, y int) (int){
	// The size of x and y does not affect
	// the runtime of this function

	return x+y
}

func main(){
	x := 2000
	y := 2132
	fmt.Println("Addition of", x, "and", y, "is:", addition(x, y)) 
}

// Result
// Addition of 2000 and 2132 is: 4132

The above example is implemented in the Go Programming Language.

Linear Time Complexity $O(n)$

Scaling an Algorithm with Linear Time Complexity

For some algorithms the execution time is directly proportional to the size of its input, such algorithms are categorized in linear time complexity.

An example would be a loop that iterates over elements in a list and returns its sum.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25


package main

import "fmt"

func arraySum(arr []int)(int){
	sum := 0

	// Time taken to complete this loop
	// will be directly proportional to the
	// size of arr
	for _, element := range arr{
		sum += element
	}

	return sum
}

func main(){
	arrayExample := []int{1, 2, 3, 2, 1, 1}
	fmt.Println("Sum of the array:", arrayExample, "will be", 
                arraySum(arrayExample))
}

// Output
// Sum of the array: [1 2 3 2 1 1] will be 10

If we call the function arraySum() twice then the time complexity of the program will be $O(2n)$. However, we can generalize it to $O(n)$ because even though the program performs two passes over the array, the growth rate in runtime remains linear with respect to its input size.

Quadratic Time Complexity $O(n^2)$

Scaling an Algorithm with Quadratic Time Complexity

Similar to linear time complexity, algorithms exhibiting quadratic time complexity experience execution times that are directly proportional to the square of the number of inputs. These algorithms scale relatively slower (longer execution time) compared to linear time complexity algorithms like $O(n)$, $O(2n)$, etc.

For example, a program that displays pair combinations of all elements in an array using nested loops.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45


package main

import "fmt"

func showCombinations(arr []int){

	// The inner loop is executed n (size of arr) times.
	// Thus, the total time complexity of this function will be O(n*n)
	for _, element1 := range arr{

		// Time complexity of the inner loop
		// is directly proportional to the size of arr i.e. O(n)
		for _, element2 := range arr{

			if(element1 != element2){
				fmt.Println("Combination:", element1, "and", 
                                            element2)
			}

		}

	}
}

func main(){
	arrayExample := []int{123, 1234, 456, 5462}
	fmt.Println("Pair combination of all elements in the array: ", 
                arrayExample, "are:")
	showCombinations(arrayExample)
}

// Output
// Pair combination of all elements in the array:  [123 1234 456 5462] are:
// Combination: 123 and 1234
// Combination: 123 and 456
// Combination: 123 and 5462
// Combination: 1234 and 123
// Combination: 1234 and 456
// Combination: 1234 and 5462
// Combination: 456 and 123
// Combination: 456 and 1234
// Combination: 456 and 5462
// Combination: 5462 and 123
// Combination: 5462 and 1234
// Combination: 5462 and 456

Exponential Time Complexity $O(2^n)$

Scaling an Algorithm with Exponential Time Complexity

A brute-force algorithm to find the $n$th number in the Fibonacci series has exponential time complexity because it branches in two recursive calls on every iteration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21


package main

import "fmt"

func fibonacci(n int) (int){
	if n <= 1 {
		return n
	}
	
	// The recursive calls will branch
	// further in two more calls
	return fibonacci(n-1) + fibonacci(n-2)
}

func main() {
	n := 10 
	fmt.Println("The", n, "th Fibonacci number is:", fibonacci(n))
}

// Output
// The 10 th Fibonacci number is: 55

Algorithms with $O(2^n)$, $O(e^n)$, $O(10^n)$, etc. time complexities are grouped under exponential time. Among these, the $2^n$ function has widespread use in computer science like Moore’s law or to find the number of memory addresses possible with $n$ bits arrangement.

The number of transistors in an Integrated Circuit (IC) doubles about every two years

Gordon Moore, Co-Founder of Intel, 1965

Logarithmic Time Complexity $O(\log_2{n})$

Scaling an Algorithm with Logarithmic Time Complexity

The $\log_2{n}$ is the inverse of function $2^n$. The following example of a number guessing game has $O(\log_2{n})$ time complexity because it cuts the search space by half on each iteration.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84


package main

import "fmt"

func guessNumber(low int, high int)(int){
	// Returns the middle number in a range from low to high
	mid := (high+low)/2
	return mid
}

func main(){
	low := 0
	high := 100
	fmt.Println("Think of a number between", low, "and", high)
	numQuestions := 0

	for {
            var answer1, answer2 int
            guessedNumber := guessNumber(low, high)

            fmt.Println("I guessed:", guessedNumber, "Is that correct?")
            fmt.Println("1) Yes")
            fmt.Println("2) No")
            fmt.Print("Enter your response (1 or 2):")
            fmt.Scan(&answer1)

            switch(answer1){
                case 1:
                    fmt.Println("It took me", 
                                numQuestions, 
                                "questions to guess your number")

                    // It will take maximum log(n) questions to guess a number
                    // Where n is size of the number range in this case 100

                    fmt.Println("Thanks for playing")
                    return
                
                case 2:
                    numQuestions += 1
                    fmt.Println("Is it higher or lower than", guessedNumber)
                    fmt.Println("1) Higher")
                    fmt.Println("2) Lower")
                    fmt.Print("Enter your response (1 or 2):")
                    fmt.Scan(&answer2)

                    switch(answer2){
                        case 1:
                            // Halving the search space 
                            // to exclude number lower than guessed
                            low = guessedNumber
                        case 2:
                            // Halving the search space 
                            // to exclude number higher than guessed
                            high = guessedNumber
                    }
            }
	}
}

// Output
// Think of a number between 1 and 100
// I guessed: 50 Is that correct?
// 1) Yes
// 2) No
// Enter your response (1 or 2):2
// Is it higher or lower than 50
// 1) Higher
// 2) Lower
// Enter your response (1 or 2):2
// I guessed: 24 Is that correct?
// 1) Yes
// 2) No
// Enter your response (1 or 2):2
// Is it higher or lower than 24
// 1) Higher
// 2) Lower
// Enter your response (1 or 2):1
// I guessed: 37 Is that correct?
// 1) Yes
// 2) No
// Enter your response (1 or 2):1
// It took me 2 questions to guess your number
// Thanks for playing

Linearithmic Time Complexity $O(n \log_2 n)$

Scaling an Algorithm with Linearithmic Time Complexity

Merge Sort, Quick Sort, and Heap Sort are some examples of algorithms with linearithmic time complexity.

Factorial Time Complexity $O(n!)$

Scaling an Algorithm with Factorial Time Complexity

The solution to the Travelling Salesman Problem has factorial time complexity.

Comparing Algorithm Performance Using Time Complexity

Let’s say we’ve been provided with a set of algorithms and we have to choose the one which scales best with respect to the growing input size.

Assuming the output of the function $O()$ is an algorithm’s worst-case execution time in seconds. As we increase the input size from $1$ to $100$ the runtime of algorithms will scale as follows:

Algorithm	Time Complexity	Runtime ($n=2$)	Runtime ($n=10$)	Runtime ($n=100$)
Logarithmic	$O(log_2{n})$	$1$s	$3.321$s	$6.644$s
Linear	$O(n)$	$2$s	$10$s	$100$s
Linearithmic	$O(nlog_2{n})$	$2$s	$33.21$s	$664.4$s
Quadratic	$O(n^2)$	$4$s	$100$s	$10000$s
Exponential	$O(2^n)$	$4$s	$1024$s	$1.26 \times 10^{30}$s
Factorial	$O(n!)$	$2$s	$3628800$s	$9.33 \times 10^{157}$s

With the same amount of computational power and input size ($100$), an algorithm with $O(2^n)$ time complexity will finish the task in $3.99 \times 10^{22}$ years. In contrast, an algorithm with $O(n \log_2{n})$ time complexity will take only $664.4$ seconds. This illustrates the importance of performing a time complexity analysis of all possible solutions while solving a problem.

If we plot the worst-case time complexity $O(n)$ against the input size $n$ we can see that algorithms with logarithmic or linear time complexity scale better relative to algorithms with quadratic or exponential time complexity i.e. their runtime grows relatively slow as the input size increases.

Time Complexity Comparison of Algorithms

Thank you for taking the time to read this blog post! Have questions, feedback or want to discuss this topic? Feel free to reach out at blog@avni.sh.

If you found this content valuable and would like to stay updated with my latest posts, consider subscribing to my RSS Feed.

Resources

Big Theta and Asymptotic Notation Explained
What is Moore’s Law
Relationship between exponentials & logarithms
The factorial function