Circular Sentence - Practice Coding Problems

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

Understanding the Visualization

Input

Sentence with words separated by spaces

Check Connections

Verify each word connects to the next

Check Circle

Verify last word connects back to first

Key Takeaway

🎯 Key Insight: A circular sentence is like a word chain that loops back to itself perfectly

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

Approach	Time	Space	Notes
✓ Single Pass - Direct Character Check	O(n)	O(1)	Check connections while parsing without storing words
Brute Force - Check All Adjacent Pairs	O(n)	O(n)	Split into words and check each adjacent pair plus first-last connection

Single Pass - Direct Character Check — Algorithm Steps

Step 1: Iterate through sentence character by character
Step 2: At each space, check if prev char equals next char
Step 3: After loop, check if last char equals first char

Visualization

Tap to expand

Step-by-Step Walkthrough

Scan String

Iterate through each character

Check at Spaces

At each space, verify prev char = next char

Final Check

Verify last char equals first char

Code -

solution.c — C

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

bool solution(char* sentence) {
    int n = strlen(sentence);
    
    // Check connections at each space
    for (int i = 0; i < n; i++) {
        if (sentence[i] == ' ') {
            // Check if character before space equals character after space
            if (sentence[i-1] != sentence[i+1]) {
                return false;
            }
        }
    }
    
    // Check if last character equals first character
    if (sentence[n-1] != sentence[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 in the sentence

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables, no word storage

✓ Linear 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

Single Pass - Direct Character Check — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler