2025ISCC区域赛MISC

# 导入必要的库
import numpy as np                # 导入NumPy库，用于数值计算和数组操作
from PIL import Image             # 导入PIL库中的Image模块，用于图像处理
import cv2                        # 导入OpenCV库，用于计算机视觉处理
import os                         # 导入os模块，用于操作系统相关功能


def cat_face_scramble(img_data, iterations, param_a, param_b):
    """
    猫脸加密函数 - 使用Arnold变换对图像进行加密
    
    参数:
        img_data: 输入图像数据
        iterations: 迭代次数
        param_a: 变换参数a
        param_b: 变换参数b
    
    返回:
        加密后的图像
    """
    # 创建与原图像相同大小的零矩阵
    result = np.zeros_like(img_data)
    # 获取图像的高度和宽度
    height, width = img_data.shape[0], img_data.shape[1]
    # 设置变换矩阵大小，假设图像是正方形
    matrix_size = height
    
    # 进行指定次数的迭代变换
    for _ in range(iterations):
        # 遍历图像的每个像素
        for x in range(height):
            for y in range(width):
                # 计算变换后的新坐标
                new_x = (x + param_b * y) % matrix_size
                new_y = (param_a * x + (param_a * param_b + 1) * y) % matrix_size
                # 将原像素值赋给新坐标位置
                result[new_x, new_y, :] = img_data[x, y, :]
        # 更新图像数据，为下一次迭代做准备
        img_data = np.copy(result)
    
    # 保存加密后的图像
    cv2.imwrite('flag_scrambled.png', result, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
    return result


def cat_face_unscramble(img_data, iterations, param_a, param_b):
    """
    猫脸解密函数 - 使用Arnold逆变换对图像进行解密
    
    参数:
        img_data: 输入图像数据
        iterations: 迭代次数
        param_a: 变换参数a
        param_b: 变换参数b
    
    返回:
        解密后的图像
    """
    # 创建与原图像相同大小的零矩阵
    result = np.zeros_like(img_data)
    # 获取图像的高度和宽度
    height, width = img_data.shape[0], img_data.shape[1]
    # 设置变换矩阵大小，假设图像是正方形
    matrix_size = height
    
    # 进行指定次数的迭代变换
    for _ in range(iterations):
        # 遍历图像的每个像素
        for x in range(height):
            for y in range(width):
                # 计算逆变换的新坐标
                orig_x = ((param_a * param_b + 1) * x + (-param_b) * y) % matrix_size
                orig_y = ((-param_a) * x + y) % matrix_size
                # 将原像素值赋给新坐标位置
                result[orig_x, orig_y, :] = img_data[x, y, :]
        # 更新图像数据，为下一次迭代做准备
        img_data = np.copy(result)
    
    # 保存解密后的图像
    cv2.imwrite('flag_unscrambled.png', result, [int(cv2.IMWRITE_PNG_COMPRESSION), 0])
    return result


# 主程序开始

# 定义图像文件路径
image_file = '/2025 ISCC/练武题/MISC/签个到吧/attachment-30/0001_47.png'

# 检查文件是否存在
if os.path.exists(image_file):
    try:
        # 使用PIL库读取图片（对中文路径支持更好）
        image_pil = Image.open(image_file)
        # 将PIL图像转换为NumPy数组
        image_array = np.array(image_pil)
        
        # 如果图像是RGB格式，转换为BGR（OpenCV使用BGR）
        if len(image_array.shape) == 3 and image_array.shape[2] == 3:
            image_array = cv2.cvtColor(image_array, cv2.COLOR_RGB2BGR)
        
        # 输出图像读取成功信息
        print(f"图片读取成功，尺寸: {image_array.shape}")
    except Exception as e:
        # 捕获并输出图像读取失败的错误
        print(f"图片读取失败: {e}")
        exit(1)
else:
    # 如果文件不存在，输出错误信息并退出
    print(f"图片路径不存在: {image_file}")
    exit(1)

# 执行猫脸解密操作，参数为：迭代次数=1, a=1, b=-2
cat_face_unscramble(image_array, 1, 1, -2)

# 如需执行猫脸加密，可取消下面的注释
# cat_face_scramble(image_array, 1, 2, 3)

from PIL import Image
from tqdm import tqdm
import time
 
def calculate_weighted_color(image_path: str, weights: dict = None) -> float:
   """
  计算图片的加权颜色值
   
  参数:
      image_path (str): 图片文件路径
      weights (dict): 通道权重字典（默认 {'red':0.6, 'green':0.3, 'blue':0.1}）
   
  返回:
      float: 加权颜色值（0.0-765.0）
   
  异常:
      FileNotFoundError: 文件不存在
      ValueError: 无效图片格式或损坏文件
  """
   # 默认权重（可根据需求调整）
   weights = weights or {
       'red': 0.6,
       'green': 0.3,
       'blue': 0.1
  }
 
   try:
       # 1. 资源管理优化
       with Image.open(image_path) as img:
           # 2.换 转为RGB并获取像素数据
           img = img.convert("RGB")
           
           # 3. 使用生成器表达式替代双重循环（性能提升约3倍）
           total_pixels = img.width * img.height
           weighted_sum = sum(
              (r * weights['red'] + g * weights['green'] + b * weights['blue'])
               for r, g, b in tqdm(img.getdata(), total=total_pixels)
          )
 
           # 4. 计算加权平均值（更合理的计算方式）
           return weighted_sum / total_pixels
 
   except FileNotFoundError:
       print(f"错误：找不到文件 {image_path}")
       raise
   except Exception as e:
       print(f"处理图片时发生错误：{str(e)}")
       raise ValueError(f"无效图片文件 {image_path}") from e
 
if __name__ == "__main__":
   # 5. 参数化处理
   start_time = time.time()
   result = calculate_weighted_color("Sleeping_Beauty_22.png")
   print(f"\n加权颜色值: {result:.2f}（计算耗时 {time.time()-start_time:.2f}s）")

from scipy.io import wavfile
import numpy as np


def read_wav(file_path):
    """读取音频文件并返回采样率和数据"""
    try:
        rate, audio_data = wavfile.read(file_path)
        return rate, audio_data
    except FileNotFoundError:
        print(f"无法找到文件: '{file_path}'")
        return None, None
    except Exception as err:
        print(f"音频文件读取失败: {err}")
        return None, None


def convert_to_mono(audio_data):
    """将音频转换为单声道"""
    if audio_data.ndim > 1:
        return audio_data[:, 0]
    return audio_data


def extract_bit(audio_chunk, threshold=0):
    """从音频片段中提取比特值"""
    binary_values = (audio_chunk > threshold).astype(int)
    
    # 全为1表示比特0
    if binary_values.all():
        return '0'
    # 存在下降沿表示比特1
    elif (np.diff(binary_values) == -1).any():
        return '1'
    return None


def process_audio(mono_signal, rate, begin_pos, chunk_size):
    """处理音频信号并提取比特序列"""
    bit_sequence = []
    position = begin_pos
    signal_length = len(mono_signal)
    chunks_processed = 0

    print(f"音频采样率: {rate} Hz")
    print(f"每个数据块大小: {chunk_size}")
    print(f"开始位置: {begin_pos}")

    while position + chunk_size <= signal_length:
        chunk = mono_signal[position:position + chunk_size]
        bit = extract_bit(chunk)

        if bit is not None:
            bit_sequence.append(bit)

        position += chunk_size
        chunks_processed += 1

    print(f"已处理 {chunks_processed} 个数据块")
    return bit_sequence


def extract_binary_data(wav_path, start_sec=6.0, chunk_duration_sec=0.1):
    """从WAV文件中提取二进制数据"""
    # 读取音频
    rate, audio_data = read_wav(wav_path)
    if rate is None:
        return ""

    # 转换为单声道
    mono_signal = convert_to_mono(audio_data)

    # 计算参数
    begin_pos = int(start_sec * rate)
    chunk_size = int(chunk_duration_sec * rate)

    # 检查边界
    if begin_pos + chunk_size > len(mono_signal):
        print(f"错误: 起始时间 ({start_sec}秒) 超出音频范围")
        return ""

    # 提取比特序列
    bits = process_audio(mono_signal, rate, begin_pos, chunk_size)

    return "".join(bits)


if __name__ == "__main__":
    result = extract_binary_data(wav_path='./normal_speech_15.wav')
    print(f'曼彻斯特编码：{result}')

import math

def combination(n, k):
    """计算组合数 C(n,k)"""
    return math.comb(n, k)

def get_pascal_value(row, col):
    """获取杨辉三角第row行第col列的值"""
    # 杨辉三角的行列从1开始，所以需要减1来计算组合数
    return combination(row-1, col-1)

def map_to_letter(num):
    """将数字映射为字母（0->A, 1->B, ..., 25->Z）"""
    return chr((num % 26) + ord('A') - 1)

# 给定的坐标列表 (列, 行)
coordinates = [
    (2, 10), (4, 8), (2, 4), (3, 4), (11, 13), 
    (2, 11), (1, 1), (10, 26), (5, 6), (5, 9)
]

# 计算每个坐标对应的值
values = []
for col, row in coordinates:
    value = get_pascal_value(row, col)
    values.append(value)

print("计算得到的值:", values)

# 将值映射为字母
key = ""
for value in values:
    key += map_to_letter(value)

print("提取的密钥:", key)