Trouver tous les palindromes dans une chaîne

Pour cet article, nous allons nous baser sur 2 des articles précédents de la série.

Écrivez une fonction golang qui trouve tous les palindromes dans une chaîne.

J'interpréterai cela comme signifiant « à partir de la chaîne donnée, trouvez toutes les chaînes qu'elle contient qui sont des palindromes »

Dans un article précédent, nous avons créé une fonction pour trouver toutes les chaînes uniques d'une chaîne donnée.

Dans le dernier post, nous avons créé une fonction pour vérifier si une chaîne est un palindrome.

En utilisant ces 2 ensemble, nous pouvons trouver tous les palindromes possibles dans une chaîne.

func FindAllPalindromes(str string) []string {
    allPalindromes := []string{}
    uniqueStrings := uniquecombos.FindUniqueCombinations(str)
    for _, uniqueString := range uniqueStrings {
        if palindromecheck.PalindromeCheck(uniqueString) {
            allPalindromes = append(allPalindromes, uniqueString)
        }
    }
    return allPalindromes
}

Il s'avère que le test unitaire présente une courbe qui mérite d'être notée ici.

La fonction FindAllPalindromes construit le tableau de résultats dans quel ordre les palindromes sont trouvés. Cela peut ou non être l'ordre du résultat « attendu » dans le test unitaire.
Par exemple, la chaîne « aba » comporte 4 palindromes : « a », « aa », « aba » et « b ». Cependant, FindAllPalindromes renvoie « a », « aba », « aa » et « b ».

Nous avons plusieurs options ici :

• écrire une fonction qui compare deux tableaux sans égard à l'ordre, c'est à dire que les 2 tableaux ont les mêmes éléments et la même longueur.

• trier les tableaux attendus et les tableaux de résultats, puis comparer

Pour plus de simplicité, j'ai choisi la deuxième option, mais j'ai construit le résultat attendu des cas de test sous une forme pré-triée pour gagner un peu de temps sur les exécutions de tests.

func TestFindAllPalindromes(t *testing.T) {
    testCases := []struct {
        input    string
        expected []string
    }{
        // note that expected arrays have been presorted for quicker test runs
        {"", []string{}},
        {"a", []string{"a"}},
        {"ab", []string{"a", "b"}},
        {"aba", []string{"a", "aa", "aba", "b"}},
        {"aab", []string{"a", "aa", "b"}},
        {"abcba", []string{"a", "aa", "aba", "abba", "abcba", "aca", "b", "bb", "bcb", "c"}},
    }

    for _, tc := range testCases {
        results := FindAllPalindromes(tc.input)
        // sort result to match expected order
        slices.Sort(results)
        if !reflect.DeepEqual(results, tc.expected) {
            t.Errorf("findUniqueCombinations(%q) = %v; expected %v", tc.input, results, tc.expected)
        }
    }
}

Comment pouvons-nous améliorer cela ?

Publiez vos réflexions dans les commentaires.

Merci !

Le code de cet article et de tous les articles de cette série peut être trouvé ici

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!