Go语言基础之map | 李文周的博客

[Q1mi]

https://www.liwenzhou.com/posts/Go/08_map/

李文周的Blog

[272909106]

package main import ( "fmt" ) func main() { var liZi = make([]string, 0, 4) liZi = append(liZi, "how", "do", "you", "do") fmt.Println(liZi) var tongJi = make(map[string]int) for _, v := range liZi { tongJi[v] = tongJi[v] + 1 } fmt.Println(tongJi) }

[cuteculu]

package main

import (
    "fmt"
    "strings"
)

//写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。
func main() {
    str := "how do you do think you about"
    strSlice := strings.Split(str, " ")
    fmt.Println(strSlice)

    countMap := make(map[string]int, 10)
    for _, key := range strSlice {
        _, isReal := countMap[key]
        if !isReal {
            countMap[key] = 1
        } else {
            countMap[key] += 1
        }
    }
    fmt.Println(countMap)
}

[ghost]

package main

import (
    "fmt"
    "strings"
)

func main() {
    words := "how do you do"
    splits := strings.Split(words, " ")
    result := make(map[string]int, 8)
    for _, v := range splits {
        result[v] = result[v] + 1
    }
    fmt.Println(result)
}

[yeahQing]

    //要统计的句子
    sentence := "how do you do"
    words := strings.Split(sentence, " ")
    fmt.Println(words) //输出切分后的字符串数组
    //初始化一个map结果集,cap=3,因为句子拆分后只有3种键
    result := make(map[string]int, 3)
    //遍历字符串数组,让map中对应的键++
    for _, v := range words {
        result[v]++
    }
    //输出结果集
    fmt.Println(result)

[yoqu]

func wordCount(words string) (r map[string]int) {
    wordsArr := strings.Split(words, " ")
    r = make(map[string]int, len(wordsArr))
    for _, word := range wordsArr {
        r[word]++
    }
    return
}

[code4happylife]

package main

import (
    "fmt"
    "strings"
)

/**
写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。

*/

func main(){
    var testString = "how do you do"
    result := countSentence(testString)
    for stringWord,mapResult := range result{
        fmt.Printf("the word:%v appeared %v times in :%v\n",stringWord,mapResult,testString)
    }
}

func countSentence(testString string) map[string]int {
    stringAfterop := strings.Split(testString," ")
    mapDemo := make(map[string]int,10)
    for _,v := range stringAfterop{
        mapDemo[v]++
    }
    return mapDemo
}
/*the word:how appeared 1 times in :how do you do
the word:do appeared 2 times in :how do you do
the word:you appeared 1 times in :how do you do*/

[Alexander-NO-1]

作为一个PHPer， 表示对go的写法有点懵逼，尤其map与slice的声明、初始化、和相互包含的结构，看来功力不够，得多敲敲了

[Alexander-NO-1]

求七哥解答，下面是我练习时做的笔记，不知道我理解的对不对，如果对，我想问的是，为什么颠倒顺序后map3也引用map1的地址，而不是map2的地址了呢？ 难道在map2 引用map1的时候， map2的地址被GC释放掉了吗？

        map1 := make(map[string]string, 10)
        map2 := make(map[string]string, 10)

    map3 := map2
    map2 = map1
    /**
        上面的三个map很有意思，可以进一步理解引用
        map1, map2 同时初始化为一个容量为10的空集合
        之后 map3 定义为引用 map2, 结果map3 是引用现在map2的地址
        再之后 map2 引用 map1 的地址，这时map1与map2，都指向map1的地址，而map3仍然指向map2的原空地址
        所以，无论如何修改map1与map2， 都只有map1与map2相互影响， 而map3 依然为空

        如果顺序改变为 map2 = map1, map3 := map2, 那么这个三个map 将同时指向同一地址，修改相互影响

     */

[Q1mi]

