// 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... //THE CODE IS DESIGNED TO HAVE THREE WAYS OF OUTPUTTING THE COMPLETED LINE TO END USER: //1) A line with content truncated.... //2) A line with truncated content appending to start of another line... //3) Last line... //TEST CASES: //String text = "The quick brown fox jumps over the lazy dog"; (PASSED) //String text = " This is a test but making it a bit longer!"; (PASSED) //String text = "My"; (PASSED) //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) //String text =""; (PASSED) //String text = "This will be 16." (PASSED) - exact length of k = 16 /* 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 Main { public static void main(String[] args) { System.out.println("Welcome to Online IDE!! Happy Coding :)"); //THESE ARE ALL TEST CASES...... //String text = "The quick brown fox jumps over the lazy dog"; //String text=""; //String text = " This is a test but making it a bit longer!"; //String text = "My"; 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 = "This will be 16."; String lastLine=""; //last completed line //int count=0; int k=16; // 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 " " //int lengthfinalToken; // 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 wordsLastLine=0; // number words last line.. int completeLinelength=0; // used for onscreen validation to ensure it has reached k int lengthLastLine; //totalExtraPaddingBetweenWords=delimiter; // is this correct? //String sentence=""; // 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(delimiter); int tokenLength; //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.. StringBuilder sb=new StringBuilder(); // used so that the string can be manipulated before stored into completed line.. //need to think about how to allocate spaces... //need to keep a count of the words while (st.hasMoreTokens()) //checking text for tokens.... { //need be careful truncatedWord needs to be added once only, //not each time the hasMoreTokens called... //this situation is only valid once it has displayed first line to end user on the screen... if (truncatedWord!="") { sb.append(truncatedWord); // StringBuffer will be clear and ommited word from first line is stored here... sj.add(sb); //first word added to StringJoiner.... truncatedWord=""; //the content is no longer required, it also prevents re-entering until next line is processed.. sb.delete(0,sb.length()); //the Stringbuffer has to be emptied.. //otherwise this word will form part of consecutive words again... //normally this would not be the case... On this instance, it will end up adding the word strinbuffer again into StringJoiner //once the line is finalised.. This would be repeat word. //In practice, the following is also valid and saves code: //sj.add(truncatedWord) since there are no considerations to format it given its first word.. wordsIntoLineAfterTruncation++; //total number of words on line increases... } wordCount++; //overall total number of words increases.... temp=st.nextToken(); //value of the token... tokentoString = temp.toString(); //token converted to String... tokenLength=tokentoString.length(); //length of token.... //this is only needed for one sole purpose and ascertain if any word is too long.. //Unfortunately it can not preemptively get this until token arrives.... //The code has to terminate otherwise it would cause severe issues in execution given k limit.. if (tokenLength>k) { System.out.println("The following word exceeds word limit of k" + "(" + k + "): " + temp); System.exit(0); //exit } sb.append(tokentoString); //the StringBuffer will be empty to store a token. lineBeforeLastWord = sj.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.. sj.add(sb); // StringBuffer added into StringJoiner.... This is a continuous process with delimiter defined... sb.delete(0,sb.length()); //remove contents of StringBuffer ready for another word... line = sj.toString(); // it also has to keep track of line.... lineLength=line.length(); //determines length of the line... //Used during testing to ensure that the line was infact getting bigger... wordsIntoLineAfterTruncation++; //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 System.out.println("your sentence 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...) if (lineLength>k) //if the value in lineLength (formed via StringJoiner) is greater than k { //need remove last token.... //can not remember how I did that last time..remember //kept copy of stringjoiner... 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... truncatedWord=temp; System.out.println("This word getting cut off:" + truncatedWord); //it now reduces the count since one word has been removed... wordsIntoLineAfterTruncation--; buffer = k-lengthLineBeforeLastWord; //this is amount excess room on the line.. //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("The current buffer is: " + buffer); //if there is additional room.. //if it fills exactly length K the sentence, it does not qualify for padding... if (buffer>0) { // if extra spaces can go between words (such as two between words), //this is preferable than adding padding at front... as per requirements.... sj = new StringJoiner(" "); //resets StringJoiner.... //this will be empty for first line, but needs to be cleared as below thereafter... 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. 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.... for (int j=0; j0 since it is nested within this loop..... else { 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; b1) ) { //same logic as above..... extraPaddingBetweenWords = buffer/(wordsIntoLineAfterTruncation-1); System.out.println("It will now process the string with extra: " + extraPaddingBetweenWords + " padding between words:" + lastLine); System.out.println("****current length totalExtraPaddingBetweenWords: " + totalExtraPaddingBetweenWords.length() ); //now creating extra padding.... if (extraPaddingBetweenWords>0) { for (int j=0; j