Solve problems: Is Subsequence & Isomorphic Strings

Author: GolubevDS

README.MD

@@ -23,3 +23,5 @@ Solutions to problems from the [LeetCode Patterns](https://seanprashad.com/leetc
 | [Majority Element](https://leetcode.com/problems/majority-element)                                                 | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/majorityElement/index.js)        | Easy       |
 | [Running Sum of 1d Array](https://leetcode.com/problems/running-sum-of-1d-array/)                                  | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/runningSum/index.js)             | Easy       |
 | [Find Pivot Index](https://leetcode.com/problems/find-pivot-index/)                                                | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/pivotIndex/index.js)             | Easy       |
+| [Is Subsequence](https://leetcode.com/problems/is-subsequence/)                                                    | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/isSubsequence/isSubsequence.js)  | Easy       |
+| [Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/)                                            | [Solution](https://github.com/GolubevDS/LeetCodePatterns/blob/main/solutions/isIsomorphic/isIsomorphic.js)    | Easy       |

solutions/isIsomorphic/README.MD

@@ -0,0 +1,7 @@
+## [205. Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/)
+
+Given two strings `s` and `t`, determine if they are isomorphic.
+
+Two strings `s` and `t` are isomorphic if the characters in `s` can be replaced to get `t`.
+
+All occurrences of a character must be replaced with another character while preserving the order of characters. No two characters may map to the same character, but a character may map to itself.

solutions/isIsomorphic/isIsomorphic.js

@@ -0,0 +1,15 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+function isIsomorphic(s, t) {
+	for (let i = 0; i < s.length; i++) {
+		if (s.indexOf(s[i], i + 1) !== t.indexOf(t[i], i + 1))
+			return false;
+	}
+
+	return true;
+}
+
+module.exports = isIsomorphic;

solutions/isIsomorphic/isIsomorphic.spec.js

@@ -0,0 +1,28 @@
+const isIsomorphic = require('./isIsomorphic');
+
+describe('isIsomorphic', () => {
+	it('should return true when s and t are empty strings', () => {
+		const result = isIsomorphic('', '');
+		expect(result).toBe(true);
+	});
+
+	it('should return true when s and t are isomorphic', () => {
+		const result = isIsomorphic('egg', 'add');
+		expect(result).toBe(true);
+	});
+
+	it('should return false when s and t are not isomorphic', () => {
+		const result = isIsomorphic('foo', 'bar');
+		expect(result).toBe(false);
+	});
+
+	it('should handle edge cases when s and t have different lengths', () => {
+		const result = isIsomorphic('paper', 'title');
+		expect(result).toBe(true);
+	});
+
+	it('should handle edge cases when s and t have the same letters but different order', () => {
+		const result = isIsomorphic('abcdef', 'ghijkl');
+		expect(result).toBe(true);
+	});
+});

solutions/isSubsequence/README.MD

@@ -0,0 +1,5 @@
+## [392. Is Subsequence](https://leetcode.com/problems/is-subsequence/)
+
+Given two strings `s` and `t`, return `true` if `s` is a subsequence of `t`, or `false` otherwise.
+
+A subsequence of a string is a new string that is formed from the original string by deleting some (can be none) of the characters without disturbing the relative positions of the remaining characters. (i.e., `"ace"` is a subsequence of `"abcde"` while `"aec"` is not).

solutions/isSubsequence/isSubsequence.js

@@ -0,0 +1,19 @@
+/**
+ * @param {string} s
+ * @param {string} t
+ * @return {boolean}
+ */
+function isSubsequence(s, t) {
+	if (s.length > t.length) return false;
+
+	let sIndex = 0;
+
+	for(let i = 0; i < t.length; i++) {
+		if (t[i] === s[sIndex]) sIndex++;
+		if (sIndex === s.length) return true;
+	}
+
+	return sIndex === s.length;
+}
+
+module.exports = isSubsequence;

solutions/isSubsequence/isSubsequence.spec.js

@@ -0,0 +1,33 @@
+const isSubsequence = require('./isSubsequence');
+
+describe('Is Subsequence', () => {
+	it('should return true when s is an empty string', () => {
+		const result = isSubsequence('', 'hello world');
+		expect(result).toBe(true);
+	});
+
+	it('should return true when s is a substring of t', () => {
+		const result = isSubsequence('abc', 'aabbcc');
+		expect(result).toBe(true);
+	});
+
+	it('should return false when s is not a substring of t', () => {
+		const result = isSubsequence('xyz', 'hello world');
+		expect(result).toBe(false);
+	});
+
+	it('should return true when s is equal to t', () => {
+		const result = isSubsequence('hello', 'hello');
+		expect(result).toBe(true);
+	});
+
+	it('should return true when s is a single character', () => {
+		const result = isSubsequence('o', 'hello world');
+		expect(result).toBe(true);
+	});
+
+	it('should handle edge cases when s is longer than t', () => {
+		const result = isSubsequence('hello world', 'hello');
+		expect(result).toBe(false);
+	});
+});