代码练习

？回文数(类型转换)

题目

解答一：

import "strconv"
import "fmt"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 *
 * @param x int整型
 * @return bool布尔型
*/
func isPalindrome(x int) bool {
    // write code here
    var str string = strconv.Itoa(x)
    length := len(str)
    for i := 0; i < length/2; i++ {
        if str[i] != str[length-i-1] {
            return false
        }
    }
    return true
}

• 简单转换 - 在高低精度上进行转换，可以用int(),string()的方式
• 不同类型之间转换，建议用strconv的转换函数包括Atoi，string to int方式。Itoa ，int to string 方式

这里取个巧，用的Sprintf方式， Sprintf是将所有的格式化内容转为string形式并返回。Sprintf内置了String()函数进行转换，注意，这里不能循环嵌套使用string函数，只能递归一次。

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

字符类型转换有很大的问题

sort函数——排序

package main
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[:])
    a := arr[2] - arr[0]
    return a
}

注意，要import sort

逻辑运算符

位运算符里，有&，|，！、^，返回的是整数

逻辑运算符&&、||、！返回的是bool

排序题2

解题两种解法：

易错

package main
import "sort"
func minAndMax( s []int ) []int {
    // write code here
    sort.Ints(s)
    return append(s[1], s[len(s)-1])//错了！！！
}

解释：

1. append函数必须是在一个切片的基础上，加上点什么，可能是一个或多个元素，或其他切片，但至少有一个是切片
2. 一个元素也可以成切片，切近截取切片，包头不包围

package main
import "sort"
func minAndMax( s []int ) []int {
    // write code here
    sort.Ints(s)
    return append(s[:1], s[len(s)-1:]...)
    //或者是append(s[:1], s[len(s)-1])
}

怎么用集合计算字符串出现最多次的字符并返回

package main
//import "fmt"
/**
 * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
 *
 * 
 * @param s string字符串 
 * @return char字符型
*/
func character( s string ) byte {
    // write code here
    //用集合统计字符出现次数
    ret := map[byte]int{}
    for i:=0; i<len(s); i++{
        if _,ok := ret[s[i]]; !ok{
            ret[s[i]] = 1
            //这就这个程序的巧妙之处，一开始怎么初始化——
        }else{
            ret[s[i]]++
            //增加
        }
    }
    //循环 + 判断 通过每个的比较，大的就留下，而不是排序法那样的全部比较
    maxnum := ret[s[0]]//第一个字符出现次数
    maxstr := s[0]//第一个字符
    for k,v := range ret{
        if v > maxnum{
            maxnum = v
            maxstr = k
        }
    }
    return maxstr
}

？cp29 字符串的构成

package main
import "fmt"
func main(){
    x := canConstruct("ab","aax")
    fmt.Printf("%t",x)
}
func canConstruct( des string ,  src string ) bool {
    // write code here
    map_1 := map[byte]int{}
    for i:=0; i<len(src); i++{
        sed := byte(src[i])//sed就单个字符，需要把string类型转换成byte类型
        if _, ok := map_1[sed]; !ok {
            map_1[sed] = 1
        } else {
            map_1[sed]++
        }
    }
    fmt.Println(map_1)
    for j:=0; j<len(des); j++{
        for k,_ := range map_1{
            k_1 := byte(des[j])
            if k_1 == k{
                map_1[k]--
            }
            if map_1[k]<0||map_1[k] == 0{
                return false
            }
        }
    }
    return true
}