最近在跟着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 rd
number = 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('游戏结束,你没有猜到')
需求分析:
算法思路
count = 0
for 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 = day
if year % 4 == 0 and year % 100 !=0 or year % 400 == 0:
print(f'{year}年是闰年')
date_list[1]=29
else:
print(f'{year}年是平年')
date_list[1]=28
for 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 = 1
print(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 np
pop_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 = 11
count = 0
left = 0
right = len(arr_list)-1
while 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}')
break
else:
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 -1
print(binary_search(11,0,len(arr_list)-1))
基本思想:从未排序的序列中找到一个最小的元素,放到第一位,再从剩余未排序的序列中找到最小的元素,放到第二位,依此类推,直到所有元素都排序完毕
import random as rd
sec_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 rd
print('=' * 60)
print(' ' * 20, '剪刀石头布游戏')
print('1代表剪刀 2代表石头 3代表布')
game_info = {1: "剪刀", 2: "石头", 3: "布"}
score = 100
while 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 sum
list1 = []
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
# 5832104976
def 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_words
print(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
# 50
def 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
# 3
analyse_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)) # 55
print(fib(2)) # 1
递归与栈的关系
递归函数原理:每一次调用都会把当前调用压入到栈里,最后按照后进先出的原则,不停返回返回
由递归程序的执行过程,我们得知递归程序的调用是一层层向下的,而返回过程则恰好相反,一层层向上。
换个说法:最先一次的函数调用在最后返回,而最后一次的函数调用则是最先返回。这就跟栈的“后进先出”次序是一样的。因此,在实现递归调用的时候,通常就会使用栈来保存每一次调用的现场数据:
己知数字a,b,c分别为10,6,18
找出a,b,c中最大的数字(不借助函数以及列表等方式)
我们知道函数max可以直接获取到最大值,或者可以把数字添加到列表里,通过排序也能获取到最大数字,我们单纯使用if分支来实现
a, b, c = 10, 6, 18
if a > b:
max_num = a
else:
max_num = b
if max_num < c:
max_num = c
print(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_sum
for 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 = 0
for 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('()')) # True
print(valid_str('()[]{}')) # True
print(valid_str('()[]{[()]}')) # True
print(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 stack
print(valid_str('(){}[({[]})]')) # True
print(valid_str('(){}[({[)})]')) # False
print(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)) # True
print(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 // 10
print(is_palindrome(1221)) # True
print(is_palindrome(1223)) # False
print(is_palindrome(123321)) # True