feat: add solutions to lc problems: No.0068,1656

* No.0068.Text Justification
* No.1656.Design an Ordered Stream

Author: yanglbme

solution/0000-0099/0068.Text Justification/README.md

@@ -6,68 +6,79 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给定一个单词数组和一个长度&nbsp;<em>maxWidth</em>，重新排版单词，使其成为每行恰好有&nbsp;<em>maxWidth</em>&nbsp;个字符，且左右两端对齐的文本。</p>
+<p>给定一个单词数组&nbsp;<code>words</code> 和一个长度&nbsp;<code>maxWidth</code>&nbsp;，重新排版单词，使其成为每行恰好有&nbsp;<code>maxWidth</code>&nbsp;个字符，且左右两端对齐的文本。</p>
 
-<p>你应该使用&ldquo;贪心算法&rdquo;来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格&nbsp;<code>&#39; &#39;</code>&nbsp;填充，使得每行恰好有 <em>maxWidth</em>&nbsp;个字符。</p>
+<p>你应该使用 “<strong>贪心算法</strong>” 来放置给定的单词；也就是说，尽可能多地往每行中放置单词。必要时可用空格&nbsp;<code>' '</code>&nbsp;填充，使得每行恰好有 <em>maxWidth</em>&nbsp;个字符。</p>
 
 <p>要求尽可能均匀分配单词间的空格数量。如果某一行单词间的空格不能均匀分配，则左侧放置的空格数要多于右侧的空格数。</p>
 
 <p>文本的最后一行应为左对齐，且单词之间不插入<strong>额外的</strong>空格。</p>
 
-<p><strong>说明:</strong></p>
+<p><strong>注意:</strong></p>
 
 <ul>
 	<li>单词是指由非空格字符组成的字符序列。</li>
 	<li>每个单词的长度大于 0，小于等于&nbsp;<em>maxWidth</em>。</li>
 	<li>输入单词数组 <code>words</code>&nbsp;至少包含一个单词。</li>
 </ul>
 
-<p><strong>示例:</strong></p>
+<p>&nbsp;</p>
 
-<pre><strong>输入:</strong>
-words = [&quot;This&quot;, &quot;is&quot;, &quot;an&quot;, &quot;example&quot;, &quot;of&quot;, &quot;text&quot;, &quot;justification.&quot;]
-maxWidth = 16
+<p><strong>示例 1:</strong></p>
+
+<pre>
+<strong>输入: </strong>words = ["This", "is", "an", "example", "of", "text", "justification."], maxWidth = 16
 <strong>输出:</strong>
 [
-&nbsp; &nbsp;&quot;This &nbsp; &nbsp;is &nbsp; &nbsp;an&quot;,
-&nbsp; &nbsp;&quot;example &nbsp;of text&quot;,
-&nbsp; &nbsp;&quot;justification. &nbsp;&quot;
+&nbsp; &nbsp;"This &nbsp; &nbsp;is &nbsp; &nbsp;an",
+&nbsp; &nbsp;"example &nbsp;of text",
+&nbsp; &nbsp;"justification. &nbsp;"
 ]
 </pre>
 
 <p><strong>示例&nbsp;2:</strong></p>
 
-<pre><strong>输入:</strong>
-words = [&quot;What&quot;,&quot;must&quot;,&quot;be&quot;,&quot;acknowledgment&quot;,&quot;shall&quot;,&quot;be&quot;]
-maxWidth = 16
+<pre>
+<strong>输入:</strong>words = ["What","must","be","acknowledgment","shall","be"], maxWidth = 16
 <strong>输出:</strong>
 [
-&nbsp; &quot;What &nbsp; must &nbsp; be&quot;,
-&nbsp; &quot;acknowledgment &nbsp;&quot;,
-&nbsp; &quot;shall be &nbsp; &nbsp; &nbsp; &nbsp;&quot;
+&nbsp; "What &nbsp; must &nbsp; be",
+&nbsp; "acknowledgment &nbsp;",
+&nbsp; "shall be &nbsp; &nbsp; &nbsp; &nbsp;"
 ]
-<strong>解释: </strong>注意最后一行的格式应为 &quot;shall be    &quot; 而不是 &quot;shall     be&quot;,
+<strong>解释: </strong>注意最后一行的格式应为 "shall be    " 而不是 "shall     be",
 &nbsp;    因为最后一行应为左对齐，而不是左右两端对齐。       
      第二行同样为左对齐，这是因为这行只包含一个单词。
 </pre>
 
 <p><strong>示例&nbsp;3:</strong></p>
 
-<pre><strong>输入:</strong>
-words = [&quot;Science&quot;,&quot;is&quot;,&quot;what&quot;,&quot;we&quot;,&quot;understand&quot;,&quot;well&quot;,&quot;enough&quot;,&quot;to&quot;,&quot;explain&quot;,
-&nbsp;        &quot;to&quot;,&quot;a&quot;,&quot;computer.&quot;,&quot;Art&quot;,&quot;is&quot;,&quot;everything&quot;,&quot;else&quot;,&quot;we&quot;,&quot;do&quot;]
-maxWidth = 20
+<pre>
+<strong>输入:</strong>words = ["Science","is","what","we","understand","well","enough","to","explain","to","a","computer.","Art","is","everything","else","we","do"]，maxWidth = 20
 <strong>输出:</strong>
 [
-&nbsp; &quot;Science &nbsp;is &nbsp;what we&quot;,
-  &quot;understand &nbsp; &nbsp; &nbsp;well&quot;,
-&nbsp; &quot;enough to explain to&quot;,
-&nbsp; &quot;a &nbsp;computer. &nbsp;Art is&quot;,
-&nbsp; &quot;everything &nbsp;else &nbsp;we&quot;,
-&nbsp; &quot;do &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;&quot;
+&nbsp; "Science &nbsp;is &nbsp;what we",
+  "understand &nbsp; &nbsp; &nbsp;well",
+&nbsp; "enough to explain to",
+&nbsp; "a &nbsp;computer. &nbsp;Art is",
+&nbsp; "everything &nbsp;else &nbsp;we",
+&nbsp; "do &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;"
 ]
 </pre>
 
+<p>&nbsp;</p>
+
+<p><strong>提示:</strong></p>
+
+<ul>
+	<li><code>1 &lt;= words.length &lt;= 300</code></li>
+	<li><code>1 &lt;= words[i].length &lt;= 20</code></li>
+	<li><code>words[i]</code>&nbsp;由小写英文字母和符号组成</li>
+	<li><code>1 &lt;= maxWidth &lt;= 100</code></li>
+	<li><code>words[i].length &lt;= maxWidth</code></li>
+</ul>
+
+
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
@@ -143,7 +154,7 @@ class Solution {
             if (i == n || t.size() == 1) {
                 // this is the last line or only one word in a line
                 String left = String.join(" ", t);
-                String right = blank(maxWidth - left.length());
+                String right = " ".repeat(maxWidth - left.length());
                 ans.add(left + right);
                 if (i == n) {
                     break;
@@ -169,22 +180,14 @@ class Solution {
         int base = n / cnt;
         int mod = n % cnt;
         for (int i = 0, j = 0; i < cnt; ++i, ++j) {
-            StringBuilder sb = new StringBuilder(blank(base));
+            StringBuilder sb = new StringBuilder(" ".repeat(base));
             if (j < mod) {
                 sb.append(' ');
             }
             ans.add(sb.toString());
         }
         return ans;
     }
-
-    private String blank(int n) {
-        StringBuilder sb = new StringBuilder();
-        while (n-- > 0) {
-            sb.append(' ');
-        }
-        return sb.toString();
-    }
 }
 ```
 
@@ -283,6 +286,77 @@ func fullJustify(words []string, maxWidth int) []string {
 }
 ```
 
+### **C#**
+
+```cs
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+public class Solution {
+    public IList<string> FullJustify(string[] words, int maxWidth) {
+        var result = new List<string>();
+        var buffer = new List<string>();
+        var sb = new StringBuilder();
+        var len = 0;
+        
+        for (var i = 0; i < words.Length; ++i)
+        {
+            var newLen = words[i].Length + (len == 0 ? 0 : len + 1);
+            if (newLen <= maxWidth)
+            {
+                buffer.Add(words[i]);
+                len = newLen;
+            }
+            else
+            {
+                if (buffer.Count == 1)
+                {
+                    sb.Append(buffer[0]);
+                    sb.Append(' ', maxWidth - buffer[0].Length);
+                }
+                else
+                {
+                    var spaceCount = maxWidth - len + buffer.Count - 1;
+                    for (var j = 0; j < buffer.Count - 1; ++j)
+                    {
+                        sb.Append(buffer[j]);
+                        var spaceToAdd = (spaceCount - 1) / (buffer.Count - j - 1) + 1;
+                        sb.Append(' ', spaceToAdd);
+                        spaceCount -= spaceToAdd;
+                    }
+                    sb.Append(buffer.Last());
+                }
+                result.Add(sb.ToString());
+                buffer.Clear();
+                buffer.Add(words[i]);
+                sb.Clear();
+                len = words[i].Length;
+            }
+        }
+        
+        if (buffer.Count > 0)
+        {
+            for (var j = 0; j < buffer.Count; ++j)
+            {
+                if (sb.Length > 0)
+                {
+                    sb.Append(' ');
+                }
+                sb.Append(buffer[j]);
+            }
+            if (sb.Length < maxWidth)
+            {
+                sb.Append(' ', maxWidth - sb.Length);
+            }
+            result.Add(sb.ToString());
+        }
+        
+        return result;
+    }
+}
+```
+
 ### **...**
 
 ```

solution/0000-0099/0068.Text Justification/README_EN.md

@@ -4,20 +4,20 @@
 
 ## Description
 
-<p>Given an array of words and a width&nbsp;<em>maxWidth</em>, format the text such that each line has exactly <em>maxWidth</em> characters and is fully (left and right) justified.</p>
+<p>Given an array of strings <code>words</code> and a width <code>maxWidth</code>, format the text such that each line has exactly <code>maxWidth</code> characters and is fully (left and right) justified.</p>
 
-<p>You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces <code>&#39; &#39;</code> when necessary so that each line has exactly <em>maxWidth</em> characters.</p>
+<p>You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces <code>&#39; &#39;</code> when necessary so that each line has exactly <code>maxWidth</code> characters.</p>
 
-<p>Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.</p>
+<p>Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line does not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.</p>
 
-<p>For the last line of text, it should be left justified and no <strong>extra</strong> space is inserted between words.</p>
+<p>For the last line of text, it should be left-justified and no extra space is inserted between words.</p>
 
 <p><strong>Note:</strong></p>
 
 <ul>
-	<li>A word is defined as a character sequence consisting&nbsp;of non-space characters only.</li>
-	<li>Each word&#39;s length is&nbsp;guaranteed to be greater than 0 and not exceed <em>maxWidth</em>.</li>
-	<li>The input array <code>words</code>&nbsp;contains at least one word.</li>
+	<li>A word is defined as a character sequence consisting of non-space characters only.</li>
+	<li>Each word&#39;s length is guaranteed to be greater than 0 and not exceed maxWidth.</li>
+	<li>The input array <code>words</code> contains at least one word.</li>
 </ul>
 
 <p>&nbsp;</p>
@@ -125,10 +125,11 @@ class Solution:
 
 ```java
 class Solution {
+
     public List<String> fullJustify(String[] words, int maxWidth) {
         List<String> ans = new ArrayList<>();
         int n = words.length;
-        for (int i = 0; i < n; ) {
+        for (int i = 0; i < n;) {
             List<String> t = new ArrayList<>();
             int cnt = words[i].length();
             t.add(words[i++]);
@@ -139,7 +140,7 @@ class Solution {
             if (i == n || t.size() == 1) {
                 // this is the last line or only one word in a line
                 String left = String.join(" ", t);
-                String right = blank(maxWidth - left.length());
+                String right = " ".repeat(maxWidth - left.length());
                 ans.add(left + right);
                 if (i == n) {
                     break;
@@ -165,23 +166,16 @@ class Solution {
         int base = n / cnt;
         int mod = n % cnt;
         for (int i = 0, j = 0; i < cnt; ++i, ++j) {
-            StringBuilder sb = new StringBuilder(blank(base));
+            StringBuilder sb = new StringBuilder(" ".repeat(base));
             if (j < mod) {
                 sb.append(' ');
             }
             ans.add(sb.toString());
         }
         return ans;
     }
-
-    private String blank(int n) {
-        StringBuilder sb = new StringBuilder();
-        while (n-- > 0) {
-            sb.append(' ');
-        }
-        return sb.toString();
-    }
 }
+
 ```
 
 ### **C++**
@@ -279,6 +273,77 @@ func fullJustify(words []string, maxWidth int) []string {
 }
 ```
 
+### **C#**
+
+```cs
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+public class Solution {
+    public IList<string> FullJustify(string[] words, int maxWidth) {
+        var result = new List<string>();
+        var buffer = new List<string>();
+        var sb = new StringBuilder();
+        var len = 0;
+
+        for (var i = 0; i < words.Length; ++i)
+        {
+            var newLen = words[i].Length + (len == 0 ? 0 : len + 1);
+            if (newLen <= maxWidth)
+            {
+                buffer.Add(words[i]);
+                len = newLen;
+            }
+            else
+            {
+                if (buffer.Count == 1)
+                {
+                    sb.Append(buffer[0]);
+                    sb.Append(' ', maxWidth - buffer[0].Length);
+                }
+                else
+                {
+                    var spaceCount = maxWidth - len + buffer.Count - 1;
+                    for (var j = 0; j < buffer.Count - 1; ++j)
+                    {
+                        sb.Append(buffer[j]);
+                        var spaceToAdd = (spaceCount - 1) / (buffer.Count - j - 1) + 1;
+                        sb.Append(' ', spaceToAdd);
+                        spaceCount -= spaceToAdd;
+                    }
+                    sb.Append(buffer.Last());
+                }
+                result.Add(sb.ToString());
+                buffer.Clear();
+                buffer.Add(words[i]);
+                sb.Clear();
+                len = words[i].Length;
+            }
+        }
+
+        if (buffer.Count > 0)
+        {
+            for (var j = 0; j < buffer.Count; ++j)
+            {
+                if (sb.Length > 0)
+                {
+                    sb.Append(' ');
+                }
+                sb.Append(buffer[j]);
+            }
+            if (sb.Length < maxWidth)
+            {
+                sb.Append(' ', maxWidth - sb.Length);
+            }
+            result.Add(sb.ToString());
+        }
+
+        return result;
+    }
+}
+```
+
 ### **...**
 
 ```