Largest Odd Number in String - Practice Coding Problems

Largest Odd Number in String - Problem

You're given a string num representing a large integer. Your task is to find the largest-valued odd number that exists as a substring within this number.

🎯 Goal: Return the largest odd integer (as a string) that is a contiguous substring of num. If no odd number exists, return an empty string "".

Key Points:

A number is odd if its last digit is 1, 3, 5, 7, or 9
A substring must be contiguous characters from the original string
We want the largest possible value, not the longest substring

Example: In "52", we have substrings: "5", "2", "52". Only "5" is odd, so we return "5".

Input & Output

example_1.py — Basic Case

$ Input: num = "52"

› Output: "5"

💡 Note: The substrings are "5", "2", and "52". Among these, "5" and "52" could be candidates, but "52" is even (ends in 2), so only "5" is odd. Therefore, "5" is the largest odd number.

example_2.py — Multiple Odd Digits

$ Input: num = "4206"

› Output: ""

💡 Note: All digits (4, 2, 0, 6) are even, so no substring can form an odd number. We return an empty string.

example_3.py — Optimal Substring

$ Input: num = "35427"

› Output: "35427"

💡 Note: The entire string ends with 7 (odd), so "35427" is the largest possible odd number. Any smaller substring starting from index 0 would be smaller in value.

Constraints

1 ≤ num.length ≤ 10⁵
num consists of only digits
No leading zeros in the input string
num represents a valid integer

Visualization

Tap to expand

Understanding the Visualization

Understand the Goal

We want the largest-valued odd number, which means it should be as long as possible while ending in an odd digit

Key Insight

The largest odd number will always start from index 0 (to maximize value) and end at the rightmost odd digit

Scan Strategy

Start from the right and find the first odd digit, then return the prefix from start to that position

Key Takeaway

🎯 Key Insight: The largest odd number will always be the prefix ending at the rightmost odd digit, making this a perfect greedy problem!

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 22

The optimal greedy approach scans from right to left to find the rightmost odd digit. The key insight is that the largest odd number will always be a prefix ending at the rightmost odd digit. This achieves O(n) time and O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (All Substrings)	O(n²)	O(n)	Generate all possible substrings and find the largest odd one
Greedy Approach (Optimal)	O(n)	O(1)	Find the rightmost odd digit and return substring from start to that position

Brute Force (All Substrings) — Algorithm Steps

Generate all possible substrings starting from each position
For each substring, check if the last character is an odd digit
Compare valid odd substrings to find the largest value
Return the largest odd substring or empty string if none found

Visualization

Tap to expand

Step-by-Step Walkthrough

Generate Substrings

Start from each position and create all possible substrings

Check Odd Condition

Verify if the last digit of each substring is odd

Compare Values

Keep track of the largest valid odd substring found

Code -

solution.c — C

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

char* largestOddNumber(char* num) {
    int n = strlen(num);
    char* maxOdd = (char*)malloc((n + 1) * sizeof(char));
    maxOdd[0] = '\0';
    
    // Generate all possible substrings
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j <= n; j++) {
            char substring[1001];
            strncpy(substring, num + i, j - i);
            substring[j - i] = '\0';
            
            // Check if substring represents an odd number
            if (strlen(substring) > 0 && (substring[strlen(substring) - 1] - '0') % 2 == 1) {
                // Compare with current maximum
                if (strlen(maxOdd) == 0 || strlen(substring) > strlen(maxOdd) ||
                    (strlen(substring) == strlen(maxOdd) && strcmp(substring, maxOdd) > 0)) {
                    strcpy(maxOdd, substring);
                }
            }
        }
    }
    
    return maxOdd;
}

int main() {
    char input[1001];
    fgets(input, sizeof(input), stdin);
    input[strcspn(input, "\n")] = '\0';
    
    // Remove quotes
    char* num = input + 1;
    num[strlen(num) - 1] = '\0';
    
    char* result = largestOddNumber(num);
    printf("\"%s\"", result);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

We generate O(n²) substrings and potentially compare strings of length O(n)

⚠ Quadratic Growth

Space Complexity

O(n)

Space for storing the current best substring

⚡ Linearithmic Space

52.0K Views

Medium Frequency

~15 min Avg. Time

2.2K 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 (All Substrings) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler