Text Justification

                            Solution in C :

#define RES_LEN 300

char ** fullJustify(char ** words, int wordsSize, int maxWidth, int* returnSize){
    int spaces, pad, remainSpaces, lWidth, cWordLen;
    // allocate memory for the result
    char **res = calloc(sizeof(char *),  RES_LEN);
    for(int i = 0; i < RES_LEN; i++)
        res[i] = calloc(sizeof(char), maxWidth + 1);
    *returnSize = 0;
    int cLen = 0;
    
    for(int l = 0, r; l < wordsSize; l = r) {
        // find words that can fit to form a current line in result
        r = l;
        lWidth = 0; 
        cWordLen = strlen(words[r]);
        while(r < wordsSize && cWordLen + lWidth + r - l <= maxWidth) {
            lWidth += cWordLen;
            r++;
            if(r < wordsSize)
                cWordLen = strlen(words[r]);
        }
        
        // calculate the spaces and extra spaces to pad after each word in this line
        spaces = 1;
        pad = 0;
        if(r - l != 1 && r != wordsSize) {
            spaces = (maxWidth - lWidth) / (r - l - 1);
            pad = (maxWidth - lWidth) % (r - l - 1);
        }
        
		// Now, words from left to right pointers can be added to current line by justifying. 
        // Add the left most word first. Then, add all the spaces and extra padded spaces.
		// Then, add the next word 
        cLen = 0;
        cLen += sprintf(res[*returnSize], "%s", words[l]);
        for(int w = l + 1; w < r; w++) {										
            for(int i = 0; i < spaces; i++)									// append spaces after current word
                cLen += sprintf(res[*returnSize] + cLen, "%c", ' ');

            // pad extra space for words in line from left to right 
            if(pad-- > 0)													// append extra padded spaces in left justified manner                
                cLen += sprintf(res[*returnSize] + cLen, "%c", ' ');
            
            cLen += sprintf(res[*returnSize] + cLen, "%s", words[w]);            
        }
        
        // Adjust the last line by appending remaining spaces to the right
        remainSpaces = maxWidth - cLen;
        for(int i = 0; i < remainSpaces; i++)
            cLen += sprintf(res[*returnSize] + cLen, "%c", ' ');
        
        (*returnSize)++;
    }
    return res;
}
                        

                        Solution in C++ :

class Solution {
public:
    std::vector<std::string> fullJustify(std::vector<std::string>& words, int maxWidth) {
        std::vector<std::string> res;
        std::vector<std::string> cur;
        int num_of_letters = 0;

        for (std::string word : words) {
            if (word.size() + cur.size() + num_of_letters > maxWidth) {
                for (int i = 0; i < maxWidth - num_of_letters; i++) {
                    cur[i % (cur.size() - 1 ? cur.size() - 1 : 1)] += ' ';
                }
                res.push_back("");
                for (std::string s : cur) res.back() += s;
                cur.clear();
                num_of_letters = 0;
            }
            cur.push_back(word);
            num_of_letters += word.size();
        }

        std::string last_line = "";
        for (std::string s : cur) last_line += s + ' ';
        last_line = last_line.substr(0, last_line.size()-1);  // remove trailing space
        while (last_line.size() < maxWidth) last_line += ' ';
        res.push_back(last_line);

        return res;
    }
};
                    

                        Solution in Java :

public class Solution {
    public List<String> fullJustify(String[] words, int maxWidth) {
        List<String> res = new ArrayList<>();
        List<String> cur = new ArrayList<>();
        int num_of_letters = 0;

        for (String word : words) {
            if (word.length() + cur.size() + num_of_letters > maxWidth) {
                for (int i = 0; i < maxWidth - num_of_letters; i++) {
                    cur.set(i % (cur.size() - 1 > 0 ? cur.size() - 1 : 1), cur.get(i % (cur.size() - 1 > 0 ? cur.size() - 1 : 1)) + " ");
                }
                StringBuilder sb = new StringBuilder();
                for (String s : cur) sb.append(s);
                res.add(sb.toString());
                cur.clear();
                num_of_letters = 0;
            }
            cur.add(word);
            num_of_letters += word.length();
        }

        StringBuilder lastLine = new StringBuilder();
        for (int i = 0; i < cur.size(); i++) {
            lastLine.append(cur.get(i));
            if (i != cur.size() - 1) lastLine.append(" ");
        }
        while (lastLine.length() < maxWidth) lastLine.append(" ");
        res.add(lastLine.toString());

        return res;
    }
}
                    

                        Solution in Python : 
                            
class Solution:
    def fullJustify(self, words: List[str], maxWidth: int) -> List[str]:
        res, line, width = [], [], 0

        for w in words:
            if width + len(w) + len(line) > maxWidth:
                for i in range(maxWidth - width): line[i % (len(line) - 1 or 1)] += ' '
                res, line, width = res + [''.join(line)], [], 0
            line += [w]
            width += len(w)

        return res + [' '.join(line).ljust(maxWidth)]