算法笔试-编程练习-H-04-24

一、汇编语言

要求设计一种虚拟机解释器，能解析并执行以下虚拟指令。

虚拟机约定：32位的整形寄存器有a0​,a1​,..a31​，共32个寄存器；

整个虚拟机只有寄存器和立即数参与计算。

规则集（dst一定为寄存器，src为寄存器或十进制正整数，运算结果存在负数场景）：

（1）MOV dst src含义:dst = src

（2）ADD dst src0 src1含义:dst = src0 + src1

（3）SUB dst src0 src1含义:dst = src0 - src1

（4）MUL dst src0 src1含义:dst = src0 * src1

（5）DIV dst src0 src1含义:dst = src0 / src1(结果向下取整)

（6）PRINT dst含义:打印dst寄存器值

规定：不用考虑计算溢出(用例保证)，指令数最多100条，至少一条PRINT指令，寄存器保证先赋值再引用。不用考虑小数以及除0错误。

输入描述

若干行，每行一条指令

输出描述

对输入的每行指令，若为PRINT指令，则输出打印一行，该行中包括一个整数，表示寄存器的值

样例一

输入

MOV a1 100
MOV a2 200
ADD a3 a1 100
SUB a4 a3 a2
PRINT a4

输出

0

解释

a1=100

a2=200

a3=a1(100)+100=200a4=a3(200)-a2(200)=0

样例二

输入

MOV a1 100
MOV a2 200
PRINT a1
ADD a3 a1 100
SUB a4 a3 a2
PRINT a4

输出

100
0

题目分析

【题目类型：模拟】

这道题算是细节比较多的模拟。1）首先要注意如何判断输入的是变量还是数字，尤其是数字可能为负数（这道题可以取巧，因为变量都包含a）；2）其次是除法向下取整的问题int(a/b)的逻辑是向0取整，例如int(-1.5) =-1;int(1.5)=1，可以看出当值为负数时是向上取整的，而整数除法 a//b 才是绝对的向下取整；3）另外就是不确定行数的输入问题，要有自己的模板。

代码：

import sys
data = {}
for _ in sys.stdin:
    try:
        c = _.split()
        if c[0] == 'PRINT':
            print(data[c[1]])
        else:
            tmp1 = c[2]
            if 'a' in tmp1:
                tmp1 = data[tmp1]
            else:
                tmp1 = int(tmp1)
                
            if c[0] == 'MOV':
                data[c[1]] = tmp1
            else:
                tmp2 = c[3]
                if 'a' in tmp2:
                    tmp2 = data[tmp2]
                else:
                    tmp2 = int(tmp2)
                
                if c[0] == 'ADD':
                    data[c[1]] = tmp1+tmp2
                elif c[0] == 'SUB':
                    data[c[1]] = tmp1-tmp2
                elif c[0] == 'MUL':
                    data[c[1]] = tmp1*tmp2
                elif c[0] == 'DIV':
                    data[c[1]] = tmp1//tmp2
    except:
        break

二、无线通信

题目描述

无线通信移动性需要在基站上配置邻区(本端基站的小区LocalCell与周边邻基站的小区NeighborCelI映射)关系，为了能够加速无线算法的计算效率，设计一个邻区关系缓存表，用于快速的通过本小区LocalCell查询到邻小区NeighborCell。但是缓存表有一定的规格限制，因此到达规格并且需要插入新的数据时，需要删除邻区数据，选择删除邻区数据对象的策略为：

（1）使用次数最少的；

（2）如果（1）返回有多个对象,则选择最久未使用的。

请设计并实现一个满足以上要求的数据结构和算法实现。

注:假设每个LocalCell至多只有一个NeighborCell。

输入描述

1、首行以字符"capacity:"标识设置一个整数容量;

2、以"write:"标识开始进行若干组[LocalCell,NeighborCell]邻区数据的输入,每组数据为一行;如果"write:"已经存在的LocalCell数据,更新其对 应的NeighborCell,并刷新使用时间和次数加1;如果某邻区数据被删除,缓存表不再保留其记录;

3、以"read:"标识进行一次读取LocalCell的使用操作,刷新使用时间和次数加1;

4、最后以"query:"标识查询输出操作，输入正整数LocalCell，查询NeighborCell；

注:

（1）写入和读取都表示对LocalcelI的使用操作;

（2）capacity、LocalCellI和NeighborCelI都是正整数，范围在[1,10000];

（3）输入的总行数不超过30000行。

输出描述

每个查询输入正整数LocalCell对应NeighborCell，表示在邻区关系缓存表中的记录。

1、找到，则返回NeighborCell； 2、没有找到，则返回-1;

样例一

输入

capacLy:
3
write:
3
1 2
4 3
2 3
read:
2
write:
1
3 1
query:
1

输出

-1

题目分析：

【题目类型：数据结构、模拟】

需要设计一种合适的方式来记录使用次数和使用时刻。

代码：

temp = input()
capacLy = int(input())
data = {}       # 越靠后，越新

while True:
    line = input().strip()
    if line == "write:":
        n = int(input())
        for _ in range(n):
            LC, NC = map(int, input().split())
            KEYS = data.keys()
            if LC in KEYS:
                cnt = data[LC][1]
                del data[LC]
                data[LC] = [NC, cnt+1]
            else:
                if len(KEYS) >= capacLy:
                    P = -1
                    cnt = 10000000
                    for k in KEYS:
                        if data[k][1] < cnt:
                            cnt = data[k][1]
                            P = k
                    del data[P]        
                data[LC] = [NC, 1]
    elif line == "read:":
        LC = int(input())
        if LC in data.keys():
            NC = data[LC][0]
            cnt = data[LC][1]
            del data[LC]
            data[LC] = [NC, cnt+1]
    elif line == "query:":
        LC = int(input())
        if LC in data.keys():
            print(data[LC][0])
        else:
            print(-1)
        break