more code

Author: Rakesh Venkatesh

lambdas/src/main/java/com/rakeshv/Lambdas.java

@@ -1,5 +1,7 @@
 package com.rakeshv;
 
+import java.time.LocalDateTime;
+import java.util.List;
 import java.util.Optional;
 
 /**
@@ -12,6 +14,8 @@ public static void main( String[] args )
     {
         Long value = null;
 
+        List<Integer> integers = List.of(1, 3, 5, 7, 9, 100, 2, 4);
+
         Long finalValue = Optional.ofNullable(value)
                 .map(x -> 10L)
                 .orElseGet(() -> 5L);
@@ -22,8 +26,21 @@ public static void main( String[] args )
                 .map(x -> lambdas.doThisIfNotNull())
                 .orElseGet(lambdas::doThisIfNull);
         System.out.println(result);
+        System.out.println("current time is " + LocalDateTime.now());
+        integers.parallelStream()
+                .filter(Lambdas::isEven)
+                .findAny()
+                .ifPresent(System.out::println);
+        System.out.println("new time is " + LocalDateTime.now());
     }
 
+    public static boolean isEven(int x) {
+        try {
+            Thread.sleep(x * 100);
+        } catch (Exception e) {}
+
+        return x % 2 == 0;
+    }
     public String doThisIfNotNull() {
         return ("i accept only non null values");
     }

lambdas/src/main/java/com/rakeshv/StrategyPattern.java

@@ -0,0 +1,33 @@
+package com.rakeshv;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class StrategyPattern {
+    public static void main(String[] args) {
+        Map<String, Payment> map = new HashMap<>();
+        map.put("random", Payment.random());
+        map.put("another", Payment.another());
+        map.put("onemore", Payment.onemore());
+
+        double payment = map.get("onemore").pay(10, 2, 3, 4, 5);
+        System.out.println(payment);
+    }
+
+}
+
+interface Payment {
+    double pay(double amount, double a, double b, double c, double d);
+
+    static Payment random() {
+        return (amount, a, b, c, d) -> amount;
+    }
+
+    static Payment another() {
+        return ((amount, a, b, c, d) -> amount + a +b);
+    }
+
+    static Payment onemore() {
+        return ((amount, a, b, c, d) -> amount * a * b * c * d);
+    }
+}

src/Arrays/FractionalKnapsack.java

@@ -0,0 +1,59 @@
+package Arrays;
+
+import java.util.Arrays;
+
+/*
+https://www.geeksforgeeks.org/fractional-knapsack-problem/?ref=lbp
+ */
+public class FractionalKnapsack {
+    static class Item {
+        double weight;
+        double value;
+        Double cost;
+
+        Item(double w, double v) {
+            this.weight = w;
+            this.value = v;
+            this.cost = this.value / this.weight;
+        }
+    }
+
+    private double solution(double[] weights, double[] values, double capacity) {
+        Item[] items = new Item[weights.length];
+
+        for (var i = 0; i < weights.length; i++) {
+            items[i] = new Item(weights[i], values[i]);
+        }
+
+        Arrays.sort(items, (i1, i2) -> i2.cost.compareTo(i1.cost));
+
+        double totalValue = 0;
+        for (Item item : items) {
+            double currentWeight = item.weight;
+            double currentValue = item.value;
+
+            if (capacity - currentWeight >= 0) {
+                totalValue += currentValue;
+                capacity -= currentWeight;
+            } else {
+                double fraction = capacity / currentWeight;
+                double value = currentValue * fraction;
+                totalValue += value;
+                break;
+            }
+        }
+
+        return totalValue;
+    }
+
+    public static void main(String[] args) {
+        FractionalKnapsack fKnapsack =
+                new FractionalKnapsack();
+
+        double[] wt = { 10, 40, 20, 30 };
+        double[] val = { 60, 40, 100, 120 };
+        int capacity = 50;
+
+        System.out.println(fKnapsack.solution(wt, val, capacity));
+    }
+}

