华为od机试面试题目

1.华为机试102道题解

2.华为机考题目

2023年7月30日 19:30~22:00

机考提示&注意事项(考前必看):

1、注意编译环境的变化及语言选择，选自己熟悉的语言机考。

2、机考共3道题，150分钟完成。

3、题目难度为:一星和两星;2道一星的题目，各100分;1道两星的题目，200分;150分合格通过。

4、2道一星题目可以2道题切换来看，优先做最有把握的，但一旦切换到两星题目就不能切换回来看一星的题目!

5、1星题目有把握2道满分通过也好，不建议空白试卷，说不准你刚好差几分，2星题目能帮你得到几分，就刚好能通过哈!

6、Python和iava的通过率高些，听说相对简单些，C/C++相对难些。

7、C一定要选择C语言做，切勿C语言选择

C++做题，因为C++写在C语言不一定编译能通过!同样，C++一定也要用C++语言做!还有C要用标准的VC 6.0编译环境。

8、Java要用标准的eclipse和满足测试标准JDK软件包。

9、机考链接有效期7天。

10、机考前一定要在牛客网题库全部题目(100多道题)刷完，充分准备后才机考，因为机考通过率20%，一旦不通过半年内不得重考，不能参加华为其他面试，刷题链接:

https://www.nowcoder.com/ta/huawei。

11、考前请电脑桌面清理干净，关闭无关的窗口。

12、请使用最新版chrome浏览器作答(72版本以上)，考试过程中需开启摄像头、屏幕录制及手机监控，如果监控异常可能会影响您的成绩。请按指引调试好设备后再开始答题。

13、编程题支持本地IDE编码后复制粘贴至考试页面，不做跳出限制。请勿浏览除本地编译器以外的其他页面，否则会进行风险标识，影响您的成绩。(本地要用满足测试标准的IDE，保证本地编译环境与牛客网一致，考试时一定要在考试环境下进行)。

14、考试时允许使用草稿纸，请提前准备纸笔。考试过程中允许上厕所等短暂离开，但请控制离开时间。

15、考试期间如遇到断电、断网、死机等问题，可以关闭浏览器重新打开试卷链接即可继续做题。

16、遇到问题请及时与HR联系。

17、飞行模式 打开WiFi。

第一题：

题目描述

一贫如洗的樵夫阿里巴巴在去砍柴的路上，无意中发现了强盗集团的藏宝地，藏宝地有编号从0-N的箱子，每个箱子上面贴有一个数字。

阿里巴巴念出一个咒语数字，查看宝箱是否存在两个不同箱子，这两个箱子上贴的数字相同，同时这两个箱了的编号之差的绝对值小于等于咒语数字，

如果存在这样的一对宝箱，请返回最先找到的那对宝箱左边箱子的编号，如果不存在则返回-1

输入描述

第一行输入一个数字字串，数字之间使用逗号分隔，例如: 1,2,3,1

1<=字串中数字个数<=100000

-100000<=每个数字值<=100000

第二行输入咒语数字，例如: 3

1<=咒语数字<=100000

输出描述

存在这样的一对宝箱，请返回最先找到的那对宝箱左边箱子的编号，如果不存在则返回-1

1、

package main
import ( 
"fmt" 
"strings" 
)
func findMatchingBox(nums []int, target int) int { 
boxMap := make(map[int]int)
for i, num := range nums {if j, ok := boxMap[num]; ok && i-j <= target {return j}boxMap[num] = i
}return -1}
func main() { 
var input string 
fmt.Scan(&input)
numsStr := strings.Split(input, ",")
nums := make([]int, len(numsStr))
for i, numStr := range numsStr {fmt.Sscanf(numStr, "%d", &nums[i])
}var target int
fmt.Scan(&target)result := findMatchingBox(nums, target)
fmt.Println(result)}

2、

package mainimport ("fmt""strings"
)func findBoxIndex(nums []int, target int) int {indexMap := make(map[int]int)for i, num := range nums {if prevIndex, ok := indexMap[num]; ok && i-prevIndex <= target {return prevIndex}indexMap[num] = i}return -1
}func main() {var input stringfmt.Scanln(&input)var target intfmt.Scanln(&target)numStrs := strings.Split(input, ",")nums := make([]int, len(numStrs))for i, numStr := range numStrs {fmt.Sscanf(numStr, "%d", &nums[i])}result := findBoxIndex(nums, target)fmt.Println(result)
}

这个程序首先读取输入的数字字串和咒语数字。然后，它将数字字串分割成一个整数切片，并使用 findBoxIndex 函数查找满足条件的宝箱编号。findBoxIndex 函数使用一个哈希映射来记录每个数字最后出现的索引。它遍历数字切片，对于每个数字，检查它是否在哈希映射中已经存在，并且与当前索引的差小于等于咒语数字。如果是，则返回之前出现的索引；否则，将当前索引添加到哈希映射中。如果遍历完整个切片后仍然没有找到满足条件的宝箱，函数返回 -1。

阿里巴巴找黄金宝箱

一贫如洗的樵夫阿里巴巴在去砍柴的路上，无意中发现了强盗集团的藏宝地，藏宝地有编号从0~N的箱子，每个箱子上面贴有一个数字，箱子中可能有一个黄金宝箱。

黄金宝箱满足排在它之前的所有箱子数字和等于排在它之后的所有箱子数字和；第一个箱子左边部分的数字和定义为0；最后一个宝箱右边部分的数字和定义为0。

请帮阿里巴巴找到黄金宝箱，输出第一个满足条件的黄金宝箱编号，如果不存在黄金宝箱，请返回-1。

1、

package main
import ( 
"fmt" 
)
func findGoldenBox(nums []int) int { 
n := len(nums)
// 计算总和
totalSum := 0
for _, num := range nums {totalSum += num
}// 左边部分的和
leftSum := 0// 右边部分的和
rightSum := totalSumfor i := 0; i < n; i++ {rightSum -= nums[i]if leftSum == rightSum {return i}leftSum += nums[i]
}return -1}
func main() { 
var n int fmt.Scan(&n)
nums := make([]int, n)
for i := 0; i < n; i++ {fmt.Scan(&nums[i])
}result := findGoldenBox(nums)
fmt.Println(result)}

第二题：

输入描述：第一行为两个数字M，N，分别表示目录的个数和待查询的目录id，1<=M<=100 ,1<=N<=200。接下来M行，每行为1个目录的数据：目录id本目录中文件大小（子目录id列表），子目录列表中的子目录id 以逗号分隔。

输出描述：带查询目录及其子目录的大小之和。

1、这是一个典型的树状结构的处理问题。我们可以使用深度优先搜索（DFS）或广度优先搜索（BFS）来解决这个问题。下面是一个使用Go实现DFS的示例。

首先，我们需要一个数据结构来表示目录，包括它的id、文件大小，以及它的子目录列表。然后我们需要一个函数来计算一个目录及其所有子目录的文件大小之和。

package mainimport ("bufio""fmt""os""strconv""strings"
)type Directory struct {id     intsize   intchildren []*Directory
}var directoryMap = make(map[int]*Directory)func getSize(dir *Directory) int {totalSize := dir.sizefor _, child := range dir.children {totalSize += getSize(child)}return totalSize
}func main() {scanner := bufio.NewScanner(os.Stdin)scanner.Scan()line := scanner.Text()parts := strings.Split(line, " ")M, _ := strconv.Atoi(parts[0])N, _ := strconv.Atoi(parts[1])for i := 0; i < M; i++ {scanner.Scan()line = scanner.Text()parts = strings.Split(line, " ")id, _ := strconv.Atoi(parts[0])size, _ := strconv.Atoi(parts[1])dir := &Directory{id:     id,size:   size,children: []*Directory{},}directoryMap[id] = dirif len(parts) > 2 {for _, childIdStr := range strings.Split(parts[2], ",") {childId, _ := strconv.Atoi(childIdStr)dir.children = append(dir.children, directoryMap[childId])}}}fmt.Println(getSize(directoryMap[N]))
}

这个程序首先读取目录的数量和待查询的目录id，然后读取每个目录的数据并存储在一个map中。然后，它使用递归函数getSize计算待查询目录及其所有子目录的文件大小之和，并输出结果。

注意：在本示例中，我们假设输入数据是按照从父目录到子目录的顺序给出的，这样我们可以在读取每个目录的数据时立即找到其子目录。如果输入数据不是这样排序的，那么我们需要先读取所有目录的数据，然后再构建目录树。

2、

package mainimport ("fmt"
)type Directory struct {ID       intSize     intSubdirs  []intChildren []*Directory
}func calculateTotalSize(dir *Directory) int {totalSize := dir.Sizefor _, subdirID := range dir.Subdirs {subdir := dir.Children[subdirID]totalSize += calculateTotalSize(subdir)}return totalSize
}func main() {var m, n intfmt.Scanln(&m, &n)directories := make([]*Directory, m+1)for i := 1; i <= m; i++ {var id, size, numSubdirs intfmt.Scanln(&id, &size, &numSubdirs)subdirs := make([]int, numSubdirs)for j := 0; j < numSubdirs; j++ {fmt.Scan(&subdirs[j])}directory := &Directory{ID:      id,Size:    size,Subdirs: subdirs,}directories[id] = directory}for i := 1; i <= m; i++ {directory := directories[i]directory.Children = make([]*Directory, len(directory.Subdirs))for j, subdirID := range directory.Subdirs {subdir := directories[subdirID]directory.Children[j] = subdir}}result := calculateTotalSize(directories[n])fmt.Println(result)
}

首先根据输入的目录数据构建了一个目录树，然后使用递归函数 calculateTotalSize 计算给定目录及其子目录的大小之和。最后打印输出结果。

3、

package main
import ( "fmt" )
type Directory struct { 
ID int 
Size int 
Children []int 
}
func main() { 
var M, N int 
fmt.Scan(&M, &N)
directories := make(map[int]Directory)for i := 0; i < M; i++ {var id, size intvar children []intfmt.Scan(&id, &size)var num intfmt.Scan(&num)for j := 0; j < num; j++ {var childID intfmt.Scan(&childID)children = append(children, childID)}directory := Directory{ID:       id,Size:     size,Children: children,}directories[id] = directory
}result := getDirectorySize(directories, N)
fmt.Println(result)}
func getDirectorySize(directories map[int]Directory, directoryID int) int { 
directory := directories[directoryID] size := directory.Size
for _, childID := range directory.Children {size += getDirectorySize(directories, childID)
}return size}

4、

package mainimport ("bufio""fmt""os""strconv"
)const N = 1000
func dfs(u int, g [][]int, w []int) int {// 初始化为当前目录的大小res := w[u]for _, v := range g[u] {// 获取所有子目录的大小res += dfs(v, g, w)}return res
}func isDigit(c byte) bool {return c >= '0' && c <= '9'
}
func main() {scanner := bufio.NewScanner(os.Stdin)scanner.Split(bufio.ScanWords)scanner.Scan()m, _ := strconv.Atoi(scanner.Text())scanner.Scan()idx, _ := strconv.Atoi(scanner.Text())// g[i] 表示目录 i 的所有一级子目录g := make([][]int, N+1)// w[i] 表示目录 i 的文件大小w := make([]int, N+1)for i := 0; i < m; i++ {scanner.Scan()x, _ := strconv.Atoi(scanner.Text())scanner.Scan()w[x], _ = strconv.Atoi(scanner.Text())scanner.Scan()s := scanner.Text()lenS := len(s)for j := 0; j < lenS; j++ {// 如果不是数字，说明是分隔符if !isDigit(s[j]) {continue}t := 0k := jfor k < lenS && isDigit(s[k]) {t = t*10 + int(s[k]-'0')k += 1}// t 是其中一个子目录，如此由 x 指向 t ，构造出一个目录树g[x] = append(g[x], t)j = k - 1}}// 从查询的目录 idx 开始，求出这个目录和其所有子目录的大小fmt.Println(dfs(idx, g, w))
}

第三题：

题目

给你一个字符串数组，每个字符串均由小写字母组成和一个字符规律由小写字母和.和*组成，识别字符串数组中哪些字符串可以匹配到字符规律上。匹配任意单个字符 * 匹配 0 个或多个任意字符，判断字符串是否匹配，是要头部整个字符串的而不是部分字符串

