// 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) 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 - 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) /* 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......SELECT ONE ONLY! //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 text = "Thiswillbetesting 16 testing." String lastLine=""; //last completed line 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 " " boolean condition=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; // length of the last line..... String[] completedLineRepository = new String[100]; // 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 //.· 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; //length of token 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(); //LOGIC //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 word to end user on the screen... if (truncatedWord!="") { sb.append(truncatedWord); // ommited word from previous line is stored here... //this would be the first word back into the line.. //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.. sj.add(sb); //first word added to StringJoiner.... //the content is no longer required, it also prevents re-entering loop until next line is processed.. //if applicable, i.e when another word is cut off a line due to k truncatedWord=""; sb.delete(0,sb.length()); //the StringBuilder has to be emptied.. //otherwise this word will form part of consecutive words again... wordsIntoLineAfterTruncation++; //total number of words on line increases... } wordCount++; //overall total number of words increases.... temp=st.nextToken(); //value of the token stored in temp... 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 Java code.... } sb.append(tokentoString); //the StringBuilder will be empty ready to store a token. //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(); sj.add(sb); // StringBuilder 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 contents in the 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++; //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("your1 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...) //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 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("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 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... 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.... //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..... 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; b " + 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....... // 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; j>>:" + sj.toString()); sb.append(sj); completeLine=sb.toString(); System.out.println("dsds:" + completeLine); condition=false; } } //end if checking if multiple words and buffer can be divided inter-word.... //still in the try loop // it is here because words in last line is equal to 1.... else { //at this point, temp1 and temp2 are not initialised at all. // it has to be remembered that scope of temp are 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... //I found by this point my head was extremely tired on remembering all logic... //But having screen outputs gave me a sense of direction... //the while loop for st.hasMoreTokens() had closed approximately 150 words back which contained temp variable.. System.out.println("One word in last line:" + temp); //this variable tokentoString should also be initialised, but apparently failing.. //so having to convert temp back to String... //not sure why temp was in scope and not tokentoString which was used in same while loop. tokentoString=temp; System.out.println("CURRENT LENGTH of line: " + tokentoString.length()); //last line is added and being prepared for formatting.... sb.append(lastLine); 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; b!qualifies for " + buffer + " padding at end since it has:" + wordsIntoLineAfterTruncation + " word(s)"); for (int b=0; b