Skip to main content

特效函数实现

以下是函数特效的具体实现代码。


import math

def stdstr(number):
number=abs(number)
str_number = '{:03d}'.format(number)
return str_number

def countDigits(number):
return len(stdstr(number))

def getDigitAtPosition(number, digit):
num_str = stdstr(number)
if digit < len(num_str):
return int(num_str[-(digit + 1)])
return 0

def equal(number_a, number_b):
return number_a == number_b

def add(number_a, number_b):
return number_a + number_b

def sub(number_a, number_b):
return number_a - number_b

def subAbs(number_a, number_b):
return abs(number_a - number_b)

def mul(number_a, number_b):
return number_a * number_b

def div(number_a, number_b, exception=0):
if number_b == 0:
return exception
return number_a // number_b

def mod(number_a, number_b, exception=0):
if number_b == 0:
return exception
return number_a % number_b

def hasDuplicateMax(*args):
max_val = max(args)
return args.count(max_val) > 1

def hasDuplicateMin(*args):
min_val = min(args)
return args.count(min_val) > 1

def distanceEqual(number_a, number_b, dis):
return abs(number_a - number_b) == dis

def distanceInRange(number_a, number_b, dis):
return abs(number_a - number_b) <= dis

def distanceOutOfRange(number_a, number_b, dis):
return abs(number_a - number_b) >= dis

def sumNumber(number):
return sum(int(digit) for digit in stdstr(number))

def weightedSum(number, weight):
num_str = stdstr(number)
return sum(int(num_str[i]) * weight[i % len(weight)] for i in range(len(num_str)))

def singleTuple(number):
number_as_tuple = (number,)
return number_as_tuple

def getAllDigits(number):
return tuple(int(digit) for digit in stdstr(number))

def processDigitsOfSelf(number, function, *args):
digits = getAllDigits(number)
results = [function(digit, *args) for digit in digits]
return tuple(results)

def processDigitsOfSelfWithoutReflex(number, function, *args):
digits = getAllDigits(number)
results = [function(digit, *args) for digit in digits]
return tuple((digits[i], results[j]) for i in range(len(digits)) for j in range(len(digits)) if i != j)

def CompareAny(tuple_a, tuple_b, compare, *args):
return all(compare(a, b, *args) for a in tuple_a for b in tuple_b)

def CompareExist(tuple_a, tuple_b, compare, *args):
return any(compare(a, b, *args) for a in tuple_a for b in tuple_b)

def chooseCompareAny(number_a, number_b, tuple, compare, *args):
sampled_a = [getDigitAtPosition(number_a, i) for i in tuple]
sampled_b = [getDigitAtPosition(number_b, i) for i in tuple]
return all(compare(sampled_a[i], sampled_b[i], *args) for i in range(len(tuple)))

def chooseCompareExist(number_a, number_b, tuple, compare, *args):
sampled_a = [getDigitAtPosition(number_a, i) for i in tuple]
sampled_b = [getDigitAtPosition(number_b, i) for i in tuple]
return any(compare(sampled_a[i], sampled_b[i], *args) for i in range(len(tuple)))


# 1 悬浮 验证密码中个位、百位上数值是否距离其对应位置上正确密码数值的误差均为2。
def levitation(k,p):
return chooseCompareAny(k,p,(0,2),distanceEqual,2)

# 2 切换 验证密码中任意位置上数值是否存在正确密码中百位上数值减少十位上数值之后的绝对值。
def switch(k,p):
return CompareExist(getAllDigits(k),singleTuple(subAbs(getDigitAtPosition(p,2),getDigitAtPosition(p,1))),equal)

# 3 附着 验证密码中是否存在任意位置上数值÷其它任意位数上数值之后(整数部分)数值为正确密码中任意位置上数值。
def adhesion(k, p):
# 获取密码k和正确密码p中的所有数值
digits_k = getAllDigits(k)
digits_p = getAllDigits(p)
# 遍历密码k中的每个数值
for i in range(len(digits_k)):
# 再次遍历密码k中的每个数值,但跳过与i相同的索引,以便不与自身相除
for j in range(len(digits_k)):
if i != j:
# 如果除数不为0,计算整数除法的结果
if digits_k[j] != 0:
division_result = digits_k[i] // digits_k[j]
# 检查整数除法的结果是否在正确密码p的任意位置上
if division_result in digits_p:
return True
# 如果没有找到满足条件的情况,返回False
return False


# 4 巨大化 验证密码中所有位置上数值相加之后的数值是否存在正确密码中任意位置上数值。
def enlargement(k, p):
return CompareExist(singleTuple(sumNumber(k)), getAllDigits(p), equal)

# 5 最小化 验证密码中个位、十位、百位上数值相减(个位上数值-十位上数值-百位上数值)之后的绝对值是否存在正确密码中任意位置上数值。
def minimization(k, p):
return CompareExist(singleTuple(abs(weightedSum(k,(-1,-1,1)))),getAllDigits(p), equal)

# 6 余晖 验证密码中十位上数值-个位上数值之后的绝对值是否存在正确密码中百位上数值。
def afterglow(k, p):
return equal(subAbs(getDigitAtPosition(k, 1), getDigitAtPosition(k, 0)), getDigitAtPosition(p, 2))

# 7 破坏欲 验证密码中最大值减少正确密码中最大值之后的绝对值是否存在正确密码中十位上数值。
def destructiveUrge(k, p):
return equal(subAbs(max(getAllDigits(k)), max(getAllDigits(p))), getDigitAtPosition(p, 1))

