持续更新ing......

• C题 取模 ⏰
• D题 内存空间🎈
• E题 近似 GCD ⏰

文章小记：本文是记录蓝桥杯真题暴力解法的帖子，其中有部分题目会因为时间超时而无法通过。

题目	名字
C题	取模
D题	内存空间
E题	近似 GCD
F题	交通信号
G题	点亮
H题	打折
I题	owo
J题	替换字符

现在开始一题题的暴力解决：

C题 取模 ⏰

题目描述

给定 n, m ，问是否存在两个不同的数 x, y 使得 1 ≤ x < y ≤ m 且 n mod x = n mod y 。

输入格式

• 输入包含多组独立的询问。
• 第一行包含一个整数 T 表示询问的组数。
• 接下来 T 行每行包含两个整数 n, m，用一个空格分隔，表示一组询问。

输出格式

输出 T 行，每行依次对应一组询问的结果。如果存在，输出单词 Yes；如果不存在，输出单词 No。

样例输入

3
1 2
5 2
999 99

样例输出

No
No
Yes

cols = int(input())

list_cols = []
for i in range(cols):
    n_1,m_1=map(int,input().strip().split())
    list_cols.append([n_1,m_1])


for j in range(cols):
    flag = False
    for x in range(1,list_cols[j][1]+1):
        for y in range(x+1,list_cols[j][1]+1): 
            if (list_cols[j][0]%x == list_cols[j][0]%y):
                flag = True
    if flag:
        print("Yes")
    else:
        print("No")

D题 内存空间🎈

题目描述

小蓝最近总喜欢计算自己的代码中定义的变量占用了多少内存空间。

为了简化问题，变量的类型只有以下三种：

int：整型变量，一个 int 型变量占用 4 Byte 的内存空间。

long：长整型变量，一个 long 型变量占用 8 Byte 的内存空间。

String：字符串变量，占用空间和字符串长度有关，设字符串长度为 L，则字符串占用 L Byte 的内存空间，如果字符串长度为 0 则占用 0 Byte 的内存空间。

定义变量的语句只有两种形式，第一种形式为：

type var1=value1,var2=value2…;

定义了若干个 type 类型变量 var1、var2、…，并且用 value1、value2、…初始化。

多个变量之间用’,’ 分隔，语句以’;’ 结尾，type 可能是 int、long 或 String。例如 int a=1,b=5,c=6; 占用空间为 12 Byte；long a=1,b=5; 占用空间为 16 Byte；String s1=””,s2=”hello”,s3=”world”; 占用空间为 10 Byte。

第二种形式为：

type[] arr1=new type[size1],arr2=new type[size2]…;

定义了若干 type 类型的一维数组变量 arr1、arr2…，且数组的大小为 size1、size2…，多个变量之间用’,’ 进行分隔，语句以’;’ 结尾，type 只可能是 int 或 long。例如 int[] a1=new int[10]; 占用的内存空间为 40 Byte；long[] a1=new long[10],a2=new long[10]; 占用的内存空间为 160 Byte。

已知小蓝有 T 条定义变量的语句，请你帮他统计下一共占用了多少内存空间。结果的表示方式为：aGBbMBcKBdB，其中 a、b、c、d 为统计的结果，GB、MB、KB、B 为单位。优先用大的单位来表示，1GB=1024MB，1MB=1024KB，1KB=1024B，其中 B 表示 Byte。如果 a、b、c、d 中的某几个数字为 0，那么不必输出这几个数字及其单位。题目保证一行中只有一句定义变量的语句，且每条语句都满足题干中描述的定义格式，所有的变量名都是合法的且均不重复。题目中的数据很规整，和上述给出的例子类似，除了类型后面有一个空格，以及定义数组时 new 后面的一个空格之外，不会出现多余的空格。

输入格式

输入的第一行包含一个整数 T ，表示有 T 句变量定义的语句。

接下来 T 行，每行包含一句变量定义语句。

输出格式

输出一行包含一个字符串，表示所有语句所占用空间的总大小。

样例输入

1
long[] nums=new long[131072];

样例输出

1MB

# 算法思路：
# - 确保输入的类型是哪一种，进行计算内存
# - 内存大小输出：以1024为被除数依次输出

# 记录存储空间大小
int_len = 4
long_len = 8
string_len = 1

# 记录每一种类型的数据长度
int_count = 0
long_count = 0
string_count = 0
int_matrix_count = 0
long_matrix_count = 0
sum_count = 0

# 输入
cols = int(input()) 
list_cols = [] 
for i in range(cols):
    list_cols.append(str(input()).strip().split(",")) 
