Merge branch 'main' of https://github.com/Anuragjain20/Data-Structures-and-Algorithms into arj

Author: Anuragjain20

01. DataStructures/05. ArrayList/AddOddAndEvenNums/README.md

@@ -0,0 +1,3 @@
+# Using two ArrayLists, add all even numbers to one list and all odds to another. Do another pass to insert them at the correct indices.
+
+https://leetcode.com/problems/sort-array-by-parity-ii/discuss/194416/java-easy-to-understand-arraylist-solution

01. DataStructures/05. ArrayList/AddOddAndEvenNums/Solution.java

@@ -0,0 +1,25 @@
+import java.util.ArrayList;
+
+class Solution {
+    public int[] sortArrayByParityII(int[] A) {
+        ArrayList<Integer> evens = new ArrayList<Integer>();
+        ArrayList<Integer> odds = new ArrayList<Integer>();
+        for(int i = 0; i < A.length; i++){
+            if(A[i]%2==0)
+                evens.add(A[i]);
+            else
+                odds.add(A[i]);
+        }
+        int index = 0;
+        for(Integer val: evens){
+            A[index] = val;
+            index += 2;
+        }
+        index = 1;
+        for(Integer val: odds){
+            A[index] = val;
+            index += 2;
+        }
+        return A;
+    }
+}

01. DataStructures/08. Graph/GraphProject/ConnectedCities.java

@@ -0,0 +1,119 @@
+package com.DataStructures_And_Algorithms.Graph;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+
+class City {
+    int index;
+    String name;
+    String code;
+    LinkedList<City> connectedCity = new LinkedList<>();
+
+    public City(int i, String name, String code) {
+        index = i;
+        this.name = name;
+        this.code = code;
+    }
+}
+
+public class GraphProject {
+
+    int size =0;
+    List<City> cities = new ArrayList<>();
+
+    void addCity(String code, String name){
+        int i = size++;
+        City city = new City(i,name, code);
+        cities.add(city);
+    }
+
+    City cityLookup(String code){
+        for(City c:cities){
+            if(c.code.equalsIgnoreCase(code)){
+                return c;
+            }
+        }
+        return null;
+    }
+
+    void connectCity(String code1, String code2){
+        City c1 = cityLookup(code1);
+        City c2 = cityLookup(code2);
+        if( c1 == null || c2 == null){
+            System.out.println("Cannot connect, Invalid city code.");
+            return;
+        }
+        c1.connectedCity.add(c2);
+    }
+    
+    private void findBFSpath(String code) {
+        boolean[] visited = new boolean[size];
+        City city = cityLookup(code);
+        System.out.println("\n printing BFS path from city "+ city.name);
+        LinkedList<City> linkedCity = new LinkedList<>();
+        linkedCity.add(city);
+        visited[city.index] = true;
+
+        while(!linkedCity.isEmpty()){
+            City currentCity = linkedCity.poll();
+            System.out.println(" >> "+ currentCity.name);
+
+            for(City cc:currentCity.connectedCity){
+                if(!visited[cc.index]){
+                    visited[cc.index] = true;
+                    linkedCity.add(cc);
+                }
+            }
+        }
+
+    }
+
+    private void findDFSpath(String code) {
+        boolean[] visited = new boolean[size];
+        City city = cityLookup(code);
+        System.out.println("printing DFS path from city "+ city.name);
+        DFS(city, visited);
+    }
+
+    private void DFS(City city, boolean[] visited) {
+        visited[city.index] = true;
+        for(City c :city.connectedCity){
+            if(!visited[c.index]){
+                DFS(c,visited);
+            }
+        }
+        System.out.println(" >> "+city.name);
+    }
+    public static void main(String[] args) {
+        
+        GraphProject g = new GraphProject();
+        
+        //Adding cities
+        g.addCity("LR", "Larkana");
+        g.addCity("SK", "Sukkur");
+        g.addCity("NW" , "Nawabshah");
+        g.addCity("JM", "Jamshoro");
+
+        //Connecting cities
+        g.connectCity("LR", "SK");
+        g.connectCity("SK", "NW");
+        g.connectCity("NW", "JM");
+        
+        g.addCity("HY", "Hyderabad");
+        g.addCity("KR", "Karachi");
+        g.addCity("IS","Islamabad");
+        g.addCity("RP", "Rawalpindi");
+
+        g.connectCity("HY", "KR");
+        g.connectCity("KR", "IS");
+        g.connectCity("IS", "RP");
+        
+        // finding DFS path from Larkana
+        g.findDFSpath("LR");
+        
+        // finding BFS path from Hyder 
+        g.findBFSpath("HY");
+
+
+    }
+}

