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

news2024/10/7 14:30:20

一、求〈1，0，0，1，0，1，0，1〉和〈0，1，0，1，1，0，1，1，0〉的一个LCS。需要写代码的时候，请用go语言。

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

在Go语言中，求两个序列的最长公共子序列（Longest Common Subsequence, LCS）可以使用动态规划（Dynamic Programming, DP）的方法。下面是一个Go语言实现的示例代码，用于找到给定两个序列的LCS：

package main  
  
import (  
	"fmt"  
)  
  
// lcsLength 计算两个序列的最长公共子序列的长度  
func lcsLength(X []int, Y []int) int {  
	m := len(X)  
	n := len(Y)  
  
	// 创建一个二维数组来保存子问题的解  
	L := make([][]int, m+1)  
	for i := range L {  
		L[i] = make([]int, n+1)  
	}  
  
	// 动态规划填充表格  
	for i := 1; i <= m; i++ {  
		for j := 1; j <= n; j++ {  
			if X[i-1] == Y[j-1] {  
				L[i][j] = L[i-1][j-1] + 1  
			} else {  
				L[i][j] = max(L[i-1][j], L[i][j-1])  
			}  
		}  
	}  
  
	// 返回LCS的长度  
	return L[m][n]  
}  
  
// max 返回两个整数中的较大值  
func max(a, b int) int {  
	if a > b {  
		return a  
	}  
	return b  
}  
  
// lcs 构造最长公共子序列  
func lcs(X []int, Y []int) []int {  
	m := len(X)  
	n := len(Y)  
  
	L := make([][]int, m+1)  
	for i := range L {  
		L[i] = make([]int, n+1)  
	}  
  
	// 填充L[][]数组  
	for i := 1; i <= m; i++ {  
		for j := 1; j <= n; j++ {  
			if X[i-1] == Y[j-1] {  
				L[i][j] = L[i-1][j-1] + 1  
			} else {  
				L[i][j] = max(L[i-1][j], L[i][j-1])  
			}  
		}  
	}  
  
	// 从L[][]数组回溯构造LCS  
	i, j := m, n  
	lcs := []int{}  
	for i > 0 && j > 0 {  
		if X[i-1] == Y[j-1] {  
			lcs = append([]int{X[i-1]}, lcs...)  
			i--  
			j--  
		} else if L[i-1][j] > L[i][j-1] {  
			i--  
		} else {  
			j--  
		}  
	}  
  
	return lcs  
}  
  
func main() {  
	X := []int{1, 0, 0, 1, 0, 1, 0, 1}  
	Y := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}  
  
	// 计算LCS的长度  
	length := lcsLength(X, Y)  
	fmt.Printf("Length of LCS is: %d\n", length)  
  
	// 构造LCS  
	lcsResult := lcs(X, Y)  
	fmt.Println("One LCS is:", lcsResult)  
}

这段代码定义了两个函数：lcsLength 用于计算LCS的长度，lcs 用于构造LCS本身。main 函数中初始化了两个序列 X 和 Y，并调用了这两个函数来展示LCS的长度和一个可能的LCS。

请注意，LCS可能不是唯一的，因为可能有多个具有相同长度的子序列满足条件。上述代码只返回了其中一个可能的LCS。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

在Go语言中，我们可以使用动态规划的方法来求解两个序列的最长公共子序列。以下是一个简单的实现：

package main
import "fmt"

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

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

func main() {
    X := []int{1, 0, 0, 1, 0, 1, 0, 1}
    Y := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}
    m := len(X)
    n := len(Y)
    fmt.Println("Length of LCS is", lcs(X, Y, m, n))
}

在这个代码中，我们首先定义了一个二维数组L，其中L[i][j]表示序列X的前i个元素和序列Y的前j个元素的最长公共子序列的长度。然后我们遍历这两个序列，如果当前的元素相同，那么最长公共子序列的长度就是前一个元素的最长公共子序列的长度加一；否则，最长公共子序列的长度就是去掉当前元素后的最长公共子序列的长度的最大值。最后，返回的就是L[m][n]，即两个序列的最长公共子序列的长度。

在这里插入图片描述

在这里插入图片描述

360智脑，代码正常运行：

最长公共子序列（LCS）是一个在计算机科学中常见的问题，它需要找到两个序列中的最长公共子序列。下面是一个用Go语言实现的LCS函数：

package main

func lcs(X []int, Y []int) int {
	m := len(X)
	n := len(Y)

	if m == 0 || n == 0 {
		return 0
	}

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

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

	return L[m][n]
}

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}
	fmt.Println(lcs(X, Y))
}

在这个代码中，我们首先创建了一个二维数组L，其中L[i][j]表示X的前i个元素和Y的前j个元素的最长公共子序列的长度。然后，我们遍历X和Y，根据X[i-1]和Y[j-1]是否相等来更新L[i][j]。最后，L[m][n]就是X和Y的最长公共子序列的长度。

运行这段代码，我们可以得到X和Y的最长公共子序列的长度为4。

在这里插入图片描述

在这里插入图片描述

智谱清言，代码不完整：

为了找到两个序列的最长公共子序列 (LCS)，我们可以使用动态规划的方法。在Go语言中实现这一算法，我们可以创建一个二维数组来存储子问题的解，并逐步构建LCS。

下面是一个使用Go语言实现的查找两个序列LCS的示例代码：

package main
import (
	"fmt"
)
// 计算最长公共子序列的长度
func LCSLength(X []string, Y []string) int {
	// 创建一个二维数组，用于存储子问题的解
	m := len(X)
	n := len(Y)
	dp := make([][]int, m+1)
	for i := range dp {
		dp[i] = make([]int, n+1)
	}
	// 初始化二维数组
	for i := 0; i <= m; i++ {
		for j := 0; j <= n; j++ {
			if i == 0 || j == 0 {
				dp[i][j] = 0
			}
		}
	}
	// 使用动态规划来填充二维数组
	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])
			}
		}
	}
	// dp[m][n] 包含了X[0..n-1] 和 Y[0..m-1]的LCS的长度
	return dp[m][n]
}
// 辅助函数，用于返回两个整数中的最大值
func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}
// 打印最长公共子序列
func printLCS(X []string, Y []string, dp [][]int) {
	m := len(X)
	n := len(Y)
	// 创建一个二维数组来存储LCS的子序列
	lcs := make([][]string, m+1)
	for i := range lcs {
		lcs[i] = make([]string, n+1)
	}
	// 从二维数组的右下角开始填充，以找出LCS
	for i := m; i >= 1; i-- {
		for j := n; j >= 1; j-- {
			if X[i-1] == Y[j-1] {
				lcs[i][j] = X[i-1]
				// 移动到左上角，即选择“相等”的选项
				i--
				j--
			} else if dp[i-1][j] > dp[i][j-1] {
				// 移动到左边的方格，即选择“从X中删除”的选项
				i--
			} else {
				// 移动到上方的方格，即选择“从Y中删除”的选项
				j--
			}
		}
	}
	// lcs[m][n] 包含了X[0..n-1] 和 Y[0..m-1]的LCS
	fmt.Println("最长公共子序列是： ")
	for _, value := range lcs[m] {
		if value != "" {
			fmt.Print(value, " ")
		}
	}
	fmt.Println()
}
func main() {
	X := []string{"1", "0", "0", "1", "0", "1", "0", "1"}
	Y := []string{"0", "1", "0", "1", "1", "0", "1", "1", "0"}
	// 计算LCS的长度
	length := LCSLength(X,

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

通义千问，代码正常运行：

LCS（Longest Common Subsequence）是指两个序列的最长公共子序列，它不一定是连续的子序列，但是要求相对顺序不变。

以下是使用Go语言实现的一个简单的动态规划解决方案：

package main

func lcs(a, b []int) []int {
    m, n := len(a), len(b)
    dp := make([][]int, m+1)
    for i := range dp {
        dp[i] = make([]int, n+1)
    }

    // 动态规划填充dp数组
    for i := 1; i <= m; i++ {
        for j := 1; j <= n; j++ {
            if a[i-1] == b[j-1] {
                dp[i][j] = dp[i-1][j-1] + 1
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
            }
        }
    }

    // 回溯得到LCS
    i, j := m, n
    res := []int{}
    for i > 0 && j > 0 {
        if a[i-1] == b[j-1] {
            res = append([]int{a[i-1]}, res...)
            i--
            j--
        } else if dp[i-1][j] > dp[i][j-1] {
            i--
        } else {
            j--
        }
    }

    return res
}

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

func main() {
    a := []int{1, 0, 0, 1, 0, 1, 0, 1}
    b := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}
    fmt.Println(lcs(a, b))
}

这段代码首先通过动态规划计算出两个序列的最长公共子序列的长度，并存储在二维数组dp中。然后通过回溯的方式找到这个最长公共子序列。最后在main函数中调用lcs函数并打印结果。

注意：上述代码返回的是一个整数切片，即LCS的具体内容，由于输入的两个序列中相同的元素并不连续，所以LCS也是不连续的，这里直接返回了LCS的所有元素。

在这里插入图片描述

在这里插入图片描述

天工，panic：

在Go语言中，我们可以通过动态规划的方法来找到两个给定序列的 longest common subsequence (LCS)。下面是一个实现这一算法的Go语言函数：

package main

import "fmt"

// LCS computes the length of the longest common subsequence between X and Y.
func LCS(X, Y []int) int {
    m, n := len(X), len(Y)
    var dp [][]int
    dp = make([][]int, m+1)
    for i := range dp {
        dp[i] = make([]int, n+1)
    }
    
    // Initialize dp table
    for i := 0; i <= m; i++ {
        for j := 0; j <= n; j++ {
            if i == 0 || j == 0 {
                dp[i][j] = 0
            }
        }
    }
    
    // Fill the dp table
    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
}

// LCSArray finds an actual LCS between X and Y.
func LCSArray(X, Y []int) []bool {
    m, n := len(X), len(Y)
    dp := make([][]int, m+1)
    for i := range dp {
        dp[i] = make([]int, n+1)
    }
    lcs := make([]bool, m+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
                lcs[dp[i][j]] = true
            } else {
                dp[i][j] = max(dp[i-1][j], dp[i][j-1])
            }
        }
    }
    
    var lcsStr string
    var lcsIndex int
    for i := 1; i <= min(len(X), len(Y)); i++ {
        if lcs[i] {
            lcsStr += "1"
            lcsIndex = i
        } else {
            lcsStr += "0"
        }
    }
    
    lcsArray := make([]bool, lcsIndex)
    for i, v := range lcsStr {
        lcsArray[i] = v == '1'
    }
    return lcsArray
}

