Added tasks 786, 787, 788.

Author: javadev

src/main/java/g0701_0800/s0786_k_th_smallest_prime_fraction/Solution.java

@@ -0,0 +1,52 @@
+package g0701_0800.s0786_k_th_smallest_prime_fraction;
+
+// #Hard #Array #Binary_Search #Heap_Priority_Queue
+
+public class Solution {
+    public int[] kthSmallestPrimeFraction(int[] arr, int k) {
+        int n = arr.length;
+        double low = 0;
+        double high = 1.0;
+        while (low < high) {
+            double mid = (low + high) / 2;
+            int[] res = getFractionsLessThanMid(arr, n, mid);
+            if (res[0] == k) {
+                return new int[] {arr[res[1]], arr[res[2]]};
+            } else if (res[0] > k) {
+                high = mid;
+            } else {
+                low = mid;
+            }
+        }
+        return new int[] {};
+    }
+
+    private int[] getFractionsLessThanMid(int[] arr, int n, double mid) {
+        double maxLessThanMid = 0.0;
+        // stores indices of max fraction less than mid;
+        int x = 0;
+        int y = 0;
+        // for storing fractions less than mid
+        int total = 0;
+        int j = 1;
+        for (int i = 0; i < n - 1; i++) {
+            // while fraction is greater than mid increment j
+            while (j < n && arr[i] > arr[j] * mid) {
+                j++;
+            }
+            if (j == n) {
+                break;
+            }
+            // j fractions greater than mid, n-j fractions smaller than mid, add fractions smaller
+            // than mid to total
+            total += (n - j);
+            double fraction = (double) arr[i] / arr[j];
+            if (fraction > maxLessThanMid) {
+                maxLessThanMid = fraction;
+                x = i;
+                y = j;
+            }
+        }
+        return new int[] {total, x, y};
+    }
+}

src/main/java/g0701_0800/s0786_k_th_smallest_prime_fraction/readme.md

@@ -0,0 +1,36 @@
+786\. K-th Smallest Prime Fraction
+
+Hard
+
+You are given a sorted integer array `arr` containing `1` and **prime** numbers, where all the integers of `arr` are unique. You are also given an integer `k`.
+
+For every `i` and `j` where `0 <= i < j < arr.length`, we consider the fraction `arr[i] / arr[j]`.
+
+Return _the_ <code>k<sup>th</sup></code> _smallest fraction considered_. Return your answer as an array of integers of size `2`, where `answer[0] == arr[i]` and `answer[1] == arr[j]`.
+
+**Example 1:**
+
+**Input:** arr = [1,2,3,5], k = 3
+
+**Output:** [2,5]
+
+**Explanation:**
+
+    The fractions to be considered in sorted order are:
+    1/5, 1/3, 2/5, 1/2, 3/5, and 2/3.
+    The third fraction is 2/5. 
+
+**Example 2:**
+
+**Input:** arr = [1,7], k = 1
+
+**Output:** [1,7] 
+
+**Constraints:**
+
+*   `2 <= arr.length <= 1000`
+*   <code>1 <= arr[i] <= 3 * 10<sup>4</sup></code>
+*   `arr[0] == 1`
+*   `arr[i]` is a **prime** number for `i > 0`.
+*   All the numbers of `arr` are **unique** and sorted in **strictly increasing** order.
+*   `1 <= k <= arr.length * (arr.length - 1) / 2`

src/main/java/g0701_0800/s0787_cheapest_flights_within_k_stops/Solution.java

@@ -0,0 +1,39 @@
+package g0701_0800.s0787_cheapest_flights_within_k_stops;
+
+// #Medium #Dynamic_Programming #Depth_First_Search #Breadth_First_Search #Heap_Priority_Queue
+// #Graph #Shortest_Path
+
+import java.util.Arrays;
+
+public class Solution {
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        // k + 2 becase there are total of k(intermediate stops) + 1(src) + 1(dst)
+        // dp[i][j] = cost to reach j using atmost i edges from src
+        int[][] dp = new int[k + 2][n];
+        for (int[] row : dp) {
+            Arrays.fill(row, Integer.MAX_VALUE);
+        }
+        // cost to reach src is always 0
+        for (int i = 0; i <= k + 1; i++) {
+            dp[i][src] = 0;
+        }
+        // k+1 because k stops + dst
+        for (int i = 1; i <= k + 1; i++) {
+            for (int[] flight : flights) {
+                int srcAirport = flight[0];
+                int destAirport = flight[1];
+                int cost = flight[2];
+                // if cost to reach srcAirport in i - 1 steps is already found out then
+                // the cost to reach destAirport will be min(cost to reach destAirport computed
+                // already from some other srcAirport OR cost to reach srcAirport in i - 1 steps +
+                // the cost to reach destAirport from srcAirport)
+                if (dp[i - 1][srcAirport] != Integer.MAX_VALUE) {
+                    dp[i][destAirport] = Math.min(dp[i][destAirport], dp[i - 1][srcAirport] + cost);
+                }
+            }
+        }
+        // checking for dp[k + 1][dst] because there are 'k + 2' airports in a path and distance
+        // covered between 'k + 2' airports is 'k + 1'
+        return dp[k + 1][dst] == Integer.MAX_VALUE ? -1 : dp[k + 1][dst];
+    }
+}

src/main/java/g0701_0800/s0787_cheapest_flights_within_k_stops/readme.md

@@ -0,0 +1,47 @@
+787\. Cheapest Flights Within K Stops
+
+Medium
+
+There are `n` cities connected by some number of flights. You are given an array `flights` where <code>flights[i] = [from<sub>i</sub>, to<sub>i</sub>, price<sub>i</sub>]</code> indicates that there is a flight from city <code>from<sub>i</sub></code> to city <code>to<sub>i</sub></code> with cost <code>price<sub>i</sub></code>.
+
+You are also given three integers `src`, `dst`, and `k`, return _**the cheapest price** from_ `src` _to_ `dst` _with at most_ `k` _stops._ If there is no such route, return `-1`.
+
+**Example 1:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png)
+
+**Input:** n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
+
+**Output:** 200
+
+**Explanation:**
+
+The graph is shown.
+
+The cheapest price from city `0` to city `2` with at most 1 stop costs 200, as marked red in the picture. 
+
+**Example 2:**
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png)
+
+**Input:** n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
+
+**Output:** 500
+
+**Explanation:**
+
+The graph is shown.
+
+The cheapest price from city `0` to city `2` with at most 0 stop costs 500, as marked blue in the picture. 
+
+**Constraints:**
+
+*   `1 <= n <= 100`
+*   `0 <= flights.length <= (n * (n - 1) / 2)`
+*   `flights[i].length == 3`
+*   <code>0 <= from<sub>i</sub>, to<sub>i</sub> < n</code>
+*   <code>from<sub>i</sub> != to<sub>i</sub></code>
+*   <code>1 <= price<sub>i</sub> <= 10<sup>4</sup></code>
+*   There will not be any multiple flights between two cities.
+*   `0 <= src, dst, k < n`
+*   `src != dst`

src/main/java/g0701_0800/s0788_rotated_digits/Solution.java

@@ -0,0 +1,43 @@
+package g0701_0800.s0788_rotated_digits;
+
+// #Medium #Dynamic_Programming #Math
+
+public class Solution {
+    public int rotatedDigits(int n) {
+        int[] flag = new int[n + 1];
+        flag[0] = 2;
+        if (n >= 1) {
+            flag[1] = 2;
+        }
+        if (n >= 8) {
+            flag[8] = 2;
+        }
+        if (n >= 2) {
+            flag[2] = 1;
+        }
+        if (n >= 5) {
+            flag[5] = 1;
+        }
+        if (n >= 6) {
+            flag[6] = 1;
+        }
+        if (n >= 9) {
+            flag[9] = 1;
+        }
+        int rs = 0;
+        for (int i = 1; i <= n; i++) {
+            int residual = i % 10;
+            if (flag[residual] != 0) {
+                if ((residual == 1 || residual == 0 || residual == 8) && (flag[i / 10] == 2)) {
+                    flag[i] = 2;
+                    continue;
+                }
+                if (flag[i / 10] != 0) {
+                    flag[i] = 1;
+                    rs++;
+                }
+            }
+        }
+        return rs;
+    }
+}

