Goat Latin - Practice Coding Problems

Goat Latin - Problem

String Easy

Welcome to the whimsical world of Goat Latin - a playful language transformation game! Your mission is to convert regular English sentences into this silly made-up language that follows specific phonetic rules.

The Rules:

Rule 1 (Vowel Words): If a word starts with a vowel (a, e, i, o, u), simply append "ma" to the end.
Example: "apple" → "applema"
Rule 2 (Consonant Words): If a word starts with a consonant, move the first letter to the end, then append "ma".
Example: "goat" → "oatgma"
Rule 3 (Position Suffix): Add 'a' letters based on the word's position: 1st word gets "a", 2nd word gets "aa", 3rd gets "aaa", etc.

Example: "I speak Goat Latin" becomes "Imaa eakspaaaa oatGmaaaaa atinLmaaaaaaa"

Given a sentence with words separated by spaces, return the complete Goat Latin transformation!

Input & Output

example_1.py — Basic Transformation

$ Input: sentence = "I speak Goat Latin"

› Output: "Imaa eakspaaaa oatGmaaaaa atinLmaaaaaaa"

💡 Note: Word 1: 'I' starts with vowel → 'I' + 'ma' + 'a' = 'Imaa'. Word 2: 'speak' starts with 's' → 'peak' + 's' + 'ma' + 'aa' = 'eakspaaaa'. Word 3: 'Goat' starts with 'G' → 'oat' + 'G' + 'ma' + 'aaa' = 'oatGmaaaaa'. Word 4: 'Latin' starts with 'L' → 'atin' + 'L' + 'ma' + 'aaaa' = 'atinLmaaaaaaa'.

example_2.py — Mixed Cases

$ Input: sentence = "The quick brown fox"

› Output: "heTmaa ickquaaaa ownbrmaaaaa oxfmaaaaaaa"

💡 Note: All words start with consonants: 'The' → 'heTmaa', 'quick' → 'ickquaaaa', 'brown' → 'ownbrmaaaaa', 'fox' → 'oxfmaaaaaaa'. Position-based 'a' characters increase for each word.

example_3.py — Single Vowel Word

$ Input: sentence = "apple"

› Output: "applemaa"

💡 Note: Single word 'apple' starts with vowel 'a' → keep as 'apple' + 'ma' + 'a' (position 1) = 'applemaa'.

Constraints

1 ≤ sentence.length ≤ 150
sentence consists of English letters and spaces
sentence has no leading or trailing spaces
All words in sentence are separated by single spaces
Each word consists of lowercase and uppercase letters only

Visualization

Tap to expand

Understanding the Visualization

Word Intake

Split the sentence and feed each word into the assembly line

Vowel Detection

Scanner checks if word starts with vowel (a,e,i,o,u) or consonant

Transformation Station

Apply rule: vowels get 'ma' appended, consonants get first letter moved to end plus 'ma'

Position Stamper

Add 'a' characters based on word's position in the sentence

Final Assembly

Join all transformed words back into the final Goat Latin sentence

Key Takeaway

🎯 Key Insight: Each word transformation is independent and can be processed sequentially. The three-step process (vowel check → rule application → position suffix) creates a simple yet complete language transformation system.

Asked in

G Google 15 f Facebook 12 🍎 Apple 8 ⊞ Microsoft 6

The optimal approach processes each word sequentially using string manipulation techniques. Split the sentence into words, check each word's first character against vowels, apply the appropriate transformation rule, append 'ma', and add position-based 'a' characters. The solution runs in O(n*m) time where n is the number of words and m is average word length, making it efficient for the given constraints.

Common Approaches

Approach	Time	Space	Notes
✓ String Processing (Direct Approach)	O(n * m)	O(n * m)	Split sentence into words, apply all transformation rules to each word sequentially

String Processing (Direct Approach) — Algorithm Steps

Split the input sentence into individual words
For each word, check if the first character is a vowel (case-insensitive)
If vowel: keep word as-is; if consonant: move first character to end
Append 'ma' to the transformed word
Add 'a' characters based on word position (index + 1)
Join all transformed words with spaces

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Into Words

Break the sentence into individual words

Check First Letter

Determine if word starts with vowel or consonant

Apply Transformation

Move consonant or keep vowel word as-is, then add 'ma'

Add Position Suffix

Append 'a' characters based on word position

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* toGoatLatin(char* sentence) {
    char* result = malloc(10000 * sizeof(char));
    char* word = malloc(1000 * sizeof(char));
    char* temp = malloc(1000 * sizeof(char));
    int resultLen = 0, wordLen = 0, position = 1;
    int i = 0;
    
    while (sentence[i] != '\0') {
        if (sentence[i] == ' ' || sentence[i + 1] == '\0') {
            if (sentence[i] != ' ') {
                word[wordLen++] = sentence[i];
            }
            word[wordLen] = '\0';
            
            // Transform the word
            if (isVowel(word[0])) {
                strcpy(temp, word);
                strcat(temp, "ma");
            } else {
                strcpy(temp, word + 1);
                strncat(temp, word, 1);
                strcat(temp, "ma");
            }
            
            // Add position-based 'a' characters
            for (int j = 0; j < position; j++) {
                strcat(temp, "a");
            }
            
            if (resultLen > 0) {
                strcat(result, " ");
                resultLen++;
            }
            strcat(result, temp);
            resultLen += strlen(temp);
            
            wordLen = 0;
            position++;
        } else {
            word[wordLen++] = sentence[i];
        }
        i++;
    }
    
    free(word);
    free(temp);
    return result;
}

int main() {
    char sentence[10000];
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0; // Remove newline
    
    // Remove surrounding quotes if present
    if (sentence[0] == '"' && sentence[strlen(sentence) - 1] == '"') {
        sentence[strlen(sentence) - 1] = '\0';
        memmove(sentence, sentence + 1, strlen(sentence));
    }
    
    char* result = toGoatLatin(sentence);
    printf("%s\n", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n * m)

Where n is the number of words and m is the average word length. We process each character of each word once.

✓ Linear Growth

Space Complexity

O(n * m)

Space for storing the result string and intermediate transformations

⚡ Linearithmic Space

21.8K 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

String Processing (Direct Approach) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler