文心一言 VS 讯飞星火 VS chatgpt （215）-- 算法导论16.2 2题

news2024/9/23 3:22:38

二、设计动态规划算法求解 0-1 背包问题，要求运行时间为 O(nW)，n为商品数量，W是小偷能放进背包的最大商品总重量。如果要写代码，请用go语言。

文心一言：

0-1 背包问题是一个典型的动态规划问题，其目标是在给定的重量限制下最大化背包中物品的总价值。每个物品可以选择放入背包或不放入背包（0-1表示），并且每种物品只有一个。

为了设计满足 O(nW) 时间复杂度的算法，我们可以使用二维数组 dp[i][w] 来存储子问题的解，其中 i 表示考虑的物品数量，w 表示当前的重量限制。dp[i][w] 表示考虑前 i 个物品且重量不超过 w 的情况下能得到的最大价值。

下面是使用 Go 语言实现的代码：

package main  
  
import (  
	"fmt"  
)  
  
// Max returns the larger of x or y.  
func Max(x, y int) int {  
	if x > y {  
		return x  
	}  
	return y  
}  
  
// ZeroOneKnapsack 解决 0-1 背包问题  
func ZeroOneKnapsack(weights []int, values []int, W int) int {  
	n := len(weights)  
	dp := make([][]int, n+1)  
	for i := range dp {  
		dp[i] = make([]int, W+1)  
	}  
  
	for i := 1; i <= n; i++ {  
		for w := 1; w <= W; w++ {  
			if weights[i-1] <= w {  
				// 当前物品可以放入背包，考虑放入和不放入两种情况  
				dp[i][w] = Max(dp[i-1][w], dp[i-1][w-weights[i-1]]+values[i-1])  
			} else {  
				// 当前物品不能放入背包，只考虑不放入的情况  
				dp[i][w] = dp[i-1][w]  
			}  
		}  
	}  
  
	// 背包的最大价值即为 dp[n][W]  
	return dp[n][W]  
}  
  
func main() {  
	weights := []int{2, 3, 4, 5}  // 商品重量  
	values := []int{3, 4, 5, 6}  // 商品价值  
	W := 5                        // 背包最大承重  
  
	maxValue := ZeroOneKnapsack(weights, values, W)  
	fmt.Printf("The maximum value that can be put in a knapsack of capacity %d is %d\n", W, maxValue)  
}

这个算法的时间复杂度是 O(nW)，因为我们需要遍历所有的物品（n个）和所有可能的重量（W个）。空间复杂度也是 O(nW)，因为我们需要一个二维数组来存储中间结果。

注意，在实际应用中，可以通过优化来减少空间复杂度。例如，我们可以使用一维数组 dp[w] 来代替二维数组 dp[i][w]，因为当前状态 dp[i][w] 只依赖于前一个状态 dp[i-1][w] 和 dp[i-1][w-weights[i-1]]。这样的优化通常称为“滚动数组”优化，可以将空间复杂度降低到 O(W)。不过，在这里为了保持算法描述的清晰性，我们使用了二维数组。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火：

0-1背包问题是一个经典的动态规划问题。在这个问题中，我们有n个商品，每个商品i有一个价值vi和一个重量wi。我们的目标是选择一些商品放入背包，使得总价值最大，同时保证总重量不超过W。

我们可以使用一个二维数组dp来存储中间结果。dp[i][j]表示在前i个商品中选择一些商品，使得总重量不超过j的最大价值。

状态转移方程为：dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i])，其中w[i]和v[i]分别表示第i个商品的重量和价值。

初始状态为：dp[0][j] = 0，表示没有商品时，总价值为0。

最终答案为：dp[n][W]，表示在前n个商品中选择一些商品，使得总重量不超过W的最大价值。

以下是用Go语言实现的代码：

package main

import (
	"fmt"
)

func knapsack(n int, W int, w []int, v []int) int {
	dp := make([][]int, n+1)
	for i := range dp {
		dp[i] = make([]int, W+1)
	}

	for i := 1; i <= n; i++ {
		for j := 1; j <= W; j++ {
			if w[i-1] <= j {
				dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i-1]]+v[i-1])
			} else {
				dp[i][j] = dp[i-1][j]
			}
		}
	}

	return dp[n][W]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	n := 4
	W := 5
	w := []int{2, 3, 4, 5}
	v := []int{3, 4, 5, 6}
	fmt.Println(knapsack(n, W, w, v)) // 输出：7
}

这个算法的时间复杂度为O(nW)，满足题目要求。

在这里插入图片描述

在这里插入图片描述

360智脑：

动态规划算法求解0-1背包问题的基本思路是：创建一个二维数组，其中行表示商品，列表示背包所能承受的最大重量。然后，从左上角开始，逐步填充数组，直到到达右下角。在填充过程中，对于每一个商品和每一个背包重量，我们有两种选择：包含当前商品和不包含当前商品。我们比较这两种选择中能够得到的最大价值，并将其存储在数组中。

下面是用Go语言实现的代码：

package main

import "fmt"

func knapsack(weights []int, values []int, capacity int) int {
    n := len(weights)
    dp := make([][capacity + 1]int, n + 1)

    for i := 1; i <= n; i++ {
        for w := 1; w <= capacity; w++ {
            if weights[i-1] > w {
                dp[i][w] = dp[i-1][w]
            } else {
                dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]]+values[i-1])
            }
        }
    }

    return dp[n][capacity]
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func main() {
    weights := []int{1, 2, 3, 4}
    values := []int{6, 10, 12, 16}
    capacity := 5

    fmt.Println(knapsack(weights, values, capacity)) // 输出：22
}

在这个代码中，我们首先定义了一个表示商品重量的切片weights，一个表示商品价值的切片values，以及背包所能承受的最大重量capacity。然后，我们创建了一个二维数组dp，其中dp[i][w]表示前i个商品中，价值最大的子集的总价值，且其总重量不超过w。

接下来，我们从左上角开始，逐步填充数组dp。对于每一个商品和每一个背包重量，我们有两种选择：包含当前商品和不包含当前商品。我们比较这两种选择中能够得到的最大价值，并将其存储在数组dp中。

最后，我们返回数组dp的右下角元素，即为所求解的0-1背包问题的最大价值。

在这里插入图片描述

在这里插入图片描述

智谱清言：

0-1背包问题是一种典型的动态规划问题，其基本描述为：给定n种物品和一个容量为W的背包，物品i的重量是w[i]，其价值为v[i]，问应如何选择装入背包的物品，使得背包内物品的总价值最大，同时不超过背包的最大容量。

下面是使用Go语言实现的0-1背包问题的动态规划算法：

package main
import (
	"fmt"
)
// 动态规划解0-1背包问题
func knapsack(values []int, weights []int, W int, n int) int {
	// dp[i][w] 表示考虑前i件物品，背包容量为w时能够装下的最大价值
	dp := make([][]int, n+1)
	for i := range dp {
		dp[i] = make([]int, W+1)
	}
	// 初始化dp数组，可以处理边界情况
	for i := 0; i <= n; i++ {
		for w := 0; w <= W; w++ {
			if i == 0 || w == 0 {
				dp[i][w] = 0
			}
		}
	}
	// 填充dp数组
	for i := 1; i <= n; i++ {
		for w := 1; w <= W; w++ {
			if weights[i-1] <= w {
				// 可以选择放或者不放当前物品
				dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]]+values[i-1])
			} else {
				// 不能放当前物品，只能保持前i-1件物品的最大价值
				dp[i][w] = dp[i-1][w]
			}
		}
	}
	// 返回最大价值，即装满背包时的最大价值
	return dp[n][W]
}
// 辅助函数，用于比较两个int类型的值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func main() {
	// 示例数据
	values := []int{60, 100, 120}
	weights := []int{10, 20, 30}
	W := 50
	n := len(values)
	// 计算结果
	maxValue := knapsack(values, weights, W, n)
	fmt.Printf("The maximum value is %d\n", maxValue)
}

这段代码构建了一个二维数组dp，其中dp[i][w]保存的是考虑前i个物品，并且背包最大容量为w时能够得到的最大价值。算法的时间复杂度为O(nW)，其中n是物品数量，W是背包的最大容量。这是因为我们需要填充一个n+1行W+1列的二维数组。每个元素的计算只依赖于它左上角的元素和它的上一个元素，因此没有嵌套循环，直接计算即可。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工：

要设计一个运行时间为 O(nW) 的动态规划算法来解决 0-1 背包问题，我们可以使用一个一维数组 dp 来存储每个重量下的最大价值。这里的关键是要理解状态转移的过程，我们不是简单地遍历所有可能的重量组合，而是根据背包的剩余容量来更新 dp 数组。

以下是一个使用 Go 语言实现的 0-1 背包问题的动态规划解决方案：

package main

import "fmt"

// 0-1 Knapsack Problem solution with time complexity O(nW)
func knapsack(W int, weights []int, values []int) int {
    if len(weights) == 0 || W == 0 {
        return 0
    }

    dp := make([]int, W+1) // +1 to include the case where no items are taken

    for i := 1; i <= len(weights); i++ {
        for j := 1; j <= W; j++ {
            if weights[i-1] <= j {
                dp[j] = max(dp[j], dp[j-weights[i-1]]+values[i-1])
            } else {
                dp[j] = dp[j]
            }
        }
    }

    return dp[W]
}

// max returns the larger of two integers
func max(a, b int) int {
    if a >= b {
        return a
    }
    return b
}

func main() {
    W := 5 // Maximum weight that can be put in the backpack
    weights := []int{1, 2, 3} // Weights of the items
    values := []int{6, 10, 12} // Values of the items

    result := knapsack(W, weights, values)
    fmt.Println("Maximum value that can be obtained is:", result)
}

在这个实现中，我们首先检查是否至少有一个项目或背包容量不为零，如果没有，则返回零作为最大值。然后，初始化一个大小为 W+1 的 dp 数组，用于存储每个可能的重量下的最大价值。

接着，我们遍历每个项目，对于每个可能的背包重量，我们根据当前项目的重量来更新 dp 数组。如果当前项目的重量小于或等于背包的当前重量，我们就更新 dp[j] 为 dp[j-weights[i-1]]+values[i-1]，否则保持 dp[j] 不变。

最后，dp[W] 将包含背包能够容纳的最大价值。

注意这个算法的时间复杂度是 O(nW)，其中 n 是商品的数量，W 是背包的最大容量。这是因为我们需要对每个可能的背包重量和每个项目进行迭代。

在这里插入图片描述

在这里插入图片描述

灵小智：

下面是使用 Go 语言实现动态规划算法求解 0-1 背包问题的代码：

package main

import "fmt"

func knapsack(weights []int, values []int, W int) int {
	n := len(weights)
	dp := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]int, W+1)
	}

	for i := 1; i <= n; i++ {
		for j := 1; j <= W; j++ {
			if weights[i-1] > j {
				dp[i][j] = dp[i-1][j]
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]]+values[i-1])
			}
		}
	}

	return dp[n][W]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	weights := []int{2, 3, 4, 5}
	values := []int{3, 4, 5, 6}
	W := 8

	maxValue := knapsack(weights, values, W)
	fmt.Println("背包中能获得的最大价值为:", maxValue)
}

此代码通过动态规划的方式解决了 0-1 背包问题，其中 weights 列表存储每个商品的重量，values 列表存储每个商品的价值，W 是背包的最大重量。函数 knapsack 返回背包中能获得的最大价值。输出结果为背包中能获得的最大价值。

在这里插入图片描述

在这里插入图片描述

chatgpt：

以下是使用Go语言编写的动态规划算法求解0-1背包问题，运行时间复杂度为O(nW)：

package main

import (
	"fmt"
)

func knapSack(W int, wt []int, val []int, n int) int {
	dp := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]int, W+1)
	}

	for i := 0; i <= n; i++ {
		for w := 0; w <= W; w++ {
			if i == 0 || w == 0 {
				dp[i][w] = 0
			} else if wt[i-1] <= w {
				dp[i][w] = max(val[i-1]+dp[i-1][w-wt[i-1]], dp[i-1][w])
			} else {
				dp[i][w] = dp[i-1][w]
			}
		}
	}

	return dp[n][W]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	val := []int{60, 100, 120}
	wt := []int{10, 20, 30}
	W := 50
	n := len(val)

	maxValue := knapSack(W, wt, val, n)
	fmt.Println("Maximum value:", maxValue)
}

上述代码中，knapSack函数接受参数W（背包容量）、wt（商品重量数组）、val（商品价值数组）和n（商品数量），返回背包能够装下的最大价值。max函数用于返回两个整数中的较大值。

在示例中，给定3个商品的重量（wt）和价值（val），背包容量为50。根据动态规划算法，计算并输出背包能够装下的最大价值为220。

请注意，这只是一个基本的0-1背包问题求解算法示例。实际应用时，请根据具体需求进行相应修改。

在这里插入图片描述

在这里插入图片描述

kimi：

0-1 背包问题是一个经典的动态规划问题。在这个问题中，我们有 n 个商品，每个商品有一个重量 w[i] 和一个价值 v[i]。我们的目标是选择一些商品放入一个最大容量为 W 的背包中，使得背包中商品的总价值最大。

动态规划算法使用一个二维数组 dp[i][j] 来存储前 i 个商品放入容量为 j 的背包时能够获得的最大价值。状态转移方程如下：

dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + v[i]) for all 1 <= i <= n and 0 <= j <= W

以下是使用 Go 语言实现的 0-1 背包问题的动态规划算法：

package main

import (
	"fmt"
)

func knapsack(W int, weights []int, values []int) int {
	n := len(values)
	dp := make([][]int, n+1)
	for i := 0; i <= n; i++ {
		dp[i] = make([]int, W+1)
	}

	for i := 1; i <= n; i++ {
		for j := 0; j <= W; j++ {
			if j >= weights[i-1] {
				dp[i][j] = max(dp[i-1][j], dp[i-1][j-weights[i-1]]+values[i-1])
			} else {
				dp[i][j] = dp[i-1][j]
			}
		}
	}

	return dp[n][W]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	W := 50 // 小偷能放进背包的最大商品总重量
	weights := []int{10, 20, 30}
	values := []int{60, 100, 120}
	maxValue := knapsack(W, weights, values)
	fmt.Printf("Maximum value that can be put in the knapsack: %d\n", maxValue)
}

在这个实现中，我们首先定义了一个 knapsack 函数来执行动态规划算法。我们初始化一个二维数组 dp，并使用两层循环来填充它。对于每个商品 i 和每个背包容量 j，我们根据状态转移方程来更新 dp[i][j] 的值。最后，我们返回 dp[n][W]，即前 n 个商品放入容量为 W 的背包时能够获得的最大价值。

这个算法的时间复杂度是 O(nW)，因为它需要填充一个 n+1 x W+1 的二维数组。其中 n 是商品的数量，W 是背包的最大容量。

在这里插入图片描述

在这里插入图片描述

混元：

以下是使用 Go 语言实现的 0-1 背包问题的动态规划算法：

package main

import (
	"fmt"
)

func knapsack(W int, weights []int, values []int, n int) int {
	// 初始化动态规划表
	dp := make([][]int, n+1)
	for i := range dp {
		dp[i] = make([]int, W+1)
	}

	// 动态规划求解
	for i := 1; i <= n; i++ {
		for w := 0; w <= W; w++ {
			if weights[i-1] <= w {
				dp[i][w] = max(dp[i-1][w], dp[i-1][w-weights[i-1]]+values[i-1])
			} else {
				dp[i][w] = dp[i-1][w]
			}
		}
	}

	return dp[n][W]
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	W := 10
	weights := []int{2, 3, 4, 5, 9}
	values := []int{3, 4, 5, 8, 10}
	n := len(weights)

	result := knapsack(W, weights, values, n)
	fmt.Println("最大价值为：", result)
}

这个算法的时间复杂度为 O(nW)，其中 n 为商品数量，W 为小偷能放进背包的最大商品总重量。

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

Supervisor，一个超酷的 Python 库！

Supervisor，一个超酷的 Python 库！

大家好&#xff0c;今天为大家分享一个超酷的 Python 库 - supervisor。 Github地址&#xff1a;https://github.com/Supervisor/supervisor 在大型项目中&#xff0c;经常需要管理多个进程&#xff0c;确保它们能够稳定运行并协同工作。Python提供了许多工具和库来帮助实现进…
阅读更多...
使用Minio搭建文件服务器

使用Minio搭建文件服务器

Minio是一个开源的对象存储服务器&#xff0c;可以用来存储和管理大规模的数据。我们可以用它来存储图片或者视频资源。 minio和阿里云&#xff08;腾讯云、百度云等&#xff09;oss对比 托管方式&#xff1a;MinIO 是一个开源的对象存储系统&#xff0c;可以在自己的服务器或…
阅读更多...
记录Mysql主从复制-读写分离原理

记录Mysql主从复制-读写分离原理

