8/8/23 and 8/9/23

- convert_base.cc
- replace_and_remove.cc
- spreadsheet_encoding.cc
- is_string_palindromic_punctuation.cc
- reverse_words.cc
- delete_from_list.cc
- int_as_list_add.cc

Author: jsgoller1

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

@@ -1,11 +1,90 @@
+#include <cmath>
 #include <string>
 
 #include "test_framework/generic_test.h"
 using std::string;
 
+/*
+- num can be between int max and min
+- int can be negative, and may have prefixes
+- 0 is valid in any base
+- b1, b2 are 2-16
+- converting bin string to dec int: multiply each digit by power of two, sum and
+return
+- converting dec int to bin string: left to right starting from closest pow of 2
+less than num: # set bit and subtract value.
+*/
+
+#define ASCII_ZERO 48
+#define ASCII_A_LOWER 97
+#define ASCII_A_UPPER 65
+
+int digitToInt(const char digit) {
+  if ('0' <= digit && digit <= '9') {
+    return digit - ASCII_ZERO;
+  } else if ('A' <= digit && digit <= 'F') {
+    return digit - ASCII_A_UPPER + 10;
+  } else if ('a' <= digit && digit <= 'f') {
+    return digit - ASCII_A_LOWER + 10;
+  }
+  return -1;
+}
+
+char intToDigit(const int val) {
+  if (0 <= val && val <= 9) {
+    return val + ASCII_ZERO;
+  } else if (0xA <= val && val <= 0xF) {
+    return val - 10 + ASCII_A_UPPER;
+  }
+  return '!';
+}
+
+int stringToInt(const string& val, int oldBase) {
+  bool neg = val[0] == '-';
+  int total = 0;
+  int pow = 1;
+  for (int i = val.size() - 1; i >= (neg ? 1 : 0); i--) {
+    total += (digitToInt(val[i]) * pow);
+    pow *= oldBase;
+  }
+  return total * (neg ? -1 : 1);
+}
+string intToString(int value, int newBase) {
+  if (!value) {
+    return "0";
+  }
+  bool neg = value < 0;
+  value = abs(value);
+
+  string representation = neg ? "-" : "";
+  long exp = 0;
+  long sym = 1;
+  while ((sym * long(pow(newBase, exp))) <= value) {
+    exp++;
+  }
+  exp--;
+
+  while (value) {
+    sym = newBase - 1;
+    while ((sym * int(pow(newBase, exp))) > value && sym > 0) {
+      sym--;
+    }
+    representation += intToDigit(sym);
+    value -= (sym * int(pow(newBase, exp)));
+    exp--;
+  }
+  while (exp >= 0) {
+    representation += '0';
+    exp--;
+  }
+
+  return representation;
+}
+
 string ConvertBase(const string& num_as_string, int b1, int b2) {
-  // TODO - you fill in here.
-  return "";
+  int base10Val = stringToInt(num_as_string, b1);
+  string newVal = intToString(base10Val, b2);
+  return newVal;
 }
 
 int main(int argc, char* argv[]) {

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

@@ -5,9 +5,13 @@
 #include "test_framework/timed_executor.h"
 using std::shared_ptr;
 
+// If not tail, then the next node might be the tail,
+// so node.next == null.
+
 // Delete the node past this one. Assume node is not a tail.
 void DeleteAfter(const shared_ptr<ListNode<int>>& node) {
-  // TODO - you fill in here.
+  shared_ptr<ListNode<int>> deleteMe = node->next;
+  node->next = node->next->next;
   return;
 }
 shared_ptr<ListNode<int>> DeleteFromListWrapper(

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

@@ -1,10 +1,34 @@
 #include "list_node.h"
 #include "test_framework/generic_test.h"
 
+/*
+  - keep place, iterate through, (digit + digit) * place
+  - need carry if adding node by node.
+  - negatives? can handle by reading both to ints first then adding
+  - no empty list
+*/
+
 shared_ptr<ListNode<int>> AddTwoNumbers(shared_ptr<ListNode<int>> L1,
                                         shared_ptr<ListNode<int>> L2) {
-  // TODO - you fill in here.
-  return nullptr;
+  int carry = 0;
+  int total = 0;
+  shared_ptr<ListNode<int>> current = make_shared<ListNode<int>>();
+  shared_ptr<ListNode<int>> head = current;
+  while (L1 || L2 || carry) {
+    int val1 = (L1 != nullptr) ? L1->data : 0;
+    int val2 = (L2 != nullptr) ? L2->data : 0;
+    L1 = (L1 == nullptr) ? nullptr : L1->next;
+    L2 = (L2 == nullptr) ? nullptr : L2->next;
+
+    // Assuming no negatives.
+    total = (val1 + val2 + carry) % 10;
+    carry = (val1 + val2 + carry >= 10) ? 1 : 0;
+
+    current->next = make_shared<ListNode<int>>();
+    current->next->data = total;
+    current = current->next;
+  }
+  return head->next;
 }
 
 int main(int argc, char* argv[]) {

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

@@ -2,8 +2,46 @@
 
 #include "test_framework/generic_test.h"
 using std::string;
+
+/*
+- two pointer palindrome test
+- Can contain non-alphanumerics, spaces, etc. Can use isalnum
+- possibly empty
+- need to compare lowercase to lowercase for alphas, tolower()
+- edge cases:
+  - empty
+  - 11111111 (is palindrome)
+  - 11111aa (is not palindrome)
+  - !!!!!aa is palindrome
+*/
+
 bool IsPalindrome(const string& s) {
-  // TODO - you fill in here.
+  if (s.empty()) {
+    return true;
+  }
+
+  int l = 0, r = s.size() - 1;
+  while (l < r) {
+    // Find next suitable lefts and rights
+    if (!isalnum(s[l])) {
+      l++;
+      continue;
+    }
+    if (!isalnum(s[r])) {
+      r--;
+      continue;
+    }
+
+    char left = s[l], right = s[r];
+    // left is a digit and the other isn't / vice versa.
+    if ((isdigit(left) != isdigit(right)) ||
+        // tolower() returns the arg if no lowercase is available, works for
+        // digits.
+        (tolower(left) != tolower(right))) {
+      return false;
+    }
+    l++, r--;
+  }
   return true;
 }
 

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

@@ -7,10 +7,92 @@
 using std::string;
 using std::vector;
 
+/*
+- Replace every `a` with `d d`.
+- Delete every b.
+- Can assume s has enough space for final result
+- Do not need to worry about values beyond size (e.g. array[0] to array[size]
+must be represented in the final array)
+- If we process it backwards, the dd overwrites will only overwrite chars we've
+seen already. We know where it ends (or we can figure it out)
+---
+Trivial (o(n) on time and space): produce correct array, overwrite everything in
+original
+
+Cases:
+  - empty
+  - No replace (efgh)
+  - all replace (aaaaaaaa)
+  - all delete (bbbb)
+*/
+
+int ReplaceAndRemoveBruteForce(int size, char s[]) {
+  vector<char> processed;
+  for (int i = 0; i < size; i++) {
+    switch (s[i]) {
+      case 'b':
+        break;
+      case 'a':
+        processed.push_back('d');
+        processed.push_back('d');
+        break;
+      default:
+        processed.push_back(s[i]);
+        break;
+    }
+  }
+  for (int i = 0; i < processed.size(); i++) {
+    s[i] = processed[i];
+  }
+  return processed.size();
+}
+
+int calculateFinalSize(int size, char s[]) {
+  int finalSize = 0;
+  for (int i = 0; i < size; i++) {
+    switch (s[i]) {
+      case 'b':
+        break;
+      case 'a':
+        finalSize += 2;
+        break;
+      default:
+        finalSize++;
+        break;
+    }
+  }
+  return finalSize;
+}
+
+int removeB(int size, char s[]) {
+  int j = 0;
+  for (int i = 0; i < size; i++) {
+    if (s[i] == 'b') {
+      continue;
+    }
+    s[j++] = s[i];
+  }
+  return j;
+}
+
+void replaceA(int size, int finalSize, char s[]) {
+  for (int i = finalSize - 1, j = size - 1; j >= 0; j--) {
+    if (s[j] == 'a') {
+      s[i--] = 'd';
+      s[i--] = 'd';
+    } else {
+      s[i--] = s[j];
+    }
+  }
+}
+
 int ReplaceAndRemove(int size, char s[]) {
-  // TODO - you fill in here.
-  return 0;
+  int finalSize = calculateFinalSize(size, s);
+  int newEnd = removeB(size, s);
+  replaceA(newEnd, finalSize, s);
+  return finalSize;
 }
+
 vector<string> ReplaceAndRemoveWrapper(TimedExecutor& executor, int size,
                                        const vector<string>& s) {
   std::vector<char> s_copy(s.size(), '\0');

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

@@ -1,13 +1,57 @@
 #include <string>
+#include <vector>
 
 #include "test_framework/generic_test.h"
 #include "test_framework/timed_executor.h"
+using std::pair;
 using std::string;
+using std::vector;
+
+/*
+- Create an array of indexes and lengths, one for each word.
+- Reverse the array
+- Copy into a new string, then overwrite old
+- Time: O(n): each step (array creation, reversal, copying, overwriting) is
+linear
+- Takes n space for array of pairs, and n extra space for new string
+
+- Happy cases:
+  "bob talks to alice" -> "alice to talks bob"
+- Edge cases:
+  - Empty string
+  - String contains one word ("aaaaaaa")
+  - Assuming words are delimited by whitespaces; don't actually know
+  - What if there are multiple whitespaces between words? Assume not a case.
+
+ Then just reverse this list and copy it into a string.
+ -----
+ Better: mark where words are in the string. Reverse the string, then reverse
+each word.
+*/
+
+vector<int> markSpaces(const string& s) {
+  vector<int> spaceIdx;
+  for (int i = 0; i < s.size(); i++) {
+    if (s[i] == ' ') {
+      spaceIdx.push_back(i);
+    }
+  }
+  spaceIdx.push_back(s.size());
+  return spaceIdx;
+}
 
 void ReverseWords(string* s) {
-  // TODO - you fill in here.
-  return;
+  string& sentence = *s;
+  reverse(sentence.begin(), sentence.end());
+  vector<int> spaces = markSpaces(sentence);
+  int left = 0;
+  for (int i = 0; i < spaces.size(); i++) {
+    int right = spaces[i];
+    reverse(sentence.begin() + left, sentence.begin() + right);
+    left = spaces[i] + 1;
+  }
 }
+
 string ReverseWordsWrapper(TimedExecutor& executor, string s) {
   string s_copy = s;
 
@@ -17,6 +61,7 @@ string ReverseWordsWrapper(TimedExecutor& executor, string s) {
 }
 
 int main(int argc, char* argv[]) {
+  /**/
   std::vector<std::string> args{argv + 1, argv + argc};
   std::vector<std::string> param_names{"executor", "s"};
   return GenericTestMain(args, "reverse_words.cc", "reverse_words.tsv",

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

@@ -1,11 +1,37 @@
+#include <cmath>
 #include <string>
 
 #include "test_framework/generic_test.h"
 using std::string;
 
+/*
+A-Z = 1 to 26
+AA = 27
+ZZ = 702
+
+- Not considering empty str
+- This is a different kind of base 26; rightmost column is mod 26, next is mod
+26*26.
+- A to ZZ inclusive is 702 (26*26 + 26)
+*/
+
+#define ASCII_A 64  // so A = 1
+
+int SSDecodeColIDWithExp(const string& col) {
+  int total = 0;
+  int exp = 0;
+  for (auto it = col.rbegin(); it != col.rend(); it++, exp++) {
+    total += ((*it - ASCII_A) * pow(26, exp));
+  }
+  return total;
+}
+
 int SSDecodeColID(const string& col) {
-  // TODO - you fill in here.
-  return 0;
+  int total = 0;
+  for (auto it = col.begin(); it != col.end(); it++) {
+    total = (total * 26) + *it - 'A' + 1;
+  }
+  return total;
 }
 
 int main(int argc, char* argv[]) {