tatsuyax25

/**
 * @param {string[]} words
 * @param {number[]} groups
 * @return {string[]}
 */
var getLongestSubsequence = function(words, groups) {
    if (!words.length) return []; // If words array is empty, return an empty array

    let result = [words[0]]; // Start with the first word in the sequence
    let prevGroup = groups[0]; // Track the previous group value

tatsuyax25

/**
 * Computes the length of the transformed string after t transformations.
 * @param {string} s - Input string consisting of lowercase English letters.
 * @param {number} t - Number of transformations to apply.
 * @param {number[]} nums - Array of size 26, mapping each letter to its transformation size.
 * @returns {number} - Length of the resulting string modulo 10^9 + 7.
 */
function lengthAfterTransformations(s, t, nums) {
  const MOD = 1000000007n; // Large prime number for modulo operations
  const bigT = BigInt(t); // Convert `t` to BigInt to handle large values

tatsuyax25

/**
 * @param {string} s
 * @param {number} t
 * @return {number}
 */
var lengthAfterTransformations = function(s, t) {
    const MOD = 1000000007;
    const n = s.length;

    // Step 1: Count occurrences of each character in 's'

tatsuyax25

/**
 * Finds all three-digit even numbers that can be formed using the given digits.
 * @param {number[]} digits - An array of digits (0-9).
 * @return {number[]} - An array of unique three-digit even numbers.
 */
var findEvenNumbers = function(digits) {
    const arr = []; // Stores valid even numbers
    const ct = Array(10).fill(0); // Count occurrences of each digit (0-9)

    // Count frequency of digits in the input array

tatsuyax25

/**
 * Function to determine the maximum possible sum by replacing zeros
 * in either of the given arrays.
 * 
 * @param {number[]} nums1 - First array of numbers
 * @param {number[]} nums2 - Second array of numbers
 * @return {number} - Maximum possible sum or -1 if impossible
 */
var minSum = function(nums1, nums2) {
    let zeroCount1 = 0; // Count of zeros in nums1

tatsuyax25

/**
 * Function to count the number of distinct balanced permutations of a given number string.
 * A permutation is balanced if the sum of digits at even indices equals the sum at odd indices.
 * 
 * @param {string} num - Input string consisting of digits.
 * @returns {number} - Number of balanced permutations modulo 10^9 + 7.
 */
var countBalancedPermutations = function(num) {
    const MOD = 1000000007;
    const n = num.length;

tatsuyax25

/**
 * @param {number[][]} moveTime
 * @return {number}
 */
var minTimeToReach = function(moveTime) {
    const n = moveTime.length, m = moveTime[0].length;

    // Distance array initialized with Infinity, representing minimum time to reach each cell
    const d = Array.from({ length: n }, () => Array(m).fill(Infinity));

tatsuyax25

/**
 * Finds the minimum time required to reach the bottom-right cell of the grid.
 * Each cell contains a time constraint that dictates the earliest possible arrival.
 *
 * @param {number[][]} moveTime - A 2D array representing the minimum time required 
 *                                to step into each cell.
 * @return {number} - The minimum time required to reach the last cell, or -1 if unreachable.
 */
var minTimeToReach = function(moveTime) {
    const rows = moveTime.length;

tatsuyax25

/**
 * @param {number[]} nums
 * @return {number[]}
 */
var buildArray = function(nums) {
    let ans = []; // Initialize an empty array to store the result

    // Iterate through each index in the `nums` array
    for (let i = 0; i < nums.length; i++) {
        ans.push(nums[nums[i]]); // Push the element from `nums` at the index specified by `nums[i]`

tatsuyax25

/**
 * Calculates the number of ways to tile a 2 × n board using dominos and trominos.
 * @param {number} n - The width of the board.
 * @return {number} - The number of valid tilings, modulo 10^9 + 7.
 */
var numTilings = function (n) {
    const MOD = 1e9 + 7; // Modulo constraint to prevent overflow

    // Base cases for small values of n
    if (n === 1) return 1; // Only one vertical domino fits