经典面试题golang实现方式（一）

经典面试题golang实现方式（一）

以下所有题目的关键信息都会用【】括起来，我们不对题目进行分析，只给出题目的解决方案；如有疑问请不吝赐教。

题目： 
请实现一个算法，确定一个字符串的所有字符【是否全都不同】。

这里我们要求【不允许使用额外的存储结构】。

给定一个string，请返回一个bool值,true代表所有字符全都不同，false代表存在相同的字符。

保证字符串中的字符为【ASCII字符】。

字符串的长度小于等于【3000】。

代码实现：

package main

import (

    "fmt"

    "strings"

)

func isUniqueStr(s string) bool {

    if len([]rune(s)) > 3000 {

        return false

    }

    for _, v := range s {

        if v > 127 {

            return false

        }

        if strings.Count(s, string(v)) > 1 {

            return false

        }

    }

    return true

}

func main() {

    s1 := "aeiou"

    fmt.Println(isUniqueStr(s1))

    s2 := "BarackObama"

    fmt.Println(isUniqueStr(s2))

}

运行结果：

true

false

题目： 
请实现一个算法，在不使用【额外数据结构和储存空间】的情况下，翻转一个给定的字符串(可以使用单个过程变量)。

 
给定一个string，请返回一个string，为翻转后的字符串。

保证字符串的长度小于等于5000。

代码实现：

package main

import (

    "fmt"

)

func reverString(s string) (string, bool) {

    str := []rune(s)

    len := len(str)

    if len > 5000 {

        return string(str), false

    }

    for i := 0; i < len/2; i++ {

        str[i], str[len-1-i] = str[len-1-i], str[i]

    }

    return string(str), true

}

func main() {

    s1 := "This is golang"

    fmt.Println(reverString(s1))

    s2 := "gnalog si sihT"

    fmt.Println(reverString(s2))

}

运行结果：

gnalog si sihT  true

This is golang  true

题目： 
给定两个字符串，请编写程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。

这里规定【大小写为不同字符】，且考虑字符串重点空格。

给定一个string s1和一个string s2，请返回一个bool，代表两串是否重新排列后可相同。

保证两串的长度都小于等于5000。

代码实现：

package main

import (

    "fmt"

    "strings"

)

func isRegroup(s1, s2 string) bool {

    if len([]rune(s1)) != len([]rune(s2)) {

        return false

    }

    for _, v := range s1 {

        if strings.Count(s1, string(v)) != strings.Count(s2, string(v)) {

            return false

        }

    }

    return true

}

func main() {

    s1 := "This is golang"

    s2 := "gnalog si sihT"

    fmt.Println(isRegroup(s1, s2))

    s3 := "Here you are"

    s4 := "Are you here"

    fmt.Println(isRegroup(s3, s4))

    s5 := "This is golang1.1"

    s6 := "This is golang1"

    fmt.Println(isRegroup(s5, s6))

}

运行结果：

true

false

false

题目： 
请编写一个方法，将字符串中的空格全部替换为“%20”。

假定该字符串有足够的空间存放新增的字符，并且知道字符串的真实长度(小于等于1000)，同时保证字符串由【大小写的英文字母组成】。

给定一个string为原始的串，返回替换后的string。

代码实现：

package main

import (

    "fmt"

    "strings"

    "unicode"

)

func replaceBlank(s string) (string, bool) {

    if len([]rune(s)) > 1000 {

        return s, false

    }

    for _, v := range s {

        if string(v) != " " && unicode.IsLetter(v) == false {

            return s, false

        }

    }

    return strings.Replace(s, " ", "%20", -1), true

}

func main() {

    s1 := "Hello World"

    fmt.Println(replaceBlank(s1))

    s2 := "Hello,World"

    fmt.Println(replaceBlank(s2))

}

运行结果：

Hello%20World   true

Hello,World     false