首页 > 其他分享 >笔试真题——机器人拧魔方模拟

笔试真题——机器人拧魔方模拟

时间：2024-10-31 22:44:46浏览次数：3  
标签：魔方 matrix idx 真题 笔试 two turn Xm round

说明：根据遗留的记忆写出来了此篇文章，可能与原文解释有部分出入，但总体思路一致。

题目说明：

YYYYRRRRWWWWOOOOGGGGBBBB UUL'

第一行为输入为对应F, R, B, L, U, D面的元素颜色

第二行输入为翻转的标识符

标识符有：F、F'、R、R'、B、B'、L、L'、U、U'、D、D' 。分别为对应明的顺时针翻转和逆时针翻转。带'则为逆时针，不带则为顺时针

输入示意图：

image-20241031221017240

输出说明：

BWBYOORRYGWGORORWGYGWBYB

  • 示例图【无需输出，仅理解】：

image-20241031222035048

输出翻转后最终对应位置F, R, B, L, U, D的颜色序列

题解：

    • 要理解题目中，每个转动的模拟情况，每个面的转动会影响那些面

    • 旋转面的影响方框【元素】依次是什么，

      • 这里以以U移动举例：

        1. U移动会带动L、F、R、B【顺序可以改，但必须保证前后对应的面相等，因为带动顺序也很关键】

        1. 每个面划分为2*2的矩阵，那么，L会影响的元素方位是(0,0) (0,1)。F会影响的也是(0,0) (0,1)

        2. 分别模拟出每个面依次对照的影响元素的位置

    • 获取每个影响元素的方位

    • 就可以编码了，难点在于如何理解每一个面的转动以及他所带动的面的元素是什么，每一个面的带动情况是不一样的

 

难度：

复杂度高，找到移动影响序列比较繁琐，编码难度中等

编码

  • 构建常量以及每一个面的两个序列【面移动序列，面中受影响所移动的位置序列】：

    Sn, Ni = 0, 1   #常量Sn代表顺时针，Ni代表逆时针
F, R, B, L, U, D = 0,1,2,3,4,5  #随意，我只是根据题目来而已
two_d_matrix = [[0,0,0,0] for i in range(6)]    #批量初始化6个面。每一个面有2*2就是4个元素，这个使用一维数组代替是因为如果使用二级数组会很麻烦
​
Fr = [U, R, D, L]                       #Xr代表的是 X个面中，移动的4个面序列
Fm = [(2,3), (0, 2), (1, 0), (3, 1)]    #Xm代表的是每个面依次对照的影响元素的位置默认全为顺时针方向【本来应该是(0,0)~(1,1)二进制化就好了】
Lr = [U, F, D, B]
Lm = [(0,2), (0, 2), (0, 2), (3, 1)]
Dr = [F, R, B, L]
Dm = [(2,3), (2, 3), (2, 3), (2, 3)]
Rr = [D, F, U, B]
Rm = [(3,1), (3, 1), (3, 1), (0, 2)]
Ur = [F, L, B, R]
Um = [(1,0), (1, 0), (1, 0), (1, 0)]
Br = [R, U, L, D]
Bm = [(3,1), (1, 0), (0, 2), (2, 3)]
#输入的转动映射
char_to_turn = {'U':(U,Sn), "U'":(U, Ni), "F":(F,Sn),"F'":(F,Ni) , "L":(L,Sn),"L'":(L,Ni),
                "D":(D,Sn) ,"D'":(D,Ni) , "R":(R,Sn), "R'":(R,Ni),  "B":(B, Sn), "B'":(B, Ni)}
