Add the Swap for Largest Number problem under the Greedy section

Author: subhatav

src/greedy/InsertInterval.java

@@ -9,7 +9,7 @@
 // Approach: Follow Solution Link; Time Complexity: O(N)
 
 public class InsertInterval {
-    
+
     public int[][] insert(int[][] intervals, int[] injected) {
 
         List<int[]> results = new ArrayList<>();

src/greedy/JobSequencing.java

@@ -17,12 +17,12 @@ public int compute(int[][] jobs) {
         int profit = 0, size = jobs.length;
         boolean[] days = new boolean[size];
 
-        for (int job = 0; job < size; job++) {
+        for (int job = 0; job < size; job += 1) {
 
             int deadline = Math.min(size, jobs[job][0]);
 
             // Try to do Jobs on their Last Day of Deadline
-            for (int day = deadline - 1; day >= 0; day--) {
+            for (int day = deadline - 1; day >= 0; day -= 1) {
 
                 // Check if Day is Free
                 if (days[day] == false) {

src/greedy/MaxCircularSum.java

@@ -27,6 +27,7 @@ public int compute(int[] nums) {
 
         // If all Numbers are NEGATIVE
         if (maxSum <= 0) return maxSum;
+
         return Math.max(maxSum, totalSum - minSum);
     }
 }

src/greedy/MergeIntervals.java

@@ -13,8 +13,8 @@ public class MergeIntervals {
 
     public int[][] compute(int[][] intervals) {
 
-        // Sort all the Intervals in Ascending Order w.r.t. their Start Positions
-        Arrays.parallelSort(intervals, Comparator.comparingInt(interval -> interval[0]));
+        // Sort all the Intervals in Ascending Order w.r.t. the Start Positions
+        Arrays.sort(intervals, Comparator.comparingInt(interval -> interval[0]));
 
         List<int[]> results = new ArrayList<>();
 

src/greedy/MinimumArrows.java

@@ -16,7 +16,7 @@ public int compute(int[][] points) {
 
         int arrows = 1, previous = 0, size = points.length;
 
-        for (int current = 1; current < size; current++) {
+        for (int current = 1; current < size; current += 1) {
 
             // Verify if the current Balloon is NOT
             // overlapping with the current Balloon

src/greedy/MostProfitBoxes.java

@@ -9,7 +9,7 @@
 // Time Complexity: O(NlogN), Space Complexity: O(1) or O(N) depending on Sorting Algorithm
 
 public class MostProfitBoxes {
-    
+
     public int compute(int[][] boxTypes, int truckSize) {
 
         // Sort ALL the Box types in Non-increasing Order w.r.t. their Units

src/greedy/ScheduleMeetings.java

@@ -11,15 +11,15 @@
 // Approach: Sort, Check if Overlapping & Add when NOT so; Time Complexity: O(N + NlogN + N) = O(NlogN)
 
 public class ScheduleMeetings {
-    
+
     public static List<Integer> maximumMeetings(int[] start, int[] finish) {
 
         List<Integer> result = new ArrayList<>();
 
         int previous = -1, size = finish.length;
         int[][] meets = new int[size][3];
 
-        for (int time = 0; time < size; time++) {
+        for (int time = 0; time < size; time += 1) {
 
             meets[time][0] = time + 1;
             meets[time][1] = start[time];
@@ -28,7 +28,7 @@ public static List<Integer> maximumMeetings(int[] start, int[] finish) {
 
         Arrays.sort(meets, Comparator.comparingInt(meet -> meet[2]));
 
-        for (int index = 0; index < size; index++) {
+        for (int index = 0; index < size; index += 1) {
 
             if (previous < meets[index][1]) {
 

src/greedy/SeparateIntervals.java

@@ -16,7 +16,7 @@ public int compute(int[][] intervals) {
 
         int overlapped = 1, previous = 0, size = intervals.length;
 
-        for (int current = 1; current < size; current++) {
+        for (int current = 1; current < size; current += 1) {
 
             // Verify if the current Interval is NOT
             // overlapping with the current Interval

src/greedy/SwapForLargest.java

@@ -0,0 +1,52 @@
+package greedy;
+
+// Problem Link: https://leetcode.com/problems/maximum-swap/
+// Solution Link: https://leetcode.com/problems/maximum-swap/solutions/107068/java-simple-solution-o-n-time/
+
+// Approach: Use BUCKETS to Store INDICES of All DIGITS; Time Complexity: O(N)
+
+public class SwapForLargest {
+
+    public int compute(int num) {
+
+        String number = String.valueOf(num);
+        char[] digits = number.toCharArray();
+
+        int digit, top = 9, bucket;
+        int size = digits.length;
+
+        int[] buckets = new int[10];
+
+        for (int index = 0; index < size; index += 1) {
+
+            digit = digits[index] - '0';
+
+            buckets[digit] = index;
+        }
+
+        for (int index = 0; index < size; index += 1) {
+
+            digit = digits[index] - '0';
+
+            for (int mark = top; mark > digit; mark -= 1) {
+
+                bucket = buckets[mark];
+
+                if (bucket > index) {
+
+                    char backup = digits[index];
+                    digits[index] = digits[bucket];
+                    digits[bucket] = backup;
+
+                    String largest = new String(digits);
+
+                    return Integer.valueOf(largest);
+                }
+            }
+
+            top = digit;
+        }
+
+        return num;
+    }
+}