/*
Online Java - IDE, Code Editor, Compiler

Online Java is a quick and easy tool that helps you to build, compile, test your programs online.
*/
import java.util.*;
import java.util.regex.Pattern;
import java.util.regex.Matcher;

class RepeatDecimalFractions
{
    boolean isPeriodNumber=true;
    String backupFractionalPart;
    long denominator=0;
    
    //used for stop clock
    long startTime;
    long endTime;
    boolean running;
    long elapsed;
    
    long primeNumberCheckLimit;
    long maxGCF;
    long acceptedNumeratorLimit;
    String acceptedNumeratorLimitString=String.valueOf(acceptedNumeratorLimit);
    int limitPrecision;
    long numeratorOriginalLong;
    long denominatorOriginalLong;
    String partialEquationTwo;
    boolean singleDigitrecurring;
    String fractionalPart;
    String[] testOne;
    long divisor;
    boolean successReducedNumerator;
    boolean successReducedDenominator;
    boolean isTerminatingDecimal=true;
    List<Long> notPrimeLst = new ArrayList<>();
    List<Long> primeLst = new ArrayList<>();
    int numberConsecutiveDigits=0;
    
     //generated this section online via AI  ****************
    public void start() 
    {
        startTime = System.nanoTime();
        running = true;
    }

    public void stop() 
    {
        endTime = System.nanoTime();
        running = false;
    }

    public long getElapsedTime() 
    {
        if (running) 
        {
            elapsed = System.nanoTime() - startTime;
        } 
        else 
        {
            elapsed = endTime - startTime;
        }
        return elapsed;
    }

    public double getElapsedTimeInSeconds() 
    {
        return getElapsedTime() / 1_000_000_000.0;
    }
    //*******************************************************
    
    public void generateTerminatingNonRepeatFractions()
    {   
        long [] testing = new long[19];
        boolean primeNumber=false;
        long temp;
        long count=0;
        long arraySize = 2147483647;
        long [] noPrimeFactor = new long[21474836];
        long startNum=2;
        
        for (long m=startNum; m<=primeNumberCheckLimit;m++)
        {
            primeNumber=true;
             
            for (long j=2; j<m;j++)
            {
                if (m%j==0 && m>3)
                {
                    System.out.println("is not a prime number: " + m);
                    notPrimeLst.add(m);
                    primeNumber=false;
                    break;
                }
            }
            count++;
            
            if (primeNumber || (m>0 && m<3))
            {
                System.out.println("is a prime number: " + m);
                primeLst.add(m);
            }
        }
        
    }
    
    public boolean reducedNumerator(Long numerator, long divisor)
    {
        if (divisor>numerator)
        {
            return false;
        }
        else
        {
            if (numerator%divisor==0)
            {
                //System.out.println("PERFORMED REDUCTION NUMERATOR");
                successReducedNumerator = true;
                return successReducedNumerator;
            }
        }
        return false;
    }
    
    public boolean reducedDenominator(long denominator, long divisor)
    {
        //System.out.println("FUKING Den: " + denominator);
        if (denominator%divisor==0)
        {
            //System.out.println("PERFORMED REDUCTION Denominator");
            successReducedDenominator = true;
            return successReducedDenominator;
        }
        return false;
    }
    
    public boolean terminatingDecimal(long primeFactorCheck, long numerator, String decimalOriginal)
    {
        int counter=0;
        long denominatorDivisiblePrimeFactor=0;
        isTerminatingDecimal=true;
        List<Long> terminatingDecimalLst = new ArrayList<>();
        boolean primeFactorTwo=false;
        boolean primeFactorFive=false;
        int pos=0;
        String [][] originalDenominatorDividePrime = new String[2000][2];
        String [][]originalDenominatorDivideNonPrime = new String[2000][2];
        double numeratorDividePrimeNumber;
        boolean executeOnce=true;
        int numberConsecutiveDigits=0;
        
        Iterator<Long> f = primeLst.iterator();
        
        System.out.println("************************************************");    
        System.out.println("This will just be final part of the code...");
        System.out.println("Since several prime numbers have been generated, I will use the existing numerator");
        System.out.println("And store the results in a String array:   Numerator/prime number AS fraction  and Numerator/prime number AS decimal  and store results.  IT IS TO GET A FEEL OF DIFFERENT PATTERNS AS EXPLORED IN DOCUMENTATION!");
        System.out.println("This will provide a sample should I wish to populate initial array also! ");
        System.out.println("It will also show examples in which repetends have occured two or more times in the decimal precision ("+limitPrecision+ " digits wide)");
        System.out.println("THIS IS ONLY circumstances available to enhance my code to utilize mapping to fractional equivalent....");
        System.out.println("**************************************************");
        
        System.out.println("CHECK TO SEE IF ORIGINAL FRACTION IS TERMINATING: ");    
            
        while (f.hasNext())
        {
            pos=0;
            long item = f.next();
            counter++;
            
            if (item==2 && primeFactorCheck>=item)
            {
                if (primeFactorCheck%2==0)
                {
                    primeFactorTwo=true;
                }
            }
            
            if (item==5 && primeFactorCheck>=item)
            {
                if (primeFactorCheck%5==0)
                {
                    primeFactorFive=true;
                }
            }
            numeratorDividePrimeNumber = (double)(numeratorOriginalLong)/(double)(item);
        
            if (executeOnce)
            {
                if ((primeFactorFive || primeFactorTwo))
                {
                    System.out.println("Terminating fraction since reduced denominator" + "("+denominator+")" + " has prime factor (divisble by prime number of two or five)");
                    
                }
                else
                {
                    System.out.println("NOT Terminating fraction since reduced denominator " + "("+denominator+")" + " is NOT divisble by prime number of two or five");
                }
                
                if (isPeriodNumber)
                {
                    System.out.println("Original decimal:" + decimalOriginal + " is a periodic number");
                }
                else
                {
                    System.out.println("Original decimal:" + decimalOriginal + " is NOT a periodic number");
                }
            isPeriodNumber=false;
            executeOnce=false;
          }
          
          //************THIS CAN BE TURNED OFF IF REQUIRED, JUST USEFUL FOR GENERATING VALID TEST CASES***********
        originalDenominatorDividePrime[counter][pos] = numeratorOriginalLong + "/" + item;
        originalDenominatorDividePrime[counter][pos+1] = String.valueOf(numeratorDividePrimeNumber);
        
        System.out.println("Original numerator / PRIME number AS FRACTION (not reduced) => " + originalDenominatorDividePrime[counter][pos]);
        System.out.println("Original numerator / PRIME number AS DECIMAL => " +originalDenominatorDividePrime[counter][pos+1]);
        //************THIS CAN BE TURNED OFF IF REQUIRED, JUST USEFUL FOR GENERATING VALID TEST CASES***********
        }
        
        return false;
    }
        
    public void checkRecurrence()
    {
       backupFractionalPart = fractionalPart;
        
        if(fractionalPart.length()>1)
        {
            do
            {
                if (fractionalPart.charAt(0)==fractionalPart.charAt(fractionalPart.length()-1))
                {
                    numberConsecutiveDigits++;
                    singleDigitrecurring = true;
                    fractionalPart=fractionalPart.substring(1);
                    partialEquationTwo = partialEquationTwo + fractionalPart.charAt(0);
                    
                }
                else
                {
                    //fractionalPart=backupFractionalPart;
                    singleDigitrecurring = false;
                    break;
                }
            }while(fractionalPart.length()>1);
        }
    }
    
    public void fraction(String[] testOne)
    {
        boolean improperFraction=false;
        String temp;
        long posTestOneDecimal=0;
        long posTestOneFraction;
        String numeratorOriginal="";
        String denominatorOriginal="";
        String decimalOriginal="";
        long denominatorIntoNumerator=0;
        String remainingFraction="";
        String decimalPortionOriginal="";
        int posDecimalPoint;
        
        generateTerminatingNonRepeatFractions();
        
        StringTokenizer st = new StringTokenizer (testOne[0], ",");
        
        String wholeNumberPortionDecimal;
        
        while (st.hasMoreTokens())
        {
            singleDigitrecurring=false;   
            temp= st.nextToken().toString();
            
            posDecimalPoint=temp.indexOf(".");
            decimalOriginal=temp;
            
            posTestOneDecimal++;
            
            System.out.println("\n\n\n*** The Decimal presented: " + temp);
            decimalPortionOriginal = temp.substring(temp.indexOf("."));
            wholeNumberPortionDecimal = temp.substring(0,temp.indexOf("."));
            
            fractionalPart = temp.substring((temp.indexOf(".")+1));
            String fractionalPartionWithDecimal = temp.substring((temp.indexOf(".")));
            long numerator = Long.valueOf(fractionalPart);
            partialEquationTwo="";
            String fullEquationOne=  "0"+fractionalPartionWithDecimal;
            Double equationTwoA;
            
            String wholeNumberBeforeFraction;
            long wholeNumberBeforeFractionLong=0;
            String numeratorToString="";
            String denominatorToString="";
            long minNum=0;
            long maxNum=0;
            boolean exitWhileLoop=false;
            long numeratorBackup;
            StringJoiner sj1 = new StringJoiner(",");
            char firstDigitNumerator;
            
            checkRecurrence();
            fractionalPart=backupFractionalPart;
            
            if (singleDigitrecurring)
            {
                System.out.println("INDSIDE1");
                //System.out.println
                if (numberConsecutiveDigits+1==limitPrecision)
                {
                    System.out.println("INDSIDE2");
                    
                    System.out.println("Recurring digit occurs: " + limitPrecision + " times");
                    System.out.println("Recurring digit through entire decimal: " + fractionalPart.charAt(0));
                    String fullEquationTwo = fractionalPart.charAt(0) + "." + fractionalPart.charAt(0)+ partialEquationTwo;
                    
                    isPeriodNumber=false;
                        
                    System.out.println("FULL EQUATION ONE: " + fullEquationOne);
                    System.out.println("FULL EQUATION TWO: " + fullEquationTwo);
                    equationTwoA = Double.valueOf(fullEquationTwo) - Double.valueOf(fullEquationOne);
                    System.out.println("FULL EQUATION TWO A: " + equationTwoA);
                    
                    numeratorBackup=numerator;
                    numerator = equationTwoA.longValue();
                    denominator = 9;
                    remainingFraction = numerator + "/" + 9;
                    System.out.println("Fraction of recurring: " + remainingFraction);
                    numerator=numeratorBackup;
                    numberConsecutiveDigits=0;
                    
                }
                //else
                //{
                 //   numberConsecutiveDigits=0;
                //}
            }
                
            long multipliedBy;
            System.out.println("The fraction part:   " + fractionalPart);
            multipliedBy=fractionalPart.length();
            long multipliedByInteger = Long.valueOf(multipliedBy);
            denominator = 1;
            long i=0;
                
            while (i<multipliedByInteger)
            {
                i++;
            
                if (i<limitPrecision)
                {
                    denominator = denominator * 10;
                        
                }
                else
                {
                    break;
                }
            }
            System.out.println("this is numerator:   " + numerator);
            //we know that Java will not handle 20 digits
            //so we know numerator commences with 1 and adding additional 19 digits not possible
            //This correction is purpose of corect screen reporting..
            if (multipliedBy==19)
            {
                System.out.println("this is denominator: " + denominator + "0");
                
            }
            
            else
            {
                System.out.println("this is denominator: " + denominator);
            }
            
            
            
            
            
                
              if (numerator>acceptedNumeratorLimit || denominator>acceptedNumeratorLimit)
            {
                acceptedNumeratorLimitString=String.valueOf(acceptedNumeratorLimit);
                int digitsAcceptedNumeratorLimit = acceptedNumeratorLimitString.length();
                 
                if (singleDigitrecurring)
                {
                    //  we know in single digit recurring this is the limit 
                        //1000000000000000000   otherwise value will turn negative
                        //this is 18  x  0s
                        //this means that it can move on the numerator back 18 times to reach decimal point
                        //we know accepted limit is
                        //999,999,999
                        //so for the decimal point to move from end to start is the number of 0s in denominator
                        //  9 x 0s     1,000,000,000  (10 digits)
                        //however it is very likely that calculation might not progress...
                        //in which case truncate a digit off both
                    
                    System.out.println("Denominator" + "("+denominator+")" + " considered too large for computation");
                    denominatorToString = String.valueOf(denominator);
                    
                    denominatorToString=denominatorToString.substring(0,digitsAcceptedNumeratorLimit+1);
                    System.out.println("Denominator reduced to " + (digitsAcceptedNumeratorLimit+1) + " digits wide: " + "("+denominatorToString+")" + " due to recurrence numerator");
                    denominator = Long.valueOf(denominatorToString);
                    System.out.println("Truncated denominator: " + denominator);
                    
                    System.out.println("Numerator " + "("+numerator+")" + " considered too large for computation");
                    numeratorToString = String.valueOf(numerator);
                    numeratorToString=numeratorToString.substring(0,digitsAcceptedNumeratorLimit);
                    System.out.println("Numerator reduced to " + digitsAcceptedNumeratorLimit + "digits wide: " + "("+numeratorToString+")" + " due to recurrence numerator");
                    numerator = Long.valueOf(numeratorToString);
                    System.out.println("Truncated numerator:   " + numerator);
                   
                    
                    
                    firstDigitNumerator = numeratorToString.charAt(0);
                    
                    if(numeratorToString.length()==9)
                    {
                        
                    if(firstDigitNumerator=='1' || firstDigitNumerator=='3' || firstDigitNumerator=='7' || firstDigitNumerator=='9' )
                    {
                numeratorToString = numeratorToString.substring(0,numeratorToString.length()-1);
                denominatorToString = denominatorToString.substring(0,denominatorToString.length()-1);
                System.out.println("Numerator reduced to: " + numeratorToString.length() + " digits " + "("+numeratorToString+")"+" to mitigate resource limitations of recurrence 9 times (1,3,7,9)");
                System.out.println("Denominator reduced to: "   + denominatorToString.length() + " digits" + "("+denominatorToString+")"+ "inline with numerator");
                    numerator = Long.valueOf(numeratorToString);
                    denominator = Long.valueOf(denominatorToString);
                    System.out.println("Truncated numerator:   " + numerator);
                    System.out.println("Truncated numerator:   " + denominator);
                    }
                        
                    }
                    
                    
                    
                    
                    
                    
                    
                }
                
                
               else
                {
                    denominatorToString = String.valueOf(denominator);
                    numeratorToString = String.valueOf(numerator);
                    int differenceLength = Math.abs(numeratorToString.length() - denominatorToString.length());
                    int differenceNumeratorAndMaxLongPrecision = numeratorToString.length()-digitsAcceptedNumeratorLimit;
                    int differenceDenominatorAndMaxLongPrecision = denominatorToString.length()-digitsAcceptedNumeratorLimit;
                    String acceptedNumeratorLimitString=String.valueOf(acceptedNumeratorLimit);
                    
                    
                    //this should be easiest.
                    //we know truncation possible with no issues.
                    //it is important numerator reaches 9 digits
                    //and then mantain the gap
                    // I am hoping there will be a bit more flexible in length for the denominator
                    //if session gets killed..
                    //I can truncate more off numerator and denominator
                    //will see what happens
                    
                    if (numerator>acceptedNumeratorLimit && denominator>acceptedNumeratorLimit)
                    {
                        
                        digitsAcceptedNumeratorLimit = acceptedNumeratorLimitString.length();
                        
                        //we know this is the case because if denominator was multiplied by 10  (19 times), denominator would turn negative
                        
                        if (differenceLength==0)
                        {
                            System.out.println("9Numerator reduced from: " + numeratorToString.length() + " to " + digitsAcceptedNumeratorLimit + " digits");
                            numeratorToString=numeratorToString.substring(0,digitsAcceptedNumeratorLimit);
                            
                            System.out.println("10Denominator reduced from  " + denominatorToString.length() + " to " + (digitsAcceptedNumeratorLimit+1) + " digits:");
                            denominatorToString=denominatorToString.substring(0,digitsAcceptedNumeratorLimit+1);
                        }
                        
                        //these are accepted limits
                        //we also know that denominator can be
                        //one digit greater than numerator (as long as the multipliedBy doesn't equal 19)
                        //the other scenario is dealt with above if both same lengths (due to Java restriction)
                        
                        if (denominatorToString.length()!=(digitsAcceptedNumeratorLimit+1) && numeratorToString.length()!=digitsAcceptedNumeratorLimit && !singleDigitrecurring)
                        {
                       System.out.println("6Numerator reduced from: " + numeratorToString.length() + " to " + digitsAcceptedNumeratorLimit + " digits:");
                       numeratorToString=numeratorToString.substring(0,digitsAcceptedNumeratorLimit);
                        
                       //it will undertaken exact same count of digit truncation that the numerator has undertaken
                       System.out.println("7Denominator reduced from  " + denominatorToString.length() + " to " + (denominatorToString.length()-differenceNumeratorAndMaxLongPrecision) + " digits");
                       denominatorToString=denominatorToString.substring(0,(denominatorToString.length()-differenceNumeratorAndMaxLongPrecision));
                        }
                    } 
                    //numerator over and denominator under
                    if (numerator>acceptedNumeratorLimit &&  denominator<acceptedNumeratorLimit)
                    {
                        System.out.println("This is not possible on a decimal. PLEASE CHECK THE LOGIC OF THE CODE");
                   
                    }
                    
                   //this scenario not possible, it would suggest a mistake elsewhere in calculation
                   //can not have two digit difference between numerator and denominator based on original decimal
                    if (numerator<acceptedNumeratorLimit &&  denominator>acceptedNumeratorLimit)
                    
                    {
                        System.out.println("This is not possible on a decimal. PLEASE CHECK THE LOGIC OF THE CODE");
                    
                   }
                
                denominator = Long.valueOf(denominatorToString);
                System.out.println("Truncated denominator: " + denominator);
                numerator = Long.valueOf(numeratorToString);
                System.out.println("Truncated numerator:   " + numerator);
                
                
                firstDigitNumerator = numeratorToString.charAt(0); 
                    String regex="";
                    //here it can check truncated numerator
                    //it can get first digit
                    //and if it finds that pattern across the entire 9 
                    //digit numerator
                    //we know it will struggle performing a reduction
                    //since the GCF will be up to 9 digits long!
                    //if the digit is 0.333 (since 3333333 )
                    int count=0;
                    
                    if (numeratorToString.length()==9)
                    {
                        
                        //System.out.println("INSIDE!!!");
                        do
                        {
                            //System.out.println(firstDigitNumerator);
                            regex=regex + firstDigitNumerator;
                            
                            count++;
                            
                        }while(count<numeratorToString.length());
                    
                    
                    
                    regex = "["+regex+"]";
                    //System.out.println("REG: " + regex);
                    
            String regexCheck=regex;
            
            Pattern pattern = Pattern.compile(regexCheck, Pattern.CASE_INSENSITIVE);
            Matcher matcher = pattern.matcher(numeratorToString);
            
            //we know the effect is only going to be on these recurrence
            //since it will not perform reduction.
            
            //System.out.println("WHAT IS NUMERATOR: " + numeratorToString);
            //System.out.println("NUM: " + numerator);
            
            if (matcher.find() && (firstDigitNumerator=='1' || firstDigitNumerator=='3' || firstDigitNumerator=='7' || firstDigitNumerator=='9' ))
            {
                numeratorToString = numeratorToString.substring(0,numeratorToString.length()-1);
                denominatorToString = denominatorToString.substring(0,denominatorToString.length()-1);
                System.out.println("Numerator reduced to: " + numeratorToString.length() + " digits " + "("+numeratorToString+")"+" to mitigate resource limitations of recurrence 9 times (1,3,7,9)");
                System.out.println("Denominator reduced to: "   + denominatorToString.length() + " digits" + "("+denominatorToString+")"+ "inline with numerator");
            
                numerator = Long.valueOf(numeratorToString);
                denominator=Long.valueOf(denominatorToString);
            }    
                    }  
                }  //end of else
                    
            }
             
            //********NEW CODE IN THIS VERSION
            if (numerator>denominator)
            {
                maxGCF=denominator;
            }
            else
            {
                maxGCF = numerator;
            } 
        
            start();
                
            do
            {
                System.out.println("This is potential Greatest Common Factor" +"("+maxGCF+")"+" between " + "Numerator"+"("+numerator+")" + "  Denominator"+"("+denominator+")");
                //System.out.println(maxGCF);
                //System.out.println(minNum);
                //System.out.println("num: " + numerator);
                //System.out.println("den: " + denominator);
                
                if (numerator==1 || denominator==1)
                {
                    break;
                }
                
                for (divisor = 2; divisor<=maxGCF; divisor++)
                {
                    //System.out.println("This is divisor: " + divisor);
                    successReducedDenominator=false;
                    successReducedNumerator=false;
                    
                    if (divisor==(maxGCF) && (!successReducedNumerator || !successReducedDenominator))
                    {
                        exitWhileLoop=true;
                        break;
                    }
                    
                    //not best, since it is returning it will terminate...
                    if (reducedNumerator(numerator,divisor) && reducedDenominator(denominator,divisor))
                    {
                        
                        //gets initial length before the reduction process has occured
                        numeratorToString=String.valueOf(numerator);
                        denominatorToString=String.valueOf(denominator);
                        
                        long prevLengthNumerator = numeratorToString.length();
                        long prevLengthDenominator = denominatorToString.length();
                        String prevNumerator = numeratorToString;
                        String prevDenominator=denominatorToString;
                        Double prevDecimal = Double.parseDouble(prevNumerator)/Double.parseDouble(prevDenominator);
                        
                        long changeDigitsNumeratorReducing;
                        long changeDigitsDenominatorReducing;
                        long digitsZeroAppend=0;
                        
                        denominator = denominator/divisor;
                        numerator = numerator/divisor;
                        //System.out.println("CHECKING NUMERATOR (LENGTH):   " + numerator);
                        //System.out.println("CHECKING DENOMINATOR (LENGTH): " + denominator);
                        
                        double currentDecimal = (double)numerator/(double)denominator;
                        
                        
                        changeDigitsNumeratorReducing= prevLengthNumerator - String.valueOf(numerator).length();
                        System.out.println("Reduction numerator:   ("+prevNumerator+","+String.valueOf(numerator)+ " divisor: " + divisor+")");
                        changeDigitsDenominatorReducing= prevLengthDenominator - String.valueOf(denominator).length();
                        System.out.println("Reduction denominator: ("+prevDenominator+","+String.valueOf(denominator)+ " divisor: " + divisor+")");
                        
                        //TRIED BOTH OF THESE TECHNIQUE TO EITHER SHOW ON SCREEN OR SHOW CRITICAL REDUCTIONS
                        //BOTH CAUSING THE SESSION TO GET KILLED
                        System.out.println("Reduction in fraction and decimal: " + prevNumerator+"/"+prevDenominator + "("+prevDecimal+")" +" => " + numerator+"/"+denominator+"("+currentDecimal+")");
                        //sj1.add(prevNumerator.toString()+"/"+prevDenominator + "("+prevDecimal+")" + "=> " + numerator+"/"+denominator+"("+currentDecimal+")");
                        
                        
                        numeratorToString=String.valueOf(numerator);
                        denominatorToString=String.valueOf(denominator);
                        
                        divisor=1;
                    }
                    //System.out.println("Check1:" + divisor);
                }
                if (numerator>denominator)
                {
                    maxGCF=denominator;
                    maxNum=numerator;
                    minNum=denominator;
                }
                else
                {
                    maxGCF = numerator;
                    maxNum=denominator;
                    minNum=numerator;
                }
                
                
            }while(!exitWhileLoop);
            
            stop();
            
            
            System.out.println("Elapsed time in seconds to reduce fraction: " + getElapsedTimeInSeconds());
            System.out.println("reduced numerator:   " + numerator);
            System.out.println("reduced denominator: " + denominator);
            System.out.println(sj1.toString());
            
            sj1=new StringJoiner(",");
            posTestOneFraction=0;
            StringTokenizer st1 = new StringTokenizer (testOne[1], ",");
    
            while (st1.hasMoreTokens())
            {
                temp= st1.nextToken().toString();
                posTestOneFraction++;
            
                if (posTestOneDecimal==posTestOneFraction)
                {
                    System.out.println("Fraction presented is: " + temp );
                
                    if (temp.indexOf('-')!=-1)
                    {
                        numeratorOriginal = temp.substring((temp.indexOf('-')+1), temp.indexOf('/'));
                        denominatorOriginal = temp.substring(temp.indexOf('/')+1);
                    }
                    if (temp.indexOf('-')==-1)
                    {
                        numeratorOriginal = temp.substring(0,temp.indexOf('/'));
                        denominatorOriginal = temp.substring(temp.indexOf('/')+1);
                    }
                    long decimalOriginalLong = Long.valueOf(denominatorOriginal);
                    numeratorOriginalLong = Long.valueOf(numeratorOriginal);
                    denominatorOriginalLong=Long.valueOf(denominatorOriginal);
                    double result = 0;
                    String properEntireOriginalFraction="";
                    String originalFraction=temp;
                    long remainingNumerator=0;
                    
                    try
                    {
                        wholeNumberBeforeFraction = temp.substring(0,temp.indexOf("-"));
                        //System.out.println("Var: " + wholeNumberBeforeFraction);
                        wholeNumberBeforeFractionLong = Long.valueOf(wholeNumberBeforeFraction);
                        System.out.println("Whole number before fraction: " + wholeNumberBeforeFractionLong);
                    }
                    catch (StringIndexOutOfBoundsException e)
                    {
                        System.out.println("No whole number before fraction");
                    }
                    if (decimalOriginalLong<numeratorOriginalLong)
                    {
                        denominatorIntoNumerator = Long.valueOf(numeratorOriginal)/Long.valueOf(denominatorOriginal);
                        System.out.println("Original whole number from fraction (numerator/denominator):" + denominatorIntoNumerator);
                 
                        remainingNumerator = Long.valueOf(numeratorOriginal) - (Long.valueOf(denominatorOriginal) * denominatorIntoNumerator);
                        System.out.println("remaining numerator: " + remainingNumerator);
                 
                        remainingFraction = remainingNumerator + "/" + denominatorOriginal;
                        System.out.println("remaining fraction: " + remainingFraction);
                        System.out.println("Fraction provided in challenge is improper: " + temp);
                        originalFraction = temp;
                 
                        temp=remainingFraction;
                        numeratorOriginal = temp;
properEntireOriginalFraction = ((denominatorIntoNumerator+wholeNumberBeforeFractionLong) + "-" +remainingFraction);

                       
                        System.out.println("Mixed number fraction is: " + properEntireOriginalFraction);
                        
                        if (!String.valueOf(denominatorIntoNumerator+wholeNumberBeforeFractionLong).equals(wholeNumberPortionDecimal))
                        {
                            System.out.println("***Mismatch in whole numbers****");
                            System.out.println("Mixed number fraction has following whole number:" + (denominatorIntoNumerator+wholeNumberBeforeFractionLong));
                            System.out.println("Original decimal has following whole number:" + wholeNumberPortionDecimal);
                            System.out.println("***********");
                        }
                        else
                        {
                            System.out.println("1Mixed number fraction" +"("+(wholeNumberBeforeFractionLong+denominatorIntoNumerator)+")" +  " and original decimal" +"("+wholeNumberPortionDecimal+")" + " have same whole number");
                        }
                        
                        improperFraction=true; 
                    }
                    if (!improperFraction)
                    {
                        if (Long.valueOf(wholeNumberPortionDecimal)!=0 && wholeNumberBeforeFractionLong!=0)
                        {
                            if (!String.valueOf(wholeNumberBeforeFractionLong).equals(wholeNumberPortionDecimal))
                            {
                                System.out.println("***2Mismatch in whole numbers****");
                                System.out.println("Mixed number fraction has following whole number:" + (wholeNumberBeforeFractionLong));
                                System.out.println("Original decimal has following whole number:" + wholeNumberPortionDecimal);
                                System.out.println("***********");
                            }
                            else
                            {
                                System.out.println("3Mixed number fraction" +"("+(wholeNumberBeforeFractionLong)+")" +  " and original decimal" +"("+wholeNumberPortionDecimal+")" + " have same whole number");
                            }
                            
                        }
                    }
                    
if (numeratorOriginal.equals(String.valueOf(numerator)) && denominatorOriginal.equals(String.valueOf(denominator)))
                    {
                        System.out.println("fraction provided in challenge is fully reduced: " + temp);
System.out.println("Original fraction" + "("+temp+")" + " provided is exact representation of the initial decimal conversion: " + decimalOriginal);
                    }
                    else
                    {
                        System.out.println("2Fraction provided in challenge: " + temp + " might not be correctly reduced " + "("+numerator+"/"+denominator+")");
                        
                        if (improperFraction)
                        {
                            result = (double)remainingNumerator/Double.valueOf(denominatorOriginal);
                            System.out.println("1Original fraction"+"("+originalFraction+")" + "has been changed to mixed number fraction"+"("+properEntireOriginalFraction+")");
                          
                            if (!singleDigitrecurring)
                            {
                                System.out.println("Remaining fraction is: " + remainingFraction + " is non- representation of the initial decimal conversion: " + "0"+decimalPortionOriginal);
System.out.println("1Remaining fraction " + remainingFraction + " in decimal is " + result + " and NOT:" + "0"+ decimalPortionOriginal +"(original)");
                            }
                            double dec = (double)numerator/(double)denominator;
                            double numeratorDouble = Double.parseDouble(remainingFraction.substring(0,remainingFraction.indexOf("/")));
                            double denominatorDouble = Double.parseDouble(remainingFraction.substring(remainingFraction.indexOf("/")+1));
                            
                            try
                            {
                                result= numeratorDouble/denominatorDouble;
                            }
                            catch (ArithmeticException e)
                            {
                                result = dec;
                            }
                        }
                        else
                        {
                            result= Double.parseDouble(numeratorOriginal)/Double.parseDouble(denominatorOriginal);
                            
                            //System.out.println("res:" + result);
                            //long tempLong = Long.valueOf(temp);
                           
                            String fractionalPartionWithDecimalString = "0"+fractionalPartionWithDecimal;
                            
                            double hh = Math.abs(result -  Double.parseDouble(fractionalPartionWithDecimalString)); 
                            
                            //System.out.println("IN HERE!!!: " + Double.parseDouble(fractionalPartionWithDecimalString));
                            //long fractionalPartionWithDecimalLong = Long.valueOf(fractionalPartionWithDecimalString);
                            
                            //System.out.println(fractionalPartionWithDecimal);    
                            System.out.println("This is the difference"+"("+hh+")"+ " between original"+"("+fractionalPartionWithDecimalString+")" +  " decimal and associated original" + "("+result+")" +" fraction");
                            
                            //issue here, therefore chosen remove loop
                            //if (hh>0.0002000000000000)
                            //{
                                
System.out.println("2Original fraction provided " + temp + " is non- representation of the initial decimal conversion: " + "0"+fractionalPartionWithDecimal);
                            //}
                   
                        }
                        improperFraction=false;
                    }
                }
            }
            terminatingDecimal(denominator, numerator,decimalOriginal);
        }
    }
    
