华为OD机试 - 采样过滤（Python/JS/C/C++ 2024 E卷 100分）

news2024/11/18 23:01:11

在这里插入图片描述

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

专栏导读

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

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

一、题目描述

在做物理实验时，为了计算物体移动的速度，通过相机和等工具周期性的采样物体移动距离。
由于工具故障，采样数据存在误差甚至丢失。
需要通过一个算法过滤掉不正确的采样值，且不同工具的故障恢复存在差异，算法的各关门限会根据工具类型做相应的调整。

请实现一个算法，计算出给定一组采样数据中正常值的最长连续周期。

判断1个周期的采样数据 S0 是否正确的规则如下(假定物体移动速度不超过10个单位前一个采样周期 S[i-1])：

S[i] <= 0，即为错误值
S[i] < S[i-1]，即为错误值
S[i] - S[i-1] >= 10，即为错误值。

其他情况为正常值。

判断工具是否故障的规则如下：

在 M 个周期内，采样数据为错误值的次数为 T(次数可以不连续)，则工具故障。

判断故障恢复的条件如下：

产生故障后的 P 个周期内，采样数据一直为正常值，则故障恢复。

错误采样数据的处理方式：

检测到故障后，丢弃从故障开始到故障恢复的采样数据

在检测到工具故障之前，错误的采样数据，则由最后一个正常值代替；如果前面没有正常的采样值，则丢弃此采样数据。

给定一段周期的采样 数据列表，计算正常值的最长连续周期。

二、输入描述

故障确认周期数和故障恢复数T分别为M和T，故障恢复周期数为P。

第i个周期，检测点的状态为S[i]。

输入为两行，格式如下：

M T P
s1 s2 s3 …

M, T, 和 P 的取值范围为[1, 100000]

S 取值范围为[0, 100000]，从0开始编号

三、输出描述

一行，输出正常值的最长连续周期。

四、测试用例

1、输入

10 6 3
-1 1 2 3 100 10 13 9 10

2、输出

8

3、说明

S[0]=-1 为错误，且没有前一个正常值，因此被丢弃。

S[1]=1 到 S[8]=10 中，只有 S[4]=100 和 S[7]=9, S[8]=10 是错误的，但总错误次数 3 < T=6，所以没有发生工具故障。

替换错误数据后，最长连续正常周期为 8。

五、解题思路

为了计算给定一组采样数据中正常值的最长连续周期，我们需要按照题目描述的规则对数据进行过滤，并实时跟踪最长的正常周期。

具体步骤如下：

  1. 判断采样数据是否正确：
    • 对于每个采样点 S[i]，根据前一个采样点 S[i-1] 来判断其是否正确。
    • 第一个采样点 S[0] 仅需满足 S[0] > 0。
  2. 维护一个滑动窗口：
    • 使用一个固定大小为 M 的循环数组来跟踪最近 M 个周期内的错误次数。
    • 当窗口中错误次数达到或超过 T 时，标记工具为故障状态。
  3. 处理工具故障：
    • 一旦检测到工具故障，开始丢弃数据，直到连续 P 个周期的数据均为正常值，标记工具恢复正常。
    • 在故障恢复期间，错误的采样数据被丢弃。
  4. 替换错误数据：
    • 在工具未故障的情况下，如果检测到错误的采样数据且存在前一个正常值，则用前一个正常值替换错误数据。
    • 如果不存在前一个正常值，则丢弃该采样数据。
  5. 跟踪最长连续正常周期：
    • 在数据过滤的过程中，实时更新当前连续正常周期的长度，并记录最大值。
    • 通过上述步骤，可以有效过滤掉错误数据，并计算出最长的连续正常周期。

六、Python算法源码

# Python 代码实现

import sys