src/main/java/g0701_0800/s0788_rotated_digits/readme.md

@@ -0,0 +1,41 @@
+788\. Rotated Digits
+
+Medium
+
+An integer `x` is a **good** if after rotating each digit individually by 180 degrees, we get a valid number that is different from `x`. Each digit must be rotated - we cannot choose to leave it alone.
+
+A number is valid if each digit remains a digit after rotation. For example:
+
+*   `0`, `1`, and `8` rotate to themselves,
+*   `2` and `5` rotate to each other (in this case they are rotated in a different direction, in other words, `2` or `5` gets mirrored),
+*   `6` and `9` rotate to each other, and
+*   the rest of the numbers do not rotate to any other number and become invalid.
+
+Given an integer `n`, return _the number of **good** integers in the range_ `[1, n]`.
+
+**Example 1:**
+
+**Input:** n = 10
+
+**Output:** 4
+
+**Explanation:**
+
+    There are four good numbers in the range [1, 10] : 2, 5, 6, 9.
+    Note that 1 and 10 are not good numbers, since they remain unchanged after rotating. 
+
+**Example 2:**
+
+**Input:** n = 1
+
+**Output:** 0 
+
+**Example 3:**
+
+**Input:** n = 2
+
+**Output:** 1 
+
+**Constraints:**
+
+*   <code>1 <= n <= 10<sup>4</sup></code>

src/test/java/g0701_0800/s0786_k_th_smallest_prime_fraction/SolutionTest.java

@@ -0,0 +1,22 @@
+package g0701_0800.s0786_k_th_smallest_prime_fraction;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void kthSmallestPrimeFraction() {
+        assertThat(
+                new Solution().kthSmallestPrimeFraction(new int[] {1, 2, 3, 5}, 3),
+                equalTo(new int[] {2, 5}));
+    }
+
+    @Test
+    void kthSmallestPrimeFraction2() {
+        assertThat(
+                new Solution().kthSmallestPrimeFraction(new int[] {1, 7}, 1),
+                equalTo(new int[] {1, 7}));
+    }
+}

src/test/java/g0701_0800/s0787_cheapest_flights_within_k_stops/SolutionTest.java

@@ -0,0 +1,26 @@
+package g0701_0800.s0787_cheapest_flights_within_k_stops;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void findCheapestPrice() {
+        assertThat(
+                new Solution()
+                        .findCheapestPrice(
+                                3, new int[][] {{0, 1, 100}, {1, 2, 100}, {0, 2, 500}}, 0, 2, 1),
+                equalTo(200));
+    }
+
+    @Test
+    void findCheapestPrice2() {
+        assertThat(
+                new Solution()
+                        .findCheapestPrice(
+                                3, new int[][] {{0, 1, 100}, {1, 2, 100}, {0, 2, 500}}, 0, 2, 0),
+                equalTo(500));
+    }
+}

src/test/java/g0701_0800/s0788_rotated_digits/SolutionTest.java

@@ -0,0 +1,33 @@
+package g0701_0800.s0788_rotated_digits;
+
+import static org.hamcrest.CoreMatchers.equalTo;
+import static org.hamcrest.MatcherAssert.assertThat;
+
+import org.junit.jupiter.api.Test;
+
+class SolutionTest {
+    @Test
+    void rotatedDigits() {
+        assertThat(new Solution().rotatedDigits(10), equalTo(4));
+    }
+
+    @Test
+    void rotatedDigits2() {
+        assertThat(new Solution().rotatedDigits(1), equalTo(0));
+    }
+
+    @Test
+    void rotatedDigits3() {
+        assertThat(new Solution().rotatedDigits(2), equalTo(1));
+    }
+
+    @Test
+    void rotatedDigits4() {
+        assertThat(new Solution().rotatedDigits(857), equalTo(247));
+    }
+
+    @Test
+    void rotatedDigits5() {
+        assertThat(new Solution().rotatedDigits(15), equalTo(6));
+    }
+}