leetcode solutions added

C/Linear_Search.c

@@ -1,29 +1,33 @@
-#include<stdio.h>
-#include<conio.h>
-void main()
+#include <stdio.h>
+
+int main()
 {
-clrscr();
-int i,n,a[100],search;
-printf("Enter number of elements : ");
-scanf("%d",&n);
-printf("\nEnter %d elements : \n",n);
-for(i=0;i<n;i++)
- {
- scanf("%d",&a[i]);
- }
-printf("\nEnter element to be searched : ");
-scanf("%d",&search);
-for(i=0;i<n;i++)
- {
- if(a[i]==search)
-  {
-  printf("\nFound at %d .",m+1);
-  break;
-  }
- }
-if(i==n)
- {
- printf("\nElement not found.");
- }
-getch();
-}
+    int arr[50];
+    int n, number, ind = -1;
+    printf("Enter the number of elements : ");
+    scanf("%d", &n);
+    printf("Enter Array Elements : ");
+    for (int i = 0; i < n; i++)
+    {
+        scanf("%d", &arr[i]);
+    }
+    printf("\nEnter the Number to be searched : ");
+    scanf("%d", &number);
+    for (int i = 0; i < n; i++)
+    {
+        if (number == arr[i])
+        {
+            ind = i;
+            break;
+        }
+    }
+    if (ind != -1)
+    {
+        printf("\nElement %d found at %d position", number, ind + 1);
+    }
+    else
+    {
+        printf("Element not found :)\n");
+    }
+    return 0;
+}

CPP/BFS.cpp

@@ -1,48 +1,95 @@
-#include<bits/stdc++.h> 
-#include<ext/pb_ds/assoc_container.hpp>
-#include<ext/pb_ds/tree_policy.hpp>
-#pragma GCC optimize("Ofast")
-#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,fma")
-#pragma GCC optimize("unroll-loops")
-const unsigned int M = 1000000007;
-using namespace std;
-// Check
-using namespace __gnu_pbds;
-typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> T_set; // PBDS_set
-typedef tree<int,null_type,less_equal<int>,rb_tree_tag,tree_order_statistics_node_update> T_multiset; // PBDS_multiset
-
-void solve()
-{
-    int n ,m,u,v;
-    cin>>n>>m;
-    vector<list<int>> adj(n+1);
-    vector<bool> vis(n+1,false);
-    for(int i = 0; i < n ; i++ ){
-        cin>>u>>v;
-        adj[u].push_back(v);
-        adj[v].push_back(u);
-    }
-    queue<int> temp;
-    temp.push(1);
-    vis[1] = true;
-    while(!temp.empty()){
-        int curr = temp.front();
-        cout<<curr<<" ";
-        temp.pop();
-        for(int elem : adj[curr]){
-            if(!vis[elem]){
-                temp.push(elem);
-                vis[elem] = true;
-             }
-        }
-    }
-
-}
-int main()
-{
-ios_base::sync_with_stdio(false);
-cout.tie(NULL);
-cin.tie(NULL);
-solve();
-return 0;
-}
+// Program to print BFS traversal from a given 
+// source vertex. BFS(int s) traverses vertices  
+// reachable from s. 
+#include<iostream> 
+#include <list> 
+
+using namespace std; 
+
+// This class represents a directed graph using 
+// adjacency list representation 
+class Graph 
+{ 
+    int V;    // No. of vertices 
+
+    // Pointer to an array containing adjacency 
+    // lists 
+    list<int> *adj;    
+public: 
+    Graph(int V);  // Constructor 
+
+    // function to add an edge to graph 
+    void addEdge(int v, int w);  
+
+    // prints BFS traversal from a given source s 
+    void BFS(int s);   
+}; 
+
+Graph::Graph(int V) 
+{ 
+    this->V = V; 
+    adj = new list<int>[V]; 
+} 
+
+void Graph::addEdge(int v, int w) 
+{ 
+    adj[v].push_back(w); // Add w to v’s list. 
+} 
+
+void Graph::BFS(int s) 
+{ 
+    // Mark all the vertices as not visited 
+    bool *visited = new bool[V]; 
+    for(int i = 0; i < V; i++) 
+        visited[i] = false; 
+
+    // Create a queue for BFS 
+    list<int> queue; 
+
+    // Mark the current node as visited and enqueue it 
+    visited[s] = true; 
+    queue.push_back(s); 
+
+    // 'i' will be used to get all adjacent 
+    // vertices of a vertex 
+    list<int>::iterator i; 
+
+    while(!queue.empty()) 
+    { 
+        // Dequeue a vertex from queue and print it 
+        s = queue.front(); 
+        cout << s << " "; 
+        queue.pop_front(); 
+
+        // Get all adjacent vertices of the dequeued 
+        // vertex s. If a adjacent has not been visited,  
+        // then mark it visited and enqueue it 
+        for (i = adj[s].begin(); i != adj[s].end(); ++i) 
+        { 
+            if (!visited[*i]) 
+            { 
+                visited[*i] = true; 
+                queue.push_back(*i); 
+            } 
+        } 
+    } 
+} 
+
+// Driver program to test methods of graph class 
+int main() 
+{ 
+    // Create a graph given in the above diagram 
+    Graph g(4); 
+    g.addEdge(0, 1); 
+    g.addEdge(0, 2); 
+    g.addEdge(1, 2); 
+    g.addEdge(2, 0); 
+    g.addEdge(2, 3); 
+    g.addEdge(3, 3); 
+
+    cout << "Following is Breadth First Traversal "
+         << "(starting from vertex 2) \n"; 
+    g.BFS(2); 
+
+    return 0; 
+} 

