Goat Latin - Practice Coding Problems

Goat Latin - Problem

String Easy

You are given a string sentence that consists of words separated by spaces. Each word consists of lowercase and uppercase letters only.

We would like to convert the sentence to "Goat Latin" (a made-up language similar to Pig Latin.) The rules of Goat Latin are as follows:

If a word begins with a vowel ('a', 'e', 'i', 'o', or 'u'), append "ma" to the end of the word. For example, the word "apple" becomes "applema".
If a word begins with a consonant (i.e., not a vowel), remove the first letter and append it to the end, then add "ma". For example, the word "goat" becomes "oatgma".
Add one letter 'a' to the end of each word per its word index in the sentence, starting with 1. For example, the first word gets "a" added to the end, the second word gets "aa" added to the end, and so on.

Return the final sentence representing the conversion from sentence to Goat Latin.

Input & Output

Example 1 — Basic Mixed Case

$ Input: sentence = "I speak Goat Latin"

› Output: "Imaa peaksmaaa oatGmaaaa atinLmaaaaa"

💡 Note: Word 1 'I' starts with vowel: I + ma + a = 'Imaa'. Word 2 'speak' starts with consonant: peak + s + ma + aa = 'peaksmaaa'. Word 3 'Goat' starts with consonant: oat + G + ma + aaa = 'oatGmaaaa'. Word 4 'Latin' starts with consonant: atin + L + ma + aaaa = 'atinLmaaaaa'.

Example 2 — All Vowel Start

$ Input: sentence = "The quick brown fox jumped over the lazy dog"

› Output: "heTmaa uickqmaaa rownbmaaaa oxfmaaaaa umpedjmaaaaaa overmaaaaaaa hetmaaaaaaaa azylmaaaaaaaaa ogdmaaaaaaaaaa"

💡 Note: Each word is transformed: consonant words move first letter to end, all get 'ma' and position-based 'a's added.

Example 3 — Single Character Words

$ Input: sentence = "a I o"

› Output: "amaa Imaaa omaaaa"

💡 Note: Single character vowels: 'a' becomes 'amaa', 'I' becomes 'Imaaa', 'o' becomes 'omaaaa' with position-based 'a's.

Constraints

1 ≤ sentence.length ≤ 150
sentence consists of English letters and spaces only
sentence has no leading or trailing spaces
All the words in sentence are separated by a single space

Visualization

Tap to expand

Understanding the Visualization

Input

Original sentence with words separated by spaces

Transform

Apply vowel/consonant rules and add position-based 'a's

Output

Final Goat Latin sentence

Key Takeaway

🎯 Key Insight: The transformation depends on the first character being a vowel or consonant, with position-based 'a's added to each word

Asked in

G Google 15 a Amazon 12 M Microsoft 8

The key insight is to split the sentence into words, apply different transformations based on whether each word starts with a vowel or consonant, then add position-based 'a's. Best approach is direct string processing with efficient string building. Time: O(n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Direct String Processing	O(n)	O(n)	Split sentence into words, apply transformation rules to each word, then join back
StringBuilder Optimization	O(n)	O(n)	Use StringBuilder to efficiently concatenate strings and avoid multiple string object creation

Direct String Processing — Algorithm Steps

Step 1: Split sentence into individual words
Step 2: For each word, check if first character is vowel or consonant
Step 3: Apply appropriate transformation (append 'ma' for vowels, move first char to end + 'ma' for consonants)
Step 4: Add position-based 'a's (1 'a' for first word, 2 'a's for second, etc.)
Step 5: Join all transformed words back with spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Split sentence into individual words

Transform

Apply vowel/consonant rules and add position-based 'a's

Join

Combine transformed words back into sentence

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>

int isVowel(char c) {
    return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u' ||
           c == 'A' || c == 'E' || c == 'I' || c == 'O' || c == 'U';
}

char* solution(char* sentence) {
    char* result = malloc(2000);
    result[0] = '\0';
    
    char* token = strtok(sentence, " ");
    int wordIndex = 0;
    
    while (token != NULL) {
        char transformed[200];
        
        if (isVowel(token[0])) {
            // Vowel: append "ma"
            strcpy(transformed, token);
            strcat(transformed, "ma");
        } else {
            // Consonant: move first char to end, then append "ma"
            strcpy(transformed, token + 1);
            strncat(transformed, token, 1);
            strcat(transformed, "ma");
        }
        
        // Add position-based 'a's (wordIndex+1 times)
        for (int i = 0; i <= wordIndex; i++) {
            strcat(transformed, "a");
        }
        
        if (wordIndex > 0) strcat(result, " ");
        strcat(result, transformed);
        
        token = strtok(NULL, " ");
        wordIndex++;
    }
    
    return result;
}

int main() {
    char sentence[1000];
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;
    
    char* result = solution(sentence);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the sentence to split and transform words, where n is the length of the sentence

✓ Linear Growth

Space Complexity

O(n)

Space for storing the split words and building the result string

⚡ Linearithmic Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Direct String Processing — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler