当前位置: 首页 > article >正文

华为OD机试真题——荒岛求生(2025A卷:200分)Java/python/JavaScript/C/C++/GO最佳实现

在这里插入图片描述

2025 A卷 200分 题型

本专栏内全部题目均提供Java、python、JavaScript、C、C++、GO六种语言的最佳实现方式;
并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析;
本文收录于专栏:《2025华为OD真题目录+全流程解析+备考攻略+经验分享》

华为OD机试真题《荒岛求生》:


文章快捷目录

题目描述及说明

Java

python

JavaScript

C

GO

更多内容


题目名称:荒岛求生


  • 知识点:栈操作(贪心算法)、逻辑处理
  • 时间限制:1秒
  • 空间限制:256MB
  • 限定语言:不限

题目描述

一个荒岛上有若干人,岛上只有一条路通往岛屿两端的港口(左港口和右港口)。所有人以相同速度逃生,方向分为向左(负数)或向右(正数),其绝对值表示体力值。若两人相遇(即一个向右的人与一个向左的人路径重叠),则进行决斗:

  • 体力值大的一方存活,但体力值减少对方体力值的绝对值;
  • 若体力值相同,则同归于尽(双方均淘汰)。
    最终存活的人可从两端港口逃生,求逃生总人数。

输入描述
一行非零整数,用空格分隔,正数表示向右逃生,负数表示向左逃生。数组长度不超过30000。

输出描述
一个整数,表示最终逃生人数。

示例
输入:5 10 8 -8 -5
输出:2
说明:

  • 8-8同归于尽;
  • 10击败-5后剩余体力5
  • 最终存活[5, 5],均从右港口逃生,输出2

Java

问题分析

人们在一个荒岛逃生,方向分为左右(正负),体力值由绝对值表示。当两人相遇(向右遇到向左)时,体力大者存活但减少对方体力值,相等则同归于尽。最终存活的人从两端港口逃生,求总人数。


解题思路

  1. 栈处理向右的人:向右的人压入栈,向左的人与栈顶决斗。
  2. 决斗规则
    • 栈顶体力大:栈顶减少对方体力,存活。
    • 相等:栈顶弹出,同归于尽。
    • 栈顶体力小:弹出栈顶,继续与下一个栈顶决斗。
  3. 存活统计:栈内剩余为右港口逃生人数,未击败的向左人数为左港口逃生人数。

代码实现

import java.util.ArrayDeque;
import java.util.Deque;public class Main {public static void main(String[] args) {// 示例测试int[] example1 = {5, 10, 8, -8, -5};System.out.println(escapeCount(example1)); // 输出2int[] example2 = {3, -5};System.out.println(escapeCount(example2)); // 输出1int[] example3 = {-3, -4, 2};System.out.println(escapeCount(example3)); // 输出2}public static int escapeCount(int[] people) {Deque<Integer> stack = new ArrayDeque<>(); // 保存向右逃生的人int leftSurvivors = 0; // 左港口逃生人数for (int num : people) {if (num > 0) {stack.push(num); // 向右的人直接入栈} else {int k = -num; // 当前向左逃生者的体力while (k > 0) {if (stack.isEmpty()) {leftSurvivors++; // 栈空则左港口存活+1break;}int t = stack.pop(); // 取出栈顶向右的人if (t > k) {stack.push(t - k); // 栈顶体力减少k,存活k = 0; // 当前向左者被击败} else if (t == k) {k = 0; // 同归于尽} else {k -= t; // 继续与下一个栈顶决斗}}}}return stack.size() + leftSurvivors;}
}

代码详解

  1. 栈初始化Deque<Integer> stack保存向右逃生的人。
  2. 遍历处理每个人
    • 向右的人:直接压入栈。
    • 向左的人
      • k为体力绝对值,循环处理栈顶元素。
      • 栈空则左港口存活+1。
      • 栈顶大于k:栈顶存活,体力减少k
      • 栈顶等于k:同归于尽。
      • 栈顶小于k:继续处理下一个栈顶。
  3. 返回结果:栈的大小(右港口)加左港口存活人数。

示例测试

  1. 示例1[5,10,8,-8,-5]

    • 8-8同归于尽,10击败-5变为5
    • 右港口存活[5,5],输出2
  2. 示例2[3,-5]

    • 3-5击败,左港口存活1,输出1
  3. 示例3[-3,-4,2]

    • -3-4左港口存活,2右港口存活,输出3

综合分析

  1. 时间复杂度:O(N),每个元素最多入栈和出栈一次。
  2. 空间复杂度:O(N),栈空间最坏保存所有向右的人。
  3. 正确性
    • 栈处理保证所有相遇的向右和向左的人正确决斗。
    • 左港口存活人数统计未被击败的向左者。
  4. 适用性:高效处理大规模数据(3万元素)。

python

问题分析

人们在荒岛上逃生,方向分为左右(正数为右,负数为左),体力值为绝对值。相遇时决斗规则:体力大者存活并减少对方体力值,相等则同归于尽。求最终存活人数。


解题思路

  1. 栈处理向右的人:向右的人存入栈中。
  2. 处理向左的人:向左的人依次与栈顶元素决斗,直到击败对方或栈空。
  3. 存活统计:栈内剩余为右港口逃生者,未被击败的向左人数为左港口逃生者。

代码实现

def escape_count(people):stack = []  # 保存向右逃生的人left_survivors = 0  # 左港口逃生人数for num in people:if num > 0:stack.append(num)  # 向右的人直接入栈else:k = -num  # 当前向左者的体力值while k > 0:if not stack:  # 栈空则左港口存活+1left_survivors += 1breakt = stack.pop()  # 取出栈顶向右的人if t > k:stack.append(t - k)  # 栈顶体力减少k,存活k = 0  # 当前向左者被击败elif t == k:k = 0  # 同归于尽else:k -= t  # 继续与下一个栈顶决斗return len(stack) + left_survivors# 示例测试
example1 = [5, 10, 8, -8, -5]
print(escape_count(example1))  # 输出2example2 = [3, -5]
print(escape_count(example2))  # 输出1example3 = [-3, -4, 2]
print(escape_count(example3))  # 输出2

代码详解

  1. 栈初始化stack保存所有向右逃生的人。
  2. 遍历处理每个人
    • 向右的人:直接加入栈中(stack.append(num))。
    • 向左的人
      • 取绝对值k表示体力值。
      • 循环处理栈顶元素:
        • 栈空:左港口存活+1,退出循环。
        • 栈顶体力更大:栈顶存活,体力减少k,当前向左者被击败(k=0)。
        • 体力相等:同归于尽(k=0)。
        • 栈顶体力更小:继续处理下一个栈顶(k -= t)。
  3. 返回结果:栈长度(右港口存活) + 左港口存活人数。

示例测试

  1. 示例1[5, 10, 8, -8, -5]

    • 8-8同归于尽。
    • 10击败-5后变为5
    • 右港口存活[5,5],总人数2。
  2. 示例2[3, -5]

    • 3-5击败,左港口存活1。
  3. 示例3[-3, -4, 2]

    • -3-4左港口存活,2右港口存活,总人数2。

综合分析

  1. 时间复杂度:O(N),每个元素最多入栈和出栈一次。
  2. 空间复杂度:O(N),栈空间最坏保存所有向右的人。
  3. 正确性:严格处理决斗规则,确保栈和左港口人数正确统计。
  4. 适用性:高效处理大规模数据(如3万元素)。

JavaScript

问题分析

人们在荒岛上逃生,方向分为左右(正数右,负数左),体力值为绝对值。相遇时决斗规则:体力大者存活并减少对方体力值,相等则同归于尽。求最终存活人数。


解题思路

  1. 栈处理向右的人:向右的人存入栈中。
  2. 处理向左的人:向左的人依次与栈顶元素决斗,直到击败对方或栈空。
  3. 存活统计:栈内剩余为右港口逃生者,未被击败的向左人数为左港口逃生者。

代码实现

function escapeCount(people) {let stack = [];       // 保存向右逃生的人let leftSurvivors = 0; // 左港口逃生人数for (const num of people) {if (num > 0) {stack.push(num); // 向右的人直接入栈} else {let k = -num;   // 当前向左者的体力值while (k > 0) {if (stack.length === 0) { // 栈空则左港口存活+1leftSurvivors++;break;}const t = stack.pop(); // 取出栈顶向右的人if (t > k) {stack.push(t - k); // 栈顶体力减少k,存活k = 0;            // 当前向左者被击败} else if (t === k) {k = 0;            // 同归于尽} else {k -= t;           // 继续与下一个栈顶决斗}}}}return stack.length + leftSurvivors;
}// 示例测试
const example1 = [5, 10, 8, -8, -5];
console.log(escapeCount(example1)); // 输出2const example2 = [3, -5];
console.log(escapeCount(example2)); // 输出1const example3 = [-3, -4, 2];
console.log(escapeCount(example3)); // 输出2

代码详解

  1. 栈初始化stack数组保存向右逃生的人。
  2. 遍历处理每个人
    • 向右的人:直接压入栈(stack.push(num))。
    • 向左的人
      • 取绝对值k表示体力值。
      • 循环处理栈顶元素:
        • 栈空:左港口存活+1。
        • 栈顶体力更大:栈顶存活,体力减少k
        • 体力相等:同归于尽。
        • 栈顶体力更小:继续处理下一个栈顶(k -= t)。
  3. 返回结果:栈长度(右港口存活人数) + 左港口存活人数。

示例测试

  1. 示例1[5, 10, 8, -8, -5]

    • 8-8同归于尽。
    • 10击败-5后变为5
    • 右港口存活[5,5],总人数2。
  2. 示例2[3, -5]

    • 3-5击败,左港口存活1。
  3. 示例3[-3, -4, 2]

    • -3-4左港口存活,2右港口存活,总人数3。

综合分析

  1. 时间复杂度:O(N),每个元素最多入栈和出栈一次。
  2. 空间复杂度:O(N),栈空间最坏保存所有向右的人。
  3. 正确性:严格处理决斗规则,确保栈和左港口人数正确统计。
  4. 适用性:高效处理大规模数据(如3万元素)。

C++

问题分析

人们在荒岛上逃生,方向分为左右(正数右,负数左),体力值为绝对值。相遇时决斗规则:体力大者存活并减少对方体力值,相等则同归于尽。求最终存活人数。


解题思路

  1. 栈处理向右的人:向右的人存入栈中。
  2. 处理向左的人:向左的人依次与栈顶元素决斗,直到击败对方或栈空。
  3. 存活统计:栈内剩余为右港口逃生者,未被击败的向左人数为左港口逃生者。

代码实现

#include <iostream>
#include <vector>
using namespace std;int escapeCount(vector<int>& people) {vector<int> stack;       // 保存向右逃生的人(用vector模拟栈)int leftSurvivors = 0;   // 左港口逃生人数for (int num : people) {if (num > 0) {stack.push_back(num); // 向右的人直接入栈} else {int k = -num;        // 当前向左者的体力值(取绝对值)while (k > 0) {if (stack.empty()) { // 栈空则左港口存活+1leftSurvivors++;break;}int t = stack.back(); // 取栈顶元素stack.pop_back();     // 弹出栈顶if (t > k) {stack.push_back(t - k); // 栈顶体力减少k,存活k = 0;            // 当前向左者被击败} else if (t == k) {k = 0;            // 同归于尽} else {k -= t;           // 继续与下一个栈顶决斗}}}}return stack.size() + leftSurvivors;
}int main() {// 示例测试vector<int> example1 = {5, 10, 8, -8, -5};cout << escapeCount(example1) << endl; // 输出2vector<int> example2 = {3, -5};cout << escapeCount(example2) << endl; // 输出1vector<int> example3 = {-3, -4, 2};cout << escapeCount(example3) << endl; // 输出2return 0;
}

代码详解

  1. 栈初始化

    vector<int> stack; // 使用vector模拟栈,便于动态操作
    
    • 使用vectorpush_backpop_back实现栈的压入和弹出。
  2. 遍历处理每个人

    • 向右的人
      stack.push_back(num); // 直接存入栈尾
      
    • 向左的人
      int k = -num; // 取绝对值作为体力值
      while (k > 0) {if (stack.empty()) {leftSurvivors++; // 栈空则左港口存活+1break;}int t = stack.back(); // 取栈顶元素stack.pop_back();     // 弹出栈顶
      
      • 循环处理栈顶元素,直到击败所有向左者或栈空。
      • 决斗规则
        if (t > k) {        // 栈顶体力更大stack.push_back(t - k);k = 0;
        } else if (t == k) { // 同归于尽k = 0;
        } else {             // 栈顶体力更小k -= t;
        }
        
        • 栈顶存活时重新压入剩余体力,否则继续处理。
  3. 返回结果

    return stack.size() + leftSurvivors; // 右港口存活数 + 左港口存活数
    

示例测试

  1. 示例1[5, 10, 8, -8, -5]

    • 8-8同归于尽,10击败-5后剩余5
    • 右港口存活[5,5],总人数2。
  2. 示例2[3, -5]

    • 3-5击败,左港口存活1。
  3. 示例3[-3, -4, 2]

    • -3-4左港口存活,2右港口存活,总人数2。

综合分析

  1. 时间复杂度O(N)

    • 每个元素最多入栈和出栈一次,总操作次数与输入规模成线性关系。
  2. 空间复杂度O(N)

    • 栈空间最坏保存所有向右逃生者(例如输入全为正数)。
  3. 正确性

    • 严格模拟决斗规则,确保栈顶元素与向左者正确抵消。
    • 左港口存活数统计未被击败的向左者。
  4. 适用性

    • 高效处理大规模数据:3万元素可在1秒内处理完毕。
    • 代码简洁性:使用vector模拟栈,避免复杂数据结构。
  5. 为什么这是最佳实现?

    • 贪心策略:每次优先处理最近的向右者,保证局部最优。
    • 无需回溯:栈操作直接覆盖所有可能的相遇情况。
    • 低常数开销:直接操作内存,无递归或复杂计算。

C

问题分析

人们在荒岛上逃生,方向分为左右(正数右,负数左),体力值为绝对值。相遇时决斗规则:体力大者存活并减少对方体力值,相等则同归于尽。求最终存活人数。


解题思路

  1. 栈处理向右的人:向右的人存入栈中。
  2. 处理向左的人:向左的人依次与栈顶元素决斗,直到击败对方或栈空。
  3. 存活统计:栈内剩余为右港口逃生者,未被击败的向左人数为左港口逃生者。

代码实现

#include <stdio.h>
#include <stdlib.h>#define MAX_SIZE 30000  // 题目规定输入数组长度不超过30000int escapeCount(int people[], int size) {int stack[MAX_SIZE]; // 模拟栈,存储向右逃生的人int top = 0;          // 栈顶指针(指向下一个可插入的位置)int left_survivors = 0; // 左港口逃生人数for (int i = 0; i < size; i++) {int num = people[i];if (num > 0) {stack[top++] = num; // 向右的人入栈} else {int k = -num;       // 当前向左者的体力值(取绝对值)while (k > 0) {if (top == 0) { // 栈空则左港口存活+1left_survivors++;break;}int t = stack[--top]; // 取出栈顶元素if (t > k) {stack[top++] = t - k; // 栈顶体力减少k,存活k = 0;            // 当前向左者被击败} else if (t == k) {k = 0;            // 同归于尽} else {k -= t;           // 继续与下一个栈顶决斗}}}}return top + left_survivors; // 栈中剩余人数 + 左港口存活人数
}int main() {// 示例测试int example1[] = {5, 10, 8, -8, -5};printf("%d\n", escapeCount(example1, 5)); // 输出2int example2[] = {3, -5};printf("%d\n", escapeCount(example2, 2)); // 输出1int example3[] = {-3, -4, 2};printf("%d\n", escapeCount(example3, 3)); // 输出2return 0;
}

代码详解

  1. 栈初始化

    int stack[MAX_SIZE]; // 用数组模拟栈
    int top = 0;         // 栈顶指针(指向下一个空位)
    
    • 数组stack存储向右逃生的人,top表示栈顶位置。
  2. 遍历处理每个人

    • 向右的人
      stack[top++] = num; // 直接存入栈顶
      
    • 向左的人
      int k = -num;       // 取绝对值
      while (k > 0) {if (top == 0) { // 栈空则左港口存活+1left_survivors++;break;}int t = stack[--top]; // 取出栈顶元素
      
      • 循环处理栈顶元素,直到击败所有向左者或栈空。
      • 决斗规则
        if (t > k) {          // 栈顶体力更大stack[top++] = t - k; // 栈顶存活,减少k体力k = 0;
        } else if (t == k) {  // 同归于尽k = 0;
        } else {              // 栈顶体力更小k -= t;
        }
        
  3. 返回结果

    return top + left_survivors; // 栈剩余人数 + 左港口存活人数
    

示例测试

  1. 示例1{5, 10, 8, -8, -5}

    • 8-8同归于尽,10击败-5后剩余5
    • 右港口存活[5,5],总人数2。
  2. 示例2{3, -5}

    • 3-5击败,左港口存活1。
  3. 示例3{-3, -4, 2}

    • -3-4左港口存活,2右港口存活,总人数2。

综合分析

  1. 时间复杂度O(N)

    • 每个元素最多入栈和出栈一次,总操作次数与输入规模成线性关系。
  2. 空间复杂度O(MAX_SIZE)

    • 栈空间固定为MAX_SIZE,满足题目约束(数组长度≤30000)。
  3. 正确性

    • 严格模拟决斗规则,确保栈顶元素与向左者正确抵消。
    • 左港口存活数统计未被击败的向左者。
  4. 适用性

    • 高效处理大规模数据:3万元素可在1秒内处理完毕。
    • 低内存消耗:使用固定大小的数组避免动态内存分配。
  5. 为什么这是最佳实现?

    • 贪心策略:每次优先处理最近的向右者,保证局部最优。
    • 无需动态内存:预先分配栈数组,减少内存管理开销。
    • 代码简洁:直接操作数组,避免复杂数据结构。

GO

问题分析

人们在荒岛上逃生,方向分为左右(正数右,负数左),体力值为绝对值。相遇时决斗规则:体力大者存活并减少对方体力值,相等则同归于尽。求最终存活人数。


解题思路

  1. 栈处理向右的人:向右的人存入栈中。
  2. 处理向左的人:向左的人依次与栈顶元素决斗,直到击败对方或栈空。
  3. 存活统计:栈内剩余为右港口逃生者,未被击败的向左人数为左港口逃生者。

代码实现

package mainimport "fmt"func escapeCount(people []int) int {stack := make([]int, 0)     // 保存向右逃生的人(用切片模拟栈)leftSurvivors := 0          // 左港口逃生人数for _, num := range people {if num > 0 {stack = append(stack, num) // 向右的人直接入栈} else {k := -num                   // 当前向左者的体力值(取绝对值)for k > 0 {if len(stack) == 0 {     // 栈空则左港口存活+1leftSurvivors++break}// 取出栈顶元素t := stack[len(stack)-1]stack = stack[:len(stack)-1] // 弹出栈顶if t > k {stack = append(stack, t-k) // 栈顶体力减少k,存活k = 0                      // 当前向左者被击败} else if t == k {k = 0                      // 同归于尽} else {k -= t                     // 继续与下一个栈顶决斗}}}}return len(stack) + leftSurvivors // 右港口存活数 + 左港口存活数
}func main() {// 示例测试example1 := []int{5, 10, 8, -8, -5}fmt.Println(escapeCount(example1)) // 输出2example2 := []int{3, -5}fmt.Println(escapeCount(example2)) // 输出1example3 := []int{-3, -4, 2}fmt.Println(escapeCount(example3)) // 输出2
}

代码详解

  1. 栈初始化

    stack := make([]int, 0) // 使用切片模拟栈
    
    • Go 的切片(slice)动态扩展,非常适合模拟栈的 pushpop 操作。
  2. 遍历处理每个人

    • 向右的人
      stack = append(stack, num) // 追加到切片末尾(入栈)
      
    • 向左的人
      k := -num // 取绝对值
      for k > 0 {if len(stack) == 0 {leftSurvivors++ // 栈空则左港口存活+1break}t := stack[len(stack)-1]     // 取栈顶元素stack = stack[:len(stack)-1]  // 弹出栈顶
      
      • 循环处理栈顶元素,直到击败所有向左者或栈空。
      • 决斗规则
        if t > k {stack = append(stack, t-k) // 栈顶存活,减少k体力k = 0
        } else if t == k {k = 0                     // 同归于尽
        } else {k -= t                    // 继续与下一个栈顶决斗
        }
        
  3. 返回结果

    return len(stack) + leftSurvivors
    
    • 栈的长度即为右港口存活人数,加上左港口存活人数。

示例测试

  1. 示例1[5, 10, 8, -8, -5]

    • 8-8同归于尽,10击败-5后剩余5
    • 右港口存活[5,5],总人数2。
  2. 示例2[3, -5]

    • 3-5击败,左港口存活1。
  3. 示例3[-3, -4, 2]

    • -3-4左港口存活,2右港口存活,总人数3。

综合分析

  1. 时间复杂度O(N)

    • 每个元素最多入栈和出栈一次,总操作次数与输入规模成线性关系。
  2. 空间复杂度O(N)

    • 栈空间最坏保存所有向右逃生者(例如输入全为正数)。
  3. 正确性

    • 严格模拟决斗规则,确保栈顶元素与向左者正确抵消。
    • 左港口存活数统计未被击败的向左者。
  4. 适用性

    • 高效处理大规模数据:3万元素可在1秒内处理完毕。
    • 动态内存管理:Go 的切片自动扩容,避免手动内存分配。
  5. 为什么这是最佳实现?

    • 贪心策略:每次优先处理最近的向右者,保证局部最优。
    • 代码简洁:利用切片的动态特性,简化栈操作。
    • 低内存开销:切片按需分配内存,避免固定数组的空间浪费。

更多内容:

https://www.kdocs.cn/l/cvk0eoGYucWA

本文发表于【纪元A梦】,关注我,获取更多实用教程/资源!

相关文章:

华为OD机试真题——荒岛求生(2025A卷:200分)Java/python/JavaScript/C/C++/GO最佳实现

2025 A卷 200分 题型 本专栏内全部题目均提供Java、python、JavaScript、C、C、GO六种语言的最佳实现方式&#xff1b; 并且每种语言均涵盖详细的问题分析、解题思路、代码实现、代码详解、3个测试用例以及综合分析&#xff1b; 本文收录于专栏&#xff1a;《2025华为OD真题目录…...

【Python 字符串】

Python 中的字符串&#xff08;str&#xff09;是用于处理文本数据的基础类型&#xff0c;具有不可变性、丰富的内置方法和灵活的操作方式。以下是 Python 字符串的核心知识点&#xff1a; 一、基础特性 定义方式&#xff1a; s1 单引号字符串 s2 "双引号字符串" s…...

基础编程题目集 6-9 统计个位数字

本题要求实现一个函数&#xff0c;可统计任一整数中某个位数出现的次数。例如-21252中&#xff0c;2出现了3次&#xff0c;则该函数应该返回3。 函数接口定义&#xff1a; int Count_Digit ( const int N, const int D ); 其中N和D都是用户传入的参数。N的值不超过int的范围&…...

LeetCode[226] 翻转二叉树

思路&#xff1a; 使用递归&#xff0c;归根结底还是左右节点互相倒&#xff0c;那么肯定需要一个temp节点在中间传递&#xff0c;最后就是递归&#xff0c;没什么说的 代码&#xff1a; /*** Definition for a binary tree node.* public class TreeNode {* int …...

【CTFer成长之路】举足轻重的信息搜集

举足轻重的信息搜集 信息搜集 常见的搜集 题目描述: 一共3部分flag docker-compose.yml version: 3.2services:web:image: registry.cn-hangzhou.aliyuncs.com/n1book/web-information-backk:latestports:- 80:80启动方式 docker-compose up -d 题目Flag n1book{info_…...

AI——认知科学中的认知架构建立步骤与方法

认知科学中的认知架构建立步骤与方法 认知架构&#xff08;Cognitive Architecture&#xff09;是模拟人类心智活动的计算框架&#xff0c;旨在整合感知、记忆、推理、学习等核心认知功能。其建立需结合心理学理论、神经科学证据和计算建模技术。以下是建立认知架构的系统方法…...

Linux开发工具【中】

目录 一、vim 1.1 插入模式 1.2 底行模式 1&#xff09;set nu 2&#xff09;set nonu 3&#xff09; /XXX n 4&#xff09;&#xff01;command 5&#xff09;vs other 1.3 补充 1&#xff09; 批量化操作 2&#xff09;批量化替换 : 3&#xff09;快速定位&am…...

Ceph PG unfound/lost 问题排查与解决

Ceph PG unfound/lost 问题排查与解决 背景现象排查过程经验总结参考命令结语 背景 Ceph 集群出现 HEALTH_ERR&#xff0c;提示有 PG 对象丢失&#xff08;unfound&#xff09;&#xff0c;并且 repair 无法自动修复。 现象 ceph health detail 显示&#xff1a; HEALTH_ERR …...

MySQL OCP 认证限时免费活动​ 7 月 31 日 前截止!!!

为庆祝 MySQL 数据库发布 30 周年&#xff0c;Oracle 官方推出限时福利&#xff1a;2025 年 4 月 20 日至 7 月 31 日期间&#xff0c;所有人均可免费报考 MySQL OCP&#xff08;Oracle Certified Professional&#xff09;认证考试。该认证验证持证者在 MySQL 数据库管理、优化…...

Python Cookbook-7.8 使用 Berkeley DB 数据库

任务 你想将一些数据做持久化处理&#xff0c;而且也想体验一下BerkeleyDB数据库的简洁和高效。 解决方案 如果以前在你的计算机中安装过 BerkeleyDB&#xff0c;Python标准库附带的bsddb包(以及可选的 bsddb3&#xff0c;用于访间Berkeley DBrelease 3.2数据库)可以被用来作…...

STM32智能手表:基于FreeRTOS

引言 随着物联网和可穿戴设备的快速发展&#xff0c;智能手表作为典型代表&#xff0c;集成了传感器数据采集、实时显示、无线通信等多项功能。本文将深入剖析一个基于STM32和FreeRTOS的智能手表项目&#xff0c;从硬件架构到软件设计&#xff0c;逐步讲解如何构建一个完整的嵌…...

学习笔记:数据库——事务

1.内容&#xff1a; 基于现有数据库设计检查点实验&#xff0c;观察比较提交前后执行结果并分析。 2.实现 源码 -- 开启事务 START TRANSACTION;-- 插入一条订单记录&#xff08;客户ID为10002&#xff09; INSERT INTO orders (o_date, c_id) VALUES (NOW(), 10002);-- 获…...

C++命名空间、内联与捕获

命名空间namespace 最常见的命名空间是std,你一定非常熟悉,也就是: using namespace std;命名空间的基本格式 注意,要在头文件里面定义! namespace namespace_name{data_type function_name(data_type parameter){data_type result;//function contentreturn result;}…...

UE5 Daz头发转Blender曲线再导出ABC成为Groom

先安装Daz to Blender Import插件 【神器】 --DAZ一键导入blender插件的详细安装和使用&#xff0c;自带骨骼绑定和控制器&#xff0c;多姿势动画&#xff0c;Importer桥接插件_哔哩哔哩_bilibili 然后安装DAZHairConverter插件 一分钟将DAZ头发转化成Blender粒子毛发_哔哩哔…...

【进阶】C# 委托(Delegate)知识点总结归纳

1. 委托的基本概念 定义&#xff1a;委托是一种类型安全的函数指针&#xff0c;用于封装方法&#xff08;静态方法或实例方法&#xff09;。 核心作用&#xff1a;允许将方法作为参数传递&#xff0c;实现回调机制和事件处理。 类型安全&#xff1a;委托在编译时会检查方法签…...

【贪心算法】贪心算法四

贪心算法四 1.最长回文串2.增减字符串匹配3.分发饼干4.最优除法点赞👍👍收藏🌟🌟关注💖💖 你的支持是对我最大的鼓励,我们一起努力吧!😃😃 1.最长回文串 题目链接: 409. 最长回文串 题目分析: 给一个包含大小字母的字符串,从里面挑选出来一些字母构成一个…...

【漫话机器学习系列】240.真正类率(True Positive Rate,TPR)

理解真正类率&#xff08;True Positive Rate&#xff0c;TPR&#xff09;&#xff1a;公式、意义与应用 在机器学习与深度学习模型评估中&#xff0c;"真正类率"&#xff08;True Positive Rate&#xff0c;简称TPR&#xff09;是一个非常重要的指标。TPR反映了分类…...

Linux的基础开发工具

目录 前言&#xff1a; 1、包管理器yum 1.1 软件包的依赖 1.2 镜像源 1.3 查找/安装/卸载软件 2、编辑器vim 2.1 命令模式(默认) 2.1.1 撤销与反撤销 2.1.2 光标定位 2.1.3 复制&&剪切(删除)&&粘贴 2.1.4 替换 2.1.5 插入模式 2.1.6 V-Block模式 …...

【Electron】electron-vue 借助 element-ui UI 库助力桌面应用开发

前面文章我们讲过 electron 让可以用 HTML、JS、CSS 开发桌面应用程序。而 electron-vue 是一个结合了 electron 与 vue 的套件。这样我们就能方便地使用 vue 快速开发桌面应用。但是&#xff0c;vue 只是在 js 这层面做了大量的便捷的操作。对 UI 并未过多涉及。此时如果您在开…...

Linux基础(最常用基本命令)

1.查看文件ls 1.1 格式 ls 选项 参数&#xff0c;如&#xff1a;ls -lah ~/ 1.2 选项设置&#xff1a; -l&#xff1a;list 以列表方式显示文件 -h&#xff1a;human-readable 以人类可读的方式显示文件大小(会将纯数字转换为kb&#xff0c;mb) -a&#xff1a;all 显示所有的…...

含铜废水循环利用体系

在工业绿色转型浪潮中&#xff0c;含铜废水回收技术正以"资源再生智能管控"的双核驱动模式&#xff0c;重构传统水处理产业的价值链。该体系通过构建"精准分离-梯级利用-智慧运维"的闭环系统&#xff0c;不仅突破了重金属废水处理的技术桎梏&#xff0c;更…...

移动端返回指定页面

onLoad(() > { // #ifdef APP-PLUS || MP-ALIPAY || H5 onBackPress(() > { uni.switchTab({ url: ‘/pages/my/my’, }) return true }) // #endif }) onUnload(() > { // #ifdef MP-WEIXIN uni.switchTab({ url: ‘/pages/my/my’, }) // #endif })...

MySQL 安装配置(完整教程)

文章目录 一、MySQL 简介二、下载 MySQL三、安装 MySQL四、配置环境变量五、配置 MySQL5.1 初始化 MySQL5.2 搭建 MySQL 环境 六、修改 MySQL 密码七、卸载 MySQL八、结语 一、MySQL 简介 MySQL 是一款广泛使用的开源关系型数据库管理系统&#xff08;RDBMS&#xff09;&#…...

【JavaScript】二十九、垃圾回收 + 闭包 + 变量提升

文章目录 1、作用域1.1 局部作用域1.2 全局作用域1.3 作用域链 2、JC垃圾回收机制♻️3、GC算法3.1 引用计数法3.2 标记清除法 4、闭包4.1 定义4.2 闭包的应用&#xff1a;实现数据的私有 5、变量提升 1、作用域 即一个范围&#xff0c;离开了这个范围&#xff0c;这个变量就不…...

【从零开始学习RabbitMQ | 第一篇】从异步通信到交换机

目录 前言 1.什么是RabbitMQ&#xff1f; 2.同步调用的优缺点 3.异步调用的优缺点 3.1优点&#xff1a; 3.2异步调用的问题是什么&#xff1f; 4技术选型 4.1AMQP协议就是&#xff1a; 4.2kafka和RabbitMQ的使用场景 5.安装RabitMq 6.rabitmq的整体架构 7.RabibtM…...

100个常用的DeepSeek指令

日常生活类&#xff08;20个&#xff09; 1. 新闻解读&#xff1a;请为我解读今天的热点新闻。 2. 天气查询&#xff1a;请查询……的天气并推荐着装。 3. 旅行攻略&#xff1a;请制定前往……的旅行攻略。 4. 菜谱生成&#xff1a;请生成……菜的具体做法。 5. 解决方案&…...

AI(学习笔记第二课) 使用langchain进行AI开发

文章目录 AI(学习笔记第二课) 使用langchain进行AI开发学习内容&#xff1a;1. 使用背景2.创建python&#xff08;pycharm community版&#xff09;开发环境并连接deepseek2.1 创建python&#xff08;pycharm community版&#xff09;开发环境2.2 创建python工程2.3 写入初始py…...

基于Jenkins的DevOps工程实践之Jenkins共享库

文章目录 前言Jenkins共享库结构1、共享库演示2、知识点补充3、实践使用共享库格式化输出日志4、groovy基础语法4.1、 什么是 Groovy&#xff1f;4.2、groovy特点4.3、运行方法4.4、标识符4.5、基本数据类型4.5.1、string类型4.5.2、list类型 4.6、函数使用4.7、正则表达式 5、…...

使用Qt自带的Qt assistant时如何添加需要查看的文档

当我们双击打开Qt Assistant时 左边目录栏只有自带的帮助文档&#xff0c;所以需要添加要查看的文档 点击左上角Edit中的Preferences&#xff0c;点击add 找到qdoc文件夹 全选里面的内容 点击Apply 点击ok 左边的目录栏就出现所有这个版本的Qt有关的文档啦...

基于网络爬虫+Spark+Hadoop等大数据和SpringBoot技术实现的的汽车行业大数据分析与可视化平台系统(源码+论文+PPT+部署文档教程等)

博主介绍&#xff1a;CSDN毕设辅导第一人、全网粉丝50W,csdn特邀作者、博客专家、腾讯云社区合作讲师、CSDN新星计划导师、Java领域优质创作者,博客之星、掘金/华为云/阿里云/InfoQ等平台优质作者、专注于Java技术领域和学生毕业项目实战,高校老师/讲师/同行前辈交流✌ 技术范围…...