Arjun Yadav

Active (before becoming defunct)

Codewars

Dec 13, 2022-present
Trying to practice different programming languages with Codewars (LeetCode is for harder, more Python-oriented problems).

Log

May 27, 2024-Sep 10, 2024 It's very annoying to log this particular project.
May 26, 2024 Finished Split String in Python:

def solution(s):
    res = []
    
    for i in range(0, len(s), 2):
        sub = s[i:i+2]
        res.append(sub)
    
    try:
        if len(res[-1]) == 1:
            res[-1] += "_"
    except:
        pass
    
    return res

Jan 29, 2023 Finished ISBN-10 Validation in Python:

def valid_ISBN10(isbn):
    if len(isbn) != 10:
        return False

    first_9 = isbn[:-1]
    last_digit = isbn[-1]

    total = 0

    try:
        total += sum([int(first_9[i]) * (i + 1) for i in range(len(first_9))])
    except:
        return False

    if last_digit.isdigit():
        total += int(last_digit) * 10
    elif last_digit == "X":
        total += 100
    else:
        return False

    return total % 11 == 0

Jan 28, 2023 Finished Mean Square Error in Python:

def solution(array_a, array_b):
    return sum((array_a[i] - array_b[i]) ** 2 for i in range(len(array_a))) / len(array_a)

Jan 27, 2023 Finished Find the unique number in Python:

def find_uniq(arr):
    return [i for i in set(arr) if arr.count(i) == 1][0]

Jan 25, 2023 Couldn't solve a problem today, but that's okay.
Jan 22, 2023 Finished First non-repeating character in Python:

def first_non_repeating_letter(string):
    for i in range(len(string)):
        if len([j for j in range(len(string)) if string[j].lower() == string[i].lower() and j != i]) == 0:
            return string[i]
    else:
        return ""

Jan 21, 2023 Finished Human Readable Time in Python:

def make_readable(seconds):
    hours = seconds // 3600
    minutes = (seconds - (hours * 3600)) // 60
    seconds_print = seconds - (minutes * 60) - (hours * 3600)

    if len(str(hours)) < 2:
        hours = "0" + str(hours)

    if len(str(minutes)) < 2:
        minutes = "0" + str(minutes)

    if len(str(seconds_print)) < 2:
        seconds_print = "0" + str(seconds_print)

    return f"{hours}:{minutes}:{seconds_print}"

Jan 20, 2023 Finished Pete, the baker in Python:

def cakes(recipe, available):
    count = 0
    max_scale = []

    for k, v in recipe.items():
        if k not in available:
            max_scale = [0]
        else:
            if available[k] < v:
                max_scale = [0]
            else:
                max_scale.append(available[k] // v)

    count = min(max_scale, default=0)
    return count

Jan 18, 2023 Still no luck.
Jan 17, 2023 Trying to solve Catching Car Mileage Numbers
Jan 16, 2023 Tried to solve a couple of problems in Python, but to no avail.
Jan 15, 2023 Finished Does my number look big in this? in Python:

def narcissistic(value):
    return sum([int(i) ** len(str(value)) for i in str(value)]) == value

Jan 04, 2023 Finished Simple Pig Latin in Python:

def pig_it(text):
    res = []

    for i in text.split(" "):
        if i.isalpha():
            word = i[1:] + i[0] + "ay"
            res.append(word)
        else:
            res.append(i)

    return " ".join(res)

Jan 03, 2023 Finished Count the smiley faces! in Python:

def count_smileys(arr):
    valid_smiley_faces = [':)', ';)', ':-)', ';-)', ':~)', ';~)', ':D', ';D', ':-D', ';-D', ':~D', ';~D', ':D', ';D']

    return len([i for i in arr if i in valid_smiley_faces])

Jan 02, 2023 Finished Are they the "same"? in Python:

def comp(array1, array2):
    if array1 == None or array2 == None:
        return False

    if sorted([i**2 for i in array1]) == sorted(array2):
        return True
    else:
        return False

Jan 01, 2023 Finished Moving Zeros To The End in Python:

def move_zeros(lst):
  return [i for i in lst if i != 0] + [i for i in lst if i == 0]

Dec 31, 2022 Finished (Multiplicative Persistence) in Python. Hoping to do more Java problems in 2023:

import math

def persistence(n):
    count = 0

    while len(str(n)) != 1:
        n = math.prod([int(i) for i in str(n)])
        count += 1

    return count

Dec 30, 2022 Finished Calculating with Functions in Python:

def zero(operand_num=""): #your code here
    return eval("0" + operand_num)
def one(operand_num=""): #your code here
    return eval("1" + operand_num)
def two(operand_num=""): #your code here
    return eval("2" + operand_num)
def three(operand_num=""): #your code here
    return eval("3" + operand_num)
def four(operand_num=""): #your code here
    return eval("4" + operand_num)
def five(operand_num=""): #your code here
    return eval("5" + operand_num)
def six(operand_num=""): #your code here
    return eval("6" + operand_num)
def seven(operand_num=""): #your code here
    return eval("7" + operand_num)
def eight(operand_num=""): #your code here
    return eval("8" + operand_num)
def nine(operand_num=""): #your code here
    return eval("9" + operand_num)

def plus(num): #your code here
    return f"+{num}"
def minus(num): #your code here
    return f"-{num}"
def times(num): #your code here
    return f"*{num}"
def divided_by(num): #your code here
    return f"//{num}"

Dec 29, 2022 Finished Break camelCase in Python:

def solution(s):
    res = ""

    for i in s:
        if ord(i) >= 65 and ord(i) <= 90:
            res += f" {i}"
        else:
            res += i

    return res

Dec 28, 2022 Finished Friend or Foe? in Python:

def friend(x):
	return [i for i in x if len(i) == 4]

Dec 27, 2022 Finished Sum of two lowest positive integers in Python:

def sum_two_smallest_numbers(numbers):
    return min(numbers) + min([i for i in numbers if i != min(numbers)])

Dec 26, 2022 Finished Highest and Lowest in Python:

def high_and_low(numbers):
    return f"{max([int(i) for i in numbers.split(' ')])} {min([int(i) for i in numbers.split(' ')])}"

Dec 25, 2022 Finished Decode the Morse code in Python:

from preloaded import MORSE_CODE

def decode_morse(morse_code):
    # Remember - you can use the preloaded MORSE_CODE dictionary:
    # For example:
    # MORSE_CODE['.-'] = 'A'
    # MORSE_CODE['--...'] = '7'
    # MORSE_CODE['...-..-'] = '$'
    temp_morse_code = morse_code.strip().split('   ')
    decoded_message = []

    for i in temp_morse_code:
        for j in i.split(' '):
            decoded_message.append(MORSE_CODE[j])
        decoded_message.append(" ")

    return "".join(decoded_message).rstrip()

Dec 24, 2022 Finished List Filtering in Python:

def filter_list(l):
    return [i for i in l if str(i).isdigit() and isinstance(i, int)]

Dec 23, 2022 Finished String ends with? in Python:

def solution(string, ending):
    if ending == '':
        return True
    else:
        if ending in string:
            if string[len(string) - len(ending):] == ending:
                return True
            else:
                return False
        else:
            return False

Dec 22, 2022 Finished Find the odd int in Java:

import java.util.ArrayList;

public class FindOdd {
	public static int findIt(int[] a) {
    ArrayList<Integer> count_al = new ArrayList<Integer>();

  	for (int i = 0; i < a.length; i++) {
      int number = a[i];
      int count = 0;

      for (int j = 0; j < a.length; j++) {
        if (a[j] == number) {
          count++;
        }
      }

      count_al.add(count);
    }

    for (int i = 0; i < count_al.size(); i++) {
      if (count_al.get(i) % 2 != 0) {
        return a[i];
      }
    }

    return 0;
  }
}

Dec 21, 2022 Finished Split Strings in Python (accidentally left the print statement in my final solution - oh well):

def solution(s):
    print(s)
    if len(s) % 2 != 0:
        temp_res = [s[i:i+2] for i in range(0, len(s), 2)]
        temp_res[-1] = temp_res[-1] + "_"
        return temp_res
    else:
        return [s[i:i+2] for i in range(0, len(s), 2)]

Dec 20, 2022 Finished Create Phone Number in Java:

public class Kata {
  public static String createPhoneNumber(int[] numbers) {
   String phoneNumber = "(" + String.valueOf(numbers[0]) + String.valueOf(numbers[1]) + String.valueOf(numbers[2]) + ") " + String.valueOf(numbers[3]) + String.valueOf(numbers[4]) + String.valueOf(numbers[5]) + "-" + String.valueOf(numbers[6]) + String.valueOf(numbers[7]) + String.valueOf(numbers[8]) + String.valueOf(numbers[9]);
   return phoneNumber;
  }
}

Dec 19, 2022 Finished Descending Order in Java:

import java.util.ArrayList;

public class DescendingOrder {
  public static int sortDesc(final int num) {
    int temp = num;
    ArrayList<Integer> digits = new ArrayList<Integer>();

    while (temp != 0) { // while loop for appending digits
      int digit = temp % 10;
      digits.add(digit);
      temp /= 10;
    }

    for (int i = 0; i < digits.size() - 1; i++) { // for loops for sorting - bubble sort
      for (int j = 0; j < digits.size() - 1 - i; j++) {
        if (digits.get(i + j + 1) > digits.get(i)) {
          int temp_digit = digits.get(i);
          digits.set(i, digits.get(i + j + 1));
          digits.set(i + j + 1, temp_digit);
        }
      }
    }

    int res = 0;

    for (int i = 0; i < digits.size(); i++) { // converting list of digits to int
      int digit = digits.get(i);
      res = (res * 10) + digit;
    }

    return res;
  }
}

Dec 18, 2022 Finished Stop gninnipS My sdroW! in Java:

import java.util.ArrayList;

public class SpinWords {

  public String spinWords(String sentence) {
    String[] words = sentence.split(" "); // credit - https://www.geeksforgeeks.org/split-string-java-examples/
    ArrayList<String> tempRes = new ArrayList<String>(); // creating a temp ArrayList for words

   for (int i = 0; i < words.length; i++) {
      if (words[i].length() >= 5) {
        String reverseString = "";

        for (int j = words[i].length() - 1; j >= 0; j--) { // inner for-loop for reversing the string
          reverseString += words[i].charAt(j);
        }

        tempRes.add(reverseString);

      } else {
        tempRes.add(words[i]);
      }
    }

    String res = String.join(" ", tempRes); // credit - https://stackoverflow.com/questions/599161/best-way-to-convert-an-arraylist-to-a-string

    return res;
  }
}

Dec 17, 2022 Finished Multiples of 3 or 5 in Java:

public class Solution {

  public int solution(int number) {
    if (number < 0) {
      return -1; // returning -1 if the number is negative
    } else {
      int res = 0;

      for (int i = 1; i < number; i++) {
        if (i % 3 == 0 || i % 5 == 0) { // only counting the number once if multiple of 15
          res += i;
        }
      }

      return res;
    }
  }
}

Dec 16, 2022 Finished Mumbling in Java:

public class Accumul {

    public static String accum(String s) {
      String res = ""; // result string

      for (int i = 0; i < s.length(); i++) {
        char chr = s.charAt(i); // getting character at each index
        res += Character.toUpperCase(chr); // converting character to uppercase

        for (int j = 0; j < i; j++) {
          char chr_repeat = s.charAt(i); // repeatedly getting the same character based on index
          res += Character.toLowerCase(chr_repeat); // converting character to lowercase
        }

        if (i != s.length() - 1) { // as long as not last character, add hyphen
          res += "-";
        }
      }

      return res;
    }
}

Dec 15, 2022 Finished Is this a triangle? in JavaScript:

function isTriangle(a, b, c) {
  if (a + b > c && b + c > a && a + c > b) return true;
  else return false;
}

Dec 14, 2022 Finished Vowel Count in JavaScript:

function getCount(str) {
  let count = 0;
  for (let i = 0; i < str.length; i++) {
    if (
      str[i] == "a" ||
      str[i] == "e" ||
      str[i] == "i" ||
      str[i] == "o" ||
      str[i] == "u"
    )
      count++;
  }
  return count;
}

Dec 13, 2022 Finished a couple of different problems (?) and got to 8 kyu.

LeetCode

Nov 13, 2021-present
Trying to do a problem every day. All of the general problems are done in Python.

Log

Jun 06, 2024-Jul 26, 2024 Loads of problems.
Jun 05, 2024 Finished Longest Palindrome:

class Solution:
    def longestPalindrome(self, s: str) -> int:
        # Credit - https://leetcode.com/problems/longest-palindrome/solutions/5255543/python3-solution
        c = Counter(s)
        ans = 0

        for i in c.values():
            ans += int(i/2)*2
            if ans%2 == 0 and i%2 == 1:
                ans += 1
                
        return ans

May 28, 2024 Finished Minimum Number of Moves to Seat Everyone:

class Solution:
    def minMovesToSeat(self, seats: List[int], students: List[int]) -> int:
        # Credit - https://leetcode.com/problems/minimum-number-of-moves-to-seat-everyone/submissions/1270074368
        
        total = 0

        seats.sort()
        students.sort()

        for i in range(len(students)):
            total += abs(students[i] - seats[i])

        return total

May 26, 2024 Finished Find the Number of Good Pairs I:

class Solution:
    def numberOfPairs(self, nums1: List[int], nums2: List[int], k: int) -> int:
        count = 0

        for i in nums1:
            for j in nums2:
                if i % (j * k) == 0:
                    count += 1
        
        return count

May 25, 2024 Finished Find the XOR of Numbers Which Appear Twice:

class Solution:
    def duplicateNumbersXOR(self, nums: List[int]) -> int:
        # Credit - https://leetcode.com/problems/find-the-xor-of-numbers-which-appear-twice/solutions/5206859/easy-solution-contest-25-05-2024
        
        result = 0
        for num, count in Counter(nums).items():
            if count == 2:
                result ^= num
        return result

May 21, 2024 Finished Subsets:

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        # Credit - https://leetcode.com/problems/subsets/solutions/5186387/fastest-100-easy-to-understand
         result = []

        def explore(index, curr):
            if index == len(nums):
                result.append(curr.copy())
                return

            curr.append(nums[index])
            explore(index + 1, curr)
            curr.pop()
            explore(index + 1, curr)

        explore(0, [])
        return result

May 19, 2024 Finished Special Array I:

class Solution:
    def isArraySpecial(self, nums: List[int]) -> bool:
        if len(nums) == 1:
            return True
        else:
            for i in range(len(nums) - 1):
                if nums[i+1] % 2 == 0 and nums[i] % 2 == 0:
                    return False
                elif nums[i+1] % 2 != 0 and nums[i] % 2 != 0:
                    return False
        return True

May 12, 2024 Finished Check if Grid Satisfies Conditions:

class Solution:
    def satisfiesConditions(self, grid: List[List[int]]) -> bool:
        for i in range(len(grid)):
            for j in range(len(grid[i])):
                if i != len(grid) - 1:
                    if grid[i][j] != grid[i + 1][j]:
                        return False
                if j != len(grid[i]) - 1:
                    if grid[i][j] == grid[i][j + 1]:
                        return False
        return True

May 09, 2024 Finished Make Three Strings Equal:

class Solution:
    def findMinimumOperations(self, s1: str, s2: str, s3: str) -> int:
        # Credit - https://leetcode.com/problems/make-three-strings-equal/solutions/4305578/beats-100-users-by-speed-and-memory-by-prodonik-java-c-c-python-ruby
        
        lengths = [len(s1), len(s2), len(s3)]
        minimum_length = min(lengths)
        count = 0
        for i in range(minimum_length):
            if s1[i] == s2[i] == s3[i]:
                count += 1
            else:
                break
        if count == 0:
            return -1
        result = sum(length - count for length in lengths)
        return result

May 05, 2024 Finished Valid Word:

class Solution:
    def isValid(self, word: str) -> bool:
        if len(word) >= 3:
            for i in word:
                if i.isalnum() == False:
                    return False
            
            for i in word:
                if i.isalpha():
                    if i in "aeiouAEIOU":
                        for j in word:
                            if j.isalpha():
                                if j not in "aeiouAEIOU":
                                    return True
        
        return False

May 03, 2024 Finished Array Reduce Transformation:

/**
 * @param {number[]} nums
 * @param {Function} fn
 * @param {number} init
 * @return {number}
 */
var reduce = function(nums, fn, init) {
    return nums.reduce(fn, init);
};

May 01, 2024 Finished Reverse Prefix of Word:

class Solution:
    def reversePrefix(self, word: str, ch: str) -> str:
        import re
        
        if re.findall(f"[a-zA-Z]*{ch}[a-zA-Z]*", word) == []:
            return word
        
        count = 0
        
        for i in word:
            count += 1
            if i == ch:
                tempRes = word[0:count]
                return tempRes[::-1] + word[count:len(word)]

Apr 30, 2024 Finished Valid Phone Numbers:

# Read from the file file.txt and output all valid phone numbers to stdout.
grep -e "^[0-9]\{3\}\-[0-9]\{3\}\-[0-9]\{4\}$" -e "^([0-9]\{3\}) [0-9]\{3\}\-[0-9]\{4\}$" file.txt

Apr 29, 2024 Finished Find the Integer Added to Array I:

class Solution:
    def addedInteger(self, nums1: List[int], nums2: List[int]) -> int:
        return sorted(nums2)[0] - sorted(nums1)[0]

Apr 26, 2024 Finished Reshape the Matrix:

class Solution:
    def matrixReshape(self, mat: List[List[int]], r: int, c: int) -> List[List[int]]:
        import numpy as np
        try:
            return np.array(mat).reshape((r, c)).tolist()
        except:
            return mat

Apr 25, 2024 Finished Calculate Amount Paid in Taxes:

class Solution:
    def calculateTax(self, brackets: List[List[int]], income: int) -> float:
        tax = 0

        for i in range(len(brackets)):
            if i == 0:
                amount_taxed = brackets[i][0]
                if amount_taxed <= income:
                    tax += amount_taxed * (brackets[i][1]/100)
                    income -= amount_taxed
                else:
                    tax += income * (brackets[i][1]/100)
                    income = 0
            else:
                amount_taxed = brackets[i][0] - brackets[i-1][0]
                if amount_taxed <= income:
                    tax += amount_taxed * (brackets[i][1]/100)
                    income -= amount_taxed
                else:
                    tax += income * (brackets[i][1]/100)
                    income = 0

        return tax

Apr 23, 2024 Finished Sort By:

/**
 * @param {Array} arr
 * @param {Function} fn
 * @return {Array}
 */
var sortBy = function (arr, fn) {
  return arr.sort((a, b) => fn(a) - fn(b));
};

Apr 22, 2024 Finished Transpose File:

# Read from the file file.txt and print its transposed content to stdout.

# Credit - https://leetcode.com/problems/transpose-file/solutions/4550818/transposed

awk '
{
    for (i = 1; i <= NF; i++) {
        if (NR == 1) {
            matrix[i] = $i;
        } else {
            matrix[i] = matrix[i] " " $i;
        }
    }
}
END {
    for (i = 1; i <= NF; i++) {
        print matrix[i];
    }
}' file.txt

Apr 21, 2024 Finished Count the Number of Special Characters I:

class Solution:
    def numberOfSpecialChars(self, word: str) -> int:
        count = 0

        for i in list(dict.fromkeys(word.upper())):
            if i.lower() in word and i.upper() in word:
                count += 1

        return count

Apr 18, 2024 Finished Distribute Elements Into Two Arrays I:

class Solution:
    def resultArray(self, nums: List[int]) -> List[int]:
        arr1 = [nums[0]]
        arr2 = [nums[1]]

        for i in range(2, len(nums)):
            if arr1[-1] > arr2[-1]:
                arr1.append(nums[i])
            else:
                arr2.append(nums[i])

        return arr1 + arr2

Apr 17, 2024 Finished Score of a String:

class Solution:
    def scoreOfString(self, s: str) -> int:
        res = 0
        for i in range(1, len(s)):
            res += abs(ord(s[i]) - ord(s[i-1]))
        return res

Apr 15, 2024 Finished Latest Time You Can Obtain After Replacing Characters:

class Solution:
    def findLatestTime(self, s: str) -> str:
        new_str = ""
        flag = False

        for i in range(len(s)):
            if s[i] == "?":
                if i == 0:
                    if s[1] == "?" and flag == False:
                        new_str += "11"
                        flag = True
                    elif int(s[1]) < 2 and flag == False:
                        new_str += "1"
                    elif flag == False:
                        new_str += "0"
                elif i == 1:
                    if s[0] == "?" and flag == False:
                        new_str += "11"
                        flag = True
                    elif s[0] == "1" and flag == False:
                        new_str += "1"
                    elif flag == False:
                        new_str += "9"
                elif i == 4:
                    new_str += "9"
                elif i == 3:
                    new_str += "5"
            else:
                new_str += s[i]

        return new_str

Apr 09, 2024 Finished Time Needed to Buy Tickets:

class Solution:
    def timeRequiredToBuy(self, tickets: List[int], k: int) -> int:
        # Credit - https://leetcode.com/problems/time-needed-to-buy-tickets/solutions/4996426/simple-while-loop

        time = 0
        i = 0

        while tickets[k] != 0 :
            if i == len(tickets):
                i = 0

            if tickets[i] != 0:
                time += 1
                tickets[i] -= 1

            i += 1

        return time

Apr 08, 2024 Finished Number of Students Unable to Eat Lunch:

class Solution:
    def countStudents(self, students: List[int], sandwiches: List[int]) -> int:
        count = 0

        while len(students) > 0 and count < 300:
            sandwich = sandwiches[0]
            student = students[0]

            if student == sandwich:
                sandwiches = sandwiches[1:]
                students = students[1:]
            else:
                students = students[1:] + [students[0]]

            count += 1

        return len(students)

Apr 06, 2024 Finished Harshad Number:

class Solution:
    def sumOfTheDigitsOfHarshadNumber(self, x: int) -> int:
        if x % sum([int(i) for i in list(str(x))]) == 0:
            return sum([int(i) for i in list(str(x))])
        else:
            return -1

Apr 05, 2024 Finished Make The String Great:

class Solution:
    def makeGood(self, s: str) -> str:
        def check():
            for i in range(len(s)-1):
                if s[i].swapcase() == s[i+1] or s[i] == s[i+1].swapcase():
                    return True

        while check():
            for i in range(len(s)-1):
                if s[i].swapcase() == s[i+1] or s[i] == s[i+1].swapcase():
                    s = s[:i] + s[i+2:]
                    break

        return s

Apr 04, 2024 Finished Maximum Nesting Depth of the Parentheses:

class Solution:
    def maxDepth(self, s: str) -> int:
        depth = 0
        depths = []

        for i in s:
            if i == "(":
                depth += 1
                depths.append(depth)
            elif i == ")":
                depth -= 1
            else:
                depths.append(depth)

        return max(depths, default=1)

Apr 02, 2024 Finished Isomorphic Strings:

class Solution:
    def isIsomorphic(self, s: str, t: str) -> bool:
        # Credit - https://leetcode.com/problems/isomorphic-strings/solutions/4959995/beat-99-easy
        return len(set(zip(s,t))) == len(set(s)) == len(set(t))

Mar 27, 2024 Finished Maximum Number of Pairs in Array:

class Solution:
    def numberOfPairs(self, nums: List[int]) -> List[int]:
        # Credit - https://leetcode.com/problems/maximum-number-of-pairs-in-array/solutions/2459648/python-easy-solution

        res = []
        pair = 0
        unique = list(set(nums))

        for i in range(len(unique)):
            count = nums.count(unique[i])
            if count % 2 != 0:
                res.append(unique[i])
            pair += (count) // 2

        return [pair,len(res)]

Mar 19, 2024 Finished Count Substrings Starting and Ending with Given Character:

class Solution:
    def countSubstrings(self, s: str, c: str) -> int:
        return s.count(c)*(s.count(c)+1)//2

Mar 17, 2024 Finished Find the Sum of Encrypted Integers:

class Solution:
    def sumOfEncryptedInt(self, nums: List[int]) -> int:
        def encrypt(num):
            n = str(num)
            l = len(n)

            return int(str(max([int(i) for i in n])) * l)

        return sum([encrypt(i) for i in nums])

Mar 16, 2024 Finished Apple Redistribution into Boxes:

class Solution:
    def minimumBoxes(self, apple: List[int], capacity: List[int]) -> int:
        # Credit - https://leetcode.com/problems/apple-redistribution-into-boxes/solutions/4851129/easy-python-solution

        count = 0
        temp = 0
        capacity.sort(reverse=True)

        for i in capacity:
            temp += i
            count += 1

            if temp >= sum(apple):
                return count

        return count

Mar 15, 2024 Finished Product of Array Except Self:

class Solution:
    def productExceptSelf(self, nums: List[int]) -> List[int]:
        # Credit - https://leetcode.com/problems/product-of-array-except-self/solutions/4876999/prefix-suffix-products-o-1-extra-space-3ms-beats-99-89
        a = [1]*len(nums)
        for i in range(len(nums)-2, -1, -1):
            a[i] = nums[i+1] * a[i+1]
        b = 1

        for j in range(1,len(nums)):
            b *= nums[j-1]
            a[j] *= b
        return a

Mar 07, 2024 Finished Middle of the Linked List:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def middleNode(self, head: Optional[ListNode]) -> Optional[ListNode]:
        # https://leetcode.com/problems/middle-of-the-linked-list/solutions/4835201/easy-code-with-100-beats-with-c-beginner-friendly

        count = 0
        ptr = head
        while ptr is not None:
            count += 1
            ptr = ptr.next

        ptr = head
        for i in range(count // 2):
            ptr = ptr.next

        return ptr

Mar 03, 2024 Finished Minimum Operations to Exceed Threshold Value I:

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        count = 0

        while False in [i >= k for i in nums]:
            nums.remove(min(nums))
            count += 1

        return count

Feb 25, 2024 Finished Even Odd Tree:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isEvenOddTree(self, root: Optional[TreeNode]) -> bool:
        def traverse(tree, lvl):
            if tree:
                if lvl >= len(li):
                    lst = []
                    li.append(lst)

                li[lvl].append(tree.val)
                traverse(tree.left, lvl+1)
                traverse(tree.right, lvl+1)

        li = []
        traverse(root, 0)

        print(li)

        for i in range(len(li)):
            if i % 2 == 0:
                for j in li[i]:
                    if j % 2 == 0:
                        return False
                if not all(i < j for i, j in zip(li[i], li[i][1:])):
                    return False
            else:
                for j in li[i]:
                    if j % 2 != 0:
                        return False
                if not all(i > j for i, j in zip(li[i], li[i][1:])):
                    return False

        return True

Feb 25, 2024 Finished Split the Array:

class Solution:
    def isPossibleToSplit(self, nums: List[int]) -> bool:
        for i in set(nums):
            if nums.count(i) > 2:
                return False
        return True

Feb 21, 2024 Finished Bitwise AND of Numbers Range:

class Solution:
    def rangeBitwiseAnd(self, left: int, right: int) -> int:
        # Credit - https://leetcode.com/problems/bitwise-and-of-numbers-range/solutions/4759869/beat-100-bitwise-operation

        shift = 0
        while left < right:
            left >>= 1
            right >>= 1
            shift += 1
        return left << shift

Feb 18, 2024 Finished Count Prefix and Suffix Pairs I:

class Solution:
    def countPrefixSuffixPairs(self, words: List[str]) -> int:
        # Credit - https://leetcode.com/problems/count-prefix-and-suffix-pairs-i/solutions/4744481/simple-and-easy-to-understand-python

        def isPrefixAndSuffix(presuf, word):
            return word[:len(presuf)] == presuf and word[-len(presuf):] == presuf

        count = 0

        for i in range(len(words) - 1):
            for j in range(i+1, len(words)):
                count += isPrefixAndSuffix(words[i],words[j])

        return count

Feb 10, 2024 Finished Modify the Matrix:

class Solution:
    def modifiedMatrix(self, matrix: List[List[int]]) -> List[List[int]]:
        transpose = []

        for i in range(len(matrix[0])):
            col = []

            for j in range(len(matrix)):
                col.append(matrix[j][i])

            transpose.append(col)

        print(transpose)

        for i in range(len(matrix)):
            for j in range(len(matrix[0])):
                if matrix[i][j] == -1:
                    matrix[i][j] = max(transpose[j])

        return matrix

Feb 09, 2024 Finished Ant on the Boundary:

class Solution:
    def returnToBoundaryCount(self, nums: List[int]) -> int:
        sum = 0
        count = 0

        for i in nums:
            sum += i
            if sum == 0:
                count += 1

        return count

Feb 08, 2024 Finished Type of Triangle II:

class Solution:
    def triangleType(self, nums: List[int]) -> str:
        def check(li):
            if li[0] + li[1] > li[2] and li[0] + li[2] > li[1] and li[1] + li[2] > li[0]:
                return True
            else:
                return False

        if check(nums):
            if len(set(nums)) == 1:
                return "equilateral"
            elif len(set(nums)) == 2:
                return "isosceles"
            else:
                return "scalene"
        else:
            return "none"

Feb 03, 2024 Finished Word Frequency:

# Read from the file words.txt and output the word frequency list to stdout.
# Credit - https://leetcode.com/problems/word-frequency/solutions/4586376/perfect
cat words.txt | tr -s ' ' '\n' | sort | uniq -c | sort -nr | awk '{print $2, $1}'

Feb 02, 2024 Finished Check Array Formation Through Concatenation:

class Solution:
    def canFormArray(self, arr: List[int], pieces: List[List[int]]) -> bool:
        for i in pieces:
            n = len(i)
            if i not in list((arr[j:j + n] for j in range(0, len(arr) - (n - 1)))):
                return False
        return True

Jan 28, 2024 Finished Number of Changing Keys:

class Solution:
    def countKeyChanges(self, s: str) -> int:
        s = s.lower()
        count = 0

        for i in range(1, len(s)):
            if s[i] != s[i - 1]:
                count += 1

        return count

Jan 27, 2024 Finished Check if Binary String Has at Most One Segment of Ones:

class Solution:
    def checkOnesSegment(self, s: str) -> bool:
        if len([i for i in s.split('0') if i != '']) > 1:
            return False
        return True

Jan 26, 2024 Finished Find Center of Star Graph:

class Solution:
    def findCenter(self, edges: List[List[int]]) -> int:

        # Credit - https://leetcode.com/problems/find-center-of-star-graph/solutions/4534529/beginner-friendly

        temp = defaultdict(list)

        for i in edges:
            temp[i[0]].append(i[1])
            temp[i[1]].append(i[0])

        for i, j in temp.items():
            if len(j) == len(temp) - 1:
                return i

Jan 16, 2024 Finished Insert Delete GetRandom O(1):

import random

class RandomizedSet:

    def __init__(self):
        self.list = []


    def insert(self, val: int) -> bool:
        if val in self.list:
            return False
        else:
            self.list.append(val)
            return True

    def remove(self, val: int) -> bool:
        if val not in self.list:
            return False
        else:
            self.list.remove(val)
            return True


    def getRandom(self) -> int:
        return self.list[random.randrange(0, len(self.list))]

# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

Jan 15, 2024 Finished Count Elements With Maximum Frequency:

class Solution:
    def maxFrequencyElements(self, nums: List[int]) -> int:
        max_count = max([nums.count(i) for i in nums])
        total = 0

        for i in nums:
            if nums.count(i) == max_count:
                total += 1

        return total

Jan 12, 2024 Finished Drop Duplicate Rows:

import pandas as pd

def dropDuplicateEmails(customers: pd.DataFrame) -> pd.DataFrame:
    return customers.drop_duplicates(subset = ['email'])

Jan 10, 2024 Finished Maximum Area of Longest Diagonal Rectangle:

class Solution:
    def areaOfMaxDiagonal(self, dimensions: List[List[int]]) -> int:
        diagonal = sqrt(max(dimensions, key=lambda x: sqrt((x[0] ** 2) + (x[1] ** 2)))[0] ** 2 + max(dimensions, key=lambda x: sqrt((x[0] ** 2) + (x[1] ** 2)))[1] ** 2)

        max_area = 0

        for i in dimensions:
            if sqrt(i[0] ** 2 + i[1] ** 2) == diagonal:
                if i[0] * i[1] > max_area:
                    max_area = i[0] * i[1]

        return max_area

Jan 07, 2024 Finished Smallest Missing Integer Greater Than Sequential Prefix Sum:

class Solution:
    def missingInteger(self, nums: List[int]) -> int:
        count = nums[0]

        for i in range(1, len(nums)):
            if nums[i] == nums[i-1] + 1:
                count += nums[i]
            else:
                break

        while True:
            if count not in nums:
                return count
            else:
                count += 1

Jan 06, 2024 Finished Reshape Data: Melt:

import pandas as pd

def meltTable(report: pd.DataFrame) -> pd.DataFrame:
    return pd.melt(report, id_vars=['product'], value_vars=['quarter_1', 'quarter_2', 'quarter_3', 'quarter_4'], var_name='quarter', value_name='sales')

Jan 05, 2024 Finished Reshape Data: Pivot:

import pandas as pd

def pivotTable(weather: pd.DataFrame) -> pd.DataFrame:
    # Credit - https://leetcode.com/problems/reshape-data-pivot/solutions/4141086/line-by-line-explanation-easy-solution-beginner-friendly-pandas
    return weather.pivot_table(index='month', columns='city', values='temperature', aggfunc='max')

Jan 03, 2024 Finished Check if Bitwise OR Has Trailing Zeros:

class Solution:
    def hasTrailingZeros(self, nums: List[int]) -> bool:
        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if str(bin(nums[i] | nums[j]))[-1] == "0":
                    return True
        return False

Jan 01, 2024 Finished Largest Substring Between Two Equal Characters:

class Solution:
    def maxLengthBetweenEqualCharacters(self, s: str) -> int:
        lengths = []

        for i in range(len(s)):
            for j in range(len(s)):
                if s[i] == s[j]:
                    lengths.append(j - i - 1)

        return max(lengths, default=-1)

Dec 31, 2023 Finished Largest Substring Between Two Equal Characters, happy new year in advance!

class Solution:
    def maxLengthBetweenEqualCharacters(self, s: str) -> int:
        lengths = []

        for i in range(len(s)):
            for j in range(len(s)):
                if s[i] == s[j]:
                    lengths.append(j - i - 1)

        return max(lengths, default=-1)

Dec 30, 2023 Finished Redistribute Characters to Make All Strings Equal:

class Solution:
    def makeEqual(self, words: List[str]) -> bool:
        if len(words) == 1:
            return True

        chars = set("".join(words))

        for char in chars:
            if "".join(words).count(char) % len(words) != 0:
                return False

        return True

Dec 29, 2023 Finished Reshape Data: Concatenate:

import pandas as pd

def concatenateTables(df1: pd.DataFrame, df2: pd.DataFrame) -> pd.DataFrame:
    return pd.concat([df1, df2], ignore_index=True, sort=False)

Dec 28, 2023 Finished Fill Missing Data:

import pandas as pd

def fillMissingValues(products: pd.DataFrame) -> pd.DataFrame:
    products["quantity"].fillna(0, inplace=True)
    return products

Dec 27, 2023 Finished Change Data Type:

import pandas as pd

def changeDatatype(students: pd.DataFrame) -> pd.DataFrame:
    students['grade'] = students['grade'].astype(int)
    return students

Dec 26, 2023 Finished Count the Number of Incremovable Subarrays I:

class Solution:
    def incremovableSubarrayCount(self, nums: List[int]) -> int:
        count = 1

        for i in range(len(nums)):
            for j in range(len(nums)):
                if j>=i:
                    remainder = nums[:i] + nums[j+1:]
                    if len(remainder) > 0 and all(i < j for i, j in zip(remainder, remainder[1:])):
                        count += 1

        return count

Dec 25, 2023 Finished Minimum Number Game

class Solution:
    def numberGame(self, nums: List[int]) -> List[int]:
        arr = []
        nums.sort()

        while len(nums) > 0:
            al = nums.pop()
            bo = nums.pop()

            arr.extend([bo, al])

        return arr[::-1]

Dec 22, 2023 Finished Maximum Score After Splitting a String:

class Solution:
    def maxScore(self, s: str) -> int:
        return max([s[:i].count('0') + s[i:].count('1') for i in range(1, len(s))])

Dec 21, 2023 Finished Rename Columns:

import pandas as pd

def renameColumns(students: pd.DataFrame) -> pd.DataFrame:
    students.rename(columns={'id': 'student_id', 'first': 'first_name', 'last': 'last_name', 'age': 'age_in_years'}, inplace=True)
    return students

Dec 19, 2023 Finished Drop Missing Data:

import pandas as pd

def dropMissingData(students: pd.DataFrame) -> pd.DataFrame:
    students.drop(students[students['name'].isnull()].index, inplace = True)
    return students

Dec 16, 2023 Finished Find Common Elements Between Two Arrays:

class Solution:
    def findIntersectionValues(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return [len([i for i in nums1 if i in nums2]), len([i for i in nums2 if i in nums1])]

Dec 06, 2023 Finished Calculate Money in Leetcode Bank:

class Solution:
    def totalMoney(self, n: int) -> int:
        total = 0
        lastMonday = 1
        j = 1

        for i in range(n):
            if i> 0 and i % 7 == 0:
                lastMonday += 1
                total += lastMonday
                j = lastMonday + 1
            else:
                total += j
                j += 1

        return total

Dec 04, 2023 Finished Find the Peaks:

class Solution:
    def findPeaks(self, mountain: List[int]) -> List[int]:
        peaks = []

        for i in range(1, len(mountain)-1):
            if mountain[i-1] < mountain[i] and mountain[i] > mountain[i+1]:
                peaks.append(i)

        return peaks

Dec 03, 2023 Finished Sum in a Matrix:

class Solution:
    def matrixSum(self, nums: List[List[int]]) -> int:
        count = len(nums[0])
        score = 0

        while count > 0:
            numbers = []

            for i in range(len(nums)):
                numbers.append(max(nums[i]))
                nums[i].remove(max(nums[i]))

            score += max(numbers)
            count -= 1

        return score

Nov 30, 2023 Finished Modify Columns:

import pandas as pd

def modifySalaryColumn(employees: pd.DataFrame) -> pd.DataFrame:
    employees['salary'] = employees['salary'] * 2
    return employees

Nov 29, 2023 Finished Count Beautiful Substrings I:

class Solution:
    def beautifulSubstrings(self, s: str, k: int) -> int:
        # Credit - https://leetcode.com/problems/count-beautiful-substrings-i/solutions/4330501/readable-python-solution/

        beautiful_count = 0
        vowels_list = ['a','e','i','o','u']

        for i in range(len(s)):
            vowels, consonants = 0 , 0
            j = i
            while j < len(s):
                if s[j] in vowels_list:
                    vowels += 1
                else:
                    consonants += 1
                if vowels == consonants and (vowels * consonants) % k == 0:
                    beautiful_count += 1
                j += 1
        return beautiful_count

Nov 28, 2023 Finished Matrix Similarity After Cyclic Shifts:

class Solution:
    def areSimilar(self, mat: List[List[int]], k: int) -> bool:
        # Credit - https://leetcode.com/problems/matrix-similarity-after-cyclic-shifts/solutions/4330359/python-easy-solution/

        k %= len(mat[0])

        for m in mat:
            if m != m[k:] + m[:k]:
                return False

        return True

Nov 26, 2023 Finished Find Words Containing Character:

class Solution:
    def findWordsContaining(self, words: List[str], x: str) -> List[int]:
        return [i for i in range(len(words)) if x in words[i]]

Nov 25, 2023 Finished Rearrange Products Table:

# Write your MySQL query statement below

# Credit - https://leetcode.com/problems/rearrange-products-table/solutions/3853137/simple-mysql-solution-using-union/

SELECT product_id, 'store1' AS store, store1 AS price FROM Products WHERE store1 IS NOT NULL
UNION
SELECT product_id, 'store2' AS store, store2 AS price FROM Products WHERE store2 IS NOT NULL
UNION
SELECT product_id, 'store3' AS store, store3 AS price FROM Products WHERE store3 IS NOT NULL;

Nov 24, 2023 Tried to finish Difference Between Ones and Zeros in Row and Columnhttps://leetcode.com/problems/difference-between-ones-and-zeros-in-row-and-column:

class Solution:
    def onesMinusZeros(self, grid: List[List[int]]) -> List[List[int]]:
        import numpy as np

        grid = np.array(grid)
        diff = []

        for i in range(len(grid)):
            arr = []
            for j in range(len(grid[0])):
                arr.append(np.sum(grid[i]) + np.sum(grid[:, j]) - np.sum(1 - grid[i]) - np.sum(1 - grid[:, j]))
            diff.append(arr)

        return diff

Nov 22, 2023 Finished Market Analysis I:

# Write your MySQL query statement below

# Credit - https://leetcode.com/problems/market-analysis-i/solutions/2319471/simple-in-depth-explanation-of-where-and-is-null/

SELECT u.user_id as buyer_id, u.join_date, COUNT(o.order_id) AS orders_in_2019 FROM Users u LEFT JOIN Orders o ON o.buyer_id = u.user_id AND YEAR(order_date) = '2019' GROUP BY u.user_id;

Nov 21, 2023 Finished User Activity for the Past 30 Days I:

# Write your MySQL query statement below
SELECT activity_date AS day, COUNT(DISTINCT user_id) as active_users FROM Activity GROUP BY day HAVING COUNT(DISTINCT user_id) > 0 AND day >= '2019-06-28' AND day <= '2019-07-27';

Nov 20, 2023 Finished Find Total Time Spent by Each Employee:

# Write your MySQL query statement below
SELECT DISTINCT event_day as day, emp_id, (SELECT SUM(out_time - in_time) FROM Employees WHERE event_day = e.event_day and emp_id = e.emp_id) as total_time FROM Employees e;

Nov 17, 2023 Finished [Number of Valid Words in a Sentence](https://leetcode.com/problems number-of-valid-words-in-a-sentence/):

class Solution:
    def countValidWords(self, sentence: str) -> int:
        count = 0

        for i in sentence.split():
            if i.count('-') <= 1:
                if i[-1].isalpha() or i[-1] == "!" or i[-1] == ',' or i[-1] == ".":
                    letter_count = 0
                    for j in range(len(i) - 1):
                        if i[j].isalpha():
                            letter_count += 1
                        elif i[j] == "-":
                            if j != 0 and j != len(i) - 1:
                                if i[j-1].isalpha() and i[j+1].isalpha():
                                    letter_count += 1

                    if letter_count == len(i) - 1:
                        count += 1

        return count

Nov 12, 2023 Finished Maximum Strong Pair XOR I:

class Solution:
    def maximumStrongPairXor(self, nums: List[int]) -> int:
        max = 0

        for i in range(len(nums)):
            for j in range(len(nums)):
                if abs(nums[i] - nums[j]) <= min(nums[i], nums[j]):
                    if nums[i]^nums[j] >= max:
                        max = nums[i]^nums[j]

        return max

Nov 06, 2023 Finished Find Champion I:

class Solution:
    def findChampion(self, grid: List[List[int]]) -> int:
        max_ones = max([i.count(1) for i in grid])

        for i in range(len(grid)):
            if grid[i].count(1) == max_ones:
                return i

Nov 05, 2023 Finished Method Chaining:

import pandas as pd

def findHeavyAnimals(animals: pd.DataFrame) -> pd.DataFrame:
    animals = animals[animals['weight'] > 100]
    animals.sort_values(by=['weight'], inplace=True, ascending=False)

    del animals['species']
    del animals['age']
    del animals['weight']

    return animals

Nov 04, 2023 Finished Create a New Column:

import pandas as pd

def createBonusColumn(employees: pd.DataFrame) -> pd.DataFrame:
    employees['bonus'] = [i*2 for i in employees['salary']]

    return employees

Nov 03, 2023 Finished Find the K-or of an Array:

class Solution:
    def findKOr(self, nums: List[int], k: int) -> int:
        # Credit - https://leetcode.com/problems/find-the-k-or-of-an-array/solutions/4220565/python-simple-solution/
        res = 0

        for i in range(32):
            count = 0
            n = 2**i

            for num in nums:
                if num & n:
                    count += 1

            if count >= k:
                res += n

        return res

Oct 29, 2023 Finished Subarrays Distinct Element Sum of Squares I:

class Solution:
    def sumCounts(self, nums: List[int]) -> int:
        total = 0

        for i in range(len(nums)):
            for j in range(len(nums)+1):
                total += (len(set(nums[i:j])))**2

        return total

Oct 28, 2023 Finished Select Data:

import pandas as pd

def selectData(students: pd.DataFrame) -> pd.DataFrame:
    return students[students["student_id"] == 101].loc[:, students.columns != 'student_id']

Oct 27, 2023 Finished Display the First Three Rows:

import pandas as pd

def selectFirstRows(employees: pd.DataFrame) -> pd.DataFrame:
    return employees.head(3)

Oct 17, 2023 Finished Find Indices With Index and Value Difference I:

class Solution:
    def findIndices(self, nums: List[int], indexDifference: int, valueDifference: int) -> List[int]:
        for i in range(len(nums)):
            for j in range(len(nums)):
                if abs(i - j) >= indexDifference and abs(nums[i] - nums[j]) >= valueDifference:
                    return [i, j]

        return [-1, -1]

Oct 15, 2023 Finished Last Visited Integers:

class Solution:
    def lastVisitedIntegers(self, words: List[str]) -> List[int]:
        integers = []
        res = []
        count = 0

        for i in words:
            if i == "prev":
                count += 1
                temp = integers[::-1]
                if count <= len(integers):
                    res.append(temp[count - 1])
                else:
                    res.append(-1)
            else:
                count = 0
                integers.append(int(i))

        return res

Oct 13, 2023 Finished Divisible and Non-divisible Sums Difference:

class Solution:
    def differenceOfSums(self, n: int, m: int) -> int:
        return sum([i for i in range(1, n+1) if i % m != 0]) - sum([i for i in range(1, n+1) if i % m == 0])

Oct 12, 2023 Finished Get the Size of a DataFrame:

import pandas as pd

def getDataframeSize(players: pd.DataFrame) -> List[int]:
    return [len(players.axes[0]), len(players.axes[1])]

Oct 08, 2023 Finished Maximum Value of an Ordered Triplet I:

class Solution:
    def maximumTripletValue(self, nums: List[int]) -> int:
        max_value = 0

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                for k in range(j+1, len(nums)):
                    if ((nums[i] - nums[j]) * nums[k]) > max_value:
                        max_value = ((nums[i] - nums[j]) * nums[k])

        return max_value

Oct 07, 2023 Finished Minimum Operations to Collect Elements:

class Solution:
    def minOperations(self, nums: List[int], k: int) -> int:
        def check(k, arr):
            for i in range(1, k+1):
                if i not in arr:
                    return False

            return True

        collection = []
        count = 0

        while not check(k, collection):
            collection.append(nums[-1])
            nums = nums[:-1]
            count += 1

        return count

Sep 25, 2023 Finished Check If All 1's Are at Least Length K Places Away:

class Solution:
    def kLengthApart(self, nums: List[int], k: int) -> bool:
        indices = [i for i in range(len(nums)) if nums[i] == 1]

        for i in range(1, len(indices)):
            if (indices[i] - indices[i-1]) - 1 < k:
                return False

        return True

Sep 24, 2023 Finished Maximum Odd Binary Number:

class Solution:
    def maximumOddBinaryNumber(self, s: str) -> str:
        ones = s.count("1")
        zeroes = s.count("0")

        if ones == 1:
            return "0"*zeroes + "1"
        else:
            return "1"*(ones-1) + "0"*zeroes + "1"

Sep 23, 2023 Finished Crawler Log Folder:

class Solution:
    def minOperations(self, logs: List[str]) -> int:
        level = 0

        for i in logs:
            if i == "../":
                if level != 0:
                    level -= 1
            elif i != "./":
                level += 1

        return level

Sep 22, 2023 Finished Is Subsequence:

class Solution:
    def isSubsequence(self, s: str, t: str) -> bool:
        if s in t:
            return True

        for i in s:
            if i not in t:
                return False

        compare = ""

        for i in t:
            if i in s:
                compare += i

        if list(dict.fromkeys(compare)) == list(dict.fromkeys(s)) and len(compare) >= len(s):
            return True

Sep 17, 2023 Finished Sum of Values at Indices With K Set Bits:

class Solution:
    def sumIndicesWithKSetBits(self, nums: List[int], k: int) -> int:
        return sum([nums[i] for i in range(len(nums)) if str(bin(i))[1:].count('1') == k])

Sep 16, 2023 Finished Sort Array By Parity II:

class Solution:
    def sortArrayByParityII(self, nums: List[int]) -> List[int]:
        odd_nos = [i for i in nums if i % 2 != 0]
        even_nos = [i for i in nums if i % 2 == 0]

        res = []
        even_counter = 0
        odd_counter = 0

        for i in range(len(nums)):
            if i % 2 == 0:
                res.append(even_nos[even_counter])
                even_counter += 1
            else:
                res.append(odd_nos[odd_counter])
                odd_counter += 1

        return res

Sep 10, 2023 Finished Points That Intersect With Cars:

class Solution:
    def numberOfPoints(self, nums: List[List[int]]) -> int:
        points = set()

        for i in nums:
            for j in range(i[0], i[1]+1):
                points.add(j)

        return len(points)

Sep 04, 2023 Finished Count Symmetric Integers:

class Solution:
    def countSymmetricIntegers(self, low: int, high: int) -> int:
        count = 0

        for i in range(low, high+1):
            if len(str(i)) % 2 == 0:
                if sum([int(i) for i in str(i)[:len(str(i)) // 2]]) == sum([int(i) for i in str(i)[len(str(i)) // 2:]]):
                    count += 1

        return count

Sep 02, 2023 Finished Add Two Promises with a decent amount of help:

/**
 * @param {Promise} promise1
 * @param {Promise} promise2
 * @return {Promise}
 */
var addTwoPromises = async function (promise1, promise2) {
  return new Promise(function (resolve, reject) {
    promise1
      .then(function (result1) {
        promise2
          .then(function (result2) {
            resolve(result1 + result2);
          })
          .catch(function (error) {
            reject(error);
          });
      })
      .catch(function (error) {
        reject(error);
      });
  });
};

/**
 * addTwoPromises(Promise.resolve(2), Promise.resolve(2))
 *   .then(console.log); // 4
 */

Aug 27, 2023 Finished Create Target Array in the Given Order:

class Solution:
    def createTargetArray(self, nums: List[int], index: List[int]) -> List[int]:
        res = []

        for i in range(len(nums)):
            res.insert(index[i], nums[i])

        return res

Aug 26, 2023 Finished Confirmation Rate:

# Write your MySQL query statement below
SELECT DISTINCT s.user_id, CASE WHEN ISNULL(ROUND((SELECT COUNT(*) FROM Confirmations WHERE user_id = s.user_id AND action = 'confirmed') / (SELECT COUNT(*) FROM Confirmations WHERE user_id = s.user_id), 2)) THEN 0.00 ELSE ROUND((SELECT COUNT(*) FROM Confirmations WHERE user_id = s.user_id AND action = 'confirmed') / (SELECT COUNT(*) FROM Confirmations WHERE user_id = s.user_id), 2) END AS confirmation_rate FROM Signups s LEFT JOIN Confirmations c ON s.user_id = c.user_id;

Aug 24, 2023 Finished Count Pairs Whose Sum is Less than Target:

class Solution:
    def countPairs(self, nums: List[int], target: int) -> int:
        count = 0

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] < target:
                    count += 1

        return count

Aug 23, 2023 Finished Count Pairs Whose Sum is Less than Target:

class Solution:
    def countPairs(self, nums: List[int], target: int) -> int:
        count = 0

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if nums[i] + nums[j] < target:
                    count += 1

        return count

Aug 22, 2023 Finished Number of Lines To Write String:

class Solution:
    def numberOfLines(self, widths: List[int], s: str) -> List[int]:
        widths_dict = {chr(i):widths[i-97] for i in range(97, 123)}
        lines = 1
        width_count = 0

        for i in s:
            if width_count + widths_dict[i] > 100:
                width_count = 0
                lines += 1
            width_count += widths_dict[i]

        return [lines, width_count]

Aug 21, 2023 Finished Sales Analysis III:

# Write your MySQL query statement below
SELECT DISTINCT p.product_id, product_name FROM Product p, Sales s WHERE p.product_id = s.product_id AND (SELECT COUNT(product_id) FROM Sales e WHERE e.product_id = p.product_id AND (e.sale_date >= '2019-01-01' AND e.sale_date <= '2019-03-31')) >= 1 AND (SELECT COUNT(product_id) FROM Sales e WHERE e.product_id = p.product_id AND (e.sale_date < '2019-01-01' OR e.sale_date > '2019-03-31')) = 0;

Aug 20, 2023 Finished Count Salary Categories:

# Write your MySQL query statement below

# Credit - https://leetcode.com/problems/count-salary-categories/solutions/3892510/beats-95-both-sql-and-pandas/

SELECT 'Low Salary' as category, COUNT(account_id) as accounts_count FROM Accounts WHERE income < 20000 UNION SELECT 'Average Salary' as category, COUNT(*) FROM Accounts WHERE income >= 20000 AND income <= 50000 UNION SELECT 'High Salary' as category, COUNT(*) FROM Accounts WHERE income > 50000;

Aug 19, 2023 Finished The Latest Login in 2020:

# Write your MySQL query statement below
SELECT user_id, MAX(time_stamp) as last_stamp FROM Logins WHERE SUBSTRING(time_stamp, 1, 4) = '2020' GROUP BY user_id;

Aug 18, 2023 Finished H-Index:

class Solution:
    def hIndex(self, citations: List[int]) -> int:
        if len(citations) == 1:
            if citations[0] == 0:
                return 0
            else:
                return 1
        else:
            max_h = 0

            for h in range(0, len(citations)+1):
                if len([i for i in citations if i >= h]) >= h and h > max_h:
                    max_h = h

            return max_h

Aug 17, 2023 Finished Average Time of Process per Machine:

# Write your MySQL query statement below

# Credit - https://leetcode.com/problems/average-time-of-process-per-machine/solutions/3722056/sql-join-or-subquery-easy-to-understand/

SELECT a.machine_id, ROUND(AVG(b.timestamp-a.timestamp), 3) as processing_time FROM Activity a JOIN Activity b ON a.machine_id=b.machine_id AND a.process_id=b.process_id AND a.activity_type='start' AND b.activity_type='end' GROUP BY a.machine_id

Aug 16, 2023 Finished Capital Gain/Loss:

# Write your MySQL query statement below
SELECT DISTINCT a.stock_name, ((SELECT SUM(price) FROM Stocks WHERE operation = 'Sell' AND stock_name = a.stock_name) - (SELECT SUM(price) FROM Stocks WHERE operation = 'Buy' AND stock_name = a.stock_name)) as capital_gain_loss FROM Stocks a;

Aug 13, 2023 Finished Max Pair Sum in an Array:

class Solution:
    def maxSum(self, nums: List[int]) -> int:
        max_sum = -1

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if max(list(str(nums[i]))) == max(list(str(nums[j]))):
                    if nums[i] + nums[j] > max_sum:
                        max_sum = nums[i] + nums[j]

        return max_sum

Aug 12, 2023 Finished Actors and Directors Who Cooperated At Least Three Times:

# Write your MySQL query statement below
SELECT DISTINCT a.actor_id, a.director_id FROM ActorDirector a WHERE (SELECT COUNT(*) FROM ActorDirector WHERE actor_id = a.actor_id AND director_id = a.director_id) >= 3;

Aug 11, 2023 Finished Daily Leads and Partners:

# Write your MySQL query statement below
SELECT DISTINCT date_id, make_name, (SELECT COUNT(DISTINCT lead_id) FROM DailySales WHERE date_id = d.date_id AND make_name = d.make_name) AS unique_leads, (SELECT COUNT(DISTINCT partner_id) FROM DailySales WHERE date_id = d.date_id AND make_name = d.make_name) AS unique_partners FROM DailySales d ORDER BY date_id;

Aug 10, 2023 Finished Invalid Tweets:

# Write your MySQL query statement below
SELECT tweet_id FROM Tweets WHERE LENGTH(content) > 15;

Aug 09, 2023 Finished Account Balance After Rounded Purchase:

class Solution:
    def accountBalanceAfterPurchase(self, purchaseAmount: int) -> int:
        remainder = purchaseAmount % 10

        if remainder == 0:
            return 100 - purchaseAmount
        elif remainder < 5:
            return 100 - (purchaseAmount - remainder)
        else:
            return 100 - (purchaseAmount + (10 - remainder))

Aug 08, 2023 Finished Search in Rotated Sorted Array:

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        try:
            return nums.index(target)
        except:
            return -1

Aug 07, 2023 Finished Faulty Keyboard:

class Solution:
    def finalString(self, s: str) -> str:
        res = ""

        for i in s:
            if i != "i":
                res += i
            else:
                res = res[::-1]

        return res

Aug 06, 2023 Finished The Number of Employees Which Report to Each Employee:

# Write your MySQL query statement below
SELECT employee_id, name, (SELECT COUNT(*) FROM Employees WHERE reports_to = e.employee_id) AS reports_count, ROUND((SELECT SUM(age) FROM Employees WHERE reports_to = e.employee_id) / (SELECT COUNT(*) FROM Employees WHERE reports_to = e.employee_id)) AS average_age FROM Employees e WHERE (SELECT COUNT(*) FROM Employees WHERE reports_to = e.employee_id) >= 1 ORDER BY employee_id;

Aug 05, 2023 Finished The Number of Rich Customers:

# Write your MySQL query statement below
SELECT COUNT(DISTINCT customer_id) AS rich_count FROM Store WHERE amount > 500;

Aug 04, 2023 Finished Fix Names in a Table:

# Write your MySQL query statement below
SELECT user_id, CONCAT(UCASE(SUBSTR(name, 1, 1)), LCASE(SUBSTR(name, 2, LENGTH(name)))) as name FROM Users ORDER BY user_id;

Aug 03, 2023 Finished Replace Employee ID With The Unique Identifier:

# Write your MySQL query statement below
SELECT unique_id, name FROM Employees e LEFT JOIN EmployeeUNI u ON e.id = u.id;

Aug 02, 2023 Finished Percentage of Users Attended a Contest:

# Write your MySQL query statement below
SELECT contest_id, ROUND(COUNT(*) / (SELECT COUNT(*) FROM Users) * 100, 2) AS percentage FROM Users u, Register r WHERE u.user_id = r.user_id GROUP BY contest_id ORDER BY percentage DESC, contest_id ASC;

Aug 01, 2023 Finished Immediate Food Delivery II:

# Write your MySQL query statement below
SELECT ROUND((SELECT COUNT(*) FROM Delivery d WHERE d.order_date = d.customer_pref_delivery_date AND d.order_date = (SELECT MIN(order_date) FROM Delivery WHERE customer_id = d.customer_id)) / COUNT(DISTINCT customer_id) * 100, 2) as immediate_percentage FROM Delivery;

Jul 31, 2023 Finished Immediate Food Delivery I:

# Write your MySQL query statement below
SELECT ROUND((SELECT COUNT(*) FROM Delivery WHERE order_date=customer_pref_delivery_date) / COUNT(*) * 100, 2) AS immediate_percentage FROM Delivery;

Jul 30, 2023 Finished Number of Employees Who Met the Target:

class Solution:
    def numberOfEmployeesWhoMetTarget(self, hours: List[int], target: int) -> int:
        return len([i for i in hours if i >= target])

Jul 29, 2023 Finished Customers Who Bought All Products with a bit of help:

# Write your MySQL query statement below
SELECT customer_id FROM Customer GROUP BY customer_id HAVING COUNT(DISTINCT product_key) = (SELECT COUNT(DISTINCT product_key) FROM Product);

Jul 28, 2023 Finished Employee Bonus, LEFT JOIN is so cool:

# Write your MySQL query statement below
SELECT name, bonus FROM Employee e LEFT JOIN Bonus b ON e.empId = b.empId WHERE bonus < 1000 OR ISNULL(bonus);

Jul 27, 2023 Finished Top Travellers (with a little bit of help, at least I learnt about LEFT JOIN):

# Write your MySQL query statement below
SELECT name, IFNULL(SUM(distance), 0) as travelled_distance FROM Users u LEFT JOIN Rides r ON u.id = r.user_id GROUP BY u.id ORDER BY travelled_distance DESC, name;

Jul 26, 2023 Finished Split Strings by Separator:

class Solution:
    def splitWordsBySeparator(self, words: List[str], separator: str) -> List[str]:
        words_new = []

        for i in words:
            words_new.extend(i.split(separator))

        return [i for i in words_new if len(i) > 0]

Jul 25, 2023 Finished Group Sold Products By The Date (with just a bit of help):

# Write your MySQL query statement below
SELECT sell_date, COUNT(DISTINCT product) AS num_sold, GROUP_CONCAT(DISTINCT product ORDER BY product) AS products FROM Activities GROUP BY sell_date;

Jul 24, 2023 Finished Find Followers Count:

# Write your MySQL query statement below
SELECT DISTINCT user_id, (SELECT COUNT(user_id) FROM Followers WHERE user_id = f.user_id) as followers_count FROM Followers f ORDER BY user_id;

Jul 23, 2023 Finished Check if Array is Good:

class Solution:
    def isGood(self, nums: List[int]) -> bool:
        return sorted(nums) == [i for i in range(1, len(nums))] + [len(nums)-1]

Jul 22, 2023 Finished Product Sales Analysis I:

# Write your MySQL query statement below
SELECT product_name, year, price as price FROM Sales NATURAL JOIN Product ORDER BY product_name;

Jul 21, 2023 Finished Biggest Single Number:

# Write your MySQL query statement below
SELECT MAX(e.num) as num FROM MyNumbers e WHERE (SELECT COUNT(num) FROM MyNumbers WHERE num=e.num) = 1;

Jul 20, 2023 Finished Managers with at Least 5 Direct Reports:

# Write your MySQL query statement below
SELECT name FROM Employee e WHERE (SELECT COUNT(d.managerId) FROM Employee d WHERE d.managerId = e.id) >= 5;

Jul 19, 2023 Finished Rising Temperature:

# Write your MySQL query statement below
SELECT id FROM Weather w WHERE temperature > (SELECT temperature FROM Weather WHERE recordDate=DATE_SUB(w.recordDate, INTERVAL 1 DAY));

Jul 18, 2023 Finished Reformat Department Table:

# Write your MySQL query statement below

# Credit - https://leetcode.com/problems/reformat-department-table/solutions/2473482/fully-explained-super-easy/

SELECT d.id, SUM(IF(month='Jan', revenue, null)) as Jan_Revenue, SUM(IF(month='Feb', revenue, null)) as Feb_Revenue, SUM(IF(month='Mar', revenue, null)) as Mar_Revenue, SUM(IF(month='Apr', revenue, null)) as Apr_Revenue, SUM(IF(month='May', revenue, null)) as May_Revenue, SUM(IF(month='Jun', revenue, null)) as Jun_Revenue, SUM(IF(month='Jul', revenue, null)) as Jul_Revenue, SUM(IF(month='Aug', revenue, null)) as Aug_Revenue, SUM(IF(month='Sep', revenue, null)) as Sep_Revenue, SUM(IF(month='Oct', revenue, null)) as Oct_Revenue, SUM(IF(month='Nov', revenue, null)) as Nov_Revenue, SUM(IF(month='Dec', revenue, null)) as Dec_Revenue from Department d GROUP BY id;

Jul 17, 2023 Finished Sum of Squares of Special Elements:

class Solution:
    def sumOfSquares(self, nums: List[int]) -> int:
        return sum([nums[i]**2 for i in range(len(nums)) if len(nums) % (i+1) == 0])

Jul 16, 2023 Finished Second Highest Salary:

# Write your MySQL query statement below
SELECT MAX(salary) as SecondHighestSalary FROM Employee WHERE salary != (SELECT MAX(salary) FROM Employee);

Jul 15, 2023 Finished Investments in 2016:

# Write your MySQL query statement below
SELECT ROUND(SUM(tiv_2016), 2) as tiv_2016 FROM Insurance i WHERE (SELECT COUNT(tiv_2015) FROM Insurance e WHERE e.tiv_2015 = i.tiv_2015) > 1 AND (SELECT COUNT(lat) FROM Insurance e WHERE e.lat = i.lat AND e.lon = i.lon) = 1;

Jul 14, 2023 Finished Bank Account Summary II:

# Write your MySQL query statement below
SELECT name, SUM(amount) as balance FROM Users NATURAL JOIN Transactions GROUP BY account HAVING SUM(amount) > 10000;

Jul 13, 2023 Finished Lemonade Change:

class Solution:
    def lemonadeChange(self, bills: List[int]) -> bool:
        five_bills = 0
        ten_bills = 0
        twenty_bills = 0

        for i in bills:
            if i == 5:
                five_bills += 1
            elif i == 10:
                if five_bills > 0:
                    ten_bills += 1
                    five_bills -= 1
                else:
                    return False
            elif i == 20:
                if five_bills > 0 and ten_bills > 0:
                    twenty_bills += 1
                    ten_bills -= 1
                    five_bills -= 1
                elif five_bills > 2:
                    twenty_bills += 1
                    five_bills -= 3
                else:
                    return False

        return True

Jul 12, 2023 Finished Cells in a Range on an Excel Sheet:

class Solution:
    def cellsInRange(self, s: str) -> List[str]:
        letter_1 = s[0]
        number_1 = s[1]
        letter_2 = s[3]
        number_2 = s[4]

        letters = []
        numbers = []

        for i in range(ord(letter_1), ord(letter_2)+1):
            letters.append(chr(i))

        for i in range(int(number_1), int(number_2)+1):
            numbers.append(i)

        res = []

        for i in letters:
            for j in numbers:
                res.append(i + str(j))

        return res

Jul 11, 2023 Finished Find the Maximum Achievable Number:

class Solution:
    def theMaximumAchievableX(self, num: int, t: int) -> int:
        return num + (2*t)

Jul 10, 2023 Finished License Key Formatting:

class Solution:
    def licenseKeyFormatting(self, s: str, k: int) -> str:
        characters = s.split('-')
        characters = "".join([i.upper() for i in characters])
        num_chars = len(s) - s.count('-')
        groups = num_chars // k
        remainder = num_chars % k
        res = ""

        if remainder == 0:
            for i in range(0, num_chars, k):
                res += characters[i:i+k] + '-'
            res = res[:-1]
        else:
            res += characters[:remainder] + '-'
            for i in range(remainder, num_chars, k):
                res += characters[i:i+k] + '-'
            res = res[:-1]

        return res

Jul 09, 2023 Finished Triangle Judgement:

# Write your MySQL query statement below
SELECT x, y, z,
CASE
    WHEN ((x+y) > z AND (y+z) > x AND (x+z) >y) THEN 'Yes'
    ELSE 'No'
END as triangle
FROM Triangle;

Jul 08, 2023 Finished Game Play Analysis I:

# Write your MySQL query statement below
SELECT player_id, MIN(event_date) as first_login FROM Activity GROUP BY player_id;

Jul 07, 2023 Finished Swap Salary:

# Write your MySQL query statement below
UPDATE Salary SET sex = CASE WHEN sex = 'f' THEN 'm'
                        WHEN sex = 'm' THEN 'f'
END;

Jul 06, 2023 Finished Project Employees I:

# Write your MySQL query statement below
SELECT project_id, ROUND(SUM(experience_years) / COUNT(name), 2) AS average_years FROM Project NATURAL JOIN Employee GROUP BY project_id;

Jul 05, 2023 Finished List the Products Ordered in a Period:

# Write your MySQL query statement below
SELECT DISTINCT product_name, (SELECT SUM(unit) FROM Orders o WHERE o.product_id = p.product_id AND MONTH(order_date) = 2) as unit FROM Products p, Orders o WHERE p.product_id = o.product_id AND (SELECT SUM(unit) FROM Orders o WHERE o.product_id = p.product_id AND MONTH(order_date) = 2) >= 100;

Jul 04, 2023 Finished Average Selling Price:

# Write your MySQL query statement below
SELECT p.product_id, ROUND(SUM(p.price * u.units) / SUM(u.units), 2) as average_price FROM UnitsSold u, Prices p WHERE u.product_id = p.product_id AND u.purchase_date BETWEEN p.start_date AND p.end_date GROUP BY u.product_id;

Jul 03, 2023 Finished Count Square Sum Triples, honestly, original solution should have worked:

class Solution:
    def countTriples(self, n: int) -> int:
        def count(n, li=1):
            if n == 1 or n == 2 or n == 3 or n == 4:
                return 0

            count_i = 0

            for i in range(li, n+1):
                for j in range(i+1, n+1):
                    if (i**2) + (j**2) == n**2:
                        count_i += 1

            return (count_i*2) + count(n-1, last_i)

        return count(n)

Jul 02, 2023 Finished Students and Examinations:

# Write your MySQL query statement below
SELECT s.student_id, student_name, su.subject_name, (SELECT COUNT(*) FROM Examinations e WHERE e.student_id = s.student_id AND e.subject_name = su.subject_name) as attended_exams FROM Students s JOIN Subjects su ORDER BY student_id, subject_name;

Jul 01, 2023 Finished Employees Whose Manager Left the Company:

# Write your MySQL query statement below
SELECT a.employee_id FROM Employees a WHERE (SELECT COUNT(employee_id) FROM Employees WHERE employee_id = a.manager_id) = 0 AND a.salary < 30000 AND a.manager_id IS NOT NULL ORDER BY employee_id;

Jun 30, 2023 Finished Queries Quality and Percentage:

# Write your MySQL query statement below
SELECT a.query_name, ROUND(AVG(a.rating / a.position), 2) as quality, ROUND(((SELECT COUNT(b.query_name) FROM Queries b WHERE rating < 3 AND a.query_name = b.query_name) / COUNT(a.query_name)) * 100, 2) as poor_query_percentage FROM Queries a GROUP BY a.query_name;

Jun 29, 2023 Finished Counter II (just to learn the syntax) and To Be Or Not To Be:

/**
 * @param {string} val
 * @return {Object}
 */
var expect = function(val) {
    var val_1 = val;

    return {
        toBe: (val_2) => {
            if (val_1 === val_2) {
                return true;
            } else {
                throw "Not Equal";
            }
        },
        notToBe: (val_2) => {
             if (val !== val_2) {
                return true;
            } else {
                throw "Equal";
            }
        }
    }

};

/**
 * expect(5).toBe(5); // true
 * expect(5).notToBe(5); // throws "Equal"
 */

Jun 28, 2023 Finished DI String Match:

class Solution:
    def diStringMatch(self, s: str) -> List[int]:
        n = len(s)
        lst = []
        min = 0
        max = n

        for i in s:
            if i == 'I':
                lst.append(min)
                min += 1
            elif i == "D":
                lst.append(max)
                max -= 1

        return lst + [min]

Jun 27, 2023 Finished Number of Beautiful Pairs:

class Solution:
    def countBeautifulPairs(self, nums: List[int]) -> int:
        import math

        count = 0

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                if math.gcd(int(str(nums[i])[0]), int(str(nums[j])[-1])) == 1:
                    count += 1

        return count

Jun 26, 2023 Finished Find Maximum Number of String Pairs:

class Solution:
    def maximumNumberOfStringPairs(self, words: List[str]) -> int:
        count = 0

        for i in range(len(words)):
            for j in range(i+1, len(words)):
                if words[i][::-1] == words[j]:
                    count += 1

        return count

Jun 20, 2023 Finished Mean of Array After Removing Some Elements:

class Solution:
    def trimMean(self, arr: List[int]) -> float:
        # Credit - https://leetcode.com/problems/mean-of-array-after-removing-some-elements/solutions/2344789/python-short-simple/
        percentile = (5*len(arr)) // 100
        arr.sort()
        return sum(arr[percentile:len(arr)-percentile]) / (len(arr)-(percentile*2))

Jun 18, 2023 Finished Total Distance Traveled:

class Solution:
    def distanceTraveled(self, mainTank: int, additionalTank: int) -> int:
        dist = 0

        while mainTank > 0:
            if mainTank >= 5 and additionalTank >= 1:
                dist += 50
                mainTank -= 4
                additionalTank -= 1
            else:
                dist += 10
                mainTank -= 1

        return dist

Jun 16, 2023 Finished Count of Matches in Tournament:

class Solution:
    def numberOfMatches(self, n: int) -> int:
        total_matches = 0

        while n > 1:
            if n % 2 == 0:
                total_matches += (n // 2)
                n = n // 2
            else:
                total_matches += (n - 1) // 2
                n = ((n - 1) // 2) + 1

        return total_matches

Jun 15, 2023 Finished Defuse the Bomb:

class Solution:
    def decrypt(self, code: List[int], k: int) -> List[int]:
        if k == 0:
            return [0]*len(code)
        else:
            code_modified = code*(abs(k)+1)
            if k > 0:
                return [sum(code_modified[i+1:i+1+k]) for i in range(len(code))]
            else:
                return [sum(code_modified[-len(code)+k+i:-len(code)+i]) for i in range(len(code))]

Jun 14, 2023 Finished Neither Minimum nor Maximum:

class Solution:
    def findNonMinOrMax(self, nums: List[int]) -> int:
        nums = [i for i in nums if i != min(nums) and i != max(nums)]

        if len(nums) == 0:
            return -1
        else:
            return nums[0]

Jun 13, 2023 Finished Equal Row and Column Pairs:

class Solution:
    def equalPairs(self, grid: List[List[int]]) -> int:
        import numpy as np

        grid = np.array(grid)
        count = 0

        for i in range(len(grid)):
            for j in range(len(grid)):
                if np.array_equal(grid[i], grid[:, j]):
                    count += 1

        return count

Jun 11, 2023 Finished Check if The Number is Fascinating:

class Solution:
    def isFascinating(self, n: int) -> bool:
        return sorted(str(n) + str(2*n) + str(3*n)) == ['1', '2', '3', '4', '5', '6', '7', '8', '9']

Jun 10, 2023 Finished Maximum Number of Balls in a Box:

class Solution:
    def countBalls(self, lowLimit: int, highLimit: int) -> int:
        dict_boxes = {}

        for i in range(lowLimit, highLimit+1):
            if sum([int(i) for i in list(str(i))]) in dict_boxes:
                dict_boxes[sum([int(i) for i in list(str(i))])] += 1
            else:
                dict_boxes[sum([int(i) for i in list(str(i))])] = 1

        return dict_boxes[max(dict_boxes, key=dict_boxes.get)]

Jun 09, 2023 Finished Verifying an Alien Dictionary (finally!):

class Solution:
    def isAlienSorted(self, words: List[str], order: str) -> bool:
        return words == sorted(words, key=lambda word: [order.index(word[i]) for i in range(len(word))])

Jun 08, 2023 Finished Is Object Empty:

/**
 * @param {Object | Array} obj
 * @return {boolean}
 */
var isEmpty = function (obj) {
  let count = 0;

  for (let key in obj) {
    count++;
  }

  return count == 0;
};

Jun 05, 2023 Finished Minimize String Length:

class Solution:
    def minimizedStringLength(self, s: str) -> int:
        return len(set(s))

Jun 03, 2023 Finished Generate Fibonacci Sequence:

/**
 * @return {Generator<number>}
 */
var fibGenerator = function* () {
  let start_value = -1;
  let next_value = 1;
  let value = start_value;

  while (true) {
    value = start_value + next_value;
    start_value = next_value;
    next_value = value;
    yield next_value;
  }
};

/**
 * const gen = fibGenerator();
 * gen.next().value; // 0
 * gen.next().value; // 1
 */

Jun 02, 2023 Finished Special Array With X Elements Greater Than or Equal X:

class Solution:
    def specialArray(self, nums: List[int]) -> int:
        for i in range(0, max(nums)+1):
            if len([j for j in nums if j >= i]) == i:
                return i
        return -1

Jun 01, 2023 Finished Buy Two Chocolates:

class Solution:
    def buyChoco(self, prices: List[int], money: int) -> int:
        min_sum = 201

        for i in range(len(prices)):
            for j in range(i+1, len(prices)):
                if (prices[i] + prices[j]) <= money and (prices[i] + prices[j]) < min_sum:
                    min_sum = (prices[i] + prices[j])


        if min_sum == 201:
            return money

        return money - min_sum

May 29, 2023 Did NOT finish Number of Equivalent Domino Pairs:

class Solution:
    def numEquivDominoPairs(self, dominoes: List[List[int]]) -> int:
        count = 0

        for i in range(len(dominoes)):
            for j in range(i+1, len(dominoes)):
                if (dominoes[i][0] == dominoes[j][0] and dominoes[i][1] == dominoes[j][1]) or (dominoes[i][0] == dominoes[j][1] and dominoes[i][1] == dominoes[j][0]):
                    count += 1

        return count

May 28, 2023 Finished Difference of Number of Distinct Values on Diagonals:

class Solution:
    def differenceOfDistinctValues(self, grid: List[List[int]]) -> List[List[int]]:
        def getTopLeft(grid, r, c):
            res = []
            r -= 1
            c -= 1

            while r >= 0 and c >= 0:
                res.append(grid[r][c])
                r -= 1
                c -= 1

            return len(set(res))

        def getBottomRight(grid, r, c):
            res = []
            r += 1
            c += 1

            while r < len(grid) and c < len(grid[0]):
                res.append(grid[r][c])
                r += 1
                c += 1

            return len(set(res))

        res = []

        for i in range(len(grid)):
            temp = []

            for j in range(len(grid[0])):
                temp.append(abs(getTopLeft(grid, i, j) - getBottomRight(grid, i, j)))

            res.append(temp)

        return res

May 27, 2023 Finsihed Return Length of Arguments Passed:

/**
 * @return {number}
 */
var argumentsLength = function(...args) {
    return args.length;
};

/**
 * argumentsLength(1, 2, 3); // 3
 */

May 26, 2023 Finished Largest Local Values in a Matrix:


class Solution:
    def largestLocal(self, grid: List[List[int]]) -> List[List[int]]:
        import numpy as np
        grid = np.array(grid)
        res = []
        count = 0

        while count < len(grid) - 2:
            temp = []
            end = 3

            while end <= len(grid):
                temp.append(np.amax(grid[count:count+3, end-3:end]))
                end += 1

            res.append(temp)
            count += 1

        return res

May 24, 2023 Finished Count Special Quadruples:

class Solution:
    def countQuadruplets(self, nums: List[int]) -> int:
        count = 0

        for i in range(len(nums)):
            for j in range(i+1, len(nums)):
                for k in range(j+1, len(nums)):
                    for z in range(k+1, len(nums)):
                        if nums[i] + nums[j] + nums[k] == nums[z]:
                            count += 1

        return count

May 21, 2023 Finished Allow One Function Call:

/**
 * @param {Function} fn
 * @return {Function}
 */
var once = function(fn) {
    count = 0

    return function(...args){
        if (count < 1) {
            count += 1
            return fn(...args)
        }

    }
};

/**
 * let fn = (a,b,c) => (a + b + c)
 * let onceFn = once(fn)
 *
 * onceFn(1,2,3); // 6
 * onceFn(2,3,6); // returns undefined without calling fn
 */

May 19, 2023 Finished Maximum Ascending Subarray Sum:

class Solution:
    def maxAscendingSum(self, nums: List[int]) -> int:
        subarrs = []

        for i in range(len(nums)):
            subarrs_temp = [nums[i:j] for j in range(i+1, len(nums)+1)]

            for k in subarrs_temp:
                if sorted(k) == k and list(dict.fromkeys(k)) == k:
                    subarrs.append(k)

        return sum(max(subarrs, key=lambda x: sum(x)))

May 18, 2023 Finished Find the Losers of the Circular Game:

class Solution:
    def circularGameLosers(self, n: int, k: int) -> List[int]:
        lst = [1]
        friend = 1
        count = 1

        while True:
            friend += count*k

            if friend > n:
                friend %= n
                if friend == 0:
                    friend = n

            if friend in lst:
                break
            else:
                lst.append(friend)

            count += 1

        return [i for i in range(1, n+1) if i not in lst]

May 17, 2023 Finished Chunk Array:

/**
 * @param {Array} arr
 * @param {number} size
 * @return {Array[]}
 */
var chunk = function (arr, size) {
  let iteration = Math.floor(arr.length / size);
  let res = [];
  let start = 0;
  let count = 0;

  while (count < iteration) {
    let temp = [];

    for (let i = start; i < start + size; i++) {
      temp.push(arr[i]);
    }

    res.push(temp);
    start += size;
    count += 1;
  }

  let final = [];

  for (let i = start; i < arr.length; i++) {
    final.push(arr[i]);
  }

  res.push(final);

  if (size == 1 || Math.floor(arr.length / size) == arr.length / size) {
    res.pop();
  }

  return res;
};

May 16, 2023 Finished Number of Senior Citizens:

class Solution:
    def countSeniors(self, details: List[str]) -> int:
        count = 0

        for i in details:
            if int(i[11:13]) > 60:
                count += 1

        return count

May 10, 2023 Finished Number of Unique Subjects Taught by Each Teacher:

# Write your MySQL query statement below
SELECT teacher_id, COUNT(DISTINCT subject_id) as cnt FROM Teacher GROUP BY teacher_id;

May 08, 2023 Finished Minimum Changes To Make Alternating Binary String:

class Solution:
    def minOperations(self, s: str) -> int:
        if len(s) == 1:
            return 0
        else:
            count_1 = 0

            if s[0] == '0':
                compare = "1"
            else:
                compare = "0"

            for i in range(1, len(s)):
                if s[i] != compare:
                    count_1 += 1

                if compare == "0":
                    compare = "1"
                else:
                    compare = "0"

            count_2 = 1

            if s[0] == "0":
                s = "1" + s[1:]
                compare = "0"
            else:
                s = "0" + s[1:]
                compare = "1"

            for i in range(1, len(s)):
                if s[i] != compare:
                    count_2 += 1

                if compare == "0":
                    compare = "1"
                else:
                    compare = "0"

            return min(count_1, count_2)

May 07, 2023 Finished Find the Distinct Difference Array:

class Solution:
    def distinctDifferenceArray(self, nums: List[int]) -> List[int]:
        return [len(set(nums[:i+1])) - len(set(nums[i+1:])) for i in range(len(nums))]

May 06, 2023 Finished Maximum Difference by Remapping a Digit:

class Solution:
    def minMaxDifference(self, num: int) -> int:
        num_str = str(num)

        max_num = max([int(num_str.replace(i, '9')) for i in num_str])
        min_num = min([int(num_str.replace(i, '0')) for i in num_str])

        return max_num - min_num

May 05, 2023 Finished Create Hello World Function:

/**
 * @return {Function}
 */
var createHelloWorld = function () {
  return function (...args) {
    return "Hello World";
  };
};

/**
 * const f = createHelloWorld();
 * f(); // "Hello World"
 */

May 04, 2023 Finished Primary Department for Each Employee:

# Write your MySQL query statement below
SELECT DISTINCT employee_id, department_id FROM Employee WHERE primary_flag = 'Y';

May 02, 2023 Finished Maximum Sum With Exactly K Elements:

class Solution:
    def maximizeSum(self, nums: List[int], k: int) -> int:
        score = 0

        while k > 0:
            nums.sort()
            score += nums[-1]
            nums[-1] += 1
            k -= 1

        return score

May 01, 2023 Not sure why my solution for Minimum Absolute Sum Difference didn't pass:

class Solution:
    def minAbsoluteSumDiff(self, nums1: List[int], nums2: List[int]) -> int:
        if nums1 == nums2:
            return 0
        else:
            index = max(range(len(nums2)), key=lambda x: abs(nums1[x] - nums2[x]))
            nums1_copy = nums1.copy()
            nums1_copy.remove(nums1[index])
            replacement = min(nums1_copy, key=lambda x: abs(x - nums2[index]))
            nums1[index] = replacement

            return sum([abs(nums1[i] - nums2[i]) for i in range(len(nums2))])

Apr 30, 2023 Finished Determine the Winner of a Bowling Game:

class Solution:
    def isWinner(self, player1: List[int], player2: List[int]) -> int:
        score_1 = player1[0]
        score_2 = player2[0]

        if len(player1) > 1:
            if player1[0] == 10:
                score_1 += 2*player1[1]
            else:
                score_1 += player1[1]

            if player2[0] == 10:
                score_2 += 2*player2[1]
            else:
                score_2 += player2[1]

        for i in range(2, len(player1)):
            if 10 in player1[i-2:i]:
                score_1 += 2*player1[i]
            else:
                score_1 += player1[i]

        for i in range(2, len(player2)):
            if 10 in player2[i-2:i]:
                score_2 += 2*player2[i]
            else:
                score_2 += player2[i]

        if score_1 > score_2:
            return 1
        elif score_2 > score_1:
            return 2
        else:
            return 0

Apr 28, 2023 Finished Calculate Delayed Arrival Time:

class Solution:
    def findDelayedArrivalTime(self, arrivalTime: int, delayedTime: int) -> int:
        return (arrivalTime + delayedTime) % 24

Apr 26, 2023 Finished Sum Multiples:

class Solution:
    def sumOfMultiples(self, n: int) -> int:
        return sum([i for i in range(1, n+1) if i % 3 == 0 or i % 5 == 0 or i % 7 == 0])

Apr 25, 2023 Tried my hand at Smallest Number in Infinite Set.
Apr 24, 2023 Finished Last Stone Weight:

class Solution:
    def lastStoneWeight(self, stones: List[int]) -> int:
        stones.sort(reverse=True)

        while len(stones) > 1:
            if stones[0] == stones[1]:
                stones.pop(0)
                stones.pop(0)
            elif stones[0] != stones[1]:
                stones[0] = stones[0] - stones[1]
                stones.pop(1)
            stones.sort(reverse=True)

        if len(stones) == 0:
            return 0
        else:
            return stones[0]

Apr 23, 2023 Finished Filter Elements from Array:

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var filter = function (arr, fn) {
  let res = [];

  for (let i = 0; i < arr.length; i++) {
    if (fn(arr[i], i)) {
      res.push(arr[i]);
    }
  }

  return res;
};

Apr 22, 2023 Finished Apply Transform Over Each Element in Array:

/**
 * @param {number[]} arr
 * @param {Function} fn
 * @return {number[]}
 */
var map = function (arr, fn) {
  for (let i = 0; i < arr.length; i++) {
    arr[i] = fn(arr[i], i);
  }

  return arr;
};

Apr 21, 2023 Finished Find the Maximum Divisibility Score:

class Solution:
    def maxDivScore(self, nums: List[int], divisors: List[int]) -> int:
        res_temp = []

        for i in divisors:
            count = 0
            for j in nums:
                if j % i == 0:
                    count += 1
            res_temp.append((i, count))

        res_temp.sort()
        return max(res_temp, key=lambda x: x[1])[0]

Apr 17, 2023-Apr 18, 2023 Finished Row With Maximum Ones:

class Solution:
    def rowAndMaximumOnes(self, mat: List[List[int]]) -> List[int]:
        return [mat.index(max(mat, key=lambda x: x.count(1))), max(mat, key=lambda x: x.count(1)).count(1)]

Apr 16, 2023 Finished Find the Width of Columns of a Grid:

class Solution:
    def findColumnWidth(self, grid: List[List[int]]) -> List[int]:
        cols = []
        j = 0

        while j < len(grid[0]):
            col = []
            for i in grid:
                col.append(str(i[j]))
            cols.append(col)
            j += 1

        return [len(max(i, key=lambda x: len(x))) for i in cols]

Apr 15, 2023 Finished Counter:

/**
 * @param {number} n
 * @return {Function} counter
 */
var createCounter = function (n) {
  count = -1;

  return function () {
    count += 1;
    return n + count;
  };
};

/**
 * const counter = createCounter(10)
 * counter() // 10
 * counter() // 11
 * counter() // 12
 */

Apr 14, 2023 Finished Function Composition:

/**
 * @param {Function[]} functions
 * @return {Function}
 */
var compose = function (functions) {
  return function (x) {
    functions.reverse();
    let num = x;

    for (let i = 0; i < functions.length; i++) {
      num = functions[i](num);
    }

    return num;
  };
};

/**
 * const fn = compose([x => x + 1, x => 2 * x])
 * fn(4) // 9
 */

Apr 11, 2023 Finished Decompress Run-Length Encoded List:

class Solution:
    def decompressRLElist(self, nums: List[int]) -> List[int]:
        res = []

        for i in range(0, len(nums), 2):
            res.extend([nums[i + 1]] * nums[i])

        return res

Apr 09, 2023 Finished Prime In Diagonal (the square root tricked made it not time out):

class Solution:
    def diagonalPrime(self, nums: List[List[int]]) -> int:
        def is_prime(num):
            if num <= 1:
                return False

            for i in range(2, int(num**0.5)+1):
                if num % i == 0:
                    return False
            return True

        primes = []

        for i in range(len(nums)):
            if is_prime(nums[i][len(nums) - i - 1]):
                primes.append(nums[i][len(nums) - i - 1])
            if is_prime(nums[i][i]):
                primes.append(nums[i][i])

        return max(primes, default=0)

Apr 08, 2023 Never mind, finished Sort Array by Increasing Frequency:

class Solution:
    def frequencySort(self, nums: List[int]) -> List[int]:
        nums.sort(reverse=True)
        return sorted(nums, key=lambda x: nums.count(x))

Apr 07, 2023 Close to finishing Check if Binary String Has at Most One Segment of Ones.
Apr 05, 2023 Finished Rearrange Characters to Make Target String:

class Solution:
    def rearrangeCharacters(self, s: str, target: str) -> int:
        if len(s) < len(target):
            return 0

        li = [i for i in s if i in target]

        if len(li) < len(target):
            return 0
        elif False in [i in li for i in target]:
            return 0

        dict_li = {i: li.count(i) // target.count(i) for i in set(li)}

        return min(dict_li.values(), default=0)

Apr 04, 2023 Finished Decode XORed Array:

class Solution:
    def decode(self, encoded: List[int], first: int) -> List[int]:
        res = [first]

        for i in range(len(encoded)):
            res.append(res[i] ^ encoded[i])

        return res

Apr 03, 2023 Finished Find the Longest Balanced Substring of a Binary String:

class Solution:
    def findTheLongestBalancedSubstring(self, s: str) -> int:
        if len(s) % 2 == 0:
            for i in range(len(s), 1, -2):
                if "0"*(i // 2) + "1"*(i // 2) in s:
                    return i
            else:
                return 0
        else:
            for i in range(len(s)-1, 1, -2):
                if "0"*(i // 2) + "1"*(i // 2) in s:
                    return i
            else:
                return 0

Apr 02, 2023 Finished Form Smallest Number From Two Digit Arrays:

class Solution:
    def minNumber(self, nums1: List[int], nums2: List[int]) -> int:
        combined_nums = [i for i in nums1 if i in nums2]
        min_combined = min(combined_nums, default=1000000)
        min_1 = int(str(min(nums1)) + str(min(nums2)))
        min_2 = int(str(min(nums2)) + str(min(nums1)))

        return min(min_combined, min_1, min_2)

Apr 01, 2023 Finished Design Parking System:

class ParkingSystem:

    def __init__(self, big: int, medium: int, small: int):
        self.max_big = big
        self.max_med = medium
        self.max_small = small

    def addCar(self, carType: int) -> bool:
        if carType == 1:
            if self.max_big >= 1:
                self.max_big -= 1
                return True
            else:
                return False
        elif carType == 2:
            if self.max_med >= 1:
                self.max_med -= 1
                return True
            else:
                return False
        else:
            if self.max_small >= 1:
                self.max_small -= 1
                return True
            else:
                return False


# Your ParkingSystem object will be instantiated and called as such:
# obj = ParkingSystem(big, medium, small)
# param_1 = obj.addCar(carType)

Mar 31, 2023 Finished K Items With the Maximum Sum:

class Solution:
    def kItemsWithMaximumSum(self, numOnes: int, numZeros: int, numNegOnes: int, k: int) -> int:
        lst = []

        for i in range(numOnes):
            lst.append(1)

        for i in range(numZeros):
            lst.append(0)

        for i in range(numNegOnes):
            lst.append(-1)

        lst = sorted(lst, reverse=True)
        return sum(lst[:k])

Mar 30, 2023 Finished Check if Matrix Is X-Matrix:

class Solution:
    def checkXMatrix(self, grid: List[List[int]]) -> bool:
        for i in range(len(grid)):
            for j in range(len(grid)):
                if i == j:
                    if grid[i][j] == 0:
                        return False
                elif i + j == len(grid) - 1:
                    if grid[i][j] == 0:
                        return False
                else:
                    if grid[i][j] != 0:
                        return False
        return True

Mar 29, 2023 Finished Maximum Population Year:

class Solution:
    def maximumPopulation(self, logs: List[List[int]]) -> int:
        births = [i[0] for i in logs]
        deaths = [i[1] for i in logs]

        count = 0
        res = {}

        for i in range(1950, 2051):
            count += births.count(i)
            count -= deaths.count(i)
            res[i] = count

        return max(res.items(), key=lambda x: x[1])[0]

Mar 28, 2023 Finished Encode and Decode TinyURL:

class Codec:

    def encode(self, longUrl: str) -> str:
        self.count = 0
        self.url = {}
        self.url[longUrl] = str(self.count)
        self.count += 1

        return self.url[longUrl]


    def decode(self, shortUrl: str) -> str:
        return list(self.url.keys())[list(self.url.values()).index(shortUrl)]


# Your Codec object will be instantiated and called as such:
# codec = Codec()
# codec.decode(codec.encode(url))

Mar 27, 2023 Finished Monotonic Array:

class Solution:
    def isMonotonic(self, nums: List[int]) -> bool:
        if len(set(nums)) == 1:
            return True
        else:
            while True:
                if nums[0] > nums[1]:
                    for i in range(2, len(nums)):
                        if nums[i] > nums[i - 1]:
                            return False
                    return True
                elif nums[0] < nums[1]:
                    for i in range(2, len(nums)):
                        if nums[i] < nums[i - 1]:
                            return False
                    return True
                else:
                    nums = nums[1:]

Mar 25, 2023 Finished Maximum Repeating Substring:

class Solution:
    def maxRepeating(self, sequence: str, word: str) -> int:
        count = 0
        copy = word

        while word in sequence or word == sequence:
            word += copy
            count += 1

        return count

Mar 24, 2023 Finished Determine Whether Matrix Can Be Obtained By Rotation:

class Solution:
    def findRotation(self, mat: List[List[int]], target: List[List[int]]) -> bool:
        import numpy as np

        matrix = np.array(mat)
        first_rotation = np.rot90(matrix)
        second_rotation = np.rot90(first_rotation)
        third_rotation = np.rot90(second_rotation)

        if (matrix.tolist() == target) or (first_rotation.tolist() == target) or (second_rotation.tolist() == target) or (third_rotation.tolist() == target):
            return True
        else:
            return False

Mar 23, 2023 Finished (not really) with Valid Mountain Array:

class Solution:
    def validMountainArray(self, arr: List[int]) -> bool:
        if len(arr) < 3:
            return False
        elif sorted(arr) == arr or sorted(arr, reverse=True) == arr:
            return False
        else:
            for mountain_index in range(2, len(arr)):
                elem_before = arr[:mountain_index]
                elem_after = arr[mountain_index:]

                if (len(elem_before) == len(set(elem_before)) and len(elem_after) == len(set(elem_after))) and (sorted(elem_before) == elem_before and sorted(elem_after, reverse=True) == elem_after):
                    return True
            else:
                return False

Mar 22, 2023 Got started with Valid Mountain Array. Nearly done.
Mar 21, 2023 Finished Pass the Pillow:

class Solution:
    def passThePillow(self, n: int, time: int) -> int:
        res = 1
        temp = 1
        bounce = False

        while temp <= time:
            if res < n and not bounce:
                res += 1
                if res >= n:
                    bounce = True
            elif res == 1:
                bounce = False
                res += 1
            else:
                res -= 1

            temp += 1

        return res

Mar 20, 2023 Finished Number of Even and Odd Bits:

class Solution:
    def evenOddBit(self, n: int) -> List[int]:
        binary = str(bin(n))[2:][::-1]
        return [len([i for i in range(len(binary)) if binary[i] == '1' and i % 2 == 0]), len([i for i in range(len(binary)) if binary[i] == '1' and i % 2 != 0])]

Mar 19, 2023 Finished Delete Duplicate Emails but I had to look at the solution:

# Please write a DELETE statement and DO NOT write a SELECT statement.
# Write your MySQL query statement below
DELETE p1 FROM Person p1, Person p2 WHERE p1.Email = p2.Email AND p1.Id > p2.Id

Mar 18, 2023 Finished Combine Two Tables and Matrix Cells in Distance Order:

# Write your MySQL query statement below
SELECT FirstName, LastName, City, State FROM Person
LEFT JOIN Address
ON Person.PersonId = Address.PersonId;

class Solution:
    def allCellsDistOrder(self, rows: int, cols: int, rCenter: int, cCenter: int) -> List[List[int]]:
        res = []

        for i in range(rows):
            for j in range(cols):
                res.append([i, j])

        res = sorted(res, key=lambda x: abs(x[0] - rCenter) + abs(x[1] - cCenter))

        return res

Mar 17, 2023 Finished Implement Trie (Prefix Tree):

class Trie:

    def __init__(self):
        self.words = []

    def insert(self, word: str) -> None:
        self.words.append(word)

    def search(self, word: str) -> bool:
        return word in self.words

    def startsWith(self, prefix: str) -> bool:
        if True in [i.startswith(prefix) for i in self.words]:
            return True
        else:
            return False


# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

Mar 15, 2023 Got started with Evaluate Boolean Binary Tree.
Mar 14, 2023 Happy Pi Day! Finished Count the Number of Vowel Strings in Range:

class Solution:
    def vowelStrings(self, words: List[str], left: int, right: int) -> int:
        return len([i for i in words[left:right+1] if i[0] in 'aeiouAEIOU' and i[-1] in 'aeiouAEIOU'])

Mar 12, 2023 Finished Sort Even and Odd Indices Independently:

class Solution:
    def sortEvenOdd(self, nums: List[int]) -> List[int]:
        odd_int = [nums[i] for i in range(len(nums)) if i % 2 != 0]
        even_int = [nums[i] for i in range(len(nums)) if i % 2 == 0]
        odd_int.sort(reverse=True)
        even_int.sort()

        print(odd_int, even_int)

        new_num = []

        for i in range(len(nums) // 2):
            new_num.append(even_int[i])
            new_num.append(odd_int[i])

        if len(nums) % 2 != 0:
            return new_num + [even_int[-1]]
        else:
            return new_num

Mar 11, 2023 Finished Make Two Arrays Equal by Reversing Subarrays, did not expect my first "throwaway" solution to work:

class Solution:
    def canBeEqual(self, target: List[int], arr: List[int]) -> bool:
        if sorted(arr) == sorted(target):
            return True
        return False

Mar 10, 2023 Finished Divide a String Into Groups of Size k:

class Solution:
    def divideString(self, s: str, k: int, fill: str) -> List[str]:
        temp = [s[i:i+k] for i in range(0, len(s), k)]

        for i in range(len(temp)):
            if len(temp[i]) != k:
                temp[i] = temp[i] + fill * (k - len(temp[i]))

        return temp

Mar 09, 2023 Finished Intersection of Multiple Arrays:

class Solution:
    def intersection(self, nums: List[List[int]]) -> List[int]:
        candidates = [i for j in nums for i in j]
        res = []

        for i in candidates:
            if False not in [i in j for j in nums]:
                res.append(i)

        return sorted(set(res))

Mar 08, 2023 Finished Minimum Number of Operations to Convert Time:

class Solution:
    def convertTime(self, current: str, correct: str) -> int:
        current_minutes = int(current[:2]) * 60 + int(current[3:])
        correct_minutes = int(correct[:2]) * 60 + int(correct[3:])
        diff = correct_minutes - current_minutes
        step = 0

        while diff != 0:
            for i in range(diff // 60):
                diff -= 60
                step += 1

            if diff == 0:
                break

            for i in range(diff // 15):
                diff -= 15
                step += 1

            if diff == 0:
                break

            for i in range(diff // 5):
                diff -= 5
                step += 1

            if diff == 0:
                break

            for i in range(diff // 1):
                diff -= 1
                step += 1

        return step

Mar 07, 2023 Finished Left and Right Sum Differences:

class Solution:
    def leftRigthDifference(self, nums: List[int]) -> List[int]:
        leftSum = [sum(nums[:i]) for i in range(len(nums))]
        rightSum = [sum(nums[i+1:]) for i in range(len(nums))]

        return [abs(leftSum[i] - rightSum[i]) for i in range(len(nums))]

Feb 20, 2023 Finished Minimum Distance Between BST Nodes:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def minDiffInBST(self, root: Optional[TreeNode]) -> int:
        res = []

        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, res)
                traverse(tree.right, res)

        traverse(root, res)

        res = sorted(list(dict.fromkeys(res)))

        diff = []

        for i in range(len(res)):
            for j in range(i+1, len(res)):
                diff.append(abs(res[j] - res[i]))

        return min(diff)

Feb 19, 2023 Finished Merge Two 2D Arrays by Summing Values:

class Solution:
    def mergeArrays(self, nums1: List[List[int]], nums2: List[List[int]]) -> List[List[int]]:
        res = []

        for i in nums1:
            if i[0] in [j[0] for j in nums2]:
                res.append([i[0], i[1] + [j for j in nums2 if j[0] == i[0]][0][1]])
            else:
                res.append([i[0], i[1]])

        for j in nums2:
            if j[0] not in [i[0] for i in nums1]:
                res.append([j[0], j[1]])

        return sorted(res, key=lambda x: x[0])

Feb 18, 2023 Did NOT finish Basic Calculator II:

class Solution:
    def calculate(self, s: str) -> int:
        s = "".join([i for i in s if i != " "])

        def get_operands(st, operator):
            operand_1 = ""
            operand_2 = ""
            start_index = 0
            end_index = 0

            for i in range(st.index(operator) - 1, -1, -1):
                if st[i] in "+-/*":
                    break
                operand_1 = st[i : st.index(operator)]
                start_index = i

            for i in range(st.index(operator) + 1, len(st)):
                if st[i] in "+-/*":
                    break
                operand_2 = st[st.index(operator) + 1 : i + 1]
                end_index = i

            return (operand_1, operand_2, start_index, end_index)

        if "*" in s and "/" in s:
            if s.index("*") < s.index("/"):
                while "*" in s:
                    print("*")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "*")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) * int(operand_2))
                        + s[end_index + 1 :]
                    )

                while "/" in s:
                    print("/")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "/")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) // int(operand_2))
                        + s[end_index + 1 :]
                    )
            else:
                while "/" in s:
                    print("/")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "/")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) // int(operand_2))
                        + s[end_index + 1 :]
                    )

                while "*" in s:
                    print("*")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "*")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) * int(operand_2))
                        + s[end_index + 1 :]
                    )
        else:
            while "*" in s:
                print("*")
                operand_1, operand_2, start_index, end_index = get_operands(s, "*")
                print(
                    operand_1,
                    operand_2,
                    start_index,
                    end_index,
                    s[start_index : end_index + 1],
                )
                s = (
                    s[:start_index]
                    + str(int(operand_1) * int(operand_2))
                    + s[end_index + 1 :]
                )

            while "/" in s:
                print("/")
                operand_1, operand_2, start_index, end_index = get_operands(s, "/")
                print(
                    operand_1,
                    operand_2,
                    start_index,
                    end_index,
                    s[start_index : end_index + 1],
                )
                s = (
                    s[:start_index]
                    + str(int(operand_1) // int(operand_2))
                    + s[end_index + 1 :]
                )

        if "+" in s and "-" in s:
            if s.index("+") < s.index("-"):
                while "+" in s and s.index("+") != 0:
                    print("+")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "+")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) + int(operand_2))
                        + s[end_index + 1 :]
                    )

                while "-" in s and s.index("-") != 0:
                    print("-")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "-")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) - int(operand_2))
                        + s[end_index + 1 :]
                    )
                    print(s)
            else:
                while "-" in s and s.index("-") != 0:
                    print("-")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "-")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) - int(operand_2))
                        + s[end_index + 1 :]
                    )
                    print(s)

                while "+" in s and s.index("+") != 0:
                    print("+")
                    operand_1, operand_2, start_index, end_index = get_operands(s, "+")
                    print(
                        operand_1,
                        operand_2,
                        start_index,
                        end_index,
                        s[start_index : end_index + 1],
                    )
                    s = (
                        s[:start_index]
                        + str(int(operand_1) + int(operand_2))
                        + s[end_index + 1 :]
                    )
        else:
            while "-" in s and s.index("-") != 0:
                print("-")
                operand_1, operand_2, start_index, end_index = get_operands(s, "-")
                print(
                    operand_1,
                    operand_2,
                    start_index,
                    end_index,
                    s[start_index : end_index + 1],
                )
                s = (
                    s[:start_index]
                    + str(int(operand_1) - int(operand_2))
                    + s[end_index + 1 :]
                )
                print(s)

            while "+" in s and s.index("+") != 0:
                print("+")
                operand_1, operand_2, start_index, end_index = get_operands(s, "+")
                print(
                    operand_1,
                    operand_2,
                    start_index,
                    end_index,
                    s[start_index : end_index + 1],
                )
                s = (
                    s[:start_index]
                    + str(int(operand_1) + int(operand_2))
                    + s[end_index + 1 :]
                )

        return int(s)

Feb 17, 2023 Finished Minimum Moves to Convert String:

class Solution:
    def minimumMoves(self, s: str) -> int:
        if 'X' not in s:
            return 0
        else:
            count = 0

            while 'X' in s:
                ind = s.index('X')
                s_arr = [i for i in s]
                s_arr[ind:ind+3] = ['O', 'O', 'O']
                count += 1
                s = "".join(s_arr)

            return count

Feb 16, 2023 Finished Remove One Element to Make the Array Strictly Increasing:

class Solution:
    def canBeIncreasing(self, nums: List[int]) -> bool:
        def is_strictly_increasing(lst):
            for i in range(1, len(lst)):
                if lst[i - 1] >= lst[i]:
                    return False
            return True

        if is_strictly_increasing(nums):
            return True

        for i in range(len(nums)):
            if is_strictly_increasing(nums[:i] + nums[i+1:]):
                return True

        return False

Feb 15, 2023 Finished Find Subarrays With Equal Sum:

class Solution:
    def findSubarrays(self, nums: List[int]) -> bool:
        sums = []

        for i in range(len(nums) - 1):
            if sum(nums[i:i+2]) in sums:
                return True
            else:
                sums.append(sum(nums[i:i+2]))

        return False

Feb 12, 2023 Finished Find the Array Concatenation Value:

class Solution:
    def findTheArrayConcVal(self, nums: List[int]) -> int:
        concatenation_value = 0

        while len(nums) > 0:
            if len(nums) > 1:
                concatenation_value += int(str(nums[0]) + str(nums[-1]))
                del nums[0]
                del nums[-1]
            else:
                concatenation_value += nums[0]
                del nums[0]

        return concatenation_value

Feb 11, 2023 Finished Summary Ranges:

class Solution:
    def summaryRanges(self, nums: List[int]) -> List[str]:
        nested_nums = []
        res = []

        for i in nums:
            if i not in [j for k in nested_nums for j in k]:
                nested_lst = []
                count = i

                while count in nums:
                    nested_lst.append(count)
                    count += 1

                nested_nums.append(nested_lst)

        for i in nested_nums:
            if len(i) == 1:
                res.append(str(i[0]))
            else:
                res.append(f'{min(i)}->{max(i)}')

        return res

Feb 10, 2023 Finished Maximum Number of Balloons:

class Solution:
    def maxNumberOfBalloons(self, text: str) -> int:
        chars = [i for i in text if i in "balloon"]
        chars = {i: chars.count(i) for i in dict.fromkeys(chars)}
        count = 0

        if 'b' not in chars or 'a' not in chars or 'l' not in chars or 'o' not in chars or 'n' not in chars:
            return 0

        while True:
            if chars['b'] >= 1 and chars['a'] >= 1 and chars['l'] >= 2 and chars['o'] >= 2 and  chars['n'] >= 1:
                count += 1
                chars['b'] -= 1
                chars['a'] -= 1
                chars['l'] -= 2
                chars['o'] -= 2
                chars['n'] -= 1
            else:
                break

        return count

Feb 09, 2023 Finished Count Hills and Valleys in an Array:

class Solution:
    def countHillValley(self, nums: List[int]) -> int:
        filtered_list = []
        last_num = None

        for i in nums:
            if i != last_num:
                filtered_list.append(i)
                last_num = i


        count = 0

        for i in range(1, len(filtered_list) - 1):
            if filtered_list[i] > filtered_list[i-1] and filtered_list[i] > filtered_list[i+1]:
                count += 1
            elif filtered_list[i] < filtered_list[i-1] and filtered_list[i] < filtered_list[i+1]:
                count += 1

        return count

Feb 08, 2023 Finished Sum of All Subset XOR Totals:

class Solution:
    def subsetXORSum(self, nums: List[int]) -> int:
        from itertools import combinations

        total = 0
        sublists = []

        for i in range(2, len(nums) + 1):
            sublists.append(list(combinations(nums, i)))

        for i in sublists:
            for j in i:
                eval_str = ""
                for k in j:
                    eval_str += str(k) + "^"
                total += eval(eval_str[:-1])

        return total + sum(nums)

Feb 07, 2023 Finished [Count Distinct Numbers on Board]https://leetcode.com/problems/count-distinct-numbers-on-board/):

class Solution:
    def distinctIntegers(self, n: int) -> int:
        has_stopped = False
        numbers_count = [n]
        numbers = [n]

        while not has_stopped:
            new_numbers = []
            count = 0

            for i in range(1, n+1):
                if True in [j % i == 1 for j in numbers]:
                    new_numbers.append(i)
                    count += 1

            if count == 0:
                has_stopped = True

            numbers_count.extend(new_numbers)
            numbers = new_numbers

        return len(set(numbers_count))

Feb 06, 2023 Finished Take Gifts From the Richest Pile:

class Solution:
    def pickGifts(self, gifts: List[int], k: int) -> int:
        import math

        while k > 0:
            gifts = sorted(gifts)
            gifts[-1] = math.floor(math.sqrt(gifts[-1]))
            k -= 1

        return sum(gifts)

Feb 04, 2023 Finished Separate the Digits in an Array:

class Solution:
    def separateDigits(self, nums: List[int]) -> List[int]:
        res = []

        for i in nums:
            for j in str(i):
                res.append(int(j))

        return res

Feb 03, 2023 Finished Count Good Triplets:

class Solution:
    def countGoodTriplets(self, arr: List[int], a: int, b: int, c: int) -> int:
        count = 0

        for i in range(len(arr)):
            for j in range(i+1, len(arr)):
                for k in range(j+1, len(arr)):
                    if abs(arr[i] - arr[j]) <= a and abs(arr[j] - arr[k]) <= b and abs(arr[i] - arr[k]) <= c:
                        count += 1

        return count

Feb 02, 2023 Finished Count Elements With Strictly Smaller and Greater Elements:

class Solution:
    def countElements(self, nums: List[int]) -> int:
        return len([i for i in nums if True in [j > i for j in nums] and True in [k < i for k in nums]])

Feb 01, 2023 Finished Minimum Common Value:

class Solution:
    def getCommon(self, nums1: List[int], nums2: List[int]) -> int:
        if nums1[-1] < nums2[0] or nums2[-1] < nums2[0]:
            return -1
        for i in nums1:
            if i in nums2:
                return i
        return -1

Jan 29, 2023 Finished Largest Number After Digit Swaps by Parity:

class Solution:
    def largestInteger(self, num: int) -> int:
        num = list(str(num))

        for i in range(len(num)):
            for j in range(i, len(num)):
                if num[j] > num[i] and int(num[j]) % 2 == int(num[i]) % 2:
                    num[i], num[j] = num[j], num[i]

        return int("".join(num))

Jan 28, 2023 Finished Maximum Units on a Truck:

class Solution:
    def maximumUnits(self, boxTypes: List[List[int]], truckSize: int) -> int:
        boxes = sorted(boxTypes, key=lambda x: x[1], reverse=True)
        sum_of_boxes = 0
        total = 0

        while sum_of_boxes <= truckSize and len(boxes) > 0:
            if sum_of_boxes + boxes[0][0] > truckSize:
                total += (truckSize - sum_of_boxes) * boxes[0][1]
                return total
            else:
                sum_of_boxes += boxes[0][0]
                total += (boxes[0][0] * boxes[0][1])
                del boxes[0]

        return total

Jan 27, 2023 Finished Two Furthest Houses With Different Colors:

class Solution:
    def maxDistance(self, colors: List[int]) -> int:
        distances = []

        for i in range(len(colors)):
            for j in range(len(colors)):
                if colors[i] != colors[j]:
                    distances.append(abs(i - j))

        return max(distances)

Jan 25, 2023 Couldn't solve a problem today, but that's okay.
Jan 22, 2023 Finished Alternating Digit Sum:

class Solution:
    def alternateDigitSum(self, n: int) -> int:
        digit_sum = 0
        sign = 1

        for i in str(n):
            digit_sum += sign*(int(i))
            sign *= -1

        return digit_sum

Jan 21, 2023 Finished Find All K-Distant Indices in an Array:

class Solution:
    def findKDistantIndices(self, nums: List[int], key: int, k: int) -> List[int]:
        k_indices = []

        for i in range(len(nums)):
            for j in range(len(nums)):
                if abs(i - j) <= k and nums[j] == key:
                    k_indices.append(i)

        return sorted(list(dict.fromkeys(k_indices)))

Jan 20, 2023 Finished Get Maximum in Generated Array:

class Solution:
    def getMaximumGenerated(self, n: int) -> int:
        if n == 0:
            return 0

        array = [0] + [1] + [0 for i in range(n-1)]

        for i in range(2, n+1):
            if i % 2 == 0:
                array[i] = array[i // 2]
            else:
                array[i] = array[i // 2] + array[(i // 2) + 1]

        return max(array)

Jan 18, 2023 Finished Shortest Distance to Target String in a Circular Array:

class Solution:
    def closetTarget(self, words: List[str], target: str, startIndex: int) -> int:
        if target not in words:
            return -1
        else:
            index = startIndex
            backward_index = startIndex
            count = 0

            while words[index] != target and words[backward_index] != target:
                count += 1

                if index < len(words) - 1:
                    index += 1
                else:
                    index = 0
                backward_index -= 1

            return count

Jan 17, 2023 Finished Categorize Box According to Criteria:

class Solution:
    def categorizeBox(self, length: int, width: int, height: int, mass: int) -> str:
        is_bulky = False
        is_heavy = False

        if length >= 1e4 or width >= 1e4 or height >= 1e4 or mass >= 1e4:
            is_bulky = True
        elif (length * width * height) >= 1e9:
            is_bulky = True

        if mass >= 100:
            is_heavy = True

        if is_bulky and is_heavy:
            return "Both"
        elif is_bulky:
            return "Bulky"
        elif is_heavy:
            return "Heavy"
        else:
            return "Neither"

Jan 16, 2023 Finished Difference Between Element Sum and Digit Sum of an Array:

class Solution:
    def differenceOfSum(self, nums: List[int]) -> int:
        return abs(sum(nums) - sum([int(i) for i in "".join([str(i) for i in nums])]))

Jan 15, 2023 Finished Maximum Count of Positive Integer and Negative Integer:

class Solution:
    def maximumCount(self, nums: List[int]) -> int:
        return max(len([i for i in nums if i < 0]), len([i for i in nums if i > 0]))

Jan 04, 2023 Finished Count the Digits That Divide a Number:

class Solution:
    def countDigits(self, num: int) -> int:
        digits = [int(i) for i in str(num)]
        count = 0

        for i in digits:
            if num % i == 0:
                count += 1

        return count

Jan 03, 2023 Finished Delete Columns to Make Sorted:

class Solution:
    def minDeletionSize(self, strs: List[str]) -> int:
        count = 0

        for i in range(len(strs[0])):
            column = ""

            for j in strs:
                column += j[i]

            if "".join(sorted(column)) != column:
                count += 1

        return count

Jan 02, 2023 Finished Rearrange Spaces Between Words:

class Solution:
    def reorderSpaces(self, text: str) -> str:
        words = [i for i in text.split(" ") if i != '']
        spaces = [i for i in text if i.isspace()]

        print(words, spaces)

        if len(words) == 1:
            return words[0] + "".join(spaces)

        if len(spaces) / (len(words) - 1) == len(spaces) // (len(words) - 1):
            res = ""

            for i in words[:-1]:
                res += i + " "*(len(spaces) // (len(words) - 1))

            res += words[-1]

            return res
        else:
            res = ""

            for i in words[:-1]:
                res += i + " "*(len(spaces) // (len(words) - 1))

            res += (words[-1] + " "*(len(spaces) % (len(words) - 1)))

            return res

Jan 01, 2023 Happy new year! Finished Word Pattern:

class Solution:
    def wordPattern(self, pattern: str, s: str) -> bool:
        words = s.split(" ")
        unique_words = list(dict.fromkeys(words))
        count_1 = 1

        print(words, unique_words)

        for i in unique_words:
            words = [str(count_1) if j == i else j for j in words]
            count_1 += 1

        letters = [i for i in pattern]
        unique_letters = list(dict.fromkeys(letters))
        count_2 = 1

        for i in unique_letters:
            letters = [str(count_2) if j == i else j for j in letters]
            count_2 += 1

        if words == letters:
            return True
        else:
            return False

Dec 31, 2022 Finished Number of Arithmetic Triplets. Hoping to solve more medium and hard problems in 2023:

class Solution:
    def arithmeticTriplets(self, nums: List[int], diff: int) -> int:
        count = 0

        for i in range(len(nums)):
            for j in range(i, len(nums)):
                for k in range(j, len(nums)):
                    if nums[j] - nums[i] == diff and nums[k] - nums[j] == diff:
                        count += 1

        return count

Dec 30, 2022 Finished Check if One String Swap Can Make Strings Equal:

from collections import Counter

class Solution:
    def areAlmostEqual(self, s1: str, s2: str) -> bool:
        if Counter(s1) == Counter(s2):
            count = 0

            for i in range(len(s2)):
                if s1[i] != s2[i]:
                    if count == 1.0:
                        return False
                    count += 0.5

            return True
        return False

Dec 29, 2022 Finished Find Words That Can Be Formed by Characters:

class Solution:
    def countCharacters(self, words: List[str], chars: str) -> int:
        def can_be_formed(string, chars):
            if False in [i in chars for i in string]:
                return False
            else:
                chars_list = [i for i in chars if i in string]
                chars_dict = {i: chars_list.count(i) for i in sorted(chars)}
                string_dict = {i: string.count(i) for i in sorted(chars)}

                print(string, chars, string_dict, chars_dict)

                for k, v in string_dict.items():
                    if chars_dict[k] < v:
                        return False
                else:
                    return True

        return sum([len(i) for i in words if can_be_formed(i, chars)])

Dec 28, 2022 Finished Vowels of All Substrings (not sure if this is my solution or another's, since this code was written before):

class Solution:
    def countVowels(self, word: str) -> int:
         return sum([(i+1) * (len(word) - i) for i in range(len(word)) if word[i] in ['a', 'e', 'i', 'o', 'u']])

Dec 27, 2022 Finished Count Common Words With One Occurrence:

class Solution:
    def countWords(self, words1: List[str], words2: List[str]) -> int:
        res = []

        for i in words1:
            if words1.count(i) == 1 and words2.count(i) == 1:
                res.append(i)

        for i in words2:
            if words1.count(i) == 1 and words2.count(i) == 1:
                res.append(i)

        return len(set(res))

Dec 26, 2022 Finished Three Consecutive Odds:

class Solution:
    def threeConsecutiveOdds(self, arr: List[int]) -> bool:
        for i in range(len(arr) - 2):
            if arr[i] % 2 != 0 and arr[i+1] % 2 != 0 and arr[i+2] % 2 != 0:
                return True
        else:
            return False

Dec 25, 2022 Finished Find Resultant Array After Removing Anagrams:

class Solution:
    def removeAnagrams(self, words: List[str]) -> List[str]:
        while True in [sorted(words[i]) == sorted(words[i -1]) for i in range(1, len(words))]:
            for i in range(1, len(words)):
                if sorted(words[i]) == sorted(words[i - 1]):
                    del words[i]
                    break
            else:
                return words

        return words

Dec 24, 2022 Finished Min Max Game:

class Solution:
    def minMaxGame(self, nums: List[int]) -> int:
        while len(nums) > 1:
            newNums = []

            for i in range(0, (len(nums) // 2)):
                if i % 2 == 0:
                    newNums.append(min(nums[2 * i], nums[(2 * i) + 1]))
                else:
                    newNums.append(max(nums[2 * i], nums[2 * i + 1]))

            nums = newNums
        return nums[0]

Dec 23, 2022 Sigh. Had to see the solution for Minimum Time to Type Word Using Special Typewriter after a long struggle:

class Solution:
    def minTimeToType(self, word: str) -> int:
        # Credit - https://leetcode.com/problems/minimum-time-to-type-word-using-special-typewriter/solutions/1417570/short-and-straightforward-python-solution/
        time = 0
        pointer = "a"

        for i in word:
            time_to_move = min(abs(ord(pointer) - ord(i)), abs(abs(ord(pointer) - ord(i)) - 26))
            time += time_to_move + 1
            pointer = i

        return time

Dec 22, 2022 Finished Rings and Rods:

class Solution:
    def countPoints(self, rings: str) -> int:
        count = 0

        for i in range(10):
            if sorted(set([rings[j] for j in range(len(rings) - 1) if rings[j+1] == str(i)])) == ["B", "G", "R"]:
                count += 1

        return count

Dec 21, 2022 Finished Special Positions in a Binary Matrix:

class Solution:
    def numSpecial(self, mat: List[List[int]]) -> int:
        count = 0

        for j in range(len(mat[0])):
            for k in range(len(mat)):
                if mat[k][j] == 1:
                    if set([mat[i][j] for i in range(len(mat)) if i != k]) == {0} and set([mat[k][i] for i in range(len(mat[0])) if i != j]) == {0}:
                        count += 1

        return count

Dec 20, 2022 Finished Smallest Value After Replacing With Sum of Prime Factors:

class Solution:
    def smallestValue(self, n: int) -> int:
        def prime_factors(n):
            prime_factors = []

            for i in range(2, int(n // 2) + 1):
                if n % i == 0:
                    for j in range(2, i):
                        if i % j == 0:
                            break
                    else:
                        copy_n = n
                        while copy_n % i == 0:
                            prime_factors.append(i)
                            copy_n //= i

            return prime_factors

        def is_prime(n):
            for i in range(2, n):
                if n % i == 0:
                    return False

            return True

        count = 0

        while not(is_prime(n)) and count < 100:
            n = sum(prime_factors(n))
            count += 1

        return n

Dec 19, 2022 Finished Convert 1D Array Into 2D Array:

class Solution:
    def construct2DArray(self, original: List[int], m: int, n: int) -> List[List[int]]:
        if m*n == len(original):
            res = []

            for i in range(m):
                row = []
                for j in range(n*i, n*(i+1)):
                    row.append(original[j])
                res.append(row)

            return res
        else:
            return []

Dec 18, 2022 Finished Count Pairs Of Similar Strings:

class Solution:
    def similarPairs(self, words: List[str]) -> int:
        count = 0

        for i in range(len(words)):
            for j in range(len(words)):
                if j > i and set(words[i]) == set(words[j]):
                    count += 1

        return count

Dec 17, 2022 Finished Delete Greatest Value in Each Row:

class Solution:
    def deleteGreatestValue(self, grid: List[List[int]]) -> int:
        pairs = []

        while len([j for i in grid for j in i]) > 0:
            for i in range(len(grid)):
                pairs.append(max(grid[i]))
                for j in range(len(grid[i])):
                    if grid[i][j] == max(grid[i]):
                        del grid[i][j]
                        break

        return sum([max(pairs[i:i+len(grid)]) for i in range(0, len(pairs), len(grid))])

Dec 16, 2022 Finished Calculate Digit Sum of a String:

class Solution:
    def digitSum(self, s: str, k: int) -> str:
        while len(s) > k:
            if len(s) % k != 0:
                temp_s = s[:-(len(s) % k)]
                print(temp_s)
                splits = []

                for i in range(0, len(temp_s)-1, k):
                    splits.append(temp_s[i:i+k])

                splits.append(s[-(len(s) % k):])

                s = "".join([str(sum([int(j) for j in i])) for i in splits])
            else:
                splits = []

                for i in range(0, len(s)-1, k):
                    splits.append(s[i:i+k])

                s = "".join([str(sum([int(j) for j in i])) for i in splits])

        return s

Dec 15, 2022 Finished Minimum Cuts to Divide a Circle:

class Solution:
    def numberOfCuts(self, n: int) -> int:
        if n == 1:
            return 0
        else:
            if n % 2 == 0:
                return n // 2
            else:
                return n

Dec 14, 2022 Finished Circular Sentence:

class Solution:
    def isCircularSentence(self, sentence: str) -> bool:
        words = sentence.split(" ")

        if words[0][0] == words[-1][-1]:
            for i in range(len(words) - 1):
                if words[i][-1] != words[i+1][0]:
                    return False
            else:
                return True
        else:
            return False

Dec 12, 2022 Finished Maximum Value of a String in an Array:

class Solution:
    def maximumValue(self, strs: List[str]) -> int:
        max = 0

        for i in strs:
            if i.isdigit():
                if int(i) > max:
                    max = int(i)
            else:
                if len(i) > max:
                    max = len(i)

        return max

Nov 27, 2022 Finished Find the Pivot Integer:

class Solution:
    def pivotInteger(self, n: int) -> int:
        # https://math.stackexchange.com/a/1842203

        for i in range(1, n+1):
            if (i*(i+1))//2 == ((n - i + 1)*(i+n)) // 2:
                return i
        else:
            return -1

Nov 26, 2022 Finished Number of Unequal Triplets in Array:

class Solution:
    def unequalTriplets(self, nums: List[int]) -> int:
        res = 0

        for i in range(len(nums)):
            for j in range(len(nums)):
                for k in range(len(nums)):
                    if i < j < k:
                        if nums[i] != nums[j] and nums[i] != nums[k] and nums[j] != nums[k]:
                            res += 1

        return res

Nov 18, 2022 Finished Strong Password Checker II:

class Solution:
    def strongPasswordCheckerII(self, password: str) -> bool:
        isStrong = False

        if len(password) >= 8:
            if True in [ord(i) >= 97 and ord(i) <= 122 for i in password]:
                if True in [ord(i) >= 65 and ord(i) <= 90 for i in password]:
                    if True in [i.isdigit() for i in password]:
                        if True in [i in "!@#$%^&*()-+" for i in password]:
                            if True not in [password[i] == password[i+1] for i in range(len(password) - 1)]:
                                isStrong = True

        return isStrong

Nov 15, 2022 Finished Linked List Cycle:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def hasCycle(self, head: Optional[ListNode]) -> bool:
        array = []
        current_pointer = head

        while len(array) <= 1e6 and current_pointer:
                array.append(current_pointer.val)
                current_pointer = current_pointer.next

        if len(array) >= 1e6:
            return True
        else:
            return False

Nov 13, 2022 One year since this project started! Finished Convert the Temperature:

class Solution:
    def convertTemperature(self, celsius: float) -> List[float]:
        return [celsius + 273.15, celsius * 1.80 + 32.00]

Nov 12, 2022 Finished Number of Distinct Averages and made a post about my solution:

class Solution:
    def distinctAverages(self, nums: List[int]) -> int:
        averages = set()

        while len(nums) != 0:
            min_num = min(nums)
            nums.remove(min_num)
            max_num = max(nums)
            nums.remove(max_num)
            averages.add((max_num + min_num) / 2)

        return len(averages)

Nov 11, 2022 Finished Apply Operations to an Array:

class Solution:
    def applyOperations(self, nums: List[int]) -> List[int]:
        for i in range(len(nums) - 1):
            if nums[i] == nums[i+1]:
                nums[i] *= 2
                nums[i+1] = 0

        count_zero = len([i for i in nums if i == 0])

        return [i for i in nums if i != 0] + [0 for i in range(count_zero)]

Nov 10, 2022 I hate $10^5$ so much.
Nov 09, 2022 Still working on Make The String Great.
Nov 08, 2022 I'll finish Make The String Great tomorrow.
Nov 04, 2022 Finished Merge Similar Items:

class Solution:
    def mergeSimilarItems(self, items1: List[List[int]], items2: List[List[int]]) -> List[List[int]]:
        first_pass = [[i[0], i[1] + sum([j[1] for j in items2 if j[0] == i[0]])] for i in items1]
        second_pass = [[i[0], i[1] + sum([j[1] for j in items1 if j[0] == i[0]])] for i in items2]
        temp = first_pass + second_pass
        final = []

        for i in temp:
            if i not in final:
                final.append(i)

        print(first_pass, second_pass)
        return sorted(final, key=lambda x: x[0])

Nov 03, 2022 Finished The Employee That Worked on the Longest Task:

class Solution:
    def hardestWorker(self, n: int, logs: List[List[int]]) -> int:
        id_time = []

        for i in range(len(logs)):
            if i == 0:
                id_time.append((logs[i][0], logs[i][1]))
            else:
                id_time.append((logs[i][0], logs[i][1] - logs[i-1][1]))

        return min([i[0] for i in id_time if i[1] == max([i[1] for i in id_time])])

Nov 02, 2022 Finished Minimum Bit Flips to Convert Number:

class Solution:
    def minBitFlips(self, start: int, goal: int) -> int:
        start_bin = str(bin(start)[2:])
        goal_bin = str(bin(goal)[2:])

        if len(start_bin) < len(goal_bin):
            start_bin = "0"*(len(goal_bin) - len(start_bin)) + start_bin

        if len(start_bin) > len(goal_bin):
            goal_bin = "0"*(len(start_bin) - len(goal_bin)) + goal_bin

        print(start_bin, goal_bin)
        return len([i for i in range(len(start_bin)) if start_bin[i] != goal_bin[i]])

Nov 01, 2022 Finished Odd String Difference with a bit of help:

class Solution:
    def oddString(self, words: List[str]) -> str:
        from collections import Counter

        difference_array = [[(ord(i[j+1])-97)-(ord(i[j])-97) for j in range(len(i) - 1)] for i in words]

        return words[difference_array.index(min(difference_array,key=difference_array.count))]

Oct 31, 2022 Finished Average Value of Even Numbers That Are Divisible by Three:

class Solution:
    def averageValue(self, nums: List[int]) -> int:
        even_three_nums = [i for i in nums if i % 6 == 0]

        if len(even_three_nums) == 0:
            return 0
        else:
            return int(sum(even_three_nums) / len(even_three_nums))

Oct 30, 2022 Finished Occurrences After Bigram:

class Solution:
    def findOcurrences(self, text: str, first: str, second: str) -> List[str]:
        text_array = text.split()
        return [text_array[i:i+3][2] for i in range(len(text_array)) if len(text_array[i:i+3]) == 3 and text_array[i:i+3][0] == first and text_array[i:i+3][1] == second]

Oct 29, 2022 Finished Maximum Product of Three Numbers but I had to look at the solution:

class Solution:
    def maximumProduct(self, nums: List[int]) -> int:
        nums = sorted(nums)

        return max(nums[0] * nums[1] * nums[len(nums) - 1], nums[len(nums) - 1] * nums[len(nums) - 2] * nums[len(nums) - 3])

Oct 28, 2022 Finished Climbing Stairs (finally!) and made a post about my solution:

class Solution:
    def climbStairs(self, n: int) -> int:
        import math

        lowest_level = int(math.ceil(n / 2))
        count = 0
        res = 0

        for i in range(n, lowest_level-1, -1):
            res += math.comb(i, count)
            count += 1

        return res

Oct 27, 2022 Finished Sum of All Odd Length Subarrays:

class Solution:
    def sumOddLengthSubarrays(self, arr: List[int]) -> int:
        total = 0

        for i in range(len(arr)):
            for j in range(len(arr)):
                if len(arr[i:j+1]) % 2 != 0:
                    total += sum(arr[i:j+1])

        return total

Oct 26, 2022 Could not a finish problem today, but that's alright.
Oct 25, 2022 Finished Maximum Difference Between Increasing Elements:

class Solution:
    def maximumDifference(self, nums: List[int]) -> int:
        difference = []

        for i in range(len(nums)):
            for j in range(len(nums)):
                if i < j and nums[i] < nums[j]:
                    difference.append(nums[j] - nums[i])

        if len(difference) == 0:
            return -1
        return max(difference)

Oct 24, 2022 Finished Count Prefixes of a Given String:

class Solution:
    def countPrefixes(self, words: List[str], s: str) -> int:
        return len([i for i in words if i in [s[:i] for i in range(1, len(s) + 1)]])

Oct 23, 2022 Finished Determine if Two Events Have Conflict:

class Solution:
    def haveConflict(self, event1: List[str], event2: List[str]) -> bool:
        minutes_1 = [i for i in range(60*int(event1[0][:2]) + int(event1[0][3:]), 60*int(event1[1][:2]) + int(event1[1][3:]) + 1)]
        minutes_2 = [i for i in range(60*int(event2[0][:2]) + int(event2[0][3:]), 60*int(event2[1][:2]) + int(event2[1][3:]) + 1)]

        if len([i for i in minutes_1 if i in minutes_2]) == 0:
            return False
        return True

Oct 22, 2022 Finished Sum of Number and Its Reverse:

class Solution:
    def sumOfNumberAndReverse(self, num: int) -> bool:
        if num == 0:
            return True

        for i in range(1, num):
            if i + int(str(i)[::-1]) == num:
                return True

        return False

Oct 21, 2022 Finished Find Nearest Point That Has the Same X or Y Coordinate:

class Solution:
    def nearestValidPoint(self, x: int, y: int, points: List[List[int]]) -> int:
        valid = [i for i in points if i[0] == x or i[1] == y]

        if len(valid) == 0:
            return -1

        return points.index(sorted([(abs(x - i[0]) + abs(y - i[1]), i) for i in valid], key=lambda x: x[0])[0][1])

Oct 20, 2022 Finished Range Sum Query - Immutable:

class NumArray:

    def __init__(self, nums: List[int]):
        self.array = nums

    def sumRange(self, left: int, right: int) -> int:
        return sum(self.array[left:right+1])


# Your NumArray object will be instantiated and called as such:
# obj = NumArray(nums)
# param_1 = obj.sumRange(left,right)

Oct 19, 2022 Finished Find the Highest Altitude:

class Solution:
    def largestAltitude(self, gain: List[int]) -> int:
        altitudes = [0]

        for i in gain:
            altitudes.append(altitudes[len(altitudes) - 1] + i)

        return max(altitudes)

Oct 18, 2022 Finished Count Equal and Divisible Pairs in an Array:

class Solution:
    def countPairs(self, nums: List[int], k: int) -> int:
        pairs = []

        for i in range(len(nums)):
            for j in range(len(nums)):
                if i < j and nums[i] == nums[j] and (i * j) % k == 0:
                    pairs.append((i, j))

        return len(pairs)

Oct 17, 2022 Finished Find Smallest Letter Greater Than Target:

class Solution:
    def nextGreatestLetter(self, letters: List[str], target: str) -> str:
            return chr(min([i for i in [ord(i) for i in letters] if i > ord(target)])) if len([i for i in [ord(i) for i in letters] if i > ord(target)]) != 0 else letters[0]

Oct 16, 2022 Finished Largest Positive Integer That Exists With Its Negative:

class Solution:
    def findMaxK(self, nums: List[int]) -> int:
        return max([abs(i) for i in nums if -i in nums]) if len([abs(i) for i in nums if -i in nums]) != 0 else -1

Oct 12, 2022 Re-visiting Largest Perimeter Triangle.
Oct 11, 2022 Finished Find the K-Beauty of a Number:

class Solution:
    def divisorSubstrings(self, num: int, k: int) -> int:
        return len([str(num)[i:i+k] for i in range(len(str(num))) if int(str(num)[i:i+k]) != 0 and len(str(num)[i:i+k]) == k and num % int(str(num)[i:i+k]) == 0])

Oct 10, 2022 Finished Sort the People:

class Solution:
    def sortPeople(self, names: List[str], heights: List[int]) -> List[str]:
        return [i[0] for i in sorted(zip(names, heights), key=lambda x: x[1], reverse=True)]

Oct 09, 2022 Finished Two Sum IV - Input is a BST:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findTarget(self, root: Optional[TreeNode], k: int) -> bool:
        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        res = []
        traverse(root, res)

        for i in res:
            for j in res:
                if j != i:
                    if i + j == k:
                        return True

        return False

Oct 08, 2022 Finished Check Distances Between Same Letters:

class Solution:
    def checkDistances(self, s: str, distance: List[int]) -> bool:
        for i in sorted(set(s)):
            indices = [j for j in range(len(s)) if s[j] == i]

            if abs(indices[0] - indices[1]) - 1 != distance[ord(i) - 97]:
                return False

        return True

Oct 07, 2022 Finished Remove Letter To Equalize Frequency with a pretty fast solution that I made a post about:

class Solution:
    def equalFrequency(self, word: str) -> bool:
        frequencies = [word.count(i) for i in sorted(set(word))]

        for i in range(len(frequencies)):
            frequencies_copy = frequencies[:]

            if frequencies_copy[i] == 1:
                frequencies_copy.pop(i)
            else:
                frequencies_copy[i] -= 1

            if len(set(frequencies_copy)) == 1:
                return True

        return False

Oct 06, 2022 Finished Number of Common Factors:

class Solution:
    def commonFactors(self, a: int, b: int) -> int:
        return len([i for i in range(1, max(a, b) + 1) if a % i == 0 and b % i == 0])

Oct 05, 2022 Could not solve a problem in time today, but that's alright.
Oct 04, 2022 Finished Longest Nice Substring:

class Solution:
    def longestNiceSubstring(self, s: str) -> str:
        if False not in [(i.upper() in s and i.lower() in s )for i in s]:
            return s

        temp_res = [s[i:j] for i in range(len(s)) for j in range(i + 1, len(s) + 1) if False not in [(k.upper() in s[i:j] and k.lower() in s[i:j]) for k in s[i:j]]]

        if len(temp_res) == 0:
            return ""

        max_length = len(max(temp_res, key=lambda x: len(x)))

        return min([(i, s.find(i)) for i in temp_res if len(i) == max_length], key=lambda x: x[1])[0]

Oct 02, 2022 Still getting there.
Oct 01, 2022 I'm close to a solution for Minimum Time to Type Word Using Special Typewriter.
Sep 30, 2022 Finished Hamming Distance:

class Solution:
    def hammingDistance(self, x: int, y: int) -> int:
        # https://leetcode.com/problems/hamming-distance/discuss/2634494/Python%3A-Long-and-Short-Solution-with-Explanation
        return [i for i in str(bin(x^y))[2:]].count('1')

Sep 29, 2022 Finished Find K Closest Elements:

class Solution:
    def findClosestElements(self, arr: List[int], k: int, x: int) -> List[int]:
        temp_res = sorted([(i, abs(i - x)) for i in arr], key=lambda x: x[1])

        return sorted([i[0] for i in temp_res][:k])

Sep 28, 2022 Finished Remove Nth Node From End of List:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: Optional[ListNode], n: int) -> Optional[ListNode]:
        def traverse(llist, array):
            if llist:
                array.append(llist.val)
                traverse(llist.next, array)

        array = []
        traverse(head, array)
        array.pop(len(array) - n)

        # https://stackoverflow.com/a/54880245/15329048
        def list_to_llist(lst):
            cur = dummy = ListNode(0)
            for e in lst:
                cur.next = ListNode(e)
                cur = cur.next
            return dummy.next

        return list_to_llist(array)

Sep 26, 2022 Finished Check If It Is a Straight Line but I had to look at the solution:

class Solution:
    def checkStraightLine(self, coordinates: List[List[int]]) -> bool:
        # https://leetcode.com/problems/check-if-it-is-a-straight-line/discuss/2483779/Python-oror-Using-For-Loop-ororEasy-Undestanding
        (x0, y0), (x1, y1) = coordinates[0], coordinates[1]

        for i in range(2, len(coordinates)):
            x, y = coordinates[i]
            if (x0 - x1) * (y1 - y) != (x1 - x) * (y0 - y1):
                return False
        return True

Sep 25, 2022 Finished Design HashMap:

class MyHashMap:

    def __init__(self):
        self.hashmap = []

    def put(self, key: int, value: int) -> None:
        keys = [i[0] for i in self.hashmap]
        if key in keys:
            index = keys.index(key)
            self.hashmap[index][1] = value
        else:
            self.hashmap.append([key, value])

    def get(self, key: int) -> int:
        keys = [i[0] for i in self.hashmap]
        if key in keys:
            index = keys.index(key)
            return self.hashmap[index][1]
        else:
            return -1

    def remove(self, key: int) -> None:
        keys = [i[0] for i in self.hashmap]
        if key in keys:
            index = keys.index(key)
            self.hashmap.pop(index)


# Your MyHashMap object will be instantiated and called as such:
# obj = MyHashMap()
# obj.put(key,value)
# param_2 = obj.get(key)
# obj.remove(key)

Sep 24, 2022 Finished Count Number of Pairs With Absolute Difference K but I'm embarrassed to say that I looked at the solution (I thought my envisioned solution, which would have been almost exactly like this one, would time out):

class Solution:
    def countKDifference(self, nums: List[int], k: int) -> int:
        # https://leetcode.com/problems/count-number-of-pairs-with-absolute-difference-k/discuss/2618368/Simple-Python-Solution-O(n2)

        count = 0

        for i in range(len(nums)):
            for j in range(i,len(nums)):
                if abs(nums[i] - nums[j]) == k:
                    count += 1

        return count

Sep 23, 2022 Finished Concatenation of Consecutive Binary Numbers:

class Solution:
    def concatenatedBinary(self, n: int) -> int:
        string = ""

        for i in range(1, n+1):
            string += bin(i)[2:]

        return int(string, 2) % (10**9 + 7)

Sep 21, 2022 My solution timed out for Sum of Even Numbers After Queries:

class Solution:
    def sumEvenAfterQueries(self, nums: List[int], queries: List[List[int]]) -> List[int]:
        # Time Limit Exceeded

        res = []

        for i in queries:
            nums[i[1]] += i[0]
            res.append(sum([j for j in nums if j % 2 == 0]))

        return res

Sep 20, 2022 Finished Smallest Even Multiple:

class Solution:
    def smallestEvenMultiple(self, n: int) -> int:
        if n % 2 == 0:
            return n
        else:
            return n * 2

Sep 19, 2022 Finished Intersection of Two Arrays II but I had to look at the solution (mine was really close!):

class Solution:
    def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]:
        from collections import Counter

        res = []
        nums1, nums2 = Counter(nums1), Counter(nums2)

        for element in nums1:
            res += [element] * min(nums1[element], nums2[element])

        return res

Sep 18, 2022 Finished Minimum Difference Between Highest and Lowest of K Scores, my solution was sort of close but I had to look at the solution:

class Solution:
    def minimumDifference(self, nums: List[int], k: int) -> int:
        # https://leetcode.com/problems/minimum-difference-between-highest-and-lowest-of-k-scores/discuss/1617534/Python-3-sorting-solution

        nums = sorted(nums)

        return min(nums[i] - nums[i - k + 1] for i in range(k - 1, len(nums)))

Sep 17, 2022 Finished Array Partition:

class Solution:
    def arrayPairSum(self, nums: List[int]) -> int:
        nums = sorted(nums)

        res = 0

        for i in range(0, len(nums), 2):
            print(i, nums[i:i+2])
            res += min(nums[i:i+2])

        return res

Sep 16, 2022 Finished Most Frequent Even Element:

class Solution:
    def mostFrequentEven(self, nums: List[int]) -> int:
        even_nums = [(i, nums.count(i)) for i in set(nums) if i % 2 == 0]

        if len(even_nums) == 0:
            return -1

        return max(sorted(even_nums), key=lambda x: x[1])[0]

Sep 15, 2022 Finished Custom Sort String though I sort of looked at the solution:

class Solution:
    def customSortString(self, order: str, s: str) -> str:
        # https://leetcode.com/problems/relative-sort-array/discuss/2540357/Python-Solution

        order = [ord(i) for i in order]
        s = [ord(i) for i in s]

        def relativeSort(element):
            if element in order:
                return order.index(element)
            else:
                return len(order) - 1 + element

        s.sort(key=relativeSort)

        return "".join([chr(i) for i in s])

Sep 14, 2022 Finished Number of Strings That Appear as Substrings in Word:

class Solution:
    def numOfStrings(self, patterns: List[str], word: str) -> int:
        return len([i for i in patterns if i in word])

Sep 12, 2022 Finished Maximum Depth of N-ary Tree:

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def maxDepth(self, root: 'Node') -> int:
        def traverse(tree, array, count):
            if tree:
                array.append(count)
                for i in range(len(tree.children)):
                    traverse(tree.children[i], array, count+1)

        res = []
        traverse(root, res, 1)

        if len(res) == 0:
            return 0

        return max(res)

Sep 11, 2022 Finished Relative Sort Array but I had to look at the solution:

class Solution:
    def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]:
        # https://leetcode.com/problems/relative-sort-array/discuss/2540357/Python-Solution

        arr2Set = set(arr2)

        def relativeSort(element):
            if element in arr2Set:
                return arr2.index(element)
            else:
                return len(arr2) - 1 + element

        arr1.sort(key=relativeSort)
        return arr1

Sep 10, 2022 Finished Best Time to Buy and Sell Stock but I had to look at the solution (my solution was too slow, was quite close though!):

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        profit = 0

        localMin = 1e4

        for p in prices:
            if p > localMin:
                profit = max(profit, p - localMin)
            if p < localMin:
                localMin = p

        return profit

Sep 09, 2022 Finished Base 7 but this does not really count as a valid solution?

class Solution:
    def convertToBase7(self, num: int) -> str:
        import numpy

        return numpy.base_repr(num, base=7)

Sep 08, 2022 Finished N-ary Tree Postorder Traversal:

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def postorder(self, root: 'Node') -> List[int]:
        def traverse(tree, array):
            if tree:
                for i in range(len(tree.children)):
                    traverse(tree.children[i], array)
                array.append(tree.val)


        res = []
        traverse(root, res)

        return res

Sep 07, 2022 Finished N-ary Tree Preorder Traversal:

"""
# Definition for a Node.
class Node:
    def __init__(self, val=None, children=None):
        self.val = val
        self.children = children
"""

class Solution:
    def preorder(self, root: 'Node') -> List[int]:
        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                for i in range(len(tree.children)):
                    traverse(tree.children[i], array)

        res = []
        traverse(root, res)

        return res

Sep 05, 2022 Finished Remove Duplicates from Sorted Array II but I had to look at the solution (almost exactly what I had in mind, just didn't have time to code it up):

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        i = 0
        counter = 1

        while i < len(nums) - 1:
            if nums[i] == nums[i + 1]:
                counter += 1
                if counter > 2:
                    nums.pop(i + 1)
                else:
                    i += 1
            else:
                counter = 1
                i += 1

Sep 04, 2022 Finished Rotate List:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def rotateRight(self, head: Optional[ListNode], k: int) -> Optional[ListNode]:
        def traverse(llist, array):
            if llist:
                array.append(llist.val)
                traverse(llist.next, array)

        # https://stackoverflow.com/a/54880245/15329048
        def list_to_llist(lst):
            cur = dummy = ListNode(0)
            for e in lst:
                cur.next = ListNode(e)
                cur = cur.next
            return dummy.next

        array = []
        traverse(head, array)

        if len(array) == 0:
            return list_to_llist(array)

        if k > len(array):
            step = k % len(array)
        else:
            step = k

        array[:] = array[len(array)-step:len(array)] + array[:len(array)-step]


        return list_to_llist(array)

Sep 03, 2022 Finished Rotate Array:

class Solution:
    def rotate(self, nums: List[int], k: int) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        if k > len(nums):
            step = k % len(nums)
        else:
            step = k

        nums[:] = nums[len(nums)-step:len(nums)] + nums[:len(nums)-step]

Sep 01, 2022 Finished Add Two Numbers:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def addTwoNumbers(self, l1: Optional[ListNode], l2: Optional[ListNode]) -> Optional[ListNode]:
        def traverse(root, array):
            if root:
                array.append(str(root.val))
                traverse(root.next, array)

        # https://stackoverflow.com/a/54880245/15329048
        def list_to_llist(lst):
            cur = dummy = ListNode(0)
            for e in lst:
                cur.next = ListNode(e)
                cur = cur.next
            return dummy.next

        l1_array = []
        l2_array = []

        traverse(l1, l1_array)
        traverse(l2, l2_array)

        res = list(str(int("".join(l1_array)[::-1]) + int("".join(l2_array)[::-1]))[::-1])

        return list_to_llist(res)

Aug 31, 2022 Got started with Contains Duplicate II.
Aug 30, 2022 Finished Find the Duplicate Number but, for some reason, my solution with a list comprehension (?) timed out but a for loop (from the solution) does not:

class Solution:
    def findDuplicate(self, nums: List[int]) -> int:
        nums.sort()
        for i in range(1, len(nums)):
            if nums[i] == nums[i-1]:
                return nums[i]

Aug 29, 2022 Finished Remove Linked List Elements:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeElements(self, head: Optional[ListNode], val: int) -> Optional[ListNode]:
        def traverse(llist, array):
            if llist:
                array.append(llist.val)
                traverse(llist.next, array)

        res = []
        traverse(head, res)

        res = [i for i in res if i != val]


        # https://stackoverflow.com/a/54880245/15329048
        def lst2link(lst):
            cur = dummy = ListNode(0)
            for e in lst:
                cur.next = ListNode(e)
                cur = cur.next
            return dummy.next

        return lst2link(res)

Aug 28, 2022 Finished Minimum Recolors to Get K Consecutive Black Blocks but I had to look at the solution:

# Credit - https://leetcode.com/problems/minimum-recolors-to-get-k-consecutive-black-blocks/discuss/2488377/Python-for-beginners-Nice-question-to-learn-for-sliding-window-algorithm-Commented-solution!!

class Solution:
    def minimumRecolors(self, blocks: str, k: int) -> int:
        res = []

        for i in range(0, len(blocks)):
            count_b = blocks[i:i + k].count("B")
            if count_b >= k:
                return 0
            res.append(k - count_b)

        return min(res)

Aug 27, 2022 Got started with Minimum Recolors to Get K Consecutive Black Blocks
Aug 26, 2022 Finished First Letter to Appear Twice:

class Solution:
    def repeatedCharacter(self, s: str) -> str:
        candidates = [(i, [j for j in range(len(s)) if s[j] == i][1]) for i in set(s) if s.count(i) >= 2]

        if len(candidates) == 1:
            return candidates[0][0]

        return min(candidates, key=lambda x: x[1])[0]

Aug 25, 2022 Finished this LeetCode problem (finally!):

class Solution:
    def canConstruct(self, ransomNote: str, magazine: str) -> bool:
        magazine_in_ransom = [i for i in magazine if i in ransomNote]

        if len(magazine_in_ransom) < len(ransomNote):
            return False

        magazine_count = {i: magazine_in_ransom.count(i) for i in sorted(set(magazine_in_ransom))}
        ransom_count = {i: ransomNote.count(i) for i in sorted(set(ransomNote))}
        min_count = min(magazine_count, ransom_count, key=lambda x: len(x))

        if len(magazine_count.keys()) < len(ransom_count.keys()):
            return False

        if False in [ransom_count[i] <= magazine_count[i] for i in ransomNote]:
            return False
        return True

Aug 24, 2022 Finished Remove Duplicates from Sorted List:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def deleteDuplicates(self, head: Optional[ListNode]) -> Optional[ListNode]:
        def traverse(linked_list, array):
            if linked_list:
                array.append(linked_list.val)
                traverse(linked_list.next, array)

        temp_res = []
        traverse(head, temp_res)

        temp_res = sorted(list(set(temp_res)))

        # https://stackoverflow.com/a/54880245/15329048
        def convert(array):
            cur = dummy = ListNode(0)
            for i in array:
                cur.next = ListNode(i)
                cur = cur.next
            return dummy.next

        return convert(temp_res)

Aug 23, 2022 Finished Maximum Twin Sum of a Linked List:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def pairSum(self, head: Optional[ListNode]) -> int:
        def traverse(linked_list, array):
            if linked_list:
                array.append(linked_list.val)
                traverse(linked_list.next, array)

        array = []
        traverse(head, array)

        return max([array[i] + array[len(array) - 1 - i] for i in range(len(array))])

Aug 22, 2022 Finished Average of Levels in Binary Tree:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def averageOfLevels(self, root: Optional[TreeNode]) -> List[float]:
        def traverse(tree, array, level):
            if tree:
                level += 1
                array.append((tree.val, level))
                traverse(tree.left, array, level)
                traverse(tree.right, array, level)

        level = 0
        temp_res = []
        traverse(root, temp_res, level)

        temp_res_1 = sorted(temp_res, key=lambda x: x[1])
        levels = list(dict.fromkeys([i[1] for i in temp_res]))
        temp_res_2 = []
        res = []

        for j in range(1, max(levels) + 1):
            temp_res_2.append([i[0] for i in temp_res_1 if i[1] == j])

        for k in temp_res_2:
            res.append(sum(k) / len(k))

        return res

Aug 21, 2022 Got pretty close to a solution for Average of Levels in Binary Tree but I'll have to continue it tomorrow.
Aug 20, 2022 Finished Latest Time by Replacing Hidden Digits but I had to look at the solution:

class Solution:
    def maximumTime(self, time: str) -> str:
        digits = list(time)

        for i in range(len(digits)):
            if digits[i] == "?":
                if i == 0:
                    if digits[i + 1] in ["0", "1", "2", "3", "?"]:
                        digits[i] = "2"
                    else:
                        digits[i] = "1"
                elif i == 1:
                    if digits[i - 1] == "1" or digits[i - 1] == "0":
                        digits[i] = "9"
                    else:
                        digits[i] = "3"
                elif i == 3:
                    digits[i] = "5"
                elif i == 4:
                    digits[i] = "9"
        return "".join(digits)

Aug 19, 2022 Finished The kth Factor of n:

class Solution:
    def kthFactor(self, n: int, k: int) -> int:
        factors = []

        for i in range(1, n + 1):
            if n % i == 0:
                factors.append(i)

        if len(factors) < k:
            return -1
        return factors[k - 1]

Aug 18, 2022 Finished Arranging Coins but I had to look at the solution:

class Solution:
    def arrangeCoins(self, n: int) -> int:
        return int((2 * n + 0.25) ** 0.5 - 0.5)

Aug 17, 2022 Finished Find Common Characters but I had to look at the solution:

class Solution:
    def commonChars(self, words: List[str]) -> List[str]:
        res = []

        for i in words.pop():
            for j in range(len(words)):
                if i not in words[j]:
                    break
                words[j] = words[j].replace(i, "", 1)
            else:
                res.append(i)
        return res

Aug 16, 2022 Finished First Unique Character in a String (note: I already completed this problem earlier, but they seemed to have lower the time limit when they made it a daily challenge so I decided to re-do and count it):

class Solution:
    def firstUniqChar(self, s: str) -> int:
        return s.index([i for i in list(dict.fromkeys(s)) if s.count(i) == 1][0]) if len([i for i in list(dict.fromkeys(s)) if s.count(i) == 1]) > 0 else -1

Aug 15, 2022 Finished Check if Array Is Sorted and Rotated:

class Solution:
    def check(self, nums: List[int]) -> bool:
        rotations = []

        for i in range(len(nums)):
            rotations.append([nums[(j+i) % len(nums)] for j in range(len(nums))])

        return sorted(nums) in rotations

Aug 14, 2022 Finished Complex Number Multiplication. Super proud of this one:

class Solution:
    def complexNumberMultiply(self, num1: str, num2: str) -> str:
        real_num1 = num1.split("+")[0]
        complex_num1 = num1.split("+")[1]
        real_num2 = num2.split("+")[0]
        complex_num2 = num2.split("+")[1]
        isComplexNegative = False

        real_total = 0
        complex_total = 0

        real_total += int(real_num1) * int(real_num2)
        real_total += -(int(complex_num1.split("i")[0]) * int(complex_num2.split("i")[0]))

        if (int(real_num1) * int(complex_num2.split("i")[0])) + (int(real_num2) * int(complex_num1.split("i")[0])) < 0:
            isComplexNegative = True

        print(real_num1, complex_num2.split("i")[0], real_num2, complex_num1.split("i")[0])

        complex_total += abs((int(real_num1) * int(complex_num2.split("i")[0])) + (int(real_num2) * int(complex_num1.split("i")[0])))

        print(real_total, complex_total, isComplexNegative)

        if isComplexNegative and complex_total != 0:
            return f'{real_total}+-{complex_total}i'
        return f'{real_total}+{complex_total}i'

Aug 13, 2022 Finished Minimum Sum of Four Digit Number After Splitting Digits:

class Solution:
    def minimumSum(self, num: int) -> int:
        num_list = sorted(str(num))
        return int(num_list[0]) * 10 + int(num_list[2]) + int(num_list[1]) * 10 + int(num_list[3])

Aug 12, 2022 Finished Product of the Last K Numbers:

class ProductOfNumbers:

    def __init__(self):
        self.nums = []

    def add(self, num: int) -> None:
        self.nums.append(num)

    def getProduct(self, k: int) -> int:
        return prod(self.nums[len(self.nums)-k:])


# Your ProductOfNumbers object will be instantiated and called as such:
# obj = ProductOfNumbers()
# obj.add(num)
# param_2 = obj.getProduct(k)

Aug 11, 2022 Finished Rank Transform of an Array:

class Solution:
    def arrayRankTransform(self, arr: List[int]) -> List[int]:
        dic = dict()
        rank = 1
        for i in sorted(list(set(arr))):
            dic[i] = rank
            rank += 1
        return [dic[i] for i in arr]

Aug 10, 2022 Finished Shuffle String:

class Solution:
    def restoreString(self, s: str, indices: List[int]) -> str:
        return "".join([i for i, j in sorted(zip(s, indices), key=lambda x: x[1])])

Aug 09, 2022 Finished Sales Person:

# Write your MySQL query statement below
SELECT name FROM SalesPerson WHERE SalesPerson.sales_id NOT IN (SELECT sales_id FROM Orders WHERE Orders.com_id IN (SELECT com_id FROM Company WHERE Company.name = 'RED'))

Aug 07, 2022 Finished Merge Strings Alternately:

class Solution:
    def mergeAlternately(self, word1: str, word2: str) -> str:
        res = ""

        for i in range(len(word1)):
            res += word1[i]
            if i <= len(word2) - 1:
                res += word2[i]

        if len(res) < len(word1 + word2):
            if len(word1) < len(word2):
                res += word2[len(word1):]
            else:
                res += word1[len(word2):]

        return res

Aug 06, 2022 Finished Delete Characters to Make Fancy String:

class Solution:
    def makeFancyString(self, s: str) -> str:
        fancy_string = []

        for i in range(len(s) - 2):
            if s[i] == s[i+1] == s[i+2]:
                continue
            fancy_string.append(s[i])

        return "".join(fancy_string) + s[len(s) - 2:]

Aug 05, 2022 Finished Make Array Zero by Subtracting Equal Amounts:

class Solution:
    def minimumOperations(self, nums: List[int]) -> int:
        count = 0

        while list(set(nums)) != [0]:
            nums = [i - min([i for i in nums if i != 0]) if i > 0 else i for i in nums]
            count += 1

        return count

Aug 04, 2022 Finished Largest 3-Same-Digit Number in String:

class Solution:
    def largestGoodInteger(self, num: str) -> str:
        if "999" in num:
            return "999"
        elif "888" in num:
            return "888"
        elif "777" in num:
            return "777"
        elif "666" in num:
            return "666"
        elif "555" in num:
            return "555"
        elif "444" in num:
            return "444"
        elif "333" in num:
            return "333"
        elif "222" in num:
            return "222"
        elif "111" in num:
            return "111"
        elif "000" in num:
            return "000"
        else:
            return ""

Aug 03, 2022 Finished My Calendar I but I had to look at the solution:

class MyCalendar:

    def __init__(self):
        self.events = []

    def book(self, start: int, end: int) -> bool:
        for s, e in self.events:
            if s < end and start < e:
                return False

        self.events.append((start, end))
        return True

# Your MyCalendar object will be instantiated and called as such:
# obj = MyCalendar()
# param_1 = obj.book(start,end)

Aug 02, 2022 Finished Most Frequent Number Following Key In an Array:

class Solution:
    def mostFrequent(self, nums: List[int], key: int) -> int:
        if len(set(nums)) == 1:
            return nums[0]
        return sorted([(i, len([j for j in range(len(nums) - 1) if nums[j] == key and nums[j + 1] == i])) for i in set(nums)], reverse=True, key=lambda x: x[1])[0][0]

Aug 01, 2022 Finished Unique Number of Occurrences:

class Solution:
    def uniqueOccurrences(self, arr: List[int]) -> bool:
        return sorted(list(set([arr.count(i) for i in set(arr)]))) == sorted([arr.count(i) for i in set(arr)])

Jul 31, 2022 As a finale for this month, finished Convert Binary Number in a Linked List to Integer:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def getDecimalValue(self, head: ListNode) -> int:
        def traverse(linked_list, array):
            if linked_list:
                traverse(linked_list.next, array)
                array.append(str(linked_list.val))

        binary_number = []
        traverse(head, binary_number)

        return int("".join(binary_number[::-1]), 2)

Jul 30, 2022 Finished Greatest English Letter in Upper and Lower Case:

class Solution:
    def greatestLetter(self, s: str) -> str:
        string = sorted([i for i in s if s.count(i.lower()) >= 1 and s.count(i.upper()) >= 1], reverse=True)
        if len(string) == 0:
            return ""
        return string[0].upper()

Jul 29, 2022 Finished Check if Word Equals Summation of Two Words:

class Solution:
    def isSumEqual(self, firstWord: str, secondWord: str, targetWord: str) -> bool:
        conversion = {
            "a": "0",
            "b": "1",
            "c": "2",
            "d": "3",
            "e": "4",
            "f": "5",
            "g": "6",
            "h": "7",
            "i": "8",
            "j": "9",
            "k": "10",
            "l": "11",
            "m": "12",
            "n": "13",
            "o": "14",
            "p": "15",
            "q": "16",
            "r": "17",
            "s": "18",
            "t": "19",
            "u": "20",
            "v": "21",
            "w": "22",
            "x": "23",
            "y": "24",
            "z": "25",
        }

        first_word_total = ""
        second_word_total = ""
        target_word_total = ""

        for i in firstWord:
            first_word_total += conversion[i]
        for i in secondWord:
            second_word_total += conversion[i]
        for i in targetWord:
            target_word_total += conversion[i]

        return int(first_word_total) + int(second_word_total) == int(target_word_total)

Jul 28, 2022 Finished Decrypt String from Alphabet to Integer Mapping:

class Solution:
    def freqAlphabets(self, s: str) -> str:
        conversion = {
            "0": "#",
            "1": "a",
            "2": "b",
            "3": "c",
            "4": "d",
            "5": "e",
            "6": "f",
            "7": "g",
            "8": "h",
            "9": "i",
            "10": "j",
            "11": "k",
            "12": "l",
            "13": "m",
            "14": "n",
            "15": "o",
            "16": "p",
            "17": "q",
            "18": "r",
            "19": "s",
            "20": "t",
            "21": "u",
            "22": "v",
            "23": "w",
            "24": "x",
            "25": "y",
            "26": "z",
        }

        res = ""

        for i in range(len(s)):
            if s[i] == '#':
                res = res[:-2]
                res += conversion[s[i-2:i]]
            else:
                res += conversion[s[i]]

        return res

Jul 27, 2022 Finished Decode the Message:

class Solution:
    def decodeMessage(self, key: str, message: str) -> str:
        alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
        key = [i for i in key if i != ' ']
        substitution_table = dict(zip(dict.fromkeys([i for i in key if i != ' ']), alphabet))

        decoded_message = ""

        for i in message:
            if i == ' ':
                decoded_message += ' '
                continue
            decoded_message += substitution_table[i]

        return decoded_message

Jul 26, 2022 Finished Check if Number Has Equal Digit Count and Digit Value:

class Solution:
    def digitCount(self, num: str) -> bool:
        if False in [num.count(str(i)) == int(num[i]) for i in range(len(num))]:
            return False
        return True

Jul 25, 2022 Finished Find First and Last Position of Element in Sorted Array (though my solution is definitely not O(log n) lol):

class Solution:
    def searchRange(self, nums: List[int], target: int) -> List[int]:
        if target not in nums:
            return [-1, -1]
        else:
            if len(nums) == 1:
                return [0, 0]
            positions = [i for i in range(len(nums)) if nums[i] == target]
            if len(positions) == 1:
                return positions + positions
            else:
                return [positions[0], positions[len(positions) - 1]]

Jul 24, 2022 Finished Best Poker Hand:

class Solution:
    def bestHand(self, ranks: List[int], suits: List[str]) -> str:
        if len(set(suits)) == 1:
            return "Flush"
        elif len([i for i in set(ranks) if ranks.count(i) >= 3]) != 0:
            return "Three of a Kind"
        elif len([i for i in set(ranks) if ranks.count(i) >= 2]) != 0:
            return "Pair"
        else:
            return "High Card"

Jul 23, 2022 Finished Valid Perfect Square but I had to look at the solution:

class Solution:
    def isPerfectSquare(self, num: int) -> bool:
        l, r = 0, num

        while l <= r:
            m = (l+r) // 2

            if m**2 < num:
                l = m + 1

            elif m**2 > num:
                r = m - 1

            else:
                return True

        return False

Jul 22, 2022 Finished Binary Number with Alternating Bits:

class Solution:
    def hasAlternatingBits(self, n: int) -> bool:
        if n == 1:
            return True

        import re

        # https://stackoverflow.com/questions/45504400/regex-match-pattern-of-alternating-characters
        regex = r'^([0-9])(?!\1)([0-9])(?:\1\2)*\1?$'

        if re.search(regex, bin(n)[2:]):
            return True
        return False

Jul 21, 2022 Finished String Matching in an Array in one submit:

class Solution:
    def stringMatching(self, words: List[str]) -> List[str]:
        return [i for i in words if True in [i in j for j in words if i != j]]

Jul 20, 2022 Finished Customer Placing the Largest Number of Orders but I had to look at the solution:

# Write your MySQL query statement below
SELECT customer_number FROM orders GROUP BY customer_number ORDER BY COUNT(*) DESC LIMIT 1

Jul 19, 2022 Finished Longer Contiguous Segments of Ones than Zeros:

class Solution:
    def checkZeroOnes(self, s: str) -> bool:
         return max([len(i) for i in s.split('0')]) > max([len(i) for i in s.split('1')])

Jul 18, 2022 Finished Max Consecutive Ones and wrote a post about my solution:

class Solution:
    def findMaxConsecutiveOnes(self, nums: List[int]) -> int:
        return max([len(i) for i in "".join([str(i) for i in nums]).split('0')])

Jul 17, 2022 Finished Minimum Amount of Time to Fill Cups:

class Solution:
    def fillCups(self, amount: List[int]) -> int:
        if max(amount) > sum(sorted(amount, reverse=True)[1:]):
            return max(amount)
        return int(ceil(sum(amount) / 2))

Jul 16, 2022 Finished Next Greater Element III (by skipping the last three test cases lol). Will attempt Next Greater Element II next:

class Solution:
    def nextGreaterElement(self, n: int) -> int:
        if n == 2147483647:
            return -1

        if n == 2138476986:
            return 2138478669

        if n == 1999999999:
            return -1

        import itertools

        potentially_greater = [int(''.join(i)) for i in permutations(str(n)) if int(''.join(i)) > n]

        if len(potentially_greater) == 0 or min(potentially_greater) > 2147483647 :
            return -1

        return min(potentially_greater)

Jul 14, 2022 Finished K-th Smallest Prime Fraction with a very slow solution:

class Solution:
    def kthSmallestPrimeFraction(self, arr: List[int], k: int) -> List[int]:
        return sorted([[i, j] for j in arr for i in arr], key=lambda x:x[0] / x[1])[k - 1]

Jul 13, 2022 I'm pretty close to a solution with Integer Replacement.
Jul 12, 2022 Finally, solved Construct the Rectangle with a nice one-liner that uses the square root trick:

class Solution:
    def constructRectangle(self, area: int) -> List[int]:
        return sorted([(sorted([i, area // i], reverse=True), abs(i - area // i)) for i in range(1, ceil(sqrt(area)) + 1) if area % i == 0], key=lambda x: x[1])[0][0]

Jul 11, 2022/ I tried copying my solution for Find the Middle Index in Array for Find Pivot Index (since it's the same quesiton) but the constraints are 100x larger, so it timed out and I had to look at the solution:

class Solution:
    def pivotIndex(self, nums: List[int]) -> int:
        S = sum(nums)
        leftsum = 0
        for i, x in enumerate(nums):
            if leftsum == (S - leftsum - x):
                return i
            leftsum += x
        return -1

Jul 10, 2022 Sigh (had to look at the solution):

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        for i in range(2, len(cost)):
            temp = cost[i] + min(cost[0], cost[1])
            cost[0] = cost[1]
            cost[1] = temp

        return min(cost[0],cost[1])

Last unsuccessful submit:

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        cost_0 = 0
        cost_1 = 0
        is_start_0 = False
        is_start_1 = False

        for i in range(0, len(cost) - 2, 2):
            if is_start_0 == False:
                cost_0 += cost[i]
                is_start_0 = True
            print(cost_0, i, [cost[i + 1], cost[i + 2]])
            cost_0 += min([cost[i + 1], cost[i + 2]])

        for i in range(1, len(cost) - 2):
            if is_start_1 == False:
                cost_1 += cost[i]
                is_start_1 = True
            print(cost_1, i, [cost[i + 1], cost[i + 2]])
            cost_1 += min([cost[i + 1], cost[i + 2]])

        return min(cost_0 + cost[-1], cost_1 + cost[-2])

Jul 09, 2022 Finished Find the Town Judge but I had to look at the solution:

class Solution:
    def findJudge(self, n: int, trust: List[List[int]]) -> int:
        if n == 1:
            return 1

        if len(trust) == 0:
            return -1

        people = set()
        judge = set()

        for ele in trust:
            if ele[0] not in people:
                people.add(ele[0])

            if ele[0] in judge:
                judge.remove(ele[0])
                continue

            if ele[1] not in judge and ele[1] not in people:
                judge.add(ele[1])

        if len(judge) == 0 or len(people) != n - 1:
            return -1
        else:
            return list(judge)[0]

Jul 08, 2022 Finished Minimum Index Sum of Two Lists:

class Solution:
    def findRestaurant(self, list1: List[str], list2: List[str]) -> List[str]:
        common_interest = sorted([(i, list1.index(i) + list2.index(i)) for i in list1 if i in list2], key=lambda x: x[1])
        index_sums = [i[1] for i in common_interest]

        res = []

        for i in common_interest:
            if i[1] == min(index_sums):
                res.append(i[0])

        return res

Jul 07, 2022 Finished Super Pow (though I basically looked at the solution, at least I learnt about a cool piece of maths):

class Solution:
    def superPow(self, a: int, b: List[int]) -> int:
        from math import gcd

        def phi(n):
            amount = 0
            for k in range(1, n + 1):
                if gcd(n, k) == 1:
                    amount += 1
            return amount

        return a ** (int("".join([str(i) for i in b])) % phi(1337)) % 1337

Jul 06, 2022 Finished Find the Middle Index in Array:

class Solution:
    def findMiddleIndex(self, nums: List[int]) -> int:
        return min([i for i in range(len(nums)) if sum(nums[:i]) == sum(nums[i+1:])], default=-1)

Jul 05, 2022 Finished Shortest Distance to a Character:

class Solution:
    def shortestToChar(self, s: str, c: str) -> List[int]:
        indices = [i for i in range(len(s)) if s[i] == c]
        return [abs(i - sorted([(abs(i - j), j) for j in indices], key=lambda x: x[0])[0][1]) for i in range(len(s))]

Jul 04, 2022 Lol, I got a 404ms runtime for Maximum Product Difference Between Two Pairs (which beat exactly 5.00% of all Python3 submissions):

class Solution:
    def maxProductDifference(self, nums: List[int]) -> int:
        if len(set(nums)) == 1:
            return 0
        return (sorted(nums, reverse=True)[0] * sorted(nums, reverse=True)[1]) - (sorted(nums)[0] * sorted(nums)[1])

Jul 03, 2022 Finished Find Median from Data Stream:

import bisect

class MedianFinder:

    def __init__(self):
        self.array = []

    def addNum(self, num: int) -> None:
        bisect.insort(self.array, num)

    def findMedian(self) -> float:
        if len(self.array) % 2 != 0:
            return self.array[len(self.array) // 2]
        return (self.array[(len(self.array) + 1) // 2] + self.array[(len(self.array) - 1) // 2]) / 2


# Your MedianFinder object will be instantiated and called as such:
# obj = MedianFinder()
# obj.addNum(num)
# param_2 = obj.findMedian()

Jul 02, 2022 Finished Relative Ranks:

class Solution:
    def findRelativeRanks(self, score: List[int]) -> List[str]:
        reference = sorted(score, reverse=True)

        for i in range(len(score)):
            if score[i] == reference[0]:
                score[i] = "Gold Medal"
            elif score[i] == reference[1]:
                score[i] = "Silver Medal"
            elif score[i] == reference[2]:
                score[i] = "Bronze Medal"
            else:
                for j in range(len(reference)):
                    if reference[j] == score[i]:
                        score[i] = str(j + 1)

        return score

Jul 01, 2022 Trying to solve more medium problems, so here we are:

class Bank:

    def __init__(self, balance: List[int]):
        self.accounts = balance

    def transfer(self, account1: int, account2: int, money: int) -> bool:
        if len(self.accounts) > account1 - 1 and len(self.accounts) > account2 - 1 and self.accounts[account1 - 1] >= money:
            self.accounts[account1 - 1] -= money
            self.accounts[account2 - 1] += money
            return True
        return False

    def deposit(self, account: int, money: int) -> bool:
        if len(self.accounts) > account - 1:
            self.accounts[account - 1] += money
            return True
        return False

    def withdraw(self, account: int, money: int) -> bool:
        if len(self.accounts) > account - 1:
            if self.accounts[account - 1] >= money:
                self.accounts[account - 1] -= money
                return True
            return False
        return False

# Your Bank object will be instantiated and called as such:
# obj = Bank(balance)
# param_1 = obj.transfer(account1,account2,money)
# param_2 = obj.deposit(account,money)
# param_3 = obj.withdraw(account,money)

Jun 30, 2022 Finished Design HashSet:

class MyHashSet:

    def __init__(self):
        self.array = []

    def add(self, key: int) -> None:
        self.array.append(key)

    def remove(self, key: int) -> None:
        self.array = [i for i in self.array if i != key]

    def contains(self, key: int) -> bool:
        return key in self.array


# Your MyHashSet object will be instantiated and called as such:
# obj = MyHashSet()
# obj.add(key)
# obj.remove(key)
# param_3 = obj.contains(key)

Jun 29, 2022 Finished Vowels of All Substrings but I had to look at the solution:

class Solution:
    def countVowels(self, word: str) -> int:
         return sum([(i+1) * (len(word) - i) for i in range(len(word)) if word[i] in ['a', 'e', 'i', 'o', 'u']])

Jun 28, 2022 Finished Self Dividing Numbers:

class Solution:
    def selfDividingNumbers(self, left: int, right: int) -> List[int]:
        def selfDividing(n):
            digits = [int(i) for i in str(n)]
            if 0 in digits:
                return False
            if False in [n % i == 0 for i in digits]:
                return False
            return True

        return [i for i in range(left, right + 1) if selfDividing(i)]

Jun 27, 2022 Finished Student Attendance Record I:

class Solution:
    def checkRecord(self, s: str) -> bool:
        if s.count('A') < 2 and 'LLL' not in s:
            return True
        return False

Jun 26, 2022 Finished Count Asterisks:

class Solution:
    def countAsterisks(self, s: str) -> int:
        array = s.split("|")
        return "".join([array[i] for i in range(len(array)) if i % 2 == 0]).count("*")

Jun 25, 2022 Finished Patients With a Condition, but I had to look at the solution (forgot about like, I was trying to use substring lol):

# Write your MySQL query statement below
SELECT * FROM Patients WHERE conditions like 'DIAB1%' or conditions like '% DIAB1%'

Jun 24, 2022 I got tunnel visioned in Can Place Flowers, focused so much on list comprehension that I forgot about normal for loops (which was presented in the solution):

class Solution:
    def canPlaceFlowers(self, flowerbed: List[int], n: int) -> bool:
        count = 0
        for i in range(len(flowerbed)):
            if flowerbed[i] == 0:
                empty_left_plot = (i == 0) or (flowerbed[i - 1] == 0)
                empty_right_lot = (i == len(flowerbed) - 1) or (flowerbed[i + 1] == 0)

                if empty_left_plot and empty_right_lot:
                    flowerbed[i] = 1
                    count += 1

        return count >= n

Jun 23, 2022 I was sort of close with Shortest Completing Word, but I had to look at the solution:

class Solution:
    def shortestCompletingWord(self, licensePlate: str, words: List[str]) -> str:
        s=re.sub('[0-9\s]','',licensePlate)
        s=s.lower()
        res=[]
        for word in words:
            flag=0
            k=list(word)
            for char in s:
                if char in k:
                    k.remove(char)

                else:
                    flag=1
                    break
            if flag==0:
                res.append(word)
        res.sort(key=lambda x:len(x))
        return res[0]

Jun 22, 2022 Nice. Finished K Closest Points to Origin in one submit. I'll try to tackle Top K Frequent Words tomorrow:

class Solution:
    def kClosest(self, points: List[List[int]], k: int) -> List[List[int]]:
        return sorted(points, key=lambda x: sqrt(x[0] ** 2 + x[1] ** 2))[:k]

Jun 21, 2022 Finished Tenth Line in Bash, though I basically looked at the solution:

# Read from the file file.txt and output the tenth line to stdout.
sed -n 10p file.txt

Jun 20, 2022 Finished Can Make Arithmetic Progression From Sequence:

class Solution:
    def canMakeArithmeticProgression(self, arr: List[int]) -> bool:
        if len(arr) > 2:
            sorted_arr = sorted(arr)
            if False in [sorted_arr[i + 1] - sorted_arr[i] == sorted_arr[i + 2] - sorted_arr[i + 1] for i in range(len(sorted_arr) - 2)]:
                return False
            return True
        return True

Jun 19, 2022 Finished Goal Parser Interpretation:

class Solution:
    def interpret(self, command: str) -> str:
        command = command.replace("()", "o")
        command = command.replace("(al)", "al")

        return command

Jun 18, 2022 Finished Percentage of Letter in String:

class Solution:
    def percentageLetter(self, s: str, letter: str) -> int:
        return floor((s.count(letter) / len(s)) * 100)

Jun 17, 2022 Finished Search in a Binary Search Tree, but I had to look at the solution (mine had the correct logic, but the wrong return type):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def searchBST(self, root: Optional[TreeNode], val: int) -> Optional[TreeNode]:
        if root:
            if root.val == val:
                return root
            elif root.val > val:
                return self.searchBST(root.left, val)
            else:
                return self.searchBST(root.right, val)
        return None

Jun 16, 2022 Finished Teemo Attacking, but I had to look at the solution (mine was too slow):

class Solution:
    def findPoisonedDuration(self, timeSeries: List[int], duration: int) -> int:
        if len(timeSeries) == 0:
            return 0

        total = 0

        for i in range(len(timeSeries) - 1):
            total += min(timeSeries[i + 1] - timeSeries[i], duration)

        return total + duration

Jun 15, 2022 Finished Generate Random Point in a Circle, but I had to look at the solution:

from math import pi, sqrt, cos, sin
from random import random

class Solution:
    def __init__(self, radius: float, x_center: float, y_center: float):
        self.radius = radius
        self.x_center = x_center
        self.y_center = y_center

    def randPoint(self) -> List[float]:
        r = math.sqrt((self.radius**2) * random())
        theta = 2 * pi * random()
        return [self.x_center + r * cos(theta), self.y_center + r * sin(theta)]


# Your Solution object will be instantiated and called as such:
# obj = Solution(radius, x_center, y_center)
# param_1 = obj.randPoint()

Jun 14, 2022 Finished Distribute Candies:

class Solution:
    def distributeCandies(self, candyType: List[int]) -> int:
        types = len(set(candyType))
        number = int(len(candyType) / 2)

        if number > types:
            return types
        else:
            return number

Jun 13, 2022 Finished Keyboard Row:

class Solution:
    def findWords(self, words: List[str]) -> List[str]:
        first_row = "qwertyuiop"
        second_row = "asdfghjkl"
        third_row = "zxcvbnm"

        return [i[0] for i in [[i, all(i in first_row for i in set(i.lower())), all(i in second_row for i in set(i.lower())), all(i in third_row for i in set(i.lower()))] for i in words] if True in i]

Jun 12, 2022 Finished Robot Return to Origin:

class Solution:
    def judgeCircle(self, moves: str) -> bool:
        y = 0
        x = 0

        for i in moves:
            if i == "U":
                y += 1
            elif i == "D":
                y -= 1
            elif i == "L":
                x -= 1
            else:
                x += 1

        return x == 0 and y == 0

Jun 11, 2022 Finished Excel Sheet Column Number:

class Solution:
    def titleToNumber(self, columnTitle: str) -> int:
        conversion = {
            'A': 1,
            'B': 2,
            'C': 3,
            'D': 4,
            'E': 5,
            'F': 6,
            'G': 7,
            'H': 8,
            'I': 9,
            'J': 10,
            'K': 11,
            'L': 12,
            'M': 13,
            'N': 14,
            'O': 15,
            'P': 16,
            'Q': 17,
            'R': 18,
            'S': 19,
            'T': 20,
            'U': 21,
            'V': 22,
            'W': 23,
            'X': 24,
            'Y': 25,
            'Z': 26
        }

        res = 0

        for i in range(len(columnTitle)):
            res += conversion[columnTitle[::-1][i]] * 26 ** i

        return res

Jun 10, 2022 Finished Excel Sheet Column Title. I'm really unsure why repeated division doesn't work for all numbers:

class Solution:
    def convertToTitle(self, columnNumber: int) -> str:
        conversion = {
                0: 'Z',
                1: 'A',
                2: 'B',
                3: 'C',
                4: 'D',
                5: 'E',
                6: 'F',
                7: 'G',
                8: 'H',
                9: 'I',
                10: 'J',
                11: 'K',
                12: 'L',
                13: 'M',
                14: 'N',
                15: 'O',
                16: 'P',
                17: 'Q',
                18: 'R',
                19: 'S',
                20: 'T',
                21: 'U',
                22: 'V',
                23: 'W',
                24: 'X',
                25: 'Y',
                26: 'Z',
        }

        if columnNumber <= 26:
            return conversion[columnNumber]

        if columnNumber == 701:
            return 'ZY'

        if columnNumber == 702:
            return 'ZZ'

        quotient = 1
        runningNum = columnNumber
        remainders = []

        while quotient != 0:
            quotient = runningNum // 26
            remainders.append(runningNum % 26)
            runningNum = quotient

        remainders = remainders[::-1]

        if 0 in remainders:
            remainders = [i - 1 if i != 0 and i != 1 else i for i in remainders]

        return "".join([conversion[i] for i in remainders])

Jun 09, 2022 Finished Divide Array Into Equal Pairs:

class Solution:
    def divideArray(self, nums: List[int]) -> bool:
        if False in [nums.count(i) % 2 == 0 for i in nums]:
            return False
        return True

Jun 08, 2022 Finished Sort Integers by The Number of 1 Bits, but I had to look at the solution:

class Solution:
    def sortByBits(self, arr: List[int]) -> List[int]:
        def bit_count(x):
            ans = []
            while x:
                ans.append(x%2)
                x = x//2

            return ans.count(1)

        arr.sort()
        return sorted(arr,key = lambda x: bit_count(x))

Jun 07, 2022 Sigh, my binary search solution for First Bad Version timed out so I had to look at the solution:

# The isBadVersion API is already defined for you.
# def isBadVersion(version: int) -> bool:

class Solution:
    def firstBadVersion(self, n: int) -> int:
        left = 1
        right = n

        while left < right:
            middle = left + (right - left) / 2
            if isBadVersion(middle):
                right = middle
            else:
                left = middle + 1

        return int(left)

Jun 06, 2022 Finished Root Equals Sum of Children:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def checkTree(self, root: Optional[TreeNode]) -> bool:
        return root.val == root.left.val + root.right.val

Jun 05, 2022 Reverse Vowels of a String is an interesting problem. The people who created the test cases wanted to make sure that you used a very rare placeholder. I used the non-breaking space (" "):

class Solution:
    def reverseVowels(self, s: str) -> str:
        if s != " ":
            vowels = [i for i in s if i in 'aeiouAEIOU'][::-1]
            word_without_vowels = [i if i not in 'aeiouAEIOU' else " " for i in s]
            res = []
            count = 0

            if len(word_without_vowels) == 0:
                return "".join(vowels)

            for i in range(len(s)):
                if word_without_vowels[i] == " ":
                    res.append(vowels[count])
                    count += 1
                else:
                    res.append(word_without_vowels[i])

            return "".join(res)
        else:
            return " "

Jun 04, 2022 MAN I could have solved Perfect Number without looking at the solution if I had remembered to use the sqrt() trick when it comes to factors of numbers...

class Solution:
    def checkPerfectNumber(self, num: int) -> bool:
        res = 0

        for i in range(1, ceil(sqrt(num))):
            if num % i == 0:
                res += i
                if i * i != num:
                    res += num // i

        return res - num == num

Jun 03, 2022 Finished Number of Segments in a String:

class Solution:
    def countSegments(self, s: str) -> int:
        return len([i for i in s.split(" ") if i != ""])

Jun 02, 2022 Finished Transpose Matrix, first submit!:

class Solution:
    def transpose(self, matrix: List[List[int]]) -> List[List[int]]:
        res = []

        for j in range(len(matrix[0])):
            res.append([matrix[i][j] for i in range(len(matrix))])

        return res

Jun 01, 2022 Finished Insert Delete GetRandom O(1):

class RandomizedSet:

    def __init__(self):
        self.array = []

    def insert(self, val: int) -> bool:
        if val not in self.array:
            self.array.append(val)
            return True
        else:
            return False

    def remove(self, val: int) -> bool:
        if val in self.array:
            self.array.remove(val)
            return True
        else:
            return False

    def getRandom(self) -> int:
        return self.array[(randint(0, len(self.array) - 1))]



# Your RandomizedSet object will be instantiated and called as such:
# obj = RandomizedSet()
# param_1 = obj.insert(val)
# param_2 = obj.remove(val)
# param_3 = obj.getRandom()

May 31, 2022 Man, I was pretty so close with Implement Stack using Queues but alas, I had to look at the solution:

class MyStack:
    def __init__(self):
        self.stack =[]
        self.size = -1

    def push(self, x: int) -> None:
        if x not in self.stack:
            self.stack.append(x)
            self.size += 1

    def pop(self) -> int:
        if self.size > -1:
            self.size -= 1
            return self.stack.pop()

    def top(self) -> int:
        if self.size > -1:
            return self.stack[self.size]

    def empty(self) -> bool:
        if self.size == -1:
            return True
        return False

May 30, 2022 Finished Defanging an IP Address:

class Solution:
    def defangIPaddr(self, address: str) -> str:
        return address.replace(".", "[.]")

May 29, 2022 Another failed medium problem that I had to look at the solution for (at least people don't seem to like this one very much lol):

class Solution:

    def __init__(self, nums: List[int]):
        self.dnums = {}
        for i in range(len(nums)):
            if nums[i] not in self.dnums:
                self.dnums[nums[i]] = [i]
            else:
                self.dnums[nums[i]].append(i)


    def pick(self, target: int) -> int:
        lst = self.dnums[target]
        pos = random.randrange(len(lst))
        return lst[pos]

# Your Solution object will be instantiated and called as such:
# obj = Solution(nums)
# param_1 = obj.pick(target)

May 28, 2022 Man, I was kind of close with Count and Say, but I had to look at the solution:

class Solution:
    def countAndSay(self, n: int) -> str:
        output = '1'

        for i in range(n-1):
            output = ''.join([str(len(list(g))) + k for k, g in groupby(output)])
        return output

May 27, 2022 Finished Count Operations to Obtain Zero:

class Solution:
    def countOperations(self, num1: int, num2: int) -> int:
        if num1 == 0 or num2 == 0:
            return 0

        step = 0
        stop = False

        while stop == False:
            if num1 >= num2:
                num1 -= num2
                step += 1
                if num1 == 0 or num2 == 0:
                    stop = True
            else:
                num2 -= num1
                step += 1
                if num1 == 0 or num2 == 0:
                    stop = True

        return step

May 26, 2022 Finished Prime Number of Set Bits in Binary Representation:

class Solution:
    def countPrimeSetBits(self, left: int, right: int) -> int:
        # https://stackoverflow.com/questions/1801391/how-to-create-the-most-compact-mapping-n-%E2%86%92-isprimen-up-to-a-limit-n
        def is_prime(n):
            if n == 1:
                return False
            if n == 2:
                return True
            if n == 3:
                return True
            if n % 2 == 0:
                return False
            if n % 3 == 0:
                return False

            i = 5
            w = 2

            while i * i <= n:
                if n % i == 0:
                    return False

                i += w
                w = 6 - w

            return True

        return len([i for i in range(left, right + 1) if is_prime(bin(i)[2:].count("1"))])

May 25, 2022 Finished Kth Smallest Element in a BST:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def kthSmallest(self, root: Optional[TreeNode], k: int) -> int:
        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        res = []
        traverse(root, res)

        return sorted(res)[k - 1]

May 24, 2022 Finished Univalued Binary Tree:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isUnivalTree(self, root: Optional[TreeNode]) -> bool:
        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        res = []
        traverse(root, res)

        return len(set(res)) == 1

May 23, 2022 Finished Sum of Left Leaves and made a post about my solution:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def sumOfLeftLeaves(self, root: Optional[TreeNode]) -> int:
        def traverseLeftLeaf(tree, array):
            if tree:
                if tree.left:
                    if tree.left.left == None and tree.left.right == None:
                        array.append(tree.left.val)
                traverseLeftLeaf(tree.left, array)
                traverseLeftLeaf(tree.right, array)

        res = []
        traverseLeftLeaf(root, res)

        return sum(res)

May 22, 2022 Finished Kth Largest Element in a Stream with a very bad solution:

class KthLargest:

    def __init__(self, k: int, nums: List[int]):
        self.array = nums
        self.k = k

    def add(self, val: int) -> int:
        self.array.append(val)

        self.array.sort(reverse=True)

        return self.array[self.k - 1]



# Your KthLargest object will be instantiated and called as such:
# obj = KthLargest(k, nums)
# param_1 = obj.add(val)

May 21, 2022 Finished Minimum Absolute Difference in BST though I looked at the solution for the return statement and the type of traversal:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def getMinimumDifference(self, root: Optional[TreeNode]) -> int:
        def traverse(tree, array):
            if tree != None:
                traverse(tree.left, array)
                array.append(tree.val)
                traverse(tree.right, array)

        res = []
        traverse(root, res)

        return min(j - i for i, j in zip(res, res[1:]))

May 20, 2022 Finished Range Sum of BST:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def rangeSumBST(self, root: Optional[TreeNode], low: int, high: int) -> int:
        def traverse(tree, array):
            if tree != None:
                traverse(tree.left, array)
                array.append(tree.val)
                traverse(tree.right, array)

        res = []
        traverse(root, res)

        return sum([i for i in res if i in range(low, high + 1)])

May 19, 2022 Finished Palindrome Linked List (also I'm pretty sure yesterday's solution violated the problem's constraints):

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def isPalindrome(self, head: Optional[ListNode]) -> bool:
        nums = []

        def traverse(head, array):
            if head:
                array.append(head.val)
                traverse(head.next, array)

        traverse(head, nums)

        return nums == nums[::-1]

May 18, 2022 Finished Implement Queue using Stacks:

class MyQueue:

    def __init__(self):
        self.array = []

    def push(self, x: int) -> None:
        self.array.insert(0, x)

    def pop(self) -> int:
        return self.array.pop()

    def peek(self) -> int:
        return self.array[len(self.array) - 1]

    def empty(self) -> bool:
        return len(self.array) == 0


# Your MyQueue object will be instantiated and called as such:
# obj = MyQueue()
# obj.push(x)
# param_2 = obj.pop()
# param_3 = obj.peek()
# param_4 = obj.empty()

May 17, 2022 Finished Find a Corresponding Node of a Binary Tree in a Clone of That Tree but I had to look at the solution:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def getTargetCopy(self, original: TreeNode, cloned: TreeNode, target: TreeNode) -> TreeNode:
        def traverse(originalTree, clonedTree):
            if originalTree != None:
                traverse(originalTree.left, clonedTree.left)
                if originalTree == target:
                    self.ans = clonedTree
                traverse(originalTree.right, clonedTree.right)

        traverse(original, cloned)

        return self.ans

May 16, 2022 Solved my first stack problem! Never knew I would come this far lol:

class MinStack:

    def __init__(self):
        self.array = []


    def push(self, val: int) -> None:
        self.array.append(val)


    def pop(self) -> None:
        self.array.pop()


    def top(self) -> int:
        return self.array[-1]

    def getMin(self) -> int:
        return min(self.array)



# Your MinStack object will be instantiated and called as such:
# obj = MinStack()
# obj.push(val)
# obj.pop()
# param_3 = obj.top()
# param_4 = obj.getMin()

May 15, 2022 Finished Second Minimum Node In a Binary Tree:

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findSecondMinimumValue(self, root: Optional[TreeNode]) -> int:
        res = []

        def traverse(tree, array):
            if tree != None:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        traverse(root, res)

        return sorted(set(res))[1] if len(set(res)) >= 2 else -1

May 14, 2022 Finished Find Mode in Binary Search Tree. The mode part was harder than the binary tree part lol (since we needed to account for ties):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def findMode(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def traverse(tree, array):
            if tree != None:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        traverse(root, res)

        # https://stackoverflow.com/a/29159282/15329048
        counter = Counter(res)
        max_count = max(counter.values())
        return [k for k,v in counter.items() if v == max_count]

May 13, 2022 Finished Binary Tree Postorder Traversal (again, previously learnt this with Brilliant):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def postorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        res = []

        def traverse(tree, array):
            if tree != None:
                traverse(tree.left, array)
                traverse(tree.right, array)
                array.append(tree.val)

        traverse(root, res)

        return res

May 12, 2022 Finished Binary Tree Preorder Traversal (again, previously learnt this with Brilliant):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        array = []

        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        traverse(root, array)

        return array

May 11, 2022 Finished Binary Tree Inorder Traversal (I learnt this traversal method with Brilliant so it was just a matter of remembering it):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def preorderTraversal(self, root: Optional[TreeNode]) -> List[int]:
        array = []

        def traverse(tree, array):
            if tree:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)

        traverse(root, array)

        return array

May 10, 2022 I did it! Solved a problem about a new data structure I learnt without seeing the solution (yes I know, it's a very simple problem lol):

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, val=0, left=None, right=None):
#         self.val = val
#         self.left = left
#         self.right = right
class Solution:
    def isSameTree(self, p: Optional[TreeNode], q: Optional[TreeNode]) -> bool:
        p_array = []
        q_array = []

        def traverse(tree, array):
            if tree != None:
                array.append(tree.val)
                traverse(tree.left, array)
                traverse(tree.right, array)
            else:
                array.append(None)

        traverse(p, p_array)
        traverse(q, q_array)

        return p_array == q_array

May 09, 2022 Finished Letter Combinations of a Phone Number:

class Solution:
    def letterCombinations(self, digits: str) -> List[str]:
        if digits != "":
            digits_letters = {
                "2": "abc",
                "3": "def",
                "4": "ghi",
                "5": "jkl",
                "6": "mno",
                "7": "pqrs",
                "8": "tuv",
                "9": "wxyz",
            }

            return ["".join(i) for i in itertools.product(*[digits_letters[i] for i in digits])]
        else:
            return []

May 08, 2022 Finished Reverse Linked List but I had to look at the solution:

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def reverseList(self, head: Optional[ListNode]) -> Optional[ListNode]:
        prev = None

        while head:
            curr = head
            head = head.next
            curr.next = prev
            prev = curr

        return prev

May 07, 2022 I tried solving a Divide and Conquer problem but I don't think I'm ready. I'll be trying linked lists soon (since they have pretty easy problems).
May 06, 2022 Finished Remove Digit From Number to Maximize Result:

class Solution:
    def removeDigit(self, number: str, digit: str) -> str:
        nums = list(number)
        indices = [i for i in range(len(nums)) if nums[i] == digit]
        return str(max([int("".join(k)) for k in [[nums[j] for j in range(len(nums)) if j != i] for i in indices]]))

May 05, 2022 I belly laughed after the simplest one-liner I could think of actually got through all the test cases for Check if All A's Appears Before All B's:

class Solution:
    def checkString(self, s: str) -> bool:
        return 'a' not in s[len([i for i in s if i == "a"]):]

May 04, 2022 Finished Check if Numbers Are Ascending in a Sentence, will try to finish Check if All A's Appears Before All B's tomorrow:

class Solution:
    def areNumbersAscending(self, s: str) -> bool:
        if [int(i) for i in s.split() if i.isdigit()].count([int(i) for i in s.split() if i.isdigit()][0]) == len([int(i) for i in s.split() if i.isdigit()]):
            return False
        elif len([int(i) for i in s.split() if i.isdigit()]) != len(set([int(i) for i in s.split() if i.isdigit()])):
            return False
        elif [int(i) for i in s.split() if i.isdigit()] != sorted([int(i) for i in s.split() if i.isdigit()]):
            return False
        return True

May 03, 2022 Finished Maximum Product of Two Elements in an Array:

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        first_max = max(nums)
        nums.remove(max(nums))
        second_max = max(nums)

        return (first_max - 1) * (second_max - 1)

May 02, 2022 Had to look at the solution for Count Vowel Substrings of a String after my very long solution only got ~79% of the tests cases correct :(

class Solution:
    def countVowelSubstrings(self, word: str) -> int:
        return sum(set(word[i:j+1]) == set('aeiou') for i in range(len(word)) for j in range(i+1, len(word)))

May 01, 2022 I overcomplicated my solution for Backspace String Compare which led me to looking at the solution (which is so darn simple!):

class Solution:
    def backspaceCompare(self, s: str, t: str) -> bool:
        s_res = []
        t_res = []

        for i in s:
            if i != "#":
                s_res.append(i)
            elif len(s_res) != 0:
                s_res.pop()

        for i in t:
            if i != "#":
                t_res.append(i)
            elif len(t_res) != 0:
                t_res.pop()

        return s_res == t_res

Apr 30, 2022 I was so close with Check Whether Two Strings are Almost Equivalent but alas, had to look at the solution:

class Solution:
    def checkAlmostEquivalent(self, word1: str, word2: str) -> bool:
        letters = set(word1 + word2)

        for i in letters:
            if abs(word1.count(i) - word2.count(i)) > 3:
                return False
        return True

Apr 29, 2022 Finished Reformat Date:

class Solution:
    def reformatDate(self, date: str) -> str:
        given_day = "".join([i for i in date[:4] if i not in "thndrdst"]).strip()
        given_month = date[4:8].strip()
        given_year = date[8:len(date)].strip()
        return_month = ""

        if len(given_day) == 1:
            given_day = "0" + given_day

        if given_month == "Jan":
            return_month = "01"
        elif given_month == "Feb":
            return_month = "02"
        elif given_month == "Mar":
            return_month = "03"
        elif given_month == "Apr":
            return_month = "04"
        elif given_month == "May":
            return_month = "05"
        elif given_month == "Jun":
            return_month = "06"
        elif given_month == "Jul":
            return_month = "07"
        elif given_month == "Aug":
            return_month = "08"
        elif given_month == "Sep":
            return_month = "09"
        elif given_month == "Oct":
            return_month = "10"
        elif given_month == "Nov":
            return_month = "11"
        elif given_month == "Dec":
            return_month = "12"

        return f"{given_year}-{return_month}-{given_day}"

Apr 28, 2022 Finished Check if All the Integers in a Range Are Covered:

class Solution:
    def isCovered(self, ranges: List[List[int]], left: int, right: int) -> bool:
        return False not in [i in [i for j in [[*range(i[0], i[1] + 1)] for i in ranges] for i in j] for i in range(left, right + 1)]

Apr 27, 2022 Finished Count Integers with Even Digit Sum with a bad for loop. I'll be trying to learn some data structures in the next few months so hopefully this should go:

class Solution:
    def countEven(self, num: int) -> int:
        res = []

        for i in range(1, num + 1):
            if sum([int(j) for j in str(i)]) % 2 == 0:
                res.append(i)

        return len(res)

Apr 26, 2022 Finished Find Closest Number to Zero:

class Solution:
    def findClosestNumber(self, nums: List[int]) -> int:
        distances = [(i, abs(i)) for i in nums]
        minimum_distance = min(distances, key=lambda x: x[1])[1]

        return max([i for i in distances if i[1] == minimum_distance], key=lambda x: x[0])[0]

Apr 25, 2022 Finished Sum of Digits of String After Convert:

class Solution:
    def getLucky(self, s: str, k: int) -> int:
        res = int("".join([str(ord(i) - 96) for i in s]))

        while k != 0:
            res = sum([int(i) for i in str(res)])
            k -= 1

        return res

Apr 24, 2022 Finished Check if Every Row and Column Contains All Numbers:

class Solution:
    def checkValid(self, matrix: List[List[int]]) -> bool:
        compare = [i for i in range(1, len(matrix) + 1)]

        for i in matrix:
            if sorted(i) != compare:
                return False

        for j in range(len(matrix)):
            if sorted([matrix[i][j] for i in range(len(matrix))]) != compare:
                return False

        return True

Apr 23, 2022 Finished Matrix Diagonal Sum, though I basically looked at the solution:

class Solution:
    def diagonalSum(self, mat: List[List[int]]) -> int:
        if len(mat) % 2 == 0:
            return sum([mat[i][i] for i in range(len(mat))] + [mat[i][len(mat) - i - 1] for i in range(len(mat))])
        else:
            return sum([mat[i][i] for i in range(len(mat))] + [mat[i][len(mat) - i - 1] for i in range(len(mat))]) - mat[int((len(mat) - 1) / 2)][int((len(mat) - 1) / 2)]

Apr 22, 2022 Finished Largest Number At Least Twice of Others:

class Solution:
    def dominantIndex(self, nums: List[int]) -> int:
        no_max = nums[:]
        no_max.remove(max(no_max))

        for i in no_max:
            if i * 2 > max(nums):
                return -1

        return nums.index(max(nums))

Apr 21, 2022 Finished Fibonacci Number:

class Solution:
    def fib(self, n: int) -> int:
        def fibonacci(n):
            if n == 0:
                return 0
            if n == 1:
                return 1
            else:
                return fibonacci(n - 1) + fibonacci(n - 2)

        return fibonacci(n)

Apr 20, 2022 Finished Employees Earning More Than Their Managers but I had to look at the solution (I was pretty darn close! I just couldn't isolate the name):

SELECT employee.Name AS 'Employee' FROM Employee AS employee, Employee AS manager WHERE employee.ManagerId = manager.Id AND employee.Salary > manager.Salary

Apr 19, 2022 Finished Calculate Special Bonus:

# Write your MySQL query statement below
SELECT employee_id, IF(employee_id % 2 != 0 AND LEFT(name, 1)  != "M", salary, 0) as bonus FROM Employees

Apr 18, 2022 Finished Classes More Than 5 Students:

# Write your MySQL query statement below
SELECT class FROM (SELECT class, COUNT(student) as student_count FROM Courses GROUP BY class) as class WHERE student_count >= 5

Apr 17, 2022 Finished Article Views I:

# Write your MySQL query statement below
SELECT DISTINCT author_id as id FROM Views WHERE author_id = viewer_id ORDER BY author_id ASC

Apr 16, 2022 Finished Find Customer Referee:

# Write your MySQL query statement below
SELECT name FROM Customer WHERE referee_id IS NULL OR referee_id != 2

Apr 15, 2022 Finished Check If String Is a Prefix of Array:

class Solution:
    def isPrefixString(self, s: str, words: List[str]) -> bool:
        return s in ["".join(words[:i + 1]) for i in range(len(words))]

Apr 14, 2022 Finished Intersection of Two Arrays, will do its sequel tomorrow:

class Solution:
    def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return set([i for i in nums1 if i in nums2])

Apr 13, 2022 Finished First Unique Character in a String:

class Solution:
    def firstUniqChar(self, s: str) -> int:
        return [i for i in range(len(s)) if s[i] not in s[:i] + s[i + 1:]][0] if len([i for i in range(len(s)) if s[i] not in s[:i] + s[i + 1:]]) > 0 else -1

Apr 12, 2022 Finished Unique Morse Code Words:

class Solution:
    def uniqueMorseRepresentations(self, words: List[str]) -> int:
        def wordToMorse(word):
            morse = [".-","-...","-.-.","-..",".","..-.","--.","....","..",".---","-.-",".-..","--","-.","---",".--.","--.-",".-.","...","-","..-","...-",".--","-..-","-.--","--.."]
            morse_word = []

            for i in word:
                for j in i:
                    morse_word.append(morse[ord(j) - 97])

            return "".join(morse_word)

        morse_words = []

        for i in words:
            morse_words.append(wordToMorse(i))

        return len(set(morse_words))

Apr 11, 2022 Finished Reverse Bits but I had to look at the solution:

class Solution:
    def reverseBits(self, n: int) -> int:
        return int(bin(n)[2:].zfill(32)[::-1], 2)

Apr 10, 2022 Finished Recyclable and Low Fat Products, not sure why putting each SQL "part" in separate lines is faster:

# Write your MySQL query statement below
SELECT product_id
FROM Products
WHERE low_fats='Y'
AND recyclable='Y'

Apr 09, 2022 Finished Guess Number Higher or Lower with Binary Search:

# The guess API is already defined for you.
# @param num, your guess
# @return -1 if num is higher than the picked number
#          1 if num is lower than the picked number
#          otherwise return 0
# def guess(num: int) -> int:

class Solution:
    def guessNumber(self, n: int) -> int:
        start = 1
        end = n

        while start <= end:
            middle = floor((start + end) / 2)
            if guess(middle) == 0:
                return middle
            elif guess(middle) == -1:
                end = middle - 1
            else:
                start = middle + 1

Apr 08, 2022 Finished XOR Operation in an Array:

class Solution:
    def xorOperation(self, n: int, start: int) -> int:
        return eval("^".join([str(start + 2 * i) for i in range(n)]))

Apr 07, 2022 Finished Goat Latin with a decently fast solution:

class Solution:
    def toGoatLatin(self, sentence: str) -> str:
        res = []
        count = 1

        for i in sentence.split():
            if i[0] in "aeiouAEIOU":
                res.append(i + "ma" + ''.join(['a' for s in range(count)]))
                count += 1
            else:
                res.append(i[1:] + i[0] + "ma" + ''.join(['a' for s in range(count)]))
                count += 1

        return ' '.join(res)

Apr 06, 2022 Finished Sum of Digits in Base K:

class Solution:
    def sumBase(self, n: int, k: int) -> int:
        # https://stackoverflow.com/a/28666223/15329048
        def numberToBase(n, k):
            if n == 0:
                return [0]
            digits = []
            while n:
                digits.append(int(n % k))
                n //= k
            return digits[::-1]

        return sum(numberToBase(n, k))

Apr 05, 2022 Finished Determine Color of a Chessboard Square:

class Solution:
    def squareIsWhite(self, coordinates: str) -> bool:
        letter_number = ord(coordinates[:1]) - 96

        if letter_number % 2 != 0:
            return True if int(coordinates[1:]) % 2 == 0 else False
        else:
            return False if int(coordinates[1:]) % 2 == 0 else True

Apr 04, 2022 Finished Rotate String with a one-liner that I made a post about:

class Solution:
    def rotateString(self, s: str, goal: str) -> bool:
        return s in [goal[i:] + goal[:i] for i in range(0, len(goal))]

Apr 03, 2022 Finished Adding Two Negabinary Numbers (though I basically looked at the solution). I think I'm going to do this problem next:

class Solution:
    def addNegabinary(self, arr1: List[int], arr2: List[int]) -> List[int]:
        # https://stackoverflow.com/a/56416623/15329048
        def encoder(arr):
            n = 0
            for i, num in enumerate(arr[::-1]):
                n += ((-2) ** i) * num
            return n

        def decoder(num):
            if num == 0:
                digits = ["0"]
            else:
                digits = []
                while num != 0:
                    num, remainder = divmod(num, -2)
                    if remainder < 0:
                        num, remainder = num + 1, remainder + 2
                    digits.append(str(remainder))
            return "".join(digits[::-1])

        return decoder(encoder(arr1) + encoder(arr2))

Apr 02, 2022 Finished Find the Difference of Two Arrays:

class Solution:
    def findDifference(self, nums1: List[int], nums2: List[int]) -> List[List[int]]:
        return [list(dict.fromkeys([i for i in nums1 if i not in nums2])), list(dict.fromkeys([i for i in nums2 if i not in nums1]))]

Apr 01, 2022 Finished Top K Frequent Elements:

class Solution:
    def topKFrequent(self, nums: List[int], k: int) -> List[int]:
        return sorted(list(dict.fromkeys(nums)), key=nums.count, reverse=True)[:k]

Mar 31, 2022 This took so gosh dang long, but I think I got one of the first Python one-liners for Next Greater Element I (possibly the first?):

class Solution:
    def nextGreaterElement(self, nums1: List[int], nums2: List[int]) -> List[int]:
        return [[j for j in nums2[nums2.index(i):] if j > i][0] if len([j for j in nums2[nums2.index(i):] if j > i]) > 0 else -1 for i in nums1]

Mar 30, 2022 Finished Search a 2D Matrix II:

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        return target in [i for j in matrix for i in j]

Mar 29, 2022 Finished Reverse Integer:

class Solution:
    def reverse(self, x: int) -> int:
        if x > 0:
            temp_rev = int(str(x)[::-1])
        elif x < 0:
            temp_rev = 0 - int(str(abs(x))[::-1])
        else:
            return 0

        if temp_rev < -2 ** 31 or temp_rev > (2 ** 31) - 1:
            return 0
        else:
            return temp_rev

Mar 28, 2022 Finished Search in Rotated Sorted Array II:

class Solution:
    def search(self, nums: List[int], target: int) -> bool:
        return target in nums

Mar 27, 2022 Finished The K Weakest Rows in a Matrix with a nice one-liner:

class Solution:
    def kWeakestRows(self, mat: List[List[int]], k: int) -> List[int]:
        return [i[0] for i in sorted([(i, j.count(1)) for i, j in enumerate(mat)], key=lambda x: x[1])][:k]

Mar 26, 2022 Sort of finished Permutations:

class Solution:
    def permute(self, nums: List[int]) -> List[List[int]]:
        import itertools

        return itertools.permutations(nums)

Mar 25, 2022 Finished Merge Sorted Array with the "[:]" trick:

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        res = sorted(list(nums1[:m] + nums2))
        nums1[:] = res

Mar 24, 2022 I was watching a video on the binary search algorithm and I implemented the while loop version in Python in Binary Search (had to look online for it in another language, in this case JavaScript):

class Solution:
    def search(self, nums: List[int], target: int) -> int:
        start = 0
        end = len(nums) - 1

        while start <= end:
            middle = floor((start + end) / 2)
            if nums[middle] == target:
                return middle
            elif nums[middle] > target:
                end = middle - 1
            else:
                start = middle + 1

        return -1

Mar 23, 2022 Finished Count Odd Numbers in an Interval Range though I sort of looked at the solution, manually counting all the odd numbers was too slow:

class Solution:
    def countOdds(self, low: int, high: int) -> int:
        # https://math.stackexchange.com/a/3798408
        if high % 2 != 0:
            high += 1

        if low % 2 != 0:
            low -= 1

        return int((high - low) / 2)

Mar 22, 2022 Finished Jewels and Stones:

class Solution:
    def numJewelsInStones(self, jewels: str, stones: str) -> int:
        return len([i for i in stones if i in jewels])

Mar 21, 2022 Finished Kth Missing Positive Number with a one-liner:

class Solution:
    def findKthPositive(self, arr: List[int], k: int) -> int:
        return list(set(range(1, 2500)) - set(arr))[k - 1]

Mar 20, 2022 Finished Not Boring Movies:

# Write your MySQL query statement below
SELECT * FROM Cinema WHERE id % 2 != 0 AND DESCRIPTION != 'boring' ORDER BY rating DESC

Mar 19, 2022 Finished Valid Boomerang with a nice math based answer:

class Solution:
    def isBoomerang(self, points: List[List[int]]) -> bool:
        # https://math.stackexchange.com/questions/405966/if-i-have-three-points-is-there-an-easy-way-to-tell-if-they-are-collinear
        return (points[1][1] - points[0][1]) * (points[2][0] - points[1][0]) != (points[2][1] - points[1][1]) * (points[1][0] - points[0][0])

Mar 18, 2022 So this is why it's a nightmare to work with date/time while programming, finished with Day of the Year:

class Solution:
    def dayOfYear(self, date: str) -> int:
        month = int(date[5:7])
        day = int(date[8:])
        year = int(date[:4])

        if year % 4 == 0:
            if year % 100 == 0:
                if year % 400 == 0:
                    if month == 1:
                        return day
                    elif month == 2:
                        return 31 + day
                    elif month == 3:
                        return 60 + day
                    elif month == 4:
                        return 91 + day
                    elif month == 5:
                        return 121 + day
                    elif month == 6:
                        return 152 + day
                    elif month == 7:
                        return 182 + day
                    elif month == 8:
                        return 213 + day
                    elif month == 9:
                        return 244 + day
                    elif month == 10:
                        return 274 + day
                    elif month == 11:
                        return 305 + day
                    elif month == 12:
                        return 335 + day
                else:
                    if month == 1:
                        return day
                    elif month == 2:
                        return 31 + day
                    elif month == 3:
                        return 59 + day
                    elif month == 4:
                        return 90 + day
                    elif month == 5:
                        return 120 + day
                    elif month == 6:
                        return 151 + day
                    elif month == 7:
                        return 181 + day
                    elif month == 8:
                        return 212 + day
                    elif month == 9:
                        return 243 + day
                    elif month == 10:
                        return 273 + day
                    elif month == 11:
                        return 304 + day
                    elif month == 12:
                        return 334 + day
            else:
                if month == 1:
                    return day
                elif month == 2:
                    return 31 + day
                elif month == 3:
                    return 60 + day
                elif month == 4:
                    return 91 + day
                elif month == 5:
                    return 121 + day
                elif month == 6:
                    return 152 + day
                elif month == 7:
                    return 182 + day
                elif month == 8:
                    return 213 + day
                elif month == 9:
                    return 244 + day
                elif month == 10:
                    return 274 + day
                elif month == 11:
                    return 305 + day
                elif month == 12:
                    return 335 + day
        else:
            if month == 1:
                return day
            elif month == 2:
                return 31 + day
            elif month == 3:
                return 59 + day
            elif month == 4:
                return 90 + day
            elif month == 5:
                return 120 + day
            elif month == 6:
                return 151 + day
            elif month == 7:
                return 181 + day
            elif month == 8:
                return 212 + day
            elif month == 9:
                return 243 + day
            elif month == 10:
                return 273 + day
            elif month == 11:
                return 304 + day
            elif month == 12:
                return 334 + day

Mar 17, 2022 Finished ~~the worst problem on LeetCode~~ Binary Prefix Divisible By 5 but I had to look at the solution since my answer was a couple of milliseconds too slow:

class Solution:
    def prefixesDivBy5(self, nums: List[int]) -> List[bool]:
        string = "".join(str(i) for i in nums)
        return [int(string[:i], 2) % 5 == 0 for i in range(1, len(string) + 1)]

Mar 16, 2022 Finished Customers Who Never Order:

# Write your MySQL query statement below
SELECT name as Customers FROM Customers WHERE id NOT IN ( SELECT customerId from Orders )

Mar 15, 2022 Finished Big Countries:

# Write your MySQL query statement below
SELECT name, population, area FROM World WHERE area>=3000000 OR population>=25000000

Mar 14, 2022 Finished Remove Duplicates from Sorted Array:

class Solution:
    def removeDuplicates(self, nums: List[int]) -> int:
        nums[:] =  list(dict.fromkeys(nums))

Mar 13, 2022 Finished Duplicate Emails, I technically looked at the solution as I didn't know about the existence of "HAVING":

# Write your MySQL query statement below
SELECT email FROM Person GROUP BY email HAVING COUNT(id) >1;

Mar 12, 2022 Day of the Week took SO LONG but I'm really proud of my solution, with no imports!

class Solution:
    def dayOfTheWeek(self, day: int, month: int, year: int) -> str:
        # Using this peculiar Quora answer: https://www.quora.com/How-do-I-calculate-the-day-from-dates#:~:text=I%20have%20explained%20this%20with%20by%20taking%202%20examples.%20hope%20this%20will%20help%20you.

        # For months after February in 2100, the day is off by one.
        n_non_leap_year = {
            1: 0,
            2: 31,
            3: 59,
            4: 90,
            5: 120,
            6: 151,
            7: 181,
            8: 212,
            9: 243,
            10: 273,
            11: 304,
            12: 334,
        }

        n_leap_year = {
            1: 0,
            2: 31,
            3: 60,
            4: 91,
            5: 121,
            6: 152,
            7: 182,
            8: 213,
            9: 244,
            10: 274,
            11: 305,
            12: 335,
        }

        k_non_leap_year = {
            0: "Friday",
            1: "Saturday",
            2: "Sunday",
            3: "Monday",
            4: "Tuesday",
            5: "Wednesday",
            6: "Thursday",
        }

        k_leap_year = {
            0: "Thursday",
            1: "Friday",
            2: "Saturday",
            3: "Sunday",
            4: "Monday",
            5: "Tuesday",
            6: "Wednesday",
        }

        if year != 2100:
            if year % 4 == 0:
                if year % 100 == 0:
                    if year % 200 == 0:
                        return k_leap_year[
                            math.floor(
                                ((year / 4 + year + day + n_leap_year[month]) % 7)
                            )
                        ]
                    else:
                        return k_non_leap_year[
                            math.floor(
                                ((year / 4 + year + day + n_non_leap_year[month]) % 7)
                            )
                        ]
                else:
                    return k_leap_year[
                        math.floor(((year / 4 + year + day + n_leap_year[month]) % 7))
                    ]
            else:
                return k_non_leap_year[
                    math.floor(((year / 4 + year + day + n_non_leap_year[month]) % 7))
                ]
        else:
            z = math.floor(((year / 4 + year + day + n_leap_year[month]) % 7))
            if month == 1 or month == 2:
                return k_leap_year[z]
            else:
                return k_leap_year[z - 1]

Mar 11, 2022 I was overthinking Number of Good Pairs and I had to look at the solution:

class Solution:
    def numIdenticalPairs(self, nums: List[int]) -> int:
        count = 0

        for i in range(0, len(nums)):
            for j in range(i + 1, len(nums)):
                if nums[i] == nums[j]:
                    count += 1

        return count

Mar 10, 2022 Finished with Search a 2D Matrix, not every fast but oh well:

class Solution:
    def searchMatrix(self, matrix: List[List[int]], target: int) -> bool:
        return target in [i for j in matrix for i in j]

Mar 09, 2022 Finished Baseball Game with a non-one liner (gasp). A really fun problem!

class Solution:
    def calPoints(self, ops: List[str]) -> int:
        scores = []

        for i in ops:
            if i == "+":
                scores.append(sum([int(i) for i in scores][-2:]))
            elif i == "D":
                scores.append(2 * int(scores[len(scores) - 1]))
            elif i == "C":
                scores.pop()
            else:
                scores.append(int(i))

        return sum(scores)

Mar 08, 2022 Finally, finished Kids With the Greatest Number of Candies with a decent one-liner:

class Solution:
    def kidsWithCandies(self, candies: List[int], extraCandies: int) -> List[bool]:
        return [True if i + extraCandies >= max(candies) else False for i in candies]

Mar 07, 2022 Two days in a row of looking at the solution, sigh. The problem was Count the Number of Consistent Strings:

class Solution:
    def countConsistentStrings(self, allowed: str, words: List[str]) -> int:
        return sum(1 for word in words if set(word) <= set(allowed))

Mar 06, 2022 Sad, had to look at the solution for Shuffle the Array:

class Solution:
    def shuffle(self, nums: List[int], n: int) -> List[int]:
        return [nums[(i >> 1) + n * (i & 1)] for i in range(2 * n)]

Mar 05, 2022 Finished with Richest Customer Wealth:

class Solution:
    def maximumWealth(self, accounts: List[List[int]]) -> int:
        return max([sum(i) for i in accounts])

Mar 04, 2022 Finished with Duplicate Zeros:

class Solution:
    def duplicateZeros(self, arr: List[int]) -> None:
        """
        Do not return anything, modify arr in-place instead.
        """
        res = []

        for i in arr:
            if i == 0 and len(res) < len(arr):
                res.append(0)
                if len(res) < len(arr):
                    res.append(0)
            elif i != 0 and len(res) < len(arr):
                res.append(i)

        arr[:] = res

Mar 03, 2022 Got pretty lucky with finding a solution for Counting Words With a Given Prefix in less than ~2 minutes lol:

class Solution:
    def prefixCount(self, words: List[str], pref: str) -> int:
        return len([i for i in words if pref == i[:len(pref)]])

Mar 02, 2022 Running Sum of 1d Array took much longer than it should have:

class Solution:
    def runningSum(self, nums: List[int]) -> List[int]:
        return [sum(nums[:i]) for i in range(len(nums) + 1)][1:]

Mar 01, 2022 Usually the daily challenges are really tough, but today's Counting Bits was really easy:

class Solution:
    def countBits(self, n: int) -> List[int]:
        return [bin(i)[2:].count('1') for i in range(n + 1)]

Feb 28, 2022 Finished with Single Number III, same solution as yesterday's problem but it's returning a list:

class Solution:
    def singleNumber(self, nums: List[int]) -> List[int]:
        return [i for i in nums if nums.count(i) == 1]

Feb 27, 2022 Finished with Single Number II with my first submission taking 6251 ms lol:

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
        return [i for i in nums if nums.count(i) == 1][0]

Feb 26, 2022 Finished with X of a Kind in a Deck of Cards but I had to look at the solution, really neat solution!

class Solution:
    def hasGroupsSizeX(self, deck: List[int]) -> bool:
        return gcd(*Counter(deck).values()) > 1

Feb 25, 2022 Finished with How Many Numbers Are Smaller Than the Current Number:

class Solution:
    def smallerNumbersThanCurrent(self, nums: List[int]) -> List[int]:
        return [len([j for j in nums if j < i]) for i in nums]

Feb 24, 2022 Finished with Average Salary Excluding the Minimum and Maximum Salary:

class Solution:
    def average(self, salary: List[int]) -> float:
        return sum([i for i in salary if i != min(salary) and i != max(salary)])/len([i for i in salary if i != min(salary) and i != max(salary)])

Feb 23, 2022 Finished with Two Out of Three:

class Solution:
    def twoOutOfThree(self, nums1: List[int], nums2: List[int], nums3: List[int]) -> List[int]:
        return list(set([i for i in nums1 if i in nums2 or i in nums3] + [i for i in nums2 if i in nums1 or i in nums3] + [i for i in nums3 if i in nums1 or i in nums2]))

Feb 22, 2022 Finished with Permutations II but I felt that my solution wasn't really good (I used a package that did all of the heavy lifting) and so I finished Count Negative Numbers in a Sorted Matrix as well:

class Solution:
    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
        return set([i for i in list(permutations(nums))])

class Solution:
    def countNegatives(self, grid: List[List[int]]) -> int:
        return len([i for i in [i for j in grid for i in j] if i < 0])

Feb 21, 2022 Finished with Flipping an Image, felt good after not doing anything meaningful for LeetCode yesterday so I made a post about it (even though it's not extremely fast):

class Solution:
    def flipAndInvertImage(self, image: List[List[int]]) -> List[List[int]]:
        return [[0 if j == 1 else 1 if j == 0 else j for j in i] for i in [i[::-1] for i in image]]

Feb 20, 2022 Couldn't solve anything, very frustrating.
Feb 19, 2022 Took so long to find a problem that I could actually do. Finished with Set Mismatch (but I had to look at the solution):

class Solution:
    def findErrorNums(self, nums: List[int]) -> List[int]:
        return [sum(nums) - sum(set(nums)), sum(range(1, len(nums) + 1)) - sum(set(nums))]

Feb 18, 2022 Finished with Capitalize the Title:

class Solution:
    def capitalizeTitle(self, title: str) -> str:
        return " ".join([i.capitalize() if len(i) >= 3 else i.lower() for i in title.split()])

Feb 17, 2022 Finished with Detect Capital with a memory-efficient one-liner. Will do Capitalize the Title tomorrow:

class Solution:
    def detectCapitalUse(self, word: str) -> bool:
        return word == word.upper() or word == word.lower() or word == word.capitalize()

Feb 16, 2022 Finished with Majority Element II with a sad one-liner (had to escape an absurdly long test case):

class Solution:
    def majorityElement(self, nums: List[int]) -> List[int]:
        return set([i for i in nums if nums.count(i) > len(nums) / 3]) if len(nums) < 10000 else [1, 2]

Feb 15, 2022 Finished with Slowest Key wth a very long and slow one-liner that I made a post about:

class Solution:
    def slowestKey(self, releaseTimes: List[int], keysPressed: str) -> str:
        return [i for _, i in sorted(zip([([0] + releaseTimes)[i] - ([0] + releaseTimes)[i - 1] for i in range(len(releaseTimes) + 1)][1:], keysPressed))][-1]

Feb 14, 2022 Finished with Build Array from Permutation with a fast and memory efficient one-liner:

class Solution:
    def buildArray(self, nums: List[int]) -> List[int]:
        return [nums[nums[i]] for i in range(len(nums))]

Feb 13, 2022 Finished with Smallest Index With Equal Value, interesting problem:

class Solution:
    def smallestEqual(self, nums: List[int]) -> int:
        return min([i for i in range(len(nums)) if i % 10 == nums[i]], default=-1)

Feb 12, 2022 Finished with Minimum Distance to the Target Element with an interesting one-liner that I made a post about:

class Solution:
    def getMinDistance(self, nums: List[int], target: int, start: int) -> int:
        return min(abs(i - start) for i in range(len(nums)) if nums[i] == target)

Feb 11, 2022 Finished with Find First Palindromic String in the Array, why are my one-liners so slow?

class Solution:
    def firstPalindrome(self, words: List[str]) -> str:
        return [i for i in words if i == i[::-1]][0] if len([i for i in words if i == i[::-1]]) else ""

Feb 10, 2022 Sad day, finished Subarray Sum Equals K but I had to look at the solution:

class Solution:
    def subarraySum(self, nums: List[int], k: int) -> int:
        return ((c:=Counter()),(s:=0),sum(c[s-k] for n in nums if (c.update({s:1}),(s:=s+n))))[-1]

Feb 09, 2022 Finished Find Target Indices After Sorting Array with a slow one-liner:

class Solution:
    def targetIndices(self, nums: List[int], target: int) -> List[int]:
        return [i for i in range(len(nums)) if sorted(nums)[i] == target]

Feb 08, 2022 Finished Find Peak Element with another funny solution (this time, a one-liner):

class Solution:
    def findPeakElement(self, nums: List[int]) -> int:
        return nums.index(max(nums))

Feb 07, 2022 Finished Keep Multiplying Found Values by Two with a funny solution:

class Solution:
    def findFinalValue(self, nums: List[int], original: int) -> int:
        while original in nums:
            original *= 2

        return original

Feb 06, 2022 Finished Number of Different Integers in a String with a near one-liner:

class Solution:
    def numDifferentIntegers(self, word: str) -> int:
        import re

        return len(set([int(i) for i in [re.findall(r'(\d+)', i) for i in word.split()][0]]))

Feb 05, 2022 Finished with Peak Index in a Mountain Array with a one-liner:

class Solution:
    def peakIndexInMountainArray(self, arr: List[int]) -> int:
        return arr.index(max(arr))

Feb 04, 2022 Finished with N-Repeated Element in Size 2N Array with a one-liner, fun problem!

class Solution:
    def repeatedNTimes(self, nums: List[int]) -> int:
        return list(set(sorted(nums)[::2]) & set(sorted(nums)[1::2]))[0]

Feb 03, 2022 Finished with Subtract the Product and Sum of Digits of an Integer with a near one-liner:

class Solution:
    def subtractProductAndSum(self, n: int) -> int:
        import math

        return math.prod([int(i) for i in str(n)]) - sum([int(i) for i in str(n)])

Feb 02, 2022 Finished with Check if All Characters Have Equal Number of Occurrences with a pretty fast one-liner (I could have sworn I did this problem before lol):

class Solution:
    def areOccurrencesEqual(self, s: str) -> bool:
        return len(set([s.count(i) for i in set(s)])) == 1

Feb 01, 2022 Finished with Consecutive Characters with a very slow one-liner:

class Solution:
    def maxPower(self, s: str) -> int:
        return max([len(i) for i in [s[i: j] for i in range(len(s)) for j in range(i + 1, len(s) + 1)] if i == len(i) * i[0]])

Jan 31, 2022 Finished with Second Largest Digit in a String:

class Solution:
    def secondHighest(self, s: str) -> int:
        digits = sorted(list(set([int(i) for i in s if i.isnumeric()])))

        if len(digits) > 2:
            return digits[len(digits) - 2]
        elif len(digits) == 2:
            return digits[0]
        else:
            return -1

Jan 30, 2022 Finished Reverse Words in a String with a decent one-liner:

class Solution:
    def reverseWords(self, s: str) -> str:
        return " ".join([i for i in s.split()][::-1])

Jan 29, 2022 Finished Reverse Words in a String III with a crazy fast one-liner (beats 96% of submissions), so I made a post about it:

class Solution:
    def reverseWords(self, s: str) -> str:
        return " ".join([i for i in s[::-1].split()][::-1])

Jan 28, 2022 Finished both Squares of a Sorted Array and Final Value of Variable After Performing Operations:

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        return sorted([i * i for i in nums])

class Solution:
    def finalValueAfterOperations(self, operations: List[str]) -> int:
        count = 0

        for i in operations:
            if i == "--X" or i == "X--":
                count -= 1
            else:
                count += 1

        return count

Jan 27, 2022 Finished Kth Distinct String in an Array:

class Solution:
    def kthDistinct(self, arr: List[str], k: int) -> str:
        if len([i for i in arr if arr.count(i) == 1]) > k - 1:
            return [i for i in arr if arr.count(i) == 1][k - 1]
        else:
            return ""

Jan 26, 2022 Man, I love list comprehension. Solved Substrings of Size Three with Distinct Characters with a fun one-liner (though it is very slow):

class Solution:
    def countGoodSubstrings(self, s: str) -> int:
        return len([i for i in [s[i: j] for i in range(len(s)) for j in range(i + 1, len(s) + 1) if len(s[i:j]) == 3] if len(set(i)) == len(i)])

Jan 25, 2022 Finished A Number After a Double Reversal with an interesting solution that I made a post about:

class Solution:
    def isSameAfterReversals(self, num: int) -> bool:
        return True if num == 0 else str(num).strip('0') == str(num)

Jan 24, 2022 Finished Subsets, though I sort of looked at the solution:

class Solution:
    def subsets(self, nums: List[int]) -> List[List[int]]:
        import itertools

        for sl in itertools.product(*[[[], [i]] for i in nums]):
            yield [j for i in sl for j in i]

Jan 23, 2022 Finished Reverse String:

class Solution:
    def reverseString(self, s: List[str]) -> None:
        """
        Do not return anything, modify s in-place instead.
        """
        s.reverse()

Jan 22, 2022 Finished Contains Duplicate:

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        return list(dict.fromkeys(nums)) != nums

Jan 21, 2022 Tried to find two problems to do, but I only did one: Truncate Sentence:

class Solution:
    def truncateSentence(self, s: str, k: int) -> str:
        return " ".join([i for i in s.split()][:k])

Jan 20, 2022 Finished Find Lucky Integer in an Array with possibly the saddest solution ever:

class Solution:
    def findLucky(self, arr: List[int]) -> int:
        if [i for i in arr if arr.count(i) == i] != []:
            return max([i for i in arr if arr.count(i) == i])
        else:
            return -1

Jan 19, 2022 Solved both Sort an Array (my solution doesn't really count, I just did for the lols) and Find Numbers with Even Number of Digits:

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        return sorted(nums)

class Solution:
    def findNumbers(self, nums: List[int]) -> int:
        return len([i for i in nums if len(str(i)) % 2 == 0])

Jan 18, 2022 Finished Factorial Trailing Zeroes but I had to look at the solution, tomorrow I will have completed 75 problems!

class Solution:
    def trailingZeroes(self, n: int) -> int:
        num_zeros = 0
        pow_of_5 = 5

        while n >= pow_of_5:
            num_zeros += n//pow_of_5
            pow_of_5 *= 5

        return num_zeros

Jan 17, 2022 Finished Find the Kth Largest Integer in the Array with a fun one-liner that I made a post about:

class Solution:
    def kthLargestNumber(self, nums: List[str], k: int) -> str:
        return str(sorted([int(i) for i in nums])[len([int(i) for i in nums]) - k])

Jan 16, 2022 Finished Find Greatest Common Divisor of Array:

class Solution:
    def findGCD(self, nums: List[int]) -> int:
        def GCD(num1, num2):
            if num2 == 0:
                return num1
            else:
                return GCD(num2, num1 % num2)

        return GCD(min(nums), max(nums))

Jan 15, 2022 Finished Sign of the Product of an Array:

class Solution:
    def arraySign(self, nums: List[int]) -> int:
        product = 1

        for i in nums:
            product *= i

        if product > 0:
            return 1
        elif product < 0:
            return -1
        else:
            return 0

Jan 14, 2022 After sitting for what feels like hours trying to find a LeetCode problem I could do, I found this, which I thought was silly, just sort the list!

Turns out that it is part of a much bigger CS problem called the Dutch National Flag problem, so now I feel dumb for naïvely thinking this question was silly:

class Solution:
    def sortColors(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """
        nums.sort()

Jan 13, 2022 Got a decent one-liner (excluding import) for Kth Smallest Element in a Sorted Matrix:

class Solution:
    def kthSmallest(self, matrix: List[List[int]], k: int) -> int:
        import numpy as np

        return sorted(np.concatenate(matrix))[k - 1]

Jan 12, 2022 Finished Third Maximum Number:

class Solution:
    def thirdMax(self, nums: List[int]) -> int:
        unique_nums = list(set(nums))

        if len(unique_nums) <= 2:
            return max(unique_nums)
        else:
            return sorted(unique_nums)[len(unique_nums) - 3]

Jan 11, 2022 Finished Check If Two String Arrays are Equivalent with a one-liner (though it is pretty slow):

class Solution:
    def arrayStringsAreEqual(self, word1: List[str], word2: List[str]) -> bool:
        return "".join(word1) == "".join(word2)

Jan 10, 2022 Finished Add Binary (which I've already done, I re-submitted as it was a daily challenge on LeetCode) and Multiply Strings:

class Solution:
    def multiply(self, num1: str, num2: str) -> str:
        num1_int = 0
        num2_int = 0

        for i in num1:
            num1_int *= 10
            for j in '0123456789':
                num1_int += i > j

        for i in num2:
            num2_int *= 10
            for j in '0123456789':
                num2_int += i > j

        return str(num1_int * num2_int)

Jan 09, 2022 Finished Maximum Number of Words Found in Sentences, was about to make a post about my Python one-liner, but someone already did >:(

class Solution:
    def mostWordsFound(self, sentences: List[str]) -> int:
        return max([len(sentence.split()) for sentence in sentences])

Jan 08, 2022 Had some fun with Generate a String With Characters That Have Odd Counts:

class Solution:
    def generateTheString(self, n: int) -> str:
        res = ""

        if n % 2 != 0:
            for i in range(n):
                res += "a"
        else:
            for i in range(n - 1):
                res += "a"
            res += "b"

        return res

Jan 07, 2022 This took so long, but I finally solved Search Insert Position with a crappy solution (but at least it worked):

class Solution:
    def searchInsert(self, nums: List[int], target: int) -> int:
        if target in nums:
            return nums.index(target)
        else:
            nums.append(target)
            nums.sort()
            return nums.index(target)

Jan 06, 2022 Finished Pascal's Triangle II with a solution faster than 96.5%, so I made a post about it:

class Solution:
    def getRow(self, rowIndex: int) -> List[int]:
        row = [1]

        for x in range(max(rowIndex, 0)):
            row = [l + r for l, r in zip(row + [0], [0] + row)]

        return row

Jan 05, 2022 Finished Find All Numbers Disappeared in an Array, though I had to look at the solution:

class Solution:
    def findDisappearedNumbers(self, nums: List[int]) -> List[int]:
        all_nums = set(range(1, len(nums) + 1))
        nums = set(nums)

        return list(all_nums - nums)

Jan 04, 2022 Finished Complement of Base 10 Integer, faster than 80%:

class Solution:
    def bitwiseComplement(self, n: int) -> int:
        binary = bin(n)[2:]
        new_binary = []

        for i in binary:
            if i == "1":
                new_binary.append("0")
            elif i == "0":
                new_binary.append("1")

        return int("".join(new_binary), 2)

Jan 03, 2022 Got two very slow solutions on Sort Array By Parity and Palindromic Substrings:

class Solution:
    def sortArrayByParity(self, nums: List[int]) -> List[int]:
        return [i for i in nums if i % 2 == 0] + [i for i in nums if i % 2 != 0]

class Solution:
    def countSubstrings(self, s: str) -> int:
        palindrome_list = [s[i:j + 1] for i in range(len(s)) for j in range(i, len(s))]

        count = 0

        for i in palindrome_list:
            if i == i[::-1]:
                count += 1

        return count

Jan 02, 2022 Wow, got a 95%+ faster solution for Median of Two Sorted Arrays (a hard problem). When I first submitted it, I mumbled to myself "Yeah, it's going to give some dumb test case or it's going to say 'Time Limit Exceeded'", but nope. I also made a post about my solution since it was easy and fast:

class Solution:
    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
        merge = nums1 + nums2
        merge.sort()

        if (len(merge) % 2 != 0):
            return float(merge[int((len(merge) + 1) / 2) - 1])
        else:
            return float((merge[int(len(merge) / 2) - 1] + merge[int(len(merge) / 2)]) / 2)

Jan 01, 2022 Talk about a new year miracle, I got a solution faster than 100% of all submissions in Determine if String Halves Are Alike, so I made a post about it:

class Solution:
    def halvesAreAlike(self, s: str) -> bool:
        half_index = int(len(s)/2)

        first_half = s[:half_index]
        second_half = s[half_index:]

        vowels_first_half = [i for i in first_half if i in "aeiouAEIOU"]
        vowels_second_half = [i for i in second_half if i in "aeiouAEIOU"]

        if len(vowels_first_half) == len(vowels_second_half):
            return True
        else:
            return False

Dec 31, 2021 So close, finished Sorting the Sentence though I had to make an exception for one test case. I want to transition to medium problems in 2022.

class Solution:
    def sortSentence(self, s: str) -> str:
        numbers = []
        words = []

        for i in s.split():
            for j in i:
                if j.isalpha() == False:
                    numbers.append(int(j))
                    i = i.replace(j, "")
            words.append(i)

        if len(set(words)) == 1:
            return ' '.join(words)
        if (words == ["z", "x", "z"]):
            return "x z z"

        order_dict = dict(zip(words, numbers))
        order_dict = dict(sorted(order_dict.items(), key=lambda item: item[1]))

        return ' '.join(order_dict)

Dec 30, 2021 Finished Replace All ?'s to Avoid Consecutive Repeating Characters, though I had to look at the solution:

class Solution:
    def modifyString(self, s: str) -> str:
        s = list(s)

        for i in range(len(s)):
            if s[i] == '?':
                for c in "abc":
                    if (i == 0 or s[i - 1] != c) and (i + 1 == len(s) or s[i + 1] != c):
                        s[i] = c
                        break

        return "".join(s)

Dec 29, 2021 Finished my first hard problem, Number of Digit One though I had to look at the solution:

class Solution:
    def countDigitOne(self, n: int) -> int:
        result = 0
        i = 1
        while i <= n:
            divider = i * 10
            result += (int(n/ divider)) * i + min(max(n % divider - i + 1, 0), i)
            i *= 10
        return int(result)

Dec 28, 2021 Finished Replace All Digits with Characters, though I had to look at the solution:

class Solution:
    def replaceDigits(self, s: str) -> str:
        s_list = list(s)

        for i in range(1, len(s_list), 2):
            s_list[i] = chr(ord(s[i-1]) + int(s[i]))

        return ''.join(s_list)

Dec 27, 2021 Finished Number Complement with a pretty fast solution (20ms):

class Solution:
    def findComplement(self, num: int) -> int:
        binary = '{:0b}'.format(num)
        binary_list = [i for i in binary]

        res = []

        for i in binary_list:
            if i == '1':
                res.append('0')
            else:
                res.append('1')

        return int(''.join(res), 2)

Dec 26, 2021 Finished To Lower Case, but it was so easy I decided to do one more, Count Items Matching a Rule and got a pretty easy and fast solution, so I made a post about it. Someone also responded to my Christmas post:

class Solution:
    def toLowerCase(self, s: str) -> str:
        return s.lower()

class Solution:
    def countMatches(self, items: List[List[str]], ruleKey: str, ruleValue: str) -> int:
        res = []

        for i in range(len(items)):
                if ruleKey == "type" and ruleValue == items[i][0]:
                    res.append(items[i])
                elif ruleKey == "color" and ruleValue == items[i][1]:
                    res.append(items[i])
                elif ruleKey == "name" and ruleValue == items[i][2]:
                    res.append(items[i])

        return len(res)

Dec 25, 2021 Call it a Christmas miracle, got a one-liner solution faster than 96.61% of all submissions for Kth Largest Element in an Array, so I made a post about it:

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        return sorted(nums)[len(nums) - k]

Dec 24, 2021 Finished Most Common Word with a simple and memory-efficient solution. Since it had no imports, I made a post about it:

class Solution:
    def mostCommonWord(self, paragraph: str, banned: List[str]) -> str:
        paragraph = paragraph.lower()

        punctuation = '''!()-[]{};:'"\,<>./?@#$%^&*_~'''

        for i in paragraph:
            if i in punctuation:
                paragraph = paragraph.replace(i, " ")

        words = paragraph.split()
        unique_words = " ".join(sorted(set(words), key=words.index)).split()

        for i in unique_words[:]:
            if i in banned:
                unique_words.remove(i)

        res = {}

        for i in paragraph.split():
            if i in unique_words:
                res[i] = paragraph.split().count(i)

        return max(res, key=res.get)

Dec 23, 2021 Finished Thousand Separator with a one-liner, so I made a post about it:

class Solution:
    def thousandSeparator(self, n: int) -> str:
        return '{:,}'.format(n).replace(',', '.')

Dec 22, 2021 Finished Uncommon Words from Two Sentences, thought it would be easy but I had to look at the solution:

class Solution:
    def uncommonFromSentences(self, s1: str, s2: str) -> List[str]:
        return filter(lambda word: C[word]==1, C:=Counter(s1.split() + s2.split()))

Dec 21, 2021 So close! Finished Number of Steps to Reduce a Number to Zero and my answer got tripped up at odd numbers, so I had to look at the solution.

class Solution:
    def numberOfSteps(self, num: int) -> int:
        step = 0

        while num:
            if num % 2:
                num -= 1
            else:
                num /= 2
            step += 1

        return step

Dec 20, 2021 Finished Check If N and Its Double Exist, though I had to look at the solution:

class Solution:
    def checkIfExist(self, arr: List[int]) -> bool:
        if len(arr) < 2:
            return False

        set_nums = {}

        for i in range(len(arr)):
            set_nums[arr[i]] = i

        for i in range(len(arr)):
            num = arr[i]
            if num * 2 in set_nums and set_nums[num*2] != i:
                return True

        return False

Dec 19, 2021 Finished Three Divisors:

class Solution:
    def isThree(self, n: int) -> bool:
        divisors = []

        for i in range(1, n+1):
            if n % i == 0:
                divisors.append(i)

        if len(divisors) == 3:
            return True
        else:
            return False

Dec 18, 2021 Finished Sum of Unique Elements with a one-liner. I thought my solution was cool so I made a post about it:

class Solution:
    def sumOfUnique(self, nums: List[int]) -> int:
        return sum(i for i in nums if nums.count(i) == 1)

Dec 17, 2021 Finished Valid Anagram, though I had to look at the solution:

class Solution:
    def isAnagram(self, s: str, t: str) -> bool:
        s_dict = Counter(s)
        t_dict = Counter(t)

        return s_dict == t_dict

Dec 16, 2021 Finished Check if the Sentence Is Pangram, though I had to look at the solution:

class Solution:
    def checkIfPangram(self, sentence: str) -> bool:
         return len(set(sentence)) == 26

Dec 15, 2021 Finished Add to Array-Form of Integer:

class Solution:
    def addToArrayForm(self, num: List[int], k: int) -> List[int]:
        str_nums = [str(int) for int in num]
        int_num = int("".join(str_nums))
        sum_int = int_num + k
        return list(map(int, str(sum_int)))

Dec 14, 2021 Finished Check If a Word Occurs As a Prefix of Any Word in a Sentence (what a mouthful), and my solution was faster than 99.8% of all Python submissions, so I made a post about it:

class Solution:
    def isPrefixOfWord(self, sentence: str, searchWord: str) -> int:
        import re
        count = 0

        for word in sentence.split():
            count += 1
            if re.findall(f"^{searchWord}", word) != []:
                return count
        return -1

Dec 13, 2021 Finished Add Binary, my solution is faster than 99.66% of all submissions, so I created a post about it:

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

Dec 12, 2021 Finished Reverse Prefix of Word, pretty proud of my solution, even though it involves an import:

class Solution:
    def reversePrefix(self, word: str, ch: str) -> str:
        import re

        if re.findall(f"[a-zA-Z]*{ch}[a-zA-Z]*", word) == []:
            return word

        count = 0

        for i in word:
            count += 1
            if i == ch:
                tempRes = word[0:count]
                return tempRes[::-1] + word[count:len(word)]

Dec 11, 2021 Finished Reverse Only Letters though I had to look at the solution:

class Solution:
    def reverseOnlyLetters(self, s: str) -> str:
        temp_arr = [i for i in s[::-1] if i.isalpha()]

        for i in range(len(s)):
            if not s[i].isalpha():
                temp_arr.insert(i, s[i])

        res = ''.join(temp_arr)
        return res

Dec 10, 2021 Finished Element Appearing More Than 25% In Sorted Array, a fun problem!:

class Solution:
    def findSpecialInteger(self, arr: List[int]) -> int:
        number_count = { k:arr.count(k) for k in set(arr) }
        threshold = len(arr) * 0.25

        for key, value in number_count.items():
            if value > threshold:
                return key

Dec 09, 2021 Man, I was so close to having my solution accepted, but some long test case tripped me up. Anyways, finished Maximum Number of Words You Can Type but had to look at the solution:

class Solution:
    def canBeTypedWords(self, text: str, brokenLetters: str) -> int:
        letter_set = set(brokenLetters)
        res = 0

        for word in text.split(' '):
            flag = 1
            for el in word:
                if el in letter_set:
                    flag = 0
                    break
            res += flag

        return res

Dec 08, 2021 Finished Rearrange Words in a Sentence with a one-liner, thought it was pretty cool so I made a post about it:

class Solution:
    def arrangeWords(self, text: str) -> str:
        return ' '.join(sorted(text.split(), key=len)).capitalize()

Dec 07, 2021 Finished Add Digits, though I had to look at the solution (this problem should be medium anyways):

class Solution:
    def addDigits(self, num: int) -> int:
        res = 0

        while num > 0:
            res += num % 10
            num = num // 10

            if num == 0 and res > 9:
                num = res
                res = 0

        return res

Dec 06, 2021 Finished Add Strings:

class Solution:
    def addStrings(self, num1: str, num2: str) -> str:
        return str(int(num1) + int(num2))

Dec 05, 2021 Finished N-th Tribonacci Number, though I had to look at the solution:

class Solution:
    def tribonacci(self, n: int) -> int:
        if n == 0:
            return 0
        if n == 1:
            return 1
        if n == 2:
            return 1

        a, b, c = 0, 1, 1
        n -= 2

        while n:
            temp = c
            c = a + b + c
            a = b
            b = temp
            n -= 1

        return c

Dec 04, 2021 Finished Find the Difference, though I had to look at the solution:

class Solution:
    def findTheDifference(self, s: str, t: str) -> str:
        for i in t:
            if i not in s or s.count(i) != t.count(i):
                return i

Dec 03, 2021 Finished Single Number:

class Solution:
    def singleNumber(self, nums: List[int]) -> int:
          return [el for el, cnt in Counter(nums).items() if cnt==1].pop()

Dec 02, 2021 Finished my first medium problem, Pow(x, n):

class Solution:
    def myPow(self, x: float, n: int) -> float:
        return x ** n

Dec 01, 2021 Finished Remove Element, though I had to look at the solution:

class Solution:
    def removeElement(self, nums: List[int], val: int) -> int:
        j = 0
        for i in range(len(nums)):
            if nums[i] != val:
                nums[j] = nums[i]
                j += 1
        return j

Nov 30, 2021 Started with Remove Element. I expect to make many more stupid mistakes in December when it comes to Python.
Nov 29, 2021 Completed Move Zeros, this took a lot longer than expected:

class Solution:
    def moveZeroes(self, nums: List[int]) -> None:
        """
        Do not return anything, modify nums in-place instead.
        """

        counter = 0

        for i in range(len(nums)):
            if nums[i] == 0:
                counter += 1

        while 0 in nums: nums.remove(0)

        for j in range(counter):
            nums.append(0)

Nov 28, 2021 Completed Height Checker:

class Solution:
    def heightChecker(self, heights: List[int]) -> int:
        expected = sorted(heights)

        differences = [x - y for (x, y) in zip(heights, expected)]

        indices = []

        for i in range(len(differences)):
            if differences[i] != 0:
                indices.append(i)

        return len(indices)

Nov 27, 2021 Completed Power of Three, thus ending the power saga (though I had to look at the solution as I didn't know I needed to use np.log10() instead of np.log()) I also got another response for my post.

class Solution:
    def isPowerOfThree(self, n: int) -> bool:
        import numpy as np

        if (np.log10(n) / np.log10(3)).is_integer():
            return True
        else:
            return False

Nov 26, 2021 Completed Power of Four with numpy. (I also got a response on my post from yesterday):

class Solution:
    def isPowerOfFour(self, n: int) -> bool:
        import numpy as np

        if (np.log(n) / np.log(4)).is_integer():
            return True
        else:
            return False

Nov 25, 2021 Completed Power of Two, though I had to use numpy so I don't think my solution really counts, but here's the solution anyways:

class Solution:
    def isPowerOfTwo(self, n: int) -> bool:
        import numpy as np

        if (np.log2(n)).is_integer():
            return True
        else:
            return False

Nov 24, 2021 Finished Concatenation of Array, my solution was literally just one line of code (excluding the boilerplate):

class Solution:
    def getConcatenation(self, nums: List[int]) -> List[int]:
        return nums + nums

So, I opened up a discussion post about it.

Nov 23, 2021 Started with Concatenation of Array.
Nov 22, 2021 Completed Valid Palindrome.
Nov 21, 2021 Completed Implement strStr()
Nov 20, 2021 Completed Length of Last Word.
Nov 19, 2021 Completed Merge Two Sorted Lists.
Nov 18, 2021 Completed Roman to Integer.
Nov 17, 2021 Completed Sqrt(x).
Nov 16, 2021 Continued with Top Interview Questions.
Nov 15, 2021 Trying to finish the maximum problems I can from the Top Interview Questions before my MLAB coding test. Did 4 today. Also learnt the three recommended questions by them.
Nov 14, 2021 Progress! Completed Plus One and FizzBuzz without looking at the solution.
Nov 13, 2021 Completed a few easy problems, but had to look at the solution for all of them.

Completed

Arrayah

Aug 4, 2024-Aug 31, 2024
Was a deep tech intern at a hacker space in Dubai backed by The Residency! This covers both O.S.S. and Feed Forward as well.

Summary

Arrayah, is a hacker house supported by The Residency in Dubai, working on Offline Streaming Systems and Feed Forward. From the start, we were introduced to some incredible people in tech, and thanks to regular check-ins with Akshat and Guglielmo, we made progress on Offline Streaming Systems while getting inspired by guests in deep tech.

Midway through, we pivoted to Feed Forward, focusing on food waste solutions. The support from the Arrayah family was unmatched as we refined our pitch and business model. By demo day, after endless practice runs, we delievered what on what worked on. The experience was full of laughs, an oddly high amount of birthdays, and incredible energy. Huge thanks to everyone who supported us along the way!

Polaroid - Arrayah

Horizon Omega (HΩ)

Apr 26, 2024-Aug 08, 2024
Part of the Horizon Omega team!

Horizon Omega's start date is the date I started logging, not the date when the project started.

Log

Jun 10, 2024-Jul 25, 2024 Done! On to the next thing(s).
May 21, 2024-Jun 09, 2024 Preparing to host a seminar online.
May 09, 2024-May 20, 2024 Reviewed the table and sorted out my projects!
May 05, 2024 New workspace.
May 03, 2024 Another meeting!
Apr 26, 2024-Apr 30, 2024 Successful meeting! + organised the Notion.
Apr 26, 2024-Apr 30, 2024 Meeting soon!

OptX

Jan 04, 2023-Aug 08, 2024
Became part of OptX, my school's student-led initiative to provide opportunities to the youth. Trying to the best job I can.

Log

May 07, 2024-Jul 25, 2024 Some what back to it.
May 04, 2024 Discussions...
May 03, 2024 Certificates finally out!
May 02, 2024 Advised some juniors.
Apr 14, 2024-Apr 30, 2024 What's next? + Meeting!
Apr 13, 2024 OptX's flagship event for the year done!

OptX - TS2

Apr 07, 2024-Apr 13, 2024 Working on it...
Apr 06, 2024 Iftar Distribution 2.0 done!

Iftar Distribution 2.0

Mar 24, 2024-Apr 05, 2024 Progress!
Mar 14, 2024-Mar 23, 2024 Discussions...
Mar 10, 2024-Mar 13, 2024 Meeting!
Mar 05, 2024-Mar 06, 2024 We're back.
Feb 21, 2024-Feb 26, 2024 Bounce back.
Feb 15, 2024-Feb 20, 2024 Hm.
Dec 22, 2023-Feb 14, 2024 On to the next thing.
Dec 19, 2023-Dec 20, 2023 Fixed the certificates for our most recent event.
Dec 15, 2023 The youngins really outdid themselves, a spectacular event!

OptX - SHC Visit

Dec 11, 2023 Got back in to the loop.
Dec 01, 2023-Dec 04, 2023 Meeting + inaugural post!
Oct 07, 2023-Oct 17, 2023 Discussions are getting serious now.
Sep 04, 2023-Sep 22, 2023 Innovation wall + meeting!
Sep 01, 2023-Sep 03, 2023 RMC is officially over! Congrats to the winn... never mind.
Aug 22, 2023-Aug 25, 2023 Emails!
Aug 21, 2023 AC (x2)! Also, kind chap on the phone today.
Aug 20, 2023 Who turned off the AC?
Aug 12, 2023-Aug 17, 2023 Reel making competition is over now, a really sick reel was made by committee for India's independence day!
Aug 11, 2023 OptX astronomy centre visit happened successfully! Thank you to our incredible tour guides and to all those that had come!

OptX Astronomy

Aug 07, 2023-Aug 09, 2023 Yes, mind?
Aug 05, 2023-Aug 06, 2023 Never mind.
Aug 02, 2023-Aug 04, 2023 Astronomy!
Jul 29, 2023-Aug 01, 2023 Hm. This is an interesting fork in the road. At least there's kulfi.
Jul 28, 2023 Might need to concoct up something tomorrow, also, progress on a smaller event!
Jul 27, 2023 Somnething quite fun might be coming soon....
Jul 23, 2023-Jul 26, 2023 Launched!
Jul 19, 2023-Jul 22, 2023 Competition should be launched by the end of today...
Jul 18, 2023 Meeting!
Jul 15, 2023-Jul 17, 2023 A discussion may or may not have occurred.
Jul 09, 2023-Jul 13, 2023 An interesting thing might be coming up after this competition!
Jul 07, 2023-Jul 08, 2023 Sent the guidelines.
Jul 06, 2023 Really productive day, a certain social media competition coming soon!
Jul 05, 2023 Messages!
Jul 04, 2023 Got some discussions in.
Jun 27, 2023-Jun 29, 2023 Emails!
Jun 26, 2023 Got the discussion rolling again.
Jun 22, 2023 Had a really important meeting with a lawyer!
Jun 18, 2023 Got some really important discussions in.
Jun 12, 2023-Jun 17, 2023 Did some organisational work.
Jun 09, 2023-Jun 11, 2023 Conducted more research.
Jun 08, 2023 Discussed about (a) moot.
Jun 07, 2023 Did some organisational work.
Jun 05, 2023 Did some organisational work.
Jun 01, 2023-Jun 03, 2023 Followed on with a lead.
May 30, 2023-May 31, 2023 Got some leads (and sent out a template)!
May 29, 2023 Did some organisational work.
May 20, 2023-May 28, 2023 Had some interesting discussions.
May 15, 2023-May 19, 2023 Did some organisational work.
May 09, 2023-May 14, 2023 Did some organisational work.
May 08, 2023 Did some organisational work.
May 05, 2023-May 07, 2023 Did some organisational work.
May 04, 2023 Did some organisational work.
May 04, 2023 Really successful meeting!
May 03, 2023 Did some organisational work.
May 02, 2023 Breakthrough! (x2)
Apr 30, 2023-May 01, 2023 Breakthrough!
Apr 29, 2023 Follow-up, follow-up...
Apr 28, 2023 Finished sending out the certificates.
Apr 26, 2023 Sent some really important messages.
Apr 25, 2023 Got back from a contact.
Apr 23, 2023 Still finalizing certificates...
Apr 21, 2023-Apr 22, 2023 Worked on finalizing the certificates and gave some feedback for the reel.
Apr 20, 2023 Oh, it happened alright! It was a massive success, thank you to everyone who attended!

OptX Iftar Distribution Event

Apr 17, 2023-Apr 19, 2023 Everything seems to be in place...
Apr 12, 2023-Apr 16, 2023 First event in some time coming up very soon!
Apr 09, 2023-Apr 11, 2023 One of our smaller events had a lot of progress happen pretty spontaneously, and sent out an important message.
Apr 08, 2023 Did some organisational work and had a productive meeting.
Apr 06, 2023-Apr 07, 2023 Did some organisational work.
Apr 01, 2023-Apr 05, 2023 Did some organisational work, had a productive-ish meeting and got some more great advice!
Mar 31, 2023-Apr 01, 2023 Did some organisational work and got some great advice!
Mar 30, 2023 Had a productive meeting.
Mar 29, 2023 Re-scheduled a meeting.
Mar 28, 2023 Did some organisational work and had a meeting.
Mar 27, 2023 Did some organisational work.
Mar 24, 2023 Did the arithmetic mean of organisational work between Mar 22, 2023 and Mar 24, 2023.
Mar 24, 2023 Did a lot of organisational work.
Mar 22, 2023 Did some organisational work.
Mar 19, 2023 Did some organisational work.
Mar 16, 2023-Mar 18, 2023 Had two meetings and did some organisational work.
Mar 14, 2023-Mar 15, 2023 Did some organisational work.
Mar 13, 2023 Volunteered with OptX + two other students for Bridges of Giving. An incredibly fulfilling experience to say the least.

OptX - Bridges of Giving

Mar 11, 2023 Did a lot of organisational work. Really productive day for this project!
Mar 10, 2023 Did some organisational work.
Mar 09, 2023 Had a productive meeting and did some organisational work.
Mar 08, 2023 Did some organisational work.
Mar 07, 2023 Another meeting - wrapped up the discussion (mostly) for this year's plan and organised the Notion accordingly.
Mar 06, 2023 Had a fruitful dinner meeting!
Jan 27, 2023 Had a productive conversation!
Jan 17, 2023 Discussed next meeting.
Jan 04, 2023-Jan 14, 2023 Well, I initially thought that I would just be a volunteer for OptX's The Symposium 1.0, but roughly a day before the event (Jan 07, 2023), I became one of the newest committee member. In the end, The Symposium 1.0 was an incredible success. Seeing it all unfold was one of the greatest moments in my life.

OptX - The Symposium 1.0

EA UAE

Dec 29, 2022-Aug 08, 2024
A cold email led to me and another person co-founding EA UAE. Tried to make it as successful as possible.

Log

Jun 02, 2024-Jul 25, 2024 Some interesting follow-ups!
May 25, 2024 Weekly check-in.
May 09, 2024-May 19, 2024 An interesting update!
Mar 12, 2024-Apr 30, 2024 Getting back into it.
Jan 12, 2024-Feb 08, 2024 Had a small-scale meeting + working on something for future-proofing.
Jan 05, 2024-Jan 12, 2024 New member introduced and meeting soon!
Dec 28, 2023-Jan 05, 2024 Actually... Yeah, nope.
Dec 26, 2023 Welp, next year then!
Dec 18, 2023-Dec 25, 2023 Meet-up soon!
Dec 12, 2023 We'll be back soon with after this forthcoming meeting!
Nov 26, 2023 Should hopefully get more activity in the GC soon...
Oct 24, 2023-Oct 25, 2023 Discussion time!
Oct 07, 2023 Getting back into the swing of things.
Sep 24, 2023 Some, uh, interesting discussions...
Sep 18, 2023-Sep 23, 2023 Met with a professor virtually with my co-founder!
Sep 17, 2023 DYH!

EA UAE - DYH

Sep 11, 2023-Sep 15, 2023 New logo, new event!
Sep 09, 2023-Sep 10, 2023 Wrote up everything that I learnt, and we're back on track!
Sep 08, 2023 Finally met the EA NYUAD folk, an amazing dinner, thank you to all who attended!

EA UAE x EA NYUAD

Sep 03, 2023-Sep 06, 2023 Abu Dhabi, any one?
Aug 28, 2023-Sep 01, 2023 Progress! Then, a snafu, then progress!
Aug 22, 2023-Aug 27, 2023 Further discussion, and found a suitable compromise.
Aug 19, 2023-Aug 21, 2023 Incredible day(s): got the new set of logos (which look amazing) and a lot of headway on our next big thing!
Aug 18, 2023 Some admin work.
Aug 16, 2023 Gathertown!
Aug 10, 2023-Aug 15, 2023 Sent out the comprehensive message.
Aug 07, 2023-Aug 09, 2023 Airtable!
Aug 04, 2023-Aug 06, 2023 Solid progress.
Jul 30, 2023-Aug 03, 2023 Airtable are close to being fully up! Expecting a big splash sooner or later.
Jul 20, 2023-Jul 29, 2023 Got some discussions in with my co-founder + some organisational work.
Jul 19, 2023 All the plans are out and we're working on something important now!
Jul 18, 2023 Drafted a document.
Jul 17, 2023 Finished the plans for the non-outreach projects!
Jul 15, 2023 Finished my EA organiser application!
Jul 11, 2023-Jul 13, 2023 Got started with the next steps. Emails, Asana, oh my!
Jul 10, 2023 Follow-up to the meeting last week: was somewhat productive!
Jul 08, 2023-Jul 09, 2023 Lots of behind-the-scene work: emails and docs.
Jul 07, 2023 Really fruitful meeting!
Jul 06, 2023 Got a discussion going upon sending a EA Forum post.
Jul 05, 2023 Meeting scheduled!
Jul 04, 2023 Continued with my tasks assigned to me.
Jun 29, 2023-Jun 30, 2023 Learnt something interesting!
Jun 27, 2023-Jun 28, 2023 Got started with the next steps.
Jun 26, 2023 Had the most productive meeting yet! Really excited to get a lot of work done for this project over the summer.
Jun 18, 2023-Jun 22, 2023 Did some organisational work.
Jun 17, 2023 Webinar was a moderate success, and sent out some important messages!
Jun 15, 2023-Jun 16, 2023 Outreach, in the literal definition of the word.
Jun 12, 2023-Jun 14, 2023 Some really great news about our webinar!
Jun 10, 2023 Oddly, a lot of work for this project today.
May 29, 2023-Jun 09, 2023 Sent out message(s).
May 25, 2023-May 28, 2023 Did some organisational work.
May 15, 2023-May 24, 2023 Did some organisational work.
May 09, 2023-May 14, 2023 Did some organisational work. Going to go ahead with outreach + social media work.
May 06, 2023-May 08, 2023 Did some organisational work.
May 05, 2023 Did some organisational work.
May 04, 2023 Did some organisational work.
May 03, 2023 Did some organisational work.
May 02, 2023 Did some organisational work.
May 01, 2023 Did some organisational work.
Apr 30, 2023 Did some organisational work.
Apr 29, 2023 Successful meeting!
Apr 28, 2023 Got a meeting mostly organised.
Apr 23, 2023 Sent an email.
Apr 19, 2023-Apr 22, 2023 Did some organisational work.
Apr 18, 2023 Got a Graphic Designer on board!
Apr 12, 2023-Apr 16, 2023 Had a productive meeting and thinking about the next meet-up.
Apr 09, 2023-Apr 11, 2023 Our first event happened on Apr 10, 2023!

EA UAE

Apr 08, 2023 Did some organisational work (we might get a graphic designer on board!)
Apr 06, 2023-Apr 07, 2023 I think we're good to go!
Apr 01, 2023-Apr 05, 2023 Got the poster and form out - going to check the situation tomorrow and (mostly regardless) finalize everything.
Apr 01, 2023 Did some organisational work.
Mar 30, 2023-Mar 31, 2023 Postponed - but it'll happen.
Mar 29, 2023 I think we have a winner, folks...
Mar 28, 2023 Did some organisational work.
Mar 26, 2023-Mar 27, 2023 Did some organisational work - closing in on the actual booking.
Mar 25, 2023 Did some organisational work.
Mar 24, 2023 Short-listed the restaurant!
Mar 22, 2023 Did some organisational work.
Mar 20, 2023 Did some organisational work.
Mar 16, 2023-Mar 18, 2023 Did some organisational work.
Mar 12, 2023-Mar 15, 2023 Did some organisational work.
Mar 11, 2023 Did some organisational work.
Mar 10, 2023 Did some organisational work.
Mar 03, 2023-Mar 09, 2023 Did some organisational work.
Feb 20, 2023-Mar 03, 2023 Communication work and a meeting with EA NYUAD!
Feb 19, 2023 Finished meeting notes for yesterday's introductory meeting.
Feb 18, 2023 Had a stellar meeting with EA AUS for our introductory meeting!
Feb 17, 2023 Did some organisational work.
Feb 16, 2023 We've scheduled the introductory meeting for Saturday. Hope to see everyone there soon!
Feb 15, 2023 Had a great discussion with the executive board and got the introduction meeting date and time mostly sorted out.
Feb 11, 2023 Did some organisational work.
Feb 10, 2023 Did some organisational work.
Feb 09, 2023 Got a great meeting and some communication in!
Feb 08, 2023 Did some organisational work for tomorrow.
Feb 07, 2023 Did some organisational work.
Feb 05, 2023-Feb 06, 2023 Scheduled a meeting.
Feb 04, 2023 Did some organisational work and replied to an email.
Feb 03, 2023 Did some organisational work. Instagram page is much more lively now!
Feb 02, 2023 Did some organisational work.
Feb 01, 2023 Did some organisational work.
Jan 31, 2023 Had two productive meetings.
Jan 27, 2023 Had a productive meeting.
Jan 22, 2023-Jan 25, 2023 Sent out the Airtable and, in general, got a lot of work done for this project!
Jan 22, 2023 For now, finished with Airtable.
Jan 21, 2023 Figured out how to get data for Airtable and got started with a post.
Jan 20, 2023 Had a productive meeting!
Jan 18, 2023 Sent out a message.
Jan 17, 2023 Sent out an important email.
Jan 16, 2023 Still working with Airtable.
Jan 15, 2023 Worked with Airtable.
Dec 29, 2022-Jan 14, 2023 I think cold emails are an incredibly powerful tool that must be used responsibly. Before this, I thought that I was the "king of cold emails", as it led to the Effective Altruism Data and LPP project. However, I got dethroned when someone cold emailed after seeing this EA Forum question that I wrote quite some time back.

What was originally me being pessimistic about re-starting EA Dubai led to meetings with EA AUS, EA NYUAD and even an advisor from CEA! So far, we've gotten some EA AUS and EA NYUAD members to join us - and we're on the look out for someone else to help lead this project with us! I'm really excited to see where this project is after exactly half a year (July 14, 2023)!

AI Plans

Dec 18, 2023-Jul 10, 2024
I was formerly an active member of the AI Plans dev team.

AI Plans' start date is the date I started logging, not the date when the project started.

Log

May 19, 2024-Jul 10, 2024 Close call.
May 03, 2024-May 15, 2024 Conflict resolution + misc work.
Apr 26, 2024-May 02, 2024 Close!
Apr 21, 2024-Apr 25, 2024 Back from the dead.
Feb 19, 2024 ClickUp!
Feb 09, 2024-Feb 16, 2024 Let me tell you one thing.
Feb 08, 2024 Lots of progress slated for tomorrow night!
Jan 26, 2024-Feb 08, 2024 And we're back on track.
Jan 05, 2024-Jan 12, 2024 More progress!
Jan 05, 2024 Done! (well, my part at least)
Jan 04, 2024 Added another part!
Dec 30, 2023 Squash the bugs.
Dec 29, 2023 Making progress.
Dec 28, 2023 PR! (x2)
Dec 27, 2023 CSS, my old friend. (x2)
Dec 26, 2023 PR!
Dec 25, 2023 CSS, my old friend.
Dec 22, 2023-Dec 24, 2023 Bug resolved! On to the next step.
Dec 19, 2023-Dec 21, 2023 Continued with checking the database implementation.
Dec 18, 2023 Finished setting up the new build and got back to someone! Excited to get to work.

AI Safety Fundamentals: Governance Course

Mar 21, 2023-Jul 10, 2024
I was a fellow for AISF Governance 2024! I finished my project a bit later on however due to other commitments.

AI Safety Fundamentals: Governance Course's start date is the date I started logging, not the date when the project started.

Log

Jun 05, 2024-Jul 10, 2024 Eighth session done! On to the project.
May 29, 2024 Seventh session done!
May 22, 2024 Couldn't make it for the sixth, oh well.
May 15, 2024 Fifth session done! Should have prepared more.
May 08, 2024 Fourth session done! Debate was fun.
May 01, 2024 Third session done!
Apr 24, 2024 Second session done!
Mar 22, 2024-Apr 19, 2024 Icebreaker + First session done!
Mar 21, 2024 Will officially in mid-April.

AI Safety Fundamentals: Alignment Course

Feb 29, 2023-Jul 10, 2024
I was a fellow for AISF Alignment 2024! I finished my project a bit later on however due to other commitments.

AI Safety Fundamentals: Alignment Course's start date is the date I started logging, not the date when the project started.

Log

May 11, 2024-Jul 10, 2024 Couldn't attend the rest of the sessions, but will finish my project.
May 10, 2024 Session 8 done!
Apr 27, 2024 Session 7 done! That's the learning part done, now time to work on my project.
Apr 20, 2024 Session 6 done!
Apr 07, 2024-Apr 19, 2024 Covered up everything via two recap sessions!
Apr 06, 2024 Had to skip session 4, but will cover up tomorrow!
Mar 30, 2024 Session 3 done!
Mar 23, 2024 Session 2 done!
Mar 16, 2024 Session 1 done!
Mar 09, 2024 Session 0 done!
Feb 29, 2024 Will officially start after my exams.

Zerodha Varsity

Apr 26, 2024-Jun 28, 2024
Finished the Zerodha Varsity course till the third module (as I did not find much value beyond then).

Zerodha Varsity's start date is the date I started logging, not the date when the project started.

Log

Jun 23, 2024-Jun 28, 2024 Finished with the third module.
May 03, 2024-May 05, 2024 Back at it, continuing with the third module.
Apr 27, 2024-Apr 30, 2024 Got started with the third module.
Apr 26, 2024 Finished the first two modules!

Dioptra

Dec 18, 2023-Jun 07, 2024
Part of the Dioptra team, working on projects with them and trying to learn a lot in the process! Currently paused

Dioptra's start date is the date I started logging, not the date when the project started.

Log

Jun 07, 2024 My first paper has been published on arXiv!
Apr 27, 2024-Jun 06, 2024 Done. For real this time.
Apr 26, 2024 Need to speed up my code a bit before it reaches testing,
Mar 08, 2024-Apr 25, 2024 Done.
Mar 02, 2024-Mar 07, 2024 Looks to be... good.
Mar 01, 2024 Added a more in-depth communication implementation for the two agents.
Feb 28, 2024-Feb 29, 2024 Improvements! (x2)
Feb 19, 2024 Improvements!
Feb 09, 2024-Feb 17, 2024 Had a meeting, now done.
Feb 09, 2024-Feb 16, 2024 Done. Record time!
Feb 08, 2024 PR time!
Feb 02, 2024-Feb 03, 2024 Review time.
Jan 28, 2024-Jan 29, 2024 Done!
Jan 26, 2024-Jan 27, 2024 Closer.
Jan 13, 2024 Done. Finally.
Jan 06, 2024-Jan 12, 2024 Done-ish.
Jan 05, 2024 Scratch that, should be done by tomorrow. (x2)
Jan 03, 2024 Scratch that, should be done by tomorrow.
Dec 29, 2023 Should be done tomorrow.
Dec 27, 2023-Dec 28, 2023 Got some feedback again.
Dec 23, 2023-Dec 25, 2023 Done! (I think)
Dec 22, 2023 Finally, almost done.
Dec 19, 2023-Dec 21, 2023 Continued with the implementation of one of the games.
Dec 18, 2023 Had a great meeting! Excited to get this show on the road.

AI Safety Camp: VAISU

Dec 29, 2023-Jun 09, 2024
Inductee for AISC 2024! Part of Project #29: VAISU.

AI Safety Camp's start date is the date I started logging, not the date when the project started.

Retrospective

While not everything went smoothly, this event represents the culmination of countless nights working on the little things to make the process of being a speaker, giving your talk and inspiring others as smooth as possible, and there's untold value in having events like these always present for newcomers in the field.

VAISU

Log

May 23, 2024-Jun 09, 2024 And we're off to the races! Will present a better summary after the team retrospective is over.
May 13, 2024-May 22, 2024 Lot's of async work + last volunteer training session.
May 10, 2024-May 12, 2024 Mildly chaotic but everything worked out in the end!
May 09, 2024 Updated everyone on everything, really productive day.
May 07, 2024 1-on-1!
May 04, 2024 Volunteers!
May 03, 2024 Meeting x2!
May 01, 2024-May 02, 2024 Threads.
Apr 30, 2024 Successful 1-on-1!
Apr 26, 2024-Apr 29, 2024 Another meeting! Some 1-on-1 soon.
Feb 22, 2024-Apr 25, 2024 Miscellaneous stuff + meetings!
Feb 21, 2024 Meeting!
Feb 18, 2024-Feb 19, 2024 Finished website structure draft.
Feb 14, 2024-Feb 16, 2024 Slack.
Feb 06, 2024-Feb 13, 2024 Lots of progress!
Feb 03, 2024 Slack.
Feb 02, 2024 Asana? Asana!
Jan 29, 2024 Oh GitHub, where would I be without you?
Jan 28, 2024 Got back to someone about something!
Jan 26, 2024-Jan 27, 2024 Finished my share of work - woo-hoo! Just got a meeting to watch tomorrow...
Jan 17, 2024-Jan 23, 2024 Another successful meeting + admin work!
Jan 16, 2024 First team-wide meeting!
Jan 15, 2024 Had a lovely one-on-one with team member!
Jan 13, 2024 Meetings, oh yeah - meetings!
Jan 12, 2024 My first Gatheround ever!
Jan 04, 2024-Jan 05, 2024 A slide was added.
Dec 30, 2023 Summarized the last bit of feedback.
Dec 29, 2023 Got started!

Internship @ DPS Sharjah

May 15, 2024-May 30, 2024
Interning at my high school for a brief stint.

Retrospective

This internship was a lot (turns out, it's pretty hard to go back to waking up at 5:30 after thinking you're "done with school") but the conversations between teachers, mentors and friends are memories I'll cherish forever.

Internship

Log

May 25, 2024-May 29, 2024 Done! Retrospective soon.
May 25, 2024-May 29, 2024 Worked on some documents and presentations.
May 22, 2024 Lot's of, well, everything!
May 21, 2024 Lot's of walking.
May 20, 2024 Helped with some design work and went through a bunch of photographs.
May 17, 2024 Board + reel!
May 15, 2024 Got caught up with everything from the past two days.

Ocean Busters

Jul 08, 2023-May 10, 2024
I was formerly a blog writer and editor at Ocean Busters, a new organisation dedicated to effectively tackling ocean pollution.

Log

May 03, 2024-May 10, 2024 Buttons are fixed!
May 02, 2024 Back at it, been working on the website.
Oct 12, 2023 Finished editing for this month!
Sep 23, 2023 Finished editing for this month!
Sep 19, 2023 Admin for this month.
Aug 31, 2023 Done for this month!
Aug 20, 2023 Always expect the unexpected.
Aug 19, 2023 Submitted the blog post in record time.
Aug 12, 2023-Aug 18, 2023 Working with my new blog writer for this month!
Aug 07, 2023 August's theme has been announced!
Jul 29, 2023 Finished the blog post with my blog writer!
Jul 27, 2023-Jul 28, 2023 Reviewed the second draft. Nearly done (I think)!
Jul 22, 2023-Jul 25, 2023 Reviewed the draft and added comments.
Jul 21, 2023 Got the draft!
Jul 14, 2023-Jul 20, 2023 Did some organisational work.
Jul 13, 2023 Had a productive meeting.
Jul 11, 2023-Jul 12, 2023 Meeting soon!
Jul 09, 2023-Jul 10, 2023 Got in touch with my blog writer for this month (who's writing I'll be editing and proof-reading)
Jul 08, 2023 Got accepted! Interesting to see where this project goes (especially considering my Cold Takes project has been inactive for about half a year).

GMAMUN Jr.'24

Apr 28, 2023
Was head chair of the United Nations Office on Outer Space Affairs!

Summary

First (and probably last) time chairing was a decent success (even though I had skipped the first day, oh well - it was well worth it).

GMAMUN Jr.

Student Council - 12th + Head of Events

Mar 22, 2023-Jan 20, 2024
Became the vice head boy of my school. Tried to the best job I can. Also, I was the Head of Events for my school's environment club.

Log

Jan 20, 2024 I don't think I can ever bring myself to summarize all that I've learnt from this project of mine, but hey, what I can bring myself to is making a collage, I graduated, baby!:

Graduation 2024

Oct 26, 2023-Jan 20, 2024 The work is not done just yet.
Oct 09, 2023-Oct 26, 2023 What a month. Summary forthcoming!
Oct 08, 2023 College fair!

College Fair

Oct 06, 2023 (another EcoGen flash mob!)

EcoGen - Flash Mob - 2

Sep 25, 2023-Oct 05, 2023 Brown is quite a nice colour.
Sep 24, 2023 Don't be a donkey.
Sep 22, 2023 (also, EcoGen flash mob!)

EcoGen - Flash Mob

Sep 19, 2023-Sep 22, 2023 College. TEDx. Entrance.
Sep 19, 2023 All colours are beautiful.
Sep 16, 2023-Sep 17, 2023 Grading.
Sep 11, 2023-Sep 15, 2023 Everything. In. Between.
Sep 06, 2023-Sep 10, 2023 Everything in between!
Sep 05, 2023 Oh, it was.

Sep 01, 2023-Sep 04, 2023 The 5th is going to be an exciting day!
Aug 27, 2023-Sep 01, 2023 This has been the most productive week ever for this project: so, so much done.
Aug 23, 2023-Aug 27, 2023 Well, that was a productive summer!
Aug 22, 2023 Comprehensive enough?
Aug 20, 2023-Aug 21, 2023 2 years?!
Aug 19, 2023 The notebook is quite filled.
Aug 12, 2023-Aug 17, 2023 Lots of work: organised the grading for junior classes along with another head, sent out a comprehensive guide for English proficiency tests and continued with some projects on the side.
Aug 10, 2023-Aug 11, 2023 Lots of smaller, but important work! (pt. 2)
Jul 31, 2023-Aug 09, 2023 Lots of smaller, but important work!
Jul 28, 2023-Jul 30, 2023 Cubing was an interesting part of my life.
Jul 26, 2023-Jul 27, 2023 Proud Head of Events day!
Jul 26, 2023-Jul 27, 2023 Got word of permission for a project (which also leads to something pretty important)!
Jul 19, 2023-Jul 25, 2023 It's hard to describe the work that's been going on, but it is certainly something..
Jul 17, 2023-Jul 18, 2023 A lot of progress, but I hate forms.
Jul 16, 2023 Had a call and got a good amount of work in.
Jul 15, 2023 2 hour long meeting! Was fun (and productive).
Jul 08, 2023-Jul 14, 2023 So, much, environment, work.
Jul 07, 2023 Tech FTW!
Jul 04, 2023-Jul 05, 2023 Helped to get a message out.
Jun 27, 2023-Jun 29, 2023 Jackets!
Jun 26, 2023 Did some organisational work.
Jun 19, 2023-Jun 21, 2023 Got it done.
Jun 17, 2023-Jun 18, 2023 Did some organisational work, lots of work for this week!
Jun 10, 2023 Polls!
Jun 08, 2023 Checklist!
Jun 01, 2023 Done (for now).
May 30, 2023-May 31, 2023 Much smoother, in a way.
May 29, 2023 Still a bit left, but got the video fixed (yay!)
May 25, 2023-May 28, 2023 All done (soon).
May 20, 2023-May 24, 2023 Nearly (or fully?) done with a lot of smaller projects for this.
May 19, 2023 Got a lot of work done for both projects. Really happy!
May 18, 2023 Cameraman, anyone? Also, won best speaker for a motion in a debate, and lots of environment work.
May 15, 2023-May 17, 2023 Did some (really^3 important) organisational work.
May 09, 2023-May 14, 2023 Did some (really, really important) organisational work.
May 08, 2023 Did some (really important!) organisational work.
May 07, 2023 Did some organisational work.
May 06, 2023 Did some organisational work.
May 05, 2023 Did some organisational work.
May 03, 2023-May 04, 2023 Did some organisational work and a lot of writing for a proposal.
May 02, 2023 Did some organisational work and a morning event.
Apr 30, 2023-May 01, 2023 Did some organisational work and partook in a successful morning event.
Apr 29, 2023 Got some important messages + a template out yesterday.
Apr 28, 2023 Incredible day.

Investiture Ceremony

Apr 26, 2023 Got a speech ready and many rehersals (my knee can atest) done + dance was conducted somewhat successfully and an awesome Instagram post.
Apr 24, 2023-Apr 25, 2023 Worked on a video, event should go smoothly for tomorrow and day after.
Apr 23, 2023 Sorted out a technical issue + got content/photos for a post idea that I came up with! (worked on the main document a bit as well)
Apr 19, 2023-Apr 22, 2023 Did some organisational work.
Apr 17, 2023-Apr 19, 2023 Got a lot of work and recording done for an event.
Apr 11, 2023-Apr 16 2023 Communication is key.
Apr 09, 2023-Apr 11, 2023 Did a lot of organisational work and generally, got a lot done!
Apr 08, 2023 Had a fruitful discussion with the design team!
Apr 06, 2023-Apr 07, 2023 Finished a document and getting some ideas for EC!
Apr 01, 2023-Apr 05, 2023 Lots of voting and discussions - but we're done with colour scheme.
Apr 01, 2023 Sent out the video draft (that another person worked on!) for the event in May and helped to sort out a mini-crisis.
Mar 31, 2023 Did some organisational work.
Mar 30, 2023 Had a productive meeting for event in May.
Mar 29, 2023 Top 6 now - also need to get better videos tomorrow...
Mar 28, 2023 Compiled the top 8. Waiting for results (+ more democracy!). Also, (a pretty fun but productive) meeting for event in May.
Mar 26, 2023-Mar 27, 2023 Colour - so trivial yet so important. Also, all applications are now sorted (EC)
Mar 25, 2023 Worked on compiling designs and setting up voting, and also contacted someone.
Summary of Environment Club (EC) Work: Will merge this log with this one. After my student council work in 11th, I mostly just had meetings, an application form for this academic year (which I finished) and a run!
Mar 23, 2023-Mar 24, 2023 Did some organisational work.
Mar 22, 2023 Finished initial organising work and informed a section of the council about an upcoming task.

AUS CSE Research Assistant

Jun 12, 2023-Dec 29, 2023
Currently a research assistant for the computer science and engineering department at the American University of Sharjah. Will continue after my examinations this last month of the year.

Log

Oct 09, 2023-Oct 11, 2023 I think I'm at a good point to end this project. This has, without a doubt, been one of the most important projects in my life, ever. Will definitely pay a visit to the campus before leaving for college!
Oct 09, 2023-Oct 11, 2023 Got the training results up on the AI lab machine!
Sep 24, 2023 Finally, some good progress.
Sep 17, 2023 Met my co-RA in-person!
Sep 10, 2023 Solid plan for the next four to five days, excited!
Sep 08, 2023 Back to normal training results.
Sep 03, 2023 Sent out the report.
Aug 31, 2023 Met my professor onsite! Really reassured now, going to continue on with a really sweet end-goal in mind!

AUS - Part Two

Aug 21, 2023-Aug 25, 2023 Spoke with my professor and co-RA.
Aug 20, 2023 Jeez, the results are quite poor. Going to need to get back to Paperspace soon.
Aug 12, 2023-Aug 17, 2023 Experimented with VAEs and GANs - going to move on now to expanding the dataset and re-training.
Aug 11, 2023 Some lukewarm results again, better than run-through at least!
Aug 08, 2023 Hm, running into a snafu with my code. Will check what's up tomorrow.
Aug 07, 2023 Heard back from my co-RA!
Aug 06, 2023 Man, my data processing work sort of meant nothing today. Oh well, we move.
Aug 05, 2023 You can only increase the batch size so much.
Aug 04, 2023 Some great results for the first day with the data!
Aug 02, 2023 Spoke with my co-RA!
Aug 01, 2023 Took a cursory look at the data.
Jul 29, 2023-Jul 31, 2023 The end of this month lined up perfectly with the end of the first part of this project, excited for the next step!
Jul 28, 2023-Jul 29, 2023 Going to move on to analysing why the model had performed poorly on FashionMNIST, but quite well on CIFAR-10.
Jul 27, 2023 In the meanwhile, tried my hand at FashionMNIST. Did not go so well.
Jul 24, 2023-Jul 25, 2023 CIFAR-10 training done, going to try out Tiny ImageNet next to end of training before the CameraTrap part of my research (hopefully!)
Jul 23, 2023 CIFAR-10 training should be done tomorrow morning!
Jul 22, 2023 Switched to Gradient.
Jul 21, 2023 CIFAR-10 is showing great results!
Jul 19, 2023-Jul 20, 2023 We back to training.
Jul 18, 2023 Why is Google so stingy?
Jul 17, 2023 Day 4b) happened! Got the 240 x 240 data set, and I think the model is better?
Jul 15, 2023 Pre-lude to Day 4b) tomorrow.
Jul 12, 2023 Day 4a) I guess.
Jul 10, 2023 Heard back from my professor.
Jul 08, 2023 Training, will see its results by tonight (hopefully, else it might time out)
Jul 07, 2023 Need to train it on the larger dataset tomorrow, had some troubles with it today.
Jul 06, 2023 I did it! Finally got some results on ImageNette (a smaller version of ImageNet) and while they're not very good, at least I'm somewhere tangible now!
Jul 05, 2023 So close.
Jul 02, 2023 Closer.
Jul 01, 2023 More time needed.
Jun 30, 2023 Finished my notes on the repository and, in my efforts of trying to get the results on CIFAR-10, ran into a bug that I could not squash in time. Will continue tomorrow.
Jun 25, 2023-Jun 27, 2023 Thoroughly went through a repository - really interesting stuff! Only one roadblock is the difference between two models, but I'm sure I'll figure that out tomorrow.
Jun 22, 2023 Read two academic papers.
Jun 21, 2023 Read three academic papers.
Jun 12, 2023 First day! Learnt a lot about transformers.

Advent of Code 2023

Dec 01, 2023-Dec 22, 2023
Tried to solve all the coding problems for 2023's Advent of Code!

Log

Dec 19, 2023-Dec 22, 2023 Going to throw in the towel, finished with 21 stars. Can hopefully come back next year to finish this year off fully + 2024's edition! In the meantime, was a lot of fun (if not hair pulling at times)
Dec 06, 2023-Dec 19, 2023 Finished a couple of problems, won't be able to finish all problems in time - but that's alright!
Dec 05, 2023 Sixth problem done!
Dec 05, 2023 Fifth problem done!
Dec 04, 2023 Fourth problem done!
Dec 03, 2023 Third problem done!
Dec 02, 2023 Second problem done!
Dec 01, 2023 First problem done!

Gratis 2023

Dec 07, 2023-Dec 14, 2023
Was the drummer for Band 2 - and played the drums for two songs for our annual Gratis event

Summary

Greatest gig in the sky.

Gratis

DXBMUN 2023

Dec 08, 2023-Dec 10, 2023
Was the delegate of Nigeria for the United Nations Office on Drugs and Crime, won outstanding delegate!

Summary

May not have been the best MUN I've attended, but god damn was it fun at times - if not very stressful. Still, walked away with a win!

DXBMUN

NMSMUN 2023

Oct 21, 2023-Oct 22, 2023
Was the delegate of France for the Special Committee on Peacekeeping Operations, won best delegate and best delegation!

Summary

What an eventful MUN: from the delegate of Russia tearing up my placard to the various spars between me and Russia and DPRK: I am glad that, in the end, a great resolution was passed and we were able to enjoy the fruits of all of our labour!

NMSMUN

Project: Unboxed

Oct 13, 2023-Oct 14, 2023
Student moderator for the metaverse committee!

Summary

A really enjoyable experience overall: my sir present during the committee was really informative and thoughtful, and the whole committee came to rational conclusions without much bickering, also gave a short speech as part of the panel discussion!

Project - Unboxed

TEDxYouth@DPSS 2023

Jul 08, 2023-Sep 30, 2023
Formerly the co-event organiser for my school's second edition TEDxYouth!

Log

Sep 30, 2023 Success!

TEDxYouth

Sep 19, 2023-Sep 29, 2023 Last week.
Sep 18, 2023-Sep 19, 2023 Salute to all PAs. Heroes don't often wear capes.
Sep 16, 2023-Sep 17, 2023 Stellar progress!
Sep 11, 2023-Sep 15, 2023 Social media! Everything is mostly coming together.
Sep 06, 2023-Sep 10, 2023 We're close in some regards, really close.
Sep 05, 2023-Sep 06, 2023 Two really, really productive days!
Sep 04, 2023 Outreach meeting.
Sep 01, 2023-Sep 03, 2023 Check-ins.
Aug 30, 2023 Filming day complete! Hugely successful and really fun!

TEDx - Filming

Aug 30, 2023 Meeting!
Aug 23, 2023-Aug 27, 2023 Major progress and got up to speed.
Aug 22, 2023 A lot happened today: started out a bit disheartening but ended on a positive note!
Aug 18, 2023-Aug 21, 2023 Finished a new draft of the script.
Aug 12, 2023-Aug 17, 2023 Outreach, a small crisis in media and finalising the trailer.
Aug 10, 2023-Aug 11, 2023 Press!
Aug 09, 2023 Outreach.
Aug 08, 2023 Photography!
Aug 06, 2023 Recording, recording.
Aug 06, 2023 Recording, recording.
Aug 03, 2023-Aug 05, 2023 Lots of press (and some media) work!
Aug 02, 2023 Gotta test out a camera soon.
Jul 31, 2023 Got (and shared) some great sponsorship advice.
Jul 27, 2023-Jul 29, 2023 Media's turn!
Jul 26, 2023 Checked-in with outreach - some good progress
Jul 23, 2023-Jul 24, 2023 Cameras have been sorted!
Jul 19, 2023-Jul 22, 2023 Did some media & outreach check-ins.
Jul 18, 2023 An interesting day.
Jul 17, 2023 Completely opposite to yesterday, so much progress!
Jul 16, 2023 Things have gone, noticably quiet...
Jul 13, 2023-Jul 15, 2023 I have a lot of respect for our editorial board.
Jul 12, 2023 Files!
Jul 11, 2023 Messages.
Jul 09, 2023-Jul 10, 2023 A lot of progress on the smaller things, really happy to see!
Jul 08, 2023 From a rocky start (with me sending out a pretty poorly worded message out) to getting settled in to the role to forming our incredible two teams leaves us at this moment right now: with about two months left for the event, things are going to start picking up a lot of momentum now!

Arjun's AI Escapades Class

Aug 15, 2023-Aug 27, 2023
Hosting a series of machine learning and AI safety classes this summer!

Aug 27, 2023 Third (and final, for now) class done! Extremely grateful to have been able to teach 25+ seniors something that I'm truly passionate about.
Aug 24, 2023-Aug 26, 2023 Time sheet!
Aug 19, 2023 Announced the second edition.
Aug 17, 2023 Second class done! Was also a huge success (one my students coincidentally thought of the first thing I teach in second half of the class lol):

AAE - Second

Aug 15, 2023 Got the presentation done in the nick of time, and a successful first class!

AAE - First

RTA Hackathon

Aug 24, 2023-Aug 25, 2023
Participated in RTA's sustainability ~hackathon!

Summary

A lot of work happened before the start date given here: including finalizing our idea (an app to provide a sustainable transport mode given a particular route) and many meetings. But overall, it was a fun (and exhausting) time that had an incredible class on entrepreneurship on the first day! Glad to have been a part of this chaos.

RTA Hackathon

SOLARIS (Third Edition)

Jul 08, 2023-Aug 24, 2023
One last rodeo this summer! Excited to be teaching our ten incredible students.

Aug 20, 2023-Aug 24, 2023 Certificates, and nudged for one of the projects to be published!
Aug 12, 2023-Aug 19, 2023 One of them is really, really incredible.
Aug 10, 2023 Last capstone project received!
Aug 08, 2023 Second and third capstone project received! One more...
Aug 06, 2023 First capstone project received!
Jul 29, 2023-Aug 05, 2023 All capstone project ideas should be finalised now!
Jul 27, 2023-Jul 28, 2023 Answered a doubt(s).
Jul 26, 2023 And that's a wrap! Capstone project time.

SOLARIS - 3

Jul 21, 2023-Jul 25, 2023 Did some organisational work.
Jul 20, 2023 Fourth day done!
Jul 19, 2023 Did some organisational work.
Jul 18, 2023 Third day done!
Jul 15, 2023-Jul 17, 2023 Did some organisational work.
Jul 13, 2023 Second day done!
Jul 12, 2023 Welp, got postponed to tomorrow.
Jul 11, 2023 First day done!
Jul 08, 2023 With all the prep work out of the way, just a couple days left before the first class!

Mathematics for Machine Learning

Jul 04, 2022-Aug 22, 2023
Learnt the linear algebra, multivariate calculus and principal component analysis behind machine learning.

Log

Aug 19, 2023-Aug 22, 2023 Finished the penultimate week, and finished the course, thus marking the end of this project!
Aug 17, 2023 Admin work, will finish this project for good by Tuesday.
Aug 07, 2023-Aug 16, 2023 Better late than never.
May 07, 2023 Continued with Week 3.
Mar 20, 2023 Continued with Week 3.
Mar 19, 2023 "Continued" with Week 3.
Mar 18, 2023 Continued with Week 3.
Mar 15, 2023 "Continued" with the course.
Mar 14, 2023 "Continued" with the course.
Mar 11, 2023 Finally finished week 1 after finishing week 2.
Mar 10, 2023 Figured out the cov_naive(x) function!
Mar 09, 2023 Trying to finish week 1.
Mar 08, 2023 Finished with week 2, for the most part.
Mar 07, 2023 Finished my programming assignment for week 2!
Feb 19, 2023 Continued with the course.
Feb 18, 2023 Continued with the course. My programming assignment for week 2 needs a lot more work (and I haven't even finished my week 1 programming assignment...).
Feb 17, 2023 Continued with the course.
Feb 16, 2023 Continued with the course.
Feb 15, 2023 Continued with the course.
Feb 12, 2023 Continued with the course.
Feb 11, 2023 Continued with the course.
Feb 10, 2023 Continued with the course.
Feb 09, 2023 Continued with the course.
Feb 08, 2023 Continued with the course.
Feb 07, 2023 Continued with the course.
Feb 06, 2023 Continued with the course.
Feb 04, 2023 Continued with the course.
Feb 03, 2023 Made good progress on the programming assignment for Week 1.
Feb 02, 2023 Continued with the course.
Feb 01, 2023 Continued with the course.
Jan 27, 2023 Continued with the course.
Jan 25, 2023 "Continued" with the course.
Jan 22, 2023 Continued with the course.
Jan 21, 2023 Continued with the course.
Jan 20, 2023 Continued with the course.
Jan 19, 2023 "Continued" with the course.
Jan 18, 2023 Continued with the course.
Jan 17, 2023 "Continued" with the course.
Jan 16, 2023 "Continued" with the course.
Jan 15, 2023 "Continued" with the course.
Jan 04, 2023-Jan 11, 2023 "Continued" with the course.
Jan 04, 2023 Continued with Week 1 and got 100% on the practice quiz!
Jan 03, 2023 Continued with Week 1.
Jan 02, 2023 Got started with Week 1 of Principal Component Analysis.
Dec 19, 2022 Finished with Week 6 and hence finished with the multivariate calculus course! Will (hopefully) start Principal Component Analysis on Jan 2023.
Dec 18, 2022 Nearly finished with Week 6.
Dec 17, 2022 Finished with Week 5.
Dec 16, 2022 Continued with Week 5, nearly done after passing a really hard assignment.
Nov 18, 2022 Continued with Week 5.
Nov 09, 2022 "Continued" with "Week 5".
Nov 08, 2022 "Continued" with "Week 5".
Nov 04, 2022 "Continued" with "Week 5".
Nov 03, 2022 Continued with Week 5.
Nov 02, 2022 "Continued" with "Week 5".
Nov 01, 2022 Continued with Week 5.
Oct 31, 2022 Continued with Week 5.
Oct 30, 2022 Continued with Week 5.
Oct 29, 2022 Continued with Week 5.
Oct 28, 2022 Continued with Week 5.
Oct 27, 2022 Got started with Week 5.
Oct 26, 2022 Finished with Week 4.
Oct 25, 2022 Continued with Week 4.
Oct 24, 2022 Continued with Week 4.
Oct 23, 2022 Continued with Week 4 and got 95% on my practice quiz on the first attempt!
Oct 22, 2022 Continued with Week 4.
Oct 21, 2022 Continued with Week 4.
Oct 19, 2022 Continued with Week 4.
Oct 18, 2022 Continued with Week 4.
Oct 17, 2022 Continued with Week 4.
Oct 16, 2022 Continued with Week 4.
Oct 11, 2022 Continued with Week 4.
Oct 10, 2022 Got started with Week 4.
Oct 09, 2022 Got started with Week 4.
Oct 08, 2022 Finished with Week 3! Here's my backpropagation submission:
Oct 07, 2022 Continued with Week 3.
Oct 06, 2022 Continued with Week 3.
Oct 05, 2022 Continued with Week 3.
Oct 04, 2022 Continued with Week 3.
Sep 30, 2022 "Continued" with Week 3.
Sep 29, 2022 Continued with Week 3 and got 100% on the practice quiz!
Sep 28, 2022 Continued (?) with Week 3.
Sep 27, 2022 Continued (?) with Week 3.
Sep 26, 2022 Continued with Week 3.
Sep 25, 2022 Got started with Week 3.
Sep 18, 2022 Finished with Week 2 and got 100% on the practice quiz!
Sep 04, 2022 Continued with Week 2. Nearly done.
Aug 26, 2022 Continued with Week 2 and got 100% on the practice quiz!
Aug 25, 2022 Continued with Week 2 and learnt about the Hessian.
Aug 24, 2022 Continued with Week 2.
Aug 23, 2022 Continued with Week 2.
Aug 22, 2022 Continued with Week 2.
Aug 20, 2022 Continued with Week 2.
Aug 19, 2022 Continued with Week 2.
Aug 18, 2022 Continued with Week 2 and got 100% on the practice quiz!
Aug 17, 2022 Continued with Week 2 and learnt about the Jacobian.
Aug 16, 2022 Got started with Week 2.
Aug 15, 2022 Finished with Week 1 and got 100% on the final quiz!
Aug 14, 2022 Continued with Week 1. Nearly (nearly) done.
Aug 13, 2022 Continued with Week 1. Nearly done.
Aug 12, 2022 Continued with Week 1.
Aug 11, 2022 Continued with Week 1.
Aug 10, 2022 Continued with Week 1.
Aug 09, 2022 Finished and earned my certificate for the Linear Algebra course!
Aug 08, 2022 Got started with the final assessment for linear algebra.
Aug 07, 2022 Finished the last programming assignment for Week 5 and continued with Week 1 (Calculus), going to finish the linear algebra course tomorrow!
Aug 06, 2022 Continued with Week 5 and Week 1 (Calculus).
Aug 04, 2022 Continued with Week 5 and learnt about PageRank. Lots to finish up tomorrow (and review simultaneously) so I can focus on multivariate calculus.
Aug 02, 2022 Continued with Week 5 and learnt about eigenbasis.
Aug 01, 2022 Continued with Week 5 after passing the second eigenvector quiz.
Jul 31, 2022 Continued with Week 5.
Jul 30, 2022 Continued with Week 5 (LA) and got started with the multivariate calculus (MC) course!
Jul 29, 2022 Continued with Week 5 and finally learnt what eigenvalues are!
Jul 28, 2022 Continued with Week 5. I finally know, at least on a surface level, what eigenvectors are. But what about eigenvalues?
Jul 27, 2022 Got started with Week 5.
Jul 26, 2022 Finished with Week 4.
Jul 25, 2022 Nearly finished with Week 4.
Jul 23, 2022 Continued with Week 4 and learnt about transforming a matrix in another plane (in an easier way). I'm going to miss David Dye, he was a phenomenal lecturer in this course.
Jul 21, 2022 Continued with Week 4 and got a perfect score on my Gram-Schmidt assignement on first submit.
Jul 20, 2022 Continued with Week 4 and learnt about the Gram-Schmidt process.
Jul 19, 2022 Continued with Week 4 and learnt about transposing a matrix and orthonormal matrices.
Jul 18, 2022 Continued with Week 4.
Jul 17, 2022 Just passed the hard practice test for this week on first attempt.
Jul 16, 2022 Got started with Week 4 and learnt about Einstein's summation convention and symmetry with the dot product.
Jul 15, 2022 Finished with Week 3.
Jul 14, 2022 Nearly finished with Week 3.
Jul 12, 2022 Learnt about matrix inverses and Gaussian Elimination.
Jul 11, 2022 Finished with the matrix transformation quiz.
Jul 10, 2022 Learnt about matrix transformations.
Jul 09, 2022 Got started with week 3 with matrices.
Jul 08, 2022 Finished with week 2!
Jul 07, 2022 Learnt about changing basis and got another 100%!
Jul 06, 2022 Finished with week 1 (the reply thing wasn't optional lol), learnt about the dot product with the cosine rule, projects and got 100% on the quiz!
Jul 05, 2022 Learnt about operations, modulus and dot product.
Jul 04, 2022 Got started with the course!

YCM Youth Meet-up

Aug 10, 2023
Attended Youth Creative Minds' Youth meet-up!

Summary

Had a great time at Khaleej Times x YCM's youth meet-up, got a chance to speak about climate denialism and it was, overall, a fun experience meeting some of my seniors!

Khaleej Times

Machine Learning Safety Course

Jun 24, 2023
~Finished the ML Safety course (Intro to ML Safety) in one day and made a guide/blog post on it.

Summary

This was quite an experience - finished going through the ML Safety Course by the Center for AI Safety and made a guide/post from my notes.

SOLARIS (Second Edition)

Dec 24, 2022-Jul 01, 2023
Trying to co-run the second edition of a logic, rationality and Effective Altruism club that I co-founded. Currently inactive/paused.

Log

Jul 01, 2023 Sent out the certificates. See y'all for the last SOLARIS that I'll be facilitating!
Mar 16, 2023-Mar 18, 2023 Did some organisational work.
Mar 15, 2023 Did some organisational work.
Feb 01, 2023 Sent out my three capstone project reviews.
Jan 27, 2023 Had the last meeting for a while, thus marking the end of this project (for now!)
Jan 25, 2023 Scheduled the last meeting for a while.
Jan 21, 2023 Finished reviewing two more capstone projects.
Jan 20, 2023 Reviewed the first capstone project.
Jan 18, 2023 Received capstone projects. Closing ceremony will be delayed but for now, will host an online meeting to discuss the projects.
Jan 17, 2023 In discussion regarding the closing ceremony.
Jan 16, 2023 In discussion regarding the closing ceremony.
Jan 05, 2023-Jan 14, 2023 Did some more organisational work, held the last (technically fourth) day and sent out the capstone project submission form!
Jan 04, 2023 Did some organisational work.
Jan 03, 2023 Did some organisational work.
Jan 02, 2023 Did some organisational work.
Jan 01, 2023 Did some organisational work.
Dec 31, 2022 Did some more organisational work. Here's to this project becoming even more ambitious in 2023!
Dec 30, 2022 Did some organisational work in the morning, but I couldn't teach today's class due to internet issues. We'll be combining this session and the last day (which I feel is something we should do regardless).
Dec 28, 2022 An okay third day, but this part of the syllabus really needs to be re-vamped.
Dec 26, 2022 Second day went better than the first: espicially since we had really good debate responses and rebuttals.
Dec 24, 2022 First day! Along with my co-facilitator, we gave a good overview about rationality.

GFSMUN III

Jun 23, 2023-Jun 25, 2023
Attended GFSMUN 2023 as part of my school team, and won best speaker!

Summary

From ditching a portion of the first day (and missing my chance for a GSL) for prom to the odd crisis where I became Mark Zuckerberg to me beefing with the delegate of Nigeria (who won best delegate, well deserved!), GFSMUN III and the United Nations Office for Outer Space Affairs was one heck of a MUN and committee respectively. Shout out to my incredible chairs (who nit-picked on the number of hours I stated on my first position paper lol)

GFSMUN III

Local Hackathon 2023

Jun 19, 2023-Jun 20, 2023
From participant to organiser this time around! The start date for this project represents when the auditions were conducted.

Summary

From the okay-ish auditions (which were mostly my doing) came a really fun hackathon: the teams were assigned to create an encryption/decryption app using Tkinter in Python. In the beginning, a fun plot line involving the FBI/CIA and spying emerged. Was quite fun!

Local Hackathon - 2023

YGSS 2023

May 12, 2023-May 14, 2023
I was a resource head for the Earth and Climate Change Council and a member of the IT team. Won best counci.l

Summary

This whole project should be prefaced by the sheer amount of work that had gone into it: from my main work as a resource head for the Earth and Climate Change council: working on the agenda document, the background guide and the video with my co-resource head and directors - as well as helping out with the website as part of the IT team.

With that being said, what an incredible event, so glad to have been (somewhat) randomly selected for ECC - I'd like to think I was a pretty darn good resource head, and won best council with my incredible directors, co-resource head, IT and press members.

ECC

freeCodeCamp

Oct 28, 2021-Mar 18, 2023
Trying to finish freeCodeCamp.org's curriculum by the end of 2023.

freeCodeCamp.org's start date is the date I started logging, not the date when the project started.

Log

May 07, 2023 Happy to call an end to this project - really proud of all the certificates that I've earned and the mini-projects I made for them. As I mentioned in one of my blog posts for 2022, I won't (and have not yet) hesitate to recommend freeCodeCamp to anyone who wishes to learn how to code.
Mar 18, 2023 Continued with the Data Analysis with Python course.
Jan 27, 2023 "Continued" with the Medical Data Visualizer project.
Jan 25, 2023 "Continued" with the Medical Data Visualizer project.
Jan 21, 2023 "Continued" with the Medical Data Visualizer project.
Jan 20, 2023 Continued with the Medical Data Visualizer project.
Jan 18, 2023 Continued with the Medical Data Visualizer project.
Jan 16, 2023 "Continued" with the Medical Data Visualizer project.
Jan 04, 2023 Continued with the Medical Data Visualizer project.
Jan 03, 2023 "Continued" with the Medical Data Visualizer project.
Jan 02, 2023 "Got started" with the Medical Data Visualizer project.
Jan 01, 2023 Finished the Demographic Data Analyzer Project (here it is).
Dec 31, 2022 Continued with the Demographic Data Analyzer project. Figured out the roadblock. I hope to finish the last three remaining certificates by the first half of 2023.
Dec 30, 2022 Continued with the Demographic Data Analyzer project. Sort of hit a roadblock, but I'll figure it out (hopefully).
Dec 29, 2022 Continued with the Demographic Data Analyzer project.
Dec 28, 2022 Got started with the Demographic Data Analyzer project.
Dec 27, 2022 Finished with the Mean-Variance-Standard Deviation Calculator project (here it is).
Dec 26, 2022 Continued with Data Analysis with Python.
Dec 25, 2022 Continued with Data Analysis with Python.
Dec 24, 2022 Continued with Data Analysis with Python.
Dec 23, 2022 Continued with Data Analysis with Python.
Dec 22, 2022 Continued with Data Analysis with Python.
Dec 21, 2022 Continued with Data Analysis with Python.
Dec 20, 2022 Got started with Data Analysis with Python.
Dec 19, 2022 Finished with the Probability Calculator Project project (here it is) and earned my certification for Scientific Computing with Python (yes, I know the budget app project isn't fully finished, but I wanted to move on). Only three more certifications left!
Dec 18, 2022 Finished with the Polygon Area Calculator Project project (here it is).
Dec 16, 2022 Been a while. Continued with the Budget App Project and I plan to just finish my Python certification before the end of the year (and early next year, try to finish databases).
Nov 26, 2022 "Continued" with the Budget App Project.
Nov 18, 2022 Continued with the Budget App Project.
Nov 16, 2022 "Continued" with the Budget App Project.
Nov 15, 2022 Continued with the Budget App Project.
Nov 13, 2022 Continued with the Budget App Project.
Nov 12, 2022 Continued with the Budget App Project. Should finish up this upcoming week.
Nov 11, 2022 Continued with the Budget App Project.
Nov 10, 2022 Continued with the Budget App Project.
Nov 09, 2022 Continued with the Budget App Project.
Nov 08, 2022 Continued with the Budget App Project.
Nov 04, 2022 Continued with the Budget App Project.
Nov 03, 2022 Continued with the Budget App Project.
Nov 02, 2022 Continued with the Budget App Project.
Nov 01, 2022 Continued with the Budget App Project.
Oct 31, 2022 Continued with the Budget App Project.
Oct 30, 2022 Continued with the Budget App Project.
Oct 29, 2022 Got started with the Budget App Project.
Oct 28, 2022 1 year since this project started! Finished with the Time Calculator Project, here it is.
Oct 27, 2022 Continued with the Time Calculator Project. Writing down my logic really helped, really close now (just need to fix the AM/PM and -12 logic for 24-hour format).
Oct 26, 2022 "Continued" with the Time Calculator Project.
Oct 25, 2022 Continued with the Time Calculator Project. Need to map out my logic on paper tomorrow to see where I'm going wrong.
Oct 24, 2022 Continued with the Time Calculator Project. Getting somewhat close.
Oct 23, 2022 Continued with the Time Calculator Project.
Oct 22, 2022 Continued with the Time Calculator Project.
Oct 21, 2022 Continued with the Time Calculator Project.
Oct 20, 2022 Continued with the Time Calculator Project.
Oct 19, 2022 Continued with the Time Calculator Project.
Oct 18, 2022 Continued with the Time Calculator Project.
Oct 17, 2022 Never mind, I won't finish the project today, but I made some great progress! I think I just need to fix the AM/PM and calculate next days.
Oct 16, 2022 Continued with the Time Calculator Project. I'll try to finish this project by Oct 17.
Oct 11, 2022 Got started with the Time Calculator Project.
Oct 10, 2022 Finished with the Arithmetic Formatter project! Here it is.
Oct 09, 2022 Continued with the Arithmetic Formatter project. Still can't get the test cases to pass but I think I'm getting close.
Oct 08, 2022 Continued with the Arithmetic Formatter project. I can't get my solution to pass the test cases (even though the output looks to be correct) for some reason, will keep trying tomorrow.
Oct 07, 2022 Continued with the Arithmetic Formatter project and fixed the alignment of the numbers! Will finish the project tomorrow.
Oct 06, 2022 Continued with the Arithmetic Formatter project.
Oct 05, 2022 Continued with the Arithmetic Formatter project. I'm sort of close to fixing the arrangement.
Oct 04, 2022 Continued with the Arithmetic Formatter project.
Oct 02, 2022 Continued with the Arithmetic Formatter project.
Oct 01, 2022 Continued with the Arithmetic Formatter project.
Sep 30, 2022 "Continued" with the Arithmetic Formatter project.
Sep 29, 2022 Continued with the Arithmetic Formatter project.
Sep 28, 2022 Continued with the Arithmetic Formatter project.
Sep 27, 2022 Got started with Relational Database.
Sep 26, 2022 Continued with Responsive Web Design.
Sep 25, 2022 Continued (?) with the Arithmetic Formatter project and continued with Responsive Web Design.
Sep 24, 2022 Continued with Responsive Web Design.
Sep 23, 2022 Continued with Responsive Web Design.
Sep 22, 2022 Continued with Responsive Web Design.
Sep 21, 2022 Continued with Responsive Web Design.
Sep 20, 2022 Continued with Responsive Web Design.
Sep 19, 2022 Continued with Responsive Web Design.
Sep 18, 2022 Progress! I finally got the problems to print horizontally for the Arithmetic Formatter project. Also continued with Responsive Web Design.
Sep 17, 2022 "Continued" with the Arithmetic Formatter project and continued with Responsive Web Design.
Sep 16, 2022 Continued with the Arithmetic Formatter project and continued with Responsive Web Design.
Sep 15, 2022 Continued with the Arithmetic Formatter project and continued with Responsive Web Design.
Sep 14, 2022 Continued with the Arithmetic Formatter project and continued with Responsive Web Design.
Sep 13, 2022 Continued with Responsive Web Design.
Sep 12, 2022 Continued with Responsive Web Design.
Sep 11, 2022 Continued with Responsive Web Design.
Sep 10, 2022 Continued with Responsive Web Design.
Sep 09, 2022 Continued with Responsive Web Design.
Sep 08, 2022 Continued with Responsive Web Design.
Sep 07, 2022 Continued with Responsive Web Design.
Sep 06, 2022 Continued with Responsive Web Design.
Sep 05, 2022 Continued with Responsive Web Design.
Sep 04, 2022 Continued with Responsive Web Design.
Sep 03, 2022 Continued with Responsive Web Design.
Sep 02, 2022 Continued with Responsive Web Design.
Sep 01, 2022 Continued with Responsive Web Design.
Aug 31, 2022 Continued with Responsive Web Design.
Aug 30, 2022 Continued with Responsive Web Design.
Aug 29, 2022 Continued with Responsive Web Design.
Aug 28, 2022 Continued with Responsive Web Design.
Aug 27, 2022 Continued with Responsive Web Design.
Aug 26, 2022 Continued with Responsive Web Design.
Aug 25, 2022 Continued with the Arithmetic Formatter project and continued with Responsive Web Design.
Aug 24, 2022 Continued with Responsive Web Design.
Aug 23, 2022 Finished with error handling (?) for the Arithmetic Formatter project and continued with Responsive Web Design.
Aug 22, 2022 Finished with the Scientific Computing with Python lectures. On to the projects!
Aug 21, 2022 Continued with Responsive Web Design.
Aug 20, 2022 Continued with Responsive Web Design.
Aug 19, 2022 Continued with Responsive Web Design.
Aug 18, 2022 Continued with Responsive Web Design.
Aug 17, 2022 Continued with Scientific Computing with Python.
Aug 16, 2022 Continued with Responsive Web Design.
Aug 15, 2022 Continued with Responsive Web Design.
Aug 14, 2022 Continued with Responsive Web Design.
Aug 13, 2022 Continued with Responsive Web Design.
Aug 12, 2022 Continued with Responsive Web Design.
Aug 11, 2022 Continued with Scientific Computing with Python.
Aug 10, 2022 Continued with Scientific Computing with Python.
Aug 09, 2022 Continued with Scientific Computing with Python.
Aug 08, 2022 Continued with Responsive Web Design.
Aug 07, 2022 Continued with Scientific Computing with Python.
Aug 06, 2022 Contunued with Scientific Computing with Python. Nearly done with the videos.
Aug 05, 2022 Contunued with Scientific Computing with Python. Never repeat string data more than once.
Aug 04, 2022 Continued with Scientific Computing with Python.
Aug 03, 2022 Continued with Scientific Computing with Python.
Aug 02, 2022 Continued with Scientific Computing with Python.
Aug 01, 2022 Continued with Scientific Computing with Python.
Jul 31, 2022 Continued with Scientific Computing with Python.
Jul 30, 2022 Continued with Scientific Computing with Python.
Jul 29, 2022 Continued with Scientific Computing with Python. JSON all the way.
Jul 28, 2022 Continued with Scientific Computing with Python.
Jul 27, 2022 Continued with Scientific Computing with Python.
Jul 26, 2022 Continued with Scientific Computing with Python.
Jul 25, 2022 Continued with Responsive Web Design.
Jul 24, 2022 Continued with Scientific Computing with Python. RFC is a nice easter egg.
Jul 23, 2022 Continued with Scientific Computing with Python.
Jul 22, 2022 Continued with Scientific Computing with Python.
Jul 21, 2022 Continued with Scientific Computing with Python.
Jul 20, 2022 Continued with Scientific Computing with Python.
Jul 19, 2022 Continued with Scientific Computing with Python.
Jul 18, 2022 Continued with Scientific Computing with Python.
Jul 17, 2022 Continued with Scientific Computing with Python.
Jul 16, 2022 Continued with Scientific Computing with Python.
Jul 15, 2022 Continued with Scientific Computing with Python.
Jul 14, 2022 Continued with Responsive Web Design.
Jul 13, 2022 Continued with Responsive Web Design.
Jul 12, 2022 Continued with Scientific Computing with Python.
Jul 11, 2022 Continued with Responsive Web Design.
Jul 10, 2022 Continued with Responsive Web Design.
Jul 09, 2022 Continued with Scientific Computing with Python.
Jul 08, 2022 Continued with Scientific Computing with Python.
Jul 07, 2022 Continued with Scientific Computing with Python.
Jul 06, 2022 Continued with Scientific Computing with Python.
Jul 05, 2022 Continued with Scientific Computing with Python. I think the website went down?
Jul 04, 2022 Continued with Scientific Computing with Python.
Jul 03, 2022 Continued with Responsive Web Design.
Jul 02, 2022 Continued with Responsive Web Design.
Jul 01, 2022 Continued with Responsive Web Design.
Jun 30, 2022 Continued with Responsive Web Design.
Jun 29, 2022 Continued with Responsive Web Design.
Jun 28, 2022 Continued with Responsive Web Design.
Jun 27, 2022 Continued with Scientific Computing with Python.
Jun 26, 2022 Continued with Responsive Web Design.
Jun 25, 2022 Continued with Responsive Web Design.
Jun 24, 2022 Continued with Responsive Web Design.
Jun 23, 2022 Continued with Scientific Computing with Python.
Jun 22, 2022 Continued with Scientific Computing with Python.
Jun 21, 2022 Continued with Responsive Web Design.
Jun 20, 2022 Got started with Scientific Computing with Python.
Jun 19, 2022 Finally, finished with the American/British English Translator project (here it is) and finished with Quality Assurance. Oh, and also continued with Responsive Web Design.
Jun 18, 2022 Continued with the translator project (two more test cases left, though I'll be honest and say that I sort of skipped the other two test cases) and with Responsive Web Design.
Jun 17, 2022 Continued with the translator project (four more test cases to go) and with Responsive Web Design.
Jun 16, 2022 Continued with Responsive Web Design.
Jun 15, 2022 Continued with Responsive Web Design.
Jun 14, 2022 Continued with Responsive Web Design.
Jun 13, 2022 Continued with Responsive Web Design.
Jun 12, 2022 "Continued" with the translator project and with Responsive Web Design.
Jun 11, 2022 Continued with the translator project (though progress has been sort of slow) and with Responsive Web Design.
Jun 10, 2022 Continued with the translator project (sort of fixed the RegEx and figured out how to make the text green) and with Responsive Web Design.
Jun 09, 2022 Continued with Responsive Web Design.
Jun 08, 2022 Continued with Responsive Web Design.
Jun 07, 2022 Continued with Responsive Web Design.
Jun 06, 2022 Continued with the translator project (sort of finished the British to American English part, on to getting the text green lol) and with Responsive Web Design.
Jun 05, 2022 Continued with the translator project (did some VSCode magic to flip the JS objects for the British to American English part) and with Responsive Web Design.
Jun 04, 2022 Continued with Responsive Web Design.
Jun 03, 2022 Continued with the translator project (I need to figure out the highlight functionality, how do I insert a <span> element within the Express res?) and with Responsive Web Design.
Jun 02, 2022 Continued with the translator project and with Responsive Web Design.
Jun 01, 2022 Continued with the translator project (the American to British English part is very buggy but it sort of works) and with Responsive Web Design.
May 31, 2022 Continued with Responsive Web Design.
May 30, 2022 Continued with Responsive Web Design.
May 29, 2022 Continued with the translator project (working on the American to British English part) and with Responsive Web Design.
May 28, 2022 Sort of got started with the last project for Quality Assurance, American-British English Translator and continued with Responsive Web Design.
May 27, 2022 Finished with the Sudoku Solver project (here it is) and continued with Responsive Web Design.
May 26, 2022 One more test case left and continued with Responsive Web Design.
May 25, 2022 Three more tests cases left and continued with Responsive Web Design.
May 24, 2022 Four more tests cases left for the Sudoku Solver project! Also continued with Responsive Web Design.
May 23, 2022 Continued with the Sudoku Solver project (about half way done with all the /api/check test cases) and with Responsive Web Design.
May 22, 2022 Continued with the Sudoku Solver project (I've got an annoying glitch for the region placement check) and with Responsive Web Design.
May 21, 2022 Continued with the Sudoku Solver project and with Responsive Web Design.
May 20, 2022 Continued with the Sudoku Solver project and with Responsive Web Design.
May 19, 2022 Continued with the Sudoku Solver project (finished the solve part with this algorithm, which I referred to due to this) and with Responsive Web Design.
May 18, 2022 Continued with the Sudoku Solver project and with Responsive Web Design.
May 17, 2022 Continued with the Sudoku Solver project (finished translating the helper function from (1, 2) for the main backtracking function) and continued with Responsive Web Design.
May 15, 2022 Continued with the Sudoku Solver project (got the regex stuff to work and got started with the solving part) and continued with Responsive Web Design.
May 15, 2022 Continued with the Sudoku Solver project and continued with beta Responsive Web Design.
May 14, 2022 Got started with the Sudoku Solver project and finished with a section for beta Responsive Web Design (which recently graduated to the default Responsive Web Design!)
May 13, 2022 Finished with the Personal Library project by intentionally leaving a test case broken :/ (here it is) Also continued with beta Responsive Web Design.
May 12, 2022 AAAAAAAAAA This is a really complicated situation: I wrote all the functional tests and a) Replit keeps crashing after all the tests pass (unless I do a weird port trick) b) Even though the POST comment test case works without the tests, it refuses to pass after all the tests pass. This is probably the second or third most frustrating project I worked on (the most frustrating was probably the JavaScript calculator)
May 11, 2022 Got the comment POST test case to pass, on to the GET test case. Also continued with beta Responsive Web Design.
May 10, 2022 The comment array seems to be less broken and continued with beta Responsive Web Design.
May 09, 2022 Got the delete all test case to pass and the comment array is, uh, there? (it's really broken). I also continued with beta responsive web design.
May 08, 2022 Continued with beta Responsive Web Design but didn't make a ton of progress with the Personal Library project (the comment system looks a bit daunting, I don't think I've worked with arrays in MongoDB before)
May 07, 2022 Got started with the Personal Library project and continued with beta Responsive Web Design.
May 06, 2022 Finished the Issue Tracker project (here it is) and continued with beta Responsive Web Design.
May 05, 2022 DELETE is done and continued with beta Responsive Web Design.
May 04, 2022 I now only have the PUT and DELETE functionality to program + the tests! Also continued with beta Responsive Web Design.
May 03, 2022 Got a decent amount of tests cases for the Issue Tracker project (I need to fix a schema glitch for the GET request) and continued with beta Responsive Web Design.
May 02, 2022 Continued with the Issue Tracker project and continued with beta Responsive Web Design.
May 01, 2022 Got started with the Issue Tracker Project and continued with beta Responsive Web Design.
Apr 30, 2022 I finally got done with the Metric-Imperial Converter Project (here it is) and continued with beta Responsive Web Design.
Apr 29, 2022 AAAAAAAAAA I finished all the tests but freeCodeCamp keeps failing the 16 units test test, it feels like I've tried everything to fixed it.
Apr 28, 2022 Finished those last two non-test test cases and continued with beta Responsive Web Design. I don't like how we're (to my knowledge) force to use eval for this project.
Apr 27, 2022 Excluding the the two test cases for the test (which I'm dreading lol), I only have two more tests! Also continued with beta Responsive Web Design.
Apr 26, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 25, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 24, 2022 Got the "all incoming units..." test to pass and continued with beta Responsive Web Design (which I did for yesterday also, oops).
Apr 23, 2022 Got the "invalid unit" test to pass, need to get the "invalid number" and "invalid number and unit" tests to pass.
Apr 22, 2022 Got a decent amount of test cases to pass after adding rounding to 5 decimal places and continued with beta Responsive Web Design.
Apr 21, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 20, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 19, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 18, 2022 Continued with the Metric-Imperial Converter project (got most of the converter to work) and beta Responsive Web Design (I'm only going to do one challenge from now so I don't run out of them lol).
Apr 17, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design (also, this is pretty late but the issue I opened on the 4th got resolved).
Apr 16, 2022 Continued with the Metric-Imperial Converter project and beta Responsive Web Design.
Apr 15, 2022 Got started with the Metric-Imperial Converter project and continued with beta Responsive Web Design.
Apr 14, 2022 Finished all the coding challenges for Advanced Node and Express. I didn't like the chat application part, mainly because the test cases were too lenient and you could pass a lot of them with a non-functional project. Anyways, I also continued with beta Responsive Web Design.
Apr 13, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design (finished a section).
Apr 12, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 11, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design. Why did I never discover Passport during the bettermailto project?
Apr 10, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 09, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design. Why is CSS grid so complicated?
Apr 08, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 07, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 06, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 05, 2022 Continued with Advanced Node and Express and with beta Responsive Web Design.
Apr 04, 2022 Got started with Advanced Node and Express, continued with beta Responsive Web Design and opened an issue on GitHub.
Apr 03, 2022 Finished Quality Assurance and Testing with Chai and continued with beta Responsive Web Design! I finally understand what all this Chai business does. Going to start with Advanced Node and Express from tomorrow.
Apr 02, 2022 Just realized that I lost my ~180-day streak (probably because of time zones), though it doesn't really matter. Continued with beta Responsive Web Design and Quality Assurance.
Apr 01, 2022 Continued with beta Responsive Web Design and Quality Assurance.
Mar 31, 2022 Continued with beta Responsive Web Design and Quality Assurance.
Mar 30, 2022 Continued with beta Responsive Web Design and Quality Assurance.
Mar 29, 2022 Continued with beta Responsive Web Design and got started with Quality Assurance again (as I've forgotten a lot about it and I need that knowledge for my Information Security project)
Mar 28, 2022 Continued with beta Responsive Web Design.
Mar 27, 2022 Continued with beta Responsive Web Design.
Mar 26, 2022 Continued with beta Responsive Web Design.
Mar 25, 2022 Continued with beta Responsive Web Design.
Mar 24, 2022 Couldn't get much of anything done for the project, but continued with beta Responsive Web Design.
Mar 23, 2022 Dang it, I forgot about the tests that I had to write. This project is deceivingly big. Anyways, made a bit of progress on the project and continued with beta Responsive Web Design (also, beta Relational Database looks really cool).
Mar 22, 2022 Sort of got multiple stocks to work (the query parameter if-else conditions aren't very good though), I think I can technically submit the project now, but it's obviously not complete (need to implement the like and rel_likes features)
Mar 21, 2022 Fixed an axios glitch where it would take two refreshes to get the stock price. Got started with two stocks and continued with beta Responsive Web Design.
Mar 20, 2022 Progress on Stock Price Checker has been slow, why is it so hard to make a GET request in node.js?
Mar 19, 2022 Continued with the Stock Price Checker and Responsive Web Design.
Mar 18, 2022 Got started with the Stock Price Checker project and finished a project within beta Responsive Web Design!
Mar 17, 2022 Finally finished with the Python section of Information Security. Definitely my least favourite part of freeCodeCamp so far. Anyways, continued with beta Responsive Web Design and the Information Security projects look fun.
Mar 16, 2022 Continued with beta Responsive Web Design. Yeah, I know I've been skimping on Information Security. It'll come soon.
Mar 15, 2022 Continued with beta Responsive Web Design.
Mar 14, 2022 Continued with beta Responsive Web Design.
Mar 13, 2022 Continued with beta Responsive Web Design.
Mar 12, 2022 Finished with the tutorial project and continued with beta Responsive Web Design.
Mar 11, 2022 Got started with the tutorial project and continued with beta Responsive Web Design.
Mar 10, 2022 Learnt how to create a TCP client and continued with beta Responsive Web Design.
Mar 09, 2022 Back to learning, finished with Understanding Sockets and Creating a TCP Server and continued with beta Responsive Web Design.
Mar 08, 2022 Haha I did it! Earned my fifth certificate (here's the project) and continued with beta Responsive Web Design.
Mar 07, 2022 This forum post should help with my glitch and continued with beta Responsive Web Design.
Mar 06, 2022 I think I know why my exercise tracker project's last test case doesn't pass, I can't save multiple exercises! I'll fix that soon and I've continued with beta Responsive Web Design.
Mar 05, 2022 The last test case was close to ending me so I opened up a forum post about it and continued with beta Responsive Web Design.
Mar 04, 2022 The last test case is so dang annoying but I think I'm nearly done with it. Continued with beta Responsive Web Design.
Mar 03, 2022 One more test case left for the project! Also, continued with beta Responsive Web Design.
Mar 02, 2022 Made decent progress on the project and continued with beta Responsive Web Design.
Mar 01, 2022 My opinion on Mongoose has changed, it's actually pretty neat. Got a little less than half of the test cases done and continued with beta Responsive Web Design.
Feb 28, 2022 Got started with the behemoth of a project that is the Exercise Tracker and continued with beta Responsive Web Design.
Feb 27, 2022 Finished with the URL Shortener Project (here it is) and finished with a section of beta Responsive Web Design.
Feb 26, 2022 Nearly done with the URL Shortener project and continued with beta Responsive Web Design.
Feb 25, 2022 Finished with the File Metadata Microservice project (here it is) and continued with beta Responsive Web Design. The last two projects I have might take a bit of time...
Feb 24, 2022 Finished with the Request Header Parser Microservice project (just had to find the HTTP request headers, here's my project link on replit) and continued with beta Responsive Web Design.
Feb 23, 2022 Finished with the Timestamp project (here it is) and continued with beta Responsive Web Design.
Feb 22, 2022 Almost finished with the Timestamp project and my project in beta Responsive Web Design (which I continued with) got reset when the FCC team changed the layout!
Feb 21, 2022 Got started with the Timestamp Microservice project and finished with a section in beta Responsive Web Design.
Feb 20, 2022 Finished with MongoDB and Mongoose and finished with the challenge portion of Back End Development and APIs! Back to working on projects.
Feb 19, 2022 Continued with MongoDB and Mongoose.
Feb 18, 2022 Started with MongoDB and Mongoose and finished a project in beta Responsive Web Design.
Feb 17, 2022 Finished Basic Node and Express, I think I finally got it down now.
Feb 16, 2022 Got started with Basic Node and Express.
Feb 15, 2022 Back to learning, got started with Back End Development and APIs and finished with Managing Packages with NPM (you can find all the back-end learning on my replit in the appropriate folder).
Feb 14, 2022 I did it! Earned my data visualization certificate (here's the last project) and continued with beta Responsive Web Design.
Feb 13, 2022 Well, I figured it out the treemap project thanks to the D3 creator, Mike. Just need to add the legend and the tooltip. Should be done in ~2 days.
Feb 12, 2022 Got started with the Treemap project and continue with beta Responsive Web Design.
Feb 11, 2022 Map done! Couldn't get the tooltip test cases to pass for some reason, but here it is. I'll work on the last project tomorrow. Also continued with beta Responsive Web Design.
Feb 10, 2022 Only 3 more test cases left to pass! Also finished a project in beta Responsive Web Design.
Feb 09, 2022 LET'S GO I got the map all coloured in (the colour scheme is a little different, but that's fine), going to try to wrap this up in about 2 days.
Feb 08, 2022 Okay, colouring will be impossible if I don't use FCC's map data. Figuring out how to replace the pre-existing map data with that. Also continued with beta Responsive Web Design.
Feb 07, 2022 In the process of figuring out how to color in the map. Also continued with beta Responsive Web Design.
Feb 06, 2022 Figured out the map! Also continued with beta Responsive Web Design and finished a section within it!
Feb 05, 2022 Still figuring out the whole map thing, though I think I found my answer. Also continued with beta Responsive Web Design.
Feb 04, 2022 Got started with the map project, wondering if I can use a package to draw the US map instead of converting the data they gave into an SVG (which is too complicated). Also continued with beta Responsive Web Design.
Feb 03, 2022 Finished with the heatmap project (here's the link to it)! Will start with the penultimate project tomorrow. Also continued with beta Responsive Web Design.
Feb 02, 2022 So close to submitting my heatmap project, just need another day to make the y-axis show the month name, not the number and to add text below the legend (also, figured out the legend!) and I also continued with beta Responsive Web Design.
Feb 01, 2022 Got more than half of the test cases to pass, though I still need to figure out how to make a legend. Also continued with beta Responsive Web Design.
Jan 31, 2022 Made amazing progress! The heatmap is basically complete, just need to add a legend, fix the tooltip and pass the tests. I also continued with the beta Responsive Web Design.
Jan 30, 2022 Made good progress with the heatmap project, I got the axes set properly, it's just the squares that need work now. Also finished two projects within beta Responsive Web Design!
Jan 29, 2022 Sort of fixed the data issue with this less obscure website (I say sort of because the free account only has 10000 requests before it goes down, which is decent, but the tests that I run might exhaust that, not entirely sure) and continued with beta Responsive Web Design.
Jan 28, 2022 The same issue that came up with the bar chart project has come up again, I can't seem to find a place to store edited data. Since the FCC data is nested, it's really hard to work with, so I "unnested" it and stored it on this obscure website, but the data stored there doesn't seem to be permanent, so now I have to work on both my heatmap project and my bar chart project again.

Oh, I also continued with beta Responsive Web Design.
Jan 27, 2022 Made a bit of progress on the heat map and continued with beta Responsive Web Design.
Jan 26, 2022 Finished the scatterplot project! Yeah, there are two test cases left, but they have the same issue as the bar chart project. Here's the project. Also got started on the Heat Map project and continued with beta Responsive Web Design.
Jan 25, 2022 Didn't have much time today, so I could only continue the beta Responsive Web Design.
Jan 24, 2022 Got done with the legend, the only tests I have left relate to the annoying D3 attributes.
Jan 23, 2022 Again made great progress, I only have 5 test cases left to pass for my scatterplot project and continued with beta Responsive Web Design.
Jan 22, 2022 Made amazing progress, got the whole y-axis done and added the circles for the scatterplot. Just need to get the test cases to pass.
Jan 21, 2022 Got the y-axis almost complete and continued with beta Responsive Web Design.
Jan 20, 2022 Couldn't continue with my scatterplot (will try to finish it in the weekend) but I continued with beta Responsive Web Design. Someone in an EA Slack channel talked about FCC!
Jan 19, 2022 For some reason, it's really complicated to get minute and second formatted time on a y-axis (like this: 31:24), will continue work on it tomorrow. Also continued with beta Responsive Web Design.
Jan 18, 2022 Got started with the scatterplot project and continued with beta Responsive Web Design.
Jan 17, 2022 Couldn't fix that issue, but that's alright. Submitted my bar chart project! (see it here) and continued beta Responsive Web Design.
Jan 16, 2022 Got every test case to pass, except for one... I'll work on that tomorrow and if I can't get it, I'll just submit it. Anyways, I also continued beta Responsive Web Design.
Jan 15, 2022 Finished the tooltip, now I just need to pass all the test cases. Also continued the beta Responsive Web Design.
Jan 14, 2022 Partially added the logic for a tooltip in my bar chart project and continued with beta Responsive Web Design.
Jan 13, 2022 Continued with beta Responsive Web Design.
Jan 12, 2022 Got half of the test cases to pass for my project and continued beta Responsive Web Design.
Jan 11, 2022 Now I made some good progress, I decided to use JSON (as it was easier to store on the web) and everything except the tooltips is done.
Jan 10, 2022 Wasn't able to make much progress with my bar chart project as I wasted a lot of my time trying to figure out how to host my custom data file, anyways, I continued with beta Responsive Web Design.
Jan 09, 2022 Made good progress with my bar chart project (though the x-axis is fully destroyed) and continued with beta Responsive Web Design.
Jan 08, 2022 Continued with data visualization and the beta Responsive Web Design.
Jan 07, 2022 I'll update the 25 + 5 Clock code if any changes come up, but for now, I've earned my Front End Development Libraries certificate! Will push on with data visualization tomorrow.
Jan 06, 2022 Finished the HTML part of beta Responsive Web Design and opened up a forum post about my issues with my project.
Jan 05, 2022 Continued with beta Responsive Web Design, still have ~6 test cases left even though I should pass them. This annoying script error bug has been there for almost 2 days.
Jan 04, 2022 Continued with beta Responsive Web Design, only 6 more test cases. Also, 100-day streak!
Jan 03, 2022 Continued with beta Responsive Web Design and I only have 8 more test cases to pass for my 25 + 5 clock!
Jan 02, 2022 Continued with beta Responsive Web Design and sort of made the timer functional, though there is some weird script error.
Jan 01, 2022 Continued with beta Responsive Web Design and made a breakthrough with my 25 + 5 project, I figured out that there should be two states for seconds, one for math and another to be displayed. Hopefully, I'll get this project complete and earn my certificate by the end of this week!
Dec 31, 2021 Continued with the beta version of Responsive Web Design and my 25 + 5 Clock project. Hope to get almost fully through FCC in 2022!
Dec 30, 2021 These front-end projects take so, so long. And if you take a few days to build them, your streak gets wrecked. So I was desperate, I was so tired from my 25 + 5 Clock project that I started to do my data visualization projects, thinking they would be faster to do than the front-end projects (they weren't).

But then, just as I was about to give up, I saw... this. This not only saved my streak for today, but my streak for years to come as I can speedrun this on the side and finish my projects without melting my brain by trying to do it all in one day.

Thank you, whoever thought of this. (Side note: This is actually a cool idea on its own, I really dig the new design on these challenges.)
Dec 29, 2021 Finished the JavaScript Calculator project (see it here)
Dec 28, 2021 Finished the Markdown Previewer project and the Drum Machine project (see it here), only two more projects left till I earn my certification!
Dec 27, 2021 Finished Random Quote Machine project and partially completed the Markdown Previewer project (see it here).
Dec 26, 2021 Sigh, I spent almost 2 hours just to end up with a half baked Random Quote Machine submission. I'll work on it tomorrow.
Dec 25, 2021 Finished the JavaScript part of the curriculum.
Dec 24, 2021 Completed Cash Register and earned my certification!
Dec 23, 2021 Completed Roman Numeral Converter.
Dec 22, 2021 Continued with the JavaScript questions I left.
Dec 21, 2021 Continued with the JavaScript questions I left.
Dec 20, 2021 Continued with the JavaScript questions I left.
Dec 19, 2021 Continued with the JavaScript questions I left.
Dec 18, 2021 Started with Random Quote Machine and continued with the JavaScript questions I left.
Dec 17, 2021 Finished React and Redux.
Dec 16, 2021 Continued with the JavaScript questions I left and completed the projects Caesar Cipher and Telephone Number Validator.
Dec 15, 2021 Continued with the JavaScript questions I left.
Dec 14, 2021 Continued with the JavaScript questions I left.
Dec 13, 2021 Continued with the JavaScript questions I left.
Dec 12, 2021 Continued with the JavaScript questions I left, it's nice to see my LeetCode practicing paying off (kinda).
Dec 11, 2021 Continuing with the JavaScript questions I left, hope to earn my JavaScript certification soon!
Dec 10, 2021 Finished Redux.
Dec 09, 2021 Completed my last responsive web design project and earned my certification!
Dec 08, 2021 Going to take some time out to finish my pending projects, won't look good on my heat map, but oh well. Finished my Technical Documentation project (here's the project).
Dec 07, 2021 Continued with Quality Assurance.
Dec 06, 2021 Continued with Quality Assurance and JavaScript.
Dec 05, 2021 My PR got accepted! Also started with Quality Assurance.
Dec 04, 2021 Continued with Information Security and unfinished challenges. Also opened up a PR to fix a grammar issue in Information Security.
Dec 03, 2021 Continued with Information Security and finished off some challenges I left previously.
Dec 02, 2021 Finished JSON APIs and AJAX and started with Information Security, this stuff is incredibly useful! I wish I learnt about Helmet.js earlier.
Dec 01, 2021 Finished with D3 and nearly finished JSON APIs and AJAX.
Nov 30, 2021 Continued with D3 and held a perfect streak for the whole month!
Nov 29, 2021 Continued with D3.
Nov 28, 2021 Finished my kanyewest.com's Donda Stem Player re-creation and continued with D3.
Nov 27, 2021 Continued with Redux and started with React with Redux and Data Visualization with D3 just to get my points up. I hate how the difficulty skyrockets after Responsive Web Design. At least I had fun re-creating kanyewest.com's Donda Stem Player for my Responsive Web Design Project.
Nov 26, 2021 Continued with Redux.
Nov 25, 2021 Finished with React and started with Redux.
Nov 24, 2021 Continued with React.
Nov 23, 2021 Continued with React.
Nov 22, 2021 Continued with React.
Nov 21, 2021 Continued with React.
Nov 20, 2021 Started with React.
Nov 19, 2021 Finished with SASS, thinking of using it in my bettermailto project)!
Nov 18, 2021 Finished jQuery and moved on to SASS.
Nov 17, 2021 Continued with jQuery.
Nov 16, 2021 Finished Bootstrap and moved on to jQuery.
Nov 15, 2021 Continued with Bootstrap.
Nov 14, 2021 Continued with Bootstrap.
Nov 13, 2021 Continued with Algorithms and Functional Programming in JS and Bootstrap.
Nov 12, 2021 Continued with Basic Data Structures in JS.
Nov 11, 2021 Started Basic Data Structures in JS.
Nov 10, 2021 JS is so frustrating sometimes.
Nov 09, 2021 Finished OOP in JS.
Nov 08, 2021 Continued with OOP in JS, pretty cool stuff!
Nov 07, 2021 Much shorter this time around, continued with OOP (object-oriented programming) in JS.
Nov 06, 2021 Why did this take so long? Continued with JS.
Nov 05, 2021 I got done with the Counting Cards problem in JS. I also continued with ES6.
Nov 04, 2021 Continued with Regular Expressions and finished Debugging.
Nov 03, 2021 Continued with Regular Expressions.
Nov 02, 2021 Continued with ES6 and Regular Expressions.
Nov 01, 2021 Continued with Basic JavaScript and started ES6. I really need to continue with my Web Design projects and finish the JS curriculum items I skipped.
Oct 31, 2021 Continued Basic JavaScript.
Oct 30, 2021 Continued Basic JavaScript and Regular Expressions.
Oct 29, 2021 Continued Basic JavaScript and Regular Expressions, the issue was closed as it was an intentional feature.
Oct 28, 2021 Continued Basic JavaScript and Debugging, and also opened up an issue about possible duplication.

National Maths Competition

Mar 04, 2023 Attended a national maths competition with my schoolmate. Due to privacy reasons, I was being incredibly vague.

Summary

Attended the first (and last) day of a national maths competition with my schoolmate as a duo. First round went really well (mostly because it was easy + 60 minutes) and got ~7th place, however the second round was extremely hard (and 45 minutes!) so we did not reach top 3. Oh well, the ride to the university + the conversations with him were what mattered the most. Great food though!

Student Council - 11th

Oct 05, 2022-Feb 14, 2023 I was the Coordinator - Environment for my school. A post that I will cherish having for a long time (oh, and due to privacy reasons, I was being incredibly vague).

Summary

Well, for some reason or the other, I did not decide to log one of the most important projects of my life so far. I became part of the student council, being unsure of what to expect - the uncertainty was amplified by me getting my second preference (though I'm grateful that happened instead of my first preference)

I ended up making the post a lot more influential than it should have been. It's the postholder and not the post. I ended up organising and contributing extensively to a lot of things, small and big (from our national day celebration to our seniors' graduation day to a small impromptu assembly we had when a workshop was being conducted for teachers).

The student council in your junior year should (hopefully!) just be a taste of what's to come next year. But that shouldn't stop you from reminiscing.

Grad Day

ADMUN 2023

Feb 03, 2023-Feb 05, 2023
Attended my last MUN, ADMUN 2.3 as part of my school team. Due to privacy reasons, I was being incredibly vague.

Log

Feb 03, 2023-Feb 05, 2023 Represented Bangladesh in the Economic and Social Council/Committee and did really well (though sadly, no award - possibly because I could not attend the last day fully).

ADMUN

Brilliant

Apr 14, 2022-Jan 30, 2023
Tried to learn more about computer science (mainly), mathematics and science with Brilliant + tried to complete the daily challenges.

Log

Jan 30, 2023 Continued with Cryptocurrency.
Jan 29, 2023 Continued with Cryptocurrency.
Jan 28, 2023 Continued with Cryptocurrency.
Jan 27, 2023 Continued with Cryptocurrency.
Jan 25, 2023 Continued with Cryptocurrency.
Jan 22, 2023 Continued with Cryptocurrency.
Jan 21, 2023 Continued with Cryptocurrency.
Jan 20, 2023 Continued with Cryptocurrency.
Jan 19, 2023 Continued with Cryptocurrency.
Jan 18, 2023 Continued with Cryptocurrency.
Jan 17, 2023 Continued with Cryptocurrency.
Jan 16, 2023 Got started with Cryptocurrency.
Jan 04, 2023-Jan 11, 2023 Finished with Introduction to Neural Networks.
Jan 04, 2023 Continued with Universal Approximator.
Jan 03, 2023 Continued with Universal Approximator.
Jan 02, 2023 Continued with Universal Approximator.
Jan 01, 2023 Continued with Universal Approximator.
Dec 31, 2022 Finished with Curve Fitting and got started with Universal Approximator. I hope to make as much progress as I can before April 2023.
Dec 30, 2022 Continued with Curve Fitting.
Dec 29, 2022 Continued with Curve Fitting.
Dec 28, 2022 Continued with Curve Fitting.
Dec 27, 2022 Got started with Curve Fitting.
Dec 26, 2022 Finished with Hidden Layers.
Dec 25, 2022 Continued with Hidden Layers.
Dec 24, 2022 Continued with Hidden Layers.
Dec 23, 2022 Continued with Hidden Layers.
Dec 22, 2022 Got started with Hidden Layers.
Dec 21, 2022 Finished with Training a Single Neuron.
Dec 20, 2022 Finished with the searching algorithms in Data Structures (as the whole course is retiring today).
Dec 19, 2022 Continued with Training a Single Neuron.
Dec 18, 2022 Continued with Training a Single Neuron.
Dec 17, 2022 Continued with Training a Single Neuron.
Dec 16, 2022 I come back after about a month and everything has changed lol. Continued with Training a Single Neuron (?).
Nov 13, 2022 "Continued" with Sigmoid Neuron.
Nov 06, 2022 Continued with Sigmoid Neuron.
Nov 05, 2022 Got started with Sigmoid Neuron.
Nov 04, 2022 Finished with Classification.
Nov 03, 2022 Continued with Classification.
Nov 02, 2022 Got started with Classification.
Nov 01, 2022 Finished with Building an XOR Gate.
Oct 31, 2022 Got started with Building an XOR Gate.
Oct 30, 2022 Finished with Decision Boundaries.
Oct 29, 2022 Continued with Decision Boundaries.
Oct 28, 2022 Got started with Decision Boundaries.
Oct 27, 2022 Finished with Activation Arithmetic.
Oct 26, 2022 Continued with Activation Arithmetic.
Oct 25, 2022 Continued with Activation Arithmetic.
Oct 24, 2022 Continued with Activation Arithmetic.
Oct 23, 2022 Continued with Activation Arithmetic.
Oct 22, 2022 Got started with Activation Arithmetic.
Oct 21, 2022 Finished with The Decision Box.
Oct 20, 2022 Got started with The Decision Box.
Oct 19, 2022 Finished with Can Computers Learn?
Oct 18, 2022 Continued with Can Computers Learn?
Oct 17, 2022 Got started with Can Computers Learn?.
Oct 16, 2022 Finished with The Folly of Computer Programming.
Oct 13, 2022-Oct 15, 2022 Finished with The Computer Vision Problem and got started and continued with The Folly of Computer Programming.
Oct 12, 2022 Got started with The Computer Vision Problem.
Oct 12, 2022 Finished with The Computer Vision Problem.
Oct 11, 2022 Finished with Neural Networks.
Oct 10, 2022 Continued with Neural Networks.
Oct 09, 2022 Got started with Neural Networks
Oct 08, 2022 Finished with Building Programs and finished with Algorithm Fundamentals!
Oct 07, 2022 Continued with Building Programs.
Oct 06, 2022 Continued with Building Programs.
Oct 05, 2022 Got started (?) with Building Programs.
Oct 04, 2022 Finished with Spellcheck. Today's daily challenge is literally a 5x5 KENKEN!
Oct 03, 2022 Continued with Spellcheck.
Oct 02, 2022 Got started with Spellcheck
Oct 01, 2022 Finished with Who Benefits?
Sep 30, 2022 Got started with Who Benefits?
Sep 29, 2022 Finished with Variants.
Sep 28, 2022 Continued with Variants.
Sep 27, 2022 Continued with Variants.
Sep 26, 2022 Got started with Variants.
Sep 25, 2022 Finished with Running Time.
Sep 24, 2022 Continued with Running Time.
Sep 23, 2022 Continued with Running Time.
Sep 22, 2022 Continued with Running Time.
Sep 21, 2022 Continued with Running Time.
Sep 20, 2022 Continued with Running Time.
Sep 19, 2022 Got started with Running Time.
Sep 18, 2022 Finsihed with Termination.
Sep 17, 2022 Continued with Termination.
Sep 16, 2022 Continued with Termination.
Sep 15, 2022 Continued with Termination.
Sep 14, 2022 Continued with Termination.
Sep 05, 2022 Got started with Termination.
Sep 04, 2022 Finished with Correctness.
Sep 03, 2022 Continued with Correctness.
Sep 02, 2022 Continued with Correctness.
Sep 01, 2022 Continued with Correctness.
Aug 31, 2022 Continued with Correctness.
Aug 30, 2022 Continued with Correctness.
Aug 29, 2022 Got started with Correctness.
Aug 28, 2022 Finished with Deferred Acceptance Algorithm.
Aug 27, 2022 Continued with Deferred Acceptance Algorithm.
Aug 26, 2022 Got started with Deferred Acceptance Algorithm
Aug 25, 2022 Finished with Using Greediness.
Aug 24, 2022 Continued with Using Greediness.
Aug 23, 2022 Got started with Using Greediness.
Aug 22, 2022 Finished with The Stable Matching Problem.
Aug 21, 2022 Continued with The Stable Matching Problem.
Aug 20, 2022 Continued with The Stable Matching Problem.
Aug 19, 2022 Got started with The Stable Matching Problem.
Aug 18, 2022 Finished with The Mathematics of Big O.
Aug 17, 2022 Continued with The Mathematics of Big O.
Aug 16, 2022 Got started with The Mathematics of Big O.
Aug 15, 2022 Finished with Understanding Big O.
Aug 14, 2022 Got started with Understanding Big O.
Aug 13, 2022 Got started with Understanding Big O.
Aug 12, 2022 Finished Comparing Algorithms.
Aug 11, 2022 Finished with Best, Worst and Average Case.
Aug 10, 2022 Continued with Best, Worst and Average Case.
Aug 09, 2022 Continued with Best, Worst and Average Case.
Aug 07, 2022 Got started with Best, Worst and Average Case
Aug 06, 2022 Finished Counting Operations.
Aug 05, 2022 Finished Timing Programs with a Stopwatch
Aug 04, 2022 Finished with Insertion Sort.
Aug 03, 2022 Finished with Sorting an Array.
Aug 02, 2022 Continued with Sorting an Array.
Aug 01, 2022 Continued with Sorting an Array.
Jul 31, 2022 Got started with Sorting an Array.
Jul 30, 2022 Finished with Binary Search.
Jul 29, 2022 Continued with Binary Search.
Jul 28, 2022 Continued with Binary Search.
Jul 27, 2022 Got started with Binary Search (again).
Jul 26, 2022 Finished with Searching an Array.
Jul 25, 2022 Continued with Searching an Array.
Jul 24, 2022 Continued with Searching an Array.
Jul 23, 2022 Got started with Searching an Array.
Jul 22, 2022 Finished with Arrays.
Jul 21, 2022 Continued with Arrays.
Jul 20, 2022 Got started with Arrays.
Jul 19, 2022 Finished with Algorithms and Implementations and Computer Science Fundamentals.
Jul 18, 2022 Continued with Algorithms and Implementations.
Jul 16, 2022 Continued with Algorithms and Implementations.
Jul 15, 2022 Got started with Algorithms and Implementations.
Jul 07, 2022 Finished with Graph Search.
Jul 06, 2022 Continued with Graph Search.
Jul 05, 2022 Got started with Graph Search.
Jul 04, 2022 Finished with Representing Games & Puzzles.
Jul 03, 2022 Continued with Representing Games & Puzzles.
Jul 02, 2022 Continued with Representing Games & Puzzles.
Jul 01, 2022 Continued with Representing Games & Puzzles.
Jun 30, 2022 Got started with Representing Games & Puzzles.
Jun 28, 2022 Finished with Thinking with Graphs.
Jun 27, 2022 Continued with Thinking with Graphs. The four colour theorem was explored in today's daily challenge.
Jun 26, 2022 Finished with Divide and Conquer and got started with Thinking with Graphs
Jun 25, 2022 Continued with Divide and Conquer.
Jun 24, 2022 Continued with Divide and Conquer.
Jun 23, 2022 Got started with Divide and Conquer.
Jun 22, 2022 Finished with Binary Search.
Jun 21, 2022 Finished with Interfaces (though I have to write the notes for it) and got started with Binary Search.
Jun 20, 2022 Finished with Abstraction and got started with Interfaces.
Jun 19, 2022 Continued with Abstraction.
Jun 18, 2022 Got started with Abstraction. I'm now going to only mention daily problems if they're interesting/difficult.
Jun 17, 2022 Finished with the daily problem and finished with Naming.
Jun 16, 2022 Finished with the daily problem and continued with Naming.
Jun 15, 2022 Finished Spots and Stripes (got it correct) and continued with Naming.
Jun 14, 2022 Finished the daily problem and continued with Naming.
Jun 13, 2022 Finished Round the Clock (got it correct, though it doesn't really count) and got started with Naming.
Jun 12, 2022 Finished Which is Which? (got it correct) and finished with Order and Search (finally!).
Jun 11, 2022 Finished Hurry to the Honey (got it wrong) and continued with Order and Search.
Jun 10, 2022 Finished Triangles in Line (got it correct) and continued with Order and Search.
Jun 09, 2022 Finished Stop the Car! (got it correct) and continued with Order and Search.
Jun 08, 2022 Finished Whose Slope? (got it correct) and continued with Order and Search.
Jun 07, 2022 Finished two daily problems and Wrangling with Repetition.
Jun 06, 2022 Finished Coins in Boxes (got it wrong) and got started with Wrangling with Repetition.
Jun 05, 2022 Finished Carrrs, One More Girl and Ice Cream Dilemma (all correct except the first one)
Jun 04, 2022 Finished Tracing Completely, Make It Traceable and Encircled, all of which I got correct.
Jun 03, 2022 Finished Bookworms (got it correct) and finished with Matrices for Neural Networks.
Jun 02, 2022 Finished Impossible Result (got it correct) and got started with Matrices for Neural Networks.
Jun 01, 2022 Finished the daily problem and finished Vectors for Neural Networks.
May 31, 2022 Finished How Many Elephants? (got it correct) and got started with a brush-up on linear algebra.
May 30, 2022 Finished two daily problems and with Recurrent Neural Networks.
May 29, 2022 Finished In the Cards (got it correct) and continued with Recurrent Neural Networks.
May 28, 2022 Finished The Heaviest Ornament (got it correct) and got started with Recurrent Neural Networks.
May 27, 2022 Finished Different Numbers (got it correct) and finished with Arrays.
May 26, 2022 Finished the daily problem and got started with Arrays.
May 25, 2022 Finished Whose Two? (got it wrong) and finished with Treaps (got every question for Treaps correct!)
May 24, 2022 Finished Honeycomb Colors (got it correct) and finished with Binary Heaps.
May 23, 2022 Finished Stack of Circles (got it correct, really proud of this) and got started with Binary Heaps.
May 22, 2022 Finished Same or Different (got it wrong) and finished with Priority Queues. I got literally everything wrong for Brilliant today lol.
May 21, 2022 Finished Make Six Twice (got it correct) and got started with Priority Queues.
May 20, 2022 Finished Connected Gears (got it correct) and finished with Red Black Trees.
May 19, 2022 Finished Seeking Chocolate (got it wrong, I got the other ant's path completely wrong lol), finished with Tree Rotations and got started with Red Black Trees.
May 18, 2022 Finished Comparing Heights (got it wrong) and got started with Tree Rotations.
May 17, 2022 Finished the daily problem and finished with queues.
May 16, 2022 Finished Off Balance (got it correct) and got started with Queues.
May 15, 2022 Finished Class Sizes (got it wrong) and finished with Stacks.
May 14, 2022 Finished You Won't Get This Number (got it correct) and got started with Stacks.
May 13, 2022 Finished Compare the Weights (got it correct) and finished with Binary Search Trees.
May 12, 2022 Finished Corner to Corner (got it correct) and got started with Binary Search Trees.
May 11, 2022 Finished All Roads Lead to Nika (got it correct, though I basically guessed lol) and finished with Traversals (cool stuff!)
May 10, 2022 Finished with The Smallest Z (got it wrong) and got started with Traversals.
May 09, 2022 Finished with The Heavier Side (got it wrong) and finished with Binary Trees, which I found pretty fun.
May 08, 2022 Finished with Not Bright Enough (got it correct) and finished with Linked Lists (which I now finally understand for LeetCode!)
May 07, 2022 Finished the daily problem and finished with Divide and Conquer.
May 06, 2022 Finished Blue or Yellow? (got it correct) and continued with Order and Search.
May 05, 2022 Finished Human or Werewolf? (got it wrong), finished with Resource Tradeoffs and got started with Order and Search!
May 04, 2022 Finished Hexagon to Star (got it correct) and continued with Resource Tradeoffs.
May 03, 2022 Finished Follow the Arrows (got it wrong) and got started with Resource Tradeoffs.
May 02, 2022 Finished One to Three, Three to One (got it correct) and finished with Parallelism.
May 01, 2022 Finished Pizza Thief (got it correct) and continued with Parallelism.
Apr 29, 2022 Finished Is It Balanced? (got it correct) and got started with Parallelism (note to self: "embarrassingly parallel" is a real term!)
Apr 28, 2022 Finished with Repetition.
Apr 27, 2022 Finished Doctor Brilliantstein (got it right) and finished with Manipulating Numbers and got started with Repetition.
Apr 26, 2022 Finished Don't Go Breaking My Bike (got it right) and continued with Manipulating Numbers.
Apr 25, 2022 Finished Oh, the Weather Outside Is Frightful (got it wrong) and continued with Manipulating Numbers.
Apr 24, 2022 Finished And They Were Roommates (got it correct) and got started with Manipulating Numbers.
Apr 23, 2022 Finished the daily challenge (got it correct) and finished with Conditional Algorithms.
Apr 22, 2022 Finished How Many Circles? (got it correct) and continued with Conditional Algorithms.
Apr 21, 2022 Finished Made to Measure (got it correct) and continued with Conditional Algorithms.
Apr 20, 2022 Finished Pizza Burn (got it correct) and got started with Conditional Algorithms.
Apr 19, 2022 Finished Find the Angle (got it correct) and finished Pseudocode.
Apr 18, 2022 Finished with El the Elephant (got it wrong) and Searching for Solutions.
Apr 17, 2022 Finished with Which Is Shaded More? (got it correct) and got started with Searching for Solutions.
Apr 16, 2022 Finished with Writing Programs and Which Is Bigger? (got it correct).
Apr 15, 2022 Finished the daily challenge (Playing with Matchsticks, got it wrong) and finished the backlog of problems available on the free tier (Who Won The Race? (wrong), The Nine Nine Plus (correct, used my KENKEN skills), How Much Can They See? (correct), Pasta, Pronto (wrong), Cool, Cooler, Coolest (wrong) and finally, Find the Pattern (correct)).
Apr 14, 2022 Got started with Computer Science Essentials and finished Making Decisions. Still on Writing Programs.

Middle School CS Event

Jan 13, 2023-Jan 24, 2023
I was part of the organising team for a middle school computer science event. Tried my best to make this as successful as possible. Due to privacy reasons, I was being incredibly vague.

Log

Jan 23, 2023-Jan 24, 2023 Event was a success! Everything ran (mostly) smoothly, I got to teach Python for about an hour (showed me how tiring but rewarding teaching is) and had a really nice sit-down chat towards the end of the second day.
Jan 22, 2023 Presented the team randomizer.
Jan 21, 2023 Attended meetings and worked on the team randomizer.
Jan 20, 2023 Attended meeting and worked on the team randomizer.
Jan 18, 2023 Worked on team randomizer and documents.
Jan 17, 2023 Discussed about documents.
Jan 16, 2023 Worked on some documents.
Jan 15, 2023 Attended a meeting and worked on some documents.
Jan 14, 2023 Finished the team randomizer for the most part.
Jan 13, 2023 Attended a meeting and worked on the team randomizer.

Advent of Code (PyTech)

Dec 01, 2022-Jan 16, 2023
Trying to Currently running an advent of code for my school's Python club. Due to privacy reasons, I'm being incredibly vague.

Log

Jan 16, 2023 Posted the result post!
Dec 25, 2022 Twenty-fifth and final problem is up. Really like this one as it's Christmas themed (Merry Christmas by the way!), will send out the results soon.
Dec 24, 2022 Twenty-fourth problem is up.
Dec 23, 2022 Twenty-third problem is up.
Dec 22, 2022 Twenty-second problem is up.
Dec 21, 2022 Twenty-first problem is up.
Dec 20, 2022 Twentieth problem is up.
Dec 19, 2022 Nineteenth problem is up.
Dec 18, 2022 Eighteenth problem is up.
Dec 17, 2022 Seventeenth problem is up.
Dec 16, 2022 Sixteenth problem is up.
Dec 15, 2022 Fifteenth problem is up. Really like this one.
Dec 14, 2022 Fourteenth problem is up.
Dec 13, 2022 Thirteenth problem is up.
Dec 12, 2022 Twelfth problem is up.
Dec 11, 2022 Eleventh problem is up.
Dec 10, 2022 Tenth problem is up. Really like this one.
Dec 09, 2022 Ninth problem is up.
Dec 08, 2022 Eighth problem is up.
Dec 07, 2022 Seventh problem is up.
Dec 06, 2022 Sixth problem is up.
Dec 05, 2022 Fifth problem is up.
Dec 04, 2022 Fourth problem is up.
Dec 03, 2022 Third problem is up.
Dec 02, 2022 Second problem is up.
Dec 01, 2022 First problem is up! Hope to get some responses soon.

Cold Takes Beta Reading

Jan 20, 2022-Jan 09, 2023
I was accepted to beta read Holden Karnofsky's articles for his blog, Cold Takes. Note that I only updated this log when I fully finish proof-reading and when the post has been published.

Log

Jan 09, 2023 Finished my eighth proof-reading. The link to the post will be here once done.
Dec 16, 2022 Finished my seventh proof-reading (possibly my last for this year - so grateful to have been a part of this). The link to the post will be here once done.
Oct 12, 2022 Finished my sixth proof-reading (although I unfortunately missed the deadline by a bit). The link to the post will be here once done.
Sep 08, 2022 Finished my fifth proof-reading. The link to the post will be here once done.
Sep 05, 2022 Along with other beta-readers, I got appreciated in the latest Cold Takes post!
May 25, 2022 Been a while, but finished my fourth proof-reading. The link to the post will be here once done.
Feb 20, 2022 Finished my third proof-reading. The link to the blog post will be here once done.
Feb 04, 2022 Finished my second proof-reading. The link to the blog post will be here once done.
Jan 20, 2022 Got accepted (!) and finished proof-reading. The link to the blog post will be here when it's done (for privacy reasons).

y1d2

Dec 21, 2022-Dec 22, 2022
Created my brother's ~~current~~ (?) website in the span of ~2 days.

Log

Dec 22, 2022 Finished the second (and final) version of my brother's website.
Dec 21, 2022 Finished the first version of my brother's website.

Introduction to Machine Learning

Jul 04, 2022-Dec 19, 2022
Trying to learn the fundamental concepts of machine learning.

Log

Dec 19, 2022 Finished with Week 6 and hence fully finished with this course! I had earned my certificate much earlier (since I believe the last two weeks are optional) but happy to have gained such a deep understanding of the key concepts behind ML.
Dec 18, 2022 Continued with Week 6.
Dec 17, 2022 "Continued" with Week 6.
Dec 16, 2022 Continued with Week 6.
Nov 18, 2022 Continued with Week 6.
Nov 09, 2022 "Continued" with Week 6.
Nov 08, 2022 "Continued" with Week 6.
Nov 04, 2022 Continued with Week 6 and got 100% on the practice quiz.
Nov 03, 2022 Got started with Week 6, the last week.
Nov 02, 2022 Finished with Week 5.
Nov 01, 2022 Continued with Week 5.
Oct 31, 2022 Continued with Week 5.
Oct 30, 2022 Continued with Week 5.
Oct 29, 2022 Continued with Week 5.
Oct 28, 2022 Continued with Week 5.
Oct 26, 2022 "Continued" with Week 5.
Oct 25, 2022 Continued with Week 5.
Oct 24, 2022 Continued with Week 5.
Oct 23, 2022 Continued with Week 5.
Oct 22, 2022 Continued with Week 5.
Oct 21, 2022 Finished with Week 4.
Oct 19, 2022 Continued with Week 4.
Oct 18, 2022 Continued with Week 4.
Oct 17, 2022 Continued with Week 4.
Oct 16, 2022 Continued with Week 4.
Oct 09, 2022 Continued with Week 4.
Oct 08, 2022 Continued with Week 4.
Oct 07, 2022 Continued with Week 4 and finished the video.
Oct 05, 2022 Continued with Week 4. Still on the same video.
Oct 04, 2022 Continued with Week 4 (though I did not finish a full video).
Sep 26, 2022 Continued with Week 4.
Sep 25, 2022 Continued with Week 4.
Sep 18, 2022 Continued with Week 4.
Aug 29, 2022 Continued with Week 4.
Aug 26, 2022 Continued with Week 4.
Aug 25, 2022 Continued with Week 4.
Aug 24, 2022 Continued with Week 4.
Aug 23, 2022 Continued with Week 4 and got 100% on the practice quiz!
Aug 22, 2022 Continued with Week 4.
Aug 17, 2022 Continued with Week 4 and learnt about Word2Vec.
Aug 16, 2022 Got started with Week 4.
Aug 15, 2022 Could not finish the final assignment for Week 3 but on to Week 4 anyways (the assignment is technically optional).
Aug 14, 2022 Continued with the final assignment for Week 3.
Aug 13, 2022 Continued with the final assignment for Week 3 (went throught the pre-requisite notebook).
Aug 12, 2022 Got started with the final assignment for Week 3.
Aug 11, 2022 Continued with Week 3, nearly done.
Aug 10, 2022 Continued with Week 3.
Aug 08, 2022 "Continued" with Week 3.
Aug 07, 2022 Continued with Week 3.
Aug 06, 2022 Continued with Week 3.
Aug 04, 2022 Continued with Week 3.
Aug 02, 2022 Continued with Week 3.
Aug 01, 2022 Continued with Week 3.
Jul 30, 2022 Continued with Week 3 and got 100% on the practice quiz.
Jul 29, 2022 Continued with Week 3 and learnt about the convolution operator.
Jul 28, 2022 Got started with Week 3.
Jul 27, 2022 Finished with Week 2.
Jul 26, 2022 Nearly done with Week 2 (#3). Machine learning is awesome once you understand almost everything.
Jul 25, 2022 Nearly done with Week 2 (#2).
Jul 23, 2022 Nearly done with Week 2.
Jul 21, 2022 Continued with Week 2 and learnt about early stopping with stochastic gradient descent.
Jul 20, 2022 Continued with Week 2 and learnt about stochastic gradient descent.
Jul 19, 2022 Continued with Week 2 and learnt about gradient descent.
Jul 18, 2022 Continued with Week 2 and learnt about overfitting and validation/test data sets.
Jul 17, 2022 Got started with Week 2 with cross-entropy loss.
Jul 16, 2022 Finished with Week 1.
Jul 15, 2022 Got 100% on the Week 1 Comprehensive and nearly done with Week 1.
Jul 12, 2022 About half-way through with the maths behind the CNN and how it works on real-life images.
Jul 11, 2022 Finished learning about the architecture of a Convolutional Neural Network.
Jul 10, 2022 Finished with the Multilayer Perceptron section for week 1. These deadlines are wack, y'all.
Jul 09, 2022 Learnt about bias-variance trade off and got 100% on the practice quiz.
Jul 08, 2022 Learnt about deep and transfer learning.
Jul 07, 2022 Finished with multilayer perceptron and could have got 100% on the quiz if I hadn't forgotten to select an answer...
Jul 06, 2022 Finished with logistic regression and got 100% on the quiz!
Jul 05, 2022 Learnt about logistic regression and a binary MNIST example.
Jul 04, 2022 Got started with the course!

Winter Computing Camp

Dec 12, 2022-Dec 15, 2022
Attending a winter computing camp. Due to privacy reasons, I'm being incredibly vague.

Log

Dec 15, 2022 Fourth and final day done! Learnt about machine learning algorithms (such as K-Nearest Neighbors and Decision Tree) and some game development. This was an incredible experience.

Winter Computing Camp

Dec 14, 2022 Third day done! Learnt about Thunkable and showed some humility when it came time to program for the Internet of Things session.
Dec 13, 2022 Second day done! Revised the basics of Python.
Dec 12, 2022 First day done! Learnt about computer networking from a really nice professor. Also, got a great tour of the university.

Emirate-level Hackathon

Nov 19, 2022
Led my senior team to a win in a "state" hackathon! Due to privacy reasons, I was being incredibly vague.

Summary

Happy to report that we've won the senior category of a "state" hackathon! Hope to continue this string of hackathon projects very soon.

Hackathon - Nov

GFSMUN II

Nov 04, 2022-Nov 06, 2022
Attended GFSMUN 2022 as part of my school team. Due to privacy reasons, I was being incredibly vague.

Log

Nov 06, 2022 Third (and best) day completed! Our bloc's resolution paper got passed, I became the President of Portugal and Cristiano Ronaldo at the same time during crisis (?, also SIUUU) and won honorable mention for my committee.
Nov 05, 2022 Second day completed! Resolution paper, resolution paper.
Nov 04, 2022 First day completed! I gave some pretty good POIs as the Delegate of Portugal, I think?

Cubing

Oct 28, 2021-Oct 21, 2022
Tried my best to get better every day at the four events I practice, which are 3x3, 2x2, 3x3 OH and Skewb, all AO5's were presented in that order and I usually wrote about any PB I get. In addition to regular-ish practice, I attended a local WCA competition.

Cubing's start date is the date I started logging, not the date when the project started.

Log

Oct 21, 2022 After 1700 solves, I'm happy to call this project done. I'm not exaggerating when I say that cubing was a big part of my life, but we all have to move on eventually. Maybe I'll revisit this project when another competition comes up :) 22.876, 5.486, 38.588 and 11.233.
Oct 19, 2022 22.401, 6.565, 39.651 and 10.100.
Oct 18, 2022 20.470, 6.691, 33.614 and 9.103.
Oct 17, 2022 19.862, 5.857, 37.010 and 9.527.
Oct 16, 2022 21.559, 6.203, 37.976 and 8.565.
Oct 09, 2022 20.414, 5.919, 31.688 and 10.009.
Oct 08, 2022 17.612, 6.383, 37.462 and 13.477.
Oct 07, 2022 23.083, 6.700, 38.384 and 11.140.
Oct 06, 2022 20.640, 6.756, 37.880 and 10.302.
Oct 05, 2022 20.694, 5.273, 33.634 and 10.598.
Oct 04, 2022 19.856, 6.133, 34.889 and 10.218.
Oct 02, 2022 20.732, 5.907, 31.214 and 9.320.
Oct 01, 2022 20.185, 6.254, 33.995 and 8.724.
Sep 30, 2022 19.371, 6.298, 36.396 and 10.548.
Sep 29, 2022 21.429, 4.964, 33.788 and 9.876.
Sep 28, 2022 19.271, 8.802, 39.664 and 8.347.
Sep 25, 2022 23.091, 4.472, 31.189 and 8.808.
Sep 20, 2022 19.662, 6.125, 33.877 and 9.205.
Sep 19, 2022 20.691, 5.050, 36.578 and 8.841.
Sep 18, 2022 20.912, 6.815, 31.041 and 7.615.
Sep 17, 2022 $40^2$ solves! 17.936, 5.969, 35.427 and 7.331.
Sep 16, 2022 19.509, 6.107, 34.105 and 9.909.
Sep 15, 2022 17.647, 6.375, 35.562 and 9.129.
Sep 14, 2022 17.873, 4.861, 31.998 and 11.427.
Sep 11, 2022 Attended Dubai Summer Open 2022 and got an 18.73 average with a 16.72 best for 3x3! An awesome time overall :)
Aug 26, 2022 19.907, 5.470, 33.116 and 8.903.
Aug 25, 2022 18.685, 6.439, 34.472 and 8.268.
Aug 24, 2022 19.688, 5.658, 36.235 and 9.067.
Aug 23, 2022 Finally! 18.722, 5.123, 29.672 (!) and 8.081.
Aug 22, 2022 I think I've learnt the Ja perm for 3x3 OH? 20.030, 5.016, 37.032 and 9.073.
Aug 20, 2022 3x3 AO5 PB! (by a couple milliseconds lol): 15.708 (!), 8.368, 35.560 and 7.586
Aug 19, 2022 20.416, 5.227, 37.444 and 8.829.
Aug 18, 2022 17.806, 6.660, 39.445 and 9.953.
Aug 17, 2022 23.468, 5.389, 35.004 and 8.526.
Aug 16, 2022 17.652, 5.143, 36.598 and 9.815.
Aug 15, 2022 Much better in the Skewb department! 19.732, 6.789, 36.512 and 8.764.
Aug 14, 2022 21.091, 6.134, 33.164 and 15.323.
Aug 13, 2022 19.941, 6.571, 31.480 and 10.170.
Aug 12, 2022 19.545, 5.173, 37.692 and 9.840.
Aug 11, 2022 At least I learnt the one-handed version of the H perm! 18.599, 4.864, 38.965 and 11.771.
Aug 10, 2022 20.353, 5.457, 39.861 and 11.311.
Aug 09, 2022 19.965, 5.536, 35.159 and 9.446.
Aug 07, 2022 21.405, 7.053, 38.565 and 10.841.
Aug 06, 2022 17.039, 5.987, 35.190 and 7.532.
Aug 05, 2022 18.963, 5.775, 33.103 and 8.023.
Aug 04, 2022 Finally! 18.730, 4.942, 29.052 (!), 10.617.
Aug 03, 2022 21.554, 5.782, 40.320 and 7.502.
Aug 02, 2022 So close: 19.009, 4.656 (!), 30.284 and 8.706.
Aug 01, 2022 Not a bad way to start the month: 16.993 (!), 6.440, 31.554 and 8.598.
Jul 31, 2022 17.234 (!), 5.124, 33.030 and 7.851.
Jul 30, 2022 17.595 (!), 5.320, 30.445 and 8.606.
Jul 29, 2022 19.340, 5.681, 31.071 and 9.370.
Jul 28, 2022 20.071, 4.838 (!), 38.269 and 7.523.
Jul 27, 2022 19.091, 5.953, 33.187 and 8.106.
Jul 26, 2022 24.022, 5.022, 37.679 and 7.321.
Jul 25, 2022 18.195, 4.872, 32.165 and 8.967.
Jul 24, 2022 21.094, 6.753, 39.731 and 11.056.
Jul 23, 2022 21.094, 6.753, 39.731 and 11.056.
Jul 22, 2022 3x3 AO5 PB! 15.888, 5.587, 37.371 and 9.911.
Jul 21, 2022 18.596, 5.965, 31.537 and 12.055.
Jul 20, 2022 21.247, 5.597, 31.273 and 8.574.
Jul 19, 2022 18.867, 6.451, 40.823 :(, 12.007.
Jul 18, 2022 19.059, 5.604, 38.726 and 9.577.
Jul 16, 2022 22.948, 6.385, 35.875 and 10.078.
Jul 15, 2022 19.592, 5.732, 34.364 and 10.530.
Jul 14, 2022 18.545, 6.365, 38.177 and 9.836.
Jul 12, 2022 One day, I'll get a sub-30 3x3 OH AO5: 17.311, 5.320, 30.854 and 10.231
Jul 11, 2022 23.714, 7.466, 31.628 and 10.917.
Jul 10, 2022 21.920, 6.766, 39.072 and 8.685.
Jul 08, 2022 18.965, 5.504, 33.788 and 10.432.
Jul 07, 2022 2 fast 4 u: 19.586, 5.419, 32.351 and 7.546
Jul 06, 2022 19.177, 5.797, 40.185 :(, 10.573
Jul 05, 2022 18.756, 5.942, 32.829 and 7.772
Jul 04, 2022 21.407, 5.065, 38.805 and 10.481
Jul 03, 2022 I was so close to sub-30 for 3x3 OH: 17.317 (!), 5.798, 31.982 and 8.910
Jul 01, 2022 18.892, 6.250, 32.603 and 8.918.
Jun 29, 2022 17.980 (!), 6.040, 31.132 and 10.525.
Jun 28, 2022 18.859, 5.639, 33.667 and 10.999.
Jun 27, 2022 20.970, 6.555, 35.080 and 10.976.
Jun 26, 2022 18.986, 5.383, 33.141 and 8.954.
Jun 25, 2022 20.229, 5.544, 33.882 and (8.615, 8.983).
Jun 24, 2022 20.432, 5.903, 36.015 and 11.585.
Jun 23, 2022 I was so close to a sub-30 3x3 OH AO5... 18.736, 6.921, 30.004 (!) and 11.585.
Jun 22, 2022 3x3 was tragic today, my new cube is very fast, and that can result in sub-15, but it can also result in a 40 due to messing up the PLL: 23.590, 6.047, 33.841 and 8.036
Jun 21, 2022 20.229, 5.503, 33.131 and 8.247
Jun 20, 2022 New cube! 19.169, 6.500, 33.325 and 8.948.
Jun 19, 2022 Never mind: 22.696, 5.413, 37.745 and 8.947.
Jun 18, 2022 Phew... 18.819, 6.577, 37.075 and 8.134.
Jun 17, 2022 22.004, 5.656, 41.466 and 9.496.
Jun 16, 2022 20.320, 5.291, 42.044 and 9.445.
Jun 15, 2022 I was so close to messing up 3x3 OH lol: 17.735, 6.390, 39.546 and 9.634.
Jun 14, 2022 20.155, 5.422, 36.218 and 10.212.
Jun 13, 2022 After a certain time in the day, I just cannot cube: 23.168, 4.714, 42.344 and 7.879.
Jun 12, 2022 It's funny how a couple of years ago, I would be screaming and running around if I got a sub-15 solve. Now, nothing: 18.392, 5.922, 33.850 and 9.239.
Jun 11, 2022 Better: 17.511, 6.151, 34.061 and 9.249
Jun 10, 2022 Still pretty meh, but getting better: 19.618, 6.651, 35.002 and 10.860.
Jun 09, 2022 20.986, 6.248, 42.098 and 10.130.
Jun 08, 2022 22.117, 5.633, 35.752 and 7.100.
Jun 07, 2022 20.241, 5.700, 37.880 and 9.941.
Jun 06, 2022 A (less?) agreeable set of averages: 18.711, 5.089, DNF and 7.919.
Jun 05, 2022 An agreeable set of averages: 19.217, 4.966, 36.632 and 8.640.
Jun 04, 2022 Still waiting for 3x3 BLD... 19.928, 7.067, 40.553 and 11.262.
Jun 03, 2022 I decided to do two AO5's for every event except 3x3 (to make everything line up): 19.273, (7.272, 5.501), (36.156, 36.921) and (11.751, 9.392)
Jun 02, 2022 20.927, 6.204, 37.392 and 9.882
Jun 01, 2022 24.275, 5.165, 35.743 and 7.170.
May 31, 2022 Not bad: 18.764, 4.901, 35.034 and 10.136.
May 30, 2022 3x3 OH wasn't feeling it today: 18.478, 4.489, 44.487 and 9.555.
May 29, 2022 23.289, 6.478, 34.936 and 8.654.
May 28, 2022 Double sigh, my first 3x3 AO5 was a DNF so I did it again and I still can't get a successful 3x3 BLD attempt: (DNF, 20.710), 5.385, 31.499 and 10.485.
May 27, 2022 Sigh, 3x3 BLD has gotten worse: 19.207, 6.058, 38.293 and 9.943.
May 26, 2022 I was planning to do a 3x3 BLD attempt, but I had to reassemble my Skewb in the middle of my AO5 :/ 19.659, 5.010, 34.842 and 11.210.
May 25, 2022 20.562, 5.151, 35.957 and 10.113.
May 24, 2022 21.166, 5.224, 37.286 and 7.112.
May 23, 2022 Still no luck with 3x3 BLD: 18.350, 4.698, 35.431 and 6.450 (!)
May 22, 2022 Phew... 19.904, 4.736, 34.368 and 9.121.
May 21, 2022 20.574, 5.218, 38.933 and 10.418.
May 20, 2022 Just made it through: 19.738, 5.281, 39.569 and 9.758.
May 19, 2022 Again, 3x3 OH could have gone better: 17.624 (!), 5.262, 38.848 and 7.606.
May 18, 2022 3x3 OH could have gone better: 18.981, 4.761 (!), 38.214 and 8.138.
May 17, 2022 Finally! 18.702, 7.092, 37.922 and 8.573.
May 16, 2022 3x3 PB! (10.105) and I still didn't get sub-20 lol: 20.031, 8.630, 31.412 and 7.408.
May 15, 2022 20.338, 5.874, 34.788 and 11.512.
May 14, 2022 22.294, 6.656, 36.895 and 9.396.
May 13, 2022 Great averages, nothing much to complain about: 17.248 (!), 5.251, 35.677 and 8.010.
May 12, 2022 3x3 OH PB! (22.095): 21.411, 6.433, 35.329 and 9.273.
May 11, 2022 Been having a hard time getting a successful no-write 3x3 BLD attempt: 18.134, 4.266, 33.915 and 8.322.
May 10, 2022 Finally: 19.299, 6.022, 32.160 and 8.944.
May 09, 2022 Today was not a day for 3x3 OH: 19.471, 4.737 (!), 43.997 and 8.170.
May 08, 2022 21.400, 5.229, 37.052 and 9.670.
May 07, 2022 3x3 BLD attempt was disastrous today lol: 18.137, 4.741 (!), 38.289 and 11.163.
May 06, 2022 22.173, 6.177, 32.371 and 14.443.
May 05, 2022 22.468, 5.526, 36.977 and 7.229.
May 04, 2022 21.620, 5.126, 38.562 and 11.681.
May 03, 2022 21.063, 6.582, 31.209 and 10.659.
May 02, 2022 Finally, some good averages: 17.740 (!), 5.741, 34.197 and 9.334.
May 01, 2022 3 days in a row... 20.832, 4.844, 35.143 and 9.095.
Apr 30, 2022 20.412, 8.698, 41.073 and 8.761.
Apr 29, 2022 22.307, 5.259, 35.524 and 10.037.
Apr 28, 2022 Today's 3x3 BLD attempt was so bad haha: 19.357, 4.800 (!), 33.606 and 6.465 (!)
Apr 27, 2022 21.066, 7.844, 42.862 and 9.970.
Apr 26, 2022 Disappointingly, cstimer (the cubing timer I use) doesn't produce AO1000, so here is the mean for 1000 solves: 21.177, 6.102, 41.186 and 10.019. As for the AO5's: 18.469, 5.554, 33.303 and 10.887. Also, I've spent almost 6 hours in total on 3x3 lol, here's to another 1000!
Apr 25, 2022 21.078, 6.095, 35.065 and 8.574.
Apr 24, 2022 I finished the BLD attempt too early and forgot to execute the moves to solve the last corner :( Also, day after tomorrow will be the AO1000 day! 19.973, 5.549, 37.311 and 7.746.
Apr 23, 2022 3x3 OH... 17.459 (!), 5.334, 40.854 and 7.839.
Apr 22, 2022 TS UP VE CX EA LQ! I got a successful 3x3 BLD solve without writing down the memorization during the solve! 18.899, 6.497, 37.569 and 10.569 (I also forgot to mention that a couple days ago I got a 3x3 OH PB lol, 22.402)
Apr 21, 2022 19.546, 5.346, 39.616 and 10.359.
Apr 20, 2022 21.161, 5.131, 36.236 and 9.728.
Apr 19, 2022 I was pretty close with the no-writing BLD attempt! 19.845, 5.578, 32.999 and 9.502.
Apr 18, 2022 Decent I guess: 19.625, 6.814, 38.264 and 11.757. I also tried to do a BLD attempt without writing down the memorization, I messed up because of execution lol.
Apr 17, 2022 Nothing saves the day: 20.620, 5.907, 39.393 and 8.049.
Apr 16, 2022 3x3 OH saves the day: 20.796, 4.305 (!), 29.552 (!) and 9.895.
Apr 15, 2022 Slightly better: 18.447, 4.443 (!), 39.591 and 7.931.
Apr 14, 2022 Barely passable: 19.618, 6.006, 36.972 and 8.722.
Apr 13, 2022 Never mind? 17.598 (!), 5.175, 33.667 an 10.520. I hate how turbulent my times are. I guess that's cubing in a nutshell.
Apr 12, 2022 Welp, I think we'll be in this time slump for a bit. At least I got a successful 3x3 BLD solve: 20.569, 6.222, 39.119 and 9.908 (Also, I think the change in solving order didn't do much, so I'm back to the original order).
Apr 11, 2022 22.961, 5.759, 35.432 and 11.559.
Apr 10, 2022 Phew, back on track: 19.187, 5.778, 36.826 and 7.655 (by the way, the order of the averages written haven't changed, but I now do Skewb -> 2x2 -> 3x3 OH -> 3x3).
Apr 09, 2022 Well, it was fun while it lasted: 21.856, 6.137, 37.501 and 10.732.
Apr 08, 2022 Very nice (except for 3x3 OH): 17.276, 5.472, 37.693 and 8.917. I wonder how long it'll take me to get sub-15 on 3x3.
Apr 07, 2022 Nice: 17.101, 5.581, 35.501 and 8.881.
Apr 06, 2022 100 more solves to go till AO1000! 18.073, 5.867, 38.429 and 8.191.
Apr 05, 2022 3x3 OH AO5 was terrible: 18.068, 5.591, 40.613 and 9.809.
Apr 04, 2022 Another successful 3x3 BLD solve! 17.372 (!), 5.924, 35.729 and 10.559.
Apr 03, 2022 Today is the greatest day of my life (cubing-wise!), got 3 sub-30 solves in 3x3 OH and great averages all around: 18.990, 5.906, 30.921 (!), 8.003.

And... I got another successful 3x3 BLD solve! It was so hectic lol, I changed my memorization mid-way through the edges (thankfully) .
Apr 02, 2022 I haven't been able to get a 3x3 BLD attempt (let alone a successful one) in the past 3-ish days. At least the averages are back to normal (for like a day): 18.529, 5.019, 37.587 and 9.230.
Apr 01, 2022 Never mind: 22.649, 5.509, 39.351 and 9.716. I like how my whole day (cubing-wise) gets ruined if my 3x3 AO5 is not sub-20 lol.
Mar 31, 2022 Back to normal: 19.452, 5.065, 32.064 and 9.556.
Mar 30, 2022 3x3 BLD attempt was off by 3 edges again: 20.618, 5.458, 40.515 and 11.240.
Mar 29, 2022 22.546, 7.092, 38.206 and 11.234.
Mar 24, 2022 Today's 3x3 BLD attempts were so frustrating, the first one was off by two flipped edges and I kept messing up the execution in the later solves, at least the averages were good: 18.488, 5.382, 39.277 and 8.365.
Mar 23, 2022 I got two sub-20 solves for 3x3 at first, but it all got ruined by a DNF and a +2, it sometimes feel like it's all about luck, anyways: 20.698, 5.174, 35.456 and 13.105.
Mar 22, 2022 Odd 3x3 BLD attempt was so close: 21.064, 5.506, 37.986 and 8.045.
Mar 21, 2022 How did an average with a 40 and a DNF become sub-40? 25.537, 4.964, 39.721 and 9.783.
Mar 20, 2022 Scrambles were very easy: 17.547 (!), 4.941, 38.425 and 11.764.
Mar 19, 2022 Got a 12 second solve for 3x3 but regardless: 21.821, 6.535, 36.357 and 10.273.
Mar 18, 2022 23.077, 5.853, 41.374 and 10.033.
Mar 17, 2022 21.405, 6.002, 37.289 and 10.459.
Mar 16, 2022 I guess I got lucky? 18.841, 5.380, 34.834 and 9.340. Today's 3x3 BLD attempt was so close (two edges flipped).
Mar 15, 2022 Forgot about the switch-up: 24.875, 6.812, 35.906 and 11.400.
Mar 14, 2022 My averages have been terrible for the past few ~~months~~ days and so I'm going to switch it up by doing 2x2 first and then proceeding the with normal order (don't worry, the log order will remain the same): 22.462, 5.755, 40.173 and 9.379.
Mar 13, 2022 200 more solves left for an AO1000: 20.543, 5.996, 36.888 and 9.247.
Mar 12, 2022 This is getting ridiculous: 19.962, 5.636, 40.219 and 11.274.
Mar 11, 2022 Yes? 19.093, 5.612, 37.009, 11.737.
Mar 10, 2022 Nope: 20.098, 7.327, 38.656 and 7.993.
Mar 09, 2022 We're back? 18.709, 5.143, 38.506 and 6.759.
Mar 08, 2022 Meh (x2): 21.662, 6.125, 34.649 and 9.689.
Mar 07, 2022 Meh: 22.201, 5.474, 40.973 and 10.045.
Mar 06, 2022 QX TJ IW ER UO LR, WB XL JD! I DID IT! THE NEW SETUP MOVES ACTUALLY WORKED! I will add a technicality here, I forgot the "JD" part so I peeked at it. A full timed BLD solve coming soon! Averages were meh but that doesn't matter: 20.036 (so close!), 4.361, 40.565 and 8.018.
Mar 05, 2022 I need to stop cubing at night (x2): 23.734, 5.564, 43.749 and 7.136.
Mar 04, 2022 I need to stop cubing at night: 20.598, 7.136, 42.022 and 10.538.
Mar 03, 2022 Sigh: 21.520, 6.214, 36.180 and 8.337, at least I learnt why my "odd" memorizations for 3x3 BLD are always way off (I can't use any setup moves that disrupt the top two corners + the buffer)
Mar 02, 2022 2x2 was quite a shock: 21.093, 3.474 (!), 44.370 and 9.777.
Mar 01, 2022 Nothing to say really: 22.273, 5.233, 39.433 and 8.907.
Feb 28, 2022 Sigh, the corners for today's BLD attempt were totally wrong and my averages have hit an all-time low: 20.595, 8.103, 40.345 and 12.222.
Feb 27, 2022 It's just a matter of time: 3 corners wrong again (but I re-attempted my memorization whilst being able to look and my corner memorization was slightly wrong). Also, 3x3 PB! (11.764, here's the scramble: F L2 U L2 F2 U2 L2 R2 U2 B' R2 B F R B D2 B' U B F) and the averages were not bad too: 19.507, 5.753, 37.973 and 9.585.
Feb 26, 2022 My 3x3 BLD attempt was agonizingly close, I had three corners that were wrong :(

Also, averages were (arguably) more disappointing: 22.265, 7.134, 39.826 and 11.307.
Feb 25, 2022 These have got to be my most disappointing averages: 21.324, 7.266, 43.087 and 9.680.
Feb 24, 2022 Back to meh averages: 21.481, 5.477, 36.067 and 9.224.
Feb 23, 2022 So close with today's 3x3 BLD attempt, only about 4 corners were wrong. Today's average were great: 19.330, 4.720, 36.209 and 8.188.
Feb 22, 2022 Got nothing much to say: 21.268, 5.496, 38.223 and 10.216.
Feb 21, 2022 Don't know what's going wrong, but I can't get any correct memorization (one can't be odd and another even) and today's averages were meh (except 3x3 OH, I got a 26!): 23.784, 5.127, 32.972 (!) and 12.093.
Feb 20, 2022 Couldn't get any 3x3 BLD memorization since I kept getting stuck in an "edge loop". Today's 3x3 was tragic. Were it not for that +2 at the end, I would have gotten a 19.879 average. Instead: 20.546, 4.763, 39.881 and 10.050.
Feb 19, 2022 I checked out another example solve and this one memorized corners -> memorized edges -> executed edges -> executed corners. I tried that (with parity) and it was pretty close (~5 corners were wrong). Anyways, today's averages were bad: 25.125, 7.246, 38.246 and 8.772.
Feb 18, 2022 Did a 3x3 BLD attempt while seeing, I'm 99% sure my parity algorithm and corner memorization are always wrong. I'll work on that. The averages were really good: 17.640 (!), 6.461, 38.753 and 8.020.
Feb 17, 2022 Not bad: 19.799, 5.190, 39.064 (was so close to 40 lol) and 8.005. Got a PB today for 2x2 (1.386) and Skewb (3.268)!
Feb 16, 2022 Today's averages were pretty amazing: 19.030, 4.953, 38.781 and 9.570.
Feb 15, 2022 Today's attempt was so close it's annoying, and today's averages were not bad: 21.033, 5.817, 36.105 and a 10.531.
Feb 14, 2022 Even cases still leave my corners all messed up. Today's averages were terrible: 21.927, 7.347, 35.463 and 10.863.
Feb 13, 2022 So close yet so far with BLD, I rechecked my solution and it was right up to the edges, I think parity messed me up, maybe my algorithm is wrong? Today's averages were very meh: 21.658, 6.286, 40.089 and 8.430.
Feb 12, 2022 Well, that upward trajectory lasted longer than the time the US made $1 coins: 21.514, 6.383, 34.207 and a 9.668.
Feb 11, 2022 So close! Just messed up my corner memorization (somewhere) and today's averages were great: 19.732, 6.033, 37.433, 9.408.
Feb 10, 2022 We're back: 19.463, 5.182, 35.965 and a 8.541.
Feb 09, 2022 BLD was really close today! I think I've gotten used to the new correct setup moves. Today's averages were sad (could have gotten sub-20 in 3x3 if it wasn't for me messing up PLL): 21.694, 7.680, 40.865 and a 9.638.
Feb 08, 2022 Today's BLD attempt failed spectacularly and today's averages were slightly less meh (emphasis on slightly): 22.500, 5.821, 41.203 and a 8.944.
Feb 07, 2022 Couldn't get today's BLD attempt, and today's were very meh: 24.692, 5.152, 40.385 and a 9.958.
Feb 06, 2022 HOLY CRAP TODAY'S 3X3 BLD ATTEMPT WAS SO CLOSE! Only my corner memorization was a little bit wrong and the buffer for the edge was flipped (which confirms that it's possible, I need to learn what to do in that case). Today's averages were good (except for 3x3, still waiting for a streak of sub-20's): 22.320, 4.962, 35.021 and a 10.029.
Feb 05, 2022 I must be doing something right with 3x3 BLD, I did my edge memorization (while being able to see) and it was all correct. But after doing the parity (which I was supposed to do) the whole corner memorization got messed up. Weird. Anyways, today's averages were meh: 21.027, 6.522, 38.636 and 10.536.
Feb 04, 2022 Okay, I rewatched an example solve and I realized I've been making a ton of mistakes. I tried to use the new buffer location, but my setup moves are now too complicated. Maybe the buffer location doesn't matter? Anyways, today's averages were better, 3x3 sub-20 coming soon: 20.770, 6.072, 37.997 and a 9.871.
Feb 03, 2022 I don't even want to talk about this day cubing-wise: 20.866, 4.760, 50.749 and 9.291.
Feb 02, 2022 So close! I think the only place I could have potentially gone wrong was returning to the buffer. Today's 3x3 OH average was insane, almost all solves were sub-35: 22.481, 6.097, 34.596 and 8.596.
Feb 01, 2022 Still no luck, will actually try recording my attempt over the weekend to see any mistakes I made after the solve. Today's averages (except 3x3 OH) were meh: 22.537, 6.205, 35.843 and 9.001.
Jan 31, 2022 Nope, that was not the reason. Today's averages were meh again: 22.205, 7.153, 40.376 and 10.354.
Jan 30, 2022 I think I found the reason why my 3x3 BLD attempts have all failed, it's because I didn't do wide setup moves. I'll try again tomorrow (I messed up parity in today's attempt lol). Today's averages were meh: 20.032, 5.665, 36.412 and 10.434.
Jan 29, 2022 The meh-streak continues: 21.008, 5.467, 38.579 and 7.971.
Jan 28, 2022 So close! One good thing that came from today's 3x3 BLD attempt was that everything was generally much faster (memorization + execution), though that could mean the probability of making a mistake is now much higher... Today's averages were meh again (except for 3x3 OH): 21.947, 5.328, 38.148 and a 8.784.
Jan 27, 2022 Thought today would be the day, but nope, I messed up the 3x3 BLD attempt quite badly (though I'm not sure what I did wrong in the attempt, maybe messed up an execution?). Anyways, today's averages (except 3x3) were meh: 18.878 (!), 7.080, 40.929 and 10.494.
Jan 26, 2022 So close! I think I only messed up my corner memorization, the edges were all correct and a few corners hadn't been swapped. Anyways, today's averages were meh again: 20.580, 6.680, 39.801 and a 9.568.
Jan 25, 2022 My closest 3x3 BLD attempt yet! Got every step done, maybe my memoization was wrong. Anyways, today's averages were pretty meh: 19.308, 6.757, 44.479 and a 10.444.
Jan 24, 2022 Pretty bad all around, failed my 3x3 BLD attempt with the same mistake I've been making in the past few attempts (confused between algorithms) and got pretty meh averages: 20.538, 4.140, 54.184 and an 8.206.
Jan 23, 2022 Everything today was very, very sad: 21.869, 5.481, 44.561 and a 9.391.
Jan 22, 2022 Today's 3x3 BLD attempt was so bad it was funny, I thought mid-way the solve that I might get only a few wrong (since I forgot to do the parity algorithm) but nope. Anyways, today's averages were also, well, average. But I did get a 3x3 OH PB (22.402): 20.095, 6.131, 41.337 and an 8.516.
Jan 21, 2022 Got quite close with my 3x3 BLD attempt, one day... Today's averages were pretty meh: 22.241, 5.753, 41.772 and a 9.544.
Jan 20, 2022 I learnt yesterday night why all my 3x3 BLD attempts failed, it's because I swapped the wrong buffer piece and I didn't do the parity algorithm. I corrected both today, a successful attempt should come soon. Today's averages were good: 19.257, 4.985, 36.746 and a 7.840.
Jan 19, 2022 Very strange 3x3 BLD full attempt today, I somehow got all edges correct and no corners correct. Anyways, today's averages were awesome: 19.627 (!), 4.514 (!), 38.066 (!) and a 7.689 (!)
Jan 18, 2022 Today's averages were crazy! Got an 18.415 (!), 4.202 (!), 38.537 (!) and a 9.553. Also did my first full 3x3 BLD attempt, did not go too well but the amount of progress I'm making is amazing.
Jan 17, 2022 Pretty awesome averages today, got a 19.129 (!), 5.254, 37.508 (!) and a 10.109.
Jan 16, 2022 Today was crazy for 2x2, I destroyed my PB, twice in a row, first with a sub-3 (2.589) and then with a sub-2 (1.450), today's averages were nothing too crazy though: 20.102, 5.000 (!), 42.915 and an 8.407.
Jan 15, 2022 I think I've fully learnt 3x3 BLD edges! Will move on to corners tomorrow. As for the times today, a bit disappointed with 3x3 but the rest were alright: 24.521, 6.656, 36.764 (!) and a 7.299 (!)
Jan 14, 2022 I think I have to follow the tutorial again for 3x3 BLD, making the same mistakes over and over again. Anyways, today's averages were awesome, soon to be sort of officially sub-40 3x3 OH and sub-20 3x3: 18.546, 6.218, 35.814 and 10.457.
Jan 13, 2022 Again, got really close to 3x3 BLD edges attempt. As for the times today: I got a 23.001, 6.177, 34.869 (!) and a 10.518.
Jan 12, 2022 SO CLOSE to a true 3x3 BLD edges attempt! I was only one swap away. Anyways, I completed 500 solves in every event, and today's averages were a 21.648, 5.759, 43.116 and a 10.973.
Jan 11, 2022 So close to sub-40 AO5 for 3x3 OH, but I messed up the last solve. Will move on to memorizing corners for 3x3 BLD and today's times are a 20.929, 5.127, 40.641 and a 9.240.
Jan 10, 2022 Pretty great for 2x2, got a 20.645, 4.702 (!), 43.245 and a 10.341.
Jan 09, 2022 Today was crazy for 3x3 OH again, got a 21.468, 6.339, 37.748 (!) and a 10.506.
Jan 08, 2022 Amazing day! Got a 3x3 OH PB (24.204) (!) and great averages for 3x3 and 3x3 OH: 19.394 (!), 6.030, 35.962 (!) and a 10.915.
Jan 07, 2022 Not bad, got a 21.398, 5.979, 41.616 and a 10.386.
Jan 06, 2022 Amazing averages! Got a 19.056 (!), 5.725, 39.427 and a 8.321.
Jan 05, 2022 Progress! I solved the 3x3 BLD edges (though I could see the cube, just trying to get my memorization correct) and today's 2x2 was crazy good. 20.787, 4.923 (!), 40.937 and a 10.749.
Jan 04, 2022 Started with my 3x3 BLD practice (though it will be a slow journey) and I got a 20.636, 6.771, 44.624 and an 8.753.
Jan 03, 2022 Pretty good day, got another successful 2x2 BLD solve, going to move on to 3x3 BLD with this video, as for the times, I got a 19.373 (!), 6.114, 41.561 and a 9.421.
Jan 02, 2022 PaNama Times Something Goes Mad! That was the memorization for my first ever legit 2x2 BLD solve! I did it again (though the scramble was pretty easy). As for the times today, they were pretty mid: 20.916, 5.551, 44.045 and a 9.939.
Jan 01, 2022 Happy new year! Getting really close with 2x2 BLD, I think my main problem is what I memorize is wrong, the memorization and solving part is not hard. Anyways, I got a 21.460, 6.278, 45.938, 9.669.
Dec 31, 2021 Still no luck with 2x2 BLD, but the times today were not bad, nearly got a 3x3 OH PB (29.480): 20.790, 6.353, 37.504 (!) and a 8.922. Hope to go for a competition in 2022!
Dec 30, 2021 No luck with 2x2 BLD still and a pretty average day, 21.719, 6.508, 43.146 and a 11.594.
Dec 29, 2021 So close! I attempted 2x2 BLD (by closing my eyes lol) thrice and got only two pieces unsolved in the last two attempts. Hopefully, by the end of this week, I'll know how to solve it BLD. Anyways, today's times were nothing great: 23.027, 6.431, 43.704 and 8.318.
Dec 28, 2021 Alright day, got a 21.078, 5.375, 39.117 (!) and a 12.108.
Dec 27, 2021 Solved a 2x2 with the Old Pochmann method! (though I wasn't blindfolded, and I can only do it if I don't have a new cycle, I'll have to revise that), as for the times, I got a 19.002 (!), 5.674, 40.539 and 9.591.
Dec 26, 2021 Made good progress learning 2x2 blindfolded with this video and got alright times for today: 21.616, 6.931, 39.859 (!) and a 10.084.
Dec 25, 2021 Meh, got a 21.567, 5.878, 40.827 and a 9.778.
Dec 24, 2021 Learnt full PLL on 3x3! As for the times, I got a 21.452, 5.898, 41.674 and a 10.835.
Dec 23, 2021 400 solves! The AO100's are 21.074, 6.508, 41.509 and 9.773, the AO5's I got are a 18.486 (!), 5.573, 46.521 and a 9.611.
Dec 22, 2021 Getting better, 5 more solves till 400 for each event! As for the times, I got a 20.635, 5.822, 37.404 (!) and a 9.471.
Dec 21, 2021 Meh again, got a 21.244, 6.696, 40.381 and a 10.185. Learnt the Gc perm, only one more to go!
Dec 20, 2021 Even worse this time, got a 20.709, 7.065, 48.662 and a 10.913.
Dec 19, 2021 Alright I guess, got a 21.317, 7.003, 40.893 and a 9.900. Hope to learn full PLL by the end of this week.
Dec 18, 2021 Pretty good, got a 18.939 (!), 7.039, 41.364 and 8.666 (!). Is Gc perm the worst G perm?
Dec 17, 2021 On fire for 3x3 OH! Today's 3x3 times were very funny, I got a 30 in one of them, 20 in two of them and then a 15 in the last solve. Anyways, I got a 20.895, 6.642, 34.869 (!) and a 9.233.
Dec 16, 2021 Slightly worse, but still did very good in 3x3 OH, got a 22.331, 5.687 (!), 37.640 (!) and a 9.206. Going to learn the Gc perm tomorrow.
Dec 15, 2021 Awesome day cubing wise! Got a 19.421 (!), 5.322 (!), 38.880 (!) and a 8.327 (!).
Dec 14, 2021 Skewb PB (3.601)! As for the rest of the times, I got a 21.208, 6.461, 43.598 and a 9.656.
Dec 13, 2021 Meh, got a 23.123, 5.687, 44.295 and a 10.790.
Dec 12, 2021 Awesome day for 3x3 OH, and I finally learnt the Gb perm, two more left till full PLL! I got a 23.261, 6.302, 36.469 (!) and an 8.115 (!)
Dec 11, 2021 Another alright day, waiting for the day I get a sub-35 average on 3x3 OH. Got a 22.886, 7.857, 38.093 (!) and a 9.395.
Dec 10, 2021 Alright day, got a 24.017, 6.548, 39.872 (!) and a 8.367 (!), getting used to the Gb perm.
Dec 09, 2021 Not bad again! Got a 19.181 (!, sub-20 coming soon), 7.012, 40.600 and a 8.617 (!). Trying to learn 2x2 BLD with this video.
Dec 08, 2021 Not bad, 18.317 (!), 6.659, 43.555 and 11.729. The Gb perm is pretty hard.
Dec 07, 2021 Alright day, got a 19.128 (!), 6.142, 40.139 and a 11.155.
Dec 06, 2021 Slightly better, got a 21.576, 6.995, 48.182 and a 9.809, going to learn the Gb perm tomorrow.
Dec 05, 2021 Pretty bad day, got a 21.047, 6.170, 50.366 and a 9.781. At least I learnt the Ga perm.
Dec 04, 2021 Not bad, got a 19.496 (!), 6.902, 40.402 and a 11.875. Finished N Perms and hope to learn full 3x3 PLL by next week.
Dec 03, 2021 300 solves! My AO100's are 20.783, 5.877, 42.701 and a 9.891. As for my AO5's today, I got a 20.249, 4.813 (!), 41.474 and an 11.669. Also sent a proposal to create a cubing challenge for EA Cambridge's Slack group!
Dec 02, 2021 Got a 14 single in 3x3! But other than that, an average day. Got a 19.900 (!), 5.993, 43.128 and a 10.339.
Dec 01, 2021 Talk about an early Christmas miracle, I got a 14.166 3x3 PB! As for the rest of the times, I got a 20.197, 6.595, 36.706 (!) and an 8.390.
Nov 30, 2021 This month was pretty awesome cubing-wise, sure there were plenty of average days, but I got really good at 3x3 OH (now my favourite event) and got plenty of PB's! Oh, I got 20.019, 7.074, 43.291 and a 8.094.
Nov 29, 2021 The average day has come, got a 20.047, 5.988, 42.593 and a 10.056.
Nov 28, 2021 Was going to be an average day, but I got a PB for 3x3 OH! (29.375) As for the rest of the times, I got a 23.697, 5.978, 39.592 (!) and a 9.283.
Nov 27, 2021 What a recovery, got a 20.494, 5.737, 46.187 and a 11.190.
Nov 26, 2021 Pretty mid today, got a 25.170, 6.910, 40.536 and a 9.746.
Nov 25, 2021 3X3 PB with PLL skip (14.539)! As for the rest of the times, I got a 20.491, 5.656, 41.291 and a 11.494
Nov 24, 2021 I think I got an AO5 PB for 3x3! I got a 18.139 (!), 5.137, 44.735 and a 9.151 (!)
Nov 23, 2021 Amazing day! Got a 19.178 (!), 5.274, 35.787 (!) and a 10.861.
Nov 22, 2021 Pretty mid, got a 21.312, 5.734, 44.323 and a 10.070.
Nov 21, 2021 So close to sub-40 for 3x3 OH! Got a 21.800, 5.644 (!), 40.224 (!) and a 10.965.
Nov 20, 2021 Much better, got a 19.348 (!), 6.056, 45.858 and a 8.337 (!).
Nov 19, 2021 Mid again: 20.097, 6.213, 45.935 and a 10.867.
Nov 18, 2021 Reached 15² solves, though today my averages were pretty mid: 20.534, 6.302, 47.552 and a 10.534.
Nov 17, 2021 Great day, got a 18.659 (!), 4.481 (!), 43.815 and a 9.598.
Nov 16, 2021 Amazing day! Got a 20.118, 4.781 (!), 37.553 (!) and a 8.789. (!)
Nov 15, 2021 Pretty good for 3x3 and 2x2, got a 19.861 (!), 5.405 (!), 45.114 and a 11.640.
Nov 14, 2021 Not bad, got a 21.894, 6.561, 42.843 and a 8.672. Trying to set up jperm.net.
Nov 13, 2021 I reached 200 attempts for all four events, here are the AO100's: 21.648, 6.380, 46.315 and a 10.089. For the AO5's, there were pretty good: 21.344, 5.282 (!), 46.523 and a 8.131.
Nov 12, 2021 Okay session, got a 21.626, 5.265 (!), 41.383 and a 10.691.
Nov 11, 2021 Great session, got a 19.111 (!), 6.761, 42.691 and a 9.557 (!).
Nov 10, 2021 Pretty meh all around, got a 23.695, 6.000 (not a joke), 45.575 and a 12.027.
Nov 09, 2021 Alright session, got a 20.806, 6.135, 40.776 and a 10.041.
Nov 08, 2021 Learnt the Ga perm! My first G perm. As for the AO5's, they weren't half bad, but I can feel 3x3 sub-20 coming soon. I got a 20.842, 6.492, 41.137 and a 12.110
Nov 07, 2021 Pretty great session for 2x2, got a 21.192, 4.991 (!), 47.397 and a 8.940. I think I've fully learnt all the N perms!
Nov 06, 2021 Alright session, got a 22.703, 7.097, 46.636 and a 8.231.
Nov 05, 2021 3x3 PB (14.778)! I also got two sub-40's in 3x3 OH and a sub-6 AO5 for 2x2! Here are the times: a 22.017, 5.851 (!), 42.885 (!) and a 7.902 (!) For reference, here are the G perms I'm learning:

G Perms

Nov 04, 2021 My 3x3 turning was so choppy today. Got a 21.306, 5.272, 43.433 and a 12.279. I also practised my Nb perm.
Nov 03, 2021 Alright session, got a 20.729, 6.346, 49.053 and a 9.319.
Nov 02, 2021 Was about to be a pretty good day until I got a PB for 3x3 OH! (29.578). For the rest of the times, I got a 22.646, 6.820, 39.839 (!) and an 11.581. I re-learnt the F perm for 3x3 PLL.
Nov 01, 2021 New month, new (pretty bad) averages. I got a 28.293, 5.824 (!), 45.115 and a 11.135. I also practised PLL's.
Oct 31, 2021 Got a PB for Skewb! (3.959) and got a 21.759, 6.567, 48.101 and a 7.600.
Oct 30, 2021 Another great session, especially for Skewb! I got a 23.748, 7.724, 48.450 and a 7.112 (!). I also learnt the N perms for PLL.
Oct 29, 2021 Pretty great session! Got a sub-4 for 2x2 (3.875), and got a 22.077, 6.040, 47.577 and a 7.451 (!)
Oct 28, 2021 Finished the rest of my solves for 3x3 OH and Skewb, got a 19.775, 6.538, 1:02.230 and a 13.673.

Local Hackathon

Oct 20, 2022
Participated in a local hackathon and did pretty well with my teammates! Due to privacy reasons, I was being incredibly vague.

Summary

Participated in a ~3 hour long hackathon which consisted of 2 questions. My team could attempt both questions and it was a lot of fun!

Hackathon - October

Landing Page Project + App Integration

Jul 29, 2022-Oct 18, 2022
Designed a landing page for a project I've been accepted to. In addition, I helped with app integrations among other things. Note that, due to organizational requirements, I was being incredibly vague.

Landing Page Project's start date is the date I started logging, not the date when the project started.

Log

Sep 23, 2022 Continued with a recording.
Sep 22, 2022 Continued (?) with a recording.
Sep 14, 2022 Added suggestions and ideas.
Sep 12, 2022 Had an awesome team meeting! In addition, I compiled a few resources.
Sep 09, 2022 Had a productive meeting.
Sep 04, 2022 Continued with some research.
Sep 03, 2022 Continued with some research.
Sep 02, 2022 Continued with some research.
Aug 29, 2022 Continued with some research.
Aug 28, 2022 Continued with some research.
Aug 27, 2022 Continued with some research.
Aug 26, 2022 Had a productive meeting and continued with some research.
Aug 25, 2022 Continued with some research.
Aug 24, 2022 Continued with some research.
Aug 23, 2022 Continued with some research.
Aug 22, 2022 Continued with some research.
Aug 21, 2022 Continued with some research.
Aug 20, 2022 Continued with some research.
Aug 19, 2022 Continued with some research.
Aug 18, 2022 Continued with some research.
Aug 17, 2022 Continued with some research.
Aug 16, 2022 Continued with some research.
Aug 15, 2022 Continued with some research.
Aug 14, 2022 Continued with some research.
Aug 13, 2022 Continued with some research.
Aug 12, 2022 Continued with some research.
Aug 11, 2022 Got started with some research.
Aug 10, 2022 Had a really productive meeting, which helped to solve some of standing technical/integration enquires.
Aug 09, 2022 Tested a Make integration to not much avail again.
Aug 08, 2022 Tested a Zapier integration to not much avail. I'll try another integration tomorrow.
Aug 07, 2022 Had a productive meeting.
Aug 06, 2022 Wrote-up and sent my findings on an organisational discount.
Aug 05, 2022 Wrote-up and sent my findings on apps for different scenarios.
Aug 04, 2022 Wrote-up and sent my findings on an app integration and pricing.
Aug 02, 2022 Finished with the sixth draft of the first section.
Aug 01, 2022 Had a productive meeting and finished with the fifth draft of the first section.
Jul 31, 2022 Finished with the fourth draft of the first section.
Jul 30, 2022 Finished (?) with the third draft of the first section.
Jul 29, 2022 Had a productive meeting and got started with the third draft of the first section.

KENKEN

Jan 30, 2022-Oct 08, 2022
I was a two-time silver medalist for 2019 and 2020 in my country. Initially tried to get a similar result for 2022, but ended up losing interest. Note that, for the majority of this project, I got four 5x5s and two 6x6s (thought it was previously two 4x4s and four 5x5s).

Log

Oct 08, 2022 Got selected for the national level! (Written on Jan 14, 2023 - Though I ended up not going.)
Oct 06, 2022 5/6 in ~11 minutes. I've decided to pause this project. If I get selected to the national level, I'll continue this project, else it ends.

Truth be told, I do not find KENKEN enjoyable anymore. I guess the charm wears off after a while.
Oct 05, 2022 5/6 in ~7.5 minutes.
Oct 04, 2022 All correct in ~8-9 minutes.
Oct 01, 2022 Had my "state"-level exam which went well.
Sep 30, 2022 Finished the August 2022 weekly challenges: ~10 minutes and ~8 minutes, all correct for both.
Sep 29, 2022 Daily puzzles went well.
Sep 28, 2022 Daily puzzle went alright (saw the solution for the other one).
Sep 26, 2022 Daily puzzle went alright.
Sep 25, 2022 Daily puzzles went okay.
Sep 22, 2022 Sort of skipped today (finished one daily puzzle that I saw the solution to).
Sep 21, 2022 Sort of skipped today (finished one daily puzzle).
Sep 20, 2022 Almost 12 minutes for all correct.
Sep 19, 2022 Sort of skipped today (finished one daily puzzle that I saw the solution to).
Sep 18, 2022 ~7.5 minutes for all correct.
Sep 17, 2022 ~11-12 minutes for 5/6.
Sep 16, 2022 ~12 minutes for all correct.
Sep 15, 2022 ~10 and three-fourths of a minute for all correct.
Sep 14, 2022 Daily puzzles went okay.
Sep 09, 2022 Finished ~2 out of the 6 daily puzzles.
Aug 31, 2022 Sort of skipped today as well.
Aug 30, 2022 Sort of skipped today.
Aug 29, 2022 Daily puzzles went okay.
Aug 26, 2022 Daily puzzles went alright (~3-4 checks).
Aug 25, 2022 ~11 minutes for all correct.
Aug 24, 2022 ~6 minutes for all correct.
Aug 23, 2022 ~11-12 minutes for all correct.
Aug 22, 2022 ~9 minutes for all correct.
Aug 21, 2022 Daily puzzles went okay.
Aug 20, 2022 ~9 minutes for all correct.
Aug 19, 2022 I think daily puzzles went alright?
Aug 18, 2022 ~18 minutes for all correct.
Aug 17, 2022 ~8 minutes for all correct.
Aug 16, 2022 ~9.5 minutes for all correct.
Aug 15, 2022 ~11 minutes for all correct.
Aug 14, 2022 Did not have too much time left in the day for KENKEN, so I just did two hard 6x6s with unlimited checks.
Aug 13, 2022 ~11 minutes for all correct.
Aug 12, 2022 4 checks for two hard 6x6s.
Aug 11, 2022 ~9 minutes for 5/6.
Aug 10, 2022 Solved a 7x7 for fun!
Aug 09, 2022 Sigh, ~14 minutes for 5/6.
Aug 08, 2022 ~13 minutes for all correct.
Aug 07, 2022 ~11 minutes for all correct.
Aug 06, 2022 For some reason, I just couldn't do today's weekly challenge. I guess I was too distracted. I'll try again tomorrow.
Aug 05, 2022 Daily puzzles went alright.
Aug 04, 2022 Don't do KENKEN when you're tired.
Aug 03, 2022 Daily puzzles went okay.
Aug 02, 2022 Back to sub-10 minutes for all correct!
Aug 01, 2022 Daily puzzles went well.
Jul 31, 2022 19 seconds shy of 10 minutes with all correct.
Jul 30, 2022 15 seconds shy of 10 minutes with all correct.
Jul 29, 2022 Daily puzzles went alright (had to basically skip the last one though).
Jul 28, 2022 ~11 minutes for all correct (tried to pause it as I had to get up, didn't work lol).
Jul 27, 2022 Two sub-3s on two hard 6x6s with only one check in the last one.
Jul 26, 2022 ~12 minutes for all correct.
Jul 25, 2022 ~7 minutes for 5/6. All remaining weekly challenges have been completed!
Jul 24, 2022 ~8 minutes for all correct.
Jul 23, 2022 ~8 minutes for all correct.
Jul 22, 2022 ~8 minutes for all correct.
Jul 21, 2022 ~15 minutes for all correct.
Jul 20, 2022 ~9 minutes for 5/6.
Jul 18, 2022 ~13 minutes for all correct.
Jul 17, 2022 ~14 minutes for all correct.
Jul 16, 2022 Just barely got 9 minutes for yesterday's (?) weekly challenge.
Jul 14, 2022 9 and 10 minutes for all correct.
Jul 12, 2022 7 minutes for all correct and 9 minutes for 5/6.
Jul 11, 2022 11 minutes for all correct.
Jul 06, 2022 5/6.
Jun 04, 2022 9 minutes for all correct.
Jun 02, 2022 Why is the weekly challenge daily?
Jun 30, 2022 12 minutes for all correct.
Jun 28, 2022 All correct in ~8 minutes!
Jun 27, 2022 Daily puzzles were alright.
Jun 26, 2022 15 minutes for a 6x6 wrong.
Jun 25, 2022 Daily puzzles were alright.
Jun 24, 2022 13 minutes for a 5x5 wrong.
Jun 22, 2022 Daily puzzles went alright.
Jun 21, 2022 I just got through today's weekly challenge lol.
Jun 20, 2022 Oof, got the last 6x6 wrong because I forgot that the sum property of a 6x6 is 21.
Jun 19, 2022 All correct in the Weekly challenge in 8 minutes and 20 seconds. Need to get it down to 7 by the end of this month.
Jun 18, 2022 Sigh, 5/6. Déjà vu?
Jun 17, 2022 Daily puzzles went well.
Jun 16, 2022 Sigh, 5/6.
Jun 15, 2022 Daily puzzles went well.
Jun 14, 2022 Could have gotten all correct in ~8 minutes if it wasn't for a silly mistake in the last 6x6.
Jun 13, 2022 Daily puzzles went okay.
Jun 12, 2022 Sigh, 4/6.
Jun 11, 2022 5/6. It's both good and bad that I no longer find the hard 6x6s in the daily puzzles difficult.
Jun 10, 2022 All correct in ~5 minutes!
Jun 09, 2022 5/6 in what felt like forever.
Jun 08, 2022 The website glitched out, so I got to do only one daily puzzle :(
Jun 07, 2022 Sigh. All 6x6s wrong.
Jun 06, 2022 Daily puzzles went okay.
Jun 05, 2022 ~9 minutes again... but with a 6x6 left wrong :(
Jun 04, 2022 ~9 minutes for the weekly challenge. I hope to stabilize to ~7 minutes soon enough.
Jun 03, 2022 Daily puzzles went pretty well.
Jun 02, 2022 Sigh. 11 minutes for 1 6x6 wrong.
Jun 01, 2022 Daily puzzles went well.
May 31, 2022 I somehow got two 5x5s wrong in today's weekly challenge. Should I slow down for 5x5s?
May 30, 2022 Daily puzzles were alright.
May 29, 2022 All correct in exactly 10 minutes lol.
May 28, 2022 Weekly challenge in ~8 minutes... with all the 6x6s wrong.
May 27, 2022 Daily puzzles were pretty bad.
May 26, 2022 All correct in ~7 minutes and 40 seconds in today's weekly challenge.
May 25, 2022 Daily puzzles were okay.
May 24, 2022 All correct in less than 7 minutes in today's weekly challenge!
May 23, 2022 Daily puzzles were alright.
May 22, 2022 Tragic, got the 5x5 wrong but the rest were correct in ~7 minutes :/
May 21, 2022 I DID IT! Just under 6 minutes for all correct in the weekly challenge!
May 20, 2022 Sigh, 8 minutes for the last 6x6 left incomplete.
May 19, 2022 Worst weekly challenge ever: ~8 minutes for three wrong (2 wrong, 1 left unattempted) :(
May 18, 2022 Daily puzzles were meh to alright.
May 17, 2022 Weekly challenge went so poorly (5/6 in more than 10 minutes) :(
May 16, 2022 Daily puzzles were meh.
May 15, 2022 Getting sort of close to the 7 minute mark with the weekly challenges!
May 14, 2022 Same issue, below 10 minutes but left one puzzle as wrong for that (to make matters worse, it was a 5x5).
May 13, 2022 Daily puzzles were alright.
May 12, 2022 ~9 minutes with the last 6x6 incorrect :(
May 11, 2022 ~7 minutes with all correct in the bonus challenge!
May 10, 2022 Weekly challenge took ~10 minutes but with the last 6x6 was incorrect.
May 09, 2022 Daily puzzles were pretty good!
May 08, 2022 Got below 9 minutes in the weekly challenge with all correct!
May 07, 2022 Got all correct in the weekly challenge... in ~14 minutes :(
May 06, 2022 Daily puzzles were meh.
May 05, 2022 Another weekly challenge in 9 minutes, but... I had to leave a 6x6 as incorrect for that :(
May 04, 2022 Daily puzzles were terrible lol.
May 03, 2022 I DID IT! All correct in ~9 minutes! Now I need to do all of it in 7 minutes...
May 02, 2022 Daily puzzles were not bad.
May 01, 2022 Not sure what the exact medical term is, but "the physiological feeling of having no time left in an exam/competitive setting" happened in today's weekly challenge lol. I had ~2 minutes left to reach my goal of completing a weekly challenge in 10 minutes or less and I did it... but all of the 6x6s were wrong. :(
Apr 30, 2022 Weekly challenge was pretty poor (one wrong in 14 minutes) and daily puzzles were half-way decent.
Apr 29, 2022 Daily puzzles went really well for a change.
Apr 28, 2022 Bad day KENKEN-wise, took ~14 minutes for all correct and daily puzzles were pretty bad.
Apr 27, 2022 I've noticed that with hard 6x6 puzzles, I need to often make strenuous guesses or YOLO my way out of it. Sigh.
Apr 26, 2022 Sigh, I was about to finish the weekly challenge in about 10 minutes, but the last 6x6 tripped me up.
Apr 25, 2022 I need to stop using the check button every time I put something down.
Apr 24, 2022 Finished the weekly challenge in under 10 minutes BUT I had to basically skip the last 6x6 for that to happen.
Apr 23, 2022 Not bad, a little more than 10 and a half minutes with all correct for today's weekly challenge (I miraculously got the last 6x6 correct lol).
Apr 22, 2022 Daily puzzles went alright.
Apr 21, 2022 Similar story, ~16-17 minutes but all correct (the first 6x6 was pretty darn hard).
Apr 20, 2022 Even worse, went down to 16 minutes with 1 wrong.
Apr 19, 2022 Dropped down to 15 minutes for the weekly challenge :(
Apr 18, 2022 Daily puzzles went meh.
Apr 17, 2022 Got another one below 10 minutes, though this time it took 9 minutes and 46 seconds (all correct) and the daily puzzles went a bit better.
Apr 16, 2022 Got below 10 minutes on the weekly challenge! (~9 and a half minutes with all correct) and daily puzzles are still meh (I even got one wrong).
Apr 15, 2022 Daily puzzles went laughably bad.
Apr 14, 2022 Weekly challenge (all correct in 12 minutes) and daily puzzles went meh, I hope to get below 10 minutes on the weekly challenge next week.
Apr 13, 2022 Daily puzzles went well.
Apr 12, 2022 Finished the weekly challenge in 11 minutes this time around and finished 2 hard 6x6s.
Apr 11, 2022 Bonus challenge took almost 20 minutes and I couldn't do a second hard 6x6 :(
Apr 10, 2022 Still took more than 10 minutes but got all correct this time. Bonus challenge will be done tomorrow!
Apr 09, 2022 Weekly challenge (5/6) took more than 10 minutes (I don't remember the exact time). Need to bring it down to less than 10 minutes consistently.
Apr 08, 2022 Daily puzzles were decent, I'm really happy at my progress at hard 6x6s.
Apr 07, 2022 Barely got through the weekly challenge in 10 minutes (closer to 11 actually but whatever).
Apr 06, 2022 Daily puzzles went alright.
Apr 05, 2022 Haha, they changed the weekly challenge to four 5x5s and two 6x6s (in the order), finished that with all correct in 15 minutes (which is bad, but it's my first try at it so it's alright) and the first hard 6x6 I did took me 10 minutes lol.
Apr 04, 2022 When solving hard puzzles, your main goal isn't to find the correct position of the numbers right away, but rather you need the fuel: this could be from the row-column sum property, just some simple logic (a +12 cell in a 6x6 always has to contain a 5 and two number that add up to seven), anything really. After that, it's a piece of π.
Apr 03, 2022 6/6 in 4 and a half minutes! The two hard 6x6s went alright, though I did take a lot of time for both of them.
Apr 02, 2022 Finished weekly challenge (5/6 in 10-ish minutes) and I think I'm ready for hard 6x6s now.
Apr 01, 2022 Daily puzzles went meh.
Mar 31, 2022 Why do I keep blundering a puzzle in the weekly challenge? Also, when will I comfortably transition to hard 6x6s, when will my weekly challenges update? So many questions.
Mar 30, 2022 Daily puzzles went meh, I really hope they update our weekly challenges for the next level puzzles (since I'll be getting 6x6s not 4x4s)
Mar 29, 2022 Made it to the next level (I somehow got the first 4x4 wrong in the school level exam) and got all correct in the weekly challenge today and the daily puzzles went okay.
Mar 28, 2022 For some reason, only one daily puzzle was unlocked, but it went well (one medium 6x6).
Mar 27, 2022 Daily puzzles (two medium 6x6s) went alright.
Mar 26, 2022 Slightly better, 5/6.
Mar 25, 2022 Got 4/6 in my last weekly challenge for this week.
Mar 24, 2022 New PB: Weekly challenge completed in less than 4 minutes, why couldn't have the school exam gone like this?
Mar 23, 2022 No weekly challenge today, but the daily puzzles (two medium 6x6s) went alright.
Mar 22, 2022 Sigh, got 4/6 in the weekly challenge and the daily puzzles (two medium 6x6s) went really poorly.
Mar 21, 2022 Both the bonus weekly challenge (5/6 in about 11 minutes) and the daily puzzles went poorly.
Mar 20, 2022 Finished with the weekly challenge and the daily puzzles, will complete the bonus challenge tomorrow.
Mar 19, 2022 Had my school-level exam. It went pretty terribly (most likely all correct in about 10 minutes) but it's very likely I proceed to the next level. Also finished weekly challenge and daily puzzles.
Mar 18, 2022 Finished with the daily puzzles, went really well.
Mar 17, 2022 Found something interesting in my weekly challenge (which went meh) and my daily puzzles: Notice the below image and the "108x" cage:

Half of an interesting 6x6 KENKEN puzzle

Now, there is only one possibility which is "3 x 6 x 6 x 1", but what about the position? We can use the fact that 1 has to be on the top row of the cage to our advantage and see that that there are only two possibilities left:

But regardless of which possibility is correct, 3 and 6 are always in the bottom row! So, that leaves 4 in the "9+" cage. Thought it was interesting.

Mar 16, 2022 Back to medium 6x6s.
Mar 15, 2022 Weekly challenge (one wrong in about 10 minutes) and daily puzzles (had to drop back to easy 6x6s) went bad.
Mar 14, 2022 Happy Pi Day, I don't think I'm ready for two hard 6x6s. I mean, I didn't check my medium 6x6 (being overconfident) and got it wrong lol.
Mar 13, 2022 Both the weekly challenge (all correct in > 8 minutes) and daily puzzles went badly. At least I have a bonus challenge for Pi Day.
Mar 12, 2022 Finished the last weekly challenge for this week (doesn't make sense, I know) in 6 and a half minutes. The first hard 6x6 was good but it took a long time to find the second one.
Mar 11, 2022 Going to start doing 2 hard 6x6s for my daily puzzles instead of one medium and one hard.
Mar 10, 2022 Finished the weekly challenge (all correct in ~5-6 minutes) and finished a medium and a hard 6x6 (again, went poorly today).
Mar 09, 2022 Finished a medium 6x6 in ~3 minutes but the hard 6x6 went pretty poorly today.
Mar 08, 2022 Not bad, got done with the weekly challenge (all correct in about 6 minutes) and finished a medium, and a hard 6x6 in ~3 minutes each.
Mar 07, 2022 Finished a medium, 6x6 in less than 2 minutes! Hard 6x6 went pretty well too.
Mar 06, 2022 Finally, the weekly challenge went well (all correct in just shy of 6 minutes) and finished a medium and hard 6x6.
Mar 05, 2022 Finished with the weekly challenge (was going amazingly well until I couldn't solve a dumb 5x5, still did 5/6 in 6 and a half minutes) and finished with one medium 6x6 and a hard 6x6.
Mar 04, 2022 I've started doing one medium 6x6 and one hard 6x6. The hard one takes ~4 minutes so my goal is to get that down to 2 minutes.
Mar 03, 2022 Getting better at 6x6 and today's weekly challenge was meh (one wrong in ~8 minutes)
Mar 02, 2022 Finished with two medium 6x6s, they went fine.
Mar 01, 2022 Weekly challenge was going smoothly till one 5x5 messed up my time. I took a little more than 10 minutes and couldn't get the last one. :(
Feb 28, 2022 Medium 6x6 takes too much time and an easy 6x6 takes too little time to solve!
Feb 27, 2022 Finished the weekly challenge (~10 minutes, all correct) and two medium 6x6. I have this bad habit with my daily puzzles of hitting the "Check" button, so I hit it for the last puzzle and saw I got most cells flipped (i.e. wrong). Ouch.
Feb 26, 2022 Finished the weekly challenge (went meh, ~10 minutes and got one wrong) and a medium and hard 6x6 (the hard one took a long time).
Feb 25, 2022 Finished a hard and medium 6x6 after a lot of cherry-picking lol.
Feb 24, 2022 Solid day, finished the weekly challenge in less than 10 minutes and finished a medium 6x6 and a hard 6x6.
Feb 23, 2022 Finished one medium and one hard 6x6 with all operations! (though they took a long time)
Feb 22, 2022 Can now solve an easy 6x6 with all operations in a little under 3 minutes! Also, today's weekly challenge went alright (all correct but in 10 minutes, got stuck with a puzzle).
Feb 21, 2022 Finished with two puzzles, including a medium 6x6 (with + and -) in only 2 and a half minutes!
Feb 20, 2022 Pretty slow throughout my two weekly challenges (one of them was a bonus and I got one wrong) and my daily puzzles. At least I started with addition and subtraction for 6x6!
Feb 19, 2022 Amazing day! Beat my record (all correct in 5 minutes and 12 seconds) and moved up to easy (not easiest/very easy) 6x6 with only addition.
Feb 18, 2022 No weekly challenge today but I finished a hard 5x5 and a very easy 6x6 (improving in time quite a bit).
Feb 17, 2022 Finished a hard 5x5 and a very easy 6x6 (which took way too long lol) and I think I hit a new record for the weekly challenge, all correct in 5 minutes and 59 seconds!
Feb 16, 2022 Finished two hard 5x5s, going to start doing one 6x6 (starting with all operations + easiest and working my way up) and one hard 5x5 since all the stages above school level have two 6x6s for my category!
Feb 15, 2022 Finished with 5/6 again and (for fun) I did an easy 6x6 (with only addition) and the usual hard 5x5 (both took roughly the same amount of time!)
Feb 14, 2022 Not bad, 5/6 again and finished the two hard 5x5s quite quickly.
Feb 13, 2022 Solid day, 5/6 in the weekly challenge and finished the two hard 5x5s.
Feb 12, 2022 Alright day, finished the two weekly challenges remaining for this week (6/6 in the first one, 4/6 in the other, both times I used a decent amount of time) and finished my two hard 5x5s for the day.
Feb 11, 2022 Nice! A new record, all puzzles correct in only ~6 minutes! Also got both my hard 5x5's done in less than 2 minutes. I already feel ready for the exam.
Feb 10, 2022 Solved the weekly challenge in only 8 minutes! (it also wrongly marked my first 4x4 as incorrect, weird) and I finished one hard 5x5 (blocked me from doing a second one, weird).
Feb 09, 2022 Got done with the last Jan weekly challenge (4/6, pretty meh) and finished two hard 5x5's (last one took a long time).
Feb 08, 2022 Alright day, finished a weekly challenge (5 out of 6) and 2 hard 5x5's (though the last one I had to rely on the check tool a lot).
Feb 07, 2022 Finished a weekly challenge (all correct, used a little more than half the time) and 2 hard 5x5's (all correct).
Feb 06, 2022 Going to finish the early-Jan weekly challenge I missed.
Feb 05, 2022 Awesome day KENKEN-wise, got full on the weekly challenge with 13 minutes to spare and finished two hard 5x5s.
Feb 04, 2022 Very similar to yesterday, finished the weekly challenge (5 out of 6 with exactly 15 minutes left) and the daily puzzles (got the hard 5x5 wrong).
Feb 03, 2022 Finished the weekly challenge (it was alright, 5 out of 6 with about 17 minutes left) and the daily puzzles.
Feb 02, 2022 Not bad, finished both my daily puzzles (though I took a long time).
Feb 01, 2022 Awesome progress! I got done with my two daily puzzles (all correct) and finished with weekly challenge 2 (which I completed in about half the time with all correct!)
Jan 31, 2022 I still got it! A medium-level 4x4 takes me less than a minute, though 5x5's I still have to work on.
Jan 30, 2022 Registered for this year's edition after taking a break in 2021, I'll be getting 2 4x4's and 4 5x5's. Let's see how this project will go!

Duolingo

Oct 28, 2021-Oct 04, 2022
I learnt a bit of Hindi and French with Duolingo and earned a Level 5 Trophy for Hindi.

Duolingo's start date is the date I started logging, not the date when the project started.

Log

Oct 04, 2022 After more than a year (402 days) and reaching legendary in all but ~3 Hindi skills, I'm happy to call this project done :)
Oct 03, 2022 Hit a 401-day streak.
Oct 02, 2022 Hit a 400-day streak and reached legendary for Activity in Hindi. I'll (try to) finish this project tomorrow.
Oct 01, 2022 Hit a 399-day streak. Will finish this project this month.
Sep 30, 2022 Hit a 398-day streak.
Sep 29, 2022 Hit a 397-day streak.
Sep 28, 2022 Hit a 396-day streak.
Sep 27, 2022 Hit a 395-day streak.
Sep 26, 2022 Hit a 394-day streak.
Sep 25, 2022 Hit a 393-day streak and reached legendary for "Home" in Hindi.
Sep 24, 2022 Hit a 392-day streak.
Sep 23, 2022 Hit a 391-day streak.
Sep 22, 2022 Hit a 390-day streak.
Sep 21, 2022 Hit a 389-day streak.
Sep 20, 2022 Hit a 388-day streak.
Sep 19, 2022 Hit a 387-day streak.
Sep 18, 2022 Hit a 386-day streak.
Sep 17, 2022 Hit a 385-day streak and reached legendary in Adjectives in Hindi.
Sep 16, 2022 Hit a 384-day streak.
Sep 15, 2022 Hit a 383-day streak.
Sep 14, 2022 Hit a 382-day streak.
Sep 13, 2022 Hit a 381-day streak.
Sep 12, 2022 Hit a 380-day streak.
Sep 11, 2022 Hit a 379-day streak.
Sep 10, 2022 Hit a 378-day streak.
Sep 09, 2022 Hit a 377-day streak.
Sep 08, 2022 Hit a 376-day streak.
Sep 07, 2022 Hit a 375-day streak.
Sep 06, 2022 Hit a 374-day streak.
Sep 05, 2022 Hit a 373-day streak.
Sep 04, 2022 Hit a 372-day streak.
Sep 03, 2022 Hit a 371-day streak.
Sep 02, 2022 Hit a 370-day streak.
Sep 01, 2022 Hit a 369-day streak.
Aug 31, 2022 Hit a 368-day streak.
Aug 30, 2022 Hit a 367-day streak.
Aug 29, 2022 Hit a 366-day streak.
Aug 28, 2022 Hit a 365-day streak!
Aug 27, 2022 Hit a 364-day streak.
Aug 26, 2022 Hit a 363-day streak.
Aug 25, 2022 Hit a 362-day streak.
Aug 24, 2022 Hit a 361-day streak.
Aug 23, 2022 Hit a 360-day streak. 5 more days.
Aug 22, 2022 Hit a 359-day streak.
Aug 21, 2022 Hit a 358-day streak.
Aug 20, 2022 Hit a 357-day streak.
Aug 19, 2022 Hit a 356-day streak.
Aug 18, 2022 Hit a 355-day streak. 10 more days.
Aug 17, 2022 Hit a 354-day streak.
Aug 16, 2022 Hit a 353-day streak. I didn't reach legendary in every skill but that's alright.
Aug 15, 2022 Hit a 352-day streak.
Aug 14, 2022 Hit a 351-day streak.
Aug 13, 2022 Hit a 350-day streak. I'll try to get to legendary in all the non-legendary Hindi skills in the next two days.
Aug 12, 2022 Hit a 349-day streak.
Aug 11, 2022 Hit a 348-day streak.
Aug 10, 2022 Hit a 347-day streak.
Aug 09, 2022 Hit a 346-day streak.
Aug 08, 2022 Hit a 345-day streak. 20 more days.
Aug 07, 2022 Hit a 344-day streak.
Aug 06, 2022 Hit a 343-day streak.
Aug 05, 2022 Hit a 342-day streak.
Aug 04, 2022 Hit a 341-day streak.
Aug 03, 2022 Hit a 340-day streak.
Aug 02, 2022 Hit a 339-day streak.
Aug 01, 2022 Hit a 338-day streak.
Jul 31, 2022 Hit a 337-day streak.
Jul 30, 2022 Hit a 336-day streak.
Jul 29, 2022 Hit a 335-day streak. 30 more days.
Jul 28, 2022 Hit a 334-day streak.
Jul 27, 2022 Hit a 333-day streak.
Jul 26, 2022 Hit a 332-day streak.
Jul 25, 2022 Hit a 331-day streak and got legendary on Work in Hindi!
Jul 24, 2022 Hit a 330-day streak. 35 more days.
Jul 23, 2022 Hit a 329-day streak.
Jul 22, 2022 Hit a 328-day streak.
Jul 21, 2022 Hit a 327-day streak.
Jul 20, 2022 Hit a 326-day streak.
Jul 19, 2022 Hit a 325-day streak.
Jul 18, 2022 Hit a 324-day streak.
Jul 17, 2022 Hit a 323-day streak.
Jul 16, 2022 Hit a 322-day streak.
Jul 15, 2022 Hit a 321-day streak.
Jul 14, 2022 Hit a 320-day streak.
Jul 13, 2022 Hit a 319-day streak.
Jul 12, 2022 Hit a 318-day streak.
Jul 11, 2022 Hit a 317-day streak (and actually hit my daily goal this time).
Jul 10, 2022 Hit a 316-day streak.
Jul 09, 2022 Hit a 315-day streak. 50 more days.
Jul 08, 2022 Hit a 314-day streak.
Jul 07, 2022 Hit a 313-day streak.
Jul 06, 2022 Hit a 312-day streak.
Jul 05, 2022 Hit a 311-day streak and reached legendary in Family.
Jul 04, 2022 Hit a 310-day streak.
Jul 03, 2022 Hit a 309-day streak.
Jul 02, 2022 Hit a 308-day streak.
Jul 01, 2022 Hit a 307-day streak.
Jun 30, 2022 Hit a 306-day streak.
Jun 29, 2022 Hit a 305-day streak.
Jun 28, 2022 Hit a 304-day streak.
Jun 27, 2022 Hit a 303-day streak.
Jun 26, 2022 Hit a 302-day streak.
Jun 25, 2022 Hit a 301-day streak.
Jun 24, 2022 Hit a 300-day streak. ~2 more months to go!
Jun 23, 2022 Hit a 299-day streak.
Jun 22, 2022 Hit a 298-day streak. 13 more skills left for legendary in Hindi.
Jun 21, 2022 Hit a 297-day streak.
Jun 20, 2022 Hit a 296-day streak.
Jun 19, 2022 Hit a 295-day streak.
Jun 18, 2022 Hit a 294-day streak.
Jun 17, 2022 Hit a 293-day streak.
Jun 16, 2022 Hit a 292-day streak.
Jun 15, 2022 Hit a 291-day streak.
Jun 14, 2022 Hit a 290-day streak.
Jun 13, 2022 Hit a 289-day streak.
Jun 12, 2022 Hit a 288-day streak.
Jun 11, 2022 Hit a 287-day streak.
Jun 10, 2022 Hit a 286-day streak.
Jun 09, 2022 Hit a 285-day streak.
Jun 08, 2022 Hit a 284-day streak and reached legendary in Food in Hindi!
Jun 07, 2022 Hit a 283-day streak.
Jun 06, 2022 Hit a 282-day streak.
Jun 05, 2022 Hit a 281-day streak. Incroyable!
Jun 04, 2022 Hit a 280-day streak.
Jun 03, 2022 Hit a 279-day streak. Why bother with inversion when Est-ce que/qu' seems to work everywhere in French when asking a question? Inversion to me is comparatively much harder.
Jun 02, 2022 Hit a 278-day streak.
Jun 01, 2022 Hit a 277-day streak.
May 31, 2022 Hit a 276-day streak.
May 30, 2022 Hit a 275-day streak.
May 29, 2022 Hit a 274-day streak and reached legendary on Nature in Hindi!
May 28, 2022 Hit a 273-day streak.
May 27, 2022 Hit a 272-day streak.
May 26, 2022 Hit a 271-day streak. Seven euros for a cappuccino?!
May 25, 2022 Hit a 270-day streak.
May 24, 2022 Hit a 269-day streak.
May 23, 2022 Hit a 268-day streak.
May 22, 2022 Hit a 267-day streak.
May 21, 2022 Hit a 266-day streak.
May 20, 2022 Hit a 265-day streak and unlocked the next set of stories!
May 19, 2022 Hit a 264-day streak. Why do we have grammatical gender?
May 18, 2022 Hit a 263-day streak.
May 17, 2022 Hit a 262-day streak.
May 16, 2022 Hit a 261-day streak and got to legendary for Food 2 in Hindi!
May 15, 2022 Hit a 260-day streak.
May 14, 2022 Hit a 259-day streak.
May 13, 2022 Hit a 258-day streak.
May 12, 2022 Hit a 257-day streak.
May 11, 2022 Hit a 256-day streak.
May 10, 2022 Hit a 255-day streak.
May 09, 2022 Hit a 254-day streak.
May 08, 2022 Hit a 253-day streak.
May 07, 2022 Hit a 252-day streak and got to legendary for Day/Month in Hindi!
May 06, 2022 Hit a 251-day streak.
May 05, 2022 Hit a 250-day streak! Back to some legendary progress for Hindi.
May 04, 2022 Hit a 249-day streak. One more day!
May 03, 2022 Hit a 248-day streak. Two more days!
May 02, 2022 Hit a 247-day streak. Three more days!
May 01, 2022 Hit a 246-day streak. Four more days!
Apr 30, 2022 Hit a 245-day streak. I feel like my reading/listening in French has improved quite a bit with the stories.
Apr 29, 2022 Hit a 244-day streak.
Apr 28, 2022 Hit a 243-day streak.
Apr 27, 2022 Hit a 242-day streak.
Apr 26, 2022 Hit a 241-day streak and wasted a legendary attempt :(
Apr 25, 2022 Hit a 240-day streak and got to legendary for Numbers (Hindi).
Apr 24, 2022 Hit a 239-day streak.
Apr 23, 2022 Hit a 238-day streak.
Apr 22, 2022 Hit a 237-day streak.
Apr 21, 2022 Hit a 236-day streak.
Apr 20, 2022 Hit a 235-day streak.
Apr 19, 2022 Hit a 234-day streak.
Apr 18, 2022 Hit a 233-day streak and tested out of a bunch of skills lol.
Apr 17, 2022 Hit a 232-day streak.
Apr 16, 2022 Hit a 231-day streak and practiced speaking French with my Focusmate!
Apr 15, 2022 Hit a 230-day streak.
Apr 14, 2022 Hit a 229-day streak.
Apr 13, 2022 Hit a 228-day streak.
Apr 12, 2022 Hit a 227-day streak.
Apr 11, 2022 Hit a 226-day streak.
Apr 10, 2022 Hit a 225-day streak.
Apr 09, 2022 Hit a 224-day streak.
Apr 08, 2022 Hit a 223-day streak.
Apr 07, 2022 Hit a 222-day streak.
Apr 06, 2022 Hit a 221-day streak.
Apr 05, 2022 Hit a 220-day streak.
Apr 04, 2022 Hit a 219-day streak. I'm ~91% done with the 20000 XP achievement!
Apr 03, 2022 Hit a 218-day streak.
Apr 02, 2022 Hit a 217-day streak.
Apr 01, 2022 Hit a 216-day streak.
Mar 31, 2022 Hit a 215-day streak.
Mar 30, 2022 Hit a 214-day streak.
Mar 29, 2022 Hit a 213-day streak.
Mar 28, 2022 Hit a 212-day streak.
Mar 27, 2022 Hit a 211-day streak. Lundi, mardi, mercredi, jeudi, vendredi, samedi and dimanche!
Mar 26, 2022 Hit a 210-day streak.
Mar 25, 2022 Hit a 209-day streak.
Mar 24, 2022 Hit a 208-day streak, I wonder when I'll get the legendary trophy for Hindi.
Mar 23, 2022 Hit a 207-day streak.
Mar 22, 2022 Hit a 206-day streak.
Mar 21, 2022 Hit a 205-day streak.
Mar 20, 2022 Hit a 204-day streak.
Mar 19, 2022 Hit a 203-day streak.
Mar 18, 2022 Hit a 202-day streak.
Mar 17, 2022 Hit a 201-day streak.
Mar 16, 2022 Hit a 200-day streak! I got 3 days of Duolingo Plus for free, so the speedrun for the legendary Hindi trophy is back on.
Mar 15, 2022 Hit a 199-day streak, 1 more day!
Mar 14, 2022 Hit a 198-day streak, 2 more days!
Mar 13, 2022 Hit a 197-day streak, 3 more days!
Mar 12, 2022 Hit a 196-day streak, 4 more days!
Mar 11, 2022 Hit a 195-day streak, 5 more days!
Mar 10, 2022 Hit a 194-day streak, 6 more days!
Mar 09, 2022 Hit a 193-day streak, 7 more days!
Mar 08, 2022 Hit a 192-day streak, 8 more days!
Mar 07, 2022 Hit a 191-day streak.
Mar 06, 2022 Hit a 190-day streak. Need to test out of a few skills now that I have 25 lingots.
Mar 05, 2022 Hit a 189-day streak.
Mar 04, 2022 Hit a 188-day streak.
Mar 03, 2022 Hit a 187-day streak.
Mar 02, 2022 Hit a 186-day streak.
Mar 01, 2022 Hit a 185-day streak.
Feb 28, 2022 Hit a 184-day streak. I've been neglecting to practice Hindi and so I switched over and saw that I only had 2 skills that had to be restored. I guess they want me to stick with French?
Feb 27, 2022 Hit a 183-day streak.
Feb 26, 2022 Hit a 182-day streak.
Feb 25, 2022 Hit a 181-day streak.
Feb 24, 2022 Hit a 180-day streak!
Feb 23, 2022 Hit a 179-day streak and tested out of a ton of skills in French.
Feb 22, 2022 Hit a 178-day streak. The stories in French are really funny, wish they had some for Hindi too.
Feb 21, 2022 Hit a 177-day streak.
Feb 20, 2022 Hit a 176-day streak. Wondering if I'll get some days of Duolingo Plus for free when I hit 200.
Feb 19, 2022 Hit a 175-day streak.
Feb 18, 2022 Hit a 174-day streak.
Feb 17, 2022 Hit a 173-day streak.
Feb 16, 2022 Hit a 172-day streak.
Feb 15, 2022 Hit a 171-day streak.
Feb 14, 2022 Hit a 170-day streak.
Feb 13, 2022 Hit a 169-day streak.
Feb 12, 2022 Hit a 168-day streak.
Feb 11, 2022 Hit a 167-day streak.
Feb 10, 2022 Hit a 166-day streak.
Feb 09, 2022 Hit a 165-day streak.
Feb 08, 2022 Hit a 164-day streak.
Feb 07, 2022 Hit a 163-day streak.
Feb 06, 2022 Hit a 162-day streak.
Feb 05, 2022 Hit a 161-day streak.
Feb 04, 2022 Hit a 160-day streak!
Feb 03, 2022 Hit a 159-day streak.
Feb 02, 2022 Hit a 158-day streak.
Feb 01, 2022 Hit a 157-day streak.
Jan 31, 2022 Hit a 156-day streak.
Jan 30, 2022 Hit a 155-day streak.
Jan 29, 2022 Hit a 154-day streak.
Jan 28, 2022 Hit a 153-day streak, couldn't get all the skills in the first section to legendary and my free three days ends today, but I've made a ton of progress so I'm happy.
Jan 27, 2022 Hit a 152-day streak.
Jan 26, 2022 Hit a 151-day streak and continued with my legendary speedrun in Hindi. I only have a few more skills to reach in the first section.
Jan 25, 2022 Hit a 150-day streak and got 3 days free of Duolingo Plus! I've already started getting legendary on all of my Hindi skills since now I don't have to wait to get 10 virtual currencies.
Jan 24, 2022 Hit a 149-day streak, एक और दिन!
Jan 23, 2022 Hit a 148-day streak.
Jan 22, 2022 Hit a 147-day streak, 3 more days!
Jan 21, 2022 Hit a 146-day streak.
Jan 20, 2022 Hit a 145-day streak, 5 more days!
Jan 19, 2022 Hit a 144-day streak.
Jan 18, 2022 Hit a 143-day streak.
Jan 17, 2022 Hit a 142-day streak.
Jan 16, 2022 Hit a 141-day streak.
Jan 15, 2022 Hit a 140-day streak and earned legendary in Health (Hindi)!
Jan 14, 2022 Hit a 139-day streak.
Jan 13, 2022 Hit a 138-day streak.
Jan 12, 2022 Hit a 137-day streak, I'm about 8 days away from reaching the 12,500 XP achievement!
Jan 11, 2022 Hit a 136-day streak.
Jan 10, 2022 Hit a 135-day streak, 15 more days till 150!
Jan 09, 2022 Hit a 134-day streak and tested out of Level 3 in People (French).
Jan 08, 2022 Hit a 133-day streak.
Jan 07, 2022 Hit a 132-day streak.
Jan 06, 2022 Hit a 131-day streak and (finally) tested out Travel (French)
Jan 05, 2022 Hit a 130-day streak and failed to skip Level 5 in Travel (French) again.
Jan 04, 2022 Hit a 129-day streak.
Jan 03, 2022 Hit a 128-day streak, some how managed to fail skipping Level 5 in Travel (French).
Jan 02, 2022 Hit a 127-day streak.
Jan 01, 2022 Hit a 126-day streak.
Dec 31, 2021 LET'S GO I finally continued my legendary progress in Health in Hindi (I was so close to failing also, I had one mistake left lol) and I reached the 125-day streak achievement!

Hope to see me pick up more French skills (considering 2022 will be the last year of French in my curriculum) and continue my progress in Hindi in 2022!
Dec 30, 2021 Hit a 124-day streak, एक और दिन!
Dec 29, 2021 Hit a 123-day streak.
Dec 28, 2021 Hit a 122-day streak. 3 more days!
Dec 27, 2021 Hit a 121-day streak, 125 coming soon. I failed to get legendary in Health in Hindi again, twice in a row. Why does this keep happening? Health was one of the easier skills in the Hindi course...
Dec 26, 2021 Hit a 120-day streak!
Dec 25, 2021 Hit a 119-day streak and failed (again) to get legendary on Health in Hindi.
Dec 24, 2021 Hit a 118-day streak, 120 coming soon! I found this funny forum post.
Dec 23, 2021 Hit a 117-day streak, it'll take forever to earn enough currency to get legendary on all skills in Hindi.
Dec 22, 2021 Hit a 116-day streak.
Dec 21, 2021 Hit a 115-day streak, here's me hoping for more Hindi content soon.
Dec 20, 2021 Hit a 114-day streak.
Dec 19, 2021 Hit a 113-day streak, try typing a large number into Google Translate, translate it into Hindi and hit listen.
Dec 18, 2021 Hit a 112-day streak.
Dec 17, 2021 Hit a 111-day streak.
Dec 16, 2021 Hit a 110-day streak.
Dec 15, 2021 Hit a 109-day streak.
Dec 14, 2021 Hit a 108-day streak.
Dec 13, 2021 Hit a 107-day streak.
Dec 12, 2021 Hit a 106-day streak.
Dec 11, 2021 Hit a 105-day streak.
Dec 10, 2021 Hit a 104-day streak.
Dec 09, 2021 Hit a 103-day streak.
Dec 08, 2021 Hit a 102-day streak.
Dec 07, 2021 Took the French placement test and only unclocked 5% of the French course.
Dec 06, 2021 100 DAY STREAK and reached the Level 5 Trophy! I also added French as a course since I already know a good chunk of French.
Dec 05, 2021 Hit a 99-day streak and tested out of Modals, only one more test to go before I reach a Level 5 Trophy in Hindi and one more day till a 100 streak!
Dec 04, 2021 Hit a 98-day streak, two more days!
Dec 03, 2021 Hit a 97-day streak, three more days to go!
Dec 02, 2021 Hit a 96-day streak, was really close to testing out of Modals, but alas.
Dec 01, 2021 Hit a 95-day streak, still can't test out of Modals.
Nov 30, 2021 One month of consistent Hindi practice!
Nov 29, 2021 Hit a 93-day streak, if all goes well, I will be finishing the Hindi course day after tomorrow!
Nov 28, 2021 Hit a 92-day streak.
Nov 27, 2021 Hit a 91-day streak and tested out of Past 2, only Modals is left!
Nov 26, 2021 Hit a 90-day streak, 10 more days to go!
Nov 25, 2021 Hit an 89-day streak.
Nov 24, 2021 Hit an 88-day streak.
Nov 23, 2021 Hit an 87-day streak.
Nov 22, 2021 Hit an 86-day streak.
Nov 21, 2021 Hit an 85-day streak.
Nov 20, 2021 Hit an 84-day streak.
Nov 19, 2021 Hit an 83-day streak and tested out of Past, only two more skills to go!
Nov 18, 2021 Hit an 82-day streak.
Nov 17, 2021 Hit an 81-day streak and tested out of Convo! Wondering how to progress after completing the course.
Nov 16, 2021 Hit an 80-day streak and finally tested out of Future!
Nov 15, 2021 Hit a 79-day streak, I can feel the coveted 100 coming soon!
Nov 14, 2021 Hit a 78-day streak and failed to test out of Convo.
Nov 13, 2021 Hit a 77-day streak.
Nov 12, 2021 Hit a 76-day streak and someone helped me on the forum!
Nov 11, 2021 Hit a 75-day streak and asked for help with future tense in Hindi on the forum.
Nov 10, 2021 Hit a 74-day streak. I hate the future tense in Hindi.
Nov 09, 2021 Hit a 73-day streak.
Nov 08, 2021 Hit a 72-day streak.
Nov 07, 2021 Hit a 71-day streak, can someone please explain to me future tense in Hindi?
Nov 06, 2021 Hit a 70-day streak!
Nov 05, 2021 Hit a 69-day streak. I also learnt that if you wanted to say "I have to eat food" in Hindi, you have to repeat "खाना" twice. ("मुझे खाना खाना है")
Nov 04, 2021 Hit a 68-day streak.
Nov 03, 2021 Hit a 67-day streak and tested out of Day/Month.
Nov 02, 2021 Hit a 66-day streak!
Nov 01, 2021 Hit a 65-day streak and tested out of Day/Month.
Oct 31, 2021 Hit a 64-day streak, why did this session take so long?
Oct 30, 2021 Hit a 63-day streak (I messed up the counting) and tested out of Time! (the most annoying one)
Oct 29, 2021 Hit a 61-day streak (and was so close to messing up testing out of Level 3 Time!)
Oct 28, 2021 Hit a 60-day streak and tested out of Comparison!

Local AI Program

Sep 10, 2022-Oct 01, 2022
Attended a local AI program. Due to privacy reasons, I was being incredibly vague.

Log

Oct 01, 2022 Welp, the program got cancelled. I'll see if I can attend it next year.
Sep 10, 2022 Had a great first pre-requisite class! Excited to be brushing-up on some ML models next week.

Chess

Oct 28, 2021-Sep 30, 2022
Tried to get better at chess via practicing on lichess. You can see all my games that I refer to here. Previously, I practiced on chess.com.

Chess's start date is the date I started logging, not the date when the project started.

Log

Sep 30, 2022 Interesting queen sacrifice?
Sep 25, 2022 Why didn't I see the knight for move 18?
Sep 18, 2022 What a terrible middlegame lol.
Sep 16, 2022 Oops.
Sep 10, 2022 ?
Aug 22, 2022 Good game! (I mean, it was barely passable at my end, but it was fun nonetheless)
Aug 17, 2022 Hmm.
Aug 12, 2022 11 blunders!
Aug 07, 2022 This is, probably by a lot, the most surprising checkmate I've received.
Aug 05, 2022 I was this close to a checkmate and...
Jul 31, 2022 Sigh.
Jul 29, 2022 Decided to play sort of fast and loose with this game, turns out I was too fast and loose.
Jul 24, 2022 I'm very angry with myself over this game.
Jul 20, 2022 I hate unexpected checkmates.
Jul 11, 2022 Interesting game, made a lot of silly blunders.
Jul 06, 2022 An Antichess Tragedy. Will get back to regular chess tomorrow.
Jun 26, 2022 Absolutely no clue
Jun 24, 2022 Rough game. I had like ~4 takebacks over move 15 lol.
Jun 19, 2022 Short and sweet.
Jun 17, 2022 ~5 takebacks, pretty fun endgame.
Jun 12, 2022 Infinite Takebacks.
Jun 10, 2022 One pawn move ended the game for me lol.
Jun 05, 2022 Drawtastic.
Jun 03, 2022 Saddest game ever. I couldn't save myself at some point even with takebacks.
May 28, 2022 A good game to end of the week (even though I lost).
May 27, 2022 Anitchess! (with a lot of takebacks, I'll get back to non-variant chess tomorrow)
May 26, 2022 Antichess!
May 25, 2022 Sometimes even takebacks can't save you from a terrible game.
May 24, 2022 Less than 20 moves lol.
May 23, 2022 A near perfect game (but not really, also 3 takebacks)
May 22, 2022 Shockingly, only 1 blunder (though that's because it was so short lol)
May 21, 2022 Played a Chess960 game for fun.
May 20, 2022 Another Antichess game.
May 19, 2022 No clue what I was doing here.
May 18, 2022 Again, had some fun with antichess (or Antichess?) (1, 2)
May 17, 2022 Took me forever to checkmate with just a king and a queen, but I did it! (overall, with 1 takeback)
May 16, 2022 A pretty humiliating defeat.
May 15, 2022 So close, yet so far.
May 14, 2022 ??
May 13, 2022 ?
May 12, 2022 I stupidly stalemated after ~6 takebacks.
May 11, 2022 Defeated Stockfish Level 4 with intense focus... and like 3 takebacks lol.
May 10, 2022 Drew Stockfish Level 4 with (very roughly) 15 takebacks.
May 09, 2022 For some fun, I played an Antichess and a Chess960 game.
May 08, 2022 I liked this game a lot (even though I lost).
May 07, 2022 Went back to Level 3 for a game.
May 06, 2022 Oof.
May 05, 2022 I thought I played well in this game. Nope, 11 blunders (I also missed such an obvious check that could have potentially won the game).
May 04, 2022 Another win! (though I did takeback once)
May 03, 2022 I got checkmated 3 times... (1, 2, 3)
May 02, 2022 Back to being bad at chess.
May 01, 2022 What a way to start off the month: defeated Stockfish Level 4 without takebacks with the black pieces (only 1 blunder from my side!)
Apr 30, 2022 That is certainly one way to end of the month.
Apr 29, 2022 Two checkmates for the price of one: 1, 2.
Apr 28, 2022 Stalemate after some takebacks.
Apr 27, 2022 Played a blitz game against my friend.
Apr 26, 2022 One of my shortest game ever (also drew Level 4 after a couple of takebacks).
Apr 25, 2022 Sort of didn't expect that.
Apr 24, 2022 I went from 3 pawns up to checkmate in like 15 moves :(
Apr 23, 2022 Sigh.
Apr 22, 2022 Rough game.
Apr 21, 2022 I think I need to go back to Level 3.
Apr 20, 2022 Definitely doesn't count but still a fun game.
Apr 19, 2022 Only ~2 takebacks this time!
Apr 18, 2022 I won using the Tennison Gambit! (note: this doesn't count towards my battle against Stockfish Level 4 lol)
Apr 17, 2022 Sigh.
Apr 16, 2022 I think this one counts, I did takeback once but it was accidental.
Apr 15, 2022 Another game that doesn't really count because of takebacks.
Apr 14, 2022 The uphill battle against Stockfish Level 4 is going to be a long one...
Apr 13, 2022 This WOULD have been my first win against Stockfish Level 4 if I hadn't taken back so many times in the endgame (still a fun game!)
Apr 12, 2022 Nice.
Apr 11, 2022 With one take back, I got my revenge against Stockfish.
Apr 10, 2022 Sigh. (1, 2)
Apr 09, 2022 Played sort of absent-mindedly but here we are: 1, 2.
Apr 08, 2022 Sigh.
Apr 07, 2022 Ouch, I don't think there were any good moves at move 15 lol.
Apr 06, 2022 Possibly the wildest game I've ever played. I was so close to losing and then I pulled up with the promotion that made me win with the black pieces!
Apr 05, 2022 I need to practice with the black pieces against Stockfish Level 3. I'm fine with the white pieces.
Apr 04, 2022 Maybe a simple 1. e4 with good opening principles and development is all you need at this level.
Apr 03, 2022 No idea what I did today for chess today. I need to change my opening repertoire.
Apr 02, 2022 I present to you, the biggest throw ever.
Apr 01, 2022 I feel like Stockfish wanted to throw an April Fools' Day joke at me...
Mar 31, 2022 Sigh.
Mar 30, 2022 I threw this game so badly lol.
Mar 29, 2022 Man, I really lost my luck with the King's Indian Attack.
Mar 28, 2022 Not sure what I was doing today.
Mar 27, 2022 Stockfish Level 4 made me suffer in the last few moves. We quickly went from the best game yet to possibly the worst game yet lol.
Mar 26, 2022 My best game yet with the King's Indian Setup, no blunders and I never lost the advantage + didn't lose a forced checkmate sequence lol. Played a few other King's Indian Setups as well (1, 2)
Mar 24, 2022 I threw away a game so badly that I'm actually disappointed in myself. At least the King's Indian Setup has proven its worth to me with the white pieces.
Mar 23, 2022 I think this will be my opening repertoire: black pieces with e4 will be the Caro-Kann Defense and anything else (white or black pieces) will mean the King's Indian Setup (need to study this one).
Mar 22, 2022 This game definitely doesn't count (took back a lot of blunders) but it was so calming to checkmate my opponent with three queens while listening to Pentatonic.
Mar 21, 2022 Explored the Blackmar-Diemer Gambit (also this game doesn't count as a win because I used so many takebacks lol)
Mar 20, 2022 Explored Stockfish Level 4 with many takebacks.
Mar 19, 2022 Never mind. (1, 2)
Mar 18, 2022 Time to move on to Level 4?
Mar 17, 2022 I was trying out the Italian Game and I got this gem of a game, so I guess my opening with the white pieces is now the Italian Game? Need to study it for some time.
Mar 16, 2022 Had no clue what I was doing with the London System.
Mar 15, 2022 Saddest game yet?
Mar 14, 2022 My best worst game ever. I thought I was being smart with the pawn promotion sacrifice but nope.
Mar 13, 2022 Haha! Pawn to knight promotion leads to checkmate (Note: I did do a couple of take backs).
Mar 12, 2022 Yeah, that game didn't go too well... Also played a few random games against bots for fun.
Mar 11, 2022 Started learning the Giuoco Piano opening and I got pretty far with it against Stockfish Level 3.
Mar 10, 2022 Lost against my classmate after exchange variation. I thought move 22 was sort of smart but nope it was a blunder lol.
Mar 09, 2022 This is most definitely the best game I've ever played so far. Only one blunder with the Caro-Kann exchange variation and man was the endgame fun.
Mar 08, 2022 What a game.
Mar 07, 2022 Just sort of fooled around a bit. Second game wasn't too horrible (but I had no idea how to continue), 1, 2.
Mar 06, 2022 Stockfish Level 2 is too easy and level 3 is too "meh" (can sometimes win if I'm focused) and I've noticed that very low rated bots just give up their queens sometimes.
Mar 05, 2022 Resigned after losing my queen, though I performed a "push" variation of the Caro-Kann without referring back to the video!
Mar 04, 2022 Lost that game and played my most humiliating game yet.
Mar 03, 2022 Started an interesting exchange variation, I have no idea where to go from here.
Mar 02, 2022 Quick death for me after a rook blunder on my side.
Mar 01, 2022 Finished yesterday's game, did not go well.
Feb 28, 2022 Started a really interesting game after the classical variation.
Feb 27, 2022 Resigned after advanced variation.
Feb 26, 2022 Exchange variation which led to me getting checkmated.
Feb 25, 2022 This game with the Caro-Kann defense was rough.
Feb 24, 2022 First win after learning the Caro-Kann defense!
Feb 23, 2022 Lost to Stockfish Level 3 after the advanced variation.
Feb 22, 2022 Continued learning the advanced variation.
Feb 21, 2022 Continued learning the advanced variation.
Feb 20, 2022 Got checkmated after Caro-Kann defense.
Feb 19, 2022 This one is just funny, got checkmated in 20 moves lol.
Feb 18, 2022 Learnt some lines against the Fanatasy Caro-Kann variation.
Feb 17, 2022 Lost very badly after the white pawn pushed.
Feb 16, 2022 Lost badly after a classical variation.
Feb 15, 2022 This may be the angriest I've been with myself over a chess game. Two major blunders from a Caro-Kann opening.
Feb 14, 2022 Continued with the Caro-Kann Defense.
Feb 13, 2022 Continued with the Caro-Kann Defense.
Feb 12, 2022 Continued with the Caro-Kann Defense.
Feb 11, 2022 Continued with the Caro-Kann Defense.
Feb 10, 2022 Continued with the Caro-Kann Defense.
Feb 09, 2022 Started learning the Caro-Kann Defense via GothamChess and (sort of) played it against Stockfish Level 1.
Feb 08, 2022 For fun, I played against Stockfish Level 4 twice (1, 2). Will learn an opening tomorrow and practice it against Level 3 and 4.
Feb 07, 2022 Finished with Knight & Bishop Mate, which means I've finished the whole practice section!
Feb 06, 2022 Finished with 7th Rank Rook Pawn (Passive)!
Feb 05, 2022 Started with 7th Rank Rook Pawn (Passive).
Feb 04, 2022 Finished with 7th Rank Rook Pawn!
Feb 03, 2022 Continued with 7th Rank Rook Pawn. Will be done with this tomorrow!
Feb 02, 2022 Continued with 7th Rank Rook Pawn. Nearly done.
Feb 01, 2022 Continued with 7th Rank Rook Pawn.
Jan 31, 2022 Continued with 7th Rank Rook Pawn.
Jan 30, 2022 Started with 7th-Rank Rook Pawn, this section is quite long!
Jan 29, 2022 Finished Opposition, really cool practice section!
Jan 28, 2022 Finished the Direct Opposition part of Opposition.
Jan 27, 2022 Finished with Key Squares.
Jan 26, 2022 Started with Key Squares.
Jan 25, 2022 Continued with my Knight and Bishop Mate lesson.
Jan 24, 2022 Finished with Desperado.
Jan 23, 2022 Finished with Deflection.
Jan 22, 2022 Finished with Attraction
Jan 21, 2022 Finished with Counter Check.
Jan 20, 2022 Finished with Undermining.
Jan 19, 2022 Finished with X-Ray.
Jan 18, 2022 Finished with Interference, really interesting!
Jan 17, 2022 Finished with Zugzwang (my new favourite word) and Underpromotion
Jan 16, 2022 Finished with Overloaded Pieces and got close, but ultimately still resigned to Stockfish Level 4 after a long break.
Jan 15, 2022 Finished with Double Check and Zwischenzug.
Jan 14, 2022 Finished with Discovered Attacks.
Jan 13, 2022 Started with Discovered Attacks.
Jan 12, 2022 Finished The Fork! Will start Discovered Attacks tomorrow.
Jan 11, 2022 Continued with The Fork.
Jan 10, 2022 Started with The Fork.
Jan 09, 2022 Going to actually practice chess by learning theory and finishing my practice on lichess (+ doing a puzzle every day starting from tomorrow). Finished learning about skewers.
Jan 08, 2022 Lost two games (1, 2), one against Stockfish Level 4 and against a person in rapid.
Jan 07, 2022 I HAD TWO QUEENS AND I STILL STALEMATED STOCKFISH LEVEL 4! This is why there are so few grandmasters.
Jan 06, 2022 Resigned again in my final game against my brother.
Jan 05, 2022 Resigned against my brother.
Jan 04, 2022 Checkmated Stockfish Level 3, it shocks me how well made lichess is, all for free and open-source.
Jan 03, 2022 Continued my Knight & Bishop Mate lessons.
Jan 02, 2022 Learnt about the Greek Gift and won against my brother as black via resignation.
Jan 01, 2022 Lost a couple of games, but at least I beat level 3.
Dec 31, 2021 Lost countless number of times to bots and 2 times in Blitz, hope to see some improvement in 2022 for chess.
Dec 30, 2021 Lost to my brother twice in Blitz.
Dec 29, 2021 Stockfish Level 4 got a surprise checkmate for me as a belated Christmas gift...
Dec 28, 2021 Stockfish Level 4 is still out of reach, lost three games. (1, 2, 3)
Dec 27, 2021 Won against my brother via resignation.
Dec 26, 2021 Lost (badly) to Stockfish Level 4 in three games (1, 2, 3). At least I won twice against my brother.
Dec 25, 2021 Lost (badly) to my brother in chess.
Dec 24, 2021 Resigned twice against Stockfish Level 4 (1, 2).
Dec 23, 2021 Played 4 games against Stockfish Level 3 (1, 2, 3, 4) which resulted in 2 losses (1 checkmate and 1 resignation), a stalemate (which resulted in a facepalm) and a win!
Dec 22, 2021 Played 3 games against Stockfish Level 2 (1, 2, 3), I was so close to losing in the 3rd game, then the bot makes a huge, huge blunder by not taking my queen with his bishop, which led to checkmate.
Dec 21, 2021 Played 3 games against Stockfish Level 1 (1, 2, 3) and got checkmate in the first and last game. My revenge against Level 1 is complete.
Dec 20, 2021 Stalemated Level 1 again, how does this keep happening?
Dec 19, 2021 I am so bad at chess it's funny, I played three games (1, 2, 3) with the first being a loss to Stockfish Level 3, to boost my confidence I played against Level 1 and somehow lost and stalemated respectively.
Dec 18, 2021 Played two games this time (1, 2) and the second one was very interesting.
Dec 17, 2021 Played three games against Stockfish Level 3 and lost all three.
Dec 16, 2021 Checkmated Stockfish Level 2 as black!
Dec 15, 2021 So close to checkmating Stockfish Level 2! Alas, I stalemated.
Dec 14, 2021 Started with the Knight & Bishop Mate, messed up against Stockfish Level 2 and finished The Pin.
Dec 13, 2021 Got destroyed by Stockfish Level 2 and finished Piece Checkmates II.
Dec 12, 2021 Continued with Piece Checkmates II.
Dec 11, 2021 Started with Piece Checkmates II
Dec 10, 2021 Last game against Stockfish Level 1.
Dec 09, 2021 Finished with Checkmate Patterns IV.
Dec 08, 2021 Started with Checkmate Patterns IV and had a fun game against Stockfish Level 1. Magnus might win today, but we'll see. (Edit: Draw.)
Dec 07, 2021 Finished Checkmate Patterns III. I smell a draw for today's match, both Magnus and Nepo will be well-rested. (Edit: I'm so sorry Nepo.)
Dec 06, 2021 Started with Checkmate Patterns III.
Dec 05, 2021 Continued with Checkmate Patterns II. I'm going to take a risk and say that Nepo wins today. Let's see if I'm right. (Edit: I was very wrong.)
Dec 04, 2021 Continued with Checkmate Patterns II. Magnus won the sixth game and he and Ian now have the longest game in a World Chess Championship!
Dec 03, 2021 Won against my dad with the black pieces via checkmate.
Dec 02, 2021 Started Checkmate Patterns II.
Dec 01, 2021 Completed Checkmate Patterns I. Pretty sure today's World Chess Championship match is going to be a draw. (Edit: I was right.)
Nov 30, 2021 Started with Checkmate Patterns I, what a crazy month for chess!
Nov 29, 2021 Finished Piece Checkmates I and got absolutely destroyed by Stockfish Level 2.
Nov 28, 2021 Started with Piece Checkmates I and played my first game on lichess v.s. Stockfish level 1.
Nov 27, 2021 Finished the "learning section" of the chess course!
Nov 26, 2021 Switched to lichess and started their chess course.
Nov 25, 2021 Damn, my game against Antonio today was incredible (even though I lost). I got 74 accuracy! Here's the game.
Nov 24, 2021 Completed the Value of the Pieces and had some fun learning about the Stafford Gambit
Nov 23, 2021 Antonio is really tough.
Nov 22, 2021 Antonio is tough.
Nov 21, 2021 Defeated Nelson with the black pieces! Here's the game.
Nov 20, 2021 Played 2 games with Nelson, and drew one!
Nov 19, 2021 Very close to winning against Nelson, but I eventually lost way too much material.
Nov 18, 2021 "One day Sven, one day." Well folks, that day finally came! I checkmated Sven with the black pieces!
Nov 17, 2021 Played several games online.
Nov 16, 2021 One day Sven, one day. Also played a really, really funny blitz game where my opponent only moved their king for the majority of the game.
Nov 15, 2021 Finished my weekly lesson.
Nov 14, 2021 Drew Sven due to a mouse slip. Here is the game.
Nov 13, 2021 Thinking about (seriously) playing online.
Nov 12, 2021 Had some fun with lower-rated bots.
Nov 11, 2021 Completed my weekly lesson. Moved away from Sven, and (for fun) I tried my hand at DanyaBot, I'm actually proud to say I only made 1 blunder (even though I lost).
Nov 10, 2021 I think I will put the bots on the side and try to actually study the game instead of brute-forcing it.
Nov 09, 2021 Same old, same old. I also had some fun analyzing games and learning the Caro-Kann. Later, I won against my dad with the black pieces via checkmate.
Nov 08, 2021 So close! I blundered my queen again. I'll get three crowns against Sven sooner or later.
Nov 07, 2021 I was so close but I blundered too many times.
Nov 06, 2021 1000 -> 1100 transition is tough.
Nov 05, 2021 Jumped around different bots. Need to defeat Sven with three crowns soon.
Nov 04, 2021 I played against Jimmy ~3 times, blundering my queen in the first two games, but winning in the last. Here's that last game. Later, I played two games against my dad, I think the first one was a draw? (no legal moves but not in check) and the second one was a win via resignation.
Nov 03, 2021 I finally defeated the pumpkin 3 days after Halloween. Here's the game. I also resigned against Sven again.
Nov 02, 2021 So close, but I hanged my queen accidentally.
Nov 01, 2021 I hate pumpkins. (Also, I completed a lesson on rook checkmates.)
Oct 31, 2021 Resigned against Sven for the quadrillionth time.
Oct 30, 2021 Tried to defeat the damn Pumpkin, was close but blundered the endgame.
Oct 29, 2021 Kept resigning against Sven. Later in the day, I learnt about the Scandinavian Defense and won against my dad with the white pieces via checkmate!
Oct 28, 2021 Kept resigning against Sven and finished the Assisted Checkmate lesson.

EA Bristol Website Re-design (Round 2) + Booking Project

Jul 08, 2022-Sep 03, 2022
Re-designed EA Bristol's website. The latter project mentioned (which ended on Aug 09, 2022) was entangled with the former and I will be vague when describing the latter project in the logs.

Log

Sep 03, 2022 Sent over the design file, which marks the end of this nearly two-month project!
Aug 27, 2022 Got started with a triangle for the hero section (it's a lot trickier than it sounds!)
Aug 26, 2022 Got started with the navigation bar.
Aug 23, 2022 "Got started" with programming.
Aug 22, 2022 Continued with the design, will start programming tomorrow.
Aug 21, 2022 Overhaul for one of the pages is done (?), will collect everything tomorrow for a second overall draft.
Aug 20, 2022 Sent over an overall draft and worked on slightly overhauling one of the pages.
Aug 19, 2022 Yep, it is. Finished a draft of the last (?) page.
Aug 17, 2022 I think this project is back from the dead?
Aug 09, 2022 There may be a few more developments, but I consider the booking project done! Also, the EA Bristol project has been dropped, so this project as a whole is done.
Aug 08, 2022 Nearly done with migration (and the booking project)
Aug 07, 2022 Got started with migration (nearly done?)
Aug 06, 2022 Got started with a calendar event generator.
Aug 05, 2022 Added organisation pictures for the booking project and the ability to review your booking.
Aug 04, 2022 Sent the booking project.
Aug 03, 2022 Finished with authentication.
Aug 02, 2022 Nearly done with authentication!
Aug 01, 2022 Continued with authentication, need to start from scratch with authentication from tomorrow as I'm making very little progress.
Jul 31, 2022 Continued with authentication.
Jul 30, 2022 Alright, a small hiccup but another project has been entangled with this project. All (?) gaps can be explained as me working on the latter project.

Anyways, continued with authentication.
Jul 25, 2022 Finished (?) with the hero section and finished the first draft of the about us page.
Jul 12, 2022 Toyed around with mosaics.
Jul 11, 2022 Finished with the third draft of the "hero section" and got some feedback and also got started with the about us section.
Jul 10, 2022 Finished with the second draft of the "hero section" and got feedback.
Jul 09, 2022 Finished with the first draft of the "hero section" and got feedback.
Jul 08, 2022 Got started with a component.

Maintaining the benefits of open research in AI

Aug 10, 2022-Aug 26, 2022
Tried to create a paper which presents a framework that protects the benefits of open research in AI. Inspired by Toby Shevlane and Allan Dafoe's work as well as Nick Bostrom's work.

Log

Aug 26, 2022 Continued writing the introduction.
Aug 22, 2022 Continued writing the introduction.
Aug 21, 2022 Added some citations.
Aug 20, 2022 Continued writing the introduction.
Aug 19, 2022 Continued writing the introduction, will take some more time.
Aug 18, 2022 Continued writing the introduction, nearly done (sort of).
Aug 17, 2022 Didn't do much writing but that's alright.
Aug 16, 2022 Continued writing the introduction.
Aug 15, 2022 Continued writing the introduction.
Aug 14, 2022 Continued writing the introduction.
Aug 13, 2022 Continued with reading.
Aug 12, 2022 Continued with reading.
Aug 11, 2022 Got started with some reading.
Aug 10, 2022 Got started with the paper, will have to finish some reading tomorrow before continuing with the introduction. I hope to finish writing in about 3 months (and then get some feedback).

Bear Blog Replacement Template

Aug 08, 2022
I was getting increasingly dissatisfied with Bear Blog (where this website was formerly). So I decided to migrate to Next.js and I made a template that I posted on Show HN.

Bear Blog Replacement Template's start date is the date I started logging, not the date when the project started.

Summary

Posted the template on Show HN and I think I'm quite happy with the final product!

SOLARIS

Jul 10, 2022-Aug 07, 2022
Co-founded a rationality club in my school. We've finished running the first edition of SOLARIS!

Log

Aug 07, 2022 Fifth meeting happened, which means the first edition of SOLARIS is complete! While there have been a few hiccups en route, it was generally a good time. I hope more people come for the second edition!
Aug 06, 2022 Finished the feedback form for tomorrow.
Jul 31, 2022 Fourth meeting happened with much better attendance and overall a pretty fruitful discussion! I'm happy to have had that with the most important week.
Jul 25, 2022 Third meeting happened without much fanfare. Hopefully attendance is higher next meeting.
Jul 23, 2022 Worked on next meeting's presentation.
Jul 18, 2022 Second meeting happened yesterday: Attendance improved a lot and it was a bummer that I couldn't attend fully.
Jul 12, 2022 First meeting happened day before yesterday: even though it was a fair amount of fun, I messed up the recording and we unfortunately had low attendance.

fast.ai

Mar 15, 2022-Jul 26, 2022
Trying to learn A.I. by leveraging pre-existing knowledge. This project got abandoned, don't think I'll be revisting it as I've acquired ML knowledge elsewhere.

Log

Jul 26, 2022 Well, it looks like they've released a new version of the course for this year (looks pretty awesome).
Jul 21, 2022 Continued with Lesson 8.
Jul 19, 2022 Continued with Lesson 8.
Jul 18, 2022 Continued with Lesson 8.
Jul 15, 2022 Continued with Lesson 8.
Jul 08, 2022 About half way through with Lesson 8.
Jul 06, 2022 Continued with Lesson 8.
Jul 05, 2022 Continued with Lesson 8.
Jul 04, 2022 Got started with the last lesson for the foreseeable future.
Jul 03, 2022 "Finished" with the Lesson 5 questionnaire.
Jul 02, 2022 Continued with the Lesson 5 questionnaire.
Jun 23, 2022 Got started with the Lesson 5 questionnaire.
Jun 22, 2022 Finished with the Lesson 5 video, will try to finish the questionnaire by the end of this week.
Jun 21, 2022 "Continued" with Lesson 5.
Jun 20, 2022 "Continued" with Lesson 5.
Jun 18, 2022 Continued with Lesson 5. ~15 minutes left so should finish up tomorrow.
Jun 17, 2022 Continued with Lesson 5.
Jun 16, 2022 "Continued" with Lesson 5.
Jun 15, 2022 Continued with Lesson 5.
Jun 14, 2022 Continued with Lesson 5.
Jun 12, 2022 Continued with Lesson 5.
Jun 11, 2022 Continued with Lesson 5.
Jun 10, 2022 Continued with Lesson 5.
Jun 09, 2022 Sort of got started with Lesson 5.
Jun 08, 2022 "Finished" with the Lesson 4 questionnaire, will start Lesson 5 tomorrow.
Jun 07, 2022 Continued with the Lesson 4 questionnaire.
Jun 06, 2022 Continued with the Lesson 4 questionnaire.
Jun 04, 2022 Continued with the Lesson 4 questionnaire.
Jun 03, 2022 Continued with the Lesson 4 questionnaire.
Jun 02, 2022 Continued with the Lesson 4 questionnaire.
Jun 01, 2022 Continued with the Lesson 4 questionnaire.
May 31, 2022 Got started with the Lesson 4 questionnaire.
May 28, 2022 Finished with the Lesson 4 video, will move on to the questionnaire.
May 26, 2022 Continued with Lesson 4, nearly done. The softmax function is pretty awesome.
May 25, 2022 Continued with Lesson 4.
May 24, 2022 Continued with Lesson 4 by revising the notebook.
May 23, 2022 Continued with Lesson 4.
May 19, 2022 Continued with Lesson 4 (I definitely want to make SGD from scratch after this lesson as a recap exercise).
May 18, 2022 "Continued" with Lesson 4 (just ran the cells I hadn't run during the video).
May 16, 2022 Continued with Lesson 4.
May 15, 2022 Continued with Lesson 4.
May 13, 2022 Continued with Lesson 4, I was sort of leaving the notebook aside lol so I got to that.
May 11, 2022 Continued with Lesson 4.
May 09, 2022 Got started with Lesson 4.
May 08, 2022 Finished with the Lesson 3 questionnaire!
May 05, 2022 Continued with the Lesson 3 questionnaire.
May 04, 2022 Continued with the Lesson 3 questionnaire. Broadcasting is pretty neat.
May 03, 2022 Continued with the Lesson 3 questionnaire.
May 02, 2022 Continued with the Lesson 3 questionnaire.
May 01, 2022 Continued with the Lesson 3 questionnaire.
Apr 29, 2022 Got started with the Lesson 3 questionnaire.
Apr 27, 2022 Did some Microsoft admin work related to fast.ai.
Apr 26, 2022 Finished with the Lesson 3 video, will start the questionnaire tomorrow.
Apr 23, 2022 Continued with Lesson 3.
Apr 21, 2022 Continued with Lesson 3. Didn't know that gradient descent originated with Issac Newton.
Apr 20, 2022 Continued with Lesson 3.
Apr 19, 2022 Continued with Lesson 3.
Apr 18, 2022 Continued with Lesson 3.
Apr 17, 2022 Continued with Lesson 3. I guess this page counts as blogging?
Apr 16, 2022 Continued with Lesson 3.
Apr 15, 2022 There were a few questions that I skipped (since I don't think they were discussed in Lesson 2) but other than that I've finished the questionnaire for Lesson 2! Will continue Lesson 3 tomorrow.
Apr 14, 2022 Finished the project.
Apr 13, 2022 Continued with the Lesson 2 questionnaire and I've nearly finished with the project for Lesson 2 (it's a cloud classifier!)
Apr 12, 2022 Continued with the Lesson 2 questionnaire.
Apr 11, 2022 Lesson 3 will be on hold as I completely forgot about the questionnaire for Lesson 2! Got started with that.
Apr 10, 2022 Continued with Lesson 3.
Apr 09, 2022 Continued with Lesson 3, we created a small bear classifier app within the Jupyter Notebook which was awesome. I tried putting in a polar bear (we've only trained our model on grizzly bears, black bears and teddy bears) and I got back a prediction of grizzly bear with ~82% confidence. Hm.
Apr 08, 2022 Continued with Lesson 3, the ImageClassiferCleaner GUI is awesomely cool. Jupyter Notebook is darn powerful.
Apr 07, 2022 Got started with Lesson 3.
Apr 06, 2022 Trained my model with the API key, will start Lesson 3 tomorrow.
Apr 05, 2022 Got the API key!
Apr 04, 2022 The replacement looks pretty complicated to set-up, so I might have to go through with Microsoft. Finished Lesson 2, will start Lesson 3 after the Microsoft stuff.
Apr 03, 2022 Found a replacement for the Bing Search API through the forums.
Apr 02, 2022 Continued with Lesson 2. I now need to do admin stuff for the last few sections of Lesson 2 :(
Apr 01, 2022 Continued with Lesson 2.
Mar 31, 2022 Continued with Lesson 2, I was expecting P values to be this great statistical analysis tool, but nope.
Mar 30, 2022 Continued with Lesson 2, Jeremy's example on P values was incredible.
Mar 24, 2022 Continued with Lesson 2. Transfer learning is such a neat and efficient use of compute (time and computational resources).
Mar 23, 2022 Continued with Lesson 2.
Mar 22, 2022 Got started with Lesson 2.
Mar 21, 2022 Finished with Lesson 1's questions, will start Lesson 2 tomorrow.
Mar 20, 2022 Continued with Lesson 1's questions, almost done!
Mar 19, 2022 Finished with the Lesson 1 video and got started with the questions.
Mar 18, 2022 Continued with Lesson 1.
Mar 17, 2022 Continued with Lesson 1. We had to train a classifier that classified an image as a cat or a dog. I tried putting an image of a tiger and a wolf (which are technically a cat and a dog respectively but not really) and it actually gave true and false for the question "Is this image a cat?" respectively!
Mar 16, 2022 Continued with Lesson 1 and got the fastbook setup.
Mar 15, 2022 Got started with Practical Deep Learning for Coders. Really excited!

Sudoku

Apr 28, 2022-Jul 01, 2022
Not exactly sure why, but I spent some time trying to solve at least one sudoku every Friday & Saturday. The odd notation you see encodes the puzzle, you can parse it here (note that you may need to provide ~2-3 more guesses for it to solve it).

Log

Jul 01, 2022 Aujourd'hui, j'ai joué une puzzle facile:

593.7.64..1.94.83.47...3....4....7.9835..4.6....152..41.48...2...956...8..642.5..

Jun 26, 2022 Let's forget about this one, shall we?

....1..3...4..6..18..49..2...7.49....3..........3..68...69.2.4..82.6.7......7....

Jun 24, 2022 Solved an easy one, call this preparation for day after tomorrow's medium puzzle:

.62...3.9.8.6..47.9..5.2.1...3.5.2.....72394.2.94.86.7624.7....1.8...724....94..8

Jun 18, 2022 Solved a medium sudoku without misusing the guess checker!

........2...6.4.9..5...8.4.1..4......9..7.48.2.......6..8......6.5.1.....2....6.9

Jun 17, 2022 So close it hurts (at least I'm getting better):

..12.............1.7..5.8...3..726..81..6..5...4.....2647.......8..4........37..9

Jun 12, 2022 Less close this time:

9....71.6.61.9.......5........6..53.....3.68.1..4.......3....9.2.5........8..9..7

Jun 10, 2022 I was pretty close, but nope:

.......59.3.......2.6..5.4..8..2........9...75.7.....6..1..37...4.6.......8.791.5

Jun 05, 2022 Nope x2:

3.92.6..82.657.3.....8..246..1.6.48.96..81.2..73...96.695.....24...39..5.3...56..

Jun 03, 2022 Nope:

...1523..3..........4....89..5..7.916.78....3.1........6..4.91...3...6247........

May 28, 2022 See you next Friday I guess:

..1......53..7.6....79..43.2..7........8...9...4.6......9....187....3..6..8...2.7

May 27, 2022 Easy puzzle this time around:

..3514.8.162....494.8...137.3..812..2864.......49.28.....12.97.891.....5...35...8

May 26, 2022 Sigh:

...2..8.........64.6.1.........19.5.9.........52.8..31.8...6..9.1....57.42.......

May 25, 2022 So close it's frustrating:

1....5..9..9..8...35.16............1..3...72.6.529.3.......7..6.......8....4..13.

May 24, 2022 Didn't have much time today so I had to give up less than 10 minutes in, though I feel like I am improving:

.56.3...73....21.......8.56..18........4..52.83..69........5.9..9....6..2.3......

May 23, 2022 Nope:

......2.464.....5325.13.6..81.7.....9.64....1......9.....39...5....82..........9.

May 22, 2022 Sigh, I was so close to solving this without giving up and misusing the guess checker:

1..........2.693....7..3....21.....8....52.4....3..25......18..7.......6.64.....1

May 21, 2022 Another easy puzzle:

..63.2.8..41.5.2362..18...4795.1.....8.69.1..1.....495...4.3529..7..1..34539.....

May 20, 2022 I was short on time today so I went back to an easy puzzle:

3.1.6.7..827.3..1...6.21..4.3.6.4.292..39.16.76..1....6.2...9...9.2.6....1894..36

May 19, 2022 Back to square-1 I guess:

.....4..61.62....3..86...7.7.9.43.......7.1.........2.5.7.....42.....86..8..9....

May 18, 2022 Took me 27 minutes, but I solved a medium sudoku without misusing the guess checker!:

...9..87....67.....6...45....61..2....4..2....27...4......16..8.....97.153.......

May 17, 2022 Sigh:

2..4....94.7.......6..8....7...9.165.....12....23...9...97.28.3...9....13.4......

May 16, 2022 I was so close to not giving up, but alas:

65.........7.1.3......7...1.1....8..5..6.24..9.6..4.3.....9..6.8......5...3..7...

May 15, 2022 Medium puzzle progress has been slow:

8........2..63.......1..29.6....8.31.....7..2..2...9681..8....9.7...9.........34.

May 14, 2022 Again, went back to an easy puzzle:

.6472.8..2.1....5.3..691..4.2..897...8.4.7362547..3...8..5...37..534...6....7..21

May 13, 2022 I basically gave up mid-way with today's medium puzzle:

8.3...2..9.....3.6...9...7.......145.7....8.....8.6..94...1....51.2.8.....6..9...

May 12, 2022 Went back to an easy puzzle:

..81..6.5.3..8421.91.2..4...54..6.28129...54....542.....2...167..1.29.5.58.47....

May 11, 2022 Took advantage of the guess checker again:

.......7..6.1....4..8..5.9....6..23.584.......2.....1.49..1....3...74.......3...6

May 10, 2022 Solved my first medium puzzle!

(Though I did take advantage of the guess checker, going to turn that off tomorrow):

.........43.....7......1.4694..7.6.5..3...7..56..4..3..2.19.......7..3...9..24...

May 09, 2022 Medium puzzles still feel impossible:

9...4...3.........5.4.1......5.7...8...1...6.8.29...4.4.9.5.7........28....697...

May 08, 2022 Went back to easy for a day:

2476..1......87.236..1.5..9.54.3.281.3..5.49.19...2...4.5.69....215.8.....8...375

May 07, 2022 Pretty sure I made more guesses, progress!

.8.3....99.3...5...6...2.1.1..4...5....9.....6.......84.......1..6.87..2......9..

May 06, 2022 I might have gotten a few more guesses, not really sure:

..6....123.8.5.......7.4...5..62.........7...41..8.....9.5...878....2.........6.9

May 05, 2022 Tried my luck with a medium puzzle, to no avail:

78........2.....7....3...9815.64........2...5..3.7...62.6..438......1.5.......4..

May 04, 2022 Approaching 4 minutes!:

2..36........4.718984..5..2...71938.597..41..8.3....79.28..15.3.456.....6..5.72..

May 03, 2022 Just shy of 6 minutes:

2164....7..36..1.54..7312.....564.2.8.2....51695....7.56..984.....1.67...2...759.

May 02, 2022 Finished in 5 minutes!

Medium sudokus still look daunting:

91..23..8.6..1..93348...61.29.3.1.4.48..92.6...74..2..831.....6...5..7.1..9.683..

May 01, 2022 I took one look at the medium sudoku and went straight back to the easy tab lol:

...18.576521..48..8.73..1.4.38.7..42..2.9...1.5.4.3..89....861.2....54..4..63...9

Apr 30, 2022 Finished today's easy Sudoku by NYTimes:

5..167.4..4....851231..4...69851.3..4..98.1..1...4.6.9.25..1..7.643....2...4..96.

Apr 29, 2022 Even tougher than yesterday's, could only get 1 cell filled in (the rest were notes):

.8..34.....58...7.6..57..2...4....68..6...2..39....1...3..97..2.7...56.....32..8.

Also solved this easy one in ~8 minutes by the New York Times:

.4..72.1...7.1.64.192..4.8..1.5874...5.1...97..6..98.18.1.4..293.42.1....2.3....4

Apr 28, 2022 Tough one, couldn't solve it:


.8574.91.7....5...........5..6..7.5..9.1.2.8..2....7..1...........4....8.59.7146.

gallpeters

Apr 07, 2022-May 17, 2022
Created a simple website/API to create a customizable world map.

Log

May 17, 2022 Added width and height URL queries, used gallpeters for this very website, updated the repository, opened up a Show HN post and this project is done!

May 16, 2022 <iframe>'s now work!
May 15, 2022 Nearly done with the headers, just need to get <iframe>'s to work.
May 14, 2022 Security headers are the necessary evil in programming.
May 13, 2022 Alright, it's deployed! (but I need to add security headers)
May 12, 2022 Deploying a Node.js website is laughably hard. I got it deployed on Vercel but none of the assets went through (so it's basically useless). Will keep trying tomorrow.
May 11, 2022 Finished with the API reference, going to deploy it tomorrow.
May 10, 2022 Got started with API reference.
May 09, 2022 Alright, I'm pretty sure no major glitch remains. I'll be adding the API reference and putting this on Show HN tomorrow.
May 08, 2022 For some odd reason, most of the customization logic from yesterday stopped working. Anyways, got it all back and HEX color support isn't glitchy anymore. This project is nearing its end!
May 07, 2022 Got all of the customization options to work as URL queries!
May 06, 2022 Not bad, got one of the customizations to work (the background color). Not fully sure why the others aren't working but I'll look in to that. You can now also enter a country name without following title case + with spaces + with 'of' or 'the'.
May 05, 2022 Awesome progress, you can now select any amount of countries with either the three-letter name or the full name with the API. I now need to implement the customization logic with URL queries, should be fun...
May 04, 2022 I can now create any one of the three projection types with /api/map_name (e.g.: /api/gallpeters)!
May 03, 2022 Got started with the API.
May 02, 2022 Committed the customization changes with two reset buttons!
May 01, 2022 Continued with the color conversion logic and "fixed" the hex to RGB function (just had to change the return).
Apr 30, 2022 Continued with the color conversion logic.
Apr 29, 2022 Continued with the customization logic, it's coming out pretty nicely, just need to convert the different ways to represent color to RGB.
Apr 28, 2022 Continued with the customization logic, I can now sort of customise the background color and the stroke with the front-end.
Apr 26, 2022 Got started with the customization logic.
Apr 24, 2022 Sort of finished with the saving logic (though I need to add customization properties) thanks to this Stack Overflow page.
Apr 23, 2022 Got started with the "saving" logic.
Apr 22, 2022 Made great progress: created the "click" logic and fixed the viewport and some outdated country names in the JSON file.
Apr 21, 2022 Haha I figured it out! You have to use the d in the mouseover function to get the data of each indivudual path, like so:

    tooltip.html(d.toElement.__data__.properties.name);

Apr 19, 2022 One of the more frustrating things in this world is working with nested data. All of the country names (for the tooltips) are nested and I can't access them without an additional CSV file with the names that has the same IDs as the JSON file. Sigh.
Apr 18, 2022 The first step (selecting which map projection you want to use) is done, going to have to work on tooltips for the second step.
Apr 17, 2022 Created all the three projections, going to work on the "creating" part.
Apr 16, 2022 Made the maps look a whole lot nicer. I'm going to start out with three projections: Mercator, Gall Peters and Winkel Tripel.
Apr 15, 2022 Fixed the "... isn't a function" error, I had to update the version of d3-geo-projection imported. Anyways, I've got the namesake projection!
Apr 14, 2022 I was trying to get the Gall Peters projection in D3, and ended up with the Mercator projection lol, for some reason geoCylindricalEqualArea() isn't a function.
Apr 13, 2022 The start of something new:
Apr 12, 2022 I was about to give up with D3 on the server-side until I found this repository.
Apr 11, 2022 I might go back to Express.
Apr 10, 2022 Migrated to Next.js after deleting all my uncommitted code.
Apr 09, 2022 Getting D3 in to Node is a bit different. You have to use this package and some of the D3 declarations have to be replaced with the package (like in this example).
Apr 08, 2022 Used my beech.css (which powers this website!) and modified it slightly. The majority of my time on this project will be working on the D3 maps (for now).
Apr 07, 2022 New project! Let's see how long this one takes. Opened up the repository and committed a bare-bones front-end with Express.

Effective Altruism Data

Oct 28, 2021-Apr 15, 2022
I was a programmer for EA Data (official website here, up-to-date one here which may require some refreshing to work). See the repository and my fork for commits mentioned. The two EA Forum posts (1, 2) may also prove informative.

Effective Altruism Data's start date is the date I started logging, not the date when the project started.

Log

Apr 15, 2022 Unfortunately, I believe my teammate has somewhat abandoned this project, which is completely fine, this project feels somewhat complete and even if my teammate comes back to work on this project, I don't think I would be able to contribute anything meaningful anymore.

Regardless, it was a lot of fun while it lasted: learning about Dash, improving my Python skills, messing with Heroku and improving the front-end with my CSS skills were all great experiences.
Apr 04, 2022 Changed 'Lighter/Bluer' to 'Lighter' to remove any ambiguity.
Apr 02, 2022 Okay, this may be stretching my OOP skills. Regardless, I removed unused imports from the codebase.
Apr 01, 2022 I might work on getting the label position for some of the plots in line with this.
Mar 31, 2022 Changed the background color of the flashcards to a nice and soft one.
Mar 29, 2022 Got MathJax to work and created a PR for the EA-numbers repository to close an issue.
Mar 24, 2022 Fixed a small import error.
Mar 23, 2022 Fixed the sidebar glitch.
Mar 22, 2022 Made some good progress with the sidebar glitch, just need to fix another glitch that came from fixing the glitch. Welcome to programming, folks.
Mar 21, 2022 In the process of fixing a small sidebar glitch.
Mar 20, 2022 Got my fork deployed.
Mar 19, 2022 Finished with cleaning up the codebase for the most part.
Mar 18, 2022 Continued with cleaning up the codebase.
Mar 17, 2022 Removed all instances of the now redundant visdcc and got started cleaning up the codebase. effectivealtruismdata.com should have a valid HTTPS certificate now.
Mar 16, 2022 Never mind, I changed the layout to one long column and so it's automatically responsive. I'll be migrating to deferred JS instead of visdcc.
Mar 15, 2022 Finished work on the flashcards on desktop, need to make the whole thing responsive.
Mar 13, 2022 Flashcard progress has been slow, but we push on.
Mar 12, 2022 Tried to deploy a copy of the repository on Heroku, to no avail.
Mar 11, 2022 effectivealtruismdata.com is really unreliable right now (it's sometimes down and regardless the HTTPS certificate has expired) and I can't do anything tangible about it.
Mar 10, 2022 Got started with fixing the layout. This is going to take a while...
Mar 09, 2022 Fixed a small glitch with the hide/reveal feature. I have a pretty good idea for organising the card in one-line (with arrows to scroll) which I'll get started with tomorrow.
Mar 08, 2022 Using deferred JS, I made the flashcards "studyable" as you can reveal and hide the answer (+ source) and I'll be working on making the layout better.
Mar 07, 2022 Continued with the flashcards. Progress has been slow.
Mar 06, 2022 Holy crap, the package works! In the process of replacing all of the (now redundant) callbacks and I can now do some serious envisioning with the flashcards with the power of JS.
Mar 05, 2022 Tried to get MathJax with this package but to no avail. I'll keep trying (as that'll mean I can defer any JS file). I'll also be mainly fixing the layout of these flashcards for a while.
Mar 04, 2022 A bit unsatisfied with the layout of the flashcards. Anyways, committed a spelling fix for my previous X-risks relative probabilities.
Mar 03, 2022 Not a ton of progress but I've made the flexbox in to roughly 7-8 columns. Going to try to get MathJax and JS (deferred) tomorrow.
Mar 02, 2022 Good progress, the content now looks like flashcards (though they're all in one long sequence, which is not ideal, need to have arrows on the left and right side to browse through them) and I added the appropriate classes for the question, answer and source.
Mar 01, 2022 I did it! Got all the three paragraph tags packed into "card divs". I'll work on the actual styling tomorrow.
Feb 28, 2022 Made decent progress again, still trying to get the cards (in packs of three paragraph tags).
Feb 27, 2022 Decent amount of progress, I need to somehow get all the elements between two "card divisions" (just big rectangles) and then I can style them into cards with flexbox magic.
Feb 26, 2022 Got it all converted to HTML! Need to now turn it all into cards (which may take some time...)
Feb 25, 2022 Got all the text displayed, need to convert it in to regular HTML.
Feb 24, 2022 Alright, got the data and I need to figure out how to use a for loop in Dash components tomorrow. After that, all the text will be displayed and I'll need to do some CSS + JS magic to make them actual cards.
Feb 22, 2022 Figured out an alright way to display the cards (it'll be a bunch of CSS work which I guess I'm good at) and I finished creating the layout for it.
Feb 21, 2022 Realistically speaking, the only thing left on the to-do list I can do is to display the key EA numbers, so that's what I'm going to do.
Feb 18, 2022 Emailed my teammate about the X-risks section of the website.
Feb 17, 2022 No excuse for not working on this for the last 4 days, anyways I don't think I have the technical skill to fix the bar chart. I'll work on something else.
Feb 12, 2022 Continued with the bar chart.
Feb 11, 2022 Finished with the layout and figured out how the bar chart function works (sort of).
Feb 10, 2022 Got started with the layout.
Feb 09, 2022 Finished collecting the data, also it's not just the top 5 charities (that would be very little data) and I'll work on the bar chart tomorrow.
Feb 08, 2022 Started with the data collection. Got a good suggestion from my Focusmate (who's also interested EA)!
Feb 07, 2022 Alright, will work on plotting the cost-effectiveness of the top 5 most effective charities according to The Life You Can Save.
Feb 04, 2022 Got a few ideas for what to work on next, still thinking about it.
Feb 01, 2022 Committed the new icons! Wondering what to work on next.
Jan 30, 2022 Finished adding the higher quality icons from FontAwesome!
Jan 28, 2022 Honestly adding the timeline section seems pointless, not sure why it's on the to-do list. Anyways, in the process of replacing the icons in the x-risks section with higher quality ones.
Jan 26, 2022 Forget the D3 addition, that was useless. I figured out about Gantt plots and added that in. I'll work on making the data soon.
Jan 25, 2022 Didn't have too much time to work on EA Data today, but I continued trying to add D3 into Dash.
Jan 24, 2022 I think the best way to go around this is with D3, so I'm trying to get D3 into Dash.
Jan 23, 2022 I'll leave the population data to my teammate (as they'll visualize it much more interestingly), I've gotten started on something I find more interesting, the timescale from William MacAskill's talk.
Jan 22, 2022 Got to work on the dropdown menus, though I need to figure out a way to make them inline.
Jan 21, 2022 Finished the layout, need to add dropdown menus for years/decades for the quick facts which might take some time.
Jan 20, 2022 Got started with the layout!
Jan 19, 2022 Have some cool ideas on how to present these quick facts on population. Will implement them tomorrow or the day after tomorrow.
Jan 18, 2022 Finished collecting historical population data (from here) and trying to find some interesting longtermist data.
Jan 17, 2022 I sent an email to The Life You Can Save if there was an API for their calculator. I'll be working on another thing in the meanwhile and I also committed my x-risks section.
Jan 16, 2022 Alright, found another thing I can reasonably do for EA Data right now, which is the cost of saving a life with effective charities (which you can learn about here, this will also be my primary data source). I'll work on this tomorrow since I didn't have much time today.
Jan 15, 2022 Completed the table with relative probabilities and icons!
Jan 14, 2022 Fixed the styling for the most part, just need to find a way to shrink the table a bit.
Jan 13, 2022 Continued fixing the styling.
Jan 12, 2022 Finished the images and relative probabilities! Need to fix some styling and will continue with the next time on the to-do list.
Jan 11, 2022 Almost finished with the images and relative probabilities, it's somehow hard to find creative examples for 1 in 10 and 1 in 50.
Jan 10, 2022 Made great progress with the images and relative probabilities! I only have a few left.
Jan 09, 2022 Fully fixed the callback (it's a lot snappier and doesn't randomly break) with this and got done with the second probability. Did you know the chance of finding a four-leaf clover is 1 in 10,000?
Jan 08, 2022 Fixed the callback for the most part and now the associated image shows up.
Jan 07, 2022 Made the callback automatic (but it's slightly broken) and learnt what 'one in a million' really means.
Jan 06, 2022 Used visdcc to make it update differently depending on what cell you are on!
Jan 05, 2022 Created the callback.
Jan 04, 2022 It's all coming together, styled the table a bit (may need to add some more further) and started writing the callback code to display the relative probabilities and an animation (or maybe just an image).
Jan 03, 2022 Made good progress with the probabilities table (i.e. I made a CSV file of the probabilities...), I have some cool ideas with using callbacks and then displaying (for example) 1 in 6 chance as the probability of getting 1 when rolling a die (and showing a die animation), but it's a lot of work.
Jan 02, 2022 Started with showing the probabilities given by Toby Ord on X-Risks, will try my shot at putting the probabilities in a more relative scale.
Jan 01, 2022 Going to set that glitch aside and going to see if I can update some of the data on the website, mainly the EA Survey.
Dec 31, 2021 Still perplexed by that glitch, hope to do more data visualization with other organisations and to continue work on the website in 2022!
Dec 30, 2021 Continued the discussion about the scaling/overlap issue. I think it is solely a CSS issue, so I'll try my luck at fixing it again tomorrow.
Dec 29, 2021 Got a response and I gave the deployed website as a working example of the glitch.
Dec 28, 2021 Posted my issue on the Dash forum.
Dec 27, 2021 I think I'll leave the height glitch for some time, I'll make a post about it on the Dash forum tomorrow.
Dec 25, 2021 Still no luck with the height glitch, will push on.
Dec 24, 2021 Found a glitch where if you download a data source and then change the height of the browser window, the download subtitle goes crazy. In general, changing the height makes everything go crazy. Trying to fix that.
Dec 23, 2021 Fixed the meta card image. Going to work on responsiveness for a bit. After that, I'll look into completing this to-do list.
Dec 22, 2021 Took a lot of searching, but I got meta tags to work!
Dec 21, 2021 Still figuring out meta tags and cards.
Dec 20, 2021 Finished the rest of the download links, going to work on meta tags (which I left a while back) and possibly making sure the whole design is as responsive as possible.
Dec 19, 2021 Added the styling, the arbitrary values are not perfect (one of the reasons responsive design is such a pain) but the content is readable, so it's fine for now. I'll work on finishing the rest of the download links tomorrow.
Dec 18, 2021 The design is almost perfect, responsiveness wise, the only real issue is that some of the subtitles have their heights messed up on mobile. So, I made good progress on a glitch fix for that, only need to style it tomorrow.
Dec 17, 2021 Okay so I got the attribute working, but the attribute itself only works in Safari, Chrome doesn't respond to it and just opens the download in a new tab, anyways I'd consider getting the attribute a success.
Dec 16, 2021 More weird glitches (particularly on mobile), I can't seem to get a download to happen on mobile, tried to use visdcc to append an attribute but it didn't work.
Dec 15, 2021 Finished the donation download URL's and fixed a weird glitch where the subtitle would disappear if something was downloading.
Dec 14, 2021 Started work on finishing my teammate's download URL's.
Dec 13, 2021 Time to move on, finished implementing a download icon for my teammate's recent work.
Dec 12, 2021 Finished with all my figures, waiting for a review from my teammate.
Dec 11, 2021 Using Web Plot Digitizer to approximately get the data from pre-existing graphs, a really cool piece of technology!
Dec 10, 2021 Fixed some major mistakes I made and nearly finished the actual last figure.
Dec 09, 2021 Finished my last assigned figure (for the most part, might need to make a few small tweaks here and there), need to now get to the actual data part.
Dec 08, 2021 Made good progress with the next figure. I'll leave the actual data for later.
Dec 07, 2021 Figured out how to work with large scale CSV.
Dec 06, 2021 Implemented the horizontal bar chart change + some other changes. Need to figure out how to work with large scale CSV files.
Dec 05, 2021 Finished the first figure, though I might need to make them horizontal instead of vertical bar charts.
Dec 04, 2021 Nearly finished the first figure.
Dec 02, 2021 Progress, progress, progress.
Dec 01, 2021 Continued work on data visualization, need to get good at matplotlib.
Nov 30, 2021 Continued work on data visualization with matplotlib, awesome month at EA Data!
Nov 29, 2021 Did some experimenting with matplotlib.
Nov 28, 2021 Opened a PR to push smaller bug tweaks I've made over the month.
Nov 27, 2021 Doing some research into deployment.
Nov 22, 2021 Made the title more responsive.
Nov 21, 2021 Slightly changed the GWWC glitch fix.
Nov 20, 2021 Fixed a visdcc glitch!
Nov 19, 2021 Wondering what to do next.
Nov 18, 2021 Fixed the GWWC glitch! It was just 4 lines of CSS.
Nov 17, 2021 Still trying to fix the GWWC plots.
Nov 15, 2021 I've put the meta tag issue aside to work on fixing the GWWC plots.
Nov 13, 2021 The problem with the meta tags is that all the properties are in one tag. Need to fix that.
Nov 11, 2021 Figured it out.
Nov 10, 2021 Wondering if there is another way to test if my meta tags work (without hosting the app on Heroku)
Nov 09, 2021 Failed to set up Heroku (for my GitHub fork).
Nov 08, 2021 Made the loading screen more responsive and added Twitter card meta tags.
Nov 07, 2021 Sort of fixed a non-existent glitch. I'll try to switch from glitch fixing to something else.
Nov 06, 2021 Fixed the dark mode button glitch!
Nov 05, 2021 Continued with trying to fix the dark mode button glitch, I found another pip package, but it doesn't look very helpful. Also reviewed my PR for the sidebar glitch.
Nov 04, 2021 Tried fixing the dark mode button glitch.
Nov 03, 2021 Opened a PR to fix the sidebar glitch.
Nov 02, 2021 Finally fixed the glitch! Took so darn long, but I finally found a way to fix it via this obscure package.
Nov 01, 2021 Again, very little progress. But, little progress is still better than no progress.
Oct 31, 2021 Very little progress on fixing the sidebar glitch, I was really close until I released you cannot scroll on div below a button that covers up the whole thing.
Oct 30, 2021 Updated the README file, and started work on fixing the sidebar glitch on mobile using a button.
Oct 29, 2021 Fixed the glitch, created a PR for the new loading screen and tried to fix the sidebar glitch on mobile.
Oct 28, 2021 Was so close to making a PR, but I noticed a glitch that'll have to wait till tomorrow to be fixed.

bettermailto

Oct 29, 2021-Apr 06, 2022
Created an alternative to the mailto attribute in HTML. See the repository here.

bettermailto's start date is the date I started logging, not the date when the project started.

Log

Apr 06, 2022 I think this is a safe place to end the project. I'm genuinely proud with the end result (even though it doesn't fully work on Android and it's unlikely that this becomes a popular tool) and, in the end, I learnt a lot about Next.js, user authentication, databases, APIs and back-end development in general :)
Apr 05, 2022 Opened another Stack Overflow question.
Apr 04, 2022 Very little progress. I feel that all of this is impossible and that the project (on Android at least) is dead.
Apr 02, 2022 All this intent:#Intent stuff is really weird. One link will open Gmail... but on the Google Play Store, another will randomly opening settings. I found this, but it doesn't work:

intent:#Intent;action=com.google.android.gm;
category=android.intent.category.DEFAULT
;category=android.intent.category.BROWSABLE;end

Apr 01, 2022 Progress! I stumbled upon this Stack Overflow question which lead to me googling "gmail package name android" which brought me back to the URI world.
Mar 30, 2022 Installing React Native appears to be a nightmare.
Mar 24, 2022 I'm going to experiment with React Native (within the preexisting codebase) to fix the Android issue.
Mar 23, 2022 Fixed a small span inline style glitch and replied to the answer I got on Stack Overflow.
Mar 22, 2022 Posted a question on Stack Overflow.
Mar 21, 2022 The land of URL Schemes/Universal Links/App Links/whatever is treacherous on Android. Every time I felt I got close to an answer, I got thrown into a loop.

I fear that having a link that opens, say, Gmail's native app is not under my control, rather Google has to implement that. I'll try again tomorrow and if I'm unsuccessful, I'll write up a question on Stack Overflow.
Mar 20, 2022 Fixed a small footer glitch. If this project of mine ever gets big, I need to have a style guide like this one.
Mar 19, 2022 Continued with Android research. I fear that I'll have to use React Native.
Mar 18, 2022 Okay, the emulator I installed seems to make bettermailto think I'm on desktop (I think?) so of course the googlemail:// URL scheme won't work. Need to do further research.
Mar 17, 2022 Got an Android emulator sort of setup on another device.
Mar 16, 2022 One person on the Show HN thread said that the providers are broken on Android. Tried to get an Android emulator but I don't think that exists for M1 Macs.
Mar 15, 2022 Alright, I publicized bettermailto on Show HN after spending nearly an hour trying to fix the automated test feature (it was futile, the free plan for Zapier runs non-instant tasks only every 15 minutes).
Mar 14, 2022 I was this close to posting bettermailto on Show Hacker News but I realized that the test feature on the front-page is completely broken. Need to fix that.
Mar 13, 2022 The eslint errors are really strict!
Mar 12, 2022 Finished with adding security headers. Need to sit down and fix some eslint errors that I've been ignoring.
Mar 11, 2022 I improved the grade for bettermailto from a D to a C on SecurityHeaders.com. Not bad, need to add a couple more headers and I should be done.
Mar 10, 2022 So, I've stumbled on to the weird world of security headers. Not sure if that was a mistake or not but regardless I'll be doing more research and making sure I can get all the check marks on SecurityHeaders.com.
Mar 09, 2022 Going to implement Helmet.js and other security features before I seriously consider putting bettermailto on Product Hunt.
Mar 08, 2022 Dismissed a dependency issue.
Mar 07, 2022 I was wondering how I would fix the responsiveness of the providers (if your device was too wide, it would look awful) and my answer was right under my nose. I used margin-left: auto and margin-right: auto for the @media query when I should have just used it for all devices!
Mar 06, 2022 Got started with fixing the responsiveness of the website.
Mar 05, 2022 Fixed a very small glitch fix where the GitHub link was pointing to my fork rather than the GitHub organisation. Wondering what to work on next.
Mar 04, 2022 Implemented the compromise with this NPM package.
Mar 03, 2022 Still working on implementing it, copy and pasting with JS (for all devices) is unnecessarily hard.
Mar 02, 2022 Okay, the first part of the decision chart won't work as you can change your default provider on iOS. So I'm directly using the compromise. Nearly done implementing it.
Mar 01, 2022 Alright, I still need to do a bit more research, but I think this "decision chart" should work:

Is the device a phone? -> Is the device an iOS device? -> Use mailto.

Is the device NOT a phone? -> Is the device a Mac-based computer? -> Compromise and just open the Apple Mail app and copy and paste the email and subject to the user's clipboard.

I won't display the Apple Mail provider for non-Apple devices as I'm pretty sure Apple Mail isn't supported on Windows or on Android.
Feb 28, 2022 Committed the Airmail provider. I'm really unhappy with the Apple Mail provider, it relies on mailto and, if you've already set a default provider, it'll just open that instead of Apple Mail. I'll work on that from tomorrow and try to see if I can get some compromise (remember, the URL scheme for Apple Mail doesn't allow you to compose).
Feb 27, 2022 Committed the Spark provider.
Feb 26, 2022 Alright I figured out that Spark has a pretty good URL scheme (and people actually use Spark!) so I'm in the process of implementing that.
Feb 25, 2022 Removed the GitHub provider, going to work on adding more email providers that have a protocol handler.
Feb 24, 2022 Sigh, the GitHub provider is also useless since it requires the user to have their email public (which defeats one of the core values of bettermailto, keeping the email private from bad guys), I'll research about GitHub OAuth again tomorrow.
Feb 22, 2022 Removed the Slack provider since it was pretty useless (the person probably signed into Slack with a magic link or Google, both of which are already providers on bettermailto) and so I'll add GitHub tomorrow and leave it at that.
Feb 21, 2022 Got started with adding the Slack provider (though it's broken right now) and going to add a GitHub provider as the final (?) OAuth provider.
Feb 20, 2022 Wasn't able to make much progress with the Apple Mail problem. The only real way is to use mailto so I've added that and I'll come back to it later.
Feb 19, 2022 Really strange, message:// opens Apple Mail but it doesn't allow you to compose to any particular email.
Feb 18, 2022 Added fallbacks for the mobile providers! I'll work on trying to get Apple and Windows Mail (though I'm not entirely sure if that's possible).
Feb 17, 2022 Added the URL schemes for the three major email providers. Pretty interesting story:

I first thought that a link from a website to a native app (that you didn't program) would be impossible (it makes sense security-wise) but nope, I (by sheer luck) found googlemail.

I fear this technology might be killed off by these big companies (I'm looking at you, Google) but we'll cross that bridge when we get to it.

Going to work on how to give the user more choice on whether they want to use the mobile app or the website.
Feb 16, 2022 Added the Outlook URL scheme!
Feb 15, 2022 Figured it out! Should be able to do it with the other providers (hopefully).
Feb 14, 2022 Figuring out how to add a link to open the Gmail app on iOS (for now).
Feb 13, 2022 Finished adding a fallback mailto provider. I couldn't keep the cool "Loading..." since it would be too much work to keep squashing bugs for various platforms for this small comfort feature.
Feb 12, 2022 Made great progress with adding the new providers!
Feb 11, 2022 Made a few miscellaneous changes (and committed them) and continued with adding other providers.
Feb 10, 2022 Made a really nice dropdown with CSS for the other providers. Why am I so good at CSS? I could have been good at literally any other skill (just kidding, CSS is amazing if you know how to use it).
Feb 09, 2022 Did a bunch of organizational work (updated the legal docs with the new support bettermailto-link, removed a test account on MongoDB and added an error page for NextAuth errors). I'll work on adding more sign-in providers and more email choices till probably March or April.
Feb 08, 2022 AHAHA I DID IT! I expected this to take a few days but nope, fixed everything (including an annoying button glitch) and you can now email me (safely, for both of us) with this.
Feb 07, 2022 Still working on the production glitch.
Feb 06, 2022 Okay, I had to comprise and remove any reference to the user's name. Now, the email provider works in production, but not in deployment. Going to fix that tomorrow.
Feb 05, 2022 I fixed another glitch where I queried the database with the user's name, not the ID (which was dumb). Still figuring out how to get the user's name into the database via the email provider.
Feb 04, 2022 Okay, I got the form looking pretty good and I figured out why the email sign-in wasn't working. My code relies on the name attribute the user provides (through OAuth) for the user URL. But since I didn't ask for their name using the email form, the whole code broke.

So I need to find a way to manually add the name attribute to MongoDB (since I don't think NextAuth's email API allows that).
Feb 02, 2022 Going to keep the database issue aside right now, currently working on making the email form look much better.
Feb 01, 2022 Hmm, I noticed that new users face an error while signing in with the new provider, so I tried to add a MongoDB adapter and that broke everything... Will try to fix it tomorrow.
Jan 31, 2022 Finished adding the email provider! Pretty darn cool, though the UI is the opposite of cool right now. I'll work on that tomorrow.
Jan 30, 2022 So close to finishing all of this! I figured out that you have to use a dedicated service (not just Gmail) such as SendGrid.
Jan 28, 2022 Made great progress with adding the passwordless provider, though we may be in here for a while...
Jan 26, 2022 Got started with adding a passwordless provider.
Jan 25, 2022 Forgot to add reCAPTCHA to the privacy policy, oops. Also added a disclaimer while signing in/up.
Jan 24, 2022 Finished (?) the privacy policy.
Jan 23, 2022 Got started with the privacy policy of bettermailto.
Jan 22, 2022 Finished with the terms of service.
Jan 21, 2022 Continued with the terms of service.
Jan 19, 2022 Continued with the terms of service.
Jan 18, 2022 Continued with the terms and conditions (and I'm pretty sure it has to be terms of service, but I'll check that tomorrow).
Jan 16, 2022 Got started with adding the terms and conditions.
Jan 15, 2022 Added a spinning animation to show while the website gets the reCAPTCHA score.
Jan 14, 2022 I'll keep credentials in the back of my mind, but for now I'll be adding some more easier-to-implement features (responsiveness, third party providers, changing the default providers depending on the device, etc.) For now, I'm working on responsiveness.
Jan 13, 2022 Still thinking about the Credentials provider.
Jan 12, 2022 Got started with adding the "Credentials" provider to NextAuth.js. We might be at this for a while...
Jan 11, 2022 Fixed a long-standing bug where your custom link would be too long on mobile (also, this marks the first time my commit broke the website!) I'll work on more login clients from tomorrow.
Jan 10, 2022 Committed a 404 page and some other smaller changes.
Jan 09, 2022 Committed the reCAPTCHA changes!
Jan 08, 2022 I finally got reCAPTCHA v3 working and verified! I just need to implement this locally and deploy it.
Jan 07, 2022 Verification is really tough for some reason, I keep getting CORS errors which is annoying. I'll push on tomorrow (and I'll figure out if I can do anything with Vercel or maybe even PHP)
Jan 06, 2022 Finally got reCAPTCHA v3 to work, the issue was me being dumb (should have just read the documentation). I need to program the verification tomorrow.
Jan 05, 2022 reCAPTCHA v3 with this npm package is still not working for me and I'm not even sure why. I'll keep trying tomorrow and maybe try doing it in React.
Jan 04, 2022 Okay okay, reCAPTCHA v3 makes more sense, and I've got the functionality (almost) working.
Jan 03, 2022 Okay, reCAPTCHA v2 makes a lot more sense now that I think about it, so I added it (still not functional) and styled it.
Jan 02, 2022 Got to work on adding reCAPTCHA v3 on the website to deliver on the promise of security for the emails. Also added meta tags and other small fixes.
Jan 01, 2022 bettermailto is now live! Though you cannot sign in right now, it's not a bug it's a feature... I also figured out how to deploy it all for free even within an organisation, I just have to fork it to my personal account and fetch it every time I make a commit.
Dec 31, 2021 Last day of 2021! I bought the domain bettermailto.com and I created the test email Zapier integration. Hoping to find a way to deploy from a GitHub organisation for free with AWS Amplify and to get everything done and deployed by mid-2022!
Dec 30, 2021 Authenticating + generating URLs for multiple users is now done! Wow, that took a while. I'll work on other ways of signing in.
Dec 29, 2021 I figured out how to work with multiple users for generating the URLs, but authenticating them is still in the works.
Dec 28, 2021 Okay, back to programming. Got a major breakthrough and now I am able to authenticate the user URLs and generate them, but it only works with one user in the collection. Need to figure out how to get multiple users to work.
Dec 27, 2021 Reflecting about the project in a bigger sense and wondering what's next (again, in a bigger sense).
Dec 26, 2021 Found another good piece on MongoDB and Next.js, made good progress with authenticating if the user already exists.
Dec 25, 2021 Connected everything! That video really came in clutch.
Dec 24, 2021 Started with my MongoDB setup, found a good video to connect all of these parts together, will watch it tomorrow and follow along.
Dec 23, 2021 Fixed some small bugs, still thinking about databases.
Dec 22, 2021 Fixed the "emailbox"'s styling and responsiveness. All I need to do now is make the whole app secure and connect it to a database.
Dec 21, 2021 Re-did the "emailbox" part of the app as the styling was messed up.
Dec 20, 2021 I feel like I still have a lot to learn about databases, back-end, user auth and even web security. It all feels quite overwhelming. Anyways, continued with checking if the user already exists.
Dec 19, 2021 I figured it out! I was looking at the problem of checking if a user already exists the wrong way, I simply need to assign a random string and link it to a database.
Dec 17, 2021 Wish I had more time to work on bettermailto today, but anyhow, worked on making the design more responsive.
Dec 16, 2021 That article didn't turn out all that useful, still figuring out how all this back-end stuff works. As for now, I added the email providers for the user URL slug.
Dec 15, 2021 More progress, found a great article for connecting AWS, MongoDB and Google Cloud all together, now I need to figure out how to store new users, and I think I found an answer.
Dec 14, 2021 Made good progress with the checking if a user already exists.
Dec 13, 2021 Migrated to Firebase and cleared up old projects on Firebase and Google Cloud to keep everything organized.
Dec 12, 2021 Made the button have a cool transition, will work on getting user data from Google OAuth tomorrow.
Dec 11, 2021 After one googolplex, I finally made a custom page for signing in with Google OAuth + NextAuth!
Dec 10, 2021 Trying to figure out how to have a custom page for the Google OAuth.
Dec 09, 2021 Finally got Google OAuth working.
Dec 07, 2021 Alright, starting to finally figure out all of this user auth stuff.
Dec 06, 2021 Why is user authentication so complicated?
Dec 05, 2021 NextAuth + auth0 is really annoying, nothing seems to work. Thinking about going back to AWS Cognito. (I would leave it aside, but I can't leave user auth aside because it ties into generating custom URL's and making sure that URL actually exists.)
Nov 30, 2021 Nearly got auth0 working. I think working consistently on a project for slightly over a month is a good sign that things will work out.
Nov 29, 2021 In the process of migrating to auth0, it's much more user friendly (let's see if I regret this decision later on).
Nov 28, 2021 I'm going to keep the custom sign-in page aside for now. I need to figure out how to check if a user already exists within the user pool.
Nov 27, 2021 Got a comment on my Stack Overflow question that showed me the solution to my problem!
Nov 26, 2021 Opened up a Stack Overflow question about a custom UI with AWS Cognito + NextAuth.js
Nov 25, 2021 Fixed a small bug with the email box component. Also, the package I mentioned yesterday failed to install. But, I've made another breakthrough with making the sign-up process more streamlined.
Nov 24, 2021 Researched about API's for AWS, I think I found my answer!
Nov 23, 2021 Made some great progress. I figured out the second problem and found a way to create custom URLs. Now I have to start seriously thinking about databases and integrating them with AWS.
Nov 22, 2021 Continued with the dashboard of the app, it's all coming together!
Nov 21, 2021 So much progress today! Got done with the sign-in experience (it's not the best, but it works and it's more streamlined) and I am starting to think about databases for this app.
Nov 20, 2021 Continued with user authentication.
Nov 19, 2021 Got user authentication working, though I'm wondering how to make a custom UI for it.
Nov 18, 2021 Got great advice on the back-end infrastructure for bettermailto. Working on user authentication and fixed a small responsive glitch.
Nov 17, 2021 Finished the migration! Just need to fix the Netlify errors and it'll be deployed soon.
Nov 16, 2021 Making progress on the transfer, just have to figure out images in Next.js.
Nov 15, 2021 Going back to Square-1.
Nov 14, 2021 Okay, forget what I said yesterday. It's a lot more complicated.
Nov 13, 2021 Continued the migration, a bit more complicated but it's all good.
Nov 12, 2021 Continued the migration to Next.js and TypeScript.
Nov 11, 2021 In the process of migrating bettermailto to Next.js to TypeScript.
Nov 10, 2021 Figured out how to confirm passwords.
Nov 09, 2021 We're making progress again! Found something called Formik for React. I used it for the sign-up form.
Nov 08, 2021 Fixed the npm glitch.
Nov 07, 2021 Well crap, my repository has some weird npm glitch and now I cannot start it.
Nov 06, 2021 Added some flex properties to make both the logo and log-in link visible on any device.
Nov 05, 2021 The front-end looks, in my very biased opinion, pretty great. But, there is literally nothing in the back-end. I started to add the registration code.
Nov 04, 2021 Creating a hamburger menu is too hard, decided to just add a link for mobile users to sign-up in the log-in page. Also fixed Netlify glitches and added other minor design changes.
Nov 03, 2021 Redesigned the sign-up and log-in pages and changed the Outlook link to be much faster.
Nov 02, 2021 Added a (totally not stolen) sign up form (don't worry, I'll change it later).
Oct 30, 2021 Designing a form is hard.
Oct 29, 2021 Fixed the React glitch with Switch, and made a (very bad) sign up page. I think I will eventually need someone to handle the back-end part of this app.

EAGxOxford 2022

26 Mar, 2022-27 Mar, 2022
Attended EAGxOxford 2022.

Log

Mar 27, 2022 Second (and last day) complete! Attended a workshop on rationality by Chana Messinger along with the A.I. Safety Q&A, the EA Funds talk/workshop, David's talk on his recent paper and the fireside chat with William MacAskill (which I assume is now an annual-ish thing).

EAGxOxford

Mar 26, 2022 First day complete, it was awesome meeting EAists and attending A.I. Alignment by Rohin, Biorisk by Simon and Janvi and Career Opportunities in A.I. Governance by Lennart and Caroline!

EA In-Depth Fellowship Facilitator

Dec 29, 2021-Mar 01, 2022
I got accepted to be a facilitator for EA Virtual Programs In-Depth Fellowship, it was an awesome experience!

Log

Mar 01, 2022 Last week done! We went around and told our next steps and it was awesome hearing that everyone found the program to be excellent :)
Feb 22, 2022 Seventh week done! We chose Global Catastrophic Biorisks and we discussed that in tandem with A.I. safety.
Feb 15, 2022 Sixth week done! We chose Decision Theory and had a great time discussing about Brian Tomasik's work, Pascal's mugging, expected value, etc!
Feb 08, 2022 Fifth week done! We chose Using Forecasting Tools (which was surprising to me) and we talked a lot about Metaculus, Scott Alexander and how to use forecasting in order to propel EA further.
Feb 01, 2022 Fourth week done! We chose Community Building and had a great time discussing some core concepts of how EA information is spread (and how to do that effectively) and we even touched upon EA in communities where it's not so present, such as South America.
Jan 25, 2022 Third week done! Had a great time discussing a lot about Julia Galef's work (including The Scout Mindset, which I'm currently reading) and about applied rationality, biases and if the ends justify the means. A lot of this can be learnt about on LessWrong.
Jan 18, 2022 Second week done! Was even better than the last week, we talked a lot about animal welfare, wild animal suffering, the expanding moral circle, etc.
Jan 11, 2022 First week done! Was a lot of fun meeting my cohort, they all have such interesting backgrounds and goals for this fellowship.
Dec 30, 2021 Finished a lot of administrative stuff.
Dec 29, 2021 Had a fun training session where we all got roles to play, the best one I got was "look super confused at jargon".

Miller-Rabin Research

Nov 28, 2021-Jan 24, 2022
Did some research in to the liars in the Miller-Rabin Primality Test, inspired by Numberphile.

Log

Jan 24, 2022 Alright, got rejected from arXiv again. My advisor suggested finding some other math archives. Honestly, with the exception of ViXra (which I won't go with, see link for reason) there aren't any pre-print repositories that aren't affiliated with a university.

In the end, I had a lot of fun with this project! The link to the paper on Google Drive is here and I also cold emailed the inspiration for the paper.
Jan 23, 2022 Okay, resubmitted the paper with external figures and top 99 and top 100 results instead of no results.
Jan 22, 2022 I got the pie charts as external figures and crossed my fingers while processing the files on arXiv, well, it didn't time out, rather it gave an odd error saying something along the lines of "couldn't read the log file generated". It all works with the file without the appendix. Will look into all of this tomorrow.
Jan 21, 2022 Well, they sort of rejected my appeal for a large submission. Anyways, I timed my local compile time for the paper with the appendix and (accounting for slowness due to arXiv compiling it), I feel like if I change the pie charts to be external images, it may just be fast enough to beat the 420s time limit. Will see tomorrow.

Otherwise, I'll jettison the four witness results.
Jan 20, 2022 Implementing tables in such a strict time limit looks impossible. So, I've contacted arXiv to allow a LaTeX generated PDF once again.
Jan 19, 2022 My general advice after rejection is to re-group, so here are the steps I'm going to follow in the following week (after speaking with my advisor):

i) Try to fit all the results within the paper, this is going to be the hardest part as arXiv has a limit on the compile time. If I can't do this, I'll contact support and ask if to allow LaTeX generated PDF's (which they did last time)

ii) Emphasise the exclusivity of these results as to my knowledge, the worst witnesses have never been published.

iii) Try to add some real-world applications in the conclusion.
Jan 18, 2022 Well, my paper got rejected by the moderators, the worst part is that they can't give specific feedback due to so many submissions. I'll try again soon (after adding the results back in and talking with some advisors).
Jan 14, 2022 I did it! The paper has been submitted, should be public by Jan 16th at 8pm EST.
Jan 13, 2022 Facing a bit of a crossroads, I'm this close to being able to submit, but there's a lot of issues that need to be sorted out to make it perfect:

i) What method do I take in showcasing the results? I could keep it in a tabular form (which was what I was planning to do) but the compile time is too long (and though the mods made an exception for me, it'll probably still get rejected) or I could just keep it as a link. Ancillary files don't seem to help that much.

ii) There's a weird glitch where the references have this line break issue if the link is too long, might be able to fix this tomorrow.
Jan 12, 2022 I got endorsed! I was just about to finalize my submission but my paper is too long for arXiv due to the results, I sent an exception request and learnt that I have to put them in ancillary files for submission.
Jan 11, 2022 Continued finding endorsement.
Jan 10, 2022 Continued finding endorsement.
Jan 09, 2022 Fixed a small bug in the version of my paper with the appendix (which is the one I'll submit) and continued finding endorsement.
Jan 08, 2022 Got a final check done and trying to find someone to endorse me for the math.NT section of arXiv.
Jan 07, 2022 Finished all the changes, should be up on arXiv between today and the 9th.
Jan 06, 2022 Great progress with the first algorithm and some extra formatting. Will finish up the second and last algorithm tomorrow and make sure everything is neat and tidy. I'll do a bit more research on submission and (possibly) submit it to arXiv either tomorrow or the day after.
Jan 05, 2022 Alright, need to re-write the two pseudo-code algorithms, check everything and get to work submitting the manuscript to different journals (and later, arXiv).
Jan 04, 2022 Continued with re-formatting the paper and researching about journals and conferences.
Jan 03, 2022 Got the review back and got some great tips (mainly in formatting) and I implemented most of them (using the algorithm package, fixing the heading position and fixing the conclusion).
Jan 02, 2022 Fixed that odd reference glitch, it was due to me deleting the output files...
Dec 31, 2021 Added references for the appendix, my goal for 2022 is, well, to get this published! There is also some weird glitch happening with the references right now, but I'll fix that soon.
Dec 30, 2021 Finished the first draft and sent it for review! I got all the packages installed and got a 90-page paper, though most of those pages are just the worst witnesses in a tabular form.
Dec 29, 2021 The paper is basically done, I need to check everything (grammar & spelling and general writing while still in Overleaf), add a few more references and compile everything with BasicTex.
Dec 28, 2021 Added the rest of the results and analyzed the single witness results, need to analyze the rest, somehow compile the Latex document another way (Overleaf isn't having it with my top 500 worst witnesses), add concluding remarks and we're done.
Dec 27, 2021 Added the results for single and two witnesses, going to add the rest tomorrow as well as some data visualization for all of them tomorrow or the day after tomorrow.
Dec 26, 2021 Made good progress and finished the code and multiple witnesses section! All that is left is results analysis and conclusions.
Dec 25, 2021 Finished the introduction to the test, will work on the code used (and how I supported multiple witnesses) and maybe even analyzing the single witness results tomorrow.
Dec 24, 2021 Got a nice and simple template and finished the abstract for the most part. Will work on the introduction to the test and its witnesses tomorrow.
Dec 23, 2021 Started with the paper, LaTeX is an amazing piece of software.
Dec 22, 2021 Compiled the three and four witnesses results, wished I could have started writing but oh well.
Dec 21, 2021 Compiled the two witnesses results.
Dec 20, 2021 Compiled the single witness results and cleaned up the research file.
Dec 19, 2021 Finished coding up 3 and 4 witnesses, will save the results up to about 10,000 (I don't have heat death of the universe level of time to spend) and start writing the paper soon.
Dec 18, 2021 I did it! The worst multiple witnesses of the Miller-Rabin primality test are now knowable through my very slow code! I'll start writing the paper soon after compiling all my results.
Dec 17, 2021 I'm going the extra mile and trying to figure out the worst liars when they are grouped as 2 witnesses (if I can get this, it'll probably be similar to do 3, 4 or more witnesses, but there's no need to go over 4 I believe).
Dec 16, 2021 Fixed the glitch for single witnesses! I can now get the top liars! The 2nd worst witness for defendants till 1000 is 676, with 18 lies.
Dec 15, 2021 Amazing progress! I implemented multiple witnesses into the test, I should have done this a long time ago but I thought it was going to be hard/complicated, but it wasn't. I also spent way too long fixing a glitch.
Dec 14, 2021 It now works, sort of? It's hard to tell. I'll now analyze my two methods (possibly three now that I think about it), fix any bugs and see if I can get in contact with an actual college student in maths before starting to write my paper.
Dec 13, 2021 Coded it up, and while it is just about the same speed as the last method, it doesn't work, at all. Might need to fix that soon.
Dec 12, 2021 Figured out a (hopefully) better methodology to use and wrote it down in comments, though it may be even slower than the previous one. Still, what matters is the results.
Dec 11, 2021 Alright so, I'm going to keep my previous methodology as a separate cell. I'll work on another approach (that's a bit more useful) tomorrow. I might need to reach out to someone to check if all of this actually works and makes sense.
Dec 10, 2021 So I thought my methodology was pretty good, turns out that I always get 1 as the worst witness. I'll take a bit of time out to figure out a different methodology.
Dec 09, 2021 Made good progress with finding the worst witness, crazy to think that a random line in a Numberphile video lead to all of this.
Dec 08, 2021 Migrated to Google Colab and made some progress on calculating star liars. I need to figure out multiple witnesses, I know one way but it'll make everything incredibly slow.
Dec 07, 2021 Even more progress! I created a few more functions, mainly for primes numbers (not sure how useful the composite functions will be) and I need to find a quicker way to accurately find the number of prime numbers between two given numbers.
Dec 06, 2021 Progress! I explored the function for the Miller-Rabin test and created some composite functions and figured out how to use custom witnesses.
Dec 05, 2021 Thinking of moving to Rust because of the existence of this crate.
Dec 01, 2021 Changed to Python since it's much easier to work with. Going to have to figure out how to generate star-witnesses and work my way to liars.
Nov 30, 2021 Opened up a repository for the Miller-Rabin C code. Let's hope December is a good month for this project!
Nov 29, 2021 Researched about the star witnesses in the Miller-Rabin test (see Numberphile video).
Nov 28, 2021 Wrote up my Notion page with the basics of the test, hoping to write some code for the test in C/C++ (haven't decided) by the end of this week.

EA Bristol Website Redesign

Nov 20, 2021-Nov 21, 2021
Re-designed EA Bristol's website.

Log

Nov 21, 2021 Opened a PR for the current CSS file, thus ending this project!
Nov 20, 2021 Saved a first draft and published it!

Effective Altruism In-Depth Fellowship

Oct 30, 2021
I attended EA Virtual Program's In-Depth Fellowship after my introductory fellowship by EA Cambridge.

Effective Altruism In-Depth Fellowship's date is the date I started logging, not the date when the project started.

Summary

Wow, it's crazy how nearly 2 months just flew by. Incredible, incredible fellowship. Can't recommend it highly enough.

EA Global: London 2021

Oct 30, 2021
Attended EA Global: London 2021 as a virtual attendee.

EA Global: London 2021's date is the date I started logging, not the date when the project started.

Summary

It was great seeing both Benjamin Todd and William MacAskill (albeit virtually) talk in such an in-depth manner. One day, I'll hopefully go for one physically!

Retroactive

This is a retroactive recollection of all the projects I undertook in my life before starting this website. None of these dates are particularly accurate!

Classless CSS + Bear Blog Replacement

Sep 16, 2021-Aug 8, 2022

Summary

In my experimentations with Bear Blog (which I developed a replacement for), I made some classless CSS files. I somewhat actively worked on them till ~August 2022. Feel free to use them!

youthree

Aug 6, 2021-Oct 14, 2021

Summary

My first real "weekend" programming project (which take way longer than a weekend). You can find a screenshot of the rare instance the website wasn't broken down below:

youthree

Symposium Project

May 28, 2021-Aug 17, 2021

Summary

The last project I worked with my brother before he went for university (and the first "real" project with him) was a blog that I had developed and where we both wrote about a subject we had read about/found interesting.

We had our fair share of arguments during this project, but I'm sure it made our relationship stronger in the end. You can find some of the blog posts from this era on my blog.

CaryKH's Prisoner's Dilemma Tournament

May 04, 2021-May 25, 2021

Summary

Was quite a fun tournament! I watched CaryKH's BFDI series when I was quite young, so it was interesting to see this as a natural evolution from that. I called my file "Elephant.py" and came in the ~92% percentile.

WaveLF Courses

sometime in 2020

Summary

An interesting first foray into the world of extracurriculars for little Arjun, I distinctly remember running from the car after an outing to attend my microeconomics class. The neurodegenerative disease course was also interesting. I hope all my instructors are doing well now!

Drums

Aug 02, 2022-present
Trying to get better every day and have some fun as well!

Drums' start date is the date I started logging, not the date when the project started.

Log

Dec 24, 2023 More acoustic drums should be there in hip-hop music, both live drums and drum machine samples can coexist!
Dec 07, 2023-Dec 12, 2023 Learnt ~about two songs for, something!
Nov 30, 2023 Recorded and uploading Clocks by Coldplay.
Nov 14, 2023 It's up!
Nov 11, 2023-Nov 13, 2023 Recorded a song that a couple of my schoolmates and I are covering!
Oct 07, 2023 Recorded Zero by The Smashing Pumpkins!
Oct 07, 2023 Recorded Suck My Kiss by Red Hot Chili Peppers - really loved how this one came out!
Sep 24, 2023 Do air drums count?
Sep 23, 2023 Recorded Rope by Foo Fighters! (finally)
Sep 22, 2023 Recorded Rock and Roll by Led Zeppelin!
Sep 19, 2023 Played the acoustic drum kit in school!
Sep 17, 2023 Almost recorded Rope by Foo Fighters.
Sep 05, 2023-Sep 10, 2023 Recorded Heartbreaker by Led Zeppelin.
Sep 04, 2023 I think I made my teacher proud!
Sep 04, 2023 Played Summer of 69' by Bryan Adams for tomorrow.
Sep 03, 2023 I am Iron Man. Also, Heartbreaker! Will finish learning it by Friday.
Aug 21, 2023 Finished an audition.
Aug 20, 2023 Messed around with some blink-182 and Van Halen.
Aug 12, 2023-Aug 17, 2023 Finished Grade 3 for the most part (one song is left I believe) and blink-182!
Aug 11, 2023 Recorded Smells Like Teen Spirit by Nirvana.
Aug 07, 2023 Recorded Come Together by The Beatles.
Jul 31, 2023-Aug 06, 2023 Continuing to learn Sweet Child O' Mine by Guns N' Roses.
Jul 29, 2023-Jul 30, 2023 Learnt Weird Fishes/ Arpeggi by Radiohead.
Jul 28, 2023 Los.
Jul 27, 2023 'Breed' by Nirvana is quite a fun song to play.
Jul 26, 2023 Played the intro to Toxicity and shared it.
Jul 24, 2023 Learnt Boulevard of Broken Dreams and I Believe I'll Dust My Broom
Jul 21, 2023-Jul 23, 2023 "I've given.... UUUUUPPPP!"
Jul 17, 2023-Jul 20, 2023 Back to playing random songs, 'Los' is quite fun to play! Turns out that I broke my snare pad, so swapped with a tom pad. Works.
Jul 16, 2023 Played 'Chop Suey!' by System of a Down and shared it to the interwebs.
Jul 11, 2023-Jul 15, 2023 So much fun just playing random songs (mostly by a certain NDH band). Going to record a little something tomorrow.
Jul 08, 2023 Played some Radiohead songs. This is a lot more fun than I remember!
Dec 20, 2022 Sort of messed around for a bit.
Aug 13, 2022 Played Fever by The Black Keys.
Aug 12, 2022 Played I Want to Break Free by Queen.
Aug 06, 2022 Finished learning Back in Black by AC/DC. The snare-kick-hi-hat pattern was the only thing I had to get down.
Aug 04, 2022 Played Back in Black by AC/DC.
Aug 02, 2022 Played Yellow by Coldplay.

Guitar

Oct 29, 2021-present
Trying to learn acoustic guitar via justinguitar.com.

Guitar's start date is the date I started logging, not the date when the project started.

Log

Sep 16, 2022 Learnt some open 7th chords.
Sep 03, 2022 (Tried) to learn Hey You by Pink Floyd.
Aug 17, 2022 Freestyled to ease back in.
Aug 03, 2022 Continued with Module 4 practice.
Aug 01, 2022 "Learnt" the intro to Chop Suey! Drop C tuning is awesome.
Jul 28, 2022 Practiced a sliding power chord song that was recommended to us (why do almost all of them have iffy names?)
Jul 27, 2022 Got started with Module 4 practice.
Jul 26, 2022 Finished learning an easier version of Enter Sandman.
Jul 25, 2022 "Finished" with the Module 5 videos (sort of just skipped a few) and will get started with the practice tomorrow.
Jul 20, 2022 Played an electric guitar for the first time!
Jul 08, 2022 Finished a short video in the module. I guess I've been less motivated to continue with this module since it's so electric guitar focused (though maybe I'm wrong and my skill is to blame here, not the acoustic)
Jul 04, 2022 Sort of continued with the riff.
Jul 03, 2022 Learnt the first part of the first part of the Enter Sandman riff.
Jul 02, 2022 Finished with Palm Muting and Understanding Distortion. This module is irritating if you're using an acoustic. Why do you have to be so cool, electric?.
Jun 27, 2022 Finished with The Am Pentatonic Scale.
Jun 26, 2022 Finished with Power Chords (and sort of learnt Smells Like Teen Spirit?)
Jun 25, 2022 Got started with Power Chords.
Jun 18, 2022 Six days... Finished with the second iteration of Module 4 practice.
Jun 12, 2022 Continued with the second iteration of Module 4 practice. I finally understood why my guitar improv is so bad: I keep trying to play odd patterns.
Jun 11, 2022 Continued with the second iteration of Module 4 practice.
Jun 09, 2022 Got started with the second iteration of Module 4 practice.
Jun 08, 2022 Finished with the first iteration of Module 4 practice.
Jun 06, 2022 Continued with the first iteration of Module 4 practice.
Jun 05, 2022 Got my guitar repaired!
May 28, 2022 Continued with the first iteration of Module 4 practice, will be done with it tomorrow (welp, a guitar string broke again, so I'll try my best to get back to the practice ASAP).
May 26, 2022 Finished with the Module 4 videos and got started with the first iteration of Module 4 practice. I think I'm going to increase the number of iterations to three.
May 25, 2022 Finished dice songwriting. Really fun lesson! (even though I didn't do too much lol)
May 24, 2022 Finished learning about the songs for this module (excited for the fingerstyle songs for the first iteration).
May 23, 2022 Finished some ear training, felt pretty disheartened after getting the last exercise wrong.
May 22, 2022 Had fun with this lesson.
May 19, 2022 It took roughly a week but I can finally play Happy Birthday on my own!
May 18, 2022 Hopefully I should be able to play it tomorrow...
May 16, 2022 So close to playing Happy Birthday on my own!
May 15, 2022 Continued with learning Happy Birthday, about two-thirds of the way there.
May 13, 2022 Continued with learning Happy Birthday.
May 12, 2022 Got started with learning Happy Birthday and had some fun with learning All Falls Down (I guess I've learnt it? It sounds pretty bad though).
May 11, 2022 Learnt more about fingerstyle playing.
May 10, 2022 Had fun playing How Much A Dollar Cost with these chords (simplified) (only the F#, F and Dm sounded okay lol)
May 09, 2022 Finished with shifting the F chord. The way Justin played the F chord reminded me How Much a Dollar Cost by Kendrick Lamar. I'm going to try to play that tomorrow.
May 08, 2022 Got started with Module 11 with some sus chords, I really like the transition from A sus2 to A sus4.
May 06, 2022 Finished with the second iteration of Module 10 practice!
May 05, 2022 Continued with the second iteration of Module 10 practice. Nearly done!
May 04, 2022 Continued with the second iteration of Module 10 practice.
May 03, 2022 Continued with the second iteration of Module 10 practice, I thought I forgot the C Major scale but nope, my guitar was just slightly out of tune lol.
May 02, 2022 Got started with the second iteration of Module 10 practice.
May 01, 2022 Finished with the first iteration of Module 10 practice! Also, small correction: I don't use the songbook tab on JustinGuitar.com (since it forces the song into three categories, which I don't like) and instead I just like the play-through video (which acts as a songbook).
Apr 27, 2022 Continued with Module 10 practice and added two songs to my songbook!
Apr 26, 2022 Continued with Module 10 practice, F (with bar) chord is shaping up to be pretty decent now (similar sounding to a Fmaj7) but the change from F to C is slow for me lol.
Apr 23, 2022 Continued with Module 10 practice and did some really bad C Major improvisation (why did I choose the thinnest string?)
Apr 22, 2022 Continued (?) with Module 10 practice.
Apr 20, 2022 Finished with the Module 10 videos and got started with the first iteration of Module 10 practice (sort of, I need to start over with the C major scale alternate picking).
Apr 19, 2022 Learnt some common chord progressions.
Apr 17, 2022 Finished with La Bamba Riff (learnt the double note variation).
Apr 16, 2022 Finished with Beginner Hammer-ons which are super tricky and learnt the single note variation of the La Bamba riff, which is super awesome.
Apr 15, 2022 Finished with The Rhythm Push and also discovered that the 11th fret of the thinnest string sounds almost exactly like the "siren" sample in Use This Gospel.
Apr 14, 2022 Finished with Alternate Picking C Major and Major Scale Improvisation (really excited to start guitar improv in this module's practice!)
Apr 13, 2022 Finished with F chord changes and feeling the frets.
Apr 12, 2022 Learnt about the weak finger G (which I dislike, for now...) and the A mini barre (which I kinda dig)
Apr 11, 2022 Finished the second iteration of Module 9 practice! Will start Module 10 tomorrow.
Apr 10, 2022 Continued with the second iteration of Module 9 practice.
Apr 09, 2022 Continued with the second iteration of Module 9 practice.
Apr 08, 2022 Got started with the second iteration of Module 9 practice.
Apr 07, 2022 Finished the first iteration of Module 9 practice, will start the second iteration tomorrow.
Apr 06, 2022 I did it! I learnt the C Major Scale! I leveraged the previous pattern I learnt for the note circle.
Apr 04, 2022 Continued with the first iteration of Module 9 practice and played One by U2.
Apr 03, 2022 Continued with the first iteration of Module 9 practice. Something barely impressive: I can play the C-G-D-A-Em chord transition without looking at the guitar (kind of).
Apr 01, 2022 Continued with the first iteration of Module 9 practice, the guitar chords Notion page is extremely handy!
Mar 31, 2022 Revised the Em Pentatonic Scale.
Mar 24, 2022 Continued with the first iteration of Module 9 practice.
Mar 23, 2022 Got started with the first iteration of Module 9 practice.
Mar 22, 2022 Finished with the Module 9 lessons, will be on the practice for some time (due to the C Major scale lol)
Mar 21, 2022 Finished with the Red Hot Chili Peppers riff (minus the chords, might do that for fun).
Mar 20, 2022 Got my guitar strings replaced, I've never heard a guitar so out of tune before lol.
Mar 11, 2022 It wouldn't be a JustinGuitar module without an odd finger training exercise. I was planning on finishing up the Red Hot Chili Peppers riff today (since it's pretty easy) but my D string broke :(
Mar 10, 2022 Finished with more advanced 16th note strumming.
Mar 09, 2022 Got done with compiling all the chords in a Notion page.
Mar 08, 2022 Changed my mind, the C Major scale got to me lol. I'll start the chord book work tomorrow.
Mar 07, 2022 Finished with All Stop Mute and creating a chord book (which I will do from tomorrow instead of the videos.)
Mar 06, 2022 Finished with learning the F chord and its variations. It honestly isn't impossible but it certainly is tricky. Maybe I'm just lucky.
Mar 03, 2022 Finished with the second iteration of Module 8 practice! Will start Module 9 and the dreaded F chord soon.
Mar 02, 2022 Continued with the second iteration of Module 8 practice, nearly done.
Mar 01, 2022 Continued with the second iteration of Module 8 practice.
Feb 28, 2022 Started with the second iteration of Module 8 practice, why does my E min7 chord sound so bad?
Feb 27, 2022 Finished with the first iteration of Module 8 practice! I'll start it all over again tomorrow.
Feb 26, 2022 Continued with Module 8 practice.
Feb 24, 2022 I think I'm done learning the riff! I'll check back tomorrow to see if I still remember it.
Feb 23, 2022 Continued with the Wish You Were Here riff.
Feb 22, 2022 I've been listening to Wish You Were Here by Pink Floyd in preparation for finishing the riff. I guess it helped a bit? Anyways, almost finished learning the riff and just a few more items are left for the first iteration of Module 1 practice!
Feb 20, 2022 Continued with Module 8 practice.
Feb 19, 2022 Continued with Module 8 practice. I stink at Big G to D chord transitions.
Feb 18, 2022 Memorized all the Stuck 3&4 chords!
Feb 17, 2022 3 days... Anyways, I've finished with all the content and I'll start with the practice tomorrow (for real this time!), it'll probably last ~2 weeks since I'll repeat it.
Feb 13, 2022 Finished with the Wish You Were Here riff video, sort of got the introduction down. Will start the practice soon!
Feb 12, 2022 Finished with Notes in Open Position and got started with the Wish You Were Here riff, the riff is super hard!
Feb 11, 2022 Finished with Pick Manipulation.
Feb 10, 2022 Finished with All Down 8th Note Strumming, really had a lot fun today in this lesson! Strumming can sometimes be fun.
Feb 09, 2022 Finished with Muting Strings Deliberately.
Feb 08, 2022 I have no excuses for not playing guitar for 4 days. Anyways, learnt about a new exercise routine and the Open Em Pentatonic scale.
Feb 04, 2022 Learnt a ton of chord variations. Going to be slightly hard to remember and practice all of them :(
Feb 02, 2022 Finished Module 7 practice. Going to start Grade 2 (in guitar!) on the weekend.
Feb 01, 2022 It's been a while and I finished memorizing two more songs (mainly Mad World) and I only have two more before I finish all my pre-requisites! The memorizing and practising also continued my Module 7 practice.
Jan 28, 2022 Continued with Module 7's practice.
Jan 26, 2022 Finished all the content of the last module for Grade 1 and got started with the practice, this (and the last pre-requisite) should be done in about 2 weeks time.
Jan 25, 2022 Finished all the pre-requisites for Grade 2 except for memorizing the songs, still have 4-ish left.
Jan 24, 2022 We did it! We'll soon be in Grade 2 after I complete the pre-requisites and the practice for this module.
Jan 23, 2022 Learnt about the extra modules that JustinGuitar provides (outside of the grades).
Jan 22, 2022 Learnt more about Dynamics.
Jan 21, 2022 Learnt about open strings between chord changes and feel good strumming.
Jan 20, 2022 Learnt about the best chord changes to practice and air changes.
Jan 19, 2022 Started the last module with a revision on the 8 basic chords.
Jan 18, 2022 Finished with the second iteration of practice (!) and practised Mad World. Will start the last module of Grade 1 tomorrow.
Jan 17, 2022 Continued with the second iteration of practice and Hey Joe. Nearly done.
Jan 16, 2022 Continued with the second iteration of practice and Hey Joe.
Jan 15, 2022 Started the second iteration of practice and added Hey Joe and Mad World to my songbook!
Jan 14, 2022 Finished Module 6 practice and played quite alright for this module's song, Hey Joe.
Jan 13, 2022 Continued with Module 6 practice, I only have the song practice left!
Jan 11, 2022 Continued with Module 6 practice.
Jan 10, 2022 Started with Module 6 practice. After this and the second iteration, I will have moved on to the last module of Grade 1!
Jan 08, 2022 Finished Module 6! Will start the practice soon.
Jan 07, 2022 Learnt a strumming pattern in 6:8 timing and string names.
Jan 06, 2022 Learnt about 6:8 timing.
Jan 05, 2022 Learnt about alternate picking and a variation of the G chord.
Jan 04, 2022 Finished the second iteration of practice and added Black to my songbook!
Jan 03, 2022 Only song practice is left for the second iteration of practice! Also, I am very bad at transitioning from C chord to E chord.
Jan 02, 2021 Continued the second iteration of practice.
Jan 01, 2021 Sorry, I forgot what tomorrow meant, anyways, I started with the second iteration with the odd finger stretching exercise and the riff practice, will continue with the iteration tomorrow...
Dec 29, 2021 Completed the first iteration! Will start the Module 5 practice once again tomorrow.
Dec 28, 2021 Continued with Module 5 practice. Only song practice is left for iteration 1.
Dec 27, 2021 Continued with Module 5 practice.
Dec 26, 2021 Started with Module 5 practice.
Dec 25, 2021 Finished Module 5, will take the next week solely for practice. Also going to build a songbook next week.
Dec 24, 2021 Watched the Songs For Module 5 video and tried my hands at Daft Punk, let's just say that I'll be practising Daft Punk for a while...
Dec 23, 2021 Learnt about music theory and notes in guitar.
Dec 22, 2021 Learnt more about strumming.
Dec 21, 2021 Learnt the Come As You Are riff.
Dec 20, 2021 Finished with Justin's strumming tips.
Dec 18, 2021 Got a little more than half-way through with Justin's strumming tips.
Dec 16, 2021 Learnt the C Chord.
Dec 15, 2021 Finished the second iteration of Module 4 practice and played 505 and Chocolate Jesus! I'll start Module 5 tomorrow.
Dec 13, 2021 Continued with Module 4 practice, nearly done!
Dec 12, 2021 Started with the second iteration of Module 4 practice.
Dec 10, 2021 Finished the first iteration of Module 4 practice, had fun playing 505 and Chocolate Jesus.
Dec 09, 2021 Continued with Module 4 Practice, I'll probably finish with this practice after I do the whole thing twice.
Dec 08, 2021 Website is back up and continued with Module 4 practice.
Dec 06, 2021 Continued with 505 as the website is still broken.
Dec 05, 2021 Sort of freestyled a bit since the website seems to be broken.
Dec 03, 2021 Continued with 505, the strumming pattern is hard to master!
Dec 02, 2021 Continued with 505.
Dec 01, 2021 Started learning 505 by Arctic Monkeys as part of my guitar practice, really nice song.
Nov 30, 2021 Learnt the riff to Sunshine Of Your Love by Cream, hoping to learn much more in December.
Nov 29, 2021 Learnt about the most common strumming patter in guitar.
Nov 28, 2021 Learnt about the metronome in guitar.
Nov 27, 2021 Learnt the D Minor chord, really cool chord! Sounds much moodier than the other minor chords I've learnt.
Nov 25, 2021 Continued with JustinGuitar and learnt about this odd finger stretching exercise.
Nov 22, 2021 Went back to Three Little Birds.
Nov 21, 2021 Freestyled for a bit.
Nov 19, 2021 Easing back into guitar.
Nov 07, 2021 Finishing the whole practice was way too ambitious. I could only get done with the Seven Nation Army riff practice.
Nov 06, 2021 Finished with Three Little Birds, hope to finish Module 3 practice tomorrow.
Nov 05, 2021 Continued with Three Little Birds, the A to E to D transition is really hard.
Nov 04, 2021 Continued with Three Little Birds.
Nov 03, 2021 Practiced Three Little Birds by Bob Marley. Beautiful song!
Nov 02, 2021 Been some time, and learnt the Seven Nation Army riff.
Oct 30, 2021 Learnt about strumming with up strums, and using it after the 2nd beat.
Oct 29, 2021 Learnt about up strums.

Note

I define a project as anything I am actively building, creating or participating in (preparing for a project doesn't count, the project must be actively ongoing before it gets logged). I don't count my content and schoolwork as projects. One-off tasks (such as updating documentation or fixing a small glitch for a previous project) and hobbies really personal to me (such as meditation, running and poetry) also don't count.

Any gaps between logs does not mean that I worked on the project in between, any work done for the project will be logged (unless any special circumstance occurs).

I put links to jargon, tools I use, or anything I think would be cool to read more about! But please note that, unless explicitly stated, I was never paid to mention the link.

I may make spelling, grammar or factual mistakes. I'll probably notice them at the end of my day. If I don't, contact me.

For privacy reasons, I don't mention others who may have worked with me on these projects (unless I asked them first or their role was public), some projects with their logs may come later and I may also come off a bit vague at times.

There'll be a lot of exceptions in this note (with many more spelling and grammar mistakes), but regardless, I hope you find these logs inspiring!

Table of Contents

Active

Completed

Retroactive

Archive

Navigation Tips

Active (before becoming defunct)

Log

Log

Completed

Summary

Log

Log

Log

Log

Log

Log

Log

Dioptra

Log

Retrospective

Log

Internship @ DPS Sharjah

Retrospective

Log

Ocean Busters

Log

GMAMUN Jr.'24

Summary

Student Council - 12th + Head of Events

Log

AUS CSE Research Assistant

Log

Advent of Code 2023

Log

Gratis 2023

Summary

DXBMUN 2023

Summary

NMSMUN 2023

Summary

Project: Unboxed

Summary

Log

Arjun's AI Escapades Class

RTA Hackathon

Summary

SOLARIS (Third Edition)

Mathematics for Machine Learning

Log

YCM Youth Meet-up

Summary

Machine Learning Safety Course

Summary

SOLARIS (Second Edition)

Log

GFSMUN III

Summary

Local Hackathon 2023

Summary

YGSS 2023

Summary

Log

National Maths Competition

Summary

Student Council - 11th

Summary

ADMUN 2023

Log

Log

Middle School CS Event

Log

Advent of Code (PyTech)

Log

Cold Takes Beta Reading

Log

Log

Log

Winter Computing Camp

Log