文心一言 VS 讯飞星火 VS chatgpt (106)-- 算法导论10.1 4题

举报
福大大架构师每日一题 发表于 2023/10/05 21:42:03 2023/10/05
【摘要】 文心一言 VS 讯飞星火 VS chatgpt (106)-- 算法导论10.1 4题43/100发布文章weixin_48502062未选择任何文件 四、用go语言,重写 ENQUEUE 和 DEQUEUE 的代码,使之能处理队列的下溢和上溢。 文心一言:在 Go 语言中,我们可以使用切片来实现队列。下面是如何实现 ENQUEUE 和 DEQUEUE 操作,同时处理队列的下溢和上溢的情况:...

文心一言 VS 讯飞星火 VS chatgpt (106)-- 算法导论10.1 4题
43/100
发布文章
weixin_48502062
未选择任何文件

四、用go语言,重写 ENQUEUE 和 DEQUEUE 的代码,使之能处理队列的下溢和上溢。

文心一言:

在 Go 语言中,我们可以使用切片来实现队列。下面是如何实现 ENQUEUE 和 DEQUEUE 操作,同时处理队列的下溢和上溢的情况:

package main  
  
import "fmt"  
  
type Queue struct {  
    elements []interface{}  
}  
  
// 创建一个新的队列  
func NewQueue() *Queue {  
    return &Queue{}  
}  
  
// ENQUEUE 操作,向队列尾部添加一个元素  
func (q *Queue) Enqueue(value interface{}) {  
    q.elements = append(q.elements, value)  
}  
  
// DEQUEUE 操作,从队列头部移除一个元素  
func (q *Queue) Dequeue() (interface{}, error) {  
    if len(q.elements) == 0 {  
        return nil, fmt.Errorf("队列下溢")  
    }  
    value := q.elements[0]  
    q.elements = q.elements[1:]  
    return value, nil  
}  
  
func main() {  
    queue := NewQueue()  
    // 测试 ENQUEUE 操作  
    queue.Enqueue(1)  
    queue.Enqueue(2)  
    queue.Enqueue(3)  
    fmt.Println(queue.elements) // 输出: [1 2 3]  
    // 测试 DEQUEUE 操作  
    value, err := queue.Dequeue()  
    if err != nil {  
        fmt.Println(err)  
    } else {  
        fmt.Println(value) // 输出: 1  
        fmt.Println(queue.elements) // 输出: [2 3]  
    }  
    // 测试下溢情况  
    value, err = queue.Dequeue()  
    if err != nil {  
        fmt.Println(err) // 输出: 队列下溢  
    } else {  
        fmt.Println(value)   
    }  
}

这个程序中,我们创建了一个名为 Queue 的结构体,它包含一个 elements 切片来存储队列的元素。Enqueue 方法在 elements 切片的尾部添加一个元素,Dequeue 方法从 elements 切片的头部移除一个元素。如果 Dequeue 方法在尝试移除元素时发现队列为空,它将返回一个错误,表示队列下溢。

在这里插入图片描述

在这里插入图片描述

讯飞星火:

要处理队列的下溢和上溢,我们可以在 ENQUEUE 和 DEQUEUE 函数中添加一些条件判断。当队列为空时,将元素添加到队列;当队列满时,从队列中删除一个元素。以下是使用 Go 语言重写的代码:

package main

import "fmt"

type Queue []int

func (q *Queue) Enqueue(v int) {
    if len(*q) < cap(*q) {
        *q = append(*q, v)
    } else {
        for i := len(*q); i > 0; i-- {
            (*q)[i-1] = (*q)[i-2]
        }
        (*q)[0] = v
    }
}

func (q *Queue) Dequeue() int {
    if len(*q) > 0 {
        v := (*q)[0]
        *q = (*q)[1:]
        return v
    }
    return -1
}

func main() {
    q := &Queue{}
    q.Enqueue(1)
    q.Enqueue(2)
    q.Enqueue(3)
    fmt.Println(q.Dequeue()) // 输出 1
    fmt.Println(q.Dequeue()) // 输出 2
    fmt.Println(q.Dequeue()) // 输出 3
    fmt.Println(q.Dequeue()) // 输出 -1,表示队列为空
}