def main():
    import sys

    # 读取输入的第一行，获取 M, T, P
    first_line = sys.stdin.readline().strip()
    if not first_line:
        first_line = sys.stdin.readline().strip()
    M, T, P = map(int, first_line.split())

    # 读取第二行，获取所有采样数据
    second_line = sys.stdin.readline().strip()
    S = list(map(int, second_line.split()))
    N = len(S)

    # 初始化滑动窗口，用于记录最近 M 个周期内的错误次数
    window = [0] * M  # 滑动窗口数组，大小为 M
    window_error_count = 0  # 当前滑动窗口内的错误次数
    window_index = 0  # 当前滑动窗口的索引

    # 初始化其他变量
    last_correct = None  # 存储最后一个正常的采样值
    current_run = 0  # 当前连续正常周期的长度
    max_run = 0  # 最大连续正常周期的长度
    fault_state = False  # 标记是否处于故障状态
    recovery_counter = 0  # 恢复计数器，记录连续正常周期数

    for i in range(N):
        if not fault_state:
            # 判断当前采样数据是否正确
            if i == 0:
                is_correct = S[i] > 0
            else:
                is_correct = (S[i] > 0) and (S[i] >= S[i-1]) and ((S[i] - S[i-1]) < 10)
            
            new_error_flag = 0 if is_correct else 1  # 错误标志，0表示正确，1表示错误

            # 更新滑动窗口中的错误次数
            window_error_count -= window[window_index]  # 减去即将被替换的旧值
            window[window_index] = new_error_flag  # 更新当前窗口位置的错误标志
            window_error_count += new_error_flag  # 增加新的错误标志
            window_index = (window_index + 1) % M  # 滑动窗口索引向后移动

            # 检查是否触发故障
            if window_error_count >= T:
                fault_state = True  # 进入故障状态
                recovery_counter = 0  # 重置恢复计数器
                current_run = 0  # 重置当前连续正常周期长度
                continue  # 开始丢弃数据
            

            if is_correct:
                last_correct = S[i]  # 更新最后一个正常值
                current_run += 1  # 当前连续正常周期长度加一
                if current_run > max_run:
                    max_run = current_run  # 更新最大连续正常周期长度
            else:
                if last_correct is not None:
                    # 用最后一个正常值替换错误数据
                    current_run += 1  # 替换后视为正常，当前连续正常周期长度加一
                    if current_run > max_run:
                        max_run = current_run  # 更新最大连续正常周期长度
                else:
                    # 没有正常值可替换，丢弃此数据
                    current_run = 0  # 当前连续正常周期长度重置
        else:
            # 处于故障状态，丢弃数据
            # 判断当前采样数据是否正确，用于恢复
            if i == 0:
                is_correct = S[i] > 0
            else:
                is_correct = (S[i] > 0) and (S[i] >= S[i-1]) and ((S[i] - S[i-1]) < 10)
            
            if is_correct:
                recovery_counter += 1  # 连续正常周期数加一
                if recovery_counter >= P:
                    fault_state = False  # 恢复正常状态
                    recovery_counter = 0  # 重置恢复计数器
                    # 重置滑动窗口
                    window = [0] * M
                    window_error_count = 0
                    window_index = 0
                    current_run = 0  # 重置当前连续正常周期长度
                    last_correct = None  # 重置最后一个正常值
            else:
                recovery_counter = 0  # 出现错误，恢复计数器重置

    # 输出最长连续正常周期长度
    print(max_run)

if __name__ == "__main__":
    main()

七、JavaScript算法源码

// JavaScript 代码实现

const readline = require('readline');

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

let inputLines = [];

rl.on('line', (line) => {
    inputLines.push(line.trim());
    if (inputLines.length === 2) {
        rl.close();
    }
}).on('close', () => {
    // 读取第一行，获取 M, T, P
    let [M, T, P] = inputLines[0].split(' ').map(Number);

    // 读取第二行，获取所有采样数据
    let S = inputLines[1].split(' ').map(Number);
    let N = S.length;

    // 初始化滑动窗口，用于记录最近 M 个周期内的错误次数
    let window = new Array(M).fill(0);  // 滑动窗口数组，大小为 M
    let window_error_count = 0;  // 当前滑动窗口内的错误次数
    let window_index = 0;  // 当前滑动窗口的索引

    // 初始化其他变量
    let last_correct = null;  // 存储最后一个正常的采样值
    let current_run = 0;  // 当前连续正常周期的长度
    let max_run = 0;  // 最大连续正常周期的长度
    let fault_state = false;  // 标记是否处于故障状态
    let recovery_counter = 0;  // 恢复计数器，记录连续正常周期数

    for (let i = 0; i < N; i++) {
        if (!fault_state) {
            // 判断当前采样数据是否正确
            let is_correct;
            if (i === 0) {
                is_correct = S[i] > 0;
            } else {
                is_correct = (S[i] > 0) && (S[i] >= S[i - 1]) && ((S[i] - S[i - 1]) < 10);
            }

            let new_error_flag = is_correct ? 0 : 1;  // 错误标志，0表示正确，1表示错误

            // 更新滑动窗口中的错误次数
            window_error_count -= window[window_index];  // 减去即将被替换的旧值
            window[window_index] = new_error_flag;  // 更新当前窗口位置的错误标志
            window_error_count += new_error_flag;  // 增加新的错误标志
            window_index = (window_index + 1) % M;  // 滑动窗口索引向后移动

            // 检查是否触发故障
            if (window_error_count >= T) {
                fault_state = true;  // 进入故障状态
                recovery_counter = 0;  // 重置恢复计数器
                current_run = 0;  // 重置当前连续正常周期长度
                continue;  // 开始丢弃数据
            }

            if (is_correct) {
                last_correct = S[i];  // 更新最后一个正常值
                current_run += 1;  // 当前连续正常周期长度加一
                if (current_run > max_run) {
                    max_run = current_run;  // 更新最大连续正常周期长度
                }
            } else {
                if (last_correct !== null) {
                    // 用最后一个正常值替换错误数据
                    current_run += 1;  // 替换后视为正常，当前连续正常周期长度加一
                    if (current_run > max_run) {
                        max_run = current_run;  // 更新最大连续正常周期长度
                    }
                } else {
                    // 没有正常值可替换，丢弃此数据
                    current_run = 0;  // 当前连续正常周期长度重置
                }
            }
        } else {
            // 处于故障状态，丢弃数据
            // 判断当前采样数据是否正确，用于恢复
            let is_correct;
            if (i === 0) {
                is_correct = S[i] > 0;
            } else {
                is_correct = (S[i] > 0) && (S[i] >= S[i - 1]) && ((S[i] - S[i - 1]) < 10);
            }

            if (is_correct) {
                recovery_counter += 1;  // 连续正常周期数加一
                if (recovery_counter >= P) {
                    fault_state = false;  // 恢复正常状态
                    recovery_counter = 0;  // 重置恢复计数器
                    // 重置滑动窗口
                    window = new Array(M).fill(0);
                    window_error_count = 0;
                    window_index = 0;
                    current_run = 0;  // 重置当前连续正常周期长度
                    last_correct = null;  // 重置最后一个正常值
                }
            } else {
                recovery_counter = 0;  // 出现错误，恢复计数器重置
            }
        }
    }

    // 输出最长连续正常周期长度
    console.log(max_run);
});

八、C算法源码

/* C 代码实现 */

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

int main(){
    int M, T, P;
    // 读取 M, T, P
    scanf("%d %d %d", &M, &T, &P);

    // 读取第二行的采样数据
    // 假设最大采样数量为100000，动态分配
    int *S = (int*)malloc(100000 * sizeof(int));
    int N = 0;
    while(scanf("%d", &S[N]) != EOF){
        N++;
    }

    // 初始化滑动窗口
    int *window = (int*)calloc(M, sizeof(int));  // 初始化为0
    int window_error_count = 0;
    int window_index = 0;

    // 初始化其他变量
    int last_correct = -1;  // -1表示没有正常值
    int current_run = 0;
    int max_run = 0;
    int fault_state = 0;  // 0表示正常，1表示故障
    int recovery_counter = 0;

    for(int i=0; i<N; i++){
        if(!fault_state){
            // 判断当前采样数据是否正确
            int is_correct;
            if(i ==0){
                is_correct = S[i] >0;
            }
            else{
                is_correct = (S[i] >0) && (S[i] >= S[i-1]) && ((S[i] - S[i-1]) <10);
            }

            int new_error_flag = is_correct ? 0 :1;

            // 更新滑动窗口中的错误次数
            window_error_count -= window[window_index];
            window[window_index] = new_error_flag;
            window_error_count += new_error_flag;
            window_index = (window_index +1) % M;

            // 检查是否触发故障
            if(window_error_count >= T){
                fault_state = 1;  // 进入故障状态
                recovery_counter =0;
                current_run =0;  // 重置当前连续正常周期长度
                continue;  // 开始丢弃数据
            }

            if(is_correct){
                last_correct = S[i];
                current_run +=1;
                if(current_run > max_run){
                    max_run = current_run;
                }
            }
            else{
                if(last_correct != -1){
                    // 用最后一个正常值替换错误数据
                    current_run +=1;
                    if(current_run > max_run){
                        max_run = current_run;
                    }
                }
                else{
                    // 没有正常值可替换，丢弃此数据
                    current_run =0;
                }
            }
        }
        else{
            // 处于故障状态，丢弃数据
            // 判断当前采样数据是否正确，用于恢复
            int is_correct;
            if(i ==0){
                is_correct = S[i] >0;
            }
            else{
                is_correct = (S[i] >0) && (S[i] >= S[i-1]) && ((S[i] - S[i-1]) <10);
            }

            if(is_correct){
                recovery_counter +=1;
                if(recovery_counter >= P){
                    fault_state =0;  // 恢复正常状态
                    recovery_counter =0;
                    // 重置滑动窗口
                    for(int j=0; j<M; j++){
                        window[j] =0;
                    }
                    window_error_count =0;
                    window_index =0;
                    current_run =0;  // 重置当前连续正常周期长度
                    last_correct = -1;  // 重置最后一个正常值
                }
            }
            else{
                recovery_counter =0;
            }
        }
    }

    // 输出最长连续正常周期长度
    printf("%d\n", max_run);

    // 释放内存
    free(S);
    free(window);
    return 0;
}

九、C++算法源码

// C++ 代码实现

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

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

    int M, T, P;
    // 读取 M, T, P
    cin >> M >> T >> P;

    // 读取第二行的采样数据
    vector<int> S;
    int num;
    while(cin >> num){
        S.push_back(num);
    }
    int N = S.size();

    // 初始化滑动窗口
    vector<int> window(M, 0);  // 滑动窗口数组，大小为 M
    int window_error_count = 0;
    int window_index = 0;

    // 初始化其他变量
    int last_correct = -1;  // -1表示没有正常值
    int current_run = 0;
    int max_run = 0;
    bool fault_state = false;  // 标记是否处于故障状态
    int recovery_counter = 0;

    for(int i=0; i<N; i++){
        if(!fault_state){
            // 判断当前采样数据是否正确
            bool is_correct;
            if(i ==0){
                is_correct = S[i] >0;
            }
            else{
                is_correct = (S[i] >0) && (S[i] >= S[i-1]) && ((S[i] - S[i-1]) <10);
            }

            int new_error_flag = is_correct ? 0 :1;

            // 更新滑动窗口中的错误次数
            window_error_count -= window[window_index];
            window[window_index] = new_error_flag;
            window_error_count += new_error_flag;
            window_index = (window_index +1) % M;

            // 检查是否触发故障
            if(window_error_count >= T){
                fault_state = true;  // 进入故障状态
                recovery_counter =0;
                current_run =0;  // 重置当前连续正常周期长度
                continue;  // 开始丢弃数据
            }

            if(is_correct){
                last_correct = S[i];
                current_run +=1;
                if(current_run > max_run){
                    max_run = current_run;
                }
            }
            else{
                if(last_correct != -1){
                    // 用最后一个正常值替换错误数据
                    current_run +=1;
                    if(current_run > max_run){
                        max_run = current_run;
                    }
                }
                else{
                    // 没有正常值可替换，丢弃此数据
                    current_run =0;
                }
            }
        }
        else{
            // 处于故障状态，丢弃数据
            // 判断当前采样数据是否正确，用于恢复
            bool is_correct;
            if(i ==0){
                is_correct = S[i] >0;
            }
            else{
                is_correct = (S[i] >0) && (S[i] >= S[i-1]) && ((S[i] - S[i-1]) <10);
            }

            if(is_correct){
                recovery_counter +=1;
                if(recovery_counter >= P){
                    fault_state = false;  // 恢复正常状态
                    recovery_counter =0;
                    // 重置滑动窗口
                    fill(window.begin(), window.end(), 0);
                    window_error_count =0;
                    window_index =0;
                    current_run =0;  // 重置当前连续正常周期长度
                    last_correct = -1;  // 重置最后一个正常值
                }
            }
            else{
                recovery_counter =0;
            }
        }
    }

    // 输出最长连续正常周期长度
    cout << max_run << "\n";

    return 0;
}

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

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

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

在这里插入图片描述

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2200280.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MySQL数据的增删改查

MySQL数据的增删改查

CRUD CRUD指的是创建&#xff08;Create&#xff09;,读取&#xff08;Retrieve&#xff09;&#xff0c;更新&#xff08;Update&#xff09;和删除&#xff08;Delete&#xff09;,它是数据库或者持久层在软件系统中执行的基本功能&#xff0c;构成了大多数应用程序和服务器…
阅读更多...
图神经网络之异构图转同构图

图神经网络之异构图转同构图

