adding project rubric

Author: LiquidPlummer

Code Challenges/Bigger is Greater/.idea/.gitignore

@@ -0,0 +1,5 @@
+public class Main {
+    public static void main(String[] args) {
+        System.out.println(Result.biggerIsGreater("dkhc"));
+    }
+}

Code Challenges/Bigger is Greater/.idea/Bigger is Greater.iml

@@ -0,0 +1,61 @@
+import java.util.Arrays;
+
+class Result {
+
+    /*
+     * Complete the 'biggerIsGreater' function below.
+     *
+     * The function is expected to return a STRING.
+     * The function accepts STRING w as parameter.
+     */
+
+    public static String biggerIsGreater(String w) {
+        // Write your code here
+        //find the latest candidates in the string, closest to the end
+        //candidates are adjacent characters in the string where s[a] < s[a+1]
+        //swap those candidates... there might be another step after that... sort the rest? yeah
+        //made a mistake here, need to swap s[a] with the next largest character to it's right, then sort the rest
+
+
+        char[] array = w.toCharArray();
+
+        //find candidate
+        int candidateIndex = -1;
+        for(int i = array.length-1; i > 0; i--) {
+            if(array[i-1] < array[i]) {
+                candidateIndex = i-1;
+                break;
+            }
+        }
+
+        //short circuit, no candidates
+        if(candidateIndex == -1) {
+            return "no answer";
+        }
+
+        int swapIndex = -1;
+        for(int i = array.length-2; i > candidateIndex; i--) {
+            //we've already been through this once, everything to the right of candidate is descending
+            //so find the first larger char to the right of candidate right-to-left
+            if(array[i] > array[candidateIndex]) {
+                swapIndex = i;
+            }
+        }
+
+
+
+        //do swap
+        char temp = array[candidateIndex];
+        array[candidateIndex] = array[swapIndex];
+        array[swapIndex] = temp;
+
+        //sort the rest of the list
+        if(candidateIndex < array.length-1) {
+            Arrays.sort(array, candidateIndex, array.length);
+        }
+
+        return String.valueOf(array);
+
+    }
+
+}

Code Challenges/Bigger is Greater/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,10 @@
+public class Main {
+    public static void main(String[] args) {
+        int[] nums = new int[]{2,5};
+        int target = 0;
+        Solution solution = new Solution();
+
+        System.out.println(solution.search(nums, target));
+
+    }
+}

Code Challenges/Bigger is Greater/.idea/misc.xml

@@ -0,0 +1,27 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        return recurse(nums, 0, nums.length-1, target);
+
+    }
+
+    public int recurse(int[] nums, int begin, int end, int target) {
+        int midpoint = begin + ((end - begin)/2);
+
+        //Base case - found it
+        if(nums[midpoint] == target) {
+            return midpoint;
+        }
+
+        //Base case - didn't find it
+        if(end <= begin) {
+            return -1;
+        }
+
+        //Recurse until we find it
+        if(target < nums[midpoint]) {
+            return recurse(nums, begin, midpoint-1, target);
+        } else {
+            return recurse(nums, midpoint+1, end, target);
+        }
+    }
+}

Code Challenges/Bigger is Greater/.idea/modules.xml

@@ -0,0 +1,13 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Main {
+    public static void main(String[] args) {
+        List<String> myList = new ArrayList<>();
+        myList.add("mpxz");
+        myList.add("abcd");
+        myList.add("wlmf");
+
+        System.out.println(Result.gridChallenge(myList));
+    }
+}

Code Challenges/Bigger is Greater/.idea/vcs.xml

@@ -0,0 +1,22 @@
+import java.util.Arrays;
+import java.util.List;
+
+public class Result {
+    public static String gridChallenge(List<String> grid) {
+        // Write your code here
+        for(int i = 0; i < grid.size(); i++) {
+            char[] arr = grid.get(i).toCharArray();
+            Arrays.sort(arr);
+            grid.set(i, String.valueOf(arr));
+        }
+
+        for(int i = 0; i < grid.get(0).length(); i++) { //left to right
+            for(int j = 1; j < grid.size(); j++) { //up down
+                if(grid.get(j).charAt(i) < grid.get(j-1).charAt(i)) {
+                    return "NO";
+                }
+            }
+        }
+        return "YES";
+    }
+}

Code Challenges/Bigger is Greater/out/production/Bigger is Greater/Main.class

@@ -0,0 +1,10 @@
+import java.util.Arrays;
+import java.util.List;
+
+public class Main {
+    public static void main(String[] args) {
+
+        List<Integer> arr = Arrays.asList(1,6,5,2,4,3);
+        System.out.println(Result.larrysArray(arr));
+    }
+}

Code Challenges/Bigger is Greater/out/production/Bigger is Greater/Result.class

@@ -0,0 +1,37 @@
+import java.util.List;
+
+public class Result {
+    int inversions;
+
+    public  String larrysArray(List<Integer> A) {
+        this.inversions = 0;
+        Integer[] a = (Integer[])A.toArray();
+        mergeSort(a, 0, a.length-1);
+    }
+
+    private Integer[] mergeSort(Integer[] array, int l, int r) {
+        //base case - array size 1
+        if(r - l == 1) {
+            return new Integer[]{array[l]};
+        }
+
+        //recurse
+        return merge(mergeSort(array, l, r/2), mergeSort(array, 1 + r/2, r));
+    }
+
+    private Integer[] merge(Integer[] a, Integer[] b) {
+        int aCursor = 0, bCursor = 0, i = 0;
+        Integer[] array = new Integer[a.length*2];
+        while(i < array.length) {
+            if(a[aCursor] < b[bCursor]) {
+                array[i] = a[aCursor];
+                aCursor++;
+            } else {
+                array[i] = b[bCursor];
+                bCursor++;
+            }
+            i++;
+        }
+        return array;
+    }
+}