C++/326.cpp

@@ -0,0 +1,32 @@
+#include <iostream>
+#include <cstdint>
+#include <cmath>
+
+class Solution {
+public:
+    bool isPowerOfThree(int n) {
+        if ( n <= 0 ) { return false; }
+        if ( n == 1 ) { return true; }
+        for ( int i = 1; i < n; ++i ) {
+            long val = pow(3, i);
+            if ( val == n ) { return true; }
+            if ( val > n ) { return false; }
+        }
+        return false;
+    }
+};
+
+void r(int n, bool exp) {
+    std::cout << "Solution().isPowerOfThree(" << n << ") = ";
+    std::cout << Solution().isPowerOfThree(n);
+    std::cout << " | exp: " << exp << "\n";
+};
+
+int main(void) {
+    r(27, true);
+    r(9, false);
+    r(0, false);
+    r(-1, false);
+
+    return 0;
+}

C++/637.cpp

@@ -0,0 +1,74 @@
+#include <iostream>
+#include <cstdint>
+#include <vector>
+
+#include "./utils.hpp"
+
+using std::vector;
+using std::string;
+
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+ *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+ * };
+ */
+class Solution {
+public:
+    vector<double>
+    averageOfLevels(TreeNode *root)
+    {
+        vector<double> vec;
+        vector<int> amount;
+        _go(0, root, vec, amount);
+        for ( unsigned int i = 0; i < vec.size(); ++i ) {
+            vec[i] /= amount[i];
+        }
+        return vec;
+    }
+
+    void
+    _go(unsigned long level, TreeNode *root, vector<double> &vec, vector<int> &amount)
+    {
+        if ( root == NULL ) { return; }
+        if ( level >= vec.size() ) {
+            vec.push_back(0);
+            amount.push_back(0);
+        }
+        vec[level] += root->val;
+        ++amount[level];
+        ++level;
+        _go(level, root->left, vec, amount);
+        _go(level, root->right, vec, amount);
+    }
+};
+
+
+void r(TreeNode *root, vector<double> exp) {
+    std::cout << "Solution().averageOfLevels(" << treenode_to_str(root) << ") = ";
+    std::cout << vector_to_str(Solution().averageOfLevels(root));
+    std::cout << " | exp: " << vector_to_str(exp) << "\n";
+};
+
+int main(void) {
+    TreeNode root1l = TreeNode(9);
+    TreeNode root1rl = TreeNode(15);
+    TreeNode root1rr = TreeNode(7);
+    TreeNode root1r = TreeNode(20, &root1rl, &root1rr);
+    TreeNode root1 = TreeNode(3, &root1l, &root1r);
+    r(&root1, {3.00000,14.50000,11.00000});
+
+    TreeNode root2ll = TreeNode(15);
+    TreeNode root2lr = TreeNode(7);
+    TreeNode root2l = TreeNode(9, &root2ll, &root2lr);
+    TreeNode root2r = TreeNode(20);
+    TreeNode root2 = TreeNode(3, &root2l, &root2r);
+    r(&root2, {3.00000,14.50000,11.00000});
+
+    return 0;
+}

C++/utils.hpp

@@ -0,0 +1,41 @@
+
+#include <string>
+#include <vector>
+
+struct TreeNode {
+    int val;
+    TreeNode *left;
+    TreeNode *right;
+    TreeNode() : val(0), left(nullptr), right(nullptr) {}
+    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
+    TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
+};
+
+std::string
+treenode_to_str(TreeNode *root)
+{
+    if ( root == NULL ) { return "nil"; }
+    std::string ret;
+    ret += "TreeNode(";
+    ret += std::to_string(root->val);
+    ret += ", ";
+    ret += treenode_to_str(root->left);
+    ret += ", ";
+    ret += treenode_to_str(root->right);
+    ret += ")";
+    return ret;
+}
+
+template<typename T>
+std::string
+vector_to_str(std::vector<T> vec)
+{
+    std::string ret = "[";
+    for ( unsigned long i = 0; i < vec.size(); ++i ) {
+        if ( i == 0 ) { ret += "\""; ret += std::to_string(vec[i]); ret += "\""; continue; }
+        ret += ", \""; ret += std::to_string(vec[i]); ret += "\"";
+    }
+    ret += "]";
+    return ret;
+}
+

C/1436.c

@@ -0,0 +1,110 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+char *
+destCity(char*** paths, int pathsSize, int* pathsColSize) {
+    struct {
+        char **data;
+        unsigned long size;
+        unsigned long cap;
+    } froms = {0};
+    struct {
+        char **data;
+        unsigned long size;
+        unsigned long cap;
+    } tos = {0};
+
+    froms.cap = pathsSize;
+    froms.data = calloc(froms.cap, sizeof(*froms.data));
+
+    tos.cap = pathsSize;
+    tos.data = calloc(tos.cap, sizeof(*tos.data));
+
+    for ( int i = 0; i < pathsSize; ++i ) {
+        froms.data[froms.size++] = paths[i][0];
+        tos.data[tos.size++] = paths[i][1];
+    }
+
+    char *ret = NULL;
+    for ( unsigned long i = 0; i < tos.size; ++i ) {
+        bool found = false;
+        for ( unsigned long j = 0; j < froms.size; ++j ) {
+            if ( strcmp(tos.data[i], froms.data[j]) == 0 ) {
+                found = true;
+                break;
+            }
+        }
+        if ( ! found ) { ret = tos.data[i]; break; }
+    }
+
+    (void) pathsColSize;
+
+    free(tos.data);
+    free(froms.data);
+
+    return ret;
+}
+
+char *
+paths_to_cstr_temp(char ***paths, int pathsSize) {
+    static char *data = NULL;
+    static unsigned long size = 0;
+    static unsigned long cap = 1024;
+
+    if ( data == NULL ) { data = malloc(sizeof(char) * (cap + 1)); }
+    size = 0;
+    memset(data, 0, cap);
+
+    data[size++] = '[';
+    for ( int i = 0; i < pathsSize; ++i ) {
+        if ( size + 32 >= cap ) { cap = cap*2; data = realloc(data, cap*2); }
+
+        if ( i > 0 ) { data[size++] = ','; }
+        data[size++] = '[';
+        char *from = paths[i][0];
+        while ( *from != '\0' ) { data[size++] = *from++; }
+        data[size++] = ',';
+        char *to = paths[i][1];
+        while ( *to != '\0' ) { data[size++] = *to++; }
+        data[size++] = ']';
+    }
+    data[size++] = ']';
+    data[size++] = '\0';
+
+    return data;
+}
+
+void
+r(char ***paths, int pathsSize, char *exp)
+{
+    printf("destCity(%s, %d) = %s | exp: %s\n",
+           paths_to_cstr_temp(paths, pathsSize),
+           pathsSize,
+           destCity(paths, pathsSize, NULL),
+           exp);
+}
+
+int
+main(void)
+{
+
+    char *paths11[2] = {"London","New York"};
+    char *paths12[2] = {"New York","Lima"};
+    char *paths13[2] = {"Lima","Sao Paulo"};
+    char **paths1[] = {paths11, paths12, paths13};
+    r(paths1, 3, "Sao Paulo");
+
+    char *paths21[2] = {"B","C"};
+    char *paths22[2] = {"D","B"};
+    char *paths23[2] = {"C","A"};
+    char **paths2[] = {paths21, paths22, paths23};
+    r(paths2, 3, "A");
+
+    char *paths31[2] = {"A","Z"};
+    char **paths3[] = {paths31};
+    r(paths3, 1, "Z");
+
+    return 0;
+}

C/2903.c

