Feedback

C# - Römische Zahlen / Roman Numerals

Veröffentlicht von am 08.10.2012
(1 Bewertungen)
Dieser Code überprüft die Eingabe auf syntaktische Korrektheit der römischen Zahl und konvertiert sie dann in eine Dezimalzahl

---
This code checks the input for formal correctnes of the roman number and the converts it into a decimal number
GFU-Schulungen  [Anzeige]

Visual Studio Team Foundation Server 2017/2015 (TFS) für Entwickler - Kompakt

Nach Teilnahme an dieser Schulung kennen Sie alle wesentlichen Funktionen des TFS für Entwickler. Sie setzen Software-Entwicklung mit dem Visual Studio Team Foundation Server erfolgreich um.

ASP.NET Core und Angular Komplett für .NET-Entwickler

Sie  lernen in drei (3) Tagen wie man mit  ASP.NET Core und den Technologien  MVC, Entity Framework, WebAPI und  Razor professionelle sowie moderne  Web-Anwendungsarchitekturen aufbaut.  Die Schulung ist der perfekte  Einstieg um insbesondere datengetriebene  und präsentationsorientierte  Applikationen auf Basis der robusten und  skalierbaren ASP.NET Core  Plattform zu erstellen. Nach der Veranstaltung kennen Sie die Konzepte von Angular und können Angular in neue und bestehende ASP.NET-Anwendungen einsetzen.

using System;
using System.Collections.Generic;

namespace RomanNumerals
{
    public static class Program
    {
        public static void Main()
        {
            try
            {
                Dictionary<Char, UInt16> romanNumerals;
                String input;
                List<UInt16> numbers;
                UInt16 highestNumber;
                String highestNumeral;
                UInt16 result;
                UInt16 dCount;
                UInt16 cCount;
                UInt16 lCount;
                UInt16 xCount;
                UInt16 vCount;
                UInt16 iCount;

                romanNumerals = new Dictionary<Char, UInt16>(7);
                romanNumerals.Add('I', 1);
                romanNumerals.Add('V', 5);
                romanNumerals.Add('X', 10);
                romanNumerals.Add('L', 50);
                romanNumerals.Add('C', 100);
                romanNumerals.Add('D', 500);
                romanNumerals.Add('M', 1000);
                Console.WriteLine("Please enter a roman numeral and press <Enter>");
                input = Console.ReadLine().ToUpper();
                numbers = new List<UInt16>(input.Length);
                #region Input Checking

                //The following code check against the following rules:

                //The numbers have to be steady or descending
                //You can substract C only from M and D
                //You can substract X only from C and L
                //You can substract I only from X and V
                //D, L and V can only appear once
                //C, X and I can only appear thrice in a row

                highestNumber = 1000;
                highestNumeral = "M";
                dCount = 0;
                cCount = 0;
                lCount = 0;
                xCount = 0;
                vCount = 0;
                iCount = 0;
                foreach(Char letter in input)
                {
                    UInt16 number;

                    if(romanNumerals.TryGetValue(letter, out number) == false)
                    {
                        Console.WriteLine("'{0}' is not a roman number", letter);
                        return;
                    }
                    numbers.Add(number);
                }
                for(Int32 i = 0; i < numbers.Count; i++)
                {
                    if(i < numbers.Count - 1)
                    {
                        if(numbers[i] < numbers[i + 1])
                        {
                            UInt16 substraction;

                            if(numbers[i] == 1)
                            {
                                if((numbers[i + 1] != 5) && (numbers[i + 1] != 10))
                                {
                                    Console.WriteLine("You can substract 'I' only from 'V' or 'X'");
                                    return;
                                }
                            }
                            else if(numbers[i] == 10)
                            {
                                if((numbers[i + 1] != 50) && (numbers[i + 1] != 100))
                                {
                                    Console.WriteLine("You can substract 'X' only from 'L' or 'C'");
                                    return;
                                }
                            }
                            else if(numbers[i] == 100)
                            {
                                if((numbers[i + 1] != 500) && (numbers[i + 1] != 1000))
                                {
                                    Console.WriteLine("You can substract 'C' only from 'D' or 'M'");
                                    return;
                                }
                            }
                            else
                            {
                                Console.WriteLine("You cannot substract '{0}' from '{1}'", input[i], input[i + 1]);
                                return;
                            }
                            substraction = (UInt16)(numbers[i + 1] - numbers[i]);
                            if(substraction > highestNumber)
                            {
                                Console.WriteLine("You cannot have '{0}' following '{1}'", input[i].ToString() + input[i + 1].ToString(), highestNumeral);
                                return;
                            }
                            else
                            {
                                highestNumeral = input[i].ToString() + input[i + 1].ToString();
                                if(substraction == highestNumber)
                                {
                                    Console.WriteLine("You cannot have '{0}' following '{0}'", highestNumeral);
                                    return;
                                }
                                highestNumber = (UInt16)(numbers[i] - 1);
                                i++;
                                if(DetermineMaxSequentials(input, numbers, i, ref dCount, ref cCount, ref lCount, ref xCount, ref vCount, ref iCount, true))
                                {
                                    return;
                                }
                                continue;
                            }
                        }
                    }
                    if(numbers[i] > highestNumber)
                    {
                        Console.WriteLine("You cannot have '{0}' following '{1}'", input[i], highestNumeral);
                        return;
                    }
                    else
                    {
                        if(DetermineMaxSequentials(input, numbers, i, ref dCount, ref cCount, ref lCount, ref xCount, ref vCount, ref iCount, false))
                        {
                            return;
                        }
                        highestNumber = numbers[i];
                        highestNumeral = input[i].ToString();
                    }
                }
                #endregion
                #region Calculation
                result = 0;
                for(Int32 i = 0; i < numbers.Count; i++)
                {
                    if(i == numbers.Count - 1)
                    {
                        result += numbers[i];
                    }
                    else
                    {
                        if(numbers[i] < numbers[i + 1])
                        {
                            UInt16 substraction;

                            substraction = (UInt16)(numbers[i + 1] - numbers[i]);
                            result += substraction;
                            i++;
                        }
                        else
                        {
                            result += numbers[i];
                        }
                    }
                }
                #endregion
                Console.WriteLine("Result: {0}", result);
            }
            catch(Exception ex)
            {
                Console.WriteLine("Exception: {0}", ex.Message);
            }
            finally
            {
                Console.WriteLine("Press <Enter> to exit");
                Console.ReadLine();
            }
        }

        #region Input Checking
        private static Boolean DetermineMaxSequentials(String input
            , List<UInt16> numbers
            , Int32 index
            , ref UInt16 dCount
            , ref UInt16 cCount
            , ref UInt16 lCount
            , ref UInt16 xCount
            , ref UInt16 vCount
            , ref UInt16 iCount
            , Boolean isSubstraction)
        {
            Boolean abort;
            UInt16 maxOne;
            UInt16 maxThree;

            maxOne = 1;
            if(isSubstraction)
            {
                maxThree = 4;
            }
            else
            {
                maxThree = 3;
            }
            if(DetermineMaxSequentials(input, numbers, index, ref dCount, maxOne, 500, "one", out abort) == false)
            {
                if(DetermineMaxSequentials(input, numbers, index, ref cCount, maxThree, 100, "three", out abort) == false)
                {
                    if(DetermineMaxSequentials(input, numbers, index, ref lCount, maxOne, 50, "one", out abort) == false)
                    {
                        if(DetermineMaxSequentials(input, numbers, index, ref xCount, maxThree, 10, "three", out abort) == false)
                        {
                            if(DetermineMaxSequentials(input, numbers, index, ref vCount, maxOne, 5, "one", out abort) == false)
                            {
                                DetermineMaxSequentials(input, numbers, index, ref iCount, maxThree, 1, "three", out abort);
                            }
                        }
                    }
                }
            }
            return (abort);
        }

        private static Boolean DetermineMaxSequentials(String input
            , List<UInt16> numbers
            , Int32 index
            , ref UInt16 count
            , UInt16 maxCount
            , UInt16 value
            , String numberWord
            , out Boolean abort)
        {
            abort = false;
            if(numbers[index] == value)
            {
                count++;
                if(count > maxCount)
                {
                    Console.WriteLine("You cannot have more than {0} '{1}'", numberWord, input[index]);
                    abort = true;
                }
                return (true);
            }
            return (false);
        }
        #endregion
    }
}

Kommentare zum Snippet

 

Logge dich ein, um hier zu kommentieren!