Equal Rational Numbers - Practice Coding Problems

Equal Rational Numbers - Problem

Math String Hard

Can Two Different-Looking Numbers Actually Be Equal?

You're given two strings s and t that represent rational numbers (numbers that can be expressed as fractions). Your task is to determine if these two strings represent the same mathematical value, even though they might look completely different!

Here's the twist: these numbers can have repeating decimals represented with parentheses. For example:
• "0.1(6)" means 0.1666666... (the 6 repeats forever)
• "1.(9)" means 1.9999999... which actually equals 2!
• "123.00(1212)" means 123.001212121212...

The strings follow these formats:
1. Integer only: "12", "0", "123"
2. Decimal (no repeat): "0.5", "1.", "2.12"
3. Repeating decimal: "0.1(6)", "1.(9)", "123.00(1212)"

Goal: Return true if both strings represent the same rational number, false otherwise.

Input & Output

example_1.py — Basic Repeating Decimal

$ Input: s = "0.1(6)", t = "0.16666666666"

› Output: true

💡 Note: 0.1(6) means 0.1666666... (6 repeats forever), which equals the finite decimal representation up to precision limits

example_2.py — Famous Mathematical Identity

$ Input: s = "1.(9)", t = "2.0"

› Output: true

💡 Note: 1.(9) means 1.999999... which mathematically equals exactly 2.0. This is a famous identity: 0.999... = 1

example_3.py — Different Looking Same Numbers

$ Input: s = "0.(52)", t = "0.525252"

› Output: false

💡 Note: 0.(52) = 0.525252525252... (infinite), while 0.525252 is finite. They are different numbers

Constraints

Each given string will have length in range [1, 50]
The strings only contain digits, '.', '(', and ')'
The integer part will not start with '0' unless it is "0"
For the repeating part, there won't be trailing zeros
The given strings represent non-negative rational numbers

Visualization

Tap to expand

Understanding the Visualization

Identify the Pattern

Separate the integer part, non-repeating decimal, and repeating part

Apply the Formula

Use mathematical formulas to convert repeating decimals to exact fractions

Simplify

Reduce both fractions to lowest terms using Greatest Common Divisor

Compare

Cross-multiply to check if a/b = c/d without floating point errors

Key Takeaway

🎯 Key Insight: Every rational number has a unique fraction representation in lowest terms - that's the mathematical fingerprint we use for perfect comparison!

Asked in

G Google 8 f Meta 5 ⊞ Microsoft 3 Apple 2

The optimal solution converts both rational number strings to their exact fraction representation (numerator/denominator) and compares them mathematically. This approach handles all edge cases including the famous identity 0.999... = 1 and avoids precision errors that plague decimal expansion methods.

Common Approaches

Approach	Time	Space	Notes
✓ Fraction Conversion (Optimal)	O(n + log(max(num, den)))	O(1)	Convert both numbers to fraction form and compare in lowest terms
Brute Force (Decimal Expansion)	O(P)	O(P)	Convert both numbers to long decimal strings and compare

Fraction Conversion (Optimal) — Algorithm Steps

Parse each input string to extract integer, non-repeating, and repeating parts
Convert the parsed components to exact fraction form using mathematical formulas
For repeating decimals, use the formula: 0.abc(def) = (abcdef - abc) / (999...000...)
Reduce both fractions to their lowest terms using GCD
Compare the reduced fractions for equality

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Components

Extract integer, non-repeating, and repeating parts

Convert to Fraction

Use mathematical formulas to get exact numerator/denominator

Reduce to Lowest Terms

Apply GCD to simplify both fractions

Cross Multiply

Compare a/b == c/d by checking a*d == b*c

Code -

solution.c — C

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

typedef struct {
    long long num, den;
} Fraction;

long long gcd(long long a, long long b) {
    if (a < 0) a = -a;
    if (b < 0) b = -b;
    while (b != 0) {
        long long temp = b;
        b = a % b;
        a = temp;
    }
    return a;
}

long long power10(int exp) {
    long long result = 1;
    for (int i = 0; i < exp; i++) {
        result *= 10;
    }
    return result;
}

Fraction parseToFraction(char* s) {
    Fraction result;
    
    if (strstr(s, "(") == NULL) {
        if (strstr(s, ".") == NULL) {
            result.num = atoll(s);
            result.den = 1;
            return result;
        } else {
            char* dotPos = strchr(s, '.');
            int dotIdx = dotPos - s;
            
            char integerPart[100], decimalPart[100];
            strncpy(integerPart, s, dotIdx);
            integerPart[dotIdx] = '\0';
            strcpy(decimalPart, s + dotIdx + 1);
            
            if (strlen(integerPart) == 0) strcpy(integerPart, "0");
            if (strlen(decimalPart) == 0) {
                result.num = atoll(integerPart);
                result.den = 1;
                return result;
            }
            
            char fullNum[200];
            sprintf(fullNum, "%s%s", integerPart, decimalPart);
            result.num = atoll(fullNum);
            result.den = power10(strlen(decimalPart));
            
            long long g = gcd(result.num, result.den);
            result.num /= g;
            result.den /= g;
            return result;
        }
    } else {
        char* parenPos = strchr(s, '(');
        int parenIdx = parenPos - s;
        
        char beforeParen[100], repeating[100];
        strncpy(beforeParen, s, parenIdx);
        beforeParen[parenIdx] = '\0';
        
        int repeatLen = strlen(s) - parenIdx - 2;
        strncpy(repeating, s + parenIdx + 1, repeatLen);
        repeating[repeatLen] = '\0';
        
        char integerPart[100], nonRepeating[100];
        char* dotPos = strchr(beforeParen, '.');
        
        if (dotPos == NULL) {
            strcpy(integerPart, beforeParen);
            if (strlen(integerPart) == 0) strcpy(integerPart, "0");
            strcpy(nonRepeating, "");
        } else {
            int dotIdx = dotPos - beforeParen;
            strncpy(integerPart, beforeParen, dotIdx);
            integerPart[dotIdx] = '\0';
            strcpy(nonRepeating, beforeParen + dotIdx + 1);
            if (strlen(integerPart) == 0) strcpy(integerPart, "0");
        }
        
        char fullNumber[200], beforeRepeat[200];
        sprintf(fullNumber, "%s%s%s", integerPart, nonRepeating, repeating);
        sprintf(beforeRepeat, "%s%s", integerPart, nonRepeating);
        if (strlen(beforeRepeat) == 0) strcpy(beforeRepeat, "0");
        
        long long fullNum = atoll(fullNumber);
        long long beforeNum = atoll(beforeRepeat);
        result.num = fullNum - beforeNum;
        
        result.den = power10(strlen(nonRepeating));
        for (int i = 0; i < strlen(repeating); i++) {
            result.den = result.den * 10 - power10(strlen(nonRepeating));
        }
        result.den = (power10(strlen(repeating)) - 1) * power10(strlen(nonRepeating));
        
        long long baseNum = atoll(beforeRepeat);
        result.num = result.num + baseNum * result.den;
        
        long long g = gcd(result.num > 0 ? result.num : -result.num, result.den);
        result.num /= g;
        result.den /= g;
        return result;
    }
}

int isRationalEqual(char* s, char* t) {
    Fraction frac1 = parseToFraction(s);
    Fraction frac2 = parseToFraction(t);
    
    return frac1.num * frac2.den == frac2.num * frac1.den;
}

int main() {
    char s[100], t[100];
    scanf("%s %s", s, t);
    printf("%s\n", isRationalEqual(s, t) ? "true" : "false");
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + log(max(num, den)))

n is the length of input strings for parsing, log factor for GCD calculation

⚡ Linearithmic

Space Complexity

O(1)

Only storing integer values for numerator and denominator

✓ Linear Space

32.4K Views

Medium Frequency

~35 min Avg. Time

856 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

Fraction Conversion (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler