using System;

using NUnit.Framework;

using NUnitLite;

​

using System.Linq;

​

public class RomanToHexPalindrome

{

    public static string IsHexadecimalPalindrome(string romanNumber)

    {

        if (string.IsNullOrEmpty(romanNumber))

        {

            return "Error: Roman numeral cannot be null or empty.";

        }

​

        romanNumber = romanNumber.ToUpper();

        try

        {

​

            if (!IsValidRomanNumeral(romanNumber))

            {

                return "Error: Invalid Roman numeral format.";

            }

        }

        catch (ArgumentException e)

        {

            return "Error: " + e.Message;

        }

​

        int decimalNumber;

        try

        {

            decimalNumber = RomanToDecimal(romanNumber);

        }

        catch (ArgumentException e)

        {

            return "Error: " + e.Message;

        }

​

        if (decimalNumber > 10000)

        {

            return "Error: Number exceeds the maximum allowed value of 10000.";

        }

​

        string hexNumber = decimalNumber.ToString("X");

​

        if (IsPalindrome(hexNumber))

        {

            return $"{romanNumber} is \"{hexNumber}\" which is a hexadecimal palindrome.";

        }

​

        // Check with leading zeros

        for (int i = 1; i <= 4; ++i) //try padding with up to 4 zeros

        {

            string paddedHex = new string('0', i) + hexNumber;

            if (IsPalindrome(paddedHex))

            {

                hexNumber = paddedHex;

                return $"{romanNumber} is \"{hexNumber}\" which is a hexadecimal palindrome.";

            }

        }

​

​

        return $"{romanNumber} is \"{hexNumber}\" which is not a hexadecimal palindrome.";

    }

​

    private static bool IsPalindrome(string str) 

    => str.SequenceEqual(str.Reverse());

​

    private static int RomanToDecimal(string roman)

    {

        int result = 0;

        int prevValue = 0;

​

        for (int i = roman.Length - 1; i >= 0; i--)

        {

            char currentChar = roman[i];

            int currentValue = GetValue(currentChar);

​

            if (currentValue < prevValue)

            {

                result -= currentValue;

            }

            else

            {

                result += currentValue;

            }

​

            prevValue = currentValue;

        }

​

        return result;

    }

​

    private static int GetValue(char romanChar)

    {

        switch (romanChar)

        {

            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: throw new ArgumentException("Invalid Roman numeral character: " + romanChar);

        }

    }

​

    private static bool IsValidRomanNumeral(string roman)

    {

        // Basic validation to reject invalid sequences

        if (roman.Contains("IIII") || roman.Contains("VV") || roman.Contains("LL") || roman.Contains("DD") || roman.Contains("VX") || roman.Contains("VL") || roman.Contains("VC") || roman.Contains("VD") || roman.Contains("VM") || roman.Contains("XD") || roman.Contains("XM") || roman.Contains("LC") || roman.Contains("LD") || roman.Contains("LM") || roman.Contains("DM"))

        {

            return false;

        }

​

        // More comprehensive validation can be added here based on Roman numeral rules

        // Check for correct subtractive notation

        for (int i = 0; i < roman.Length - 1; i++)

        {

            int currentValue = GetValue(roman[i]);

            int nextValue = GetValue(roman[i + 1]);

​

            if (currentValue < nextValue)

            {

                if (currentValue == 5 || currentValue == 50 || currentValue == 500)

                {

                    return false; // V, L, and D cannot be used for subtraction

                }

                if (i > 0 && GetValue(roman[i - 1]) < currentValue)

                {

                    return false; // Only one small-value symbol may be placed before a large-value symbol

                }

                if (nextValue / currentValue > 10)

                {

                    return false; // I can only precede V and X, X can only precede L and C, and C can only precede D and M

                }

            }

        }

​

        return true;

    }

​

    public static int Main(string[] args)

    {

        return new AutoRun().Execute(args); 

    }

}  

​

​

​

// unit tests

​

​

[TestFixture]

public class RomanToHexPalindromeTests

{

    [Test]

    public void IsHexadecimalPalindrome_ValidPalindrome_ReturnsTrue()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("MMDCCXLVI"), Is.EqualTo("MMDCCXLVI is \"ABA\" which is a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_ValidNonPalindrome_ReturnsFalse()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("MMDCC"), Is.EqualTo("MMDCC is \"A8C\" which is not a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_ValidPalindromeWithPadding_ReturnsTrue()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("MMDCCXX"), Is.EqualTo("MMDCCXX is \"0AA0\" which is a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_NullInput_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome(null), Is.EqualTo("Error: Roman numeral cannot be null or empty."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_EmptyInput_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome(""), Is.EqualTo("Error: Roman numeral cannot be null or empty."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_InvalidRomanNumeral_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("IIII"), Is.EqualTo("Error: Invalid Roman numeral format."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_NumberOutOfRange_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("MMMMMMMMMMMI"), Is.EqualTo("Error: Number exceeds the maximum allowed value of 10000."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_NonRomanCharacters_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("XYZ"), Does.StartWith("Error: Invalid Roman numeral character:"));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_CaseInsensitiveInput_ReturnsCorrectResult()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("mmdccxlvi"), Is.EqualTo("MMDCCXLVI is \"ABA\" which is a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_EdgeCaseMinimumValue_ReturnsCorrectResult()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("I"), Is.EqualTo("I is \"1\" which is a hexadecimal palindrome."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("II"), Is.EqualTo("II is \"2\" which is a hexadecimal palindrome."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("III"), Is.EqualTo("III is \"3\" which is a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_EdgeCaseMaximumValue_ReturnsCorrectResult()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("MMMMMMMMMM"), Is.EqualTo("MMMMMMMMMM is \"2710\" which is not a hexadecimal palindrome."));

    }

​

    [Test]

    public void IsHexadecimalPalindrome_InvalidSubtractiveNotation_ReturnsError()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("VX"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("VL"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("VC"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("VD"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("VM"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("XD"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("XM"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("LC"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("LD"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("LM"), Is.EqualTo("Error: Invalid Roman numeral format."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("DM"), Is.EqualTo("Error: Invalid Roman numeral format."));

    }

    [Test]

    public void IsHexadecimalPalindrome_LeadingZerosNeeded_ReturnsCorrectResult()

    {

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("DCCCXXXVI"), Is.EqualTo("DCCCXXXVI is \"344\" which is not a hexadecimal palindrome."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("DCCCXXXVII"), Is.EqualTo("DCCCXXXVII is \"345\" which is not a hexadecimal palindrome."));

        Assert.That(RomanToHexPalindrome.IsHexadecimalPalindrome("DCCCXXXVIII"), Is.EqualTo("DCCCXXXVIII is \"346\" which is not a hexadecimal palindrome."));

    }

}