华为OD机试 - 信号发射和接收 - 矩阵（Python/JS/C/C++ 2024 E卷 200分）

于 2024-10-03 10:51:30 发布
阅读量297 收藏 4
点赞数 12
分类专栏： 搬砖工逆袭Java架构师 文章标签： 华为od 矩阵 python
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/guorui_java/article/details/142664395
版权

在这里插入图片描述

华为OD机试 2024E卷题库疯狂收录中，刷题点这里

专栏导读

本专栏收录于《华为OD机试真题（Python/JS/C/C++）》。

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

一、题目描述

有一个二维的天线矩阵，每根天线可以向其他天线发射信号，也能接收其他天线发射的信号。为了简化起见，我们约定每根天线只能向东和向南发射信号，换言之，每根天线只能接收到东侧或南侧的信号。

每根天线有自己的高度值anth，每根天线的高度存储在一个二维数组Q中，各个天线的位置用[r, c]表示，r代表天线的行位置（从0开始编号），c代表天线的列位置（从0开始编号）。

在某一方向（东向或南向），某根天线可以收到其他天线的信号（也可能收不到任何其他天线的信号），对任一天线X和天线Y，天线X能接收到天线Y信号的条件是：

天线X在天线Y的东边或南边

天线X和天线Y之间的其他天线的高度都低于天线X和天线Y，或天线X和天线Y之间无其他天线，即无遮挡。

如下面示意：

在这里插入图片描述
在天线矩阵中的第0行上：

天线[0, 0]接收不到任何其他天线的信号；
天线[0, 1]可以接收到天线[0, 0]的信号；
天线[0, 2]可以接收到天线[0, 1]的信号；
天线[0, 3]可以接收到天线[0, 1]和天线[0, 2]的信号；
天线[0, 4]可以接收到天线[0, 3]的信号；
天线[0, 5]可以接收到天线[0, 4]的信号。

在天线的第0列上：

天线[0, 0]接收不到任何其他天线的信号；
天线[1, 0]可以接收到天线[0, 0]的信号；
天线[2, 0]可以接收到天线[1, 0]的信号；
天线[3, 0]可以接收到天线[2, 0]和天线[0, 0]的信号；
天线[4, 0]可以接收到天线[3, 0]的信号；
天线[5, 0]可以接收到天线[3, 0]和天线[4, 0]的信号。

给一个m行n列的矩阵（二维矩阵），矩阵存储着天线的高度，求出每根天线可以接收到多少根其他天线的信号，结果输出到m行n列的矩阵（二维矩阵）中。

二、输入描述

输入为1个m行n列的矩阵（二维矩阵）anth[m][n]，矩阵存储着天线的高度，高度[anth[r][c]]为大于0的整数。

第一行为输入矩阵的行数和列数，如：

m n

第二行为输入矩阵的元素值，按行输入，如：

anth[0][0] anth[0][1] … anth[0][n-1]
anth[1][0] anth[1][1] … anth[1][n-1]
…
anth[m-1][0] … anth[m-1][n-1]

三、输出描述

输出一个m行n列的矩阵（二维数组）ret[m][n]，矩阵存储每根天线能接收到多少根其他天线的信号，根数为ret[r][c]。

第一行为输出矩阵的行数和列数，如：

m n

第二行为输出矩阵的元素值，按行输出，如：

ret[0][0] ret[0][1] … ret[0][n-1]
ret[1][0] ret[1][1] … ret[1][n-1]
…
ret[m-1][0] … ret[m-1][n-1]

备注

1 ≤ m ≤ 500
1 ≤ n ≤ 500
0 < anth[r][c] < 10^5

四、测试用例

测试用例1：

1、输入

1 6
2 4 1 5 3 3

2、输出

1 6
0 1 1 2 1 1

3、说明

输入为1行6列的天线矩阵的高度值

[2 4 1 5 3 3]

输出为1行6列的结果矩阵

[0 1 1 2 1 1]

测试用例2：

1、输入

2 6
2 5 4 3 2 8 9 7 5 10 10 3

2、输出

2 6
0 1 1 1 1 4
1 2 2 4 2 2

3、说明

输入为2行6列的天线矩阵高度值

[2 5 4 3 2 8]
[9 7 5 10 10 3]

输出为2行6列的结果矩阵

[0 1 1 1 1 4]
[1 2 2 4 2 2]

五、解题思路