输入

第一行为空格分割的多个字符串 1 < 单个字符串长度 < 100， 1 < 字符串个数 < 100 ，第二行为字符规律 1 <= 字符规律长度 <= 50 不需要考虑异常场景

输出

匹配的字符串在阵列中的下标（从0开始）多个匹配时，下标升序，并用分隔符分割若均不匹配输出-1

1、

package mainimport ("fmt""strings"
)func isMatch(s, p string) bool {m, n := len(s), len(p)dp := make([][]bool, m+1)for i := range dp {dp[i] = make([]bool, n+1)}dp[0][0] = truefor i := 0; i <= m; i++ {for j := 1; j <= n; j++ {if p[j-1] == '*' {dp[i][j] = dp[i][j-2] || (i > 0 && (s[i-1] == p[j-2] || p[j-2] == '.') && dp[i-1][j])} else {dp[i][j] = i > 0 && (s[i-1] == p[j-1] || p[j-1] == '.') && dp[i-1][j-1]}}}return dp[m][n]
}func findMatchedStrings(strs []string, pattern string) string {var res []intfor i, str := range strs {if isMatch(str, pattern) {res = append(res, i)}}if len(res) == 0 {return "-1"}return strings.Trim(strings.Replace(fmt.Sprint(res), " ", ",", -1), "[]")
}func main() {var strs []stringvar pattern stringfmt.Scan(&strs)fmt.Scan(&pattern)fmt.Println(findMatchedStrings(strs, pattern))
}

该实现中，isMatch 函数用于判断一个字符串是否可以匹配到给定的字符规律上。该函数的实现参考了 LeetCode 上的第 10 题的解法。

findMatchedStrings 函数用于找到所有可以匹配到给定字符规律的字符串的下标。如果没有任何字符串可以匹配到字符规律，则返回 -1。该函数的实现中使用了 strings 和 fmt 包中的函数来格式化输出。

2、

package mainimport ("fmt""strings"
)func matchStrings(stringsArr []string, pattern string) string {var result []stringfor i, str := range stringsArr {if isMatch(str, pattern) {result = append(result, fmt.Sprintf("%d", i))}}if len(result) > 0 {return strings.Join(result, " ")}return "-1"
}func isMatch(str, pattern string) bool {if len(str) != len(pattern) {return false}for i := 0; i < len(str); i++ {if pattern[i] != '.' && pattern[i] != '*' && str[i] != pattern[i] {return false}}return true
}func main() {var stringsArr []stringvar pattern stringfmt.Print("Enter the strings separated by space: ")fmt.Scanf("%s", &stringsArr)fmt.Print("Enter the pattern: ")fmt.Scanf("%s", &pattern)result := matchStrings(stringsArr, pattern)fmt.Println("Output:", result)
}

这个程序首先读取输入的字符串数组和字符规律，然后调用matchStrings函数来进行匹配。在matchStrings函数中，它遍历字符串数组，并检查每个字符串是否与给定的字符规律匹配，如果匹配，则将该字符串的索引添加到结果数组中。最后，它将结果数组转换为字符串并返回。

isMatch函数用于检查单个字符串是否与给定的字符规律匹配。它首先检查字符串长度是否与字符规律长度相同，然后逐个字符进行比较。如果字符规律中的字符不是.或*且与字符串中的字符不匹配，则返回false。

3、可以使用正则表达式来实现字符串的匹配。首先将字符规律转换为正则表达式的格式，然后逐个遍历字符串数组，使用正则表达式进行匹配。

package mainimport ("fmt""regexp""strings"
)func main() {var strs []stringvar pattern string// 读取输入fmt.Scan(&strs)fmt.Scan(&pattern)// 将字符规律转换为正则表达式的格式pattern = strings.ReplaceAll(pattern, ".", "\\.")pattern = strings.ReplaceAll(pattern, "*", ".*")// 构建正则表达式对象reg := regexp.MustCompile("^" + pattern + "$")// 遍历字符串数组，进行匹配matches := make([]int, 0)for i, str := range strs {if reg.MatchString(str) {matches = append(matches, i)}}// 输出匹配的字符串下标if len(matches) > 0 {fmt.Println(strings.Trim(strings.Join(strings.Fields(fmt.Sprint(matches)), " "), "[]"))} else {fmt.Println(-1)}
}

