【牛客编程题】GO语言入门46题

GP01-GP18：输出，变量，常量，指针，字符串，类型转换，运算符，数组
GP19-GP38：切片，map，条件，循环
GP39-GP46：函数，结构体，接口，错误

做题链接：https://www.nowcoder.com/exam/oj?page=1&tab=语法篇&topicId=317

文章目录

GP1 go的第一个程序

package main

import (
    "fmt"
)
func main() {
    fmt.Println("Hello World!")
}
1
2
3
4
5
6
7
8

GP2 小明信息

package main

import (
    "fmt"
)
func main() {
    var name string = "小明";
    var age int64 = 23;
    var sex bool = true;
    fmt.Println(name);
    fmt.Println(age);
    fmt.Println(sex);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

GP3 个人信息

package main

import (
    "fmt"
)
func main() {
    var name string;
    var age int;
    var sex bool;
    fmt.Println(name);
    fmt.Println(age);
    fmt.Println(sex);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

GP4 国家名称

package main

import  "fmt"

func main() {
    const a string = "中国"
    const b string = "英国"
    const c string = "美国"
    fmt.Println(a)
    fmt.Println(b)
    fmt.Println(c)
}
1
2
3
4
5
6
7
8
9
10
11
12

GP5 值和指针

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a int整型 变量a
 * @param b int整型 变量b
 * @return bool布尔型一维数组
*/
func equal( a int ,  b int ) []bool {
    // write code here
    return []bool{&a==&b, a==b};
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP6 拼接字符串

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s string字符串一维数组 
 * @return string字符串
*/
func join( s []string ) string {
    // write code here
    var t string
    for _, x := range s{ //位置和值
        t += x
    }
    return t
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

GP7 字符数量

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s string字符串 
 * @return int整型
*/
func count( s string ) int {
    // write code here
    var arr = []rune(s) //rune数组，即int32数组
    return len(arr)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP8 回文数

package main
import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param x int整型 
 * @return bool布尔型
*/
func isPalindrome( x int ) bool {
    // write code here
    var s string = fmt.Sprintf("%d",x) //int转string
    length := len(s)
    for i := 0; i < length/2; i++ {
        if s[i] != s[length-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

GP9 格式化字符串

package main
import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 将一个正整数转换为字符串
 * @param num int整型 给定的正整数
 * @return string字符串
*/
func formatstr( num int ) string {
    // write code here
    a := fmt.Sprintf("%d",num)
    return a;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP10 字符求和

package main
//import "fmt"
import "strconv"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a string字符串 
 * @param b string字符串 
 * @return string字符串
*/
func sum( a string ,  b string ) string {
    // write code here
    x,_ := strconv.Atoi(a)
    y,_ := strconv.Atoi(b)
    return strconv.Itoa(x+y)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP11 长方形的周长

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a int整型 长方形的长
 * @param b int整型 长方形的宽
 * @return int整型
*/
func perimeter( a int ,  b int ) int {
    // write code here
    return 2*(a+b)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP12 温度转换

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param f double浮点型 华氏温度
 * @return double浮点型
*/
func temperature( f float64 ) float64 {
    // write code here
    v := float64(5)/float64(9)
    v = v*(f-32)
    return v
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

GP13 工程时间

package main

import (
    "fmt"
)
func main() {
     fmt.Println(97/7)
     fmt.Println(97%7)
}
1
2
3
4
5
6
7
8
9

GP14 器材采购

package main
//import "fmt"
import "sort"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param x int整型 采购单价
 * @param y int整型 采购单价
 * @param z int整型 采购单价
 * @return int整型
*/
func compare( x int ,  y int ,  z int ) int {
    // write code here
    arr := [3]int{x,y,z}
    sort.Ints(arr[:])
    return arr[2]-arr[0]
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

GP15 逻辑运算

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a bool布尔型 
 * @param b bool布尔型 
 * @return bool布尔型一维数组
*/
func logicalOperation( a bool ,  b bool ) []bool {
    // write code here
    return []bool{ a&&b, a||b, !a, !b }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP16 位运算

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a int整型 
 * @param b int整型 
 * @return int整型一维数组
*/
func bitOperate( a int ,  b int ) []int {
    // write code here
    return []int { a&b, a|b, a^b }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP17 联谊活动

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param x int整型 参加活动人数
 * @return bool布尔型
*/
func odevity( x int ) bool {
    // write code here
    if x % 2 ==1 {
        return false
    }
    return true
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP18 保龄球

package main

import  "fmt"

func main() {
    var a [5]int
    a = [5]int{2,5,4,6,5}
    fmt.Println(a)
}
1
2
3
4
5
6
7
8
9

GP19 创建切片

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param length int整型 切片初始化长度
 * @param capacity int整型 切片初始化容量
 * @return int整型一维数组
*/
func makeslice( length int ,  capacity int ) []int {
    // write code here
    var slice []int = make([]int, length, capacity)
    for i:=0 ; i < len(slice); i++ {
        slice[i] = i;
    }
    return slice
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

GP20 切片复制

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param src int整型一维数组 源切片
 * @param des int整型一维数组 目的切片
 * @return int整型一维数组
*/
func sliceCopy( src []int ,  des []int ) []int {
    // write code here
    des = make([]int, len(src), len(src))
    copy(des, src)
    return des
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP21 出队

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s int整型一维数组 身高
 * @param index int整型 出队索引
 * @return int整型一维数组
*/
func deleteElement( s []int ,  index int ) []int {
    // write code here
    s1 := s[:index]
    s2 := s[index+1:]
    s1 = append(s1, s2...)
    return s1
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

GP22 评委打分

package main
//import "fmt"
import "sort"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s int整型一维数组 评委给出分数
 * @return int整型一维数组
*/
func minAndMax( s []int ) []int {
    // write code here
    sort.Ints(s)
    return append(s[:1], s[len(s)-1:] ...)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP23 调整顺序

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s int整型一维数组 
 * @return int整型一维数组
*/
func convert( s []int ) []int {
    // write code 
    for i:= 0 ; i < len(s)/2; i++ {
        s[i], s[len(s)-i-1] = s[len(s)-i-1], s[i]
    }
    return s
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP24 判断两个切片是否有相同的元素

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s1 int整型一维数组 
 * @param s2 int整型一维数组 
 * @return bool布尔型
*/
func equal( s1 []int ,  s2 []int ) bool {
    // write code here
    for i:=0; i < len(s1); i++ {
        if s1[i] != s2[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

GP25 合并有序数组

package main
//import "fmt"
import "sort"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param nums1 int整型一维数组 
 * @param m int整型 
 * @param nums2 int整型一维数组 
 * @param n int整型 
 * @return int整型一维数组
*/
func merge( nums1 []int ,  m int ,  nums2 []int ,  n int ) []int {
    // write code here
    arr := append(nums1[:m],nums2[:n]...)
    sort.Ints(arr)
    return arr
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

GP26 置衣柜

package main

import  "fmt"

func main() {
    s := []string{"帽子", "围巾", "衣服", "裤子", "袜子"}
    fmt.Println(s)
}
1
2
3
4
5
6
7
8

GP27 成绩表

package main

import (
    "fmt"
)
func main() {
    var ma map[string]int = map[string]int{
        "小明":60,
        "小王":70,
        "张三":95,
        "李四":98,
        "王五":100,
        "张伟":88,
    }
    fmt.Println(ma)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

GP28 单词字符

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s string字符串 
 * @return char字符型
*/
func character( s string ) byte {
    // write code here
    str := []byte(s)
    n := 0
    m := make(map[byte]int)
    var b byte
    for _, v := range str{
        m[v]++
        if(m[v] > n){
            n = m[v]
            b = v
        }
    }
    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

GP29 字符串构成

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param des string字符串 
 * @param src string字符串 
 * @return bool布尔型
*/
func canConstruct( des string ,  src string ) bool {
    // write code here
    ma := make(map[byte]int)
    s := []byte(src)
    for _, i := range s{
        ma[i]++
    }
    p := []byte(des)
    for _, i := range p{
        if ma[i]==0 {
            return false
        }
        ma[i]--
    }
    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

GP30 不重复的数

package main
//import "fmt"
import "sort"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s int整型一维数组 
 * @return int整型一维数组
*/
func getNoRepeat( s []int ) []int {
    // write code here
    var ans []int
    have := make(map[int]int)
    for _, i := range s{
        if _,ok := have[i] ; ok == false{
            have[i] = 1
        }else{
            have[i]++;
        }
    }
    for i,j := range have{
        if j==1{
            ans = append(ans, i)
        }
    }
    sort.Ints(ans)
    return ans
}
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

GP31 年龄分段

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param age int整型 年龄
 * @return string字符串
*/
func getAge( age int ) string {
    // write code here
    if age >= 0 && age < 1 {
        return "婴儿"
    } else if age <= 4 {
        return "幼儿"
    } else if age <= 11 {
        return "儿童"
    } else if age <= 18 {
        return "少年"
    } else if age <= 35 {
        return "青年"
    } else if age <= 59 {
        return "中年"
    } else {
        return "老年"
    }
}
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

GP32 成绩判定

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param score int整型 分数
 * @return string字符串
*/
func judgeScore( score int ) string {
    // write code here
     switch {
        case score<60: return "不及格"
        case score<80: return "中等"
        case score<90: return "良好"
        default: return "优秀"
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

GP33 游乐园门票

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param hight double浮点型 身高
 * @return bool布尔型
*/
func ispay( hight float64 ) bool {
    // write code here
    return hight>=160.0
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

GP34 推箱子

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param forwards string字符串 推箱子方向
 * @return bool布尔型
*/
func pushBox( forwards string ) bool {
    // write code here
    var x int
    var y int
    for _, v := range forwards{
        if(v=='U'){
            y += 1
        }else if(v=='R'){
            x += 1
        }else if(v=='D'){
            y -= 1
        }else{
            x -= 1
        }
    }
    return x==0 && y==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

GP35 乘法口诀表

package main

import "fmt"
func main() {
    for i := 1; i <= 9; i++ {
        for j := 1; j <= i; j++ {
            fmt.Printf("%d*%d=%-3d",j,i,j*i)
        }
        fmt.Println()
    }
}
1
2
3
4
5
6
7
8
9
10
11

GP36 坐标转换

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param array int整型二维数组 
 * @return int整型一维数组
*/
func transform( array [][]int ) []int {
    // write code here
    var ans []int
    for i:=0; i < len(array); i++{
        for j:=0; j < len(array[0]); j++{
            ans = append(ans, array[i][j])
        }
    }
    return ans
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

GP37 质量检查

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param material int整型一维数组 成品质量
 * @param standard int整型 质检标准
 * @return int整型一维数组
*/
func check( material []int ,  standard int ) []int {
    // write code here
    var ans []int
    for i:=0; i < len(material); i++{
        if(material[i]>=standard){
            ans = append(ans, material[i])
        }
    }
    return ans
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

GP38 团队闯关

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param score int整型一维数组 团队成员分数
 * @param target int整型 达标分数
 * @return bool布尔型
*/
func canPass( score []int ,  target int ) bool {
    // write code here
    for i:=0; i < len(score); i++{
        if(score[i]>target){
            return true;
        }
    }
    return false
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

GP39 数字的阶乘

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param i int整型 数字
 * @return int整型
*/
func factorial( i int ) int {
    // write code here
    if i == 0{
        return 1
    }
    return i * factorial(i-1)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP40 绝对值

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param x int整型 
 * @return int整型
*/
func absfunc( x int ) int {
    // write code here
    if x<0 {
        x = -x
    }
    return x
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP41 加减乘除

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param a int整型 
 * @param b int整型 
 * @return int整型一维数组
*/
func operate( a int ,  b int ) []int {
    // write code here
    return []int{a+b,a-b,a*b,a/b,a%b}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

GP42 学生信息II

package main

import (
    "fmt"
)

type student struct{
    name string
    sex bool
    age int
    score int
}
func main() {
    a := student{
        name : "小明", age:23, sex:true, score:88,
    }  
    fmt.Println(a.name)
    fmt.Println(a.sex)
    fmt.Println(a.age)
    fmt.Println(a.score)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

GP43 学生信息III

package main

import (
	"fmt"
)

type address struct {
	city     string
    province string
}
type stu struct {
	name  string
	sex   bool
	age   int
	score int
	add   address
}

func main() {
	a := stu{
		name:  "小明",
		age:   23,
		sex:   true,
		score: 88,
		add: address{
			city:     "长沙市",
			province: "湖南省",
		},
	}
	fmt.Println(a.name)
	fmt.Println(a.sex)
	fmt.Println(a.age)
	fmt.Println(a.score)
	fmt.Println(a.add.province)
	fmt.Println(a.add.city)
}


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

GP44 动物和老虎

package main

import "fmt"

type animal interface {
	sleep()
	eat()
}
type tiger struct {
}

func (t tiger) sleep() {
	fmt.Println("sleep")
}
func (t tiger) eat() {
	fmt.Println("eat")
}
func main() {
	var t animal = tiger{}
	t.sleep()
	t.eat()

}


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

GP45 网络延迟

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param ping int整型 网络延迟值
 * @return string字符串
*/
func defineerr( ping int ) string {
    // write code here
    if ping > 100{
        return "网络延迟"
    }
    return ""
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

GP46 体温异常

package main
//import "fmt"

/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param t double浮点型 体温
 * @return string字符串
*/
func temperature( t float64 ) (ans string) {
    // write code here
    ans = ""
    defer func(){
        if err:= recover();err!=nil{
            ans = "体温异常"
        }
    }()
    if t > 37.5{
        panic("体温异常")
    }
    return ans
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

相关阅读:
解读阿里Q2财报：阿里云的跨周期引擎
 SHELL （bash）编程记录
 Python爬虫-爬取B站番剧封面
 spring上传文件
 线性表的应用 —— 双向链表 && 循环链表
 用友2023届秋招Java笔试-S2卷-编程题详解
 C++ //练习 10.2 重做上一题，但读取string序列存入list中。
OpenVX 源码分析-- 图的执行(TI / Sample)
1-前端基本知识-CSS
Hadoop到底是什么？他又由哪些组成？
原文地址：https://blog.csdn.net/qq_33957603/article/details/126059125