Longest Palindrome - Practice Coding Problems

Longest Palindrome - Problem

Imagine you have a collection of letter tiles, each with either a lowercase or uppercase letter. Your task is to build the longest possible palindrome using these tiles!

A palindrome reads the same forwards and backwards, like "racecar" or "A man a plan a canal Panama" (ignoring spaces). However, in this problem, case matters - so "Aa" is not a palindrome because uppercase 'A' and lowercase 'a' are different characters.

Goal: Given a string s containing letters, return the length of the longest palindrome you can construct using those letters.

Example: With letters "abccccdd", you can build "dccaccd" (length 7) by using pairs of letters symmetrically and putting one odd-count letter in the middle.

Input & Output

example_1.py — Basic Case

$ Input: s = "abccccdd"

› Output: 7

💡 Note: We can construct palindrome "dccaccd" using: 2 pairs of 'c', 1 pair of 'd', and 1 'a' in the center. Total length = 4 + 2 + 1 = 7.

example_2.py — Single Character

$ Input: s = "a"

› Output: 1

💡 Note: The palindrome is just "a" itself, so the length is 1.

example_3.py — All Same Characters

$ Input: s = "aaaa"

› Output: 4

💡 Note: We can use all 4 'a's to construct palindrome "aaaa". Since count is even, no center character needed.

Visualization

Tap to expand

Understanding the Visualization

Count Building Materials

Survey all available letters and count how many of each type you have

Form Symmetric Pairs

For each letter type, determine how many symmetric pairs you can create

Choose Center Piece

If any letter has leftover count, pick one as the unique center element

Calculate Total Length

Sum all pairs (×2 for symmetry) plus 1 if using a center piece

Key Takeaway

🎯 Key Insight: A palindrome uses character pairs symmetrically, with at most one odd-frequency character in the center. Count frequencies once, then sum pairs and add 1 if any odd count exists.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through the string to count frequencies, then O(k) to process counts where k ≤ min(n, 128) for ASCII

✓ Linear Growth

Space Complexity

O(k)

Hash table stores at most k unique characters where k ≤ min(n, 128) for ASCII characters

✓ Linear Space

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase and/or uppercase English letters only
Case sensitive: 'A' and 'a' are considered different characters

Asked in

G Google 23 a Amazon 18 f Meta 15 Apple 12 ⊞ Microsoft 10

The optimal solution uses a hash table to count character frequencies in O(n) time. Key insight: palindromes need pairs of characters for symmetry, plus at most one odd-count character for the center. Calculate pairs as (count // 2) * 2 and add 1 if any character has odd frequency.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Count All Frequencies)	O(n²)	O(1)	Count frequency of each character, then calculate palindrome length
One-Pass Hash Table (Optimal)	O(n)	O(k)	Count character frequencies in one pass and calculate result simultaneously

Brute Force (Count All Frequencies) — Algorithm Steps

For each unique character, count its frequency using a nested loop
For each character frequency, add all pairs (frequency // 2 * 2) to result
If any character has odd frequency and no center is used yet, add 1 for center
Return the total length

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Character 'a'

Scan entire string to count 'a' occurrences

Check Character 'b'

Scan entire string again to count 'b' occurrences

Calculate Pairs

For each character, calculate how many pairs can be formed

Code -

solution.c — C

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

int longestPalindrome(char* s) {
    if (!s || strlen(s) == 0) return 0;
    
    int len = strlen(s);
    int length = 0;
    bool used[256] = {false}; // ASCII characters
    
    // Count frequency for each unique character
    for (int i = 0; i < len; i++) {
        if (used[(unsigned char)s[i]]) continue;
        
        // Count occurrences of this character
        int count = 0;
        for (int j = 0; j < len; j++) {
            if (s[j] == s[i]) count++;
        }
        
        // Add pairs to the result
        length += (count / 2) * 2;
        used[(unsigned char)s[i]] = true;
    }
    
    // Add one character for center if possible
    if (length < len) {
        length += 1;
    }
    
    return length;
}

int main() {
    char s[1001];
    fgets(s, sizeof(s), stdin);
    
    // Remove newline and quotes
    int len = strlen(s);
    if (s[len-1] == '\n') s[len-1] = '\0';
    if (s[0] == '"' && s[strlen(s)-1] == '"') {
        s[strlen(s)-1] = '\0';
        memmove(s, s+1, strlen(s));
    }
    
    printf("%d\n", longestPalindrome(s));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each unique character (up to n), we scan the entire string (n operations)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a few variables, no extra data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 2000
s consists of lowercase and/or uppercase English letters only
Case sensitive: 'A' and 'a' are considered different characters

127.9K Views

High Frequency

~8 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Count All Frequencies) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler