Word wrap: Difference between revisions
m
→{{header|Wren}}: Changed to Wren S/H
(added Scheme example) |
m (→{{header|Wren}}: Changed to Wren S/H) |
||
(79 intermediate revisions by 44 users not shown) | |||
Line 17:
If your language provides this, you get easy extra credit,
but you ''must reference documentation'' indicating that the algorithm
is something better than a simple
If you have both basic and extra credit solutions, show an example where
the two algorithms give different results.
{{Template:Strings}}
<br><br>
=={{header|11l}}==
{{trans|Go}}
<syntaxhighlight lang="11l">F word_wrap(text, line_width)
V words = text.split_py()
I words.empty
R ‘’
V wrapped = words[0]
V space_left = line_width - wrapped.len
L(word) words[1..]
I word.len + 1 > space_left
wrapped ‘’= "\n"word
space_left = line_width - word.len
E
wrapped ‘’= ‘ ’word
space_left -= 1 + word.len
R wrapped
V frog = ‘
In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime-tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything.’
L(width) (72, 80)
print(‘Wrapped at ’width":\n"word_wrap(frog, width))
print()</syntaxhighlight>
{{out}}
<pre>
Wrapped at 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime-tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
Wrapped at 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|360 Assembly}}==
The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.
<
WORDWRAP CSECT
USING WORDWRAP,R13
Line 189 ⟶ 250:
LA R4,S1
LH R5,LENS1
ICM R5,B'1000',=C' ' padding
MVCL R6,R4 pg=substr(s1,1,lens1)
XPRNT PG,L'PG put skip list(pg)
Line 210 ⟶ 271:
LA R4,S2
LH R5,LENS2
ICM R5,B'1000',=C' ' padding
MVCL R6,R4 pg=substr(s2,1,lens2)
XPRNT PG,L'PG put skip list(pg)
Line 247 ⟶ 308:
PG DS CL80
YREGS
END WORDWRAP</
{{out}}
<pre>
Line 268 ⟶ 329:
caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Action!}}==
<syntaxhighlight lang="action!">CHAR ARRAY text(1000)
CARD length
PROC AppendText(CHAR ARRAY part)
BYTE i
FOR i=1 TO part(0)
DO
text(length)=part(i)
length==+1
OD
RETURN
INT FUNC GetPosForWrap(BYTE lineLen INT start)
INT pos
pos=start+lineLen
IF pos>=length THEN
RETURN (length-1)
FI
WHILE pos>start AND text(pos)#32
DO
pos==-1
OD
IF pos=start THEN
pos=start+lineLen
ELSE
pos==-1
FI
RETURN (pos)
PROC PrintTextWrapped(BYTE lineLen)
INT i,pos
BYTE wrap,screenWidth=[40]
i=0
WHILE i<length
DO
pos=GetPosForWrap(lineLen,i)
IF pos-i=screenWidth-1 OR pos=length-1 THEN
wrap=0
ELSE
wrap=1
FI
WHILE i<=pos
DO
Put(text(i))
i==+1
OD
WHILE i<length AND text(i)=32
DO
i==+1
OD
IF wrap THEN
PutE()
FI
OD
RETURN
PROC Test(BYTE lineLen)
BYTE CH=$02FC
Put(125) ;clear screen
PrintF("Line length=%B%E%E",lineLen)
PrintTextWrapped(lineLen)
PrintF("%E%EPress any key to continue...")
DO UNTIL CH#$FF OD
CH=$FF
RETURN
PROC Main()
BYTE LMARGIN=$52,old
length=0
AppendText("Lorem ipsum dolor sit amet, consectetur adipiscing elit. ")
AppendText("Maecenas varius sapien vel purus hendrerit vehicula. ")
AppendText("Integer hendrerit viverra turpis, ac sagittis arcu pharetra id. ")
AppendText("Sed dapibus enim non dui posuere sit amet rhoncus tellus consectetur. ")
AppendText("Proin blandit lacus vitae nibh tincidunt cursus. ")
AppendText("Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. ")
AppendText("Nam tincidunt purus at tortor tincidunt et aliquam dui gravida. ")
AppendText("Nulla consectetur sem vel felis vulputate et imperdiet orci pharetra. ")
AppendText("Nam vel tortor nisi. Sed eget porta tortor. ")
AppendText("Aliquam suscipit lacus vel odio faucibus tempor. ")
AppendText("Sed ipsum est, condimentum eget eleifend ac, ultricies non dui.")
old=LMARGIN
LMARGIN=0 ;remove left margin on the screen
Test(40)
Test(30)
Test(20)
LMARGIN=old ;restore left margin on the screen
RETURN
</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Word_wrap.png Screenshot from Atari 8-bit computer]
<pre>
Line length=40
Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Maecenas varius sapien
...
Sed ipsum est, condimentum eget eleifend
ac, ultricies non dui.
Press any key to continue...
Line length=30
Lorem ipsum dolor sit amet,
consectetur adipiscing elit.
...
condimentum eget eleifend ac,
ultricies non dui.
Press any key to continue...
Line length=20
Lorem ipsum dolor
sit amet,
...
eleifend ac,
ultricies non dui.
</pre>
=={{header|Ada}}==
The specification of a class '''Word_Wrap.Basic''' in a package '''Word_Wrap''':
<
with procedure Put_Line(Line: String);
package Word_Wrap is
Line 289 ⟶ 484:
end record;
end Word_Wrap;</
The implementation of that package:
<
procedure Push_Word(State: in out Basic; Word: String) is
Line 328 ⟶ 523:
end Finish;
end Word_Wrap;</
Finally, the main program:
<
procedure Wrap is
Line 393 ⟶ 588:
end loop;
Wrapper.Finish;
end Wrap;</
{{out}} set to 72 lines (with input picked by cut-and-paste from the task description):
Line 418 ⟶ 613:
For more sophisticated algorithms (the extra credit), one could derive
a class '''Word_Wrap.<something>''' from '''Word_Wrap.Basic'''.
=={{header|AppleScript}}==
Being a scripting language, AppleScript would normally be used just to tell some scriptable text process what fonts and margins to use and leave that process to sort out its own wraps. But the "greedy" algorithm's easy to implement for line widths measured in characters:
<syntaxhighlight lang="applescript">on wrapParagraph(para, lineWidth)
if (para is "") then return para
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to {space, tab} -- Doesn't include character id 160 (NO-BREAK SPACE).
script o
property wrds : para's text items -- Space- or tab-delimited chunks.
end script
set spaceWidth to (count space) -- ;-)
set spaceLeft to lineWidth
set theLines to {}
set i to 1
repeat with j from 1 to (count o's wrds)
set wordWidth to (count item j of o's wrds)
if (wordWidth + spaceWidth > spaceLeft) then
set end of theLines to text 1 thru (-1 - wordWidth) of (text from text item i to text item j of para)
set i to j
set spaceLeft to lineWidth - wordWidth
else
set spaceLeft to spaceLeft - (wordWidth + spaceWidth)
end if
end repeat
set end of theLines to text from text item i to end of para
set AppleScript's text item delimiters to character id 8232 -- U+2028 (LINE SEPARATOR).
set output to theLines as text
set AppleScript's text item delimiters to astid
return output
end wrapParagraph
local para
set para to "If there is a way to do this that is built-in, trivial, or provided in a standard library, show that. Otherwise implement the minimum length greedy algorithm from Wikipedia."
return wrapParagraph(para, 70) & (linefeed & linefeed) & wrapParagraph(para, 40)</syntaxhighlight>
{{output}}
<syntaxhighlight lang="applescript">"If there is a way to do this that is built-in, trivial, or provided
in a standard library, show that. Otherwise implement the minimum
length greedy algorithm from Wikipedia.
If there is a way to do this that is
built-in, trivial, or provided in a
standard library, show that. Otherwise
implement the minimum length greedy
algorithm from Wikipedia."</syntaxhighlight>
However, it's more efficient to look for the last space in each line than to see how many "words" will fit:
<syntaxhighlight lang="applescript">on wrapParagraph(para, lineWidth)
set theLines to {}
set spaceTab to space & tab
set len to (count para)
set i to 1
repeat until (i > len)
set j to i + lineWidth - 1
if (j < len) then
repeat with j from j to i by -1
if (character j of para is in spaceTab) then exit repeat
end repeat
-- The "greedy" algorithm keeps words which are longer than or
-- the same length as the line width intact. Do the same here.
if (j = i) then
repeat with j from (i + lineWidth) to len
if (character j of para is in spaceTab) then exit repeat
end repeat
end if
else
set j to len
end if
set end of theLines to text i thru j of para
set i to j + 1
end repeat
set astid to AppleScript's text item delimiters
set AppleScript's text item delimiters to character id 8232 -- U+2028 (LINE SEPARATOR).
set output to theLines as text
set AppleScript's text item delimiters to astid
return output
end wrapParagraph</syntaxhighlight>
Using AppleScriptObjC, the second approach can be achieved with a regular expression:
<syntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
on wrapParagraph(para, lineWidth)
if (para is "") then return para
set str to current application's class "NSMutableString"'s stringWithString:(para)
-- Replace each run of up to (lineWidth - 1) characters followed by a space or a tab,
-- or by the end of the paragraph, with itself and a LINE SEPARATOR character.
tell str to replaceOccurrencesOfString:(".{1," & (lineWidth - 1) & "}(?:[ \\t]|\\Z)") withString:("$0" & character id 8232) ¬
options:(current application's NSRegularExpressionSearch) range:({0, its |length|()})
-- Remove the LINE SEPARATOR inserted at the end.
tell str to replaceOccurrencesOfString:(character id 8232) withString:("") ¬
options:(0) range:({(its |length|()) - 2, 2})
return str as text
end wrapParagraph</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">txt: "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur."
print wordwrap txt
print ""
print wordwrap.at:45 txt</syntaxhighlight>
{{out}}
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus.
Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec
consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero
egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem
lacinia consectetur.
Lorem ipsum dolor sit amet, consectetur
adipiscing elit. Donec a diam lectus. Sed sit
amet ipsum mauris. Maecenas congue ligula ac
quam viverra nec consectetur ante hendrerit.
Donec et mollis dolor. Praesent et diam eget
libero egestas mattis sit amet vitae augue.
Nam tincidunt congue enim, ut porta lorem
lacinia consectetur.</pre>
=={{header|AutoHotkey}}==
Basic word-wrap. Formats text that has been copied to the clipboard.
<
return
WrapText(Text, LineLength) {
}</
{{Out}}
<pre>72
Line 456 ⟶ 779:
Basic word wrap.
<
{
if ( length(p) < 1 ) return
Line 495 ⟶ 818:
END {
wordwrap_paragraph(par)
}</
To test it,
Line 501 ⟶ 824:
<pre>
awk -f wordwrap.awk -v width=80 < text.txt
</pre>
=={{header|BaCon}}==
<syntaxhighlight lang="qbasic">paragraph$ = "In olden times when wishing still helped one," \
" there lived a king whose daughters were all beautiful, but" \
" the youngest was so beautiful that the sun itself, which has" \
" seen so much, was astonished whenever it shone in her face." \
" Close by the king's castle lay a great dark forest, and under" \
" an old lime tree in the forest was a well, and when the day" \
" was very warm, the king's child went out into the forest and" \
" sat down by the side of the cool fountain, and when she was" \
" bored she took a golden ball, and threw it up on high and" \
" caught it, and this ball was her favorite plaything."
PRINT ALIGN$(paragraph$, 72, 0)
PRINT ALIGN$(paragraph$, 90, 0)</syntaxhighlight>
BaCon has the ALIGN$ function which can align text left-side, right-side, centered or both sides at any given column.
{{out}}
<pre>
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that
the sun itself, which has seen so much, was astonished whenever it
shone in her face. Close by the king's castle lay a great dark forest,
and under an old lime tree in the forest was a well, and when the day
was very warm, the king's child went out into the forest and sat down
by the side of the cool fountain, and when she was bored she took a
golden ball, and threw it up on high and caught it, and this ball was
her favorite plaything.
In olden times when wishing still helped one, there lived a king whose daughters were all
beautiful, but the youngest was so beautiful that the sun itself, which has seen so much,
was astonished whenever it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side of the cool
fountain, and when she was bored she took a golden ball, and threw it up on high and
caught it, and this ball was her favorite plaything.
</pre>
=={{header|Batch File}}==
Basic word wrap.
<
set "input=Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur!"
Line 544 ⟶ 902:
)
endlocal & set "line=%line%"
goto proc_loop</
{{Out}}
<pre>Lorem ipsum dolor sit amet, consectetur
Line 563 ⟶ 921:
=={{header|Bracmat}}==
<
$ ( "In olden times when wishing still helped one, there lived a king "
"whose daughters were all beautiful, but the youngest was so beautiful "
Line 591 ⟶ 949:
& out$(str$("72 columns:\n" wrap$(!Text.72)))
& out$(str$("\n80 columns:\n" wrap$(!Text.80)))
);</
{{out}}
<pre>72 columns:
Line 615 ⟶ 973:
=={{header|C}}==
===Smart wrapping===
<syntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 622 ⟶ 981:
/* nonsensical hyphens to make greedy wrapping method look bad */
const char *string = "In olden times when wishing still helped one, there lived a king "
/*
*/
#define PENALTY_LONG
#define PENALTY_SHORT
typedef struct word_t {
} *word;
word make_word_list(const char *s, int *n)
{
}
}
}
int greedy_wrap(word words, int count, int cols, int *breaks)
{
}
}
}
}
}
}
/* tries to make right margin more even; pretty sure there's an off-by-one bug
int balanced_wrap(word words, int count, int cols, int *breaks)
{
else
}
}
}
}
}
}
void show_wrap(word list, int count, int *breaks)
{
}
}
}
int main(void)
{
}</
===In-place greedy===
Long words exceeding the line length are not wrapped.
<syntaxhighlight lang="c">
#include <
void wrap_text(char *line_start, int width) {
char *last_space = 0;
char *p;
for (p = line_start; *p; p++) {
if (*p == '\n') {
line_start = p + 1;
}
if (
last_space =
}
if (p - line_start > width && last_space) {
*last_space = '\n';
line_start = last_space + 1;
last_space = 0;
}
}
}
char const text[] =
"In olden times when wishing still helped one, there lived a king whose "
"daughters were all beautiful, but the youngest was so beautiful that the "
"sun itself, which has seen so much, was astonished whenever it shone in "
"her face. Close by the king's castle lay a great dark forest, and under "
"an old lime-tree in the forest was a well, and when the day was very "
"warm, the king's child went out into the forest and sat down by the side "
"of the cool fountain, and when she was bored she took a golden ball, and "
"threw it up on high and caught it, and this ball was her favorite "
"plaything.";
int main(void) {
char buf[sizeof(text)];
puts("--- 80 ---");
memcpy(buf, text, sizeof(text));
wrap_text(buf, 80);
puts(buf);
puts("\n--- 72 ---");
memcpy(buf, text, sizeof(text));
wrap_text(buf, 72);
puts(buf);
}
</syntaxhighlight>
{{out}}
<pre>
--- 80 ---
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
--- 72 ---
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
</pre>
=={{header|C sharp}}==
Greedy algorithm:
<
{
using System;
Line 930 ⟶ 1,295:
}
}
}</
{{out}}
<pre>------------------------------------------------------------------------
Line 957 ⟶ 1,322:
venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu
nibh.</pre>
=={{header|C++}}==
Basic task.
{{trans|Go}}
<syntaxhighlight lang="cpp">#include <iostream>
#include <sstream>
#include <string>
const char *text =
{
"In olden times when wishing still helped one, there lived a king "
"whose daughters were all beautiful, but the youngest was so beautiful "
"that the sun itself, which has seen so much, was astonished whenever "
"it shone in her face. Close by the king's castle lay a great dark "
"forest, and under an old lime tree in the forest was a well, and when "
"the day was very warm, the king's child went out into the forest and "
"sat down by the side of the cool fountain, and when she was bored she "
"took a golden ball, and threw it up on high and caught it, and this "
"ball was her favorite plaything."
};
std::string wrap(const char *text, size_t line_length = 72)
{
std::istringstream words(text);
std::ostringstream wrapped;
std::string word;
if (words >> word) {
wrapped << word;
size_t space_left = line_length - word.length();
while (words >> word) {
if (space_left < word.length() + 1) {
wrapped << '\n' << word;
space_left = line_length - word.length();
} else {
wrapped << ' ' << word;
space_left -= word.length() + 1;
}
}
}
return wrapped.str();
}
int main()
{
std::cout << "Wrapped at 72:\n" << wrap(text) << "\n\n";
std::cout << "Wrapped at 80:\n" << wrap(text, 80) << "\n";
}</syntaxhighlight>
{{out}}
<pre>
Wrapped at 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
Wrapped at 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.</pre>
=={{header|Clojure}}==
<
(defn wrap-line [size text]
(loop [left size line [] lines []
Line 971 ⟶ 1,406:
(recur (- size wlen) [word] (conj lines (apply str line)) (next words))))
(when (seq line)
(conj lines (apply str line))))))</
<
(defn wrap-line [size text]
(re-seq (re-pattern (str ".{1," size "}\\s|.{1," size "}"))
(clojure.string/replace text #"\n" " ")))</
<syntaxhighlight lang="clojure">;; cl-format based version
(defn wrap-line [size text]
(clojure.pprint/cl-format nil (str "~{~<~%~1," size ":;~A~> ~}") (clojure.string/split text #" ")))</syntaxhighlight>
Usage example :
<
a king whose daughters were all beautiful, but the youngest was so
beautiful that the sun itself, which has seen so much, was astonished
Line 990 ⟶ 1,429:
(doseq [line (wrap-line 72 text)]
(println line))</
{{out}}
Line 1,002 ⟶ 1,441:
threw it up on high and caught it, and this ball was her favorite
plaything.</pre>
=={{header|Commodore BASIC}}==
Nothing terribly fancy. Except for screen control codes, this should actually work on a wide variety of 8-bit BASIC outside of the Commodore realm. Note that strings are limited to 255 total characters, and <code>INPUT</code> will retrieve only a limited number of characters (less than 80 on the Commodore 64) even for a string, not to mention that special characters such as comma, semicolon, etc. have special meaning and are not captured.
<syntaxhighlight lang="gwbasic">10 rem word wrap - commodore basic
20 rem rosetta code
30 s$="":co=40:gosub 200
35 print chr$(147);chr$(14)
40 print "The current string is:"
41 print chr$(18);s$;chr$(146)
42 print:print "Enter a string, blank to keep previous,"
43 print "or type 'sample' to use a preset"len(z$)" character string."
44 print:input s$:if s$="sample" then s$=z$
45 print:print "enter column limit, 10-80 [";co;"{left}]";:input co
46 if co<12 or co>80 then goto 45
50 print chr$(147);"Wrapping on column";co;"results as:"
55 gosub 400
60 print
65 print r$
70 print
80 input "Again (y/n)";yn$
90 if yn$="y" then goto 35
100 end
200 rem set up sample string
205 data "Lorem Ipsum is typically a corrupted version of 'De finibus "
210 data "bonorum et malorum', a first-century BC text by the Roman statesman "
215 data "and philosopher Cicero, with words altered, added, and removed to "
220 data "make it nonsensical, improper Latin."
225 data "zzz"
230 z$=""
235 read tp$:if tp$<>"zzz" then z$=z$+tp$:goto 235
240 return
400 rem word-wrap string
401 tp$=s$:as$=""
405 if len(tp$)<=co then goto 440
410 for i=0 to co-1:c$=mid$(tp$,co-i,1)
420 if c$<>" " and c$<>"-" then next i
425 ad$=chr$(13):if c$="-" then ad$="-"+chr$(13)
430 as$=as$+left$(tp$,co-1-i)+ad$:tp$=mid$(tp$,co-i+1,len(tp$)):i=0
435 goto 405
440 as$=as$+tp$
450 r$=as$
460 return</syntaxhighlight>
{{out}}
<pre>Wrapping on column 40 results as:
Lorem Ipsum is typically a corrupted
version of 'De finibus bonorum et
malorum', a first-century BC text by
the Roman statesman and philosopher
Cicero, with words altered, added, and
removed to make it nonsensical,
improper Latin.
Again (y/n)? y
...
Wrapping on column 20 results as:
Lorem Ipsum is
typically a
corrupted version
of 'De finibus
bonorum et
malorum', a first-
century BC text by
the Roman statesman
and philosopher
Cicero, with words
altered, added, and
removed to make it
nonsensical,
improper Latin.
Again (y/n)? n
ready.
█</pre>
=={{header|Common Lisp}}==
<syntaxhighlight lang
(defun greedy-wrap (str width)
Line 1,017 ⟶ 1,540:
(push (subseq str begin-curr-line prev-space) lines)
(setq begin-curr-line (1+ prev-space)) )))
</syntaxhighlight>
{{out}}
Line 1,049 ⟶ 1,572:
"took a golden ball, and threw it up on high and caught it, and this ball was her"
"favorite plaything.")</pre>
=={{header|D}}==
===Standard Version===
<
immutable frog =
"In olden times when wishing still helped one, there lived a king
Line 1,068 ⟶ 1,590:
foreach (width; [72, 80])
writefln("Wrapped at %d:\n%s\n", width, frog.wrap(width));
}</
{{out}}
<pre>Wrapped at 72:
Line 1,095 ⟶ 1,617:
Basic algorithm. The text splitting is lazy.
{{trans|Go}}
<
string wrap(in string text, in int lineWidth) {
Line 1,129 ⟶ 1,651:
foreach (width; [72, 80])
writefln("Wrapped at %d:\n%s\n", width, frog.wrap(width));
}</
{{out}}
<pre>Wrapped at 72:
Line 1,151 ⟶ 1,673:
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.</pre>
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
<syntaxhighlight lang="Delphi">
const TestStr: string =
'In olden times when wishing still helped one, there lived a king whose '+
'daughters were all beautiful, but the youngest was so beautiful that the '+
'sun itself, which has seen so much, was astonished whenever it shone in '+
'her face. Close by the king''''s castle lay a great dark forest, and under '+
'an old lime tree in the forest was a well, and when the day was very '+
'warm, the king''''s child went out into the forest and sat down by the side '+
'of the cool fountain, and when she was bored she took a golden ball, and '+
'threw it up on high and caught it, and this ball was her favorite plaything.';
function ExtractToken(S: string; Sep: TASCIICharSet; var P: integer): string;
{Extract token from S, starting at P up to but not including Sep}
{Terminates with P pointing past Sep or past end of string}
var C: char;
begin
Result:='';
while P<=Length(S) do
begin
C:=S[P]; Inc(P);
if C in Sep then break
else Result:=Result+C;
end;
end;
function WrapLines(S: string; WrapCol: integer): string;
{Returns S, with lines wrapped a specified column}
var Inx,J: integer;
var WordStr,LineStr: string;
begin
Result:='';
Inx:=1;
LineStr:='';
while true do
begin
{Grab next word}
WordStr:=ExtractToken(S,[#$20,#$09,#$0D,#$0A],Inx);
{Check to see if adding this word will exceed the column}
if (Length(LineStr)+Length(WordStr))<WrapCol then
begin
{If not, add to current line}
if Length(LineStr)>0 then LineStr:=LineStr+' ';
LineStr:=LineStr+WordStr;
end
else
begin
{Save the line to the output string}
Result:=Result+LineStr+CRLF;
LineStr:=WordStr;
end;
if Inx>Length(S) then break;
end;
if Length(LineStr)>0 then Result:=Result+LineStr;
end;
procedure DrawRuler(Memo: TMemo);
begin
Memo.Lines.Add(' 5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80');
Memo.Lines.Add('----+----|----+----|----+----|----+----|----+----|----+----|----+----|----+----|');
end;
procedure ShowWordWrap(Memo: TMemo);
var S: string;
begin
DrawRuler(Memo);
S:=WrapLines(TestStr,60);
Memo.Lines.Add(S);
DrawRuler(Memo);
S:=WrapLines(TestStr,40);
Memo.Lines.Add(S);
DrawRuler(Memo);
S:=WrapLines(TestStr,20);
Memo.Lines.Add(S);
end;
</syntaxhighlight>
{{out}}
<pre>
Wrap at column 60
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80
----+----|----+----|----+----|----+----|----+----|----+----|----+----|----+----|
In olden times when wishing still helped one, there lived a
king whose daughters were all beautiful, but the youngest
was so beautiful that the sun itself, which has seen so
much, was astonished whenever it shone in her face. Close
by the king''s castle lay a great dark forest, and under an
old lime tree in the forest was a well, and when the day
was very warm, the king''s child went out into the forest
and sat down by the side of the cool fountain, and when she
was bored she took a golden ball, and threw it up on high
and caught it, and this ball was her favorite plaything.
Wrap at column 40
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80
----+----|----+----|----+----|----+----|----+----|----+----|----+----|----+----|
In olden times when wishing still
helped one, there lived a king whose
daughters were all beautiful, but the
youngest was so beautiful that the sun
itself, which has seen so much, was
astonished whenever it shone in her
face. Close by the king''s castle lay a
great dark forest, and under an old
lime tree in the forest was a well,
and when the day was very warm, the
king''s child went out into the forest
and sat down by the side of the cool
fountain, and when she was bored she
took a golden ball, and threw it up on
high and caught it, and this ball was
her favorite plaything.
Wrap at column 20
5 10 15 20 25 30 35 40 45 50 55 60 65 70 75 80
----+----|----+----|----+----|----+----|----+----|----+----|----+----|----+----|
In olden times when
wishing still helped
one, there lived a
king whose daughters
were all beautiful,
but the youngest was
so beautiful that
the sun itself,
which has seen so
much, was astonished
whenever it shone in
her face. Close by
the king''s castle
lay a great dark
forest, and under an
old lime tree in
the forest was a
well, and when the
day was very warm,
the king''s child
went out into the
forest and sat down
by the side of the
cool fountain, and
when she was bored
she took a golden
ball, and threw it
up on high and
caught it, and this
ball was her
favorite plaything.
Elapsed Time: 27.316 ms.
</pre>
=={{header|Dyalect}}==
<syntaxhighlight lang="dyalect">let loremIpsum = <[Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius sapien
vel purus hendrerit vehicula. Integer hendrerit viverra turpis, ac sagittis arcu
pharetra id. Sed dapibus enim non dui posuere sit amet rhoncus tellus
consectetur. Proin blandit lacus vitae nibh tincidunt cursus. Cum sociis natoque
penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam tincidunt
purus at tortor tincidunt et aliquam dui gravida. Nulla consectetur sem vel
felis vulputate et imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta
tortor. Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,
condimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc sed
venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu
nibh.]>
func wrap(text, lineWidth) {
String.Concat(values: wrapWords(text.Split('\s', '\r', '\n'), lineWidth))
}
and wrapWords(words, lineWidth) {
var currentWidth = 0
for word in words {
if currentWidth != 0 {
if currentWidth + word.Length() < lineWidth {
currentWidth += 1
yield " "
} else {
currentWidth = 0
yield "\n"
}
}
currentWidth += word.Length()
yield word
}
}
and printWrap(at) {
print("Wrap at \(at):")
print(wrap(loremIpsum, at))
print()
}
printWrap(at: 72)
printWrap(at: 80)</syntaxhighlight>
{{out}}
<pre>Wrap at 72:
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius
sapien vel purus hendrerit vehicula. Integer hendrerit viverra turpis,
ac sagittis arcu pharetra id. Sed dapibus enim non dui posuere sit amet
rhoncus tellus consectetur. Proin blandit lacus vitae nibh tincidunt
cursus. Cum sociis natoque penatibus et magnis dis parturient montes,
nascetur ridiculus mus. Nam tincidunt purus at tortor tincidunt et
aliquam dui gravida. Nulla consectetur sem vel felis vulputate et
imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta tortor.
Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,
condimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc
sed venenatis feugiat, augue orci pellentesque risus, nec pretium lacus
enim eu nibh.
Wrap at 80:
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius sapien
vel purus hendrerit vehicula. Integer hendrerit viverra turpis, ac sagittis arcu
pharetra id. Sed dapibus enim non dui posuere sit amet rhoncus tellus
consectetur. Proin blandit lacus vitae nibh tincidunt cursus. Cum sociis natoque
penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam tincidunt
purus at tortor tincidunt et aliquam dui gravida. Nulla consectetur sem vel
felis vulputate et imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta
tortor. Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,
condimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc sed
venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu
nibh.</pre>
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
linew = 40
#
ind = 1
repeat
if ind > len words$[]
inp$ = input
words$[] = strsplit inp$ " "
ind = 1
.
until inp$ = ""
w$ = words$[ind]
ind += 1
if len out$ + len w$ + 1 <= linew
if out$ <> ""
out$ &= " "
.
out$ &= w$
else
print out$
out$ = w$
.
.
print out$
#
input_data
In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime-tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything.’
</syntaxhighlight>
=={{header|Elena}}==
ELENA 6.x :
<syntaxhighlight lang="elena">import extensions;
import system'routines;
import extensions'text;
string text =
"In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything.";
extension wrapOp
{
wrap(int lineWidth)
{
int currentWidth := 0;
^ TokenEnumerator
.new(self)
.selectBy::(word)
{
currentWidth += word.Length;
if (currentWidth > lineWidth)
{
currentWidth := word.Length + 1;
^ newLineConstant + word + " "
}
else
{
currentWidth += 1;
^ word + " "
}
}
.summarize(new StringWriter())
}
}
public program()
{
console.printLine(new StringWriter("-", 72));
console.printLine(text.wrap(72));
console.printLine(new StringWriter("-", 80));
console.printLine(text.wrap(80));
}</syntaxhighlight>
{{out}}
<pre>
------------------------------------------------------------------------
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
--------------------------------------------------------------------------------
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Elixir}}==
{{trans|Erlang}}
<
def paragraph( string, max_line_length ) do
[word | rest] = String.split( string, ~r/\s+/, trim: true )
Line 1,180 ⟶ 2,056:
IO.puts String.duplicate("-", len)
IO.puts Word_wrap.paragraph(text, len)
end)</
{{out}}
Line 1,200 ⟶ 2,076:
=={{header|Erlang}}==
<syntaxhighlight lang="erlang">
-module( word_wrap ).
Line 1,206 ⟶ 2,082:
paragraph( String, Max_line_length ) ->
task() ->
lines( [Word | T], Max_line_length ) ->
lines_assemble( Word, {Max, Line_length, Line, Acc} ) when erlang:length(Word) + Line_length > Max -> {Max, erlang:length(Word), Word, [Line | Acc]};
lines_assemble( Word, {Max, Line_length, Line, Acc} ) -> {Max, Line_length + 1 + erlang:length(Word), Line ++ " " ++ Word, Acc}.
</syntaxhighlight>
{{out}}
<pre>
Line 1,242 ⟶ 2,118:
=={{header|F_Sharp|F#}}==
{{trans|C#}}
<
let LoremIpsum = "
Line 1,281 ⟶ 2,157:
Wrap l n |> Seq.iter (printf "%s")
printfn ""
0</
{{out}}
<pre style="font-size:smaller">------------------------------------------------------------------------
Line 1,308 ⟶ 2,184:
venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu
nibh.</pre>
=={{header|Factor}}==
<syntaxhighlight lang="factor">USE: wrap.strings
IN: scratchpad "Most languages in widespread use today are applicative languages
: the central construct in the language is some form of function call, where a f
unction is applied to a set of parameters, where each parameter is itself the re
sult of a function call, the name of a variable, or a constant. In stack languag
es, a function call is made by simply writing the name of the function; the para
meters are implicit, and they have to already be on the stack when the call is m
ade. The result of the function call (if any) is then left on the stack after th
e function returns, for the next function to consume, and so on. Because functio
ns are invoked simply by mentioning their name without any additional syntax, Fo
rth and Factor refer to functions as words, because in the syntax they really ar
e just words." [ 60 wrap-string print nl ] [ 45 wrap-string print ] bi</syntaxhighlight>
{{out}}
<pre>
Most languages in widespread use today are applicative
languages: the central construct in the language is some
form of function call, where a function is applied to a set
of parameters, where each parameter is itself the result of
a function call, the name of a variable, or a constant. In
stack languages, a function call is made by simply writing
the name of the function; the parameters are implicit, and
they have to already be on the stack when the call is made.
The result of the function call (if any) is then left on
the stack after the function returns, for the next function
to consume, and so on. Because functions are invoked simply
by mentioning their name without any additional syntax,
Forth and Factor refer to functions as words, because in the
syntax they really are just words.
Most languages in widespread use today are
applicative languages: the central construct
in the language is some form of function
call, where a function is applied to a set
of parameters, where each parameter is itself
the result of a function call, the name of a
variable, or a constant. In stack languages,
a function call is made by simply writing
the name of the function; the parameters are
implicit, and they have to already be on the
stack when the call is made. The result of
the function call (if any) is then left on
the stack after the function returns, for the
next function to consume, and so on. Because
functions are invoked simply by mentioning
their name without any additional syntax,
Forth and Factor refer to functions as words,
because in the syntax they really are just
words.
</pre>
=={{header|Forth}}==
<
\ usage: gforth wrap.f in.txt 72
Line 1,335 ⟶ 2,262:
2dup strip-nl
.wrapped
bye</
=={{header|Fortran}}==
Early Fortran provided no facility for manipulating text until the A format code was introduced by Fortran 4 that allowed characters to be read into variables, which could then be manipulated and written out. F77 introduced the CHARACTER data type which however did not have a notion of a variable-length string, other than via the programmer keeping track with auxiliary variables. F90 enabled the introduction via user-written functions and data types of a string-like facility, whereby a CHARACTER type variable would be resized on assignment. F95 formalised this facility as a part of the language.
There are no facilities for "flowing" text on output according to a specified width, though various direct methods are possible. For instance, given a variable containing thousands of characters, <
...
DO I = 0,120
WRITE (6,*) TEXT(I*80 + 1:(I + 1)*80)
END DO</
would write forth the text with eighty characters per line, paying no attention to the content when it splits a line.
Line 1,354 ⟶ 2,281:
Should there be no suitable split in the fragment being appended, then, arbitrarily, if that fragment is short then it is not appended: the line is rolled with trailing spaces. But if it has more than six characters, it will be placed and a crude chop made.
<syntaxhighlight lang="fortran">
MODULE RIVERRUN
INTEGER BL,BLIMIT,BM
PARAMETER (BLIMIT = 222)
CHARACTER*(BLIMIT) BUMF
INTEGER OUTBUMF
DATA OUTBUMF/0/
PRIVATE BL,BLIMIT,BM
PRIVATE BUMF,OUTBUMF
CONTAINS
INTEGER FUNCTION LSTNB(TEXT) !Sigh. Last Not Blank.
Concocted yet again by R.N.McLean (whom God preserve) December MM.
Code checking reveals that the Compaq compiler generates a copy of the string and then finds the length of that when using the latter-day intrinsic LEN_TRIM. Madness!
Can't DO WHILE (L.GT.0 .AND. TEXT(L:L).LE.' ')
Curse the morons who think it good that the compiler MIGHT evaluate logical expressions fully.
Crude GO TO rather than a DO-loop, because compilers use a loop counter as well as updating the index variable.
Line 1,374 ⟶ 2,301:
Checking the indexing of CHARACTER variables for bounds evoked astounding stupidities, such as calculating the length of TEXT(L:L) by subtracting L from L!
Comparison runs of GNASH showed a saving of ~25-30% in its mass data scanning for this, involving all its two-dozen or so single-character comparisons, not just in LSTNB.
CHARACTER*(*),INTENT(IN):: TEXT
INTEGER L
L = LEN(TEXT)
1 IF (L.LE.0) GO TO 2
IF (ICHAR(TEXT(L:L)).GT.ICHAR(" ")) GO TO 2
L = L - 1
GO TO 1
2 LSTNB = L
RETURN
END FUNCTION LSTNB
SUBROUTINE STARTFLOW(OUT,WIDTH)
INTEGER OUT
INTEGER WIDTH
OUTBUMF = OUT
BM = WIDTH
IF (BM.GT.BLIMIT) STOP "Too wide!"
BL = 0
END SUBROUTINE STARTFLOW!Simple enough.
SUBROUTINE FLOW(TEXT)
CHARACTER*(*) TEXT
INTEGER TL
INTEGER T1,T2
INTEGER L
IF (OUTBUMF.LT.0) STOP "Call STARTFLOW first!"
TL = LSTNB(TEXT)
IF (TL.LE.0) THEN
CALL FLUSH
RETURN
END IF
IF (TEXT(1:1).LE." ") CALL FLUSH
Chunks of TEXT are to be appended to BUMF.
T1 = 1
10 IF (BL.GT.0) THEN
BL = BL + 1
BUMF(BL:BL) = " "
END IF
Consider the amount of text to be placed, TEXT(T1:TL)
L = TL - T1 + 1
IF (BM - BL .GE. L) THEN
BUMF(BL + 1:BM + L) = TEXT(T1:TL)
BL = BL + L
IF (BL .GE. BM - 1) CALL FLUSH
RETURN
END IF
Calculate the available space up to the end of a line. BUMF(BL + 1:BM)
L = BM - BL
T2 = T1 + L
IF (TEXT(T2:T2) .LE. " ") GO TO 12
T2 = T2 - 1
11 IF (TEXT(T2:T2) .GT. " ") THEN
T2 = T2 - 1
IF (T2 .GT. T1) GO TO 11
IF (L .LE. 6) THEN
CALL FLUSH
GO TO 10
END IF
T2 = T1 + L - 1
END IF
L = T2 - T1 + 1
12 BUMF(BL + 1:BL + L) = TEXT(T1:T1 + L - 1)
BL = BL + L
CALL FLUSH
Consider what the flushed line didn't take. TEXT(T1 + L:TL)
T1 = T1 + L
13 IF (T1.GT.TL) RETURN
IF (TEXT(T1:T1).LE." ") THEN
T1 = T1 + 1
GO TO 13
END IF
IF (T1.LE.TL) GO TO 10!Does anything remain?
RETURN
CONTAINS
SUBROUTINE FLUSH
IF (BL.GT.0) WRITE (OUTBUMF,"(A)") BUMF(1:BL)
BL = 0
END SUBROUTINE FLUSH
END SUBROUTINE FLOW
END MODULE RIVERRUN
PROGRAM TEST
Line 1,472 ⟶ 2,399:
1 READ (IN,2) BUMF
2 FORMAT (A)
IF (BUMF(1:1).NE."C") GO TO 1
CALL STARTFLOW(MSG,66)
3 CALL FLOW(BUMF)
READ (IN,2) BUMF
IF (BUMF(1:1).EQ."C") GO TO 3
CALL FLOW("")
CLOSE (IN)
END</
Output: note that the chorus is presented with a leading space so as to force a new line start for it.
<pre>
Line 1,507 ⟶ 2,434:
</pre>
For text flowing purposes the actual source lister expected to find block comments with a space after the C (so that column three was the first character of the text to be flowed), so the above source would be listed as-is - except for overprinting key words and underlining, easy with a lineprinter but much more difficult on modern printers that expect a markup language instead.
=={{header|FreeBASIC}}==
<syntaxhighlight lang="freebasic">Dim Shared As String texto, dividido()
texto = "In olden times when wishing still helped one, there lived a king " &_
"whose daughters were all beautiful, but the youngest was so beautiful "&_
"that the sun itself, which has seen so much, was astonished whenever "&_
"it shone-in-her-face. Close-by-the-king's castle lay a great dark "&_
"forest, and under an old lime-tree in the forest was a well, and when "&_
"the day was very warm, the king's child went out into the forest and "&_
"sat down by the side of the cool-fountain, and when she was bored she "&_
"took a golden ball, and threw it up on high and caught it, and this "&_
"ball was her favorite plaything."
Sub Split(splitArray() As String, subject As String, delimitador As String = " ")
Dim As Integer esteDelim, sgteDelim, toks
Dim As String tok
Redim splitArray(toks)
Do While Strptr(subject)
sgteDelim = Instr(esteDelim + 1, subject, delimitador)
splitArray(toks) = Mid(subject, esteDelim + 1, sgteDelim - esteDelim - 1)
If sgteDelim = FALSE Then Exit Do
toks += 1
Redim Preserve splitArray(toks)
esteDelim = sgteDelim
Loop
End Sub
Sub WordWrap(s As String, n As Integer)
Split(dividido(),s," ")
Dim As String fila = ""
For i As Integer = 0 To Ubound(dividido)
If Len(fila) = 0 Then
fila = fila & dividido(i)
Elseif Len(fila & " " & dividido(i)) <= n Then
fila = fila & " " & dividido(i)
Else
Print fila
fila = dividido(i)
End If
Next i
If Len(fila) > 0 Then Print dividido(Ubound(dividido))
End Sub
Print "Ajustado a 72:"
WordWrap(texto,72)
Print !"\nAjustado a 80:"
WordWrap(texto,80)
Sleep
</syntaxhighlight>
{{out}}
<pre>
Ajustado a 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it
shone-in-her-face. Close-by-the-king's castle lay a great dark forest,
and under an old lime-tree in the forest was a well, and when the day
was very warm, the king's child went out into the forest and sat down by
the side of the cool-fountain, and when she was bored she took a golden
ball, and threw it up on high and caught it, and this ball was her
plaything.
Ajustado a 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone-in-her-face.
Close-by-the-king's castle lay a great dark forest, and under an old lime-tree
in the forest was a well, and when the day was very warm, the king's child went
out into the forest and sat down by the side of the cool-fountain, and when she
was bored she took a golden ball, and threw it up on high and caught it, and
plaything.
</pre>
=={{header|Go}}==
Basic task, no extra credit.
<
import (
Line 1,552 ⟶ 2,556:
fmt.Println("wrapped at 72:")
fmt.Println(wrap(frog, 72))
}</
{{out}}
<pre>
Line 1,579 ⟶ 2,583:
'''Solution 1: Imperative Style'''
<
def sb = new StringBuilder()
def line = ''
Line 1,591 ⟶ 2,595:
}
sb.append(line.trim()).toString()
}</
Testing:
<
In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
Line 1,605 ⟶ 2,609:
println wordWrap(text)
println wordWrap(text, 120)</
{{out}}
<pre>In olden times when wishing still helped one, there lived a king whose daughters
Line 1,625 ⟶ 2,629:
A solution using the groovy list.inject method which corresponds to foldLeft in other languages.
<
String wordWrap(str, width=80) {
str.tokenize(' ').inject([[]]) { rows, word ->
Line 1,632 ⟶ 2,636:
}.collect { it.join(' ') }.join('\n')
}
</syntaxhighlight>
this solution shows off the more functional aspects of groovy.
Line 1,642 ⟶ 2,646:
Throwing away all readability, using a number of groovy tricks (abusing default parameter values etc) and just going for performance and terseness of code we get the following:
<
import groovy.transform.TailRecursive
import static java.lang.Math.min
Line 1,651 ⟶ 2,655:
b.length()+w >= len ? b << str[i..-1] : wordWrap(str, w, min(x+w+1, len), b, len, 0)
}
</syntaxhighlight>
Should be noted that this is not idiomatic groovy or a recommended way of programming, but it is interesting as an exercise.
Line 1,661 ⟶ 2,665:
Note that this solution uses recursion and the @TailRecursive annotation which expands the recursive calls into a non-recursive loop at runtime, thus avoiding stack overflow exceptions for large data sets. Note also that the following expressions are equivalent:
<
def a = new StringBuilder()
def a = '' << ''
</
Should also be noted that this solution ignores and breaks for the case where words are longer than a line. I have a version which takes this case into account but I figured this was unreadable enough.
Line 1,674 ⟶ 2,678:
=={{header|Haskell}}==
Greedy wrapping:
<syntaxhighlight lang="haskell">ss =
concat
[ "In olden times when wishing still helped one, there lived a king"
, "whose daughters were all beautiful, but the youngest was so beautiful"
, "that the sun itself, which has seen so much, was astonished whenever"
, "sat down by the side of the cool fountain, and when she was bored she"
, "took a golden ball, and threw it up on high and caught it, and this"
, "ball was her favorite plaything."
]
wordwrap maxlen =
where
wrap_ pos (w:ws)
-- at line start: put down the word no matter what
| otherwise = ' ' : w ++ wrap_ (pos + lw + 1) ws
where
lw = length w
main = mapM_ putStr [wordwrap 72 ss, "\n", wordwrap 32 ss]</syntaxhighlight>
Alternative greedy wrapping: <
wWrap :: Int -> String -> String
wWrap n =
unlines
. map unwords
. wWrap'' n
. words
. concat
. lines
wWrap'' _ [] = []
wWrap'' n ss =
(\(a, b) -> a : wWrap'' n b) $
last . filter ((<= n) . length . unwords . fst) $
zip (inits ss) (tails ss)
main :: IO ()
main =
putStrLn $
wWrap 80 $
concat
[ "In olden times when wishing still helped one,",
" there lived a king whose daughters were all",
" beautiful, but the youngest was so beautiful",
" that the sun itself, which has seen so much,",
" was astonished whenever, it shone in her",
" face. Close by the king's castle lay a great",
" dark forest, and under an old lime-tree in",
" the forest was a well, and when the day was",
" very warm, the king's child went out into the",
" forest and sat down by the side of the cool",
" fountain, and when she was bored she took a",
" golden ball, and threw it up on high and",
" caught it, and this ball was her favorite",
" plaything."
]</syntaxhighlight>
=={{header|Icon}} and {{header|Unicon}}==
Line 1,725 ⟶ 2,749:
The following works in both languages.
<
procedure main(A)
ll := integer(A[1]) | 72
Line 1,746 ⟶ 2,770:
if *trim(l) = 0 then suspend "\n" # Paragraph boundary
}
end</
Sample runs:
Line 1,780 ⟶ 2,804:
->
</pre>
=={{header|IS-BASIC}}==
The word warp, any kind of text alignment, specifying tab positions are basic services of the EXOS operating system.
<syntaxhighlight lang="is-basic">100 TEXT 80
110 CALL WRITE(12,68,0)
120 PRINT :CALL WRITE(10,70,1)
130 DEF WRITE(LEFTMARGIN,RIGHTMARGIN,JUSTIFIED)
140 STRING S$*254
150 RESTORE
160 PRINT TAB(LEFTMARGIN);CHR$(243);
170 PRINT TAB(RIGHTMARGIN-1);CHR$(251)
180 DO
190 READ IF MISSING EXIT DO:S$
200 PRINT S$;
210 LOOP
220 IF JUSTIFIED THEN PRINT CHR$(248) ! <- Extra credit :-)
230 PRINT
240 END DEF
250 DATA "In olden times when wishing still helped one, there lived a king whose daughters were all beautiful, but the youngest was so beautiful that the sun itself, which has seen so much, was astonished whenever it shone in her face. "
260 DATA "Close by the king's castle lay a great dark forest, and under an old lime-tree in the forest was a well, and when the day was very warm, the king's child went out into the forest and sat down by the side of the cool fountain, "
270 DATA "and when she was bored she took a golden ball, and threw it up on high and caught it, and this ball was her favorite plaything."
</syntaxhighlight>
{{out}}
<pre> In olden times when wishing still helped one, there
lived a king whose daughters were all beautiful, but the
youngest was so beautiful that the sun itself, which has
seen so much, was astonished whenever it shone in her
face. Close by the king's castle lay a great dark
forest, and under an old lime-tree in the forest was a
well, and when the day was very warm, the king's child
went out into the forest and sat down by the side of the
cool fountain, and when she was bored she took a golden
ball, and threw it up on high and caught it, and this
ball was her favorite plaything.
In olden times when wishing still helped one, there lived a
king whose daughters were all beautiful, but the youngest
was so beautiful that the sun itself, which has seen so
much, was astonished whenever it shone in her face. Close by
the king's castle lay a great dark forest, and under an old
lime-tree in the forest was a well, and when the day was
very warm, the king's child went out into the forest and sat
down by the side of the cool fountain, and when she was
bored she took a golden ball, and threw it up on high and
caught it, and this ball was her favorite plaything.</pre>
=={{header|J}}==
'''Solution''':<
wrap =: (] turn edges) ,&' '
turn =: LF"_`]`[}
edges =: (_1 + ] #~ 1 ,~ 2 >/\ |) [: +/\ #;.2</
'''Example''':<
ww GA NB. Wrap at 75 chars by default
Line 1,801 ⟶ 2,871:
dedicated to the
proposition that all men
were created equal.</
=={{header|Java}}==
<
package rosettacode;
Line 1,811 ⟶ 2,881:
public class WordWrap
{
{
}
{
{
{
}
{
}
}
}
{
}
}
</syntaxhighlight>
=={{header|JavaScript}}==
===Recursive===
'''Solution''':<
function wrap (text, limit) {
if (text.length > limit) {
Line 1,868 ⟶ 2,937:
return text;
}
</syntaxhighlight>
'''Example''':<
console.log(wrap(text, 80));
</syntaxhighlight>
{{out}}
Line 1,881 ⟶ 2,950:
</pre>
'''Example''':<
console.log(wrap(text, 42));
</syntaxhighlight>
{{out}}
Line 1,900 ⟶ 2,969:
A simple regex suffices (and proves fastest) for the greedy version:
<
'use strict';
Line 1,922 ⟶ 2,991:
)
})(60);</
{{Out}}
Line 1,934 ⟶ 3,003:
=== EcmaScript 6 ===
<
/**
* [wordwrap description]
Line 1,991 ⟶ 3,060:
}).join('\n'); // Объединяем элементы массива по LF
}
</syntaxhighlight>
'''Example'''<
console.log(wordwrap("The quick brown fox jumped over the lazy dog.", 20, "<br />\n"));
</syntaxhighlight>
{{out}}
Line 2,007 ⟶ 3,076:
In jq, all strings are Unicode strings, for which the length is calculated as the number of codepoints.
<
# Note: very long words are not truncated.
# input: a string
Line 2,020 ⟶ 3,089:
then .[-1] += ($pad * " ") + $word
else . + [ $word]
end );</
'''Task 1''':
<
{{Out}}
aaa bb
Line 2,028 ⟶ 3,097:
ddddd
'''Task 2''':
<
{{Out}}
aaa
Line 2,036 ⟶ 3,105:
'''With input from a file''': Russian.txt
<div style="overflow:scroll; height:100px;">
<
менее 100 советских самолетов поднялись в воздух, когдаамериканские
авианосцы "Уинсон" и "Мидуэй" приблизились на 50 миль к Владивостоку.
</
'''Main''':
wrap_text(40)[]
{{Out}}
<
советских военных судов и самолетов была
отмечена в Японском море после появления
Line 2,051 ⟶ 3,120:
"Уинсон" и "Мидуэй" приблизились на 50
миль к Владивостоку.
</syntaxhighlight>
=={{header|Julia}}==
{{works with|Julia|0.6}}
Using [https://github.com/carlobaldassi/TextWrap.jl TextWrap.jl] library.
<syntaxhighlight lang="julia">using TextWrap
text = """Reformat the single paragraph in 'text' to fit in lines of no more
than 'width' columns, and return a new string containing the entire
wrapped paragraph. As with wrap(), tabs are expanded and other
whitespace characters converted to space. See TextWrapper class for
available keyword args to customize wrapping behaviour."""
println("# Wrapped at 80 chars")
print_wrapped(text, width=80)
println("\n\n# Wrapped at 70 chars")
print_wrapped(text, width=70)</syntaxhighlight>
{{out}}
<pre># Wrapped at 80 chars
Reformat the single paragraph in 'text' to fit in lines of no more than 'width'
columns, and return a new string containing the entire wrapped paragraph. As
with wrap(), tabs are expanded and other whitespace characters converted to
space. See TextWrapper class for available keyword args to customize wrapping
behaviour.
# Wrapped at 70 chars
Reformat the single paragraph in 'text' to fit in lines of no more
than 'width' columns, and return a new string containing the entire
wrapped paragraph. As with wrap(), tabs are expanded and other
whitespace characters converted to space. See TextWrapper class for
available keyword args to customize wrapping behaviour.</pre>
=={{header|Klingphix}}==
<syntaxhighlight lang="klingphix">:wordwrap %long !long
%ps 0 !ps
split
len [ drop
pop swap len $ps + !ps
$ps $long > [ len !ps nl ] if
print " " print
$ps 1 + !ps
] for
drop
;
"tlhIngan Hol jatlhwI', pIvan. ghomuv! nItebHa' mu'ghomvam wIchenmoHlaH. boQchugh Hoch, mu'ghom Dun mojlaH.
tlhIngan maH! Qapla'! DaH tlhIngan Hol mu'ghom'a' Dalegh. qawHaqvam chenmoHlu'DI' 'oHvaD wIqIpe'DIya ponglu'.
'ach jInmolvamvaD Saghbe'law' tlhIngan Hol, DIS 2005 'oH mevmoHlu'. 'ach DIS 2006 jar wa'maHcha'DIch Wikia jInmolDaq vIHta'.
Hov lengvaD chenmoHlu' tlhIngan Hol'e' 'ej DaH 'oH ghojtaH ghot law'. Qapbej Holvam wIcha'meH, qawHaqvam chenmoHlu'.
taHjaj wo', taHjaj Hol! Sov qawHaq tlhab 'oH 'ej ghItlhmey DIqonmeH tlhIngan Hol wIlo'. ghItlhmey chenmoHlaH 'ej choHlaH tlhIngan Hol
jatlhlaHbogh Hoch ghotpu''e'. wej tIn Sov qawHaqvam, 'ach ghurlI' 'e' wItul. DaH 229 ghItlhmey ngaS.
vay' Daghel DaneHchugh qoj vay' Dachup DaneHchugh, vaj tachDaq maghom."
dup
72 wordwrap nl nl
100 wordwrap nl nl
"End " input</syntaxhighlight>
{{out}}
<pre>tlhIngan Hol jatlhwI', pIvan. ghomuv! nItebHa' mu'ghomvam wIchenmoHlaH.
boQchugh Hoch, mu'ghom Dun mojlaH. tlhIngan maH! Qapla'! DaH tlhIngan
Hol mu'ghom'a' Dalegh. qawHaqvam chenmoHlu'DI' 'oHvaD wIqIpe'DIya
ponglu'. 'ach jInmolvamvaD Saghbe'law' tlhIngan Hol, DIS 2005 'oH
mevmoHlu'. 'ach DIS 2006 jar wa'maHcha'DIch Wikia jInmolDaq vIHta'. Hov
lengvaD chenmoHlu' tlhIngan Hol'e' 'ej DaH 'oH ghojtaH ghot law'. Qapbej
Holvam wIcha'meH, qawHaqvam chenmoHlu'. taHjaj wo', taHjaj Hol! Sov
qawHaq tlhab 'oH 'ej ghItlhmey DIqonmeH tlhIngan Hol wIlo'. ghItlhmey
chenmoHlaH 'ej choHlaH tlhIngan Hol jatlhlaHbogh Hoch ghotpu''e'. wej
tIn Sov qawHaqvam, 'ach ghurlI' 'e' wItul. DaH 229 ghItlhmey ngaS. vay'
Daghel DaneHchugh qoj vay' Dachup DaneHchugh, vaj tachDaq maghom.
tlhIngan Hol jatlhwI', pIvan. ghomuv! nItebHa' mu'ghomvam wIchenmoHlaH. boQchugh Hoch, mu'ghom Dun
mojlaH. tlhIngan maH! Qapla'! DaH tlhIngan Hol mu'ghom'a' Dalegh. qawHaqvam chenmoHlu'DI' 'oHvaD
wIqIpe'DIya ponglu'. 'ach jInmolvamvaD Saghbe'law' tlhIngan Hol, DIS 2005 'oH mevmoHlu'. 'ach DIS
2006 jar wa'maHcha'DIch Wikia jInmolDaq vIHta'. Hov lengvaD chenmoHlu' tlhIngan Hol'e' 'ej DaH 'oH
ghojtaH ghot law'. Qapbej Holvam wIcha'meH, qawHaqvam chenmoHlu'. taHjaj wo', taHjaj Hol! Sov qawHaq
tlhab 'oH 'ej ghItlhmey DIqonmeH tlhIngan Hol wIlo'. ghItlhmey chenmoHlaH 'ej choHlaH tlhIngan Hol
jatlhlaHbogh Hoch ghotpu''e'. wej tIn Sov qawHaqvam, 'ach ghurlI' 'e' wItul. DaH 229 ghItlhmey ngaS.
vay' Daghel DaneHchugh qoj vay' Dachup DaneHchugh, vaj tachDaq maghom.
End</pre>
=={{header|Kotlin}}==
<syntaxhighlight lang="scala">// version 1.1.3
val text =
"In olden times when wishing still helped one, there lived a king " +
"whose daughters were all beautiful, but the youngest was so beautiful " +
"that the sun itself, which has seen so much, was astonished whenever " +
"it shone in her face. Close by the king's castle lay a great dark " +
"forest, and under an old lime tree in the forest was a well, and when " +
"the day was very warm, the king's child went out into the forest and " +
"sat down by the side of the cool fountain, and when she was bored she " +
"took a golden ball, and threw it up on high and caught it, and this " +
"ball was her favorite plaything."
fun greedyWordwrap(text: String, lineWidth: Int): String {
val words = text.split(' ')
val sb = StringBuilder(words[0])
var spaceLeft = lineWidth - words[0].length
for (word in words.drop(1)) {
val len = word.length
if (len + 1 > spaceLeft) {
sb.append("\n").append(word)
spaceLeft = lineWidth - len
}
else {
sb.append(" ").append(word)
spaceLeft -= (len + 1)
}
}
return sb.toString()
}
fun main(args: Array<String>) {
println("Greedy algorithm - wrapped at 72:")
println(greedyWordwrap(text, 72))
println("\nGreedy algorithm - wrapped at 80:")
println(greedyWordwrap(text, 80))
}</syntaxhighlight>
{{out}}
<pre>
Greedy algorithm - wrapped at 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
Greedy algorithm - wrapped at 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Lambdatalk}}==
The test text will be the third first paragraphs of Jules Verne's book, The Mysterious Island.
<syntaxhighlight lang="scheme">
{def text
Personne n’a sans doute oublié le terrible coup de vent de nord-est qui se déchaîna au milieu de l’équinoxe de cette année, et pendant lequel le baromètre tomba à sept cent dix millimètres. Ce fut un ouragan, sans intermittence, qui dura du 18 au 26 mars. Les ravages qu’il produisit furent immenses en Amérique, en Europe, en Asie, sur une zone large de dix-huit cents milles, qui se dessinait obliquement à l’équateur, depuis le trente-cinquième parallèle nord jusqu’au quarantième parallèle sud ! (L’île mystérieuse / Jules Verne)}
-> text
</syntaxhighlight>
1) lambdatalk can simply call HTML tags and CSS rules:
<syntaxhighlight lang="scheme">
{def wrap1
{lambda {:n}
pre {@ style="width::npx; // the line width in pixels
white-space:pre-wrap; "}}} // the word-wrap rule
-> wrap1
{{wrap1 500} {text}}
->
Personne n’a sans doute oublié le terrible coup de vent de nord-est
qui se déchaîna au milieu de l’équinoxe de cette année, et pendant
lequel le baromètre tomba à sept cent dix millimètres. Ce fut un
ouragan, sans intermittence, qui dura du 18 au 26 mars. Les ravages
qu’il produisit furent immenses en Amérique, en Europe, en Asie, sur
une zone large de dix-huit cents milles, qui se dessinait obliquement
à l’équateur, depuis le trente-cinquième parallèle nord jusqu’au
quarantième parallèle sud ! (L’île mystérieuse / Jules Verne)
</syntaxhighlight>
2) a lambdatalk function
A translation from the Kotlin entry:
<syntaxhighlight lang="scheme">
{def wrap2 // the function's name
{def wrap2.r // recursive "loop"
{lambda {:linewidth :a1 :spaceleft :a2}
{if {A.empty? :a1} // it's the end so ...
then {A.toS :a2} // ... return the sentence
else {let { {:linewidth :linewidth} // local variables
{:spaceleft :spaceleft} // lambdatalk has no closure
{:a1 :a1} // so we recall outers values
{:a2 :a2} // ... manually
{:word {A.first :a1}} // get the first word
{:length {W.length {A.first :a1}}} // compute its length
} {wrap2.r // do it again with
:linewidth // the linewidth unchanged
{A.rest :a1} // the rest of array
{if {> {+ :length 1} :spaceleft} // if ...
then {- :linewidth :length} // then update spaceleft and
{A.addlast! {br}:word :a2} // push a breakline and the word
else {- :spaceleft {+ :length 1}} // else update spaceleft and
{A.addlast! :word :a2}} }}}}} // push the word
{lambda {:linewidth :text} // a function with 2 arguments
{wrap2.r :linewidth // call the recursive "loop"
{A.rest {A.new :text}} // the input as an array minus first word
{- :linewidth {W.length {S.get 0 :text}}} // compute spaceleft
{A.new {S.get 0 :text}}}}} // the output as an array plus first word
-> wrap2
{wrap2 70 {text}} ->
Personne n’a sans doute oublié le terrible coup de vent de
nord-est qui se déchaîna au milieu de l’équinoxe de cette
année, et pendant lequel le baromètre tomba à sept cent dix
millimètres. Ce fut un ouragan, sans intermittence, qui dura
du 18 au 26 mars. Les ravages qu’il produisit furent
immenses en Amérique, en Europe, en Asie, sur une zone large
de dix-huit cents milles, qui se dessinait obliquement à
l’équateur, depuis le trente-cinquième parallèle nord
jusqu’au quarantième parallèle sud ! (L’île mystérieuse /
Jules Verne)
</syntaxhighlight>
3) A translation of the javascript entry. The {jswrap n text} function contains lines until n characters
<syntaxhighlight lang="javascript">
LAMBDATALK.DICT['jswrap'] = function() {
var wrap = function(text, limit) {
if (text.length > limit) {
var edge = text.slice(0, limit).lastIndexOf(' ');
if (edge > 0) {
var line = text.slice(0, edge);
var remainder = text.slice(edge + 1);
return line + '\n' + wrap(remainder, limit);
}
}
return text;
};
var args = arguments[0].trim().split(" ");
var limit = parseInt(args.shift());
var text = args.join(" ");
return wrap(text,limit);
};
{jswrap 60 {text}} ->
Personne n’a sans doute oublié le terrible coup de vent de
nord-est qui se déchaîna au milieu de l’équinoxe de cette
année, et pendant lequel le baromètre tomba à sept cent dix
millimètres. Ce fut un ouragan, sans intermittence, qui
dura du 18 au 26 mars. Les ravages qu’il produisit furent
immenses en Amérique, en Europe, en Asie, sur une zone
large de dix-huit cents milles, qui se dessinait
obliquement à l’équateur, depuis le trente-cinquième
parallèle nord jusqu’au quarantième parallèle sud ! (L’île
mystérieuse / Jules Verne)
</syntaxhighlight>
=={{header|Lasso}}==
<
) => {
}
Line 2,066 ⟶ 3,393:
wordwrap(#text)
'<hr />'
wordwrap(#text, 90)</
-><pre>Lorem ipsum dolor sit amet, consectetur
Line 2,094 ⟶ 3,421:
{{trans|Erlang}}
<syntaxhighlight lang="lisp">
(defun wrap-text (text)
(wrap-text text 78))
Line 2,120 ⟶ 3,447:
((word `#(,max ,line-len ,line ,acc))
`#(,max ,(+ line-len 1 (length word)) ,(++ line " " word) ,acc)))
</syntaxhighlight>
=== Regex Implementation ===
<
(defun make-regex-str (max-len)
(++ "(.{1," (integer_to_list max-len) "}|\\S{"
Line 2,134 ⟶ 3,461:
(re:replace text find-patt replace-patt
'(global #(return list)))))
</syntaxhighlight>
Usage examples:
<syntaxhighlight lang="lisp">
> (set test-text (++ "Even today, with proportional fonts and complex layouts, there are still cases where you need to wrap text at a specified column. "
"The basic task is to wrap a paragraph of text in a simple way in your language. If there is a way to do this that is built-in, trivial, or "
"provided in a standard library, show that. Otherwise implement the minimum length greedy algorithm from Wikipedia.")
> (io:format (wrap-text text 80))
</syntaxhighlight>
<pre>
Even today, with proportional fonts and complex layouts, there are still cases
Line 2,152 ⟶ 3,479:
ok
</pre>
<
> (io:format (wrap-text text 50))
</syntaxhighlight>
<pre>
Even today, with proportional fonts and complex
Line 2,170 ⟶ 3,497:
Lingo/Director has 2 visual components for displaying text, text and field members. Both can soft-wrap text directly. In cases where you need a hard-wrapped representation of a text, this could e.g. be implemented like this:
(Note: this solution is meant for proportional fonts and based on actual text rendering. For the more trivial case of non-proportial font word wrapping, just pass a non-proportinal font like e.g. Courier in the 'style' argument)
<
----------------------------------------
Line 2,211 ⟶ 3,538:
channel(1).removeScriptedSprite()
return lines
end</
Usage:
<
"eiusmod tempor incidunt ut labore et dolore magna aliqua. Ut enim ad minim "&\
"veniam, quis nostrud exercitation ullamco laboris nisi ut aliquid ex ea commodi "&\
Line 2,224 ⟶ 3,551:
repeat with l in lines
put l
end repeat</
{{Out}}
<pre>
Line 2,247 ⟶ 3,574:
=={{header|Lua}}==
<
local res = {}
for w in s:gmatch("%S+") do
Line 2,291 ⟶ 3,618:
print(textwrap(example1))
print()
print(textwrap(example1, 60))</
{{out}}
Line 2,311 ⟶ 3,638:
</pre>
=={{header|
M2000 Environment (where actual a M2000 script executed) provide the means to print proportional text, in console, in layer in console form, in user windows layers, and in printer paper. To render proportional text we can use:
Print statement with styles from 4 to 10 (so 0 to 3 are non proportional, by default we use 0). Styles applied with $() print's internal function. So a Print $(4), set from current position the proportional style. This has word wrap, but stop at wrapping. Print statement not used for documents (or strings with paragraphs). We can print text with diacritics.
Report statement is the default renderer for text. Not only render text, but can be used to calculate the number of lines before actual render text. Report also prints in characters row, and can be used with Double statement to change temporary to Double height font. Also use Italic and Bold state. Also can print text with diacritics as Print statement can. Lead space from paragraph stay there, and spaces can be get bigger or smaller from original size, but not to small. Because we can give the width of the output (in character units, or in twips units), we can find easy the bounding box. Report statement when rendering to anything except console, stop rendering, after scrolling the 3/4 of layer height (the lower part which can scroll, maybe all the height, depends on setting split screen function), waiting for user to press space or a mouse button.
Legend Statement use Font and font size (Mode in M2000) for each call, and print text in graphic position, using alignment but not word warp, and we can use rotation. Functions size.x() and size.y() can return then dimension of the bounding box,
We can use controls on forms to render text, and EditBox has word wrap, and a state when no edit allowed, we can view/scroll text only.
This example use a text in a$, where first remove line breaks. Then set font to Tahoma, and console size to 80 characters by 50 lines, and display the current font size (automatic environment insert line space between text rows). Also display state for Bold and Italic. Then we get the text from 9th row, as proportional text, italic, centered with a width for lines as 60 characters width. Then ask for a keypress.
At the second phase, in a loop, render text twice, the first as is, the second changing color in each line. To perform that, it render once without displaying, get from ReportLines the number of lines, and then execute a for loop and do a partial display, but each time rendering starts from first line, and display from the line we choose, for lines we choose (first choose lines and next using Line choose the first line). Until now we didn't get somewhere in memory the actual lines, only in layer, displayed.
At the third phase, we can get in a document variable all lines (where actual made each line break). We can find the length in twips for each line, but this is with spaces with standard width. Report use spaces smaller or bigger than normal space, and do a distribution of pixels that can't be fit in all spaces chunks, mostly at the right chunks. So even using a non proportional font, we get from Report at rendering proportional spacings.
The inner editor of M2000 environment also works with Word Warp and can change it with F1 any time. Also EditBox can change with F1 word wrap, in user forms (windows).
All of these statements not handle tab character (9) as tab. Editor change tab with spaces, and Print/report/Legend prints tab as a square character (as for 9.4 version of M2000 Environment and Interpreter).
<syntaxhighlight lang="m2000 interpreter">
Module Checkit {
\\ leading space from begin of paragraph stay as is
a$={ In olden times when wishing still helped one, there
lived a king whose daughters were all beautiful, but the youngest
was so beautiful that the sun itself, which has seen so
much, was astonished whenever it shone in her face.
}
const crlf$=chr$(13)+chr$(10)
a$=replace$(crlf$, " ", a$)+crlf$
const justify=0
const flushright=1
const centered=2
const flushleft=3
\\ set layer font
Font "Tahoma"
Form 80, 50
Print "Font:";Fontname$
Print "Font size:";Mode;"pt"
Print "Bold:";Bold
Print "Italic:";Italic
\\ set left margin for Report
Cursor 10, 8 ' pos 10 row 8 (11 9 - it is 0 based)
m=Italic
Italic 1
Report centered, trim$(A$), Width-10-10
Italic m
Print @(0,79),"Press any key";
wait$=key$
Refresh 5000
charwidth=scale.x div width
For i=2000 to scale.x-charwidth step 150
\\ clear screen with 14pt fonts
Mode 12.75
\\ by default use justify, word wrap
Report a$, i
\\ we can calculate only using a negative parameter
Report a$, i, -10000
k=ReportLines
\\ print any line in differnet color
Dim a(2)
a(0)=11, 15 ' 0 to 15 are vb6 colors, we can use html colors #aabbcc, #ff2211
For j=1 to k {
Pen a(j mod 2) {
Report a$, i, 1 line j
}
}
Refresh 5000
wait$=key$
Next i
Report a$, scale.x/2, -1000
k=ReportLines
Document Doc$
Report a$, scale.x/2, k as Doc$
\\ Print document without expanding spaces
Print $(4), ' 4=proportional printing using columns, on line online, word wrap, expand to fit in columns
For i=1 to k {
Print "*";Paragraph$(Doc$, i);"*"
}
Print $(0), ' restore to non proportional printing
For i=1 to k {
Print i, size.x(Paragraph$(Doc$, i), Fontname$, Mode), size.y(Paragraph$(Doc$, i), Fontname$, Mode)
}
\\ scale.x unit in twips
Report a$, scale.x/2
\\ width unit in characters
Report a$, width/2
Print @(width div 2),
Report flushright, a$, width/2
Cursor 0, Row
I=Italic
Double
Italic 1
Report centered, a$
Italic I
Double
Normal
}
Checkit
</syntaxhighlight>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">string="In olden times when wishing still helped one, there lived a king whose daughters were all beautiful, but the youngest was so beautiful that the sun itself, which has seen so much, was astonished whenever it shone in her face. Close by the king's castle lay a great dark forest, and under an old lime-tree in the forest was a well, and when the day was very warm, the king's child went out into the forest and sat down by the side of the cool fountain, and when she was bored she took a golden ball, and threw it up on high and caught it, and this ball was her favorite plaything.";
wordWrap[textWidth_,spaceWidth_,string_]:=Module[{start,spaceLeft,masterString},
spaceLeft=textWidth;
Line 2,338 ⟶ 3,770:
];
StringJoin@@Riffle[masterString,"\n"]
];</
{{out}} for width 72 and 80:
<syntaxhighlight lang="text">wordWrap[72, 1, string]
wordWrap[80, 1, string]</
{{out}}
<pre>In olden times when wishing still helped one, there lived a king
Line 2,362 ⟶ 3,794:
her favorite plaything.</pre>
=={{header|MiniScript}}==
<syntaxhighlight lang="miniscript">str = "one two three four five six seven eight nine ten eleven!"
width = 15
words = str.split
pos = 0
line = ""
for word in words
pos = pos + word.len + 1
if pos <= width then
line = line + word + " "
else
print line[:-1]
line = word + " "
pos = word.len
end if
end for
print line[:-1]</syntaxhighlight>
{{out}}
<pre>
one two three
four five six
seven eight
nine ten
eleven!
</pre>
=={{header|NetRexx}}==
===version 1===
<
options replace format comments java crossref symbols
Line 2,441 ⟶ 3,898:
''
return speech01
</syntaxhighlight>
{{out}}
<pre style="height:15em; overflow:scroll">
Line 2,464 ⟶ 3,921:
===version 2===
<
* 23.08.2013 Walter Pachl translated from REXX version 2
**********************************************************************/
Line 2,491 ⟶ 3,948:
If s>'' Then
say s
return</
=={{header|Nim}}==
<
let txt = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur."
echo
echo ""
echo
</syntaxhighlight>
{{out}}
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus.
Line 2,519 ⟶ 3,976:
=={{header|OCaml}}==
<
let txt = "In olden times when wishing still helped one, there lived
Line 2,551 ⟶ 4,008:
) (0, "") words
in
print_endline (Buffer.contents buf)</
Testing:
Line 2,560 ⟶ 4,017:
$ ocaml word_wrap.ml 50 | wc -L
50</pre>
=={{header|Ol}}==
<syntaxhighlight lang="scheme">
(define (get-one-word start)
(let loop ((chars #null) (end start))
(let ((char (car end)))
(if (has? (list #\space #\newline) char)
(values (reverse chars) (force (cdr end)))
(loop (cons char chars) (force (cdr end)))))))
(define (get-all-words string)
(let loop ((words #null) (start (str-iter string)))
(let* ((word next (get-one-word start)))
(if (null? next)
(reverse words)
(loop (cons (runes->string word) words) next)))))
(define (get-one-line words n)
(let loop ((line #null) (words words) (i 0))
(let*((word (car words))
(len (string-length word)))
(if (null? (cdr words))
(values (reverse (cons word line)) #null)
(if (> (+ i len) n 1)
(values (reverse line) words)
(loop (cons word line) (cdr words) (+ i len 1)))))))
(define (get-all-lines words n)
(let loop ((lines #null) (words words))
(let* ((line words (get-one-line words n)))
(if (null? words)
(reverse (cons line lines))
(loop (cons line lines) words)))))
(define (hyphenation width string)
(let*((words (get-all-words string))
(lines (get-all-lines words width)))
lines))
</syntaxhighlight>
{{out}}
<pre>
; <== (print "{0---------1+++++++++2---------3+++++++++4---------5+++++++++6---------7+++++++++}")
; <== (for-each print (hyphenation 80 "In olden times when wishing still helped one, there lived a king whose daughters were all beautiful, but the youngest was so beautiful that the sun itself, which has seen so much, was astonished whenever it shone in her face. Close by the king's castle lay a great dark forest, and under an old lime-tree in the forest was a well, and when the day was very warm, the king's child went out into the forest and sat down by the side of the cool fountain, and when she was bored she took a golden ball, and threw it up on high and caught it, and this ball was her favorite plaything. "))
; ==> {0---------1+++++++++2---------3+++++++++4---------5+++++++++6---------7+++++++++}
; ==> (In olden times when wishing still helped one, there lived a king whose daughters)
; ==> (were all beautiful, but the youngest was so beautiful that the sun itself, which)
; ==> (has seen so much, was astonished whenever it shone in her face. Close by the)
; ==> (king's castle lay a great dark forest, and under an old lime-tree in the forest)
; ==> (was a well, and when the day was very warm, the king's child went out into the)
; ==> (forest and sat down by the side of the cool fountain, and when she was bored she)
; ==> (took a golden ball, and threw it up on high and caught it, and this ball was her)
; ==> (favorite)
</pre>
=={{header|PARI/GP}}==
<
my(t="",cur);
s=Vec(s);
Line 2,587 ⟶ 4,099:
King="And so let freedom ring from the prodigious hilltops of New Hampshire; let freedom ring from the mighty mountains of New York; let freedom ring from the heightening Alleghenies of Pennsylvania; let freedom ring from the snow-capped Rockies of Colorado; let freedom ring from the curvaceous slopes of California. But not only that: let freedom ring from Stone Mountain of Georgia; let freedom ring from Lookout Mountain of Tennessee; let freedom ring from every hill and molehill of Mississippi. From every mountainside, let freedom ring.";
wrap(King, 75)
wrap(King, 50)</
{{out}}
Line 2,615 ⟶ 4,127:
=={{header|Perl}}==
Regex. Also showing degraded behavior on very long words:
<
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
Line 2,632 ⟶ 4,144:
$_ = $s;
s/\s*(.{1,25})\s/$1\n/g, print;</
=={{header|Phix}}==
<!--<syntaxhighlight lang="phix">(phixonline)-->
<span style="color: #004080;">string</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"""In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful that the sun itself,
which has seen so much, was astonished whenever it shone in her face. Close by the king's
castle lay a great dark forest, and under an old lime-tree in the forest was a well, and
when the day was very warm, the king's child went out into the forest and sat down by the
side of the cool fountain, and when she was bored she took a golden ball, and threw it up
on high and caught it, and this ball was her favorite plaything."""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">" "</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">procedure</span> <span style="color: #000000;">word_wrap</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">,</span> <span style="color: #004080;">integer</span> <span style="color: #000000;">maxwidth</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">words</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">words</span><span style="color: #0000FF;">[</span><span style="color: #000000;">1</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">2</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">words</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">word</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">words</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span>
<span style="color: #008080;">if</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">line</span><span style="color: #0000FF;">)+</span><span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">word</span><span style="color: #0000FF;">)+</span><span style="color: #000000;">1</span><span style="color: #0000FF;">></span><span style="color: #000000;">maxwidth</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">line</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">line</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">word</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">line</span> <span style="color: #0000FF;">&=</span> <span style="color: #008000;">" "</span><span style="color: #0000FF;">&</span><span style="color: #000000;">word</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<span style="color: #7060A8;">puts</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">line</span><span style="color: #0000FF;">&</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">procedure</span>
<span style="color: #000000;">word_wrap</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">72</span><span style="color: #0000FF;">)</span>
<span style="color: #000000;">word_wrap</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">,</span><span style="color: #000000;">80</span><span style="color: #0000FF;">)</span>
<!--</syntaxhighlight>-->
{{Out}}
<pre>
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime-tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Phixmonti}}==
<syntaxhighlight lang="phixmonti">include ..\Utilitys.pmt
72 var long
0 >ps
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius sapien
vel purus hendrerit vehicula. Integer hendrerit viverra turpis, ac sagittis arcu
pharetra id. Sed dapibus enim non dui posuere sit amet rhoncus tellus
consectetur. Proin blandit lacus vitae nibh tincidunt cursus. Cum sociis natoque
penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam tincidunt
purus at tortor tincidunt et aliquam dui gravida. Nulla consectetur sem vel
felis vulputate et imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta
tortor. Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,
condimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc sed
venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu
nibh."
split
len for drop
pop swap len ps> + >ps
tps long > if ps> drop len >ps nl endif
print " " print
ps> 1 + >ps
endfor
drop ps> drop
</syntaxhighlight>
{{out}} 72 and 100.
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius
sapien vel purus hendrerit vehicula. Integer hendrerit viverra turpis,
ac sagittis arcu pharetra id. Sed dapibus enim non dui posuere sit amet
rhoncus tellus consectetur. Proin blandit lacus vitae nibh tincidunt
cursus. Cum sociis natoque penatibus et magnis dis parturient montes,
nascetur ridiculus mus. Nam tincidunt purus at tortor tincidunt et
aliquam dui gravida. Nulla consectetur sem vel felis vulputate et
imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta tortor.
Aliquam suscipit lacus vel odio faucibus tempor. Sed ipsum est,
condimentum eget eleifend ac, ultricies non dui. Integer tempus, nunc
sed venenatis feugiat, augue orci pellentesque risus, nec pretium lacus
enim eu nibh.</pre>
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius sapien vel purus hendrerit
vehicula. Integer hendrerit viverra turpis, ac sagittis arcu pharetra id. Sed dapibus enim non dui
posuere sit amet rhoncus tellus consectetur. Proin blandit lacus vitae nibh tincidunt cursus. Cum
sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Nam tincidunt
purus at tortor tincidunt et aliquam dui gravida. Nulla consectetur sem vel felis vulputate et
imperdiet orci pharetra. Nam vel tortor nisi. Sed eget porta tortor. Aliquam suscipit lacus vel odio
faucibus tempor. Sed ipsum est, condimentum eget eleifend ac, ultricies non dui. Integer tempus,
nunc sed venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu nibh.</pre>
=={{header|PHP}}==
<syntaxhighlight lang="php"><?php
$text = <<<ENDTXT
If there's anything you need
All you have to do is say
You know you satisfy everything in me
We shouldn't waste a single day
So don't stop me falling
It's destiny calling
A power I just can't deny
It's never changing
Can't you hear me, I'm saying
I want you for the rest of my life
Together forever and never to part
Together forever we two
And don't you know
I would move heaven and earth
To be together forever with you
ENDTXT;
// remove preexisting line breaks
$text = str_replace( PHP_EOL, " " , $text );
echo wordwrap( $text, 20 ), PHP_EOL, PHP_EOL;
echo wordwrap( $text, 40 ), PHP_EOL, PHP_EOL;
echo wordwrap( $text, 80 ), PHP_EOL, PHP_EOL;
</syntaxhighlight>
{{Out}}
<pre style="font-size:84%;height:55ex">
If there's anything
you need All you
have to do is say
You know you satisfy
everything in me We
shouldn't waste a
single day So don't
stop me falling It's
destiny calling A
power I just can't
deny It's never
changing Can't you
hear me, I'm saying
I want you for the
rest of my life
Together forever and
never to part
Together forever we
two And don't you
know I would move
heaven and earth To
be together forever
with you
If there's anything you need All you
have to do is say You know you satisfy
everything in me We shouldn't waste a
single day So don't stop me falling
It's destiny calling A power I just
can't deny It's never changing Can't you
hear me, I'm saying I want you for the
rest of my life Together forever and
never to part Together forever we two
And don't you know I would move heaven
and earth To be together forever with
you
If there's anything you need All you have to do is say You know you satisfy
everything in me We shouldn't waste a single day So don't stop me falling It's
destiny calling A power I just can't deny It's never changing Can't you hear me,
I'm saying I want you for the rest of my life Together forever and never to
part Together forever we two And don't you know I would move heaven and earth To
be together forever with you
</pre>
=={{header|Picat}}==
<syntaxhighlight lang="picat">import util.
go =>
text(1,Text),
foreach(LineWidth in [60,80])
println(lineWidth=LineWidth),
println(wrap(Text,LineWidth)),
nl
end,
nl.
wrap(Text,LineWidth) = Wrapped =>
Words = Text.split(),
Wrapped = Words[1],
SpaceLeft = LineWidth - Wrapped.len,
foreach(Word in Words.tail)
WordLen = Word.length,
if (WordLen + 1) > SpaceLeft then
Wrapped := Wrapped ++ "\n" ++ Word,
SpaceLeft := LineWidth - WordLen
else
Wrapped := Wrapped ++ " " ++ Word,
SpaceLeft := SpaceLeft - WordLen - 1
end
end.
text(1,"Lorem ipsum dolor sit amet, consectetur adipiscing
elit, sed do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco
laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure
dolor in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non
proident, sunt in culpa qui officia deserunt mollit anim id est
laborum.").</syntaxhighlight>
{{out}}
<pre>lineWidth = 60
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed
do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit
esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia
deserunt mollit anim id est laborum.
lineWidth = 80
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis
nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.</pre>
=={{header|PicoLisp}}==
'[http://software-lab.de/doc/refW.html#wrap wrap]' is a built-in.
<
The quick
brown fox
jumps over
the lazy dog
-> "The quick^Jbrown fox^Jjumps over^Jthe lazy dog"</
=={{header|PL/I}}==
<
ww: proc Options(main);
/*********************************************************************
Line 2,691 ⟶ 4,420:
End;
End;
End;</
Test result using this:
<pre>
Line 2,711 ⟶ 4,440:
=={{header|PowerShell}}==
Basic word wrap.
<
$divide=$args[0] -split " "
$width=$args[1]
Line 2,717 ⟶ 4,446:
foreach($word in $divide){
}
}
Line 2,739 ⟶ 4,468:
wrap $paragraph 100
### End script</
{{Out}}
<pre>
Line 2,769 ⟶ 4,498:
===Pipeline Version===
Slightly modified the previous to become the guts of this version. Now there is a default (80 characters) and a lower and upper limit for the -Width parameter. An unlimited number of strings may be passed to the helper function, New-WordWrap, through the pipeline.
<syntaxhighlight lang="powershell">
function Out-WordWrap
{
Line 2,799 ⟶ 4,528:
foreach ($word in $words)
{
{
else
{
}
Line 2,822 ⟶ 4,551:
}
}
</syntaxhighlight>
Grab some data and send it down the pipeline:
<syntaxhighlight lang="powershell">
[string[]]$paragraphs = "Rebum everti delicata an vel, quo ut temporibus interpretaris, mea debet mnesarchum disputando ad. Id has dolorum contentiones, mel ea noster adipisci. Id persius appareat eos, aeque dolorum fastidii eam in. Partem assentior contentiones ut mea. Cu augue facilis fabellas cum, vix eu sanctus denique imperdiet, appareat percipit qui ex.",
"Nihil discere phaedrum at duo, no eum adhuc autem error. Quo aliquam delicata contentiones et, in sed ferri legimus sententiae, nihil solet docendi id eum. Ius ut meliore vulputate adipiscing, sea cu virtute praesent. Euripidis instructior est eu. Veri cotidieque ex vel, aliquam eruditi nusquam sea ne, eu wisi ubique ullamcorper est. Qui doctus epicuri ei. Cum esse detracto concludaturque ea, veri erant per ad, vide ancillae principes ius id.",
Line 2,837 ⟶ 4,566:
$paragraphs | Out-WordWrap -Width 100
</syntaxhighlight>
{{Out}}
<pre>
Line 2,883 ⟶ 4,612:
possim ex. Theophrastus conclusionemque ad quo, inimicus deseruisse voluptatibus eum et. Duis
delectus mandamus an mei, usu timeam nostrum suscipiantur id.
</pre>
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<syntaxhighlight lang="prolog">% See https://en.wikipedia.org/wiki/Line_wrap_and_word_wrap#Minimum_number_of_lines
word_wrap(String, Length, Wrapped):-
re_split("\\S+", String, Words),
wrap(Words, Length, Length, Wrapped, '').
wrap([_], _, _, Result, Result):-!.
wrap([Space, Word|Words], Line_length, Space_left, Result, String):-
string_length(Word, Word_len),
string_length(Space, Space_len),
(Space_left < Word_len + Space_len ->
Space1 = '\n',
Space_left1 is Line_length - Word_len
;
Space1 = Space,
Space_left1 is Space_left - Word_len - Space_len
),
atomic_list_concat([String, Space1, Word], String1),
wrap(Words, Line_length, Space_left1, Result, String1).
sample_text("Lorem ipsum dolor sit amet, consectetur adipiscing \
elit, sed do eiusmod tempor incididunt ut labore et dolore magna \
aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco \
laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure \
dolor in reprehenderit in voluptate velit esse cillum dolore eu \
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non \
proident, sunt in culpa qui officia deserunt mollit anim id est \
laborum.").
test_word_wrap(Line_length):-
sample_text(Text),
word_wrap(Text, Line_length, Wrapped),
writef('Wrapped at %w characters:\n%w\n',
[Line_length, Wrapped]).
main:-
test_word_wrap(60),
nl,
test_word_wrap(80).</syntaxhighlight>
{{out}}
<pre>
Wrapped at 60 characters:
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed
do eiusmod tempor incididunt ut labore et dolore magna
aliqua. Ut enim ad minim veniam, quis nostrud exercitation
ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit
esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia
deserunt mollit anim id est laborum.
Wrapped at 80 characters:
Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis
nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu
fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in
culpa qui officia deserunt mollit anim id est laborum.
</pre>
=={{header|PureBasic}}==
<
DataSection
Data.s "In olden times when wishing still helped one, there lived a king "+
EndDataSection
Line 2,933 ⟶ 4,724:
Repeat : d$=Inkey() : Delay(50) : Until FindString("lr",d$,1,#PB_String_NoCase) : PrintN(d$+#CRLF$)
main(t$,lw) : Input()
</syntaxhighlight>
{{out}}
<pre>
Line 2,979 ⟶ 4,770:
=={{header|Python}}==
<
>>> help(textwrap.fill)
Help on function fill in module textwrap:
Line 3,018 ⟶ 4,809:
wrap(), tabs are expanded and other whitespace characters converted to space. See
TextWrapper class for available keyword args to customize wrapping behaviour.
>>> </
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> $ "Consider the inexorable logic of the Big Lie. If a man has
a consuming love for cats and dedicates himself to the
protection of cats, you have only to accuse him of killing
and mistreating cats. Your lie will have the unmistakable
ring of truth, whereas his outraged denials will reek of
falsehood and evasion. Those who have heard voices from the
nondominant brain hemisphere remark of the absolute
authority of the voice. They know they are hearing the
Truth. The fact that no evidence is adduced and that the
voice may be talking utter nonsense has nothing to do with
facts. Those who manipulate Truth to their advantage, the
people of the Big Lie, are careful to shun facts. In fact
nothing is more deeply offensive to such people than the
concept of fact. To adduce fact in your defense is to rule
yourself out of court."
nest$ dup
55 wrap$ cr
75 wrap$ cr
say "-- William S. Burroughs, Ghost Of Chance, 1981" cr</syntaxhighlight>
{{out}}
<pre>Consider the inexorable logic of the Big Lie. If a man
has a consuming love for cats and dedicates himself to
the protection of cats, you have only to accuse him of
killing and mistreating cats. Your lie will have the
unmistakable ring of truth, whereas his outraged
denials will reek of falsehood and evasion. Those who
have heard voices from the nondominant brain hemisphere
remark of the absolute authority of the voice. They
know they are hearing the Truth. The fact that no
evidence is adduced and that the voice may be talking
utter nonsense has nothing to do with facts. Those who
manipulate Truth to their advantage, the people of the
Big Lie, are careful to shun facts. In fact nothing is
more deeply offensive to such people than the concept
of fact. To adduce fact in your defense is to rule
yourself out of court.
Consider the inexorable logic of the Big Lie. If a man has a consuming love
for cats and dedicates himself to the protection of cats, you have only to
accuse him of killing and mistreating cats. Your lie will have the
unmistakable ring of truth, whereas his outraged denials will reek of
falsehood and evasion. Those who have heard voices from the nondominant
brain hemisphere remark of the absolute authority of the voice. They know
they are hearing the Truth. The fact that no evidence is adduced and that
the voice may be talking utter nonsense has nothing to do with facts. Those
who manipulate Truth to their advantage, the people of the Big Lie, are
careful to shun facts. In fact nothing is more deeply offensive to such
people than the concept of fact. To adduce fact in your defense is to rule
yourself out of court.
-- William S. Burroughs, Ghost Of Chance, 1981</pre>
=={{header|R}}==
=== Using the base library ===
Use <code>strwrap()</code>:
<
> cat(paste(strwrap(x=c(x, "\n"), width=80), collapse="\n"))
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus.
Line 3,035 ⟶ 4,887:
hendrerit. Donec et mollis dolor. Praesent et diam eget
libero egestas mattis sit amet vitae augue. Nam tincidunt
congue enim, ut porta lorem lacinia consectetur.</
=== Using the stringr tidyverse library ===
Another option, using <code>stringr::str_wrap</code>
<syntaxhighlight lang="rsplus">
> x <- "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas congue ligula ac quam viverra nec consectetur ante hendrerit. Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. "
> cat(stringr::str_wrap(x, 60))
Lorem ipsum dolor sit amet, consectetur adipiscing elit.
Donec a diam lectus. Sed sit amet ipsum mauris. Maecenas
congue ligula ac quam viverra nec consectetur ante
hendrerit. Donec et mollis dolor. Praesent et diam eget
libero egestas mattis sit amet vitae augue. Nam tincidunt
congue enim, ut porta lorem lacinia consectetur.
</syntaxhighlight>
=={{header|Racket}}==
Using a library function:
<syntaxhighlight lang="racket">
#lang at-exp racket
(require scribble/text/wrap)
Line 3,056 ⟶ 4,920:
high and caught it, and this ball was her favorite plaything.})
(for-each displayln (wrap-line text 60))
</syntaxhighlight>
Explicit (and simple) implementation:
<
#lang racket
Line 3,082 ⟶ 4,946:
;;; Usage:
(wrap (string-split text) 70)
</syntaxhighlight>
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku" line>my $s = "In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close-by-the-king's-castle-lay-a-great-dark
forest, and under an old lime-tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything.";
$s ~~ s:g/»\s+/ /;
$s ~~ s/\s*$/\n\n/;
say $s.subst(/ \s* (. ** 1..66) \s /, -> $/ { "$0\n" }, :g);
say $s.subst(/ \s* (. ** 1..25) \s /, -> $/ { "$0\n" }, :g);</syntaxhighlight>
=={{header|REXX}}==
===version 0===
This version was the original (of version 1) and has no error checking and only does left-margin justification.
<
parse arg iFID width . /*obtain optional arguments from the CL*/
if iFID=='' | iFID=="," then iFID='LAWS.TXT' /*Not specified? Then use the default.*/
Line 3,098 ⟶ 4,980:
do k=2 for words(@)-1; x=word(@,k) /*parse until text (@) exhausted. */
_=$ x /*append it to the $ list and test. */
if length(_)>=width then do; say $
_=x
end
$=_ /*new words (on a line) are OK so far.*/
end /*m*/
if $\=='' then say $ /*handle any residual words (overflow).*/
/*stick a fork in it, we're all done. */</
'''output''' is the same as version 1 using the '''L'''eft option (the default).
===version 1===
The input for this program is in a file (named '''LAWS.TXT''').
The default width of the output is the current terminal width (normally, this would be the window's width).
<br>If the terminal width (or window's width) is indeterminable, then 80 is used.
<br>The width can be expressed as a percentage (i.e.: 50%) which signifies to use ½ of the terminal's width).
Line 3,123 ⟶ 5,006:
</pre>
('''L'''eft is the default.)
This version was modified (for speed at the expense of simplicity) to accommodate faster processing of large files.
<br>Instead of appending lines of a file to a character string, the words are picked off and stored in a stemmed array.
<br>This decreases the amount of work that REXX has to do to retrieve (get) the next word in the (possibly) ginormous string.
<
parse arg iFID width
if iFID=='' | iFID=="," then iFID = 'LAWS.TXT'
if width=='' |width=="," then width= linesize()
if right(width, 1) =='%'
if
just= left(
if pos(just, 'BCLR')==0 then call err "KIND (3rd arg) is illegal:" kind
if _\=='' then call err "too many arguments specified." _
if \datatype(width,'W') then call err "WIDTH (2nd arg) isn't an integer:" width
n=0 /*the number of words in the file. */
do j=0 while lines(iFID)\==0
_=linein(iFID)
do until _==''; n= n +
parse var _ @.n
end /*
end /*j*/
if j==0 then call err 'file' iFID "not found."
if n==0 then call err 'file' iFID "is empty (or has no words)"
$=@.1 /*initialize $ string with first word*/
do m=2 for n-1;
_= $ x
if length(_)>= width then call tell
$=
end /*m*/
call tell /*handle any residual words (if any). */
exit /*stick a fork in it, we're all done. */
/*──────────────────────────────────────────────────────────────────────────────────────*/
err: say; say '***error***'; say; say arg(1); say; say; exit 13
/*──────────────────────────────────────────────────────────────────────────────────────*/
tell: if $=='' then return /* [↓] the first word may be too long.*/
Line 3,161 ⟶ 5,045:
select
when just=='L' then $= strip($) /*left ◄──────── */
when just=='R' then $= right($, w)
when just=='B' then $=justify($, w)
when just=='C' then $= center($, w)
end /*select*/
say $ /*display the line of words to terminal*/
_=
return /*go back and keep truckin'. */</
This REXX program makes use of '''LINESIZE''' REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).
Line 3,173 ⟶ 5,057:
'''input file''':
<pre style="height:
────────── Computer programming laws ──────────
The Primal Scenario -or- Basic Datum of Experience:
Line 3,264 ⟶ 5,148:
∙ Parameters are variables traveling under an assumed name.
</pre>
<pre style="height:
────────── Computer programming laws ────────── The Primal Scenario -or- Basic Datum of Experience: ∙ Systems in general work poorly or not at all. ∙
Nothing complicated works. ∙ Complicated systems seldom exceed 5% efficiency. ∙ There is always a fly in the ointment. The Fundamental Theorem: ∙ New
Line 3,271 ⟶ 5,155:
energy in the universe is constant. ∙ Systems operate by redistributing energy into different forms and into accumulations of different sizes. Laws of
Growth: ∙ Systems tend to grow, and as they grow, they encroach. The Big-Bang Theorem of Systems-Cosmology: ∙ Systems tend to expand to fill the known
universe. Parkinson's Extended Law: ∙ The system itself tends to expand at 5-6% per annum. The Generalized Uncertainty Principle: ∙ Systems display
antics. ∙ Complicated systems produce unexpected outcomes. ∙ The total behavior of large systems cannot be predicted. The Non-Additivity Theorem of
Systems-Behavior -or- Climax Design Theorem: ∙ A large system, produced by expanding the dimensions of a smaller system, does not behave like the smaller
system. LeChateliers's Principle: ∙ Complex systems tend to oppose their own proper function. ∙ Systems get in the way. ∙ The system always kicks back. ∙
Line 3,279 ⟶ 5,163:
identical to the function of the same name performed by a smaller system. The Fundamental Law of Administrative Workings: ∙ Things are what they are
reported to be. ∙ The real world is whatever is reported to the system. ∙ If it isn't official; it didn't happen. ∙ If it's made in Detroit, it must be an
automobile. ∙ A system is no better than its sensory organs. ∙ To those within a system, the outside reality tends to pale and disappear. ∙ Systems
attract systems-people. ∙ For every human system, there is a type of person adapted to thrive on it or in it. ∙ The bigger the system, the narrower and
more specialized the interface with individuals. Administrator's Anxiety: ∙ Pushing on the systems doesn't help. It just makes things worse. ∙ A complex
system cannot be "made" to work. It either works or it doesn't. ∙ A simple system, designed from scratch, sometimes works. ∙ A simple system may or may
not work. ∙ Some complex systems actually work. ∙ If a system is working, leave it alone. ∙ A complex system that works is invariably found to have
evolved from a simple system that works. ∙ A complex system designed from scratch never works and cannot be patched up to make it work. You have to start
over, beginning with a working simple system. ∙ Programs never run the first time. ∙ Complex programs never run. ∙ Anything worth doing once will probably
have to be done twice. The Functional indeterminacy Theorem: ∙ In complex systems, malfunction and even total nonfunction may not be detectable for long
periods, if ever. The Kantian Hypothesis -or- Know-Nothing Theorem: ∙ Large complex systems are beyond human capacity to evaluate. The Newtonian Lay of
Systems-Inertia: ∙ A system that performs a certain way will continue to operate in that way regardless of the need of of changed conditions. ∙ A system
continues to do its thing, regardless of need. ∙ Systems develop goals of their own the instant they come into being. ∙ Intrasystem goals come first.
Failure-Mode Theorems: ∙ Complex systems usually operate in failure mode. ∙ A complex system can fail in a infinite number of ways. ∙ If anything can go
wrong, it will. ∙ The mode of failure of a complex system cannot ordinarily be predicted from its structure. ∙ The crucial variables are discovered by
accident. ∙ The larger the system, the greater the probability of unexpected failure. ∙ "Success" or "function" in any system may be failure in the larger
or smaller systems to which the system is connected. ∙ In setting up a new system, tread softly. You may be disturbing another system that is actually
working. The Fail-Safe Theorem: ∙ When a fail-safe system fails, it fails by failing to fail safe. ∙ Complex systems tend to produce complex responses
(not solutions) to problems. ∙ Great advances are not produced by systems designed to produce great advances. ∙ Loose systems last longer and work better.
∙ Efficient systems are dangerous to themselves and to others. The Vector Theory of Systems: ∙ Systems run better when designed to run downhill. ∙ Systems
aligned with human motivational vectors will sometimes work. Systems opposing such vectors work poorly or not at all. Advanced Systems Theories: ∙
Everything is a system. ∙ Everything is a part of a larger system. ∙ The universe is infinitely systematized, both upward [larger systems] and downward
[smaller systems]. ∙ All systems are infinitely complex. (The illusion of simplicity comes from focusing attention on one or a few variables.) ∙
</pre>
{{out|output|text= when using the input: <tt> , 80 </tt>}}
<pre style="height:45ex">
────────── Computer programming laws ────────── The Primal Scenario -or- Basic
Datum of Experience: ∙ Systems in general work poorly or not at all. ∙ Nothing
complicated works. ∙ Complicated systems seldom exceed 5% efficiency. ∙ There
is always a fly in the ointment. The Fundamental Theorem: ∙ New systems
generate new problems. Occam's Razor: ∙ Systems should not be unnecessarily
multiplied. The Law of Conservation of Energy: ∙ The total amount of energy in
the universe is constant. ∙ Systems operate by redistributing energy into
different forms and into accumulations of different sizes. Laws of Growth: ∙
Systems tend to grow, and as they grow, they encroach. The Big-Bang Theorem of
Systems-Cosmology: ∙ Systems tend to expand to fill the known universe.
Parkinson's Extended Law: ∙ The system itself tends to expand at 5-6% per
annum. The Generalized Uncertainty Principle: ∙ Systems display antics. ∙
Complicated systems produce unexpected outcomes. ∙ The total behavior of large
systems cannot be predicted. The Non-Additivity Theorem of Systems-Behavior
-or- Climax Design Theorem: ∙ A large system, produced by expanding the
dimensions of a smaller system, does not behave like the smaller system.
LeChateliers's Principle: ∙ Complex systems tend to oppose their own proper
function. ∙ Systems get in the way. ∙ The system always kicks back. ∙ Positive
feedback is dangerous. Functionary's Falsity: ∙ People in systems do not do
what the system says they are doing. ∙ The function performed by a system is
not operationally identical to the function of the same name
man. ∙ A function performed by a larger system is not operationally identical
to the function of the same name performed by a smaller system. The Fundamental
Law of Administrative Workings: ∙ Things are what they are reported to be. ∙
The real world is whatever is reported to the system. ∙ If it isn't official;
it didn't happen. ∙ If it's made in Detroit, it must be an automobile. ∙ A
system is no better than its sensory organs. ∙ To those within a system, the
outside reality tends to pale and disappear. ∙ Systems attract systems-people.
∙ For every human system, there is a type of person adapted to thrive on it or
in it. ∙ The bigger the system, the narrower and more specialized the interface
with individuals. Administrator's Anxiety: ∙ Pushing on the systems doesn't
help. It just makes things worse. ∙ A complex system cannot be "made" to work.
It either works or it doesn't. ∙ A simple system, designed from scratch,
sometimes works. ∙ A simple system may or may not work. ∙ Some complex systems
∙ Intrasystem goals come first. Failure-Mode Theorems: ∙ Complex systems
usually operate in failure mode. ∙ A complex system can fail in a infinite
complex system cannot ordinarily be predicted from its structure. ∙ The crucial
variables are discovered by accident. ∙ The larger the system, the greater the
probability of unexpected failure. ∙ "Success" or "function" in any system may
In setting up a new system, tread softly. You may be disturbing another system
that is actually working. The Fail-Safe Theorem: ∙ When a fail-safe system
fails, it fails by failing to fail safe. ∙ Complex systems tend to produce
complex responses (not solutions) to problems. ∙ Great advances are not
produced by systems designed to produce great advances. ∙ Loose systems last
longer and work better. ∙ Efficient systems are dangerous to themselves and to
</pre>
{{out|output|text= [justified] when specifying: <tt> , 80 both </tt>}}
<pre style="height:45ex">
────────── Computer programming laws ────────── The Primal Scenario -or- Basic
Datum of Experience: ∙ Systems in general work poorly or not at all. ∙ Nothing
complicated works. ∙ Complicated systems seldom exceed 5% efficiency. ∙ There
is always a fly in the ointment. The Fundamental Theorem: ∙ New systems
generate new problems. Occam's Razor: ∙ Systems should not be unnecessarily
multiplied. The Law of Conservation of Energy: ∙ The total amount of energy in
the universe is constant. ∙ Systems operate by redistributing energy into
different
Systems tend to grow, and as they grow, they encroach. The Big-Bang Theorem
Systems-Cosmology: ∙ Systems tend to expand to fill the known universe.
Parkinson's Extended Law: ∙ The system itself tends to expand at 5-6% per
annum. The Generalized Uncertainty Principle: ∙ Systems display antics. ∙
Complicated systems produce unexpected outcomes. ∙ The total
systems cannot be predicted. The Non-Additivity Theorem of Systems-Behavior
-or- Climax Design Theorem: ∙ A large system, produced by expanding the
dimensions of a smaller system, does not behave like the smaller system.
LeChateliers's Principle: ∙ Complex systems tend to oppose their own proper
function. ∙ Systems get in the way. ∙ The system always kicks back. ∙ Positive
feedback is dangerous. Functionary's Falsity: ∙ People in systems do not do
what the system says they are doing. ∙ The function performed by a system is
man. ∙ A function performed by a larger system is not operationally identical
to the function of the same name performed
Law of Administrative Workings: ∙ Things are what they
The real world is whatever is reported to the system. ∙ If it isn't official;
it didn't happen. ∙ If it's made in Detroit, it
system is no better than its sensory organs. ∙
outside reality tends to pale and disappear.
∙ For every human system, there is a type of person
in it. ∙ The bigger the system, the
with individuals. Administrator's Anxiety: ∙ Pushing on the systems doesn't
help. It just makes things worse. ∙ A
It either works or it doesn't. ∙ A simple system,
sometimes works. ∙ A
nonfunction may not be detectable for long periods, if ever. The Kantian
performs a certain way will continue to operate in that way regardless of the
need of of changed conditions. ∙ A system continues to do its thing, regardless
∙ Intrasystem goals come first. Failure-Mode Theorems: ∙ Complex systems
usually operate in failure mode. ∙ A complex system can fail in a infinite
complex system cannot ordinarily be predicted from its structure. ∙ The crucial
variables are discovered by accident. ∙ The larger the system, the greater the
probability of unexpected failure. ∙ "Success" or "function" in any system may
In setting up a new system, tread softly. You may be disturbing another system
that is actually working. The Fail-Safe Theorem: ∙ When a fail-safe system
fails, it fails by failing to fail safe. ∙ Complex systems tend to produce
complex responses (not solutions) to problems. ∙ Great advances are not
produced by systems designed to produce great advances. ∙ Loose systems last
longer and work better. ∙ Efficient systems are dangerous to themselves and to
others. The Vector Theory of Systems: ∙ Systems run better when designed to run
downhill. ∙ Systems aligned with human motivational vectors will sometimes
work. Systems opposing such vectors work poorly or not at all. Advanced Systems
Theories: ∙ Everything is a system. ∙ Everything is a part of a larger system.
∙ The universe is infinitely systematized, both upward [larger systems] and
of simplicity comes from focusing attention on one or a few variables.) ∙
Parameters are variables traveling under an assumed name.
</pre>
===version 2===
<
* 20.08.2013 Walter Pachl "my way"
* 23.08.2013 Walter Pachl changed to use lastpos bif
Line 3,479 ⟶ 5,358:
Call o s
Return
o:Return lineout(oid,arg(1))</
{{out}} for widths 72 and 9
<pre>
Line 3,503 ⟶ 5,382:
tomorrow,
and so on
</pre>
=={{header|Ring}}==
<syntaxhighlight lang="ring">
# Project : Word wrap
load "stdlib.ring"
doc = "In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime-tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything."
wordwrap(doc,72)
wordwrap(doc,80)
func wordwrap(doc, maxline)
words = split(doc, " ")
line = words[1]
for i=2 to len(words)
word = words[i]
if len(line)+len(word)+1 > maxline
see line + nl
line = word
else
line = line + " " + word
ok
next
see line + nl + nl
</syntaxhighlight>
Output:
<pre>
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime-tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Ruby}}==
<
def wrap(width)
txt = gsub("\n", " ")
Line 3,536 ⟶ 5,470:
puts "." * w
puts text.wrap(w)
end</
{{out}}
Line 3,564 ⟶ 5,498:
Word Wrap style for different browsers.
This automatically adjusts the text if the browser window is stretched in any direction
<
"whose daughters were all beautiful, but the youngest was so beautiful ";_
"that the sun itself, which has seen so much, was astonished whenever ";_
Line 3,573 ⟶ 5,507:
html "<table border=1 cellpadding=2 cellspacing=0><tr" + wrap$ +" valign=top>"
html "<td width=60%>" + doc$ + "</td><td width=40%>" + doc$ + "</td></tr></table>"</
output will adjust as you stretch the browser and maintain a 60 to 40 ratio of the width of the screen.
<pre>
Line 3,580 ⟶ 5,514:
whose daughters were all beautiful, but the youngest was so | one, there lived a king whose daughters
beautiful that the sun itself, which has seen so much, was | were all beautiful, but the youngest was
astonished whenever it shone in her face.
</pre>
Without Browser
<
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
Line 3,607 ⟶ 5,541:
docOut$ = docOut$ + thisWord$
wend
print docOut$</
=={{header|Rust}}==
This is an implementation of the simple greedy algorithm.
<syntaxhighlight lang="rust">#[derive(Clone, Debug)]
pub struct LineComposer<I> {
words: I,
width: usize,
current: Option<String>,
}
impl<I> LineComposer<I> {
pub(crate) fn new<S>(words: I, width: usize) -> Self
where
I: Iterator<Item = S>,
S: AsRef<str>,
{
LineComposer {
words,
width,
current: None,
}
}
}
impl<I, S> Iterator for LineComposer<I>
where
I: Iterator<Item = S>,
S: AsRef<str>,
{
type Item = String;
fn next(&mut self) -> Option<Self::Item> {
let mut next = match self.words.next() {
None => return self.current.take(),
Some(value) => value,
};
let mut current = self.current.take().unwrap_or_else(String::new);
loop {
let word = next.as_ref();
if self.width <= current.len() + word.len() {
self.current = Some(String::from(word));
// If the first word itself is too long, avoid producing an
// empty line. Continue instead with the next word.
if !current.is_empty() {
return Some(current);
}
}
if !current.is_empty() {
current.push_str(" ")
}
current.push_str(word);
match self.words.next() {
None => return Some(current), // Last line, current remains None
Some(word) => next = word,
}
}
}
}
// This part is just to extend all suitable iterators with LineComposer
pub trait ComposeLines: Iterator {
fn compose_lines(self, width: usize) -> LineComposer<Self>
where
Self: Sized,
Self::Item: AsRef<str>,
{
LineComposer::new(self, width)
}
}
impl<T, S> ComposeLines for T
where
T: Iterator<Item = S>,
S: AsRef<str>,
{
}
fn main() {
let text = r"
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.";
text.split_whitespace()
.compose_lines(80)
.for_each(|line| println!("{}", line));
}
</syntaxhighlight>
{{out}}
<pre>
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Scala}}==
===Intuitive approach===
{{libheader|Scala}}<
object WordWrap extends App {
Line 3,654 ⟶ 5,701:
letsWrap(ewd)
letsWrap(ewd, 120)
} // 44 lines</
................................................................................
Vijftig jaar geleden publiceerde Edsger Dijkstra zijn kortstepadalgoritme.
Line 3,697 ⟶ 5,744:
The simple, greedy algorithm:
<
(import (scheme base)
(scheme write)
Line 3,737 ⟶ 5,784:
(show-para simple-word-wrap 50)
(show-para simple-word-wrap 60)
</syntaxhighlight>
{{out}}
Line 3,767 ⟶ 5,814:
=={{header|Seed7}}==
<
const func string: wrap (in string: aText, in integer: lineWidth) is func
Line 3,810 ⟶ 5,857:
writeln(wrap(frog, width));
end for;
end func;</
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
Line 3,834 ⟶ 5,881:
=={{header|Sidef}}==
===Greedy word wrap===
<
method wrap(width) {
var txt = self.gsub(/\s+/, " ")
var len = txt.len
var para = []
var i = 0
while (i < len) {
var j = (i + width)
while ((j < len) && (txt.char_at(j)
para.append(txt.substr(i, j-i))
i = j+1
}
return para.join("\n")
}
}
var text = 'aaa bb cc ddddd'
say text.wrap(6)
{{out}}
Line 3,861 ⟶ 5,908:
===Smart word wrap===
<
has width = 80
Line 3,887 ⟶ 5,934:
root << [
array.first(i+1).join(' '),
self.prepare_words(array.
]
Line 3,930 ⟶ 5,977:
self.combine([], path, { |combination|
var score = 0
combination.
score += (width - line.len -> sqr)
}
Line 3,944 ⟶ 5,991:
}
}
var sww = SmartWordWrap()
var words = %w(aaa bb cc ddddd)
var wrapped = sww.wrap(words, 6)
say wrapped
{{out}}
<pre>
Line 3,956 ⟶ 6,003:
bb cc
ddddd
</pre>
=={{header|Standard ML}}==
<syntaxhighlight lang="sml">fun wordWrap n s =
let
fun appendLine (line, text) =
text ^ line ^ "\n"
fun wrap (word, prev as (line, text)) =
if size line + 1 + size word > n
then (word, appendLine prev)
else (line ^ " " ^ word, text)
in
case String.tokens Char.isSpace s of
[] => ""
| (w :: ws) => appendLine (foldl wrap (w, "") ws)
end
val () = (print o wordWrap 72 o TextIO.inputAll) TextIO.stdIn</syntaxhighlight>
{{in}}
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore
magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo
consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur.
Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.</pre>
{{out}}
<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim
veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea
commodo consequat. Duis aute irure dolor in reprehenderit in voluptate
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint
occaecat cupidatat non proident, sunt in culpa qui officia deserunt
mollit anim id est laborum.</pre>
=={{header|Tailspin}}==
A simple greedy algorithm that will always put one word on a line even if the word is longer than the desired width.
<syntaxhighlight lang="tailspin">
templates break&{width:}
composer words
<word>* (<WS>*)
rule word: (<WS>*) [<'\S'>+]
end words
def chars: [$ -> words];
@: $chars(first);
[$chars(first~..last)... -> #] -> '$... -> '$;$#10;';$@...;' !
when <[](..~($width-$@::length))> do ..|@: ' '; $... -> ..|@: $;
otherwise '$@...;' ! @: $;
end break
'In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king''s castle lay a great dark forest, and under
an old lime-tree in the forest was a well, and when the day was very
warm, the king''s child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.' -> break&{width: 80} -> !OUT::write</syntaxhighlight>
{{out}}
<pre>
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Tcl}}==
Using a simple greedy algorithm to wrap the same text as used in the [[#Go|Go]] solution. Note that it assumes that the line length is longer than the longest word length.
<
proc wrapParagraph {n text} {
Line 3,966 ⟶ 6,080:
set RE "^(.{1,$n})(?:\\s+(.*))?$"
for {set result ""} {[regexp $RE $text -> line text]} {} {
}
return [string trimright $result "\n"]
Line 3,985 ⟶ 6,099:
puts [wrapParagraph 80 $txt]
puts "[string repeat - 72]"
puts [wrapParagraph 72 $txt]</
{{out}}
<pre>--------------------------------------------------------------------------------
Line 4,006 ⟶ 6,120:
threw it up on high and caught it, and this ball was her favorite
plaything.</pre>
=={{header|TPP}}==
The text presentation program automatically provides word wrap:
<
=={{header|TUSCRIPT}}==
<
$$ MODE TUSCRIPT
text="In olden times when wishing still helped one, there lived a king whose daughters were all beautiful, but the youngest was so beautiful that the sun itself, which has seen so much, was astonished whenever it shone in her face. Close by the king's castle lay a great dark forest, and under an old lime-tree in the forest was a well, and when the day was very warm, the king's child went out into the forest and sat down by the side of the cool fountain, and when she was bored she took a golden ball, and threw it up on high and caught it, and this ball was her favorite plaything."
Line 4,031 ⟶ 6,146:
wrappedtext=FORMAT(text,length,firstline,nextlines)
FILE "text" = wrappedtext
</syntaxhighlight>
{{out}}
<pre style='height:30ex;overflow:scroll'>
Line 4,056 ⟶ 6,171:
=={{header|VBScript}}==
<syntaxhighlight lang="vb">
column = 60
text = "In olden times when wishing still helped one, there lived a king " &_
Call wordwrap(text,column)
Sub wordwrap(s,n)
End Sub
</syntaxhighlight>
{{Out}}
Line 4,104 ⟶ 6,219:
plaything.
</pre>
=={{header|V (Vlang)}}==
{{trans|Go}}
<syntaxhighlight lang="ecmascript">fn wrap(text string, line_width int) string {
mut wrapped := ''
words := text.fields()
if words.len == 0 {
return wrapped
}
wrapped = words[0]
mut space_left := line_width - wrapped.len
for word in words[1..] {
if word.len+1 > space_left {
wrapped += "\n" + word
space_left = line_width - word.len
} else {
wrapped += " " + word
space_left -= 1 + word.len
}
}
return wrapped
}
const frog = "
In olden times when wishing still helped one, there lived a king
whose daughters were all beautiful, but the youngest was so beautiful
that the sun itself, which has seen so much, was astonished whenever
it shone in her face. Close by the king's castle lay a great dark
forest, and under an old lime-tree in the forest was a well, and when
the day was very warm, the king's child went out into the forest and
sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this
ball was her favorite plaything."
fn main() {
println("wrapped at 80:")
println(wrap(frog, 80))
println("wrapped at 72:")
println(wrap(frog, 72))
}</syntaxhighlight>
{{out}}
<pre>
wrapped at 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime-tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
wrapped at 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime-tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
</pre>
=={{header|Wren}}==
{{trans|Kotlin}}
<syntaxhighlight lang="wren">var greedyWordWrap = Fn.new { |text, lineWidth|
var words = text.split(" ")
var sb = words[0]
var spaceLeft = lineWidth - words[0].count
for (word in words.skip(1)) {
var len = word.count
if (len + 1 > spaceLeft) {
sb = sb + "\n" + word
spaceLeft = lineWidth - len
} else {
sb = sb + " " + word
spaceLeft = spaceLeft - len - 1
}
}
return sb
}
var text =
"In olden times when wishing still helped one, there lived a king " +
"whose daughters were all beautiful, but the youngest was so beautiful " +
"that the sun itself, which has seen so much, was astonished whenever " +
"it shone in her face. Close by the king's castle lay a great dark " +
"forest, and under an old lime tree in the forest was a well, and when " +
"the day was very warm, the king's child went out into the forest and " +
"sat down by the side of the cool fountain, and when she was bored she " +
"took a golden ball, and threw it up on high and caught it, and this " +
"ball was her favorite plaything."
System.print("Greedy algorithm - wrapped at 72:")
System.print(greedyWordWrap.call(text, 72))
System.print("\nGreedy algorithm - wrapped at 80:")
System.print(greedyWordWrap.call(text, 80))</syntaxhighlight>
{{out}}
<pre>
Greedy algorithm - wrapped at 72:
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
Greedy algorithm - wrapped at 80:
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|XPL0}}==
<syntaxhighlight lang="xpl0">string 0;
proc WordWrap(Text, LineWidth); \Display Text string wrapped at LineWidth
char Text, LineWidth, Word, SpaceLeft, WordWidth, I;
[SpaceLeft:= 0;
loop [loop [if Text(0) = 0 then return; \skip whitespace (like CR)
if Text(0) > $20 then quit;
Text:= Text+1;
];
Word:= Text; WordWidth:= 0;
while Word(WordWidth) > $20 do
WordWidth:= WordWidth+1;
Text:= Text + WordWidth; \move to Word terminator
if WordWidth+1 > SpaceLeft then
[CrLf(0);
for I:= 0 to WordWidth-1 do ChOut(0, Word(I));
SpaceLeft:= LineWidth - WordWidth;
]
else [ChOut(0, ^ );
for I:= 0 to WordWidth-1 do ChOut(0, Word(I));
SpaceLeft:= SpaceLeft - WordWidth - 1;
];
];
];
char Text;
[Text:=
"In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite plaything.
";
WordWrap(Text, 72); CrLf(0);
WordWrap(Text, 80); CrLf(0);
]</syntaxhighlight>
{{out}}
<pre>
In olden times when wishing still helped one, there lived a king whose
daughters were all beautiful, but the youngest was so beautiful that the
sun itself, which has seen so much, was astonished whenever it shone in
her face. Close by the king's castle lay a great dark forest, and under
an old lime tree in the forest was a well, and when the day was very
warm, the king's child went out into the forest and sat down by the side
of the cool fountain, and when she was bored she took a golden ball, and
threw it up on high and caught it, and this ball was her favorite
plaything.
In olden times when wishing still helped one, there lived a king whose daughters
were all beautiful, but the youngest was so beautiful that the sun itself, which
has seen so much, was astonished whenever it shone in her face. Close by the
king's castle lay a great dark forest, and under an old lime tree in the forest
was a well, and when the day was very warm, the king's child went out into the
forest and sat down by the side of the cool fountain, and when she was bored she
took a golden ball, and threw it up on high and caught it, and this ball was her
favorite plaything.
</pre>
=={{header|Yabasic}}==
<syntaxhighlight lang="yabasic">t$ = "In olden times when wishing still helped one, there lived a king "
t$ = t$ + "whose daughters were all beautiful, but the youngest was so beautiful "
t$ = t$ + "that the sun itself, which has seen so much, was astonished whenever "
t$ = t$ + "it shone in her face.\n\n"
t$ = t$ + t$
t$ = trim$(t$)
input "Width: " width // user specifies width
dim p$(1)
d$ = " .,\n"
n = words(t$, p$(), d$)
for i = 1 to n
if p$(i) = "\n" or len(docOut$) + len(p$(i)) > width then
print docOut$
docOut$ = ""
end if
if p$(i) <> "\n" docOut$ = docOut$ + p$(i)
next i
print docOut$
sub words(w$, p$(), d$)
local n, i, p
n = split(w$, p$(), d$)
p = 1
for i = 1 to n
p$(i) = p$(i) + mid$(w$, p + len(p$(i)), 1)
p = p + len(p$(i))
next i
return n
end sub</syntaxhighlight>
{{trans|Run BASIC}}
<syntaxhighlight lang="yabasic">t$ = "In olden times when wishing still helped one, there lived a king "
t$ = t$ + "whose daughters were all beautiful, but the youngest was so beautiful "
t$ = t$ + "that the sun itself, which has seen so much, was astonished whenever "
t$ = t$ + "it shone in her face."
wrap$ = " style='white-space: pre-wrap;white-space: -moz-pre-wrap;white-space: -pre-wrap;white-space: -o-pre-wrap;word-wrap: break-word'"
f = open("WordWrap.html", "w")
print #f "<table border=1 cellpadding=2 cellspacing=0><tr" + wrap$ +" valign=top>"
print #f "<td width=60%>" + t$ + "</td><td width=40%>" + t$ + "</td></tr></table>"
close #f
void = system("explorer WordWrap.html")</syntaxhighlight>
=={{header|zkl}}==
This is a greedy algorithm for mono spaced text with ragged right. In addition, it can look at the first two lines to do "smart indenting". It handles multiple paragraphs and a variety of input sources.
<
length=72, calcIndents=True){
sink:=Data();
getIndents:='wrap(w){
reg lines=L(), len=0, prefix="", one=True;
do(2){
}
w.push(lines.xplode()); // put first two lines back to be formated
Line 4,127 ⟶ 6,484:
};
reg len=0, prefix="", w=text.walker(1);
if(calcIndents) len,prefix=getIndents(w);
foreach line in (w){
if(not line.strip()){ // blank line
}else
}
sink
}</
<
{{out}}
<pre>
Line 4,156 ⟶ 6,513:
times ...
</pre>
<
.pump(String).println();</
{{out}}
<pre>
Line 4,165 ⟶ 6,522:
9: favorite plaything.
</pre>
<
{{out}}
<pre>
|