Merge pull request #2790 from Abe0770/main

Create 1921-eliminate-maximum-number-of-monsters.cpp

Author: felivalencia3

Diff for: cpp/0024-swap-nodes-in-pairs.cpp

@@ -0,0 +1,46 @@
+/*
+  Given a linked list, swap every two adjacent nodes and return its head. 
+  You must solve the problem without modifying the values in the list's nodes (i.e., only nodes themselves may be changed.)
+
+  Ex. Input: head = [1,2,3,4]
+      Output: [2,1,4,3]
+
+  Time  : O(N);
+  Space : O(1);
+*/
+
+/**
+ * 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* swapPairs(ListNode* head) {  
+        if (!head || !head->next) 
+            return head;
+
+        ListNode *new_head = head->next;
+        ListNode *prev = NULL;
+
+        while (head && head->next) {
+            ListNode *next_pair = head->next->next;
+            ListNode *second = head->next;
+
+            if (prev)
+                prev->next = second;
+
+            second->next = head;
+            head->next = next_pair;
+
+            prev = head;
+            head = next_pair;
+        }
+        return new_head;
+    }
+};

Diff for: cpp/1921-eliminate-maximum-number-of-monsters.cpp

@@ -0,0 +1,45 @@
+/*
+  You are playing a video game where you are defending your city from a group of n monsters. 
+  You are given a 0-indexed integer array dist of size n, where dist[i] is the initial distance in kilometers of the ith monster from the city.
+  The monsters walk toward the city at a constant speed. The speed of each monster is given to you in an integer array speed of size n, 
+  where speed[i] is the speed of the ith monster in kilometers per minute.
+  You have a weapon that, once fully charged, can eliminate a single monster. 
+  However, the weapon takes one minute to charge.The weapon is fully charged at the very start.
+  You lose when any monster reaches your city. If a monster reaches the city at the exact moment the weapon is fully charged, 
+  it counts as a loss, and the game ends before you can use your weapon.
+  
+  Return the maximum number of monsters that you can eliminate before you lose, or n if you can eliminate all the monsters before they reach the city. 
+
+  Ex. Input: dist = [1,3,4], speed = [1,1,1]
+      Output: 3
+      Explanation:
+      In the beginning, the distances of the monsters are [1,3,4]. You eliminate the first monster.
+      After a minute, the distances of the monsters are [X,2,3]. You eliminate the second monster.
+      After a minute, the distances of the monsters are [X,X,2]. You eliminate the thrid monster.
+      All 3 monsters can be eliminated.
+
+  Time  : O(N)
+  Space : O(N)
+*/
+
+class Solution {
+public:
+    int eliminateMaximum(vector<int>& dist, vector<int>& speed) {
+        vector<float> v;
+         
+        for(int i = 0 ; i < dist.size() ; i++)
+            v.push_back((float) dist[i] / speed[i]);
+            
+        sort(v.begin(), v.end());
+        int count = 0;
+        int time = 0, i = 0;
+        while(i < v.size()) {
+            if(time >= v[i])
+                return count;
+            ++count;
+            time += 1;
+            ++i;
+        }
+        return count;
+    }
+};