蓝桥杯Python组寒假第一次练习总结

A 六位数

1822: 六位数
[命题人 : admin]
时间限制 : 1.000 sec 内存限制 : 128 MB
题目描述
请编写一个程序统计在M和N之间（M<N，且包含M和N）有多少个六位数ABCDEF满足以下要求：
(1) ABCDEF这六个数字均不相同，即A、B、C、D、E和F表示六个不同的数字。
(2) AB+CD=EF。即将这个六位数拆成三个两位数，使得第1个和第2个两位数的和等于第3个两位数。
输入
单组输入。
输入两个六位正整数M和N（M<N），两者之间用空格隔开。
输出
输出在M到N之间（包含M和N）满足要求的六位数的个数。
样例输入 Copy
100000 110000
样例输出 Copy
0
来源/分类

def change(n):
    global flag
    n1=str(n)
    a = n // 10000
    n = n % 10000
    b = n // 100
    n = n % 100
    c = n
    if dis(n1)==True:
         if a + b == c:
            flag += 1
def dis(n):
    for i in range(5):
        for j in range(i+1,6):
            if n[i]==n[j]:
                return False
    return True
while True:
    n, m = map(int, input().split())
    flag = 0
    for i in range(n, m + 1):
        change(i)
    print(flag)

B 饮料换购

2154: 饮料换购
[命题人 : 202001080138]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
乐羊羊饮料厂正在举办一次促销优惠活动。
乐羊羊C型饮料，凭3个瓶盖可以再换一瓶C型饮料，并且可以一直循环下去(但不允许暂借或赊账)。
请你计算一下，如果小明不浪费瓶盖，尽量地参加活动。
那么，对于他初始买入的n瓶饮料，最后他一共能喝到多少瓶饮料。
输入
输入存在多组测试数据
每组测试数据输入一行包含一个正整数n(1<=n<=10000)
输出
对于每组数据输出一行，包含一个整数，表示实际得到的饮料数
样例输入 Copy
100
101
样例输出 Copy
149
151

while True:
    n=int(input())
    s=n
    while n>=3:
       s+=n//3
       n=n%3+n//3
    print(s)

C 01翻转

1959: 01翻转
[命题人 : 201701020223]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
小H有个仅有01构成的n行n列矩阵。
每天小H都会选择一个子矩阵，进行01翻转操作，
即该区域状态：0->1,1->0。
输入
第1行一个整数n(1<=n<=100)，表示矩阵大小。
接下来n行，表示矩阵初始状态。
第n+2行，一个整数q(1<=q<=100)，表示天数。
接下来q行，每行4个整数x1,y1,x2,y2，分别表示子矩阵的左上角坐标，右下角坐标。
题目保证：1<=x1<=x2<=n,1<=y1<=y2<=n。
输出
对于每天，输出翻转操作后矩阵的状态。
(矩阵每行最后一个元素均无空格)
样例输入 Copy
2
0 1
1 0
2
1 1 1 1
1 1 2 2
样例输出 Copy
1 1
1 0
0 0
0 1

def change(x1, y1, x2, y2):
    for i in range(x1, x2 + 1):
        for j in range(y1, y2 + 1):
                s[i][j]=s[i][j]^1
while True:
    n = int(input())
    s = [[] for i in range(n)]
    for i in range(n):
        s[i] = list(map(int, input().split()))
    q = int(input())
    for i in range(q):
        x1, y1, x2, y2 = map(int, input().split())
        change(x1-1, y1-1, x2-1, y2-1)
        for ii in range(n):
            for jj in range(n):
                print('%d ' % (s[ii][jj]), end="")
            print()

D Numbers

1965: Numbers
[命题人 : 201801020124]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
小b打算拉着小h做一道简单的数学题，但是小h觉得太简单了，于是找到了你，相信对你来说也是小菜一碟。
具体题目为：现在有一个10进制整数122，如果转成16进制的话应该是7A，那么位数和则为17。现在题目升级为给定一个10进制整数n，需要对n转化为2~n-1进制下对应的数，并求出它们的位数和a。然后将a作为分子，n转化为不同格式数的个数作为分母b。输出最简分子式a/b
输入
第一行输入一个整数t，表示t组数据(t<=100)
接下来t行，每行输入一个10进制整数n（2<n<=1000）
输出
输出n行，每行输出题目描述的最简分子式
样例输入 Copy
2
10
5
样例输出 Copy
3/1
7/3

def change(n, t):
    s = 0
    while n > 0:
        s += n % t
        n = n // t
    return s
def sim(a, b):
    min1 = min(a, b)
    for i in range(2, min1 + 1):
        while a % i == 0 and b % i == 0:
            a = a // i
            b = b // i
    return a,b
t = int(input())
for i in range(t):
    n = int(input())
    b = n - 2
    a = 0
    for j in range(2, n):
        a += change(n, j)
    a,b=sim(a,b)
    print('%d/%d'%(a,b))

E 移动距离

2155: 移动距离
[命题人 : 202001080138]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
X星球居民小区的楼房全是一样的，并且按矩阵样式排列。
其楼房的编号为1,2,3… 当排满一行时，从下一行相邻的楼往反方向排号。
比如：当小区排号宽度为6时，开始情形如下：
1 2 3 4 5 6
12 11 10 9 8 7
13 14 15 …
我们的问题是：已知了两个楼号m和n，需要求出它们之间的最短移动距离
（不能斜线方向移动）
输入
输入存在多组测试数据
输入为3个整数w m n，空格分开，都在1到10000范围内
w为排号宽度，m,n为待计算的楼号。
输出
要求输出一个整数，表示m n 两楼间最短移动距离。
样例输入 Copy
6 8 2
4 7 20
样例输出 Copy
4
5

def change(x, y):
    if y == 0:
        x -= 1
    if x % 2 == 1 and y == 0:  # 奇数
        y = 0
    elif x % 2 == 1:
        y = w - y
    elif y == 0:
        y = w - 1
    else:
        y = y - 1
    return x, y
while True:
    w, m, n = map(int, input().split())
    x1, y1 = m // w, m % w
    x2, y2 = n // w, n % w
    x1, y1 = change(x1, y1)
    x2, y2 = change(x2, y2)
    print(abs(x1 - x2) + abs(y1 - y2))

F 魔板

2133: 魔板
[命题人 : 202001080138]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
Rubik先生在发明了风靡全球魔方之后，又发明了它的二维版本——魔板。这是一张有8个大小相同的格子的魔板：

1234
8765

我们知道魔板的每一个方格都有一种颜色。这8种颜色用前8个正整数来表示。可以用颜色的序列来表示一种魔板状态，规定从魔板的左上角开始，沿顺时针方向依次取出整数，构成一个颜色序列。对于上图的魔板状态，我们用序列1,2,3,4,5,6,7,8来表示。这是基本状态。
这里提供三种基本操作，分别用大写字母A，B，C来表示（可以通过这些操作改变魔板的状态）：
A：交换上下两行；
B：将最右边的一列插入最左边；
C：魔板中央作顺时针旋转。下面是对基本状态进行操作的示范：
A：
8765
1234
B：
4123
5876
C：
1724
8635

对于每种可能的状态，这三种基本操作都可以使用。
你要编程计算用最少的基本操作完成基本状态到特殊状态的转换，输出基本操作序列。
输入
输入仅一行，包括8个整数，用空格分开，表示目标状态。
输出
输出文件的第一行包括一个整数，表示最短操作序列的长度。第二行为在字典序中最早出现的操作序列。
样例输入 Copy
2 6 8 4 5 7 3 1
样例输出 Copy
7
BCABCCB
提示
输入数据中的所有数字均为1到8之间的整数。

from queue import Queue
def A(s):
    s = list(s)
    w = s[:4]
    s[:4] = s[4:]
    s[4:] = w
    return com(s)
def B(s):
    s = list(s)
    m = s[3]
    m1 = s[7]
    del s[7]
    del s[3]
    s.insert(0, m)
    s.insert(4, m1)
    return com(s)
def C(s):
    s = list(s)
    p1 = s[5]
    p2 = s[2]
    del s[5]
    del s[2]
    s.insert(1, p1)
    s.insert(6, p2)
    return com(s)
def com(s):
    t = ''
    for y in s:
        t += y
    return t
def cout():#利用队列的性质构造bfs
    global result, init
    p.put(init)
    targ.setdefault(init, 0)#初始化targ字典为targ[init]=0
    while not p.empty():
        t = p.get()
        pro = [0 for i in range(3)]
        pro[0] = A(t)#表示三种变化后的字符串，bfs是一种并行的多线程,三种变化同时操作，最先找到目标值，则为次数最少的
        pro[1] = B(t)
        pro[2] = C(t)
        for i in range(3):
            if pro[i] not in targ:
                targ[pro[i]] = targ[t] + 1
                save[pro[i]] = [chr(ord('A') + i), t]
                p.put(pro[i])
                if pro[i] == result:
                    return targ[result]
while True:
    init = "12348765"
    targ = {} #key为操作之后的字符串，vale为第几次操作数
    save = {}#key为操作之后的字符串，vale为{操作的方法，操作之前的字符串}
    p = Queue()
    result1 = list(map(str, input().strip().split()))
    t = result1[:-5:-1]#转化目标字符串
    result1[4:] = t
    result = ""
    for t in result1:
        result += t
    cout()
    print(targ[result])
    len = targ[result]
    s = [[] for i in range(len)]
    t = save[result][1]
    s[-1] = save[result][0]
    for i in range(1,len):#遍历寻找前一个的操作方法
        s[len - i - 1] = save[t][0]
        t = save[t][1]
    r = ''
    for t in s:
        r += str(t)
    print(r)

G 神秘数列

2090: 神秘数列
[命题人 : admin]
时间限制 : 1.000 sec 内存限制 : 128 MB

题目描述
喜欢探险的Kimi同学在一个山洞中发现了一串神秘的数，这串数的前七项如下：
1, 1, 8, 22, 85, 281, 988, …
Kimi很想知道这个神秘数列中所蕴含的规律，你能否编写一个程序帮帮他。
当输入一个正整数N时，输出这个神秘数列第N项的值。
输入
单组输入。
输入一个正整数N，N<=50。

输出
输出神秘数列的第N项的值。
样例输入 Copy
8
样例输出 Copy
3382

def cout():
    for i in range(5,55):
        s.append(s[i]*3+s[i-1]*3+s[i-2]*-5)
while True:
    s=[1,1,8,22,85,281]
    cout()
    n=int(input())
    print(s[n-1])