--added: Arrays/SolvingForQueriesWithCups.java

Author: srsandy

Practice Problems/Arrays/Solving For Queries With Cups/README.md

@@ -0,0 +1,84 @@
+# Solving For Queries With Cups
+
+**Problem from HackerRank**
+
+There are `n` cups in a row (assume 1-based indexing for the cups). You have `m` balls and you place the `i`<sup>th</sup> ball in the cup _balls<sub>i</sub>_ such that there's atmost ball in each of the cups, therefore the elements of balls are pairwise distinct.
+
+Now, you perform `s` swaps, each swap contains two integers `a` and `b`, you are required to swap the positions of cups at index `a` and index `b`.
+
+Finally, you are asked `q` queries, each query contains two space separated integers `l` and `r`, you need to answer the total number of balls that are present in the cups having index from `l` to `r` (both inclusive).
+
+For example, `n=4`, `m=2`, `balls={2,4}` . Now you perform `s=3` swaps, where you swap the following cups:
+
+- 2nd and 4th
+- 2nd and 1st
+- 2nd and 3rd
+
+Finally, the balls would be at the indices `{1,4}` . So, for example, if we turned over all the cups from `l=2` to `r=4`, the number of balls found would be `1`.
+
+**Input Format**
+
+The first line of input contains `4` space separated integers `n`, `m`, `s` and `q` denoting the number of cups, number of balls, number of swaps performed and the number of queries respectively.
+
+The second line of input contains `m` space separated integers ball<sub>1</sub>, ball<sub>2</sub>, ball<sub>3</sub> ... ball<sub>n</sub> where ball<sub>i</sub> denotes the position of ball `i`.
+
+The next `s` lines containts two space separated integer `a` and `b` - the indices of cups needed to be swapped in this query.
+
+The next `q` lines containts two space separated integer `l` and `r`, the description of each query.
+
+**Constraints**
+
+- 2 <= `n` <= 10<sup>9</sup>
+- 1 <= `m` <= 10<sup>5</sup>
+- 1 <= `s, q` <= 6.10<sup>4</sup>
+- 1 <= balls<sub>i</sub>, `a`, `b` <= `n`, `a` != `b`
+- 1 <= `l` <= `r` <= `n`
+
+**Output Format**
+
+Print `q` space separated integers, where the `i`<sup>th</sup> integer denote the answer for the `i`<sup>th</sup> query.
+
+## Examples:
+
+### Example 1
+
+**Sample Input** :
+
+```java
+3 1 3 2
+2
+1 2
+1 3
+3 1
+1 2
+1 3
+```
+
+**Sample Output** :
+
+```java
+1 1
+```
+
+**Explanation**: After the given swaps, the ball will be at position **1**, hence, for both the queries, the answer is **1**.
+
+### Example 2
+
+**Sample Input** :
+
+```java
+3 2 2 2
+1 3
+1 3
+3 2
+1 2
+3 3
+```
+
+**Sample Output** :
+
+```java
+2 0
+```
+
+**Explanation**: After the given swaps, the balls would be at positions `{1,2}`. Hence, for the first query the answer would be **2** (There are **2** balls in the range `[1,2]`) and for the second query, the answer would be **0** (There are no balls in the cup **3**).

Practice Problems/Arrays/Solving For Queries With Cups/SolvingForQueriesWithCups.java

@@ -0,0 +1,118 @@
+import java.util.*;
+
+public class SolvingForQueriesWithCups {
+
+	public static void main(String[] args) {
+
+		Scanner sc = new Scanner(System.in);
+		int n = sc.nextInt();
+		int m = sc.nextInt();
+		int s = sc.nextInt();
+		int q = sc.nextInt();
+
+		List<Integer> balls = new ArrayList<>();
+
+		for (int i = 0; i < m; i++) {
+			balls.add(sc.nextInt());
+        }
+
+		List<List<Integer>> swaps = new ArrayList<>();
+
+		for (int i = 0; i < s; i++) {
+            List<Integer> swapsRowItems = new ArrayList<>();
+
+            for (int j = 0; j < 2; j++) {
+                swapsRowItems.add(sc.nextInt());
+            }
+            swaps.add(swapsRowItems);
+        }
+
+		List<List<Integer>> query = new ArrayList<>();
+
+		for (int i = 0; i < q; i++) {
+            List<Integer> queryRowItems = new ArrayList<>();
+
+            for (int j = 0; j < 2; j++) {
+                queryRowItems.add(sc.nextInt());
+            }
+
+            query.add(queryRowItems);
+        }
+
+		List<Integer> result = countCups(n, balls, swaps, query);
+
+		for (int i = 0; i < result.size(); i++) {
+           System.out.print(String.valueOf(result.get(i)));
+
+            if (i != result.size() - 1) {
+               System.out.print(" ");
+            }
+        }
+
+		 System.out.println();
+	}
+
+	public static List<Integer> countCups(int n, List<Integer> balls, List<List<Integer>> swaps, List<List<Integer>> queries) {
+        
+        List<Integer> ansList = new ArrayList<>();
+        Set<Integer> set = new HashSet<>(balls);
+        TreeMap<Integer, Integer> map = new TreeMap<>();
+                
+        for(int i=0; i<swaps.size(); i++) {
+            int x = swaps.get(i).get(0);
+            int y = swaps.get(i).get(1);
+            
+            boolean xC = set.contains(x);
+            boolean yC = set.contains(y);
+            
+            if(xC && yC || !xC && !yC) {
+                continue;
+            }
+            
+            if(xC) {
+                set.remove(x);
+                set.add(y);
+            } else {
+                set.remove(y);
+                set.add(x);
+            }
+        }
+               
+        for(int x : set) {
+            map.put(x, 0);
+        }
+               
+        map.put(0,0);
+        int count = 0;
+
+        for(int x : map.keySet()) {
+            count += 1;
+            map.put(x, count);
+        }
+               
+        for(int i=0; i<queries.size(); i++) {
+            int x = queries.get(i).get(0)-1;
+            int y = queries.get(i).get(1);
+            
+            Integer cLeft = 0;
+            Integer cRight = 0;
+            
+            cLeft = map.get(x);
+            cRight = map.get(y);
+            
+            if(cLeft == null) {
+                cLeft = map.get(map.floorKey(x));
+            }
+            
+            if(cRight == null) {
+                cRight = map.get(map.floorKey(y));
+            }
+            
+            ansList.add(cRight-cLeft);    
+        }
+        
+        return ansList;
+    }
+
+}
+