Off-by-one on range boundaries
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.
Build confidence with an intuition-first walkthrough focused on core interview patterns fundamentals.
A sentence is a list of words that are separated by a single space with no leading or trailing spaces.
"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:
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.
Example 1:
Input: sentence = "leetcode exercises sound delightful" Output: true Explanation: The words in sentence are ["leetcode", "exercises", "sound", "delightful"]. - leetcode's last character is equal to exercises's first character. - exercises's last character is equal to sound's first character. - sound's last character is equal to delightful's first character. - delightful's last character is equal to leetcode's first character. The sentence is circular.
Example 2:
Input: sentence = "eetcode" Output: true Explanation: The words in sentence are ["eetcode"]. - eetcode's last character is equal to eetcode's first character. The sentence is circular.
Example 3:
Input: sentence = "Leetcode is cool" Output: false Explanation: The words in sentence are ["Leetcode", "is", "cool"]. - Leetcode's last character is not equal to is's first character. The sentence is not circular.
Constraints:
1 <= sentence.length <= 500sentence consist of only lowercase and uppercase English letters and spaces.sentence are separated by a single space.Problem summary: 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.
Start with the most direct exhaustive search. That gives a correctness anchor before optimizing.
Pattern signal: General problem-solving
"leetcode exercises sound delightful"
"eetcode"
"Leetcode is cool"
defuse-the-bomb)Source-backed implementations are provided below for direct study and interview prep.
// Accepted solution for LeetCode #2490: Circular Sentence
class Solution {
public boolean isCircularSentence(String sentence) {
var ss = sentence.split(" ");
int n = ss.length;
for (int i = 0; i < n; ++i) {
if (ss[i].charAt(ss[i].length() - 1) != ss[(i + 1) % n].charAt(0)) {
return false;
}
}
return true;
}
}
// Accepted solution for LeetCode #2490: Circular Sentence
func isCircularSentence(sentence string) bool {
ss := strings.Split(sentence, " ")
n := len(ss)
for i, s := range ss {
if s[len(s)-1] != ss[(i+1)%n][0] {
return false
}
}
return true
}
# Accepted solution for LeetCode #2490: Circular Sentence
class Solution:
def isCircularSentence(self, sentence: str) -> bool:
ss = sentence.split()
n = len(ss)
return all(s[-1] == ss[(i + 1) % n][0] for i, s in enumerate(ss))
// Accepted solution for LeetCode #2490: Circular Sentence
impl Solution {
pub fn is_circular_sentence(sentence: String) -> bool {
let ss: Vec<String> = sentence.split(' ').map(String::from).collect();
let n = ss.len();
for i in 0..n {
if ss[i].as_bytes()[ss[i].len() - 1] != ss[(i + 1) % n].as_bytes()[0] {
return false;
}
}
return true;
}
}
// Accepted solution for LeetCode #2490: Circular Sentence
function isCircularSentence(sentence: string): boolean {
const ss = sentence.split(' ');
const n = ss.length;
for (let i = 0; i < n; ++i) {
if (ss[i][ss[i].length - 1] !== ss[(i + 1) % n][0]) {
return false;
}
}
return true;
}
Use this to step through a reusable interview workflow for this problem.
Two nested loops check every pair or subarray. The outer loop fixes a starting point, the inner loop extends or searches. For n elements this gives up to n²/2 operations. No extra space, but the quadratic time is prohibitive for large inputs.
Most array problems have an O(n²) brute force (nested loops) and an O(n) optimal (single pass with clever state tracking). The key is identifying what information to maintain as you scan: a running max, a prefix sum, a hash map of seen values, or two pointers.
Review these before coding to avoid predictable interview regressions.
Wrong move: Loop endpoints miss first/last candidate.
Usually fails on: Fails on minimal arrays and exact-boundary answers.
Fix: Re-derive loops from inclusive/exclusive ranges before coding.