Find The Index Of The First Occurrence In A String

                                            
class Solution {
public:
    int strStr(string haystack, string needle) {
        if (needle.empty()) {
            return 0;
        }
        
        int n = haystack.length();
        int m = needle.length();
        
        for (int i = 0; i <= n - m; ++i) {
            int j = 0;
            while (j < m && haystack[i + j] == needle[j]) {
                ++j;
            }
            if (j == m) {
                return i;
            }
        }
        
        return -1;
    }
};

                                            
class Solution {
    public int strStr(String haystack, String needle) {
        if (needle.isEmpty()) {
            return 0;
        }
        
        int n = haystack.length();
        int m = needle.length();
        
        for (int i = 0; i <= n - m; i++) {
            if (haystack.substring(i, i + m).equals(needle)) {
                return i;
            }
        }
        
        return -1;
    }
}

                                            
class Solution(object):
    def strStr(self, haystack, needle):
        """
        :type haystack: str
        :type needle: str
        :rtype: int
        """
        if not needle:
            return 0
        if needle not in haystack:
            return -1
        return haystack.index(needle)

                                            
int strStr(char* haystack, char* needle) {
    if (*needle == '\0') {
        return 0;
    }
    
    int haystack_len = strlen(haystack);
    int needle_len = strlen(needle);
    
    for (int i = 0; i <= haystack_len - needle_len; i++) {
        int j;
        for (j = 0; j < needle_len; j++) {
            if (haystack[i+j] != needle[j]) {
                break;
            }
        }
        if (j == needle_len) {
            return i;
        }
    }
    
    return -1;
}

                                            
public class Solution {
    public int StrStr(string haystack, string needle) {
        if (string.IsNullOrEmpty(needle)) return 0;
        
        for (int i = 0; i <= haystack.Length - needle.Length; i++) {
            if (haystack.Substring(i, needle.Length) == needle) {
                return i;
            }
        }
        
        return -1;
    }
}

                                            
function strStr(haystack: string, needle: string): number {
    if (needle === "") {
        return 0;
    }
    
    for (let i = 0; i < haystack.length; i++) {
        if (haystack.slice(i, i + needle.length) === needle) {
            return i;
        }
    }
    
    return -1;
};

                                            
class Solution {
    /**
     * @param String $haystack
     * @param String $needle
     * @return Integer
     */
    function strStr($haystack, $needle) {
        $haystackLen = strlen($haystack);
        $needleLen = strlen($needle);
        
        if ($needleLen == 0) {
            return 0;
        }
        
        for ($i = 0; $i <= $haystackLen - $needleLen; $i++) {
            if (substr($haystack, $i, $needleLen) == $needle) {
                return $i;
            }
        }
        
        return -1;
    }
}

                                            
class Solution {
    func strStr(_ haystack: String, _ needle: String) -> Int {
        if haystack.isEmpty && needle.isEmpty {
            return 0
        }
        
        guard let range = haystack.range(of: needle) else {
            return -1
        }
        
        return haystack.distance(from: haystack.startIndex, to: range.lowerBound)
    }
}

                                            
class Solution {
    fun strStr(haystack: String, needle: String): Int {
        if (needle.isEmpty()) return 0
        
        for (i in 0..haystack.length - needle.length) {
            if (haystack.substring(i, i + needle.length) == needle) {
                return i
            }
        }
        
        return -1
    }
}

                                            
class Solution {
  int strStr(String haystack, String needle) {
    if (haystack.isEmpty || needle.isEmpty) {
      return -1;
    }
    
    for (int i = 0; i <= haystack.length - needle.length; i++) {
      if (haystack.substring(i, i + needle.length) == needle) {
        return i;
      }
    }
    
    return -1;
  }
}

                                            
func strStr(haystack string, needle string) int {
    if len(needle) == 0 {
        return 0
    }
    
    for i := 0; i < len(haystack) - len(needle) + 1; i++ {
        if haystack[i:i+len(needle)] == needle {
            return i
        }
    }
    
    return -1
}

                                            
# @param {String} haystack
# @param {String} needle
# @return {Integer}
def str_str(haystack, needle)
    haystack.index(needle) || -1
end

                                            
impl Solution {
    pub fn str_str(haystack: String, needle: String) -> i32 {
        if needle.is_empty() {
            return 0;
        }
        
        if let Some(index) = haystack.find(&needle) {
            return index as i32;
        } else {
            return -1;
        }
    }
}

                                            
defmodule Solution do
  @spec str_str(haystack :: String.t, needle :: String.t) :: integer
  def str_str(haystack, needle) do
    case String.split(haystack, needle) do
      [prefix, _ | _] -> String.length(prefix)
      _ -> -1
    end
  end
end

To solve this coding challenge of finding the index of the first occurrence of

needle

haystack

, we need to iterate carefully and identify where the substring

needle

first appears within

haystack

. The solution must return

-1

needle

is not found in

haystack

. Here's a step-by-step explanation of the pseudocode to accomplish this task:

Explanation:

Initialize Variables : Begin by checking for corner cases such as the
needle

being an empty string. If
needle

is empty, return
0

immediately as it is technically found at the beginning.
Check if
needle

is in
haystack

: Before performing the search, check if
needle

is even present within
haystack

. If
needle

is not present, return
-1

.
Iterate Through
haystack

: Traverse
haystack

using an index until a window size comparable to the length of
needle

is reached.
Compare Substrings : For each index, extract the substring of
haystack

which is of the same length as
needle

and compare this substring with
needle

.
Return First Match : If a matching substring is found, return its starting index. If loop concludes without finding a match, return
-1

.

Detailed Steps in Pseudocode:

                                            
# Function to find first occurrence of needle in haystack
FUNCTION findFirstOccurrence(haystack, needle)

# Step 1: Handle edge cases where needle is empty
IF needle IS EMPTY
RETURN 0

# Step 2: Check if needle is not part of haystack at all
IF needle NOT IN haystack
RETURN -1

# Step 3: Iterate through haystack with index i
FOR i FROM 0 TO (length of haystack - length of needle)
# Extract substring of haystack
substring = haystack[i : i + length of needle]

# Step 4: Compare extracted substring with needle
IF substring EQUALS needle
RETURN i  # Return the start index of the first occurrence

# Step 5: If no match is found, return -1
RETURN -1

Here’s a breakdown of the steps to ensure clarity:

Initiate a function
findFirstOccurrence

that takes
haystack

and
needle

strings as parameters.
Check if
needle

is an empty string; if so, return
0

because an empty
needle

is always technically found at the start.
Use a direct membership check (
needle

in
haystack

) to see if
needle

is even part of
haystack

. If not, return
-1

.
Iterate over
haystack

from the start index up to the end position where a full-length
needle

substring can still be compared. This means iterating from
0

to
length of haystack - length of needle

.
For every iteration, extract a substring from
haystack

starting at the current index
i

of length equivalent to
needle

.
Compare this substring to
needle

. If a match is found, return the current index
i

.
If the loop completes without finding any match, return
-1

indicating
needle

does not occur within
haystack

.

This detailed approach ensures that all edge cases and possible input scenarios are covered, offering a methodical way to solve the challenge.