#全部面的关联面序列以及影响移动框序列，上面的二层抽象，方便后续操作
X_r = {F:Fr, R:Rr, B:Br, L:Lr, U:Ur, D:Dr}
X_m = {F:Fm, R:Rm, B:Bm, L:Lm, U:Um, D:Dm}

  • 将X面翻转（仅单面模拟，不对其他4个移动面进行模拟）以及获取对应值的方法

     1 def trun_X_round(round_name:int, S_or_N:int):
 2     """
 3     将X面进行翻转
 4     :param round_name: 输入翻转的面常量
 5     :param S_or_N: 输入顺时针或者是逆时针
 6     """
 7     x_round = two_d_matrix[round_name]
 8     new_round = copy.deepcopy(x_round)#一定要深拷贝，不然好像是会直接修改，因为浅复制是映射到同一个指针
 9     if S_or_N == Sn:                    #根据转向去翻转，顺序无所谓，逻辑要一致，这里使用了两个数组来简化，0-3类比为二进制（x,y）就像x={0,1} y={0,1}
10         new_round[1] = x_round[0]
11         new_round[3] = x_round[1]
12         new_round[2] = x_round[3]
13         new_round[0] = x_round[2]
14     else:
15         new_round[1] = x_round[0]
16         new_round[3] = x_round[1]
17         new_round[2] = x_round[3]
18         new_round[0] = x_round[2]
19     # print(new_round)                  #输出测试
20     two_d_matrix[round_name] = new_round
21     
22 def get_value(X_round:int, idx:tuple):#获取某个索引的值，返回的以面为单位，如["G","G"]
23     return [
24         two_d_matrix[X_round][idx[0]], two_d_matrix[X_round][idx[1]]
25     ]

  • 翻转其他部分：

     1 def trun_other_round_Sn(X_round:int):
 2     """
 3     翻转X影响的其他部分【受X干扰的面】
 4     :param X_round:输入面常量
 5     """
 6     Xr = X_r[X_round]           #获取所选面X的关联面序列，下为影响移动框序列
 7     Xm_ori = X_m[X_round]
 8     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]    #批量保存原移动框的值，方便后续覆盖
 9     #因为顺时针，所以第一个索引[0]移动后实际上变为最后一个[3]可以理解为循环链表，因为第一个比较特殊，拎出来做一次，理解了这个循环其实就是剩下3个idx[1,2,3]的移动
10     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
11     for idx, Xm in enumerate(Xm_ori):
12         if idx > 0:
13             #每次顺时针旋转，当前面的两个元素变为前一个面的两个元素，因为一个面有两个影响元素，temp_value以列表存储，每个存储两个元素列表，不理解调试一下就好了
14             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
15     # print(two_d_matrix)
16 ​
17     return
18 def trun_other_round_Ni(X_round:int):
19     #就是翻转了一下，就ok了，其他不影响，因为怎么转，点之间都是对应的
20     Xr = list(reversed(X_r[X_round]))
21     Xm_ori = list(reversed(X_m[X_round]))
22     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]
23 ​
24     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
25     for idx, Xm in enumerate(Xm_ori):
26         if idx > 0:
27             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
28     # print(two_d_matrix)

  • main函数：

     1 if __name__ == '__main__':
 2 ​
 3     input_list = input()
 4     
 5     count_input = 0
 6     for i in range(6):
 7         for k in range(4):#根据输入构造二维矩阵（数组），k和前面设置的常量一一对应
 8             two_d_matrix[i][k] = input_list[count_input]
 9             count_input += 1
