programming question! Options

[impala454]

Finally got around to this in some bored time at work. Works pretty damn good so far. Feel free to break it and let me know what did it.

CODE

using System;
using System.Collections.Generic;
using System.Text;
//-------------------------
using System.Text.RegularExpressions;
using System.Collections;

namespace FractionConvert
{
    class Program
    {
        static void Main(string[] args)
        {
            Fraction f = new Fraction();
            double d = 0;
            Double.TryParse(args[0], out d);
            Fraction.TryParse(d, out f);
            Console.WriteLine(f.ToString());
        }
    }

    class Fraction
    {
        int m_nNumerator;
        int m_nDenominator;
        bool m_bNegative;
        double m_dDecimal;

        public Fraction()
        {
            m_nNumerator = 0;
            m_nDenominator = 0;
            m_dDecimal = 0;
            m_bNegative = false;
        }

        public Fraction(double DecimalToConvert)
        {
            m_nNumerator = 0;
            m_nDenominator = 0;
            m_dDecimal = DecimalToConvert;
            m_bNegative = false;

            ParseFraction();
        }

        public static bool TryParse(double DecimalInput, out Fraction FractionOutput)
        {
            try
            {
                FractionOutput = new Fraction(DecimalInput);
            }
            catch (Exception)
            {
                FractionOutput = new Fraction(0);
                return false;
            }

            return true;
        }

        public override string ToString()
        {
            if(m_bNegative)
                return string.Format("-{0}/{1}", m_nNumerator, m_nDenominator);
            else
                return string.Format("{0}/{1}", m_nNumerator, m_nDenominator);
        }

        private void ParseFraction()
        {
            if (m_dDecimal == 0)
            {
                m_nNumerator = 0;
                m_nDenominator = 1; // this could be any number really
                return;
            }

            string Whole = "";
            string Decimal = m_dDecimal.ToString();

            // strip off the minus sign if there is one
            if (Decimal[0] == '-')
            {
                m_bNegative = true;
                Decimal = Decimal.Substring(1, Decimal.Length - 1);
            }

            // split out the whole number, no need to parse that
            if (Decimal.Contains("."))
            {
                Whole = Decimal.Split('.')[0];
                Decimal = Decimal.Split('.')[1];
            }

            string Pattern = GetPattern(Decimal);

            int ParseInt = 0;
            int Divisor = 1;
            ArrayList Divisors = new ArrayList();

            if (!Int32.TryParse(Pattern, out ParseInt))
            {
                throw new Exception("Not a valid decimal number");
                return;
            }

            while (ParseInt > Divisor)
            {
                if (ParseInt % Divisor == 0)
                    Divisors.Insert(0, Divisor);

                Divisor++;
            }

            int WholeNumber = 0;
            Int32.TryParse(Whole, out WholeNumber);

            // if we only have one divisor, obviously it's 1
            if (Divisors.Count == 1)
            {
                m_nNumerator = 1;
                m_nDenominator = ParseInt;
                return;
            }

            foreach (int n in Divisors)
            {
                if (10 % n == 0)
                {
                    if(Pattern.Length <= 1)
                        m_nDenominator = 10 * n / ParseInt;
                    else
                        m_nDenominator = (Pattern.Length - 1) * (int)Math.Pow(10, (double)n+1) / ParseInt;

                    if (WholeNumber > 0)
                        m_nNumerator = m_nDenominator * WholeNumber + n;
                    else
                        m_nNumerator = n;
                    break;
                }
            }
        }

        private string GetPattern(string Decimal)
        {
            // the accuracy can't be any better than half the number of digits!
            //if (m_nAccuracy > Decimal.Length / 2)
            int Accuracy = Decimal.Length / 2;

            string Pattern = "";
            int NumRepeats = 0;
            int MeasuredAccuracy = 0;
            int MaxRepeats = 0;

            for (int i = 1; i <= Accuracy; i++)
            {
                NumRepeats = 0;

                Pattern = Decimal.Substring(0, i);
                for (int j = 0; j <= Decimal.Length - Accuracy; j += Pattern.Length)
                {
                    if (Decimal.Substring(j, Pattern.Length) == Pattern)
                        NumRepeats++;
                    else
                        break;
                }
                if (NumRepeats >= MaxRepeats)
                {
                    MaxRepeats = NumRepeats;
                    MeasuredAccuracy = Pattern.Length;
                }
            }

            // if we didn't find the pattern more than once, there is no pattern
            if (MaxRepeats <= 1)
                return Decimal;
            else
                return Decimal.Substring(0, MeasuredAccuracy);
        }
    }
}

[Spectatrix]

Too long. Cliff notes?

(I kid)

[pebkac]

Interesting. I can see why Desrosiers told me not to worry about it now. When he showed us his version of this program, he didn't even implement the function at all because it was too "ambiguous."

At any rate, it's pretty helpful to know how to actually do that.

[impala454]

Too long. Cliff notes?

(I kid)

DO IT WITH LESS CODE THEN BITCH



oh and actually didn't use regexes, so that "Using Regexes" line at the top can be removed.

[Spectatrix]

DO IT WITH LESS CODE THEN BITCH



oh and actually, didn't use regexes, so that "Using Regexes" line at the top can be removed.

OK MAYBE I WILL!

[zetec]

I was right about to say, why aren't you using regular expressions again?