learning

How I use lecture notes, questions, retrieval, and revision to make AI-assisted writing part of studying

How a support vector machine chooses a decision boundary by maximizing its margin

A Python matrix simulation using direction vectors and in-place visit markers

An O(n²) Python DP solution that tracks the longest increasing subsequence ending at each index

Closing my Codeit AI Engineer Sprint chapter early after accepting an AI agent engineering role

How accuracy, recall, precision, and F1 expose different kinds of classification errors

A WordDictionary implementation using a Trie for storage and DFS for wildcard search

How decision trees choose splits, why they overfit, and how voting, bagging, and boosting address their weaknesses

A Python two-pointer solution that moves the height limiting the current area

How classification models measure probability errors and learn from them

A Python stack solution that validates bracket type and closing order

Implementing a Trie with fixed 26-child nodes and an is_end marker

A Python dynamic programming solution for checking whether a string can be segmented by a word dictionary

Encoding and restoring a list of strings by recording each string's length and a delimiter

The third weekly paper on decision trees, major boosting models, and the difference between PCA and factor analysis

Why linear regression is unsuitable for classification and how logistic regression separates classes with probabilities

Grouping anagram strings by using each sorted string as the hash map key

A Codeit mission on reading feature context, outliers, and model behavior in Kaggle's Bike Sharing Demand data

How feature scale affects model training and why Ridge, Lasso, and Elastic Net depend on comparable inputs

A one-pass Python solution that tracks the lowest earlier price to calculate maximum profit

The second weekly paper on how machine-learning models learn, fail to generalize, and are evaluated

The main ways machine-learning systems learn from data and how they differ

A Python DFS and memoization solution that stores the minimum coin count for each remaining amount

A Python DFS and backtracking solution that marks visited board cells in place

How vectors, matrices, and linear systems connect to machine-learning inputs and weight calculations

A Python binary search solution for the minimum value in a rotated sorted array

The first weekly paper on the mathematical language of machine learning and the preparation of data for analysis

A Python DFS solution that compares the depths of the left and right subtrees

Reviewing how descriptive statistics and visualizations explain center, spread, and distribution shape

A Python solution that merges two sorted linked lists with a dummy node and moving pointers

A Python recursion and memoization solution that counts valid one-digit and two-digit decodings

A Python solution using Kadane's algorithm to find the maximum sum of a contiguous subarray

A Python backtracking solution to Combination Sum using a start index and pruning

A lesson note on filtering data, creating values, and aggregating groups with Pandas

A first pass through selecting, combining, and cleaning tabular data with Pandas

A lesson note on vectors, matrices, NumPy arrays, shape, axis, and basic array operations

A Python solution that counts 1 bits by repeatedly dividing by 2

A two-pointer Python solution for checking palindromes after normalizing alphanumeric characters

Notes on Python sequences, file I/O, duplicate removal using sets, and OOP fundamentals covered in the second class of Codeit Sprint Main Course.

A DFS Python solution for checking whether a BST is built with valid value ranges

A first-class Codeit Sprint note on data science, MLOps, and Python basics.

A 3Sum solution using sorting and a two-sum-style hash map approach.

A left-product and right-product solution for Product of Array Except Self.

A recursion and memoization write-up for the Climbing Stairs problem.

A learning note on how hypothesis functions, loss functions, partial derivatives, and gradient vectors lead to gradient descent.

A comparison of sorting and character counting for the Valid Anagram problem.

Solving the rob-or-skip choice with top-down DP and memoization

Using a set to count each consecutive sequence only from its starting point

Using frequency counting and bucket arrays to return the top k frequent elements

Comparing brute force, two-pass hash map, and one-pass hash map approaches for Two Sum

Comparing brute force, sorting, and hash set approaches for duplicate detection

Solving BST range sum through BFS, DFS, and prefix sums

A learning note on linear regression, mean squared error, and why the loss function takes theta as input.

A learning note on partial derivatives and gradients from a machine learning fundamentals course

A Codeit AI Engineer Sprint note on reviewing functions, rates of change, and the basic idea behind derivatives

Why a modified Bellman-Ford approach fits the K-stop constraint better, and some implementation notes

A summary of matrix addition, scalar multiplication, matrix multiplication, element-wise multiplication, and NumPy operations

Reviewing the fundamentals of machine learning and introductory linear algebra in the Codeit pre-course.

A Codeit AI Engineer Sprint pre-course note on dictionary view objects, string immutability, and Python indexing

A short Codeit AI Engineer Sprint pre-course note on revisiting Python lists and for loops

A short note from the Codeit AI Engineer Sprint pre-course on reviewing Python basics, PEP 8, and scope

Returning to a structured learning routine to keep growing as a hands-on engineer in the AI era