在这个实现中,我们使用了 Go 语言的切片操作来模拟队列。当队列满时,我们将队列中的元素向左移动一位,然后从队列头部插入新元素。当队列为空时,我们返回 -1 作为特殊值表示队列为空。

在这里插入图片描述

在这里插入图片描述

360智脑:

以下是使用go语言重写的ENQUEUE和DEQUEUE函数,以处理队列的下溢和上溢:

package dequeue

import "sync"

type Dequeue struct {
    sync.RWMutex
    elemelem *[]*int
}

func NewDequeue() *Dequeue {
    return &Dequeue{elemelem: []*int{&[]int{}, &[]int{}, &[]int{}}}
}

func (d *Dequeue) Enqueue(elemelem *[]*int) {
    d.RLock()
    defer d.RUnlock()
    if len(*elemelem) == cap(*elemelem) {
        *elemelem = make([]*int, len(*elemelem), cap(*elemelem)*2)
    }
    *elemelem = append(*elemelem, elemelem)
}

func (d *Dequeue) Dequeue() *[]*int {
    d.RLock()
    defer d.RUnlock()
    if len(*elemelem) == 0 {
        return nil
    }
    return (*elemelem)[len(*elemelem)-1]
}

func (d *Dequeue) Len() int {
    d.RLock()
    defer d.RUnlock()
    return len(*elemelem)
}

在以上代码中,我们使用了Go语言的锁机制来保证队列数据的一致性。当队列满时,Enqueue函数会创建一个新的数组来存储数据,以避免下溢;当队列空时,Dequeue函数会返回nil,以避免上溢。同时,我们也添加了Len函数来获取队列的长度。

在这里插入图片描述

在这里插入图片描述

智谱清言:

为了处理队列的上溢和下溢,我们可以使用 Go 语言中的切片和循环来实现。以下是使用 Go 语言重写的 ENQUEUE 和 DEQUEUE 代码:

package main
import (  
	"fmt"  
)
type Queue struct {  
	data []int  
	top  int  
	size int  
}
func (q *Queue) Enqueue(value int) {  
	if q.isFull() {  
		fmt.Println("队列已满,无法入队")  
		return  
	}  
	q.size++  
	q.data = append(q.data, value)  
	q.top++  
}
func (q *Queue) Dequeue() (int, bool) {  
	if q.isEmpty() {  
		fmt.Println("队列已空,无法出队")  
		return 0, false  
	}  
	value := q.data[q.top]  
	q.top--  
	q.size--  
	return value, true  
}
func (q *Queue) isFull() bool {  
	return q.size == cap(q.data)  
}
func (q *Queue) isEmpty() bool {  
	return q.size == 0  
}
func main() {  
	q := &Queue{data: make([]int, 10)}  
	q.Enqueue(1)  
	q.Enqueue(2)  
	q.Enqueue(3)  
	q.Enqueue(4)  
	q.Enqueue(5) // 队列已满,无法入队
	fmt.Println("出队元素:", q.Dequeue())  
	fmt.Println("出队元素:", q.Dequeue())  
	fmt.Println("出队元素:", q.Dequeue())  
	fmt.Println("出队元素:", q.Dequeue())
	fmt.Println("队列已空,无法出队")  
}

在这个示例中,我们使用一个切片data来存储队列中的元素。top表示队列顶部的索引,size表示队列中的元素数量。当队列已满时,Enqueue函数将返回一个错误信息。当队列为空时,Dequeue函数将返回一个错误信息。

在这里插入图片描述

在这里插入图片描述

通义千问:

在Go语言中,队列的下溢和上溢可以通过检查队列是否已满或为空来避免。如果队列已满,我们可以拒绝新元素的添加,这被称为下溢。如果队列为空,我们可以拒绝元素的删除,这被称为上溢。
以下是一个简单的Go语言队列实现,它使用数组来存储队列的元素,并在需要时动态地扩展数组的大小:

package main

import (
	"fmt"
)

type Queue struct {
	size, count int
	elements    []int
}

func NewQueue(size int) *Queue {
	return &Queue{
		size: size,
		count: 0,
		elements: make([]int, size),
	}
}

func (q *Queue) Enqueue(element int) {
	if q.count == q.size {
		fmt.Println("Underflow")
		return
	}
	q.elements[q.count] = element
	q.count++
}

func (q *Queue) Dequeue() int {
	if q.count == 0 {
		fmt.Println("Overflow")
		return 0
	}
	element := q.elements[0]
	for i := 0; i < q.count-1; i++ {
		q.elements[i] = q.elements[i+1]
	}
	q.count--
	return element
}

func main() {
	q := NewQueue(5)
	q.Enqueue(1)
	q.Enqueue(2)
	q.Enqueue(3)
	fmt.Println(q.Dequeue()) // 1
	fmt.Println(q.Dequeue()) // 2
	fmt.Println(q.Dequeue()) // 3
	fmt.Println(q.Dequeue()) // Overflow
	fmt.Println(q.Dequeue()) // Overflow
}

在这个实现中,我们使用一个整数数组来存储队列的元素。当队列满时,我们拒绝新元素的添加,这被称为下溢。当队列为空时,我们拒绝元素的删除,这被称为上溢。我们还打印出“Underflow”和“Overflow”消息,以便我们可以跟踪队列的状态。

在这里插入图片描述

在这里插入图片描述

天工:

以下是使用 Go 语言实现 ENQUEUE 和 DEQUEUE 函数,并处理队列下溢和上溢的代码:

type Queue struct {
    items []int
    head  int
    tail  int
}

func NewQueue() *Queue {
     // 创建一个新的队列
    return &Queue{items: make([]int, 0), head: 0, tail: -1}
}

func (q *Queue) Enqueue(item int) { // 入队操作
    
    // 检查队列是否已满
    if q.tail+1 == len(q.items) {
        fmt.Println("Queue is full. Enqueue operation failed.")
        return
    }
    // 将元素添加到队列尾部
    
    q.items = append(q.items, item)
    q.tail++
    // 维护队列头部指针
    q.head = (q.head + 1) % len(q.items)
}

func (q *Queue) Dequeue() int { // 出队操作

    if q.head == q.tail {
        fmt.Println("Queue is empty. Dequeue operation failed.")
        return -1
    }

    // 获取队头元素
    item := q.items[q.head]
    // 将队头指针向后移一位
    q.head = (q.head + 1) % len(q.items)
    // 维护队尾指针
    q.tail = (q.tail + 1) % len(q.items)
    // 返回出队元素
    return item
}

在上面的代码中,我们使用了两个指针 headtail 来维护队列的状态。当队列满时,Enqueue 操作会返回一个错误信息;当队列为空时,Dequeue 操作也会返回一个错误信息。

此外,我们还使用了模运算来维护队列的循环性质。在 Enqueue 操作中,我们将新元素添加到队列的尾部,并维护队列的尾指针。在 Dequeue 操作中,我们先获取队头元素,然后将队头指针向后移一位,并维护队尾指针。这样就可以实现循环队列的功能。

在这里插入图片描述

在这里插入图片描述

chatgpt:

下面是用Go语言重写的ENQUEUE和DEQUEUE代码,可以处理队列的下溢和上溢:

package main

import (
	"errors"
	"fmt"
)

type Queue struct {
	data   []int
	front  int
	rear   int
	length int
}

func NewQueue(size int) *Queue {
	return &Queue{
		data:   make([]int, size),
		front:  -1,
		rear:   -1,
		length: size,
	}
}

func (q *Queue) IsEmpty() bool {
	return q.front == -1
}

func (q *Queue) IsFull() bool {
	return (q.rear+1)%q.length == q.front
}

func (q *Queue) Enqueue(item int) error {
	if q.IsFull() {
		return errors.New("Queue overflow")
	} else if q.IsEmpty() {
		q.front = 0
	}

	q.rear = (q.rear + 1) % q.length
	q.data[q.rear] = item

	return nil
}

func (q *Queue) Dequeue() (int, error) {
	if q.IsEmpty() {
		return -1, errors.New("Queue underflow")
	}

	item := q.data[q.front]
	if q.front == q.rear {
		q.front, q.rear = -1, -1
	} else {
		q.front = (q.front + 1) % q.length
	}

	return item, nil
}

func main() {
	queue := NewQueue(5)
	queue.Enqueue(1)
	queue.Enqueue(2)
	queue.Enqueue(3)
	queue.Enqueue(4)
	queue.Enqueue(5)

	fmt.Println(queue.Dequeue()) // Output: 1
	fmt.Println(queue.Dequeue()) // Output: 2
	fmt.Println(queue.Dequeue()) // Output: 3
	fmt.Println(queue.Dequeue()) // Output: 4
	fmt.Println(queue.Dequeue()) // Output: 5
	fmt.Println(queue.Dequeue()) // Output: Queue underflow
}

上述代码中,Queue结构体代表一个循环队列,其中front指向队列的第一个元素,rear指向队列的最后一个元素,length表示队列的长度。IsEmptyIsFull方法分别用于判断队列是否为空和是否已满。Enqueue方法将元素入队,如果队列已满则返回错误。Dequeue方法将队列的第一个元素出队,并返回该元素的值,如果队列为空则返回错误。在main函数中展示了队列的使用方式。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

四、用go语言,重写 ENQUEUE 和 DEQUEUE 的代码,使之能处理队列的下溢和上溢。
文心一言:
在 Go 语言中,我们可以使用切片来实现队列。下面是如何实现 ENQUEUE 和 DEQUEUE 操作,同时处理队列的下溢和上溢的情况:

package main

import “fmt”

type Queue struct {
elements []interface{}
}

// 创建一个新的队列
func NewQueue() *Queue {
return &Queue{}
}

// ENQUEUE 操作,向队列尾部添加一个元素
func (q *Queue) Enqueue(value interface{}) {
q.elements = append(q.elements, value)
}

// DEQUEUE 操作,从队列头部移除一个元素
func (q *Queue) Dequeue() (interface{}, error) {
if len(q.elements) == 0 {
return nil, fmt.Errorf(“队列下溢”)
}
value := q.elements[0]
q.elements = q.elements[1:]
return value, nil
}

func main() {
queue := NewQueue()
// 测试 ENQUEUE 操作
queue.Enqueue(1)
queue.Enqueue(2)
queue.Enqueue(3)
fmt.Println(queue.elements) // 输出: [1 2 3]
// 测试 DEQUEUE 操作
value, err := queue.Dequeue()
if err != nil {
fmt.Println(err)
} else {
fmt.Println(value) // 输出: 1
fmt.Println(queue.elements) // 输出: [2 3]
}
// 测试下溢情况
value, err = queue.Dequeue()
if err != nil {
fmt.Println(err) // 输出: 队列下溢
} else {
fmt.Println(value)
}
}
这个程序中,我们创建了一个名为 Queue 的结构体,它包含一个 elements 切片来存储队列的元素。Enqueue 方法在 elements 切片的尾部添加一个元素,Dequeue 方法从 elements 切片的头部移除一个元素。如果 Dequeue 方法在尝试移除元素时发现队列为空,它将返回一个错误,表示队列下溢。

在这里插入图片描述

在这里插入图片描述

讯飞星火:
要处理队列的下溢和上溢,我们可以在 ENQUEUE 和 DEQUEUE 函数中添加一些条件判断。当队列为空时,将元素添加到队列;当队列满时,从队列中删除一个元素。以下是使用 Go 语言重写的代码:

package main

import “fmt”

type Queue []int

func (q *Queue) Enqueue(v int) {
if len(*q) < cap(*q) {
*q = append(*q, v)
} else {
for i := len(*q); i > 0; i-- {
(*q)[i-1] = (*q)[i-2]
}
(*q)[0] = v
}
}

func (q *Queue) Dequeue() int {
if len(*q) > 0 {
v := (*q)[0]
*q = (*q)[1:]
return v
}
return -1
}

func main() {
q := &Queue{}
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Dequeue()) // 输出 1
fmt.Println(q.Dequeue()) // 输出 2
fmt.Println(q.Dequeue()) // 输出 3
fmt.Println(q.Dequeue()) // 输出 -1,表示队列为空
}
在这个实现中,我们使用了 Go 语言的切片操作来模拟队列。当队列满时,我们将队列中的元素向左移动一位,然后从队列头部插入新元素。当队列为空时,我们返回 -1 作为特殊值表示队列为空。

在这里插入图片描述

在这里插入图片描述

360智脑:
以下是使用go语言重写的ENQUEUE和DEQUEUE函数,以处理队列的下溢和上溢:

package dequeue

import “sync”

type Dequeue struct {
sync.RWMutex
elemelem *[]*int
}

func NewDequeue() *Dequeue {
return &Dequeue{elemelem: []*int{&[]int{}, &[]int{}, &[]int{}}}
}

func (d *Dequeue) Enqueue(elemelem *[]*int) {
d.RLock()
defer d.RUnlock()
if len(*elemelem) == cap(*elemelem) {
*elemelem = make([]*int, len(*elemelem), cap(*elemelem)*2)
}
*elemelem = append(*elemelem, elemelem)
}

func (d *Dequeue) Dequeue() *[]*int {
d.RLock()
defer d.RUnlock()
if len(*elemelem) == 0 {
return nil
}
return (*elemelem)[len(*elemelem)-1]
}

func (d *Dequeue) Len() int {
d.RLock()
defer d.RUnlock()
return len(*elemelem)
}
在以上代码中,我们使用了Go语言的锁机制来保证队列数据的一致性。当队列满时,Enqueue函数会创建一个新的数组来存储数据,以避免下溢;当队列空时,Dequeue函数会返回nil,以避免上溢。同时,我们也添加了Len函数来获取队列的长度。

在这里插入图片描述

在这里插入图片描述

智谱清言:
为了处理队列的上溢和下溢,我们可以使用 Go 语言中的切片和循环来实现。以下是使用 Go 语言重写的 ENQUEUE 和 DEQUEUE 代码:

package main
import (
“fmt”
)
type Queue struct {
data []int
top int
size int
}
func (q *Queue) Enqueue(value int) {
if q.isFull() {
fmt.Println(“队列已满,无法入队”)
return
}
q.size++
q.data = append(q.data, value)
q.top++
}
func (q *Queue) Dequeue() (int, bool) {
if q.isEmpty() {
fmt.Println(“队列已空,无法出队”)
return 0, false
}
value := q.data[q.top]
q.top–
q.size–
return value, true
}
func (q *Queue) isFull() bool {
return q.size == cap(q.data)
}
func (q *Queue) isEmpty() bool {
return q.size == 0
}
func main() {
q := &Queue{data: make([]int, 10)}
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
q.Enqueue(4)
q.Enqueue(5) // 队列已满,无法入队
fmt.Println(“出队元素:”, q.Dequeue())
fmt.Println(“出队元素:”, q.Dequeue())
fmt.Println(“出队元素:”, q.Dequeue())
fmt.Println(“出队元素:”, q.Dequeue())
fmt.Println(“队列已空,无法出队”)
}
在这个示例中,我们使用一个切片data来存储队列中的元素。top表示队列顶部的索引,size表示队列中的元素数量。当队列已满时,Enqueue函数将返回一个错误信息。当队列为空时,Dequeue函数将返回一个错误信息。

在这里插入图片描述

在这里插入图片描述

通义千问:
在Go语言中,队列的下溢和上溢可以通过检查队列是否已满或为空来避免。如果队列已满,我们可以拒绝新元素的添加,这被称为下溢。如果队列为空,我们可以拒绝元素的删除,这被称为上溢。
以下是一个简单的Go语言队列实现,它使用数组来存储队列的元素,并在需要时动态地扩展数组的大小:

package main

import (
“fmt”
)

type Queue struct {
size, count int
elements []int
}

func NewQueue(size int) *Queue {
return &Queue{
size: size,
count: 0,
elements: make([]int, size),
}
}

func (q *Queue) Enqueue(element int) {
if q.count == q.size {
fmt.Println(“Underflow”)
return
}
q.elements[q.count] = element
q.count++
}

func (q *Queue) Dequeue() int {
if q.count == 0 {
fmt.Println(“Overflow”)
return 0
}
element := q.elements[0]
for i := 0; i < q.count-1; i++ {
q.elements[i] = q.elements[i+1]
}
q.count–
return element
}

func main() {
q := NewQueue(5)
q.Enqueue(1)
q.Enqueue(2)
q.Enqueue(3)
fmt.Println(q.Dequeue()) // 1
fmt.Println(q.Dequeue()) // 2
fmt.Println(q.Dequeue()) // 3
fmt.Println(q.Dequeue()) // Overflow
fmt.Println(q.Dequeue()) // Overflow
}
在这个实现中,我们使用一个整数数组来存储队列的元素。当队列满时,我们拒绝新元素的添加,这被称为下溢。当队列为空时,我们拒绝元素的删除,这被称为上溢。我们还打印出“Underflow”和“Overflow”消息,以便我们可以跟踪队列的状态。

在这里插入图片描述

在这里插入图片描述

天工:
以下是使用 Go 语言实现 ENQUEUE 和 DEQUEUE 函数,并处理队列下溢和上溢的代码:

type Queue struct {
items []int
head int
tail int
}

func NewQueue() *Queue {
// 创建一个新的队列
return &Queue{items: make([]int, 0), head: 0, tail: -1}
}

func (q *Queue) Enqueue(item int) { // 入队操作

// 检查队列是否已满
if q.tail+1 == len(q.items) {
    fmt.Println("Queue is full. Enqueue operation failed.")
    return
}
// 将元素添加到队列尾部

q.items = append(q.items, item)
q.tail++
// 维护队列头部指针
q.head = (q.head + 1) % len(q.items)

}

func (q *Queue) Dequeue() int { // 出队操作

if q.head == q.tail {
    fmt.Println("Queue is empty. Dequeue operation failed.")
    return -1
}

// 获取队头元素
item := q.items[q.head]
// 将队头指针向后移一位
q.head = (q.head + 1) % len(q.items)
// 维护队尾指针
q.tail = (q.tail + 1) % len(q.items)
// 返回出队元素
return item

}
在上面的代码中,我们使用了两个指针 head 和 tail 来维护队列的状态。当队列满时,Enqueue 操作会返回一个错误信息;当队列为空时,Dequeue 操作也会返回一个错误信息。

此外,我们还使用了模运算来维护队列的循环性质。在 Enqueue 操作中,我们将新元素添加到队列的尾部,并维护队列的尾指针。在 Dequeue 操作中,我们先获取队头元素,然后将队头指针向后移一位,并维护队尾指针。这样就可以实现循环队列的功能。

在这里插入图片描述

在这里插入图片描述

chatgpt:
下面是用Go语言重写的ENQUEUE和DEQUEUE代码,可以处理队列的下溢和上溢:

package main

import (
“errors”
“fmt”
)

type Queue struct {
data []int
front int
rear int
length int
}

func NewQueue(size int) *Queue {
return &Queue{
data: make([]int, size),
front: -1,
rear: -1,
length: size,
}
}

func (q *Queue) IsEmpty() bool {
return q.front == -1
}

func (q *Queue) IsFull() bool {
return (q.rear+1)%q.length == q.front
}

func (q *Queue) Enqueue(item int) error {
if q.IsFull() {
return errors.New(“Queue overflow”)
} else if q.IsEmpty() {
q.front = 0
}

q.rear = (q.rear + 1) % q.length
q.data[q.rear] = item

return nil

}

func (q *Queue) Dequeue() (int, error) {
if q.IsEmpty() {
return -1, errors.New(“Queue underflow”)
}

item := q.data[q.front]
if q.front == q.rear {
	q.front, q.rear = -1, -1
} else {
	q.front = (q.front + 1) % q.length
}

return item, nil

}

func main() {
queue := NewQueue(5)
queue.Enqueue(1)
queue.Enqueue(2)
queue.Enqueue(3)
queue.Enqueue(4)
queue.Enqueue(5)

fmt.Println(queue.Dequeue()) // Output: 1
fmt.Println(queue.Dequeue()) // Output: 2
fmt.Println(queue.Dequeue()) // Output: 3
fmt.Println(queue.Dequeue()) // Output: 4
fmt.Println(queue.Dequeue()) // Output: 5
fmt.Println(queue.Dequeue()) // Output: Queue underflow

}
上述代码中,Queue结构体代表一个循环队列,其中front指向队列的第一个元素,rear指向队列的最后一个元素,length表示队列的长度。IsEmpty和IsFull方法分别用于判断队列是否为空和是否已满。Enqueue方法将元素入队,如果队列已满则返回错误。Dequeue方法将队列的第一个元素出队,并返回该元素的值,如果队列为空则返回错误。在main函数中展示了队列的使用方式。

在这里插入图片描述

在这里插入图片描述

在这里插入图片描述

Markdown 已选中 7402 字数 435 行数 当前行 435, 当前列 0HTML 6129 字数 319 段落

【版权声明】本文为华为云社区用户原创内容,转载时必须标注文章的来源(华为云社区)、文章链接、文章作者等基本信息, 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。