已知数组M包含20个互不相等的整数,数组N包含10个互不相等的整数,编程序实现把即在M中又在N中出现的整数,存放在K数组中。在屏幕上以二进制形式显示K数组元素的个数。

好的，让我来帮您解决这个问题。以下是实现此任务的Python代码：

M = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
N = [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
K = []

for i in M:
    if i in N:
        K.append(i)

count = len(K)
binary = bin(count)

print("K数组元素的个数为：", count)
print("以二进制形式显示K数组元素的个数：", binary)

首先，我们定义了包含20个互不相等的整数的M数组和包含10个互不相等的整数的N数组。然后，我们创建一个名为K的空数组来存储在M和N中同时出现的元素。

接下来，我们使用for循环遍历M数组中的每个元素。如果该元素也出现在N数组中，我们将其添加到K数组中。

然后，我们使用len()函数获取K数组中元素的个数，并使用bin()函数将其转换为二进制格式。最后，我们将结果打印到屏幕上。

希望这个代码能够帮助您解决问题！

相关问题

已知数组M包含20个互不相等的整数，数组N包含10个互不相等的整数，编程序实现把即在M中又在N中出现的整数，存放在K数组中。在屏幕上以二进制形式显示K数组元素的个数。

下面是一个汇编语言程序，实现了这个功能：

ORG 100h

M        DW 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20 ; 数组 M
N        DW 2, 4, 6, 8, 10, 12, 14, 16, 18, 20 ; 数组 N
K        DW 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ; 数组 K，初始化为 0
COUNT    DB 0 ; 统计 K 数组中非零元素的个数，初始化为 0

MOV BX, OFFSET M ; 将数组 M 的地址存入 BX 寄存器
MOV CX, 20 ; 将数组 M 的长度存入 CX 寄存器

L1:
    MOV AX, [BX] ; 将当前元素存入 AX 寄存器
    MOV SI, OFFSET N ; 将数组 N 的地址存入 SI 寄存器
    MOV DX, 10 ; 将数组 N 的长度存入 DX 寄存器
    XOR DI, DI ; 使用 DI 寄存器作为数组 K 的索引，初始化为 0
L2:
    CMP AX, [SI] ; 比较当前元素与数组 N 中的元素
    JNE L3 ; 如果不相等，跳转到 L3
    MOV [K+DI], AX ; 如果相等，将当前元素存入数组 K 中
    INC DI ; 将 DI 寄存器加 1，指向下一个 K 数组的元素
L3:
    ADD SI, 2 ; 将 SI 寄存器加 2，指向数组 N 的下一个元素
    DEC DX ; 将 DX 寄存器减 1，表示还需要比较的元素个数
    JNZ L2 ; 如果还未比较完，继续循环
    ADD BX, 2 ; 将 BX 寄存器加 2，指向数组 M 的下一个元素
    LOOP L1 ; 如果还未遍历完数组 M，继续循环

    MOV CX, 10 ; 将数组 K 的长度存入 CX 寄存器
    XOR DI, DI ; 使用 DI 寄存器作为数组 K 的索引，初始化为 0
L4:
    TEST [K+DI], [K+DI] ; 判断当前元素是否为 0
    JZ L5 ; 如果为 0，跳转到 L5
    INC COUNT ; 如果非零，计数器加 1
L5:
    INC DI ; 将 DI 寄存器加 1，指向下一个 K 数组的元素
    LOOP L4 ; 如果还未遍历完数组 K，继续循环

    CALL DISPLAY ; 调用显示函数，以二进制形式显示 COUNT 的值

DISPLAY:
    MOV BX, 2 ; 用 BX 寄存器存储常数 2
    MOV AX, COUNT ; 将 COUNT 的值存入 AX 寄存器
    MOV CX, 16 ; 将常数 16 存入 CX 寄存器，用于循环
L6:
    XOR DX, DX ; 使用 DX 寄存器清零
    DIV BX ; 将 AX 寄存器的值除以 2，商存入 AX 寄存器，余数存入 DX 寄存器
    ADD DL, '0' ; 将余数转换为对应的 ASCII 码
    MOV AH, 02h ; 调用 21h 中断，显示一个字符
    INT 21h
    LOOP L6 ; 如果还未显示完，继续循环

    MOV AH, 4Ch ; 调用 21h 中断，结束程序
    INT 21h

在这个程序中，`M` 是包含 20 个互不相等的整数的数组，`N` 是包含 10 个互不相等的整数的数组，`K` 是存放相同整数的数组，`COUNT` 是用于统计非零元素个数的变量。程序使用 `BX` 寄存器存储数组 M 的地址，使用 `CX` 寄存器存储数组 M 和数组 K 的长度，使用 `AX` 寄存器存储当前元素，使用 `SI` 寄存器存储数组 N 的地址，使用 `DX` 寄存器存储数组 N 的长度，使用 `DI` 寄存器作为数组 K 的索引。程序使用 `LOOP` 指令实现循环，使用 `TEST` 指令判断元素是否为 0。程序使用 `DIV` 指令实现除法，将二进制数转换为 ASCII 码，使用 21h 中断显示二进制数。

在程序执行完毕后，屏幕上会以二进制形式显示 K 数组中非零元素的个数。

已知一维数组中存放10个互不相等的整数,找出该数组最大值,并与数组的最后一个元素对换

好的，针对您的问题，可以使用以下的算法来解决：

1. 假设数组中第一个元素是最大值，将其保存在一个变量max中。

2. 遍历数组，如果当前元素大于max，则将当前元素赋值给max。

3. 遍历结束后，max中存储的就是数组中的最大值。

4. 将max与数组的最后一个元素对换。

下面是具体的实现代码（假设数组名为arr）：

# 找到最大值
max = arr[0]
for i in range(1, 10):
    if arr[i] > max:
        max = arr[i]

# 与最后一个元素对换
temp = arr[9]
arr[9] = max
arr[arr.index(max)] = temp

注意，此代码假设数组中确实存在10个互不相等的整数，如果不满足这个条件，可能会出现错误。