8/5/23

- Buy and sell single share of stock (C++/Py)
- Buy and sell two shares of stock (C++/Py)
- Alternating array
- Is string palindromic
- Print all primes between 0 and n
- Anki updates

Author: jsgoller1

anki/Competitive Programming.apkg

@@ -7,7 +7,17 @@
 #include "test_framework/timed_executor.h"
 using std::vector;
 void Rearrange(vector<int>* A_ptr) {
-  // TODO - you fill in here.
+  vector<int>& A = *A_ptr;
+  if (A.size() == 0) {
+    return;
+  }
+  for (size_t i = 0; i < A.size() - 1; i++) {
+    if (((i % 2 == 0) && A[i] > A[i + 1]) || ((i % 2) && A[i] < A[i + 1])) {
+      int tmp = A[i];
+      A[i] = A[i + 1];
+      A[i + 1] = tmp;
+    }
+  }
   return;
 }
 void CheckAnswer(const vector<int>& A) {

elements-of-programming-interviews/cpp/alternating_array.cc

@@ -3,8 +3,13 @@
 #include "test_framework/generic_test.h"
 using std::vector;
 double BuyAndSellStockOnce(const vector<double>& prices) {
-  // TODO - you fill in here.
-  return 0.0;
+  double bestBuy = prices[0];
+  double bestSell = 0.0;
+  for (auto price : prices) {
+    bestBuy = (bestBuy < price) ? bestBuy : price;
+    bestSell = (bestSell > price - bestBuy) ? bestSell : price - bestBuy;
+  }
+  return bestSell;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/cpp/buy_and_sell_stock.cc

@@ -1,10 +1,23 @@
+#include <limits>
 #include <vector>
 
 #include "test_framework/generic_test.h"
 using std::vector;
 double BuyAndSellStockTwice(const vector<double>& prices) {
-  // TODO - you fill in here.
-  return 0.0;
+  double negative_infinity = -std::numeric_limits<double>::infinity();
+  double firstBuy = negative_infinity;
+  double firstSell = 0.0;
+  double secondBuy = negative_infinity;
+  double secondSell = 0.0;
+  for (auto price : prices) {
+    firstBuy = (firstBuy > -price) ? firstBuy : -price;
+    firstSell = (firstSell > (price + firstBuy)) ? firstSell : price + firstBuy;
+    secondBuy =
+        (secondBuy > (firstSell - price)) ? secondBuy : firstSell - price;
+    secondSell =
+        (secondSell > (secondBuy + price)) ? secondSell : secondBuy + price;
+  }
+  return secondSell;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/cpp/buy_and_sell_stock_twice.cc

@@ -2,8 +2,18 @@
 
 #include "test_framework/generic_test.h"
 using std::string;
+
 bool IsPalindromic(const string& s) {
-  // TODO - you fill in here.
+  if (s.empty()) {
+    return false;
+  }
+  int l = 0, r = s.size() - 1;
+  while (l <= r) {
+    if (s[l++] != s[r--]) {
+      return false;
+    }
+  }
+
   return true;
 }
 

elements-of-programming-interviews/cpp/is_string_palindromic.cc

@@ -2,10 +2,41 @@
 
 #include "test_framework/generic_test.h"
 using std::vector;
-// Given n, return all primes up to and including n.
+// Brute force method. Given n return all primes up to and including n.
+vector<int> GeneratePrimesBruteForce(int n) {
+  int counter = 0;
+  if (n == 0 || n == 1) {
+    return {};
+  }
+  vector<int> primes{2};
+  for (int i = 2; i <= n; i++) {
+    int j = 0;
+    for (; j < primes.size(); j++) {
+      if (!(i % primes[j])) {
+        break;
+      }
+    }
+    if (j == primes.size()) {
+      primes.push_back(i);
+    }
+  }
+  return primes;
+}
+
 vector<int> GeneratePrimes(int n) {
-  // TODO - you fill in here.
-  return {};
+  // Sieve of Eratosthenes
+  vector<int> primes;
+  vector<bool> table(n + 1, false);
+  for (size_t i = 2; i <= n; i++) {
+    if (table[i] == true) {
+      continue;
+    }
+    primes.push_back(i);
+    for (size_t j = 0; j <= n; j += i) {
+      table[j] = true;
+    }
+  }
+  return primes;
 }
 
 int main(int argc, char* argv[]) {

elements-of-programming-interviews/cpp/prime_sieve.cc

@@ -256,57 +256,57 @@ problem_mapping = {
         },
         "5.06 Buy and sell a stock once": {
             "C++: buy_and_sell_stock.cc": {
-                "passed": 0,
+                "passed": 402,
                 "total": 402
             },
             "Java: BuyAndSellStock.java": {
                 "passed": 0,
                 "total": 402
             },
             "Python: buy_and_sell_stock.py": {
-                "passed": 0,
+                "passed": 402,
                 "total": 402
             }
         },
         "5.07 Buy and sell a stock twice": {
             "C++: buy_and_sell_stock_twice.cc": {
-                "passed": 0,
+                "passed": 402,
                 "total": 402
             },
             "Java: BuyAndSellStockTwice.java": {
                 "passed": 0,
                 "total": 402
             },
             "Python: buy_and_sell_stock_twice.py": {
-                "passed": 0,
+                "passed": 402,
                 "total": 402
             }
         },
         "5.08 Computing an alternation": {
             "C++: alternating_array.cc": {
-                "passed": 0,
+                "passed": 203,
                 "total": 203
             },
             "Java: AlternatingArray.java": {
                 "passed": 0,
                 "total": 203
             },
             "Python: alternating_array.py": {
-                "passed": 0,
+                "passed": 203,
                 "total": 203
             }
         },
         "5.09 Enumerate all primes to n": {
             "C++: prime_sieve.cc": {
-                "passed": 0,
+                "passed": 24,
                 "total": 24
             },
             "Java: PrimeSieve.java": {
                 "passed": 0,
                 "total": 24
             },
             "Python: prime_sieve.py": {
-                "passed": 0,
+                "passed": 24,
                 "total": 24
             }
         },
@@ -468,15 +468,15 @@ problem_mapping = {
     "Chapter 06: Strings": {
         "6.00 Bootcamp: Strings": {
             "C++: is_string_palindromic.cc": {
-                "passed": 0,
+                "passed": 10000,
                 "total": 10000
             },
             "Java: IsStringPalindromic.java": {
                 "passed": 0,
                 "total": 10000
             },
             "Python: is_string_palindromic.py": {
-                "passed": 0,
+                "passed": 10000,
                 "total": 10000
             }
         },

elements-of-programming-interviews/problem_mapping.js

@@ -7,7 +7,23 @@
 
 
 def rearrange(A: List[int]) -> None:
-    # TODO - you fill in here.
+    A.sort()
+    i = 1
+    while i < len(A)-1:
+        tmp = A[i]
+        A[i] = A[i+1]
+        A[i+1] = tmp
+        i += 2
+    return
+
+
+def rearrange(A: List[int]) -> None:
+    for i in range(len(A)-1):
+        if ((i % 2 == 0) and A[i] > A[i+1]) or (i % 2 and A[i] < A[i+1]):
+            tmp = A[i]
+            A[i] = A[i+1]
+            A[i+1] = tmp
+            i += 2
     return
 
 

elements-of-programming-interviews/python/alternating_array.py

@@ -3,9 +3,41 @@
 from test_framework import generic_test
 
 
+def buy_and_sell_stock_once_reversed(prices: List[float]) -> float:
+    highest = prices[-1]
+    profit = 0.0
+    for price in prices[::-1]:
+        highest = max(highest, price)
+        profit = max(profit, highest-price)
+    return profit
+
+
+def buy_and_sell_stock_once_explicit_min_price(prices: List[float]) -> float:
+    lowest_price = float('inf')
+    best_profit = 0
+    for price in prices:
+        lowest_price = min(price, lowest_price)
+        best_profit = max(best_profit, price-lowest_price)
+    return best_profit
+
+
 def buy_and_sell_stock_once(prices: List[float]) -> float:
-    # TODO - you fill in here.
-    return 0.0
+    """
+    On every day given the stock price, we can do one of 3 things:
+    3) Sell 1st share. Profit: price - lowest price so far. 
+    4) Buy 1st share. Profit: -price.
+    5) Nothing so far. Profit: 0.
+
+    To get the best possible sale for each, use the max function. 
+    """
+    first_buy = -float('inf')
+    first_sell = 0
+
+    for price in prices:
+        first_buy = max(first_buy, -price)
+        first_sell = max(first_sell, price + first_buy)
+
+    return first_sell
 
 
 if __name__ == '__main__':

elements-of-programming-interviews/python/buy_and_sell_stock.py

@@ -4,8 +4,31 @@
 
 
 def buy_and_sell_stock_twice(prices: List[float]) -> float:
-    # TODO - you fill in here.
-    return 0.0
+    """
+    On every day given the stock price, we can do one of 5 things:
+    1) Sell 2nd share. Profit: profit from 2nd buy + price. 
+    2) Buy 2nd share. Profit: profit from first sale - price.
+    3) Sell 1st share. Profit: price - lowest price so far. 
+    4) Buy 1st share. Profit: -price.
+    5) Nothing so far. Profit: 0.
+
+    To get the best possible sale for each, use the max function. The ordering we do the updates in actually doesn't
+    matter and still produces the correct result for the tests; however, the since the best second sell day depends
+    on the best second buy day, which in turn depends on the best first sell day, the order should be first_buy -> first_sell ->
+    second_buy -> second_sell.
+    """
+    first_buy = -float('inf')
+    first_sell = 0
+    second_buy = -float('inf')
+    second_sell = 0
+
+    for price in prices:
+        first_buy = max(first_buy, -price)
+        first_sell = max(first_sell, price + first_buy)
+        second_buy = max(second_buy, first_sell - price)
+        second_sell = max(second_sell, second_buy + price)
+
+    return second_sell
 
 
 if __name__ == '__main__':