Initial commit

Author: andrewbayd

.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

.gitignore

@@ -0,0 +1,82 @@
+##############################
+## Java
+##############################
+.mtj.tmp/
+*.class
+*.jar
+*.war
+*.ear
+*.nar
+hs_err_pid*
+
+##############################
+## Maven
+##############################
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+pom.xml.bak
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+.mvn/wrapper/maven-wrapper.jar
+
+##############################
+## Gradle
+##############################
+bin/
+build/
+.gradle
+.gradletasknamecache
+gradle-app.setting
+!gradle-wrapper.jar
+
+##############################
+## IntelliJ
+##############################
+out/
+.idea/
+.idea_modules/
+*.iml
+*.ipr
+*.iws
+
+##############################
+## Eclipse
+##############################
+.settings/
+tmp/
+.metadata
+.classpath
+.project
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.loadpath
+.factorypath
+
+##############################
+## NetBeans
+##############################
+nbproject/private/
+nbbuild/
+dist/
+nbdist/
+nbactions.xml
+nb-configuration.xml
+
+##############################
+## Visual Studio Code
+##############################
+.vscode/
+.code-workspace
+
+##############################
+## OS X
+##############################
+.DS_Store

README.md

@@ -0,0 +1,2 @@
+# leetcode-solutions-java
+ 

src/com/andrewbayd/FirstUniqueCharInAString.java

@@ -0,0 +1,30 @@
+package com.andrewbayd;
+
+import java.util.HashMap;
+
+public class FirstUniqueCharInAString {
+
+    /*
+    Given a string s, find the first non-repeating character in it and return its index.
+    If it does not exist, return -1.
+    The full description: https://leetcode.com/problems/first-unique-character-in-a-string/
+     */
+
+    public static int firstUniqChar(String s) {
+        HashMap<Character, Integer> letters = new HashMap<>();
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            letters.put(c, letters.getOrDefault(c, 0) + 1);
+        }
+        for (int i = 0; i < s.length(); i++) {
+            if (letters.get(s.charAt(i)) == 1) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+        assert firstUniqChar("leetcode") == 0;
+    }
+}

src/com/andrewbayd/FizzBuzz.java

@@ -0,0 +1,27 @@
+package com.andrewbayd;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class FizzBuzz {
+
+    /*
+    Classic FizzBuzz: https://leetcode.com/problems/fizz-buzz/
+     */
+
+    public static List<String> fizzBuzz(int n) {
+        List<String> result = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            if (i % 3 == 0 && i % 5 == 0) result.add("FizzBuzz");
+            else if (i % 3 == 0) result.add("Fizz");
+            else if (i % 5 == 0) result.add("Buzz");
+            else result.add("" + i);
+        }
+        return result;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(fizzBuzz(3)); //-> [1, 2, Fizz]
+        System.out.println(fizzBuzz(15)); //-> [1, 2, Fizz, 4, Buzz, Fizz, 7, 8, Fizz, Buzz, 11, Fizz, 13, 14, FizzBuzz]
+    }
+}

src/com/andrewbayd/RomanToInteger.java

@@ -0,0 +1,43 @@
+package com.andrewbayd;
+
+import java.util.HashMap;
+
+public class RomanToInteger {
+
+    /*
+    Convert given roman numeral into integer.
+    The full description: https://leetcode.com/problems/roman-to-integer/
+     */
+
+    public static int romanToInt(String s) {
+
+        HashMap<Character, Integer> roman = new HashMap<>();
+        roman.put('I', 1);
+        roman.put('V', 5);
+        roman.put('X', 10);
+        roman.put('L', 50);
+        roman.put('C', 100);
+        roman.put('D', 500);
+        roman.put('M', 1000);
+
+        int n = s.length();
+        int result = 0;
+
+        for (int i = 0; i < n; i++) {
+            char c = s.charAt(i);
+            if ((i != n - 1) && (roman.get(c) < roman.get(s.charAt(i + 1)))) {
+                result -= roman.get(c);
+            } else {
+                result += roman.get(c);
+            }
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        assert romanToInt("III") == 3;
+        assert romanToInt("LVIII") == 58;
+        assert romanToInt("MCMXCIV") == 1994;
+    }
+}

src/com/andrewbayd/Sqrt.java

@@ -0,0 +1,39 @@
+package com.andrewbayd;
+
+public class Sqrt {
+
+    /*
+    Given a non-negative integer x, compute and return the square root of x.
+    Since the return type is an integer, the decimal digits are truncated, and only the integer part of the result is returned.
+    Note: You are not allowed to use any built-in exponent function or operator, such as pow(x, 0.5) or x ** 0.5.
+    The full description: https://leetcode.com/problems/sqrtx/
+    */
+
+    public static int mySqrt(int x) {
+        if (x == 0) return 0;
+        if (x < 4) return 1;
+
+        int start = 0;
+        int end = x;
+        int res = 2;
+
+        while (start < end) {
+            long mid = (start + end) / 2;
+            if ((mid*mid <= x) && ((mid+1) * (mid+1) > x)) {
+                return (int)mid;
+            } else if (mid*mid > x) {
+                end = (int)mid;
+            } else {
+                start = (int)mid;
+            }
+        }
+        return res;
+    }
+
+    public static void main(String[] args) {
+        assert mySqrt(0) == 0;
+        assert mySqrt(3) == 1;
+        assert mySqrt(8) == 2;
+        assert mySqrt(2147395599) == 46339;
+    }
+}

src/com/andrewbayd/TwoSum.java

@@ -0,0 +1,35 @@
+package com.andrewbayd;
+
+import java.util.Arrays;
+import java.util.HashMap;
+
+public class TwoSum {
+
+    /*
+    Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+    You may assume that each input would have exactly one solution, and you may not use the same element twice.
+    You can return the answer in any order.
+    The full description: https://leetcode.com/problems/two-sum/
+     */
+
+    public static int[] twoSum(int[] nums, int target) {
+        int[] result = new int[2];
+        HashMap<Integer, Integer> passed = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++){
+            if (passed.containsKey(target - nums[i])) {
+                result[0] = passed.get(target - nums[i]);
+                result[1] = i;
+                break;
+            }
+            passed.put(nums[i], i);
+        }
+
+        return result;
+    }
+
+    public static void main(String[] args) {
+        int[] arr = {2, 11, 7, 15};
+        System.out.println(Arrays.toString(twoSum(arr, 9))); //-> [0, 2]
+    }
+}

src/com/andrewbayd/mergeTwoSortedLists/ListNode.java

@@ -0,0 +1,9 @@
+package com.andrewbayd.mergeTwoSortedLists;
+
+public class ListNode {
+    int val;
+    ListNode next;
+    ListNode() {}
+    ListNode(int val) { this.val = val; }
+    ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+}

src/com/andrewbayd/mergeTwoSortedLists/MergeTwoSortedLists.java

@@ -0,0 +1,28 @@
+package com.andrewbayd.mergeTwoSortedLists;
+
+public class MergeTwoSortedLists {
+    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
+        if (list1 == null) return list2;
+        if (list2 == null) return list1;
+
+        ListNode merged = new ListNode();
+        ListNode result = merged;
+
+        while (list1 != null && list2 != null) {
+            if (list1.val < list2.val) {
+                merged.next = new ListNode(list1.val);
+                list1 = list1.next;
+            } else {
+                merged.next = new ListNode(list2.val);
+                list2 = list2.next;
+            }
+            merged = merged.next;
+        }
+
+        if (list1 != null) merged.next = new ListNode(list1.val, list1.next);
+        if (list2 != null) merged.next = new ListNode(list2.val, list2.next);
+
+
+        return result.next;
+    }
+}