Equal Rational Numbers

Equal Rational Numbers - Problem

Math String Hard

Given two strings s and t, each of which represents a non-negative rational number, return true if and only if they represent the same number. The strings may use parentheses to denote the repeating part of the rational number.

A rational number can be represented using up to three parts:

IntegerPart: For example, 12, 0, and 123.
IntegerPart.NonRepeatingPart: For example, 0.5, 1., 2.12, and 123.0001.
IntegerPart.NonRepeatingPart(RepeatingPart): For example, 0.1(6), 1.(9), 123.00(1212).

The repeating portion of a decimal expansion is conventionally denoted within a pair of round brackets. For example: 1/6 = 0.16666666... = 0.1(6) = 0.1666(6) = 0.166(66).

Input & Output

Example 1 — Same Rational Number

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

› Output: true

💡 Note: Both represent the same repeating decimal 0.525252..., just with different groupings of the repeating part.

Example 2 — Different Numbers

$ Input: s = "0.1666(6)", t = "0.166(66)"

› Output: true

💡 Note: Both represent 1/6 = 0.16666..., showing different valid representations of the same repeating pattern.

Example 3 — No Repeating vs Repeating

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

› Output: true

💡 Note: 0.9999... equals exactly 1.0, demonstrating the mathematical equivalence.

Constraints

Each string contains only digits, '.', '(', ')'
Both strings are valid representations of rational numbers
No leading zeros except for numbers less than 1
1 ≤ s.length, t.length ≤ 20

Visualization

Tap to expand

Asked in

G Google 15 f Facebook 12 M Microsoft 8

The key insight is to convert repeating decimal representations to exact fraction form. The optimal approach uses mathematical formulas to convert repeating decimals to fractions, then compares the reduced fractions directly. Time: O(n), Space: O(1).

Common Approaches

✓ Fraction Conversion

⏱️ Time: O(n) Space: O(1)

Parse each rational number format and convert to exact fraction form (numerator/denominator), then cross-multiply to compare without floating point precision issues.

String Expansion and Comparison

⏱️ Time: O(n) Space: O(n)

Convert each rational number representation to a very long decimal string by repeating the repeating part many times, then compare the strings directly.

Dfs

⏱️ Time: N/A Space: N/A

Fraction Conversion — Algorithm Steps

Parse string to extract integer, non-repeating, and repeating parts
Convert repeating decimal to exact fraction using mathematical formula
Cross-multiply fractions to compare equality

Visualization

Tap to expand

Step-by-Step Walkthrough

Parse Components

Extract integer, non-repeating, and repeating parts

Apply Formula

Use mathematical formula to convert to exact fraction

Compare Fractions

Compare numerators and denominators directly

Code -

solution.c — C

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

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

long long gcd(long long a, long long b) {
    return b == 0 ? a : gcd(b, a % b);
}

long long abs_ll(long long x) {
    return x < 0 ? -x : x;
}

Fraction newFraction(long long num, long long den) {
    Fraction f;
    if (den == 0) den = 1;
    long long g = gcd(abs_ll(num), abs_ll(den));
    f.num = num / g;
    f.den = den / g;
    if (f.den < 0) {
        f.num = -f.num;
        f.den = -f.den;
    }
    return f;
}

Fraction addFraction(Fraction a, Fraction b) {
    return newFraction(a.num * b.den + b.num * a.den, a.den * b.den);
}

int equalsFraction(Fraction a, Fraction b) {
    return a.num == b.num && a.den == b.den;
}

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

Fraction parseToFraction(char* numStr) {
    char* openParen = strchr(numStr, '(');
    if (openParen == NULL) {
        char* dot = strchr(numStr, '.');
        if (dot == NULL) {
            return newFraction(atoll(numStr), 1);
        }
        
        char intPart[100] = {0};
        strncpy(intPart, numStr, dot - numStr);
        char* decPart = dot + 1;
        
        char combined[200];
        sprintf(combined, "%s%s", intPart, decPart);
        return newFraction(atoll(combined), power10(strlen(decPart)));
    }
    
    char* closeParen = strchr(numStr, ')');
    
    char beforeRepeat[100] = {0};
    strncpy(beforeRepeat, numStr, openParen - numStr);
    
    char repeatPart[50] = {0};
    strncpy(repeatPart, openParen + 1, closeParen - openParen - 1);
    
    char* dot = strchr(beforeRepeat, '.');
    char intPart[100] = {0};
    char nonRepeatPart[100] = {0};
    
    if (dot == NULL) {
        strcpy(intPart, strlen(beforeRepeat) == 0 ? "0" : beforeRepeat);
    } else {
        strncpy(intPart, beforeRepeat, dot - beforeRepeat);
        if (strlen(intPart) == 0) strcpy(intPart, "0");
        strcpy(nonRepeatPart, dot + 1);
    }
    
    int nonRepeatDigits = strlen(nonRepeatPart);
    int repeatDigits = strlen(repeatPart);
    
    char fullPart[200];
    sprintf(fullPart, "%s%s", nonRepeatPart, repeatPart);
    
    char basePart[200];
    sprintf(basePart, "%s%s", intPart, nonRepeatPart);
    
    char intFull[200];
    sprintf(intFull, "%s%s", intPart, fullPart);
    
    long long numerator = atoll(intFull) - atoll(basePart);
    long long denominator = power10(repeatDigits) - 1;
    denominator *= power10(nonRepeatDigits);
    
    Fraction baseFraction = newFraction(atoll(basePart), power10(nonRepeatDigits));
    Fraction repeatFraction = newFraction(numerator, denominator);
    
    return addFraction(baseFraction, repeatFraction);
}

int solution(char* s, char* t) {
    Fraction frac1 = parseToFraction(s);
    Fraction frac2 = parseToFraction(t);
    return equalsFraction(frac1, frac2);
}

int main() {
    char s[1000], t[1000];
    fgets(s, sizeof(s), stdin);
    s[strcspn(s, "\n")] = 0;
    
    fgets(t, sizeof(t), stdin);
    t[strcspn(t, "\n")] = 0;
    
    int result = solution(s, t);
    printf(result ? "true\n" : "false\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Linear time to parse strings and convert to fractions

✓ Linear Growth

Space Complexity

O(1)

Only stores numerator and denominator values

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

847 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler