判断题

1.数组是一个值类型（）

T

2.使用map不需要引入任何库（）

T

3.内置函数delete可以删除数组切片内的元素（）

F

4.指针是基础类型（）

F

5.interface{}是可以指向任意对象的Any类型（）

T

Golang不支持自动垃圾回收（）

F

7.下面代码中两个斜点之间的代码，比如json:”x”，作用是X字段在从结构体实例编码到JSON数据格式的时候，使用x作为名字，这可以看作是一种重命名的方式（）

1
2
3
4
5
type Position struct {
        X int `json:"x"`
        Y int `json:"y"`
        Z int `json:"z"`
}

T

8.通过成员变量或函数首字母的大小写来决定其作用域（）

T

9.对于常量定义zero (const zero = 0.0)，zero是浮点型常量（）

F

10.对变量x的取反操作是~x（）

F

1.golang支持goto语句（）

T

2.匿名函数可以直接赋值给一个变量或者直接执行（）

T

3.如果调用方调用了一个具有多返回值的方法，但是却不想关心其中的某个返回值，可以简单地用一个下划线“_”来跳过这个返回值，该下划线对应的变量叫匿名变量（）

T

4.错误是业务过程的一部分，而异常不是（）

T

5.golang虽然没有显式的提供继承语法，但是通过匿名组合实现了继承（）

T

6.使用for range迭代map时每次迭代的顺序可能不一样，因为map的迭代是随机的（）

T

7.import后面的最后一个元素是包名（）

F

编程题

字符串变化大小写

将字符串变化大小写并输出

输入格式:

输入一行字符串，长度无上限，中间无空格

输出格式:

输出为一行，先将字符串转换为大写，再将字符串转化成小写，中间用空格隔开

输入样例:

CuitCBIYes!

输出样例:

CuitCBIYes!

CUITCBIYES! cuitcbiyes!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
// print有 \n 用不了
package main

import (
	"fmt"
	"strings"
)

func main() {
	var input string
	fmt.Scanln(&input)
	fmt.Printf("%s %s", strings.ToUpper(input), strings.ToLower(input))
}

画梯形

输入一个数字，根据数字画梯形

输入格式:

输入：

输出格式:

一个小于10的数字

输入样例:

5

输出样例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package main

import "fmt"

// ********************  20个
//  ******************   18个

