Next tasks

Author: dev-ik

10. Regular Expression Matching/index.test.ts

@@ -0,0 +1,39 @@
+import { isMatch } from './index';
+
+describe('isMatch', () => {
+  const testCases = [
+    {
+      name: 'Case 1',
+      input: { s: 'aa', p: 'a' },
+      expected: false,
+    },
+    {
+      name: 'Case 2',
+      input: { s: 'aa', p: 'a*' },
+      expected: true,
+    },
+    {
+      name: 'Case 3',
+      input: { s: 'ab', p: '.*' },
+      expected: true,
+    },
+    {
+      name: 'Case 4',
+      input: { s: 'aab', p: 'c*a*b' },
+      expected: true,
+    },
+    {
+      name: 'Case 5',
+      input: { s: 'mississippi', p: 'mis*is*p*.' },
+      expected: false,
+    },
+  ];
+
+  for (const testCase of testCases) {
+    test(testCase.name, () => {
+      expect(isMatch(testCase.input.s, testCase.input.p)).toBe(
+        testCase.expected,
+      );
+    });
+  }
+});

10. Regular Expression Matching/index.ts

@@ -0,0 +1,36 @@
+// Description:
+// Given an input string s and a pattern p, implement regular expression matching with support for '.' and '*' where:
+//    '.' Matches any single character.
+//    '*' Matches zero or more of the preceding element.
+//The matching should cover the entire input string (not partial).
+//
+// Constraints:
+//    1 <= s.length <= 20
+//    1 <= p.length <= 20
+//    s contains only lowercase English letters.
+//    p contains only lowercase English letters, '.', and '*'.
+//It is guaranteed for each appearance of the character '*', there will be a previous valid character to match.
+
+export const isMatch = (s: string, p: string): boolean => {
+  const columns = s.length;
+  const rows = p.length;
+  const arr = Array.from({ length: columns + 1 }, () =>
+    Array(rows + 1).fill(false),
+  );
+
+  arr[0][0] = true;
+
+  for (let i = 0; i <= columns; ++i) {
+    for (let j = 1; j <= rows; ++j) {
+      if (p[j - 1] === '*') {
+        arr[i][j] = arr[i][j - 2];
+        if (i && (p[j - 2] === '.' || p[j - 2] === s[i - 1])) {
+          arr[i][j] |= arr[i - 1][j];
+        }
+      } else if (i && (p[j - 1] === '.' || p[j - 1] === s[i - 1])) {
+        arr[i][j] = arr[i - 1][j - 1];
+      }
+    }
+  }
+  return Boolean(arr[columns][rows]);
+};

11. Container With Most Water/index.test.ts

@@ -0,0 +1,22 @@
+import { maxArea } from './index';
+
+describe('maxArea', () => {
+  const testCases = [
+    {
+      name: 'Case 1',
+      input: [1, 8, 6, 2, 5, 4, 8, 3, 7],
+      expected: 49,
+    },
+    {
+      name: 'Case 2',
+      input: [1, 1],
+      expected: 1,
+    },
+  ];
+
+  for (const testCase of testCases) {
+    test(testCase.name, () => {
+      expect(maxArea(testCase.input)).toBe(testCase.expected);
+    });
+  }
+});

11. Container With Most Water/index.ts

@@ -0,0 +1,33 @@
+// Description:
+// You are given an integer array height of length n. There are n vertical lines drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+//
+// Find two lines that together with the x-axis form a container, such that the container contains the most water.
+//
+// Return the maximum amount of water a container can store.
+//
+// Notice that you may not slant the container.
+//
+// Constraints:
+//    n == height.length
+//    2 <= n <= 105
+//    0 <= height[i] <= 104
+
+export const maxArea = (height: number[]): number => {
+  let lp = 0;
+  let rp = height.length - 1;
+  let area = 0;
+
+  for (let i = 0; i <= height.length; i++) {
+    const delta = rp - lp;
+    const min = Math.min(height[rp], height[lp]);
+    const newArea = min * delta;
+
+    if (newArea > area) {
+      area = newArea;
+    }
+
+    height[rp] > height[lp] ? lp++ : rp--;
+  }
+
+  return area;
+};

12. Integer to Roman/index.test.ts

@@ -0,0 +1,27 @@
+import { intToRoman } from './index';
+
+describe('intToRoman', () => {
+  const testCases = [
+    {
+      name: 'Case 1',
+      input: 3749,
+      expected: 'MMMDCCXLIX',
+    },
+    {
+      name: 'Case 2',
+      input: 58,
+      expected: 'LVIII',
+    },
+    {
+      name: 'Case 3',
+      input: 1994,
+      expected: 'MCMXCIV',
+    },
+  ];
+
+  for (const testCase of testCases) {
+    test(testCase.name, () => {
+      expect(intToRoman(testCase.input)).toBe(testCase.expected);
+    });
+  }
+});

12. Integer to Roman/index.ts

@@ -0,0 +1,52 @@
+// Description:
+// Seven different symbols represent Roman numerals with the following values:
+//
+//     Symbol	Value
+//          I	1
+//          V	5
+//          X	10
+//          L	50
+//          C	100
+//          D	500
+//          M	1000
+// Roman numerals are formed by appending the conversions of decimal place values from highest to lowest. Converting a decimal place value into a Roman numeral has the following rules:
+//    If the value does not start with 4 or 9, select the symbol of the maximal value that can be subtracted from the input,
+//    append that symbol to the result, subtract its value, and convert the remainder to a Roman numeral.
+//
+//    If the value starts with 4 or 9 use the subtractive form representing one symbol subtracted from the following symbol,
+//    for example, 4 is 1 (I) less than 5 (V): IV and 9 is 1 (I) less than 10 (X): IX.
+//    Only the following subtractive forms are used: 4 (IV), 9 (IX), 40 (XL), 90 (XC), 400 (CD) and 900 (CM).
+//    Only powers of 10 (I, X, C, M) can be appended consecutively at most 3 times to represent multiples of 10.
+//
+//    You cannot append 5 (V), 50 (L), or 500 (D) multiple times. If you need to append a symbol 4 times use the subtractive form.
+// Given an integer, convert it to a Roman numeral.
+//
+// Constraints:
+//    1 <= num <= 3999
+
+export const intToRoman = (num: number): string => {
+  const cs: string[] = [
+    'M',
+    'CM',
+    'D',
+    'CD',
+    'C',
+    'XC',
+    'L',
+    'XL',
+    'X',
+    'IX',
+    'V',
+    'IV',
+    'I',
+  ];
+  const vs: number[] = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+  const ans: string[] = [];
+  for (let i = 0; i < vs.length; ++i) {
+    while (num >= vs[i]) {
+      num -= vs[i];
+      ans.push(cs[i]);
+    }
+  }
+  return ans.join('');
+};