initial commit

.clang-format

@@ -0,0 +1,6 @@
+BasedOnStyle: Google
+AllowShortFunctionsOnASingleLine: false
+SpaceAfterCStyleCast: true
+PointerBindsToType: false
+DerivePointerBinding: false
+IncludeBlocks: Preserve

.gitignore

@@ -0,0 +1,2 @@
+.cache
+build

canJump/meson.build

@@ -0,0 +1 @@
+executable('canJump', 'src/main.cpp', install: true)

canJump/src/canJump.hpp

@@ -0,0 +1,12 @@
+#include <algorithm>
+#include <vector>
+
+inline bool canJump(std::vector<int> &nums) {
+  int max_reach = 0;
+  for (int i = 0; i < int(nums.size()); i++) {
+    if (i > max_reach) return false;
+    max_reach = std::max(max_reach, i + nums[i]);
+    if (max_reach >= int(nums.size()) - 1) return true;
+  }
+  return true;
+}

canJump/src/main.cpp

@@ -0,0 +1,16 @@
+#include <cassert>
+#include <iostream>
+#include <vector>
+#include "canJump.hpp"
+
+int main() {
+  std::vector<int> nums = {2, 3, 1, 1, 4};
+  bool k = canJump(nums);
+  std::cout << k << std::endl;
+  assert(k == true);
+  nums = {3, 2, 1, 0, 4};
+  k = canJump(nums);
+  std::cout << k << std::endl;
+  assert(k == false);
+  return 0;
+}

jump/meson.build

@@ -0,0 +1 @@
+executable('jump', 'src/main.cpp', install: true)

jump/src/jump.hpp

@@ -0,0 +1,18 @@
+#include <vector>
+
+inline int jump(std::vector<int> &nums) {
+  int n = nums.size();
+  if (n <= 1) return 0;
+  int jumps = 0;
+  int current_end = 0;
+  int farthest = 0;
+  for (int i = 0; i < n - 1; i++) {
+    farthest = std::max(farthest, i + nums[i]);
+    if (i == current_end) {
+      jumps += 1;
+      current_end = farthest;
+      if (current_end >= n - 1) break;
+    }
+  }
+  return jumps;
+}

jump/src/main.cpp

@@ -0,0 +1,13 @@
+#include <cassert>
+#include <vector>
+#include "jump.hpp"
+
+int main() {
+  std::vector<int> nums = {2, 3, 1, 1, 4};
+  int output = jump(nums);
+  assert(output == 2);
+  nums = {2, 3, 0, 1, 4};
+  output = jump(nums);
+  assert(output == 2);
+  return 0;
+}

majorityelement/meson.build

@@ -0,0 +1 @@
+executable('majorityelement', 'src/main.cpp', install: true)

majorityelement/src/main.cpp

@@ -0,0 +1,10 @@
+#include <cassert>
+#include <iostream>
+#include "majorityelement.hpp"
+
+int main() {
+  std::vector<int> nums = {3,2,2,3};
+  int k = majorityElement(nums);
+  std::cout << "k: " << k << std::endl;
+  return 0;
+}

majorityelement/src/majorityelement.hpp

@@ -0,0 +1,10 @@
+#include <vector>
+
+inline int majorityElement(std::vector<int> &nums) {
+  int candidate, count = 0;
+  for (auto num : nums) {
+    if (!count) candidate = num;
+    num == candidate ? count += 1 : count -= 1;
+  }
+  return candidate;
+}

maxprofit/meson.build

@@ -0,0 +1 @@
+executable('maxprofit', 'src/main.cpp', install: true)

maxprofit/src/main.cpp

@@ -0,0 +1,16 @@
+#include <cassert>
+#include <vector>
+#include "maxprofit.hpp"
+#include <iostream>
+
+int main() {
+    std::vector<int> prices = {7,1,5,3,6,4};
+    int output = maxProfit(prices);
+    std::cout << "output: " << output << std::endl;
+    assert(output == 5);
+    prices = {7,6,4,3,1};
+    output = maxProfit(prices);
+    std::cout << "output: " << output << std::endl;
+    assert(output == 0);
+    return 0;
+}