1、问题理解

给定一个m x n的二维矩阵anth，表示天线的高度。每根天线可以向东（右）和向南（下）发射信号。因此，每根天线只能接收到来自西（左）或北（上）的信号。对于任意两个天线Y和X，天线X可以接收到天线Y的信号的条件是：

  • Y位于X的西边或北边。
  • 在Y和X之间的所有天线（沿行或列）都比Y和X的高度小，或者Y和X之间没有其他天线（即直接相邻）。

2、具体步骤

  1. 输入读取：
    • 使用Scanner读取矩阵的行数m和列数n。
    • 读取矩阵anth的元素值。
  2. 初始化结果矩阵：
    • 创建一个m x n的结果矩阵ret，用于存储每根天线可以接收到的信号数量。
  3. 遍历每个天线：
    • 对于每根天线X（位置[r][c]），分别向西（同一行，列索引减小）和向北（同一列，行索引减小）查找所有可能的天线Y。
    • 对于每个方向，检查Y到X之间是否满足条件：
    • 如果Y和X之间没有其他天线，则Y可以向X发送信号。
    • 如果Y和X之间有天线，所有中间天线的高度都小于Y和X的最小高度，则Y可以向X发送信号。
    • 将满足条件的Y数量累加到ret[r][c]中。
  4. 输出结果：
    • 按照题目要求的格式输出结果矩阵ret。

六、Python算法源码

# AntennaSignalReceiver.py
# 定义天线信号接收者问题的解决方案

# 导入必要的模块
import sys

def main():
    # 读取输入的行数m和列数n
    try:
        m, n = map(int, sys.stdin.readline().split())
    except:
        # 如果读取失败，退出程序
        print("输入格式错误，无法读取行数和列数。")
        return

    # 初始化天线高度矩阵anth
    anth = []
    for _ in range(m):
        try:
            row = list(map(int, sys.stdin.readline().split()))
            if len(row) != n:
                print(f"输入的列数与预期不符，预期{n}列，实际{len(row)}列。")
                return
            anth.append(row)
        except:
            print("输入格式错误，无法读取天线高度。")
            return

    # 初始化结果矩阵ret，所有元素初始化为0
    ret = [[0 for _ in range(n)] for _ in range(m)]

    # 遍历每个天线位置
    for r in range(m):
        for c in range(n):
            count = 0  # 当前天线可以接收到的信号数量

            # 向西方向查找（同一行，列索引减小）
            for yc in range(c - 1, -1, -1):
                can_receive = True  # 标记是否可以接收来自该天线的信号
                # 计算当前天线和候选天线的最小高度
                min_height = min(anth[r][c], anth[r][yc])
                # 检查候选天线和当前天线之间的所有天线
                for kc in range(yc + 1, c):
                    if anth[r][kc] >= min_height:
                        can_receive = False  # 存在高度不满足条件的天线
                        break
                if can_receive:
                    count += 1  # 可以接收来自该天线的信号

            # 向北方向查找（同一列，行索引减小）
            for yr in range(r - 1, -1, -1):
                can_receive = True  # 标记是否可以接收来自该天线的信号
                # 计算当前天线和候选天线的最小高度
                min_height = min(anth[r][c], anth[yr][c])
                # 检查候选天线和当前天线之间的所有天线
                for kr in range(yr + 1, r):
                    if anth[kr][c] >= min_height:
                        can_receive = False  # 存在高度不满足条件的天线
                        break
                if can_receive:
                    count += 1  # 可以接收来自该天线的信号

            # 将计数结果存入结果矩阵ret
            ret[r][c] = count

    # 输出结果矩阵的行数和列数
    print(f"{m} {n}")

    # 输出结果矩阵的元素值，按行输出
    for row in ret:
        print(' '.join(map(str, row)))

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// AntennaSignalReceiver.js
// 定义天线信号接收者问题的解决方案

// 使用Node.js的readline模块读取输入
const readline = require('readline');

// 创建接口实例
const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

// 初始化输入数据存储
let inputLines = [];
let m = 0, n = 0;
let currentRow = 0;

