目录

179. 最大数 Largest Number  🌟🌟

187. 重复的DNA序列 Repeated DNA Sequences  🌟🌟

🌟 每日一练刷题专栏 🌟

Golang每日一练 专栏

Python每日一练 专栏

C/C++每日一练 专栏

Java每日一练 专栏

---

注：175~178、180~185.为SQL专用题，跳过；186. 188. 已提前做了，链接如下： 

186. 颠倒字符串里的单词 II Reverse Words In A String II  🌟🌟

188. 买卖股票的最佳时机 IV  🌟🌟🌟

---

179. 最大数 Largest Number

给定一组非负整数 nums，重新排列每个数的顺序（每个数不可拆分）使之组成一个最大的整数。

注意：输出结果可能非常大，所以你需要返回一个字符串而不是整数。

示例 1：

输入：nums = [10,2]
输出："210"

示例 2：

输入：nums = [3,30,34,5,9]
输出："9534330"

提示：

• 1 <= nums.length <= 100
• 0 <= nums[i] <= 10^9

代码1： 冒泡排序

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func largestNumber(nums []int) string {
	// 将整数转换成字符串
	strs := make([]string, len(nums))
	for i := 0; i < len(nums); i++ {
		strs[i] = strconv.Itoa(nums[i])
	}
	// Bubble Sort
	for i := 0; i < len(nums); i++ {
		for j := i + 1; j < len(nums); j++ {
			if strs[i]+strs[j] < strs[j]+strs[i] {
				strs[i], strs[j] = strs[j], strs[i]
			}
		}
	}
	// 处理前导0
	i := 0
	for i < len(strs) && strs[i] == "0" {
		i++
	}
	// 拼接结果
	res := strings.Join(strs[i:], "")
	if res == "" {
		return "0"
	}
	return res
}

func main() {
	nums := []int{10, 2}
	fmt.Println(largestNumber(nums))
	nums = []int{3, 30, 34, 5, 9}
	fmt.Println(largestNumber(nums))
}

代码2： 快速排序

package main

import (
	"fmt"
	"strconv"
	"strings"
)

func largestNumber(nums []int) string {
	// 将整数转换成字符串
	strs := make([]string, len(nums))
	for i := 0; i < len(nums); i++ {
		strs[i] = strconv.Itoa(nums[i])
	}
	// 定义排序函数
	var sortFn func(i, j int) bool
	sortFn = func(i, j int) bool {
		return strs[i]+strs[j] >= strs[j]+strs[i]
	}
	// 快速排序
	quickSort(strs, sortFn, 0, len(nums)-1)
	// 处理前导0
	i := 0
	for i < len(strs) && strs[i] == "0" {
		i++
	}
	// 拼接结果
	res := strings.Join(strs[i:], "")
	if res == "" {
		return "0"
	}
	return res
}

func quickSort(strs []string, sortFn func(i, j int) bool, start, end int) {
	if start >= end {
		return
	}
	pivot := partition(strs, sortFn, start, end)
	quickSort(strs, sortFn, start, pivot-1)
	quickSort(strs, sortFn, pivot+1, end)
}

func partition(strs []string, sortFn func(i, j int) bool, start, end int) int {
	i := start
	for j := start; j < end; j++ {
		if sortFn(j, end) {
			strs[i], strs[j] = strs[j], strs[i]
			i++
		}
	}
	strs[i], strs[end] = strs[end], strs[i]
	return i
}

func main() {
	nums := []int{10, 2}
	fmt.Println(largestNumber(nums))
	nums = []int{3, 30, 34, 5, 9}
	fmt.Println(largestNumber(nums))
}

代码3： 整数转字符串后排序

package main

import (
	"fmt"
	"sort"
	"strconv"
	"strings"
)

func largestNumber(nums []int) string {
	// 将整数转换成字符串
	strs := make([]string, len(nums))
	for i := 0; i < len(nums); i++ {
		strs[i] = strconv.Itoa(nums[i])
	}
	// 自定义排序函数
	sort.Slice(strs, func(i, j int) bool {
		return strs[i]+strs[j] >= strs[j]+strs[i]
	})
	// 处理前导0
	i := 0
	for i < len(strs) && strs[i] == "0" {
		i++
	}
	// 拼接结果
	res := strings.Join(strs[i:], "")
	if res == "" {
		return "0"
	}
	return res
}

func main() {
	nums := []int{10, 2}
	fmt.Println(largestNumber(nums))
	nums = []int{3, 30, 34, 5, 9}
	fmt.Println(largestNumber(nums))
}

输出：

210
9534330

---

187. 重复的DNA序列 Repeated DNA Sequences

DNA序列 由一系列核苷酸组成，缩写为 'A', 'C', 'G' 和 'T'.。

• 例如，"ACGAATTCCG" 是一个 DNA序列 。

在研究 DNA 时，识别 DNA 中的重复序列非常有用。

给定一个表示 DNA序列 的字符串 s ，返回所有在 DNA 分子中出现不止一次的 长度为 10 的序列(子字符串)。你可以按 任意顺序 返回答案。

示例 1：

输入：s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
输出：["AAAAACCCCC","CCCCCAAAAA"]

示例 2：

输入：s = "AAAAAAAAAAAAA"
输出：["AAAAAAAAAA"]

提示：

• 0 <= s.length <= 10^5
• s[i]=='A'、'C'、'G' or 'T'

 代码1： 哈希表

package main

import "fmt"

func findRepeatedDnaSequences(s string) []string {
	// 定义一个哈希表
	cnt := make(map[string]int)
	// 遍历s，将所有长度为10的子串出现的次数存入哈希表
	for i := 0; i <= len(s)-10; i++ {
		cnt[s[i:i+10]]++
	}
	// 找到出现次数超过1的子串即可
	res := make([]string, 0)
	for k, v := range cnt {
		if v > 1 {
			res = append(res, k)
		}
	}
	return res
}

func main() {
	s := "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
	fmt.Println(findRepeatedDnaSequences(s))
	s = "AAAAAAAAAAAAA"
	fmt.Println(findRepeatedDnaSequences(s))
}

 代码2： 滑动窗口+哈希表

package main

import "fmt"

func findRepeatedDnaSequences(s string) []string {
	// 定义一个哈希表
	cnt := make(map[string]int)
	// 定义一个滑动窗口，移动长度为10
	left, right := 0, 9
	for right < len(s) {
		// 统计子串出现的次数
		cnt[s[left:right+1]]++
		left++
		right++
	}
	// 找到出现次数超过1的子串即可
	res := make([]string, 0)
	for k, v := range cnt {
		if v > 1 {
			res = append(res, k)
		}
	}
	return res
}

func main() {
	s := "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
	fmt.Println(findRepeatedDnaSequences(s))
	s = "AAAAAAAAAAAAA"
	fmt.Println(findRepeatedDnaSequences(s))
}

 代码3： 位运算+哈希表

package main

import "fmt"

func findRepeatedDnaSequences(s string) []string {
	// 构造哈希表
	cnt := make(map[int]int)
	// 将 A、C、G、T 四种核苷酸转换成二进制数
	toInt := func(c byte) int {
		switch c {
		case 'A':
			return 0
		case 'C':
			return 1
		case 'G':
			return 2
		case 'T':
			return 3
		}
		return -1
	}
	// 遍历字符串，将每个长度为10的子串存入哈希表
	left := 0
	nums := make([]int, len(s))
	for i := 0; i < len(s); i++ {
		nums[i] = toInt(s[i])
		if i-left+1 > 10 {
			left++
		}
		if i-left+1 == 10 {
			// 使用位运算计算10个二进制数组成的哈希值
			hash := 0
			for j := left; j <= i; j++ {
				hash = (hash << 2) | nums[j]
			}
			cnt[hash]++
		}
	}
	// 找到出现次数大于1的子串即可
	res := make([]string, 0)
	for k, v := range cnt {
		if v > 1 {
			sub := make([]byte, 10)
			for i := 9; i >= 0; i-- {
				sub[i] = byte(k & 3)
				k >>= 2
			}
			for i := 0; i < 10; i++ {
				switch sub[i] {
				case 0:
					sub[i] = 'A'
				case 1:
					sub[i] = 'C'
				case 2:
					sub[i] = 'G'
				case 3:
					sub[i] = 'T'
				}
			}
			res = append(res, string(sub))
		}
	}
	return res
}

func main() {
	s := "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
	fmt.Println(findRepeatedDnaSequences(s))
	s = "AAAAAAAAAAAAA"
	fmt.Println(findRepeatedDnaSequences(s))
}

输出：

[CCCCCAAAAA AAAAACCCCC]
[AAAAAAAAAA]

---

🌟 每日一练刷题专栏 🌟

✨ 持续，努力奋斗做强刷题搬运工！

👍 点赞，你的认可是我坚持的动力！ 

🌟 收藏，你的青睐是我努力的方向！ 

✎ 评论，你的意见是我进步的财富！  

☸ 主页：https://hannyang.blog.csdn.net/ 

	Golang每日一练 专栏
	Python每日一练 专栏
	C/C++每日一练 专栏
	Java每日一练 专栏