蓝桥杯冲刺

• 一、时间问题
• • 1.日期的用法(案例)
• 二、切片运算
• • 1.切片函数的使用(暴力破解案例+优化)
  • 2.切片使用
• 三、数值交换
• • 1.双双赋值相等(冒泡+暴力+交换)
• 四、算法模板+函数的使用(详细)
• • 1.循环输入模板
  • 2.递归函数的使用（详细）
  • 3.Math函数的使用
  • 4.判断字符字母空格的个数
  • • I.函数形式
    • II.Def函数形式
• 五、 矩阵的输入和用法
• • 1.矩阵的定义
  • 2.矩阵的用法
  • 3.砝码重量(案例)
• 六、排序

一、时间问题

1.日期的用法(案例)

strftime() 函数接收以时间元组，并返回以可读字符串表示的当地时间，格式由参数format决定.
%y 两位数的年份表示（00-99）
%Y 四位数的年份表示（000-9999）
%m 月份（01-12）
%d 月内中的一天（0-31）
%H 24小时制小时数（0-23）
%I 12小时制小时数（01-12）
%M 分钟数（00=59）
%S 秒（00-59）
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和时间表示
%j 年内的一天（001-366）
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数（00-53）星期天为星期的开始
%w 星期（0-6），星期天为星期的开始
%W 一年中的星期数（00-53）星期一为星期的开始
%x 本地相应的日期表示
%X 本地相应的时间表示
%Z 当前时区的名称
%% %号本身

import datetime
year,month, day=map(int,input().split())
date01=datetime.date(year,month,day)
print(date01.strftime("%j"))#strftime %j 输出某一年为一年中的第几天 包括区分闰年平年in

二、切片运算

1.切片函数的使用(暴力破解案例+优化)

#切片运算
#暴力
m=input()
res=[m[2:]]
for i in res:
    print(i,end=" ")

优化运算
注意切片位置
x=int(input())#字符串总数
m=input()#输入字符串
h=int(input())#切片-1
res=m[h-1:]
print(res)


    

2.切片使用

x=list(map(int,input().split()))
x=x[::-1]
for i in x:
    print(i,end=" ")

切片的其他使用方式：
x=list(map(int,input().split()))
x=x[::-1]
for i in x:
    print(i,end=" ")

m=int(input())#10
x=list(map(int,input().split()))
n=int(input())#2
#前进多少位置就切片截取位置然后进行拼接 例如取3 -3:+:7 注意不是-3：7
num=(x[-n:]+x[:m-n])#-2:+:8 +号是拼接 两个字符串类型
for i in range(len(num)):
   print(num[i],end=' ')

x=list(map(int,input().split()))
h=(x[-2:]+x[:8])
for i in h:
    print(i,end=" ")

三、数值交换

1.双双赋值相等(冒泡+暴力+交换)

冒泡排序
ls=list(map(int,input().split()))
for i in range(len(ls)):
    for j in range(i):
        if ls[i] <=ls[j]:
            t=ls[i]
            ls[i]=ls[j]
            ls[j]=t
for i in ls:
    print(i,end=" ")


ls=list(map(int,input().split()))
h=max(ls)
s=min(ls)
ls[0]=s
ls[-1]=h
ls[1]=2
ls[-2]=9
for i in ls:
    print(i,end=" ")


交换
ls=list(map(int,input().split()))
for i in range(len(ls)):
    if ls[i]==min(ls):
        ls[i],ls[0]=ls[0],ls[i]
    if ls[i]==max(ls):
        ls[i],ls[-1]=ls[-1],ls[i]
for i in ls:
    print(i,end=" ")

两数交换
a,b=input().split()
a,b=b,a
print(a,b)

四、算法模板+函数的使用(详细)

a=str(input())#字符串需要引号才能转为字符形式
res=[]
for i in a:
    i=ord(i)#122
    if i in range(97,122):
        res.append(chr(i+1))
    elif i==122:
        res.append(chr(97))
    else:
        res.append(chr(i))
for x in res:
    print(x,end=" ")

1.循环输入模板

循环输入模板
x=float(input())
for i in range(1,4):
    for i in range(i):
        print(f"{x:.2f}",end=" ")#在.前面加上数字为空格
    print()

x=float(input())
for i in range(1,4):
    for j in range(i):
        print(f"{x:.2f}",end=" ")#加个f 相当于scala里面加个s""
    print()

2.递归函数的使用（详细）

def LEAP_YEAR(y):
    if year % 400==0 and year % 4 ==0:
        print("L")
    else:
        print("N")
year=int(input())
LEAP_YEAR(year)



def person_pratice(n):
    ans=0#判断字母 包括大小写
    result=0#判断数字
    space=0#判断空格
    res=0#判断符号的个数
    for i in n:
        if i.isalpha():
            ans+=1
        elif i.isdigit():
            result+=1
        elif i.isspace():
            space+=1
        else:
            res+=1
    return ans,result,space,res



def person_pratice(n):
    s=['a','e','i','o','u']
    for i in s:
        if i in n:
            print(i,end="")
n=input()
person_pratice(n)


def person(h,s):#输入的参数
    h=h+s#拼接字符串
    print(h)
#类型都为字符串
h=input()
s=input()
person(h,s)


def prime(n):
    if n<2:
        print("not prime")
    else:
        for i in range(2,n):
            if n % i  == 0:
                print("not prime")
                break
        else:
            print("prime")

n=int(input())
prime(n)

3.Math函数的使用

import math
a,b,c=map(int,input().split())#如果又要实现对整数进行每数字空一格 那么map().split() 映射
s=(a+b+c)/2#浮点型
area=math.sqrt((s*(s-a)*(s-b)*(s-c)))
print("{:.3f}" .format(area))#.format 的前面用法是:.

4.判断字符字母空格的个数

I.函数形式

x=input()
ans=0#判断字母 包括大小写
result=0#判断数字
space=0#判断空格
res=0#判断符号的个数
for i in x:
    if i.isdigit():
        result+=1
    elif i.isalpha():
        ans+=1
    elif i.isspace():
        space+=1
    else:
        res+=1
print(ans,result,space,res)

II.Def函数形式

def person_pratice(n):
    ans=0#判断字母 包括大小写
    result=0#判断数字
    space=0#判断空格
    res=0#判断符号的个数
    for i in n:
        if i.isalpha():
            ans+=1
        elif i.isdigit():
            result+=1
        elif i.isspace():
            space+=1
        else:
            res+=1
    return ans,result,space,res

def main():
    result1=person_pratice(input())
    for i in result1:#对结果打印
        print(i,end=" ")
main()

五、 矩阵的输入和用法

1.矩阵的定义

定义3*3的数组

arr=[[0 for i in range(3)] for j in range(3)]
for i in range(len(arr)):
    arr[i]=input().split()#对每一行进行输出

for i in range(3):
    for j in range(i):
        t=arr[i][j]#暂时存储
        arr[i][j]=arr[j][i]#行列交换
        arr[j][i] = t

for i in range(3):
    for j in range(3):
        print(arr[i][j],end=" ")
    print()

#定义 3*3二维数组
arr=[[0 for i in range(3)] for j in range(3)]#设置每个参数值都为0
for i in range(3):#对每一行的数组进行输出
    arr[i]=input().split()

#类似于冒泡排序  行列互换
for i in range(3):#对原来的数据进行置换
    for j in range(i):#最大值为1
        t=arr[i][j] #找一个可以暂存的对象
        arr[i][j]=arr[j][i]
        arr[j][i]=t
for i in range(3):#输出
    for j in range(3):
        print(arr[i][j],end=" ")
    print()

2.矩阵的用法

#首先满足3 * 3矩阵对角线
ls=[input().split(), input().split(),input().split()]
cols=len(ls)
rows=len(ls)
#先行后列
res=0
ans=0
for i in range(cols):
    for j in range(rows):
        #当i和j相等重合的时候等于主对角线
        if i==j:
            res+=int(ls[i][j])
        #当i和j相等+2的时候等于副对角线
        if  i+j==2:
            ans+=int(ls[i][j])
print(res, ans)





3 * 3  矩阵li1转化成一个数组列表,且使该数组中仅仅包含偶数：
li1=[
     [1,2,3],
     [4,5,6],
     [7,8,9]
     ]
print([item2 for item1 in li1 for item2 in item1 if item2 %2==0])#最开头的相当于循环里面的append 追加到列表

li2=[]
for item1 in li1:
    for item2 in item1:
        if item2 % 2 == 0:
            li2.append(item2)
print(li2)





ls=[input().split(), input().split(), input().split()]
sum1=sum2=0
for i in range(3):#0 1 2 行
    for j in range(3):#0 1 2 列
        if(i==j):
            sum1+=int(ls[i][j])
        if(i+j==2):
            sum2+=int(ls[i][j])
print(sum1,sum2)
#0 2=2 1 1=2 2 0=2

3.砝码重量(案例)

n = int(input())
li = list(map(int,input().split()))#给出n个砝码的重量

weigh = sum(li) #对列表li求和，得出砝码能称出的最大重量weigh=10

#建立二维数组，dp[i][j]==1表示当有列表li中前i个砝码时可以称出重量j
dp = [[0 for i in range(weigh+1)] for j in range(n+1)]

#初始状态：当只有砝码1时，可以称出重量0和第1个砝码的重量li[1]
dp[1][0] = 1
dp[1][li[0]]=1

#如果dp[i-1][j]==1，也就是前i-1个砝码可以称出重量j，那么：
#1.前i个砝码肯定也能称出j，所以dp[i][j]=1(不把第i个砝码放进天平)
#2.有i个砝码，把第i个砝码放进天平
#把第i个砝码放进天平重的一端，测得重量为原本重量j加上第i个砝码的重量li[i-1]
#把第i个砝码放进天平轻的一端，测得重量为原本重量j和第i个砝码的重量li[i-1]相减的绝对值
for i in range(2,n+1):
    for j in range(weigh+1):
        if dp[i-1][j]:
            dp[i][j] = 1
            dp[i][j+li[i-1]] = 1
            dp[i][abs(j-li[i-1])] = 1

#减去测得重量为0的情况
print(sum(dp[n])-1)

六、排序

python中sort函数用法是pairs.sort(key=lo)，将整个pairs迭代后每一次迭代的值都会传入lo。

1、为什么xy_cmp函数返回值是1，0，-1。
xy_cmp传入的x和y参数是li相邻的两个元素，它们在进入函数前被转为了str；函数中使用x+y与y+x进行比较，这里进行的是字符串形式的比较，比如"32"+“94”=“3294”，“94”+“32”=“9432”，用"3294"<"9432"进行比较，结果会是True，这样就会返回1

xy_cmp函数返回的1，0，-1三个数字有什么意义？

这个返回的数字作为cmp_to_key函数的参数，

次函数的参数如果为正数，则会交换li相邻两元素，其他情况则不会交换

另外系统能自动了解x,y分别是指代列表中的两个对象

x与y是li列表中相邻两元素

a.sort是对a进行排序，返回None，sorted(a)返回一个排好序的副本，a不变。

2、min抓一个数，放进一个新列表，然后删除这个数，再继续min抓下一个数，原列表空了跳出循环。

matirx_done

= [[0 for i in range(0, len(matirx))]for j in range(0, len(matirx[0]))]

就将其初始化为一个与matrix相同大小的元素全为 0 的矩阵

数组的多级排序
在数组 idea_collect = [[3, 1, 2], [3, 2, 1], [3, 2, 2], [3, 1, 1]] 中,

先按照第二项排列, 再按照第三项倒序排列 可写为:

idea_collect.sort(key=lambda x: (x[1], -x[2]))

总结；x[1] 代表第二项正序排列，-x[2] 代表第三项倒序排列排列结果为 [[3, 1, 2], [3, 1, 1], [3, 2, 2], [3, 2, 1]]在一个 class 中多个函数不传参使用同一个数组。