src/Arrays/GoldMining.java

@@ -0,0 +1,43 @@
+package Arrays;
+
+import java.util.Arrays;
+
+/*
+https://www.geeksforgeeks.org/gold-mine-problem/?ref=lbp
+ */
+public class GoldMining {
+    public static void main(String[] args) {
+        int gold[][]= { {1, 3, 1, 5},
+                {2, 2, 4, 1},
+                {5, 0, 2, 3},
+                {0, 6, 1, 2} };
+
+        System.out.println(solution(gold));
+    }
+
+    public static int solution(int[][] goldMine) {
+        int[][] dp = new int[goldMine.length][goldMine[0].length];
+
+        for (var arr : dp) {
+            Arrays.fill(arr, 0);
+        }
+
+        for (var col = goldMine[0].length - 1; col >= 0; col--) {
+            for (var row = 0; row < goldMine.length; row++) {
+                int right = (col == goldMine[0].length - 1) ? 0 : dp[row][col + 1];
+                int rightUp = ((col == goldMine[0].length -1) || (row == 0)) ? 0 : dp[row-1][col + 1];
+                int rightDown = ((col == goldMine[0].length - 1) || (row == goldMine.length - 1)) ? 0 : dp[row + 1][col + 1];
+
+                dp[row][col] = goldMine[row][col] + Math.max(right, Math.max(rightUp, rightDown));
+            }
+        }
+
+        int max = dp[0][0];
+
+        for (var i = 1; i < goldMine.length; i++) {
+            max = Math.max(max, dp[i][0]);
+        }
+
+        return max;
+    }
+}

src/Arrays/JobScheduling.java

@@ -0,0 +1,92 @@
+package Arrays;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+/*
+https://www.geeksforgeeks.org/job-sequencing-using-disjoint-set-union/?ref=lbp
+ */
+public class JobScheduling {
+    static class Job {
+        char id;
+        int profit;
+        int deadline;
+
+        Job(char a, int d, int p) {
+            this.id = a;
+            this.profit = p;
+            this.deadline = d;
+        }
+
+        @Override
+        public String toString() {
+            return "Job{" +
+                    "id=" + id +
+                    ", profit=" + profit +
+                    ", deadline=" + deadline +
+                    '}';
+        }
+    }
+
+    static class DisjointSet {
+        int[] parent;
+        DisjointSet(int length) {
+            this.parent = new int[length + 1];
+
+            for (var i = 0; i < parent.length; i++) {
+                parent[i] = i;
+            }
+        }
+
+        int find(int slot) {
+            if (slot == parent[slot])
+                return slot;
+
+            return parent[slot] = find(parent[slot]);
+        }
+
+        void merge(int par, int child) {
+            this.parent[child] = par;
+        }
+    }
+
+    int maxTimeSlot(List<Job> jobs) {
+        int ans = Integer.MIN_VALUE;
+        for (var job : jobs) {
+            ans = Math.max(ans, job.deadline);
+        }
+
+        return ans;
+    }
+
+
+    void scheduleJobs(List<Job> jobs) {
+        Collections.sort(jobs, (j1, j2) -> {return (j1.profit > j2.profit) ? -1 : 1;});
+        int maxSlot = maxTimeSlot(jobs);
+        DisjointSet disjointSet = new DisjointSet(maxSlot);
+
+        for (var job : jobs) {
+//            System.out.println(" job is " + job);
+            int availableSlot = disjointSet.find(job.deadline);
+//            System.out.println("available slot is " + availableSlot);
+            if (availableSlot > 0) {
+                disjointSet.merge(disjointSet.find(availableSlot - 1), availableSlot);
+                System.out.print(job + " ");
+            }
+        }
+    }
+
+    public static void main(String[] args) {
+        ArrayList<Job> arr =new ArrayList<Job>();
+        arr.add(new Job('a',2,100));
+        arr.add(new Job('b',1,19));
+        arr.add(new Job('c',2,27));
+        arr.add(new Job('d',1,25));
+        arr.add(new Job('e',3,15));
+
+        JobScheduling jobScheduling =
+                new JobScheduling();
+        jobScheduling.scheduleJobs(arr);
+    }
+}

src/Arrays/KLargestElements.java

@@ -0,0 +1,42 @@
+package Arrays;
+
+
+import java.util.PriorityQueue;
+
+/*
+https://www.geeksforgeeks.org/k-largestor-smallest-elements-in-an-array/?ref=lbp
+ */
+public class KLargestElements {
+    PriorityQueue<Integer> priorityQueue;
+    int[] array;
+
+    KLargestElements(int[] a) {
+        this.array = a;
+        this.priorityQueue = new PriorityQueue();
+    }
+
+    public void solution(int k) {
+        for (var i = 0; i < k; i++) {
+            priorityQueue.add(array[i]);
+        }
+
+        for (var i = k ; i < array.length; i++) {
+            if (array[i] > priorityQueue.peek()) {
+                priorityQueue.poll();
+                priorityQueue.add(array[i]);
+            }
+        }
+
+        for (Integer integer : priorityQueue) {
+            System.out.print(integer + " ");
+        }
+    }
+
+    public static void main(String[] args) {
+        int arr[] = { 11, 3, 2, 1, 15, 5, 4,
+                45, 88, 96, 50, 45 };
+        KLargestElements kLargestElements =
+                new KLargestElements(arr);
+        kLargestElements.solution(3);
+    }
+}

src/Arrays/MinHeapToMaxHeap.java

@@ -0,0 +1,47 @@
+package Arrays;
+
+/*
+https://www.geeksforgeeks.org/convert-min-heap-to-max-heap/?ref=rp
+ */
+public class MinHeapToMaxHeap {
+    public static void main(String[] args) {
+        int arr[] = {3, 5, 9, 6, 8, 20, 10, 12, 18, 9};
+        printArray(arr);
+
+        convertToMaxHeap(arr);
+        printArray(arr);
+    }
+
+    public static void printArray(int[] array) {
+        for (var i : array)
+            System.out.print(i + " ");
+        System.out.println();
+    }
+
+    public static void convertToMaxHeap(int[] array) {
+        int n = array.length;
+
+        for (var i = (n-2)/2; i >=0; i--) {
+            maxHeapify(array, i, n);
+        }
+    }
+
+    public static void maxHeapify(int[] array, int i, int n) {
+        int left = 2* i + 1;
+        int right = 2 * i + 2;
+        int largest = i;
+        if (left < n && (array[left] > array[i]))
+            largest = left;
+
+        if (right < n && (array[right] > array[largest]))
+            largest = right;
+
+        if (largest != i) {
+            int tmp = array[i];
+            array[i] = array[largest];
+            array[largest] = tmp;
+            maxHeapify(array, largest, n);
+        }
+
+    }
+}

src/Arrays/UnboundedKnapsack.java

@@ -0,0 +1,35 @@
+package Arrays;
+
+import java.util.Arrays;
+
+/*
+https://iq.opengenus.org/unbounded-knapsack-problem/
+ */
+public class UnboundedKnapsack {
+    public static void main(String[] args) {
+        int val[] = {10,30,20};
+        int weight[] = {5, 10, 15};
+
+        int Capacity = 100;
+
+        System.out.println(solution(Capacity, weight, val));
+    }
+
+    public static double solution(int capacity, int[] weight, int[] value) {
+        int[] dp = new int[capacity  +1];
+        Arrays.fill(dp, 0);
+
+        if (weight.length == 0 || capacity == 0)
+            return 0;
+
+        for (var i = 0; i <= capacity; i++) {
+            for (var j = 0; j < weight.length; j++) {
+                if (weight[j] <= i) {
+                    dp[i] = Math.max(dp[i], dp[i - weight[j]] + value[j]);
+                }
+            }
+        }
+
+        return dp[capacity];
+    }
+}