How do I practice coding and algorithm questions?

Use PracHub's coding console to write, test, and debug your solutions in Python or JavaScript. View hints, test against sample inputs, and compare with official solutions.

What difficulty level is this coding question?

This is a Medium difficulty Coding & Algorithms question, commonly asked during Take-home Project rounds at Akuna Capital.

What role is this question designed for?

This question is commonly asked for Software Engineer candidates at Akuna Capital during technical interviews.

Break a palindrome to smallest non-palindrome | Akuna Capital Coding Question

Quick Overview

This question evaluates string manipulation, lexicographic ordering, and algorithmic reasoning, including careful edge-case handling and time and space complexity analysis. Commonly asked in the Coding & Algorithms domain, it assesses practical application of algorithm design and correctness reasoning with emphasis on conceptual understanding and complexity trade-offs.

Break a palindrome to smallest non-palindrome

Company: Akuna Capital

Role: Software Engineer

Category: Coding & Algorithms

Difficulty: Medium

Interview Round: Take-home Project

Given a palindromic string s of lowercase English letters, change exactly one character to obtain a new string that is not a palindrome and is lexicographically smallest among all such possibilities. If no such string exists, return an empty string. Explain your algorithm, prove correctness, and analyze time and space complexity. Provide code in your preferred language.

Quick Answer: This question evaluates string manipulation, lexicographic ordering, and algorithmic reasoning, including careful edge-case handling and time and space complexity analysis. Commonly asked in the Coding & Algorithms domain, it assesses practical application of algorithm design and correctness reasoning with emphasis on conceptual understanding and complexity trade-offs.

You are given a palindromic string s consisting of lowercase English letters. Change exactly one character so that the resulting string is not a palindrome and is lexicographically smallest among all such possible strings. If it is impossible to make the string non-palindromic by changing exactly one character, return an empty string. A string a is lexicographically smaller than string b if at the first position where they differ, a has a smaller character than b.

Constraints

1 <= len(s) <= 100000
s consists only of lowercase English letters
s is guaranteed to be a palindrome

Examples

Input: ("abccba",)

Expected Output: "aaccba"

Explanation: Changing the first non-'a' character in the first half ('b' at index 1) to 'a' gives 'aaccba', which is not a palindrome and is the smallest possible.

Input: ("a",)

Expected Output: ""

Explanation: A single-character string remains a palindrome no matter which character it is changed to, so it is impossible.

Input: ("aa",)

Expected Output: "ab"

Explanation: The first half contains only 'a', so changing the last character to 'b' produces the smallest non-palindrome.

Input: ("aba",)

Expected Output: "abb"

Explanation: The only character in the first half is already 'a', so changing the last character to 'b' gives 'abb'.

Input: ("abba",)

Expected Output: "aaba"

Explanation: Changing the 'b' in the first half to 'a' creates 'aaba', which is smaller than any valid alternative.

Input: ("zzzz",)

Expected Output: "azzz"

Explanation: Replacing the earliest character with 'a' gives the smallest lexicographic result and breaks the palindrome immediately.

Solution

def solution(s):
    n = len(s)
    if n == 1:
        return ""

    chars = list(s)

    # Make the earliest possible character as small as possible.
    # We only need to inspect the first half; changing a non-middle
    # character there to 'a' will break the palindrome.
    for i in range(n // 2):
        if chars[i] != 'a':
            chars[i] = 'a'
            return ''.join(chars)

    # If the first half is all 'a', the smallest valid change is to
    # increase the last character to 'b'.
    chars[-1] = 'b'
    return ''.join(chars)

Time complexity: O(n). Space complexity: O(n).

Hints

To make the result lexicographically smallest, try to decrease the earliest possible character.
Only characters in the first half need to be checked for replacing with 'a'. If they are all already 'a', think about changing the last character instead.

Quick Overview