tatsuyax25

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root

tatsuyax25

/**
 * @param {number[]} nums
 * @return {number}
 */
var sumFourDivisors = function(nums) {
    // Helper: return the sum of divisors of n if it has exactly 4 divisors.
    // Otherwise return 0.
    function sumIfFourDivisors(n) {
        let count = 0; // how many divisors we've found
        let sum = 0;   // sum of those divisors

tatsuyax25

/**
 * @param {number} n
 * @return {number}
 */
var numOfWays = function(n) {
    const MOD = 1_000_000_007;

    // a = number of ABC patterns for the current row
    // b = number of ABA patterns for the current row
    let a = 6;  // ABC has 6 permutations

tatsuyax25

/**
 * @param {number[]} nums
 * @return {number}
 */
var repeatedNTimes = function(nums) {
    // We'll use a Set to track which numbers we've seen.
    const seen = new Set();
    
    // Walk through each number in the array
    for (let num of nums) {

tatsuyax25

/**
 * @param {number[]} digits
 * @return {number[]}
 */
var plusOne = function(digits) {
    // Start from the last digit and move left
    for (let i = digits.length - 1; i >= 0; i--) {

        // If the current digit is less than 9, we can safely increment it
        // and return immediately because no carry is needed.

tatsuyax25

/**
 * @param {number} row
 * @param {number} col
 * @param {number[][]} cells
 * @return {number}
 */
var latestDayToCross = function(row, col, cells) {
    // Helper: check if it's possible to cross on a given day
    function canCross(day) {
        // Build a grid where 1 = water, 0 = land

tatsuyax25

/**
 * @param {string} bottom
 * @param {string[]} allowed
 * @return {boolean}
 */
var pyramidTransition = function(bottom, allowed) {
    // STEP 1: Build a mapping from (left,right) -> list of possible tops
    // Example: "ABC" means A+B -> C
    const map = new Map();
    for (let pattern of allowed) {

tatsuyax25

/**
 * @param {number[][]} grid - A 2D matrix sorted in non-increasing order
 * @return {number} - Total count of negative numbers in the matrix
 */
var countNegatives = function (grid) {
    let count = 0;

    // Loop through each row
    for (let row = 0; row < grid.length; row++) {

tatsuyax25

/**
 * Given a string of 'Y' (customer arrives) and 'N' (no customer),
 * find the hour to close the shop that minimizes penalty.
 *
 * Penalty rules:
 * - Staying open while no customers come → +1 penalty for each 'N'
 * - Closing early while customers would have come → +1 penalty for each 'Y'
 *
 * @param {string} customers
 * @return {number}

tatsuyax25

/**
 * @param {number[]} apple
 * @param {number[]} capacity
 * @return {number}
 */
var minimumBoxes = function(apple, capacity) {
    // 1. Compute the total number of apples across all packs.
    // Since aplles can be split across boxes, only the total matters.
    let totalApples = 0;
    for (let a of apple) {