#2900: Longest Unequal Adjacent Groups Subsequence I; solution & tests.

Author: vetalapo

c-sharp/Problems/greedy/LongestUnequalAdjacentGroupsSubsequenceI.cs

@@ -0,0 +1,86 @@
+/**
+ * 2900
+ * Longest Unequal Adjacent Groups Subsequence I
+ **
+ * You are given a string array words and a binary array groups both of length n,
+ * where words[i] is associated with groups[i].
+ * Your task is to select the longest alternating subsequence from words.
+ * A subsequence of words is alternating if for any two consecutive strings in the sequence,
+ * their corresponding elements in the binary array groups differ.
+ * Essentially,
+ * you are to choose strings such that
+ * adjacent elements have non-matching corresponding bits in the groups array.
+ * Formally,
+ * you need to find the longest subsequence of an array of indices
+ * [0, 1, ..., n - 1] denoted as [i0, i1, ..., ik-1],
+ * such that groups[ij] != groups[ij+1] for each 0 <= j < k - 1 and
+ * then find the words corresponding to these indices.
+ *
+ * Return the selected subsequence.
+ * If there are multiple answers,
+ * return any of them.
+ *
+ * Note: The elements in words are distinct.
+ *
+ * Example 1:
+ *   Input: words = ["e","a","b"], groups = [0,0,1]
+ *   Output: ["e","b"]
+ *   Explanation:
+ *     A subsequence that can be selected is ["e","b"] because groups[0] != groups[2].
+ *     Another subsequence that can be selected is ["a","b"] because groups[1] != groups[2].
+ *     It can be demonstrated that
+ *     the length of the longest subsequence of indices that satisfies the condition is 2.
+ *
+ * Example 2:
+ *   Input: words = ["a","b","c","d"], groups = [1,0,1,1]
+ *   Output: ["a","b","c"]
+ *   Explanation:
+ *     A subsequence that can be selected is ["a","b","c"]
+ *     because groups[0] != groups[1] and groups[1] != groups[2].
+ *     Another subsequence that can be selected is ["a","b","d"]
+ *     because groups[0] != groups[1] and groups[1] != groups[3].
+ *     It can be shown that
+ *     the length of the longest subsequence of indices
+ *     that satisfies the condition is 3.
+ *
+ * Constraints:
+ *   • 1 <= n == words.length == groups.length <= 100
+ *   • 1 <= words[i].length <= 10
+ *   • groups[i] is either 0 or 1.
+ *   • words consists of distinct strings.
+ *   • words[i] consists of lowercase English letters.
+ *
+ * Hint 1:
+ *   This problem can be solved greedily.
+ *
+ * Hint 2:
+ *   Begin by constructing the answer starting with the first number in groups.
+ *
+ * Hint 3:
+ *   For each index i in the range [1, n - 1],
+ *   add i to the answer if groups[i] != groups[i - 1].
+ **
+ * https://leetcode.com/problems/longest-unequal-adjacent-groups-subsequence-i/
+***/
+
+using System.Collections.Generic;
+
+namespace Problems;
+
+public class LongestUnequalAdjacentGroupsSubsequenceI
+{
+    public IList<string> GetLongestSubsequence( string[] words, int[] groups )
+    {
+        List<string> result = new( words.Length ) { words[0] };
+
+        for ( int right = 1; right < groups.Length; right++ )
+        {
+            if ( groups[right] != groups[right - 1] )
+            {
+                result.Add( words[right] );
+            }
+        }
+
+        return result; ;
+    }
+}

c-sharp/Tests/greedy/LongestUnequalAdjacentGroupsSubsequenceITests.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+using NUnit.Framework;
+
+using Problems;
+
+public class LongestUnequalAdjacentGroupsSubsequenceITests
+{
+    [TestCase( new string[] { "c" }, new int[] { 0 }, ExpectedResult = new string[] { "c" } )]
+    [TestCase( new string[] { "d" }, new int[] { 1 }, ExpectedResult = new string[] { "d" } )]
+    [TestCase( new string[] { "e", "a", "b" }, new int[] { 0, 0, 1 }, ExpectedResult = new string[] { "e", "b" } )]
+    [TestCase( new string[] { "a", "b", "c", "d" }, new int[] { 1, 0, 1, 1 }, ExpectedResult = new string[] { "a", "b", "c" } )]
+    [TestCase( new string[] { "d", "a", "v", "b" }, new int[] { 1, 0, 0, 1 }, ExpectedResult = new string[] { "d", "a", "b" } )]
+    public IList<string> GetLongestSubsequenceTest( string[] words, int[] groups ) =>
+        new LongestUnequalAdjacentGroupsSubsequenceI().GetLongestSubsequence( words, groups );
+}