heterogeneous graph转homogeneous 异构图创建教程dgl.to_homogeneous语法格式例子 异构图创建教程 对于异构图创建&#xff0c;可以看异构图创建教程 dgl.to_homogeneous语法格式 dgl.to_homogeneous(G, ndataNone, edataNone, store_typeTrue, return_countFalse)G&#x…
阅读更多...
K8s简介及环境搭建

K8s简介及环境搭建

一、Kubernetes简介 kubernetes 的本质是一组服务器集群&#xff0c;它可以在集群的每个节点上运行特定的程序&#xff0c;来对节点中的容器进行管理。目的是实现资源管理的自动化&#xff0c;主要提供了如下的主要功能&#xff1a; 自我修复&#xff1a;一旦某一个容器崩溃&a…
阅读更多...
使用HashiCorp Nomad Cluster App管理高可用集群

使用HashiCorp Nomad Cluster App管理高可用集群

容器化和Kubernetes如今已成为创建可扩展云原生应用程序的基本要素。但并非每个应用程序工作负载都需要容器或Kubernetes资源。HashiCorp Nomad是一个轻量级的工作负载调度程序&#xff0c;提供了与Kubernetes相似的优势&#xff0c;但不仅可以管理容器&#xff0c;还能管理其他…
阅读更多...
SSL证书是否可以给多个域名使用？

SSL证书是否可以给多个域名使用？

在当今数字化的网络环境中&#xff0c;SSL证书在保障网站安全、保护用户数据传输方面发挥着至关重要的作用。那么&#xff0c;SSL 证书是否可以给多个域名使用呢&#xff1f;这是一个在网站开发、运营和安全管理领域备受关注的问题。 SSL 证书能够给多个域名使用吗&#xff1f…
阅读更多...
指针函数C++

指针函数C++

指针函数概念 指针函数在C中是一种特殊类型的函数。从本质上讲&#xff0c;它是一个函数&#xff0c;不过其返回值是一个指针类型的数据。例如&#xff0c;像int* plusfunction(int a, int b);这样的函数声明&#xff0c;plusfunction就是一个指针函数&#xff0c;它接受两个i…
阅读更多...
Jvisualvm介绍；使用Jvisualvm：运行jvisualvm.exe；安装gc插件；查看gc

Jvisualvm介绍；使用Jvisualvm：运行jvisualvm.exe；安装gc插件；查看gc

一&#xff0c;Jvisualvm介绍 jvisualvm是用来查看硬件使用情况的工具&#xff0c;多数会用它来看内存的使用情况 VisualVM 是Netbeans的profile子项目&#xff0c;已在JDK6.0 update 7 中自带(java启动时不需要特定参数&#xff0c;监控工具在bin/jvisualvm.exe)&#xff0c…
阅读更多...
leetcode 10.9 94.二叉树的中序遍历

leetcode 10.9 94.二叉树的中序遍历

94. 二叉树的中序遍历 已解答 简单 相关标签 相关企业 给定一个二叉树的根节点 root &#xff0c;返回 它的 中序 遍历 。 示例 1&#xff1a; 输入&#xff1a;root [1,null,2,3] 输出&#xff1a;[1,3,2]示例 2&#xff1a; 输入&#xff1a;root [] 输出&#xff1a…
阅读更多...
LabelImag标注工具环境配置

LabelImag标注工具环境配置

LabelImag标注工具环境配置 Anaconda的安装和使用 Anaconda是一个集成了Python解释器、conda包管理器和众多科学计算、数据分析、机器学习等常用库的发行版。它允许用户轻松地管理Python环境和包&#xff0c;无需手动解决依赖问题。Anaconda特别适用于数据科学、机器学习、人…
阅读更多...
Mac 下编译 libaom 源码教程

Mac 下编译 libaom 源码教程

AV1 AV1是一种开放、免版税的视频编码格式&#xff0c;由开放媒体联盟&#xff08;AOMedia&#xff09;开发&#xff0c;旨在提供高压缩效率和优秀的视频质量。AV1支持多种分辨率&#xff0c;包括SD、HD、4K和8K&#xff0c;并适用于视频点播&#xff08;VOD&#xff09;、直播…
阅读更多...
Python酷库之旅-第三方库Pandas(139)

Python酷库之旅-第三方库Pandas(139)

