Solve Problems 1, 9, 13 and 14

Author: THammami01

.gitignore

@@ -0,0 +1,3 @@
+.idea/
+out/
+*.iml

src/problem_0001_two_sum/Solution.java

@@ -0,0 +1,20 @@
+package problem_0001_two_sum;
+
+// LINK: https://leetcode.com/problems/two-sum/
+
+public class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        for(int i=0; i<nums.length; i++)
+            for(int j=0; j<nums.length; j++)
+                if(nums[i] + nums[j] == target && i != j)
+                    return new int[]{i, j};
+        return null;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = {3, 2, 4};
+        int target = 6;
+        int[] output = new Solution().twoSum(nums, target);
+        for (int n: output) System.out.println(n);
+    }
+}

src/problem_0009_palindrome_number/Solution.java

@@ -0,0 +1,21 @@
+package problem_0009_palindrome_number;
+
+// LINK: https://leetcode.com/problems/palindrome-number/
+
+public class Solution {
+    public String reverse(String s) {
+        StringBuilder temp = new StringBuilder();
+        for (int i = s.length() - 1; i >= 0; i--)
+            temp.append(s.charAt(i));
+        return String.valueOf(temp);
+    }
+
+    public boolean isPalindrome(int x) {
+        String s = String.valueOf(x);
+        return s.equals(reverse(s));
+    }
+
+    public static void main(String[] args) {
+        System.out.println(new Solution().isPalindrome(1234567899));
+    }
+}

src/problem_0013_roman_to_integer/Solution.java

@@ -0,0 +1,57 @@
+package problem_0013_roman_to_integer;
+
+import java.util.ArrayList;
+
+// LINK: https://leetcode.com/problems/roman-to-integer/
+// I 1 | V 5 | X 10 | L 50 | C 100 | D 500 | M 1000
+// LVIII   (50 5 1 1 1)               = 58
+// MCMXCIV (1000 100 1000 10 100 1 5) = 1994
+// 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.
+
+public class Solution {
+    public int romanToInt(String s) {
+        ArrayList<Integer> l = new ArrayList<>();
+        for (char c : s.toCharArray())
+            switch (c) {
+                case 'I':
+                    l.add(1);
+                    break;
+                case 'V':
+                    l.add(5);
+                    break;
+                case 'X':
+                    l.add(10);
+                    break;
+                case 'L':
+                    l.add(50);
+                    break;
+                case 'C':
+                    l.add(100);
+                    break;
+                case 'D':
+                    l.add(500);
+                    break;
+                case 'M':
+                    l.add(1000);
+                    break;
+                default:
+                    break;
+            }
+
+        for (int i = 0; i < l.size(); i++)
+            if (i + 1 < l.size() && l.get(i) < l.get(i + 1)) {
+                l.set(i + 1, l.get(i + 1) - l.get(i));
+                l.remove(i);
+            }
+
+        int sum = 0;
+        for (int n : l) sum += n;
+        return sum;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(new Solution().romanToInt("MCMXCIV"));
+    }
+}

src/problem_0014_longest_common_prefix/Solution.java

@@ -0,0 +1,29 @@
+package problem_0014_longest_common_prefix;
+
+import java.util.Arrays;
+
+// LINK: https://leetcode.com/problems/longest-common-prefix/
+
+public class Solution {
+    public String longestCommonPrefix(String[] strs) {
+        // MORE ABOUT STREAMS: https://www.geeksforgeeks.org/stream-in-java/
+        String shortestStr = Arrays.stream(strs)
+                .reduce(strs[0], (res, s) -> s.length() < res.length() ? s : res);
+
+        StringBuilder prefix = new StringBuilder();
+
+        outerloop:
+        for (int i = 0; i < shortestStr.length(); i++) {
+            for (String s : strs)
+                if (s.charAt(i) != shortestStr.charAt(i)) break outerloop;
+            prefix.append(shortestStr.charAt(i));
+        }
+
+        return String.valueOf(prefix);
+    }
+
+    public static void main(String[] args) {
+        String[] strs = {"flower", "flow", "flight"};
+        System.out.println(new Solution().longestCommonPrefix(strs));
+    }
+}