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

news2024/12/26 10:38:11

一、写出 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码。如果要写代码，请用go语言。

文心一言：

首先，让我们明确一下 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 这两个过程是在介绍van Emde Boas树（简称vEB树）数据结构时使用的。vEB树是一种用于支持快速查找、插入、删除和一系列集合操作的数据结构。

PROTO-vEB-MAXIMUM 过程通常用于查找给定集合中最大的元素（如果存在的话）。PROTO-vEB-PREDECESSOR 过程则用于查找给定元素的前一个元素（如果存在的话）。

以下是这两个过程的伪代码：

伪代码

PROTO-vEB-MAXIMUM

plaintext
PROTO-vEB-MAXIMUM(T, u)  
    if T.A[u] != nil  
        return PROTO-vEB-MAXIMUM(T.A[u], T.universe - 1)  
    else if T.leftChild != nil and T.leftChild.high >= 0  
        return T.leftChild.high  
    else  
        return -1 // 表示没有元素

PROTO-vEB-PREDECESSOR

PROTO-vEB-PREDECESSOR(T, x)  
    if T.A[x] != nil  
        pred = PROTO-vEB-MAXIMUM(T.A[x], x - 1)  
        if pred != -1  
            return pred + T.sum[x - 1]  
    if T.leftChild != nil and x > T.leftChild.high + T.sum[T.leftChild.high]  
        return T.leftChild.high + T.sum[T.leftChild.high]  
    return PROTO-vEB-PREDECESSOR(T.rightChild, x - T.sum[T.leftChild.high] - 1)

Go语言实现

请注意，由于vEB树的结构相对复杂，并且Go语言中没有直接的数据结构来表示vEB树，下面的代码只是基于伪代码的一个概念性实现，并且假设了一些结构和方法。

package main  
  
import (  
	"fmt"  
)  
  
// 假设的vEB树节点结构  
type vEBNode struct {  
	A            []*vEBNode // 数组子节点  
	leftChild    *vEBNode   // 左孩子节点  
	rightChild   *vEBNode   // 右孩子节点  
	high         int        // 当前子树中的最大元素  
	sum          []int      // 累积和数组  
	universe     int        // 当前子树的宇宙大小  
}  
  
// PROTO-vEB-MAXIMUM 的Go实现  
func PROTOvEBMaximum(T *vEBNode, u int) int {  
	if T.A[u] != nil {  
		return PROTOvEBMaximum(T.A[u], T.universe-1)  
	} else if T.leftChild != nil && T.leftChild.high >= 0 {  
		return T.leftChild.high  
	}  
	return -1  
}  
  
// PROTO-vEB-PREDECESSOR 的Go实现  
func PROTOvEBPredecessor(T *vEBNode, x int) int {  
	if T.A[x] != nil {  
		pred := PROTOvEBMaximum(T.A[x], x-1)  
		if pred != -1 {  
			return pred + T.sum[x-1]  
		}  
	}  
	if T.leftChild != nil && x > T.leftChild.high+T.sum[T.leftChild.high] {  
		return T.leftChild.high + T.sum[T.leftChild.high]  
	}  
	if T.rightChild != nil {  
		return T.sum[T.leftChild.high] + PROTOvEBPredecessor(T.rightChild, x-T.sum[T.leftChild.high]-1)  
	}  
	return -1 // 如果找不到前驱，则返回-1  
}  
  
func main() {  
	// 这里只是示例，实际中你需要创建和初始化vEB树  
	// ...  
  
	// 示例调用  
	// max := PROTOvEBMaximum(someVebTree, someUniverseValue)  
	// pred := PROTOvEBPredecessor(someVebTree, someValue)  
	// fmt.Println("Max:", max)  
	// fmt.Println("Predecessor:", pred)  
}

请注意，上述Go代码并没有包含vEB树的完整实现，特别是A、leftChild、rightChild、high、sum和universe等字段的初始化和更新逻辑。此外，为了完整性和正确性，你还需要添加其他必要的辅助函数和错误处理逻辑。

讯飞星火：

PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 是 vEB 树（也称为向量扩展二叉树）中的两个操作。vEB 树是一种数据结构，用于高效地处理集合的并集、交集和差集等操作。

以下是 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码：

  1. PROTO-vEB-MAXIMUM 过程：
function PROTO-vEB-MAXIMUM(x):
    if x is a leaf node:
        return x
    elif x.min == 0:
        return PROTO-vEB-MAXIMUM(x.cluster[0])
    else:
        return PROTO-vEB-MAXIMUM(x.summary)
  1. PROTO-vEB-PREDECESSOR 过程：
function PROTO-vEB-PREDECESSOR(x, predecessor):
    if x is a leaf node:
        if x == predecessor:
            return NIL
        else:
            return predecessor
    elif x.min == 0:
        return PROTO-vEB-PREDECESSOR(x.cluster[0], predecessor)
    else:
        new_predecessor = PROTO-vEB-MAXIMUM(x.summary)
        if new_predecessor == predecessor:
            return NIL
        else:
            return PROTO-vEB-PREDECESSOR(x.summary, new_predecessor)

注意：这里的伪代码仅作为参考，实际实现时可能需要根据具体的 vEB 树结构和算法进行调整。

360智脑：

您提到的这两个过程看起来像是某种算法或数据结构相关的内容，但没有给出足够的上下文来确定它们的确切含义。然而，我可以为您提供一个通用的伪代码示例，这将有助于您了解如何实现这些过程。

伪代码通常不依赖于特定的编程语言，因此我将首先提供伪代码，然后如果您需要，我可以将其转换为Go语言的代码。

PROTO-vEB-MAXIMUM

// 初始化最大值为null或适当的默认值
max := null

// 遍历数据结构以找到最大值
for each element e in PROTO-vEB:
    if max is null or e > max:
        max := e

return max

PROTO-vEB-PREDECESSOR

// 初始化前驱为null或适当的默认值
predecessor := null

// 遍历数据结构以找到前驱元素
for each element e in PROTO-vEB:
    // 前驱被定义为小于给定值的最大元素
    if predecessor is null or e < value and e >= predecessor:
        predecessor := e

return predecessor

请注意，这里的PROTO-vEB表示某种数据结构或集合，而value是一个您可能用来查找给定元素的前驱的参数。

如果您需要这些过程的Go语言实现，请告诉我，我可以根据您的具体需求来编写相应的代码。

智谱清言：

在回答这个问题之前，我需要先了解一下 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 这两个过程的含义和上下文。这两个名字看起来像是自定义的过程名称，可能是用于处理某种特定数据结构（比如虚拟扩展平衡树，vEB tree）的算法的一部分。

通常，在伪代码中，PROTO-vEB-MAXIMUM 可能会是找到vEB树中最大元素的过程，而 PROTO-vEB-PREDECESSOR 可能是找到给定元素的前驱元素（即小于该元素的最大元素）的过程。

下面我会给出这两个过程的伪代码，然后用Go语言实现这些伪代码。

伪代码：

// PROTO-vEB-MAXIMUM 过程
function PROTO-vEB-MAXIMUM(T)
    if T is empty
        return null
    maximum = T.root.key  // 假设根节点的键值是最大值
    current = T.root
    while current.right is not null
        maximum = current.key
        current = current.right
    return maximum
// PROTO-vEB-PREDECESSOR 过程
function PROTO-vEB-PREDECESSOR(T, x)
    if x is null or x is T.root
        return null
    if x.left is not null
        current = x.left
        while current.right is not null
            current = current.right
        return current
    else
        parent = x.parent
        while parent is not null and x == parent.left
            x = parent
            parent = parent.parent
        return parent

请注意，伪代码假定 T 是一个有效的vEB树实例，并且 T 具有 root 属性和 key、left、right、parent 等节点属性。这些属性和方法需要根据实际情况进行定义和实现。

现在，我会用Go语言实现这些伪代码。

Go语言实现：

package main
import (
	"fmt"
)
type Node struct {
	key       int
	left      *Node
	right     *Node
	parent    *Node
}
type vEBTree struct {
	root *Node
}
// 返回最大值
func (t *vEBTree) PROTO_vEB_MAXIMUM() int {
	if t.root == nil {
		return -1 // 或者根据实际情况返回null或其他标识
	}
	maximum := t.root.key
	current := t.root
	for current.right != nil {
		maximum = current.key
		current = current.right
	}
	return maximum
}
// 返回给定元素的前驱
func (t *vEBTree) PROTO_vEB_PREDECESSOR(x *Node) *Node {
	if x == nil || x == t.root {
		return nil
	}
	if x.left != nil {
		current := x.left
		for current.right != nil {
			current = current.right
		}
		return current
	} else {
		parent := x.parent
		for parent != nil && x == parent.left {
			x = parent
			parent = parent.parent
		}
		return parent
	}
}
func main() {
	// 创建vEB树的示例代码（省略）
	// ...
	// 获取最大值
	maximum := vEBTreeInstance.PROTO_vEB_MAXIMUM()
	fmt.Println("Maximum value in vEB tree:", maximum)
	// 查找某个元素的前驱（省略）
	// ...
}

在Go代码中，我们定义了 Node 结构体来表示vEB树的节点，以及 vEBTree 结构体来表示vEB树本身。实现了两个方法 PROTO_vEB_MAXIMUM 和 PROTO_vEB_PREDECESSOR 来分别找到最大元素和给定元素的前驱。注意，这里我们假定了 `nil

天工：

在计算机科学中，van Emde Boas 结构（或称为 vEB 树）是一种用于处理整数集合的数据结构，它支持高效的插入、删除和查找操作。PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 是 vEB 树中的两个重要操作，分别用于找到集合中的最大元素和找到给定元素的前驱。

以下是 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码描述：

PROTO-vEB-MAXIMUM(V)
1. if V.min ≠ NIL
2.     return V.min
3. else
4.     return NIL

PROTO-vEB-PREDECESSOR(V, x)
1. if x <= 0
2.     return NIL
3. if V.min ≠ NIL and x > V.min
4.     return V.min
5. u ← V.u
6. high(x) ← floor(x / sqrt(u))
7. low(x) ← x mod sqrt(u)
8. if V.cluster[high(x)].min ≠ NIL and low(x) > V.cluster[high(x)].max
9.     return index of (high(x), V.cluster[high(x)].max) in universe U
10. else if V.summary ≠ NIL and PROTO-vEB-PREDECESSOR(V.summary, high(x)) ≠ NIL
11.     cluster ← V.cluster[PROTO-vEB-PREDECESSOR(V.summary, high(x))]
12.     return index of (PROTO-vEB-PREDECESSOR(cluster, low(x))) in universe U
13. else
14.     return NIL

由于 Go 语言不是伪代码，而是实际的编程语言，因此我将提供一个简化版本的 vEB 树实现，其中包括了 MAXIMUM 和 PREDECESSOR 函数的示例代码。请注意，这个实现是非常基础的，并没有包含所有的 vEB 树特性，但它可以帮助你理解如何将上述伪代码转换为 Go 代码。

package main

import "fmt"

type vEBTree struct {
	min, max *int
	clusters []vEBTree
	summary *vEBTree
	u int
}

func newVEBTree(u int) *vEBTree {
	return &vEBTree{
		u: u,
	}
}

func (v *vEBTree) maximum() *int {
	return v.max
}

func (v *vEBTree) predecessor(x int) *int {
	if v.min != nil && x > *v.min {
		return v.min
	}

	high := x / (v.u / 2)
	low := x % (v.u / 2)

	if clusters := v.clusters; len(clusters) > 0 {
		if max := clusters[high].maximum(); max != nil && low > *max {
			return &((high*(v.u/2) + *max))
		}
		if pred := clusters[high].predecessor(low); pred != nil {
			return pred
		}
	}

	return nil
}

// ... 其他 vEB 树函数（如 insert, delete）在这里省略 ...

func main() {
	// 创建 vEB 树实例并演示 maximum 和 predecessor 函数
	tree := newVEBTree(16)
	values := []int{3, 10, 14, 2, 8}
	for _, value := range values {
		// 假设这里有一个 insert 函数来插入值到 vEB 树中
		// tree.insert(value)
	}

	fmt.Println("Maximum:", *tree.maximum()) // 应该输出 14
	fmt.Println("Predecessor of 12:", *tree.predecessor(12)) // 应该输出 10
}

请注意，这个 Go 代码示例并不完整，因为它缺少了一些必要的函数（如 insert 和 delete），以及一些错误检查和边界情况处理。此外，Go 语言中的指针使用可能会让代码看起来比伪代码更复杂。在实际应用中，你可能需要一个更加健壮和完整的 vEB 树实现。

chatgpt：

以下是 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码：

// PROTO-vEB-MAXIMUM 伪代码
func ProtoVEBMaximum(V vEBTree) (max int) {
    if V.u == 2 { // 基本情况，如果只有两个元素，则返回较大的那个元素
        if len(V.cluster[1]) > 0 {
            return V.cluster[1][0]
        } else {
            return V.cluster[0][0]
        }
    } else if V.max != -1 { // 如果最大值已经被存储在 max 中，则直接返回
        return V.max
    } else { // 否则，在子簇中递归查找最大值，并保存到 max 中
        high := ProtoVEBMaximum(V.summary)
        low := ProtoVEBMaximum(V.cluster[high])
        return combine(high, low, V.u)
    }
}

// PROTO-vEB-PREDECESSOR 伪代码
func ProtoVEBPredecessor(V vEBTree, x int) (predecessor int, found bool) {
    if V.u == 2 { // 基本情况，如果只有两个元素，则根据给定值 x 返回前驱或者不存在
        if x == 1 && len(V.cluster[0]) > 0 {
            return 0, true
        } else {
            return -1, false
        }
    } else if V.max != -1 && x > V.max { // 如果最大值存在且给定值大于最大值，则返回最大值作为前驱
        return V.max, true
    } else { // 在子簇中递归查找前驱
        high := ProtoVEBPredecessor(V.summary, high(x))
        var low int
        var found bool
        if high != -1 {
            low, found = ProtoVEBPredecessor(V.cluster[high], low(x))
        }
        if found { // 如果在子簇中找到了前驱，则返回结果
            return combine(high, low, V.u), true
        } else { // 否则，继续在更小的子簇中查找前驱
            predCluster := ProtoVEBPredecessor(V.summary, high)
            if predCluster == -1 {
                return -1, false
            }
            predLow := ProtoVEBMaximum(V.cluster[predCluster])
            return combine(predCluster, predLow, V.u), true
        }
    }
}

以上是使用 Go 语言编写的 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码。请注意，这只是伪代码，具体实现可能需要进行适当的调整和优化。

kimi：

PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 是在 van Emde Boas (vEB) 树中查找最大元素和给定元素的前驱的算法过程。vEB 树是一种用于高效搜索、插入和删除操作的数据结构，特别适合处理宇宙集合中的元素，其中宇宙集合的大小是 2 的幂。

以下是 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的伪代码：

PROTO-vEB-MAXIMUM 伪代码

PROTO-vEB-MAXIMUM(T, v)
    if T is empty
        return NIL
    if v is less than the size of the universe
        return the maximum of the table T[v]
    else
        w <- the maximum of the table T
        return PROTO-vEB-MAXIMUM(T[w], (v - size(T[w])) * (size(T[w+1])) / size(T[w]))

PROTO-vEB-PREDECESSOR 伪代码

PROTO-vEB-PREDECESSOR(T, v)
    if T is empty
        return NIL
    if v is less than the size of the active table T
        return the predecessor in the active table T
    else
        w <- the active table index for v
        u <- PROTO-vEB-PREDECESSOR(T[w], (v - size(T[w])) * (size(T[w+1])) / size(T[w]))
        if u is not NIL
            return (w + 1) * size(T[w]) + u
        else
            return w

在 Go 语言中，我们可以将这些伪代码转换为实际的函数实现。以下是 Go 语言版本的实现：

package main

import (
	"fmt"
)

// 假设我们有一个简化的 vEB 树结构和一些辅助函数来模拟查找操作

// UniverseSize 是宇宙集合的大小，必须是 2 的幂
const UniverseSize = 1024

// Table 模拟 vEB 树中的活动表
var Table = make([]int, UniverseSize)

// ActiveTableSize 模拟活动表的大小
var ActiveTableSize = 0

// findMax 在活动表中查找最大元素
func findMax(v int) int {
	if ActiveTableSize == 0 {
		return -1 // NIL 表示
	}
	return Table[ActiveTableSize-1]
}

// findPredecessor 在活动表中查找前驱
func findPredecessor(v int) int {
	if ActiveTableSize == 0 {
		return -1 // NIL 表示
	}
	// 简化的前驱查找，仅作为示例
	for i := ActiveTableSize - 2; i >= 0; i-- {
		if Table[i] < v {
			return Table[i]
		}
	}
	return Table[0] // 返回最小的元素作为前驱
}

func main() {
	// 填充表和初始化的代码...

	// 示例：查找最大元素
	maxValue := findMax(UniverseSize)
	fmt.Printf("The maximum value in the vEB tree is: %d\n", maxValue)

	// 示例：查找元素 500 的前驱
	predecessor := findPredecessor(500)
	fmt.Printf("The predecessor of value 500 is: %d\n", predecessor)
}

请注意，这个 Go 语言示例仅用于演示 PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 过程的基本思想，并没有实现完整的 vEB 树结构和所有相关操作。在实际应用中，vEB 树的实现会更加复杂，并且需要考虑更多的细节，如树的构建、更新和维护操作。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

混元：

PROTO-vEB-MAXIMUM 和 PROTO-vEB-PREDECESSOR 是 van Emde Boas 树（vEB）数据结构的两个操作。vEB 树是一种高效的数据结构，用于实现优先队列和其他抽象数据类型，如集合和映射。以下是这两个操作的伪代码：

  1. PROTO-vEB-MAXIMUM(T)

伪代码：

function PROTO-vEB-MAXIMUM(T):
    if T.min != NIL:
        return T.min
    else:
        return NIL
  1. PROTO-vEB-PREDECESSOR(T, x)

伪代码：

function PROTO-vEB-PREDECESSOR(T, x):
    if x < T.min:
        return NIL
    elif x > T.max:
        return T.max
    else:
        return T.summary.PROTO-vEB-PREDECESSOR(T, x)

以下是使用 Go 语言实现这两个操作的代码示例：

package main

import (
	"fmt"
)

type vEB struct {
	min     int
	max     int
	summary *vEB
}

func PROTOvEBMAXIMUM(T *vEB) int {
	if T.min != -1 {
		return T.min
	} else {
		return -1
	}
}

func PROTOvEBPREDECESSOR(T *vEB, x int) int {
	if x < T.min {
		return -1
	} else if x > T.max {
		return T.max
	} else {
		return PROTOvEBPREDECESSOR(T.summary, x)
	}
}

func main() {
	T := &vEB{min: 5, max: 10, summary: &vEB{min: 3, max: 7, summary: nil}}
	fmt.Println("PROTO-vEB-MAXIMUM:", PROTOvEBMAXIMUM(T)) // Output: 5
	fmt.Println("PROTO-vEB-PREDECESSOR of 7:", PROTOvEBPREDECESSOR(T, 7)) // Output: 3
}

请注意，这里的代码示例仅用于演示目的，实际实现可能需要根据具体需求进行调整。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

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

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

相关文章

Vue - JavaScript基础学习

Vue - JavaScript基础学习

一、语言概述 JavaScript 中的类型应该包括这些&#xff1a; 1.数字&#xff08;默认双精度区别于Java&#xff09; console.log(3 / 2); // 1.5,not 1 console.log(Math.floor(3 / 2)); // 10.1 0.2 0.30000000000000004NaN&#xff08;Not a Number&#x…
阅读更多...
深入用户内心：设计师如何通过可用性测试洞察用户需求

深入用户内心：设计师如何通过可用性测试洞察用户需求

可用性测试是指让用户体验产品的原型或成品。设计师通过观察和分析用户的使用行为和感受&#xff0c;进一步合理地改进产品的设计方法。你可能会想知道我们可以用什么方法来测试可用性&#xff1f;随着互联网行业的快速迭代更新&#xff0c;可用性测试衍生出了许多类型和方法。…
阅读更多...
Packet Tracer-HSRP+DHCPv4+VLAN间路由+以太通道综合实验

Packet Tracer-HSRP+DHCPv4+VLAN间路由+以太通道综合实验

实验拓扑&#xff1a; 实验内容&#xff1a; VLAN及VLAN间路由的配置&#xff0c;以太通道的配置&#xff0c;STP的根调整&#xff0c;DHCPv4的配置&#xff0c;首跳冗余HSRP的配置。 实验最终结果&#xff1a; PC可以自动获取到DHCP-Server分配的IP地址&#xff0c;实现首跳…
阅读更多...
【人工智能】模型性能评估

【人工智能】模型性能评估

模型性能衡量介绍 混淆矩阵 混淆矩阵(Confusion Matrix&#xff09; TP(真阳性)&#xff1a;预测为阳性&#xff0c;且预测正确。 TN(真阴性)&#xff1a;预测为阴性&#xff0c;且预测正确。 FP(伪阳性)&#xff1a;预测为阳性&#xff0c;但预测错误&#xff0c;又称型一误…
阅读更多...
widedeep模型简介

widedeep模型简介

wide&deep模型 1.简介2.原理2.1 网络结构 3. 稀疏密集特征4.API和子类方式实现 1.简介 Wide and deep 模型是 TensorFlow 在 2016 年 6 月左右发布的一类用于分类和回归的模型&#xff0c;并应用到了 Google Play 的应用推荐中。wide and deep 模型的核心思想是结合线性模…
阅读更多...
VBA_MF系列技术资料1-615

VBA_MF系列技术资料1-615

MF系列VBA技术资料1-615 为了让广大学员在VBA编程中有切实可行的思路及有效的提高自己的编程技巧&#xff0c;我参考大量的资料&#xff0c;并结合自己的经验总结了这份MF系列VBA技术综合资料&#xff0c;而且开放源码&#xff08;MF04除外&#xff09;&#xff0c;其中MF01-0…
阅读更多...
Ubuntu切换内核版本

Ubuntu切换内核版本

#安装内核安装工具 sudo apt-get install software-properties-common sudo add-apt-repository ppa:cappelikan/ppa sudo apt-get update sudo apt-get install mainline#安装指定内核版本(有些版本并不能安装成功) mainline install 5.14.10#更新GRUB配置 sudo update-grub#查…
阅读更多...
go mod模式下，import gitlab中的项目

go mod模式下，import gitlab中的项目

背景 为了go项目能够尽可能复用代码&#xff0c;把一些公用的工具类&#xff0c;公用的方法等放到共用包里统一管理。把共用包放到gitlab的私有仓库中。 遇到的问题 通过https方式&#xff0c;执行go get报了错误。 通过ssh方式&#xff0c;执行go get报了错误。 修改配置&am…
阅读更多...
Joomla 3.7.0 (CVE-2017-8917) SQL注入漏洞环境

Joomla 3.7.0 (CVE-2017-8917) SQL注入漏洞环境

1 漏洞概述 Joomla是一个基于PHP的内容管理系统&#xff08;CMS&#xff09;&#xff0c;广泛应用于各类网站。2017年&#xff0c;Joomla 3.7.0版本被发现存在SQL注入漏洞&#xff08;CVE-2017-8917&#xff09;&#xff0c;攻击者可以利用该漏洞对数据库进行未授权查询或操作…
阅读更多...
副业树洞聊天项目/树洞倾诉/陪陪系统源码/树洞源码下载搭建

副业树洞聊天项目/树洞倾诉/陪陪系统源码/树洞源码下载搭建

随着社会的发展和人们生活水平的提高&#xff0c;越来越多的人在面临心理压力、情感困扰或生活困境时&#xff0c;需要一个可以宣泄、倾诉和寻求支持的平台。而传统的人际交往方式往往会遇到难以排解的问题&#xff0c;比如担心被他人知晓自己的隐私等&#xff0c;这就导致了人…
阅读更多...
鸿蒙系统和安卓系统通过termux搭建Linux系统—Centos

鸿蒙系统和安卓系统通过termux搭建Linux系统—Centos

目录 1. 前言 2. 效果图展示 3. 安装termux 4. 安装Centos系统 4.1 更换源 4.2 拉取镜像 4.3 启动centos 5.结尾 1. 前言 大家好&#xff0c;我是jiaoxingk 今天这篇文章让你能够在手机或者平板上使用Linux-Centos系统 让你随时随地都能操作命令行进行装13 2. 效果图展示…
阅读更多...
【科普知识】伺服电机中的内置制动器

【科普知识】伺服电机中的内置制动器

在工业自动化和机器人技术快速发展的今天&#xff0c;伺服电机作为核心驱动元件&#xff0c;其性能与功能直接影响整个系统的运行效率与稳定性。 近年来&#xff0c;一体化伺服电机技术不断融合创新&#xff0c;并逐步加入了许多新的硬件和软件的功能&#xff0c;为工业自动化领…
阅读更多...
全域外卖是谁创办的公司？

全域外卖是谁创办的公司？

全域外卖是谁创办的公司&#xff1f;这个问题是抽象的。正确的问法应该是全域外卖是谁研发的系统。 在了解全域外卖系统前&#xff0c;我们首先要了解什么是全域外卖&#xff0c;什么是全域团购。全域指的是多平台。当然这个平台是越多越好。实际上也可以理解为聚合外卖、聚合…
阅读更多...
图数据库助力供应链柔性升级

图数据库助力供应链柔性升级

导读 当今市场环境受短视频等流媒体影响&#xff0c;任何风险事件在社交网络中传播速度极其迅速&#xff0c;留给企业的反应时间按分秒计&#xff0c;传统供应链的年度计划面对剧烈变化的市场环境已失去意义。此外&#xff0c;受近年局势动荡的影响&#xff0c;市场需求和供应…
阅读更多...
Unity 资源 之 限时免费的Lowpoly农场动物，等你来领！

Unity 资源 之 限时免费的Lowpoly农场动物，等你来领！

Unity资源 之 Lowpoly farm animals 农村动物 前言资源包内容领取兑换码 前言 Unity 资源商店为大家带来了一份特别的惊喜——限时免费的农场动物资源&#xff01;这是一个充满趣味和实用性的资源包。 资源包内容 在这个资源包中&#xff0c;你可以找到丰富多样的低地养殖动物…
阅读更多...
VScode代码片段自动转图标

VScode代码片段自动转图标

注&#xff1a;在VScode编辑器中&#xff0c;编辑html、vue等文件时&#xff0c;特定代码片段&#xff08;token/xxx’等&#xff09;自动转图标显示&#xff0c;按住“ctrl鼠标左键”还可跳转“https://icones.js.org/collections”&#xff0c;个人感觉干扰代码编写&#xff…
阅读更多...
VMware 安装Windows 7 SP1

VMware 安装Windows 7 SP1

1.下载镜像 迅雷&#xff1a;ed2k://|file|cn_windows_7_enterprise_with_sp1_x64_dvd_u_677685.iso|3265574912|E9DB2607EA3B3540F3FE2E388F8C53C4|/ 2.安装过程 自定义名字&#xff0c;点击【浏览】自定义安装路径 点击【浏览】&#xff0c;选择下载镜像的路径 结束啦~ Win…
阅读更多...
详解http协议

详解http协议

什么是HTTP协议 定义 Http协议即超文本传送协议 (HTTP-Hypertext transfer protocol) 。 它定义了浏览器&#xff08;即万维网客户进程&#xff09;怎样向万维网服务器请求万维网文档&#xff0c;以及服务器怎样把文档传送给浏览器。从层次的角度看&#xff0c;HTTP是面向&am…
阅读更多...
记录一个写SpringBoot中Hive数据可以正常提取但无法存到MySQL的bug

记录一个写SpringBoot中Hive数据可以正常提取但无法存到MySQL的bug

【背景】 我正在用SpringBoot框架写一个数据治理项目&#xff0c;目前所处阶段是将hive和hdfs中的元数据提取出来&#xff0c;存储到MySQL中&#xff0c;我的hive和hdfs上的数据存储在三台Linux服务器上&#xff08;hadoop102-104&#xff09;&#xff0c;MySQL在我本地Window…
阅读更多...
C语言常用的内存操作函数

C语言常用的内存操作函数

在C语言中经常会操作内存中的数据&#xff0c;下面来介绍一下常用的一些内存操作函数。 memcpy memcpy用于从source的位置开始向后复制num个字节到destination的内存位置&#xff0c;其函数原型如下&#xff1a; //destination是目标地址&#xff0c;source是源地址&#xff…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023