Added problems to Math and Backtracking

Author: Prashant Jain

src/in/knowledgegate/dsa/backtracking/GenerateParentheses.java

@@ -0,0 +1,67 @@
+package in.knowledgegate.dsa.backtracking;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Given n pairs of parentheses, write a function
+ * to generate all combinations of well-formed
+ * parentheses.
+ *
+ * Example 1:
+ * Input: n = 3
+ * Output: ["((()))","(()())","(())()","()(())","()()()"]
+ *
+ * Example 2:
+ * Input: n = 1
+ * Output: ["()"]
+ *
+ * Constraints:
+ * 1 <= n <= 8
+ */
+public class GenerateParentheses {
+  public static void main(String[] args) {
+    GenerateParentheses generator =
+        new GenerateParentheses();
+    List<String> parentheses =
+        generator.generateParenthesis(3);
+    System.out.println("Generate output:");
+    for (String parenthesis : parentheses) {
+      System.out.print(" " + parenthesis);
+    }
+  }
+
+  public List<String> generateParenthesis(int n) {
+    List<String> result = new ArrayList<>();
+    backtrack(result, new StringBuilder(), 0, 0
+        ,n);
+    return result;
+  }
+
+  private void backtrack(List<String> result,
+      StringBuilder cur, int open, int close,
+                         int max) {
+    if (cur.length() == max*2) {
+      result.add(cur.toString());
+      return;
+    }
+
+    if (open < max) {
+      cur.append('(');
+      backtrack(result, cur, open + 1, close,
+          max);
+      cur.deleteCharAt(cur.length() - 1);
+    }
+    if (close < open) {
+      cur.append(')');
+      backtrack(result, cur, open, close + 1,
+          max);
+      cur.deleteCharAt(cur.length() - 1);
+    }
+  }
+}
+
+
+
+
+

src/in/knowledgegate/dsa/math/PlusOne.java

@@ -0,0 +1,69 @@
+package in.knowledgegate.dsa.math;
+
+/**
+ * You are given a large integer represented as an
+ * integer array digits, where each digits[i] is
+ * the ith digit of the integer. The digits are
+ * ordered from most significant to least significant
+ * in left-to-right order. The large integer does
+ * not contain any leading 0's.
+ *
+ * Increment the large integer by one and return
+ * the resulting array of digits.
+ *
+ *
+ * Example 1:
+ * Input: digits = [1,2,3]
+ * Output: [1,2,4]
+ * Explanation: The array represents the integer 123.
+ * Incrementing by one gives 123 + 1 = 124.
+ * Thus, the result should be [1,2,4].
+ *
+ * Example 2:
+ * Input: digits = [4,3,2,1]
+ * Output: [4,3,2,2]
+ * Explanation: The array represents the integer 4321.
+ * Incrementing by one gives 4321 + 1 = 4322.
+ * Thus, the result should be [4,3,2,2].
+ *
+ * Example 3:
+ * Input: digits = [9]
+ * Output: [1,0]
+ * Explanation: The array represents the integer 9.
+ * Incrementing by one gives 9 + 1 = 10.
+ * Thus, the result should be [1,0].
+ *
+ * Constraints:
+ * 1 <= digits.length <= 100
+ * 0 <= digits[i] <= 9
+ * digits does not contain any leading 0's.
+ */
+public class PlusOne {
+  public static void main(String[] args) {
+    PlusOne plusOne = new PlusOne();
+    int[] res = plusOne.plusOne(new int[]{9,9,9
+        ,9});
+    for (int item : res) {
+      System.out.print(" " + item);
+    }
+  }
+
+  public int[] plusOne(int[] digits) {
+    int carry = 1;
+    for (int i = digits.length - 1; carry > 0 && i >= 0; i--) {
+      int temp = carry;
+      carry = (digits[i] + carry) / 10;
+      digits[i] = (digits[i] + temp) % 10;
+    }
+    if (carry != 1) {
+      return digits;
+    } else {
+      int[] res = new int[digits.length + 1];
+      res[0] = 1;
+      for (int i = 0; i < digits.length; i++) {
+        res[i+1] = digits[i];
+      }
+      return res;
+    }
+  }
+}

src/in/knowledgegate/dsa/math/RomanToInteger.java

