did a problem I was stuck on and a new one

Author: Github11200

Solutions/DMOJ Solutions/S3/goodSamples.cpp

@@ -0,0 +1,59 @@
+#include "../../../helperFunctions.h"
+
+using namespace std;
+
+/*******************************************************************************************
+  Link: https://dmoj.ca/problem/ccc22s3
+  Points: 15/15
+  Inspiration: https://www.geekedu.org/blogs/2022-waterloo-ccc-senior-problem-solution#toc-8
+*******************************************************************************************/
+
+void goodSamples()
+{
+  long long N, M, K;
+  scanf("%lld %lld %lld", &N, &M, &K);
+  vector<long long> result;
+
+  for (long long i = 0; i < N; ++i)
+  {
+    // How many notes we have remaining after the one on the current index
+    long long remainingAfterThisIndex = N - i - 1;
+    // The maximum number of good samples we can make, K - remainingAfterThisIndex just gives us how many we can add at this index, so if
+    // K = 5 and remainingAfterThisIndex = 2 then we can add a MAXIMUM of 3, but if M = 2 then it limits it to just 2 more good samples
+    long long currentMaxNotes = min(K - remainingAfterThisIndex, M);
+
+    // If we can't add any more samples then just exit
+    if (currentMaxNotes <= 0)
+      break;
+
+    long long value = 0;
+
+    // If we can still add distinct integers and we do have to add them then do so
+    if (currentMaxNotes > i)
+    {
+      // Get either i + 1 or M, whichever one is smaller, M just limits it so it doesn't go past the highest note
+      value = min(M, i + 1);
+      currentMaxNotes = value;
+    }
+    else
+      value = result[i - currentMaxNotes]; // Use a previous note
+    result.push_back(value);
+    // Update the number of good samples we've created so far
+    K -= currentMaxNotes;
+  }
+
+  if (K == 0 && result.size() == N)
+  {
+    for (long long i = 0; i < result.size(); ++i)
+      printf("%lld ", result[i]);
+    printf("\n");
+    return;
+  }
+  printf("-1\n");
+}
+
+int main()
+{
+  goodSamples();
+  return 0;
+}

Solutions/DMOJ Solutions/S3/quantumOperations.cpp

@@ -0,0 +1,92 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+
+/*******************************************************************************************
+  Link: https://dmoj.ca/problem/ccc05s3
+  Points: 15/15
+  Inspiration: https://github.com/kingMonkeh/CCC-Solutions/blob/main/2005%20S3.cpp
+*******************************************************************************************/
+
+void quantumOperations()
+{
+  int N, ARows, AColumns, BRows, BColumns;
+  scanf("%d", &N);
+
+  vector<vector<int>> A, B;
+
+  scanf("%d %d", &ARows, &AColumns);
+  A.resize(ARows, vector<int>(AColumns));
+  for (int i = 0; i < ARows; ++i)
+    for (int j = 0; j < AColumns; ++j)
+      scanf("%d", &A[i][j]);
+
+  for (int i = 0; i < N - 1; ++i)
+  {
+    scanf("%d %d", &BRows, &BColumns);
+    B.clear();
+    B.resize(BRows, vector<int>(BColumns));
+    for (int i = 0; i < BRows; ++i)
+      for (int j = 0; j < BColumns; ++j)
+        scanf("%d", &B[i][j]);
+
+    vector<vector<int>> ACopy = A;
+    A.clear();
+    A.resize(ARows * BRows, vector<int>(AColumns * BColumns));
+    for (int j = 0; j < ACopy.size(); ++j)
+      for (int k = 0; k < ACopy[j].size(); ++k)
+        for (int m = 0; m < B.size(); ++m)
+          for (int n = 0; n < B[m].size(); ++n)
+            A[m + BRows * j][n + BColumns * k] = ACopy[j][k] * B[m][n];
+
+    ARows *= BRows;
+    AColumns *= BColumns;
+  }
+
+  int maximumElement = INT_MIN;
+  int minimumElement = INT_MAX;
+  int maximumRowSum = INT_MIN;
+  int minimumRowSum = INT_MAX;
+  int maximumColumnSum = INT_MIN;
+  int minimumColumnSum = INT_MAX;
+
+  vector<int> rowSums(A.size(), 0);
+  vector<int> columnSums(A[0].size(), 0);
+
+  for (int i = 0; i < A.size(); ++i)
+  {
+    for (int j = 0; j < A[i].size(); ++j)
+    {
+      maximumElement = max(maximumElement, A[i][j]);
+      minimumElement = min(minimumElement, A[i][j]);
+
+      rowSums[i] += A[i][j];
+      columnSums[j] += A[i][j];
+    }
+  }
+
+  for (int i = 0; i < rowSums.size(); ++i)
+  {
+    maximumRowSum = max(maximumRowSum, rowSums[i]);
+    minimumRowSum = min(minimumRowSum, rowSums[i]);
+  }
+
+  for (int i = 0; i < columnSums.size(); ++i)
+  {
+    maximumColumnSum = max(maximumColumnSum, columnSums[i]);
+    minimumColumnSum = min(minimumColumnSum, columnSums[i]);
+  }
+
+  printf("%d\n", maximumElement);
+  printf("%d\n", minimumElement);
+  printf("%d\n", maximumRowSum);
+  printf("%d\n", minimumRowSum);
+  printf("%d\n", maximumColumnSum);
+  printf("%d\n", minimumColumnSum);
+}
+
+int main()
+{
+  quantumOperations();
+  return 0;
+}

