Add destination city problem

Author: sudheerj

README.md

@@ -63,6 +63,7 @@ List of Programs related to data structures and algorithms
 | 22  | Range Sum queries                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/22.sumRange/sumRange.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/22.sumRange/sumRange.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/22.sumRange/sumRange.md)        | Easy | Array traversal |
 | 23  | Disappeared numbers                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/23.disappearedNumbers/disappearedNumbers.md)        | Easy | Array traversal |
 | 24  | Identical pairs                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/24.identicalPairs/identicalPairs.md)        | Easy | Array traversal & map |
+| 25  | Destination City                |        [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)        | [JavaScript](https://livecodes.io/?console=open&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.js)               |        [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/array/25.destinationCity/destinationCity.md)        | Easy | Array traversal & set |
 
 ### String
 

src/java1/algorithms/array/destinationCity/DestinationCity.java

@@ -0,0 +1,33 @@
+package java1.algorithms.array.destinationCity;
+
+import java.util.HashSet;
+import java.util.Set;
+
+public class DestinationCity {
+    private static String destinationCity(String[][] paths){
+        Set<String> fromCities = new HashSet<>();
+
+        for (String[] city : paths) {
+            fromCities.add(city[0]);
+        }
+
+        for (String[] city : paths) {
+            if(!fromCities.contains(city[1])){
+                return city[1];
+            }
+        }
+
+        return "";
+        
+    }
+
+    public static void main(String[] args) {
+        String[][] paths1 = new String[][]{{"Hyderabad","KL"},{"KL","Singapore"},{"Singapore","Sydney"}};
+        String[][] paths2 = new String[][]{{"New Jersey","Austin"},{"New York","New Jersey"},{"Austin","Dallas"}};
+        String[][] paths3 = new String[][]{{"Dallas", "London"}};
+
+        System.out.println(destinationCity(paths1));
+        System.out.println(destinationCity(paths2));
+        System.out.println(destinationCity(paths3));    
+    }
+}

src/java1/algorithms/array/destinationCity/DestinationCity.md

@@ -0,0 +1,34 @@
+**Description:**
+Given an array of `paths`, where `paths[i] = [cityAi, cityBi]` indicates that a direct path exists from cityAi to cityBi. Considering the destination city as a city without any path outgoing to another city, return the destination city.
+
+**Note:** Assume that the graph of paths form a line without any loop.
+
+### Examples
+Example 1:
+
+Input: paths = [["Hyderabad","KL"],["KL","Singapore"],["Singapore","Sydney"]]
+Output: Sydney
+
+Example 2:
+
+Input: paths = [["New Jersey","Austin"],["New York","New Jersey"],["Austin","Dallas"]]
+Output: Dallas
+
+Example 3:
+
+Input: paths = [["Dallas", "London"]],
+Output: London
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and hash set for storing for finding the destination city. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `destinationCity`, which accepts input array(`paths`) to find the destination city.
+   
+2. Initialize a `fromCities` set variale to store the list of from cities in paths. The given paths array is traversed and `fromCities` is populated with all from city values. 
+   
+3. Iterate over given array(`path`) agin, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of path elements in an array. This is because we need to iterate over all the elements at most twice for finding the destination city.
+ 
+It takes constant time complexity of `O(n)` due to a set additional datastructure for storing the from cities.

src/javascript/algorithms/array/24.identicalPairs/identicalPairs.md

@@ -14,7 +14,7 @@ Example 2:
 Input: nums = [2, 2, 2, 2],
 Output: 6
 
-Example 2:
+Example 3:
 
 Input: nums = [1, 2, 3, 4],
 Output: 0

src/javascript/algorithms/array/25.destinationCity/destinationCity.js

@@ -0,0 +1,21 @@
+function destinationCity(paths){
+    let fromCities = new Set();
+
+    for(const [from, to] of paths) {
+        fromCities.add(from);
+    }
+
+    for(const [from, to] of paths) {
+        if(!fromCities.has(to)) {
+            return to;
+        }
+    }
+}
+
+const paths1 = [["Hyderabad","KL"],["KL","Singapore"],["Singapore","Sydney"]];
+const paths2 = [["New Jersey","Austin"],["New York","New Jersey"],["Austin","Dallas"]];
+const paths3 = [["Dallas", "London"]];
+
+console.log(destinationCity(paths1));
+console.log(destinationCity(paths2));
+console.log(destinationCity(paths3));

src/javascript/algorithms/array/25.destinationCity/destinationCity.md

@@ -0,0 +1,34 @@
+**Description:**
+Given an array of `paths`, where `paths[i] = [cityAi, cityBi]` indicates that a direct path exists from cityAi to cityBi. Considering the destination city as a city without any path outgoing to another city, return the destination city.
+
+**Note:** Assume that the graph of paths form a line without any loop.
+
+### Examples
+Example 1:
+
+Input: paths = [["Hyderabad","KL"],["KL","Singapore"],["Singapore","Sydney"]]
+Output: Sydney
+
+Example 2:
+
+Input: paths = [["New Jersey","Austin"],["New York","New Jersey"],["Austin","Dallas"]]
+Output: Dallas
+
+Example 3:
+
+Input: paths = [["Dallas", "London"]],
+Output: London
+
+**Algorithmic Steps**
+This problem is solved with the help of array traversal and hash set for storing for finding the destination city. The algorithmic approach can be summarized as follows:
+
+1. Create a function named `destinationCity`, which accepts input array(`paths`) to find the destination city.
+   
+2. Initialize a `fromCities` set variale to store the list of from cities in paths. The given paths array is traversed and `fromCities` is populated with all from city values. 
+   
+3. Iterate over given array(`path`) agin, return the toCity value as destination city if that city doesn't exist inside `fromCities`. This is because only destination city cannot have a outgoing path.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, where `n` is the number of path elements in an array. This is because we need to iterate over all the elements at most twice for finding the destination city.
+ 
+It takes constant time complexity of `O(n)` due to a set additional datastructure for storing the from cities.