golang力扣刷题(一)


title: golang力扣刷题(一)
date: 2021-10-14 21:03:50
categories:

  • go
    tags:
  • 基础

力扣刷题(一)

力扣刷题 全部题目模块(1~30)

简单

山峰数组

符合下列属性的数组 arr 称为 山峰数组(山脉数组) :arr.length >= 3存在 i(0 < i < arr.length - 1)使得:
arr[0] < arr[1] < … arr[i-1] < arr[i] arr[i] > arr[i+1] > … > arr[arr.length - 1] 给定由整数组成的山峰数组 arr ,返回任何满足 arr[0] < arr[1] < … arr[i - 1] < arr[i] > arr[i + 1] > … > arr[arr.length - 1] 的下标 i ,即山峰顶部。

示例 1:

输入:arr = [0,1,0]
输出:1

示例 2:

输入:arr = [1,3,5,4,2]
输出:2
func peakIndexInMountainArray(arr []int) int {var i,j intj=len(arr)-1for i=0;i<j;i++{if (arr[i]>arr[j]) {j=j-1i=i-1}}return i
}从
执行用时:8 ms, 在所有 Go 提交中击败了88.24%的用户
内存消耗:4.5 MB, 在所有 Go 提交中击败了16.18%的用户

两数之和

给定一个整数数组 nums 和一个整数目标值 target,请你在该数组中找出 和为目标值 target 的那 两个 整数,并返回它们的数组下标。你可以假设每种输入只会对应一个答案。但是,数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1:
输入:nums = [2,7,11,15], target = 9
输出:[0,1]
解释:因为 nums[0] + nums[1] == 9 ,返回 [0, 1] 。
示例 2:
输入:nums = [3,2,4], target = 6
输出:[1,2]
func twoSum(nums []int, target int) []int {var i,j int//b:=[]int{}  这里定义的切片已经被赋值,切片是只读对象b:=make([]int, 2)    //var b []intfor i=0;i<len(nums)-1;i++{for j=i+1;j<=len(nums)-1;j++{if(nums[i]+nums[j]==target){            b[0]=ib[1]=j         }}}return b
}
执行用时:36 ms, 在所有 Go 提交中击败了9.31%的用户
内存消耗:3.7 MB, 在所有 Go 提交中击败了87.59%的用户

整数反转

给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。

如果反转后整数超过 32 位的有符号整数的范围 [−231, 231 − 1] ,就返回 0。

假设环境不允许存储 64 位整数(有符号或无符号)。

示例 1:

输入:x = 123
输出:321

示例 2:

输入:x = -123
输出:-321

示例 3:

输入:x = 120
输出:21
func reverse(x int) int {n:=0for (x!=0){n=n*10+x%10x=x/10}if(n<(-2147483648))||(n>(2147483647)){n=0}// max := int(^uint32((0)) >> 1)// min := ^max// if(n<min)||(n>max){//     n=0// }//if(n<(-2^31))||(n>(2^31-1)){ //go语言中^表示按位异或  不是次方  pow(2, 32)//    n=0//}return n
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了64.87%的用户

无符号整型uint,其最小值是0,其二进制表示的所有位都为0,

const UINT_MIN uint = 0

其最大值的二进制表示的所有位都为1,那么,

const UINT_MAX = ^uint(0)

有符号整型int,根据补码,其最大值二进制表示,首位0,其余1,那么,

const INT_MAX = int(^uint(0) >> 1)

根据补码,其最小值二进制表示,首位1,其余0,那么,

const INT_MIN = ^INT_MAX

回文数

给你一个整数 x ,如果 x 是一个回文整数,返回 true ;否则,返回 false 。

回文数是指正序(从左向右)和倒序(从右向左)读都是一样的整数。例如,121 是回文,而 123 不是。

示例 1:

输入:x = 121
输出:true

示例 2:

输入:x = -121
输出:false
解释:从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
func isPalindrome(x int) bool {i:=0a:=xif x<0{return false}for x!=0{i=i*10+x%10x=x/10}if i==a{return true}else {return false}
}
执行用时:20 ms, 在所有 Go 提交中击败了47.91%的用户
内存消耗:4.9 MB, 在所有 Go 提交中击败了91.25%的用户

罗马数字转整数

罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。

字符 数值

I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:

I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
给定一个罗马数字,将其转换成整数。输入确保在 1 到 3999 的范围内。

func romanToInt(s string) int {var mm = []struct { value  stringb int}{{"M", 1000},{"CM", 900},{"D", 500},{"CD", 400},{"C",100},{"XC", 90},{"L",50},{"XL", 40},{"X", 10},{"IX", 9},{"V", 5},{"IV",4},{"I",1},}
x:=0
var ss string
for j:=0;j<len(s);j++{if j+1<len(s) {ss = string(s[j]) + string(s[j+1]) //判断组合}else {ss="d"   //遍历从上到下"MDCXCV" 防止XC  在V前面计算}println(ss)for _,a:=range mm{if ss==a.value{x=x+a.bj=j+1    //for循环后面还要再++  所以+1break}if j==len(s){return x}if string(s[j])==a.value{x=x+a.bbreak}}
}
return x
}
执行用时:24 ms, 在所有 Go 提交中击败了15.05%的用户
内存消耗:3 MB, 在所有 Go 提交中击败了57.37%的用户
var symbolValues = map[byte]int{'I': 1, 'V': 5, 'X': 10, 'L': 50, 'C': 100, 'D': 500, 'M': 1000}func romanToInt(s string) (ans int) {n := len(s)for i := range s {value := symbolValues[s[i]]if i < n-1 && value < symbolValues[s[i+1]] {ans -= value} else {ans += value}}return
}

最长公共前缀

编写一个函数来查找字符串数组中的最长公共前缀。

如果不存在公共前缀,返回空字符串 “”。

示例 1:

输入:strs = ["flower","flow","flight"]
输出:"fl"
func longestCommonPrefix(strs []string) string {x:=make([]rune,0,200)if strs == nil {return string(x)} else {             //不为空时lens:=len(strs[0])for i:=0;i<len(strs);i++{    //找出子串最小长度if lens>len(strs[i]){lens=len(strs[i])}}i, j := 0, 0for j<lens {                  //到最小长度停止d := strs[i][j]for i:=0;i < len(strs); {    if d == strs[i][j] {i++} else {return string(x)}if i == len(strs) {       //遍历到后面  加进去x = append(x, rune(d))}}j++}}return string(x)
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.3 MB, 在所有 Go 提交中击败了89.99%的用户

有效的括号

给定一个只包括 ‘(’,’)’,’{’,’}’,’[’,’]’ 的字符串 s ,判断字符串是否有效。

有效字符串需满足:

左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。

示例 1:

输入:s = "()"
输出:true
type Stack struct {            //定义栈size inttop  intdata []string
}
func isValid(s string) bool {s1 := Stack{}                  //初始化栈s1.size = len(s)s1.top = -1s1.data = make([]string, len(s))for _, a := range s {             //遍历svar b stringif string(a) == ")" {           //设置出栈条件b = "("}if string(a) == "}" {b = "{"}if string(a) == "]" {b = "["}if s1.top > -1 && s1.data[s1.top] == b { //相等出栈s1.top--} else {                                //不等入栈s1.top++s1.data[s1.top] = string(a)}}if s1.top == -1 {                             //判断栈空为truereturn true} else {return false}
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了17.24%的用户

合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

image

输入:l1 = [1,2,4], l2 = [1,3,4]
输出:[1,1,2,3,4,4]
func mergeTwoLists(L1 *ListNode, L2 *ListNode) *ListNode {L3 := &ListNode{-200, L1}               //设置L3.Next=L1head := L3                              //头指针for L1 != nil && L2 != nil {if L1.Val >= L2.Val {                 // 指向小的head.Next = L2println(head.Val)head = head.NextL2 = L2.Next} else {head.Next = L1println(head.Val)head = head.NextL1 = L1.Next}}if L2 != nil {                          //那个不为空 指向它 添到后面head.Next = L2}if L1 != nil {head.Next = L1}return L3.Next
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.5 MB, 在所有 Go 提交中击败了42.80%的用户

删除有序数组中的重复项

给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。

不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

说明:

为什么返回数值是整数,但输出的答案是数组呢?

请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {print(nums[i]);
}
示例 1:
输入:nums = [1,1,2]
输出:2, nums = [1,2]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
func removeDuplicates(nums []int) int {var a, b intif len(nums) == 0 {         //排除一些特殊情况return 0}if len(nums) == 1 {return 1} else {a = nums[0]j := 1for i := 1; i < len(nums); i++ {b = nums[i]if a != b {               //不相等的时候用b,去逐渐取代数组里面的值nums[j] = b             a = nums[j]j++}}return j}
}
执行用时:8 ms, 在所有 Go 提交中击败了84.52%的用户
内存消耗:4.3 MB, 在所有 Go 提交中击败了99.94%的用户

移除元素

给你一个数组 nums 和一个值 val,你需要 原地 移除所有数值等于 val 的元素,并返回移除后数组的新长度。

不要使用额外的数组空间,你必须仅使用 O(1) 额外空间并 原地 修改输入数组。

元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

说明:

为什么返回数值是整数,但输出的答案是数组呢?

请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。

你可以想象内部操作如下:

// nums 是以“引用”方式传递的。也就是说,不对实参作任何拷贝
int len = removeElement(nums, val);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {print(nums[i]);
}
示例 1:
输入:nums = [3,2,2,3], val = 3
输出:2, nums = [2,2]
解释:函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如,函数返回的新长度为 2 ,而 nums = [2,2,3,3] 或 nums = [2,2,0,0],也会被视作正确答案。
func removeElement(nums []int, val int) int {var b intj := 0for i := 0; i < len(nums); i++ {b = nums[i]if b != val {nums[j] = bj++}}return j
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了58.62%的用户

实现strStr()

实现 strStr() 函数。

给你两个字符串 haystack 和 needle ,请你在 haystack 字符串中找出 needle 字符串出现的第一个位置(下标从 0 开始)。如果不存在,则返回 -1 。

说明:

当 needle 是空字符串时,我们应当返回什么值呢?这是一个在面试中很好的问题。

对于本题而言,当 needle 是空字符串时我们应当返回 0 。这与 C 语言的 strstr() 以及 Java 的 indexOf() 定义相符。

示例 1:
输入:haystack = "hello", needle = "ll"
输出:2
func strStr(haystack string, needle string) int {n := len(needle)falge := falsem := -1if len(needle) == 0 {    //排除特殊情况return 0}for a, b := range haystack {if b == rune(needle[0]) && falge == false {   //相等开始遍历m = afalge = true}if a+n > len(haystack) {          //防止数组越界和不必要的遍历return -1}if falge == true {           for d, c := range needle {                 if d == len(haystack) {     //排除len(needle)>len(haystack)的情况return -1}if c != rune(haystack[m]) {   //遇到不一样的返回 break}m++}if m-a == n {             //如果全部遍历完 一样的话 return 下标return a} else {falge = false}}}return m
}
执行用时:380 ms, 在所有 Go 提交中击败了11.06%的用户
内存消耗:2.6 MB, 在所有 Go 提交中击败了65.18%的用户

中等

两数相加

给你两个 非空 的链表,表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的,并且每个节点只能存储 一位 数字。请你将两个数相加,并以相同形式返回一个表示和的链表。你可以假设除了数字 0 之外,这两个数都不会以 0 开头。

输入:l1 = [2,4,3], l2 = [5,6,4]
输出:[7,0,8]
解释:342 + 465 = 807.
示例 2:
输入:l1 = [0], l2 = [0]
输出:[0]
示例 3:
输入:l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出:[8,9,9,9,0,0,0,1]
/*** Definition for singly-linked list.* type ListNode struct {*     Val int*     Next *ListNode* }*/
func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {//传入的l1指针是ListNode结构体类型的dummy := &ListNode{}//定义结构体指针赋值为空for dy,rst :=dummy,0;l1 != nil || l2 != nil || rst !=0;dy = dy.Next{//指针指向同一位置if l1 != nil {rst += l1.Vall1 = l1.Next}if l2 != nil {rst += l2.Vall2 = l2.Next}dy.Next = &ListNode{Val: rst % 10}rst /=10}return dummy.Next
}

无重复字符的最长子串

给定一个字符串 s ,请你找出其中不含有重复字符的 最长子串 的长度。

示例 1:

输入: s = "abcabcbb"
输出: 3 
解释: 因为无重复字符的最长子串是 "abc",所以其长度为 3。

示例 2:

输入: s = "bbbbb"
输出: 1
解释: 因为无重复字符的最长子串是 "b",所以其长度为 1。
func lengthOfLongestSubstring(s string) int {s1 := make([]rune, 0,len(s))max := 0for _, a := range s {flag := truefor j, b := range s1 {if b == a {if len(s1) > max {max= len(s1)}s1 = s1[j+1:]s1 = append(s1, b)flag = false}}if flag {s1 = append(s1, a)if len(s1) > max {max = len(s1)}}}return max  
}
执行用时:12 ms, 在所有 Go 提交中击败了44.77%的用户
内存消耗:2.9 MB, 在所有 Go 提交中击败了55.17%的用户

最长回文子串

给你一个字符串 s,找到 s 中最长的回文子串。

示例 1:

输入:s = "babad"
输出:"bab"
解释:"aba" 同样是符合题意的答案。

示例 2:

输入:s = "cbbd"
输出:"bb"
func longestPalindrome(s string) string {s1:=make([]rune,0,len(s))s2:=make([]rune,0,len(s))var l,r intmax:=0min:=0for _,a:=range s{s1=append(s1,a)}lens:=len(s1)if lens==1{return string(s1[0])}else {for i:=1;i<lens;i++{if s1[i]==s1[i-1]{for l,r=i-1,i;l>=0&&r<lens;{if s[l]==s[r]{if r-l>max-min{max=rmin=l}l--r++}else{break}}for l,r=i-1,i+1;l>=0&&r<lens;{if s[l]==s[r]{if r-l>max-min{max=rmin=l}l--r++}else{break}}}else {for l,r=i-1,i+1;l>=0&&r<lens;{if s[l]==s[r]{if r-l>max-min{max=rmin=l}l--r++}else{break}}}}}s2=s1[min:max+1]return string(s2)
}
执行用时:8 ms, 在所有 Go 提交中击败了67.11%的用户
内存消耗:3.4 MB, 在所有 Go 提交中击败了47.22%的用户

Z字型变换

将一个给定字符串 s 根据给定的行数 numRows ,以从上往下、从左到右进行 Z 字形排列。

比如输入字符串为 “PAYPALISHIRING” 行数为 3 时,排列如下:

P   A   H   N
A P L S I I G
Y   I   R

之后,你的输出需要从左往右逐行读取,产生出一个新的字符串,比如:“PAHNAPLSIIGYIR”。

请你实现这个将字符串进行指定行数变换的函数:

string convert(string s, int numRows);

示例 1:

输入:s = "PAYPALISHIRING", numRows = 3
输出:"PAHNAPLSIIGYIR"

示例 2:

输入:s = "PAYPALISHIRING", numRows = 4
输出:"PINALSIGYAHRPI"
解释:
P     I    N
A   L S  I G
Y A   H R
P     I
func convert(s string, numRows int) string {num:=numRowsj:=len(s)/num+nums1:=make([][]rune,num)for num:=range s1{s1[num]=make([]rune,0,j)}s2:=make([]rune,0,len(s))for _,a:=range s{s2=append(s2,a)}i:=0falg:=trueif num==1{return s}else {for _,b:=range s2{s1[i]=append(s1[i],b)if falg==false{i--if i==(-1){falg=truei=1}}else {i++if i==num{falg=falsei=num-2}}}s4:=make([]rune,0,len(s))for nn:=range s1{for _,mm:=range s1[nn]{s4=append(s4,mm)}}return string(s4)}
}
执行用时:8 ms, 在所有 Go 提交中击败了79.04%的用户
内存消耗:7.3 MB, 在所有 Go 提交中击败了9.95%的用户

字符串转换整数

请你来实现一个 myAtoi(string s) 函数,使其能将字符串转换成一个 32 位有符号整数(类似 C/C++ 中的 atoi 函数)。

函数 myAtoi(string s) 的算法如下:

读入字符串并丢弃无用的前导空格
检查下一个字符(假设还未到字符末尾)为正还是负号,读取该字符(如果有)。 确定最终结果是负数还是正数。 如果两者都不存在,则假定结果为正。
读入下一个字符,直到到达下一个非数字字符或到达输入的结尾。字符串的其余部分将被忽略。
将前面步骤读入的这些数字转换为整数(即,“123” -> 123, “0032” -> 32)。如果没有读入数字,则整数为 0 。必要时更改符号(从步骤 2 开始)。
如果整数数超过 32 位有符号整数范围 [−231, 231 − 1] ,需要截断这个整数,使其保持在这个范围内。具体来说,小于 −231 的整数应该被固定为 −231 ,大于 231 − 1 的整数应该被固定为 231 − 1 。
返回整数作为最终结果。
注意:

本题中的空白字符只包括空格字符 ’ ’ 。
除前导空格或数字后的其余字符串外,请勿忽略 任何其他字符。

func myAtoi(s string) int {var x int =0var falg bool = trues2:=make([]rune,0,len(s))for _,n:=range s{      //去掉前面空格if n==' '{if len(s2)==0{continue}else {s2=append(s2,n)}}else  {s2=append(s2,n)}}if len(s2)==0{return 0}s1:=make([]rune,0,len(s2))i:=0if s2[i]=='+'{i++}else if s2[i]=='-'{i++falg=false}else if s2[i]>57||s2[i]<48{return 0}for i<len(s2){if s2[i]>=48&&s2[i]<=57{   //数字加入字符串s1=append(s1,s2[i])i++}else{break}}s=string(s1)x, _ = strconv.Atoi(s)   //字符串 转换为int 型if falg==true{    //判断正负x=x}else{x=-x}if x>(2147483647){   //判断范围x=2147483647}else if x<(-2147483648){x=-2147483648}return x
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.4 MB, 在所有 Go 提交中击败了11.08%的用户

盛最多水的容器

给你 n 个非负整数 a1,a2,…,an,每个数代表坐标中的一个点 (i, ai) 。在坐标内画 n 条垂直线,垂直线 i 的两个端点分别为 (i, ai) 和 (i, 0) 。找出其中的两条线,使得它们与 x 轴共同构成的容器可以容纳最多的水。

说明:你不能倾斜容器。

示例 1:

image

输入:[1,8,6,2,5,4,8,3,7]
输出:49
解释:图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下,容器能够容纳水(表示为蓝色部分)的最大值为 49。

func maxArea(height []int) int {i:=0j:=len(height)-1     //i,j分别指向首尾var ss,max,ii intfor   i<j{if height[i]<height[j]{ ss=height[i]       //ss=最小值}else {ss=height[j]}ii = ss*(j-i)        //容积ss=ss+1              //ss逐渐增大,两边不够的逐渐排除if height[i]<ss{     i++}if height[j]<ss{j--}if max>ii{         //只保存最大值max=max}else {max=ii}}
return max
}
执行用时:84 ms, 在所有 Go 提交中击败了22.36%的用户
内存消耗:8.6 MB, 在所有 Go 提交中击败了14.00%的用户

整数转罗马数字

罗马数字包含以下七种字符: I, V, X, L,C,D 和 M。

字符          数值
I             1
V             5
X             10
L             50
C             100
D             500
M             1000

例如, 罗马数字 2 写做 II ,即为两个并列的 1。12 写做 XII ,即为 X + II 。 27 写做 XXVII, 即为 XX + V + II 。

通常情况下,罗马数字中小的数字在大的数字的右边。但也存在特例,例如 4 不写做 IIII,而是 IV。数字 1 在数字 5 的左边,所表示的数等于大数 5 减小数 1 得到的数值 4 。同样地,数字 9 表示为 IX。这个特殊的规则只适用于以下六种情况:

I 可以放在 V (5) 和 X (10) 的左边,来表示 4 和 9。
X 可以放在 L (50) 和 C (100) 的左边,来表示 40 和 90。
C 可以放在 D (500) 和 M (1000) 的左边,来表示 400 和 900。
给你一个整数,将其转为罗马数字。

func intToRoman(num int) string {x:=make([]rune,0,10)for num!=0{var m intm=(num/1000)if m==0{var d intd=num/500if d==0{var c intc=num/100if c==0{var l intl=num/50if l==0{var xx intxx=num/10if xx==0{var v intv=num/5if v==0{if num==4{x=append(x,'I')x=append(x,'V')num=0}else{for i:=0;i<num;i++{x=append(x,'I')}num=0}}else{if num/9==1{x=append(x,'I')x=append(x,'X')num=0}else{x=append(x,'V')for i:=0;i<(num%5);i++{x=append(x,'I')}num=0}}}else {if xx==4{x=append(x,'X')x=append(x,'L')num=num%10}else {for i:=0;i<xx;i++{x=append(x,'X')}num=num%10}}}else {if num/90==1{x=append(x,'X')x=append(x,'C')num=num%10}else{x=append(x,'L')for i:=0;i<(num/10)-5;i++{x=append(x,'X')}num=num%10}}}else if c==4{x=append(x,'C')x=append(x,'D')num=num%100}else{for i:=0;i<c;i++{x=append(x,'C')num=num%100}}}else{if num/900==1{x=append(x,'C')x=append(x,'M')num=num%100}else {     //d==1的情况 678x=append(x,'D')for i:=0;i<((num/100)-5);i++{x=append(x,'C')}num=num%100}}}else {for i:=0;i<m;i++{x=append(x,'M')}num=num%1000}}return string(x)
}执行用时:4 ms, 在所有 Go 提交中击败了94.18%的用户
内存消耗:3.3 MB, 在所有 Go 提交中击败了91.04%的用户
var valueSymbols = []struct {   //标准答案  想复杂了value  intsymbol string
}{{1000, "M"},{900, "CM"},{500, "D"},{400, "CD"},{100, "C"},{90, "XC"},{50, "L"},{40, "XL"},{10, "X"},{9, "IX"},{5, "V"},{4, "IV"},{1, "I"},
}func intToRoman(num int) string {roman := []byte{}for _, vs := range valueSymbols {for num >= vs.value {num -= vs.valueroman = append(roman, vs.symbol...)}if num == 0 {break}}return string(roman)
}

三数之和

给你一个包含 n 个整数的数组 nums,判断 nums 中是否存在三个元素 a,b,c ,使得 a + b + c = 0 ?请你找出所有和为 0 且不重复的三元组。

注意:答案中不可以包含重复的三元组。

func threeSum(nums []int) [][]int {s1:=make([][]int,0)
if len(nums)<3{       //前期处理return s1
}
for i:=0;i<len(nums);i++{     //数组排序for j:=i+1;j<len(nums);j++{if nums[i]>nums[j]{nums[i],nums[j]=nums[j],nums[i]}}
}
flag:=false                  //给一个标记
for k:=0;nums[k]<=1&&k<len(nums)-2;k++{    //循环往后找j:=len(nums)-1for i:=k+1;i<j;{if nums[k]+nums[i]+nums[j]>0{          //大于0  后面太大了  向前走j--continue}if nums[k]+nums[i]+nums[j]<0{           //小于0  前面太小了  向后走i++continue}if nums[k]+nums[i]+nums[j]==0{           //等于0   插入数组if len(s1)==0{                           //判断是否为第一组 感觉有点多余s1=append(s1,[]int{nums[k],nums[i],nums[j]})i++                                  //i++ continue不要在往后了continue}else{for _,d:=range s1{                  //先遍历一遍去重if len(d)>0{if nums[k]==d[0]&&nums[i]==d[1]&&nums[j]==d[2] {flag=true                      //找到了 改标记break}}else {break}}if flag==false{                   //看标记插入s1=append(s1,[]int{nums[k],nums[i],nums[j]})i++continue}flag=false}i++}}
}
return s1
}
执行用时:324 ms, 在所有 Go 提交中击败了7.65%的用户
内存消耗:7.4 MB, 在所有 Go 提交中击败了92.49%的用户
func threeSum(nums []int) [][]int {n := len(nums)sort.Ints(nums)    //排序ans := make([][]int, 0)// 枚举 afor first := 0; first < n; first++ {// 需要和上一次枚举的数不相同if first > 0 && nums[first] == nums[first - 1] {continue}// c 对应的指针初始指向数组的最右端third := n - 1target := -1 * nums[first]// 枚举 bfor second := first + 1; second < n; second++ {// 需要和上一次枚举的数不相同if second > first + 1 && nums[second] == nums[second - 1] {continue}// 需要保证 b 的指针在 c 的指针的左侧for second < third && nums[second] + nums[third] > target {third--}// 如果指针重合,随着 b 后续的增加// 就不会有满足 a+b+c=0 并且 b<c 的 c 了,可以退出循环if second == third {break}if nums[second] + nums[third] == target {ans = append(ans, []int{nums[first], nums[second], nums[third]})}}}return ans
}

最接近的三数之和

给定一个包括 n 个整数的数组 nums 和 一个目标值 target。找出 nums 中的三个整数,使得它们的和与 target 最接近。返回这三个数的和。假定每组输入只存在唯一答案。

示例:

输入:nums = [-1,2,1,-4], target = 1
输出:2
解释:与 target 最接近的和是 2 (-1 + 2 + 1 = 2) 。
func threeSumClosest(nums []int, target int) int {sort.Ints(nums)            //排序j := len(nums) - 1max := nums[0] + nums[1] + nums[2]aa := float64(max - target)cc := math.Abs(aa)for k := 0; k < j-1; k++ {    //循环遍历j = len(nums) - 1for i := k + 1; i < j; {kij := nums[k] + nums[i] + nums[j]hhl := float64(kij - target)bb := math.Abs(hhl)if kij < target {     //小了 加一个if cc > bb {cc = bbmax = kij}i++} else if kij > target {    //大了 减一个if cc > bb {cc = bbmax = kij}j--} else {return kij}}}return max
}
执行用时:4 ms, 在所有 Go 提交中击败了96.46%的用户
内存消耗:2.7 MB, 在所有 Go 提交中击败了66.12%的用户

电话号码的字母组合

给定一个仅包含数字 2-9 的字符串,返回所有它能表示的字母组合。答案可以按 任意顺序 返回。

给出数字到字母的映射如下(与电话按键相同)。注意 1 不对应任何字母。

image

示例 1:

输入:digits = "23"
输出:["ad","ae","af","bd","be","bf","cd","ce","cf"]
var ss = [8][]string{     //设二维数组{"a", "b", "c"},{"d", "e", "f"},{"g", "h", "i"},{"j", "k", "l"},{"m", "n", "o"},{"p", "q", "r", "s"},{"t", "u", "v"},{"w", "x", "y", "z"},
}
func letterc(a []string, b []string) []string {   //设置函数处理两个数组var cc []stringfor i := 0; i < len(a); i++ {for j := 0; j < len(b); j++ {cc = append(cc, a[i]+b[j])}}return cc
}
func letterCombinations(digits string) []string {var cc []stringvar digitsint []intfor _, d := range digits {      //处理一下字符串 转int  匹配对应数组dint, _ := strconv.Atoi(string(d))digitsint = append(digitsint, dint)}if len(digits) == 0 {return cc}if len(digits) == 1 {           //分情况讨论cc := ss[digitsint[0]-2]return (cc)}if len(digits) == 2 {a := ss[digitsint[0]-2]b := ss[digitsint[1]-2]cc = letterc(a, b)return cc} else {                        //大于等于3的情况a := ss[digitsint[0]-2]b := ss[digitsint[1]-2]cc = letterc(a, b)for i := 2; i < len(digits); i++ {aaa := ss[digitsint[i]-2]cc = letterc(cc, aaa)}return cc}
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了21.63%的用户

四数之和

给你一个由 n 个整数组成的数组 nums ,和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] (若两个四元组元素一一对应,则认为两个四元组重复):

0 <= a, b, c, d < n
a、b、c 和 d 互不相同
nums[a] + nums[b] + nums[c] + nums[d] == target
你可以按 任意顺序 返回答案 。

示例 1:

输入:nums = [1,0,-1,0,-2,2], target = 0
输出:[[-2,-1,1,2],[-2,0,0,2],[-1,0,0,1]]
func fourSum(nums []int, target int) [][]int {sort.Ints(nums) //数组排序s1 := make([][]int, 0)if len(nums) < 4 {return s1}flag := truefor m := 0; m < len(nums); m++ {for n := m + 1; n < len(nums)-2; n++ {j := len(nums) - 1for i := n + 1; i < j; {num := nums[m] + nums[n] + nums[i] + nums[j]if num < target {i++}if num > target {j--}if num == target {for _, d := range s1 { //先遍历一遍去重if len(d) > 0 {if nums[m] == d[0] && nums[n] == d[1] && nums[i] == d[2] && nums[j] == d[3] {flag = false //找到了 改标记break}} else {break}}if flag == true { //看标记插入s1 = append(s1, []int{nums[m], nums[n], nums[i], nums[j]})i++continue}flag = truei++}}}}return s1
}
执行用时:28 ms, 在所有 Go 提交中击败了15.10%的用户
内存消耗:2.9 MB, 在所有 Go 提交中击败了24.59%的用户

删除链表的倒数第N个节点

给你一个链表,删除链表的倒数第 n 个结点,并且返回链表的头结点。

**进阶:**你能尝试使用一趟扫描实现吗?

image

输入:head = [1,2,3,4,5], n = 2
输出:[1,2,3,5]
package maintype ListNode struct {Val  intNext *ListNode
}func removeNthFromEnd(head *ListNode, n int) *ListNode {p := head      //设两个指针指向头指针q := headc := 0         //给出计数if head.Next == nil {         //排除特殊情况return head.Next}for head.Next != nil {       if c == n {p = p.Next} else {c++                      //计数 直到c==n}head = head.Next}if c == n {                  //去掉这个数p.Next = p.Next.Next}if c < n {                   //排除n==len(数组)return q.Next}return q
}
func main() {list := []int{1, 2, 3, 4, 5}head := &ListNode{Val: list[0]}tail := headfor i := 1; i < len(list); i++ {head.Next = &ListNode{Val: list[i]}head = head.Next}println(tail.Val)println(tail.Next.Val)n := 2x := removeNthFromEnd(tail, n)print(x)
}执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.2 MB, 在所有 Go 提交中击败了99.97%的用户

括号生成

数字 n 代表生成括号的对数,请你设计一个函数,用于能够生成所有可能的并且 有效的 括号组合。

有效括号组合需满足:左括号必须以正确的顺序闭合。

示例 1:
输入:n = 3
输出:["((()))","(()())","(())()","()(())","()()()"]
示例 2:
输入:n = 1
输出:["()"]
func generateParenthesis(n int) []string {
s=make([]string,0)                    //不能为var s []string   append 插不进去
generate(n,0,0,"")                       //设置一个函数 递归调用
return s
}
func generate(n int,l int ,r int,cur string){if r==n&&l==n{                        //左括号数量=右括号数量=n时  插入数组切片s=append(s,cur)return}if l<n{                              //左括号数量小于n时 cur加入“(”generate(n,l+1,r,cur+"(")}if r<n&&r<l{                          //右括号数量小于n切 右括号的数量要小于左括号 cur+")"generate(n,l,r+1,cur+")")}
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.7 MB, 在所有 Go 提交中击败了71.77%的用户

两两交换链表中的节点

给定一个链表,两两交换其中相邻的节点,并返回交换后的链表。

你不能只是单纯的改变节点内部的值,而是需要实际的进行节点交换。

image

输入:head = [1,2,3,4]
输出:[2,1,4,3]
func swapPairs(head *ListNode) *ListNode {var p, q, m *ListNode             //定义三个指针if head == nil {return head} else {he := &ListNode{Val: -1, Next: head} m = he                          //m始终指向p,q前面p = head                        //p在前q = head.Next                   //q在后for p != nil && q != nil {p.Next = q.Nextq.Next = p                    //交换m.Next = qm = p                         //m跟上p = p.Nextif p == nil {                 //结束条件break}q = p.Next}return he.Next}
}
执行用时:0 ms, 在所有 Go 提交中击败了100.00%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了56.09%的用户

两数相除

给定两个整数,被除数 dividend 和除数 divisor。将两数相除,要求不使用乘法、除法和 mod 运算符。

返回被除数 dividend 除以除数 divisor 得到的商。

整数除法的结果应当截去(truncate)其小数部分,例如:truncate(8.345) = 8 以及 truncate(-2.7335) = -2
示例 1:
输入: dividend = 10, divisor = 3
输出: 3
解释: 10/3 = truncate(3.33333..) = truncate(3) = 3
func dd(a int, b int) int {      //返回两个正数的除后的值if b == 1 {             //排除b==1的情况return a}if a > b {i := 1d := b                      //给个记录for a > b {b = b << 1                 //    <<1 相当于乘2i = i << 1}if a < b {                    //证明给高了b = b >> 1                   //除回来i = i >> 1c := a - bfor c >= d {                 //用简单的加法c = c - di++ }} return i                 //返回} else if a == b {       //a==b的情况return 1} else {                  //a<b的情况return 0}
}
func divide(dividend int, divisor int) int {if dividend == 0 {return 0}var b intif dividend < 0 {       //保证给上面函数提供两个正数if divisor > 0 {c := dd((-dividend), divisor)b = -c               //根据情况加负号} else {c := dd(-dividend, -divisor)b = c}} else {if divisor > 0 {c := dd(dividend, divisor)b = c} else {c := dd(dividend, -divisor)b = -c}}if b > (2147483647) { //判断范围b = 2147483647} else if b < (-2147483648) {b = -2147483648}return b
}
执行用时:364 ms, 在所有 Go 提交中击败了58.55%的用户
内存消耗:2.5 MB, 在所有 Go 提交中击败了5.12%的用户

困难

寻找两个正序数组的中位数

给定两个大小分别为 m 和 n 的正序(从小到大)数组 nums1 和 nums2。请你找出并返回这两个正序数组的 中位数 。

示例 1:
输入:nums1 = [1,3], nums2 = [2]
输出:2.00000
解释:合并数组 = [1,2,3] ,中位数 2
示例 2:
输入:nums1 = [1,2], nums2 = [3,4]
输出:2.50000
解释:合并数组 = [1,2,3,4] ,中位数 (2 + 3) / 2 = 2.5
func findMedianSortedArrays(nums1 []int, nums2 []int) float64 {var i,j,m,n,u intm=len(nums1)n=len(nums2)if n<m {nums1,nums2=nums2,nums1m,n=n,m}var x float64nums3:=make([]int,n+m)i,u=0,0for  i<m || j<n {if i==m{for j<n{nums3[u]=nums2[j]u++j++}}else if j==n{for i<m{nums3[u]=nums1[i]i++u++}}else if i<m||j<n {if nums1[i] <= nums2[j] {nums3[u] = nums1[i]println(nums3[u])u++i++} else {nums3[u] = nums2[j]println(nums3[u])u++j++}}}var a,b,y inta=(m+n)%2b=(m+n)/2if a==0{x=(float64(nums3[b-1]+nums3[b]))/2}else {b=(m+n)/2x=float64(nums3[b])println(y)}return x
}

正则表达式匹配

给你一个字符串 s 和一个字符规律 p,请你来实现一个支持 ‘.’ 和 ‘*’ 的正则表达式匹配。

‘.’ 匹配任意单个字符
‘*’ 匹配零个或多个前面的那一个元素
所谓匹配,是要涵盖 整个 字符串 s的,而不是部分字符串。

示例 1:

输入:s = "aa" p = "a"
输出:false
解释:"a" 无法匹配 "aa" 整个字符串。

示例 2:

输入:s = "aa" p = "a*"
输出:true
解释:因为 '*' 代表可以匹配零个或多个前面的那一个元素, 在这里前面的元素就是 'a'。因此,字符串 "aa" 可被视为 'a' 重复了一次。
func isMatch(s string, p string) bool {if len(p) == 0 { //排除p==0的情况if len(s) != 0 {return false}return true}if len(s) == 0 {   //排除S等于0的情况if len(p) == 0 {return false}for i := 0;i < len(p); {   //P不等于0if p[i] != '*' {       //'*' 匹配零个或多个前面的那一个元素if i+1 < len(p)  && p[i+1] == '*'{i+=2         //a* 相当于没有 跳到后面检查continue}return false}else {  //如果p[i] =='*'  return truereturn true}}return true}ss, pp := s[0], p[0]if ss == pp || pp == '.' {if len(p) == 1 {return isMatch(s[1:], p[1:])} else {if p[1] == '*' {match := isMatch(s, p[2:])  // p[1] == '*' 前面可以抵消 返回后面再查一遍if match {return true}match = isMatch(s[1:], p)    //确保第一个匹配   'aa'  'a*'if match {return true}} else {   //都没有问题 s,p缩短一位return isMatch(s[1:], p[1:])}}} else {   //ss != pp || pp != '.'if len(p) == 1 {return false} else {if p[1] == '*' {return isMatch(s, p[2:])}}}return false
}
执行用时:12 ms, 在所有 Go 提交中击败了15.89%的用户
内存消耗:2.1 MB, 在所有 Go 提交中击败了94.79%的用户

合并K个生序链表

给你一个链表数组,每个链表都已经按升序排列。

请你将所有链表合并到一个升序链表中,返回合并后的链表。

示例 1:
输入:lists = [[1,4,5],[1,3,4],[2,6]]
输出:[1,1,2,3,4,4,5,6]
解释:链表数组如下:
[1->4->5,1->3->4,2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6
type ListNode struct {Val  intNext *ListNode
}
func mergeKLists(lists []*ListNode) *ListNode {var p, q, he *ListNodeif len(lists) == 0 {return p}head := &ListNode{Val: 100000, Next: lists[0]}for i := 1; i < len(lists); i++ {he = head                //始终操作第一个数组p = head.Next           q = lists[i]             //q逐个代表后面的数组 插入第一个数组中for q != nil && p != nil {         //和正常两个链表合并一样if p.Val <= q.Val {he.Next = phe = he.Nextp = p.Next} else {he.Next = qhe = he.Nextq = q.Next}}if q != nil {he.Next = q}if p != nil {he.Next = p}}return head.Next
}
func main() {var lists = [][]int{{1, 4, 5},{1, 3, 4},{2, 6},}var tt []*ListNode             //定义指针数组for i := 0; i < len(lists); i++ {       //逐个遍历生成指链表head := &ListNode{Val: lists[i][0]}tail := headfor j := 1; j < len(lists[i]); j++ {head.Next = &ListNode{Val: lists[i][j]}head = head.Next}tt = append(tt, tail)         //插入指针数组}println(tt[0].Val)x := mergeKLists(tt)for x != nil {print(x.Val)x = x.Next}
}
执行用时:104 ms, 在所有 Go 提交中击败了28.10%的用户
内存消耗:5.3 MB, 在所有 Go 提交中击败了54.40%的用户

K个一组翻转链表

给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。

k 是一个正整数,它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

输入:head = [1,2,3,4,5], k = 2
输出:[2,1,4,3,5]

输入:head = [1,2,3,4,5], k = 3
输出:[3,2,1,4,5]
func reverselist(head *ListNode) (l *ListNode, r *ListNode) { var p, q, m *ListNode    //翻转函数,输入123,返回321 的头尾指针p = headq = head.Nextm = q.Nextif m == nil {q.Next = pp.Next = nilreturn q, p}for q != nil {q.Next = pp = qq = mif m.Next != nil {m = m.Next} else {q.Next = pbreak}}head.Next = nilreturn q, head
}
func reverseKGroup(head *ListNode, k int) *ListNode {var pp, qq, h, l, r, left, right *ListNodei := 1if k == 1 {return head}pp = headqq = ppfor pp.Next != nil {pp = pp.Nexti++if i == k {    //相等了就调用上面函数翻转一下i = 1h = pppp = pp.Nexth.Next = nill, r = reverselist(qq)if left == nil && right == nil {left = lright = r} else {right.Next = l             //首尾相接right = r}qq = ppif pp == nil {break}}}right.Next = qq                  //接上剩余部分return left
}
执行用时:4 ms, 在所有 Go 提交中击败了90.01%的用户
内存消耗:3.6 MB, 在所有 Go 提交中击败了99.95%的用户

串联所有单词的子串

给定一个字符串 s 和一些 长度相同 的单词 words 。找出 s 中恰好可以由 words 中所有单词串联形成的子串的起始位置。

注意子串要与 words 中的单词完全匹配,中间不能有其他字符 ,但不需要考虑 words 中单词串联的顺序。

示例 1:
输入:s = "barfoothefoobarman", words = ["foo","bar"]
输出:[0,9]
解释:
从索引 0 和 9 开始的子串分别是 "barfoo" 和 "foobar" 。
输出的顺序不重要, [9,0] 也是有效答案。
//此方法可以得到答案 ,但是超时了
func findblock(s []string, words []string, ) bool {wordss := make([]bool, 0)for a := 0; a < len(words); a++ {   //给words加一个标签 ,遍历到就改变wordss = append(wordss, false)}b := 0for i := 0; i < len(s); i++ {for j := 0; j < len(words); j++ {if s[i] == words[j] && wordss[j] == false {   //遍历到就改变wordss[j] = trueb++                //计数加一break}}}if b == len(words) {       //计数等于len(words)长度 证明全部遍历过了return true} else {return false}
}
func findSubstring(s string, words []string) []int {c := make([]int, 0)blocklen := len(words) * len(words[0]) //滑块长度for i := 0; i < len(s)-blocklen+1; i++ {s1 := s[i : i+blocklen] //滑块s2 := make([]string, 0, len(words))for j := 0; j < len(s1)-len(words[0])+1; {s2 = append(s2, s1[j:j+len(words[0])]) //将滑块分块j += len(words[0])}if findblock(s2, words) { //匹配函数c = append(c, i) //匹配成功将i 加入}}return c
}
//修改版
func findblock(s []string, wordsreceive map[string]int) bool {wordsreceive2 := make(map[string]int, 0)falge := truefor i := 0; i < len(s); i++ {if a, ok := wordsreceive[s[i]]; ok { //如果查到的话if b, ok := wordsreceive2[s[i]]; ok {if b < a { //如果查到了 但b<a去掉重复掉wordsreceive2[s[i]] = b + 1} else {falge = falsebreak}} else { //第一次肯定查不到wordsreceive2[s[i]] = 1 //插入进去}} else {falge = false //没查到break}}return falge
}
func findSubstring(s string, words []string) []int {c := make([]int, 0)blocklen := len(words) * len(words[0]) //滑块长度wordsreceive := make(map[string]int, 0) //创建一个字典,出现相同字典+1for _, bb := range words {wordsreceive[bb] = wordsreceive[bb] + 1println(wordsreceive[bb])}for i := 0; i < len(s)-blocklen+1; i++ {s1 := s[i : i+blocklen] //滑块s2 := make([]string, 0, len(words))for j := 0; j < len(s1)-len(words[0])+1; {s2 = append(s2, s1[j:j+len(words[0])]) //将滑块分块j += len(words[0])}if findblock(s2, wordsreceive) { //匹配函数c = append(c, i) //匹配成功将i 加入}}return c
}
执行用时:56 ms, 在所有 Go 提交中击败了46.46%的用户
内存消耗:7.2 MB, 在所有 Go 提交中击败了31.31%的用户

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

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

相关文章

力扣刷题(二)

title: golang力扣刷题&#xff08;二&#xff09; date: 2021-11-04 10:06:27 categories: go tags:基础 力扣刷题&#xff08;二&#xff09; 力扣刷题 全部题目模块&#xff08;30&#xff5e;60&#xff09; 简单 搜索插入位置 给定一个排序数组和一个目标值&#xff…

Visual Studio无法登录,提示“我们无法添加此账户”解决办法

问题如下&#xff1a; 解决办法&#xff1a; 1.点击菜单栏 “帮助” —— “注册Visual Studio” 2.点击 “账户选项” 3. 如图&#xff0c;选择 “系统 Web 浏览器”&#xff0c;点击 “确定” 4. 返回上一页&#xff0c;点击 “登录” 5.软件会自动跳转到浏览器进行登录验证…

oracle创建完用户无法登陆

create user test identified by test;之后cmd登陆报如下错误 user TEST lacks CREATE SESSION privilege; logon denied 右键用户编辑分配如下权限&#xff0c;问题解决

Windows创建新账户进行登录

前言&#xff1a; 先谈谈为什么我会写这篇文章&#xff0c;既是讲述历史&#xff0c;也是描述场景。如相似可进行相关操作&#xff0c;如不同还望谨慎考虑后操作。 由于工作需要&#xff0c;每天都要开电脑&#xff0c;关电脑。麻烦的是&#xff0c;此电脑上有两个账号且称为A、…

postgres创建用户无法登录

CREATE USER testUser WITH PASSWORD 123456 GRANT USAGE, SELECT ON ALL SEQUENCES IN SCHEMA public TO testUser 然后登录&#xff0c;结果验证失败&#xff0c;解决方案&#xff1a;testUser->testuser就可以了

王小川开怼李彦宏,国产AI大模型研发终于进入“骂街”阶段

经过一段时间的沉寂&#xff0c;因为ChatGPT的出现&#xff0c;国内互联网又恢复了往日的生机&#xff0c;连“激情互怼”的戏码也搬了出来。 在阔别舞台中心一年半后&#xff0c;搜狗前CEO王小川吹响了进军AI大模型的号角&#xff0c;成立百川智能&#xff0c;一口气接受了包括…

【AI新趋势期刊#2】AI发明计算机算法,如何给大模型排行,照片秒变二维码,视频一键动漫风

前言 每天都要浏览大量AI相关新闻&#xff0c;是不是感到信息量爆炸&#xff0c;有效信息少&#xff1f; 这么多新产品和新工具&#xff0c;到底哪些是真正是有价值的&#xff0c;哪些只是浮躁的一时热点&#xff1f; 想参与AI产品和工具的开发&#xff0c;从哪里能够获得大…

2022 年国产编程语言发展总结

近日&#xff0c;OSCHINA 和 Gitee 联合发布了《2022 中国开源开发者报告》。凹语言作者柴树杉在报告中对开源数据库领域进行了解读&#xff0c;以下为原文。 2022 年 8 月&#xff0c;知名的科技视频制作者何同学发布了一个爆款视频《我做了一个自己打字的键盘》。视频中有一个…

华南理工大学与思迈特软件成立【人工智能联合实验室】

3月14日&#xff0c;华南理工大学—广州思迈特软件【人工智能联合实验室】正式揭牌&#xff0c;探索人工智能技术和商业智能产品的融合。广州市科学技术局高新技术处、广州市科学技术局成果与区域创新处、天河区科技工业和信息化局科技发展科、华南理工大学科学技术研究院、华南…

openinstall是什么?看看ChatGPT怎么说

openinstall是什么&#xff1f;openinstall拥有怎样的产品价值和市场地位&#xff1f;今天我们对话“全球最先进的人工智能语言模型”——ChatGPT&#xff0c;通过该超前的聊天机器人更客观全面地了解openinstall。 ChatGPT到底是什么&#xff1f;这是由硅谷人工智能实验室Ope…

论文综述降重小窍门

众所周知&#xff0c;综述最需要解决的问题其实是降重的问题。 毕竟综述就是以引用文献为主&#xff0c;重复率之高&#xff0c;实则惨不忍睹。下面就来看看笔者琢磨出来的「降重神掌」。 SCI降重办法梳理&#xff1a; SCI论文降重是论文发布前必经的步骤&#xff0c;想要顺利…

H5接入微信公众号方法(超详细)

微信官方文档 一、使用真实公众号并认证开发者&#xff0c;或者申请使用测试号 注意&#xff1a; 在微信开发者工具中调试&#xff0c;必须先成为公众号开发者&#xff0c;可以在微信公众号后台进行配置 位置&#xff1a; 公众号后台 > 设置与开发 > 开发者工具 > w…

公众号H5页面接入微信登录流程

起步 首先创建一个项目&#xff0c;我们采用uni-app来作为我们的前端框架 环境安装 全局安装vue-cli npm install -g vue/cli 创建uni-app 使用正式版&#xff08;对应HBuilderX最新正式版&#xff09; vue create -p dcloudio/uni-preset-vue my-project 在安装过程中…

海报的5种处理方式,让你的照片更吸睛

你知道海报应该怎么处理吗&#xff1f;照片是一个作品里最能吸引人注意的&#xff0c;我们可以试一试将照片处理成海报。那么你知道海报式的图片应该怎么处理吗&#xff1f;一起来看看吧&#xff01; 方法一&#xff1a;图形元素强调 如果照片本身的视觉冲击力不强&#xff0c…

AI技术在智能海报设计中的应用

背景 在视觉设计领域中&#xff0c;设计师们往往会因为一些简单需求付出相当多的时间&#xff0c;比如修改文案内容&#xff0c;设计简单的海报版式&#xff0c;针对不同机型、展位的多尺寸拓展等。这些工作需要耗费大量的时间、人力成本&#xff08;5~6张/人日&#xff09;&am…

vue3 antd项目实战——table表格(一文带你快速实现后台管理系统最常用的table表格)

零基础filter实现最简单的table表格 知识调用核心干货下期预告关键字模糊查找&#xff08;纯前端&#xff09;关键字模糊查找&#xff08;前后交互&#xff09; 知识调用 功能实现可能要用到的知识&#xff1a;vue3ant design vuets实战【ant-design-vue组件库引入】vue3项目实…

tf.placeholder代码详解

tf.placeholder(dtype, shape, name) 作用&#xff1a;创建一个类型为dtype&#xff0c;形状为shape&#xff0c;名字为name的一个Tensor类型 返回值&#xff1a;一个tensor类型 注意&#xff1a;tf.placeholder生成的tensor并不能直接print&#xff0c;需要通过sess.run才…

人工智能之线性代数应用

线性代数 1. 从初等函数到高等数学 一元线性函数 在中学的初等数学里,把函数 f ( x ) = k x + b f(x)=kx+b f(x)=kx+b ( k , b k,b k,b是不变量),称为一元线性函数,因为在平面直角坐标系中这个函数的图形就是一条线,就是变量(包括自变量和因变量)之间的映射关系描述为…

《乐队的夏天》刺猬乐队下半年音乐节巡演时间表

《乐队的夏天》总决赛&#xff0c;HOT5乐队诞生&#xff01; 新裤子乐队夺冠&#xff0c;痛仰乐队和刺猬乐队分列第二名和第三名&#xff0c;Click#15和盘尼西林乐队获得第四名和第五名。 在hot5乐队中有这么一支乐队&#xff0c;深得Guitar Pro的喜爱 高晓松评说&#xff1a…

什么是刺猬理念

一、什么是刺猬理念 刺猬理念是指把复杂的世界简化成单个有组织性的观点&#xff0c;一条基本原则或一个基本理念&#xff0c;发挥统帅和指导作用。核心是把事情简单化&#xff0c;把所有的挑战和进退维谷的局面压缩为简单的。 二、刺猬理念的寓言故事 狐狸是一种狡猾的动物&am…