Solutions/Leetcode Solutions/medium/houseRobber.cpp

@@ -19,72 +19,8 @@ void iterativeInOrderTraversal(TreeNode *root)
   }
 }
 
-void iterativePreOrderTraversal(TreeNode *root)
-{
-  stack<TreeNode *> nextNodes;
-  nextNodes.push(root);
-  while (!nextNodes.empty())
-  {
-    root = nextNodes.top();
-    nextNodes.pop();
-    printf("%d ", root->val);
-    if (root->right != nullptr)
-      nextNodes.push(root->right);
-    if (root->left != nullptr)
-      nextNodes.push(root->left);
-  }
-}
-
-void iterativePostOrderTraversal(TreeNode *root)
-{
-  stack<TreeNode *> nextNodes;
-  while (!nextNodes.empty() || root != nullptr)
-  {
-    if (root != nullptr)
-    {
-      nextNodes.push(root);
-      root = root->left;
-    }
-    else
-    {
-      TreeNode *temp = nextNodes.top()->right;
-      if (temp == nullptr)
-      {
-        temp = nextNodes.top();
-        nextNodes.pop();
-        printf("%d ", temp->val);
-        while (!nextNodes.empty() && temp == nextNodes.top()->right)
-        {
-          temp = nextNodes.top();
-          nextNodes.pop();
-          printf("%d ", temp->val);
-        }
-      }
-      else
-        root = temp;
-    }
-  }
-}
-
-int jumpGame2(vector<int> nums)
-{
-  int l = 0;
-  int r = 0;
-  int res = 0;
-  while (r < nums.size() - 1)
-  {
-    int farthest = 0;
-    for (int i = l; i <= r; ++i)
-      farthest = max(farthest, nums[i] + i);
-    l = r + 1;
-    r = farthest;
-    ++res;
-  }
-  return res;
-}
-
 int main()
 {
-  cout << jumpGame2(vector<int>({2, 3, 1, 1, 4})) << endl;
+  iterativeInOrderTraversal(createDefaultTree());
   return 0;
 }

Solutions/Leetcode Solutions/medium/longestSubstringWithoutRepeatingCharacters.cpp

@@ -9,7 +9,7 @@
 #include <math.h>
 #include <set>
 #include <bits/stdc++.h>
-#include "Miscellaneous/helperFunctions.h"
+#include "helperFunctions.h"
 
 using namespace std;
 
@@ -2658,7 +2658,5 @@ int main()
   vector<int> nums2({1, 1, 2, 2});
   vector<vector<int>> nums2d({{4, 3, 1}, {6, 5, 2}, {9, 7, 3}});
 
-  displayVector(nums1);
-
   return 0;
 }