The problem that you are addressing (along with a load more) is excellently solved by the Text::Autoformat module.

For simpler needs, see Text::Wrap.

If you wish to avoid any modules, you can do it this way:

#!/usr/local/bin/perl
use strict;
use warnings;

my $var = "this is just a sample of a string, there is nothing really 
+important in the scalar, just a lot of text";

my $pos = 9;
while(( $pos = index($var, ' ', $pos)) > -1 ) {
    substr($var, $pos, 1) = "\n";
    $pos += 10;
}
print "\n$var\n";
[download]

Just remember, TIMTOWTDI.

- - arden.

Your question looks remarkably similar to the one you posted here. Are you not happy with the answers you received before? Did you try any of the suggestions?

Similar question, but different. In the first question I didn't care about the nth character, in this case I do. This question is slightly more complicated.

Given you had an answer to a similar question, what attempts (if any) did you make to adapt that answer to the new requirement(s)?

Perlmonks is not a free software development shop. We gladly provide our knowledge to those who have made every attempt to solve their problems and cannot go further. If you want someone to write your code for you, look at http://jobs.perl.org for reasonable rates on consultants.

------
We are the carpenters and bricklayers of the Information Age.

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

#!/usr/bin/perl

use strict;
use warnings;

my $var = "this is just a sample of a string, there is nothing really 
+important in the scalar, just a lot of text";
my @box = split(/\b/, $var);
my @line;

while (@box) {
  shrink();
}

sub shrink {
  my $word = '';
  while (length $word <= 10) {
    last unless (@box);
    $word .= shift @box;
  }
  push (@line, $word);
}

print join("\n", @line), "\n";
[download]

s/\s/\n/g;
[download]

s/(?<=[^\n]{10})\s/\n/g;
[download]

s/([^\n]{10})\s/$1\n/g;
[download]

Ok, bonus round: there is a way to do it with lookbehind, but it's ugly. We use \G to indicate where the last match left off. We want there to be at least 10 non-newlines between any new match and the old one. So:

s/(?<=(?:(?<!\G)[^\n]){10})\s/\n/g;
[download]

Update: Ok, re-reading the original question, we don't want to SUBSTITUTE for spaces, we want the newline to be inserted AFTER a space, and the space is (at least) the 10th character, meaning it's preceded by 9 chars. Thus:

s/([^\n]{9}\s)/$1\n/g;
[download]

s/(.{10})([^\s]*?)\s/\1\2\n/g;
[download]

Very good answer, but you can simplify it to

s/(.{9}\S*\s)/$1\n/g
[download]

Note especially the use of $1 instead of \1.

Update: inserted the \s I forgot.

Update 2:As pointed to by Roy Johnson, the \S* can be left out like this:

s/(.{9}\s)/$1\n/g
[download]

Also, I changed {10} to {9} as the space is the tenth character.

That was actualy a bit of fun there. Not sure how you wanted to handle cleaning up the spaces but here is my go at it. I used a while loop with a regex and the /g modifier. The regex is /(.{10,}?\b)/gThat should be read as find 10 or more occurances of any character followed by a word break ( you could change this to a space or \s, however it suits you, this just works pretty well). Here is the full bit, you would have to change the printing to concating into a new string but thats no challenge.

1234567890123456789
this is just
 a sample
of a string
, there is
 nothing really
 important
 in the scalar
, just a lot
[download]