Solution For Find The Index Of The First Occurrence In A String

Problem Statement:

Given two strings, haystack and needle, return the index of the first occurrence of needle in haystack. If needle is not part of haystack, return -1.

Example:

Input: haystack = “hello”, needle = “ll”
Output: 2

Input: haystack = “aaaaa”, needle = “bba”
Output: -1

Solution:

The problem can be solved using the brute-force approach where we iterate through haystack and compare the substring of the same length as the needle to the needle. When we find a match we return the starting index of the match. If we don’t find any match, we return -1.

Algorithm:

1. Check the base cases. If the needle is empty return 0. If the length of the haystack is less than the length of needle, return -1.

2. Iterate through the haystack with a loop until haystack length minus needle length. For each iteration, take a substring of the same length as the needle and compare it to needle.

3. If the current substring matches the needle, return the starting index of the match.

4. If we do not find any match, return -1.

Time Complexity: O(n^2) [n is the length of the haystack]

Code:

class Solution:
def strStr(self, haystack: str, needle: str) -> int:

    if not needle:
        return 0

    h_len = len(haystack)
    n_len = len(needle)

    if h_len < n_len:
        return -1

    for i in range(h_len - n_len + 1):
        if haystack[i:i + n_len] == needle:
            return i

    return -1

Conclusion:

The problem can be solved using the brute-force approach where we iterate through haystack and compare the substring of the same length as the needle to the needle. When we find a match we return the starting index of the match. If we don’t find any match, we return -1.

Step by Step Implementation For Find The Index Of The First Occurrence In A String

public int findFirstOccurrence(String s, String target) {
    // edge case
    if (s == null || target == null || target.length() == 0) {
        return -1;
    }
    
    // use two pointers, one for s and one for target
    int i = 0, j = 0;
    
    // keep going until we reach the end of s
    while (i < s.length()) {
        // if the characters match, keep going
        if (s.charAt(i) == target.charAt(j)) {
            i++;
            j++;
        } 
        // otherwise, reset j back to 0 and move i back to where it was before we started matching
        else {
            i = i - j + 1;
            j = 0;
        }
        
        // if we reach the end of target, that means we found a match
        if (j == target.length()) {
            return i - j;
        }
    }
    
    // if we reach the end of s without finding a match, return -1
    return -1;
}

def findFirstOccurrence(string, target): 

# Initialize left and right pointers 
left = 0
right = len(string) - 1

# While left <= right, keep searching 
while left <= right: 

# Calculate the middle index 
mid = left + (right - left) // 2

# If the target is found at the middle 
if string[mid] == target: 

# Check if the target is the first occurrence by 
# comparing it to the element to its left 
if mid == 0 or string[mid - 1] != target: 
return mid 

# If the target is not the first occurrence, 
# search its left side 
else: 
right = mid - 1

# If the target is smaller than the middle element, 
# search its left side 
elif target < string[mid]: 
right = mid - 1

# If the target is greater than the middle element, 
# search its right side 
else: 
left = mid + 1

# If the target is not found in the array 
return -1

var findTheIndexOfTheFirstOccurrenceInAString = function(str, target) {
  // your code here
};

int findFirstOccurrence(string s, string target) {
    int targetLen = target.size(); 
    int sLen = s.size(); 
    
    // if target is empty, we can return 0 
    if (targetLen == 0) return 0; 
    
    // if s is empty, then obviously the target can't be found 
    if (sLen == 0) return -1; 
    
    // We can use a hashmap to keep track of all the characters in the target 
    unordered_map targetCharCount; 
    for (int i = 0; i < targetLen; i++) {
        targetCharCount[target[i]]++; 
    }
    
    // We can use a sliding window approach to keep track of the characters in the current window 
    int start = 0; 
    int end = 0; 
    int minWindowLen = INT_MAX; 
    int minWindowStart = 0; 
    int matched = 0; 
    
    // We can use a hashmap to keep track of all the characters in the current window 
    unordered_map currWindowCharCount; 
    
    // We keep expanding the window until we find a valid window 
    while (end < sLen) {
        // If the character at the current end index is not present in the target, we can keep expanding 
        if (targetCharCount.find(s[end]) == targetCharCount.end()) {
            end++; 
            continue;
        }
        
        // If the character at the current end index is present in the target, we add it to the current window 
        currWindowCharCount[s[end]]++; 
        
        // If the character at the current end index is present in the target and its frequency in the current window is less than or equal to its frequency in the target, we increment our matched variable 
        if (currWindowCharCount[s[end]] <= targetCharCount[s[end]]) {
            matched++; 
        }
        
        // If we have found a valid window, we try to shrink it from the start 
        while (matched == targetLen) {
            // If the current window size is less than the minimum window size, we update the minimum window size and the start index of the minimum window 
            if (end - start + 1 < minWindowLen) {
                minWindowLen = end - start + 1; 
                minWindowStart = start; 
            }
            
            // If the character at the start index is not present in the target, we can keep shrinking 
            if (targetCharCount.find(s[start]) == targetCharCount.end()) {
                start++; 
                continue; 
            }
            
            // If the character at the start index is present in the target, we remove it from the current window 
            currWindowCharCount[s[start]]--; 
            
            // If the character at the start index is present in the target and its frequency in the current window is less than its frequency in the target, we decrement our matched variable 
            if (currWindowCharCount[s[start]] < targetCharCount[s[start]]) {
                matched--; 
            }
            
            // We increment the start index to keep shrinking the window 
            start++; 
        }
        
        // We increment the end index to keep expanding the window 
        end++; 
    }
    
    // If we have not found a valid window, we return -1 
    if (minWindowLen == INT_MAX) return -1; 
    
    // Otherwise, we return the start index of the minimum window 
    return minWindowStart; 
}

public int FindIndex(string s, char c) { // return the index of the first occurrence of char c in string s int index = -1; for (int i = 0; i < s.Length; i++) { if (s[i] == c) { index = i; break; } } return index; }