const longestPalindrome = (s) => {
    if(s.length === 1) return s
    
    const odd = longestOddPalindrome(s)
    const even = longestEvenPalindrome(s)
    
    
    if(odd.length >= even.length) return odd
    if(even.length > odd.length) return even
};

const longestOddPalindrome = (s) => {    
    let longest = 0
    let longestSubStr = ""
    
    for(let i = 1; i < s.length; i++) {
        
        let currentLongest = 1
        let currentLongestSubStr = ""
        let left = i - 1
        let right = i + 1
        
        while(left >= 0 && right < s.length) {
            const leftLetter = s[left]
            const rightLetter = s[right]

            left--
            right++

            if(leftLetter === rightLetter) {
                currentLongest += 2
                currentLongestSubStr = s.slice(left+1, right)
            } else break
        }
        
                        
        if(currentLongest > longest) {
            if(currentLongestSubStr) longestSubStr = currentLongestSubStr 
            else longestSubStr = s[i]
            longest = currentLongest
        }
    }
    
    return longestSubStr
}

const longestEvenPalindrome = (s) => {    
    let longest = 0
    let longestSubStr = ""
    
    for(let i = 0; i < s.length - 1; i++) {
        if(s[i] !== s[i+1]) continue;
        
        let currentLongest = 2
        let currentLongestSubStr = ""
        let left = i - 1
        let right = i + 2
        
        while(left >= 0 && right < s.length) {
            const leftLetter = s[left]
            const rightLetter = s[right]

            left--
            right++
            
            if(leftLetter === rightLetter) {
                currentLongest += 2
                currentLongestSubStr = s.slice(left+1, right)
            } else break
        }
                
                
        if(currentLongest > longest) {
            if(currentLongestSubStr) longestSubStr = currentLongestSubStr
            else longestSubStr = s[i] + s[i+1]
    
            longest = currentLongest
        }
    }
    
    return longestSubStr
}
console.log(longestPalindrome("babad"))

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
var twoSum = function(nums, target) {
    for(let i = 0; i < nums.length; i++) {
        for(let j = 0; j < nums.length; j++) {
            if(nums[i] + nums[j] === target && i !== j) {
                return [i, j]
            }
        }
    }
};

// There are n rings and each ring is either red, green, or blue. The rings are distributed across ten rods labeled from 0 to 9.

// You are given a string rings of length 2n that describes the n rings that are placed onto the rods. Every two characters in rings forms a color-position pair that is used to describe each ring where:

// The first character of the ith pair denotes the ith ring's color ('R', 'G', 'B').
// The second character of the ith pair denotes the rod that the ith ring is placed on ('0' to '9').
// For example, "R3G2B1" describes n == 3 rings: a red ring placed onto the rod labeled 3, a green ring placed onto the rod labeled 2, and a blue ring placed onto the rod labeled 1.

// Return the number of rods that have all three colors of rings on them.


let rings = "B0B6G0R6R0R6G9";
var countPoints = function(rings) {
    
    let sum = 0;
    
	// Always 10 Rods
    for (let i = 0; i < 10; i++) {
        if (rings.includes(`B${i}`) && rings.includes(`G${i}`) && rings.includes(`R${i}`)) {
            sum+=1;
        }
    }
    
    return sum;
    
};

console.log(countPoints(rings));

const geometricProgression = (end, start = 1, step = 2) =>
  Array.from({
    length: Math.floor(Math.log(end / start) / Math.log(step)) + 1,
  }).map((_, i) => start * step ** i);
  
geometricProgression(256); // [1, 2, 4, 8, 16, 32, 64, 128, 256]
geometricProgression(256, 3); // [3, 6, 12, 24, 48, 96, 192]
geometricProgression(256, 1, 4); // [1, 4, 16, 64, 256]

alert("bruh")

const toFixed = (n, fixed) => ~~(Math.pow(10, fixed) * n) / Math.pow(10, fixed);
// Examples
toFixed(25.198726354, 1);       // 25.1
toFixed(25.198726354, 2);       // 25.19
toFixed(25.198726354, 3);       // 25.198
toFixed(25.198726354, 4);       // 25.1987
toFixed(25.198726354, 5);       // 25.19872
toFixed(25.198726354, 6);       // 25.198726