diff --git a/10 Days of Statistics/Day 2 - Basic Probability/Solution.txt b/10 Days of Statistics/Day 2 - Basic Probability/Solution.txt
index 1786d66..ffd2411 100644
--- a/10 Days of Statistics/Day 2 - Basic Probability/Solution.txt	
+++ b/10 Days of Statistics/Day 2 - Basic Probability/Solution.txt	
@@ -7,7 +7,7 @@ Answer: 5/6
 
 There are 6 possibilities on each die. On 2 dice, there are 6 * 6 = 36 possibilities
 
-There are 6 cases where sum >= 10: (4,6), (5,6), (6,6), (5,5), (5,6), (6,6)
+There are 6 cases where sum >= 10: (4,6), (5,5), (5,6), (6,4), (6,5), (6,6)
 
 This gives us probability(sum >= 10) = 6/36 = 1/6
 
diff --git a/10 Days of Statistics/Day 6 - The Central Limit Theorem I/Solution.java b/10 Days of Statistics/Day 6 - The Central Limit Theorem I/Solution.java
index e177b39..13cf6a6 100644
--- a/10 Days of Statistics/Day 6 - The Central Limit Theorem I/Solution.java	
+++ b/10 Days of Statistics/Day 6 - The Central Limit Theorem I/Solution.java	
@@ -2,8 +2,6 @@
 //     Github: github.com/rshaghoulian
 // HackerRank: hackerrank.com/rshaghoulian
 
-/* This HackerRank problem has a buggy tutorial (formula is incorrect) and a buggy
-   solution (uses the incorrect formula) Hopefully they fix this issue soon.    */
 public class Solution {
 
     public static void main(String[] args) {
@@ -12,13 +10,9 @@ public class Solution {
         double maxWeight = 9800;
         int    n         = 49;
         
-        double samplesMean = mean * n;
-        
-        /* this INCORRECT formula (based off HackerRank tutorial) passes HackerRank tests */
-        double samplesSTD  = std * Math.sqrt(n); 
-        
-        /* this is the correct formula (which currently wont pass HackerRank tests) */
-        // double samplesSTD = std / Math.sqrt(n); 
+        /* Formulas are from problem's tutorial */
+        double samplesMean = n * mean;
+        double samplesSTD  = Math.sqrt(n) * std;
         
         System.out.format("%.4f", cumulative(samplesMean, samplesSTD, maxWeight));
     }
diff --git a/10 Days of Statistics/Day 6 - The Central Limit Theorem II/Solution.java b/10 Days of Statistics/Day 6 - The Central Limit Theorem II/Solution.java
index 41b88ab..522da68 100644
--- a/10 Days of Statistics/Day 6 - The Central Limit Theorem II/Solution.java	
+++ b/10 Days of Statistics/Day 6 - The Central Limit Theorem II/Solution.java	
@@ -10,14 +10,10 @@ public class Solution {
         double mean        = 2.4;
         double std         = 2;
 
-        double samplesMean = mean * n;
+        /* Formulas are from problem's tutorial */
+        double samplesMean = n * mean;
+        double samplesSTD  = Math.sqrt(n) * std;
 
-        /* this INCORRECT formula (based off HackerRank tutorial) passes HackerRank tests */
-        double samplesSTD  = std * Math.sqrt(n); 
-        
-        /* this is the correct formula (which currently wont pass HackerRank tests) */
-        // double samplesSTD = std / Math.sqrt(n); 
-        
         System.out.format("%.4f", cumulative(samplesMean, samplesSTD, ticketsLeft));
     }
     
diff --git a/10 Days of Statistics/Day 9 - Multiple Linear Regression/Solution.java b/10 Days of Statistics/Day 9 - Multiple Linear Regression/Solution.java
new file mode 100644
index 0000000..21928b1
--- /dev/null
+++ b/10 Days of Statistics/Day 9 - Multiple Linear Regression/Solution.java	
@@ -0,0 +1,179 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.util.Arrays;
+
+public class Solution {
+    public static void main(String[] args) {
+        /* Read input: Create and fill X,Y arrays */
+        Scanner scan = new Scanner(System.in);
+        int m = scan.nextInt();
+        int n = scan.nextInt();
+        double [][] X = new double[n][m + 1];
+        double [][] Y   = new double[n][1];
+        for (int row = 0; row < n; row++) {
+            X[row][0] = 1;
+            for (int col = 1; col <= m; col++) {
+                X[row][col] = scan.nextDouble();
+            }
+            Y[row][0] = scan.nextDouble();
+        }
+
+        /* Calculate B */
+        double [][] xtx    = multiply(transpose(X),X);
+        double [][] xtxInv = invert(xtx);
+        double [][] xty    = multiply(transpose(X), Y);
+        double [][] B      = multiply(xtxInv, xty);
+        
+        int sizeB = B.length;
+        
+        /* Calculate and print values for the "q" feature sets */
+        int q = scan.nextInt();
+        for (int i = 0; i < q; i++) {
+            double result = B[0][0];
+            for (int row = 1; row < sizeB; row++) {
+                result += scan.nextDouble() * B[row][0];
+            }
+            System.out.println(result);
+        }
+    }
+    
+    /* Multiplies 2 matrices in O(n^3) time */
+    public static double[][] multiply(double [][] A, double [][] B) {
+        int aRows = A.length;
+        int aCols = A[0].length;
+        int bRows = B.length;
+        int bCols = B[0].length;
+        
+        double [][] C = new double[aRows][bCols];
+        int cRows = C.length;
+        int cCols = C[0].length;
+        
+        for (int row = 0; row < cRows; row++) {
+            for (int col = 0; col < cCols; col++) {
+                for (int k = 0; k < aCols; k++) {
+                    C[row][col] += A[row][k] * B[k][col];
+                }
+            }
+        }
+        return C;
+    }
+    
+    public static double[][] transpose(double [][] matrix) {
+        /* Create new array with switched dimensions */
+        int originalRows = matrix.length;
+        int originalCols = matrix[0].length;
+        int rows = originalCols;
+        int cols = originalRows;
+        double [][] result = new double[rows][cols];
+        
+        /* Fill our new 2D array */
+        for (int row = 0; row < originalRows; row++) {
+            for (int col = 0; col < originalCols; col++) {
+                result[col][row] = matrix[row][col];
+            }
+        }
+        return result;
+    }
+    
+    /******************************************************************/
+    /* Matrix Inversion code (the 2 functions below) are from:        */
+    /*   http://www.sanfoundry.com/java-program-find-inverse-matrix/  */
+    /******************************************************************/
+
+    public static double[][] invert(double a[][]) 
+    {
+        int n = a.length;
+        double x[][] = new double[n][n];
+        double b[][] = new double[n][n];
+        int index[] = new int[n];
+        for (int i=0; i<n; ++i) 
+            b[i][i] = 1;
+ 
+         // Transform the matrix into an upper triangle
+        gaussian(a, index);
+ 
+         // Update the matrix b[i][j] with the ratios stored
+        for (int i=0; i<n-1; ++i)
+            for (int j=i+1; j<n; ++j)
+                for (int k=0; k<n; ++k)
+                    b[index[j]][k]
+                            -= a[index[j]][i]*b[index[i]][k];
+ 
+         // Perform backward substitutions
+        for (int i=0; i<n; ++i) 
+        {
+            x[n-1][i] = b[index[n-1]][i]/a[index[n-1]][n-1];
+            for (int j=n-2; j>=0; --j) 
+            {
+                x[j][i] = b[index[j]][i];
+                for (int k=j+1; k<n; ++k) 
+                {
+                    x[j][i] -= a[index[j]][k]*x[k][i];
+                }
+                x[j][i] /= a[index[j]][j];
+            }
+        }
+        return x;
+    }
+ 
+        // Method to carry out the partial-pivoting Gaussian
+        // elimination.  Here index[] stores pivoting order.
+ 
+    public static void gaussian(double a[][], int index[]) 
+    {
+        int n = index.length;
+        double c[] = new double[n];
+ 
+         // Initialize the index
+        for (int i=0; i<n; ++i) 
+            index[i] = i;
+ 
+         // Find the rescaling factors, one from each row
+        for (int i=0; i<n; ++i) 
+        {
+            double c1 = 0;
+            for (int j=0; j<n; ++j) 
+            {
+                double c0 = Math.abs(a[i][j]);
+                if (c0 > c1) c1 = c0;
+            }
+            c[i] = c1;
+        }
+ 
+         // Search the pivoting element from each column
+        int k = 0;
+        for (int j=0; j<n-1; ++j) 
+        {
+            double pi1 = 0;
+            for (int i=j; i<n; ++i) 
+            {
+                double pi0 = Math.abs(a[index[i]][j]);
+                pi0 /= c[index[i]];
+                if (pi0 > pi1) 
+                {
+                    pi1 = pi0;
+                    k = i;
+                }
+            }
+ 
+           // Interchange rows according to the pivoting order
+            int itmp = index[j];
+            index[j] = index[k];
+            index[k] = itmp;
+            for (int i=j+1; i<n; ++i)   
+            {
+                double pj = a[index[i]][j]/a[index[j]][j];
+ 
+                 // Record pivoting ratios below the diagonal
+                a[index[i]][j] = pj;
+ 
+                 // Modify other elements accordingly
+                for (int l=j+1; l<n; ++l)
+                    a[index[i]][l] -= pj*a[index[j]][l];
+            }
+        }
+    }
+}
diff --git a/30 Days of Code/Day 10 - Binary Numbers/Solution.java b/30 Days of Code/Day 10 - Binary Numbers/Solution.java
new file mode 100644
index 0000000..37067dd
--- /dev/null
+++ b/30 Days of Code/Day 10 - Binary Numbers/Solution.java	
@@ -0,0 +1,29 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+public class Solution {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int n = scan.nextInt();
+        scan.close();
+        System.out.println(consecutiveOnes(n));
+    }
+    
+    public static int consecutiveOnes(int n) {
+        int count = 0;
+        int max   = 0;
+        while (n > 0) {
+            if (n % 2 == 1) {
+                count++;
+                max = Math.max(max, count);
+            } else {
+                count = 0;
+            }
+            n = n >> 1;
+        }
+        return max;
+    }
+}
diff --git a/30 Days of Code/Day 11 - 2D Arrays/Solution.java b/30 Days of Code/Day 11 - 2D Arrays/Solution.java
new file mode 100644
index 0000000..645294a
--- /dev/null
+++ b/30 Days of Code/Day 11 - 2D Arrays/Solution.java	
@@ -0,0 +1,39 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+public class Solution {
+
+    public static void main(String [] args) {
+        Scanner scan = new Scanner(System.in);
+        int arr[][] = new int[6][6];
+        for (int row = 0; row < 6; row++) {
+            for (int col = 0; col < 6; col++) {
+                arr[row][col] = scan.nextInt();
+            }
+        }
+        scan.close();
+        
+        System.out.println(maxHourglass(arr));
+    }
+    
+    public static int maxHourglass(int [][] arr) {
+        int max = Integer.MIN_VALUE;
+        for (int row = 0; row < 4; row++) {
+            for (int col = 0; col < 4; col++) {
+                int sum = findSum(arr, row, col);
+                max = Math.max(max, sum);
+            }
+        }
+        return max;
+    }
+    
+    private static int findSum(int [][] arr, int r, int c) {
+        int sum = arr[r+0][c+0] + arr[r+0][c+1] + arr[r+0][c+2] 
+                                + arr[r+1][c+1] + 
+                  arr[r+2][c+0] + arr[r+2][c+1] + arr[r+2][c+2];
+        return sum;
+    }
+}
diff --git a/30 Days of Code/Day 12 - Inheritance/Solution.java b/30 Days of Code/Day 12 - Inheritance/Solution.java
new file mode 100644
index 0000000..1867e93
--- /dev/null
+++ b/30 Days of Code/Day 12 - Inheritance/Solution.java	
@@ -0,0 +1,51 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+class Student extends Person{
+    private int[] testScores;
+
+    /*  
+    *   Class Constructor
+    *   
+    *   @param firstName - A string denoting the Person's first name.
+    *   @param lastName - A string denoting the Person's last name.
+    *   @param id - An integer denoting the Person's ID number.
+    *   @param scores - An array of integers denoting the Person's test scores.
+    */
+    public Student(String firstName, String lastName, int id, int [] scores) {
+        super(firstName, lastName, id);
+        testScores = scores;
+    }
+
+    /*  
+    *   Method Name: calculate
+    *   @return A character denoting the grade.
+    */
+    public char calculate() {
+        double average = 0;
+        for (int score : testScores) {
+            average += score;
+        }
+        average /= testScores.length;
+        
+        if  (average >= 90) {
+            return 'O';
+        }
+        else if (average >= 80) {
+            return 'E';
+        }
+        else if (average >= 70) {
+            return 'A';
+        }
+        else if (average >= 55) {
+            return 'P';
+        }
+        else if (average >= 40) {
+            return 'D';
+        }
+        else {
+            return 'T';
+        }
+    }
+}
diff --git a/30 Days of Code/Day 13 - Abstract Classes/Solution.java b/30 Days of Code/Day 13 - Abstract Classes/Solution.java
new file mode 100644
index 0000000..434338e
--- /dev/null
+++ b/30 Days of Code/Day 13 - Abstract Classes/Solution.java	
@@ -0,0 +1,18 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+class MyBook extends Book {
+    int price;
+    
+    MyBook(String title, String author, int price) {
+        super(title, author);
+        this.price = price;
+    }
+    
+    void display() {
+        System.out.println("Title: " + title);
+        System.out.println("Author: " + author);
+        System.out.println("Price: " + price);
+    }
+}
diff --git a/30 Days of Code/Day 14 - Scope/Solution.java b/30 Days of Code/Day 14 - Scope/Solution.java
new file mode 100644
index 0000000..08779e5
--- /dev/null
+++ b/30 Days of Code/Day 14 - Scope/Solution.java	
@@ -0,0 +1,24 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+class Difference {
+    private int[] elements;
+    public int maximumDifference;
+    
+    Difference (int [] elements) {
+        this.elements = elements;
+    }
+
+    // O(n) runtime. O(1) space
+    void computeDifference() {
+        maximumDifference = 0;
+        int min = elements[0];
+        int max = elements[0];
+        for (int num : elements) {
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+        }
+        maximumDifference = max - min;
+    }
+} // End of Difference class
diff --git a/30 Days of Code/Day 15 - Linked List/Solution.java b/30 Days of Code/Day 15 - Linked List/Solution.java
new file mode 100644
index 0000000..223ace4
--- /dev/null
+++ b/30 Days of Code/Day 15 - Linked List/Solution.java	
@@ -0,0 +1,16 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+public static Node insert(Node head, int data) {
+    if (head == null) {
+        return new Node(data);
+    } else {
+        Node n = head;
+        while (n.next != null) {
+            n = n.next;
+        }
+        n.next = new Node(data);
+        return head;
+    }
+}
diff --git a/Algorithms/Implementation/Mini-Max Sum/Solution.java b/Algorithms/Implementation/Mini-Max Sum/Solution.java
new file mode 100644
index 0000000..cc93e9d
--- /dev/null
+++ b/Algorithms/Implementation/Mini-Max Sum/Solution.java	
@@ -0,0 +1,24 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+//          Runtime: O(n)     
+// Space Complexity: O(1)
+public class Solution {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        long sum = 0;
+        long min = Integer.MAX_VALUE;
+        long max = Integer.MIN_VALUE;
+        for (int i = 0; i < 5; i++) {
+            long num = scan.nextLong();
+            sum += num;
+            min = Math.min(min, num);
+            max = Math.max(max, num);
+        }
+        scan.close();
+        System.out.print((sum - max) + " " + (sum - min));
+    }
+}
diff --git a/Algorithms/Warmup/Circular Array Rotation/Solution.java b/Algorithms/Warmup/Circular Array Rotation/Solution.java
new file mode 100644
index 0000000..d157cee
--- /dev/null
+++ b/Algorithms/Warmup/Circular Array Rotation/Solution.java	
@@ -0,0 +1,55 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.util.Arrays;
+
+/*           Runtime: O(n)     
+    Space Complexity: O(1) by doing an "in place" rotation
+*/
+public class Solution {
+    public static void main(String[] args) {
+        /* Read input and create array */
+        Scanner scan = new Scanner(System.in);
+        int n = scan.nextInt();
+        int k = scan.nextInt();
+        int q = scan.nextInt();
+        int [] array = new int[n];
+        for (int i = 0; i < n; i++) {
+            array[i] = scan.nextInt();
+        }
+        
+        /* Rotate array (in place) using 3 reverse operations */
+        k = k % n; // to account for cases where k > n
+        reverse(array, 0, array.length - 1);
+        reverse(array, 0, k - 1);
+        reverse(array, k, array.length - 1);
+        
+        /* Print output */
+        for (int i = 0; i < q; i++) {
+            int m = scan.nextInt();
+            System.out.println(array[m]);
+        }
+        scan.close();
+    }
+    
+    /* Reverses array from "start" to "end" inclusive */
+    private static void reverse(int [] array, int start, int end) {
+        if (array == null || start < 0 || start >= array.length || 
+            end < 0 || end >= array.length || start >= end) {
+            return;
+        }
+        int mid = (start + end) / 2;
+        for (int i = start; i <= mid; i++) {
+            int offset = i - start;
+            swap(array, start + offset, end - offset);
+        }
+    }
+
+    private static void swap (int [] array, int i, int j) {
+        int temp = array[i];
+        array[i] = array[j];
+        array[j] = temp;
+    }
+}
diff --git a/Algorithms/Warmup/Time Conversion/Solution.java b/Algorithms/Warmup/Time Conversion/Solution.java
new file mode 100644
index 0000000..9bee705
--- /dev/null
+++ b/Algorithms/Warmup/Time Conversion/Solution.java	
@@ -0,0 +1,26 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+public class Solution {
+    public static void main(String[] args) {
+        /* Read and save input */
+        Scanner scan = new Scanner(System.in);
+        String str = scan.nextLine();
+        scan.close();
+        int hours   = Integer.valueOf(str.substring(0,2));
+        int minutes = Integer.valueOf(str.substring(3,5));
+        int seconds = Integer.valueOf(str.substring(6,8));
+
+        /* Convert to 24-hour format */
+        if (str.substring(8, 10).equals("PM") && hours != 12) {
+            hours += 12;
+        } else if (str.substring(8, 10).equals("AM") && hours == 12) {
+            hours = 0;
+        }
+        
+        System.out.format("%02d:%02d:%02d", hours, minutes, seconds);        
+    }
+}
diff --git a/Cracking the Coding Interview/Data Structures/Arrays - Left Rotation/Solution.java b/Cracking the Coding Interview/Data Structures/Arrays - Left Rotation/Solution.java
index e11a435..15f5725 100644
--- a/Cracking the Coding Interview/Data Structures/Arrays - Left Rotation/Solution.java	
+++ b/Cracking the Coding Interview/Data Structures/Arrays - Left Rotation/Solution.java	
@@ -21,12 +21,12 @@ public class Solution {
         scan.close();
         
         /* Rotate array (in place) using 3 reverse operations */
+        numRotations %= size; // to account for numRotations > size
         int rotationSpot = size - 1 - numRotations;
         reverse(array, 0, size - 1);
         reverse(array, 0, rotationSpot);
         reverse(array, rotationSpot + 1, size - 1);
         
-        
         /* Print rotated array */
         for (int i = 0; i < size; i++) {
             System.out.print(array[i] + " ");
@@ -35,7 +35,13 @@ public class Solution {
     
     /* Reverses array from "start" to "end" inclusive */
     private static void reverse(int [] array, int start, int end) {
-        for (int offset = 0; offset <= (end - start) / 2; offset++) {
+        if (array == null || start < 0 || start >= array.length || 
+            end < 0 || end >= array.length || start >= end) {
+            return;
+        }
+        int mid = (start + end) / 2;
+        for (int i = start; i <= mid; i++) {
+            int offset = i - start;
             swap(array, start + offset, end - offset);
         }
     }
@@ -46,3 +52,4 @@ public class Solution {
         array[j] = temp;
     }
 }
+
diff --git a/Java/BigNumber/Java BigDecimal/Solution.java b/Java/BigNumber/Java BigDecimal/Solution.java
new file mode 100644
index 0000000..f0cefa6
--- /dev/null
+++ b/Java/BigNumber/Java BigDecimal/Solution.java	
@@ -0,0 +1,35 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.math.BigDecimal;
+import java.util.*;
+class Solution{
+    public static void main(String []args){
+        //Input
+        Scanner sc= new Scanner(System.in);
+        int n=sc.nextInt();
+        String []s=new String[n+2];
+        for(int i=0;i<n;i++){
+            s[i]=sc.next();
+        }
+        sc.close();
+
+        Comparator<String> customComparator = new Comparator<String>() {
+            @Override
+            public int compare(String s1, String s2) {
+                BigDecimal a = new BigDecimal(s1);
+                BigDecimal b = new BigDecimal(s2);
+                return b.compareTo(a); // descending order
+            }
+        };
+
+        Arrays.sort(s, 0, n, customComparator);
+        
+        //Output
+        for(int i=0;i<n;i++)
+        {
+            System.out.println(s[i]);
+        }
+    }
+}
diff --git a/Java/BigNumber/Java BigInteger/Solution.java b/Java/BigNumber/Java BigInteger/Solution.java
new file mode 100644
index 0000000..f792e7a
--- /dev/null
+++ b/Java/BigNumber/Java BigInteger/Solution.java	
@@ -0,0 +1,16 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.math.BigInteger;
+
+public class Solution {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        BigInteger a = new BigInteger(scan.next());
+        BigInteger b = new BigInteger(scan.next());
+        System.out.println(a.add(b));
+        System.out.println(a.multiply(b));
+    }
+}
diff --git a/Java/BigNumber/Java Primality Test/Solution.java b/Java/BigNumber/Java Primality Test/Solution.java
new file mode 100644
index 0000000..1d79a7a
--- /dev/null
+++ b/Java/BigNumber/Java Primality Test/Solution.java	
@@ -0,0 +1,27 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.math.BigInteger;
+
+/*
+
+I use isProbablePrime() with certainty = 10 to achieve 99.9% accuracy. 
+However, even certainty = 1 (which achieves 50% accuracy) is enough to 
+pass the HackerRank test cases.
+
+isProbablePrime() is always 100% certain if it tells you if a number 
+is "not prime". If it says "prime", it's only 99.9% certain. It may be 
+the case that it just hasn't found a prime number number that divides 
+the BigInteger yet.
+
+*/
+public class Solution {
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        BigInteger n = scan.nextBigInteger();
+        scan.close();
+        System.out.println(n.isProbablePrime(10) ? "prime" : "not prime");
+    }
+}
diff --git a/Java/Data Structures/Java 1D Array (Part 2)/Solution.java b/Java/Data Structures/Java 1D Array (Part 2)/Solution.java
new file mode 100644
index 0000000..d120c47
--- /dev/null
+++ b/Java/Data Structures/Java 1D Array (Part 2)/Solution.java	
@@ -0,0 +1,44 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.util.HashMap;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int T = scan.nextInt();
+        for (int testCase = 0; testCase < T; testCase++) {
+            int n = scan.nextInt();
+            int m = scan.nextInt();
+            
+            /* Create array of values */
+            int [] array = new int[n];
+            for (int i = 0; i < n; i++) {
+                array[i] = scan.nextInt();
+            }
+            
+            System.out.println(solvable(array, m, 0) ? "YES" : "NO");
+        }
+    }
+    
+    /* Basically a depth-first search (DFS). 
+       Marks each array value as 1 when visiting (Side-effect: alters array) */
+    private static boolean solvable(int [] array, int m, int i) {
+        /* Base Cases */
+        if (i < 0 || array[i] == 1) {
+            return false;
+        } else if (i + 1 >= array.length || i + m >= array.length) {
+            return true;
+        }
+        
+        array[i] = 1; // marks as visited
+
+        /* Recursive Cases */
+        return solvable(array, m, i - 1) || 
+               solvable(array, m, i + 1) || 
+               solvable(array, m, i + m);
+    }
+}
diff --git a/Java/Data Structures/Java 1D Array/Solution.java b/Java/Data Structures/Java 1D Array/Solution.java
new file mode 100644
index 0000000..94e1583
--- /dev/null
+++ b/Java/Data Structures/Java 1D Array/Solution.java	
@@ -0,0 +1,26 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+       
+        Scanner scan = new Scanner(System.in);
+        int n = scan.nextInt();
+
+        int [] a = new int[n];
+        for (int i = 0 ; i < n; i++) {
+            a[i] = scan.nextInt();
+        }
+
+        scan.close();
+
+        // Prints each sequential element in array a
+        for (int i = 0; i < a.length; i++) {
+            System.out.println(a[i]);
+        }
+    }
+}
diff --git a/Java/Data Structures/Java 2D Array/Solution.java b/Java/Data Structures/Java 2D Array/Solution.java
new file mode 100644
index 0000000..645294a
--- /dev/null
+++ b/Java/Data Structures/Java 2D Array/Solution.java	
@@ -0,0 +1,39 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+public class Solution {
+
+    public static void main(String [] args) {
+        Scanner scan = new Scanner(System.in);
+        int arr[][] = new int[6][6];
+        for (int row = 0; row < 6; row++) {
+            for (int col = 0; col < 6; col++) {
+                arr[row][col] = scan.nextInt();
+            }
+        }
+        scan.close();
+        
+        System.out.println(maxHourglass(arr));
+    }
+    
+    public static int maxHourglass(int [][] arr) {
+        int max = Integer.MIN_VALUE;
+        for (int row = 0; row < 4; row++) {
+            for (int col = 0; col < 4; col++) {
+                int sum = findSum(arr, row, col);
+                max = Math.max(max, sum);
+            }
+        }
+        return max;
+    }
+    
+    private static int findSum(int [][] arr, int r, int c) {
+        int sum = arr[r+0][c+0] + arr[r+0][c+1] + arr[r+0][c+2] 
+                                + arr[r+1][c+1] + 
+                  arr[r+2][c+0] + arr[r+2][c+1] + arr[r+2][c+2];
+        return sum;
+    }
+}
diff --git a/Java/Data Structures/Java ArrayList/Solution.java b/Java/Data Structures/Java ArrayList/Solution.java
new file mode 100644
index 0000000..e168c0a
--- /dev/null
+++ b/Java/Data Structures/Java ArrayList/Solution.java	
@@ -0,0 +1,42 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.util.ArrayList;
+
+/* We need a 2-D array to solve this problem. We can't use an int[][] since we
+   don't know the initial dimensions. So, we use ArrayList<ArrayList<Integer>> */
+public class Solution {
+
+    public static void main(String[] args) {
+        Scanner scan = new Scanner(System.in);
+        int n = scan.nextInt();
+                
+        /* Save numbers in 2-D ArrayList */
+        ArrayList<ArrayList<Integer>> list = new ArrayList<>();
+        for (int row = 0; row < n; row++) {
+            int d = scan.nextInt();
+            ArrayList<Integer> numbers = new ArrayList<>();
+            for (int col = 0; col < d; col++) {
+                numbers.add(scan.nextInt());
+            }
+            list.add(numbers);
+        }
+        
+        /* Answer the queries */
+        int q = scan.nextInt();
+        for (int i = 0; i < q; i++) {
+            int x = scan.nextInt();
+            int y = scan.nextInt();
+            try {
+                int num = list.get(x-1).get(y-1);
+                System.out.println(num);
+            } catch (IndexOutOfBoundsException e) {
+                System.out.println("ERROR!");
+            }
+        }
+        
+        scan.close();        
+    }
+}
diff --git a/Java/Data Structures/Java Subarray/Solution.java b/Java/Data Structures/Java Subarray/Solution.java
new file mode 100644
index 0000000..9cf5d30
--- /dev/null
+++ b/Java/Data Structures/Java Subarray/Solution.java	
@@ -0,0 +1,37 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        /* Read and save input */
+        Scanner scan = new Scanner(System.in);
+        int size = scan.nextInt();
+        int [] array = new int[size];        
+        for (int i = 0; i < size; i++) {
+            array[i] = scan.nextInt();
+        }
+        scan.close();
+        
+        System.out.println(negativeSubarrays(array));
+    }
+    
+    /* O(n^2) runtime */
+    private static int negativeSubarrays(int [] array) {
+        int count = 0;
+        int sum   = 0;
+        for (int i = 0; i < array.length; i++) {
+            for (int j = i; j < array.length; j++) {
+                sum += array[j];
+                if (sum < 0) {
+                    count++;
+                }
+            }
+            sum = 0;
+        }
+        return count;
+    }
+}
diff --git a/Java/Strings/Java Regex 3 - Username Checker/Solution.java b/Java/Strings/Java Regex 3 - Username Checker/Solution.java
new file mode 100644
index 0000000..a8264af
--- /dev/null
+++ b/Java/Strings/Java Regex 3 - Username Checker/Solution.java	
@@ -0,0 +1,31 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.io.*;
+import java.util.*;
+import java.text.*;
+import java.math.*;
+import java.util.regex.*;
+
+public class Solution {
+   public static void main(String[] args){
+      Scanner in = new Scanner(System.in);
+      int testCases = Integer.parseInt(in.nextLine());
+      while(testCases>0){
+         String username = in.nextLine();
+         //String pattern = Complete this line in the editable area below  
+         String pattern = "^[a-zA-Z]\\w{7,29}$";
+
+         Pattern r = Pattern.compile(pattern);
+         Matcher m = r.matcher(username);
+          
+         if (m.find( )) {
+            System.out.println("Valid");
+         } else {
+            System.out.println("Invalid");
+         }
+         testCases--;
+      }
+   }
+}
diff --git a/Java/Strings/Pattern Syntax Checker/Solution.java b/Java/Strings/Pattern Syntax Checker/Solution.java
index 0775d75..aa9be88 100644
--- a/Java/Strings/Pattern Syntax Checker/Solution.java	
+++ b/Java/Strings/Pattern Syntax Checker/Solution.java	
@@ -1,7 +1,3 @@
-//     Author: Rodney Shaghoulian
-//     Github: github.com/rshaghoulian
-// HackerRank: hackerrank.com/rshaghoulian
-
 import java.util.Scanner;
 import java.util.regex.Pattern;
 import java.util.regex.PatternSyntaxException;
@@ -13,7 +9,7 @@ public class Solution {
     public static void main(String[] args){
         Scanner scan = new Scanner(System.in);
         int testCases = Integer.parseInt(scan.nextLine());
-        while (testCases > 0){
+        while (testCases-- > 0){
            String pattern = scan.nextLine();
            try {
                Pattern.compile(pattern);
diff --git a/Java/Strings/Tag Content Extractor/Solution.java b/Java/Strings/Tag Content Extractor/Solution.java
new file mode 100644
index 0000000..28fae50
--- /dev/null
+++ b/Java/Strings/Tag Content Extractor/Solution.java	
@@ -0,0 +1,31 @@
+//     Author: Rodney Shaghoulian
+//     Github: github.com/rshaghoulian
+// HackerRank: hackerrank.com/rshaghoulian
+
+import java.util.Scanner;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/* Solution assumes we can't have the symbol "<" as text between tags */
+public class Solution{
+    public static void main(String[] args){
+        Scanner scan = new Scanner(System.in);
+        int testCases = Integer.parseInt(scan.nextLine());
+        
+        while (testCases-- > 0) {
+            String line = scan.nextLine();
+            
+            boolean matchFound = false;
+            Pattern r = Pattern.compile("<(.+)>([^<]+)</\\1>");
+            Matcher m = r.matcher(line);
+
+            while (m.find()) {
+                System.out.println(m.group(2));
+                matchFound = true;
+            }
+            if ( ! matchFound) {
+                System.out.println("None");
+            }
+        }
+    }
+}
diff --git a/README.md b/README.md
index 9635494..410cb2e 100644
--- a/README.md
+++ b/README.md
@@ -5,30 +5,40 @@ My Java solutions to [HackerRank](https://www.hackerrank.com/) challenges
 
 ## Java
 
-| Domain |          Subdomain          |                                                         Challenge                                                        | Difficulty |                                                                        Solution                                                                       |
-|:------:|:---------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:----------:|:-----------------------------------------------------------------------------------------------------------------------------------------------------:|
-|  Java  |         Introduction        | [Welcome to Java!](https://www.hackerrank.com/challenges/welcome-to-java)                                                |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Welcome%20to%20Java!/Solution.java)        |
-|  Java  |         Introduction        | [Java Stdin and Stdout I](https://www.hackerrank.com/challenges/java-stdin-and-stdout-1)                                 |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Stdin%20and%20Stdout%20I/Solution.java)   |
-|  Java  |         Introduction        | [Java If-Else](https://www.hackerrank.com/challenges/java-if-else)                                                       |    Easy    |            [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20If-Else/Solution.java)           |
-|  Java  |         Introduction        | [Java Stdin and Stdout II](https://www.hackerrank.com/challenges/java-stdin-stdout)                                      |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Stdin%20and%20Stdout%20II/Solution.java)  |
-|  Java  |         Introduction        | [Java Output Formatting](https://www.hackerrank.com/challenges/java-output-formatting)                                   |    Easy    |      [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Output%20Formatting/Solution.java)     |
-|  Java  |         Introduction        | [Java Loops I](https://www.hackerrank.com/challenges/java-loops-i)                                                       |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Loops%20I/Solution.java)          |
-|  Java  |         Introduction        | [Java Loops II](https://www.hackerrank.com/challenges/java-loops)                                                        |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Loops%20II/Solution.java)          |
-|  Java  |         Introduction        | [Java Datatypes](https://www.hackerrank.com/challenges/java-datatypes)                                                   |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Datatypes/Solution.java)          |
-|  Java  |         Introduction        | [Java End-of-file](https://www.hackerrank.com/challenges/java-end-of-file)                                               |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20End-of-file/Solution.java)         |
-|  Java  |         Introduction        | [Java Static Initializer Block](https://www.hackerrank.com/challenges/java-static-initializer-block)                     |    Easy    | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Static%20Initializer%20Block/Solution.java) |
-|  Java  |         Introduction        | [Java Int to String](https://www.hackerrank.com/challenges/java-int-to-string)                                           |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Int%20to%20String/Solution.java)      |
-|  Java  |         Introduction        | [Java Data and Time](https://www.hackerrank.com/challenges/java-date-and-time)                                           |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Date%20and%20Time/Solution.java)      |
-|  Java  |         Introduction        | [Java Currency Formatter](https://www.hackerrank.com/challenges/java-currency-formatter)                                 |    Easy    |     [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Currency%20Formatter/Solution.java)     |
-|  Java  |           Strings           | [Java Strings Introduction](https://www.hackerrank.com/challenges/java-strings-introduction)                             |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Strings%20Introduction/Solution.java)      |
-|  Java  |           Strings           | [Java Substring](https://www.hackerrank.com/challenges/java-substring)                                                   |    Easy    |             [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Substring/Solution.java)             |
-|  Java  |           Strings           | [Java String Compare](https://www.hackerrank.com/challenges/java-string-compare)                                         |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Compare/Solution.java)         |
-|  Java  |           Strings           | [Java String Reverse](https://www.hackerrank.com/challenges/java-string-reverse)                                         |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Reverse/Solution.java)         |
-|  Java  |           Strings           | [Java Anagrams](https://www.hackerrank.com/challenges/java-anagrams)                                                     |    Easy    |              [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Anagrams/Solution.java)             |
-|  Java  |           Strings           | [Java String Tokens](https://www.hackerrank.com/challenges/java-string-tokens)                                           |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Tokens/Solution.java)          |
-|  Java  |           Strings           | [Pattern Syntax Checker](https://www.hackerrank.com/challenges/pattern-syntax-checker)                                   |    Easy    |        [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Pattern%20Syntax%20Checker/Solution.java)        |
-|  Java  |           Strings           | [Java Regex](https://www.hackerrank.com/challenges/java-regex)                                                           |   Medium   |               [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Regex/Solution.java)               |
-|  Java  |           Strings           | [Java Regex 2 - Duplicate Words](https://www.hackerrank.com/challenges/duplicate-word)                                   |    Easy    | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Regex%202%20-%20Duplicate%20Words/Solution.java) |
+| Domain |          Subdomain          |                                                         Challenge                                                        | Difficulty |                                                                        Solution                                                                        |
+|:------:|:---------------------------:|:------------------------------------------------------------------------------------------------------------------------:|:----------:|:------------------------------------------------------------------------------------------------------------------------------------------------------:|
+|  Java  |         Introduction        | [Welcome to Java!](https://www.hackerrank.com/challenges/welcome-to-java)                                                |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Welcome%20to%20Java!/Solution.java)         |
+|  Java  |         Introduction        | [Java Stdin and Stdout I](https://www.hackerrank.com/challenges/java-stdin-and-stdout-1)                                 |    Easy    |    [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Stdin%20and%20Stdout%20I/Solution.java)   |
+|  Java  |         Introduction        | [Java If-Else](https://www.hackerrank.com/challenges/java-if-else)                                                       |    Easy    |            [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20If-Else/Solution.java)            |
+|  Java  |         Introduction        | [Java Stdin and Stdout II](https://www.hackerrank.com/challenges/java-stdin-stdout)                                      |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Stdin%20and%20Stdout%20II/Solution.java)   |
+|  Java  |         Introduction        | [Java Output Formatting](https://www.hackerrank.com/challenges/java-output-formatting)                                   |    Easy    |      [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Output%20Formatting/Solution.java)      |
+|  Java  |         Introduction        | [Java Loops I](https://www.hackerrank.com/challenges/java-loops-i)                                                       |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Loops%20I/Solution.java)           |
+|  Java  |         Introduction        | [Java Loops II](https://www.hackerrank.com/challenges/java-loops)                                                        |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Loops%20II/Solution.java)          |
+|  Java  |         Introduction        | [Java Datatypes](https://www.hackerrank.com/challenges/java-datatypes)                                                   |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Datatypes/Solution.java)           |
+|  Java  |         Introduction        | [Java End-of-file](https://www.hackerrank.com/challenges/java-end-of-file)                                               |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20End-of-file/Solution.java)          |
+|  Java  |         Introduction        | [Java Static Initializer Block](https://www.hackerrank.com/challenges/java-static-initializer-block)                     |    Easy    |  [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Static%20Initializer%20Block/Solution.java) |
+|  Java  |         Introduction        | [Java Int to String](https://www.hackerrank.com/challenges/java-int-to-string)                                           |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Int%20to%20String/Solution.java)       |
+|  Java  |         Introduction        | [Java Data and Time](https://www.hackerrank.com/challenges/java-date-and-time)                                           |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Date%20and%20Time/Solution.java)       |
+|  Java  |         Introduction        | [Java Currency Formatter](https://www.hackerrank.com/challenges/java-currency-formatter)                                 |    Easy    |      [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Introduction/Java%20Currency%20Formatter/Solution.java)     |
+|  Java  |           Strings           | [Java Strings Introduction](https://www.hackerrank.com/challenges/java-strings-introduction)                             |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Strings%20Introduction/Solution.java)       |
+|  Java  |           Strings           | [Java Substring](https://www.hackerrank.com/challenges/java-substring)                                                   |    Easy    |              [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Substring/Solution.java)             |
+|  Java  |           Strings           | [Java String Compare](https://www.hackerrank.com/challenges/java-string-compare)                                         |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Compare/Solution.java)          |
+|  Java  |           Strings           | [Java String Reverse](https://www.hackerrank.com/challenges/java-string-reverse)                                         |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Reverse/Solution.java)          |
+|  Java  |           Strings           | [Java Anagrams](https://www.hackerrank.com/challenges/java-anagrams)                                                     |    Easy    |              [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Anagrams/Solution.java)              |
+|  Java  |           Strings           | [Java String Tokens](https://www.hackerrank.com/challenges/java-string-tokens)                                           |    Easy    |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20String%20Tokens/Solution.java)          |
+|  Java  |           Strings           | [Pattern Syntax Checker](https://www.hackerrank.com/challenges/pattern-syntax-checker)                                   |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Pattern%20Syntax%20Checker/Solution.java)        |
+|  Java  |           Strings           | [Java Regex](https://www.hackerrank.com/challenges/java-regex)                                                           |   Medium   |                [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Regex/Solution.java)               |
+|  Java  |           Strings           | [Java Regex 2 - Duplicate Words](https://www.hackerrank.com/challenges/duplicate-word)                                   |    Easy    |  [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Regex%202%20-%20Duplicate%20Words/Solution.java) |
+|  Java  |           Strings           | [Java Regex 3 - Username Checker](https://www.hackerrank.com/challenges/valid-username-checker)                          |   Medium   | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Java%20Regex%203%20-%20Username%20Checker/Solution.java) |
+|  Java  |           Strings           | [Tag Content Extractor](https://www.hackerrank.com/challenges/tag-content-extractor)                                     |   Medium   |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Strings/Tag%20Content%20Extractor/Solution.java)         |
+|  Java  |          BigNumber          | [Java BigInteger](https://www.hackerrank.com/challenges/java-biginteger)                                                 |    Easy    |            [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/BigNumber/Java%20BigInteger/Solution.java)            |
+|  Java  |          BigNumber          | [Java BigDecimal](https://www.hackerrank.com/challenges/java-bigdecimal)                                                 |   Medium   |            [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/BigNumber/Java%20BigDecimal/Solution.java)            |
+|  Java  |          BigNumber          | [Java Primality Test](https://www.hackerrank.com/challenges/java-primality-test)                                         |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/BigNumber/Java%20Primality%20Test/Solution.java)         |
+|  Java  |       Data Structures       | [Java 1D Array](https://www.hackerrank.com/challenges/java-1d-array-introduction)                                        |    Easy    |        [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Data%20Structures/Java%201D%20Array/Solution.java)        |
+|  Java  |       Data Structures       | [Java 2D Array](https://www.hackerrank.com/challenges/java-2d-array)                                                     |    Easy    |        [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Data%20Structures/Java%202D%20Array/Solution.java)        |
+|  Java  |       Data Structures       | [Java Subarray](https://www.hackerrank.com/challenges/java-negative-subarray)                                            |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Data%20Structures/Java%20Subarray/Solution.java)         |
+|  Java  |       Data Structures       | [Java Arraylist](https://www.hackerrank.com/challenges/java-arraylist)                                                   |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Data%20Structures/Java%20ArrayList/Solution.java)        |
+|  Java  |       Data Structures       | [Java 1D Array (Part 2)](https://www.hackerrank.com/challenges/java-1d-array)                                            |   Medium   |  [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Java/Data%20Structures/Java%201D%20Array%20(Part%202)/Solution.java) |
 
 
 ## 30 Days of Code
@@ -45,6 +55,12 @@ My Java solutions to [HackerRank](https://www.hackerrank.com/) challenges
 | Tutorials | 30 Days of Code |  7  | [Arrays](https://www.hackerrank.com/challenges/30-arrays)                                          |     Easy     |                 [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%207%20-%20Arrays/Solution.java)                |
 | Tutorials | 30 Days of Code |  8  | [Dictionaries and Maps](https://www.hackerrank.com/challenges/30-dictionaries-and-maps)            |     Easy     |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%208%20-%20Dictionaries%20and%20Maps/Solution.java)       |
 | Tutorials | 30 Days of Code |  9  | [Recursion](https://www.hackerrank.com/challenges/30-recursion)                                    |     Easy     |               [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%209%20-%20Recursion/Solution.java)               |
+| Tutorials | 30 Days of Code |  10 | [Binary Numbers](https://www.hackerrank.com/challenges/30-binary-numbers)                          |     Easy     |           [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2010%20-%20Binary%20Numbers/Solution.java)           |
+| Tutorials | 30 Days of Code |  11 | [2D Arrays](https://www.hackerrank.com/challenges/30-2d-arrays)                                    |     Easy     |              [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2011%20-%202D%20Arrays/Solution.java)             |
+| Tutorials | 30 Days of Code |  12 | [Inheritance](https://www.hackerrank.com/challenges/30-inheritance)                                |     Easy     |              [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2012%20-%20Inheritance/Solution.java)             |
+| Tutorials | 30 Days of Code |  13 | [Abstract Classes](https://www.hackerrank.com/challenges/30-abstract-classes)                      |     Easy     |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2013%20-%20Abstract%20Classes/Solution.java)          |
+| Tutorials | 30 Days of Code |  14 | [Scope](https://www.hackerrank.com/challenges/30-scope)                                            |     Easy     |                 [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2014%20-%20Scope/Solution.java)                |
+| Tutorials | 30 Days of Code |  15 | [Linked List](https://www.hackerrank.com/challenges/30-linked-list)                                |     Easy     |             [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/30%20Days%20of%20Code/Day%2015%20-%20Linked%20List/Solution.java)            |
 
 
 ## Cracking the Coding Interview
@@ -103,16 +119,20 @@ My Java solutions to [HackerRank](https://www.hackerrank.com/) challenges
 | Tutorials | 10 Days of Statistics |  7  | [Spearman's Rank Correlation Coefficient](https://www.hackerrank.com/challenges/s10-spearman-rank-correlation-coefficient) |       Easy      | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/10%20Days%20of%20Statistics/Day%207%20-%20Spearman%27s%20Rank%20Correlation%20Coefficient/Solution.java) |
 | Tutorials | 10 Days of Statistics |  8  | [Least Square Regression Line](https://www.hackerrank.com/challenges/s10-least-square-regression-line)                     |       Easy      |        [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/10%20Days%20of%20Statistics/Day%208%20-%20Least%20Square%20Regression%20Rate/Solution.java)       |
 | Tutorials | 10 Days of Statistics |  8  | [Pearson Correlation Coefficient II](https://www.hackerrank.com/challenges/s10-mcq-7)                                      | Multiple Choice |      [Solution.txt](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/10%20Days%20of%20Statistics/Day%208%20-%20Pearson%20Correlation%20Coefficient%20II/Solution.txt)     |
+| Tutorials | 10 Days of Statistics |  9  | [Multiple Linear Regression](https://www.hackerrank.com/challenges/s10-multiple-linear-regression)                         |      Medium     |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/10%20Days%20of%20Statistics/Day%209%20-%20Multiple%20Linear%20Regression/Solution.java)         |
 
 
 ## Algorithms
 
-|   Domain   | Subdomain |                                      Challenge                                     | Difficulty |                                                                  Solution                                                                  |
-|:----------:|:---------:|:----------------------------------------------------------------------------------:|:----------:|:------------------------------------------------------------------------------------------------------------------------------------------:|
-| Algorithms |   Warmup  | [Solve Me First](https://www.hackerrank.com/challenges/solve-me-first)             |    Easy    |    [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Solve%20Me%20First/Solution.java)    |
-| Algorithms |   Warmup  | [Simple Array Sum](https://www.hackerrank.com/challenges/simple-array-sum)         |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Simple%20Array%20Sum/Solution.java)   |
-| Algorithms |   Warmup  | [Compare the Triplets](https://www.hackerrank.com/challenges/compare-the-triplets) |    Easy    | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Compare%20the%20Triplets/Solution.java) |
-| Algorithms |   Warmup  | [A Very Big Sum](https://www.hackerrank.com/challenges/a-very-big-sum)             |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/A%20Very%20Big%20Sum/Solution.java)   |
-| Algorithms |   Warmup  | [Diagonal Difference](https://www.hackerrank.com/challenges/diagonal-difference)   |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Diagonal%20Difference/Solution.java)  |
-| Algorithms |   Warmup  | [Plus Minus](https://www.hackerrank.com/challenges/plus-minus)                     |    Easy    |       [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Plus%20Minus/Solution.java)       |
-| Algorithms |   Warmup  | [Staircase](https://www.hackerrank.com/challenges/staircase)                       |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Staircase/Solution.java)        |
+|   Domain   |    Subdomain   |                                         Challenge                                        | Difficulty |                                                                    Solution                                                                   |
+|:----------:|:--------------:|:----------------------------------------------------------------------------------------:|:----------:|:---------------------------------------------------------------------------------------------------------------------------------------------:|
+| Algorithms |     Warmup     | [Solve Me First](https://www.hackerrank.com/challenges/solve-me-first)                   |    Easy    |      [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Solve%20Me%20First/Solution.java)     |
+| Algorithms |     Warmup     | [Simple Array Sum](https://www.hackerrank.com/challenges/simple-array-sum)               |    Easy    |     [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Simple%20Array%20Sum/Solution.java)    |
+| Algorithms |     Warmup     | [Compare the Triplets](https://www.hackerrank.com/challenges/compare-the-triplets)       |    Easy    |   [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Compare%20the%20Triplets/Solution.java)  |
+| Algorithms |     Warmup     | [A Very Big Sum](https://www.hackerrank.com/challenges/a-very-big-sum)                   |    Easy    |     [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/A%20Very%20Big%20Sum/Solution.java)    |
+| Algorithms |     Warmup     | [Diagonal Difference](https://www.hackerrank.com/challenges/diagonal-difference)         |    Easy    |    [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Diagonal%20Difference/Solution.java)    |
+| Algorithms |     Warmup     | [Plus Minus](https://www.hackerrank.com/challenges/plus-minus)                           |    Easy    |         [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Plus%20Minus/Solution.java)        |
+| Algorithms |     Warmup     | [Staircase](https://www.hackerrank.com/challenges/staircase)                             |    Easy    |          [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Staircase/Solution.java)          |
+| Algorithms |     Warmup     | [Time Conversion](https://www.hackerrank.com/challenges/time-conversion)                 |    Easy    |      [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Time%20Conversion/Solution.java)      |
+| Algorithms |     Warmup     | [Circular Array Rotation](https://www.hackerrank.com/challenges/circular-array-rotation) |    Easy    | [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Warmup/Circular%20Array%20Rotation/Solution.java) |
+| Algorithms | Implementation | [Mini-max Sum](https://www.hackerrank.com/challenges/mini-max-sum)                       |    Easy    |    [Solution.java](https://github.com/rshaghoulian/HackerRank-solutions/blob/master/Algorithms/Implementation/Mini-Max%20Sum/Solution.java)   |