# 输入处理
# - 输出数据处理
for x in range(cols):
    # int类型 - 直接算
    if (list_cols[x][0][0:4] == "int "):
        int_count = len(list_cols[x]) * int_len
    # long类型 - 直接算
    if (list_cols[x][0][0:5] == "long "):
        long_count = len(list_cols[x]) * long_len
    # string类型 - 以"为分隔符
    if (list_cols[x][0][0:7] == "String "):
        for y_str in range(len(list_cols[x])) :# 一行有几个变量
            # 计算划分后每一个长度的第一个的len作为一个变量的内存
            len_temp_str = len(list_cols[x][y_str].split("\"")[1])
            string_count += len_temp_str
    # int[] 类型 - 以[为分隔符    
    if (list_cols[x][0][0:6] == "int[] "):
        # 先以]为分隔符，再奖第一个以[为分隔符，int类型转换得到结果
        for y_int in range(len(list_cols[x])):# 一行有几个变量
            temp = list_cols[x][y_int].split("[")
            len_temp_int = int(temp[-1].split("]")[0]) * int_len
            int_matrix_count += len_temp_int
    # long[] 类型 - 以[为分隔符    
    if (list_cols[x][0][0:7] == "long[] "):
        for y_long in range(len(list_cols[x])):# 一行有几个变量
            temp = list_cols[x][y_long].split("[")
            len_temp_long = int(temp[-1].split("]")[0]) * long_len
            long_matrix_count += len_temp_long
  
# 数据综合
sum_count = int_count+long_count+string_count+int_matrix_count+long_matrix_count
# 结果输出
GB = sum_count//1024//1024//1024
MB = sum_count//1024//1024%1024
KB = sum_count//1024%1024
B = sum_count%1024
if (GB != 0):
    print(GB,end="")
    print("GB",end="")
if (MB != 0):
    print(MB,end="")
    print("MB",end="")
if (KB != 0):
    print(KB,end="")
    print("KB",end="")
if (B != 0):
    print(B,end="")
    print("B",end="")

E题 近似 GCD ⏰

题目描述

小蓝有一个长度为 n 的数组 A = (a1, a2, · · · , an)，数组的子数组被定义为从原数组中选出连续的一个或多个元素组成的数组。数组的最大公约数指的是数组中所有元素的最大公约数。如果最多更改数组中的一个元素之后，数组的最大公约数为 g，那么称 g 为这个数组的近似 GCD。一个数组的近似 GCD 可能有多种取值。

具体的，判断 g 是否为一个子数组的近似 GCD 如下：

1. 如果这个子数组的最大公约数就是 g，那么说明 g 是其近似 GCD。
2. 在修改这个子数组中的一个元素之后（可以改成想要的任何值），子数组的最大公约数为 g，那么说明 g 是这个子数组的近似 GCD。
   小蓝想知道，数组 A 有多少个长度大于等于 2 的子数组满足近似 GCD 的值为 g。

输入格式

输入的第一行包含两个整数 n, g，用一个空格分隔，分别表示数组 A 的长度和 g 的值。
第二行包含 n 个整数 a1, a2, · · · , an，相邻两个整数之间用一个空格分隔。

输出格式

输出一行包含一个整数表示数组 A 有多少个长度大于等于 2 的子数组的近似 GCD 的值为 g 。

样例输入

5 3
1 3 6 4 10

样例输出

5

提示

满足条件的子数组有 5 个：
[1, 3]：将 1 修改为 3 后，这个子数组的最大公约数为 3 ，满足条件。
[1, 3, 6]：将 1 修改为 3 后，这个子数组的最大公约数为 3 ，满足条件。
[3, 6]：这个子数组的最大公约数就是 3 ，满足条件。
[3, 6, 4]：将 4 修改为 3 后，这个子数组的最大公约数为 3 ，满足条件。
[6, 4]：将 4 修改为 3 后，这个子数组的最大公约数为 3，满足条件。
对于 20% 的评测用例，2 ≤ n ≤ 102；
对于 40% 的评测用例，2 ≤ n ≤ 103；
对于所有评测用例，2 ≤ n ≤ 105 ，1 ≤ g, ai ≤ 109。

cols,gcd = map(int,input().split())
second = input().split()
list_cols = [int(i) for i in second]
sum = 0   
    
for x in range(cols-1):
    list_temp = []
    list_temp.append(list_cols[x])
    # print(x)
    for y in range(x+1,cols):
        count = 0
        list_temp.append(list_cols[y])
        for k in list_temp:
            if (k%gcd == 0):
                count += 1
        if count >= len(list_temp)-1:
            sum += 1
    # print(list_temp)            
print(sum)