24 Point algorithm Source code (C #) __ algorithm

Using System;
Using System.Collections.Generic;
Using System.Text;

Using System.Collections; 
    namespace Heroassociation {///<summary>///24 Point///</summary> public class Twentyfourpoint
        {///<summary>///fractional class, for fractional operations. </summary> class Fraction {///<summary>///molecule///&
            lt;/summary> private int numerator;

            <summary>///denominator///</summary> private int denominator;  public fraction (int number): This (number, 1) {} public fraction (int numerator, int denominator) {if (denominator = = 0) {throw new Divi
                Debyzeroexception ("Denominator cannot be 0"); int sign = numerator * Denominator < 0?
                -1:1;
        Numerator = Abs (numerator);        Denominator = Abs (denominator);
                This.numerator = sign * NUMERATOR/GCD (numerator, denominator);
            This.denominator = DENOMINATOR/GCD (numerator, denominator); public static fraction operator + (fraction A, fraction b) {if (A.denominator =
                = B.denominator) {return new fraction (A.numerator + b.numerator, a.denominator); else {return new fraction (A.numerator * b.denominator
                + B.numerator * a.denominator, A.denominator * b.denominator); }} public static fraction operator-(fraction A, fraction b) {if (a . Denominator = = B.denominator) {return new fraction (A.numerator-b.numerator, A.deno
                Minator); else {return new FraCtion (A.numerator * b.denominator-b.numerator * a.denominator, A.denominator * b.denominator); } public static fraction operator * (fraction A, fraction b) {retur
            N New Fraction (A.numerator * b.numerator, A.denominator * b.denominator); public static fraction operator/(fraction A, fraction b) {return new fraction
            (A.numerator * b.denominator, A.denominator * b.numerator);
                public override bool Equals (object obj) {fraction a = (fraction) obj;
            return this.numerator = = A.numerator && This.denominator = = A.denominator; Override int GetHashCode () {return This.numerator.GetHashCode () ^ This. Denominator.
            GetHashCode ();
          }///<summary>///is an integer///</summary>  <returns></returns> public bool Isinteger () {return numerator%
            denominator = 0; }///<summary>///gcd///</summary>///<param name= "
            A "></param>///<param name=" B "></param>///<returns></returns>
            private static int Gcd (int a, int b) {return b = 0 A:GCD (b, a% B);
            private static int Abs (int a) {return a < 0-a:a;
            public int result () {return numerator/denominator;
            public bool Iszero () {return numerator = 0; }}///<summary>///arithmetic operation Combination Enumerator, does not change the order of the fractions///</summary> class Arit hmeticiterator:ienumerable<fraction> {private fraction[] fractions; <summary>///constructs arithmetic enumeration objects///</summary>///<param name= "Fractions" &G t; fractional array </param> public arithmeticiterator (fraction[] fractions) {This.fracti
            ONS = fractions; Public ienumerator<fraction> GetEnumerator () {if (fractions).
                    Length = = 1) {yield return fractions[0];
                Yield break; for (int i = 1; i < fractions. Length;
                    i++) {fraction[] leftfractions = new Fraction[i]; fraction[] rightfractions = new fraction[fractions.
                    Length-i];
                    Array.copy (fractions, 0, leftfractions, 0, leftfractions.length);
        Array.copy (Fractions, I, rightfractions, 0, rightfractions.length);            foreach (fraction leftfraction in New Arithmeticiterator (leftfractions)) {
                            foreach (fraction rightfraction in New Arithmeticiterator (rightfractions)) {
                            Yield return leftfraction + rightfraction;
                            Yield return leftfraction-rightfraction;
                            Yield return leftfraction * rightfraction; if (!rightfraction.iszero ()) {yield return Leftfraction/rig
                            Htfraction; }}}} IEnumerator Ienumerable.get
            Enumerator () {return GetEnumerator (); }///<summary>///fractional full array iterator///</summary> class Fractionspermuta Tioniterator:ienumerable<fraction[]&gT
            {private fraction[] fractions; <summary>///structured Fractions///</summary>///<param name= "Fractions"
                > Fractional Array </param> public fractionspermutationiterator (fraction[] fractions) {
            This.fractions = fractions; Public ienumerator<fraction[]> GetEnumerator () {if (fractions).
                    Length = = 1) {yield return fractions;
                Yield break; for (int idx = 0; idx < fractions. Length; idx++) {fraction[] result = new fraction[fractions.
                    Length];

                    Result[0] = Fractions[idx];

                    fraction[] subfractions = removeat (fractions, IDX);
             foreach (fraction[] FRS in new Fractionspermutationiterator (subfractions)) {           Array.copy (FRS, 0, result, 1, FRS).
                        Length);
                    yield return result;
            }}///<summary>///deletes the element at the specified location of the vegetarian group, returning the new array. </summary>///<param name= "Array" > original array. Do not change the original array </param>///<param name= "idx" ></param>///<returns></returns&gt
            ; private static fraction[] RemoveAt (fraction[] array, int idx) {fraction[] subfractions = new Fraction[array.

                LENGTH-1]; if (idx > 0) {//former part array.copy (Array, 0, subfractions, 0, IDX)
                ; } if (idx < array.  LENGTH-1) {//second half array.copy (Array, idx + 1, subfractions, IDX,
                SUBFRACTIONS.LENGTH-IDX);
            return subfractions;} IEnumerator Ienumerable.getenumerator () {return GetEnumerator ();

        } private int A, B, C, D; public static bool Can24 (int A, int b, int c, int d) {return new Twentyfourpoint (A, B, C, D).
        Can24 ();
            Public Twentyfourpoint (int a, int b, int c, int d) {this.a = A;
            this.b = b;
            THIS.C = C;
        THIS.D = D;
            public bool Can24 () {fraction[] fractions = new FRACTION[4];
            Fractions[0] = new fraction (THIS.A);
            FRACTIONS[1] = new fraction (this.b);
            FRACTIONS[2] = new fraction (THIS.C);

            FRACTIONS[3] = new fraction (THIS.D); foreach (fraction[] onefractions in new fractionspermutationiterator (fractions)) {foreach (Fr Action fra in New Arithmeticiterator (onefractions)) {if(Fra. Isinteger () && fra.
                    Result () = = () {return true;
        }} return false;
 }
    }
}