在实际生产环境中&#xff0c;一台MySQL服务器同时对数据库读写&#xff0c;往往满足不了高并发的需求&#xff0c;因此我们可以使用主从复制的方式来实现数据同步&#xff0c;再通过读写分离的手段提高MySQL并发负载能力。 MySQL主从复制原理 如图&#xff1a; &#xff08;1…
阅读更多...
C语言例3-18：使用关系表达式的例子

C语言例3-18：使用关系表达式的例子

关系表达式的一般形式&#xff1a; 表达式 关系运算符 表达式 最初代码如下&#xff1a; #include<stdio.h> int main(void) {int i3,j4,k5;float f11.0, f22.1;char c1a, c2d; //a(97) d(100)printf("i>j 的结果为&#xff1a…
阅读更多...
B/S基于云计算的云HIS智慧医院管理系统源码带电子病历编辑器

B/S基于云计算的云HIS智慧医院管理系统源码带电子病历编辑器

目录 一、系统概述 二、开发环境 三、系统功能 1、门诊部分 2、住院部分 3、电子病历 4、药物管理 5、统计报表 6、综合维护 7、运营运维 云HIS系统&#xff1a;病案首页 云his系统源码 SaaS应用 功能易扩 统一对外接口管理 现如今&#xff0c;大数据、云计算、移动…
阅读更多...
中霖教育：考注册会计师报班能提高通过率吗?

中霖教育：考注册会计师报班能提高通过率吗?

CPA考试涵盖了会计、审计、税法及相关的知识,这些知识点不仅繁多而且专业性强&#xff0c;对于自学能力较弱或时间不足的考生来说&#xff0c;有一定的挑战性。在这种情况下&#xff0c;报班提供了系统化和结构化的学习方案&#xff0c;有助于考生更快地掌握考点和难点。 经验…
阅读更多...
分类预测 | Matlab实现GSWOA-KELM混合策略改进的鲸鱼优化算法优化核极限学习机的数据分类预测

分类预测 | Matlab实现GSWOA-KELM混合策略改进的鲸鱼优化算法优化核极限学习机的数据分类预测

分类预测 | Matlab实现GSWOA-KELM混合策略改进的鲸鱼优化算法优化核极限学习机的数据分类预测 目录 分类预测 | Matlab实现GSWOA-KELM混合策略改进的鲸鱼优化算法优化核极限学习机的数据分类预测效果一览基本介绍程序设计参考资料 效果一览 基本介绍 GSWOA-KELM分类&#xff0…
阅读更多...
位运算#蓝桥杯

位运算#蓝桥杯

位运算#蓝桥杯 文章目录 位运算#蓝桥杯1、小蓝学位运算2、异或森林3、位移4、笨笨的机器人5、博弈论 1、小蓝学位运算 #include<bits/stdc.h> using namespace std; using LL long long; const LL N 1e97; template<int kcz> struct ModInt { #define T (*this)…
阅读更多...
1997-2022年各省市场化指数及分项指数（初始数据+计算代码+结果）

1997-2022年各省市场化指数及分项指数（初始数据+计算代码+结果）

1997-2022年各省市场化指数及分项指数&#xff08;初始数据计算代码结果&#xff09; 1、时间&#xff1a;1997-2022年 2、来源&#xff1a;2019年之前的数据来源于市场化指数报告&#xff0c;其中2020年之后的数据根据历年数据拓展所得 3、指标&#xff1a;province、year、…
阅读更多...
【办公类-40-01】20240311 用Python将MP4转MP3提取音频 （家长会系列一）

【办公类-40-01】20240311 用Python将MP4转MP3提取音频 （家长会系列一）

作品展示&#xff1a; 背景需求&#xff1a; 马上就要家长会&#xff0c;我负责做会议前的照片滚动PPT&#xff0c;除了大量照片视频&#xff0c;还需要一个时间很长的背景音乐MP3 一、下载“歌曲串烧” 装一个IDM 下载三个“串烧音乐MP4”。 代码展示 家长会背景音乐: 歌曲串…
阅读更多...
Windows 安装 Ubuntu 子系统

Windows 安装 Ubuntu 子系统

大约是22年的时候&#xff0c;开始玩这个windows的子系统&#xff0c;当时安装比较顺利。最近也是想看看linux&#xff0c;就在新电脑上装了个ubuntu&#xff0c;记录安装过程。 1.Microsoft Store 搜索 ubuntu&#xff0c;先看评价&#xff1a;很多报错&#xff0c;先不要慌 2…
阅读更多...
C语言——动态内存分配

C语言——动态内存分配

前言&#xff1a;通过前面的学习&#xff0c;我们知道C语言中在内存中开辟空间的方法有&#xff1a;变量和数组。既然拥有了开辟空间的方法&#xff0c;我们为什么还要学习动态内存分配呢&#xff1f; int val 20; //在内存中开辟四个字节的空间 int arr[10] { 0 }; //在内…
阅读更多...
AI探索实践16 - Typescript开发AI应用8：为大模型增加记忆(Memory)

AI探索实践16 - Typescript开发AI应用8：为大模型增加记忆(Memory)

大家好&#xff0c;我是feng&#xff0c;欢迎关注公众号和我一起探索。如果文章对你有所启发&#xff0c;请为我点赞、转发以及在下方留言自己的理解&#xff01; 每次发文章都看到不少人收藏。我自己也有这个习惯&#xff0c;但是基本上收藏起来的东西都没再打开过。哪怕再遇到…
阅读更多...
Vite为什么比Webpack快

Vite为什么比Webpack快

一、引言 主流的前端构建工具包括以下几种&#xff1a; Webpack&#xff1a;当下最热门的前端资源模块化管理和打包工具。它能够将许多松散的模块按照依赖和规则打包成符合生产环境部署的前端资源。同时&#xff0c;Webpack还支持代码分割&#xff0c;可以按需加载模块&#…
阅读更多...
普林斯顿算法讲义（四）

普林斯顿算法讲义（四）

原文&#xff1a;普林斯顿大学算法课程 译者&#xff1a;飞龙 协议&#xff1a;CC BY-NC-SA 4.0 6.1 事件驱动模拟 原文&#xff1a;algs4.cs.princeton.edu/61event 译者&#xff1a;飞龙 协议&#xff1a;CC BY-NC-SA 4.0 本章节正在建设中。 根据弹性碰撞的法则使用事件驱动…
阅读更多...
STM32使用常见错误合集（正在更新版）

STM32使用常见错误合集（正在更新版）

本文章记录一些学习STM32的一些错误问题 一、编译、烧录类问题 1、烧录不成功&#xff0c;Keil提示RDDI-DAP Error【场景&#xff1a;PWM驱动直流电机】 解决方案&#xff1a;将电机断开再进行烧录&#xff0c;断开后就可以美美烧录不报错啦~ 二、Keil使用问题 1、打开一个…
阅读更多...
中宣部防沉迷系统PHP版本(管局防沉迷验证-PHP-全版本-接口测试样例)

中宣部防沉迷系统PHP版本(管局防沉迷验证-PHP-全版本-接口测试样例)

现在对接游戏&#xff0c;无论是登录还是支付都是要去对接防沉迷实名认证接口&#xff0c;但前期的话你要登录网络游戏防沉迷实名认证系统进行接口测试&#xff0c;$appid &#xff0c;$bizId&#xff0c;$key去接口测试页面找&#xff08;正式上线在密钥管理&#xff09;&…
阅读更多...
2024.3.14

2024.3.14

1、成员函数版本实现算术运算符的重载 全局函数版本实现算术运算符的重载 #include <iostream>using namespace std;class Team {friend const Team operator-(const Team &t1, const Team &t2); private:int a;int b; public:Team(){}Team(int a, int b):a(a…
阅读更多...
建筑安全监测系统解决方案-GNSS位移监测站

建筑安全监测系统解决方案-GNSS位移监测站

方案背景 房屋建筑安全是人们生产、经营、居住、学习、娱乐等经济生活和人身安全的基本保证。近年来&#xff0c;房屋安全事故频发&#xff0c;造成了人员伤亡和极大财产损失。因此&#xff0c;在保护居民的人身安全和财产安全方面&#xff0c;房屋建筑安全管理就显得尤为重要…
阅读更多...
python--字符串切片和常用的写法

python--字符串切片和常用的写法

python--字符串切片和常用的写法 正序切片格式注意点 倒序切片格式 字符串运算字符串转义字符串常用方法大小写相关的统计相关的拆分&替换字符串连接&#xff08;面试&#xff09;字符串格式化 正序切片 格式 str1[起始索引:结束索引]左闭右开&#xff08;取左边下标的值&…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023