2021总结

最新推荐文章于 2024-04-30 11:11:45 发布
最新推荐文章于 2024-04-30 11:11:45 发布
阅读量340 收藏 1
点赞数 1
文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46576480/article/details/122363880
版权

python基础：

python菜鸟教程100例：

题目1：

有四个数字：1、2、3、4，能组成多少个互不相同且无重复数字的三位数？各是多少？

#coding=utf-8
count = 0
for i in range(1,5):
    for j in  range(1,5):
        for k in range(1,5):
            if (i != j) and (i != k) and (j != k):
                print(i,j,k)
                count += 1
print('能组成{}个'.format(count))

 for循环语句，嵌套循环，再排除不符合条件三位数 

题目2：

企业发放的奖金根据利润提成。利润(I)低于或等于10万元时，奖金可提10%；利润高于10万元，低于20万元时，低于10万元的部分按10%提成，高于10万元的部分，可提成7.5%；20万到40万之间时，高于20万元的部分，可提成5%；40万到60万之间时高于40万元的部分，可提成3%；60万到100万之间时，高于60万元的部分，可提成1.5%，高于100万元时，超过100万元的部分按1%提成，从键盘输入当月利润I，求应发放奖金总数？

I = int(input())
X = [1000000, 600000, 400000, 200000, 100000, 0]
Y = [0.01, 0.015, 0.03, 0.05, 0.075, 0.1]
r = 0
for i in range(0,6):
    if I > X[i]:
        r += (I - X[i]) * Y[i]
        print((I - X[i]) * Y[i])
        I = X[i]
print('-'*30)
print(r)

列表索引+循环语句+条件语句，input输入函数，int将输入的数转换成整型 

python数据类型： 

dic = {

    'A': 'J, J, 6',
    'B': 'K, K, 10',
    'C': '2, 9, 9, 8'

}
print(dic)
print('A:', dic['A'])
print(dic.get('A'))


 #字典的健组成的列表
print(dic.keys())
print('A' in dic.keys()) #判断

 #字典的值组成的列表
print(dic.values())

  #返回字典的键值对组成的列表
print(dic.items())

for k,v in dic.items():   #遍历字典
    print(k, '=>', v)

'''del 字典[健]：删除指定的键值对
    字典.pop(key)：删除指定的键值对
    字典1.update(字典2):字典1合并字典2 对于字典1中已有的健用字典2覆盖'''

 #快速生成列表，列表推导式，字典推导式，集合推导式
l = [x for x in range(10) if x % 2 == 0]
print(l)

d1 = {n : n**2 for n in range(5)}
print(d1)
d2 = {q: w for q, w in d1.items()}
print(d2)

#模拟抽奖
import random
ln = ['张三','刘二','李四','杨五']
print(ln[random.randint(0,3)])
print(random.choice(ln))

fruits = ("apple", "banana", "cherry")
(green, yellow, red) = fruits
print(green)
print(yellow)
print(red)
print(len(dic))

 

题目3：

一个整数，它加上100后是一个完全平方数，再加上168又是一个完全平方数，请问该数是多少？

for i in range(1,85):
    j = 168/i
    if (i+j) % 2 == 0 and (j-i) % 2 == 0:
        m = (i+j)/2
        n = (j-i)/2
        x1 = n**2 - 100
        x2 = m**2 - 100- 168
        print(x1 , x2)
        if x1 == x2:
            print('x{}'.format(x1))
            print('-' * 30)

两个完全平方数为：m，n

i = (m-n), j=(m+n)

i*j =168

i，j要么都是奇数，要么都是偶数

题目4：

输入某年某月某日，判断这一天是这一年的第几天？

year = int(input('year'))
month = int(input('month'))
day = int(input('day'))

def All_day(year, month, day):
    month_day_list = [0,31,28,31,30,31,30,31,31,30,31,30,31]
    sum = 0
    for i in range(month):
        if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
            month_day_list1 = month_day_list
            month_day_list1[2] = 29
            sum += month_day_list1[i]
        else:
            sum += month_day_list[i]
    sum += day
    print(sum)

All_day(year,month,day)

列表索引，求和，判断是否闰年，闰年二月为29天

题目5：

输入三个整数x,y,z，请把这三个数由小到大输出。

list = []
for i in range(3):
    a = input(i)
    list.append(a)
list.sort()
print(list)

list.append()在列表最后追加元素，新增多个元素可以用list.extend()，还有在列表中间添加元素list.insert(x,y),两个参数第一个要插入新元素的位置，第二个参数表示要插入的新元素

list.sort()对列表进行排序，sort会修改并对原列表排序，每没有返回值

 题目6：

斐波那契数列。

def fib(n):
    result = []
    a, b = 0, 1
    result.append(b)
    for i in range(n):
        a, b = b, a+b
        result.append(b)
    print(result)


n  = int(input())
fib(n)

[1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 

a,b为0，1，则有b=a+b，将b加入列表result，循环操作

题目7：

将一个列表的数据复制到另一个列表中。

a = [1,2,3,4,5]
b = a.copy()
print(b)

b = a
print(b)

b = a[:]
print(b)

一个是copy，切片赋值

题目8：

输出 9*9 乘法口诀表。

for i in range(1,10):
    for j in  range(1,1+i):
        print('%d*%d=%d' %(i,j,i*j),end='\t')
    print()

......
循环制表，格式化输出

题目9：

暂停一秒输出。

import time
dic = {

    'A': 'J, J, 6',
    'B': 'K, K, 10',
    'C': '2, 9, 9, 8'

}
for k,v in dic.items():
    print(k,v)
    time.sleep(1)

调用import模块，遍历字典键值对，暂停一秒输出 

题目10：

暂停一秒输出，并格式化当前时间

import time
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))
time.sleep(1)
print(time.strftime('%Y-%m-%d %H:%M:%S',time.localtime()))

%Y-%m-%d：年月日的格式化输出分别是四位数年份，月份，月内的一天

 %H:%M:%S：二十四小时制，分钟数，秒

time.localtime：将时间戳格式化为本地时间

题目11：

古典问题：有一对兔子，从出生后第3个月起每个月都生一对兔子，小兔子长到第三个月后每个月又生一对兔子，假如兔子都不死，问每个月的兔子总数为多少？


num,num1 = 0,1
for i in range(10):
    num, num1 = num1 , num+num1
    print(num1)

兔子个数为斐波那契数列1，1，2，3，5，8，13，21......

题目12：

判断101-200之间有多少个素数，并输出所有素数。

count = 1
for i  in range(101, 201):
    for j in range(2,i):
        if i % j == 0:
            break
    else:
        print(i)
        count += 1
print(count)

除了1和本身外不能被整除，排除能被整除的数，不能整除数输出，个数加1

 题目13：

打印出所有的"水仙花数"，所谓"水仙花数"是指一个三位数，其各位数字立方和等于该数本身。例如：153是一个"水仙花数"，因为153=1的三次方＋5的三次方＋3的三次方。

