Standard Finite-State-Machine (FSM) Implementation - II

-
There are multiple ways to solve this problem, but I find a state machine implementation very intuitive, even if we have to leave some of the state transitions empty (no-op). The state manages whether you're in "same char" mode or "different char". Code is down below, cheers, ACC.




You are given two strings s1 and s2 of the same length.

A mismatched segment is a maximal contiguous range of indices where the characters of s1 and s2 differ at every index.

Return a 2D array containing [sub1, sub2] for each mismatched segment, where sub1 and sub2 are the corresponding substrings from s1 and s2, respectively. Return the segments in increasing order of their starting indices. If there are no mismatched segments, return an empty array.

A substring is a contiguous non-empty sequence of characters within a string.

 

Example 1:

Input: s1 = "earth", s2 = "empty"

Output: [["ar","mp"],["h","y"]]

Explanation:

  • The characters at indices 1 and 2 differ, forming the mismatched segment ["ar","mp"].
  • The characters at index 4 differ, forming the mismatched segment ["h","y"].

Example 2:

Input: s1 = "action", s2 = "nation"

Output: [["ac","na"]]

Explanation:

The characters at indices 0 and 1 differ, forming the mismatched segment ["ac","na"]. All remaining characters are equal in both strings.

Example 3:

Input: s1 = "hot", s2 = "hot"

Output: []

Explanation:

The two strings are identical, so there are no mismatched segments.

 

Constraints:

  • 1 <= s1.length == s2.length <= 100
  • s1 and s2 consist of lowercase English letters.

public class Solution {
    public IList> FindMismatchedSegments(string s1, string s2)
    {
        bool stateMatches = false;

        List> retVal = new List>();
        string mismatchS1 = "";
        string mismatchS2 = "";

        for (int i = 0; i < s1.Length; i++)
        {
            if (s1[i] == s2[i])
            {
                if (stateMatches)
                {
                    //No-op
                }
                else
                {
                    if (mismatchS1.Length > 0)
                    {
                        retVal.Add(new List() { mismatchS1, mismatchS2 });
                    }
                    stateMatches = true;
                }
            }
            else
            {
                if (stateMatches)
                {
                    mismatchS1 = s1[i].ToString();
                    mismatchS2 = s2[i].ToString();
                    stateMatches = false;
                }
                else
                {
                    mismatchS1 += s1[i].ToString();
                    mismatchS2 += s2[i].ToString();
                }
            }
        }
        if (!stateMatches)
        {
            if (mismatchS1.Length > 0)
            {
                retVal.Add(new List() { mismatchS1, mismatchS2 });
            }
        }

        return retVal;
    }
}

Comments

Post a Comment

Popular posts from this blog

Standard Priority Queue IX: Vowels Frequency

-
Tally the frequency of the vowels. Push that into a pQueue, the caveat is when the frequencies are the same, you need to keep track of the first occurrence of each vowel and do some math to insert into the priority queue with the right order. After that, it is just dequeuing and inserting into the proper places. Use StringBuilder to avoid unnecessary string allocations. Code is down below, cheers, ACC. Sort Vowels by Frequency - LeetCode You are given a string  s  consisting of lowercase English characters. Rearrange only the  vowels  in the string so that they appear in  non-increasing  order of their frequency. If multiple vowels have the same  frequency , order them by the position of their  first occurrence  in  s . Return the modified string. Vowels are  'a' ,  'e' ,  'i' ,  'o' , and  'u' . The  frequency  of a letter is the number of times it occurs in the string.   Example 1: Input:   ...
Read more

Binary Search to Find Next Greater Element V

-
You can use the .BinarySearch method of List<T>. It works well, there is a bit of a trick that you need to do when the return index is negative (just assign it to its complement, ~index). No need to perform the Binary Search "by hand" anymore. Achieves a good NLogN, fast solution. LC suggests a Tree to be used but this approach (two lists, one for even, one for odd) works well. Code is down below, cheers, ACC. Count Smaller Elements With Opposite Parity - LeetCode You are given an integer array  nums  of length  n . The  score  of an index  i  is defined as the number of indices  j  such that: i < j < n nums[j] < nums[i] nums[i]  and  nums[j]  have different parity (one is even and the other is odd). Return an integer array  answer  of length  n , where  answer[i]  is the score of index  i .   Example 1: Input:   nums = [5,2,4,1,3] Output:   [2,1,2,0,0] Explanation: Fo...
Read more

Simulation: Build Generations

-
This was a very interesting problem in my opinion. It is a classic exercise in simulation, especially related to population growth. The constraints are small enough that you can brute-force and you'll be fine. Some techniques worth mentioning: 1/ Use a hash set for quick verification whether a point is in the generation 2/ Hash using the boundaries - using 7 as a seed works, hence x*7*7 + y*7 + z is a solid hash without the worry of overflowing 3/ Use two lists for generations: current and next 4/ Build next generation using an N^2 approach (it is OK since N = 6) 5/ Prune using the fact that the points in the next generation always have smaller numbers (due to the floor((a+b)/2)), hence if ever any of the indexes of your target is larger than the largest corresponding index in the current generation, you can safely assume that there won't be a solution. Also, prune using the fact that if the next generation isn't larger than the previous one, no solution will be found Code ...
Read more