// min returns the smaller of two integers.
func min(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 := LCS(X, Y)
    fmt.Printf("The length of the LCS is: %d\n", length)
    
    lcs := LCSArray(X, Y)
    fmt.Println("An LCS:", lcs)
}

这段代码首先定义了一个计算LCS长度的函数LCS和返回实际LCS的函数LCSArray。然后，它使用这两个函数来处理输入序列并打印出LCS的长度以及一个实际的LCS。在main函数中，我们调用了LCS和LCSArray函数来处理给定的序列。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

灵小智，代码正常运行：

下面是使用Go语言编写的代码，用于找到给定两个数组的最长公共子序列（LCS）：

package main

import (
	"fmt"
)

func findLCS(arr1, arr2 []int) []int {
	m := len(arr1)
	n := len(arr2)

	// 创建二维数组用于存储LCS的长度
	dp := make([][]int, m+1)
	for i := 0; i <= m; i++ {
		dp[i] = make([]int, n+1)
	}

	// 填充dp数组
	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if arr1[i-1] == arr2[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
			}
		}
	}

	// 根据dp数组回溯找到LCS
	lcs := make([]int, dp[m][n])
	index := dp[m][n] - 1
	i := m
	j := n
	for i > 0 && j > 0 {
		if arr1[i-1] == arr2[j-1] {
			lcs[index] = arr1[i-1]
			i--
			j--
			index--
		} else if dp[i-1][j] > dp[i][j-1] {
			i--
		} else {
			j--
		}
	}

	return lcs
}

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

func main() {
	arr1 := []int{1, 0, 0, 1, 0, 1, 0, 1}
	arr2 := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}

	lcs := findLCS(arr1, arr2)
	fmt.Println("最长公共子序列：", lcs)
}

运行代码将输出：

最长公共子序列： [1 0 0 1 0 1]

这是给定两个数组 [1, 0, 0, 1, 0, 1, 0, 1] 和 [0, 1, 0, 1, 1, 0, 1, 1, 0] 的最长公共子序列。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

chatgpt，代码正常运行：

以下是使用Go语言编写的代码，求解给定序列的最长公共子序列（LCS）：

package main

import "fmt"

func lcs(seq1, seq2 []int) []int {
	m := len(seq1)
	n := len(seq2)

	// 创建二维数组存储动态规划中间结果
	dp := make([][]int, m+1)
	for i := 0; i <= m; i++ {
		dp[i] = make([]int, n+1)
	}

	// 填充动态规划表
	for i := 1; i <= m; i++ {
		for j := 1; j <= n; j++ {
			if seq1[i-1] == seq2[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
			}
		}
	}

	// 回溯找出最长公共子序列
	lcsSeq := make([]int, 0)
	i, j := m, n
	for i > 0 && j > 0 {
		if seq1[i-1] == seq2[j-1] {
			lcsSeq = append(lcsSeq, seq1[i-1])
			i--
			j--
		} else if dp[i][j-1] >= dp[i-1][j] {
			j--
		} else {
			i--
		}
	}

	return reverse(lcsSeq)
}

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

func reverse(seq []int) []int {
	n := len(seq)
	for i := 0; i < n/2; i++ {
		seq[i], seq[n-i-1] = seq[n-i-1], seq[i]
	}
	return seq
}

func main() {
	seq1 := []int{1, 0, 0, 1, 0, 1, 0, 1}
	seq2 := []int{0, 1, 0, 1, 1, 0, 1, 1, 0}

	lcsSeq := lcs(seq1, seq2)

	fmt.Println("Longest Common Subsequence (LCS):", lcsSeq)
}

上述代码使用动态规划算法求解给定序列的最长公共子序列，输出结果为 [0，0，1，0，1]。

在这里插入图片描述

在这里插入图片描述

kimi，代码不能运行：

最长公共子序列（Longest Common Subsequence，LCS）问题可以通过动态规划来解决。以下是一个使用 Go 语言实现的 LCS 算法，用于找到两个给定序列的最长公共子序列：

package main

import (
	"fmt"
)

// LCS 函数计算两个序列的最长公共子序列的长度
func LCS(x, y []int) (int, []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])
			}
		}
	}

	// 回溯找到最长公共子序列
	result := make([]int, dp[m][n])
	i, j := m, n
	for i > 0 && j > 0 {
		if x[i-1] == y[j-1] {
			result[--i] = x[i-1]
			j--
		} else if dp[i-1][j] > dp[i][j-1] {
			i--
		} else {
			j--
		}
	}

	return dp[m][n], result
}

// 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, lcs := LCS(x, y)
	fmt.Printf("Length of LCS: %d\n", length)
	fmt.Printf("LCS:        %v\n", lcs)
}

在这个程序中，LCS 函数接受两个整数切片 x 和 y 作为输入，并返回这两个序列的最长公共子序列的长度以及子序列本身。我们使用一个二维数组 dp 来存储子问题的解，其中 dp[i][j] 表示序列 x 的前 i 个元素和序列 y 的前 j 个元素的最长公共子序列的长度。然后，我们通过回溯 dp 数组来构建最长公共子序列。

运行这个程序，你将得到序列 <1, 0, 0, 1, 0, 1, 0, 1> 和 <0, 1, 0, 1, 1, 0, 1, 1, 0> 的最长公共子序列及其长度。

在这里插入图片描述

在这里插入图片描述

混元，代码正常运行：

这两个序列的最长公共子序列（LCS）是：〈0，1，0，1，0，1，0，1〉。

以下是使用 Go 语言实现的求解两个序列的 LCS 的代码：

package main

import (
	"fmt"
)

func longestCommonSubsequence(text1 string, text2 string) string {
	m, n := len(text1), len(text2)
	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 text1[i-1] == text2[j-1] {
				dp[i][j] = dp[i-1][j-1] + 1
			} else {
				dp[i][j] = max(dp[i-1][j], dp[i][j-1])
			}
		}
	}

	lcs := ""
	i, j := m, n
	for i > 0 && j > 0 {
		if text1[i-1] == text2[j-1] {
			lcs = string(text1[i-1]) + lcs
			i--
			j--
		} else if dp[i-1][j] > dp[i][j-1] {
			i--
		} else {
			j--
		}
	}

	return lcs
}

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

func main() {
	text1 := "10010101"
	text2 := "010110110"
	fmt.Println(longestCommonSubsequence(text1, text2))
}

这段代码首先定义了一个 longestCommonSubsequence 函数，输入为两个字符串，输出为它们的 LCS。函数内部使用动态规划算法求解 LCS 的长度，并根据 dp 数组还原出 LCS。最后在 main 函数中调用该函数并输出结果。

在这里插入图片描述

在这里插入图片描述

总结

代码能正常运行的，答案没问题。普天同庆。

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

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

相关文章

C++ //练习 10.7 下面的程序是否有错误？如果有，请改正。

C++ //练习 10.7 下面的程序是否有错误？如果有，请改正。

C Primer&#xff08;第5版&#xff09; 练习 10.7 练习 10.7 下面的程序是否有错误&#xff1f;如果有&#xff0c;请改正。 (a) vector<int>vec; list<int> lst; int i;while(cin>>i)lst.push_back(i);copy(lst.cbegin(), lst.cend(), vec.begin());(b) …
阅读更多...
DDS笔记

DDS笔记

1.DDS 直接数字式频率合成器&#xff08;Direct Digital Synthesizer,DDS&#xff09;是通过相位和幅值 的映射实现任意频率的正弦曲线样本的方法 系统时钟CLK频率为fclk&#xff0c;输出信号频率为fout&#xff0c;频率字输入K的位宽为N位。 相位累加器通常由一个N位加法器和…
阅读更多...
Docker之自定义镜像上传阿里云

Docker之自定义镜像上传阿里云

目录 一、Alpine制作jdk镜像 1. 下载镜像 2. 创建并编辑Dockerfile 3. 执行Dockerfile构建镜像 4. 测试 二、Alpine制作jre镜像 1. 下载jre 2. 上传gz压缩包&#xff0c;删除无用的文件&#xff0c;并重新压缩 3. 创建并编辑Dockerfile 4. 执行Dockerfile并构建镜像…
阅读更多...
【电商干货】5分钟了解电商数据API测试完整流程，建议收藏！可获取免费测试key！

【电商干货】5分钟了解电商数据API测试完整流程，建议收藏！可获取免费测试key！

