Wyniki wyzwania wydajnego kodu

				
					/** Notes from roman number principles that I've figured out:
    _________________________________________________________________________________________________ General:
    [rule 1] For these set: {M, D, C, L, X, V, I}
        - Maximum value that can be built is 3999. (MMMCMXCIX)
          Next value 4000 would need extra letter. (Mv) => (V = 5, v = 5000)
        - Maximum length of the roman stringValue is 15.
          (MMMDCCCLXXXVIII) = 3888

    [rule 2] Numbers in the romanValue are arranged in the descending order.
        The only exception is subtraction.
        This allows to go through the ConversionList, going only forward.
    _________________________________________________________________________________________________ Subtraction:
    [rule 3] Cannot subtract by {500, 50, 5} => {D, L, V}.
        - Examples: DM != 500, LC != 50

    [rule 4]
        - From X you can only subtract I, example: IX = 9       Wrong: VX != 5
        - From C you can only subtract X, example: XC = 90      Wrong: IC != 99, Good: 99 = XCIX
        - From M you can only subtract C, example: MCM = 1900   Wrong: XM != 990, Good: 990 = CMXC

    [rule 5]
        - After subtracting: IX, it will never appear: V
        - After subtracting: XC, it will never appear: L
        - After subtracting: CM, it will never appear: D
    _________________________________________________________________________________________________ Letters Quantity:
    [rule 6] There can never be more than ONE of {D, L, V}.
        - Examples: DDD != 1500, LL != 100

    [rule 7] There cannot be more than FOUR of {M, C, X}.
        - Examples: XXXIX = 39, MMMCM = 3900

    [rule 8] There cannot be more than three of {M, C, X} IN A ROW.
    _________________________________________________________________________________________________ Other:
    [9] Subtracting the same expression several times:
        - Examples: MMIXIXIXIX or MMIVIVIVIV or XLXLVII

    [10] Wrong value after subtraction, like IVI or ILI
        - It's basically [rule 4] and [rule 5] violation

    [11] Post Subrtation errors: {VIV, IVI, IXI}
**/
#pragma once

#include<string>
#include<forward_list>


//_____________________________________________________________________________________
typedef std::forward_list<std::pair<char,int>> ConversionList;

class ValueTooLow_Exception{};
class ValueTooHigh_Exception{};

class TooManyInRow_Exception{};
class BadValue_Exception{};

class BadSubtraction_Exception{};
class BadValueAfterSubtraction_Exception{};


//_____________________________________________________________________________________
ConversionList conversionList {
    {'M',1000},
    {'D',500},
    {'C',100},
    {'L',50},
    {'X',10},
    {'V',5},
    {'I',1}
};
const int c_maxInRow = 3;
const int c_minValue = 1;
const int c_maxValue = 3999;


//_____________________________________________________________________________________
ConversionList::iterator GiveIteratorOnCharacter(const char, ConversionList::iterator);

bool CheckForFiveish(int);   // if value == 5 or 50 or 500


//_____________________________________________________________________________________
std::string toRoman(int value){
    if (value < c_minValue)
        throw ValueTooLow_Exception();

    if (value > c_maxValue)
        throw ValueTooHigh_Exception();

    auto head = conversionList.begin();
    auto tail = head;
    float floatcalc;    // non-integer result of calculation
    int intcalc;        // integer result of calculation
    std::string result = "";

    while(value > 0){
        floatcalc = static_cast<float>(value) / static_cast<float>((*head).second);
        intcalc = value / (*head).second;

        if (floatcalc < 1){
            if (floatcalc >= 0.9f && !CheckForFiveish((*head).second)){
                // Subtraction: A => Works for NOT-fiveish scenerios: IX, XC, CM    {X, C, M}
                tail = head;
                std::advance(head, 2);

                result += (*head).first;
                value += (*head).second;
                result += (*tail).first;
                value -= (*tail).second;

                ++tail;
            }
            else{
                tail = head;
                ++head;
            }
        }
        else if (intcalc > 3){
            // Subtraction: B => Works for fiveish scenerios: IV, XL, CD    {V, L, D}
            result += (*head).first;
            value += (*head).second;
            result += (*tail).first;
            value -= (*tail).second;
        }
        else{
            result.append(intcalc, (*head).first);
            value -= ((*head).second * intcalc);
        }
    }
    return result;
}



int fromRoman(std::string value){
    const unsigned int strLength = value.length();
    int counter_theSame = 0, lastFiveSeen = 0, lastSubtraction = 0;
    int resultValue = 0;
    int indexValue;
    int nextValue;

    ConversionList::iterator clScope;
    //auto clScope = conversionList.begin();
    // CLSCOPE - Narrows the scope of conversionList browsing
    // *cl - Conversion List Scope

    ConversionList::iterator scout;
    //auto scout = GiveIteratorOnCharacter(value[0], clScope);
    // SCOUT - Goes ahead, checks what to do.
    // Moves only between clScope and conversionList.end();

    clScope = conversionList.begin();
    scout = GiveIteratorOnCharacter(value[0], clScope);
    indexValue = (*scout).second;

    if(CheckForFiveish(indexValue))
        lastFiveSeen = indexValue;

    for (unsigned int index = 1; index < strLength; ++index){
        scout = GiveIteratorOnCharacter(value[index], clScope);
        nextValue = (*scout).second;

        if (nextValue == lastFiveSeen)
            throw TooManyInRow_Exception();

        if (indexValue == nextValue){
            if (CheckForFiveish(nextValue))
                throw TooManyInRow_Exception();

            if ((counter_theSame+1) < c_maxInRow)    ++counter_theSame;
            else                                    throw TooManyInRow_Exception(); // More than 3 equal letters in a row

            clScope = scout;
        }
        else{
            counter_theSame = 0; // Because nextValue is different from this one.

            if (indexValue < nextValue){ // Subtraction scenario:
                if (indexValue < (nextValue / 10))      // [rule 4]
                    throw BadSubtraction_Exception();

                if(CheckForFiveish(indexValue))
                    throw BadSubtraction_Exception();   // [rule 3] Cannot subtract by {D, L, V}.

                lastSubtraction = indexValue;
                indexValue = -indexValue;

                clScope = scout;
                ++clScope;

                if(CheckForFiveish((*clScope).second))  // [rule 10] Post substraction errors
                    ++clScope;
            }
            else if (nextValue == lastSubtraction)      // [rule 11] Post substraction errors
                throw BadValueAfterSubtraction_Exception();
        }
        resultValue += indexValue;
        indexValue = nextValue;
    }
    return resultValue + indexValue;
}

/// Searches the conversionList for given CHARACTER.
/// Starts from ITER position to conversionList end().
ConversionList::iterator GiveIteratorOnCharacter(const char character, ConversionList::iterator iter){
    while(iter != conversionList.end()){
        if ((*iter).first == character)
            return iter;
        else
            ++iter;
    }
    // Value is not within the given range of the ConversionList. (or it's not there at all)
    throw BadValue_Exception();
}

bool CheckForFiveish(int value){
    if (value == 5)     // V
        return true;

    if (value == 50)    // L
        return true;

    if (value == 500)   // D
        return true;

    return false;
}