当前位置:   article > 正文

python蓝桥杯(考前一定要掌握的常用函数及问题)_蓝桥杯python

蓝桥杯python


本人不才,以下是蓝桥杯中最为基础的函数,考前一定要掌握。

注意

1. 要保证数据类型对齐

a=[1,3,'5']
b=5
if b in a:
    print('true')#这里输出为空,因为一个是int的5,一个是str的5
  • 1
  • 2
  • 3
  • 4
1.sort()
b=[1,6,2]
b.sort()#这里不能写b=b.sort()
print(b)
以下也是
a.append  #添加的可以是str ,int
a.extend
b.insert
a.remove(10)#尽管a中有多个10,只去一个

2. count=0
def sum()
    global count#定义一个全局变量
    count+=1
    
3. 把可能出错的点找出来,防止报错
    if tx < 0 or tx >= row or ty < 0 or ty >= col:  # 越界情况
            continue
4. while len(data)>=2:#用于判断循环,一直输出yes
       print('yes')
if len(data)>=2:#只输出一个yes
    print('yes')
    
data=5
while data >=2:#while是一直循环,变量一直被附新值
    print('yes')
    data-=1
    
6. print(round(3.5),int(3.8))  > 保留45入,只保留整数
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  1. int(input()) float(input())

常用函数

Input

1. 只需要一行输入
data = list(map(int,input().split()))
m,n = map(int,intput().split())
2. 多行输入
多个input语句,如下三种
请添加图片描述

1. Input输入返回的是str,2. 多个值就是list—input.split() 3. 根据需求map(int,input.split()) 4. 每出现一个input就代表一行 5. 加了map就表示左侧是多接收
a=input()#一个值
a,b=input().split()#左边限定为两值(空格输入,回车执行)
c=input().split()#list

1、输入一个数字直接 m = int(input())2、输入两个数字就是 
   m, n = map(int, input().split())#用了map就意为着左边是多值接收,
3. a,b=map(int,input().split("#"))4. str=list(map(int,input().split()))#这样可以**一行输入**无线多的数据,用list盛放
5. data=[int(input()) for _ in range(10)]#将**多行input的输入**,放到一个list中
6. data=[list(map(int,input().split())) for i in range(2)]相同的思想生成数组
7. data=[tuple(map(int, input().split())) for _ in range(n)]
8. 连着输入for i in range(t):
                        x=input()
9. arr = input().split()#list里一个是str,一个是int
	print(arr)
	a=list(map(int,input().split()))
	print(a)
	12 6
	['12', '6']
	45 6
	[45, 6]
9.a=2.568
a=str(a)
print(float(a[0:4])+1)#通过变成str,不4舍5入,再float成数值
print('%.2f'%(float(a)))#%.2f直接4舍5入
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22

占位符

主要是填充格式问题,注意加‘ ’号的就成了字符,{ : #x}控制一切

%s 字符串  {:s}  {:#x}.format(18)#将18保存为16进制的格式
%d 整数    {:d}
%.2f 浮点数字(用小数点符号,45)   {:.2f}
%.2e 浮点数字(科学计数法)     {:.2e}1212加引号的就是字符,不加就是数值
  • 1
  • 2
  • 3
  • 4
  • 5

%对应{:}
print(’{}’.format(‘爱’))# %,{:} 都在print()里面
print(‘11%s’%(‘ss’))

print("我喜欢%s,%s天%.2f时"%('你',32,125.158))
print('我喜欢{},{:d}天{:.2f}时'.format('你',32,123.158))
print('{:0>5}'.format('33'))#一共填充5个数字,前4个为0
  • 1
  • 2
  • 3

format格式化(将n按x格式化赋给a),(#:保留进制前缀)
a=format(n,‘格式’)#格式只能小写
format(18, ‘b’)#二进制
format(18, ‘#b’)#二进制
format(18, ‘x’)#16
format(18, ‘o’)#8

str类型的内建函数

# 小写 s=S.lower() 
# 大写 S.upper() 
#大小写互换 S.swapcase() 
# 只有首字母大写 S.capitalize()  L love you
# 只要遇到空格都会大写s.title    L Love You
# 输出width个字符,S左对齐,不足部分用fillchar填充,默认的为空格。 
S.ljust(width,[fillchar]) 

返回字符串第一次出现的索引,如果没有匹配项则返回-1,索引从0开始,s.find针对字符串,会返回-1,s.index()针对列表,找不到直接报错
S.find('a', 0,3)0-2的索引中找
s.rfind('a',0,3)
s='l love'
print(s.index('l'))#0 只能返回首次出现的地方
print(s.find('l',1,-1))#2 指定位置查询
# 计算substr在S中出现的次数 
S.count(substr, start, end) 
#把S中的oldstar替换为newstr,count为替换次数
S.replace(oldstr, newstr, count)
S.strip([chars]) 移除s list中指定的chars字符

S.split([sep, [maxsplit]]) # 以sep为分隔符,把S分成一个list。maxsplit表示分割的次数。
S.join(seq)#.join(): 连接字符串数组。将字符串、元组、列表中的元素以指定的字符(分隔符)连接生成一个新的字符串
a='-'
b='helloword'
print(a.join(b))
>h-e-l-l-o-w-o-r-d

str='sdfWFSDss'
a=str.find('s',0,10)#第一个s返回索引,从0开始
a=str.rfind('s',0,10)#最后一个返回索引
a=str.count('s',0,10)
a=str.replace('s','0')
a=str.strip('s')#剥离str中所有的‘s’
print(a)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34

Print()

for i in range(10):
    print(i,end='')#打印在一行
    print(i,end='\n')#换行符结尾
  • 1
  • 2
  • 3

a[起点 :终点 :步长]切片

  1. 切片可以切列表,字符串,不能且int(可转化)
  2. 切片包含起点,不包含终点
  3. 对于未指明起点的,步长=1,从0开始,步长=-1,从最后一位开始
a=[0,1,2,3,4,5]
1. #对于未指明起点的,步长=1,从0开始,步长=-1,从最后一位开始
print(a[:3:1])————[0, 1, 2]
print(a[:3:-1])
>[0, 1, 2]
 [5, 4]
print((a[::-1]))————[5, 4, 3, 2, 1, 0]
print(a[:2:-1])————[5, 4, 3]起点为index=-1,从后往前走,不包括终点2
2. #从起点1,倒着走到3,返回空
print(a[1:3:-1])————[]不会返回,所以为空
print(a[3:1:-1])可以
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

数字运算

##输入32345分别输出每位
%求余(后面只跟10//求整
sum= a%10+a//10%10+a//100%10+a//1000%10+a//10000
》》5+4+3+2+3

a=25165
print(a%10,a//10%10,a//100%10,a//1000%10,a//10000)
print(a//10000,a//1000%10,a//100%10,a//10%10,a%10)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

list运算

##二维列表:列表中的元素是列表,本质:一维列表
a=[[1,2,3],[3,4,5]]
--list.append(lista)#lista当成一个元素加到前面的列表中
--lista+listb #才是拼接
--list.extend(str)#extend()里面是字符串时,每一个字符都是一个元素,里面要是list的话,则list当成一个元素加入
>>list.extend([1,2,3])
--list.insert(index,obj)
--list.remove(obj)移除第一个匹配项
--list.index(obj)找出某个值第一个匹配项的下标
--list(seq)将字符串转为列表
--zip(list1,list2)zip封装三列表,在for遍历
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
a=['sds',152, ]
b=['sds',545,'ttt']
a.append('sdf')#当成一个str加入
a.extend('sdf1')#每个字符算一个str
b.insert(1,'love')#在b的第1个位置前插入,自己成为第1个数
a.remove(152)#移除第一个匹配项
print(a)
print(b)
print(list('45125'))#将字符串转为列表

f=['sdf1']
a.extend('df1')=['sds', 'sdf', 's', 'd', 'f', '1'] a.extend(f)=['sds', 'sdf', 'sdf1']
['sds', 'love', 545, 'ttt']
['4', '5', '1', '2', '5']zip封装三列表,在for遍历
a=[1,1,1,1]
b=[1,1,1,1]
c=[1,1,1,1]
for i,j ,k in zip(a,b,c):
    print(i,j,k)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21

刷题

1. 回文数

正着数和倒着数都一样,输出所有的这样的四位数
如 1221

def hui(a):
    if str(a) == str(a)[::-1] and len(str(a))==4 :
        print(a,end=' ')

for i in range(10000):
    hui(i)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6

2. 水仙花数

问题描述
  153是一个非常特殊的数,它等于它的每位数字的立方和,即153=111+555+333。编程求所有满足这种条件的三位十进制数。
输出格式
  按从小到大的顺序输出满足条件的三位十进制数,每个数占一行。
三位数&是否满足条件,遍历

def shui(a):
    if len(str(a))==3:
        if int((str(a)[0]))**3+int((str(a)[1]))**3+int((str(a)[2]))**3==a:
            print(a,)

def shui1(a):
    if len(str(a))==3:
        if (a//100)**3+(a%100//10)**3+(a%100%10)**3 == a:
            print(a)

for i in range(1000):
    shui(i)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

3. 查找整数

给出一个包含n个整数的数列,问整数a在数列中的第一次出现是第几个。
输入格式
第一行包含一个整数n。
第二行包含n个非负整数,为给定的数列,数列中的每个数都不大于10000。
第三行包含一个整数a,为待查找的数。
输出格式
如果a在数列中出现了,输出它第一次出现的位置(位置从1开始编号),否则输出-1。
样例输入
6
1 9 4 8 3 9
9
样例输出
2
数据规模与约定
1 <= n <= 1000。

要匹配好数据格式

n = int(input())#str
arr = input().split()#list中是str
a = input()

n=int(input())#int
m=list(map(int,input().split()))#list中是int
z=int(input())

for i in range(n):
    if z==m[i]:
        print(i+1)
        break

if z not in m:
    print(-1)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

4. 数列特征

max(列表)

n=int(input())
m=list(map(int,input().split()))
print(max(m))
print(min(m))
print(sum(m))
  • 1
  • 2
  • 3
  • 4
  • 5

5. 字母图形

利用字母可以组成一些美丽的图形,下面给出了一个例子:

ABCDEFG

BABCDEF

CBABCDE

DCBABCD

EDCBABC

这是一个5行7列的图形,请找出这个图形的规律,并输出一个n行m列的图形。
输入格式
输入一行,包含两个整数n和m,分别表示你要输出的图形的行数的列数。
输出格式
输出n行,每个m个字符,为你的图形。
样例输入
5 7
样例输出
ABCDEFG
BABCDEF
CBABCDE
DCBABCD
EDCBABC
数据规模与约定
1 <= n, m <= 26。

利用[: : ]切片的方式,把第一个当样本,后面的都在那上面操作

a=[]
str='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
a.extend(str)
m,n=map(int,input().split())
c=a[: n: 1]
for i in range(n):
    print(c[i],end='')
print(end='\n')

for j in range(m-1):
    d=c[j+1 : :-1]
    e=c[1 :n-(j+2)+1 : 1]

    for v in range(n):
        print((d+e)[v],end='')
    print(end='\n')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
n,m = map(int,input().split())
a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in range(n):
    s=a[0:m]
    print(s[1:i+1][::-1]+s[:m-i])



  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8

6. 字串01

对于长度为5位的一个01串,每一位都可能是0或1,一共有32种可能。它们的前几个是:

00000

00001

00010

00011

00100

请按从小到大的顺序输出这32种01串。
输入格式
本试题没有输入。
输出格式
输出32行,按从小到大的顺序每行一个长度为5的01串。
样例输出
00000
00001
00010
00011

for i in range(32):
    print('{0:0>5}'.format(format(i,'b')))
  • 1
  • 2

在这里插入图片描述

7. 闰年判断

给定一个年份,判断这一年是不是闰年。
当以下情况之一满足时,这一年是闰年:

  1. 年份是4的倍数而不是100的倍数;
  2. 年份是400的倍数。
    其他的年份都不是闰年。
    输入格式
    输入包含一个整数y,表示当前的年份。
    输出格式
    输出一行,如果给定的年份是闰年,则输出yes,否则输出no。
    说明:当试题指定你输出一个字符串作为结果(比如本题的yes或者no,你需要严格按照试题中给定的大小写,写错大小写将不得分。
    样例输入
    2013
    样例输出
    no
    样例输入
    2016
    样例输出
    yes
    数据规模与约定
    1990 <= y <= 2050。
n=int(input())
if n%4==0 and n%400==0 or n%100!=0:
    print('yes')
else:
    print('no')
  • 1
  • 2
  • 3
  • 4
  • 5

8. 阶乘计算

两个参数,一个控制数字递增,一个控制相乘

n=input()
c=1
z=[i for i  in range(1,int(n)+1)]
for i in range(int(n)):
    c=c*int(z[i])
print(c)


n=int(input())
a=b=1
while a<=n:
    b=b*a
    a+=1
print(b)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14

9. 哈夫曼树

问题描述
  Huffman树在编码中有着广泛的应用。在这里,我们只关心Huffman树的构造过程。
  给出一列数{pi}={p0, p1, …, pn-1},用这列数构造Huffman树的过程如下:
  1. 找到{pi}中最小的两个数,设为pa和pb,将pa和pb从{pi}中删除掉,然后将它们的和加入到{pi}中。这个过程的费用记为pa + pb。
  2. 重复步骤1,直到{pi}中只剩下一个数。
  在上面的操作过程中,把所有的费用相加,就得到了构造Huffman树的总费用。
  本题任务:对于给定的一个数列,现在请你求出用该数列构造Huffman树的总费用。

例如,对于数列{pi}={5, 3, 8, 2, 9},Huffman树的构造过程如下:
  1. 找到{5, 3, 8, 2, 9}中最小的两个数,分别是2和3,从{pi}中删除它们并将和5加入,得到{5, 8, 9, 5},费用为5。
  2. 找到{5, 8, 9, 5}中最小的两个数,分别是5和5,从{pi}中删除它们并将和10加入,得到{8, 9, 10},费用为10。
  3. 找到{8, 9, 10}中最小的两个数,分别是8和9,从{pi}中删除它们并将和17加入,得到{10, 17},费用为17。
  4. 找到{10, 17}中最小的两个数,分别是10和17,从{pi}中删除它们并将和27加入,得到{27},费用为27。
  5. 现在,数列中只剩下一个数27,构造过程结束,总费用为5+10+17+27=59。
输入格式
  输入的第一行包含一个正整数n(n<=100)。
  接下来是n个正整数,表示p0, p1, …, pn-1,每个数不超过1000。
输出格式
  输出用这些数构造Huffman树的总费用。
样例输入
5
5 3 8 2 9
样例输出
59

remove去除,fei+=迭代

m=int(input())
a=list(map(int,input().split()))
fei=0
while len(a)>1:
    min1=min(a)
    a.remove(min1)
    min2=min(a)
    a.remove(min2)
    a.append(min1+min2)
    fei+=(min1+min2)
print(fei)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

pop去除,fei存到list中,求sum

m=int(input())
a=list(map(int,input().split()))
b=[0 for i in range(m-1)]
for v in range(m-1):
    a.sort()
    min1=a.pop(0)
    min2=a.pop(0)
    b[v]=min1+min2
    a.append(b[v])
print(sum(b))

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

10. 递归问题

在这里插入图片描述
斐波那契

def feibo(n):
    if n==1 or n==2:
        return 1
    return feibo(n-1)+feibo(n-2)

a=feibo(5)
print(a)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

11.报时

21:54读作“twenty one fifty four”

i,m=map(int,input().split())
dic={0:'zero', 1: 'one', 2:'two', 3:'three', 4:'four', 5:'five', 6:'six', 7:'seven', 8:'eight', 9:'nine', 10:'ten', 11:'eleven', 12:'twelve', 13:'thirteen', 14:'fourteen', 15:'fifteen', 16:'sixteen', 17:'seventeen', 18:'eighteen', 19:'nineteen', 20:'twenty',30:'thirty',40:'forty',50:'fifty'}
def jisuan(n):
    if n in list(dic.keys()):
        n= dic[n]
        return n
    else:
        ge=dic[n%10]
        shi=dic[n-n%10]
        a=shi+' '+ge
        return a

print(jisuan(i)+' '+jisuan(m))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

1. FJ字符串

问题描述
  FJ在沙盘上写了这样一些字符串:
  A1 = “A”
  A2 = “ABA”
  A3 = “ABACABA”
  A4 = “ABACABADABACABA”
  … …
  你能找出其中的规律并写所有的数列AN吗?
输入格式
  仅有一个数:N ≤ 26。
输出格式
  请输出相应的字符串AN,以一个换行符结束。输出中不得含有多余的空格或换行、回车符。
样例输入
3
样例输出
ABACABA
递归,下一行=上一行+一个字母+上一行

q=int(input())
a='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
b=[]
c=['A']
b.extend(a)
def fj(n):

    if n==1:
        return c
    return fj(n-1)+list(b[n-1])+fj(n-1)
w=fj(q)
for i in range(len(w)):
    print(w[i],end='')
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

chr(ord(‘A’)+i)—利用这个进行asscii和数值的转化,实现ABC自动变

n=int(input())

str=''
for i in range(n):
    str=str+ chr(ord('A')+i)+ str
print(str)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

2. 矩形面积交

问题描述
  平面上有两个矩形,它们的边平行于直角坐标系的X轴或Y轴。对于每个矩形,我们给出它的一对相对顶点的坐标,请你编程算出两个矩形的交的面积。
输入格式
  输入仅包含两行,每行描述一个矩形。
  在每行中,给出矩形的一对相对顶点的坐标,每个点的坐标都用两个绝对值不超过10^7的实数表示。
输出格式
  输出仅包含一个实数,为交的面积,保留到小数后两位。
样例输入
1 1 3 3
2 2 4 4
样例输出
1.00


解题思路:

重点是找到两个矩形产生交集的条件
矩阵1的对角点坐标的横坐标取最小, 矩阵2的对角点坐标的横坐标取最小,然后再从这两个值中取最大,得x1
矩阵1的对角点坐标的横坐标取最大, 矩阵2的对角点坐标的横坐标取最大,然后再从这两个值中取最小,得x2
如果x1<x2,这两个矩形才会有交集
纵坐标同理
最后交集的面积就为:
area = (x2 - x1) * (y2 - y1)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

在这里插入图片描述

area=0
x1=max(min(rect1[0],rect1[2]),min(rect2[0],rect2[2]))
x2=min(max(rect1[0],rect1[2]),max(rect2[0],rect2[2]))

y1=max(min(rect1[1],rect1[3]),min(rect2[1],rect2[3]))
y2=min(max(rect1[1],rect1[3]),max(rect2[1],rect2[3]))

if x1<x2 and y1<y2:
    print('{:.2f}'.format((y2-y1)*(x2-x1)))
else:
    print('{:.2f}'.format(area))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

3. 字符串对比

if elif elif(顺序执行)
只要满足一个,后面就不执行,反过来就是说它能print(4)说明前面的条件都不满足
因此elif直接是有关系的,每加一个elif就多了一个约束,一层层递进,跟下面单独写的if else是一回事
if if 是(并列运行),它们没什么关系
print(1)

str1=str(input())
str2=str(input())
if len(str1) !=len(str2):
    print(1)
else:
    if str1 ==str2:
        print(2)
    else:
        if str1.upper() == str1.upper():
            print(3)
        else:
            print(4)

  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

4. 时间转换

问题描述
  给定一个以秒为单位的时间t,要求用H:M:S的格式来表示这个时间。H表示时间,M表示分钟,而S表示秒,它们都是整数且没有前导的“0”。例如,若t=0,则应输出是“0:0:0”;若t=3661,则输出“1:1:1”。
输入格式
  输入只有一行,是一个整数t(0<=t<=86399)。
输出格式
  输出只有一行,是以“H:M:S”的格式所表示的时间,不包括引号。
样例输入
0
样例输出
0:0:0
样例输入
5436
样例输出
1:30:36
解题思路:

time=int(input())
print('{}:{}:{}'.format(time//3600,time%3600//60,time%3600%60))
  • 1
  • 2

5. 石子游戏

n=int(input())
data=[int(input()) for i in range(n)]
result=0
while len(data)>=2:
    data.sort()
    result+=(data[-1]+1)*(data[-2]+1)
    data[-2]+=data[-1]
    data.pop(-1)
print(result)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

6. 复数求和

n=int(input())
data=[list(map(int,input().split())) for i in range(n)]
print(data)

for i in range(n):
    if len(data[i])==1:
        data[i].append(0)
x=0
y=0
for v in range(n):
    x+=data[v][0]
    y+=data[v][1]
print('{}+{}i'.format(x,y))
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13

7. 最大公约数算法

辗转相除法

有两整数a和b:

① a%b得余数c

② 若c=0,则b即为两数的最大公约数

③ 若c≠0,则a=b,b=c,再回去执行①

def gong(a,b):
    if a%b==0:
        return b
    else:
        c=a%b
        a=b
        b=c
        return gong(a,b)

n=int(input())
data=[list(map(int,input().split())) for _ in range(n)]
for i in range(n):
    a=data[i][0]
    b=data[i][1]
    x=gong(a,b)
    print(x)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16

== while c!=0:
a=b
b=c
c=a%b==通过while循环的方式,一直迭代

n=int(input())
data=[list(map(int,input().split())) for _ in range(n)]
for i in range(n):
    a = data[i][0]
    b = data[i][1]
    c=a%b
    while c!=0:
        a=b
        b=c
        c=a%b
    print(b)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11

递归

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

def func(x):
    if x>0:
        print('抱着',end='')
        func(x-1)
        print('的我',end='')
    else:
        print('我的小鲤鱼',end='')

func(2)
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/我家小花儿/article/detail/64182
推荐阅读
相关标签
  

闽ICP备14008679号