CPP/Leet Code Solutions/1894-merge-strings-alternately/merge-strings-alternately.cpp

@@ -0,0 +1,19 @@
+class Solution {
+public:
+    string mergeAlternately(string word1, string word2) {
+        int n = word1.size();
+        int m = word2.size();
+        string ans="";
+
+       for(int i=0;i<word1.size() && i < word2.size();i++){
+            ans+=word1[i];
+            ans+=word2[i];
+       }
+       if (n > m) {
+            ans += word1.substr(m);
+        } else if (n < m) {
+            ans += word2.substr(n);
+        }
+        return ans;
+    }
+};

CPP/Leet Code Solutions/1916-find-center-of-star-graph/find-center-of-star-graph.cpp

@@ -0,0 +1,6 @@
+class Solution {
+public:
+    int findCenter(vector<vector<int>>& e) {
+    return e[0][0] == e[1][0] || e[0][0] == e[1][1] ? e[0][0] : e[0][1];
+}
+};

CPP/Leet Code Solutions/2148-minimum-number-of-moves-to-seat-everyone/minimum-number-of-moves-to-seat-everyone.cpp

@@ -0,0 +1,13 @@
+class Solution {
+public:
+    int minMovesToSeat(vector<int>& seats, vector<int>& students) {
+        sort(seats.begin(), seats.end());
+        sort(students.begin(),students.end());
+
+        int sum=0;
+        for(int i=0;i<seats.size(); i++){
+            sum += abs(seats[i]-students[i]);
+        }
+        return sum;
+    }
+};

CPP/Leet Code Solutions/2216-delete-the-middle-node-of-a-linked-list/delete-the-middle-node-of-a-linked-list.cpp

@@ -0,0 +1,38 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* deleteMiddle(ListNode* head) {
+
+        ListNode* slow=head;
+        ListNode* fast=head;
+        ListNode*prev=head;
+
+        if( head->next == NULL){
+            head = NULL;
+            return head;
+        }
+
+
+
+        while(fast!=NULL && fast->next!=NULL){
+            prev = slow;
+            slow = slow->next;
+            fast = fast->next->next;
+        }
+
+        prev->next = slow->next;
+        slow->next = NULL;
+
+        return head;
+
+    }
+};

CPP/Leet Code Solutions/2271-rearrange-array-elements-by-sign/rearrange-array-elements-by-sign.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    vector<int> rearrangeArray(vector<int>& nums) {
+        vector<int> positives, negatives; // Separate vectors for positive and negative numbers
+
+        // Separate the numbers into positives and negatives
+        for (int num : nums) {
+            if (num < 0) {
+                negatives.push_back(num);
+            } else {
+                positives.push_back(num);
+            }
+        }
+
+        vector<int> ans(nums.size()); // Initialize the answer vector with the correct size
+        int posIndex = 0, negIndex = 0; // Indices for positives and negatives
+
+        // Fill the ans vector by alternating between positives and negatives
+        for (int i = 0; i < nums.size(); i++) {
+            if (i % 2 == 0) {
+                ans[i] = positives[posIndex++];
+            } else {
+                ans[i] = negatives[negIndex++];
+            }
+        }
+
+        return ans;
+    }
+};