@Alexander-NO-1 求七哥解答，下面是我练习时做的笔记，不知道我理解的对不对，如果对，我想问的是，为什么颠倒顺序后map3也引用map1的地址，而不是map2的地址了呢？ 难道在map2 引用map1的时候， map2的地址被GC释放掉了吗？

        map1 := make(map[string]string, 10)
        map2 := make(map[string]string, 10)

  map3 := map2
  map2 = map1
  /**
      上面的三个map很有意思，可以进一步理解引用
      map1, map2 同时初始化为一个容量为10的空集合
      之后 map3 定义为引用 map2, 结果map3 是引用现在map2的地址
      再之后 map2 引用 map1 的地址，这时map1与map2，都指向map1的地址，而map3仍然指向map2的原空地址
      所以，无论如何修改map1与map2， 都只有map1与map2相互影响， 而map3 依然为空

      如果顺序改变为 map2 = map1, map3 := map2, 那么这个三个map 将同时指向同一地址，修改相互影响

   */

你写的是下面的意思吧？

a := 1
b := 2
c := b
b = a

---

a := 1
b := 2
b = a
c := b

[Alexander-NO-1]

@Q1mi

@Alexander-NO-1 求七哥解答，下面是我练习时做的笔记，不知道我理解的对不对，如果对，我想问的是，为什么颠倒顺序后map3也引用map1的地址，而不是map2的地址了呢？ 难道在map2 引用map1的时候， map2的地址被GC释放掉了吗？

        map1 := make(map[string]string, 10)
        map2 := make(map[string]string, 10)

    map3 := map2
    map2 = map1
    /**
        上面的三个map很有意思，可以进一步理解引用
        map1, map2 同时初始化为一个容量为10的空集合
        之后 map3 定义为引用 map2, 结果map3 是引用现在map2的地址
        再之后 map2 引用 map1 的地址，这时map1与map2，都指向map1的地址，而map3仍然指向map2的原空地址
        所以，无论如何修改map1与map2， 都只有map1与map2相互影响， 而map3 依然为空

        如果顺序改变为 map2 = map1, map3 := map2, 那么这个三个map 将同时指向同一地址，修改相互影响

     */

你写的是下面的意思吧？

a := 1 b := 2 c := b b = a

---

a := 1 b := 2 b = a c := b

嗯是这个意思， 但是slice和map是引用类型，普通变量看不出来效果吧，新手，七哥辛苦了

[Uarealoser]

@Alexander-NO-1

@Q1mi

@Alexander-NO-1 求七哥解答，下面是我练习时做的笔记，不知道我理解的对不对，如果对，我想问的是，为什么颠倒顺序后map3也引用map1的地址，而不是map2的地址了呢？ 难道在map2 引用map1的时候， map2的地址被GC释放掉了吗？

        map1 := make(map[string]string, 10)
        map2 := make(map[string]string, 10)

  map3 := map2
  map2 = map1
  /**
      上面的三个map很有意思，可以进一步理解引用
      map1, map2 同时初始化为一个容量为10的空集合
      之后 map3 定义为引用 map2, 结果map3 是引用现在map2的地址
      再之后 map2 引用 map1 的地址，这时map1与map2，都指向map1的地址，而map3仍然指向map2的原空地址
      所以，无论如何修改map1与map2， 都只有map1与map2相互影响， 而map3 依然为空

      如果顺序改变为 map2 = map1, map3 := map2, 那么这个三个map 将同时指向同一地址，修改相互影响

   */

你写的是下面的意思吧？

a := 1
b := 2
c := b
b = a

---

a := 1
b := 2
b = a
c := b

嗯是这个意思， 但是slice和map是引用类型，普通变量看不出来效果吧，新手，七哥辛苦了

你说的这个跟是不是引用类型没关系吧，就是个值的传递性。

[jagaimotomato]

func times(word string, search string) (int){ var times int for i := 0; i < len(strings.Split(search, " ")); i++ { if strings.Split(search, " ")[i] == word { times++ } } return times } 我没看题目， 这是某一个字符出现字数

[jagaimotomato]

func allTimes(word string, search string) (map[string]int){ result := make(map[string]int, 3) for _, key := range strings.Split(search, " ") { result[key]++ } return result }

[zunruiliu]

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

[Q1mi]

@zrleo

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

slice的底层是一个数组，不同的slice可能会共用一个底层数组。

[biuaxia]

@Q1mi

@zrleo

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

slice的底层是一个数组，不同的slice可能会共用一个底层数组。

同问，但是博主的答案我表示不懂，我理解的map["q1mi"]是指向了s，那么s切片为[1,3]，map["q1mi"]应该一致呢

[biuaxia]

题2：

实际答案为： [11 22 33 44 55 66 77 3] [11 33 44 55 66 77 3] [11 33 44 55 66 77 3 3] 关于最后一次append操作实际上是将1位置的元素由后面的元素补上，且将len-1，就形成了删除的效果，但是map还是指向的原来内容，且容量不变，故后面还有3，实际就是第一步追加的3收起

[shuwenjunn]

package main

import (
    "fmt"
    "strings"
)

func main() {
    var s = "how do you do do"

    var slice = strings.Split(s, " ")
    fmt.Println(slice)
    fmt.Printf("%T,%d\n", slice, len(slice)) //切片类型的 string
    var l = len(slice)

    var m = make(map[string]int, l) //初始化map

    for i, v := range slice {
        _, ok := m[v]
        if !ok {
            times := 0
            for j := i; j < l; j++ {
                if slice[j] == v {
                    times++
                }
            }
            m[v] = times
        }
    }

    fmt.Println(m)
}

[mytea003]

第一题：

1、首先这题是我做出来之后才懂的；解这题有两个问题：1是字符串需要做成切片才能使单词独立；2是单词作为key，每出现一次value+1。

有个需要注意的地方

map由键+值组成的，键是唯一的，相同的键，只会是值有不同，不会存在两个相同的键。理解这点，解这题的话就不需要进行两个键的比较了。

第一个问题关注点如下包及函数：

func Split(s, sep string) []string用去掉s中出现的sep的方式进行分割，会分割到结尾，并返回生成的所有片段组成的切片（每一个sep都会进行一次切割，即使两个sep相邻，也会进行两次切割）。如果sep为空字符，Split会将s切分成每一个unicode码值一个字符串。

strings包的Split函数的用法：

fmt.Printf("%q\n", strings.Split("a,b,c", ","))
fmt.Printf("%q\n", strings.Split("a man a plan a canal panama", "a "))
fmt.Printf("%q\n", strings.Split(" xyz ", ""))
fmt.Printf("%q\n", strings.Split("", "Bernardo O'Higgins"))

输出： ["a" "b" "c"]

["" "man " "plan " "canal panama"]

[" " "x" "y" "z" " "]

[""]

第二个问题关注的是map的value的赋值。这个应该很简单吧

map2[v2] = map2[v2] + 1

完整的解题1

func main(){
        str := "how do you do"
    strSlice := strings.Split(str, " ")            //做成切片
    var map1 = make(map[string]int, len(strSlice)) //定义接收的数据结构map
    for i, v := range strSlice {
        _, ok := map1[v] //这里的意思是判断map里面v这个键是否存在，如果存在就读出数值和判断是否成功。
        if !ok {         //如果OK，就什么都不处理退出。
            count := 0
            for j := i; j < len(strSlice); j++ { //循环多少次呢？ 初始化的次数是切片的次数；条件表达式是小于切片的次数；结束语句是自增加。
                if strSlice[j] == v { //如果切片的第几个元素和外层读出来的v值也就是切片的第一个元素作对比。
                    count++ //相同就计数加1，如果不相同就算了。这个count计数变量是内部的，到了外层for第二次循环的时候，count变量会清零。
                }
            }
            map1[v] = count //相同自加一之后就会写到当前map的键对应的值。
        }
    }

    fmt.Println(map1)
}

完整的解题2

func main(){
        str2 := "how do you do"
    strSlice2 := strings.Split(str2, " ")
    map2 := make(map[string]int, len(strSlice2))
    for _, v2 := range strSlice2 {
        map2[v2] = map2[v2] + 1
    }
    fmt.Println(map2)
}

第二题

2、正确结果应该为【1，3，3】； 结果心算错了，我写的是【1，2，3，1，2，3】；

• fmt.Printf("第一次打印%+v\n", s) 这里的%+我没看懂，为什么可以这样写，也没找到有关资料。
• s = append(s[:1], s[2:]...)这句我理解错了，以为是最追，其实是删除2这个元素。

因为切片是引用类型，所以所有的操作都是底层的同一组数据，也就是刚开始定义的s。 还有一个点，在s变量被追加1个元素3之后，就把这个切片的容量赋值给了map，当时容量是3，那么以后怎么搞这个变量s，对于map来说，它只会受到前3个元素的影响，3个元素之后的变化，m是不再受到影响。

[wyhhh]

package main

import `fmt`

func main() {
    //写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。
    // 常规的字符串操作的算法题
    const Sentence = `how do you do`
    mp := map[string]int{}
    sl := []byte{} // 先定义一个byte数组用于临时存放串
    for i := 0; i < len(Sentence); i++ {
        if Sentence[i] == ' ' { // 如果等于空格 那么存入map
            fmt.Println("sl.s =", string(sl))
            mp[string(sl)]++
            sl = sl[0:0]
        } else { // 否则 追加到byte数组中
            sl = append(sl, Sentence[i])
        }
    }
    mp[string(sl)]++  // 最后跳出后再补上最后个单词即可
    fmt.Println("mp =", mp)
}

[wyhhh]

@zrleo

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

自始至终只有一个堆区的底层数组 切片的操作不过是改变了size而已

[John520]

package main

import
(
    "fmt"
    "strings"
) 

func main(){
    s:="how do you do"
    split:=strings.Split(s," ")
    m:=make(map[string]int,len(split))
    for _,i:= range split{
        value, ok := m[i]
        if(ok){
            m[i]=value+1
        }else{
            m[i]=1
        }

    }
    fmt.Println(m)

}

[John520]

更新一下用正则匹配更加严谨

package main

import
(
    "fmt"
    // "strings"
    "regexp"
) 

func main(){
    s:="how do you    do"
    // split:=strings.Split(s," ")
    // update 采用正则匹配来分割字符串
    spaceRe, _ := regexp.Compile(`\s+`)

    split := spaceRe.Split(s, -1)
    m:=make(map[string]int,len(split))
    for _,i:= range split{
        value, ok := m[i]
        if(ok){
            m[i]=value+1
        }else{
            m[i]=1
        }

    }
    fmt.Println(m)

}

[John520]

[1 2 3]
[1 3]
[1 3 3]

[tangjoin]

package main

import (
    "fmt"
    "strings"
)

// 写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。
func main() {
    str := "how do you do you d d k k k k k k k kkkk"
    type mapA map[string]int
    mapStr := make(mapA)
    arrStr := strings.Split(str, " ")
    for _, val := range arrStr {
        if mapStr[val] > 0 {
            mapStr[val]++
        } else {
            mapStr[val] = 1
        }
    }
    fmt.Printf("%v \n", mapStr)

}
// map[d:2 do:2 how:1 k:7 kkkk:1 you:2]

[tyf740083371]

这里开始，爷就有点懵了。

[cutety]

package main

import ( "fmt" "strings" )

func main() { str := "how do you do with it how do" //用strings方法将每个单词放到切片中 stringSlice := strings.Split(str, " ") fmt.Println(stringSlice) //创建一个map将切片中的单词放进去 wordMap := make(map[string]int) //遍历stringSlice for _, value := range stringSlice { //fmt.Println(value) v, ok := wordMap[value] if ok { v++ wordMap[value] = v } else { wordMap[value] = 1 }

}
fmt.Println(wordMap)

}

[Eron-CN]

package main

import "fmt" import "strings"

func main(){

text := "how do you do I do nothing and you"

textArray := strings.Split(text, " ")

countMap := make(map[string]int, 8)

for _ , v := range textArray {
    countMap[v]++
}

for k, v := range countMap{
    fmt.Printf("k: %s v: %d\n",k,v)
}

}

[yangfan16]

// 统计英文中单词的出现次数

func CalWordNum(str string) map[string]int {
    result := make(map[string]int)
    data := strings.Split(str, " ")
    for _, val := range data {
        result[val]++
    }
    return result
}

// 打印结果 slice可以向后扩展

[1 2 3]
[1 3]
[1 3 3]

[MissToX]

package main

import ( "fmt" "strings" )

func main() { s := "how do you do" sSclice := strings.Split(s, " ") fmt.Println(sSclice) fmt.Println(sSclice[2]) sMap := make(map[string]int) for i := 0; i < len(sSclice); i++ { _, ok := sMap[sSclice[i]] if ok { sMap[sSclice[i]]++ } else { sMap[sSclice[i]] = 1 } } fmt.Println(sMap) }

但是我用for key := range sSclice出现“cannot use key (type int) as type string in map index”

[jipyu]

题目1:

func countWords(s string) {
    keys := strings.Split(s, " ")
    var countMap = map[string]int{}
    for _, k := range keys {
        countMap[k]++
    }
    for k := range countMap {
        fmt.Println(k, countMap[k])
    }
}

[LnkSaber]

为啥别人最后一个是 【1，3，3】 切片不是地址传递么?

func homeworkOne(s string){

// [1,2,3]
// [1,3]
// [1,3]
word := strings.Split(s," ")
var countMap = map[string]int{}
for _,val :=range word{
    countMap[val]++
}
for k := range countMap {
    fmt.Println(k, countMap[k])
}

}

[LnkSaber]

@Q1mi

@zrleo

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

slice的底层是一个数组，不同的slice可能会共用一个底层数组。

所以不应该是【1，3】么

[jacobwwang]

0. 切片：包含指针，长度和容量
1. m["q1mi"] 和 s 指向同一个数组：[1 2 3]
2. s 切片删除了下标为 1 的元素，直接在共享数组修改，修改后数组为 [1 3 3]
3. 此时 s 的指针，指向底层共享数组，长度为 2，容量为 4（容量为 4，是因为扩容一次）
4. m["q1mi"] 的指针，也指向底层共享数组，长度为 3，容量为 4

[c-jf]

打印结果不应该是： [1,2,3] [1,3] [1,3] 不应该是这样么，为什么评论里面有人说是[1,3,3],请问[1,3,3]是怎么来的，这里没懂

[wilsonliu123]

package main

import (
    "flag"
    "fmt"
    "strings"
)

func main() {
    var str string
    flag.StringVar(&str,"sentence","","Input test string")
    flag.Parse()

    if len(strings.TrimSpace(str)) == 0 {
        fmt.Println("Please input some sentence....")
        return
    }
    aryStr := strings.Split(str," ")
    mapStr :=make(map[string]int)
    for _, s := range aryStr {
        times,_:= mapStr[s]
        times ++
        mapStr[s]=times
    }
    fmt.Printf("%v\n",mapStr)
}

[kenaxy]

func mapTest() {
    str := "how do you do"
    words := strings.Split(str, " ")
    fmt.Printf("%v --- %T\n", words, words)
    var result = make(map[string]int, 3)
    for _, v := range words {
        v1, ok := result[v]
        if !ok {
            result[v] = 1
        } else {
            result[v] = v1 + 1
        }
    }

    fmt.Println(result)
}

[ruan-x]

func exercise1(str string) map[string]int { arr := strings.Split(str, " ") m := make(map[string]int) for _, k := range arr { if v, ok := m[k]; ok { m[k] = v + 1 } else { m[k] = 1 } } return m }

[JinQing1991]

@LnkSaber

@Q1mi

@zrleo

fmt.Printf("%+v\n", m["q1mi"])

输出结果竟然是 [1 3 3] 没太明白 求指导啊

slice的底层是一个数组，不同的slice可能会共用一个底层数组。

所以不应该是【1，3】么

切片s的长度是2，容量是4，切片m["q1mi"]的长度是3，容量是4，这两个切片共享了同一个底层的数组。s = append(s[:1], s[2:]...)这个操作删除了切片s中的一个元素，同时也修改了底层数组的值。

[fucheng53614]

str := "how do you do"

wordCount := make(map[string]int, 10)
for _, v := range strings.Split(str, " ") {
    value, ok := wordCount[v]
    if ok {
        wordCount[v] = value + 1
    }else{
        wordCount[v] = 1
    }
}

for k, v := range wordCount {
    fmt.Println(k, v)
}

[sub-rats]

package main

import ( "fmt" "strings" )

// 统计单词出现的次数

