Exemple #1
0
        /// <summary>
        /// The main method that is called outside this class that will solve the puzzle
        /// and return the answer
        /// </summary>
        /// <returns>The answer to the puzzle</returns>
        public int solvePuzzle()
        {
            // load the data from the PuzzleData.txt
            string puzzleData = this.LoadPuzzleDataIntoMemory();

            // create an instance of compiler that will run the code
            Compiler.Compiler compiler = new Compiler.Compiler();

            // covert the text file into a list of instcutions the compiler will understand
            compiler.parseInstructions(puzzleData);
            // run the program until completion or an invinat loop is dectected
            compiler.run();

            // get the accumulator value which is the answer to the puzzle
            return(compiler.accumulatorValue);
        }
Exemple #2
0
        /// <summary>
        /// The main method that is called outside this class that will solve the puzzle
        /// and return the answer
        /// </summary>
        /// <returns>The answer to the puzzle</returns>
        public int solvePuzzle()
        {
            // load the data from the PuzzleData.txt
            string puzzleData = this.LoadPuzzleDataIntoMemory();

            // create an instance of compiler that will run the code
            Compiler.Compiler compiler = new Compiler.Compiler();

            // covert the text file into a list of instcutions the compiler will understand
            compiler.parseInstructions(puzzleData);

            // go through the instructions when we come accross a jump or no operation change
            // the code and then run it to see if the program executes correctly.
            // once we find a sequence where the code executes correctly, return that executions
            // acccumilators value as the answer to the puzzle
            int accumulatorValue = this.findCorrectCompilerSequence(compiler.ListOfInstructionsToRun);


            // the answer to part 2 of the puzzle
            return(accumulatorValue);
        }
Exemple #3
0
        /// <summary>
        /// The passed in instructions has infinat loop in its exection.
        /// This function alter the instructions to find the correct sequence
        /// which allows the code to run to completion
        /// </summary>
        /// <param name="originalInstructions">the instructions that when run cause an infant loop</param>
        /// <returns>the accumulator value on the execution of code that runs the correct instructions or int.MinValue if there was a problem</returns>
        private int findCorrectCompilerSequence(List <Compiler.Instruction> originalInstructions)
        {
            // create an instance of the compiler which will run the code
            Compiler.Compiler compiler = new Compiler.Compiler();

            // go through each instruction
            for (int eachInstructionIndex = 0; eachInstructionIndex < originalInstructions.Count; eachInstructionIndex++)
            {
                // when we find a jump or No OPeration instruction, swop them around and rerun the code.
                // if the code executes without terminating because of infant loop, we have found
                // the sequence of instructions that should be executed

                // get the current instruction
                Compiler.Instruction currentInstruction = originalInstructions[eachInstructionIndex];

                // check to see if this is a nump or NoOPeration instruction.
                // we don't care about any other kind of instruction, so just
                // carry onto the next loop if we don't find one.
                switch (currentInstruction.instructionType)
                {
                // we found a jump instruction
                case Compiler.InstrcutionType.Jump:



                    // if the instructions have previusly been ran, there currentInstruction.instructionCounter will not be zero which
                    // will effect the exectuion of the program and most likely make the program terminate
                    // because it thinks an infinant loop has been detected.
                    // So reset all instruction counters to zero
                    this.resetInstructionCounterOnInstructionList(originalInstructions);

                    // change the current instruction from a jump to a no operation
                    currentInstruction.instructionType = Compiler.InstrcutionType.NoOPeration;
                    // reset the compiler so its ready to run a new sequence of instructions
                    compiler.resetCompiler();
                    // give the compiler the new instructions
                    compiler.setInstructions(originalInstructions);
                    // run the new sequence
                    compiler.run();

                    // check to see if the program terminated sucsesfully or it terminated because
                    // of an infant loop
                    if (compiler.reasonProgramFinished == Compiler.ReasonProgramFinished.ProgramCompleted)
                    {    // we have found the correct instructions for the program to run
                         // no need to carry on doing any more checks

                        // return from this function with accumulator value for the sequence we just ran
                        return(compiler.accumulatorValue);
                    }
                    else
                    {    // program did not execute sucsesfully so this sequnce of instructions is wrong
                        // reset the instruction back to its original instruction and move
                        // onto the next instruction int he loop
                        currentInstruction.instructionType = Compiler.InstrcutionType.Jump;
                    }

                    break;

                // we found a No Operation instruction
                case Compiler.InstrcutionType.NoOPeration:

                    // if the instructions have previusly been ran, there currentInstruction.instructionCounter will not be zero which
                    // will effect the exectuion of the program and most likely make the program terminate
                    // because it thinks an infinant loop has been detected.
                    // So reset all instruction counters to zero
                    this.resetInstructionCounterOnInstructionList(originalInstructions);

                    // change the current instruction from a no operation to a jump instruction
                    currentInstruction.instructionType = Compiler.InstrcutionType.Jump;
                    // reset the compiler so its ready to run a new sequence of instructions
                    compiler.resetCompiler();
                    // give the compiler the new instructions
                    compiler.setInstructions(originalInstructions);
                    // run the new sequence
                    compiler.run();

                    // check to see if the program terminated sucsesfully or it terminated because
                    // of an infant loop
                    if (compiler.reasonProgramFinished == Compiler.ReasonProgramFinished.ProgramCompleted)
                    {    // we have found the correct instructions for the program to run
                         // no need to carry on doing any more checks

                        // return from this function with accumulator value for the sequence we just ran
                        return(compiler.accumulatorValue);
                    }
                    else
                    {    // program did not execute sucsesfully so this sequnce of instructions is wrong
                        // reset the instruction back to its original instruction and move
                        // onto the next instruction int he loop
                        currentInstruction.instructionType = Compiler.InstrcutionType.NoOPeration;
                    }


                    break;
                }
            }
            // this should never be hit but if it is, there is a problem
            return(int.MinValue);
        }