文心一言 VS 讯飞星火 VS chatgpt （206）-- 算法导论15.4 3题

三、设计 LCS-LENGTH的带备忘的版本，运行时间为O(mn)。需要写代码的时候，请用go语言。

文心一言，代码正常运行：

LCS-LENGTH（Longest Common Subsequence Length）问题的带备忘的版本通常指的是使用动态规划（Dynamic Programming, DP）和备忘录（Memoization）来优化算法性能，避免重复计算。通过维护一个表（即“备忘录”）来存储已经计算过的子问题的解，从而在解决新问题时可以直接查找已存储的结果，而不是重新计算。

以下是使用Go语言实现的一个带备忘的LCS-LENGTH算法的示例。在这个示例中，lcsLength 函数计算两个字符串的最长公共子序列长度，并且使用一个二维数组 memo 来存储子问题的解，其中 memo[i][j] 存储的是 str1 的前 i 个字符和 str2 的前 j 个字符的最长公共子序列长度。

package main  
  
import (  
	"fmt"  
)  
  
func lcsLength(str1, str2 string) int {  
	m, n := len(str1), len(str2)  
	memo := make([][]int, m+1)  
	for i := range memo {  
		memo[i] = make([]int, n+1)  
	}  
  
	for i := 1; i <= m; i++ {  
		for j := 1; j <= n; j++ {  
			if str1[i-1] == str2[j-1] {  
				memo[i][j] = memo[i-1][j-1] + 1  
			} else {  
				memo[i][j] = max(memo[i-1][j], memo[i][j-1])  
			}  
		}  
	}  
  
	return memo[m][n]  
}  
  
func max(a, b int) int {  
	if a > b {  
		return a  
	}  
	return b  
}  
  
func main() {  
	str1 := "ABCDEFG"  
	str2 := "XYZABCDEFGHIJKL"  
	length := lcsLength(str1, str2)  
	fmt.Printf("The length of the Longest Common Subsequence is: %d\n", length)  
}

在这个实现中，lcsLength 函数首先初始化一个 (m+1) x (n+1) 的二维数组 memo，其中 m 和 n 分别是两个输入字符串 str1 和 str2 的长度。然后，它使用两个嵌套的循环来遍历 str1 和 str2 的所有字符组合。

如果 str1 的第 i 个字符和 str2 的第 j 个字符相同，则最长公共子序列的长度加一，即 memo[i][j] = memo[i-1][j-1] + 1。如果不同，则最长公共子序列的长度是去掉 str1 的第 i 个字符后的最长公共子序列和去掉 str2 的第 j 个字符后的最长公共子序列中的较大值，即 memo[i][j] = max(memo[i-1][j], memo[i][j-1])。

最后，函数返回 memo[m][n]，即两个字符串的最长公共子序列的长度。

请注意，这个实现的时间复杂度是 O(mn)，其中 m 和 n 分别是两个输入字符串的长度。这是因为我们需要填充一个 m x n 的表，而每个表项的计算时间是常数时间。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

讯飞星火，代码正常运行：

在Go语言中，我们可以使用动态规划来解决这个问题。以下是实现LCS-LENGTH的带备忘的版本的代码：

package main
import "fmt"

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

func lcsLength(X, Y []int) int {
    m := len(X)
    n := len(Y)
    c := make([][]int, m+1)
    for i := range c {
        c[i] = make([]int, n+1)
    }
    for i := 0; i <= m; i++ {
        for j := 0; j <= n; j++ {
            if i == 0 || j == 0 {
                c[i][j] = 0
            } else if X[i-1] == Y[j-1] {
                c[i][j] = c[i-1][j-1] + 1
            } else {
                c[i][j] = max(c[i-1][j], c[i][j-1])
            }
        }
    }
    return c[m][n]
}

func main() {
    X := []int{1, 3, 4, 5, 6, 7, 7, 8}
    Y := []int{2, 3, 5, 6, 7, 8, 9, 10}
    fmt.Println("Length of LCS is", lcsLength(X, Y))
}

在这个程序中，我们首先定义了一个二维数组c，用于存储子问题的解。然后，我们遍历两个输入序列，如果当前位置的元素相同，则该位置的LCS长度为左上角元素的LCS长度加一；否则，该位置的LCS长度为左边元素和上边元素中较大的那个LCS长度。最后，右下角的元素就是整个序列的LCS长度。

在这里插入图片描述

在这里插入图片描述

360智脑，代码不能运行：

以下是一个使用Go语言实现的LCS-Length带备忘的版本：

package main

func lcsLength(memo map[int][int]int, X string, Y string, m int, n int) int {
    if m == 0 || n == 0 {
        return 0
    }

    if v, ok := memo[m][n]; ok {
        return v
    }

    if X[m-1] == Y[n-1] {
        memo[m][n] = lcsLength(memo, X, Y, m-1, n-1) + 1
    } else {
        memo[m][n] = max(lcsLength(memo, X, Y, m-1, n), lcsLength(memo, X, Y, m, n-1))
    }

    return memo[m][n]
}

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

func main() {
    X := "ABCBDAB"
    Y := "BDCAB"
    memo := make(map[int][int]int)
    m := len(X)
    n := len(Y)
    fmt.Println(lcsLength(memo, X, Y, m, n))
}

在这个代码中，我们使用了一个备忘录（memo）来存储之前计算过的LCS长度。当我们计算LCS长度时，我们首先检查备忘录中是否已经有这个值。如果有，我们就直接返回它；如果没有，我们就计算它，并将其存储在备忘录中。

这个算法的运行时间为O(mn)，因为我们在计算LCS长度时，最多需要遍历X和Y字符串的每个字符。

在这里插入图片描述

在这里插入图片描述

智谱清言，代码正常运行：

为了设计一个运行时间为O(mn)的LCS-LENGTH算法，我们可以使用动态规划(DP)技术，并辅以带备忘的递归方法来避免重复计算。在下面给出的Go语言代码中，我们将计算两个字符串str1和str2的最长公共子序列的长度。

package main
import (
	"fmt"
)
// LCSLength 计算两个字符串的最长公共子序列的长度
// 使用带备忘的递归方法
func LCSLength(str1, str2 string) int {
	// 创建一个二维切片来保存子问题的结果
	// dp[i][j] 表示str1的前i个字符与str2的前j个字符的LCS长度
	dp := make([][]int, len(str1)+1)
	for i := range dp {
		dp[i] = make([]int, len(str2)+1)
	}
	// 初始化dp数组
	for i := 0; i <= len(str1); i++ {
		for j := 0; j <= len(str2); j++ {
			if i == 0 || j == 0 {
				dp[i][j] = 0
			}
		}
	}
	// 递归计算LCS长度，同时更新dp数组
	return recursiveLCSLength(str1, str2, 0, 0, dp)
}
// recursiveLCSLength 递归计算最长公共子序列的长度
// 同时更新dp数组以避免重复计算
func recursiveLCSLength(str1, str2 string, i, j int, dp [][]int) int {
	// 检查是否已经计算过这个子问题
	if dp[i][j] != 0 {
		return dp[i][j]
	}
	// 如果i或j为0，那么LCS长度为0
	if i == 0 || j == 0 {
		dp[i][j] = 0
		return 0
	}
	// 如果str1[i-1] == str2[j-1]，那么当前字符是LCS的一部分
	if str1[i-1] == str2[j-1] {
		dp[i][j] = 1 + recursiveLCSLength(str1, str2, i-1, j-1, dp)
	} else {
		// 否则，取左侧或上侧的LCS长度中的较大值
		dp[i][j] = max(recursiveLCSLength(str1, str2, i-1, j, dp), recursiveLCSLength(str1, str2, i, j-1, dp))
	}
	return dp[i][j]
}
// max 返回两个整数中的较大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
func main() {
	str1 := "ABCBDAB"
	str2 := "BDCAB"
	fmt.Println("The length of LCS is:", LCSLength(str1, str2))
}

这段代码定义了一个LCSLength函数，它使用一个二维切片dp来存储子问题的解，并且通过递归函数recursiveLCSLength来计算最长公共子序列的长度。递归函数会在每次需要计算相同子问题时，检查是否已经在dp中存储了结果，以避免重复计算。

main函数中给出了一个例子，计算字符串"ABCBDAB"和"BDCAB"的最长公共子序列的长度，并打印结果。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

天工，代码正常运行：

Certainly! Below is an implementation of the LCS problem with memoization in Go that runs in O(mn) time, where m and n are the lengths of the two input strings. This implementation uses a二维数组 to store the results of subproblems, avoiding重复计算.

package main

import "fmt"

// LCSMemo computes the length of the longest common subsequence between X and Y using memoization.
func LCSMemo(X, Y string) int {
	m, n := len(X), len(Y)
	dp := make([][]int, m+1)
	for i := range dp {
		dp[i] = make([]int, n+1)
	}

	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if X[i-1] == Y[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
			}
		}
	}

	return dp[m][n]
}

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

func main() {
	X := "AGGTAB"
	Y := "GXTXAYB"
	length := LCSMemo(X, Y)
	fmt.Printf("Length of LCS: %d\n", length)
}

To use this code, simply run it with the Go runtime and it will output the length of the longest common subsequence between the two given strings. The max function is used to handle the comparison of integers, as int in Go does not guarantee a specific signedness.

在这里插入图片描述

在这里插入图片描述

灵小智，代码正常运行：

下面是用Go语言编写的带备忘录的最长公共子序列（LCS）问题的代码示例：

package main

import (
	"fmt"
)

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

func lcsLengthMemoized(X, Y string, m, n int, memo [][]int) int {
	if m == 0 || n == 0 {
		return 0
	}

	if memo[m][n] != -1 {
		return memo[m][n]
	}

	if X[m-1] == Y[n-1] {
		memo[m][n] = 1 + lcsLengthMemoized(X, Y, m-1, n-1, memo)
		return memo[m][n]
	}

	memo[m][n] = max(lcsLengthMemoized(X, Y, m-1, n, memo), lcsLengthMemoized(X, Y, m, n-1, memo))
	return memo[m][n]
}

func lcsLength(X, Y string) int {
	m := len(X)
	n := len(Y)

	memo := make([][]int, m+1)
	for i := range memo {
		memo[i] = make([]int, n+1)
		for j := range memo[i] {
			memo[i][j] = -1
		}
	}

	return lcsLengthMemoized(X, Y, m, n, memo)
}

func main() {
	X := "ABCBDAB"
	Y := "BDCAB"

	fmt.Printf("Length of LCS: %d\n", lcsLength(X, Y))
}

在这个代码中，我们使用了备忘录（memo）来保存已计算过的子问题的结果，以避免重复计算。通过将已计算过的结果存储在备忘录中，我们可以将算法的运行时间从指数级别降低到线性级别。这样，算法的运行时间为O(mn)，其中m和n分别是字符串X和Y的长度。

以上是用Go语言编写的带备忘录的LCS问题的代码示例，希望对你有帮助！

在这里插入图片描述

在这里插入图片描述

chatgpt，代码正常运行：

当设计LCS-LENGTH函数的带备忘的版本时，可以使用动态规划的思想。下面是用Go语言实现的代码：

package main

import (
	"fmt"
)

func lcsLengthMemo(X, Y string) int {
	m := len(X)
	n := len(Y)

	// 创建并初始化备忘录
	memo := make([][]int, m+1)
	for i := 0; i <= m; i++ {
		memo[i] = make([]int, n+1)
		for j := 0; j <= n; j++ {
			memo[i][j] = -1
		}
	}

	var lcs func(int, int) int
	lcs = func(i, j int) int {
		if memo[i][j] != -1 { // 如果已经计算过，直接返回备忘录中的值
			return memo[i][j]
		}
		
		if i == 0 || j == 0 { // 边界条件，其中一个字符串为空
			memo[i][j] = 0
			return 0
		}

		if X[i-1] == Y[j-1] { // 当前字符匹配成功，继续向前匹配
			memo[i][j] = lcs(i-1, j-1) + 1
			return memo[i][j]
		} else { // 当前字符不匹配，取两种情况下的最大值
			left := lcs(i-1, j)
			top := lcs(i, j-1)
			if left > top {
				memo[i][j] = left
			} else {
				memo[i][j] = top
			}
			return memo[i][j]
		}
	}

	return lcs(m, n)
}

func main() {
	X := "ABCBDAB"
	Y := "BDCAB"
	fmt.Println("LCS长度:", lcsLengthMemo(X, Y))
}

该代码使用了备忘录来存储已经计算过的子问题的结果，避免重复计算。通过递归方式进行动态规划，从后往前匹配字符串，并记录最长公共子序列的长度。运行时间复杂度为O(mn)。

在这里插入图片描述

在这里插入图片描述

kimi，代码正常运行：

在 Go 语言中，设计一个带有备忘（Memoization）的 LCS-LENGTH 版本，可以通过创建一个额外的二维切片来存储已经计算过的子问题的解。这样，当我们需要计算一个新的子问题时，我们首先检查这个解是否已经被计算过。如果已经计算过，我们可以直接使用这个解，而不需要重新计算，从而提高算法的效率。

以下是带有备忘的 LCS-LENGTH 函数的 Go 语言实现：

package main

import (
	"fmt"
)

// LCS-LENGTH 函数计算两个序列的最长公共子序列的长度
func LCSLength(x, y []int) int {
	m, n := len(x), len(y)
	memo := make([][]int, m+1)
	for i := range memo {
		memo[i] = make([]int, n+1)
	}

	return lcsLengthMemo(x, y, m, n, memo)
}

// lcsLengthMemo 是 LCS-LENGTH 的递归实现，带有备忘
func lcsLengthMemo(x, y []int, m, n int, memo [][]int) int {
	if m == 0 || n == 0 {
		return 0
	}

	// 检查解是否已经在备忘数组中
	if memo[m][n] != 0 {
		return memo[m][n]
	}

	if x[m-1] == y[n-1] {
		// 如果当前元素相同，递归计算去掉这两个元素后的子问题的解
		memo[m][n] = 1 + lcsLengthMemo(x, y, m-1, n-1, memo)
	} else {
		// 如果当前元素不同，分别计算两种情况的解，并取最大值
		memo[m][n] = max(
			lcsLengthMemo(x, y, m-1, n, memo),
			lcsLengthMemo(x, y, m, n-1, memo),
		)
	}

	return memo[m][n]
}

// max 返回两个整数中的最大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func main() {
	x := []int{1, 0, 0, 1, 0, 1, 0, 1}
	y := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}

	length := LCSLength(x, y)
	fmt.Printf("Length of LCS: %d\n", length)
}

在这个实现中，LCSLength 函数是用户调用的接口，它初始化备忘数组并调用 lcsLengthMemo 函数。lcsLengthMemo 函数是递归实现，它使用备忘数组来避免重复计算。这个算法的时间复杂度是 O(m * n)，因为每个子问题只计算一次，并且我们使用 O(m * n) 的空间来存储备忘数组。

在这里插入图片描述

在这里插入图片描述

混元，代码正常运行：

带备忘的 LCS-LENGTH 算法是一种动态规划方法，用于计算两个字符串的最长公共子序列的长度。以下是使用 Go 语言实现的带备忘的 LCS-LENGTH 算法：

package main

import (
	"fmt"
)

func lcsLengthMemo(x, y string, m, n int, memo [][]int) int {
	if m == 0 || n == 0 {
		return 0
	}

	if memo[m][n] != -1 {
		return memo[m][n]
	}

	if x[m-1] == y[n-1] {
		memo[m][n] = 1 + lcsLengthMemo(x, y, m-1, n-1, memo)
	} else {
		memo[m][n] = max(lcsLengthMemo(x, y, m-1, n, memo), lcsLengthMemo(x, y, m, n-1, memo))
	}

	return memo[m][n]
}

func lcsLength(x, y string) int {
	m, n := len(x), len(y)
	memo := make([][]int, m+1)
	for i := range memo {
		memo[i] = make([]int, n+1)
		for j := range memo[i] {
			memo[i][j] = -1
		}
	}

	return lcsLengthMemo(x, y, m, n, memo)
}

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

func main() {
	x := "ABCBDAB"
	y := "BDCAB"
	fmt.Printf("The length of the LCS is: %d\n", lcsLength(x, y))
}

这个实现首先创建一个二维数组 memo 用于存储已经计算过的子问题的解。lcsLengthMemo 函数是一个递归函数，用于计算两个字符串的最长公共子序列的长度。当递归到基本情况时，它会返回 0。如果当前子问题已经计算过，它会直接返回已经计算的结果。否则，它会计算当前子问题的解，并将其存储在备忘录中，然后返回解。

lcsLength 函数是一个包装函数，用于初始化备忘录并调用 lcsLengthMemo 函数。最后，main 函数调用 lcsLength 函数并打印结果。

在这里插入图片描述

在这里插入图片描述

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

springboot+vue学生网上请假系统

springboot+vue学生网上请假系统

学生网上请假系统 摘要 随着信息技术在管理上越来越深入而广泛的应用&#xff0c;管理信息系统的实施在技术上已逐步成熟。本文介绍了学生网上请假系统的开发全过程。通过分析学生网上请假系统管理的不足&#xff0c;创建了一个计算机管理学生网上请假系统的方案。文章介绍了…
阅读更多...
社区店经营全攻略：为何成为创业者的首选？

社区店经营全攻略：为何成为创业者的首选？

在当今的创业环境中&#xff0c;社区店越来越受到创业者的关注和青睐。 作为一名开鲜奶吧5年的创业者&#xff0c;我见证了无数的实体项目&#xff0c;这篇文章&#xff0c;为大家深入解析社区店的优势&#xff0c;以及为何它成为了众多创业者的首选。 社区店的主要优势在于以…
阅读更多...
自注意力机制（Self-Attention）

自注意力机制（Self-Attention）

注意&#xff1a;本文引用自专业人工智能社区Venus AI 更多AI知识请参考原站&#xff08;【http://www.aideeplearning.cn】&#xff09; Transformer模型中最关键部分就是自注意力&#xff08;Self-Attention&#xff09;机制&#xff0c;正如 Transformer 的论文的标题是“…
阅读更多...
ConcurrentHashMap的演进：从Java 8之前到Java 17的实现原理深度剖析

ConcurrentHashMap的演进：从Java 8之前到Java 17的实现原理深度剖析

目录 一、引言二、Java 8之前的ConcurrentHashMap1、内部结构与初始化2、Segment类3、并发控制4、扩容与重哈希5、总结 三、Java 8中的ConcurrentHashMap1、数据结构2、并发控制2.1. CAS操作2.2. synchronized同步块 3、哈希计算与定位4、扩容与重哈希5、总结 四、Java 17中的C…
阅读更多...
Docker知识点总结

Docker知识点总结

二、Docker基本命令&#xff1a; Docker支持CentOs 6 及以后的版本; CentOs7系统可以直接通过yum进行安装&#xff0c;安装前可以 1、查看一下系统是否已经安装了Docker: yum list installed | grep docker 2、安装docker&#xff1a; yum install docker -y -y 表示自动确认…
阅读更多...
安装Realtek Audio Driver失败[Error Code：-0001]

安装Realtek Audio Driver失败[Error Code：-0001]

安装Realtek Audio Driver失败[Error Code&#xff1a;-0001] 首先来看一下我们遇到的问题GPT4的推荐解决方法&#xff08;流水账&#xff09;笔者自己真实有效的解决办法 首先来看一下我们遇到的问题 描述&#xff1a;在笔记本更新完电脑之后&#xff0c;没有自带声音驱动。然…
阅读更多...
【LeetCode】升级打怪之路 Day 11：栈的应用、单调栈

【LeetCode】升级打怪之路 Day 11：栈的应用、单调栈

今日题目&#xff1a; Problem 1: 栈的应用 155. 最小栈 | LeetCode20. 有效的括号 | LeetCode150. 逆波兰表达式求值 | LeetCode Problem 2: 单调栈 496. 下一个更大元素 I739. 每日温度503. 下一个更大元素 II 目录 Problem 1&#xff1a;栈 - “先进后出”的应用LC 155. 最…
阅读更多...
2024龙年特别篇 -- 魔法指针 之 指针变量

2024龙年特别篇 -- 魔法指针 之 指针变量

目录 ​编辑 字符指针变量 字符指针 字符数组 关于字符数组的试题 数组指针变量 数组指针 利用指针数组打印数组 打印二维数组 数组作为形参 当形参为指针时&#xff08;指针数组&#xff09; 函数指针变量 利用函数实现加法输出的多种方式 字符指针变量 字符指针 char …
阅读更多...
[NSSCTF 2nd] web复现

[NSSCTF 2nd] web复现

1.php签到 <?phpfunction waf($filename){$black_list array("ph", "htaccess", "ini");$ext pathinfo($filename, PATHINFO_EXTENSION);foreach ($black_list as $value) {if (stristr($ext, $value)){return false;}}return true; }if(i…
阅读更多...
CKA考生注意：这些Deployment要点能助你一臂之力！

CKA考生注意：这些Deployment要点能助你一臂之力！

往期精彩文章 : 提升CKA考试胜算&#xff1a;一文带你全面了解RBAC权限控制&#xff01;揭秘高效运维&#xff1a;如何用kubectl top命令实时监控K8s资源使用情况&#xff1f;CKA认证必备&#xff1a;掌握k8s网络策略的关键要点提高CKA认证成功率&#xff0c;CKA真题中的节点维…
阅读更多...
蓝桥杯集训·每日一题2024 （前缀和）

蓝桥杯集训·每日一题2024 （前缀和）

笔记&#xff1a; 例题&#xff1a; #include<bits/stdc.h> using namespace std; const int N 5000010; char str[N]; int s[N]; int main(){int t;cin>>t;for(int a1;a<t;a){int n;cin>>n;scanf("%s",str1);for(int i1;i<n;i){s[i]s[i-1]…
阅读更多...
重磅！交通领域顶级会议TRB会议将进行重大改革

重磅！交通领域顶级会议TRB会议将进行重大改革

美国交通研究委员会年会&#xff08;Transportation Research Board annual meeting,以下简称TRB会议&#xff09;是由美国交通研究委员会举办的交通领域的国际顶级会议。该会议每年举办一次&#xff0c;在华盛顿特区召开。TRB会议是交通研究领域知名度最高的学术会议之一&…
阅读更多...
AI又进化了

AI又进化了

B站&#xff1a;啥都会一点的研究生公众号&#xff1a;啥都会一点的研究生 一直想做但没做的板块&#xff0c;整理一段时间内AI领域的前沿动态&#xff08;符合大多粉丝研究领域/感兴趣方向&#xff09;&#xff0c;了解了解外面世界发展成啥样了&#xff0c;一起看看吧~ 谷歌…
阅读更多...
跟 AI 学 StarRocks：简介

跟 AI 学 StarRocks：简介

因为要支持公司的 BI 建设&#xff0c;团队引入了 StarRocks 数据库&#xff0c;此前我没有了解过此项技术&#xff0c;不过因为有架构师引入了此项技术栈&#xff0c;就顺便学习一下。 一、什么是 MPP 数据库&#xff1f; MPP 数据库指的是大规模并行处理&#xff08;Massiv…
阅读更多...
Hololens 2应用开发系列（2）——MRTK基础知识及配置文件配置（上）

Hololens 2应用开发系列（2）——MRTK基础知识及配置文件配置（上）

Hololens 2应用开发系列&#xff08;2&#xff09;——MRTK基础知识及配置文件配置 一、前言二、MRTK基础知识2.1 MRTK概述2.2 MRTK运行逻辑2.3 MRTK配置文件介绍2.4 MRTK服务 三、配置文件使用3.1 总配置文件3.2 相机配置3.3 其他配置 参考文献 一、前言 在前面的文章中&…
阅读更多...
DDR5 新特性概述

DDR5 新特性概述

主页&#xff1a; 元存储博客 文章目录 前言1. SDR 与 DDR2. DDR5 的新特点总结 前言 DDR5 带来更快的处理速度和更大的存储空间&#xff0c;为云计算、大数据等领域的发展提供了强有力的支持。 1. SDR 与 DDR single data rate&#xff0c; 1 个时钟周期做一次数据传输 do…
阅读更多...
更改elementui的箭头图片以及位置

更改elementui的箭头图片以及位置

//更改箭头位置 .el-tree-node__content > .el-tree-node__expand-icon {position: absolute;right: 12px; }//更改箭头图片 .el-tree-node__expand-icon {transform: rotate(-90deg); } .el-tree-node__expand-icon.expanded {transform: rotate(0deg); } // 有子节点 且已…
阅读更多...
使用QEMU搭建U-Boot+LinuxKernel+busybox+NFS嵌入式开发环境

使用QEMU搭建U-Boot+LinuxKernel+busybox+NFS嵌入式开发环境

目录 0.课程大纲1.为什么要使用QEMU学习嵌入式QEMU简介使用QEMU可以做哪些事情?当前嵌入式行业现状如何适应这种变化使用QEMU学习嵌入式有哪些好处?驱动开发技能为什么要学习Linux 2.搭建嵌入式开发基本环境2.1.安装u-boot-tools2.2.安装交叉编译工具什么是ABI和EABI 3.QEMU安…
阅读更多...
DSI2协议之BTA行为理解

DSI2协议之BTA行为理解

概念： DSI协议spec支持总线控制权在master和slave之间发生交换，即通过bus turn around来实现； BUS TURN AROUND： BTA 的实现是通过controller—>cdphy的turnrequest信号来实现； 关于控制器发出turnrequest给phy，phy通过lvds/trio线输出turnaround sequence如下图中…
阅读更多...
C++基于多设计模式下的同步异步日志系统day3

C++基于多设计模式下的同步异步日志系统day3

C基于多设计模式下的同步&异步日志系统day3 &#x1f4df;作者主页&#xff1a;慢热的陕西人 &#x1f334;专栏链接&#xff1a;C基于多设计模式下的同步&异步日志系统 &#x1f4e3;欢迎各位大佬&#x1f44d;点赞&#x1f525;关注&#x1f693;收藏&#xff0c;&am…
阅读更多...
最新文章

Copyright @ 2022~2023