def mystery(x):
if not isinstance(x, str) or len(x) != 2**2:
return False
e = [77, 89, 67, 70]
k = ord('*')
for i in range(len(e)):
if ord(x[i]) != e[i] ^ (k + i):
return False
return True
def mystery(x):
if not isinstance(x, str):
return False
if len(x) != 6:
return False
if not x.isdigit():
return False
num_val = int(x)
# Condition 1: Divisibility check
# The number 1547 is the product of three distinct prime numbers.
if num_val % 1547 != 0:
return False
# Condition 2: Weighted sum of digits
weighted_sum = 0
for i, digit_char in enumerate(x):
weighted_sum += int(digit_char) * (i + 1)
# Condition 3: Comparison with a derived value
# The number 1323 is the product of powers of two distinct prime numbers.
if weighted_sum != num_val // 1323:
return False
return True
def mystery(x):
if not isinstance(x, str): return False
if len(x) != 2 + 3: return False
if not x.isdigit(): return False
if x[0] != str(1): return False
num = int(x)
if num % (2**4 + 1) != 2**3: return False
if num % (2**3 + 5) != 2**2 + 1: return False
if num % (3**2 + 2) != 3: return False
if num % (2**2 + 3) != 1: return False
return True
def mystery(x):
if not isinstance(x, str):
return False
if len(x) != 7:
return False
numeric_parts_str = ""
letter_parts_sum = 0
# Validate character pattern and extract parts
for i, char in enumerate(x):
if i % 2 == 0: # Even index (0, 2, 4, 6) must be a digit
if not char.isdigit():
return False
numeric_parts_str += char
else: # Odd index (1, 3, 5) must be an uppercase letter
if not char.isalpha() or not char.isupper():
return False
letter_parts_sum += ord(char) # Sum ASCII values of letters
num_val = int(numeric_parts_str)
# Condition 1: The number formed by the digits must not contain '0'
if '0' in numeric_parts_str:
return False
# Condition 2: The sum of the digits of `num_val` must be a perfect square
sum_digits_num_val = sum(int(d) for d in numeric_parts_str)
# Check if sum_digits_num_val is a perfect square
if sum_digits_num_val < 0: # Should not happen for sums of digits
return False
sqrt_sum = int(sum_digits_num_val**0.5)
if sqrt_sum * sqrt_sum != sum_digits_num_val:
return False
# Condition 3: `num_val` must be a Niven (or Harshad) number
# A Niven number is an integer that is divisible by the sum of its digits.
if num_val % sum_digits_num_val != 0:
return False
# Condition 4: A bitwise XOR checksum
# The magic number 1205 is a specific constant.
magic_number = 1205
if (num_val ^ letter_parts_sum) != magic_number:
return False
return True
def mystery(x):
if not isinstance(x, str): return False
if len(x) != 6: return False
if not x.isdigit(): return False
num = int(x)
if num % (1 + 1) != 0: return False
if num % (4**2 + 1) != 2**2 + 1: return False
if num % (2 + 1) != 2**0: return False
if num % (5**2 - 2) != 3**2 + 2: return False
if num % (4**2 + 3) != 2**3 - 1: return False
if num % (5**2 + 4) != 3**2 + 4: return False
return True
def mystery(x):
# Helper functions
def is_prime(n):
if n < 2: return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0: return False
return True
def is_fibonacci(n):
if n < 0: return False
# A number N is Fibonacci if 5*N^2 + 4 or 5*N^2 - 4 is a perfect square
def is_perfect_square_local(num):
if num < 0: return False
sqrt = int(num**0.5)
return sqrt * sqrt == num
return is_perfect_square_local(5 * n * n + 4) or is_perfect_square_local(5 * n * n - 4)
def is_perfect_square(n):
if n < 0: return False
sqrt = int(n**0.5)
return sqrt * sqrt == n
# Condition 0: Type and Length
if not isinstance(x, str):
return False
if len(x) != 8:
return False
# Condition 1: Character type and position validation
# x[0], x[7] must be digits
# x[1], x[6] must be lowercase letters
# x[2], x[5] must be uppercase letters
# x[3], x[4] must be non-alphanumeric, non-whitespace special characters, and different
if not (x[0].isdigit() and x[7].isdigit()): return False
if not (x[1].islower() and x[6].islower()): return False
if not (x[2].isupper() and x[5].isupper()): return False
# Special character checks: non-alphanumeric, non-whitespace
# ord(char) must be >= 33 (printable ASCII starts) and <= 126 (tilde)
# Exclude digits (48-57), uppercase (65-90), lowercase (97-122)
def is_special_char_strict(char):
o = ord(char)
return (33 <= o <= 47) or \
(58 <= o <= 64) or \
(91 <= o <= 96) or \
(123 <= o <= 126)
if not (is_special_char_strict(x[3]) and is_special_char_strict(x[4])): return False
if x[3] == x[4]: return False # Must be different special characters
# Extract values
num_from_digits = int(x[0] + x[7])
lower_sum = ord(x[1]) + ord(x[6])
upper_prod = ord(x[2]) * ord(x[5])
special_xor = ord(x[3]) ^ ord(x[4])
# Condition 2: Digits specific
# num_from_digits must be a prime number greater than 10
if not (num_from_digits > 10 and is_prime(num_from_digits)): return False
# Condition 3: Lowercase letters specific
# lower_sum must be a Fibonacci number
# The absolute difference between the ASCII values of the two lowercase chars must be odd.
if not is_fibonacci(lower_sum): return False
if abs(ord(x[1]) - ord(x[6])) % 2 == 0: return False # Difference must be odd
# Condition 4: Uppercase letters specific
# upper_prod must be a perfect square
# The square root of upper_prod must be an ASCII value of an uppercase letter
if not is_perfect_square(upper_prod): return False
sqrt_upper_prod = int(upper_prod**0.5)
if not (ord('A') <= sqrt_upper_prod <= ord('Z')): return False
# Condition 5: Special characters specific
# special_xor must be equal to num_from_digits (from Condition 2)
if special_xor != num_from_digits: return False
return True
def mystery(x):
if not isinstance(x, str): return False
if len(x) != 6: return False
if not x.isdigit(): return False
num = int(x)
if num % (3-1) != (1-1): return False
if num % (2**2 +1) != (2**1 +1): return False
if num % (2**4 +1) != (2**4 -1): return False
if num % (4**2 +3) != (3**2 +5): return False
if num % (5**2 -2) != (2**3 +6): return False
if num % (3**3 +2) != (2**2 +7): return False
return True
def mystery(x):
# Helper functions
def is_prime(n):
if n < 2: return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0: return False
return True
def find_next_prime(n):
# Finds the smallest prime number strictly greater than n
current_num = n + 1
while True:
if is_prime(current_num):
return current_num
current_num += 1
# Condition 0: Type and Length
if not isinstance(x, str) or len(x) != 7:
return False
# Condition 1: Character type and position validation
# x[0], x[1], x[5] must be digits
# x[2], x[3], x[4] must be uppercase letters
# x[6] must be a lowercase letter
if not (x[0].isdigit() and x[1].isdigit() and x[5].isdigit()): return False
if not (x[2].isupper() and x[3].isupper() and x[4].isupper()): return False
if not x[6].islower(): return False
# Derived values
num_val_1 = int(x[0] + x[1]) # Two-digit number
num_val_2 = int(x[5]) # Single digit number
ord_x2 = ord(x[2])
ord_x3 = ord(x[3])
ord_x4 = ord(x[4])
letter_chars_sum = ord_x2 + ord_x3 + ord_x4
last_letter_ord = ord(x[6])
# Condition 2: num_val_1 specific
# num_val_1 must be a prime number (must be > 10 as it's a two-digit number)
if not is_prime(num_val_1): return False
# Condition 3: num_val_2 specific
# num_val_2 must be a perfect square digit (1, 4, 9)
if num_val_2 not in [1, 4, 9]: return False
# Condition 4: Uppercase letters specific
# ASCII values of x[2], x[3], x[4] must be consecutive uppercase letters
# e.g., 'A', 'B', 'C'
if not (ord_x2 + 1 == ord_x3 and ord_x3 + 1 == ord_x4): return False
# Condition 5: Lowercase letter specific (interdependency)
# The ASCII value of x[6] must be the smallest prime number strictly greater than num_val_1.
expected_last_letter_ord = find_next_prime(num_val_1)
if last_letter_ord != expected_last_letter_ord: return False
# Also ensure it's a lowercase letter as per Condition 1 (already checked, but good for robustness)
if not (ord('a') <= last_letter_ord <= ord('z')): return False
# Condition 6: Final checksum (combining all parts with a magic number)
# This magic number is derived from the intended solution.
magic_number = 321
checksum = (num_val_1 * num_val_2) ^ letter_chars_sum ^ last_letter_ord
if checksum != magic_number: return False
return True
def mystery(x):
if not isinstance(x, str): return False
if len(x) != 6: return False
if not x.isdigit(): return False
num = int(x)
if num % (3**2 -2) != (2**3 -2): return False
if num % (4**2 -5) != (3**2 +1): return False
if num % (2**3 +5) != (2**0): return False
if num % (2**4 +1) != (4**2): return False
if num % (4**2 +3) != (2**3 +5): return False
if num % (5**2 -2) != (2**1): return False
return True
def mystery(x):
# Helper functions
def is_prime(n):
if n < 2: return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0: return False
return True
def is_perfect_square(n):
if n < 0: return False
sqrt = int(n**0.5)
return sqrt * sqrt == n
def is_special_char_strict(char):
o = ord(char)
# Printable ASCII range (33-126) excluding digits, uppercase, lowercase
return (33 <= o <= 47) or \
(58 <= o <= 64) or \
(91 <= o <= 96) or \
(123 <= o <= 126)
def get_prime_factors(n):
factors = set()
d = 2
temp = n
while d * d <= temp:
if temp % d == 0:
factors.add(d)
while temp % d == 0:
temp //= d
d += 1
if temp > 1:
factors.add(temp)
return factors
def is_sphenic(n):
# A sphenic number is a positive integer that is the product of three distinct prime numbers.
if not isinstance(n, int) or n <= 0:
return False
factors = get_prime_factors(n)
return len(factors) == 3 and all(is_prime(f) for f in factors)
# Condition 0: Type and Length
if not isinstance(x, str) or len(x) != 9:
return False
# Condition 1: Character type and position validation
# x[0] and x[4] must be digits
# x[1], x[2], x[3] must be uppercase letters
# x[5], x[6], x[7] must be lowercase letters
# x[8] must be a special character (non-alphanumeric, non-whitespace, printable ASCII)
if not (x[0].isdigit() and x[4].isdigit()): return False
if not (x[1].isupper() and x[2].isupper() and x[3].isupper()): return False
if not (x[5].islower() and x[6].islower() and x[7].islower()): return False
if not is_special_char_strict(x[8]): return False
# Derived values from string parts
d1 = int(x[0])
d2 = int(x[4])
u1, u2, u3 = ord(x[1]), ord(x[2]), ord(x[3])
l1, l2, l3 = ord(x[5]), ord(x[6]), ord(x[7])
s = ord(x[8])
# Condition 2: Digits specific
# d1 and d2 must be distinct prime digits (2, 3, 5, or 7)
# The sum of d1 and d2 must be a perfect square
if not (is_prime(d1) and is_prime(d2) and d1 != d2): return False
if not is_perfect_square(d1 + d2): return False
# Condition 3: Uppercase letters specific
# u1, u2, u3 must be strictly increasing (u1 < u2 < u3)
# They must form an arithmetic progression (e.g., A, C, E)
# u1 and u3 (the first and third letters' ASCII values) must be prime numbers
# The sum of their ASCII values (u1 + u2 + u3) must be exactly 240
if not (u1 < u2 < u3): return False
if not (u2 - u1 == u3 - u2): return False
if not (is_prime(u1) and is_prime(u3)): return False
if not (u1 + u2 + u3 == 240): return False
# Condition 4: Lowercase letters specific
# l1, l2, l3 must be strictly increasing and form consecutive letters in the alphabet (e.g., 'a', 'b', 'c')
# The sum of their ASCII values (l1 + l2 + l3) must be equal to s * (d1 + d2)
if not (l1 < l2 < l3): return False
if not (l1 + 1 == l2 and l2 + 1 == l3): return False
if not (l1 + l2 + l3 == s * (d1 + d2)): return False
# Condition 5: Special character specific
# The ASCII value of s must be a perfect square
if not is_perfect_square(s): return False
# Condition 6: Global checksum
# The sum of all derived numeric values (d1 + d2 + u1 + u2 + u3 + l1 + l2 + l3 + s)
# must be a sphenic number.
total_sum = d1 + d2 + u1 + u2 + u3 + l1 + l2 + l3 + s
if not is_sphenic(total_sum): return False
return True