def solve(s):
    def is_palindrome(t):
        return t == t[::-1]
    
    n, evens, odds = len(s), 0, 0

    for i in range(n):
        for j in range(i + 1, n + 1):
            sub, k, merged = s[i:j], 0, ''
            while k < len(sub):
                if k + 1 < len(sub) and sub[k] == sub[k + 1]:
                    merged += sub[k]
                    k += 2
                else:
                    merged += sub[k]
                    k += 1
            if is_palindrome(merged):
                if (j - i) % 2 == 0:
                    evens += 1
                else:
                    odds += 1
    return [evens, odds]

#include <stdio.h>
#include <regex.h>
int isPowerOfTwo(const char *binaryString) {
    regex_t regex;
    int result;
    result = regcomp(&regex, "^0*10*$", REG_EXTENDED);
    if (result) {
        printf("Could not compile regex\n");
        return 0;
    }
    result = regexec(&regex, binaryString, 0, NULL, 0);
    regfree(&regex);
    if (!result) {
        return 1;
    } else {
        return 0;
    }
}

int main() {
    int t;
    char binaryString[1000]; 
    scanf("%d", &t);
    while (t--) {
        scanf("%s", binaryString);
        if (isPowerOfTwo(binaryString)) {
            printf("True\n");
        } else {
            printf("False\n");
        }
    }

    return 0;
}

string largestMagical(string binString) {
    if (binString.empty()) return binString;
    vector<string> ans;
    int cnt = 0, j = 0;
    for (int i = 0; i < binString.size(); ++i) {
        cnt += binString[i] == '1' ? 1 : -1;
        if (cnt == 0) {
            ans.push_back("1" + largestMagical(binString.substr(j + 1, i - j - 1)) + "0");
            j = i + 1;
        }
    }
    sort(ans.begin(), ans.end(), greater<string>());
    return accumulate(ans.begin(), ans.end(), string{});
}

def toolchanger(tools, start_index, target):
    n = len(tools)
    target_index = -1

    for i in range(n):
        if tools[i] == target:
            target_index = i
            break

    right_moves = (target_index - start_index + n) % n
    left_moves = (start_index - target_index + n) % n

    return min(right_moves, left_moves)

Check your mails ✅

import math

def largestAdjacentLCM(arr):
    lcm = lambda x, y: abs(x*y) // math.gcd(x, y)
    return max(lcm(arr[i], arr[i+1]) for i in range(len(arr) - 1))