@@ -0,0 +1,130 @@
+package in.knowledgegate.dsa.math;
+
+/**
+ * Roman numerals are represented by seven different
+ * symbols: I, V, X, L, C, D and M.
+ *
+ * Symbol       Value
+ * I             1
+ * V             5
+ * X             10
+ * L             50
+ * C             100
+ * D             500
+ * M             1000
+ * For example, 2 is written as II in Roman numeral,
+ * just two one's added together. 12 is written as
+ * XII, which is simply X + II. The number 27 is
+ * written as XXVII, which is XX + V + II.
+ *
+ * Roman numerals are usually written largest to
+ * smallest from left to right. However, the numeral
+ * for four is not IIII. Instead, the number four
+ * is written as IV. Because the one is before the
+ * five we subtract it making four. The same
+ * principle applies to the number nine, which is
+ * written as IX. There are six instances where
+ * subtraction is used:
+ *
+ * I can be placed before V (5) and X (10) to make 4 and 9.
+ * X can be placed before L (50) and C (100) to make 40 and 90.
+ * C can be placed before D (500) and M (1000) to make 400 and 900.
+ * Given a roman numeral, convert it to an integer.
+ *
+ *
+ * Example 1:
+ * Input: s = "III"
+ * Output: 3
+ * Explanation: III = 3.
+ *
+ * Example 2:
+ * Input: s = "LVIII"
+ * Output: 58
+ * Explanation: L = 50, V= 5, III = 3.
+ *
+ * Example 3:
+ * Input: s = "MCMXCIV"
+ * Output: 1994
+ * Explanation: M = 1000, CM = 900, XC = 90 and IV = 4.
+ *
+ *
+ * Constraints:
+ * 1 <= s.length <= 15
+ * s contains only the characters
+ * ('I', 'V', 'X', 'L', 'C', 'D', 'M').
+ * It is guaranteed that s is a valid roman
+ * numeral in the range [1, 3999].
+ */
+public class RomanToInteger {
+  public static void main(String[] args) {
+    RomanToInteger converter =
+        new RomanToInteger();
+    System.out.println("III:" + converter.romanToInt("III"));
+    System.out.println("LVIII:" + converter.romanToInt("LVIII"));
+    System.out.println("MCMXCIV:" + converter.romanToInt("MCMXCIV"));
+  }
+
+  public int romanToInt(String s) {
+    int result = 0;
+    int i = 0;
+    s = s + "00";
+
+    while (true) {
+      char c = s.charAt(i);
+      char next = s.charAt(i + 1);
+      switch (c) {
+        case 'I':
+          if (next == 'V') {
+            result += 4;
+            i++;
+          } else if (next == 'X') {
+            result += 9;
+            i++;
+          } else {
+            result += 1;
+          }
+          break;
+
+        case 'X':
+          if (next == 'L') {
+            result += 40;
+            i++;
+          } else if (next == 'C') {
+            result += 90;
+            i++;
+          } else {
+            result += 10;
+          }
+          break;
+
+        case 'C':
+          if (next == 'D') {
+            result += 400;
+            i++;
+          } else if (next == 'M') {
+            result += 900;
+            i++;
+          } else {
+            result += 100;
+          }
+          break;
+        case 'V':
+          result += 5;
+          break;
+        case 'L':
+          result += 50;
+          break;
+        case 'D':
+          result += 500;
+          break;
+        case 'M':
+          result += 1000;
+          break;
+        case '0':
+        default:
+          return result;
+      }
+      i++;
+    }
+  }
+}

src/in/knowledgegate/dsa/math/RotateArray.java

@@ -0,0 +1,56 @@
+package in.knowledgegate.dsa.math;
+
+import java.util.Arrays;
+
+/**
+ * Given an array, rotate the array to the right
+ * by k steps, where k is non-negative.
+ *
+ * Example 1:
+ * Input: nums = [1,2,3,4,5,6,7], k = 3
+ * Output: [5,6,7,1,2,3,4]
+ * Explanation:
+ * rotate 1 steps to the right: [7,1,2,3,4,5,6]
+ * rotate 2 steps to the right: [6,7,1,2,3,4,5]
+ * rotate 3 steps to the right: [5,6,7,1,2,3,4]
+ *
+ * Example 2:
+ * Input: nums = [-1,-100,3,99], k = 2
+ * Output: [3,99,-1,-100]
+ * Explanation:
+ * rotate 1 steps to the right: [99,-1,-100,3]
+ * rotate 2 steps to the right: [3,99,-1,-100]
+ *
+ *
+ * Constraints:
+ * 1 <= nums.length <= 105
+ * -231 <= nums[i] <= 231 - 1
+ * 0 <= k <= 105
+ */
+public class RotateArray {
+  public static void main(String[] args) {
+    RotateArray rotateArray = new RotateArray();
+    int[] nums = new int[]{1,2,3,4,5,6,7};
+    System.out.print("Rotating " + Arrays.toString(nums));
+    rotateArray.rotate(nums, 10);
+    System.out.println(" : " + Arrays.toString(nums));
+  }
+  public void rotate(int[] nums, int k) {
+    // Another way: int[] copyArr = nums.clone();
+    int[] copyArr = new int[nums.length];
+    for (int i = 0; i < nums.length; i++) {
+      copyArr[i] = nums[i];
+    }
+
+    for (int i = 0; i < nums.length; i++) {
+      nums[(i+k)%nums.length] = copyArr[i];
+    }
+  }
+}
+
+
+
+
+
+
+