题目来源:
Python语法的25个练习题
https://www.52pojie.cn/thread-1689186-1-1.html
第12、15、24题为作业,请留在评论区,不调用任何模块的方式实现。
题目1:水仙花数
.版本 2.支持库 spec.子程序 题目1_水仙花数.局部变量 start, 整数型.局部变量 stop, 整数型.局部变量 i, 整数型, , , 100~999.局部变量 i1, 整数型.局部变量 i2, 整数型.局部变量 i3, 整数型start = 100stop = 1000.变量循环首 (start, stop - 1, 1, i) ' i = 123 ' 假设 i1 = i \ 100 ' 取百位数字 123//100=1 i2 = i \ 10 % 10 ' 取十位数字 123//10=12 12%10=2 i3 = i % 10 ' 取个位数字 123%10=3 .如果真 (到整数 (求次方 (i1, 3)) + 到整数 (求次方 (i2, 3)) + 到整数 (求次方 (i3, 3)) = i) 调试输出 (到文本 (i) + “是水仙花数”) ' 153是水仙花数 ' 370是水仙花数 ' 371是水仙花数 ' 407是水仙花数 .如果真结束.变量循环尾 ()
题目2:四叶玫瑰数
.版本 2.支持库 spec.子程序 题目2_四叶玫瑰数.局部变量 start, 整数型.局部变量 stop, 整数型.局部变量 i, 整数型, , , 1000~9999.局部变量 i1, 整数型.局部变量 i2, 整数型.局部变量 i3, 整数型.局部变量 i4, 整数型start = 1000stop = 10000.变量循环首 (start, stop - 1, 1, i) ' i = 1234 ' 假设 i1 = i \ 1000 ' 取千位数字 1234//1000=1 i2 = i \ 100 % 10 ' 取百位数字 1234//100=12 12%10=2 i3 = i \ 10 % 10 ' 取十位数字 1234//10=123 123%10=3 i4 = i % 10 ' 取个位数字 1234%10=4 .如果真 (到整数 (求次方 (i1, 4)) + 到整数 (求次方 (i2, 4)) + 到整数 (求次方 (i3, 4)) + 到整数 (求次方 (i4, 4)) = i) 调试输出 (到文本 (i) + “是四叶玫瑰数”) ' 1634是四叶玫瑰数 ' 8208是四叶玫瑰数 ' 9474是四叶玫瑰数 .如果真结束.变量循环尾 ()
题目3:逆序输出字符串
.版本 2.支持库 spec.子程序 题目3_逆序输出字符串.局部变量 str, 文本型, , , 只允许数字或字母.局部变量 len, 整数型, , , 不考虑中文,需特殊处理(1个汉字占2字节).局部变量 i, 整数型.局部变量 ret, 文本型标准输出 (#标准输出设备, “请输入字符串” + #换行符)str = 标准输入 ()' str = “123456”' str = “abcdefghijklmnopqrstuvwxyz”' str = “52pojie_OVVO”len = 取文本长度 (str).变量循环首 (len, 1, -1, i) ret = ret + 取文本中间 (str, i, 1).变量循环尾 ()调试输出 (ret)
题目4:猜数字小游戏
.版本 2.支持库 spec.子程序 题目4_猜数字小游戏.局部变量 number, 整数型, , , 0~100都有可能.局部变量 i, 整数型.局部变量 choice, 整数型.局部变量 ok, 逻辑型置随机数种子 ()number = 取随机数 (0, 100)调试输出 (“嘘~这是随机数:” + 到文本 (number)).计次循环首 (10, i) 标准输出 (#标准输出设备, “请输入你要猜测的数字:” + #换行符) choice = 到整数 (标准输入 ()) .如果 (choice > number) 调试输出 (“你猜大了”) .否则 .如果 (choice < number) 调试输出 (“你猜小了”) .否则 ok = 真 调试输出 (“你猜对了,真棒!”) 调试输出 (“你一共用了” + 到文本 (i) + “次机会”) 跳出循环 () .如果结束 .如果结束 调试输出 (“还剩” + 到文本 (10 - i) + “次机会”).计次循环尾 ().如果真 (ok = 假) 调试输出 (“游戏结束,你没有猜到”)
题目5:百鸡百钱
.版本 2.支持库 spec.子程序 题目5_百鸡百钱.局部变量 count, 整数型.局部变量 x, 整数型.局部变量 y, 整数型.局部变量 z, 整数型count = 0.变量循环首 (1, 20 - 1, 1, x) .变量循环首 (1, 33 - 1, 1, y) z = 100 - x - y .如果真 (z > 0 且 5 × x + 3 × y + z ÷ 3 = 100) count = count + 1 调试输出 (取重复文本 (60, “=”)) 调试输出 (“第” + 到文本 (count) + “种买法,公鸡买了” + 到文本 (x) + “只,母鸡买了” + 到文本 (y) + “只,小鸡买了” + 到文本 (z) + “只”) ' ============================================================ ' 第1种买法,公鸡买了4只,母鸡买了18只,小鸡买了78只 ' ============================================================ ' 第2种买法,公鸡买了8只,母鸡买了11只,小鸡买了81只 ' ============================================================ ' 第3种买法,公鸡买了12只,母鸡买了4只,小鸡买了84只 .如果真结束 .变量循环尾 ().变量循环尾 ()
题目6:闰年问题升级版
.版本 2.支持库 spec.子程序 题目6_闰年问题升级版.局部变量 year, 整数型.局部变量 month, 整数型.局部变量 day, 整数型.局部变量 date_list, 整数型, , "0".局部变量 count_day, 整数型.局部变量 i, 整数型标准输出 (#标准输出设备, “请输入年份” + #换行符)year = 到整数 (标准输入 ())标准输出 (#标准输出设备, “请输入月份” + #换行符)month = 到整数 (标准输入 ())标准输出 (#标准输出设备, “请输入日期” + #换行符)day = 到整数 (标准输入 ())' year = 2022' month = 10' day = 3date_list = { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }count_day = day.如果 (year % 4 = 0 且 year % 100 ≠ 0 或 year % 400 = 0) 调试输出 (到文本 (year) + “年是闰年”) date_list [2] = 29.否则 调试输出 (到文本 (year) + “年是平年”) date_list [2] = 28.如果结束.计次循环首 (month - 1, i) count_day = count_day + date_list [i].计次循环尾 ()调试输出 (到文本 (year) + “年” + 到文本 (month) + “月” + 到文本 (day) + “日是当年的第” + 到文本 (count_day) + “天”)' 2022年是平年' 2022年10月3日是当年的第276天
题目7:猴子吃桃问题
.版本 2.支持库 spec.子程序 题目7_猴子吃桃问题.局部变量 p, 整数型.局部变量 i, 整数型p = 1调试输出 (“第10天还剩下” + 到文本 (p) + “个桃子”).变量循环首 (9, 1, -1, i) p = (p + 1) × 2 调试输出 (“第” + 到文本 (i) + “天还剩下” + 到文本 (p) + “个桃子”).变量循环尾 ()调试输出 (“第一天一共摘了” + 到文本 (p) + “个桃子”)' 第10天还剩下1个桃子' 第9天还剩下4个桃子' 第8天还剩下10个桃子' 第7天还剩下22个桃子' 第6天还剩下46个桃子' 第5天还剩下94个桃子' 第4天还剩下190个桃子' 第3天还剩下382个桃子' 第2天还剩下766个桃子' 第1天还剩下1534个桃子' 第一天一共摘了1534个桃子
题目8:冒泡排序
.版本 2.支持库 spec.子程序 题目8_冒泡排序.局部变量 pop_list, 整数型, , "0".局部变量 count, 整数型.局部变量 i, 整数型.局部变量 j, 整数型' pop_list = { 82, 15, 15, 41, 37, 31 }pop_list = { 29, 12, 19, 37, 14 }count = 取数组成员数 (pop_list)调试输出 (“没排序之前的列表”, pop_list).计次循环首 (count, i) .计次循环首 (count - i, j) .如果真 (pop_list [j] > pop_list [j + 1]) 交换变量 (pop_list [j], pop_list [j + 1]) .如果真结束 .计次循环尾 ().计次循环尾 ()调试输出 (“排好序的列表为”, pop_list)' {15, 15, 31, 37, 41, 82}' {12, 14, 19, 29, 37}
题目9:二分查找法
第一种 纯算法的方式
.版本 2.支持库 spec.子程序 题目9_二分查找法_纯算法.局部变量 arr_list, 整数型, , "0".局部变量 number, 整数型.局部变量 count, 整数型.局部变量 left, 整数型.局部变量 right, 整数型.局部变量 middle, 整数型.局部变量 ok, 逻辑型arr_list = { 5, 7, 11, 22, 27, 33, 39, 52, 58 }number = 11count = 0left = 0right = 取数组成员数 (arr_list) - 1.判断循环首 (left ≤ right) middle = (left + right) \ 2 count = count + 1 .如果 (number > arr_list [middle + 1]) left = middle + 1 .否则 .如果 (number < arr_list [middle + 1]) right = middle - 1 .否则 ok = 真 调试输出 (“数字” + 到文本 (number) + “已找到,索引值为” + 到文本 (middle)) 跳出循环 () .如果结束 .如果结束.判断循环尾 ().如果 (ok = 假) 调试输出 (“数字” + 到文本 (number) + “没有找到”).否则 调试输出 (“一共用了” + 到文本 (count) + “次查找”).如果结束' 数字11已找到,索引值为2' 一共用了3次查找
第二种 递归函数的方式
.版本 2.支持库 spec.子程序 binary_search, 整数型, 公开.参数 arr_list, 整数型, 参考 数组.参数 number, 整数型.参数 left, 整数型.参数 right, 整数型.局部变量 middle, 整数型.如果 (left ≤ right) middle = (left + right) \ 2 .如果 (number < arr_list [middle]) right = middle - 1 .否则 .如果 (number > arr_list [middle]) left = middle + 1 .否则 返回 (middle) .如果结束 .如果结束 返回 (binary_search (arr_list, number, left, right)).否则 返回 (-1).如果结束返回 (0).子程序 题目9_二分查找法_递归函数的方式.局部变量 arr_list, 整数型, , "0"arr_list = { 5, 7, 11, 22, 27, 33, 39, 52, 58 }调试输出 (binary_search (arr_list, 11, 0, 取数组成员数 (arr_list) - 1)) ' 3
题目10:选择排序
.版本 2.支持库 spec.子程序 题目10_选择排序.局部变量 sec_list, 整数型, , "0".局部变量 length, 整数型.局部变量 i, 整数型.局部变量 min_index, 整数型.局部变量 j, 整数型sec_list = { 91, 30, 93, 98, 26, 98, 20, 90 }length = 取数组成员数 (sec_list)调试输出 (“未排序的列表为:”, sec_list).计次循环首 (length, i) min_index = i .变量循环首 (i, length, 1, j) .如果真 (sec_list [min_index] > sec_list [j]) min_index = j .如果真结束 .变量循环尾 () 交换变量 (sec_list [min_index], sec_list [i]) 调试输出 (“第” + 到文本 (i) + “轮排好序是:”, sec_list).计次循环尾 ()调试输出 (“最终排好序的列表为:”, sec_list)' 数组:8{20,26,30,90,91,93,98,98}
题目11:剪刀石头布
.版本 2.支持库 spec.子程序 题目11_剪刀石头布.局部变量 game_info, 文本型, , "0".局部变量 score, 整数型.局部变量 是否跳出, 逻辑型.局部变量 robots_choice, 整数型.局部变量 user_choice, 整数型调试输出 (取重复文本 (60, “=”))调试输出 (取重复文本 (20, “ ”), “剪刀石头布游戏”)调试输出 (“1代表剪刀 2代表石头 3代表布”)加入成员 (game_info, “剪刀”)加入成员 (game_info, “石头”)加入成员 (game_info, “布”)score = 100置随机数种子 ()是否跳出 = 假.判断循环首 (是否跳出 = 假) robots_choice = 取随机数 (1, 3) 标准输出 (#标准输出设备, “请出拳” + #换行符) user_choice = 到整数 (标准输入 ()) .如果真 (寻找文本 (到文本 (user_choice), “1”, , 假) = -1 且 寻找文本 (到文本 (user_choice), “2”, , 假) = -1 且 寻找文本 (到文本 (user_choice), “3”, , 假) = -1) 调试输出 (“出拳错误,请重新出拳”) 到循环尾 () .如果真结束 调试输出 (取重复文本 (60, “*”)) 调试输出 (“电脑出” + game_info [robots_choice]) 调试输出 (“你出” + game_info [user_choice]) 调试输出 (取重复文本 (60, “*”)) .如果 (user_choice = 1 且 robots_choice = 3 或 user_choice = 2 且 robots_choice = 1 或 user_choice = 3 且 robots_choice = 2) score = score + 10 调试输出 (“你赢得本轮游戏,当前分数为” + 到文本 (score)) .否则 .如果 (user_choice = robots_choice) 调试输出 (“本轮游戏平局,当前分数为” + 到文本 (score)) .否则 score = score - 10 调试输出 (“你输了本轮游戏,当前分数” + 到文本 (score)) .如果结束 .如果结束 .如果 (score ≥ 200) 调试输出 (“游戏结束,你赢得比赛”) 跳出循环 () .否则 .如果 (score ≤ 0) 调试输出 (“游戏结束,你输了”) 跳出循环 () .否则 .如果结束 .如果结束.判断循环尾 ()
题目12:快乐数
调试输出 ("请完善")
题目13:猜年龄(一)
.版本 2.支持库 spec.子程序 题目13_猜年龄_一.局部变量 i, 整数型.局部变量 j, 整数型.变量循环首 (1, 100 - 1, 1, i) .变量循环首 (1, i - 1, 1, j) .如果真 (i × j = 6 × (i + j) 且 i - j < 8) 调试输出 (i, j) ' 15 | 10 .如果真结束 .变量循环尾 ().变量循环尾 ()
题目14:猜年龄(二)
.版本 2.支持库 spec.子程序 数组_去重复_整数型, 整数型, 公开, 返回剩余不重复数组的成员数量.参数 整数数组, 整数型, 参考 数组, 要去重复的 整数数组.局部变量 成员数, 整数型.局部变量 i, 长整数型.局部变量 a, 整数型数组排序 (整数数组, 真)成员数 = 取数组成员数 (整数数组)i = 0a = 1.判断循环首 (a ≤ 成员数) i = i + 1 整数数组 [i] = 整数数组 [a] .循环判断首 () a = a + 1 .如果真 (a > 成员数) 跳出循环 () .如果真结束 .循环判断尾 (整数数组 [i] = 整数数组 [a]).判断循环尾 ()重定义数组 (整数数组, 真, i)返回 (i).子程序 题目14_猜年龄_二.局部变量 i, 整数型.局部变量 i3, 文本型.局部变量 i4, 文本型.局部变量 arr, 整数型, , "0".局部变量 a, 整数型.变量循环首 (10, 30 - 1, 1, i) i3 = 到文本 (到整数 (求次方 (i, 3))) i4 = 到文本 (到整数 (求次方 (i, 4))) .如果真 (取文本长度 (i3) = 4 且 取文本长度 (i4) = 6) 清除数组 (arr) .计次循环首 (取文本长度 (i3), a) 加入成员 (arr, 到整数 (取文本中间 (i3, a, 1))) .计次循环尾 () .计次循环首 (取文本长度 (i4), a) 加入成员 (arr, 到整数 (取文本中间 (i4, a, 1))) .计次循环尾 () 数组_去重复_整数型 (arr) .如果真 (取数组成员数 (arr) = 10) 调试输出 (i) ' 18 调试输出 (i3 + i4) ' 5832104976 .如果真结束 .如果真结束.变量循环尾 ()
题目15:split算法实现
调试输出 ("请完善")
题目16:大衍数列
.版本 2.支持库 spec.子程序 题目16_大衍数列.局部变量 x, 整数型.局部变量 a, 整数型.变量循环首 (1, 101 - 1, 1, x) .如果 (x % 2 = 0) ' 偶数 a = 到整数 (求次方 (x, 2) \ 2) .否则 a = 到整数 ((求次方 (x, 2) - 1) \ 2) .如果结束 调试输出 (a) ' 0 ' 2 ' 4 ' 8 ' 12 ' 18 ' 24 ' 32 ' 40 ' 50 ' ....变量循环尾 ()
题目17:单词分析
.版本 2.支持库 e2ee.支持库 spec.子程序 analyse_words, , , 需要E2EE支持库.参数 words, 文本型.局部变量 len, 整数型.局部变量 i, 整数型.局部变量 arr, 文本型, , "0".局部变量 key, 文本型.局部变量 json, 存取键值表.局部变量 value, 整数型.局部变量 最大值的_key, 文本型.局部变量 最大值的_value, 整数型len = 取文本长度 (words).计次循环首 (len, i) 加入成员 (arr, 取文本中间 (words, i, 1)).计次循环尾 ()' 数组:10{“h”,“e”,“l”,“l”,“o”,“w”,“o”,“r”,“l”,“d”}.计次循环首 (取数组成员数 (arr), i) key = arr [i] json.置整数 (key, json.取整数 (key) + 1).计次循环尾 ()' {"h":1,"e":1,"d":1,"l":3,"w":1,"o":2,"r":1}arr = json.取键数组 ().计次循环首 (取数组成员数 (arr), i) key = arr [i] value = json.取整数 (key) .如果 (i = 1) 最大值的_key = key 最大值的_value = value .否则 .如果真 (value ≥ 最大值的_value) 最大值的_key = key 最大值的_value = value .如果真结束 .如果结束.计次循环尾 ()调试输出 (最大值的_key) ' l调试输出 (最大值的_value) ' 3.子程序 题目17_单词分析analyse_words (“helloworld”)
题目18:利用栈打印菱形
.版本 2.支持库 spec.子程序 diamond.参数 n, 整数型.局部变量 stack, 文本型, , "0".局部变量 i, 整数型.局部变量 p_str, 文本型' stack = { }.计次循环首 (2 × n - 1, i) .如果 (i ≤ n) p_str = 取重复文本 (n - i, “ ”) + 取重复文本 (2 × i - 1, “*”) .如果真 (i ≠ n) 加入成员 (stack, p_str) .如果真结束 调试输出 (p_str) .否则 调试输出 (stack [取数组成员数 (stack)]) 删除成员 (stack, 取数组成员数 (stack), 1) .如果结束.计次循环尾 ()' ....*' ...***' ..*****' .*******' *********' .*******' ..*****' ...***' ....*.子程序 题目18_利用栈打印菱形diamond (5)
题目19:深入理解递归函数
.版本 2.支持库 spec.子程序 p.参数 n, 整数型.如果真 (n = 0) 返回 ().如果真结束调试输出 (“递归前->”, n)p (n - 1)调试输出 (“递归后->”, n).子程序 题目19_深入理解递归函数p (5)' “递归前->” | 5' “递归前->” | 4' “递归前->” | 3' “递归前->” | 2' “递归前->” | 1' “递归后->” | 1' “递归后->” | 2' “递归后->” | 3' “递归后->” | 4' “递归后->” | 5
题目20:斐波那契递归函数
.版本 2.支持库 spec.子程序 fib, 整数型.参数 n, 整数型.如果真 (n ≤ 2) 返回 (1).如果真结束返回 (fib (n - 1) + fib (n - 2)).子程序 题目20_斐波那契递归函数调试输出 (fib (10)) ' 55调试输出 (fib (2)) ' 1
题目21:三个数取最大数
.版本 2.支持库 spec.子程序 题目21_三个数取最大数.局部变量 a, 整数型.局部变量 b, 整数型.局部变量 c, 整数型.局部变量 max_num, 整数型a = 10b = 6c = 18.如果 (a > b) max_num = a.否则 max_num = b.如果结束.如果真 (max_num < c) max_num = c.如果真结束调试输出 (max_num) ' 18
题目22:因子之和“完数”
.版本 2.支持库 spec.子程序 factor_sum, 整数型.参数 n, 整数型.局部变量 s_sum, 整数型.局部变量 i, 整数型s_sum = 0.变量循环首 (1, n - 1, 1, i) .如果真 (n % i = 0) s_sum = s_sum + i .如果真结束.变量循环尾 ()返回 (s_sum).子程序 题目22_因子之和_完数.局部变量 j, 整数型.变量循环首 (1, 1000 - 1, 1, j) .如果真 (j = factor_sum (j)) 调试输出 (j) ' 6 ' 28 ' 496 .如果真结束.变量循环尾 ()
题目23:递归阶乘求和
.版本 2.支持库 spec.子程序 factor, 整数型.参数 n, 整数型.如果真 (n < 2) 返回 (1).如果真结束返回 (n × factor (n - 1)).子程序 题目23_递归阶乘求和.局部变量 s_sum, 整数型.局部变量 i, 整数型s_sum = 0.变量循环首 (1, 11 - 1, 1, i) s_sum = s_sum + factor (i).变量循环尾 ()调试输出 (s_sum) ' 4037913
题目24:有效的括号
调试输出 ("请完善")
题目25:回文数的两种解法
解法一:通过逆转字符串进行比对
.版本 2.支持库 spec.子程序 is_palindrome_1, 逻辑型.参数 x, 整数型.局部变量 str_x, 文本型.局部变量 len, 整数型.局部变量 i, 整数型.局部变量 ret, 文本型.如果真 (x < 0 或 x > 0 且 x % 10 = 0) 返回 (假).如果真结束str_x = 到文本 (x)len = 取文本长度 (str_x).变量循环首 (len, 1, -1, i) ret = ret + 取文本中间 (str_x, i, 1).变量循环尾 ()返回 (str_x = ret).子程序 题目25_回文数的两种解法_一调试输出 (is_palindrome_1 (121)) ' 真调试输出 (is_palindrome_1 (120)) ' 假
解法二:反转一半数字和前半部分的数字进行比较
.版本 2.支持库 spec.子程序 is_palindrome_2, 逻辑型.参数 x, 整数型.局部变量 reverted, 整数型.如果真 (x < 0 或 x > 0 且 x % 10 = 0) 返回 (假).如果真结束reverted = 0.判断循环首 (x > reverted) reverted = reverted × 10 + x % 10 x = x \ 10.判断循环尾 ()返回 (x = reverted 或 x = reverted \ 10).子程序 题目25_回文数的两种解法_二调试输出 (is_palindrome_2 (1221)) ' 真调试输出 (is_palindrome_2 (1223)) ' 假调试输出 (is_palindrome_2 (123321)) ' 真
广告合作:本站广告合作请联系QQ:858582 申请时备注:广告合作(否则不回)
免责声明:本站资源来自互联网收集,仅供用于学习和交流,请遵循相关法律法规,本站一切资源不代表本站立场,如有侵权、后门、不妥请联系本站删除!
三星在GTC上展示了专为下一代游戏GPU设计的GDDR7内存。
首次推出的GDDR7内存模块密度为16GB,每个模块容量为2GB。其速度预设为32 Gbps(PAM3),但也可以降至28 Gbps,以提高产量和初始阶段的整体性能和成本效益。
据三星表示,GDDR7内存的能效将提高20%,同时工作电压仅为1.1V,低于标准的1.2V。通过采用更新的封装材料和优化的电路设计,使得在高速运行时的发热量降低,GDDR7的热阻比GDDR6降低了70%。