@@ -0,0 +1,89 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdbool.h>
+
+/**
+ * Note: The returned array must be malloced, assume caller calls free().
+ */
+int *
+findIndices(int* nums, int numsSize, int indexDifference, int valueDifference, int* returnSize)
+{
+    int *ret = malloc(2*sizeof(int));
+    ret[0] = -1;
+    ret[1] = -1;
+
+    for ( int i = 0; i < numsSize; ++i ) {
+        for ( int j = i; j < numsSize; ++j ) {
+            if ( abs(i-j) < indexDifference ) { continue; }
+            if ( abs(nums[i]-nums[j]) < valueDifference ) { continue; }
+            ret[0] = i;
+            ret[1] = j;
+            goto exit;
+        }
+    }
+
+exit:
+    *returnSize = 2;
+    return ret;
+}
+
+char *
+list_to_cstr_temp(int *nums, int numsSize)
+{
+    char *data = NULL;
+    unsigned long size = 0;
+    unsigned long cap = 1024;
+
+    size = 0;
+    if ( data == NULL ) { data = malloc(cap * sizeof(*data)); }
+    memset(data, 0, cap);
+
+    data[size++] = '[';
+    for ( int i = 0; i < numsSize; ++i ) {
+        if ( size + 2 >= cap ) { cap *= 2; data = realloc(data, cap); }
+        if ( i > 0 ) { data[size++] = ','; }
+        data[size++] = nums[i] + '0';
+    }
+    data[size++] = ']';
+    data[size++] = '\0';
+
+    return data;
+}
+
+void
+r(int *nums, int numsSize, int indexDifference, int valueDifference, int *exp)
+{
+    int t;
+    char *numsCstr = list_to_cstr_temp(nums, numsSize);
+    int *ret = findIndices(nums, numsSize, indexDifference, valueDifference, &t);
+    char *retCstr = list_to_cstr_temp(ret, 2);
+    char *expCstr = list_to_cstr_temp(exp, 2);
+    printf("findIndices(%s, %d, %d, %d) = %s | exp: %s\n",
+           numsCstr, numsSize, indexDifference, valueDifference,
+           retCstr,
+           expCstr);
+
+    free(numsCstr);
+    free(ret);
+    free(retCstr);
+    free(expCstr);
+}
+
+int
+main(void)
+{
+    int nums1[] = {5,1,4,1};
+    int exp1[] = {0,3};
+    r(nums1, 4, 2, 4, exp1);
+
+    int nums2[] = {2,1};
+    int exp2[] = {0,0};
+    r(nums2, 2, 0, 0, exp2);
+
+    int nums3[] = {1,2,3};
+    int exp3[] = {-1,-1};
+    r(nums3, 3, 2, 4, exp3);
+
+    return 0;
+}

Go/1128.go

@@ -0,0 +1,64 @@
+package main
+
+import (
+	"fmt"
+	"os"
+)
+
+func numEquivDominoPairs(dominoes [][]int) int {
+	var ret int = 0
+
+	var out_size int = len(dominoes)
+
+	var seen map[string][]int = make(map[string][]int)
+	var ok bool
+
+	var i int = 0
+	for i = 0; i < out_size; i += 1 {
+		var a, b rune = rune(dominoes[i][0]), rune(dominoes[i][1])
+
+		var key string = string([]rune{a, b})
+
+		var idxs []int
+		idxs, ok = seen[key]
+		if ok { seen[key] = append(idxs, i); continue }
+
+		var inv_key string = string([]rune{b, a})
+		idxs, ok = seen[inv_key]
+		if ok { seen[inv_key] = append(idxs, i); continue }
+
+		seen[key] = []int{ i }
+	}
+
+	permuts_num := func (list []int) int {
+		var ret int = 0
+
+		var list_size int = len(list)
+		var i int = 0
+		for ; i < list_size; i += 1 {
+			var j int = i+1
+			for ; j < list_size; j += 1 { ret += 1 }
+		}
+
+		return ret
+	}
+
+	for _, v := range seen { ret += permuts_num(v) }
+
+	return ret
+}
+
+func main() {
+	r := func(dominoes [][]int, exp int) {
+		fmt.Printf(
+			"numEquivDominoPairs(%v) = %v | exp: %v\n", dominoes,
+			numEquivDominoPairs(dominoes), exp,
+		)
+	}
+
+	r([][]int{{1, 2}, {2, 1}, {3, 4}, {5, 6}}, 1)
+	r([][]int{{1, 2}, {1, 2}, {1, 1}, {1, 2}, {2, 2}}, 3)
+	r([][]int{{2, 1}, {1, 2}, {1, 2}, {1, 2}, {2, 1}, {1, 1}, {1, 2}, {2, 2}}, 15)
+
+	os.Exit(0)
+}

