456data

点击下载数据

import random
import math
import sys
import os

def generate_large_number(digits, allow_zero=True):
    """生成指定位数的大数"""
    if digits == 0:
        return "0"
    if not allow_zero and digits == 1:
        return str(random.randint(1, 9))

    first_digit = random.randint(1, 9) if digits > 0 else 0
    rest_digits = ''.join(str(random.randint(0, 9)) for _ in range(digits - 1))
    return str(first_digit) + rest_digits

def generate_binary_number(bits):
    """生成指定位数的二进制数"""
    if bits == 0:
        return "0"
    first_bit = "1"
    rest_bits = ''.join(random.choice('01') for _ in range(bits - 1))
    return first_bit + rest_bits

def op1_generator(test_id):
    """生成加法测试数据"""
    digits = random.randint(1, 75000)
    a = generate_large_number(digits)
    b = generate_large_number(digits)
    result = str(int(a) + int(b))
    return f"1 {a} {b}", result

def op2_generator(test_id):
    """生成减法测试数据"""
    digits_a = random.randint(1, 75000)
    digits_b = random.randint(1, digits_a)

    a = generate_large_number(digits_a)

    # 确保b <= a
    if random.random() < 0.5:
        # b比a小
        b_digits = min(digits_b, len(a))
        b = generate_large_number(b_digits)
        while int(b) > int(a):
            b = generate_large_number(b_digits)
    else:
        # b与a位数相同但值更小
        b = generate_large_number(len(a))
        while int(b) > int(a):
            b = generate_large_number(len(a))

    result = str(int(a) - int(b))
    return f"2 {a} {b}", result

def op3_generator(test_id):
    """生成乘法测试数据"""
    if 91 <= test_id <= 135:
        digits = random.randint(1, 10000)
    elif test_id < 145: 
        digits = random.randint(1, 380384)
    else:
        digits = 380384
    a = generate_large_number(digits)
    b = generate_large_number(digits)
    result = str(int(a) * int(b))
    return f"3 {a} {b}", result

def op4_generator(test_id):
    """生成除法测试数据"""
    a_digits = random.randint(1, 384)
    a = generate_large_number(a_digits)

    max_b_digits = min(random.randint(1, 384), len(a))
    b = generate_large_number(random.randint(1, max_b_digits), allow_zero=False)

    # 确保b不为0且合理
    while int(b) == 0:
        b = generate_large_number(random.randint(1, max_b_digits), allow_zero=False)

    quotient = str(int(a) // int(b))
    remainder = str(int(a) % int(b))
    return f"4 {a} {b}", f"{quotient}\n{remainder}"

def op5_generator(test_id):
    """生成幂模测试数据"""
    a_digits = random.randint(1, 256)
    b_digits = random.randint(1, 256)
    m = random.randint(1, 300)

    a = generate_large_number(a_digits)
    b = generate_large_number(b_digits)

    # 计算 a^b mod 10^m
    base = int(a)
    exponent = int(b)
    modulus = 10 ** m

    # 使用快速幂算法
    result = pow(base, exponent, modulus)

    return f"5 {a} {b} {m}", str(result)

def op6_generator(test_id):
    """生成二进制转十进制测试数据"""
    bits = random.randint(1, 10000)
    if test_id >= 205:
       bits = 10000
    binary_str = generate_binary_number(bits)
    decimal_val = int(binary_str, 2)
    return f"6 {binary_str}", str(decimal_val)

def op7_generator(test_id):
    """生成十进制转二进制测试数据"""
    digits = random.randint(1, 3010)
    if test_id >= 295:
        digits = 3010
    decimal_str = generate_large_number(digits)
    binary_val = bin(int(decimal_str))[2:]
    return f"7 {decimal_str}", binary_val

def op8_generator(test_id):
    """生成位运算测试数据"""
    a_digits = random.randint(1, 2048)
    b_digits = random.randint(1, 2048)
    if test_id >= 350:
        a_digits = 2048
    if test_id >= 355:
        b_digits = 2048
    a = int(generate_large_number(a_digits))
    b = int(generate_large_number(b_digits))

    and_result = a & b
    or_result = a | b
    xor_result = a ^ b

    return f"8 {a} {b}", f"{and_result}\n{or_result}\n{xor_result}"

def gcd(a, b):
    """计算最大公约数"""
    while b:
        a, b = b, a % b
    return a

def op9_generator(test_id):
    """生成最小公倍数测试数据"""
    a_digits = random.randint(1, 8336)
    b_digits = random.randint(1, 8336)
    if test_id >= 395:
        a_digits = 8336
    if test_id >= 400:
        b_digits = 8336
    a = int(generate_large_number(a_digits, allow_zero=False))
    b = int(generate_large_number(b_digits, allow_zero=False))

    lcm = abs(a * b) // gcd(a, b)
    return f"9 {a} {b}", str(lcm)

def extended_gcd(a, b):
    """扩展欧几里得算法"""
    if a == 0:
        return b, 0, 1
    gcd_val, x1, y1 = extended_gcd(b % a, a)
    x = y1 - (b // a) * x1
    y = x1
    return gcd_val, x, y

def mod_inverse(a, m):
    """计算模逆元"""
    gcd_val, x, _ = extended_gcd(a, m)
    if gcd_val != 1:
        return None
    return (x % m + m) % m

def op10_generator(test_id):
    """生成模逆元测试数据"""
    digits = random.randint(1, 64)
    if test_id >= 500:
        digits = 64

    # 生成互质的a和m
    while True:
        m = int(generate_large_number(digits, allow_zero=False))
        a = random.randint(1, m - 1)

        if gcd(a, m) == 1:
            break

    inverse = mod_inverse(a, m)
    return f"10 {a} {m}", str(inverse)

def nCr(n, r):
    """计算组合数"""
    if r > n:
        return 0
    if r == 0 or r == n:
        return 1

    # 使用动态规划计算组合数
    C = [0] * (r + 1)
    C[0] = 1

    for i in range(1, n + 1):
        for j in range(min(i, r), 0, -1):
            C[j] = C[j] + C[j - 1]

    return C[r]

def op11_generator(test_id):
    """生成组合数测试数据"""
    a = random.randint(1, 5120)
    b = random.randint(1, a)

    result = nCr(a, b)
    return f"11 {a} {b}", str(result)

def matrix_mult(A, B, mod):
    """矩阵乘法"""
    return [[(A[0][0]*B[0][0] + A[0][1]*B[1][0]) % mod,
             (A[0][0]*B[0][1] + A[0][1]*B[1][1]) % mod],
            [(A[1][0]*B[0][0] + A[1][1]*B[1][0]) % mod,
             (A[1][0]*B[0][1] + A[1][1]*B[1][1]) % mod]]

def matrix_power(matrix, power, mod):
    """矩阵快速幂"""
    result = [[1, 0], [0, 1]]  # 单位矩阵
    base = matrix

    while power > 0:
        if power % 2 == 1:
            result = matrix_mult(result, base, mod)
        base = matrix_mult(base, base, mod)
        power //= 2

    return result

def fibonacci_mod(n, mod):
    """计算斐波那契数列第n项模mod"""
    if n <= 2:
        return 1 % mod

    # 使用矩阵快速幂
    base_matrix = [[1, 1], [1, 0]]
    result_matrix = matrix_power(base_matrix, n - 2, mod)

    return (result_matrix[0][0] + result_matrix[0][1]) % mod

def op12_generator(test_id):
    """生成斐波那契数列测试数据"""
    a_digits = random.randint(1, 384)
    if test_id >= 545:
        a_digits = 384
    m = random.randint(1, 300)
    if test_id >= 550:
        m = random.randint(175, 300)
    a = int(generate_large_number(a_digits, allow_zero=False))
    mod = 10 ** m

    result = fibonacci_mod(a, mod)
    return f"12 {a} {m}", str(result)

def generate_test_data():
    """生成所有测试数据"""
    # 创建测试数据目录
    if not os.path.exists('test_data'):
        os.makedirs('test_data')

    test_id = 1

    print("生成操作1测试数据...")
    for i in range(45):
        input_data, output_data = op1_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作2: 减法 (测试点16-30)
    print("生成操作2测试数据...")
    for i in range(45):
        input_data, output_data = op2_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作3: 乘法 (测试点31-50)
    print("生成操作3测试数据...")
    for i in range(60):
        input_data, output_data = op3_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作4: 除法 (测试点51-70)
    print("生成操作4测试数据...")
    for i in range(60):
        input_data, output_data = op4_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作5: 幂模 (测试点71-80)
    print("生成操作5测试数据...")
    for i in range(30):
        input_data, output_data = op5_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作6: 二进制转十进制 (测试点81-92)
    print("生成操作6测试数据...")
    for i in range(36):
        input_data, output_data = op6_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作7: 十进制转二进制 (测试点93-100)
    print("生成操作7测试数据...")
    for i in range(24):
        input_data, output_data = op7_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作8: 位运算 (测试点101-120)
    print("生成操作8测试数据...")
    for i in range(60):
        input_data, output_data = op8_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作9: 最小公倍数 (测试点121-135)
    print("生成操作9测试数据...")
    for i in range(45):
        input_data, output_data = op9_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作10: 模逆元 (测试点136-150)
    print("生成操作10测试数据...")
    for i in range(45):
        input_data, output_data = op10_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作11: 组合数 (测试点151-170)
    print("生成操作11测试数据...")
    for i in range(60):
        input_data, output_data = op11_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    # 操作12: 斐波那契数列 (测试点171-185)
    print("生成操作12测试数据...")
    for i in range(45):
        input_data, output_data = op12_generator(test_id)

        with open(f'test_data/test{test_id}.in', 'w') as f:
            f.write(input_data)
        with open(f'test_data/test{test_id}.out', 'w') as f:
            f.write(output_data)

        test_id += 1

    print(f"所有555个测试数据生成完成！保存在test_data目录中。")

if __name__ == "__main__":
    random.seed(1312537)
    sys.set_int_max_str_digits(10000000)
    generate_test_data()