package main
import "fmt"
func isInterval(intervalList [][]int, number int) string {
var (
high = len(intervalList)
low = 0
)
for high > low {
mid := (high + low) / 2
if intervalList[mid][0] > number {
high = mid
} else if intervalList[mid][1] < number {
low = mid + 1
} else {
return "True"
}
}
return "FALSE"
}
func main() {
/*
问题描述: 给定一个数组,长度是 1000,。给定一个 number,判断 number 是否在这些区间内,返回 True 或者 False
问题举例: 输入:List = [[100, 1100], [1000, 2000], [5500, 6500]],number = 6000 输出: True
*/
var intervalList = [][]int{
[]int{100, 1100},
[]int{1000, 2000},
[]int{5500, 6500},
}
var number = 6000
fmt.Println(isInterval(intervalList, number))
}
package main
import "fmt"
func dotProduct(a []int, b []int) int {
if len(a) == 0 || len(b) == 0 || len(a) != len(b) {
return -1
}
ans := 0
for i := 0; i < len(a); i++ {
ans += a[i] + b[i]
}
return ans
}
func main() {
/*
求点积
问题描述: 给出两个数组,求他们的点积
问题示例: A = [1, 1, 1] B = [2, 2, 2] 输出: 6
A = [3, 2] B = [2, 3, 3] 输出: -1 (没有点积)
*/
a := []int{1, 1, 1}
b := []int{2, 2, 2}
fmt.Println(dotProduct(a, b))
}
package main
import (
"fmt"
"sort"
)
func isTwin(s string, t string) string {
var (
oddS []int
evenS []int
oddT []int
evenT []int
sByte = []byte(s)
tByte = []byte(t)
)
if len(sByte) != len(tByte) {
return "No"
}
for i := 0; i < len(sByte); i++ {
if i&1 == 1 {
oddS = append(oddS, int(sByte[i]))
oddT = append(oddT, int(tByte[i]))
} else {
evenS = append(evenS, int(sByte[i]))
evenT = append(evenT, int(tByte[i]))
}
}
sort.Sort(sort.IntSlice(oddS))
sort.Sort(sort.IntSlice(oddT))
sort.Sort(sort.IntSlice(evenS))
sort.Sort(sort.IntSlice(evenT))
for i := 0; i < len(oddS); i++ {
if oddS[i] != oddT[i] {
return "No"
}
}
for i := 0; i < len(evenS); i++ {
if evenS[i] != evenT[i] {
return "No"
}
}
return "YES"
}
func main() {
/*
双胞胎字符串
问题描述: 给定两个字符串 s 和 t,每次可以任意交换 s 的奇数位或偶数位上的字符,问能否经过若干次交换,使 s 变成 t
问题示例: s = "abcd" t = "cdab" 输出: "YES", s = "abcd" t = "bcda" 输出: "NO"
*/
s := "abcd"
t := "bcda"
fmt.Println(isTwin(s, t))
}
package main
import (
"fmt"
"strings"
)
func wordCounter(s string) int {
var ans int = 0
words := strings.Split(s, " ")
for _, value := range words {
if value != "" {
ans++
}
}
return ans
}
func main() {
/*
计算单词数量
问题描述: 计算字符串中的单词数,其中一个单词的定义为不含空格的连续字符串
问题示例: 输入: "Hello, my name is Jack" 输出: 5
*/
s := "Hello, my name is Jack"
fmt.Println(wordCounter(s))
}
package main
import "fmt"
func nextGreaterElement(nums1 []int, nums2 []int) []int {
var (
m = make(map[int]int)
stack []int
)
for _, v := range nums2 {
if len(stack) != 0 && v > stack[len(stack)-1] {
m[stack[len(stack)-1]] = v
stack = stack[:len(stack)-1]
}
stack = append(stack, v)
}
for len(stack) != 0 {
m[stack[len(stack)-1]] = -1
stack = stack[:len(stack)-1]
}
for k, v := range nums1 {
nums1[k] = m[v]
}
return nums1
}
func main() {
/*
下一个更大的数
问题描述: 两个不重复的数组,nums1 和 nums2,其中 nums1 是 nums2 的子集。在 nums2 的相应位置找到 nums 所有元素的下一个更大的数字。若不存在,则输出-1 nums1 和 nums2 中所有数字都是唯一的,且长度不超过 1000
问题示例: 输入: nums1 = [4, 1, 2] nums2 = [1, 3, 4, 2] 输出: [-1, 3, -1] 注: 对于 nums1 中的 4,在 nums2 中没有找到更大的数字,所以返回-1;其余数字一次类推
*/
nums1 := []int{4, 1, 2}
nums2 := []int{1, 3, 4, 2}
fmt.Println(nextGreaterElement(nums1, nums2))
}
package main
import (
"fmt"
"sort"
"strconv"
)
func main() {
/*
问题描述: 全运会期间,根据 N 名运动员得分情况,找到相对等级和获得最高分的 3 人,分别获得金、银、铜牌。N 是正整数,且不超过 10000。运动员成绩默认唯一。
问题示例: 输入: [5, 4, 3, 2, 1] 输出: ["金牌", "银牌", "铜牌", "4", "5"] 注: 前三名成绩较高,获得金银铜,对于后两位运动员,只输出相对等级 (排名),第四、第五名
*/
nums := []int{5, 4, 3, 1, 2}
m := make(map[string]int)
numsLen := len(nums)
answer := make([]string, numsLen)
for i := 0; i < numsLen; i++ {
m[strconv.Itoa(nums[i])] = i
}
sort.Sort(sort.Reverse(sort.IntSlice(nums)))
for i := 0; i < numsLen; i++ {
res := strconv.Itoa(i + 1)
if i == 0 {
res = "金牌"
} else if i == 1 {
res = "银牌"
} else if i == 2 {
res = "铜牌"
}
answer[m[strconv.Itoa(nums[i])]] = res
}
fmt.Println(answer)
}
package main
import "fmt"
func printStar() {
conf := 0 // 配置、终端默认设置
bg := 0 // 背景色、终端默认设置
text := 31 // 前景色、红色
fmt.Printf("%c[%d;%d;%dm%s%c[0m", 0x1B, conf, bg, text, "*", 0x1B)
}
func main() {
/*
画出一个红色的五角星
*/
/*这是五角星的上面一个角*/
for i := 1; i < 6; i++ {
for j := 1; j < 19-i; j++ {
fmt.Printf(" ")
}
for k := 1; k <= 2*i-1; k++ {
printStar()
}
fmt.Println()
}
/*这是五角星的中间两个角*/
for i := 1; i < 5; i++ {
for j := 1; j < 3*i-3; j++ {
fmt.Printf(" ")
}
for k := 1; k < 42-6*i; k++ {
printStar()
}
fmt.Println()
}
/*这是中间与下部相接的部分*/
for i := 1; i < 3; i++ {
for j := 1; j < 12-i; j++ {
fmt.Printf(" ")
}
for k := 1; k < 12+2*i; k++ {
printStar()
}
fmt.Println()
}
/*这是五角星的下面两个角*/
for i := 1; i < 5; i++ {
for j := 1; j < 10-i; j++ {
fmt.Printf(" ")
}
for k := 1; k < 10-2*i; k++ {
printStar()
}
for m := 1; m < 6*i-3; m++ {
fmt.Printf(" ")
}
for n := 1; n < 10-2*i; n++ {
printStar()
}
fmt.Println()
}
}
package main
import (
"fmt"
"math"
"strconv"
"strings"
)
func fn2(input string) string {
var (
C = 50
H = 30
rs []string
)
inStr := strings.Split(input, ",")
for _, value := range inStr {
intValue, _ := strconv.Atoi(value)
result := (2 * C * intValue) / H
Q := math.Pow(float64(result), 0.5)
rs = append(rs, strconv.Itoa(int(Q)))
}
return strings.Join(rs, ",")
}
func main() {
/*
编写一个程序,根据给定的公式计算和打印值。
Q = [(2 * C * D)/ H] 的平方根 以下是 C 和 H 的固定值: C 为 50。 H 为 30 。
D 是变量,其值应以逗号分隔的顺序输入到程序中。
示例让我们假设以下逗号分隔的输入序列已赋予程序:100,150,180 程序的输出应为:18,22,24
*/
input := "100,150,180"
fmt.Println(fn2(input))
}
package main
import (
"fmt"
)
type operate func(x int) float64 // 定义一个函数类型
// 具体执行函数
func peven(n int) float64 {
s := 0.0
for i := 2; i <= n; i = i + 2 {
s += 1.0 / float64(i)
}
return s
}
func podd(n int) float64 {
s := 0.0
for i := 1; i <= n; i = i + 2 {
s += 1.0 / float64(i)
}
return s
}
// 调用函数
func dcall(op operate, n int) float64 {
return op(n)
}
func main() {
/*
编写一个函数,输入 n 为偶数时,调用函数求 1/2+1/4+…+1/n,当输入 n 为奇数时,调用函数 1/1+1/3+…+1/n
*/
var (
n = 3
sum float64
f operate
)
if n%2 == 0 {
f = peven
sum = dcall(f, n)
} else {
f = podd
sum = dcall(f, n)
}
fmt.Println(sum)
}
package main
import (
"fmt"
"net"
"os"
"time"
)
func process(conn net.Conn) {
defer conn.Close()
for {
buf := make([]byte, 512)
n, err := conn.Read(buf)
if err != nil {
fmt.Println("read error:", err)
return
}
readString := string(buf[:n])
fmt.Println("Read:", readString)
//返回给客户端的信息
strTemp := fmt.Sprintf("[%s] 已收到 %s ", time.Now().String(), readString)
conn.Write([]byte(strTemp))
}
}
func main() {
/*
实现 socket 服务端
*/
listenTcp := "0.0.0.0:5000"
listen, err := net.Listen("tcp", listenTcp)
if err != nil {
fmt.Println("Listen failed, err:", err)
os.Exit(1)
}
fmt.Println("Start Server....")
fmt.Println("Listen", listenTcp)
for {
conn, err := listen.Accept() // 监听是否有连接
if err != nil {
fmt.Println("Accept failed, err:", err)
}
go process(conn) // 协程
}
}
package main
import (
"bufio"
"fmt"
"net"
"os"
"strings"
)
func main() {
/*
实现 socket 客户端
*/
connTcp := "127.0.0.1:5000"
conn, err := net.Dial("tcp", connTcp)
if err != nil {
fmt.Println("Error dialing", err.Error())
os.Exit(1)
}
defer conn.Close()
inputReader := bufio.NewReader(os.Stdin)
for {
fmt.Println("请发送消息(退出请输入q):")
inputString, _ := inputReader.ReadString('\n')
trimInput := strings.Trim(inputString, "\r\n")
if strings.ToLower(trimInput) == "q" {
os.Exit(0)
}
if _, err := conn.Write([]byte(trimInput)); err != nil {
fmt.Println("Error conn", err.Error())
os.Exit(1)
}
//接收服务端反馈
buffer := make([]byte, 512)
n, err := conn.Read(buffer)
if err != nil {
fmt.Println("Waiting server back msg error", err.Error())
return
}
readString := string(buffer[:n])
fmt.Println("Server:", readString)
}
}
package main
import "fmt"
func outputs(s string) string {
runes := []rune(s)
for from, to := 0, len(runes)-1; from < to; from, to = from+1, to-1 {
runes[from], runes[to] = runes[to], runes[from]
}
return string(runes)
}
func main() {
/*
字符串反转
将随机输入的字符串反转后输出
*/
fmt.Println(outputs("abcdefg"))
}
package main
import (
"fmt"
"path/filepath"
"time"
)
func IsContain(items []string, item string) bool {
for _, eachItem := range items {
if eachItem == item {
return true
}
}
return false
}
func main() {
/*
监控文件删除或新增状态
对目录下的文件进行增和删除的监控,如果有增和删打印出来,并打印文件名
*/
dirPath := "./*"
beforeFiles, _ := filepath.Glob(dirPath)
for {
time.Sleep(time.Second * 10)
afterFiles, _ := filepath.Glob(dirPath)
var addFiles []string
for _, val := range afterFiles {
if !IsContain(beforeFiles, val) {
addFiles = append(addFiles, val)
}
}
var delFiles []string
for _, val := range beforeFiles {
if !IsContain(afterFiles, val) {
delFiles = append(delFiles, val)
}
}
fmt.Println("Added: ", addFiles)
fmt.Println("Removed: ", delFiles)
beforeFiles = afterFiles
}
}
package main
import (
"bufio"
"fmt"
"os"
"strings"
"time"
)
func main() {
/*
每隔一分钟读取一次日志文件,
把访问超过 200 次的 IP 统计到的黑名单中
日志文件样式可以为:每行的首个字符串是 ip,与后面字符之间的分割是符号空格 1.2.3.4 xxxx xxx 10.1.2.33 xx xx
*/
lineNumber := 0
for {
file, err := os.Open("E:\\04.dev\\go\\learn\\letcode\\a.log")
if err != nil {
panic(err)
}
ipCount := make(map[string]int)
fileScanner := bufio.NewScanner(file)
lineCount := 1
for fileScanner.Scan() {
if lineCount > lineNumber {
line := strings.Split(fileScanner.Text(), " ")
ipCount[line[0]]++
lineNumber++
}
lineCount++
}
for key, val := range ipCount {
if val >= 2 {
fmt.Println("加入黑名单的ip是:", key)
}
}
file.Close()
time.Sleep(time.Second * 60)
}
}
package main
import "fmt"
func dictF(n int) map[int]int {
m := make(map[int]int)
for i := 1; i <= n; i++ {
m[i] = i * i
}
return m
}
func main() {
/*
生成特定顺序的字典
使用给定的整数 n, 编写一个程序以生成包含(i,i * i)的字典
输入: 8
输出: {1:1, 2:4, 3:9, 4:16, 5:25, 6:36, 7:49, 8:64 }
*/
n := 8
fmt.Println(dictF(n))
}
package main
import (
"fmt"
"math/rand"
"os"
"strings"
)
func CheckCode() string {
var defaultLetters = []rune("abcdefghijklmnopqrstuvwxyz0123456789")
b := make([]rune, 4)
for i := range b {
b[i] = defaultLetters[rand.Intn(len(defaultLetters))]
}
return string(b)
}
func main() {
/*
制作随机验证码,不区分大小写。
要求用户输入的值和显示的验证码一致时,程序退出;
不一致时,刷新验证码后继续输入,直到用户输入正确为止;(也可限定输入错误次数)
*/
for {
code := CheckCode()
var inputCode string
fmt.Printf("验证码: %s\n", code)
fmt.Printf(">>> ")
fmt.Scanln(&inputCode)
if strings.ToLower(inputCode) == strings.ToLower(code) {
fmt.Println("验证码正确")
os.Exit(0)
} else {
fmt.Println("验证码错误重新输入!")
}
}
}
package main
import "fmt"
func main() {
/*
程序以 X,Y 2 位为输入,并生成一个二维数组
输入:3,5 输出:[[0,0,0,0,0],[0,1,2,3,4],[ 0,2,4,6,8]]
*/
rowNum := 3
colNum := 5
mutiList := make([][]int, rowNum)
for i := 0; i < rowNum; i++ {
mutiList[i] = make([]int, colNum)
}
for i := 0; i < rowNum; i++ {
for j := 0; j < colNum; j++ {
mutiList[i][j] = i * j
}
}
fmt.Println(mutiList)
}
package main
import (
"fmt"
"math"
)
func Map(f func(int) int, v []int) (r []int) {
r = make([]int, len(v))
for i, value := range v {
r[i] = f(value)
}
return
}
func fn(x int) int {
return int(math.Pow(float64(x), 2))
}
func main() {
/*
列表 [1,2,3,4,5],请使用 map() 函数输出 [1,4,9,16,25]
并使用列表推导式提取出大于 10 的数,最终输出 [16,25]
*/
v := []int{1, 2, 3, 4, 5}
r := Map(fn, v)
var r2 []int
for _, val := range r {
if val > 10 {
r2 = append(r2, val)
}
}
fmt.Println(r2)
}
package main
import "fmt"
func main() {
/*
找出 1000 以内的所有完数
完全数(Perfect number),又称完美数或完备数,是一些特殊的自然数。
它所有的真因子(即除了自身以外的约数)的和(即因子函数),恰好等于它本身。
如果一个数恰好等于它的因子之和,则称该数为“完全数”
*/
for i := 1; i < 1000; i++ {
sum := 0
for j := 1; j < i; j++ {
if i%j == 0 {
sum += j
}
}
if sum == i {
fmt.Println(i)
}
}
}
package main
import "fmt"
func main() {
/*
给定四个数字:1、2、3、4,能组成互不相同且无重复数字的三位数 (最多)
*/
var ret []int
for i := 1; i < 5; i++ {
for j := 1; j < 5; j++ {
for k := 1; k < 5; k++ {
if i != j && j != k && i != k {
ret = append(ret, i*100+j*10+k)
}
}
}
}
fmt.Println("总计:", len(ret))
for _, value := range ret {
fmt.Println(value)
}
}
package main
import "fmt"
func sort(a []int) []int {
aLen := len(a)
for i := 0; i <= aLen; i++ { // 冒泡排序
for j := 1; j < aLen-i; j++ {
if a[j] < a[j-1] {
a[j], a[j-1] = a[j-1], a[j]
}
}
}
return a
}
func main() {
/*
对一个数组从小到大进行排序
*/
a := []int{77,99,22,3,6,2,123,72}
fmt.Println(sort(a))
}
package main
import (
"fmt"
"math"
)
func IsPrime(n int) bool {
if n >2 && n % 2 == 0 {
return true
}
for i:=2; i <= int(math.Ceil(math.Sqrt(float64(n)))) ; i ++ {
if n % i == 0 {
return false
}
}
return true
}
func main() {
/*
判断 101-200 之间有多少个素数,并输出所有素数
*/
var primes []int
num := 0
for i :=101; i < 200; i ++ {
if IsPrime(i) {
num ++
primes= append(primes, i)
}
}
fmt.Println("素数总额: ",num)
fmt.Println("素数列表: ",primes)
}
package main
import (
"errors"
"fmt"
"math/rand"
)
func solve(sli []int64) ([]int64, error) {
sliLen := len(sli)
if sliLen <= 1 {
return []int64{}, errors.New("参数有误")
}
for i:= sliLen-1; i>0; i-- {
randNum := rand.Intn(i) // 获取随机数
sli[i], sli[randNum] = sli[randNum],sli[i] // 互相赋值
}
return sli, nil
}
func main() {
/*
随机打乱一个数组
Fisher-Yates算法
*/
sli := []int64{1,2,3,4,5,6,7,8}
if newSli,err := solve(sli); err != nil {
fmt.Println(err)
} else {
fmt.Println(newSli)
}
}
package main
type NextedIterator struct { // 扁平迭代器
index int // index是当前Next调用应该返回的第index个数
nums []int // 存放展平后的数字
}
func Constructor(nestedList []*NestedInteger) *NextedIterator {
nums := []int{}
for _, node := range nestedList { // 遍历nestedList
flatten(node, &nums)
}
return &NextedIterator{index: 0, nums: nums} // 创建并返回扁平迭代器
}
func flatten(node *NestedInteger, nums *[]int) {
if node.IsInteger() { // 如果是数字
*nums = append(*nums, node.GetInteger()) // 将数字推入res
} else { // 是nestedList
for _, child := range node.GetList() { // 遍历nestedList,child是当前子元素
flatten(child, nums)
}
}
}
func (this *NextedIterator) Next() int { // 一个个获取展平后的数组的元素
val := this.nums[this.index] // 获取元素
this.index++ // 更新index
return val
}
func (this *NextedIterator) HasNext() bool { // 是否还能获取到元素
return this.index <= len(this.nums)-1 // 取决于index是否越了nums的界
}
func main() {
/*
深度列表:[1, [2], [[3], 4], 5] 平面化后:[1,2,3,4,5]
*/
}
package main
import (
"fmt"
"regexp"
)
func IsEmail(s string) bool {
pattern := `^[0-9a-z][_.0-9a-z-]{0,31}@([0-9a-z][0-9a-z-]{0,30}[0-9a-z]\.){1,4}[a-z]{2,4}$`
reg := regexp.MustCompile(pattern)
return reg.MatchString(s)
}
func main() {
/*
匹配邮箱地址
*/
email := []string{"test01@163.com","test02@163.123", ".test03g@qq.com", "test04@gmail.com"}
for _, val := range email {
if is := IsEmail(val); is {
fmt.Printf("%s 是符合规定的邮件地址\n",val)
} else {
fmt.Printf("%s 不符合要求\n",val)
}
}
}
package main
import "fmt"
func reverseInteger(n string) string {
r := []rune(n)
rLen := len(r)
for i,j :=0,rLen-1; i<j; i,j=i+1,j-1{
r[i], r[j] = r[j], r[i]
}
return string(r)
}
func main() {
/*
问题描述:反转一个只有三位数的整数
问题示例: 输入:n = 123 输出: 321
*/
n := "123"
fmt.Println(reverseInteger(n))
}