Go/1957.go

@@ -0,0 +1,46 @@
+package main
+
+import (
+	"strings"
+	"fmt"
+	"os"
+)
+
+func makeFancyString(s string) string {
+	var sb strings.Builder
+
+	var char byte = s[0];
+	var char_count int = 1;
+	sb.WriteByte(char)
+
+	var s_size int = len(s)
+	var i int = 1
+	for ; i < s_size; i += 1 {
+		if s[i] == char {
+			char_count += 1
+			if char_count >= 3 {
+				continue
+			}
+		} else {
+			char = s[i]
+			char_count = 1
+		}
+		sb.WriteByte(char)
+	}
+
+	return sb.String()
+}
+
+func main() {
+	r := func(s string, exp string) {
+		fmt.Printf(
+			"makeFancyString(%v) = %v | exp: %v\n", s, makeFancyString(s), exp,
+		)
+	}
+
+	r("leeetcode", "leetcode")
+	r("aaabaaaa", "aabaa")
+	r("aab", "aab")
+
+	os.Exit(0)
+}

Python/2882.py

@@ -0,0 +1,52 @@
+# 2882. Drop Duplicate Rows
+
+import sys
+
+import pandas as pd
+
+def dropDuplicateEmails(customers: pd.DataFrame) -> pd.DataFrame:
+    return customers.drop_duplicates(subset=['email'], keep='first')
+
+
+def main() -> int:
+
+    def r(customers: pd.DataFrame, exp: pd.DataFrame) -> None:
+        res: pd.DataFrame = dropDuplicateEmails(customers)
+        print(f"dropDuplicateEmails({customers}) = {res} | exp: {exp}")
+        pass
+
+    r(
+        pd.DataFrame.from_dict(
+            {
+                "customer_id": [1, 2, 3, 4, 5, 6],
+                "name": ["Ella", "David", "Zachary", "Alice", "Finn", "Violet"],
+                "email": [
+                    "emily@example.com",
+                    "michael@example.com",
+                    "sarah@example.com",
+                    "john@example.com",
+                    "john@example.com",
+                    "alice@example.com",
+                ],
+            }
+        ),
+        pd.DataFrame.from_dict(
+            {
+                "customer_id": [1, 2, 3, 4, 6],
+                "name": ["Ella", "David", "Zachary", "Alice", "Violet"],
+                "email": [
+                    "emily@example.com",
+                    "michael@example.com",
+                    "sarah@example.com",
+                    "john@example.com",
+                    "alice@example.com",
+                ],
+            }
+        ),
+    )
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Python/520.py

@@ -0,0 +1,27 @@
+# 520. Detect Capital
+
+import sys
+
+class Solution:
+    def detectCapitalUse(self, word: str) -> bool:
+        if word[0].islower():
+            return all(x.islower() for x in word[1:])
+
+        return all(x.islower() for x in word[1:]) or all(x.isupper() for x in word[1:])
+    pass
+
+def main() -> int:
+    def r(word: str, exp: bool) -> None:
+        ret: bool = Solution().detectCapitalUse(word)
+        print(
+            f"Solution().detectCapitalUse({word}) = {ret} | exp: {exp}"
+        )
+        pass
+
+    r("USA", True)
+    r("FlaG", False)
+
+    return 0
+
+if __name__ == "__main__":
+    sys.exit(main())

Python/66.py

@@ -0,0 +1,43 @@
+# 66. Plus One
+
+import sys
+from typing import List
+
+
+class Solution:
+    def plusOne(self, digits: List[int]) -> List[int]:
+        size: int = len(digits)
+        i: int = size - 1
+
+        while i >= 0:
+            print(i)
+            digits[i] += 1
+            if digits[i] < 10:
+                break
+            digits[i] = 0
+            if i == 0:
+                digits.insert(0, 1)
+            i -= 1
+            pass
+
+        return digits
+
+    pass
+
+
+def main() -> int:
+    def r(digits: List[int], exp: List[int]) -> None:
+        ret: List[int] = Solution().plusOne(digits.copy())
+        print(f"Solution().plusOne({digits}) = {ret} | exp: {exp}")
+        pass
+
+    r([1, 2, 3], [1, 2, 4])
+    r([4, 3, 2, 1], [4, 3, 2, 2])
+    r([9], [1, 0])
+    r([4, 3, 2, 9], [4, 3, 3, 0])
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

