【算法模板】算竞技巧：Python对拍数据生成

T0uken

已于 2024-08-07 22:11:12 修改

阅读量1.1k

点赞数 32

分类专栏：竞赛算法文章标签：算法 python 开发语言

于 2024-08-07 14:22:56 首次发布

本文链接：https://blog.csdn.net/2303_80346267/article/details/140990972

版权

竞赛算法专栏收录该内容

35 篇文章 2 订阅

订阅专栏

在计算机编程竞赛中，对拍（Testlib）是一种验证程序正确性的方法。它通常用于检查一个程序的输出是否与另一个程序的输出一致，以确保程序的正确性。

对拍程序

【算法模板】算竞技巧：对拍全解_算法竞赛对拍-CSDN博客

#include <iostream>
#include <chrono>

int main() {
    system("g++ std.cpp -o std.exe");
    system("g++ force.cpp -o force.exe");
    int cnt = 0;
    do {
        std::cout << "Round " << ++cnt << std::endl;
        system("python data.py > input.txt");

        clock_t start = clock();
        system("std.exe < input.txt > sout.txt");
        clock_t end = clock();
        std::cout << "std:"
                  << double(end - start)/ CLOCKS_PER_SEC << "sec" << std::endl;

        start = clock();
        system("force.exe < input.txt > fout.txt");
        end = clock();
        std::cout << "force:"
                  << double(end - start)/ CLOCKS_PER_SEC << "sec" << std::endl;

    } while (system("fc fout.txt sout.txt") == 0);
    return 0;
}

`random`模块

Python的random模块提供了生成伪随机数的各种方法。这些方法可以用于生成整数、浮点数、随机选择、打乱顺序等。下面是random模块的一些常用功能函数以及它们的使用方法：

random.random()

生成一个范围在[0.0, 1.0)之间的浮点数。

# 生成一个随机浮点数
print(random.random())  # 输出示例：0.37444887175646646

random.randint(a, b)

生成一个范围在[a, b]之间的随机整数，包括a和b。

# 生成一个范围在1到10之间的随机整数
print(random.randint(1, 10))  # 输出示例：7

random.uniform(a, b)

生成一个范围在[a, b]之间的随机浮点数。

# 生成一个范围在1.5到10.5之间的随机浮点数
print(random.uniform(1.5, 10.5))  # 输出示例：7.123456789

random.choice(seq)

从非空序列seq中随机选择一个元素。

# 从列表中随机选择一个元素
print(random.choice([1, 2, 3, 4, 5]))  # 输出示例：3

random.choices(population, weights=None, k=1)

从population中随机选择k个元素，返回一个列表。可以指定weights进行加权随机选择。

# 从列表中随机选择3个元素
print(random.choices([1, 2, 3, 4, 5], k=3))  # 输出示例：[4, 1, 5]

# 使用权重进行随机选择
print(random.choices([1, 2, 3, 4, 5], weights=[10, 1, 1, 1, 1], k=3))  # 输出示例：[1, 1, 4]

random.sample(population, k)

从population中随机选择k个唯一元素，返回一个列表。

# 从列表中随机选择3个唯一元素
print(random.sample([1, 2, 3, 4, 5], k=3))  # 输出示例：[2, 5, 3]

random.shuffle(seq)

将序列seq中的元素随机打乱，seq会被原地修改。

# 随机打乱列表中的元素
lst = [1, 2, 3, 4, 5]
random.shuffle(lst)
print(lst)  # 输出示例：[3, 1, 5, 2, 4]

random.gauss(mu, sigma)

生成一个服从高斯分布（正态分布）的随机浮点数，均值为mu，标准差为sigma。

# 生成一个均值为0，标准差为1的高斯分布随机浮点数
print(random.gauss(0, 1))  # 输出示例：-0.4943560805796826

random.seed(a=None)

初始化随机数生成器。a可以是任意可散列的对象。如果省略或为None，则使用系统时间或操作系统提供的随机源。
```
# 使用种子进行随机数生成
random.seed(42)
print(random.random())  # 输出示例：0.6394267984578837
```

random.getrandbits(k)

生成一个拥有k个随机比特位的整数。

# 生成一个拥有16个随机比特位的整数
print(random.getrandbits(16))  # 输出示例：57856

`itertools` 模块

combinations(iterable, r)

返回可迭代对象的所有长度为 r 的组合，不重复且不考虑顺序。

comb = itertools.combinations('ABCD', 2)  
for item in comb:  
    print(item)  # 输出 ('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')

permutations(iterable, r=None)

返回可迭代对象的所有长度为 r 的排列，顺序重要。

perm = itertools.permutations('ABC', 2)  
for item in perm:  
    print(item)  # 输出 ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')

product(*iterables, repeat=1)

返回输入可迭代对象的笛卡尔积，可以指定 repeat 参数。

prod = itertools.product('AB', repeat=2)  
for item in prod:  
    print(item)  # 输出 ('A', 'A'), ('A', 'B'), ('B', 'A'), ('B', 'B')

整数数组

import random

def generate_integer_array(n, low=0, high=1000):
    array = [random.randint(low, high) for _ in range(n)]
    # 输出数组大小
    print(n)
    # 输出数组元素，使用空格分隔
    print(" ".join(map(str, array)))

if __name__ == "__main__":
    n = random.randint(1, 100)  # 随机生成数组大小
    generate_integer_array(n)

浮点数数组

import random

def generate_float_array(n, low=0.0, high=1000.0):
    array = [random.uniform(low, high) for _ in range(n)]
    # 输出数组大小
    print(n)
    # 输出数组元素，使用空格分隔，并保留两位小数
    print(" ".join(f"{x:.2f}" for x in array))

if __name__ == "__main__":
    n = random.randint(1, 100)  # 随机生成数组大小
    generate_float_array(n)

字符串

import random  

def generate_random_string(length,choices = "ABC"):  
    print(length)
    random_string = ''.join(random.choice(choices) for _ in range(length))  
    return random_string

if __name__ == "__main__":
    n = random.randint(1,10) 
    result = generate_random_string(n)  
    print(result)

从1到n的排列

import random

def generate_permutation(n):
    permutation = list(range(1, n + 1))
    # 随机打乱排列
    random.shuffle(permutation)
    
    # 输出排列大小
    print(n)
    # 输出排列元素，使用空格分隔
    print(" ".join(map(str, permutation)))

if __name__ == "__main__":
    n = random.randint(1, 100)  # 随机生成排列大小
    generate_permutation(n)

树

import random

def generate_tree(num_nodes):
    edges = []
    for i in range(2, num_nodes + 1):
        u = random.randint(1, i - 1)
        # 生成从节点u到节点i的边
        edges.append((u, i))
    
    # 输出节点数
    print(num_nodes)
    # 输出所有边
    for u, v in edges:
        print(u, v)

if __name__ == "__main__":
    num_nodes = random.randint(2, 10)  # 随机生成节点数
    generate_tree(num_nodes)

无向图

import random

def generate_undirected_graph(num_nodes, num_edges):
    edges = set()
    while len(edges) < num_edges:
        u = random.randint(1, num_nodes)
        v = random.randint(1, num_nodes)
        if u != v:
            if u > v:
                u, v = v, u
            # 确保边(u, v)是唯一的
            edges.add((u, v))
    
    # 输出节点数和边数
    print(num_nodes, num_edges)
    # 输出所有边
    for u, v in edges:
        print(u, v)

if __name__ == "__main__":
    num_nodes = random.randint(2, 10)  # 随机生成节点数
    num_edges = random.randint(1, num_nodes * (num_nodes - 1) // 2)  # 随机生成边数
    generate_undirected_graph(num_nodes, num_edges)

有向图

import random

def generate_directed_graph(num_nodes, num_edges):
    edges = set()
    while len(edges) < num_edges:
        u = random.randint(1, num_nodes)
        v = random.randint(1, num_nodes)
        if u != v:
            # 确保边(u, v)是唯一的
            edges.add((u, v))
    
    # 输出节点数和边数
    print(num_nodes, num_edges)
    # 输出所有边
    for u, v in edges:
        print(u, v)

if __name__ == "__main__":
    num_nodes = random.randint(2, 10)  # 随机生成节点数
    num_edges = random.randint(1, num_nodes * (num_nodes - 1))  # 随机生成边数
    generate_directed_graph(num_nodes, num_edges)

*函数图像

import tkinter as tk  # 导入tkinter模块以便在Python中创建图形用户界面  

def plot_function(x_values, y_values):  
    # 创建根窗口  
    root = tk.Tk()  
    root.title("Function Plotter")  # 设置窗口标题  

    # 创建一个画布，指定宽度、高度和背景颜色  
    canvas = tk.Canvas(root, width=400, height=400, bg="white")  
    canvas.pack()  # 将画布添加到窗口中并显示  

    # 获取画布的宽度和高度  
    width = int(canvas['width'])  
    height = int(canvas['height'])  

    # 计算x和y值的最小值和最大值，以确定数据范围  
    x_min, x_max = min(x_values), max(x_values)  
    y_min, y_max = min(y_values), max(y_values)  

    # 根据画布的大小和数据范围计算x和y的缩放因子  
    x_scale = width / (x_max - x_min)  
    y_scale = height / (y_max - y_min)  

    # 计算每个点在画布上的位置，并进行缩放  
    points = [  
        (  
            (x - x_min) * x_scale,  # 使用缩放因子转换x坐标  
            height - (y - y_min) * y_scale  # 使用缩放因子转换y坐标，y坐标需要反转以符合画布的坐标系  
        )  
        for x, y in zip(x_values, y_values)  # 将x和y值组合在一起  
    ]  

    # 在画布上绘制线条，连接相邻的点  
    for i in range(len(points) - 1):  
        canvas.create_line(points[i], points[i + 1], fill="blue")  # 绘制线条，颜色为蓝色  

    # 进入主事件循环，等待用户操作  
    root.mainloop()

if __name__ == "__main__":
    x_values = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    y_values = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

    plot_function(x_values, y_values)