目录 一、用法精讲 626、pandas.plotting.scatter_matrix方法 626-1、语法 626-2、参数 626-3、功能 626-4、返回值 626-5、说明 626-6、用法 626-6-1、数据准备 626-6-2、代码示例 626-6-3、结果输出 627、pandas.plotting.table方法 627-1、语法 627-2、参数 …
阅读更多...
从0开始linux（11）——进程（3）进程的切换与调度

从0开始linux（11）——进程（3）进程的切换与调度

欢迎来到博主的专栏&#xff1a;从0开始linux 博主ID&#xff1a;代码小豪 文章目录 进程优先级进程的切换linux的调度算法 进程优先级 进程的优先级决定了进程获得CPU资源分配的顺序&#xff0c;在进程&#xff08;0&#xff09;这篇文章中博主就讲过并发和并行两个概念。即对…
阅读更多...
ai论文写作软件哪个好？分享5款ai论文题目生成器

ai论文写作软件哪个好？分享5款ai论文题目生成器

在当前的学术研究和写作领域&#xff0c;AI论文写作软件已经成为提高效率和质量的重要工具。根据多个来源的评测和推荐&#xff0c;以下是五款值得推荐的AI论文写作软件&#xff0c;其中特别推荐千笔-AIPassPaper。 1. 千笔-AIPassPaper 千笔-AIPassPaper是一款基于深度学习和…
阅读更多...
超级详细 安装 Python 最佳实践文档

超级详细 安装 Python 最佳实践文档

第一步&#xff0c;下载Python 打开Python官网&#xff1a;Welcome to Python.org 可以根据自己的需要下载相应的版本 第二步&#xff0c;安装Python 右键.exe文件->选择打开 安装 勾选 Install for all users选项 Browse为选择安装路径&#xff0c;可以自定安装路径 D盘…
阅读更多...
动态规划12：213. 打家劫舍 II

动态规划12：213. 打家劫舍 II

动态规划解题步骤&#xff1a; 1.确定状态表示&#xff1a;dp[i]是什么 2.确定状态转移方程&#xff1a;dp[i]等于什么 3.初始化&#xff1a;确保状态转移方程不越界 4.确定填表顺序&#xff1a;根据状态转移方程即可确定填表顺序 5.确定返回值 题目链接&#xff1a;213.…
阅读更多...
DAMA数据管理知识体系(第15章 数据管理成熟度评估)

DAMA数据管理知识体系(第15章 数据管理成熟度评估)

课本内容 15.1 引言 概要 能力成熟度评估&#xff08;Capability Maturity Assessment&#xff0c;CMA&#xff09;是一种基于能力成熟度模型&#xff08;Capability Maturity Model&#xff0c;CMM&#xff09;框架的能力提升方案&#xff0c;描述了数据管理能力初始状态发展到…
阅读更多...
怎么将手机备忘录传送至电脑

怎么将手机备忘录传送至电脑

在数字化时代&#xff0c;手机备忘录已成为我们生活中不可或缺的一部分。无论是记录购物清单、工作事项&#xff0c;还是灵感闪现的瞬间&#xff0c;手机备忘录都能随时记录下这些宝贵的信息&#xff0c;帮助我们防止遗忘。然而&#xff0c;有时候我们需要将这些备忘录内容转移…
阅读更多...
IPSeizer/Zenmap 查看内网哪些ip没有被占用

IPSeizer/Zenmap 查看内网哪些ip没有被占用

下载IPSeizer, 无需安装直接双击打开使用&#xff0c;填入需要的网段&#xff0c;点start查询 或者使用Zenmap&#xff0c;指定范围和端口号
阅读更多...
LSTM（长短时记忆网络）

LSTM（长短时记忆网络）

一、引言 在处理序列数据时&#xff0c;循环神经网络&#xff08;RNN&#xff09;虽然能够处理序列数据并保留历史信息&#xff0c;但在实践中发现它对于捕捉长时间依赖关系的能力有限&#xff0c;尤其是在训练过程中容易遇到梯度消失或梯度爆炸的问题。为了解决这些问题&…
阅读更多...
《Oracle DB备份与恢复》开篇：一切从Oracle Incarnation开始

《Oracle DB备份与恢复》开篇：一切从Oracle Incarnation开始

题记&#xff1a;从本篇开始&#xff0c;我将为大家介绍Oracle DB备份与恢复。备份恢复是DBA的核心工作&#xff0c;重在实操&#xff0c;多加练习&#xff0c;模拟各种DB或实例崩溃的场景。不同于一些博主一出场就讲如何备份恢复&#xff0c;我将从备份的源头原理开始介绍。本…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023