An answer of the exercise: Maps on a tour of Go

answer_word_count.go

package main

import (
	"code.google.com/p/go-tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	a := strings.Fields(s)
	for _, v := range a {
		m[v]++
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	//split the sentence into  words
	words := strings.Fields(s)
	
	//instantiate wordcount map
        //where word will be the key, and count will be value
	wordcount := make(map[string]int)

	//loop through each word in sentence..
	for _, element := range words {
		
		// and increment the counter of that word by 1
		wordcount[element] = wordcount[element] + 1
	}

	return wordcount
}

func main() {
	wc.Test(WordCount)
}

I think mine is stupid but it works ...

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	fs := strings.Fields(s)
	m := make(map[string]int)
	for _, v := range fs {
            if len(v) == 1 {
                c := strings.Count(s, v + " ")
		m[v] = c
	    } else {
		m[v] = strings.Count(s, v)
	    }	
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	count := make(map[string]int)
	for _, v := range strings.Fields(s) {
		count[v] = (count[v] + 1)
	}
	return count
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	wordsList := strings.Fields(s)
	for _, word := range wordsList {
		m[word]++
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	fields := strings.Fields(s)
	
	for _, v := range fields {
		m[v]++
	}
	
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

// WordCount comment
func WordCount(s string) map[string]int {
	fields := strings.Fields(s)
	result := map[string]int{}

	for _, v := range fields {
		if _, ok := result[v]; ok {
			result[v]++
		} else {
			result[v] = 1
		}
	}

	return result
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	var sList = strings.Fields(s)
	var wordCount = make(map[string]int)
	for _, v := range sList {
		wordCount[v] = wordCount[v] + 1
	}
	return wordCount
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc";
	"strings";
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	a := strings.Fields(s)
	for _, v := range(a) {
		m[v]++
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

I had some problems with testing function wc.test so I tested it manually

package main

import "strings"
import "fmt"

func WordCount(s string) map[string]int {
	m := make(map[string]int)

	out := strings.Split(s, " ")

	for _, val := range out {
		m[val]++
	}


	return m
}

func main() {
	m := make(map[string]int)
	m = WordCount("This is how I count a lot of words and I test function of counting words")
	fmt.Println(m)
}

package main

import (
"golang.org/x/tour/wc"
"strings"
)

func WordCount(s string) map[string]int {
words := strings.Fields(s)
m := make(map[string]int, len(words))
for _,v := range words{
m[v] += 1
}
return m
}

func main() {
wc.Test(WordCount)
}

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {

	counts := make(map[string]int)
	words := strings.Fields(s)
	
	for i := range words{
	
			counts[words[i]]++
	
	}
	return counts
}

func main() {
	wc.Test(WordCount)
}

Here is my answer:

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	r := strings.Fields(s)
	for _, v := range r {
		_,ok:= m[v]
		if ok {
		   m[v] = m[v] +1
		}else{
		   m[v] = 1
		}
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	splitInput := strings.Split(s," ")
	wordCount := make(map[string]int)
	for _ , r := range splitInput {
		wordCount[r] = wordCount[r]+1
	}

	return wordCount
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
    words := strings.Fields(s)
	wordCount := make(map[string]int)
	
	for _, word := range words {
	    if _, exist := wordCount[word]; exist == true {
		    wordCount[word] += 1
		} else {
		    wordCount[word] = 1
		}
	}
	return wordCount
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	f := strings.Fields(s)
	wc := make(map[string]int)
	
	for _, v := range f {
		wc[v]++
	}
	
	return wc
}

func main() {
	wc.Test(WordCount)
}

without "strings"

I'm a beginner so please give me some advice

package main

import (
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	var word string
	ans := make(map[string]int)
	for i, w := range s {
		if string(w) == " "{
			ans[word]++
			word = ""
		}else if i == len(s)-1 {
			word += string(w)
			ans[word]++
			word = ""
		}else{
			word += string(w)
		}
	}
	return ans
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"

	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	words := strings.Fields(s)
	wordCounts := make(map[string]int)
	for _, v := range words {
		wordCounts[v]++
	}
	return wordCounts
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	var sentence []string = strings.Fields(s)
	var m = make(map[string]int)
	var edited bool = false

	for _, v := range sentence {
		for key, i := range m {
			if key == "" {
				edited = false
			} else if v == key && key != "" {
				i++
				m[v] = i
				edited = true
			}
		}
		if !edited {
			m[v] = 1
		} else {
			edited = false
		}
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	for _, a := range strings.Split(s, " ") {
		v, ok := m[a]
		if ok {
			m[a] = v + 1
		} else {
			m[a] = 1
		}
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

without Split or Fields func

O(n)

package main

import (
	"golang.org/x/tour/wc"
)

// Return a map of the counts of each “word” in the string s.
func WordCount(s string) (wordsMap map[string]int) {

	wordsMap = make(map[string]int)
	sizeS := len(s)
	j := 0
	for i := 0; i < sizeS; i++ {
		// you can replace this condition with regex or multiple condition with differents caracters, but the test only consider the spaces.
		if s[i] == ' ' {
			wordsMap[s[:i]]++
			s = s[(i + 1):]
			sizeS -= j + 1
			i -= j
			j = 0
		}
		j++
	}
	wordsMap[s]++
	return
}

// The wc.Test function runs a test suite against the provided function and prints success or failure.
func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m:= map[string]int{}

	for _,v:= range strings.Fields(s) {
		m[v]++
	}
	
	return m
}

func main() {
	wc.Test(WordCount)
}

Que es? El jue., 13 de mayo de 2021 23:15, Boullon Daniel ***@***.***> escribió:

…

***@***.**** commented on this gist. ------------------------------ without Split or Fields func O(n) package main import ( "golang.org/x/tour/wc" ) // Return a map of the counts of each “word” in the string s. func WordCount(s string) (wordsMap map[string]int) { wordsMap = make(map[string]int) sizeS := len(s) j := 0 for i := 0; i < sizeS; i++ { // you can replace this condition with regex or multiple condition with differents caracters, but the test only consider the spaces. if s[i] == ' ' { wordsMap[s[:i]]++ s = s[(i + 1):] sizeS -= j + 1 i -= j j = 0 } j++ } wordsMap[s]++ return } // The wc.Test function runs a test suite against the provided function and prints success or failure. func main() { wc.Test(WordCount) } — You are receiving this because you commented. Reply to this email directly, view it on GitHub <https://gist.github.com/2280069#gistcomment-3742179>, or unsubscribe <https://github.com/notifications/unsubscribe-auth/AST4I6IFZU5UNOUQY4W5MBTTNSBVJANCNFSM4IYSUVXA> .

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	var m = map[string]int {}
	for _, w:= range strings.Fields(s) {
		_, ok := m[w]
		if (ok) {
			m[w] += 1
		} else {
			m[w] = 1
		}
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	for _,w:= range strings.Split(s," "){
		_,ok := m[w]
		if ! ok {
			m[w] = 1
		} else {
			m[w] += 1
		}
	}
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	m := make(map[string]int)
	
	ss := strings.Fields(s)
	for _, word := range ss {
		_, exists := m[word]
		
		if exists {
			m[word]++
		} else {
			m[word] = 1
		}
	}
	
	return m
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	a := []string{s}
	var b map[string]int
	b = make(map[string]int)
	for _, el := range a {
		a1 := strings.Fields(el)
		for e1, e2 := range a1 {
			e1 = b[e2]
			if e1 == e1 {
				b[e2] = e1 + 1
			}
		}
	}
	return b
}

func main() {
	wc.Test(WordCount)
}

package main

import (
	"strings"
	"golang.org/x/tour/wc"
)

func WordCount(s string) map[string]int {
	words := strings.Fields(s)
	words_map := make(map[string]int)

	for _, word := range words {
		if count, is_present := words_map[word]; is_present {
			words_map[word] = count + 1
		} else {
			words_map[word] = 1
		}
	}
	return words_map
}

func main() {
	wc.Test(WordCount)
}

Here is my struggling answer without strings.Fields.

package main

import "golang.org/x/tour/wc"

func WordCount(s string) map[string]int {
	result := make(map[string]int)
	words := make([]string, 0)
	var start, end, wordLen int
	for i, rune := range s {
		wordLen += 1
		if string(rune) != " " {
			continue
		}
		end = i
		words = append(words, s[start:end])
		start = i+1
		wordLen = 0
	}
	if wordLen > 0 {
		words = append(words, s[start:len(s)])
	}	
	for _, v := range words {
		_, ok := result[v]
		if ok {
			result[v] += 1
		} else {
			result[v] = 1
		}
	}
	return result
}

func main() {
	wc.Test(WordCount)
}

package main

import (
"golang.org/x/tour/wc"
"strings"
)

func WordCount(s string) map[string]int {
counterMap := make(map[string]int)

for _, word := range strings.Fields(s) {
	value, isPresent := counterMap[word]
	
	if isPresent {
		counterMap[word] = value + 1
	
	} else {
		counterMap[word] = 1
	}
}

return counterMap

}

func main() {
wc.Test(WordCount)
}

package main

import (
	"golang.org/x/tour/wc"
	"strings"
)

func WordCount(s string) map[string]int {
	count := make(map[string]int)
	
	for _, word := range strings.Fields(s) {
		count[word]++
	}
	
	return count
}

func main() {
	wc.Test(WordCount)
}