输入示例：

abc def ghi

a.*c

输出示例：

0

输入示例：

abc def ghi

a.*d

输出示例：

-1

3.华为技术面试题目

最长重复子串

描述

定义重复字符串是由两个相同的字符串首尾拼接而成。例如："abcabc" 是一个长度为 6 的重复字符串，因为它由两个 "abc" 串拼接而成；"abcba" 不是重复字符串，因为它不能由两个相同的字符串拼接而成。

给定一个字符串，请返回其最长重复子串的长度。

若不存在任何重复字符子串，则返回 0。

本题中子串的定义是字符串中一段连续的区间。

数据范围：字符串长度不大于 10^3 ，保证字符串一定由小写字母构成。

示例1

输入："ababc"

返回值：4

说明：

abab为最长的重复字符子串，长度为4

示例2

输入："abcab"

返回值：0

说明：

该字符串没有重复字符子串

使用双指针实现

思路：

  1. 遍历字符串，以每个字符为起始点，找出以该字符为起始点的最长重复子串长度。
  2. 对于每个起始点，使用双指针的方式，一个指针从起始点开始，一个指针从起始点的下一个位置开始，依次向后比较两个指针所指的字符是否相同，直到找到不相同的字符，记录下此时的子串长度。
  3. 更新最长重复子串长度。
  4. 返回最长重复子串长度。

代码实现如下：

func longestDupSubstring(s string) int {n := len(s)if n == 0 {return 0}maxLen := 0for i := 0; i < n; i++ {for j := i + 1; j < n; j++ {if s[i] == s[j] {k := 1for i+k < n && j+k < n && s[i+k] == s[j+k] {k++}if k > maxLen {maxLen = k}}}}return maxLen
}

复杂度分析：

  • 时间复杂度：O(n^3)，其中 n 是字符串的长度。两层循环遍历字符串，内部还有一层循环用于查找重复子串。
  • 空间复杂度：O(1)。没有使用额外的空间。

优化时间复杂度

优化时间复杂度是指通过改进算法或数据结构，使得算法的时间复杂度更低，从而提高算法的执行效率。

常见的优化时间复杂度的方法有：

  1. 使用更高效的算法：通过找到更优的算法来解决问题，例如使用快速排序替代冒泡排序等。
  2. 减少循环次数：避免不必要的循环，尽量减少循环的次数。
  3. 使用空间换时间：通过使用额外的数据结构来减少算法的时间复杂度，例如使用哈希表来提高查找的效率。
  4. 剪枝：在搜索算法中，通过剪枝策略来减少搜索空间，从而减少算法的时间复杂度。
  5. 动态规划：通过将问题分解成子问题，并保存子问题的解，避免重复计算，从而减少算法的时间复杂度。
  6. 图算法的优化：例如使用Dijkstra算法替代暴力搜索算法来解决最短路径问题。

需要注意的是，优化时间复杂度往往需要在算法设计的初期进行考虑，而不是在编码的过程中进行优化。同时，优化时间复杂度并不一定总是能够得到最优解，有时候需要权衡时间复杂度和空间复杂度之间的平衡。

使用滑动窗口和哈希表实现

要实现最长重复子串的问题，并且优化时间复杂度，可以使用滑动窗口和哈希表的方法。

具体步骤如下：

  1. 定义两个指针left和right，分别表示滑动窗口的左右边界。
  2. 使用哈希表记录每个字符出现的最新位置。
  3. 初始化最长重复子串的长度maxLen为0。
  4. 遍历字符串，当right指针到达字符串末尾时，结束循环。
  5. 如果当前字符在哈希表中已经存在，并且其最新位置大于等于left指针，则更新left指针为该字符最新位置的下一个位置。
  6. 更新maxLen为当前窗口的长度与maxLen的最大值。
  7. 更新当前字符的最新位置为right指针。
  8. 返回maxLen作为最长重复子串的长度。

