AlgoPractice.js

console.log("Starting AlgoPractice.js");

// Two Sum
function twoSum(numbers, target) {
    for (let i = 0; i < numbers.length; i++) {
        for (let j = i + 1; j < numbers.length; j++) {
            if (numbers[i] + numbers[j] === target && i !== j) {
                return [i, j];
            }
        }
    }
}
console.log(`${twoSum([2, 7, 11, 15], 9)}`);  // [0, 1]
console.log(`${twoSum([2, 7, 11, 15], 17)}`); // [0, 3]
console.log(`${twoSum([2, 7, 11, 15], 22)} \n`); // [1, 3]


// Move Zeros
function moveZeros(nums) {
    let maxIndex = nums.length - 1;

    for (let i = 0; i < maxIndex; i++) {
        if (nums[i] === 0) {
            nums.push(nums.splice(i, 1)[0]);
            i--; // Decrement to re-check the same index
            maxIndex--; // If we dont decrment maxIndex we will go out of bounds 
        }
    }
    return nums;
}

function moveZeroesTwoPointer(nums) {
    let left = 0; // Points to the position for the next non-zero element

    for (let right = 0; right < nums.length; right++) {
        if (nums[right] !== 0) {
            // Swap the current non-zero element with the element at 'left'
            [nums[left], nums[right]] = [nums[right], nums[left]];
            left++;
        }
    }
    return nums;
};
console.log(`${moveZeros([0, 1, 0, 3, 12])}`); // [1, 3, 12, 0, 0]
console.log(`${moveZeros([2, 1, 3, 4, 0])}`); 
console.log(`${moveZeros([3, 1, 4, 3, 12])}`); 
console.log(`${moveZeros([0, 1, 0, 0, 3, 12])}`); 
console.log(`${moveZeroesTwoPointer([0, 1, 0, 3, 12])} \n`); 


// Find the Second Largest Element in an Array
function findSecondLargest(nums) {
    if (nums.length < 2) return -1;

    let first = -Infinity;
    let second = -Infinity;

    for (const num of nums) {
        if (num > first) {
            second = first;
            first = num;
        }
        else if (num < first && num > second) second = num;
    }

    return second === -Infinity ? -1 : second;
}
console.log(`${findSecondLargest([1, 2, 3, 4, 5])}`);      // 4
console.log(`${findSecondLargest([6, 5, 3, 2, 1])}`);      // 5
console.log(`${findSecondLargest([5, 5])}`);               // -1
console.log(`${findSecondLargest([3, 5, 5])}`);            // 3
console.log(`${findSecondLargest([3, 5, 2, 8, 6])} \n`);   // 6


// Contains Duplicate
function containsDuplicate(nums) {
    const set = new Set();

    for (let num of nums) {
        if (set.has(num)) return true;
        set.add(num);
    }
    return false;
}
console.log(`${containsDuplicate([1, 2, 3, 1])}`);
console.log(`${containsDuplicate([1, 2, 3, 4])} \n`);


// Longest Substring Without Repeating Characters
function longestSubstring(s) {
    const set = new Set();

    let left = 0;
    let longestCount = 0;

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

        while (set.has(s[right])) {
            set.delete(s[left]);
            left++;
        }
        set.add(s[right]);
        longestCount = Math.max(longestCount, right - left + 1);
    }

    return longestCount;
}
console.log(`${longestSubstring("abcabcbb")}`);
console.log(`${longestSubstring("bbbbb")}`);
console.log(`${longestSubstring("abcbde")}`);
console.log(`${longestSubstring("aaaabbcccc")} \n`);


// Anagram Check
function isAnagram(s, t) {
    if (s.length !== t.length) return false;

    const charMap = new Map();

    for (const char of s) {
        charMap.set(char, (charMap.get(char) || 0) + 1); // Increment the count for each character found in s
    }

    for (const char of t) {
        if (!charMap.has(char) || charMap.get(char) === 0) return false;

        charMap.set(char, charMap.get(char) - 1); // Now decrement to check for differences in character count
    }

    return true;
}

console.log(isAnagram("anagram", "nagaram"));  // true
console.log(isAnagram("anagram", "nagarama")); // false
console.log(`${isAnagram("rat", "car")} \n`);  // false


//  Remove Adjacent Duplicates
function removeAdjacentDuplicates(input) {
    const stack = [];

    for (const char of input) {
        if (stack.length > 0 && stack[stack.length - 1] === char) stack.pop();
        else stack.push(char);
    }
    return stack.join("");
}

console.log(removeAdjacentDuplicates("abbaca"));         // "ca"
console.log(`${removeAdjacentDuplicates("azxxzy")} \n`); // "ay"


// Reverse the First K Elements of a Queue
function reverseFirstK(queue, k) {
    if (k < 0 || k > queue.length) return queue;

    const outputQueue = [];

    for (var i = k - 1; i >= 0; i--) {
        outputQueue.push(queue[i]);
    }
    outputQueue.push(...queue.slice(k)); // Add the remaining elements after the first k elements   
    return outputQueue;
}

function reverseFirstKWithQueue(items, k) { // Seems slower but I think this is what the question was asking for??
    if (k < 0 || k > items.length) return items;

    const queue = [...items];
    const stack = [];

    for (let i = 0; i < k; i++) {
        stack.push(queue.shift());
    }

    const result = [];

    while (stack.length > 0) {
        result.push(stack.pop());
    }

    result.push(...queue);
    return result;
}

console.log(reverseFirstK([1, 2, 3, 4, 5], 3)); // Output → [3, 2, 1, 4, 5]
console.log(reverseFirstKWithQueue([1, 2, 3, 4, 5], 3)); // Output → [3, 2, 1, 4, 5]