Problem Statement

Given two strings str1 and str2, the task is to determine the largest string X that divides both str1 and str2. In other words, X should be the largest string that, when repeated, can form both str1 and str2.

Solution Approach

To solve this problem, we leverage two key insights:

1. If str1 + str2 is not equal to str2 + str1, there is no common divisor string.

2. The length of the GCD string is determined by the Greatest Common Divisor (GCD) of the lengths of str1 and str2.

Implementation in Go

Below is the Go implementation for solving this problem efficiently:

package leetcode_75
import "fmt"

func GreatestCommonDivisorOfStrings() {
    str1 := "ABAB"
    str2 := "ABABAB"
    fmt.Printf("gcdOfStrings(): %v\n", gcdOfStrings(str1, str2))
}

func gcdOfStrings(str1 string, str2 string) string {
    if str1+str2 != str2+str1 {
        return ""
    }
    gcdLength := gcd(len(str1), len(str2))
    return str1[:gcdLength]
}

func gcd(a, b int) int {
    for b != 0 {
        a, b = b, a%b
    }
    return a
}

Complexity Analysis

• Time Complexity: O(N + log(min(len(str1), len(str2))))

• Space Complexity: O(1), as we use only a few additional variables.

Explanation

1. Concatenation Check: If str1 + str2 is not equal to str2 + str1, it means the two strings do not share a common pattern, so we return an empty string.

2. Finding the GCD Length: We compute the GCD of the lengths of str1 and str2.

3. Extracting the GCD String: The prefix of str1 up to the GCD length is the desired result.

Example Walkthrough

Input:

str1 = "ABAB"
str2 = "ABABAB"

Process:

• str1 + str2 = "ABABABABABAB"

• str2 + str1 = "ABABABABABAB" (equal ✅)

• GCD(len("ABAB"), len("ABABAB")) = 2

• The first 2 characters of str1 ("AB") is the GCD string.

Output:

"AB"

Conclusion

This problem demonstrates how mathematical concepts like GCD can be applied to string problems, making it a perfect blend of string manipulation and number theory. Stay tuned for more problems in the LeetCode 75 series!

The Two Sum problem is a popular question in coding interviews and foundational in learning hash maps.

Problem

Given an array of integers, return indices of the two numbers that add up to a specific target.

Example

Input: arr = [2, 7, 11, 15], target = 9
Output: [0, 1]
Explanation: arr[0] + arr[1] = 2 + 7 = 9

You can find the detailed question description here:
LeetCode — Two Sum

Brute Force Approach

The simplest way to solve this problem is to check every pair of numbers in the array.

Implementation

// Brute force - Time Complexity: O(n^2), Space Complexity: O(1)
func twoSum() []int {
    arr := []int{2, 7, 11, 15}
    target := 9
    for index1, i := range arr {
        for index2, j := range arr {
            if i+j == target {
                return []int{index1, index2}
            }
        }
    }
    return nil
}

Explanation

1. Use nested loops to iterate through all pairs of numbers.

2. Check if the sum of two numbers equals the target.

3. If it does, return their indices.

Complexity Analysis

• Time Complexity: O(n²), as we are iterating through pairs of elements.

• Space Complexity: O(1), as no additional data structures are used.

Optimised Approach

We can improve the solution using a hash map to store the numbers and their indices.

Implementation

// Optimized approach - Time Complexity: O(n), Space Complexity: O(n)
func twoSum() []int {
    arr := []int{2, 7, 11, 15}
    target := 9
    hm := make(map[int]int) 
    for index, value := range arr {
        numberToFind := target - value
        if indexFound, ok := hm[numberToFind]; ok {
            return []int{indexFound, index}
        }
        hm[value] = index
    }
    return nil
}

Explanation

1. Use a hash map to store each number and its index.

2. For each number, calculate the complement (target - current number) (i.e value in above solution).

3. Check if the complement exists in the hash map.

4. If it does, return the indices.

Complexity Analysis

• Time Complexity: O(n), as we iterate through the array once.

• Space Complexity: O(n), as we store elements in a hash map.

Code and Repository

You can find the complete code for this solution and follow my progress solving LeetCode 75 questions in Golang on GitHub:

• GitHub Repository: DSA-Golang

• Solution Code: Two Sum Solution

Let’s Connect!

I’m documenting my journey to master DSA with Golang. If you’re on a similar path or just want to connect, feel free to reach out:

• LinkedIn: Salil Luley

• My Website: salilluley.vercel.app

Stay tuned for more solutions and insights as we tackle LeetCode 75 together. Happy coding!

MyEngineeringJournal is currently under construction.

I’ll be sharing:
• AWS & DevOps learnings
• Engineering notes
• Real-world system design
• Career lessons

Stay tuned 🚀