10 ​
11     turn_list = []
12     turn_input = input()
13     for idx, turn_one in enumerate(turn_input):
14         if idx != len(turn_input)-1:
15             if turn_input[idx+1] == "'":#当下一个为翻转的字符时加上并存入
16                 add_char = turn_one + turn_input[idx+1]
17                 turn_list.append(char_to_turn[add_char])#映射完存的实际上是(X_round,Sn_or_Ni)
18             else:
19                 turn_list.append(char_to_turn[turn_one])#没有就直接存
20         elif turn_one != "'":
21             turn_list.append(char_to_turn[turn_one])#末尾不是翻转符那就存入翻转序列
22     for X, angle in turn_list:#遍历翻转数列
23         trun_X_round(X, angle)#先对X本面进行翻转【for内顺序无所谓】
24         if angle == Sn:
25             trun_other_round_Sn(X_round=X)#如果是顺时针就调用顺时针，否则就调用逆时针
26         elif angle == Ni:
27             trun_other_round_Ni(X_round=X)
28 ​
29     for i in two_d_matrix:#构造输出
30         for k in i:
31             print(k,end="")

  • all code：

  1 # 输入示例：带可视化显示
  2 # YYYYRRRRWWWWOOOOGGGGBBBB
  3 # UUL'
  4 import copy
  5 Sn, Ni = 0, 1   #常量Sn代表顺时针，Ni代表逆时针
  6 F, R, B, L, U, D = 0,1,2,3,4,5  #随意，我只是根据题目来而已
  7 two_d_matrix = [[0,0,0,0] for i in range(6)]    #批量初始化6个面。每一个面有2*2就是4个元素，这个使用一维数组代替是因为如果使用二级数组会很麻烦
  8 ​
  9 Fr = [U, R, D, L]                       #Xr代表的是 X个面中，移动的4个面序列
 10 Fm = [(2,3), (0, 2), (1, 0), (3, 1)]    #Xm代表的是每个面依次对照的影响元素的位置默认全为顺时针方向【本来应该是(0,0)~(1,1)二进制化就好了】
 11 Lr = [U, F, D, B]
 12 Lm = [(0,2), (0, 2), (0, 2), (3, 1)]
 13 Dr = [F, R, B, L]
 14 Dm = [(2,3), (2, 3), (2, 3), (2, 3)]
 15 Rr = [D, F, U, B]
 16 Rm = [(3,1), (3, 1), (3, 1), (0, 2)]
 17 Ur = [F, L, B, R]
 18 Um = [(1,0), (1, 0), (1, 0), (1, 0)]
 19 Br = [R, U, L, D]
 20 Bm = [(3,1), (1, 0), (0, 2), (2, 3)]
 21 #输入的转动映射
 22 char_to_turn = {'U':(U,Sn), "U'":(U, Ni), "F":(F,Sn),"F'":(F,Ni) , "L":(L,Sn),"L'":(L,Ni),
 23                 "D":(D,Sn) ,"D'":(D,Ni) , "R":(R,Sn), "R'":(R,Ni),  "B":(B, Sn), "B'":(B, Ni)}
 24 #全部面的关联面序列以及影响移动框序列，上面的二层抽象，方便后续操作
 25 X_r = {F:Fr, R:Rr, B:Br, L:Lr, U:Ur, D:Dr}
 26 X_m = {F:Fm, R:Rm, B:Bm, L:Lm, U:Um, D:Dm}
 27 ​
 28 def trun_X_round(round_name:int, S_or_N:int):
 29     """
 30     将X面进行翻转
 31     :param round_name: 输入翻转的面常量
 32     :param S_or_N: 输入顺时针或者是逆时针
 33     """
 34     x_round = two_d_matrix[round_name]
 35     new_round = copy.deepcopy(x_round)#一定要深拷贝，不然好像是会直接修改，因为浅复制是映射到同一个指针
 36     if S_or_N == Sn:                    #根据转向去翻转，顺序无所谓，逻辑要一致，这里使用了两个数组来简化，0-3类比为二进制（x,y）就像x={0,1} y={0,1}
 37         new_round[1] = x_round[0]
 38         new_round[3] = x_round[1]
 39         new_round[2] = x_round[3]
 40         new_round[0] = x_round[2]
 41     else:
 42         new_round[1] = x_round[0]
 43         new_round[3] = x_round[1]
 44         new_round[2] = x_round[3]
 45         new_round[0] = x_round[2]
 46     # print(new_round)                  #输出测试
 47     two_d_matrix[round_name] = new_round
 48 ​
 49 def get_value(X_round:int, idx:tuple):#获取某个索引的值，返回的以面为单位，如["G","G"]
 50     return [
 51         two_d_matrix[X_round][idx[0]], two_d_matrix[X_round][idx[1]]
 52     ]
 53 ​
 54 def trun_other_round_Sn(X_round:int):
 55     """
 56     翻转X影响的其他部分【受X干扰的面】
 57     :param X_round:输入面常量
 58     """
 59     Xr = X_r[X_round]           #获取所选面X的关联面序列，下为影响移动框序列
 60     Xm_ori = X_m[X_round]
 61     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]    #批量保存原移动框的值，方便后续覆盖
 62     #因为顺时针，所以第一个索引[0]移动后实际上变为最后一个[3]可以理解为循环链表，因为第一个比较特殊，拎出来做一次，理解了这个循环其实就是剩下3个idx[1,2,3]的移动
 63     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
 64     for idx, Xm in enumerate(Xm_ori):
 65         if idx > 0:
 66             #每次顺时针旋转，当前面的两个元素变为前一个面的两个元素，因为一个面有两个影响元素，temp_value以列表存储，每个存储两个元素列表，不理解调试一下就好了
 67             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
 68     # print(two_d_matrix)
 69 ​
 70     return
 71 def trun_other_round_Ni(X_round:int):
 72     #就是翻转了一下，就ok了，其他不影响，因为怎么转，点之间都是对应的
 73     Xr = list(reversed(X_r[X_round]))
 74     Xm_ori = list(reversed(X_m[X_round]))
 75     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]
 76 ​
 77     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
 78     for idx, Xm in enumerate(Xm_ori):
 79         if idx > 0:
 80             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
 81     # print(two_d_matrix)
 82 ​
 83 if __name__ == '__main__':
 84 ​
 85     input_list = input()
 86 ​
 87     count_input = 0
 88     for i in range(6):
 89         for k in range(4):#根据输入构造二维矩阵（数组），k和前面设置的常量一一对应
 90             two_d_matrix[i][k] = input_list[count_input]
 91             count_input += 1
 92 ​
 93     turn_list = []
 94     turn_input = input()
 95     for idx, turn_one in enumerate(turn_input):
 96         if idx != len(turn_input)-1:
 97             if turn_input[idx+1] == "'":#当下一个为翻转的字符时加上并存入
 98                 add_char = turn_one + turn_input[idx+1]
 99                 turn_list.append(char_to_turn[add_char])#映射完存的实际上是(X_round,Sn_or_Ni)
