Additional work

Author: Zanger67

README.md

@@ -0,0 +1,11 @@
+class Solution:
+    def maxCoins(self, piles: List[int]) -> int:
+        piles = deque(sorted(piles))
+
+        output: int = 0
+        while piles :
+            piles.pop()
+            output += piles.pop()
+            piles.popleft()
+
+        return output

my-submissions/m1561.py

@@ -0,0 +1,15 @@
+int comp(const void* a, const void* b) {
+    return *((int*) a) - *((int*) b);
+}
+
+int maxIceCream(int* costs, int costsSize, int coins) {
+    qsort(costs, costsSize, sizeof(int), comp);
+    
+    for (int i = 0; i < costsSize; i++) {
+        if (coins < costs[i])
+            return i;
+        coins -= costs[i];
+    }
+
+    return costsSize;
+}

my-submissions/m1833.c

@@ -0,0 +1,13 @@
+class Solution {
+    public int maxIceCream(int[] costs, int coins) {
+        Arrays.sort(costs);
+
+        for (int i = 0; i < costs.length; i++) {
+            if (coins < costs[i]) 
+                return i;
+            coins -= costs[i];
+        }
+
+        return costs.length;
+    }
+}

my-submissions/m1833.java

@@ -0,0 +1,12 @@
+class Solution:
+    def maxIceCream(self, costs: List[int], coins: int) -> int:
+        bars = 0
+        costs.sort(reverse=True)
+
+        while costs :
+            if coins < costs[-1] :
+                return bars
+            bars += 1
+            coins -= costs.pop()
+
+        return bars

my-submissions/m1833.py

@@ -0,0 +1,9 @@
+class Solution:
+    def minPairSum(self, nums: List[int]) -> int:
+        nums.sort()
+        maxx = 0
+
+        for i in range(len(nums) // 2) :
+            maxx = max(maxx, nums[i] + nums[len(nums) - i - 1])
+
+        return maxx

my-submissions/m1877 nlogn.py

@@ -0,0 +1,18 @@
+# Wanted to see if a 26-long list being reset each time would be faster
+# than a hashmap
+
+class Solution:
+    def partitionString(self, s: str) -> int:
+        current: List[bool] = [False] * 26
+
+        counter = 1
+        for c in s :
+            if current[ord(c) - ord('a')] :
+                counter += 1
+                current = [False] * 26
+                current[ord(c) - ord('a')] = True
+            
+            else :
+                current[ord(c) - ord('a')] = True
+
+        return counter

my-submissions/m2405 v1 26-List.py

@@ -0,0 +1,13 @@
+class Solution:
+    def partitionString(self, s: str) -> int:
+        lastCase: List[int] = [-1] * 26
+
+        counter = 1
+        leftPointer = 0
+        for i, c in enumerate(s) :
+            if lastCase[ord(c) - ord('a')] >= leftPointer :
+                leftPointer = i
+                counter += 1
+            lastCase[ord(c) - ord('a')] = i
+
+        return counter

my-submissions/m2405 v1-2 Redo with indices but still slower than sets.py

@@ -0,0 +1,12 @@
+class Solution:
+    def partitionString(self, s: str) -> int:
+        current = set()
+
+        counter = 1
+        for c in s :
+            if c in current :
+                counter += 1
+                current = set()
+            current.add(c)
+
+        return counter

my-submissions/m2405 v2 Set.py

@@ -0,0 +1,21 @@
+double myPowLong(double x, long n) {
+    if (n == 0) 
+        return 1.;
+
+    if (n < 0)
+        return 1 / myPowLong(x, n * -1);
+    
+    if (n == 1)
+        return x;
+
+    double half = myPowLong(x, n / 2);
+    long remainder = n % 2;
+
+    if (remainder == 1)
+        return half * half * x;
+    return half * half;
+}
+
+double myPow(double x, int n) {
+    return myPowLong(x, (long) n);
+}

my-submissions/m50.c

@@ -0,0 +1,23 @@
+class Solution {
+    public double myPow(double x, int n) {
+        return myPow(x, (long) n);
+
+    }
+    private double myPow(double x, long n) {
+        if (n == 0) 
+            return 1.;
+
+        if (n < 0)
+            return 1 / myPow(x, n * -1);
+        
+        if (n == 1)
+            return x;
+
+        double half = myPow(x, n / 2);
+        long remainder = n % 2;
+
+        if (remainder == 1)
+            return half * half * x;
+        return half * half;
+    }
+}

my-submissions/m50.java

@@ -0,0 +1,19 @@
+class Solution:
+    def myPow(self, x: float, n: int) -> float:
+        if not n :
+            return 1
+        
+        if n == 1 :
+            return x
+        
+        if n < 0 :
+            return 1 / self.myPow(x, -n)
+
+        half = n // 2
+        remainder = n - half * 2
+        half = self.myPow(x, half)
+
+        if remainder :
+            return x * half * half
+        
+        return half * half

my-submissions/m50.py

@@ -0,0 +1,32 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+
+bool isValidBSTHelper(struct TreeNode* root, long min, long max) {
+    if (!root) 
+        return true;
+
+    if ((long) root->val <= min || (long) root->val >= max) 
+        return false;
+
+    bool output = true;
+    
+    if (root->right)
+        output &= root->val < root->right->val
+                    && isValidBSTHelper(root->right, (long) root->val, max);
+
+    if (root->left)
+        output &= root->left->val < root->val
+                    && isValidBSTHelper(root->left, min, (long) root->val);
+
+    return output;
+}
+
+bool isValidBST(struct TreeNode* root) {
+    return isValidBSTHelper(root, LONG_MIN, LONG_MAX);
+}