idx

Author: JMoogs

problems/add_binary/solution.py

@@ -0,0 +1,3 @@
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        return str(bin(int(a, 2) + int(b, 2)))[2:]

problems/add_binary/solution.rs

@@ -0,0 +1,9 @@
+impl Solution {
+    pub fn add_binary(a: String, b: String) -> String {
+    let a_b = u128::from_str_radix(&a, 2).unwrap();
+    let b_b = u128::from_str_radix(&b, 2).unwrap();
+
+    let sum = a_b + b_b;
+    format!("{sum:b}")
+    }
+}

problems/add_strings/solution.rs

@@ -0,0 +1,47 @@
+impl Solution {
+    pub fn add_strings(mut num1: String, mut num2: String) -> String {
+
+        let leading_zs = (num1.len() as i32 - num2.len() as i32).abs();
+
+        let mut zeros = String::with_capacity(leading_zs as usize);
+
+        for _ in 0..leading_zs {
+            zeros.push('0');
+        }
+
+        if num1.len() < num2.len() {
+            num1 = zeros + &num1;
+        } else if num1.len() > num2.len() {
+            num2 = zeros + &num2;
+        }
+
+        let nums1rev = num1.chars().rev().collect::<Vec<char>>();
+        let nums2rev = num2.chars().rev().collect::<Vec<char>>();
+
+
+        let mut solution_rev: Vec<u32> = Vec::with_capacity(nums1rev.len() + 1);
+        // Both vecs will be the same length due to adding leading 0s
+        //
+        let mut carry: u32 = 0;
+        for i in 0..nums1rev.len() {
+            let ans = nums1rev[i].to_digit(10).unwrap() + nums2rev[i].to_digit(10).unwrap() + carry;
+
+            carry = 0;
+
+            if ans < 10 {
+                solution_rev.push(ans);
+            } else {
+                carry = 1;
+                solution_rev.push(ans % 10);
+            }
+
+        }
+        
+        if carry == 1 {
+            solution_rev.push(1);
+        }
+
+        return solution_rev.into_iter().rev().map(|n| n.to_string()).collect();
+
+    }
+}

problems/add_two_integers/solution.c

@@ -0,0 +1,5 @@
+
+
+int sum(int num1, int num2){
+    return num1 + num2;
+}

problems/add_two_integers/solution.py

@@ -0,0 +1,4 @@
+class Solution:
+    def sum(self, num1: int, num2: int) -> int:
+        return num1 + num2
+        

problems/add_two_integers/solution.rs

@@ -0,0 +1,5 @@
+impl Solution {
+    pub fn sum(num1: i32, num2: i32) -> i32 {
+        num1 + num2
+    }
+}

problems/add_two_numbers/solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn add_two_numbers(l1: Option<Box<ListNode>>, l2: Option<Box<ListNode>>) -> Option<Box<ListNode>> {
+        match (l1, l2) {
+            (None, None) => None,
+            (Some(n), None) | (None, Some(n)) => Some(n), 
+            (Some(n1), Some(n2)) => {
+                let sum = n1.val + n2.val;
+                if sum < 10 {
+                    Some(Box::new(ListNode {
+                        val: sum,
+                        next: Solution::add_two_numbers(n1.next, n2.next)
+                    }))
+                } else {
+                    let carry = Some(Box::new(ListNode::new(1)));
+                    Some(Box::new(ListNode {
+                        val: sum - 10,
+                        next: Solution::add_two_numbers(Solution::add_two_numbers(carry, n1.next), n2.next)
+                    }))
+                }
+            }
+        }
+    }
+}

problems/average_salary_excluding_the_minimum_and_maximum_salary/solution.rs

@@ -0,0 +1,33 @@
+impl Solution {
+    pub fn average(salary: Vec<i32>) -> f64 {
+        // Get sum
+
+        let mut total = 0;
+
+        let divisor = salary.len() - 2;
+
+        // the lowest has to be ignored initially but must be bigger than 0
+        let mut lowest = i32::MAX;
+
+        let mut highest = i32::MIN;
+
+        for sal in salary {
+            if sal < lowest {
+                lowest = sal;
+            }
+
+            if sal > highest {
+                highest = sal;
+            }
+
+
+            total += sal
+        }
+
+        total -= highest;
+
+        total -= lowest;
+
+        total as f64 / divisor as f64
+    }
+}

problems/base_7/solution.rs

@@ -0,0 +1,23 @@
+impl Solution {
+    pub fn convert_to_base7(num: i32) -> String {
+        let negative = num.is_negative();
+        let mut num = num.abs() as u32;
+
+        let mut n = String::new();
+        if num == 0 {
+            return "0".into();
+        }
+
+        while num != 0 {
+            n.push(char::from_digit(num % 7, 10).unwrap());
+            num /= 7;
+        }
+
+        if negative {
+            n.push('-');
+        }
+
+        n.chars().rev().collect()
+    }
+
+}

problems/best_time_to_buy_and_sell_stock/solution.rs

@@ -0,0 +1,16 @@
+impl Solution {
+pub fn max_profit(prices: Vec<i32>) -> i32 {
+  
+  let (mut min, mut max) = (i32::MAX, i32::MIN);
+
+  for price in prices {
+    max = max.max(price - min);
+    min = min.min(price);
+  }
+
+    if max < 0 {
+        max = 0
+    }
+  max
+}
+}

