15-roman-number-gcd/roman_number.c

/*-----------------------------------------------------------------------------
 *				HTBLA-Leonding 
 *-----------------------------------------------------------------------------
 * Author(s):		Marc Tismonar
 *-----------------------------------------------------------------------------
 * Description:
 * Encapsulates roman numbers and provides basic mathematical operations.
 *-----------------------------------------------------------------------------
*/

#include "roman_number.h"

// the maximum number of RomanNumbers 
#define MAX_ROMAN_NUMBER_COUNT 32

struct RomanNumberData {
    char* number;
    int length;
};


static RomanNumber romanNumber = {0};

/* Determines whether or not the letter followed by next_letter is a valid subtraction pattern of roman numbers */
static bool rn_is_valid_subtraction(char letter, char next_letter) {
    return (letter == 'I' && (next_letter == 'V' || next_letter == 'X' || next_letter == 'L' || next_letter == 'C' || next_letter == 'D' || next_letter == 'M'))
        || (letter == 'X' && (next_letter == 'L' || next_letter == 'C' || next_letter == 'D' || next_letter == 'M'))
        || (letter == 'C' && (next_letter == 'D' || next_letter == 'M'));
}

static int roman_char_to_int(char romanNumber) {
    switch(romanNumber) {
        case 'I':
        {
            return 1;
        }
        case 'V':
        {
            return 5;
        }
        case 'X':
        {
            return 10;
        }
        case 'L':
        {
            return 50;
        }
        case 'C':
        {
            return 100;
        }
        case 'D':
        {
            return 500;
        }
        case 'M':
        {
            return 1000;
        }
        default:
        {
            return 0;
        }
    }
}

static char int_to_roman_char(int number) {
    switch(number) {
        case 1:
        {
            return 'I';
        }
        case 5:
        {
            return 'V';
        }
        case 10:
        {
            return 'X';
        }
        case 50:
        {
            return 'L';
        }
        case 100:
        {
            return 'C';
        }
        case 500:
        {
            return 'D';
        }
        case 1000:
        {
            return 'M';
        }
        default:
        {
            return 0;
        }
    }
}

static bool rn_is_valid_number_str(char* string_number) {
    if(string_number == 0) {
        return 0;
    }

    for(int i = 0; i < strlen(string_number); i++) {
        if(roman_char_to_int(string_number[i]) == 0) {
            return false;
        }
    }

    return true;
}


RomanNumber rn_create(char* value) {
    if(value == 0) {
        return 0;
    }

    romanNumber = (RomanNumber)calloc(1, sizeof(struct RomanNumberData));
    romanNumber->number = value;
    romanNumber->length = strlen(value);

    return romanNumber;
}

int rn_get_value(RomanNumber number) {
    if(number == 0 || !rn_is_valid(number)) {
        return -1;
    }

    int next_number = 0;
    int current_number = 0;
    int total_number = 0;

    for(int i = 0; i < strlen(number->number); i++) {
        current_number = roman_char_to_int(number->number[i]);
        
        if (number->number[i+1] == '\0') {
            total_number += current_number;
            return total_number;
        }

        next_number = roman_char_to_int(number->number[i+1]);

        if(current_number < next_number) {
            if(!rn_is_valid_subtraction(number->number[i], number->number[i+1])) {
                return -1;
            }
            total_number -= current_number;
        } else {
            total_number += current_number;
        }
    }

    return total_number;
}

bool rn_is_valid(RomanNumber number) {
    if(number == 0) {
        return 0;
    }

    for(int i = 0; i < number->length; i++) {
        if(roman_char_to_int(number->number[i]) == 0) {
            return false;
        }
    }

    return true;
}

RomanNumber rn_gcd(RomanNumber x, RomanNumber y) {
    if(x == 0 || y == 0) {
        return 0;
    }

    int intX = rn_get_value(x);
    int intY = rn_get_value(y);

    int result = int_gcd(intX, intY);

    return 0;
}

int int_gcd(int x, int y) {
    if(y == 0) {
       return x;
    }
   return int_gcd(y, x % y);
}