maxprofit/src/maxprofit.hpp

@@ -0,0 +1,13 @@
+#include <cmath>
+#include <vector>
+
+inline int maxProfit(std::vector<int> &prices) {
+  int max_profit = 0;
+  float min_price = INFINITY;
+  for (int i = 0; i < int(prices.size()); i++) {
+    if (prices[i] < min_price) min_price = prices[i];
+    int profit = prices[i] - min_price;
+    if (profit > max_profit) max_profit = profit;
+  }
+  return max_profit;
+}

maxprofit2/meson.build

@@ -0,0 +1 @@
+executable('maxprofit2', 'src/main.cpp', install: true)

maxprofit2/src/main.cpp

@@ -0,0 +1,19 @@
+#include <cassert>
+#include <iostream>
+#include "maxprofit2.hpp"
+
+int main() {
+  std::vector<int> prices = {7, 1, 5, 3, 6, 4};
+  int k = maxProfit(prices);
+  std::cout << "k: " << k << std::endl;
+  assert(k == 7);
+  prices = {1, 2, 3, 4, 5};
+  k = maxProfit(prices);
+  std::cout << "k: " << k << std::endl;
+  assert(k == 4);
+  prices = {7, 6, 4, 3, 1};
+  k = maxProfit(prices);
+  std::cout << "k: " << k << std::endl;
+  assert(k == 0);
+  return 0;
+}

maxprofit2/src/maxprofit2.hpp

@@ -0,0 +1,11 @@
+#include <vector>
+
+inline int maxProfit(std::vector<int> &prices) {
+  int profit = 0;
+  for (int i = 1; i < int(prices.size()); i++) {
+    if (prices[i] > prices[i - 1]) {
+      profit += prices[i] - prices[i - 1];
+    }
+  }
+  return profit;
+}

meson.build

@@ -0,0 +1,10 @@
+project('leetcode', 'cpp', default_options: ['cpp_std=c++20'])
+subdir('maxprofit')
+subdir('rotate')
+subdir('majorityelement')
+subdir('twopointers')
+subdir('rmdupfromsortedarray')
+subdir('rmdupfromsortedarray2')
+subdir('maxprofit2')
+subdir('canJump')
+subdir('jump')

rmdupfromsortedarray/meson.build

@@ -0,0 +1 @@
+executable('rmdupfromsortedarray', 'src/main.cpp', install: true)

rmdupfromsortedarray/src/main.cpp

@@ -0,0 +1,13 @@
+#include "rmdupsfromsortedarray.hpp"
+#include <cassert>
+#include <iostream>
+
+int main() {
+  std::vector<int> nums1 = {1,1,2};
+  int k1 = removeDuplicates(nums1);
+  for (int i = 0; i < k1; i++) {
+      std::cout << "num1: " << nums1[i] << std::endl;
+  }
+  std::cout << "k1: " << k1 << std::endl;
+  return 0;
+}

rmdupfromsortedarray/src/rmdupsfromsortedarray.hpp

@@ -0,0 +1,13 @@
+#include <vector>
+
+inline int removeDuplicates(std::vector<int> &nums) {
+  int n = nums.size();
+  int i = 0;
+  for (int j = 0; j < n; j++) {
+    if (nums[j] != nums[i]) {
+      nums[i + 1] = nums[j];
+      i++;
+    }
+  }
+  return i + 1;
+}

rmdupfromsortedarray2/meson.build

@@ -0,0 +1 @@
+executable('rmdupfromsortedarray2', 'src/main.cpp', install: true)

rmdupfromsortedarray2/src/main.cpp

@@ -0,0 +1,15 @@
+#include "rmdufromsortedarray2.hpp"
+#include <cassert>
+#include <vector>
+
+int main() {
+  std::vector<int> nums = {1, 1, 1, 2, 2, 3};
+  std::vector<int> expectednums = {1, 1, 2, 2, 3};
+  int k = removeDuplicates(nums);
+  assert(k == int(expectednums.size()));
+  for (int i = 0; i < k; i++)
+  {
+      assert(nums[i] == expectednums[i]);
+  }
+  return 0;
+}

rmdupfromsortedarray2/src/rmdufromsortedarray2.hpp

@@ -0,0 +1,14 @@
+#include <vector>
+
+inline int removeDuplicates(std::vector<int> &nums) {
+  const int n = nums.size();
+  if (n <= 2) return n;
+
+  int i = 2;
+  for (int j = 2; j < n; ++j) {
+    if (nums[j] != nums[i - 2]) [[likely]] {
+      nums[i++] = nums[j];
+    }
+  }
+  return i;
+}

rotate/meson.build

@@ -0,0 +1 @@
+executable('rotate', 'src/main.cpp', install: true)

rotate/src/main.cpp

@@ -0,0 +1,38 @@
+// #include "twopointers.hpp"
+// #include "rmdupsfromsortedarray.hpp"
+// #include "rmdufromsortedarray2.hpp"
+#include <cassert>
+#include <iostream>
+// #include "majorityelement.hpp"
+#include "rotate.hpp"
+
+int main() {
+  // std::vector<int> nums = {3,2,2,3};
+  // int val = 3;
+  // int k = removeElement(nums, val);
+  // for (int i = 0; i < k; i++) {
+  //     std::cout << "num: " << nums[i] << std::endl;
+  // }
+  // std::cout << "k: " << k << std::endl;
+
+  // std::vector<int> nums1 = {1,1,2};
+  // int k1 = removeDuplicates(nums1);
+  // for (int i = 0; i < k1; i++) {
+  //     std::cout << "num1: " << nums1[i] << std::endl;
+  // }
+  // std::cout << "k1: " << k1 << std::endl;
+  // std::vector<int> nums = {1, 1, 1, 2, 2, 3};
+  // std::vector<int> expectednums = {1, 1, 2, 2, 3};
+  // int k = removeDuplicates(nums);
+  // assert(k == expectednums.size());
+  // for (int i = 0; i < k; i++)
+  // {
+  //     assert(nums[i] == expectednums[i]);
+  // }
+  std::vector<int> nums = {1, 2, 3, 4, 5, 6, 7};
+  rotateArray(nums, 3);
+  for (int i = 0; i < int(nums.size()); i++) {
+    std::cout << "num: " << nums[i] << std::endl;
+  }
+  return 0;
+}

rotate/src/rotate.hpp

@@ -0,0 +1,13 @@
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+inline void rotateArray(std::vector<int> &nums, int k) {
+  int n = nums.size();
+  if (n == 0) return;
+  k %= n;
+
+  std::reverse(nums.begin(), nums.end());
+  std::reverse(nums.begin(), nums.begin() + k);
+  std::reverse(nums.begin() + k, nums.end());
+}

twopointers/meson.build

@@ -0,0 +1 @@
+executable('twopointers', 'src/main.cpp', install: true)

twopointers/src/main.cpp

@@ -0,0 +1,14 @@
+#include "twopointers.hpp"
+#include <cassert>
+#include <iostream>
+
+int main() {
+  std::vector<int> nums = {3,2,2,3};
+  int val = 3;
+  int k = removeElement(nums, val);
+  for (int i = 0; i < k; i++) {
+      std::cout << "num: " << nums[i] << std::endl;
+  }
+  std::cout << "k: " << k << std::endl;
+  return 0;
+}

twopointers/src/twopointers.hpp

@@ -0,0 +1,12 @@
+#include <vector>
+
+inline int removeElement(std::vector<int> &nums, int val) {
+  int k = 0;
+  for (int i = 0; i < int(nums.size()); i++) {
+    if (nums[i] != val) {
+      nums[k] = nums[i];
+      k += 1;
+    }
+  }
+  return k;
+}