for num in range(100,1000):
    i = num//100
    j = (num//10) % 10
    k = num % 10
    if num == pow(i,3) + pow(j,3) + pow(k,3):
        print(num)

找出个位十位百位进行判断 

题目14：

将一个正整数分解质因数。例如：输入90,打印出90=2*3*3*5。

#coding=utf-8

n = int(input('请输入一个整数：'))
print(n,'=',end='')
while n>1:
    for i in range(2,n+1):
        if n%i==0:
            n=int(n/i)
            if n==1:
                print(i,end='')
            else:
                print('{}*'.format(i),end='')
            break

循环进行除法，如果能除尽，n就等于n/i，然后把i输出，当n=1 时分解完毕，每得到一个因数就重新开始循环

题目15：

利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。

#coding=utf-8

'''题目：利用条件运算符的嵌套来完成此题：学习成绩>=90分的同学用A表示，60-89分之间的用B表示，60分以下的用C表示。'''

a = int(input('输入成绩'))
if a >= 90:
    print('学生成绩为A')
elif 60<= a <=89:
    print('学生成绩为B')
elif a <60:
    print('学生成绩为C')

最基本的条件判断.....

题目16：

输出指定格式的日期。

#coding=utf-8

'''题目：输出指定格式的日期。'''
import datetime

date = datetime.date.today()
print(date.isoformat())

print(date.strftime('%d-%m-%Y'))
print(date.strftime('%d-%m-%y'))
print(date.strftime('%Y-%b-%d'))
print(date.strftime('%Y-%B-%d'))

对于datetime库的应用，其中除了strftime方法还有date方法，today方法，weekday方法，isoformat方法

时间日期格式化符号：%y   %Y   %m   %d  %H  %I  %M  %S  %a  %A  %b  %B  %c   %j 等

题目17：

输入一行字符，分别统计出其中英文字母、空格、数字和其它字符的个数。

#coding=utf-8

import string

str = input('请输入字符串：')
count_eng = 0
count_num = 0
count_space = 0
count_other = 0
for i in str:
    if i.isalpha():
        count_eng += 1
    elif i.isspace():
        count_space += 1
    elif i.isdigit():
        count_num += 1
    else:
        count_other += 1
print('英文字母个数：%d 数字个数：%d 空格个数：%d 其他：%d ' %(count_eng,count_num,count_space,count_other))

条件判断，计数，对字符中进行遍历，isalpha(), isspace(), isdigit() 分别是判断字符中的英文，空格，数字

题目18：

求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制。

#coding=utf-8

'''题目：求s=a+aa+aaa+aaaa+aa...a的值，其中a是一个数字。例如2+22+222+2222+22222(此时共有5个数相加)，几个数相加由键盘控制'''

from functools import reduce
list = []
a1 = 0
a = int(input('a='))
n = int(input('n='))
for i in range(n):
    a1 = a1 + a
    a = a * 10
    list.append(a1)
print(list)
print(reduce(lambda x,y: x+y, list))

每次把数乘以10再加上原来的数，再把得到的数放入列表，使用reduce方法得到和，rudece方法其中有一个参数需要函数，这里使用匿名函数lambda，这类函数不需要去定义函数的名字lambda等价于def，在程序只执行一次，不需要定义函数，使用lambda表达式更方便，另外在某些函数中必须以函数作为参数时，例如上面的reduce，还有filter等 可以使用

题目19：

一个数如果恰好等于它的因子之和，这个数就称为"完数"。例如6=1＋2＋3.编程找出1000以内的所有完数。

#coding=utf-8


for n in range(2,10001):
    list = []
    for i in range(2,n):
        for j in range(2,n):
            if (i * j == n and i <= j):
                if(j!=n):
                 list.append(i)
                 list.append(j)
    sum=1
    for b in list:
         sum=sum + b
    if sum == n:
        print(n)
        print(list)

将数进行因数分解，在因数不等于本身的时候，将两个因数放入列表，得到所有因数后遍历列表相加，当求出来的和与原数相等的时候输出

题目20：

一球从100米高度自由落下，每次落地后反跳回原高度的一半；再落下，求它在第10次落地时，共经过多少米？第10次反弹多高？

#coding=utf-8

t = 1
h = 100
sum_h = 100
while t <=10:
    h = h/2
    sum_h = sum_h + (2 * h)
    t += 1
    if t == 10:
        print(h)
        print(sum_h)

第一次时小球走过路程为100，后面高度每次都是前一次的一半，但小球路程经过下落和反弹，所以要计算两次，循环操作就行

题目21：

猴子吃桃问题：猴子第一天摘下若干个桃子，当即吃了一半，还不瘾，又多吃了一个第二天早上又将剩下的桃子吃掉一半，又多吃了一个。以后每天早上都吃了前一天剩下的一半零一个。到第10天早上想再吃时，见只剩下一个桃子了。求第一天共摘了多少。

#coding=utf-8

sum = 0
x = 1
for i in range(9,0,-1):
    sum = (x+1)* 2
    x = sum
print(sum)

从后往前算，最后一天剩一个，每次吃一半加一个，累加 

题目22：

两个乒乓球队进行比赛，各出三人。甲队为a,b,c三人，乙队为x,y,z三人。已抽签决定比赛名单。有人向队员打听比赛的名单。a说他不和x比，c说他不和x,z比，请编程序找出三队赛手的名单。

#coding=utf-8


A = ['a', 'b', 'c']
B = ['x', 'y', 'z']
lst = []
for i in A:
    for j in B:
        if i+j != 'ax' and i+j !='cx' and i+j !='cz':
            lst.append(i+j)
print(lst)

遍历两个队伍， a说他不和x比，c说他不和x,z比，当比赛不是ax，cx，cz时将小队比赛加入列表，最后输出

题目23：

打印出如下图案（菱形）:

#coding=utf-8

for i in range(4):
    for k in range(2-i+1):
        print(' ',end='')
    for j in range(2*i+1):
        print('*',end='')
    print(' ')

for x in range(3):
    for y in range(x+1):
        print(' ',end='')
    for z in range(4-2*x+1):
        print('*',end='')
    print(' ')

通过k，j来控制每一列的输出，i控制行的输出，下面同理

题目24：

有一分数序列：2/1，3/2，5/3，8/5，13/8，21/13...求出这个数列的前20项之和。

#coding=utf-8

from functools import reduce

x = 2
y = 1
lst = []
lst.append(x/y)
for i  in range(1,20):
    y, x = x ,x+y
    lst.append(x/y)

if len(lst) != 0 :
    print(reduce(lambda x,y: x+y ,lst))

分子x+y，分母y= x，将每一项放入列表，用reduce方法来求列表的和 ，sum也可以求列表的和

题目25：

求1+2!+3!+...+20!的和。

#coding=utf-8
a = 1
lst = []
for i in range(1,21):
    a *= i
    lst.append(a)
print('1+2!+3!+...+20!={}'.format(sum(lst)))

遇上一题同理，将每一项放入列表，用sum求列表的和，输出

题目26：

利用递归方法求5!。

#coding=utf-8

sum = 1
for i in range(1,6):
    sum = sum * i
print(sum)


sum1 = 0
def fsum(n):
    if n == 1:
        sum1 = 1
    else:
        sum1 = n * fsum(n-1)
    return sum1
print(fsum(5))

两种方法第一种用循环，第二种用递归，递归就是在函数调用函数本身，在题目中fsum函数在内部又调用了他自己，并且n = n -1 ,重复调用后当n = 1的时候结束

题目27：

利用递归函数调用方式，将所输入的5个字符，以相反顺序打印出来。

#coding=utf-8


def str(s):
    lst = [i for i in s]
    length = len(lst)
    for i in range(1,length+1):
        print(lst[length -i])



def output(s,l):
    if l == 0:
        return
    print(s[l-1])
    l -= 1
    output(s,l)
    
if __name__ == '__main__':
    s = input('输入；')
    l = len(s)
    output(s,l)
    print('-'*40)
    str(s)

同样两种方法：第一种用循环，第二种在output函数中调用output，l = l-1 ,当l==0的时候结束递归输出，26，27思路大致相同。

题目28：

有5个人坐在一起，问第五个人多少岁？他说比第4个人大2岁。问第4个人岁数，他说比第3个人大2岁。问第三个人，又说比第2人大两岁。问第2个人，说比第一个人大两岁。最后问第一个人，他说是10岁。请问第五个人多大？

#coding=utf-8

def age(n):
    if n ==1:
         last = 10
    else:
        last = age(n-1) +2
    return last

if __name__ == '__main__':
    print(age(5))

同样的递归.....

题目29：

给一个不多于5位的正整数，要求：一、求它是几位数，二、逆序打印出各位数字

#coding=utf-8

def num(x):
    a = x //10000
    a1 = x % 10000//1000
    a2 = x % 1000//100
    a3 = x % 100//10
    a4 = x % 10
    lst = [a,a1,a2,a3,a4]
    if a != 0:
        print('五个数为',lst)
    elif a1 != 0:
        print('四位数为',lst[1:])
    elif a2 != 0:
        print('三位数为',lst[2:])
    elif a3 != 0:
        print('两位数为',lst[3:])
    elif a4 != 0:
        print('一位数为',lst[-1])

if __name__ == '__main__':
    x = int(input('输入数：'))
    num(x)

对数分解，个位十位百位千位万位，并且判断是否为零，万位不为零就是五位数，其他同理，在对列表进行切片输出

题目30：

回文数：

#coding=utf-8

def num(x):
    a = x // 10000
    a4 = x % 10
    a2 = x % 1000 // 100
    a1 = x % 10000 // 1000
    a3 = x % 100 // 10
    if a == a4 and  a1 == a3:
        print('回文数')
    else:
        print('no')

if __name__ == '__main__':
    x = int(input('输入五位数数：'))
    num(x)

同样的拆分五位数，判断万位==个位 and  千位 == 十位，满足就是回文数

题目31：

请输入星期几的第一个字母来判断一下是星期几，如果第一个字母一样，则继续判断第二个字母。

#coding=utf-8


a = input('第一个字母:')
if a.lower() == 'w':
    print('Wednesday')

elif a.lower() == 'm':
    print('Monday')

elif a.lower() == 'f':
    print('Friday')

elif a.lower() == 't':
    b = input('第二个字母为：')
    if b.lower() == 'u':
        print('Tuesday')
    elif b.lower() == 'h':
        print('Thursday')

elif a.lower() == 's':
    b = input('第二个字母为：')
    if b.lower() == 'a':
        print('Saturday')
    elif b.lower() =='u':
        print('Sunday')

条件判断，str.lower() 返回小写字母

题目32：

按相反的顺序输出列表的值。

#coding=utf-8

lst = [i for i in range(10)]
lst1= lst[::-1]
print(lst1)

lst.reverse()
print(lst)

切片操作，步长设置为-1  ，还有事reverse方法将列表反转但没有返回值

题目33：

按逗号分隔列表。

#coding=utf-8

lst = [i for i in range(5)]
lst1 = ','.join(str(n) for n in lst)
print(lst1)

 列表推导式快速生成列表，join方法将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串

题目34：

练习函数调用。

#coding=utf-8

def output():
    for i in range(3):
        print('RUNOOB')
        
if __name__ == '__main__':
    output()

函数调用.....

题目35：

文本颜色设置。

#coding=utf-8

print('\033[1;30;47m 改变输出字体颜色')

第一次知道可以改变文本输出颜色 :具体方法 

数值表示的参数含义：

显示方式: 0（默认值）、1（高亮）、22（非粗体）、4（下划线）、24（非下划线）、 5（闪烁）、25（非闪烁）、7（反显）、27（非反显）
前景色: 30（黑色）、31（红色）、32（绿色）、 33（黄色）、34（蓝色）、35（洋 红）、36（青色）、37（白色）
背景色: 40（黑色）、41（红色）、42（绿色）、 43（黄色）、44（蓝色）、45（洋 红）、46（青色）、47（白色）


常见开头格式：
\033[0m            默认字体正常显示，不高亮
\033[32;0m       红色字体正常显示
\033[1;32;40m  显示方式: 高亮    字体前景色：绿色  背景色：黑色
\033[0;31;46m  显示方式: 正常    字体前景色：红色  背景色：青色

书写格式：
      开头部分：\033[显示方式;前景色;背景色m + 结尾部分：\033[0m

题目36：

求100之内的素数。

#coding=utf-8

def select(a,b):
    for i  in range(a, b+1):
        if i >1:
            for j in range(2,i):
                if i % j == 0:
                    break
            else:
                print(i)

a = int(input('输入区间最小值：'))
b = int(input('输入区间最大值：'))
select(a,b)

与实例12类似，改变一下区间就可以，因为是从1-100，要排除1 

题目37：

对10个数进行排序。

#coding=utf-8

i =0
lst =[]
while i<10:
    a = input('输入第 %d 个数' %i)
    lst.append(a)
    i +=1
print(lst)
lst.sort()
for i in lst:
    print(i)

 输入十个数并加入列表，对列表进行排序，然后遍历输出

题目38：

求一个3*3矩阵主对角线元素之和。

#coding=utf-8

import numpy as np
a = np.random.randint(0,10,size=(3,3))
print(a)
lst = []
for i in range(a.shape[0]):
    lst.append(a[i,i])
print(sum(lst))

用numpy创建一个矩阵，然后数组索引[0,0],[1,1],[2,2]位置上的数，加入空列表然后求列表和 

题目39：

有一个已经排好序的数组。现输入一个数，要求按原来的规律将它插入数组中。

#coding=utf-8

import numpy as np
a = np.random.randint(0,10,size=9)
a.sort()
print(a)
b = int(input('输入一个数：'))
c = np.append(a,b)
c.sort()
print(c)

 numpy建一个一维数组，排序，再使用np.append()方法向数组中添加一个数，在把数组重新进行排列

题目40：

将一个数组逆序输出。

#coding=utf-8

lst = [i for i in range(10)]
print(lst)
lst.reverse()
print(lst)

 创建一个数组，用reverse方法

题目41：

模仿静态变量的用法。

#coding=utf-8


import time
def func():
    x = 0
    print('x:',x)
    time.sleep(1)
    x += 1
if __name__ == '__main__':
    for i in range(3):
        func()

class function():
    y = 5
    def func(self):
        self.y += 1
        print(self.y)

print(function.y)
a = function()
a.func()

类的属性，和变变量的作用域，a是类function的实例化对象，a再调用类里面的函数，得到的是6

题目42：

学习使用auto定义变量的用法。

#coding=utf-8

num =2
def func():
    num =1
    print('局部变量：',num)
    num += 1


if __name__ == '__main__':
    func()
for i in range(3):
    print('全局变量：',num)
    num += 1

全局变量和局部变量，定义再函数内部的变量称为局部变量，在该函数外的对这个函数来说就是全局变量 

题目43：

模仿静态变量(static)另一案例。

#coding=utf-8

class fun:
    num = 1
    def f(self):
        self.num += 1
        print('内部变量',self.num)

if __name__ == '__main__':
    num = 3
    a = fun()
    for i  in range(3):
        num += 1
        print('全局变量',num)
        a.f()

 静态方法可以直接使用"类名.方法名()"直接访问，静态方法不能访问实例属性，只能使用类名访问类属性

题目44：

两个 3 行 3 列的矩阵，实现其对应位置的数据相加，并返回一个新矩阵：

#coding=utf-8

import numpy as np
x = np.random.randint(1,10,size=(3,3))
y = np.random.randint(1,10,size=(3,3))
print(x)
print('-'*30)
print(y)
print('-'*30)
print(x+y)

np创建两个3，3的随机矩阵，直接相加 

题目45：

统计 1 到 100 之和。

#coding=utf-8

sum1 = 0
for i in range(1,101):
    sum1 += i
print(sum1)

lst = [x for x in range(1,101)]
print(sum(lst))

两种方法，第一种直接遍历相加，第二种求列表和

题目46：

求输入数字的平方，如果平方运算后小于 50 则退出。

#coding=utf-8


a = int(input('输入数字'))
def fun(a):
    b = a**2
    if b<50:
        print(False)
    else:
        print(b)

fun(a)

条件判断语句，定义一个方法，调用这个方法，不满足条件直接输出

题目47：

两个变量值互换。

#coding=utf-8

def exchaneg(x,y):
    x,y =y,x
    return x,y

if __name__ == '__main__':
    x = 10
    y = 20
    print(x,y)
    x,y = exchaneg(x,y)
    print(x,y)

 定义一个方法，用等号赋值

题目48：

数字比较。

#coding=utf-8


def func(a,b):
    if a <b:
        print('a<b')
    elif a ==b:
        print('a=b')
    else:
        print('a>b')
if __name__ == '__main__':
    a = input('输入数：')
    b = input('输入第二个数：')
    func(a,b)

 条件判断......

题目49：

使用lambda来创建匿名函数。

#coding=utf-8

func = lambda a,b: (a<b) * b + (a>b) * a

a = 6
b = 3
print(func(a,b))

匿名函数的用法，等同于def定义一个函数，表达上更简单，判断a，b的大小，输出较大的那个数

题目50：

输出一个随机数。

#coding=utf-8

import random

a = random.randint(1,10)
print(a)

random模块的方法，randint随机范围内的整数

题目51：

学习使用按位与 & 。

#coding=utf-8

a = 3
print(bin(a))
b = 4
print(bin(b))
print(a & b)

按位与：将两个运算的数转为二进制，相应位上全为1 时取1，存在0 时为0。

3 ===>   0011

4 ===>  0100

3 & 4 ===> 0000

题目52：

学习使用按位或 | 。

#coding=utf-8

a = 3
b = 4
print(a | b)

 按位或：将两个运算的数转为二进制，相应位上存在1 时取1，存在0 时为0。

3 ===>   0011

4 ===>  0100

3 | 4 ===> 0111 ===> 7

题目53：

学习使用按位异或 ^ 。

#coding=utf-8

a = 3
b = 4
print(a ^ b)

  按位异或：将两个运算的数转为二进制，相应位上数字不同时取1，相同时取0。

3 ===>   0011

4 ===>  0100

3 ^ 4 ===> 0111 ===> 7

题目54：

取一个整数a从右端开始的4〜7位。

#coding=utf-8


a = int(input("请输入一个数字："))
b = a >> 4
c = ~(~0 << 4)   # b=00001111
d = b & c
print("{0:b}".format(d))

左移运算符：原来的所有位左移，最低位补0，相当于乘以2 

 3 << 4  :  3 ==> 0011  ==> 110000  ==> 48  相当于乘以2的四次方

右移运算符：原来的所有位右移，最低位丢弃，最高位使用符号位填充，相当于整除2

 3 << 4  : 3 ==> 0011  ==> 000000  ==>0  

实例54题目有点看不懂....

题目55：

学习使用按位取反~。

#coding=utf-8

a = ~3
print(a)

参加运算的两个数，转换成二进制，0变1 ，1变0, 最高位为符号位，正数的符号位为 0，负数为 1。

3 ==> 11 ==> 00 ==> 11 ==> 11 +1 ==> 100 ==> -4

题目56：

画图，学用circle画圆形。　

#coding=utf-8

from tkinter import *
canvas = Canvas(width=800, height=600,bg='white')
canvas.pack(expand=YES, fill=BOTH)
k = 1
j = 1
for i in range(26):
    canvas.create_oval(310-k,250-k,310+k,250+k,width=1)
    k += j
    j+=4
mainloop()

用tkinter中的canvas创建画宽800，高600的画布，背景颜色为白色，

pack()来设置填充方式和，扩展方式，除了expand和fill参数还有size，anchor参数

用create_oval()来绘制圆形，通过for循环语句来画同心圆

调用mainloop()方法，显示窗口

题目57：

画图，学用line画直线。

#coding=utf-8

from tkinter import *
from turtle import width

canvas = Canvas(width=800, height=600,bg='white')
canvas.pack(expand=YES,fill=BOTH)
canvas.create_line(0,200,800,200,width=4)
mainloop()

同样的方法，用create_line()来画直线

题目58：

画图，学用rectangle画方形。

#coding=utf-8

from tkinter import *
from turtle import width

root = Tk()
root.title('Canvas')
canvas = Canvas(root,width=800,height=800,bg='white')
canvas.pack(expand=YES,fill=BOTH)
canvas.create_rectangle(200,400,600,600,width=4)
root.mainloop()

create_rectangle()画方形，（200，400）为矩形坐上标，（600，600）为矩形右下标，title()来设置窗口标题

题目59：

画图，综合例子。　　

#coding=utf-8

from tkinter import *
root = Tk()
root.title('canvas')
canvas = Canvas(root,width=800, height=600,bg='white')
canvas.pack(expand=YES, fill=BOTH)
k = 1
j = 1
for i in range(26):
    canvas.create_oval(310-k,250-k,310+k,250+k,width=1)
    k += j
    j+=4
x0 =250
y0 = 300
x1 = 350
y1 = 200
for i in range(26):
    canvas.create_rectangle(x0,y0,x1,y1,width=1)
    x0 -= 5
    y0 -= 5
    x1 += 5
    y1 += 5
root.mainloop()

上面两个题画在一个窗口，for 循环方法来多次画圆和方形

题目60：

计算字符串长度。

#coding=utf-8

a = 'asdawe'
print(len(a))

len()来计算字符串长度

 题目61：

打印出杨辉三角形（要求打印出10行如下图）。

#coding=utf-8

lst = [1]
for i in range(10):
    print(lst)
    lst.append(0)
    lst = [lst[j]+lst[j-1] for j in  range(i+2)]

除每行的第一个数字之外，每个数字等于上一行对应两个数字的和

在列表后面加上0，为了后续的计算

题目62：

查找字符串。　　

#coding=utf-8

a = 'abcffr123'
b = '123'
print(a.find(b))

字符串查找返回的是索引 

题目63：

画椭圆。　

#coding=utf-8

from tkinter import *
from turtle import width

canvas = Canvas(width=800, height=800,bg='white')
canvas.pack(expand=YES,fill=BOTH)
x = 360
y = 200
x1 = x - 30
y1 = y - 30
canvas.create_oval(350-x1,250-y1,350+x1,250+y1,width=4)
mainloop()

利用画圆形的方法改变参数 

题目64：

利用ellipse 和 rectangle 画图。

#coding=utf-8
from tkinter import *

canvas = Canvas(width=800, height=600, bg='white')
left = 20
right = 50
top = 50
num = 15
for i in range(num):
    canvas.create_oval(300 - right, 300 - left, 300 + right, 300 + left)
    canvas.create_rectangle(450 - 3 * i, 400- 3 * i, 10 * (i + 2), 10 * (i + 2))
    right += 5
    left += 5
    top += 10

canvas.pack()
mainloop()

 矩形和圆形，for循环改变圆和矩形的大小

题目65：

一个最优美的图案。　　

#coding=utf-8

from tkinter import *
import math
class PTS:
    def __init__(self):
        self.x = 0
        self.y = 0
points = []

def LineToDemo():
    screenx = 400
    screeny = 400
    canvas = Canvas(width = screenx,height = screeny,bg = 'white')

    AspectRatio = 0.85
    MAXPTS = 15
    h = screeny
    w = screenx
    xcenter = w / 2
    ycenter = h / 2
    radius = (h - 30) / (AspectRatio * 2) - 20
    step = 360 / MAXPTS
    angle = 0.0
    for i in range(MAXPTS):
        rads = angle * math.pi / 180.0
        p = PTS()
        p.x = xcenter + int(math.cos(rads) * radius)
        p.y = ycenter - int(math.sin(rads) * radius * AspectRatio)
        angle += step
        points.append(p)
    canvas.create_oval(xcenter - radius,ycenter - radius,
                       xcenter + radius,ycenter + radius)
    for i in range(MAXPTS):
        for j in range(i,MAXPTS):
            canvas.create_line(points[i].x,points[i].y,points[j].x,points[j].y)

    canvas.pack()
    mainloop()
if __name__ == '__main__':
    LineToDemo()

为什么这是最优美的图案.......

tkinter和turtle有什么区别..... （不喜欢用tkinter）

题目66：

输入3个数a,b,c，按大小顺序输出。　　　

#coding=utf-8
a = input('第一个：')
b = input('第二个：')
c = input('第三个：')

def func(n1,n2):
    return n2,n1

if a > b:
    a,b=func(a,b)
if a > c:
    a,c = func(a,c)
if b > c:
    b,c = func(b,c)

print(a,b,c)

条件判断，写一个方法，将大的和小的交换，实现从小到大排序

题目67：

输入数组，最大的与第一个元素交换，最小的与最后一个元素交换，输出数组。

#coding=utf-8

lst = [0,1,2,3,4,5,6,7,8,9]
lst1 = lst.copy()
a = lst1.pop(max(lst))
b = lst1.pop(min(lst))
lst[0] = a
lst[-1] = b
print(lst)

复制一个列表，找到原列表列表中最大的和最小的，在新列表中删除，用pop方法会返回删除的数是多少，在原列表中，将第一位和最后一位的值换一下就行

题目68：

有 n 个整数，使其前面各数顺序向后移 m 个位置，最后 m 个数变成最前面的 m 个数

#coding=utf-8

lst = [1,2,3,4,6,7]
n = len(lst)
print(len(lst))
m = int(input('移动多少位：'))
def move(lst,n,m):
    lst1 = lst.copy()
    while m > 0 :
        lst1.insert(0,lst1[n-1])
        m -= 1
    lst1 = lst1[0:n]
    print(lst1)

move(lst,n,m)

方法中，将第五位也就是最后一位，插到列表最前面用insert方法，循环，每次新列表的总长度会+1，最后切片输出 

题目69：

有n个人围成一圈，顺序排号。从第一个人开始报数（从1到3报数），凡报到3的人退出圈子，问最后留下的是原来第几号的那位。

#coding=utf-8

n = int(input('人数：'))
lst = [i+1 for i in range(n)]

i = 0
k = 0
m = 0
while m < n-1:
    if lst[i] != 0:
        k += 1
    if k == 3:
        lst[i] =0
        k = 0
        m +=1
    i+=1
    if i == n:
        i =0
i = 0
while lst[i] == 0:
    i +=1
print(lst[i])

i用来索引，k用来算报数，m用来决定循环次数，当满足一次k=3时算一次循环

题目70：

写一个函数，求一个字符串的长度，在main函数中输入字符串，并输出其长度。

#coding=utf-8

if __name__ == '__main__':
    a = input('输入一个字符串：')
    print('字符串长度',len(a))

......if __name__ == '__main__':的用法

在代码作为脚本时才会执行

题目71：

编写input()和output()函数输入，输出5个学生的数据记录。

#coding=utf-8

student = {}
N = int(input('人数:'))
def in_put(N):
    for i in range(N):
        i +=1
        student[i] = {}
        a = input('学号：')
        student[i]['num'] = a
        b = input('姓名：')
        student[i]['name'] = b
        student[i]['score'] = {}
        for j in range(3):
            j += 1
            c = input('成绩：')
            student[i]['score'][j] = c
    print(student)

def out_put(N):
    for i in range(N):
        i += 1
        print(student[i]['num'],student[i]['name'])
        for j in range(3):
            j += 1
            print('{}:'.format(j),student[i]['score'][j])

if __name__ == '__main__':
    in_put(N)
    out_put(N)

用字典方法

题目72：

创建一个链表。

#coding=utf-8

if __name__ == '__main__':
    lst = []
    for i in range(5):
        a = int(input('输入数：'))
        lst.append(a)
    print(lst)

循环向列表中加入元素

题目73：

反向输出一个链表。 

#coding=utf-8

if __name__ == '__main__':
    lst = []
    for i in range(5):
        a = int(input('输入数：'))
        lst.append(a)
    print(lst)
    lst.reverse()
    print(lst)

 reverse方法，没有返回值

题目74：

列表排序及连接。

#coding=utf-8

a = [2,1,5,3,9,6]
b = [4,5,7,3,2,1]
a.sort()
print(a)
print(a+b)
a.extend(b)
print(a)

sort将列表排序，两个列表连‘+’还有extend方法

题目75：

放松一下，算一道简单的题目。 

#coding=utf-8


for i in range(5):
    n = 0
    if i != 1:
        n += 1
    if i ==3:
        n += 1
    if i == 4:
        n += 1
    if i != 4:
        n += 1
    if n == 3:
        print(64+i)

..........

 题目76：

编写一个函数，输入n为偶数时，调用函数求1/2+1/4+...+1/n,当输入n为奇数时，调用函数1/1+1/3+...+1/n

#coding=utf-8

def func1(n):
    if n % 2 == 0:
        lst =[1.0/i for i in range(2,n+1,2)]
        print(sum(lst))
    else:
        lst =[1.0/i for i in range(1,n+1,2)]
        print(sum(lst))

if __name__ == '__main__':
    n = int(input('输入一个数：'))
    func1(n)

能否被2整除判断是不是偶数，将元素加入列表求列表和

题目77：

循环输出列表

#coding=utf-8

lst = [i  for i in range(10)]
print(lst)
for i in lst:
    print(i)

遍历列表

题目78：

找到年龄最大的人，并输出。请找出程序中有什么问题。

#coding=utf-8

dic = {
    'a':'19',
    'b':'50',
    'c':'60',
}
lst = [i for i in dic.values()]
a = max(lst)
for i in dic.keys():
    if dic.get(i) == a:
        print(i)
print(a)

values返回值的列表，知道最大的，遍历字典keys找到对应的值

题目79：

字符串排序。

#coding=utf-8


str1 = input('输入字符串1：')
str2 = input('输入字符串2：')
str3 = input('输入字符串3：')
if str1 > str2:
    str1,str2 =str2,str1
if str1 >str3:
    str1,str3 =str3,str1
if str2 > str3:
    str2,str3=str3,str2

print(str1,str2,str3)

跟数字排序类似

题目80：

海滩上有一堆桃子，五只猴子来分。第一只猴子把这堆桃子平均分为五份，多了一个，这只猴子把多的一个扔入海中，拿走了一份。第二只猴子把剩下的桃子又平均分成五份，又多了一个，它同样把多的一个扔入海中，拿走了一份，第三、第四、第五只猴子都是这样做的，问海滩上原来最少有多少个桃子？

#coding=utf-8


i = 0 
j = 1    
x = 0    
while i <5:
        x =4 *j
        for i in range(0,5):
                if (x %4 !=0):
                        break
                else:
                        i =i+1
                x =(x/4) *5 +1
        j += 1
print(x)

第一支猴子拿完还剩下（x-1）*4/5个，第二只猴子分完还有（x1-1）*4/5个。j表示最后猴子拿到的桃子数，x表示每次拿完后剩下桃子数

 题目81：

809*??=800*??+9*?? 其中??代表的两位数, 809*??为四位数，8*??的结果为两位数，9*??的结果为3位数。求??代表的两位数，及809*??后的结果。

#coding=utf-8

a = 809
for i in range(10,100):
    b = i * a
    if 1000<= b <= 10000 and 8 *i <100 and 9 *i >=100:
        print(i,b)

条件判断，所有条件列出来，循环遍历

题目82：

八进制转换为十进制

#coding=utf-8

a = int('122',8)
print(a)

二进制，八进制，十六进制转换成十进制，可以用内置函数int()

题目83：

求0—7所能组成的奇数个数。

#coding=utf-8

lst = [4]
s = 4
for i in range(2,9):
    if i == 2:
        s *= 7
    else:
        s *= 8
    lst.append(s)
print(sum(lst))

0-7组成的以为奇数有4个，两位是7*4个，三位是7*8*4，s是每一层组成的奇数个数，将s加入lst，求列表和

题目84：

连接字符串。

#coding=utf-8

a = 'abcd'
b = 'mn'
print(a.join(b))

在字符出b ‘mn’中间加入‘abcd’

题目85：

输入一个奇数，然后判断最少几个 9 除于该数的结果为整数。

#coding=utf-8

a = int(input('输入一个奇数：'))
count = 1
s = 9
while s % a != 0:
    s = int(str(s)+'9')
    count += 1
print(count)

题目86：

两个字符串连接程序。

#coding=utf-8

a = 'abcd'
b = 'efgh'
print(a+b)

列表连接，可以用‘’+‘ 

题目87：

回答结果（结构体变量传递）。

#coding=utf-8

class student:
    x = 0
    c = 0
def func(stu):
    stu.x = 20
    stu.c = 'c'

a = student()
a.x=30
a.c = 'a'
print(a.x,a.c)
b= student()
b.x = 30
b.c = 'a'
func(b)
print(b.x,b.c)

对于类来说，使用类的实例化的对象可以改变类中的值，函数则不能改变

题目88：

读取7个数（1—50）的整数值，每读取一个值，程序打印出该值个数的＊。

#coding=utf-8

n = 1
while n <= 7:
    a = int(input('输入数：'))
    if 1<= a <=50:
        print('*' * a)
    else:
        print('重新输入数')
        n -=1
    n += 1

循环+条件判断

 题目89：

某个公司采用公用电话传递数据，数据是四位的整数，在传递过程中是加密的，加密规则如下：每位数字都加上5,然后用和除以10的余数代替该数字，再将第一位和第四位交换，第二位和第三位交换。

#coding=utf-8

a = int(input('输入四位数字：'))
a_lst =[]
a_lst.append(a//1000)
a_lst.append(a % 1000//100)
a_lst.append(a % 100//10)
a_lst.append(a % 10)
print(a_lst)
for i in range(4):
    a_lst[i] += 5
    a_lst[i] %= 10
for i in range(2):
    a_lst[i],a_lst[3-i] = a_lst[3-i],a_lst[i]
print(a_lst)

 题目90：

列表使用实例。

#coding=utf-8

lst =[i for i in range(10)]
print(lst)
print(len(lst))
a = [100,200]
lst.append(a[0])
print(lst,len(lst))
lst.extend(a)
print(lst,len(lst))
lst.remove(100)
print(lst)
lst.pop(-1)
print(lst)
print(lst[:])
print(lst[2:5])

列表的用法.....

 题目91：

时间函数举例1。

#coding=utf-8

import time
#ctime函数能够把时间戳转化为time.asctime()的形式
print(time.ctime(time.time()))

#asctime函数接受时间元组返回一个可读的形式
t=(2018,7,17,17,3,1,3,1,0)
print(time.asctime(t))
#asctime函数接收的可以是gmtime()和localtime()返回的时间值
print(time.asctime(time.localtime()))
print(time.asctime(time.gmtime()))

题目92：

时间函数举例2。

#coding=utf-8

import time
start= time.time() #程序开始执行时间
for i in range(1000):
    print(i)
end = time.time()  #运行完成时间
time.sleep(1)  #暂停一秒
print(end - start)  #输出程序运行时间

题目93：

时间函数举例3。

#coding=utf-8

import time
start = time.clock()
i=0
while i<1000:
    print(i)
    i +=1
end = time.clock()
print(end - start)

题目94：

时间函数举例4,一个猜数游戏，判断一个人反应快慢。

#coding=utf-8

import random
import time

a = random.randint(0,10)
d = 0
start = time.time()
while d < 3:
    b = int(input('输入一个10以内的数'))
    if a == b:
        print('猜测正确')
        break
    elif a > b:
        print('偏小')
    elif a < b:
        print('偏大')
    d += 1
end= time.time()
print(end - start)

题目95：

字符串日期转换为易读的日期格式。

#coding=utf-8

import datetime
t = datetime.datetime(year=2021, month=11, day=11, hour=19, minute=30, second=20)
print(t)

from dateutil import parser
t1 = parser.parse('dec 12 2020 8:00AM')
print(t1)

 题目96：

计算字符串中子串出现的次数。

#coding=utf-8

a = 'abbbbbbccdef'
b = 'a'
num = a.count('b')
print(num)

题目97：

从键盘输入一些字符，逐个把它们写到磁盘文件上，直到输入一个 # 为止。

#coding=utf-8


with open('runoobit.txt','w+') as f:
    str = input('input str:')
    while '#' not in str:
        f.write(str)
        str = input('input str:')
    f.close()

题目98：

从键盘输入一个字符串，将小写字母全部转换成大写字母，然后输出到一个磁盘文件"test"中保存。

#coding=utf-8

with open('test.txt','w+') as f:
    str = input('input string:')
    str = str.upper()
    f.write(str)
with open('test.txt','r') as f:
    print(f.read())

题目99：

有两个磁盘文件A和B,各存放一行字母,要求把这两个文件中的信息合并(按字母顺序排列), 输出到一个新文件C中。

#coding=utf-8

with open('test.txt','r') as f:
    a = f.read()
with open('runoobit.txt','r') as f:
    b = f.read()
with open('abc.txt','w+') as f:
    f.write(a+b)
with open('abc.txt','r') as f:
    print(f.read())

题目100：

列表转换为字典。

#coding=utf-8

lst_keys =['a',12]
lst_values =['b',23]
print(dict([lst_keys, lst_values]))

leetcode动态规划：

 leetcode509: 斐波那契数列

class Solution:
    def fib(self,n):
        n= int(n)
        if n <2 :
            return n
        return  self.fib(n-1) + self.fib(n-2)

leetcode1137：第n个泰伯那契数列

深度递归时间复杂度太高，读取缓存

class Solution:
    @functools.lru_cache(None)   #缓存
    def tribonacci(self, n: int) -> int:
        if n == 0: return 0
        if n == 2 or n==1: return 1
        return self.tribonacci(n - 3) + self.tribonacci(n - 2) + self.tribonacci(n - 1)

 70.爬楼梯

递归，使用装饰器减小时间复杂度

class Solution:
    @functools.lru_cache(None)
    def climbStairs(self, n: int) -> int:
        if n >2:
            return self.climbStairs(n-1) + self.climbStairs(n-2)
        else:
            return n

746.使用最小花费爬楼梯

动态规划

class Solution:
    def minCostClimbingStairs(self, cost: List[int]) -> int:
        p1,p2 = 0,0
        for i in range(2,len(cost)+1):
            p1,p2 = p2,min(p2+cost[i-1],p1+cost[i-2]) 
        return p2

 198.打家劫舍

动态规划

def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums)<=2:
            return max(nums)
        dp =[0]*len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
        return dp[-1]

213.打家劫舍Ⅱ

动态规划

环形

不抢最后一个和抢最后一个

class Solution:
    def rob(self, nums: List[int]) -> int:
        n = len(nums)
        if n==0:
            return 0
        if n<=2:
            return max(nums)

        dp1=[0] * n
        dp1[0] = 0
        dp1[1] = nums[1]
        for i in range(2,n):
            dp1[i] = max(dp1[i-1],nums[i] + dp1[i-2])
        
        dp2=[0] * n
        dp2[0] = nums[0]
        dp2[1] = max(nums[0],nums[1])
        for i in range(2,n-1):
            dp2[i] = max(dp2[i-1],nums[i] + dp2[i-2])
        
        return max(dp1[n-1],dp2[n-2])

740.删除获得点数

把获得的点数转成数组，用打家劫舍思路解决，动态规划

class Solution:
    def deleteAndEarn(self, nums: List[int]) -> int:
        n = len(nums)
        maxval = max(nums)
        total = [0] * (maxval+1)
        for x in nums:
            total[x] += x
        return self.rob(total)

    def rob(self, nums: List[int]) -> int:
        if not nums:
            return 0
        if len(nums)<=2:
            return max(nums)
        dp =[0]*len(nums)
        dp[0] = nums[0]
        dp[1] = max(nums[0],nums[1])
        for i in range(2,len(nums)):
            dp[i] = max(dp[i-1],dp[i-2]+nums[i])
        return dp[-1]

 55.跳跃游戏

贪心算法

class Solution:
    def canJump(self, nums: List[int]) -> bool:
        n, reach = len(nums), 0
        for i in range(n):
            if i <= reach:
                reach = max(reach, i + nums[i])
                if reach >= n - 1:
                    return True
        return False

45.跳跃游戏Ⅱ

到达边界end，step次数加1

class Solution:
    def jump(self, nums: List[int]) -> int:
        n  = len(nums)
        maxjump,end,step = 0, 0,0
        for i in range(n-1):
            if i <= maxjump:
                maxjump = max(maxjump,i+nums[i])
                if i == end:
                    end = maxjump
                    step += 1
        return step

 53.最大数组和

动态规划

class Solution:
    def maxSubArray(self, nums: List[int]) -> int:
        n = len(nums)
        if n ==0: return 0
        dp=[0] *n
        dp[0] = nums[0]
        for i in range(1,n):
            dp[i] = max(nums[i],dp[i-1]+nums[i])
        return max(dp)

918.环形最大子数组和

动态规划找出最大和最小

首尾最大，中间最小，数列和减去最小就是最大

class Solution:
    def maxSubarraySumCircular(self, nums: List[int]) -> int:
        
        n = len(nums)
        if n ==0: return 0
        dp=[0] *n
        dp[0] = nums[0]
        for i in range(1,n):
            dp[i] = max(nums[i],dp[i-1]+nums[i])

        dp1=[0] *n
        dp1[0] = nums[0]
        for i in range(1,n):
            dp1[i] = min(nums[i],dp1[i-1]+nums[i])
            
        return max(max(dp),sum(nums)-min(dp1)) if max(dp)>0 else max(dp)

 152.乘积最大子数组

考虑负负得正的情况

class Solution:
    def maxProduct(self, nums: List[int]) -> int:
        n = len(nums)
        if not nums: return 
        max_ = pmax =pmin = nums[0]
        for i in range(1,n):
            cur_max = max(pmax * nums[i], pmin * nums[i], nums[i])
            cur_min = min(pmax * nums[i], pmin * nums[i], nums[i])
            max_ = max(max_, cur_max)
            pmax = cur_max
            pmin = cur_min
        return max_

1567.乘积为正的最长子数组 

正数，复数，遇到零重置

class Solution:
    def getMaxLen(self, nums: List[int]) -> int:
        n = len(nums)
        dp, dp1 = [0] * n, [0] * n
        if nums[0] > 0:
            dp[0] = 1
        elif nums[0] < 0:
            dp1[0] = 1
        
        maxLength = dp[0]
        for i in range(1, n):
            if nums[i] > 0:
                dp[i] = dp[i-1] + 1
                dp1[i] = (dp1[i-1] + 1 if dp1[i-1] > 0 else 0)
            elif nums[i] < 0:
                dp[i] = (dp1[i-1] + 1 if dp1[i-1] > 0 else 0)
                dp1[i] = dp[i-1] + 1
            else:
                dp[i] = dp1[i] = 0
            maxLength = max(maxLength, dp[i])
        return maxLength

 1014.最佳观光组合

class Solution:
    def maxScoreSightseeingPair(self, values: List[int]) -> int:
        n = len(values)
        # dp = [0] * n
        # dp[0] = values[0]
        max_=0
        # for i in range(n):
        #     dp[i+1] = max(dp[i-1],values[i+1]+values[i]+i-(i-1))
        #     max_ = max(max_,max(dp))
        # return max_

        pmax = values[0]+0
        for i in range(1,n):
            max_ = max(max_,pmax + values[i]-i)
            pmax = max(pmax,values[i]+i)
        return max_

121.买卖股票最佳时机

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        pmax = prices[0]
        max_ = 0
        for i in range(1,n):
            max_ = max(max_,prices[i]-pmax)
            pmax = min(pmax,prices[i])
        return max_

122.买卖股票最佳时机Ⅱ

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        # n = len(prices)
        # pmax = prices[0]
        # max_ = 0
        # for i in range(1,n): 
        #     pmax = min(pmax,prices[i-1])
        #     cur_max = max(0,prices[i]-pmax)  
        #     max_ = max(max_,cur_max+max_)
        #     pmax = prices[i]           
        # return max_
        n = len(prices)
        pmax = -prices[0]
        max_ = 0
        for i in range(1,n): 
            pmax = max(pmax, max_ - prices[i])
            max_ = max(max_, prices[i] + pmax)     
        return max_

 309.最佳股票买卖时机

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        n = len(prices)
        dp0 = dp1 =0
        dp2 = -prices[0]
        for i in range(1,n):
            new_dp0 = max(dp1,dp0)
            new_dp1 = dp2 + prices[i]
            new_dp2 = max(dp2,dp0-prices[i])
            dp0,dp1,dp2 = new_dp0,new_dp1,new_dp2
        return max(dp0,dp1)

714.买卖股票的最佳时机含手续费

class Solution:
    def maxProfit(self, prices: List[int], fee: int) -> int:
        n = len(prices)
        pmax = -prices[0]
        max_ = 0
        for i in range(1,n): 
            pmax = max(pmax, max_ - prices[i])
            max_ = max(max_, prices[i] + pmax - fee)     
        return max_

睡不够123
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
PPT模板2021工作计划总结
01-24
个人收藏的最新PPT模板，分享给大家使用
2021年通信工作总结.doc
11-23
2021年通信工作总结.doc
回顾2021总结
每个人都是独一无二的，把握好自己的节奏，跟着自己的心走。
12-31 757
文章目录前言今年总结回忆和不足之处思考明年期许 前言 今天是2021年12月31日，也就是2021年的最后一天，那么我也对自己一年(大二下、大三上)进行一下年度总结吧！ 今年总结 回忆和不足之处 首先看一下去年总结对于2021的期许： 并且记录一下今年一些较为重要和印象深刻的事情： 1、寒假制作简历，在软件外包公司暑期实习(7-10月)，第一次一人在外生活，第一次进入项目组，跟随项目进度实现一些功能。 2、第一次一个人出门旅游，国庆去了南京。 3、入党，成为预备党员。 4、英语四级证书已过。 5、完成
APIO2021总结
Exelite的博客
05-23 619
APIO2021总结 比赛状态 — T1计算几何 想了一个小时后放弃，T2打算快速地把暴力拿到就去思考正解，然而随手一个小数据让自己WA了，调试用时超2h（每次修改都要 save+命令行编译+手动运行 ，还是放在同一个程序里好搞），T3也只是看了题意就想办法搞暴力，没有留时间思考。 赛后发现，T1果然是不熟悉的多边形剖分，考场上想求的多边形面积也很好求。T2/T3都是不难的题。 做T2时想到笛卡尔树模型后，问题变得抽象，对进一步正解的思考没有益处；如果觉得难以找到突破口，可以回到原问题思考，或许可以更加形
【生活篇】2021总结
胖狗子修行之路的博客
01-04 3261
2021总结
2021总结、2022展望
Switch的博客
12-26 988
2021总结 [TOC] 新冠疫情延续 经济下行 互联网凛冬 教培行业双减 上半年在30-40人的产研团队做技术TL 下半年在大厂拧螺丝 苟字当头，不投资、不负债、储备现金 风险对冲，保险意识 参与开源 Skywalking Add some new thread metric and class metric to JVMMetric (#7230) #7243 add some new thread metric and class metric to JVMMetric #52 Remove T
中国房地产市场2021总结2022展望（17页）.pdf
02-16
中国房地产市场2021总结2022展望（17页）.pdf
校内消防演练总结2021总结大全.docx
10-06
校内消防演练总结2021总结大全.docx
个人2021总结2021计划5篇.doc
10-14
个人2021总结2021计划5篇.doc
Day25-Java基础之常用类1
m0_46053885的博客
04-27 928
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 898
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
AttributeError: module ‘numpy‘ has no attribute ‘float‘.的解决方法
最新发布
chen_znn的博客
04-30 340
本文记录了AttributeError: module 'numpy' has no attribute 'float'.的解决方法
Python 二叉树的创建与遍历
youyouxiong的博客
04-24 451
在Python中创建二叉树并进行遍历，我们首先需要定义一个二叉树节点类，然后创建二叉树，最后实现几种基本的遍历方法：前序、中序、后序和层序遍历。以下是具体的实现步骤： 2. 创建二叉树 创建二叉树通常是由用户根据需要输入节点值来构建，或者通过特定的算法生成。这里我们手动创建一个简单的二叉树： 3. 实现二叉树的遍历 前序遍历 (Preorder Traversal) 访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。 中序遍历 (Inorder Traversal) 递归地遍历左子
PySide6 GUI 学习笔记——使用资源文件
Humbunklung的专栏
04-27 558
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
python中的元类
weixin_40756114的博客
04-25 923
上面说了类是类的实例的模板，所以你看类的__new__被定义为一个绑定的类方法，类本身是作为方法的第一个参数，一般命名为cls，一般情况下，__new__不需要其他的参数，__new__根据cls来产生一个实例，__new__返回产生的实例，也有tuple等少数例外__new__需要额外的参数，绝大多数情况是不需要的。正如类是类的实例的工厂，元类则是类的工厂。不过这两种关系还是有所不同，类是类的实例的模版，但元类不是类的模版，元类更像一个纯粹的类的组装工厂。
笔记：Python 注释（练习题）
欢迎来到我的CSDN博客！在这里，我将分享关于技术、学习和生活的各种笔记和心得体会。无论你是正在学习编程、探索新技术，还是对生活中的点滴有所感悟，我都希望我的博客能够给你带来启发和帮助。
04-27 880
欢迎来到Python注释练习！在这个练习中，我们将探讨Python中注释的重要性和使用方法。注释在代码中扮演着关键的角色，不仅可以提高代码的可读性，还可以帮助其他人理解你的代码逻辑。通过这些练习，你将学习如何正确地编写注释，以及如何使用注释来解释代码的功能、逻辑和设计。无论你是新手还是有经验的Python开发人员，都可以从这些练习中受益。通过实践，你将更加熟悉Python注释的最佳实践，并且能够将其应用到自己的项目中。让我们开始吧！
在win上运行linux qt的项目
关注工业机器人应用
04-26 211
效果明显， 只是没有UR的远程VNC，不影响运行效果。
POC&EXP编写—模块介绍
剁椒鱼头没剁椒的博客
04-26 574
请求方法requests.方法名()# 常见参数url # 请求的urldata # post请求携带的请求体headers # 请求头timeout # 等待时间allow_redirects # 是否运行重定向 , 默认是允许 trueproxies # 代理 , 参数是字典类型 , 示例 :协议 urlverify # ssl证书校验 , 默认是true这里我们在后期添加的时候，需要一个个手动敲上去，那么这里其实可以使用一个bp插件来代替这个过程。
vscode c++2021
07-15
### 回答1： VSCode是一种开源的集成开发环境（IDE），适用于多种编程语言，其中包括C语言。2021年，VSCode的C语言扩展集成了许多新功能和改进，使得在VSCode中进行C语言开发变得更加方便和高效。 首先，VSCode C 2021更新了代码编辑器的功能，包括智能代码补全、语法高亮、代码重构和代码片段等。这些功能使得编写C语言代码更加容易，减少了错误和重复的工作。 其次，VSCode C 2021支持了多种调试和测试工具，用于帮助开发者更好地调试C语言程序。调试工具的集成使得开发者能够逐步执行代码、查看变量的值和跟踪程序的执行路径，从而更快地定位和解决问题。 另外，VSCode C 2021还具有代码版本控制功能，允许开发者使用Git等工具进行代码管理和协作。这使得多人协作开发项目变得更加简单和高效，避免了代码冲突和版本管理方面的麻烦。 此外，VSCode C 2021还具有丰富的扩展生态系统，允许开发者根据自己的需求自定义和扩展编辑器功能。通过安装不同的插件和扩展，开发者可以进一步提升C语言开发的效率和体验。 总之，VSCode C 2021通过强大的功能和改进的用户体验，为开发者提供了一个优秀的C语言开发环境。无论是个人项目还是团队合作，都能够提供高效、方便和可靠的开发体验。 ### 回答2： VSCode是一个广受欢迎的开发工具，可以支持多种编程语言，包括C语言。VSCode C 2021版本将为C语言开发者提供更好的开发体验和功能。以下是一些VSCode C 2021的特点： 1. 强大的代码编辑功能：VSCode C 2021提供了强大的代码编辑功能，包括语法高亮、自动补全、代码格式化等。这些功能可以提高开发者的编写效率和代码质量。 2. 调试工具：VSCode C 2021内置了强大的调试工具，可以帮助开发者在调试过程中快速定位和解决问题。开发者可以设置断点、单步执行、查看变量值等。 3. 插件生态系统：VSCode C 2021拥有一个丰富的插件生态系统，开发者可以根据自己的需求安装和使用各种插件。这些插件可以提供各种功能的扩展，如代码检查、代码分析、版本控制等。 4. 集成终端：VSCode C 2021内置了一个终端，开发者可以在编辑器中直接执行命令和编译运行程序。这样可以避免频繁切换窗口，提高开发效率。 5. Git支持：VSCode C 2021提供了强大的Git集成，开发者可以直接在编辑器中进行版本控制操作，如提交、查看差异、合并等。 总而言之，VSCode C 2021为C语言开发者提供了丰富的开发功能和工具，可以帮助他们更高效地进行编码和调试。它的丰富的插件生态系统和集成终端为开发者提供了更多的选择和便利。无论是初学者还是有经验的开发者，都可以受益于使用VSCode C 2021来进行C语言开发。 ### 回答3： VSCode是一个非常流行的开源代码编辑器，广泛用于C语言开发。它被认为是一个功能丰富且易于使用的编辑器，它具有许多强大的功能，并且有许多扩展可用于增强其能力。 首先，VSCode具有强大的代码编辑功能，包括智能代码补全、语法高亮、代码格式化和代码导航等。这些功能可以大大提高编码效率，减少出错的可能性。 其次，VSCode具有集成的调试功能，可以帮助开发人员更轻松地调试他们的C代码。开发人员可以通过设置断点、单步调试等操作来跟踪程序运行的过程，快速定位并修复错误。 此外，VSCode还支持版本控制工具，如Git，可以方便地管理代码的修改和提交。它可以显示代码的版本历史，并支持合并代码的功能，使团队协作更加高效。 VSCode还具有丰富的扩展生态系统，允许用户根据自己的需求进行定制。有许多C语言相关的扩展可用，例如比较流行的C/C++和Code Runner扩展，可以进一步增强VSCode在C语言开发中的功能。 总结而言，VSCode是一个功能强大且非常受欢迎的编辑器，对于C语言开发而言，它提供了许多有用的功能和工具，可以帮助开发人员更高效地编写和调试代码。无论是个人开发者还是团队，都可以从VSCode的使用中受益，并提升他们的开发体验。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值