电商API是什么&#xff1f; API是application programming interface&#xff08;应用程序接口&#xff09;的简称&#xff0c;是一些预先定义的函数。目的是提供应用程序与开发人员基于某软件或硬件得以访问一组例程的能力&#xff0c;而又无需访问源码&#xff0c;或理解内部…
阅读更多...
CentOS安装GUI图形界面

CentOS安装GUI图形界面

CentOS安装图形界面 CentOS minimal环境安装图形界面。 列出所有可用的Environment Groups yum group list yum groupinfo "GNOME Desktop"选择GNOME Desktop软件包组进行安装 yum groupinstall -y GNOME Desktop1 如果要通过GUI配置网络需要安装Server with GU…
阅读更多...
删除有序数组中的重复项Ⅱ

删除有序数组中的重复项Ⅱ

问题 给你一个有序数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使得出现次数超过两次的元素只出现两次 &#xff0c;返回删除后数组的新长度。 不要使用额外的数组空间&#xff0c;你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。 说明…
阅读更多...
有哪些视频媒体？邀请视频媒体报道活动的好处

有哪些视频媒体？邀请视频媒体报道活动的好处

传媒如春雨&#xff0c;润物细无声&#xff0c;大家好&#xff0c;我是51媒体网胡老师。 视频媒体在当今的媒体生态中占据了重要的地位。以下是一些主要的视频媒体类型&#xff1a; 电视台&#xff1a;如中央电视台、各省级卫视台、地方电视台等&#xff0c;他们拥有专业的视…
阅读更多...
vue2后台管理系统demo，包含增删查改、模糊搜索、分页

vue2后台管理系统demo，包含增删查改、模糊搜索、分页

因一直敲小程序&#xff0c;vue不熟练&#xff0c;自己练手项目&#xff0c;就包含增删查改以及模糊搜索分页 一、页面简单但功能齐全 二、数据是mock模拟 三、启动步骤 1、 json-server --watch data.json 启动mock数据 2、npm i 下载依赖 3、npm run serve 四、github地址…
阅读更多...
PSO-CNN-LSTM多输入时序预测|粒子群算法优化的卷积-长短期神经网络时序预测(Matlab)——附代码+数据

PSO-CNN-LSTM多输入时序预测|粒子群算法优化的卷积-长短期神经网络时序预测(Matlab)——附代码+数据

目录 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 亮点与优势&#xff1a; 二、实际运行效果&#xff1a; 三、算法介绍&#xff1a; 四、完整程序数据分享下载&#xff1a; 一、程序及算法内容介绍&#xff1a; 基本内容&#xff1a; 本代码基于Matlab平台…
阅读更多...
Flutter（四）：SingleChildScrollView、GridView

Flutter（四）：SingleChildScrollView、GridView

SingleChildScrollView、GridView 遇到的问题 以下代码会报错: class GridViewPage extends StatefulWidget {const GridViewPage({super.key});overrideState<GridViewPage> createState() > _GridViewPage(); }class _GridViewPage extends State<GridViewPage&g…
阅读更多...
go并发模式之----阻塞/屏障模式

go并发模式之----阻塞/屏障模式

常见模式之一&#xff1a;阻塞/屏障模式 定义 顾名思义&#xff0c;就是阻塞等待所有goroutine&#xff0c;直到所有goroutine完成&#xff0c;聚合所有结果 使用场景 多个网络请求&#xff0c;聚合结果 大任务拆分成多个子任务&#xff0c;聚合结果 示例 package main ​…
阅读更多...
两台电脑异地怎么共享文件？

两台电脑异地怎么共享文件？

在现代社会中&#xff0c;无论是个人用户还是企事业单位&#xff0c;都经常面临着跨地域的文件共享需求。由于各种限制和条件的限制&#xff0c;如网络环境、设备限制等&#xff0c;可能导致文件共享变得非常困难。本文将介绍一款名为【天联】的组网产品&#xff0c;通过它可以…
阅读更多...
mysql快速生成1000万的测试数据