func main() { str := "how do, you; do?" bytes := ",./;)<>?:{}[]|`~!@#$%^&*(\"\'" // 1.先遍历以上的字符，然后判断字符是不是在字符中 // var temp = make([]string, 100, 100) for _, v := range bytes { if strings.Contains(str, string(v)) { temStr := strings.Split(str, string(v)) fmt.Println(temStr) } } } 我这个切割后为什么temStr会有多个值啊？

[ghost]

func wc(s string) (map[string]int) {
    s = strings.TrimSpace(s)
    ss := strings.Split(s, " ")
    var res map[string]int = make(map[string]int)
    for _, k := range ss {
        k = strings.TrimSpace(k)
        //if len(k) == 0 {
        if k == "" {
            continue
        }
        _, ok := res[k]
        if !ok {
            res[k] = 1
        } else {
            res[k]++
        }
    }
    return res
}

func main() {
    //test_map()
    s := "    How do  you   do  "
    m := wc(s)
    fmt.Println(m)
}

支持任意空格的字符串，比如how do you do

[xjb714]

        ss:="how do you do"
    m:=make(map[string]int)
    S:=strings.Split(ss," ")
    for _,value:=range S{
        m[value]++
    }
    for key,value:=range m{
        fmt.Printf("%s=%d\n",key,value)
    }

[aishuaikang]

七米老师，练习题第二题，s的最终打印结果是[1 3]，m["q1mi"]按理说应该也是[1 3]可是最终打印[1 3 3]这是咋回事呀

[xaohuihui]

请问同样是用make初始化内存，map却不能使用cap方法。

[brianchiang-tw]

hw1:
写一个程序，统计一个字符串中每个单词出现的次数。
比如：”how do you do”中how=1 do=2 you=1。

---

package main

import (
    "fmt"
    "strings"
)

func main() {

    var inputStr string = "how do you do"

    words := strings.Split(inputStr, " ")

    wordOccMap := make(map[string]int, 5)

    for _, word := range words {

        // update the occurrence of word
        wordOccMap[word] += 1
    }

    // output the occurrence of word
    for word, occ := range wordOccMap {
        fmt.Printf("%v = %v \n", word, occ)
    }

}

---

output:
how = 1 do = 2 you = 1

[brianchiang-tw]

hw2:
观察下面代码，写出最终的打印结果。

---

package main

import (
    "fmt"
)

func main() {
    type Map map[string][]int
    m := make(Map)
    s := []int{1, 2}

    fmt.Printf("cap(s) = %v \n", cap(s))

    s = append(s, 3)

    fmt.Printf("cap(s) = %v \n", cap(s))

    fmt.Printf("%+v\n", s)
    m["q1mi"] = s

    s = append(s[:1], s[2:]...)

    fmt.Printf("cap(s) = %v \n", cap(s))

    fmt.Printf("%+v\n", s)
    fmt.Printf("%+v\n", m["q1mi"])
}

---

output: cap(s) = 2 cap(s) = 4 [1 2 3] cap(s) = 4 [1 3] [1 3 3]

slice底層是一塊連續的記憶體空間，
s在第一次append之後，capacity已經成長到4, 且lenggth為3
此時s = {1, 2, 3}

雖然第二次append修改為
s = {1, 3}, length為2,但capacity仍然為4

而且，m["q1mi"]指定到的slice仍然是同一塊記憶體空間，
所以m["q1mi"] = {1,3,3}
此時 length(m["q1mi"] ) = 3,
capacity(m["q1mi"]) = 4

[Nowaterbottles]

1.第一题 func SumWords(str string) { arr := strings.Fields(str) m := make(map[string]int, 10) for _, v := range arr { m[v] += 1 } fmt.Println(m) }

[Mia123321]

写一个程序，统计一个字符串中每个单词出现的次数。比如：”how do you do”中how=1 do=2 you=1。

func main() { str := "how do you do how do you do how do you do" strSlice := strings.Split(str, " ") fmt.Println(strSlice) var strMap = make(map[string]int) for , v := range strSlice{ , ok := strMap[v] if !ok{ strMap[v] = 1 }else{ strMap[v] += 1 } } fmt.Println(strMap) }

[gaoleia-personal]

第一题

package main

import (
    "fmt"
    "strings"
)

func main()  {
    str := "how do you do"
    strSlice := strings.Split(str," ")
    wordCount := make(map[string]int, len(strSlice))
    for _,word := range strSlice {
        _,val := wordCount[word]
        if(val){
            wordCount[word] += 1
        }else{
            wordCount[word] = 1
        }
    }
    fmt.Println(wordCount)
}