func main() {
	var ln int
	fmt.Scan(&ln)

	for i := 0; i < ln; i++ {
		for j := 0; j < i; j++ {
			fmt.Print(" ")
		}
		for j := 0; j < 20-(i*2); j++ {
			fmt.Print("*")
		}
		fmt.Println()
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
package main

import "fmt"

func main() {
	var a, b int
	fmt.Scanf("%d %d", &a, &b)
	for i := a; i <= b; i++ {
		sum := 0
		temp := i
		for temp > 0 {
			digit := temp % 10
			sum += digit * digit * digit
			temp /= 10
		}
		if sum == i {
			fmt.Println(i)
		}
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// print有\n才能过
package main

import (
	"fmt"
	"math"
)

func main() {
	var a, b, c float64
	_, err := fmt.Scanf("%f %f %f", &a, &b, &c)
	if err != nil {
		fmt.Println("data error")
		return
	}
	if !isTrangle(a, b, c) {
		fmt.Println("data error")
		return
	}
	p := (a + b + c) / 2
	area := math.Sqrt(p * (p - a) * (p - b) * (p - c))
	fmt.Printf("%.2f\n", area)

}

func isTrangle(a, b, c float64) bool {
	return a+b > c && a+c > b && b+c > a
}

1
2
3
4
5
6
7
8
9
10
11
12
13
package main

import (
	"fmt"
	"math"
)

func main() {
	var x float64
	fmt.Scanf("%f", &x)
	// fmt.Print(x)
	fmt.Println(int(math.Sqrt(x)))
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
package main

import (
	"fmt"
	"strconv"
)

func main() {
	var x int
	fmt.Scan(&x)
	fmt.Println(ishuiwen(x))

}

func ishuiwen(x int) bool {
	if x < 0 || (x%10 == 0 && x != 0) {
		return false
	}
	mystr := strconv.Itoa(x)
	mylen := len(strconv.Itoa(x))
	for i := 0; i < mylen/2; i++ {
		if mystr[i] != mystr[mylen-1-i] {
			return false
		}
	}
	return true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
package main

// 到达第n阶的方法数就是到达第n-1阶和第n-2阶的方法数之和。
import (
	"fmt"
)

func main() {
	var x int
	fmt.Scan(&x)
	ans := louti(x)
	fmt.Println(ans)
}

func louti(n int) int {
	if n == 1 {
		return 1
	}
	if n == 2 {
		return 2
	}
	// 一层楼仅一种方法，两层楼两种
	a, b := 1, 2
	for i := 3; i <= n; i++ {
		a, b = b, a+b
	}
	return b
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package main

import (
	"fmt"
)

func main() {
	var a int
	fmt.Scan(&a)
	fmt.Println(isHappy(a))
}

func isHappy(n int) bool {
	m := map[int]bool{}
	for n != 1 {
		if m[n] {
			break
		}
		m[n] = true
		n = step(n)
	}
	return n == 1
}

func step(n int) int {
	sum := 0
	for n != 0 {
		sum += (n % 10) * (n % 10)
		n /= 10
	}
	return sum
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scan(&x)
	// fmt.Scan(&y)

	fmt.Println(binaryy(x))
}

func binaryy(x int) bool {
	xstr := fmt.Sprintf("%b", x)
	for i := 1; i < len(xstr); i++ {
		if xstr[i] == xstr[i-1] {
			return false
		}
	}
	return true
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
package main

import (
	"fmt"
)

func main() {
	var x int
	fmt.Scan(&x)
	// fmt.Scan(&y)
	chengji(x)
}

func chengji(x int) {
	if x >= 90 {
		fmt.Println("成绩优秀！")
	} else if 90 > x && x >= 80 {
		fmt.Println("成绩良好！")
	} else if 80 > x && x >= 60 {
		fmt.Println("成绩及格！")
	} else {
		fmt.Println("成绩不及格！")
	}
}

实验一：

剪子布

image-20230606145358962

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
package main

import "fmt"

func get(x string) int {
if x == "R" {
return 0
}
if x == "S" {
return 1
}
return 2
}
func solve() {
var a, b string
fmt.Scanf("%v %v", &a, &b)
ac := get(a)
bc := get(b)
tmp := (ac - bc + 3) % 3
if tmp == 0 {
fmt.Println("TIE")
} else if tmp == 1 {
fmt.Println("Player2")
} else {
fmt.Println("Player1")
}
}
func main() {
var t int
fmt.Scanf("%v", &t)
for t > 0 {
t--
solve()
}
}

最大公约最小共倍

image-20230606104834042

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
package main

import "fmt"

// Function to calculate GCD (Greatest Common Divisor)
func gcd(a, b int) int {
	for b != 0 {
		t := b
		b = a % b
		a = t
	}
	return a
}

// Function to calculate LCM (Least Common Multiple)
func lcm(a, b int) int {
	return a * b / gcd(a, b)
}

func main() {
	var m, n int
	fmt.Print("请输入第一个正整数 m：")
	fmt.Scan(&m)
	fmt.Print("请输入第二个正整数 n：")
	fmt.Scan(&n)

	fmt.Printf("最大公约数为：%d\n", gcd(m, n))
	fmt.Printf("最小公倍数为：%d\n", lcm(m, n))
}

实验二：

折半查找

输入n值(1<n<1000)、n个非降序排列的整数以及要查找的数x，使用二分查找算法查找x，输出x所在的下标（0~n-1）及比较次数。 若x不存在，输出-1和比较次数。

输入格式:

输入格式: 第一行是数组的个数n 第二行开始是输入数组的元素 最后一行是需要查找的元素

输出格式:

输出x所在的下标（0~n-1）及比较次数。若x不存在，输出-1和比较次数。

输入样例:

4

1

2

3

4

1

输出样例:

0

2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
package main

import (
	"fmt"
	"bufio"
	"os"
	"strconv"
)

func binarySearch(arr []int, x int) (int, int) {
	low, high, count := 0, len(arr)-1, 0

	for low <= high {
		mid := low + (high-low)/2
		count += 1

		if arr[mid] == x {
			return mid, count
		} else if arr[mid] < x {
			low = mid + 1
		} else {
			high = mid - 1
		}
	}
	return -1, count
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)

	scanner.Scan()
	n, _ := strconv.Atoi(scanner.Text())
	arr := make([]int, n)

	for i := 0; i < n; i++ {
		scanner.Scan()
		arr[i], _ = strconv.Atoi(scanner.Text())
	}

	scanner.Scan()
	x, _ := strconv.Atoi(scanner.Text())

	index, count := binarySearch(arr, x)

	fmt.Println(index)
	fmt.Println(count)
}

求鞍点

给定一个n*m矩阵A。矩阵A的鞍点是一个位置（i，j），在该位置上的元素是第 i 行上的最大数，第 j 列上的最小数。一个矩阵A也可能没有鞍点。你的任务是找出A的鞍点。。

输入格式:

自行输入一个二维数组,二维数组的长度才从键盘读入,第一个为列，第二个数字为行

输出格式:

对输入的矩阵，如果找到鞍点，就输出其下标。下标为两个数字，第一个数字是行号，第二个数字是列号，均从0开始计数。 如果找不到，就输出 找不到鞍点 注意：输出鞍点信息的时候，无需加回车。

输入样例:

2 3 1 2 3 4 5 6

输出样例:

鞍点为2(0,1)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main

import "fmt"

var n, m int

func main() {
	fmt.Scanf("%d %d", &m, &n)
	arr := make([][]int, n+1)
	for i := range arr {
		arr[i] = make([]int, m+1)
	}
	for i := 1; i <= n; i++ {
		for j := 1; j <= m; j++ {
			fmt.Scanf("%d", &arr[i][j])
		}
	}
	for i := 1; i <= n; i++ {
		tmp := 1
		for j := 2; j <= m; j++ {
			if arr[i][tmp] < arr[i][j] {
				tmp = j
			}
		}
		flag := true
		for j := 1; j <= n; j++ {
			if j == i {
				continue
			}
			if arr[i][tmp] > arr[j][tmp] {
				flag = false
				break
			}
		}
		if flag {
			fmt.Printf("鞍点为%d(%d,%d)", arr[i][tmp], i-1, tmp-1)
			return
		}
	}
	fmt.Println("找不到鞍点")
}

实验三

素数排位

已知素数序列为2、3、5、7、11、13、17、19、23、29……，即素数的第一个是2，第二个是3，第三个是5……那么，随便挑一个数，若是素数，能确定是第几个素数吗？如果不是素数，则输出0。

输入格式:

测试数据有多组，处理到文件尾。每组测试输入一正整数N（1≤N≤1000000）。

输出格式:

对于每组测试，输出占一行，如果输入的正整数是素数，则输出其排位，否则输出0。

输入样例:

6

2

6

4

5

13

991703

输出样例:

1

0

0

3

6

77901

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
package main

import (
    "fmt"
    "math"
)

// 判断是否为素数
func isPrime(num int) bool {
    if num <= 1 {
        return false
    }
    for i := 2; i <= int(math.Sqrt(float64(num))); i++ {
        if num%i == 0 {
            return false
        }
    }
    return true
}

func main() {
    var len int
    fmt.Scan(&len)
    var arr = make([]int,len)
    for i := 0;i < len;i++{
        fmt.Scan(&arr[i])
    }
    for i := 0;i < len;i++{
        if isPrime(arr[i]) {
            count := 0
            for j := 2; j <= arr[i]; j++ {
                if isPrime(j) {
                count++
                }
            }
            fmt.Println(count)
        } else {
            fmt.Println("0")
        }
    }
}

解题排行

解题排行榜中，按解题总数生成排行榜。假设每个学生信息仅包括学号、解题总数；要求先输入n个学生的信息；然后按“解题总数”降序排列，若“解题总数”相同则按“学号”升序排列。

输入格式:

首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。 每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示学生总数。然后输入n行，每行包括1个不含空格的字符串s（不超过8位）和1个正整数d，分别表示一个学生的学号和解题总数。 输出参考: fmt.Printf(“%-5d%-8s%d\n”)

输出格式:

对于每组测试数据，输出最终排名信息，每行一个学生的信息：排名、学号、解题总数。每行数据之间留一个空格。注意，解题总数相同的学生其排名也相同。

输入样例:

1

4

0010 200

1000 110

0001 200

0100 225

输出样例:

1 0100 225

2 0001 200

2 0010 200

4 1000 110

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
package main

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

type node struct {
	name string
	cnt  int
}

func solve() {
	var n int
	fmt.Scanf("%d\n", &n)
	arr := make([]node, n)
	for i := 0; i < n; i++ {
		fmt.Scanf("%s %d\n", &arr[i].name, &arr[i].cnt)
	}
	sort.Slice(arr, func(i, j int) bool {
		if arr[i].cnt == arr[j].cnt {
			a, _ := strconv.Atoi(arr[i].name)
			b, _ := strconv.Atoi(arr[j].name)
			return a < b
		} else {
			return arr[i].cnt > arr[j].cnt
		}
	})
	index := 1
	tmp := 1
	fmt.Printf("%-5d%-8s%d\n", tmp, arr[0].name, arr[0].cnt)
	for i := 1; i < n; i++ {
		index++
		if arr[i].cnt < arr[i-1].cnt {
			tmp = index
		}
		fmt.Printf("%-5d%-8s%d\n", tmp, arr[i].name, arr[i].cnt)
	}
	fmt.Println()
}
func main() {
	var t int
	fmt.Scanf("%d\n", &t)
	for t > 0 {
		t--
		solve()
	}
}

过程化实验

选择题

aadcb bdcdd

image-20230616113118824

image-20230616113343449

image-20230616113356695

image-20230616113409218

image-20230616113416873

1.请选出代码正确的输出结果。

type Person struct {

​ name string

​ age int }

func main() { p1 := Person{“Alice”, 20} p2 := Person{name: “Bob”, age: 30} p3 := Person{name: “Charlie”} fmt.Println(p1.name, p1.age) fmt.Println(p2.name, p2.age) fmt.Println(p3.name, p3.age) }

A.Alice 20 Bob 30 Charlie 0

B.Alice 20 Bob 30 Charlie

C.Alice 20 Bob 30 empty 0

D.编译错误

A

B

C

D

2.下面代码输出的正确结果是。

type Rectangle struct { width, height float64 } func (r Rectangle) Area() float64 { return r.width * r.height } func (r Rectangle) Perimeter() float64 { return 2 * (r.width + r.height) } func main() { rect := Rectangle{width: 10, height: 5} fmt.Println(“Area:”, rect.Area()) fmt.Println(“Perimeter:”, rect.Perimeter()) }

A.Area: 50 Perimeter: 30

B.Area: 30 Perimeter: 50

C.编译错误

D.Area: 30.0 Perimeter: 50.0

A

B

C

D

3.下面程序正确的输出结果是。

type ListNode struct { Val int Next *ListNode } func fn(node *ListNode) { node.Val = node.Next.Val node.Next = node.Next.Next } func main() { head := &ListNode{Val: 1, Next: &ListNode{Val: 2, Next: &ListNode{Val: 3, Next: nil}}} fn(head.Next) fmt.Println(head.Val, head.Next.Val) }

A.1 2

B.2 3

C.3 2

D.1 3

A

B

C

D

4.下面代码输出什么。

func main() { a1 := []int{10} a2 := a1[1:] fmt.Println(a2) }

A.编译失败

B.panic: runtime error: index out of range [1] with length 1

C.[]

D.其他

A

B

C

D

5.下面正确的答案是。

func main() { var x int = 10 var y *int = &x *y = 20 fmt.Println(x) }

A.10

B.20

C.运行错误

D.编译错误

A

B

C

D

6.下面答案正确的一项是。

func main() { nums := []int{1, 2, 3, 4, 5} var funcs []func() for _, num := range nums { funcs = append(funcs, func() { fmt.Println(num) }) } for _, f := range funcs { f() } }

A.1 2 3 4 5

B.5 5 5 5 5

C.编译错误

D.1 1 1 1 1

A

B

C

D

7.关于协程，下面说法正确是。

A.通过共享内存来实现通信

B.线程比协程更轻量级

C.协程不存在死锁问题

D.通过channel来进行协程间的通信

A

B

C

D

8.关于channel，下面语法错误的是。

A.var ch chan int

B.ch := make(chan int)

C.<- ch

D.ch <-

A

B

C

D

9.有关协程的说法错误的是。

A.协程和线程都可以实现程序的并发执行

B.通过channel来进行协程间的通信

C.只需要在函数调用前添加Go语言期末冲刺关键字即可实现Go语言期末冲刺的协程，创建并发任务

D.协程比线程耗费资源更多一些

A

B

C

D

10.Gin框架的主要特点是什么？。

A.高性能和低内存占用

B.易于学习和使用

C.支持中间件和路由功能

D.所有以上都是

A

B

C

D

编程题

defer使用

程序需要定义一个 Account 结构体，包含以下字段：

name：表示账户名的字符串
balance：表示账户余额的浮点数
Account 结构体需要提供以下方法：

Deposit(amount float64)：存款方法，将传入的金额加到账户余额中。
Withdraw(amount float64)：取款方法，从账户余额中扣除传入的金额。如果余额不足，则无法取款。
PrintBalance()：打印当前账户余额。
使用 defer 关键字，在存款和取款方法中添加日志记录功能。在存款时打印格式为 “存款：账户名 + 存款金额” 的日志，取款时打印格式为 “取款：账户名 - 取款金额” 的日志。

主函数中创建一个账户实例，并演示存款和取款的操作，以及打印账户余额。

请根据以上要求编写程序，并保证正确处理边界情况。

输入输出示例：
（假设账户名为 “Alice”）
注意：
使用 fmt.Printf 函数打印日志和账户余额，保留两位小数，带回车。
需要使用 defer 关键字来确保日志的打印顺序。
在取款时，如果账户余额不足，需要打印错误信息：”账户余额不足，无法取款”。

输入格式:
输入：
存款金额：100.0
取款金额：50.0

输出格式:
输出：
存款：Alice + 100.0
取款：Alice - 50.0
账户余额：50.0

输入样例:
100.0
50.0

输出样例:
存款：Alice + 100.0
取款：Alice - 50.0
账户余额：50.0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
package main

import "fmt"

type Account struct {
	name    string
	balance float64
}

func (a *Account) Deposit(amount float64) {
	defer fmt.Printf("存款：%s + %.2f\n", a.name, amount)
	a.balance += amount
}

func (a *Account) Withdraw(amount float64) {
	if amount > a.balance {
        fmt.Printf("取款：%s - %.2f\n", a.name, amount)
		fmt.Println("账户余额不足，无法取款")
		return
	}else{
	    defer fmt.Printf("取款：%s - %.2f\n", a.name, amount)
	    a.balance -= amount
    }
}

func (a *Account) PrintBalance() {
	fmt.Printf("账户余额：%.2f\n", a.balance)
}

func main() {
	a := Account{name: "Alice", balance: 0}
    var add,minus float64
    fmt.Scanln(&add)
    fmt.Scanln(&minus)
	a.Deposit(add)
	a.Withdraw(minus)
	a.PrintBalance()
}

今昔是何年

天干地支，简称为干支，源自中国远古时代对天象的观测。十干是指阏逢、旃蒙、柔兆、强圉、著雍、屠维、上章、重光、玄黓、昭阳。十二支是指困敦、赤奋若、摄提格、单阏、执徐、大荒落、敦牂、协洽、涒滩、作噩、阉茂、大渊献。简化后“甲、乙、丙、丁、戊、己、庚、辛、壬、癸”称为十天干，“子、丑、寅、卯、辰、巳、午、未、申、酉、戌、亥”称为十二地支。干支纪年一个周期的第1年为“甲子”，第2年为“乙丑”，第3年为“丙寅”，…，第11年为“甲戌”，第12年为“乙亥”，第13年为“丙子”，依此类推，60年一个周期；一个周期完了重复使用，周而复始。
已知2022年为“壬寅”年，1984年为“甲子”年，请根据给定的年份，求对应年份的干支。

输入格式:
第一行包含一个整数T(1≤T≤1000)，表示一共有T个样例，后面T行，每行包含一个整数 Y (1≤Y≤5000)，代表一个年份。

输出格式:
对于每个测试样例，输出相应的干支。

输入样例:
4
1800
1984
2000
2023

输出样例:
庚申
甲子
庚辰
癸卯

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package main

import "fmt"

var gan = []string{"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"}
var zhi = []string{"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"}

func getGanZhi(year int) (string, string) {
	ganIndex := (year - 4) % 10 // 计算天干下标
	zhiIndex := (year - 4) % 12 // 计算地支下标
	return gan[ganIndex], zhi[zhiIndex]
}

func main() {
	var t int
	fmt.Scan(&t)

	for i := 0; i < t; i++ {
		var year int
		fmt.Scan(&year)
		g, z := getGanZhi(year)
		fmt.Println(g + z)
	}
}

解题排行

解题排行榜中，按解题总数生成排行榜。假设每个学生信息仅包括学号、解题总数；要求先输入n个学生的信息；然后按“解题总数”降序排列，若“解题总数”相同则按“学号”升序排列。

输入格式:
首先输入一个正整数T，表示测试数据的组数，然后是T组测试数据。
每组测试数据先输入1个正整数n（1 ≤ n ≤ 100），表示学生总数。然后输入n行，每行包括1个不含空格的字符串s（不超过8位）和1个正整数d，分别表示一个学生的学号和解题总数。
输出参考:
fmt.Printf(“%-5d%-8s%d\n”)

输出格式:
对于每组测试数据，输出最终排名信息，每行一个学生的信息：排名、学号、解题总数。每行数据之间留一个空格。注意，解题总数相同的学生其排名也相同。

输入样例:
1
4
0010 200
1000 110
0001 200
0100 225

输出样例:
1 0100 225
2 0001 200
2 0010 200
4 1000 110

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
package main

import (
    "fmt"
    "sort"
)

type Student struct {
    id    string // 学号
    score int    // 解题总数
    rank  int    // 排名
}

// 对学生列表按照解题总数降序排序，如果解题总数相同，则按照学号升序排序
func sortStudents(students []*Student) {
    sort.Slice(students, func(i, j int) bool {
        if students[i].score == students[j].score {
            return students[i].id < students[j].id
        }
        return students[i].score > students[j].score
    })
}

func main() {
    var t int
    fmt.Scan(&t)

    for i := 0; i < t; i++ {
        var n int
        fmt.Scan(&n)

        // 读入学生信息
        students := make([]*Student, n)
        for j := 0; j < n; j++ {
            var id string
            var score int
            fmt.Scan(&id, &score)
            students[j] = &Student{id, score, 0}
        }

        // 对学生列表排序
        sortStudents(students)

        // 计算学生排名
        rank := 1
        for j := 0; j < n; j++ {
            if j > 0 && students[j].score != students[j-1].score {
                rank = j + 1
            }
            students[j].rank = rank
        }

        // 输出学生排名信息
        for j := 0; j < n; j++ {
            fmt.Printf("%-5d%-8s%d\n", students[j].rank, students[j].id, students[j].score)
        }
        fmt.Println()
    }
}

搜索插入位置

给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。

输入格式:
输入整数数存入数组。第一个数字代表数组长度 最后一个数字代表目标值，可参考下面输入代码
var n int
fmt.Scan(&n)
nums := make([]int, n)
for i := 0; i < n; i++ {
fmt.Scan(&nums[i])
}
fmt.Scan(&target)

nums 为无重复元素 的 升序 排列数组

输出格式:
输出插入位置下标。

输入 4 1 3 5 6 5
输出 2

输入 4 1 3 5 6 7
输出 4

输入样例:
4 1 3 5 6 2

输出样例:
1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
package main

import "fmt"

func searchInsert(nums []int, target int) int {
    left, right := 0, len(nums)-1
    for left <= right {
        mid := left + (right-left)/2
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            left = mid + 1
        } else {
            right = mid - 1
        }
    }
    return left
}

func main() {
    var n int
    fmt.Scan(&n)
    nums := make([]int, n)
    for i := 0; i < n; i++ {
        fmt.Scan(&nums[i])
    }
    var target int
    fmt.Scan(&target)

    pos := searchInsert(nums, target)
    fmt.Println(pos)
}