tatsuyax25

/**
 * @param {number[]} nums
 * @return {number}
 */
var minimumOperations = function(nums) {
    // Initialize a counter to keep track of total operations
    let operations = 0;

    // Loop through each number in the array
    for (let num of nums) {

tatsuyax25

/**
 * Finds the minimum number of integers needed so that
 * each interval contains at least two chosen numbers.
 *
 * @param {number[][]} intervals - Array of [start, end] intervals
 * @return {number} - Minimum number of integers chosen
 */
var intersectionSizeTwo = function(intervals) {
    // Step 1: Sort intervals
    // - Primary: by end ascending (smaller right boundary first)

tatsuyax25

/**
 * @param {number[]} nums
 * @param {number} original
 * @return {number}
 */
var findFinalValue = function(nums, original) {
    // Step 1: Convert nums into a Set for faster lookups.
    // Why? Searching in an array is O(n), but in a Set it's O(1).
    let numSet = new Set(nums);

tatsuyax25

/**
 * @param {number[]} bits
 * @return {boolean}
 */
var isOneBitCharacter = function(bits) {
    // Start from the first bit
    let i = 0;

    // Traverse until the second-to-last bit
    // (because the last bit is always 0, we want to see if it's consumed or not)

tatsuyax25

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {boolean}
 */
var kLengthApart = function(nums, k) {
    // Keep track of the index of the last '1' we saw
    let lastOneIndex = -1;

    // Loop through the array

tatsuyax25

/**
 * @param {string} s
 * @return {number}
 */
var numSub = function(s) {
    const MOD = 1_000_000_007; // Large prime for modulo operations
    let ans = 0;               // Final answer accumulator
    let run = 0;               // Current streak length of consecutive '1's

    for (let i = 0; i < s.length; i++) {

tatsuyax25

/**
 * @param {string} s
 * @return {number}
 */
let numberOfSubstrings = function (s) {
    const n = s.length;

    // dp[i] stores the nearest index <= i where a '0' occurs
    // (or -1 if none). This helps us quickly jump backwards
    // to substrings that include more zeros.

tatsuyax25

/**
 * @param {number} n
 * @param {number[][]} queries
 * @return {number[][]}
 */
var rangeAddQueries = function(n, queries) {
    // Step 1: Initialize an n x n matrix filled with 0s
    let mat = Array.from({ length: n }, () => Array(n).fill(0));

    // Step 2: Process each query

tatsuyax25

/**
 * Calculates the maximum number of operations that can be performed
 * on a binary string `s`. An operation is defined as pairing a '1'
 * with the end of a block of consecutive '0's.
 *
 * @param {string} s - Input binary string consisting of '0' and '1'
 * @return {number} - Maximum number of operations possible
 */
var maxOperations = function (s) {
    const n = s.length;   // Length of the string

tatsuyax25

/**
 * @param {number[]} nums
 * @return {number}
 */
var minOperations = function(nums) {
    // Step 1: Quick checks for trivial cases
    // If the array already contains a 1, spreading it is possible.
    // If the gcd of the entire array > 1, it's impossible to ever reach 1.
    
    const gcd = (a, b) => {