当前位置:   article > 正文

python123输出N以内的所有素数&哥德巴赫猜想&扑克牌游戏_扑克牌游戏 描述python123

扑克牌游戏 描述python123

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

编程找出N(即小于等于N)的所有素数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入一个正整数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

在同一行中从小到大依次输出不大于n的全部素数,每个数字后面一个空格。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例 1‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

  1. 输入:97
  2. 输出:2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

答案如下:

  1. def is_prime(n):
  2. """判断素数的函数,接收一个正整数为参数,参数是素数时返回True,否则返回False
  3. 减小判定区间,减少循环次数,提升效率"""
  4. if n < 2:
  5. return False # 0、1、负数以及偶数都不是素数
  6. for i in range(2, int(n ** 0.5) + 1):
  7. if n % i == 0: # 能被2到其n-1之间的数整除的数不是素数
  8. return False
  9. else:
  10. return True # for循环正常结束,未遇到return的数是素数
  11. def output_prime(number):
  12. """接收一个正整数为参数,遍历从0到number之间的所有整数
  13. 在一行中输出不大于number的所有素数,函数无返回值"""
  14. for i in range(number + 1): # 遍历小于n的整数
  15. if is_prime(i): # i为素数时输出i
  16. print(i, end=' ') # 输出后不换行,空格分隔输出
  17. positive_int = int(input()) # 输入一个正整数
  18. output_prime(positive_int) # 调用无返回值函数,不需要用print()

 哥德巴赫猜想是这个:

描述‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

1742年,哥德巴赫给欧拉的信中提出了以下猜想“任一大于2的整数都可写成三个质数之和”。常见的猜想陈述为欧拉的版本,即任一大于2的偶数都可写成两个素数之和,亦称为“强哥德巴赫猜想”或“关于偶数的哥德巴赫猜想”。比如:24=5+19,其中5和19都是素数。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入一个正整数N,当输入为偶数时,分行按照格式“N = p + q”输出N的所有素数分解,其中p 、 q均为素数且p ≤ q。当输入为奇数或N<4时,输出'Data error!' 。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入一个正整数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出格式‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

当输入为偶数时,分行按照格式“N = p + q”输出N的所有素数分解,其中p 、 q均为素数且p ≤ q。当输入为奇数或N<4时,输出'Data error!' 。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

示例 1‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

  1. 输入:30
  2. 输出:
  3. 30=7+23
  4. 30=11+19
  5. 30=13+17