problems/big_countries/solution.sql

@@ -0,0 +1,4 @@
+# Write your MySQL query statement below
+SELECT name, population, World.area
+FROM World
+WHERE World.area >= 3000000 OR population >= 25000000

problems/binary_tree_inorder_traversal/solution.c

@@ -0,0 +1,41 @@
+
+
+#include <stdio.h>
+
+// struct TreeNode {
+//      int val;
+//      struct TreeNode *left;
+//      struct TreeNode *right;
+// };
+
+typedef struct TreeNode TreeNode;
+
+
+void traverse(TreeNode* tree, int* nums, int* returnSize) {
+
+
+    if (tree->left) {
+        traverse(tree->left, nums, returnSize);
+        
+    };
+
+    // Add one after adding the value in the current tree.
+    nums[(*returnSize)++]=tree->val;
+
+    if (tree->right) {
+        traverse(tree->right, nums, returnSize);
+    }
+
+}
+
+int* inorderTraversal(struct TreeNode* root, int* returnSize){
+    int* nums = (int*) malloc(100*sizeof(int));
+    *returnSize = 0;
+    
+    if (root) {
+        traverse(root, nums, returnSize);
+    }
+    
+    nums = realloc(nums, sizeof(int) * (*returnSize));
+    return nums;
+}

problems/climbing_stairs/solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+pub fn climb_stairs(n: i32) -> i32 {
+
+    fn fib(n: i32) -> i32 {
+    let mut a = 0;
+    let mut b = 1;
+    let mut temp;
+
+    for _ in 0..n {
+        temp = a;
+        a = b;
+        b = b + temp;
+    }
+    return a
+}
+        return fib(n+1)
+}
+
+
+}

problems/container_with_most_water/solution.rs

@@ -0,0 +1,20 @@
+impl Solution {
+    pub fn max_area(height: Vec<i32>) -> i32 {
+        let max_idx = height.len();
+        let mut start = 0;
+        let mut end = max_idx - 1;
+        let mut max_area = height[start].min(height[end]) * (end - start) as i32;
+
+        while start < end {
+            if height[start] > height[end] {
+                end -= 1;
+            } else {
+                start += 1;
+            }
+            max_area = max_area.max(height[start].min(height[end]) * (end - start) as i32)
+        }
+
+        max_area
+    }
+
+}

problems/contains_duplicate/solution.rs

@@ -0,0 +1,13 @@
+use std::collections::HashSet;
+impl Solution {
+    pub fn contains_duplicate(nums: Vec<i32>) -> bool {
+        let mut set = HashSet::new();
+
+        for num in nums.into_iter() {
+            if !set.insert(num) {
+                return true;
+            }
+        }
+        return false;
+    }
+}

problems/convert_sorted_array_to_binary_search_tree/solution.c

@@ -0,0 +1,34 @@
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     struct TreeNode *left;
+ *     struct TreeNode *right;
+ * };
+ */
+struct TreeNode* sortedArrayToBST(int* nums, int numsSize) {
+	if (numsSize == 0) {
+		return 0;
+	}
+
+	struct TreeNode* node = malloc(sizeof(struct TreeNode));
+	if (numsSize == 1) {
+		node->val = *nums;
+		node->left = 0;
+		node->right = 0;
+		return node;
+	}
+
+	int half_idx = numsSize / 2;
+
+	// Set the middle number to the node's value
+	node->val = nums[half_idx];
+	// printArr(nums, half_idx);
+	// printArr(nums + half_idx + 1, numsSize - (half_idx + 1));
+	// Sort all numbers up to but not including the middle number
+	node->left = sortedArrayToBST(nums, half_idx);
+	// Sort all numbers after the middle number
+	node->right = sortedArrayToBST(nums + half_idx + 1, numsSize - (half_idx + 1));
+
+	return node;
+}

problems/count_and_say/solution.rs

@@ -0,0 +1,41 @@
+impl Solution {
+    pub fn count_and_say(n: i32) -> String {
+        let mut current = String::from("1");
+        if n == 1 {
+            return current;
+        }
+
+        for _ in 0..(n - 1) {
+            current = runlength_encode(&current);
+        }
+
+        return current;
+    }
+}
+
+fn runlength_encode(s: &str) -> String {
+    if s.is_empty() {
+        return String::new();
+    }
+
+    let mut chars = s.chars();
+
+    let mut res = String::new();
+    let mut current_char = chars.next().unwrap();
+    let mut ch_count = 1;
+
+    while let Some(ch) = chars.next() {
+        if ch == current_char {
+            ch_count += 1;
+        } else {
+            res.push_str(&ch_count.to_string());
+            res.push(current_char);
+            current_char = ch;
+            ch_count = 1;
+        }
+    }
+
+    res.push_str(&ch_count.to_string());
+    res.push(current_char);
+    res
+}

problems/counting_bits/solution.rs

@@ -0,0 +1,22 @@
+impl Solution {
+pub fn count_bits(n: i32) -> Vec<i32> {
+  let mut arr: Vec<i32> = vec![];
+
+  for mut i in 0..=n {
+
+
+    let mut ones = 0;
+    while i != 0 {
+      i = i & (i - 1);
+      ones += 1
+    }
+
+    arr.push(ones)
+
+  }
+
+  arr
+}
+
+
+}