以下是使用Golang实现的代码：

func findLongestDuplicateSubstr(s string) int {n := len(s)if n <= 1 {return 0}left, right := 0, 1maxLen := 0lastIndex := make(map[byte]int)for right < n {if lastIndex[s[right]] >= left {left = lastIndex[s[right]] + 1}maxLen = max(maxLen, right-left+1)lastIndex[s[right]] = rightright++}return maxLen
}func max(a, b int) int {if a > b {return a}return b
}

该算法的时间复杂度为O(n)，其中n为字符串的长度。

使用动态规划实现

golang实现最长重复子串的长度，动态规划

这是一个经典的动态规划问题，用Golang实现最长重复子串的长度可以采用动态规划的思路：

  1. 定义一个二维数组dp，dp[i][j]表示以字符串s的第i个字符和第j个字符为结尾的最长重复子串的长度。
  2. 初始化dp数组的第一行和第一列都为0，因为以第一个字符为结尾的子串长度都为0。
  3. 遍历字符串s的每个字符，同时维护一个最大长度maxLen，用来记录当前找到的最长重复子串的长度。
  4. 如果s的第i个字符和第j个字符相等（i ≠ j），则dp[i][j] = dp[i-1][j-1] + 1，表示当前字符可以和前一个字符构成更长的重复子串。
  5. 更新maxLen为dp[i][j]和maxLen中的较大值。
  6. 最后返回maxLen即可。

下面是用Golang实现的代码示例：

func LongestRepeatingSubstring(s string) int {n := len(s)dp := make([][]int, n+1)for i := 0; i <= n; i++ {dp[i] = make([]int, n+1)}maxLen := 0for i := 1; i <= n; i++ {for j := i+1; j <= n; j++ {if s[i-1] == s[j-1] {dp[i][j] = dp[i-1][j-1] + 1maxLen = max(maxLen, dp[i][j])}}}return maxLen
}func max(a, b int) int {if a > b {return a}return b
}

使用时，调用LongestRepeatingSubstring函数并传入要计算的字符串s，即可得到最长重复子串的长度。

使用KMP算法实现

golang实现最长重复子串的长度，KMP

要使用KMP算法实现最长重复子串的长度，需要先理解KMP算法的原理。

KMP算法是一种用于字符串匹配的算法，其核心思想是通过预处理模式串（即要匹配的子串），构建一个next数组，用于在匹配过程中快速跳过已经匹配过的部分。

下面是用Golang实现最长重复子串的长度的KMP算法代码示例：

func LongestRepeatingSubstring(s string) int {n := len(s)// 构建next数组next := make([]int, n)for i := 1; i < n; i++ {j := next[i-1]for j > 0 && s[i] != s[j] {j = next[j-1]}if s[i] == s[j] {j++}next[i] = j}// 找到最长重复子串的长度maxLen := 0for i := 1; i < n; i++ {maxLen = max(maxLen, next[i])}return maxLen
}func max(a, b int) int {if a > b {return a}return b
}

使用时，调用LongestRepeatingSubstring函数并传入要计算的字符串s，即可得到最长重复子串的长度。

注意，这里的KMP算法的实现是用于计算最长重复子串的长度，而不是用于字符串匹配。所以在构建next数组时，每次比较的是s[i]和s[j]，而不是s[i]和s[j+1]。

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

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

相关文章

gin和gorm框架安装

gin和gorm框架安装

理论上只要这两句命令 go get -u gorm.io/gorm go get -u github.com/gin-gonic/gin然而却出现了问题 貌似是代理问题&#xff0c;加上一条命令 go env -w GOPROXYhttps://goproxy.cn,direct 可以成功安装 安装gorm的数据库驱动程序 go get -u gorm.io/driver/mysql
阅读更多...
鸿蒙边缘计算网关正式开售

鸿蒙边缘计算网关正式开售

IDO-IPC3528鸿蒙边缘计算网关基于RK3568研发设计&#xff0c;采用22nm先进工艺制程&#xff0c;四核A55 CPU&#xff0c;主频高达2.0GHz&#xff0c;支持高达8GB高速LPDDR4&#xff0c;1T算力NPU&#xff0c;4K H.265/H264硬解码&#xff1b;视频输出接口HDMI2.0&#xff0c;双…
阅读更多...
大专非科班转码成功自白