rl.on('line', (line) => {
    if (line.trim() === '') return; // 忽略空行
    inputLines.push(line.trim());
    // 读取行数和列数
    if (inputLines.length === 1) {
        const dimensions = line.trim().split(' ').map(Number);
        m = dimensions[0];
        n = dimensions[1];
    }
    // 读取天线高度矩阵
    if (inputLines.length > 1 && inputLines.length <= m +1) {
        currentRow++;
    }
    // 当所有输入读取完毕，开始处理
    if (inputLines.length === m +1) {
        rl.close();
    }
}).on('close', () => {
    // 解析天线高度矩阵
    let anth = [];
    for (let r =1; r <= m; r++) {
        let row = inputLines[r].split(' ').map(Number);
        anth.push(row);
    }

    // 初始化结果矩阵ret，所有元素初始化为0
    let ret = Array.from({length: m}, () => Array(n).fill(0));

    // 遍历每个天线位置
    for (let r =0; r < m; r++) {
        for (let c =0; c < n; c++) {
            let count =0; // 当前天线可以接收到的信号数量

            // 向西方向查找（同一行，列索引减小）
            for (let yc = c -1; yc >=0; yc--) {
                let canReceive = true; // 标记是否可以接收来自该天线的信号
                let minHeight = Math.min(anth[r][c], anth[r][yc]);
                // 检查候选天线和当前天线之间的所有天线
                for (let kc = yc +1; kc < c; kc++) {
                    if (anth[r][kc] >= minHeight) {
                        canReceive = false; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if (canReceive) {
                    count +=1; // 可以接收来自该天线的信号
                }
            }

            // 向北方向查找（同一列，行索引减小）
            for (let yr = r -1; yr >=0; yr--) {
                let canReceive = true; // 标记是否可以接收来自该天线的信号
                let minHeight = Math.min(anth[r][c], anth[yr][c]);
                // 检查候选天线和当前天线之间的所有天线
                for (let kr = yr +1; kr < r; kr++) {
                    if (anth[kr][c] >= minHeight) {
                        canReceive = false; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if (canReceive) {
                    count +=1; // 可以接收来自该天线的信号
                }
            }

            // 将计数结果存入结果矩阵ret
            ret[r][c] = count;
        }
    }

    // 输出结果矩阵的行数和列数
    console.log(`${m} ${n}`);

    // 输出结果矩阵的元素值，按行输出
    for (let r =0; r < m; r++) {
        console.log(ret[r].join(' '));
    }
});

八、C算法源码

/* AntennaSignalReceiver.c
 * 定义天线信号接收者问题的解决方案
 */

#include <stdio.h>
#include <stdlib.h>

int main() {
    int m, n;

    // 读取矩阵的行数m和列数n
    if (scanf("%d %d", &m, &n) != 2) {
        printf("输入格式错误，无法读取行数和列数。\n");
        return 1;
    }

    // 动态分配天线高度矩阵anth
    int **anth = (int **)malloc(m * sizeof(int *));
    for (int r = 0; r < m; r++) {
        anth[r] = (int *)malloc(n * sizeof(int));
        for (int c = 0; c < n; c++) {
            if (scanf("%d", &anth[r][c]) != 1) {
                printf("输入格式错误，无法读取天线高度。\n");
                // 释放已分配的内存
                for (int i = 0; i <= r; i++) {
                    free(anth[i]);
                }
                free(anth);
                return 1;
            }
        }
    }

    // 动态分配结果矩阵ret，初始化为0
    int **ret = (int **)malloc(m * sizeof(int *));
    for (int r = 0; r < m; r++) {
        ret[r] = (int *)calloc(n, sizeof(int));
    }

    // 遍历每个天线位置
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            int count = 0; // 当前天线可以接收到的信号数量

            // 向西方向查找（同一行，列索引减小）
            for (int yc = c -1; yc >=0; yc--) {
                int can_receive = 1; // 标记是否可以接收来自该天线的信号
                int min_height = (anth[r][c] < anth[r][yc]) ? anth[r][c] : anth[r][yc];
                // 检查候选天线和当前天线之间的所有天线
                for (int kc = yc +1; kc < c; kc++) {
                    if (anth[r][kc] >= min_height) {
                        can_receive = 0; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if (can_receive) {
                    count++; // 可以接收来自该天线的信号
                }
            }

            // 向北方向查找（同一列，行索引减小）
            for (int yr = r -1; yr >=0; yr--) {
                int can_receive = 1; // 标记是否可以接收来自该天线的信号
                int min_height = (anth[r][c] < anth[yr][c]) ? anth[r][c] : anth[yr][c];
                // 检查候选天线和当前天线之间的所有天线
                for (int kr = yr +1; kr < r; kr++) {
                    if (anth[kr][c] >= min_height) {
                        can_receive = 0; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if (can_receive) {
                    count++; // 可以接收来自该天线的信号
                }
            }

            // 将计数结果存入结果矩阵ret
            ret[r][c] = count;
        }
    }

    // 输出结果矩阵的行数和列数
    printf("%d %d\n", m, n);

    // 输出结果矩阵的元素值，按行输出
    for (int r = 0; r < m; r++) {
        for (int c = 0; c < n; c++) {
            printf("%d", ret[r][c]);
            if (c != n -1) {
                printf(" ");
            }
        }
        printf("\n");
    }

    // 释放动态分配的内存
    for (int r = 0; r < m; r++) {
        free(anth[r]);
        free(ret[r]);
    }
    free(anth);
    free(ret);

    return 0;
}

九、C++算法源码

// AntennaSignalReceiver.cpp
// 定义天线信号接收者问题的解决方案

#include <bits/stdc++.h>
using namespace std;

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);

    int m, n;

    // 读取矩阵的行数m和列数n
    cin >> m >> n;

    // 初始化天线高度矩阵anth
    vector<vector<int>> anth(m, vector<int>(n));
    for(int r =0; r < m; r++) {
        for(int c =0; c < n; c++) {
            cin >> anth[r][c];
        }
    }

    // 初始化结果矩阵ret，所有元素初始化为0
    vector<vector<int>> ret(m, vector<int>(n, 0));

    // 遍历每个天线位置
    for(int r =0; r < m; r++) {
        for(int c =0; c < n; c++) {
            int count =0; // 当前天线可以接收到的信号数量

            // 向西方向查找（同一行，列索引减小）
            for(int yc = c -1; yc >=0; yc--) {
                bool can_receive = true; // 标记是否可以接收来自该天线的信号
                int min_height = min(anth[r][c], anth[r][yc]);
                // 检查候选天线和当前天线之间的所有天线
                for(int kc = yc +1; kc < c; kc++) {
                    if(anth[r][kc] >= min_height) {
                        can_receive = false; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if(can_receive) {
                    count++; // 可以接收来自该天线的信号
                }
            }

            // 向北方向查找（同一列，行索引减小）
            for(int yr = r -1; yr >=0; yr--) {
                bool can_receive = true; // 标记是否可以接收来自该天线的信号
                int min_height = min(anth[r][c], anth[yr][c]);
                // 检查候选天线和当前天线之间的所有天线
                for(int kr = yr +1; kr < r; kr++) {
                    if(anth[kr][c] >= min_height) {
                        can_receive = false; // 存在高度不满足条件的天线
                        break;
                    }
                }
                if(can_receive) {
                    count++; // 可以接收来自该天线的信号
                }
            }

            // 将计数结果存入结果矩阵ret
            ret[r][c] = count;
        }
    }

    // 输出结果矩阵的行数和列数
    cout << m << " " << n << "\n";

    // 输出结果矩阵的元素值，按行输出
    for(int r =0; r < m; r++) {
        for(int c =0; c < n; c++) {
            cout << ret[r][c];
            if(c != n -1) {
                cout << " ";
            }
        }
        cout << "\n";
    }

    return 0;
}

🏆下一篇：华为OD机试真题 - 简易内存池（Python/JS/C/C++ 2024 E卷 200分）

🏆本文收录于，华为OD机试真题（Python/JS/C/C++）

刷的越多，抽中的概率越大，私信哪吒，备注华为OD，加入华为OD刷题交流群，每一题都有详细的答题思路、详细的代码注释、3个测试用例、为什么这道题采用XX算法、XX算法的适用场景，发现新题目，随时更新，全天CSDN在线答疑。

在这里插入图片描述

哪 吒
关注
专栏目录
【免费题库】华为OD机试 - 模拟数据序列化传输（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 模拟数据序列化传输（Java & JS & Python & C & C++）.html
华为OD机试 - 矩阵匹配（Java & JS & Python & C & C++）.html
04-20
华为OD机试 - 矩阵匹配（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
华为OD机考-统一考试机试-含ABCD卷-含java、c++、JavaScript、python-题目
01-18
这个压缩包包含了四个部分，分别标记为ABCD卷，涵盖了四种编程语言：Java、C++、JavaScript和Python。这些语言在现代软件开发中扮演着重要角色，尤其在后端开发、前端开发以及数据分析等领域。 首先，Java是一种...
华为OD机试 - 智能驾驶（Java & JS & Python & C & C++）.html
04-20
华为OD机试 - 智能驾驶（Java & JS & Python & C & C++）.html付费专栏内容，免费下载，多种语言解法
【免费题库】华为OD机试 - 最大矩阵和（Java & JS & Python & C & C++）.html
04-19
【免费题库】华为OD机试 - 最大矩阵和（Java & JS & Python & C & C++）.html
工作安排 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-25 2093
工作安排 - 华为OD统一考试(E卷) 小明每周上班都会拿到自己的工作清单，工作清单内包含n项工作，每项工作都有对应的耗时时长(单位h)和报酬，工作的总报酬为所有已完成工作的报酬之和。那么请你帮小明安排一下工作，保证小明在指定的工作时间内工作收入最大化。
引入Scrum激发研发体系活力
tonyli288的专栏
09-27 1202
确保团队成员具备必要的技能和协作能力，并保持团队的稳定性，以便于持续改进和高效运作，选择合适的团队成员至关重要。可以通过邀请外部专家授课、内部研讨会等形式，确保全员都能理解和接受这一新的工作方式，提升团队成员对Scrum的认知，并通过宣导活动，营造支持敏捷转型的企业氛围。Scrum的增量式交付和频繁的反馈循环，使得团队能够快速调整方向，响应市场变化和客户需求，提高产品的市场竞争力。Scrum通过明确的角色分工和固定的迭代周期，帮助团队更好地规划和管理工作，减少浪费和瓶颈，提高整体研发效率。
编码能力提升计划 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
10-01 394
编码能力提升计划 - 华为OD统一考试(E卷) 为了提升软件编码能力，小王制定了刷题计划，他选了题库中的n道题，编号从0到n-1，并计划在m天内按照题目编号顺序刷完所有的题目(注意，小王不能用多天完成同一题)。 在小王刷题计划中，小王需要用 `time[i]` 的时间完成编号 `i`的题目。此外，小王还可以查看答案，可以省去该题的做题时间。为了真正达到刷题效果，小王每天最多直接看一次答案。 我们定义m天中做题时间最多的一天耗时为T(直接看答案的题目不计入做题总时间)。请你帮小王求出最小的T是多少。
敏感字段加密 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-27 816
敏感字段加密 - 华为OD统一考试(E卷) 【敏感字段加密】给定一个由多个命令字组成的命令字符串: 1、字符串长度小于等于127字节，只包含大小写字母，数字，下划线和偶数个双引号; 2、命令字之间以一个或多个下划线 进行分割; 3、可以通过两个双引号""来标识包含下划线 的命令字或空命令字(仅包含两个双引号的命令字)，双引号不会在命令字内部出现;请对指定索引的敏感字段进行加密，替换为`******`(6个*)，并删除命令字前后多余的下划线_。如果无法找到指定索引的命令字，输出字符串ERROR.
报数游戏 - 华为OD统一考试(E卷)
学习,你不是一个人在战斗 ～ 961302305（QQ,微信）
09-28 626
报数游戏 - 华为OD统一考试(E卷) 100个人围成一圈，每个人有一个编号，编号从1开始到100。他们从1开始依次报数，报到为M的人自动退出圈圈，然后下一个人接着从1开始报数，直到剩余的人数小于M。请问最后剩余的人在原先的编号为多少？
前缀和(8)_矩阵区域和
wer24_25的博客
09-30 906
前缀和算法完结篇_前缀和(8)_矩阵区域和 新坑算法-----位运算 感兴趣的宝子们千万不要错过!!!
【AI知识点】共现矩阵（Co-occurrence Matrix）
虾米记的博客
10-02 613
共现矩阵（Co-occurrence Matrix）是一种在自然语言处理中广泛使用的数学工具，用于表示词语在文本中相互出现的情况。它通常用于分析词语在文本中的共现关系，即哪些词语在同一上下文中经常一起出现。共现矩阵是生成词嵌入（Word Embedding）的一种重要方法，例如在GloVe模型中，它通过捕捉词语的共现信息来学习词语的语义表示。
a = Sw，其中a和w是向量，S是矩阵，求w等于什么？w可以写成关于a和S的什么样子的公式
u013172930的博客
09-26 747
当 S 可逆时和不可逆时分别进行了分析，给出了示例
解析TMalign文本文件中的转换矩阵
最新发布
qq_27390023的博客
10-02 157
将两个蛋白质结构通过旋转和位移对齐后。
矩阵系统源码搭建，OEM贴牌，源头技术开发
2401_84415462的博客
09-29 1024
矩阵系统源码搭建需要准备的内容包括技术选型、服务器与环境搭建、需求分析与设计、源码获取与开发、测试与部署等方面。在搭建过程中，需要充分考虑项目需求和技术要求，选择合适的技术和工具，遵循良好的开发规范和代码质量标准，确保矩阵系统的质量和稳定性。矩阵系统在当今的数字化时代中发挥着重要的作用，无论是在社交媒体管理、内容分发还是数据分析等方面，都有着广泛的应用。本文将详细介绍矩阵系统源码搭建所需准备的内容，帮助开发者更好地理解和实施矩阵系统的搭建过程。
VeighNa：强大的Python开源量化交易平台
Unity打怪升级
09-26 714
VeighNa（简称 VN 或 vn.py）是一个基于 Python 的开源量化交易平台，专为量化交易爱好者和专业交易员设计。VeighNa 是由国内开发者社区推动的开源项目，旨在提供一个功能丰富、灵活且易于扩展的量化交易解决方案。该框架不仅支持多种资产类别的交易，如股票、期货、期权、加密货币等，还支持多种交易接口和协议，使得用户能够轻松进行多市场、多品种的交易策略开发和部署。
第二百五十四节 JPA教程 - JPA 多对多映射示例
2301_78772942的博客
09-27 708
第二百五十四节 JPA教程 - JPA 多对多映射示例
（笔记）第三期书生·浦语大模型实战营（十一卷王场）--书生入门岛通关第2关Python 基础知识
haidizym的博客
10-02 321
学员闯关手册：https://aicarrier.feishu.cn/wiki/ZcgkwqteZi9s4ZkYr0Gcayg1n1g?课程视频：https://www.bilibili.com/video/BV1mS421X7h4/课程文档：https://github.com/InternLM/Tutorial/tree/camp3/docs/L0/Python。
python中的深浅拷贝以及总体框架了解
AgostoDu的博客
09-26 1182
1、当b使用copy.deepcopy()深拷贝的时候，可以理解为b不仅外面的整体开辟了一个新的内存地址，b里面包含的列表也开辟了新的内存地址和a里面的内存地址没有任何关系，所以当a修改里面列表元素的值时不会影响b里面列表元素的值。print(mr) #{'name': 'lis', 'age': 18, 'scroe': 100}<br>备注：已经存在的值的优先级>默认值<br>6.3 直接修改 值，显示最新修改值 （修改默认值优先级小于直接添加的字典值）<br>
华为od机试 - 信号发射和接收
08-22
华为od机试 - 信号发射和接收主要涉及到无线通信技术和信号处理技术。信号发射是指将电信号转化为无线信号并发送出去的过程，而信号接收则是指接收到的无线信号转化为电信号并进行信号处理的过程。 在信号发射方面，首先需要进行调制操作，即将要传输的信息信号进行编码与调制。编码是将信息信号进行数字化，并添加差错检测码，以增强信号的可靠性。调制是将数字化的信息信号与载波信号进行合成，产生带有信息的调制信号。常见的调制方法有调幅（AM）、调频（FM）和调相（PM）等。 接着，经过射频功率放大器的放大处理，将调制后的信号进行放大，并通过天线发送出去。射频功率放大器是将低功率的低频信号转化为高功率的射频信号的关键元件。 在信号接收方面，首先需要进行射频信号的接收，即通过天线接收到发送方发射的无线信号。接收到的射频信号通过射频前端进行放大和滤波，然后通过解调器进行解调操作，还原出调制信号。 接着，解调器将解调后的信号经过解调处理，并进行信号采样和量化，最后得到数字化的信号。经过数字信号处理技术，包括信号滤波、降噪、解调和解码等处理，将数字化的信号还原为原始信息信号，完成信号接收。 综上所述，华为od机试 - 信号发射和接收涉及到信号的调制、传输、接收和信号处理等环节。通过合理的调制和处理手段，可以实现有效的信号传输和接收，满足无线通信的需求。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

哪 吒

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值