problems when searching for certain substrings in a string

The code doesn't work properly.

I have to check all the substrings contained in the given string and they have to meet these two requirements:

• length at least equal to 3 characters;
• starting and ending with the same character.

The output has to include those substrings and their occurences.

No problems when giving in input abbabba and abcacba, but when giving eabcacf errors start to pop-up. In fact it re-reads the cac substring and counts it another time, so I tried to fix this problem by checking where that substring is located (strings.Index function) and trimming the strings after, so if the substring needs to be re-read another time, it's for sure due to an occurency and not due to an error... at least this is what I thought.

...because when giving eabbcabcbf it re-reads cabc even after the previous fix, this is caused by the fact that cabc appears twice but not consecutively, so the previous/current approach doesn't work, it's necessarily needed a previous2/previous1/current approach to check also the third last substring, but I think that in this way, there will be always an error and fixing will result impossible.

Maybe the problem is caused by a possible wrong implementation of the code part that finds all the substrings at the beginning, but I can't figure it out how to fix it.

I attach the code and the outputs below.

Hope someone can help me!

code
(I put some fmt.Println() functions to print the slices and debug it)

package main
import (
"fmt"
"os"
"strings"
)
func main() {
string1 := os.Args[1]
count1 := 0
count2 := 0
count3 := 0
var substring1, substring2, start1, previous1, output1 string
var slice1, slice2, slice5 []string
var slice3, slice4 []int
var position1, saved1 int
var check1 bool
dict1 := make(map[string]int)
for index1 := 3; index1 <= len(string1); index1++ {
for index2 := 0; index2 <= len(string1)-3; index2++ {
for _, value3 := range string1[index2:] {
count1++
substring1 += fmt.Sprintf("%s", string(value3))
if count1 == index1 {
slice1 = append(slice1, substring1)
count1 = 0
substring1 = ""
}
}
count1 = 0
substring1 = ""
}
}
fmt.Println(slice1)
for _, value4 := range slice1 {
substring2 = value4
for index5, value5 := range substring2 {
if index5 == 0 {
start1 = string(value5)
}
if (index5 == len(substring2)-1) && (string(value5) == start1) {
slice2 = append(slice2, substring2)
}
}
}
fmt.Println(slice2)
for index6, value6 := range slice2 {
if index6 == 0 {
previous1 = value6
}
if (value6 == previous1) && (index6 == 0) {
position1 = strings.Index(string1[position1:], value6)
saved1 = position1
slice3 = append(slice3, position1)
} else if (value6 == previous1) && (index6 != 0) {
position1 = strings.Index(string1[saved1+1:], value6)
slice3 = append(slice3, position1)
} else if value6 != previous1 {
position1 = 0
position1 = strings.Index(string1[position1:], value6)
saved1 = position1
slice3 = append(slice3, position1)
}
previous1 = value6
}
fmt.Println(slice3)
for index7, value7 := range slice3 {
if value7 == -1 {
slice4 = append(slice4, index7)
}
}
fmt.Println(slice4)
if len(slice4) > 0 {
for index8, value8 := range slice2 {
for _, value9 := range slice4 {
if index8 != value9 {
check1 = false
} else {
check1 = true
break
}
}
if check1 == false {
slice5 = append(slice5, value8)
}
}
fmt.Println(slice5)
for _, value10 := range slice5 {
dict1[value10] = dict1[value10] + 1
}
for range dict1 {
count2++
}
for key1, item1 := range dict1 {
count3++
if count3 != count2 {
output1 += fmt.Sprintf("%s -> Occorrenze: %d\n", key1, item1)
} else {
output1 += fmt.Sprintf("%s -> Occorrenze: %d", key1, item1)
}
}
fmt.Println(output1)
} else {
for _, value8 := range slice2 {
dict1[value8] = dict1[value8] + 1
}
for range dict1 {
count2++
}
for key1, quantity1 := range dict1 {
count3++
if count3 != count2 {
output1 += fmt.Sprintf("%s -> Occurrences: %d\n", key1, quantity1)
} else {
output1 += fmt.Sprintf("%s -> Occurrences: %d", key1, quantity1)
}
}
fmt.Println(output1)
}
}

outputs

correct

$ go run exercise_2.go abbabba
abbabba -> Occurrences: 1
bbabb -> Occurrences: 1
babb -> Occurrences: 1
abba -> Occurrences: 2
bbab -> Occurrences: 1
bab -> Occurrences: 1

correct

$ go run exercise_2.go abcacba
abcacba -> Occurrences: 1
bcacb -> Occurrences: 1
abca -> Occurrences: 1
acba -> Occurrences: 1
cac -> Occurrences: 1

correct but actually incorrect due to bad approach

$ go run exercise_2.go eabcacf
abca -> Occurrences: 1
cac -> Occurrences: 1

incorrect

$ go run exercise_2.go eabbcabcbf
bbcabcb -> Occurrences: 1
bcabcb -> Occurrences: 1
abbca -> Occurrences: 1
bbcab -> Occurrences: 1
cabc -> Occurrences: 2
bcab -> Occurrences: 1
bcb -> Occurrences: 1

⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀

> check all the substrings contained in the given string and they have to meet these two requirements:
>
> • length at least equal to 3 characters;
>
> • starting and ending with the same character.
>
> The output has to include those substrings and their occurences.

Your solution is very complicated. Simplify.

package main
import "fmt"
func substrings(s string) map[string]int {
ss := make(map[string]int)
const k = 3 - 1
for i := 0; i < len(s)-k; i++ {
for j := i + k; j < len(s); j++ {
if s[i] == s[j] {
ss
展开收缩
]++
}
}
}
return ss
}
func main() {
fmt.Println(substrings("abbabba"))
fmt.Println(substrings("abcacba"))
fmt.Println(substrings("eabcacf"))
fmt.Println(substrings("eabbcabcbf"))
}

https://go.dev/play/p/hJMvMSYuqaa

map[abba:2 abbabba:1 bab:1 babb:1 bbab:1 bbabb:1]
map[abca:1 abcacba:1 acba:1 bcacb:1 cac:1]
map[abca:1 cac:1]
map[abbca:1 bbcab:1 bbcabcb:1 bcab:1 bcabcb:1 bcb:1 cabc:1]

Thanks to @rocka2q for helping me! This is the adjusted and final version of the code.

correct code, complete version (as I need it to work)

package main
import (
"fmt"
"os"
)
func main() {
string1 := os.Args[1]
map2 := substrings(string1)
count1 := 0
count2 := 0
var output1 string
for range map2 {
count1++
}
for key1, quantity1 := range map2 {
count2++
if count2 != count1 {
output1 += fmt.Sprintf("%s -> Occurrences: %d\n", key1, quantity1)
} else {
output1 += fmt.Sprintf("%s -> Occurrences: %d", key1, quantity1)
}
}
if len(map2) != 0 {
fmt.Println(output1)
}
}
func substrings(string1 string) map[string]int {
map1 := make(map[string]int)
for index1 := 0; index1 < len(string1)-2; index1++ {
for index2 := index1 + 2; index2 < len(string1); index2++ {
if string1[index1] == string1[index2] {
map1[string1[index1:index2+1]]++
}
}
}
return map1
}

outputs, all correct

$ go run exercise_2.go abbabba
abbabba -> Occurrences: 1
bbabb -> Occurrences: 1
babb -> Occurrences: 1
abba -> Occurrences: 2
bbab -> Occurrences: 1
bab -> Occurrences: 1

$ go run exercise_2.go abcacba
abcacba -> Occurrences: 1
bcacb -> Occurrences: 1
abca -> Occurrences: 1
acba -> Occurrences: 1
cac -> Occurrences: 1

$ go run exercise_2.go eabcacf
abca -> Occurrences: 1
cac -> Occurrences: 1

$ go run exercise_2.go eabbcabcbf
bbcabcb -> Occurrences: 1
bcabcb -> Occurrences: 1
abbca -> Occurrences: 1
bbcab -> Occurrences: 1
cabc -> Occurrences: 1
bcab -> Occurrences: 1
bcb -> Occurrences: 1