大专非科班转码成功自白

大专非科班转码成功自白 文章目录 大专非科班转码成功自白初步学习进阶学习提供阶段面试阶段总结 2023年是博主从业18年以来找工作最难的一年。但程序员这个行业还是被很多毕业生青睐。就业相对比较好&#xff0c;收入相对比较高&#xff0c;虽然面临996&#xff0c;依然给很多…
阅读更多...
vue3中使用toValue

vue3中使用toValue

toValue() 是一个在 3.3 版本中新增的 API。它的设计目的是将 ref 或 getter 规范化为值。如果参数是 ref&#xff0c;它会返回 ref 的值&#xff1b;如果参数是函数&#xff0c;它会调用函数并返回其返回值 示例
阅读更多...
Linux yum 命令，Linux apt 命令

Linux yum 命令，Linux apt 命令

目录 Linux yum 命令 yum 语法 yum常用命令 实例 1 实例 2 实例 3 国内 yum 源
阅读更多...
腾讯云服务器购买流程_三种方法图文指南

腾讯云服务器购买流程_三种方法图文指南

腾讯云服务器购买流程直接在活动上成本更低&#xff0c;在云服务器CVM或轻量应用服务器页面自定义选择比较gui&#xff0c;但是自定义云服务器CPU内存带宽配置选择范围广&#xff0c;活动上只能选择固定的活动机&#xff0c;选择范围窄&#xff0c;但是云服务器成本低。腾讯云服…
阅读更多...
高效处理矢量大数据的高可用解决方案

高效处理矢量大数据的高可用解决方案

高效处理矢量大数据的高可用解决方案 解决方案目标 存储海量矢量数据实时分析海量矢量数据实现海量矢量数据的可视化提供高可用、高性能和高可拓展性解决方案概述 海量数据查询与可视化 系统技术流程 方案一 数据存储: PostgreSQL+PostGIS（矢量数据存储和空间分析）数据服务…
阅读更多...
PAT 1036 Boys vs Girls

PAT 1036 Boys vs Girls

个人学习记录&#xff0c;代码难免不尽人意。 Sample Input 1: 3 Joe M Math990112 89 Mike M CS991301 100 Mary F EE990830 95 Sample Output 1: Mary EE990830 Joe Math990112 6 Sample Input 2: 1 Jean M AA980920 60 Sample Output 2: Absent Jean AA980920 NA #include&…
阅读更多...
MFC计算分贝

MFC计算分贝

分贝的一种定义是&#xff0c;表示功率量之比的一种单位&#xff0c;等于功率强度之比的常用对数的10倍&#xff1b; 主要用于度量声音强度&#xff0c;常用dB表示&#xff1b; 其计算&#xff0c;摘录网上一段资料&#xff1b; 声音的分贝值可以通过以下公式计算&#xff1…
阅读更多...
leetcode做题笔记66

leetcode做题笔记66

给定一个由 整数 组成的 非空 数组所表示的非负整数&#xff0c;在该数的基础上加一。 最高位数字存放在数组的首位&#xff0c; 数组中每个元素只存储单个数字。 你可以假设除了整数 0 之外&#xff0c;这个整数不会以零开头。 思路一&#xff1a;模拟题意 int* plusOne(i…
阅读更多...
NLP 时事和见解【2023】

NLP 时事和见解【2023】

一、说明 AI的新闻当然不是即时的&#xff0c;但作为趋势和苗头&#xff0c;我们不得不做出自己的决定。比如&#xff0c;一些软件的支持是否持续&#xff0c;哪些现成的软件将不再使用&#xff0c;等等。 图片来自中途 以下是NLPlanet为您选择的有关NLP和AI的每周文章&#x…
阅读更多...
Linux命令200例：tree用于以树状结构显示文件和目录

Linux命令200例：tree用于以树状结构显示文件和目录