Racket/2908.rkt

@@ -0,0 +1,44 @@
+#lang racket
+
+(define/contract (minimum-sum nums)
+  (-> (listof exact-integer?) exact-integer?)
+  (let ([nums_size (length nums)])
+    (if (< nums_size 3)
+      -1
+      (let _go ([m 153] [f nums] [s (cdr nums)] [t (cddr nums)])
+        ;(printf "m(~a) f(~a) s(~a) t(~a)\n" m f s t)
+        (if (< (length f) 3)
+          (if (= m 153) -1 m)
+          (if (< (length s) 2)
+            (_go m (cdr f) (cddr f) (cdddr f))
+            (if (pair? t)
+              (let* ([fv (car f)] [sv (car s)] [tv (car t)])
+                (if (and (< fv sv) (> sv tv))
+                  (_go (min (+ fv sv tv) m) f s (cdr t))
+                  (_go m f s (cdr t))
+                  )
+              )
+              (_go m f (cdr s) (cddr s))
+              )
+            )
+          )
+        )
+      )
+    )
+  )
+
+(define (main)
+  (define (r nums exp)
+    (printf
+      "(minimum-sum ~a) = ~a | Exp: ~a\n"
+      nums (minimum-sum nums) exp
+      )
+    )
+
+  (r '(8 6 1 5 3) 9)
+  (r '(5 4 8 7 10 2) 13)
+  (r '(6 5 4 3 4 5) -1)
+  (r '(49 50 48) 147)
+  )
+
+(main)

Racket/2951.rkt

@@ -0,0 +1,26 @@
+#lang racket
+
+(define/contract (find-peaks mountain)
+  (-> (listof exact-integer?) (listof exact-integer?))
+  (let _go ([i 1] [prev (car mountain)] [cur (cdr mountain)] [res '()])
+    (if (= 1 (length cur)) res
+      (let ([s (car cur)] [t (cadr cur)])
+        (_go (+ i 1) s (cdr cur) (append res (if (and (> s prev) (> s t)) (cons i '()) '())))
+        )
+      )
+    )
+  )
+
+(define (main)
+  (define (r mountain exp)
+    (printf
+      "(find-peaks ~a) = ~a | Exp: ~a\n"
+      mountain (find-peaks mountain) exp
+      )
+    )
+
+  (r '(2 4 4) '())
+  (r '(1 4 3 8 5) '(1 3))
+  )
+
+(main)

TypeScript/1390.ts

@@ -0,0 +1,42 @@
+// 1390. Four Divisors
+
+
+function sumFourDivisors(nums: number[]): number {
+    let divisorsCache = new Map<number, number[]>()
+    function divisors(num: number): number[] {
+        if ( divisorsCache.has(num) ) { return divisorsCache.get(num) }
+        let ret: number[] = [1, num]
+        const limit: number = num-1
+        for ( let i = 2 ; i < limit; ++i ) {
+            if ( num % i == 0 ) {
+                ret.push(i);
+                if ( ret.length > 4 ) { break; }
+            }
+        }
+        divisorsCache.set(num, ret);
+        return ret;
+    }
+    let ret: number = 0;
+    let nums_size = nums.length;
+    for ( let i = 0; i < nums_size; ++i ) {
+        const divs: number[] = divisors(nums[i]);
+        if ( divs.length == 4 ) {
+            ret += divs[0] + divs[1] + divs[2] + divs[3];
+        }
+    }
+    return ret;
+};
+
+function main() {
+    function r(nums: number[], exp: number) {
+        console.log(`sumFourDivisors([${nums}]) = ${sumFourDivisors(nums)} | exp: ${exp}`)
+    }
+
+    r([21,4,7], 32)
+    r([21,21], 64)
+    r([1,2,3,4,5], 0)
+    r([1,2,3,4,5,6,7,8,9,10], 45)
+
+}
+
+main()