(编辑：jimmy 日期: 2024/12/26 浏览：2)
最近在跟着B站的视频（aHR0cHM6Ly93d3cuYmlsaWJpbGkuY29tL3ZpZGVvL0JWMW5xNHkxazdCNA==）学习，完整看完了，记的所有笔记，这些题目也可灵活多变，你可以思考，如何去使用C、JAVA、GO等语言实现，记得留在评论区，一起学习，共同成长。
水仙花数（Narcissistic number）也被称为超完全数字不变数（pluperfect digital invariant, PPDI）、自恋数、自幂数、阿姆斯壮数或阿姆斯特朗数（Armstrong number），水仙花数是指一个 3 位数，它的每个位上的数字的 3次幂之和等于它本身。例如：1^3 + 5^3+ 3^3 = 153。
for i in range(100, 1000): i1 = i // 100 # 取百位数字 123//100=1 i2 = i // 10 % 10 # 取十位数字 123//10=12 12%10=2 i3 = i % 10 # 取个位数字 123%10=3 if i1 ** 3 + i2 ** 3 + i3 ** 3 == i: print(f"{i}是水仙花数") # 153 是水仙花数 # 370 是水仙花数 # 371 是水仙花数 # 407 是水仙花数四叶玫瑰数是4位数的自幂数。自幂数是指一个 n 位数，它的每个位上的数字的 n 次幂之和等于它本身。（例如：当n为3时，有1^3 + 5^3 + 3^3 = 153，153即是n为3时的一个自幂数，3位数的自幂数被称为水仙花数）。
for i in range(1000,10000): 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 # print(i,i1,i2,i3,i4) if i1 ** 4 + i2 ** 4 + i3 ** 4 + i4 ** 4 == i: print(f'{i}是四叶玫瑰数') # 1634 是四叶玫瑰数 # 8208 是四叶玫瑰数 # 9474 是四叶玫瑰数# 写法1：切片方式str = input("请输入字符串")print(str[::-1])# 写法2：循环转换str = input("请输入字符串")list = []for x in range(len(str) -1,-1,-1): list.append(str[x])print(''.join(list))需求分析：
import random as rdnumber = rd.randint(0,100)for i in range(10): choice = int(input("请输入你要猜测的数字：")) if choice > number: print("你猜大了") elif choice < number: print("你猜小了") else: print("你猜对了，真棒！") print(f'你一共用了{i + 1}次机会') break print(f'还剩{9 - i}次机会')else: print('游戏结束，你没有猜到')需求分析：
5x+3y+z/3 = 100
算法思路
count = 0for x in range(1,20): for y in range(1,33): z = 100 - x -y if z > 0 and 5 * x + 3 * y + z / 3 == 100: count += 1 print("="*60) print(f'第{count}种买法，公鸡买了{x}只，母鸡买了{y}只，小鸡买了{z}只') # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第1种买法，公鸡买了4只，母鸡买了18只，小鸡买了78只 # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第2种买法，公鸡买了8只，母鸡买了11只，小鸡买了81只 # == == == == == == == == == == == == == == == == == == == == == == == == == == == == == == # 第3种买法，公鸡买了12只，母鸡买了4只，小鸡买了84只输入年月日，输出该日期是否是闰年，并且输出该日期是此年份的第几天
闰年判断条件：
算法思路
year = int(input("请输入年份"))month = int(input("请输入月份"))day = int(input("请输入日期"))date_list = [31,29,31,30,31,30,31,31,30,31,30,31]count_day = dayif year % 4 == 0 and year % 100 !=0 or year % 400 == 0: print(f'{year}年是闰年') date_list[1]=29else: print(f'{year}年是平年') date_list[1]=28for i in range(month-1): count_day += date_list[i]print(f'{year}年{month}月{day}日是当年的第{count_day}天')需求分析：
猴子第一天摘下若干个桃子，当即吃了一半，还不过瘾，又多吃了一个。
第二天早上又将剩下的桃子吃掉一半，又多吃了一个。
以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。
求原来它一共摘了多少个桃子。
这题得倒着推。第10天还没吃，就剩1个，说明第9天吃完一半再吃1个还剩1个。
假设第9天还没吃之前有桃子p个
可得：p/2 - 1 = 1，得出第九天的桃子数p=4。
以此类推，即可算出第一天摘了多少桃子.
算法思路
p = 1print(f'第10天还剩下{p}个桃子')for i in range(9,0,-1): p = (p + 1) * 2 print(f'第{i}天还剩下{p}个桃子')print(f'第一天一共摘了{p}个桃子')# 第10天还剩下1个桃子# 第9天还剩下4个桃子# 第8天还剩下10个桃子# 第7天还剩下22个桃子# 第6天还剩下46个桃子# 第5天还剩下94个桃子# 第4天还剩下190个桃子# 第3天还剩下382个桃子# 第2天还剩下766个桃子# 第1天还剩下1534个桃子# 第一天一共摘了1534个桃子冒泡排序算法由来
这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端(升序或降序排列)，就如同碳酸饮料中二氧化碳的气泡最终会上浮到顶端一样，故名“冒泡排序”从前到后(即从下标较小的元素开始) 依次比较相邻元素的值，若发现比后一个值大则交换位置，使值较大的元素逐渐从前移向后部。
假设有一个列表 [29 ,12 ,19 ,37 ,14] 想升序
第一轮
第二轮
第三轮
第四轮
import numpy as nppop_list = np.random.randint(100,size=6)# pop_list = [82,15,15,41,37,31]# pop_list = [29,12,19,37,14]count = len(pop_list)print('没排序之前的列表',pop_list)for i in range(count-1): for j in range(count-i-1): if pop_list[j] > pop_list[j + 1]: # 如果要降序就是改成 < 号 pop_list[j],pop_list[j+1] = pop_list[j+1],pop_list[j]print('排好序的列表为',pop_list)# 排好序的列表为 [15, 15, 31, 37, 41, 82]# 排好序的列表为 [12, 14, 19, 29, 37]二分法是一种效率比较高的搜索方法
回忆之前做过的猜数字的小游戏，预先给定一个小于100的正整数x，让你猜，猜测过程中给予大小判断的提示，问你怎样快速地猜出来？ 我们之前做的游戏给定的是10次机会，如果我们学会二分查找法以后，不管数字是多少，最多只需要7次就能猜到数字
二分查找法
首先先猜50，如果猜对了，结束；如果猜大了，往小的方向猜，再猜25；如果猜小了，往大的方向猜，再猜75；...每猜测1次就去掉一半的数，这样我们就可以逐步逼近预先给定的数字.这种思想就是二分法。
二分法适用情况
算法思路
第一种 纯算法的方式
arr_list = [5,7,11,22,27,33,39,52,58]number = 11count = 0left = 0right = len(arr_list)-1while left<=right: middle = (left+right)//2 count += 1 if number > arr_list[middle]: left = middle +1 elif number < arr_list[middle]: right = middle - 1 else: print(f'数字{number}已找到，索引值为{middle}') breakelse: print(f'数字{number}没有找到')print(f'一共用了{count}次查找') 数字11已找到，索引值为2 一共用了3次查找第二种 递归函数的方式
arr_list = [5,7,11,22,27,33,39,52,58]def binary_search(number,left,right): if left <= right: middle = (left + right) // 2 if number < arr_list[middle]: right = middle - 1 elif number > arr_list[middle]: left = middle + 1 else: return middle return binary_search(number,left,right) else: return -1print(binary_search(11,0,len(arr_list)-1))基本思想：从未排序的序列中找到一个最小的元素，放到第一位，再从剩余未排序的序列中找到最小的元素，放到第二位，依此类推，直到所有元素都排序完毕
import random as rdsec_list = [rd.randint(1,100) for i in range(8)]# sec_list = [91,30,93,98,26,98,20,90]length = len(sec_list)print(f'未排序的列表为：{sec_list}')for i in range(length -1): min_index = i for j in range(i + 1,length): if sec_list[min_index] > sec_list[j]: min_index = j sec_list[min_index],sec_list[i] = sec_list[i],sec_list[min_index] print(f'第{i+1}轮排好序是：{sec_list}')print(f'最终排好序的列表为：{sec_list}')# 未排序的列表为：[91, 30, 93, 98, 26, 98, 20, 90]# 第1轮排好序是：[20, 30, 93, 98, 26, 98, 91, 90]# 第2轮排好序是：[20, 26, 93, 98, 30, 98, 91, 90]# 第3轮排好序是：[20, 26, 30, 98, 93, 98, 91, 90]# 第4轮排好序是：[20, 26, 30, 90, 93, 98, 91, 98]# 第5轮排好序是：[20, 26, 30, 90, 91, 98, 93, 98]# 第6轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98]# 第7轮排好序是：[20, 26, 30, 90, 91, 93, 98, 98]# 最终排好序的列表为：[20, 26, 30, 90, 91, 93, 98, 98]游戏开始，初始状态下用户和电脑都有100分，赢一局+10分，输一局-10分。当用户为0分时，游戏结束，提示游戏结束，比赛输了，当用户为200分时，游戏结束，提示游戏结束，赢得比赛、每轮比赛都输出当前的分数
1代表剪刀 2代表石头 3代表布
import random as rdprint('=' * 60)print(' ' * 20, '剪刀石头布游戏')print('1代表剪刀 2代表石头 3代表布')game_info = {1: "剪刀", 2: "石头", 3: "布"}score = 100while True: robots_choice = rd.randint(1, 3) user_choice = input("请出拳") if user_choice not in '123': print('出拳错误，请重新出拳') continue user_choice = int(user_choice) print('*' * 60) print(f'电脑出{game_info[robots_choice]}') print(f'你出{game_info[user_choice]}') print('*' * 60) if user_choice == 1 and robots_choice == 3 or user_choice == 2 \ and robots_choice == 1 or user_choice == 3 and robots_choice == 2: score += 10 print(f'你赢得本轮游戏，当前分数为{score}') elif user_choice == robots_choice: print(f'本轮游戏平局，当前分数为{score}') else: score -= 10 print(f'你输了本轮游戏，当前分数{score}') if score >= 200: print('游戏结束，你赢得比赛') break elif score <= 0: print('游戏结束，你输了') break在给定的数字下，该数字所有数位(digits)的平方和，得到的新数再次求所有数位的平方和，如此重复进行，最终结果必定为1
比如数字：19
def sum_square(n): sum = 0 for i in str(n): sum += int(i) ** 2 return sumlist1 = []n = int(input('请输入数字：'))while sum_square(n) not in list1: n = sum_square(n) list1.append(n)if n == 1: print('是快乐数')else: print('不是快乐数')for i in range(1,100): for j in range(1,i): if i*j == 6*(i+j) and i-j<8: print(i,j)# 15 10美国数学家维纳(N.Wiener)智力早熟，11岁就上了大学。
他曾在1935~1936年应邀来中国清华大学讲学。
一次，他参加某个重要会议，年轻的脸孔引人注目。于是有人询问他的年龄，
他回答说：“我年龄的立方是个4位数。我年龄的4次方是个6位数。
这10个数字正好包含了从0到9这10个数字，每个都恰好出现1次。“
请你推算一下，他当时到底有多年轻
for i in range(10,30): i3 = str(i ** 3) i4 = str(i ** 4) if len(i3) == 4 and len(i4) == 6: if len(set(i3+i4)) == 10: print(i) print(i3 + i4)# 18# 5832104976def split_s(string, sep="", num=0): split_words = [] last_index = 0 count = 0 for index, char in enumerate(string): if count == num and num > 0: split_words.append(string[last_index:len(string)]) break if char == sep: split_words.append(string[last_index:index]) last_index = index + 1 count += 1 elif index + 1 == len(string): split_words.append(string[last_index:index + 1]) return split_wordsprint(split_s("life-is-short-you-need-python",'-'))# ['life', 'is', 'short', 'you', 'need', 'python']print(split_s("life-is-short-you-need-python",'-',2))# ['life', 'is', 'short-you-need-python']中国古代文献中，曾记载过“大衍数列”，主要用于解释中国传统文化中的太极衍生原理
它的前几项是：0、2、4、8、12、18、24、32、40、50...
其规律是：偶数项，是序号平方再除2，奇数项，是序号平方减1再除2。
打印大衍数列的前100项
for x in range(1,101): if x % 2 == 0: # 偶数 a = int((x ** 2) / 2) else: # 奇数 a = int((x ** 2 - 1) / 2) print(a)# 0# 2# 4# 8# 12# 18# 24# 32# 40# 50def analyse_words(words): word_dict = {} for i in words: if i in word_dict: word_dict[i] += 1 else: word_dict[i] = 1 max_key = max(word_dict,key=word_dict.get) print(max_key) print(word_dict[max_key]) # l # 3analyse_words('helloworld')输入边长n，打印对应边长的菱形
分析：
def diamond(n): stack = [] for i in range(1, 2 * n): if i <= n: p_str = ' ' * (n - i) + '*' * (2 * i - 1) if i != n: stack.append(p_str) print(p_str) else: print(stack.pop())diamond(5)# 为了区分我把空格换成了点# ....*# ...***# ..*****# .*******# *********# .*******# ..*****# ...***# ....*什么是递归函数？
递归函数就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。
递归函数必须有结束条件。
设计递归函数三要素：
def p(n): if n == 0: return print('递归前->',n) p(n-1) print('递归后->',n)p(5)# 递归前-> 5# 递归前-> 4# 递归前-> 3# 递归前-> 2# 递归前-> 1# 递归后-> 1# 递归后-> 2# 递归后-> 3# 递归后-> 4# 递归后-> 5斐波那契数列(Fibonacci sequence)，又称黄金分割数列，因数学家莱昂纳多·斐波那契(Leonardo Fibonacci)以兔子繁殖为例子而引入，故又称为“兔子数列”，指的是这样一个数列：
1、1、2、3、5、8、13、21、34、...
这个数列，前两项都是数字1，从第三项开始，每一项数字是前两项数字之和关系表达式【f(n) = f(n-1)+f(n-2)】
def fib(n): if n<=2: return 1 return fib(n-1)+fib(n-2)print(fib(10)) # 55print(fib(2)) # 1递归与栈的关系
递归函数原理：每一次调用都会把当前调用压入到栈里，最后按照后进先出的原则，不停返回返回
由递归程序的执行过程，我们得知递归程序的调用是一层层向下的，而返回过程则恰好相反，一层层向上。
换个说法：最先一次的函数调用在最后返回，而最后一次的函数调用则是最先返回。这就跟栈的“后进先出”次序是一样的。因此，在实现递归调用的时候，通常就会使用栈来保存每一次调用的现场数据：
己知数字a，b，c分别为10，6，18
找出a，b，c中最大的数字(不借助函数以及列表等方式)
我们知道函数max可以直接获取到最大值，或者可以把数字添加到列表里，通过排序也能获取到最大数字，我们单纯使用if分支来实现
a, b, c = 10, 6, 18if a > b: max_num = aelse: max_num = bif max_num < c: max_num = cprint(max_num) # 18什么是因子？
因子就是所有可以整除这个数的数字，包括1但不包括这个数自身。比如8的因子有1，2，4什么是完数？
一个数如果恰好等于它的因子之和，这个数就称为“完数”，打印输出1000以内的完数，例如6=1+2+3，6就是“完数
def factor_sum(n): s_sum = 0 for i in range(1, n): if n % i == 0: s_sum += i return s_sumfor j in range(1, 1000): if j == factor_sum(j): print(j) # 6 # 28 # 496一个正整数的阶乘(factorial)是所有小于及等于该数的正整数之积，并且0的阶乘为1
如5!=1*2*3*4*5计算1!+2!+3!+4!+5!+…+10!关系表达式【f(n) = n*f(n-1)】def factor(n): if n < 2: return 1 return n * factor(n - 1)s_sum = 0for i in range(1, 11): s_sum += factor(i)print(s_sum) # 4037913给定一个只包括'('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
示例 1：
输入："()"
输出：True
示例 2：
输入："()[]{}"
输出：True
示例 3：
输入："(]"
输出：False
示例 4：
输入："([)]"
输出：False
解法一：字符串替换法
在字符串中找成对的()、[]、{}，找到后替换成空
使用while循环，不停判断是否存在成对的小括号中括号大括号，如果存在就使用replace替换成空
直到无法再替换的时候，再判断下当前的字符串是否为空，如果为空说明字符串是有效的，如果不为空说明字符串是无效的
def valid_str(string): if len(string) % 2 == 1: return False while '()' in string or '[]' in string or '{}' in string: string = string.replace('()', '') string = string.replace('[]', '') string = string.replace('{}', '') return string == ''print(valid_str('()')) # Trueprint(valid_str('()[]{}')) # Trueprint(valid_str('()[]{[()]}')) # Trueprint(valid_str('()[]{[(}]}')) # False解法二：利用栈的后进先出原则
先去定义一个空栈，对当前栈进行循环遍历，遇到左括号我们就把当前的左括号添加到栈里面，遇到右括号，我们就和栈顶元素进行比对
看它们是不是成对的括号，如果是，就把当前的元素出栈，直到字符串遍历结束之后，我们再来看下字符串是不是空的，如果是空的说明字符串是有效的，如果不为空说明字符串是无效的
def valid_str(string): if len(string) % 2 == 1: return False stack = [] char_dict = { ')': '(', '}': '{', ']': '[' } for char in string: if char in char_dict: # 右括号 if not stack or char_dict[char] != stack.pop(): return False else: # 左括号 stack.append(char) return not stackprint(valid_str('(){}[({[]})]')) # Trueprint(valid_str('(){}[({[)})]')) # Falseprint(valid_str('')) # True回文数是指正序(从左向右)和倒序(从右向左)都是一样的整数。例如，1221是回文，而1222不是。
解法一：通过逆转字符串进行比对
def is_palindrome(x): if x < 0 or x > 0 and x % 10 == 0: return False str_x = str(x) return str_x == str_x[::-1]print(is_palindrome(121)) # Trueprint(is_palindrome(120)) # False解法二：反转一半数字和前半部分的数字进行比较
流程
数字长度（奇数）
12321
数字长度（偶数）
1221
def is_palindrome(x): if x < 0 or x > 0 and x % 10 == 0: return False reverted = 0 while x > reverted: # 我们看下 1221 # 第一次循环我们需要把末尾数字1取出来 第二次取末尾数字2 我们需要把21变成12 reverted = reverted * 10 + x % 10 # 把x的末尾数字删除掉 x //= 10 return x == reverted or x == reverted // 10print(is_palindrome(1221)) # Trueprint(is_palindrome(1223)) # Falseprint(is_palindrome(123321)) # True