Implement wordBitsMap to Katakana struct

lib/katakana.go

@@ -1,8 +1,15 @@
 package lib
 
-import "sort"
+import (
+	"sort"
+)
 
 type WordBits uint64
+
+func (w WordBits) has(katakanaBits KatakanaBits) bool {
+	return w&WordBits(katakanaBits) != 0
+}
+
 type KatakanaBits uint64
 type KatakanaBitsMap map[rune]KatakanaBits
 type WordBitsMap map[KatakanaBits][]WordBits
@@ -12,10 +19,18 @@ type KatakanaCount struct {
 	count        int
 }
 
-func (w WordCountMap) getSortedKatakanaBitsCounts() []*KatakanaCount {
+func (w WordCountMap) toSortedKatakanaBitsList() (katakanaBits []KatakanaBits) {
+	sortedKatakanaBitsCounts := w.toSortedList()
+	for _, katakanaBitsCount := range sortedKatakanaBitsCounts {
+		katakanaBits = append(katakanaBits, katakanaBitsCount.katakanaBits)
+	}
+	return
+}
+
+func (w WordCountMap) toSortedList() []*KatakanaCount {
 	katakanaBitsCounts := w.toList()
 	sort.Slice(katakanaBitsCounts, func(i, j int) bool {
-		return katakanaBitsCounts[i].count > katakanaBitsCounts[j].count
+		return katakanaBitsCounts[i].count < katakanaBitsCounts[j].count
 	})
 	return katakanaBitsCounts
 }
@@ -47,6 +62,7 @@ func NewKatakana(words []string) *Katakana {
 	wordBitsList := katakana.loadWords(words)
 	wordCountMap := countWordBitsFrequency(wordBitsList)
 	katakana.wordCountMap = wordCountMap
+	katakana.wordBitsMap = katakana.createWordBitsMap(wordBitsList)
 	return katakana
 }
 
@@ -61,6 +77,27 @@ func (k *Katakana) toWordBits(word string) WordBits {
 	return toWordBits(k.katakanaBitsMap, word)
 }
 
+func (k *Katakana) createWordBitsMap(wordBitsList []WordBits) WordBitsMap {
+	sortedKatakanaBitsList := k.wordCountMap.toSortedKatakanaBitsList()
+	return newWordBitsMap(sortedKatakanaBitsList, wordBitsList)
+}
+
+func newWordBitsMap(sortedKatakanaBits []KatakanaBits, wordBitsList []WordBits) WordBitsMap {
+	var newWordBitsList []WordBits
+	copy(newWordBitsList, wordBitsList)
+
+	wordBitsMap := WordBitsMap{}
+	for _, wordBits := range wordBitsList {
+		for _, katakanaBits := range sortedKatakanaBits {
+			if wordBits.has(katakanaBits) {
+				wordBitsMap[katakanaBits] = append(wordBitsMap[katakanaBits], wordBits)
+				break
+			}
+		}
+	}
+	return wordBitsMap
+}
+
 func toWordBits(bitsMap KatakanaBitsMap, word string) WordBits {
 	bits := WordBits(0)
 	for _, w := range word {
@@ -74,7 +111,7 @@ func countWordBitsFrequency(wordBitsList []WordBits) WordCountMap {
 	for _, wb := range wordBitsList {
 		for i := uint64(0); i < katakanaLen; i++ {
 			katakanaBits := KatakanaBits(1 << i)
-			if wb&WordBits(katakanaBits) == 1 {
+			if wb.has(katakanaBits) {
 				wordCountMaps[katakanaBits]++
 			}
 		}

lib/katakana_test.go

@@ -1,6 +1,7 @@
 package lib
 
 import (
+	"reflect"
 	"testing"
 )
 
@@ -26,17 +27,25 @@ func TestNewKatakana(t *testing.T) {
 					katakanaBitsMap['ウ']: 2,
 					katakanaBitsMap['エ']: 1,
 				},
+				wordBitsMap: WordBitsMap{
+					katakanaBitsMap['ア']: []WordBits{
+						toWordBits(katakanaBitsMap, "アイウ"),
+					},
+					katakanaBitsMap['エ']: []WordBits{
+						toWordBits(katakanaBitsMap, "イウエ"),
+					},
+				},
 			},
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			katakana := NewKatakana(tt.args.words)
-			for katakanaBits, count := range katakana.wordCountMap {
-				expectedCount := tt.want.wordCountMap[katakanaBits]
-				if expectedCount != count {
-					t.Errorf("NewKatakana.wordCountMap[%v] = %v, want %v", katakanaBits, count, expectedCount)
-				}
+			if !reflect.DeepEqual(katakana.wordCountMap, tt.want.wordCountMap) {
+				t.Errorf("wordCountMap() = %v, want %v", katakana.wordCountMap, tt.want.wordCountMap)
+			}
+			if !reflect.DeepEqual(katakana.wordBitsMap, tt.want.wordBitsMap) {
+				t.Errorf("wordBitsMap() = %v, want %v", katakana.wordBitsMap, tt.want.wordBitsMap)
 			}
 		})
 	}