02. Algorithms/01. Arrays/18.Array Partition 1/array-partition-i.cpp

@@ -0,0 +1,16 @@
+class Solution {
+public:
+    int arrayPairSum(vector<int>& nums) {
+        int n = nums.size();
+         sort(nums.begin(),nums.end());
+        int total=0;
+        for(int i=0;i<n;i++)
+        {
+            if(i%2==0)
+            {
+                total += min(nums[i],nums[i+1]);
+            }
+        }
+        return total;
+    }
+};

02. Algorithms/01. Arrays/18.Array Partition 1/readme.md

@@ -0,0 +1,29 @@
+<h2>561. Array Partition I</h2><h3>Easy</h3><hr><div><p>Given an integer array <code>nums</code> of <code>2n</code> integers, group these integers into <code>n</code> pairs <code>(a<sub>1</sub>, b<sub>1</sub>), (a<sub>2</sub>, b<sub>2</sub>), ..., (a<sub>n</sub>, b<sub>n</sub>)</code> such that the sum of <code>min(a<sub>i</sub>, b<sub>i</sub>)</code> for all <code>i</code> is <strong>maximized</strong>. Return<em> the maximized sum</em>.</p>
+
+<p>&nbsp;</p>
+<p><strong>Example 1:</strong></p>
+
+<pre><strong>Input:</strong> nums = [1,4,3,2]
+<strong>Output:</strong> 4
+<strong>Explanation:</strong> All possible pairings (ignoring the ordering of elements) are:
+1. (1, 4), (2, 3) -&gt; min(1, 4) + min(2, 3) = 1 + 2 = 3
+2. (1, 3), (2, 4) -&gt; min(1, 3) + min(2, 4) = 1 + 2 = 3
+3. (1, 2), (3, 4) -&gt; min(1, 2) + min(3, 4) = 1 + 3 = 4
+So the maximum possible sum is 4.</pre>
+
+<p><strong>Example 2:</strong></p>
+
+<pre><strong>Input:</strong> nums = [6,2,6,5,1,2]
+<strong>Output:</strong> 9
+<strong>Explanation:</strong> The optimal pairing is (2, 1), (2, 5), (6, 6). min(2, 1) + min(2, 5) + min(6, 6) = 1 + 2 + 6 = 9.
+</pre>
+
+<p>&nbsp;</p>
+<p><strong>Constraints:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>nums.length == 2 * n</code></li>
+	<li><code>-10<sup>4</sup> &lt;= nums[i] &lt;= 10<sup>4</sup></code></li>
+</ul>
+</div>

Love Babbar DSA Sheet Solutions/Arrays/duplicate_array/duplicates.cpp

@@ -0,0 +1,39 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+
+class Solution{
+  public:
+    vector<int> duplicates(int arr[], int n) {
+    
+         vector<int> v;
+       int last;
+       sort(arr,arr+n);
+       for(int i=0;i<n;i++){
+       if(arr[i]==arr[i+1] && arr[i]!=last)
+       {v.push_back(arr[i]);
+       last=arr[i];
+       }
+       }
+       if(v.size()==0)
+       v.push_back(-1);
+       return v;
+    }
+};
+
+
+int main() {
+    
+        int n;
+        cin >> n;
+        int a[n];
+        for (int i = 0; i < n; i++) cin >> a[i];
+        Solution obj;
+        vector<int> ans = obj.duplicates(a, n);
+        for (int i : ans) cout << i << ' ';
+        cout << endl;
+    
+    return 0;
+}
+
+