100             else:
101                 turn_list.append(char_to_turn[turn_one])#没有就直接存
102         elif turn_one != "'":
103             turn_list.append(char_to_turn[turn_one])#末尾不是翻转符那就存入翻转序列
104     for X, angle in turn_list:#遍历翻转数列
105         trun_X_round(X, angle)#先对X本面进行翻转【for内顺序无所谓】
106         if angle == Sn:
107             trun_other_round_Sn(X_round=X)#如果是顺时针就调用顺时针，否则就调用逆时针
108         elif angle == Ni:
109             trun_other_round_Ni(X_round=X)
110 ​
111     for i in two_d_matrix:#构造输出
112         for k in i:
113             print(k,end="")
114 ​

自己编码的过程：

在我自己编码的途中，纯大脑模拟3维魔方并编码，而且输出如此抽象，实际上是非常困难的，因此我自己编码的时候借助了大模型生成的帮忙的可视化接口（虽然你笔试的时候肯定不能用，我当时也不够时间写出来，找到影响元素的位置序列真tm繁琐）【我命名为draw_cube.py。这个根据自己喜欢来】记得把import 改一下就好，最好复制那个输出就能显示图片了，有图片辅助更好理解

code：

 

  1 # 输入示例：带可视化显示
  2 # YYYYRRRRWWWWOOOOGGGGBBBB
  3 # UUL'
  4 import copy
  5 import draw_cube#这个是可视化的代码
  6 Sn, Ni = 0, 1   #常量Sn代表顺时针，Ni代表逆时针
  7 F, R, B, L, U, D = 0,1,2,3,4,5  #随意，我只是根据题目来而已
  8 two_d_matrix = [[0,0,0,0] for i in range(6)]    #批量初始化6个面。每一个面有2*2就是4个元素，这个使用一维数组代替是因为如果使用二级数组会很麻烦
  9 ​
 10 Fr = [U, R, D, L]                       #Xr代表的是 X个面中，移动的4个面序列
 11 Fm = [(2,3), (0, 2), (1, 0), (3, 1)]    #Xm代表的是每个面依次对照的影响元素的位置默认全为顺时针方向【本来应该是(0,0)~(1,1)二进制化就好了】
 12 Lr = [U, F, D, B]
 13 Lm = [(0,2), (0, 2), (0, 2), (3, 1)]
 14 Dr = [F, R, B, L]
 15 Dm = [(2,3), (2, 3), (2, 3), (2, 3)]
 16 Rr = [D, F, U, B]
 17 Rm = [(3,1), (3, 1), (3, 1), (0, 2)]
 18 Ur = [F, L, B, R]
 19 Um = [(1,0), (1, 0), (1, 0), (1, 0)]
 20 Br = [R, U, L, D]
 21 Bm = [(3,1), (1, 0), (0, 2), (2, 3)]
 22 #输入的转动映射
 23 char_to_turn = {'U':(U,Sn), "U'":(U, Ni), "F":(F,Sn),"F'":(F,Ni) , "L":(L,Sn),"L'":(L,Ni),
 24                 "D":(D,Sn) ,"D'":(D,Ni) , "R":(R,Sn), "R'":(R,Ni),  "B":(B, Sn), "B'":(B, Ni)}
 25 #全部面的关联面序列以及影响移动框序列，上面的二层抽象，方便后续操作
 26 X_r = {F:Fr, R:Rr, B:Br, L:Lr, U:Ur, D:Dr}
 27 X_m = {F:Fm, R:Rm, B:Bm, L:Lm, U:Um, D:Dm}
 28 ​
 29 def trun_X_round(round_name:int, S_or_N:int):
 30     """
 31     将X面进行翻转
 32     :param round_name: 输入翻转的面常量
 33     :param S_or_N: 输入顺时针或者是逆时针
 34     """
 35     x_round = two_d_matrix[round_name]
 36     new_round = copy.deepcopy(x_round)#一定要深拷贝，不然好像是会直接修改，因为浅复制是映射到同一个指针
 37     if S_or_N == Sn:                    #根据转向去翻转，顺序无所谓，逻辑要一致，这里使用了两个数组来简化，0-3类比为二进制（x,y）就像x={0,1} y={0,1}
 38         new_round[1] = x_round[0]
 39         new_round[3] = x_round[1]
 40         new_round[2] = x_round[3]
 41         new_round[0] = x_round[2]
 42     else:
 43         new_round[1] = x_round[0]
 44         new_round[3] = x_round[1]
 45         new_round[2] = x_round[3]
 46         new_round[0] = x_round[2]
 47     # print(new_round)                  #输出测试
 48     two_d_matrix[round_name] = new_round
 49 ​
 50 def get_value(X_round:int, idx:tuple):#获取某个索引的值，返回的以面为单位，如["G","G"]
 51     return [
 52         two_d_matrix[X_round][idx[0]], two_d_matrix[X_round][idx[1]]
 53     ]
 54 ​
 55 def trun_other_round_Sn(X_round:int):
 56     """
 57     翻转X影响的其他部分【受X干扰的面】
 58     :param X_round:输入面常量
 59     """
 60     Xr = X_r[X_round]           #获取所选面X的关联面序列，下为影响移动框序列
 61     Xm_ori = X_m[X_round]
 62     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]    #批量保存原移动框的值，方便后续覆盖
 63     #因为顺时针，所以第一个索引[0]移动后实际上变为最后一个[3]可以理解为循环链表，因为第一个比较特殊，拎出来做一次，理解了这个循环其实就是剩下3个idx[1,2,3]的移动
 64     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
 65     for idx, Xm in enumerate(Xm_ori):
 66         if idx > 0:
 67             #每次顺时针旋转，当前面的两个元素变为前一个面的两个元素，因为一个面有两个影响元素，temp_value以列表存储，每个存储两个元素列表，不理解调试一下就好了
 68             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
 69     # print(two_d_matrix)
 70 ​
 71     return
 72 def trun_other_round_Ni(X_round:int):
 73     #就是翻转了一下，就ok了，其他不影响，因为怎么转，点之间都是对应的
 74     Xr = list(reversed(X_r[X_round]))
 75     Xm_ori = list(reversed(X_m[X_round]))
 76     temp_value = [get_value(Xr[i], Xm_ori[i]) for i in range(4)]
 77 ​
 78     two_d_matrix[Xr[0]][Xm_ori[0][0]], two_d_matrix[Xr[0]][Xm_ori[0][1]] = temp_value[3][0], temp_value[3][1]
 79     for idx, Xm in enumerate(Xm_ori):
 80         if idx > 0:
 81             two_d_matrix[Xr[idx]][Xm[0]] , two_d_matrix[Xr[idx]][Xm[1]] = temp_value[idx-1][0], temp_value[idx-1][1]
 82     # print(two_d_matrix)
 83 ​
 84 if __name__ == '__main__':
 85 ​
 86     input_list = input()
 87     draw_cube.show_cube_list(input_list)#可视化输入的二阶魔法平面图
 88     count_input = 0
 89     for i in range(6):
 90         for k in range(4):#根据输入构造二维矩阵（数组），k和前面设置的常量一一对应
 91             two_d_matrix[i][k] = input_list[count_input]
 92             count_input += 1
 93 ​
 94     turn_list = []
 95     turn_input = input()
 96     for idx, turn_one in enumerate(turn_input):
 97         if idx != len(turn_input)-1:
 98             if turn_input[idx+1] == "'":#当下一个为翻转的字符时加上并存入
 99                 add_char = turn_one + turn_input[idx+1]