mysql快速生成1000万的测试数据

创建存储过程 DELIMITER //CREATE PROCEDURE generate_data() BEGINDECLARE i INT DEFAULT 1;-- 创建表CREATE TABLE IF NOT EXISTS test_table (id INT AUTO_INCREMENT PRIMARY KEY,name VARCHAR(255),age INT,email VARCHAR(255));-- 插入1000万行数据WHILE i < 10000000…
阅读更多...
Zynq—AD9238数据采集DDR3缓存千兆以太网发送实验（前导）

Zynq—AD9238数据采集DDR3缓存千兆以太网发送实验（前导）

ACM9238 高速双通道ADC模块自助服务手册AD9238 Zynq—AD9238数据采集DDR3缓存千兆以太网发送实验&#xff08;一&#xff09;-CSDN博客 一、AD9238 模块在各方面参数性能上与AD9226保持一致。但是在设计上优化了信号调理电路&#xff0c;将单端信号先转成差分信号&#xff0c…
阅读更多...
新闻稿软文投放推广发布需要注意什么

新闻稿软文投放推广发布需要注意什么

在全球化的背景下&#xff0c;各国之间的联系与互动变得越来越频繁。无论是经济、文化还是科技领域&#xff0c;各国之间的交流和合作都在不断加深。而在这个信息爆炸的互联网时代&#xff0c;人们获取信息的主要途径也逐渐转向了网络。 在这种情况下&#xff0c;软文推广成为…
阅读更多...
node 之 解决下包速度慢的问题

node 之 解决下包速度慢的问题

1.为什么下包速度慢 在使用 npm 下包的时候,默认从国外的https://registry.npmis.org/ 服务器进行下载&#xff0c;此时&#xff0c;网络数据的传输需要经过漫长的海底光缆&#xff0c;因此下包速度会很慢。 2.淘宝npm 镜像服务器 淘宝在国内搭建了一个服务器&#xff0c;专门把…
阅读更多...
Unity之ConversaDialogueSystem 对话插件使用

Unity之ConversaDialogueSystem 对话插件使用

一、插件下载或购买 官方购买地址&#xff1a;Conversa Dialogue System | 可视化脚本 | Unity Asset Store 百度网盘地址&#xff1a;提取码&#xff1a;syq1 此插件没有官方案例&#xff0c;插件作者也明确回复说后期不会出教程&#xff0c;所以此教程根据插件demo案例进行学…
阅读更多...
QT C++实践|超详细数据库的连接和增删改查操作|附源码

QT C++实践|超详细数据库的连接和增删改查操作|附源码

0&#xff1a;前言 &#x1faa7; 什么情况需要数据库? 1 大规模的数据需要处理&#xff08;比如上千上万的数据量&#xff09;2 需要把数据信息存储起来&#xff0c;无论是本地还是服务上&#xff0c;而不是断电后数据信息就消失了。 如果不是上面的原因化&#xff0c;一般…
阅读更多...
计算机网络-典型网络组网架构

计算机网络-典型网络组网架构

前面基本网络知识已经能够满足中小企业的需要了&#xff0c;今天来看下一些基本网络组网架构。 首先网络是分层架构&#xff0c;从接入层到汇聚层再到核心层&#xff0c;然后接入运营商出口。内部包括有线网络、无线网络&#xff0c;出口一般可以使用路由器或者防火墙进行安全防…
阅读更多...
人才测评工具 找准需求才能测出效果

人才测评工具 找准需求才能测出效果

怎么挖掘人才&#xff1f;怎么利用人才&#xff1f; 让每个员工发挥出最大的优势&#xff1f; 让每个员工奋斗在最适合的岗位&#xff1f; 每个HRer都考虑过&#xff0c;每个HR也都有自己独特的见解。 1、找准测评目的 我们都希望测评是全面的&#xff0c;360度的。要是仔…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023