def longest_substring(s):
    def is_odd(digit):
        return int(digit) % 2 == 1

    longest = ''
    current = s[0]

    for i in range(1, len(s)):
        if is_odd(s[i-1]) != is_odd(s[i]):
            current += s[i]
            if len(current) > len(longest):
                longest = current
        else:
            current = s[i]

    return longest

# Test cases
print(longest_substring("225424272163254474441338664823"))  # ➞ "272163254"
print(longest_substring("594127169973391692147228678476"))  # ➞ "16921472"
print(longest_substring("721449827599186159274227324466"))  # ➞ "7214"				
			
		

function caesarCipher(s, k) {
    // Normalize k to be within 0-25
    k = k % 26;

    let result = '';

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

        // Check if it's an uppercase letter
        if (charCode >= 65 && charCode <= 90) {
            result += String.fromCharCode((charCode - 65 + k) % 26 + 65);
        }
        // Check if it's a lowercase letter
        else if (charCode >= 97 && charCode <= 122) {
            result += String.fromCharCode((charCode - 97 + k) % 26 + 97);
        }
        // If it's not a letter, just append it as is
        else {
            result += s[i];
        }
    }

    return result;
}

// Test cases
console.log(caesarCipher("middle-Outz", 2));  // ➞ "okffng-Qwvb"
console.log(caesarCipher("Always-Look-on-the-Bright-Side-of-Life", 5));  // ➞ "Fqbfdx-Qttp-ts-ymj-Gwnlmy-Xnij-tk-Qnkj"
console.log(caesarCipher("A friend in need is a friend indeed", 20));  // ➞ "U zlcyhx ch hyyx cm u zlcyhx chxyyx"				
			
		

#include <iostream>
#include <string>
#include <stack>

std::string spaceMessage(const std::string& encrypted) {
    std::stack<int> countStack;
    std::stack<std::string> stringStack;
    int count = 0;
    std::string currentString = "";
    std::string result = "";

    for (char c : encrypted) {
        if (isdigit(c)) {
            count = count * 10 + (c - '0');
        } else if (c == '[') {
            countStack.push(count);
            stringStack.push(currentString);
            count = 0;
            currentString = "";
        } else if (c == ']') {
            int repeatCount = countStack.top();
            countStack.pop();
            std::string temp = currentString;
            currentString = stringStack.top();
            stringStack.pop();
            for (int i = 0; i < repeatCount; ++i) {
                currentString += temp;
            }
        } else {
            currentString += c;
        }
    }

    result += currentString;
    return result;
}

int main() {
    std::cout << spaceMessage("ABCD") << std::endl;          // Output: "ABCD"
    std::cout << spaceMessage("AB[3CD]") << std::endl;       // Output: "ABCDCDCD"
    std::cout << spaceMessage("IF[2E]LG[5O]D") << std::endl; // Output: "IFEELGOOOOOD"
    return 0;
}				
			
		

#include <iostream>
#include <vector>
#include <stack>
using namespace std;

vector<int> asteroidCollision(vector<int>& asteroids) {
    stack<int> st;
    for (int asteroid : asteroids) {
        bool destroyed = false;
        while (!st.empty() && asteroid < 0 && st.top() > 0) {
            if (st.top() < -asteroid) {
                st.pop();
                continue;
            } else if (st.top() == -asteroid) {
                st.pop();
            }
            destroyed = true;
            break;
        }
        if (!destroyed) {
            st.push(asteroid);
        }
    }

    vector<int> result(st.size());
    for (int i = st.size() - 1; i >= 0; --i) {
        result[i] = st.top();
        st.pop();
    }
    return result;
}

int main() {
    vector<int> asteroids1 = {-2, -1, 1, 2};
    vector<int> result1 = asteroidCollision(asteroids1);
    for (int asteroid : result1) {
        cout << asteroid << " ";
    }
    cout << endl;

    vector<int> asteroids2 = {-2, 1, 1, -2};
    vector<int> result2 = asteroidCollision(asteroids2);
    for (int asteroid : result2) {
        cout << asteroid << " ";
    }
    cout << endl;

    vector<int> asteroids3 = {1, 1, -2, -2};
    vector<int> result3 = asteroidCollision(asteroids3);
    for (int asteroid : result3) {
        cout << asteroid << " ";
    }
    cout << endl;

    vector<int> asteroids4 = {10, 2, -5};
    vector<int> result4 = asteroidCollision(asteroids4);
    for (int asteroid : result4) {
        cout << asteroid << " ";
    }
    cout << endl;

    vector<int> asteroids5 = {8, -8};
    vector<int> result5 = asteroidCollision(asteroids5);
    for (int asteroid : result5) {
        cout << asteroid << " ";
    }
    cout << endl;

    return 0;
}				
			
		

#include <iostream>
#include <string>

std::string caesarCipher(const std::string& s, int k) {
    // Normalize k to be within 0-25
    k = k % 26;

    std::string result;
    for (char c : s) {
        if (isupper(c)) {
            // Shift uppercase letters
            result += (c - 'A' + k + 26) % 26 + 'A';
        } else if (islower(c)) {
            // Shift lowercase letters
            result += (c - 'a' + k + 26) % 26 + 'a';
        } else {
            // Non-alphabetic characters are not changed
            result += c;
        }
    }
    return result;
}

int main() {
    std::cout << caesarCipher("middle-Outz", 2) << std::endl;  // Output: "okffng-Qwvb"
    std::cout << caesarCipher("Always-Look-on-the-Bright-Side-of-Life", 5) << std::endl;  // Output: "Fqbfdx-Qttp-ts-ymj-Gwnlmy-Xnij-tk-Qnkj"
    std::cout << caesarCipher("A friend in need is a friend indeed", 20) << std::endl;  // Output: "U zlcyhx ch hyyx cm u zlcyhx chxyyx"

    return 0;
}