100                 turn_list.append(char_to_turn[add_char])#映射完存的实际上是(X_round,Sn_or_Ni)
101             else:
102                 turn_list.append(char_to_turn[turn_one])#没有就直接存
103         elif turn_one != "'":
104             turn_list.append(char_to_turn[turn_one])#末尾不是翻转符那就存入翻转序列
105     for X, angle in turn_list:#遍历翻转数列
106         trun_X_round(X, angle)#先对X本面进行翻转【for内顺序无所谓】
107         if angle == Sn:
108             trun_other_round_Sn(X_round=X)#如果是顺时针就调用顺时针，否则就调用逆时针
109         elif angle == Ni:
110             trun_other_round_Ni(X_round=X)
111 ​
112     for i in two_d_matrix:#构造输出
113         for k in i:
114             print(k,end="")
115     draw_cube.show_cube()
116 ​
117 #YYYYRRRRWWWWOOOOGGGGBBBB
119 #OBRBWOWRYOYRGYGYWGBRBOWG
120 ​

鸣谢：

魔方模拟

标签：魔方,matrix,idx,真题,笔试,two,turn,Xm,round
From： https://www.cnblogs.com/io-T-T/p/18519050

相关文章

  • 虚拟小玩具！推荐一个基于网页技术的3D魔方，摸鱼党快玩（带私活源码）
     楔子魔方，这个词汇对于大家来说应该并不陌生。在儿时的记忆中，我们曾经可以一整天都在玩魔方。然而，随着时间的流逝，我们步入了程序员的行业，每天与电脑的鼠标和键盘为伍。在这个过程中，魔方也与时俱进，从实体玩具转变为装载在电脑中的虚拟小玩具。对制作网页魔方原理感兴趣的......
  • 2个月搞定计算机二级C语言——真题（6）解析
    1.前言本篇我们讲解2个月搞定计算机二级C语言——真题62.程序填空题2.1题目要求2.2提供的代码#include<stdio.h>unsignedlongfun(unsignedlongn){unsignedlongx=0;intt;while(n){t=n%10;/**********fou......
  • 《Java 大厂面试基础真题及解析 —— 来自一位程序员的心得分享》
    作为一名Java程序员，在经历了众多面试后，深知Java基础在大厂面试中的重要性。以下是我总结的一些常被问到的Java基础面试题及解析，希望对大家有所帮助。2024Javaoffer收割指南分享一、面向对象的三大特性（一）封装概念封装是将数据和操作数据的方法绑定在一起，形成一个......
  • Java常见面试真题之中级进阶(HashMap篇)
    前言本来想着给自己放松一下，刷刷博客，突然被几道面试题难倒！说说Hashtable与HashMap的区别？HashMap中的key我们可以使用任何类作为key吗？HashMap的长度为什么是2的N次方呢？HashMap与ConcurrentHashMap的异同？红黑树有哪几个特征？似乎有点模糊了，那就大概看一下面试题吧。......
  • 嵌入式软件名企笔试真题文章汇总帖
    1、前言欢迎各位来到我的专栏，笔者为25届应届毕业生，投递岗位为嵌入式软件开发工程师相关岗位，在秋招过程中有意记录各大企业的真实笔试题目，现以博客形式记录，有意者可自行查看！2、约定笔者专栏中的每篇文章将采用统一的习惯/步骤，以方便读者查找，主要有以下几点需要注意：专栏中的......
  • C语言真题卷（1）
     一、选择题（每小题2分，共30分）1．以下(               ) 是错误的整型常量。A. -0xabcdef         B．018         C．0x29         D．011 2．为了判断两个字符串s1和s2是否相等，应当使用（           ）。A.  if(s......
  • 【C++ 真题】B2099 矩阵交换行
    矩阵交换行题目描述给定一个5×55\times55×5的矩阵(数学上，一个......
  • 2024年最新互联网大厂精选 Java 面试真题集锦（JVM、多线程、MQ、MyBatis、MySQL、Redis
    前言春招，秋招，社招，我们Java程序员的面试之路，是挺难的，过了HR，还得被技术面，在去各个厂面试的时候，经常是通宵睡不着觉，头发都脱了一大把，还好最终侥幸能够入职一个独角兽公司，安稳从事喜欢的工作至今...近期也算是抽取出大部分休息的时间，为大家准备了一份通往大厂面试的小捷径，准备......
  • 真题练习25-PowerPoint演示文稿-全国计算机等级考试一级计算机基础及MS Office应用考
    第25组打开考生文件夹下的演示文稿yswg.pptx，按照下列要求完成对此文稿的修饰并保存。1．在第一张幻灯片中插入样式为“填充-白色，文本1，阴影”的艺术字“运行中的京津城铁”，文字效果为“转换-波形：上（或：转换-波形2）”，艺术字位置（水平：6厘米，自：左上角，垂直：7厘米，自：左上角）。第二张幻灯片的......
  • Stema练习题：十四届蓝桥杯STEMA考试Python真题试卷题解
    来源：十四届蓝桥杯STEMA考试Python真题试卷第一套编程第四题这个程序虽然代码量不大，但综合运用了多种基础算法和数据结构：贪心策略选择窗口、模拟现实过程、线性查找最小值、效率高（时间复杂度为O(N)O(N)O(N)）。题目描述：编程实现：某服务大厅同时开放3个窗口为客户办理......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99