Circular Sentence

Circular Sentence - Problem

String Easy

A sentence is a list of words that are separated by a single space with no leading or trailing spaces.

For example, "Hello World", "HELLO", "hello world hello world" are all sentences.

Words consist of only uppercase and lowercase English letters. Uppercase and lowercase English letters are considered different.

A sentence is circular if:

The last character of each word in the sentence is equal to the first character of its next word.
The last character of the last word is equal to the first character of the first word.

For example, "leetcode exercises sound delightful", "eetcode", "leetcode eats soul" are all circular sentences. However, "Leetcode is cool", "happy Leetcode", "Leetcode" and "I like Leetcode" are not circular sentences.

Given a string sentence, return true if it is circular. Otherwise, return false.

Input & Output

Example 1 — Valid Circular Sentence

$ Input: sentence = "leetcode exercises sound delightful"

› Output: true

💡 Note: Each word connects properly: leetcodE → Exercises, exerciseS → Sound, sounD → Delightful, and delightfuL loops back to Leetcode

Example 2 — Invalid Connection

$ Input: sentence = "Leetcode is cool"

› Output: false

💡 Note: The word 'Leetcode' ends with 'e' but 'is' starts with 'i', so e ≠ i makes it not circular

Example 3 — Single Word

$ Input: sentence = "eetcode"

› Output: true

💡 Note: Single word case: first character 'e' equals last character 'e', forming a circle

Constraints

1 ≤ sentence.length ≤ 500
sentence consist of only lowercase and uppercase English letters and spaces
The words in sentence are separated by a single space
There are no leading or trailing spaces

Visualization

Tap to expand

Asked in

G Google 15 M Microsoft 12 a Amazon 8

The key insight is that a circular sentence forms a perfect loop where each word's ending connects to the next word's beginning. The optimal approach checks connections directly during a single pass without storing words. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force - Check All Adjacent Pairs

⏱️ Time: O(n) Space: O(n)

Split the sentence into words, then iterate through each word to check if its last character matches the first character of the next word. Finally verify the last word connects back to the first word.

Single Pass - Direct Character Check

⏱️ Time: O(n) Space: O(1)

Instead of splitting into words first, we iterate through the sentence and check connections on-the-fly. When we encounter a space, we verify the previous character matches the next character.

Brute Force - Check All Adjacent Pairs — Algorithm Steps

Step 1: Split sentence into individual words
Step 2: For each word, check if last char equals next word's first char
Step 3: Check if last word's last char equals first word's first char

Visualization

Tap to expand

Step-by-Step Walkthrough

Split Words

Break sentence into individual words

Check Pairs

Verify each word connects to the next

Check Loop

Verify last word connects back to first

Code -

solution.c — C

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

bool solution(char* sentence) {
    char* words[1000];
    int wordCount = 0;
    
    // Split sentence into words
    char* sentenceCopy = strdup(sentence);
    char* token = strtok(sentenceCopy, " ");
    while (token != NULL) {
        words[wordCount++] = strdup(token);
        token = strtok(NULL, " ");
    }
    
    // Check each adjacent pair
    for (int i = 0; i < wordCount; i++) {
        char* currentWord = words[i];
        char* nextWord = words[(i + 1) % wordCount];  // Use modulo to wrap around
        
        int currentLen = strlen(currentWord);
        if (currentWord[currentLen - 1] != nextWord[0]) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char sentence[10000];
    fgets(sentence, sizeof(sentence), stdin);
    sentence[strcspn(sentence, "\n")] = 0;  // Remove newline
    
    bool result = solution(sentence);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through all characters to split and check connections

✓ Linear Growth

Space Complexity

O(n)

Store array of words split from the sentence

⚡ Linearithmic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

450 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

Brute Force - Check All Adjacent Pairs — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler