fix multiply exercise

Author: charliesbot

cpp/0001_two_sum/0001_two_sum.h

@@ -8,11 +8,11 @@ class Solution {
 public:
   vector<int> twoSum(vector<int> &nums, int target) {
     unordered_map<int, int> umap;
-    for (int i = 0; i < nums.size(); i++) {
+    for (size_t i = 0; i < nums.size(); i++) {
       const int current = nums[i];
 
       if (umap.count(current) > 0) {
-        return {i, umap[current]};
+        return {(int)i, umap[current]};
       }
 
       const int diff = target - nums[i];

cpp/0003_longest_substring_without_repeating_characters/0003_longest_substring_without_repeating_characters.h

@@ -14,7 +14,7 @@ class Solution {
     int max_length = 0;
     int start = 0;
 
-    for (int i = 0; i < s.length(); i++) {
+    for (size_t i = 0; i < s.length(); i++) {
       const char &letter = s[i];
 
       if (hash.find(letter) != hash.end() && hash[letter] >= start) {

cpp/0020_valid_parentheses/0020_valid_parentheses_test.cc

@@ -7,23 +7,23 @@ using std::string;
 TEST(ValidParenthesisTest, SimpleString) {
   string s = "()";
 
-  ASSERT_TRUE(Solution().isValid(s));
+  EXPECT_TRUE(Solution().isValid(s));
 }
 
 TEST(ValidParenthesisTest, AllSymbolsString) {
   string s = "()[]{}";
 
-  ASSERT_TRUE(Solution().isValid(s));
+  EXPECT_TRUE(Solution().isValid(s));
 }
 
 TEST(ValidParenthesisTest, InvalidString) {
   string s = "(]";
 
-  ASSERT_FALSE(Solution().isValid(s));
+  EXPECT_FALSE(Solution().isValid(s));
 }
 
 TEST(ValidParenthesisTest, InvalidString2) {
   string s = "]";
 
-  ASSERT_FALSE(Solution().isValid(s));
+  EXPECT_FALSE(Solution().isValid(s));
 }

cpp/0043_multiply_strings/0043_multiply_strings.h

@@ -2,58 +2,56 @@
  * return the product of num1 and num2, also represented as a string.
  */
 
-#include <string>
+#include <algorithm>
 #include <math.h>
+#include <string>
 #include <vector>
-#include <algorithm>
 
 using std::string;
 
 class Solution {
 public:
   string multiply(string num1, string num2) {
-    std::vector<int> result(num1.length() + num2.length(), 0);
+    if (num1.length() < num2.length()) {
+      std::swap(num1, num2);
+    }
 
+    std::vector<int> result(num1.length() + num2.length(), 0);
+    int carry = 0;
     int flag = 0;
 
-    for (int index1 = num1.length() - 1; index1 >= 0; index1--) {
-      int carry = 0;
-      int result_index = 0;
-      for (int index2 = num2.length() - 1; index2 >= 0; index2--) {
-        const int& raw_result = num1[index1] * num2[index2] + carry + result[result_index + flag];
-        result[result_index +flag] = raw_result % 10;
-        carry = floor(raw_result / 10);
-        result_index++;
+    for (int i = num2.length() - 1; i >= 0; i--) {
+      for (int j = num1.length() - 1; j >= 0; j--) {
+        const int result_index = num1.length() - 1 - j + flag;
+        const int a = num1[j] - '0';
+        const int b = num2[i] - '0';
+        const int current = a * b + carry + result[result_index];
+        carry = floor(current / 10);
+        result[result_index] = current % 10;
+        if (j == 0 && carry > 0) {
+          result[num1.length() + flag] += carry;
+          carry = 0;
+        }
       }
       flag++;
     }
 
-    while(result.size() > 1) {
+    while (result.size() > 1) {
       if (result.back() > 0) {
         break;
       }
+
       result.pop_back();
     }
 
     std::reverse(result.begin(), result.end());
 
     string string_result = "";
 
-    for(const int& letter: result) {
+    for (const int &letter : result) {
       string_result += std::to_string(letter);
     }
 
     return string_result;
   }
 };
-
-/*
- 32
-219
----
-carry = 0
-
-[8, 0, 0, 7, 0]
-
-7008
-*/

cpp/0043_multiply_strings/0043_multiply_strings_test.cc

@@ -1,21 +1,22 @@
-import { multiply } from "./0043_multiply_strings";
+#include "0043_multiply_strings.h"
+#include <gtest/gtest.h>
 
-test("multiply1", () => {
-  expect(multiply("2", "3")).toEqual("6");
-});
+TEST(MultiplyStrings, Example1) {
+  EXPECT_EQ(Solution().multiply("2", "3"), "6");
+}
 
-test("multiply2", () => {
-  expect(multiply("589", "24")).toBe("14136");
-});
+TEST(MultiplyStrings, Example2) {
+  EXPECT_EQ(Solution().multiply("589", "24"), "14136");
+}
 
-test("multiply3", () => {
-  expect(multiply("5891", "243")).toBe("1431513");
-});
+TEST(MultiplyStrings, Example3) {
+  EXPECT_EQ(Solution().multiply("5891", "243"), "1431513");
+}
 
-test("multiply4", () => {
-  expect(multiply("123", "456")).toEqual("56088");
-});
+TEST(MultiplyStrings, Example4) {
+  EXPECT_EQ(Solution().multiply("123", "456"), "56088");
+}
 
-test("multiply5", () => {
-  expect(multiply("0", "0")).toEqual("0");
-});
+TEST(MultiplyStrings, Example5) {
+  EXPECT_EQ(Solution().multiply("0", "0"), "0");
+}

cpp/0200_number_of_islands/0200_number_of_islands.h

@@ -21,8 +21,8 @@ class Solution {
 public:
   int numIslands(vector<vector<char>> &grid) {
     int islands = 0;
-    for (int row = 0; row < grid.size(); row++) {
-      for (int column = 0; column < grid[row].size(); column++) {
+    for (size_t row = 0; row < grid.size(); row++) {
+      for (size_t column = 0; column < grid[row].size(); column++) {
         if (grid[row][column] == '1') {
           islands++;
           dfs(grid, row, column);

cpp/0217_contains_duplicate/0217_contains_duplicate.h

@@ -0,0 +1,20 @@
+#include <unordered_set>
+#include <vector>
+
+using ::std::unordered_set;
+using ::std::vector;
+
+class Solution {
+public:
+  bool containsDuplicate(vector<int> &nums) {
+    unordered_set<int> unique_numbers;
+    for (const int &number : nums) {
+      if (unique_numbers.find(number) != unique_numbers.end()) {
+        return true;
+      }
+      unique_numbers.insert(number);
+    }
+
+    return false;
+  }
+};

cpp/0217_contains_duplicate/0217_contains_duplicate_test.cc

@@ -0,0 +1,22 @@
+#include "0217_contains_duplicate.h"
+#include <gtest/gtest.h>
+
+using std::vector;
+
+TEST(ContainsDuplicateTest, Example1) {
+  vector<int> nums = {1, 2, 3, 1};
+
+  ASSERT_TRUE(Solution().containsDuplicate(nums));
+}
+
+TEST(ContainsDuplicateTest, Example2) {
+  vector<int> nums = {1, 2, 3, 4};
+
+  ASSERT_FALSE(Solution().containsDuplicate(nums));
+}
+
+TEST(ContainsDuplicateTest, Example3) {
+  vector<int> nums = {1, 1, 1, 3, 3, 4, 3, 2, 4, 2};
+
+  ASSERT_TRUE(Solution().containsDuplicate(nums));
+}