Python-6

def question_judge(question):
    """接收一个字符串为参数，根据参数值判断问题类型，调用合适的函数进行操作。"""
    if question == '素数':       # 如果输入”素数“，再输入一个正整数n，输出不大于n的所有素数
        n = int(input())
        output_prime(n)         # 输出素数
    elif question == '回文素数':
        n = int(input())
        palindromic_prime(n)   # 输出回文素数
    elif question == '反素数':
        n = int(input())
        reverse_prime(n)  # 输出反素数
    elif question == '哥德巴赫猜想':
        n = int(input())
        goldbach_conjecture(n)
    else:
        print('输入错误')


def is_prime(n):
    """判断素数的函数,接收一个正整数为参数，参数是素数时返回True，否则返回False
    减小判定区间，减少循环次数，提升效率"""
##点击在此输入一行或多行代码
    if n < 2:
        return False
    for i in range(2,int(n / 2) + 1):
        if n % i == 0:
            return False
    else:
        return True

def output_prime(number):
    """接收一个正整数为参数，遍历从0到number之间的所有整数
    在一行中输出不大于number的所有素数，函数无返回值"""
##点击在此输入一行或多行代码
    for i in range(number + 1):
        if is_prime(i):
            print(i,end = ' ')
            

            
def palindromic(num):
    """接收一个数字为参数，判定其是否为回文数，返回布尔值。"""
    if str(num) == str(num)[::-1]:
        return True
    else:
        return False


def palindromic_prime(number):
    """接收一个正整数参数number，遍历从0到number之间的所有整数，
    若某个数是素数，且转为字符串后是回文字符串，则称其中回文素数
    找出并在同一行中从小到大输出小于number的所有回文素数，各数字间用一个空格分隔，
    函数无返回值"""
    for i in range(number + 1):
        if palindromic(i) and is_prime(i):
            print(i,end = ' ')


def reverse_num(num):
    """接收一个整数，返回其逆序字符串对应的整数"""
    return int(str(num)[::-1])


def reverse_prime(number):
    """接收一个正整数参数，找出并在同一行内输出所有小于number的反素数，数字间用一个空格分隔。
    反素数指某数i及其逆序数都是素数，但数i对应的字符串不是回文字符串
    函数无返回值"""
##点击在此输入一行或多行代码
    for i in range(number + 1):
        if is_prime(i) and is_prime(reverse_num(i)):
            if not palindromic(i):
                print(i,end = ' ')

def goldbach_conjecture(num):
    """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
    当参数为不小于4的偶数时，将其分解为两个素数的加和，按小数+数的格式输出。
    有多种组合时全部输出，但不输出重复的组合，例如输出8=3+5，不输出8=5+3。
    参数为奇数或小于4时，输出'Data error!'
    """
##点击在此输入一行或多行代码
    if num >= 4:
        if num % 2 == 0:
            for i in range(1,int(num/2)):
                if is_prime(i) and is_prime(num - i):
                    print('{} = {} + {}'.format(num,i,num-i))

    else:
        print('Data error!')
if __name__ == '__main__':
    problems = input()
    question_judge(problems)

素数求和

def isprime(n):
    for i in range(2,int(n**0.5)+1):
        if n%i==0:
            return 0
    else:
        return 1
def f(n):
    s=0
    t=0
    q=''
    for i in range(n,1,-1):
        if isprime(i)==1:
            ls.insert(0,str(i))
            s+=i
            t+=1
        if t==10:
            return '+'.join(ls)+'='+str(s)
ls=[]
p=int(input())
print(f(p))

使用凯撒密码加密和解密英文文件

import string


def judge(txt):
    """接收一个字符串为参数，如果参数值为“加密”,要求用户输入一个要加密的文件名，
    再输入一个单词做为密钥发生器，用于计算偏移量，对文件中的内容进行加密并输出。
    如果参数值为“解密”,要求用户输入一个要解密的文件名，再输入一个单词做为匹配词，
    用于破解偏移量，输出解密后的文本。若为其他输入，输出'输入错误'。"""
    if txt == '加密':
        name = input()
        code = input()
        print(caesar_cipher(read_txt(name),cal_offset(code)))
    elif txt == '解密':
        name = input()
        code = input()
        print(caesar_decrypt(read_txt(name),find_offset(code,read_txt(name))))
    else:
        print('输入错误')


def read_txt(file):
    """接收文件名为参数，读取文件中的内容为一个字符串，返回这个字符串。"""
    with open(file, 'r') as temp:
        return temp.read()

def caesar_cipher(text, offset):
    """接收一个字符串为参数，采用字母表和数字中后面第offset个字符代替当前字符的方法
    对字符串中的字母和数字进行替换，实现加密效果，返回值为加密的字符串。
    例如：2019 abc 替换为5342 def """
    before = string.ascii_letters + string.digits
    after = string.ascii_lowercase[offset:] + string.ascii_lowercase[:offset] + string.ascii_uppercase[offset:] + string.ascii_uppercase[:offset] + string.digits[offset:] + string.digits[:offset]
    t = ''.maketrans(before, after)
    return text.translate(t)



def caesar_decrypt(text, offset):
    """接收一个加密的字符串text和一个整数offset为参数，采用字母表和数字中前面第offset个字符
    代替当前字符的方法对字符串中的字母和数字进行替换，实现解密效果，返回值为解密的字符串。"""
    before = string.ascii_letters + string.digits
    after = string.ascii_lowercase[offset:] + string.ascii_lowercase[:offset] + string.ascii_uppercase[offset:] + string.ascii_uppercase[:offset] + string.digits[offset:] + string.digits[:offset]
    t = ''.maketrans(after, before)
    return text.translate(t)



def cal_offset(key_word):
    """接收一个单词为参数，计算这个单词的每个字母的ASCII值的和，
    再对9取模，结果作为偏移量offset，返回这个偏移量。"""
    a=sum(ord(ch) for ch in key_word)
    offset = a % 9
    return offset



def find_offset(key_text, ciphertext):
    """接收一个明文单词和一个加密字符串为参数，尝试用[0,8]之间的数为偏移量进行解密。
    若解密结果中包含这个明文单词，说明当前正在尝试的偏移量就是加密时所用偏移量，返回
    这个整数偏移量。
    """
    for i in range(8):
        before = string.ascii_letters + string.digits
        after = string.ascii_lowercase[i:] + string.ascii_lowercase[:i] + string.ascii_uppercase[i:] + string.ascii_uppercase[:i] + string.digits[i:] + string.digits[:i]
        t = ''.maketrans(before, after)
        if key_text.translate(t) in ciphertext:
            return i



if __name__ == '__main__':
    task = input()
    judge(task)

完美立方数

from math import *

N=int(input())
for a in range (N+1):
    for b in range (2,a):
        for c in range (b,a):
            for d in range (c,a):
                if pow(a,3)==pow(b,3)+pow(c,3)+pow(d,3):
                      print("Cube = {:.0f},Triple = ({:.0f},{:.0f},{:.0f})".format(a,b,c,d))

分解质因数

（提示：先创建一个空列表ls = [],从小到大寻找质因数，每找到一个质因数 a 就执行 ls.append(a) 加入到列表中，最后输出列表 ls 就可以了）

Is = []
n = int(input())
while n>1:
    for i in range(2,n+1):
        if n%i==0:
            n=int(n/i)
            Is.append(int(i))
            break
print(Is)

完数

def sum(n):	
	s = 0
	list=[] #存放因子
	for i in range(1,int(n/2)+1):
		if n%i == 0:
			s += i
			list.append(i)			
		if s == n and i == int(n/2): #确保遍历所有的因子
			return list
	return False

a = int(input())
j = 6
count = 0

while count<a:
	list = sum(j)
	if list:
		count += 1
		print('%d='%j,end='')
		for x in list:
			if x == list[-1]: #最后一个因子后面不加'+'
				print('%d'%x)
			else:
				print('%d+'%x,end='')
	j+=1;