Word wrap: Difference between revisions

{{trans|Go}}

 

V words = text.split_py()

I words.empty

L(width) (72, 80)

print(‘Wrapped at ’width":\n"word_wrap(frog, width))

 

{{out}}

=={{header|360 Assembly}}==

The program uses one ASSIST macro (XPRNT) to keep the code as short as possible.

WORDWRAP CSECT

USING WORDWRAP,R13

PG DS CL80

YREGS

{{out}}

<pre>

 

=={{header|Action!}}==

CARD length

 

LMARGIN=old ;restore left margin on the screen

RETURN

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Word_wrap.png Screenshot from Atari 8-bit computer]

=={{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

end record;

 

 

The implementation of that package:

 

 

procedure Push_Word(State: in out Basic; Word: String) is

end Finish;

 

 

Finally, the main program:

 

 

procedure Wrap is

end loop;

Wrapper.Finish;

 

{{out}} set to 72 lines (with input picked by cut-and-paste from the task description):

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:

 

if (para is "") then return para

set astid to AppleScript's text item delimiters

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."

 

{{output}}

in a standard library, show that. Otherwise implement the minimum

length greedy algorithm from Wikipedia.

standard library, show that. Otherwise

implement the minimum length greedy

 

However, it's more efficient to look for the last space in each line than to see how many "words" will fit:

 

set theLines to {}

set spaceTab to space & tab

return output

 

Using AppleScriptObjC, the second approach can be achieved with a regular expression:

 

use framework "Foundation"

 

return str as text

 

=={{header|Arturo}}==

 

 

print wordwrap txt

print ""

 

{{out}}

=={{header|AutoHotkey}}==

Basic word-wrap. Formats text that has been copied to the clipboard.

return

 

Result .= Match1 ((Match2 = A_Space || Match2 = A_Tab) ? "`n" : Match2)

return, Result

{{Out}}

<pre>72

Basic word wrap.

 

{

if ( length(p) < 1 ) return

END {

wordwrap_paragraph(par)

 

To test it,

 

=={{header|BaCon}}==

" there lived a king whose daughters were all beautiful, but" \

" the youngest was so beautiful that the sun itself, which has" \

 

PRINT ALIGN$(paragraph$, 72, 0)

BaCon has the ALIGN$ function which can align text left-side, right-side, centered or both sides at any given column.

{{out}}

=={{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!"

)

endlocal & set "line=%line%"

{{Out}}

<pre>Lorem ipsum dolor sit amet, consectetur

 

=={{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 "

& out$(str$("72 columns:\n" wrap$(!Text.72)))

& out$(str$("\n80 columns:\n" wrap$(!Text.80)))

{{out}}

<pre>72 columns:

 

=={{header|C}}==

#include <stdlib.h>

#include <string.h>

 

return 0;

 

=={{header|C sharp}}==

Greedy algorithm:

{

using System;

}

}

{{out}}

<pre>------------------------------------------------------------------------

Basic task.

{{trans|Go}}

#include <sstream>

#include <string>

std::cout << "Wrapped at 72:\n" << wrap(text) << "\n\n";

std::cout << "Wrapped at 80:\n" << wrap(text, 80) << "\n";

{{out}}

<pre>

 

=={{header|Clojure}}==

(defn wrap-line [size text]

(loop [left size line [] lines []

(recur (- size wlen) [word] (conj lines (apply str line)) (next words))))

(when (seq line)

 

(defn wrap-line [size text]

(re-seq (re-pattern (str ".{1," size "}\\s|.{1," size "}"))

 

(defn wrap-line [size text]

 

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

 

(doseq [line (wrap-line 72 text)]

 

{{out}}

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.

 

20 rem rosetta code

30 s$="":co=40:gosub 200

440 as$=as$+tp$

450 r$=as$

 

{{out}}

 

=={{header|Common Lisp}}==

 

(defun greedy-wrap (str width)

(push (subseq str begin-curr-line prev-space) lines)

(setq begin-curr-line (1+ prev-space)) )))

 

{{out}}

=={{header|D}}==

===Standard Version===

immutable frog =

"In olden times when wishing still helped one, there lived a king

foreach (width; [72, 80])

writefln("Wrapped at %d:\n%s\n", width, frog.wrap(width));

{{out}}

<pre>Wrapped at 72:

Basic algorithm. The text splitting is lazy.

{{trans|Go}}

 

string wrap(in string text, in int lineWidth) {

foreach (width; [72, 80])

writefln("Wrapped at %d:\n%s\n", width, frog.wrap(width));

{{out}}

<pre>Wrapped at 72:

took a golden ball, and threw it up on high and caught it, and this ball was her

favorite plaything.</pre>

 

=={{header|Dyalect}}==

 

vel purus hendrerit vehicula. Integer hendrerit viverra turpis, ac sagittis arcu

pharetra id. Sed dapibus enim non dui posuere sit amet rhoncus tellus

printWrap(at: 72)

 

{{out}}

venenatis feugiat, augue orci pellentesque risus, nec pretium lacus enim eu

nibh.</pre>

 

=={{header|Elena}}==

import system'routines;

import extensions'text;

^ TokenEnumerator

.new(self)

{

currentWidth += word.Length;

currentWidth := word.Length + 1;

}

else

console.printLine(new StringWriter("-", 80));

console.printLine(text.wrap(80));

{{out}}

<pre>

=={{header|Elixir}}==

{{trans|Erlang}}

def paragraph( string, max_line_length ) do

[word | rest] = String.split( string, ~r/\s+/, trim: true )

IO.puts String.duplicate("-", len)

IO.puts Word_wrap.paragraph(text, len)

 

{{out}}

 

=={{header|Erlang}}==

-module( word_wrap ).

 

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}.

{{out}}

<pre>

=={{header|F_Sharp|F#}}==

{{trans|C#}}

 

let LoremIpsum = "

Wrap l n |> Seq.iter (printf "%s")

printfn ""

{{out}}

<pre style="font-size:smaller">------------------------------------------------------------------------

 

=={{header|Factor}}==

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

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

{{out}}

<pre>

 

=={{header|Forth}}==

\ usage: gforth wrap.f in.txt 72

 

2dup strip-nl

.wrapped

 

=={{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.

 

...

DO I = 0,120

WRITE (6,*) TEXT(I*80 + 1:(I + 1)*80)

would write forth the text with eighty characters per line, paying no attention to the content when it splits a line.

 

 

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.

MODULE RIVERRUN !Schemes for re-flowing wads of text to a specified line length.

INTEGER BL,BLIMIT,BM !Fingers for the scratchpad.

CALL FLOW("")

CLOSE (IN)

Output: note that the chorus is presented with a leading space so as to force a new line start for it.

<pre>

 

=={{header|FreeBASIC}}==

 

texto = "In olden times when wishing still helped one, there lived a king " &_

WordWrap(texto,80)

Sleep

{{out}}

<pre>

=={{header|Go}}==

Basic task, no extra credit.

 

import (

fmt.Println("wrapped at 72:")

fmt.Println(wrap(frog, 72))

{{out}}

<pre>

 

'''Solution 1: Imperative Style'''

def sb = new StringBuilder()

def line = ''

}

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

 

println wordWrap(text)

{{out}}

<pre>In olden times when wishing still helped one, there lived a king whose daughters

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 ->

}.collect { it.join(' ') }.join('\n')

}

 

this solution shows off the more functional aspects of groovy.

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

b.length()+w >= len ? b << str[i..-1] : wordWrap(str, w, min(x+w+1, len), b, len, 0)

}

 

Should be noted that this is not idiomatic groovy or a recommended way of programming, but it is interesting as an exercise.

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.

=={{header|Haskell}}==

Greedy wrapping:

concat

[ "In olden times when wishing still helped one, there lived a king"

lw = length w

 

 

 

 

wWrap :: Int -> String -> String

" caught it, and this ball was her favorite",

" plaything."

 

=={{header|Icon}} and {{header|Unicon}}==

The following works in both languages.

 

procedure main(A)

ll := integer(A[1]) | 72

if *trim(l) = 0 then suspend "\n" # Paragraph boundary

}

 

Sample runs:

=={{header|IS-BASIC}}==

The word warp, any kind of text alignment, specifying tab positions are basic services of the EXOS operating system.

110 CALL WRITE(12,68,0)

120 PRINT :CALL WRITE(10,70,1)

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."

 

{{out}}

 

=={{header|J}}==

wrap =: (] turn edges) ,&' '

turn =: LF"_`]`[}

 

ww GA NB. Wrap at 75 chars by default

dedicated to the

proposition that all men

 

=={{header|Java}}==

package rosettacode;

 

}

 

 

=={{header|JavaScript}}==

 

===Recursive===

function wrap (text, limit) {

if (text.length > limit) {

return text;

}

console.log(wrap(text, 80));

 

{{out}}

</pre>

 

console.log(wrap(text, 42));

 

{{out}}

A simple regex suffices (and proves fastest) for the greedy version:

 

'use strict';

 

)

 

 

{{Out}}

 

=== EcmaScript 6 ===

/**

* [wordwrap description]

}).join('\n'); // Объединяем элементы массива по LF

}

 

console.log(wordwrap("The quick brown fox jumped over the lazy dog.", 20, "<br />\n"));

 

{{out}}

 

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

then .[-1] += ($pad * " ") + $word

else . + [ $word]

'''Task 1''':

{{Out}}

aaa bb

ddddd

'''Task 2''':

{{Out}}

aaa

'''With input from a file''': Russian.txt

<div style="overflow:scroll; height:100px;">

менее 100 советских самолетов поднялись в воздух, когдаамериканские

авианосцы "Уинсон" и "Мидуэй" приблизились на 50 миль к Владивостоку.

'''Main''':

wrap_text(40)[]

{{Out}}

советских военных судов и самолетов была

отмечена в Японском море после появления

"Уинсон" и "Мидуэй" приблизились на 50

миль к Владивостоку.

 

=={{header|Julia}}==

Using [https://github.com/carlobaldassi/TextWrap.jl TextWrap.jl] library.

 

 

text = """Reformat the single paragraph in 'text' to fit in lines of no more

print_wrapped(text, width=80)

println("\n\n# Wrapped at 70 chars")

 

{{out}}

 

=={{header|Klingphix}}==

%ps 0 !ps

100 wordwrap nl nl

 

{{out}}

<pre>tlhIngan Hol jatlhwI', pIvan. ghomuv! nItebHa' mu'ghomvam wIchenmoHlaH.

 

=={{header|Kotlin}}==

 

val text =

println("\nGreedy algorithm - wrapped at 80:")

println(greedyWordwrap(text, 80))

 

{{out}}

 

The test text will be the third first paragraphs of Jules Verne's book, The Mysterious Island.

{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

 

1) lambdatalk can simply call HTML tags and CSS rules:

{def wrap1

{lambda {:n}

à l’équateur, depuis le trente-cinquième parallèle nord jusqu’au

quarantième parallèle sud ! (L’île mystérieuse / Jules Verne)

 

2) a lambdatalk function

 

A translation from the Kotlin entry:

{def wrap2 // the function's name

 

jusqu’au quarantième parallèle sud ! (L’île mystérieuse /

Jules Verne)

 

3) A translation of the javascript entry. The {jswrap n text} function contains lines until n characters

 

LAMBDATALK.DICT['jswrap'] = function() {

var wrap = function(text, limit) {

parallèle nord jusqu’au quarantième parallèle sud ! (L’île

mystérieuse / Jules Verne)

 

=={{header|Lasso}}==

text::string,

row_length::integer = 75

wordwrap(#text)

'<hr />'

 

-><pre>Lorem ipsum dolor sit amet, consectetur

{{trans|Erlang}}

 

(defun wrap-text (text)

(wrap-text text 78))

((word `#(,max ,line-len ,line ,acc))

`#(,max ,(+ line-len 1 (length word)) ,(++ line " " word) ,acc)))

 

=== Regex Implementation ===

 

(defun make-regex-str (max-len)

(++ "(.{1," (integer_to_list max-len) "}|\\S{"

(re:replace text find-patt replace-patt

'(global #(return list)))))

 

Usage examples:

 

> (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))

<pre>

Even today, with proportional fonts and complex layouts, there are still cases

ok

</pre>

> (io:format (wrap-text text 50))

<pre>

Even today, with proportional fonts and complex

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)

 

----------------------------------------

channel(1).removeScriptedSprite()

return lines

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 "&\

repeat with l in lines

put l

{{Out}}

<pre>

=={{header|Lua}}==

 

local res = {}

for w in s:gmatch("%S+") do

print(textwrap(example1))

print()

 

{{out}}

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).

 

Module Checkit {

\\ leading space from begin of paragraph stay as is

}

Checkit

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

wordWrap[textWidth_,spaceWidth_,string_]:=Module[{start,spaceLeft,masterString},

spaceLeft=textWidth;

];

StringJoin@@Riffle[masterString,"\n"]

{{out}} for width 72 and 80:

{{out}}

<pre>In olden times when wishing still helped one, there lived a king

 

=={{header|MiniScript}}==

width = 15

words = str.split

end if

end for

{{out}}

<pre>

=={{header|NetRexx}}==

===version 1===

options replace format comments java crossref symbols

 

''

return speech01

{{out}}

<pre style="height:15em; overflow:scroll">

 

===version 2===

* 23.08.2013 Walter Pachl translated from REXX version 2

**********************************************************************/

If s>'' Then

say s

 

=={{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 txt.wrapWords(45)

{{out}}

<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Donec a diam lectus.

=={{header|OCaml}}==

 

 

let txt = "In olden times when wishing still helped one, there lived

) (0, "") words

in

 

Testing:

 

=={{header|Ol}}==

(define (get-one-word start)

(let loop ((chars #null) (end start))

(lines (get-all-lines words width)))

lines))

 

{{out}}

 

=={{header|PARI/GP}}==

my(t="",cur);

s=Vec(s);

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)

 

{{out}}

=={{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

 

$_ = $s;

 

=={{header|Phix}}==

<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,

<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>

{{Out}}

<pre>

 

=={{header|Phixmonti}}==

 

72 var long

endfor

drop ps> drop

{{out}} 72 and 100.

<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Maecenas varius

 

=={{header|PHP}}==

 

$text = <<<ENDTXT

 

echo wordwrap( $text, 80 ), PHP_EOL, PHP_EOL;

{{Out}}

<pre style="font-size:84%;height:55ex">

 

=={{header|Picat}}==

 

go =>

fugiat nulla pariatur. Excepteur sint occaecat cupidatat non

proident, sunt in culpa qui officia deserunt mollit anim id est

 

{{out}}

=={{header|PicoLisp}}==

'[http://software-lab.de/doc/refW.html#wrap wrap]' is a built-in.

The quick

brown fox

jumps over

the lazy dog

 

=={{header|PL/I}}==

ww: proc Options(main);

/*********************************************************************

End;

End;

Test result using this:

<pre>

=={{header|PowerShell}}==

Basic word wrap.

$divide=$args[0] -split " "

$width=$args[1]

wrap $paragraph 100

 

{{Out}}

<pre>

===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.

function Out-WordWrap

{

}

}

Grab some data and send it down the pipeline:

[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.",

 

$paragraphs | Out-WordWrap -Width 100

{{Out}}

<pre>

=={{header|Prolog}}==

{{works with|SWI Prolog}}

word_wrap(String, Length, Wrapped):-

re_split("\\S+", String, Words),

test_word_wrap(60),

nl,

 

{{out}}

 

=={{header|PureBasic}}==

DataSection

Data.s "In olden times when wishing still helped one, there lived a king "+

Repeat : d$=Inkey() : Delay(50) : Until FindString("lr",d$,1,#PB_String_NoCase) : PrintN(d$+#CRLF$)

main(t$,lw) : Input()

{{out}}

<pre>

 

=={{header|Python}}==

>>> help(textwrap.fill)

Help on function fill in module textwrap:

wrap(), tabs are expanded and other whitespace characters converted to space. See

TextWrapper class for available keyword args to customize wrapping behaviour.

 

=={{header|Quackery}}==

 

a consuming love for cats and dedicates himself to the

protection of cats, you have only to accuse him of killing

55 wrap$ cr

75 wrap$ cr

 

{{out}}

 

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.

hendrerit. Donec et mollis dolor. Praesent et diam eget

libero egestas mattis sit amet vitae augue. Nam tincidunt

 

=== Using the stringr tidyverse library ===

 

Another option, using <code>stringr::str_wrap</code>

> 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))

libero egestas mattis sit amet vitae augue. Nam tincidunt

congue enim, ut porta lorem lacinia consectetur.

 

=={{header|Racket}}==

 

Using a library function:

#lang at-exp racket

(require scribble/text/wrap)

high and caught it, and this ball was her favorite plaything.})

(for-each displayln (wrap-line text 60))

 

Explicit (and simple) implementation:

#lang racket

 

;;; Usage:

(wrap (string-split text) 70)

 

=={{header|Raku}}==

(formerly Perl 6)

whose daughters were all beautiful, but the youngest was so beautiful

that the sun itself, which has seen so much, was astonished whenever

 

say $s.subst(/ \s* (. ** 1..66) \s /, -> $/ { "$0\n" }, :g);

 

=={{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.*/

end /*m*/

if $\=='' then say $ /*handle any residual words (overflow).*/

'''output''' &nbsp; is the same as version 1 using the &nbsp; '''L'''eft &nbsp; option (the default).

 

<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 kind _ . /*obtain optional arguments from the CL*/

if iFID=='' | iFID=="," then iFID = 'LAWS.TXT' /*Not specified? Then use the default.*/

say $ /*display the line of words to terminal*/

_= x /*handle any word overflow. */

This REXX program makes use of &nbsp; '''LINESIZE''' &nbsp; REXX program (or BIF) which is used to determine the screen width (or linesize) of the terminal (console).

 

 

===version 2===

* 20.08.2013 Walter Pachl "my way"

* 23.08.2013 Walter Pachl changed to use lastpos bif

Call o s

Return

{{out}} for widths 72 and 9

<pre>

 

=={{header|Ring}}==

# Project : Word wrap

 

next

see line + nl + nl

Output:

<pre>

 

=={{header|Ruby}}==

def wrap(width)

txt = gsub("\n", " ")

puts "." * w

puts text.wrap(w)

 

{{out}}

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 ";_

 

html "<table border=1 cellpadding=2 cellspacing=0><tr" + wrap$ +" valign=top>"

output will adjust as you stretch the browser and maintain a 60 to 40 ratio of the width of the screen.

<pre>

</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

docOut$ = docOut$ + thisWord$

wend

 

=={{header|Rust}}==

This is an implementation of the simple greedy algorithm.

 

pub struct LineComposer<I> {

words: I,

.for_each(|line| println!("{}", line));

}

 

{{out}}

=={{header|Scala}}==

===Intuitive approach===

 

object WordWrap extends App {

letsWrap(ewd)

letsWrap(ewd, 120)

................................................................................

Vijftig jaar geleden publiceerde Edsger Dijkstra zijn kortstepadalgoritme.

The simple, greedy algorithm:

 

(import (scheme base)

(scheme write)

(show-para simple-word-wrap 50)

(show-para simple-word-wrap 60)

 

{{out}}

 

=={{header|Seed7}}==

 

const func string: wrap (in string: aText, in integer: lineWidth) is func

writeln(wrap(frog, width));

end for;

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

=={{header|Sidef}}==

===Greedy word wrap===

method wrap(width) {

while (i < len) {

}

}

 

 

{{out}}

 

===Smart word wrap===

 

has width = 80

root << [

array.first(i+1).join(' '),

]

 

self.combine([], path, { |combination|

var score = 0

score += (width - line.len -> sqr)

}

}

}

{{out}}

<pre>

 

=={{header|Standard ML}}==

let

fun appendLine (line, text) =

end

 

{{in}}

<pre>Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore

occaecat cupidatat non proident, sunt in culpa qui officia deserunt

mollit anim id est laborum.</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} {

puts [wrapParagraph 80 $txt]

puts "[string repeat - 72]"

{{out}}

<pre>--------------------------------------------------------------------------------

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."

wrappedtext=FORMAT(text,length,firstline,nextlines)

FILE "text" = wrappedtext

{{out}}

<pre style='height:30ex;overflow:scroll'>

 

=={{header|VBScript}}==

column = 60

text = "In olden times when wishing still helped one, there lived a king " &_

End If

End Sub

 

{{Out}}

</pre>

 

{{trans|Go}}

mut wrapped := ''

words := text.fields()

println("wrapped at 72:")

println(wrap(frog, 72))

 

{{out}}

=={{header|Wren}}==

{{trans|Kotlin}}

var words = text.split(" ")

var sb = words[0]

System.print(greedyWordWrap.call(text, 72))

System.print("\nGreedy algorithm - wrapped at 80:")

 

{{out}}

 

=={{header|XPL0}}==

proc WordWrap(Text, LineWidth); \Display Text string wrapped at LineWidth

char Text, LineWidth, Word, SpaceLeft, WordWidth, I;

WordWrap(Text, 72); CrLf(0);

WordWrap(Text, 80); CrLf(0);

 

{{out}}

 

=={{header|Yabasic}}==

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 "

next i

return n

 

{{trans|Run BASIC}}

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 "

close #f

 

 

=={{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();

}

sink

{{out}}

<pre>

times ...

</pre>

{{out}}

<pre>

9: favorite plaything.

</pre>

{{out}}

<pre>