    public RepeatDecimalFractions(String[] testOne, long acceptedNumeratorLimit, int limitPrecision, long primeNumberCheckLimit)
    {
        this.acceptedNumeratorLimit=acceptedNumeratorLimit;
        this.testOne=testOne;
        this.limitPrecision=limitPrecision;
        this.primeNumberCheckLimit = primeNumberCheckLimit;
        fraction(testOne);
    }
}

public class Main
{
    public static void main(String[] args) 
    {
        String[] testOne = new String[2];
      
       testOne[0]="0.222222222222228777, 0.777777777777778777,0.7450000025999994,3.1425,0.6,1.1,6.1,6.1,0.192367,0.10973,0.343,0.01100550275137568784,0.242424,0.1875325,0.5,1.25,0.0123,0.0001,0.999,0.15,0.86,10.4,23.5,0.75,0.1111111111111111111,0.1111111111111111111,0.33533,5.1111111111111111111,5.1111111111111111111,7.1111111111111111111,7.1111111111111111111";
       testOne[1]="1-222/100,987000200/100000020,22/7,2/3,10/9,10/9,1-3/9,5343/27775,823/7500,1/3,22/1999,30303/125000,75013/400000,1/2,1-1/4,123/10000,1/10000,999/1000,15/100,86/100,10-2/5,23-1/2,3/4,3/27,1/9,33533/100000,4-64/9,64/9,64/9,7-1/9";
        //testOne[0]="3.1425";
        //testOne[1]="22/7";
        
        //NOW FUNCTIONS
        // 0.7777777777777787777  this is constantly timing out even upon reducing acceptedNumeratorLimit
        //1-777/100   reduced from test cases
        
        long primeNumberCheckLimit = 5;
        //long acceptedNumeratorLimit=999999999;
        long acceptedNumeratorLimit=999;
        final int limitPrecision=19;
        
        
        System.out.println("********Welcome to Online IDE!! Happy Coding :)**********");
        System.out.println("NOTE: Precision is limited to " + limitPrecision + " digits wide...");
        System.out.println("NOTE: Any decimal with recurring single digit" + "("+ limitPrecision +" times)" + " will be assumed to be periodic number");
        System.out.println("NOTE: Since computational issues, reduction on decimal component EXCEEDING " + acceptedNumeratorLimit + "(9 digits) will lose its precision by 1 or more digit depending on the decimal.");
        System.out.println("NOTE: Value of acceptedNumeratorLimit = " + acceptedNumeratorLimit+ "("+String.valueOf(acceptedNumeratorLimit).length() + ") digits. This can be changed to speed up most reduced form calculations");
        System.out.println("NOTE: Also to AVOID any Session kills or hanging");
        System.out.println("To create sample of decimals and fractions, original numerator will be divided  numerator/prime number from: " + 2 + " => " + primeNumberCheckLimit);
        System.out.println("DENOMINATOR AND NUMERATOR WILL BOTH BE TRUNCATED INLINE WITH INTEGRITY ORIGINAL INPUTS");
        System.out.println("******************");
        
        RepeatDecimalFractions rdf = new RepeatDecimalFractions(testOne,acceptedNumeratorLimit,limitPrecision,primeNumberCheckLimit);
    }
}