tatsuyax25

/**
 * @param {number} k
 * @return {number}
 */
var smallestRepunitDivByK = function(k) {
    // Step 1: Handle impossible cases
    // Any number made only of '1's is odd and not divisible by 2 or 5.
    // So if k has a factor of 2 or 5, return -1 immediately.
    if (k % 2 === 0 || k % 5 === 0) {
        return -1;

tatsuyax25

/**
 * @param {number[]} nums
 * @return {boolean[]}
 */
var prefixesDivBy5 = function(nums) {
    // Result array to store true/false for each prefix
    let answer = [];

    // We'll keep track of the current number modulo 5
    // This avoids dealing with huge binary numbers directly

tatsuyax25

/**
 * @param {number[]} nums
 * @return {number}
 */
var maxSumDivThree = function(nums) {
    // Step 1: Calculate the total sum of the array
    let totalSum = nums.reduce((acc, num) => acc + num, 0);

    // Step 2: If already divisible by 3, return it
    if (totalSum % 3 === 0) return totalSum;

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.