/* Online Java - IDE, Code Editor, Compiler Online Java is a quick and easy tool that helps you to build, compile, test your programs online. */ //VERSION 4 //return statements again bizarrely do not stop execution. //Also removed system.exit(0) and set flag to control code flow. //This code takes logical concepts from Version1 and Version2 //But its improvement from version 3 since it removes the consecutiveNines aspect //but is still subject to shorter width numbers //In VERSION1 and VERSION2, accessing number1 and number2 with substring //In this example remainingPortionFirstNumber = Long.toString(number1); //so it is not sufficient to use int since it will limit length of the number. //also this is more closer to the first principles used in addition //the code is much more tider, better variable names //So I will explain most logic at variable declaration. //using same test casee. //Most importantly, it is 100% recursion based. //I had to force it back into consecutiveNines loop by configuring a flag here.. //I envisage I need to incorporate this into Version1 and Version2 to ensure //it removes iteration... and also remove do while loop public class Main { //these variables manage the StopClock static long startTime; static long endTime; static boolean running; static long elapsed; static long lastDigitNumber; //this performs %10 on remainingPortion static long remainingPortionLong; static long rightDigitTruncatedRemainingPortionLong; // this is the (initial number /10) to remove lastDigitNumber static String remainingPortion; static String remainingPortionFirstNumberString; static String remainingPortionSecondNumberString; static boolean finishedUniformMSD; //it has finished addition of the most MSD //common at same position on number1 and number2 //once it has determined grandTotal (remainingPortion is empty) static boolean finishedExecution; //either 1 or 0 as in real world static long carryForward; //total of the digits static long total; //flag to identify if consecutive nines //it affects how the numbers are changed 9=>0 (carryForward=1) //or 9=>9 (no carryForward) //or 9=>10 (if MSD and carryForward=1) static boolean consecutiveNines=false; //remainingPortionFirstNumber or remainingPortionSecondNumber //are changed to this variable //once either remainingPortionSecondNumber==0 //or remainingPortionFirstNumber==0 //i.e it is processing the left non uniform MSD //For instance the remainingPortionFirstNumber= 7 is assigned to number //76 number1 //+8 number2 static String number; static String grandTotal=""; // as you would expect to see in equals //section when performing calculation // 556 // +733 // ------ // 1289 // ------ //it keeps backupTotal since it might have filled grandTotal //above such as 289 (taking lastDigitTotal=2) //and expecting another.. But if there is not another number, //it has to store the backupTotaltotal = 12 to give 1289 static String backupTotal; //likewise it stores backupGrandTotal since above grandTotal //would be 289 and if it realises //remainingPortionFirstNumber and remainingPortionSecondNumber are 0 //it would attempt grandTotal = total + grandTotal = 12289 //instead it has to re-instate backupGrandTotal = 89 //perform grandTotal= String.valueOf(backupTotal) + backupGrandTotal = 12 89 static String backupGrandTotal; //it starts as Long conversion from String number1/number2 //progressively gets smaller static long remainingPortionFirstNumber; static long remainingPortionSecondNumber; //this will be %10 of their respective remainingPortionXXXX static long lastDigitFirstNumber; static long lastDigitSecondNumber; //total always two digits wide. This will get least MSD (total%10) static long lastDigitTotal; //logic generated via AI. //used for stop clock function public static void start() { Main.startTime = System.nanoTime(); Main.running = true; } public static void stop() { Main.endTime = System.nanoTime(); Main.running = false; } public static long getElapsedTime() { if (running) { elapsed = System.nanoTime() - startTime; } else { elapsed = endTime - startTime; } return elapsed; } public static double getElapsedTimeInSeconds() { return getElapsedTime() / 1_000_000_000.0; } public static void main(String[] args) { System.out.println("Welcome to Online IDE!! Happy Coding :)"); //extensive test cases. //All tested with flag finishedExecution in code //also used return statements (fail to function) //removed system.exit(0); //I have now marked only final test 1-14 in my code.. //so it would be interesting to see if there is a reduction in my test cases //***PASS**** - 100*** via final test 0,1,3,4,7,8,9,10,11,17,18,21 (v3a) //***PASS**** - 100*** via final test 0,1,3,4,7,8,9,10,11,14, (v4) //String number2="99"; //String number1= "1"; //***PASS**1764*** via final test 0,1,2,3,4,5,6 (v3a) //***PASS**1764*** via final test 0,1,3,4,5,6 (v4) //String number2="993"; //String number1="771"; //***PASS**1764*** via final test via final test 0,1,2,3,4,5,6 (v3a) //***PASS**1764*** via final test via final test 0,1,3,5,6 (v4) //String number2="243"; //String number1="541"; //PASS*****160****** - via final test 0,1,3,4,5,7,8,9,14,21 (v3a) //PASS*****160****** - via final test 0,1,3,4,5,7,8,9,10,11,14 (v4) //String number2 = "136"; //String number1 = "24"; //PASS******846370032454542****** via final test 0,3,4,7,8,9,10,12,13,17,18,21 (v3a) //PASS******846370032454542****** via final test 0,3,4,7,8,9,12,13,14 (v4) //String number2 = "846369999999999"; //String number1 = "32454543"; //PASS****82160**** via final test 0,1,3,4,5,7,8,9,14,15,21 (v3a) //PASS****82160**** via final test 0,1,3,4,5,7,8,9,10,12,14 (v4) //String number2 = "81636"; //String number1 = "524"; //PASS******* - 400219 via final test 0,1,3,4,5,7,8,9,10,11,12,17,18,21 (v3a) //PASS****82160**** via final test 0,1,3,4,5,7,8,9,10,11,13,14 (v4) //String number2 = "399627"; //String number1 = "592"; //pass********* - 400019 via final test 0,1,3,4,5,7,8,9,10,11,12,17,18,21 (v3a) //pass********* - 400019 via final test 0,1,3,4,5,7,8,9,10,11,13,14 (v4) //String number2 = "399947"; //String number1 = "72"; //PASS***4962****** getting via final test 0,1,3,4,5,7,8,9,14,21 (v3a) //PASS***4962****** getting via final test 0,1,3,4,5,7,8,9,10,11,14 (v4) //String number2 = "3970"; //String number1 = "992"; //PASS****** 562 via final test 0,1,2,3,4,5,6 (v3a) //PASS****** 562 via final test 0,1,3,4,5,6 (v4) //String number1 = "370"; //String number2 = "192"; //PASS**** - 1000 via final test 0,1,4,7,8,9,10,11,12,21 (v3a) //PASS**** - 1000 via final test 0,1,3,4,7,8,9,10,11,13,14 (v4) //String number2 = "999"; //String number1 = "1"; //PASS***** 1998 via final test //PASS***** 1998 via final test 0,1,3,4,6 (v4) //String number1 = "999"; //String number2 = "999"; //PASS ******* 1098 via final test 0,2,3,4,7,8,9,10,11,17,18,21 (v3) //PASS ******* 1098 via final test 0,2,3,4,7,8,9,10,11,13,14 (v4) //String number1 = "999"; //String number2 = "99"; //***PASS***108 via final test 0,2,3,4,7,8,9,10,11,18,19,21 (v3a) //***PASS***108 via final test 0,2,3,4,7,8,9,10,11,13,14 (v4) //String number1 = "99"; //String number2 = "9"; //***PASS**** 1400019 via final test 0,1,3,4,5,7,8,9,10,12,13,21 (v3a) //***PASS**** 1400019 via final test 0,1,3,4,5,7,8,9,10,12,13,14 (v4) //String number2 = "1399947"; //String number1 = "72"; //***PASS****5210*** via final test 0,1,3,4,7,8,9,14,21 (v3a) //***PASS****5210*** via final test 0,1,3,4,7,8,9,11,14, (v4) //String number2 = "4666"; //String number1 = "544"; //***PASS***711**** via final test 0,1,3,4,7,8,9,14,21 (v3a) //***PASS****5210*** via final test 0,1,3,4,7,8,9,10,11,14 (v4) //String number2 = "652"; //String number1 = "59"; //PASS****1390219 ***** via final test 0,3,4,5,7,8,9,10,12,13,17,18,21 (v3a) //PASS****1390219 ***** via final test 0,3,4,5,7,8,9,10,12,13,14 (v4) //String number2 = "1389627"; //String number1 = "592"; //PASS***********22023**** via final test 0,2,3,4,7,8,9,10,12,13,17,18,21 (v3a) //PASS***********22023**** via final test 0,2,3,4,7,8.9,10,12,13,14 (v4) //String number1 = "21999"; //String number2 = "24"; //PASS****2******* via final test 0,1,2,3,5,6 (v3a) //PASS****2******* via final test 0,1,3,5,6 (v4) //String number1 = "1"; //String number2 = "1"; //PASS***10******** via final test 0,1,2,4,6 (v3a) //PASS***10******** via final test 0,1,3,4,6 (v4) //String number1 = "1"; //String number2 = "9"; //PASS***95759******** via final test 0,2,3,5 (v3a) //PASS***95759******** via final test 0,2,3,5,7,8,9,10,12,14 (v4) //String number1 = "95427"; //String number2 = "332"; //PASS*****9719****** via final test 0,2,3,4,5,7,8,9,14,15,21 (v3a) //PASS*****9719****** via final test 0,2,3,4,5,7,8,9,10,12,14 (v4) //String number1 = "9647"; //String number2 = "72"; //PASS****100119******* via final test 0,2,3,4,5,7,8,9,10,11,12,17,18,21 (v3a) //PASS****100119******* via final test 0,2,3,4,5,7,8,9,10,13,14 (v4) //String number1 = "99647"; //String number2 = "472"; //**PASS** 10009 via final test 0,2,3,4,5,7,8,9,10,11,12,17,18,21 (v3a) //**PASS** 10009 via final test 0,2,3,4,5,7,8,9,10,11,13,14 (v4) //String number1 ="9947"; //String number2 = "62"; //PASS via final test 0,2,3,4,7,8,9,10,12,13,17,18,21 (v3a) //PASS via final test 0,2,3,4,7,8,9,10,12,14 (v4) //***PASS 22023 //String number1 = "21999"; //String number2 = "24"; //***PASS***108 via final test 0,2,3,4,7,8,9,10,11,18,19,21 (v3a) //***PASS***108 via final test 0,2,3,4,7,8,9,10,11,13,14 (v4) //String number1 = "99"; //String number2 = "9"; //PASS getting 1000 via final test 0,2,3,4,7,8,9,10,11,12,17,18,21 (v3a) //PASS getting 1000 via final test 0,2,3,4,7,8,9,10,11,13,14 (v4) //String number1 = "999"; //String number2 = "1"; //PASS via final test 0,2,3,5,7,8,9,14,15,21 (v3a) //PASS via final test 0,2,3,5,7,8,9,10,12,14 (v4) //String number1 = "888"; //String number2 = "1"; //FAIL NumberFormatException remainingPortionFirstNumber=Long.valueOf(number1); //String number1 = "99999999999999999999999999999999999999999999999999999999"; //String number2 = "32423543534543532423432423432494355443534532235324324333"; //shortened the numbers same outcome //FAIL NumberFormatException remainingPortionFirstNumber=Long.valueOf(number1); //String number1 = "99999999999999999999999999999999999"; //String number2 = "32423543534543532"; //shortened the numbers same outcome //FAIL NumberFormatException remainingPortionFirstNumber=Long.valueOf(number1); //String number1 = "321326263232722172323121232212212212"; //String number2 = "32423543534543531"; //shortened the numbers, any longer than this and program will render not //FAIL NumberFormatException remainingPortionFirstNumber=Long.valueOf(number1); //***PASS*** 1845561698584545666 via final test 0,1,2,3,4,5,6 (v3a) //***PASS*** 1845561698584545666 via final test 0,1,3,4,5,6 (v4) //String number1 = "921326263239897898"; //String number2 = "924235435344647768"; //**************INTRODUCING FEW EXTRA TEST CASES //***PASS 1000000 via final test 0,2,3,4,7,8,9,10,11,12,17,18,21 (v3a) //***PASS 1000000 via final test 0,2,3,4,7,8,9,10,13,14, (v3a) //String number1 = "999999"; //String number2 = "1"; //****PASS 10001424201998*** via final test 0,2,3,4,5,7,8,9,11,12,17,18,21 (v3a) //****PASS 10001424201998*** via final test 0,2,3,4,5,7,8,9,10,11,13,14 (v4) //String number1 = "9999990767676"; //String number2 = "1433434322"; //****PASS giving 9999990767677*** NOW FIXED via final test 0,2,3,5,7,8,9,14,15,21 (v3a) //****PASS giving 9999990767677*** NOW FIXED via final test 0,2,3,5,7,8,9,10,12,14 (v4) //similar issues below previously //String number1 = "9999990767676"; //String number2 = "1"; //****PASS giving 7899990767677*** NOW FIXED via final test 0,2,3,5,7,8,9,14,15,21 (v3a) //****PASS giving 7899990767677*** NOW FIXED via final test 0,2,3,5,7,8,9,10,12,14 (v4) //String number1 = "7899990767676"; //String number2 = "1"; //PASS ***78990767677**** via final test 0,2,3,5,7,8,9,14,15,21 (v3a) //PASS ***78990767677**** via final test 0,2,3,5,7,8,9,10,12,14 (v4) //String number1 = "78990767676"; //String number2 = "1"; //****PASS giving 97653*** via final test 0,2,5,7,8,9,14,15,21 (v3a) //****PASS giving 97653*** via final test 0,2,3,5,7,8,9,10,12,14 (v4) //String number1 = "97652"; //String number2 = "1"; //starts the clock start(); System.out.println(number1 + "+" + number2 + "= " + addition(number, number1, number2)); System.out.println(number1 + "+" + number2 + "= " + grandTotal); //stops the clock stop(); System.out.println("Elapsed time in seconds: " + getElapsedTimeInSeconds()); } public static String addition (String number, String number1, String number2) { System.out.println("final test 0"); remainingPortionFirstNumber=Long.valueOf(number1); remainingPortionFirstNumberString = String.valueOf(remainingPortionFirstNumber); remainingPortionSecondNumber=Long.valueOf(number2); remainingPortionSecondNumberString = String.valueOf(remainingPortionSecondNumber); //it assumes there are more //MSD available in remainingPortionSecondNumber //so remainingPortion gets value of remainingPortionSecondNumber //the generic variable number is also now value of number2 if (remainingPortionFirstNumber==0 && !finishedUniformMSD) { System.out.println("final test 1"); System.out.println("FORCE 1"); //generic variables are set on remaining part of number2 remainingPortion=remainingPortionSecondNumberString; number=number2; //it assigns the other number to give correct logic finishedUniformMSD = true; } //it assumes there are more //MSD available in remainingPortionFirstNumber //so remainingPortion gets value of remainingPortionFirstNumber //the generic variable number is also now value of number1 if (remainingPortionSecondNumber==0 && !finishedUniformMSD) { System.out.println("final test 2"); System.out.println("FORCE "); remainingPortion=remainingPortionFirstNumberString; number=number1; //it assigns the other number to give correct logic finishedUniformMSD = true; System.out.println("WHAT ISP: " + remainingPortionFirstNumberString); System.out.println(grandTotal); } //Note in practice both varies can be 0. //above if useful until situation arises (i.e from point finishedUniformMSD=true) //to remainingPortionFirstNumber && remainingPortionSecondNumber = 0 (last calculation) //in meantime it is focussing on getting to the finishedUniformMSD, hence code below. //it starts calculation MSD<=LSD if (!finishedUniformMSD) { System.out.println("final test 3"); System.out.println("this is when the code flows"); System.out.println(remainingPortionFirstNumberString); System.out.println(remainingPortionSecondNumberString); lastDigitFirstNumber = remainingPortionFirstNumber%10; System.out.println("This is last digit first number: " +lastDigitFirstNumber); lastDigitSecondNumber = remainingPortionSecondNumber%10; System.out.println("This is last digit first number: " +lastDigitSecondNumber); //adds digits naturally //this is my first addition. It is not violated anything in the challenge //Since this is only technique to perform calculation. Challenge is not asking //re-invent addition operator. total = lastDigitFirstNumber + lastDigitSecondNumber; System.out.println(lastDigitFirstNumber + "+" + lastDigitSecondNumber + "="+total); System.out.println("GRAND SO FAR1: " + grandTotal); System.out.println(total); //moves across one digit like in real life addition. //equivalent to discarding last digit remainingPortionFirstNumber = remainingPortionFirstNumber/10; remainingPortionSecondNumber=remainingPortionSecondNumber/10; remainingPortionFirstNumberString=Long.toString(remainingPortionFirstNumber); remainingPortionSecondNumberString=Long.toString(remainingPortionSecondNumber); //ie if total+carryForward is 10-18 and not finishedExecution if (total+carryForward>=10 && !finishedExecution) { System.out.println("final test 4"); System.out.println("OVER"); System.out.println("WHAT IS LAST DIGIT TOTAL: " + lastDigitTotal); //keeps backup as explained in variable declaration area backupTotal=Long.toString(total+carryForward); backupGrandTotal = grandTotal; //stores the total + carryForward //note for first execution, carryForward it inherits is 0 total = total + carryForward; //as real life, it uses the 2nd digit to store in grandTotal lastDigitTotal = total%10; //it is lastDigitTotal stored as MSD each time grandTotal = lastDigitTotal + grandTotal; //carryForward set since total = 10+ carryForward=1; System.out.println("***GRAND SO FAR: " + grandTotal); System.out.println("backup GRAND SO FAR: " + backupGrandTotal); System.out.println("backup total SO FAR: " + backupTotal); //recursive call again. //Note variable number is not in any other logic until //finishedUniformMSD=true; addition(number, remainingPortionFirstNumberString, remainingPortionSecondNumberString); } //end of if total 10-18 //total + carryForward <10 if (total+carryForward<10 && !finishedExecution) { System.out.println("final test 5"); System.out.println("UNDER"); backupTotal=Long.toString(total+carryForward); backupGrandTotal = grandTotal; total= total + carryForward; lastDigitTotal = total%10; System.out.println("WHAT IS TOTAL:"); grandTotal = lastDigitTotal + grandTotal; carryForward=0; System.out.println("GRAND SO FAR: " + grandTotal); System.out.println("backup GRAND SO FAR: " + backupGrandTotal); System.out.println("backup total SO FAR: " + backupTotal); addition(number, remainingPortionFirstNumberString, remainingPortionSecondNumberString); } //end if total +carryForward<10 } //end of if (!finishedUniformMSD) //System.out.println("NOT HERE1"); //means both numbers were uniform length and reached MSD //it has to rely on the backup variables. //see explanation in declaration if (remainingPortionFirstNumber==0 && remainingPortionSecondNumber==0) { System.out.println("final test 6"); System.out.println("backuptotal: " + backupTotal); System.out.println("backupGrandTotal: " + backupGrandTotal); System.out.println("grandTotal: " + grandTotal); grandTotal= String.valueOf(backupTotal) + backupGrandTotal; System.out.println("uniform numbers finished execution: grandtotal: " + grandTotal); finishedExecution=true; //System.exit(0); return grandTotal; } //this can be only option when one of the numbers most MSD is not equal to 0 //hence it completes extra logic //just to clarify if it reached grandTotal below 412 // + 26 // ------ // 38 // ------ //the remainingPortionSecondNumber is still 41/10 = 4 //whereas remainingPortionFirstNumber is 2%10 = 0 //hence loop below is applicable else { System.out.println("final test 7"); System.out.println("NOT HERE2"); if (!finishedExecution) { System.out.println("final test 8"); //this deals with the non-uniform aspect, until then, it continues normally. //this loop might be an overhead to performance, it can be removed potentially //since we know that the flag above finishedExecution would be true if //below remainingPortionFirstNumber && remainingPortionSecondNumber were 0 if (remainingPortionFirstNumber%10 == 0 || remainingPortionSecondNumber==0) { System.out.println("final test 9"); //rest processing of interest is from number, which obtained value above. remainingPortion = number; remainingPortionLong = Long.valueOf(remainingPortion); lastDigitNumber = remainingPortionLong%10; System.out.println("remain:"+ remainingPortion); System.out.println("last: " + lastDigitNumber); System.out.println(carryForward); System.out.println("GT:" + grandTotal); //easiest - done //so 784308 // + 51 = 784359 if (lastDigitNumber+carryForward<10 && !finishedExecution) //lastdigit = 3 { System.out.println("final test 10"); System.out.println("ldn: " + lastDigitNumber); total = lastDigitNumber + carryForward; System.out.println(lastDigitNumber + "+" + carryForward); grandTotal = Long.toString(total) + grandTotal; System.out.println("grad: " + grandTotal); remainingPortionLong = Long.valueOf(remainingPortion); rightDigitTruncatedRemainingPortionLong =remainingPortionLong/10; remainingPortion=String.valueOf(rightDigitTruncatedRemainingPortionLong); System.out.println("current remaining check: " + remainingPortion); //it is here because nothing is carried forward //lastDigitNumber+carryForward<10, so it can drop remainingPortion if (remainingPortion==null) { System.out.println("final test 11"); System.out.println("FINISHED CALC"); finishedExecution=true; } if (remainingPortion!=null) { System.out.println("final test 12"); grandTotal=remainingPortion+grandTotal; System.out.println("finished2"); finishedExecution=true; //there is still MSD left } } //easiest - done //so 784948 // + 71 = 785 019 if (lastDigitNumber+carryForward>9 && !finishedExecution) //lastdigit = 9 { System.out.println("final test 13"); total = lastDigitNumber + 1; //carry 1 over lastDigitNumber=total%10; grandTotal = lastDigitNumber + grandTotal; System.out.println("***CURRENT GRAND CHECKER: " + grandTotal); remainingPortionLong = Long.valueOf(remainingPortion); rightDigitTruncatedRemainingPortionLong =remainingPortionLong/10; remainingPortion=String.valueOf(rightDigitTruncatedRemainingPortionLong); System.out.println("REMAINING CHECKER!!!!: " + remainingPortion); addition(remainingPortion, remainingPortionFirstNumberString, remainingPortionSecondNumberString); //so 98499 948 // + 71 = 9 8500 019 /* if (!finishedExecution) { System.out.println("curent ggrand: " + grandTotal); System.out.println("current remain: " + remainingPortion); grandTotal=remainingPortion+grandTotal; return grandTotal; } */ } //end of final test 13 } //end of final test 9. at point where numbers not uniform } //end of final test 8. If not finished execution } //end of else final test 7 System.out.println("final test 14"); return grandTotal; } //end of main method } //end of class