示例 2‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

  1. 输入:77
  2. 输出:
  3. Data error!
  1. def is_prime(n):
  2. """判断素数的函数,接收一个正整数为参数,参数是素数时返回True,否则返回False"""
  3. if n < 2:
  4. return False # 0、1、负数以及偶数都不是素数
  5. for i in range(2, int(n ** 0.5) + 1):
  6. if n % i == 0: # 能被2到其n-1之间的数整除的数不是素数
  7. return False
  8. else:
  9. return True # for循环正常结束,未遇到return的数是素数
  10. def goldbach_conjecture(num):
  11. """ 哥德巴赫猜想, 接收一个不小于4的正整数为参数。
  12. 当参数为不小于4的偶数时,将其分解为两个素数的加和,按小数+数的格式输出。
  13. 有多种组合时全部输出,但不输出重复的组合,例如输出8=3+5,不输出8=5+3。
  14. 参数为奇数或小于4时,输出'Data error!'
  15. """
  16. if num % 2 == 0 and num >= 4: # 只判定偶数
  17. for i in range(num // 2+1): # 超过num // 2的组合为重复组合
  18. if is_prime(i) and is_prime(num - i):
  19. print(f"{num}={i}+{num-i}")
  20. else:
  21. print('Data error!')
  22. if __name__ == '__main__':
  23. positive_even = int(input()) # 输入一个正数
  24. goldbach_conjecture(positive_even)

 扑克牌游戏是这个:

描述

  1. 本题限定用以下方法打乱序列中的元素
  2. random.shuffle()

 几个人用一副扑克牌玩游戏,游戏过程通常有洗牌、发牌、理牌等动作,编写程序模拟游戏过程。新牌花色顺序为♠、♥、♣、♦,花色相同时按2、3、4、5、6、7、8、9、10、J、Q、K、A,最后是小王和大王,小王用'jokers'、大王用 'JOKERS'表示。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

按以下要求编写程序:‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

  1. 按顺序输出新牌
  2. 洗牌
  3. 按洗好的顺序输出洗过的牌
  4. 将牌轮流分给参与游戏的人,按分牌的顺序输出每个人手上的牌
  5. 对每个人手上的牌升序排序并输出
  6. 输出时,每张牌间用空格分隔

输入

输入一个正整数表示参与游戏的人数,题目限定使每个人分到的牌数相同,即人数为54的约数‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入一个正整数表示随机数种子,本题使用随机数种子保证产生序列的稳定性来完成自动评测‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输出

按顺序输出新牌
按洗好的顺序输出洗过的牌
按分牌的顺序输出每个人手上的牌
输出每个人手上升序排序的牌‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‫‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‭‬

输入输出示例

输入输出
示例 1
  1. 2
  2. 1024
  1. 参与游戏的人数:2
  2. 新牌顺序
  3. 2345678910 ♠J ♠Q ♠K ♠A ♥2345678910 ♥J ♥Q ♥K ♥A ♣2345678910 ♣J ♣Q ♣K ♣A ♦2345678910 ♦J ♦Q ♦K ♦A jokers JOKERS
  4. 洗牌顺序
  5. ♣K ♠27 ♠J ♦9 jokers ♣8283 ♣A ♥K ♠9 ♥J ♦J ♣5 ♠A ♠K ♣J ♥510 ♥Q ♣34897310210 ♦K ♦2856 ♠Q ♦577 ♦Q ♥96 ♣Q ♣644 ♦A ♥46103 ♥A JOKERS
  6. 每个人手上分到的牌
  7. ♣K ♠7988 ♣A ♠9 ♦J ♠A ♣J ♠10387101025 ♠Q ♦7 ♦Q ♠664410 ♥A
  8. 2 ♠J jokers ♥23 ♥K ♥J ♣5 ♠K ♥5 ♥Q ♦4932 ♦K ♠86579 ♣Q ♣4 ♦A ♥63 JOKERS
  9. 每个人手上排序的牌
  10. 4567910 ♠Q ♠A ♥4810 ♥A ♣367810 ♣J ♣K ♣A ♦278910 ♦J ♦Q
  11. 238 ♠J ♠K ♥235679 ♥J ♥Q ♥K ♣2459 ♣Q ♦3456 ♦K ♦A jokers JOKERS

答案如下:

  1. import random
  2. def start():
  3. """初始顺序,返回元素为字符串的列表"""
  4. cards_start = [i + j for i in desigh for j in num] + ghost
  5. return cards_start
  6. def shuffle_cards(cards_start):
  7. """打乱顺序,返回元素为字符串的列表"""
  8. random.shuffle(cards_start)
  9. return cards_start
  10. def traver(cards_shuffle, m):
  11. """发牌给m个人,返回二维列表"""
  12. person = []
  13. for i in range(m):
  14. person.append(cards_shuffle[i::m])
  15. return person
  16. def sort_cards(person, m):
  17. """对m个人手上的牌进行升序排序,花色按黑红梅方,牌面按点数,大王最大,小王第二大"""
  18. person_sort = []
  19. for i in range(m):
  20. if ('jokers' in person[i]) and ('JOKERS' in person[i]):
  21. person[i].remove('jokers')
  22. person[i].remove('JOKERS')
  23. person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['jokers', 'JOKERS'])
  24. elif 'jokers' in person[i]:
  25. person[i].remove('jokers')
  26. person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['jokers'])
  27. elif 'JOKERS' in person[i]:
  28. person[i].remove('JOKERS')
  29. person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:])))+['JOKERS'])
  30. else:
  31. person_sort.append(sorted(person[i], key=lambda x: (desigh.index(x[0]), num.index(x[1:]))))
  32. return person_sort
  33. if __name__ == '__main__':
  34. desigh = ['♠', '♥', '♣', '♦'] # 表示黑桃、红桃、梅花、方块
  35. num = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
  36. ghost = ['jokers', 'JOKERS']
  37. n = int(input()) # 输入参与游戏的人数
  38. s = int(input())
  39. random.seed(s)
  40. print(f'参与游戏的人数:{n}')
  41. cards = start()
  42. print('新牌顺序')
  43. print(*cards)
  44. cards_after = shuffle_cards(cards)
  45. print('洗牌顺序')
  46. print(*cards_after)
  47. cards_n = traver(cards_after, n)
  48. print('每个人手上分到的牌')
  49. for i in range(n):
  50. print(*cards_n[i])
  51. cards_sort = sort_cards(cards_n, n)
  52. print('每个人手上排序的牌')
  53. for i in range(n):
  54. print(*cards_sort[i])

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/知新_RL/article/detail/423689
推荐阅读
相关标签
  

闽ICP备14008679号