# 8 亘古 验证密码中个位上数值是否存在正确密码中其对应位置上的数值。
def eon(k, p):
return equal(getDigitAtPosition(k, 0), getDigitAtPosition(p, 0))

# 9 消除反应 验证密码中任意位置上数值是否存在正确密码中其对应位置上的数值。
def reactionElimination(k, p):
return chooseCompareExist(k, p, (0,1,2) , equal)

# 10 命运之轮 验证密码中百位上数值是否存在正确密码中十位上数值或是个位上数值。
def wheelOfFate(k, p):
return CompareExist(singleTuple(getDigitAtPosition(k, 2)),
(getDigitAtPosition(p, 1), getDigitAtPosition(p, 0)),
equal)

# 11 欢谑 验证密码中任意位置上数值±1或是±2之后的绝对值是否存在正确密码中百位上数值。
def ridicule(k, p):
return CompareExist((add(getDigitAtPosition(k, 0), 1),
add(getDigitAtPosition(k, 1), 1),
add(getDigitAtPosition(k, 2), 1),
subAbs(getDigitAtPosition(k, 0), 1),
subAbs(getDigitAtPosition(k, 1), 1),
subAbs(getDigitAtPosition(k, 2), 1),
add(getDigitAtPosition(k, 0), 2),
add(getDigitAtPosition(k, 1), 2),
add(getDigitAtPosition(k, 2), 2),
subAbs(getDigitAtPosition(k, 0), 2),
subAbs(getDigitAtPosition(k, 1), 2),
subAbs(getDigitAtPosition(k, 2), 2)),
singleTuple(getDigitAtPosition(p, 2)), equal)

# 12 天敌 验证密码中任意位置上数值求余正确密码中百位上数值之后的绝对值是否存在正确密码中个位上数值。
def nemesis(k, p):
return CompareExist(processDigitsOfSelf(k, mod, getDigitAtPosition(p, 2), -1),
singleTuple(getDigitAtPosition(p, 0)), equal)

# 13 细致 验证密码中最大值+最小值之后的绝对值是否等于正确密码中任意位置上数值。
def meticulous(k, p):
return CompareExist(singleTuple(add(max(getAllDigits(k)), min(getAllDigits(k)))),
getAllDigits(p), equal)

# 14 偶值 验证密码中任意位置上数值是否等于正确密码中偶数之和。
def evenValue(k, p):
even_sum_p = sum(int(getDigitAtPosition(p, i)) for i in range(len(stdstr(p))) if (int(getDigitAtPosition(p, i)) % 2 == 0))
return CompareExist(getAllDigits(k), singleTuple(even_sum_p), equal)

# 15 旋律 验证密码中最大值与最小值之差的绝对值是否存在正确密码中任意位置上数值。
def melody(k, p):
return CompareExist(singleTuple(subAbs(max(getAllDigits(k)), min(getAllDigits(k)))),
getAllDigits(p), equal)

# 16 几率 验证密码中任意位置上的数值开平方之后(整数部分)数值是否存在正确密码中百位上数值或是十位上数值。
def probability(k, p):
return CompareExist(processDigitsOfSelf(k, lambda x: int(x**0.5)),
(getDigitAtPosition(p, 2),getDigitAtPosition(p, 1)), equal)

# 17 噩兆 验证密码中个位上数值的负值是否存在正确密码中个位上数值减去十位上数值之后的数值。
def omen(k, p):
return equal(-getDigitAtPosition(k, 0), sub(getDigitAtPosition(p, 0), getDigitAtPosition(p, 1)))

# 18 变因 验证密码中数值平均值(整数部分)是否存在正确密码中数值的平均值(整数部分)。
def variable(k, p):
k_avg = sumNumber(k) // countDigits(k)
p_avg = sumNumber(p) // countDigits(p)
return equal(k_avg, p_avg)

# 19 梦境 验证密码中百位上数值是否存在正确密码中百位上数值求余个位上数值之后的数值。
def dreamscape(k, p):
return equal(getDigitAtPosition(k, 2), mod(getDigitAtPosition(p, 2), getDigitAtPosition(p, 0), 0))

# 20 异物 验证密码中0的个数是否等于正确密码中0的个数。
def foreignObject(k, p):
count_zero_k = stdstr(k).count('0')
count_zero_p = stdstr(p).count('0')
return equal(count_zero_k, count_zero_p)

# 21 奇点 验证密码中奇数之和是否存在正确密码中最小值。
def singularity(k, p):
k_odd_sum = sum(d for d in getAllDigits(k) if d % 2 != 0)
return equal(k_odd_sum, min(getAllDigits(p)))

# 22 决心 验证密码任意位置上数值乘2之后的数值是否存在正确密码中百位上数值或是个位上数值。
def determination(k, p):
hundred_digit_p = getDigitAtPosition(p, 2)
unit_digit_p = getDigitAtPosition(p, 0)
doubled_digits_k = processDigitsOfSelf(k, mul, 2)
return CompareExist(doubled_digits_k, (hundred_digit_p, unit_digit_p), equal)

# 23 读取干扰 验证密码中个位上数值的阶乘是否等于正确密码中最大值。
def readInterference(k, p):
unit_digit_k = getDigitAtPosition(k, 0)
factorial_k = math.factorial(unit_digit_k)
digits_p = getAllDigits(p)
max_p = max(digits_p)
return equal(factorial_k, max_p)

# 24 无限接近 验证密码中数值是否距离正确密码中数值误差处于[0,100]之间。
def infinitelyClose(k, p):
return subAbs(k, p) <= 100