leetcode cpp

Author: AlaaRAD

AddTwoNumbers.cpp

@@ -0,0 +1,65 @@
+#include <iostream>
+
+
+
+// 2. Leetcode add two numbers
+
+
+ // 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* addTwoNumbers(ListNode* l1, ListNode* l2) {
+        
+        ListNode* head = new ListNode();
+        ListNode* current = head;
+        int carry = 0;
+
+        while (l1 != nullptr || l2 != nullptr || carry != 0) {
+            int sum = carry;
+            if (l1 != nullptr) {
+                sum += l1->val;
+                l1 = l1->next;
+            }
+            if (l2 != nullptr) {
+                sum += l2->val;
+                l2 = l2->next;
+            }
+            current->next = new ListNode(sum % 10);
+            carry = sum / 10;
+            current = current->next;
+        }
+
+        return head->next;
+    }
+};
+
+int main()
+{
+    Solution solution;
+
+    ListNode* l1 = new ListNode(2);
+    l1->next = new ListNode(4);
+    l1->next->next = new ListNode(3);
+
+    ListNode* l2 = new ListNode(5);
+    l2->next = new ListNode(6);
+    l2->next->next = new ListNode(4);
+
+    ListNode* result = solution.addTwoNumbers(l1, l2);
+
+    while (result != nullptr) {
+        std::cout << result->val << " ";
+        result = result->next;
+    }
+
+
+    return 0;
+}

LongestSubString.cpp

@@ -0,0 +1,42 @@
+#include <iostream>
+
+
+
+class Solution {
+public:
+    int lengthOfLongestSubstring(std::string s) {
+
+        std::string subString = "";
+        int max =0;
+
+        for (char c : s)
+        {
+        if (subString.find(c) == std::string::npos)
+        {
+            subString += c;
+            if (subString.length() > max)
+            {
+                max = subString.length();
+            }
+
+        }
+        else
+        {
+            subString = "";
+            subString += c;
+        }
+
+        }
+            return max;
+    }
+};
+
+
+
+int main()
+{
+    std::string s = "abcabcbbabcdef";
+    Solution sol;
+    std::cout << sol.lengthOfLongestSubstring(s) << std::endl;
+    return 0;
+}

two_sum.cpp

@@ -0,0 +1,59 @@
+#include <vector>
+#include <iostream>
+#include <unordered_map>
+
+
+class Solution {
+
+    public:
+    std::vector<int> twoSum(std::vector<int>& nums, int target) {
+        
+        std::vector<int> result;
+
+        for (int i = 0; i < nums.size(); i++) {
+            for (int j = i + 1; j < nums.size(); j++) {
+                if (nums[i] + nums[j] == target) {
+                    result.push_back(i);
+                    result.push_back(j);
+                    return result;
+                }
+            }
+        }
+
+        return result;
+    }
+
+    // another solution with unordered map
+    std::vector<int> twoSum2(std::vector<int>& nums, int target) {
+        
+        std::unordered_map<int, int> map;
+        std::vector<int> result;
+        for (int i = 0; i < nums.size(); i++) {
+            int complement = target - nums[i];
+            if (map.find(complement) != map.end()) {
+                result.push_back(map[complement]);
+                result.push_back(i);
+                return result;
+            }
+            map[nums[i]] = i;
+        }
+
+
+
+};
+
+int main() {
+
+    Solution solution;
+
+    std::vector<int> nums = {2, 7, 11, 15};
+    int target = 18;
+
+    std::vector<int> result = solution.twoSum(nums, target);
+
+    for (auto i : result) {
+        std::cout <<  i << std::endl;
+    }
+
+    return 0;
+}