// ALL DONE // JUST CAN NOT REMEMBER HOW TO FIGURE OUT IF LAST TOKEN.... // SINCE NO TREATMENT HAS TAKEN PLACE ON IT!!! // THE LOGIC ON APPLICATION WILL FAIL IF ONE WORD //SINCE IT WILL PROCESS HASMORETOKENS AND ALSO !HASMORETOKENS SINCE IT DOESN'T KNOW THE ONLY TOKEN //TRIGGERS BOTH STATES..... // I HAVE JUST USED TRY AND CATCH OUT OF THIS AREA OF CODE.... // ALL FIXED NOW! //I have also avoided any booleans since also more prone to error having to toggle states back to original... //It now allows end user to customise the padding delimiter. // This can be useful since it is not possible to count the number of whitespace since it is invisible.... //THE CODE IS DESIGNED TO HAVE THREE WAYS OF OUTPUTTING THE COMPLETED LINE TO END USER: //1) A line with content truncated //2) Final line //TEST CASES (DO NOT UNCOMMENT ANY OF THESE) //String text = "The quick brown fox jumps over the lazy dog"; (PASSED - this is the example..) //String text = " This is a test but making it a bit longer!"; (PASSED - spanning more lines..) //String text = "My"; (PASSED - this is exactly 1 word..) //String text = "My name is Amit Amlani. This is a sligthly longer test to see if the text can be spanned across multiple lines."; (PASSED - much longer text) //String text =""; (PASSED - no String) //String text = "This will be 16." (PASSED - exact length of k) //String text = "Thiswillbetesting 16 testing." (PASSED - first word too long exceeds k) //String text = " Some blank now but there should be extreme amount on start second line"; PASSED //PASSED //String text="Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers write once, run anywhere (WORA),[16] meaning that compiled Java code can run on all platforms that support Java without the need to recompile.[17] Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture. The syntax of Java is similar to C and C++, but has fewer low-level facilities than either of them. The Java runtime provides dynamic capabilities (such as reflection and runtime code modification) that are typically not available in traditional compiled languages."; //With the new code it now functions as below.... /* 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.*; public class FullyJustified { public static void main(String[] args) { System.out.println("Welcome to Online IDE!! Happy Coding :)"); //THESE ARE ALL TEST CASES......SELECT ONE ONLY! //String text = "The quick brown fox jumps over the lazy dog"; // no issues..... //String text=""; // no issues //String text = " This is a test, but making it a bit longer!"; //no issues.... //String text = "My"; //no issues //String text = " My name is Amit Amlani. This is a sligthly longer test to see if the text can be spanned across multiple lines."; //String text = " Some blank now but there should be extreme amount on start second line"; //String text = "This will be 16."; //no issues. //String text = "This will be 16. Amit"; //no issues.... //String text = "Thiswillbetesting 16 testing."; //no issues //String text = "Java is a high-level, class-based"; // no issues... // no issues, but it was vital I tried random text from the internet, since I realised //my code was not geared towards having 1 word per line... //and my test cases had tendency to be biased... //now resolved.... String text="Java is a high-level, class-based, object-oriented programming language that is designed to have as few implementation dependencies as possible. It is a general-purpose programming language intended to let programmers write once, run anywhere (WORA),[16] meaning that compiled Java code can run on all platforms that support Java without the need to recompile.[17] Java applications are typically compiled to bytecode that can run on any Java virtual machine (JVM) regardless of the underlying computer architecture. The syntax of Java is similar to C and C++, but has fewer low-level facilities than either of them. The Java runtime provides dynamic capabilities (such as reflection and runtime code modification) that are typically not available in traditional compiled languages."; String lastLine=""; //last completed line int k=50; // this is the length of the line, the example states 16 String tokentoString=""; //tokens require conversion to String... String line; // this will be the line before any padding has been applied.. int wordCount=0; // a running total of number words.. This will be useful notably when it reaches !hasMoreTokens int lineLength; // this is the length of the line before it applies any String lineBeforeLastWord=""; //not most friendly name, but it refers to the line with truncation undertaken... int lengthLineBeforeLastWord; // length of the line as described above... String completeLine=""; //this will be presented to end user in maximum three possible ways... String totalExtraPaddingBetweenWords=""; // This is the padding which needs to be divided equally inter-words.. int extraPaddingBetweenWords=0; //this will work in conjunction with totalExtraPaddingBetweenWords to generate the correct amount " " boolean conditionOncePerLine=true; // this is a bit difficult to explain... But since some of my logic was done as part of if else, //I wanted to move the code so that it does not repeat.. But it is not possible to put it between the if else //since it will be unreachable.... int extraFrontPadding=0; // total front padding... String truncatedWord=""; // this will either contain a single word overspilt or be blank... String delimiter=" "; // this is used to process any StringTokenizers and get the words... int wordsIntoLineAfterTruncation=0; // words on line after truncation.. This is very important to understand where padding can be applied.. int buffer=0; // this is simply k - (length of line after truncation occured); int completeLinelength=0; // used for onscreen validation to ensure it has reached k int lengthLastLine=0; // length of the last line..... int newposText=0; // will be used as index to navigate through text String existingFrontalPadding=""; // new code implemented, end user might have existing front padding... //Tokenizer strips it off, so has to be manually re-instated.... String existingFrontalPaddingTest="*"; //End user can select any character, I have differed symbol from // the paddingTest variable... int existingFrontalPaddingCount=0; // counts amount extra Frontal padding.... String[] completedLineRepository = new String[1000]; // this can be set to preference.... //not possible to predetermine... but if wanted to extend the code, it can be speculated.... int num=0; // counter used for completedLineRepository to place all Strings inside..... //these are two options to test the padding.. Sometimes it is critical especially if padding is on right hand side //and to see it visibly.... //note this includes the natural space between words //end user can specify their own padding character //note it differs from the full stop. //only time the bullet point would become a hindrance if there actually is a bullet point already in the text //.· first char is full stop followed by bullet point.... String paddingTest = "·"; //used for padding.. same for inter-word and intra-text //String paddingTest = " "; // I initally wanted to mantain several StringJoiners. // During the coding I used 2 or 3... But it could be hazardous if it was not cleared. //Also they were used mutually exclusively, so it was an extra risk having different instances.. // So I kept one instance, and it was used: StringJoiner sj = new StringJoiner(paddingTest); int tokenLength=0; //length of token taken from StringTokenizer //to avoid mistakes in coding, and setting wrong parameter into the constructor, I have mantained //three for readability.. //First argument is the String text. //delimiter is set as " " since each word has this delimiter... StringTokenizer st = new StringTokenizer(text, delimiter); String temp=""; // this will hold the value of the token in while loop above to process tokens. StringTokenizer st1; // constructor will be initial during code as follows: //= new StringTokenizer (lineBeforeLastWord, delimiter); String temp1; // this will hold the value of the token in while loop above to process tokens. StringTokenizer st2; // constructor will be initial during code as follows: //=new StringTokenizer(lastLine, delimiter); String temp2; // this will hold the value of the token in while loop above to process tokens.. // used so that the string can be manipulated before stored into completed line.. //on several occasions, it could have been bypassed and StringJoiner store straight into String variable.. // I prefer the tidiness of StringBuilder.. StringBuilder sb=new StringBuilder(); String alternateToken=""; // was required to distinguish if the front token had existing frontal padding.... //LOGIC //need to think about how to allocate spaces... //need to keep a count of the words // *** THIS IS NEW CODE APPEARING STRAIGHT AWAY *** //I didn't particularly want to go through the lines in such a manner //but it was only way to get existing frontal padding. //in principle my whole code could have been completed on this basis, but I wanted //to adapt different techniques to enhance my learning experience... System.out.println("Original Text: " + text +"\n"); //traverse the text for (int h=newposText; hk) { System.out.println("The following word exceeds line limit of k" + "(" + k + "):" + (temp)); System.exit(0); //exit Java code.... } //clears StringBuilder since the value is stored in alternate first Token.. //note again, token will not be alternate for any tokens except the first one... sb.delete(0,sb.length()); //***NEW CODE**** Now it is beyond first token... if (wordCount>0) { //important for testing... //System.out.println("This is the token here:" + tokentoString); //System.out.println("This is the alternate token here:" + alternateToken); sb.append(tokentoString); //the StringBuilder will be empty and ready to store a token no different to previous code.. //but unfortunately this code is repeated twice due to scenarios of pre-storing first word in StringBuffer //and afterwards... //used during testing... //System.out.println("677777This is sj.toString():" + sj.toString()); } //used for testing..... //System.out.println("currently inside StringBuilder again:" + sb.toString()); //always keeps and overwrites this... It is also one word less than what will be sent into //StringJoiner.. Reason is if the k limit is exceeded, it has the line available to roll back to without //having to process all tokens again.. lineBeforeLastWord = sj.toString(); //used for testing, once again it is combination of extraFrontPadding + tokentoString //System.out.println("ALTERNATE FIRST TOKEN WITH EXISTING FRONTAL PADDING:" + alternateToken); //used for testing, looking at above code, it will be seen that //StringJoiner will have nothing in it, unless a truncatedWord //has been stored in it, so that it can be passed into StringBuilder for new line.. //It will start process now below, and use right decision making... //System.out.println("SJ NOW!!!!: " + sj.toString()); if (existingFrontalPadding=="") { //this is straight forward since it will use the token that is already added into the //StringBuilder //note the StringBuilder will only have one word at time since values are passed to //StringJoiner for formatting... //System.out.println("option 1"); sj.add(sb); // StringBuilder added into StringJoiner.... This is a continuous process with delimiter defined... //System.out.println("This is the token chosen:" + sb.toString()); } //as above, there is existingFrontalPadding else { System.out.println("Your existing frontal padding:"+existingFrontalPadding); //two strings are added to StringJoiner instead.... //System.out.println("option 2"); //remember alternateToken is tokentoString+extraFrontPadding; sj.add(alternateToken); System.out.println("This is the token chosen:" + alternateToken); } //important to clear value now otherwise all tokens will get this padding.. existingFrontalPadding=""; // ***** FROM HERE ONWARDS, THE LOGIC FLOWS EXACTLY SAME WAY, UNLESS HIGHLIGHTED... sb.delete(0,sb.length()); //remove contents of StringBuffer ready for another token //used for testing to ensure that it looks like the text... //expecting this to grow as .hasMoreTokens continues.... //System.out.println("INSIDE StringJoiner:" + sj.toString()); line = sj.toString(); // it also has to keep track of contents in the line.... in order to make decision with k //used testing.... //System.out.println("Value of sj.toString: " + line); //used for testing... //System.out.println("unformmated line here so far:" + line); lineLength=line.length(); //determines length of the line... //note this value should be exactly same as wordCount if all the words fit naturally and exactly at K boundaries on a line //Alternatively, it should also be the same with wordCount on the first line, up to point a word is truncated for exceeding k //or it would be the same as wordCount if there is a single line only (irrespective of the number words) wordsIntoLineAfterTruncation++; //System.out.println(extraFrontPadding); //Used during testing to ensure that the line was infact getting bigger... // it is important to keep this active since it drives all logic.. System.out.println("Your line getting bigger:" + line + "(" + lineLength + " chars inc white space)"); System.out.println("Words after truncation: " + wordsIntoLineAfterTruncation); //This is just some pseudo code..... //first thing is if the natural line has taken it over k, // need to truncate a word..... //count length of words... // subtract it from k.... //if less than (wordCount-1) //pads at front.... (COMPLETE...) //completely missed this in my previous coding.... //it will not store the first line otherwise for such examples (where fullstop is exactly limit of k) //String text = "This will be 16. Amit"; //all housekeeping and reset of variables required as usual once stored in repository. //otherwise as a knock on effect !hasMoreTokens will give a negative buffer // and padding value will be severely distorted.... //System.out.println("777656456465464value of temp:" + temp); if (lineLength==k) { completeLine = line; //note it is line here not lineBeforeLastWord since no truncation.. //stores the line completedLineRepository[num]=line; num++; //counter for index... //System.out.println(completeLine); completeLinelength=completeLine.length(); //VERY CRITICAL PART.. ITS FIRST TIME END USER SEES LINE System.out.println("Completed line:" +line); //reset StringJoiner inline with a completed line.. This is only time StringJoiner are reset.... sj=new StringJoiner(paddingTest); //it is now ready to start counter for a new line.... wordsIntoLineAfterTruncation=0; //important to set the padding between words back to none since a new line is being created from scratch. totalExtraPaddingBetweenWords=""; //it also has to remove contents of StringBuilder, which is always one token in length... sb.delete(0,sb.length()); //stores completedLine in completedLineRepository to access entire finished lines later.... //Also on this instance, need to remember that temp (the last token) still holds a value // on this instance, it has to be erased to entirety.. //otherwise logic later on will involve truncatedWord=temp.. //clearly this has not occured.. //this is derived from temp, so best to clear both here.... tokentoString=""; temp=""; System.out.println("NEW LENGTH of line:" + completeLinelength); } //if the value in lineLength (formed via StringJoiner) is greater than k //k can be adjusted by the end user in above section.... if (lineLength>k) { //need remove last token.... //can not remember how I did that last time..remember //kept copy of stringjoiner... //as explained before, the choice of variable name is a bit poor. //but it is the line stored which fits to constraints of k.... lengthLineBeforeLastWord= lineBeforeLastWord.length(); System.out.println("Rolled back to(due to exceeding " + k +"):" + lineBeforeLastWord); System.out.println("Length rolled back line: " + lengthLineBeforeLastWord); //at this point there clearly is not enough buffer to allow an additional space between //the characters... //it has to therefore force the spaces on the left hand side... //also, if it has rolled back, it needs to store a copy of the last word that was //truncated... //otherwise nextToken will bypass it since it is already processed it. truncatedWord=temp; System.out.println("This word getting truncated:" + truncatedWord); //it now reduces the count since one word has been removed... wordsIntoLineAfterTruncation--; //this is amount excess room on the line.. buffer = k-lengthLineBeforeLastWord; //Screen outputs to ensure execution is ok.. System.out.println("The current buffer is: " + buffer); System.out.println("Number words to accomodate for: " + wordsIntoLineAfterTruncation + "("+ lineBeforeLastWord+")"); System.out.println("Last word in tokenizer should be same as truncated word: " + temp); System.out.println("What is wordcount here: " + wordCount); System.out.println("What is truncated word count: " + wordsIntoLineAfterTruncation +"(" + lineBeforeLastWord +") " + lengthLineBeforeLastWord + " chars" ); System.out.println("Value of temp:" + temp); //if there is additional room.. //if it fills exactly length K the sentence, it does not qualify for padding... if (buffer>0) { // if extra uniform spaces can go between words (such as two between words), //this is preferable than adding padding at front... as per requirements.... //but it is only possible in scenario below.... sj = new StringJoiner(paddingTest); //resets StringJoiner.... //this will be empty for first line, but needs to be cleared as below thereafter... //in practice it would be overwritten, but feels comfortable once content is officially wiped. completeLine=""; //note that for every 3 words, inter-word padding is considered at two locations // so 1 is subtracted from wordsIntoLineAfterTruncation.. //it is only possible if there is no remainder from the buffer, so modulus will be taken... //the same inter-word spacing has to be adhered to at all times... //Also need to be careful and consider minimum words in line has to be greater than 1... //Otherwise it will start putting inter-word padding which is not possible. //System.out.println(wordsIntoLineAfterTruncation); //I had to introduce try as new code.... // since I never had a situation in my testing that the wordsIntoLineAfterTruncation //was 1 on first line... and identical on the next.. // i.e no space for 2nd word on the 1st line... and no space for 3rd work on 2nd line.. //it didn't give opportunity for variable to get bigger than 1 // hence the ArithmeticException try { if (buffer%(wordsIntoLineAfterTruncation-1)==0 && wordsIntoLineAfterTruncation>1) { //uniform extra padding between words... extraPaddingBetweenWords = buffer/(wordsIntoLineAfterTruncation-1); System.out.println("CURRENT LENGTH of line: " + lengthLineBeforeLastWord); System.out.println("Qualified for extra padding"); //informs end user... System.out.println(extraPaddingBetweenWords + " extra padding between:" + lineBeforeLastWord); // This now configures extra padding.. // Note this is unrelated to existing space between words.... //It will be seen that StringJoiner has two variables in the new instance... //The paddingTest is what end user can specify in variable declaration section at the top... for (int j=0; j0 since it is still nested within this if loop..... //also if there are no tokens, it will process this... //the safest way is to ensure that temp!="" and tokentoString!="" //This has been set when a string appears with exact k length.. //but safest way would be checking that truncatedWord is blank since it formed from above... //lots options... else { if (temp!="") { extraFrontPadding=buffer; //assigning all spare space at front.... System.out.println(lineBeforeLastWord + " =>qualifies for " + extraFrontPadding + " padding at front since it has:" + wordsIntoLineAfterTruncation + " words"); //preparing the unformatted line for modification.... sb.append(lineBeforeLastWord); System.out.println("CURRENT LENGTH of line: " + lengthLineBeforeLastWord); // now its time to put padding in..... much easier this time... for (int b=0; bqualifies for " + extraFrontPadding + " padding at end since it has:" + wordsIntoLineAfterTruncation + " words"); //preparing the unformatted line for modification.... sb.append(lineBeforeLastWord); System.out.println("CURRENT LENGTH of line: " + lengthLineBeforeLastWord); // now its time to put padding in..... much easier this time... for (int b=0; b0 is set as expected.... if (wordsIntoLineAfterTruncation==0 && wordCount>0) { wordsIntoLineAfterTruncation++; //even though no truncation performed, it still increments as expected... } //The below was also old logic, which was difficult process at time... //** OLD RATIONALE , NOT EXPLAINED PROPERLY //Need to understand how this knows the words in the last line even though it has not processed above... //At this point, I quickly realised I did not explore this in my testing.... //it is expected to force a new line after . since this is exactly k.... //String text = "This will be 16. Amit"; //This failed.. so it raised a concern.... //at same time, it failed on my old code in exact code region, this was relief //so given chance to explore.... // in the left over, it still has entire text... //workaround coding... but not used... //if (lengthLastLine>tokenLength) //{ // lastLine=temp; //} System.out.println("Left over StringJoiner: " + wordsIntoLineAfterTruncation + " word(s)=> " + lastLine + " (" + lengthLastLine + " chars inc white space)"); System.out.println("Total running words: " + wordCount); // more simple to follow... // We know content that is remaining will not form any truncation, since //it has been handled in all scenarios above.... buffer=k-lengthLastLine; //seting buffer... System.out.println("Buffer is: " + buffer); //PSEUDO CODE //a slightly different if condition is required.. // first part it checks if buffer can be spread evenly.. And as before, it needs to be longer than //1 word long in order for inter-word padding... // it can be seen here why the try & catch was required... //If there was 1 word in last line, subtracting 1 would give 0... //Buffer/0 would give an overflow....... has to be observed buffer could also be 0... // We know however there is a legitimate cause for one word in the line... //since it can qualify for padding... if ((buffer%(wordsIntoLineAfterTruncation-1)==0 && wordsIntoLineAfterTruncation>1) ) { //same logic as above..... extraPaddingBetweenWords = buffer/(wordsIntoLineAfterTruncation-1); System.out.println("It will now process the string with extra: " + extraPaddingBetweenWords + " padding between words:" + lastLine); //now creating extra padding.... if (extraPaddingBetweenWords>0) { for (int j=0; j1) else { if (wordCount>0) { //at this point, temp1 and temp2 are not initialised at all. // it has to be remembered that value of respective temp variables are overwritten within their respective do while loops //temp was associated with the main StringTokenizer for all text... //temp1 was part of the lineBeforeLastWord... this was all the strings that had formatting... //temp2 was processed just above... again this was part of do while loop, but it has an initialised value... //it has to be one word since the if did not allow entry unless wordsIntoLineAfterTruncation>1 //but is it possible to have 0 words in temp? //this is impossible since temp is value from st.hasMoreTokens (from original text). //infact none of the temp values can be blank, unless it has not stored the firstToken yet.. // or value cleared as in linelength (unformatted) is exactly k //Just to re-iterate, it will not necessarily reach here if there is one word in last line.. //since this was the if.... associated with this else... //if ((buffer%(wordsIntoLineAfterTruncation-1)==0 && wordsIntoLineAfterTruncation>1) ) //and it can be seen that it would fail at minimum //wordsIntoLineAfterTruncation-1 //wordsIntoLineAfterTruncation>1 System.out.println("There is one word in last line:" + temp); //I had forgotten to initialise the value of tokentoString and tokenLength in declaration... //this was reason for the below.... //This can readily happen, and fortunately it allowed me to reduce old code of initalising them... //**** THIS WAS OLD UNEXPLAINED THOUGHT PROCESS *********** //I also expected the variable tokentoString should also be initialised, but apparently failing.. //so having to convert temp back to String... //not sure why value in temp was in scope and not tokentoString which was used in same while loop. //but fortunately situation was recoverable. //also all variables are global throughout the whole code.... //No longer required..... //tokentoString =temp.toString(); //tokenLength = tokentoString.length(); System.out.println("CURRENT LENGTH of line: " + tokenLength); //last line is added and being prepared for formatting.... //last line has value of temp in it.... sb.append(lastLine); //information to end user System.out.println(lastLine + " =>qualifies for " + buffer + " padding at end since it has:" + wordsIntoLineAfterTruncation + " word(s)"); //since it is one word, the requirements are different. //all padding is fitted at the end inside the StringBuilder..... //only a subtle change required in the insert.... for (int b=0; bqualifies for " + buffer + " padding at end since it has:" + wordsIntoLineAfterTruncation + " word(s)"); //adding padding at the end. for (int b=0; b