如果不用numpy完成以上问题

如果你不想使用NumPy来保留两位小数，可以使用`format()`函数来设置精度。其他部分的代码保持不变，仅替换掉使用`np.around`的部分。以下是修改后的代码：

import random

# 生成20个1到100之间的随机整数
numbers = [random.randint(1, 100) for _ in range(20)]
numbers = list(set(numbers))  # 去重

# 对于偏离较大的数值，这里假设我们只考虑绝对值大于95的数
numbers = [str(num) if abs(num) > 95 else str(format(num, '.2f')) for num in numbers]  # 保留两位小数

# 按照逆序排序
numbers.sort(reverse=True)

# 写入文件
with open('output.txt', 'w', newline='') as file:
    file.write('原始数列：\n')
    for number in numbers:
        file.write(f'{number}\n')

相关问题

python 编写程序实现hill密码算法（不用 numpy）

Hill密码是一种基于矩阵的加密技术，它将明文转换为密文，通过矩阵乘法完成加密过程。以下是Python编写的一个简单的希尔密码实现，不需要使用numpy库：

def matrix_multiply(a, b):
    # 扩展位运算来处理矩阵乘法
    result = [[0] * len(b[0]) for _ in range(len(a))]
    for i in range(len(a)):
        for j in range(len(b[0])):
            for k in range(len(b)):
                result[i][j] ^= a[i][k] ^ b[k][j]
    return result

def encrypt(plaintext, key_matrix):
    # 将明文分为等长的块，并转化为字符到数字的映射
    plaintext_blocks = [list(map(ord, block)) for block in zip(*[iter(plaintext)] * 5)]
    
    # 加密每个块
    encrypted_blocks = []
    for block in plaintext_blocks:
        encrypted_block = matrix_multiply(block, key_matrix)
        encrypted_blocks.append([chr(c % 26 + 'a'.encode('utf-8')[0]) for c in encrypted_block])
        
    # 合并加密后的块
    ciphertext = ''.join(''.join(block) for block in encrypted_blocks)
    return ciphertext

def decrypt(ciphertext, key_matrix):
    return encrypt(ciphertext, inverse(key_matrix))

# 生成随机的2x2关键矩阵（希尔密码通常使用2x2矩阵）
key_matrix = [
    [7, 1],
    [4, 9]
]

# 示例：加密和解密
plaintext = "Hello, World!"
ciphertext = encrypt(plaintext, key_matrix)

print(f"Plaintext: {plaintext}")
print(f"Ciphertext: {ciphertext}")

decrypted_text = decrypt(ciphertext, key_matrix)
print(f"Decrypted Text: {decrypted_text}")

在这个例子中，我们首先定义了两个函数：`matrix_multiply`用于计算矩阵的异或乘法，以及`encrypt`和`decrypt`分别用于加密和解密。请注意，由于希尔密码的局限性，它只适用于小字母，且长度需能整除5。

python不使用librosa库，通过FFT实现变调不变速，音频信号采样率为44.1kHz，时长2秒，要求先将输入信号处理为数组，尽量不要使用numpy的广播特性，请考虑滤波、重采样等方法，以及考虑使用分块处理或流氏处理，不用着急回答我，尽可能完善地考虑进多因素再回答

好的，这是一个更加完善的实现方法。首先，我们需要对输入信号进行预处理，包括滤波和重采样。滤波可以帮助去除信号中的噪声，而重采样可以降低信号的采样率，使得后续处理更加高效。下面是一个示例代码：

import wave
import struct
import math
import scipy.signal

def preprocess_signal(filename, target_sr=16000):
    # 打开音频文件
    with wave.open(filename, 'rb') as wav:
        # 获取采样率
        sr = wav.getframerate()
        # 获取每个采样的位数
        samplewidth = wav.getsampwidth()
        # 获取音频信号的通道数
        nchannels = wav.getnchannels()
        # 获取音频信号的帧数
        nframes = wav.getnframes()
        # 读取音频信号
        data = wav.readframes(nframes)

    # 将二进制数据转换为整数数组
    if samplewidth == 2:
        # 16位采样
        fmt = f'<{nframes * nchannels}h'
    else:
        # 8位采样
        fmt = f'<{nframes * nchannels}B'
    data = struct.unpack(fmt, data)

    # 将整数数组转换为浮点数数组
    if samplewidth == 2:
        # 16位采样，将整数转换为浮点数
        data = [x / 32768.0 for x in data]
    else:
        # 8位采样，将整数转换为浮点数
        data = [x / 128.0 - 1.0 for x in data]

    # 滤波
    nyquist = 0.5 * sr
    b, a = scipy.signal.butter(4, [20 / nyquist, 5000 / nyquist], btype='band')
    data = scipy.signal.filtfilt(b, a, data)

    # 重采样
    if sr != target_sr:
        resample_ratio = float(target_sr) / sr
        data = scipy.signal.resample(data, int(nframes * resample_ratio))

    return data, target_sr

接下来，我们可以将音频信号进行分块处理，以避免内存溢出。具体来说，我们可以将整段音频分成多个块，每个块的长度为一个窗口大小。对于每个块，我们先将其进行FFT变换，然后对其进行变调操作，并使用逆FFT变换将其转换回时域信号。最后，我们将多个块拼接起来，得到最终的输出信号。下面是一个示例代码：

def pitch_shift(data, sr, n_steps):
    # 定义变调系数
    pitch_ratio = 2.0 ** (n_steps / 12.0)

    # 定义窗口大小和步长
    window_size = 1024
    hop_size = 256

    # 定义FFT参数
    n_fft = window_size
    win = scipy.signal.hann(window_size)

    # 定义输出数组
    out_data = []

    # 将输入信号分成多个块
    n_frames = len(data) // hop_size
    for i in range(n_frames):
        # 计算当前块的起始位置和结束位置
        start = i * hop_size
        end = start + window_size

        # 取出当前块的数据
        x = data[start:end]

        # 进行FFT变换
        X = scipy.fft.fft(x * win, n=n_fft)

        # 对频域信号进行缩放
        freqs = scipy.fft.fftfreq(n_fft, 1.0 / sr)
        scale = pitch_ratio ** (freqs / sr)
        X = X * scale

        # 进行逆FFT变换
        y = scipy.fft.ifft(X, n=n_fft).real

        # 将当前块的数据添加到输出数组中
        out_data.extend(y)

    # 将浮点数数组转换为整数数组
    if samplewidth == 2:
        # 16位采样，将浮点数转换为整数
        out_data = [int(x * 32767.0) for x in out_data]
    else:
        # 8位采样，将浮点数转换为整数
        out_data = [int((x + 1.0) * 128.0) for x in out_data]

    # 将整数数组转换为二进制数据
    if samplewidth == 2:
        # 16位采样
        fmt = f'<{len(out_data)}h'
        out_data = struct.pack(fmt, *out_data)
    else:
        # 8位采样
        fmt = f'<{len(out_data)}B'
        out_data = struct.pack(fmt, *out_data)

    return out_data

最后，我们可以将输出信号写入到音频文件中：

def write_wave(filename, data, sr):
    with wave.open(filename, 'wb') as wav:
        wav.setframerate(sr)
        wav.setnchannels(1)
        wav.setsampwidth(2)
        wav.writeframes(data)

这样就完成了变调不变速的实现。需要注意的是，这个实现方法可能比较耗时，特别是对于大型音频文件，可能需要一定的时间来处理。如果需要更快的处理速度，可以考虑使用GPU加速。