- LCP 1. 猜数字">一、LCP 1. 猜数字
- 1281. 整数的各位积和之差">二、1281. 整数的各位积和之差
- 1290. 二进制链表转整数">三、1290. 二进制链表转整数
- 四、反转字符串
- 771. 宝石与石头">五、771. 宝石与石头
- 六、链表交换
- 七、杨辉三角
- 八、杨辉三角 II
- 九、反转一个单链表。
- 十、斐波那契
- 十一、爬楼梯
- 十二、第二高的薪水(MYSQL)
- 打印从1到最大的n位数">十三、打印从1到最大的n位数
- 统计位数为偶数的数字">十四、统计位数为偶数的数字
- 统计有序矩阵中的负数">十五、统计有序矩阵中的负数
- IP 地址无效化">十六、IP 地址无效化
- 替换空格">十七、替换空格
- 位1的个数">十八、位1的个数
- 大的国家">十九、大的国家
- 解压缩编码列表">二十、解压缩编码列表
- 判定字符是否唯一">二十一、判定字符是否唯一
- URL化">二十二、URL化
一、LCP 1. 猜数字
小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？
输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。
示例 1：
输入：guess = [1,2,3], answer = [1,2,3]输出：3解释：小A 每次都猜对了。
示例 2：
输入：guess = [2,2,3], answer = [3,2,1]输出：1解释：小A 只猜对了第二次。
限制：
guess的长度 = 3answer的长度 = 3guess的元素取值为 {1, 2, 3} 之一。answer的元素取值为 {1, 2, 3} 之一。
答案
func game(guess []int, answer []int) int {num := 0for i,_:= range guess{if guess[i]==answer[i]{num+=1}}return num}## 下面这种效率高func game(guess []int, answer []int) int {num := 0for i,g:= range guess{if g==answer[i]{num+=1}}return num}
二、1281. 整数的各位积和之差
给你一个整数 n，请你帮忙计算并返回该整数「各位数字之积」与「各位数字之和」的差。
示例 1：
输入：n = 234输出：15解释：各位数之积 = 2 * 3 * 4 = 24各位数之和 = 2 + 3 + 4 = 9结果 = 24 - 9 = 15
示例 2：
输入：n = 4421输出：21解释：各位数之积 = 4 * 4 * 2 * 1 = 32各位数之和 = 4 + 4 + 2 + 1 = 11结果 = 32 - 11 = 21
提示：
1 <= n <= 10^5
答案
func subtractProductAndSum(n int) int {var a = [5]int{-1,-1,-1,-1,-1}for i:=0;i<5;i++{if n ==0 {break}a[i] = n%10n = n/10}sum :=0mult :=1for w:= range a{if a[w]==-1{break}sum+=a[w]mult*=a[w]}return mult-sum}# 优化版 一开始太傻逼了。不应该不应该这样想啊func subtractProductAndSum(n int) int {sum :=0mult :=1for i:=0;i<5;i++{sum+= n%10mult*= n%10n = n/10if n ==0 {break}}return mult-sum}
三、1290. 二进制链表转整数
给你一个单链表的引用结点 head。链表中每个结点的值不是 0 就是 1。已知此链表是一个整数数字的二进制表示形式。
请你返回该链表所表示数字的 十进制值 。
示例 1：
输入：head = [1,0,1]输出：5解释：二进制数 (101) 转化为十进制数 (5)
示例 2：
输入：head = [0]输出：0
示例 3：
输入：head = [1]输出：1
示例 4：
输入：head = [1,0,0,1,0,0,1,1,1,0,0,0,0,0,0]输出：18880
示例 5：
输入：head = [0,0]输出：0
提示：
链表不为空。
链表的结点总数不超过 30。
每个结点的值不是 0 就是 1。
这道题巧妙的运运用到了 位运算符 ｜或 &与 运算 这个思想需要谨记
答案
func getDecimalValue(head *ListNode) int {re := 0for tmp := head ; nil != tmp ; {re = (re << 1) | (tmp.Val)tmp = tmp.Next}return re}
四、反转字符串
编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。
不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。
你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。
示例 1：
输入：["h","e","l","l","o"]输出：["o","l","l","e","h"]
示例 2：
输入：["H","a","n","n","a","h"]输出：["h","a","n","n","a","H"]
答案
递归方案
func reverseString(s []byte) {bytes, _ := helper(s, 0)fmt.Printf("%c",bytes)}func helper(s []byte, n int)([]byte, int){i := len(s)if n<i/2{a:=s[n]s[n]=s[i-n-1]s[i-n-1]=an=n+1return helper(s,n)}return s,0}
for循环
func reverseString(s []byte) {w := len(s)for i,j:=range(s){if i<w/2 {s[i]=s[w-i-1]s[w-i-1]=j}}fmt.Printf("%c",s)}
五、771. 宝石与石头
给定字符串J 代表石头中宝石的类型，和字符串 S代表你拥有的石头。 S 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
J 中的字母不重复，J 和 S中的所有字符都是字母。字母区分大小写，因此”a”和”A”是不同类型的石头。
示例 1:
输入: J = "aA", S = "aAAbbbb"输出: 3
示例 2:
输入: J = "z", S = "ZZ"输出: 0
注意:
S 和 J 最多含有50个字母。J 中的字符不重复。
答案：
golang里面没有集合
不过map也是一种好的解决方案（待实现）
func numJewelsInStones(J string, S string) int {var b = []byte(J)var s = []byte(S)n:=0for _, bb := range b{for _, ss := range s{if bb == ss {n=n+1}}}return n}
六、链表交换
给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。
示例:
给定 1->2->3->4, 你应该返回 2->1->4->3.
答案：
/*** Definition for singly-linked list.* type ListNode struct {* Val int* Next *ListNode* }*/func swapPairs(head *ListNode) *ListNode {if head == nil || head.Next == nil {return head}var prev *ListNodecur := headhead = cur.Nextfor ; cur != nil && cur.Next != nil; cur = cur.Next {next := cur.Next//注意：第一次循环时，prev为nilif prev != nil {prev.Next = next}//交换两个节点cur.Next, next.Next, prev = next.Next, cur, cur}return head}
七、杨辉三角
给定一个非负整数 numRows，生成杨辉三角的前 numRows 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 5输出:[[1],[1,1],[1,2,1],[1,3,3,1],[1,4,6,4,1]]
答案
func generate(numRows int) [][]int {var a = [][]int{{1},{1,1}}if(numRows==0){a = [][]int{}return a}if(numRows==1){a = [][]int{{1}}return a}i, _, _ := zy(a, 2, numRows)return i}func zy(a [][]int,n int,numRows int)([][]int,int,int){if n>=numRows{return a,n,numRows}var b = []int{}for i:=0;i<=n;i++{if(i==0||i==n){b=append(b,a[n-1][0])} else {b=append(b,a[n-1][i-1]+a[n-1][i])}}a = append(a,b)n=n+1return zy(a,n,numRows)}
八、杨辉三角 II
给定一个非负索引 k，其中 k ≤ 33，返回杨辉三角的第 k 行。
在杨辉三角中，每个数是它左上方和右上方的数的和。
示例:
输入: 3输出: [1,3,3,1]
答案
func getRow(rowIndex int) []int {var a = [][]int{{1},{1,1}}if(rowIndex==0){b := []int{1}return b}if(rowIndex==1){return a[1]}i, _, _ := zy(a, 2, rowIndex+1)return i[rowIndex]}func zy(a [][]int,n int,numRows int)([][]int,int,int){if n>=numRows{return a,n,numRows}var b = []int{}for i:=0;i<=n;i++{if(i==0||i==n){b=append(b,a[n-1][0])} else {b=append(b,a[n-1][i-1]+a[n-1][i])}}a = append(a,b)n=n+1return zy(a,n,numRows)}
进阶：
你可以优化你的算法到 O(k) 空间复杂度吗？
优化版本
func getRow(rowIndex int) []int {// 第0行nums := []int{1}for i := 1; i <= rowIndex; i++ {// 尾部追加1nums = append(nums, 1)// 倒序计算杨辉三角当前行for j:=i-1;j>0;j--{nums[j]+=nums[j-1]}}return nums}
九、反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL输出: 5->4->3->2->1->NULL
进阶:你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
~~
答案
func reverseList(head *ListNode) *ListNode {if head==nil || head.Next==nil{return head}p := reverseList(head.Next)head.Next.Next = headhead.Next = nilreturn p}
十、斐波那契
斐波那契数，通常用 F(n) 表示，形成的序列称为斐波那契数列。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
给定 N，计算 F(N)。
示例 1：输入：2输出：1解释：F(2) = F(1) + F(0) = 1 + 0 = 1.示例 2：输入：3输出：2解释：F(3) = F(2) + F(1) = 1 + 1 = 2.示例 3：输入：4输出：3解释：F(4) = F(3) + F(2) = 2 + 1 = 3.
提示：
- 0 ≤
N≤ 30var cache map[int]int = make(map[int]int,100)func fib(N int) int {var reault intif cache[N]!= 0 {return cache[N]}if N<2{reault = N}else {reault = fib(N-1)+fib(N-2)}cache[N]=reaultreturn reault}
十一、爬楼梯
假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
注意：给定 n 是一个正整数。
示例 1：
输入： 2输出： 2解释： 有两种方法可以爬到楼顶。1. 1 阶 + 1 阶2. 2 阶
示例 2：
输入： 3输出： 3解释： 有三种方法可以爬到楼顶。1. 1 阶 + 1 阶 + 1 阶2. 1 阶 + 2 阶3. 2 阶 + 1 阶
答案
#动态规划func climbStairs(n int) int {dp:= []int{0}dp=append(dp,1)dp=append(dp,2)for i:=3;i<=n;i++{dp = append(dp,dp[i-1]+dp[i-2])}return dp[n]}
十二、第二高的薪水(MYSQL)
编写一个 SQL 查询，获取 Employee 表中第二高的薪水（Salary） 。
+----+--------+| Id | Salary |+----+--------+| 1 | 100 || 2 | 200 || 3 | 300 |+----+--------+
例如上述 Employee 表，SQL查询应该返回 200 作为第二高的薪水。如果不存在第二高的薪水，那么查询应返回 null。
+---------------------+| SecondHighestSalary |+---------------------+| 200 |+---------------------+
答案
select (select distinct Salary from Employee order by Salary desc limit 1 offset 1 )as SecondHighestSalary
十三、打印从1到最大的n位数
输入数字 n，按顺序打印出从 1 到最大的 n 位十进制数。比如输入 3，则打印出 1、2、3 一直到最大的 3 位数 999。
输入: n = 1
输出: [1,2,3,4,5,6,7,8,9]
func printNumbers(n int) []int {var w []intqq := math.Pow10(n)for i := 1; i < int(qq); i++ {w = append(w, i)}return w}
十四、统计位数为偶数的数字
给你一个整数数组 nums，请你返回其中位数为 偶数 的数字的个数。
示例 1：
输入：nums = [12,345,2,6,7896]
输出：2
解释：
12 是 2 位数字（位数为偶数）
345 是 3 位数字（位数为奇数）
2 是 1 位数字（位数为奇数）
6 是 1 位数字 位数为奇数）
7896 是 4 位数字（位数为偶数）
因此只有 12 和 7896 是位数为偶数的数字
示例 2：
输入：nums = [555,901,482,1771]
输出：1
解释：
只有 1771 是位数为偶数的数字。
提示：
1 <= nums.length <= 500
1 <= nums[i] <= 10^5
func findNumbers(nums []int) int {w:=0for _,v:=range nums{if (v>9&&v<100) ||(v>999&&v<10000){w=w+1}}return w}
十五、统计有序矩阵中的负数
给你一个 m * n 的矩阵 grid，矩阵中的元素无论是按行还是按列，都以非递增顺序排列。
请你统计并返回 grid 中 负数 的数目。
示例 1：
输入：grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
输出：8
解释：矩阵中共有 8 个负数。
示例 2：
输入：grid = [[3,2],[1,0]]
输出：0
示例 3：
输入：grid = [[1,-1],[-1,-1]]
输出：3
示例 4：
输入：grid = [[-1]]
输出：1
提示：
m == grid.length
n == grid[i].length
1 <= m, n <= 100
-100 <= grid[i][j] <= 100
func countNegatives(grid [][]int) int {w:=0for _,v:=range(grid){for _,j:=range(v){if j<0 {w+=1}}}return w}
十六、IP 地址无效化
给你一个有效的 IPv4 地址 address，返回这个 IP 地址的无效化版本。
所谓无效化 IP 地址，其实就是用 “[.]” 代替了每个 “.”。
示例 1：
输入：address = “1.1.1.1”
输出：”1[.]1[.]1[.]1”
示例 2：
输入：address = “255.100.50.0”
输出：”255[.]100[.]50[.]0”
提示：
给出的 address 是一个有效的 IPv4 地址
答案
func defangIPaddr(address string) string {return strings.Replace(address,".","[.]",3)}func defangIPaddr(address string) string {a := strings.Split(address,".")return a[0]+"[.]"+a[1]+"[.]"+a[2]+"[.]"+a[3]}
十七、替换空格
请实现一个函数，把字符串 s 中的每个空格替换成”%20”。
示例 1：
输入：s = “We are happy.”
输出：”We%20are%20happy.”
限制：
0 <= s 的长度 <= 10000
！有点投机取巧
func replaceSpace(s string) string {return strings.Replace(s," ","%20",10000)}
十八、位1的个数
编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。
示例 1：
输入：00000000000000000000000000001011
输出：3
解释：输入的二进制串 00000000000000000000000000001011 中，共有三位为 ‘1’。
示例 2：
输入：00000000000000000000000010000000
输出：1
解释：输入的二进制串 00000000000000000000000010000000 中，共有一位为 ‘1’。
示例 3：
输入：11111111111111111111111111111101
输出：31
解释：输入的二进制串 11111111111111111111111111111101 中，共有 31 位为 ‘1’。
提示：
请注意，在某些语言（如 Java）中，没有无符号整数类型。在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。
在 Java 中，编译器使用二进制补码记法来表示有符号整数。因此，在上面的 示例 3 中，输入表示有符号整数 -3。
进阶:
如果多次调用这个函数，你将如何优化你的算法？
low 答案
func hammingWeight(num uint32) int {nums := fmt.Sprintf("%b", num)return len(strings.Replace(nums, "0", "", 32))}
high 答案
func hammingWeight(num uint32) int {res:=0for {if(num==0){break}num&=num-1res+=1}return res}
十九、大的国家
这里有张 World 表
+————————-+——————+——————+———————+———————-+
| name | continent | area | population | gdp |
+————————-+——————+——————+———————+———————-+
| Afghanistan | Asia | 652230 | 25500100 | 20343000 |
| Albania | Europe | 28748 | 2831741 | 12960000 |
| Algeria | Africa | 2381741 | 37100000 | 188681000 |
| Andorra | Europe | 468 | 78115 | 3712000 |
| Angola | Africa | 1246700 | 20609294 | 100990000 |
+————————-+——————+——————+———————+———————-+
如果一个国家的面积超过300万平方公里，或者人口超过2500万，那么这个国家就是大国家。
编写一个SQL查询，输出表中所有大国家的名称、人口和面积。
例如，根据上表，我们应该输出:
+———————+——————-+———————+
| name | population | area |
+———————+——————-+———————+
| Afghanistan | 25500100 | 652230 |
| Algeria | 37100000 | 2381741 |
+———————+——————-+———————+
select name,population,area from World Where area>3000000 OR population> 25000000;
二十、解压缩编码列表
给你一个以行程长度编码压缩的整数列表 nums 。
考虑每对相邻的两个元素 [a, b] = [nums[2i], nums[2i+1]] （其中 i >= 0 ），每一对都表示解压后有 a 个值为 b 的元素。
请你返回解压后的列表。
示例：
输入：nums = [1,2,3,4]
输出：[2,4,4,4]
解释：第一对 [1,2] 代表着 2 的出现频次为 1，所以生成数组 [2]。
第二对 [3,4] 代表着 4 的出现频次为 3，所以生成数组 [4,4,4]。
最后将它们串联到一起 [2] + [4,4,4] = [2,4,4,4]。
提示：
2 <= nums.length <= 100
nums.length % 2 == 0
1 <= nums[i] <= 100
func decompressRLElist(nums []int) []int {var res []int = []int{}for i := 0; i < len(nums); i = i + 2 {for j := 0; j < nums[i]; j++ {res = append(res, nums[i+1])}}return res}
二十一、判定字符是否唯一
实现一个算法，确定一个字符串 s 的所有字符是否全都不同。
示例 1：
输入: s = “leetcode”
输出: false
示例 2：
输入: s = “abc”
输出: true
限制：
0 <= len(s) <= 100
如果你不使用额外的数据结构，会很加分。
func isUnique(astr string) bool {n := len(astr)var m map[byte]int = make(map[byte]int)for i := 0; i < n; i++ {m[astr[i]] = 0}return n == len(m)}
二十二、URL化
URL化。编写一种方法，将字符串中的空格全部替换为%20。假定该字符串尾部有足够的空间存放新增字符，并且知道字符串的“真实”长度。（注：用Java实现的话，请使用字符数组实现，以便直接在数组上操作。）
示例1:
输入：”Mr John Smith “, 13
输出：”Mr%20John%20Smith”
示例2:
输入：” “, 5
输出：”%20%20%20%20%20”
提示：
字符串长度在[0, 500000]范围内。
func replaceSpaces(S string, length int) string {var w []bytefor i := 0; i < length; i++ {w = append(w, S[i])}return strings.Replace(string(w), " ", "%20", length)}
若有收获，就点个赞吧
0 人点赞