&#x1f3c6;作者简介&#xff0c;黑夜开发者&#xff0c;全栈领域新星创作者✌。CSDN专家博主&#xff0c;阿里云社区专家博主&#xff0c;2023年6月csdn上海赛道top4。 &#x1f3c6;数年电商行业从业经验&#xff0c;历任核心研发工程师&#xff0c;项目技术负责人。 &…
阅读更多...
android：输入框时局部上移

android：输入框时局部上移

一、我遇到的情况是登录界面&#xff0c;在我输入用户名时下面的输入框被遮挡。很影响美观&#xff0c;于是我就在看很多ap上在你输入时整个界面是不会被遮挡的&#xff0c;我看了其他博主的解决过程后我的也不存在遮挡问题了。 二、我的解决方案: 方法一&#xff1a;在你的A…
阅读更多...
Live800:客服常用的6大提问技巧，帮助客服服务更高效

Live800:客服常用的6大提问技巧，帮助客服服务更高效

作为企业最前线的客服&#xff0c;提升服务质量是必须要做到的&#xff0c;而如何提升服务质量呢&#xff1f;其中一项关键点就是提问技巧。在客户沟通中&#xff0c;提问的方式和技巧直接影响着客户对企业服务的满意度。下面&#xff0c;本文将介绍客服常用的6大提问技巧&…
阅读更多...
lancet: 【推荐】--源码学习

lancet: 【推荐】--源码学习

一个全面、高效、可复用的go语言工具函数库&#xff1b; 可以学习源码的好的地方&#xff0c;这个是个工具库&#xff0c;建议最好的办法是 在项目中导入后&#xff0c;然后查看他的各个源代码进行学习使用 golangd中&#xff0c;查看导入包以及他的源代码&#xff1b; 中文…
阅读更多...
C# Winform DataGridView 数据刷新问题

C# Winform DataGridView 数据刷新问题

目录 一、问题 二、创建项目 三、绑定空的数据源 四、绑定有数据的数据源 五、修改绑定的数据源 六、解决数据源刷新问题 七、解决刷新数据界面闪烁 一、问题 DataGridView 是比较常用的表格控件&#xff0c;在 DataGridView 中显示数据&#xff0c; 一般使用 dataGrid…
阅读更多...
DP（区间DP）

DP（区间DP）

目录 石子合并 合并果子&#xff08;贪心 Huffman树&#xff09; 环形石子合并 石子合并 设有 N 堆石子排成一排&#xff0c;其编号为 1,2,3,…,N。 每堆石子有一定的质量&#xff0c;可以用一个整数来描述&#xff0c;现在要将这 N 堆石子合并成为一堆。 每次只能合并相邻…
阅读更多...
国产低功耗蓝牙HS6621CxC/6621Px系列支持Find My网络功能方案芯片

国产低功耗蓝牙HS6621CxC/6621Px系列支持Find My网络功能方案芯片

目录 什么是“Find My“&#xff1f;HS6621系列简介 什么是“Find My“&#xff1f; “Find My”是苹果公司于19年前推出的针对失物追踪&#xff0c;Find My iPhone&#xff08;查找我的iPhone&#xff09;和Find My Friends&#xff08;查找朋友&#xff09;的结合体应用。为…
阅读更多...
9.2.2Socket(TCP)

9.2.2Socket(TCP)

一.过程: 1.建立连接(不是握手),虽然内核中的连接有很多,但是在应用程序中,要一个一个处理. 2. 获取任务:使用ServerSocket.accept()方法,作用是把内核中的连接获取到应用程序中,这个过程类似于生产者消费者模型. 3. 使用缓冲的时候,注意全缓冲和行缓冲. 4.注意关闭文件资源…
阅读更多...
TCP 三次握手，四次挥手

TCP 三次握手，四次挥手

1、三次握手 第一次握手 SYN 等于1&#xff0c;SeqX 第二次握手 SYN等于1 ACK等于1&#xff0c;SeqY&#xff0c;AckX1 第三次SYN等于0 ACK等于1&#xff0c;SeqX1&#xff0c;AckY1 ackRow都是对应请求seqraw&#xff0c;三次握手后&#xff0c;Seq就是服务器前一个包中的ac…
阅读更多...
最新文章

Copyright @ 2022~2023