World: r3wp

.Yes "Newfile would have to be "parsed" into words

something like:

Newfile: parse file

or 

file: parse/with file {separator character}

troubel is, parse doesn't only just parse on " " if specified ...

so, you might lose other characters.

I think this can be done in one pass.

I would not rely on parse helpers, as parse string delimiter, but 
use full parse/all, if you need precise result ...

Yes, give me a minute...

capitalize-word: func [

    s [string!]
    /local len

][

    either 5 < len: length? s [

        s: rejoin ["<strong>" uppercase s/1 next s </strong>]

    ][

        s

    ]
 
]



capitalize-text: func [
    s [string!]

    /local result word-rule alpha non-alpha w c
][

    result: copy {}
    alpha: charset [#"A" - #"Z" #"a" - #"z"]

    non-alpha: complement alpha

     word-rule: [copy w [some alpha] (insert tail result capitalize-word 
     w)]
    other-rule: [copy c non-alpha (insert tail result c)]

    parse/all s [some [word-rule | other-rule] end]
    result

]

>> capitalize-text {The result changes according to formating.}  
          

; 
== {The <strong>Result</strong> <strong>Changes</strong> <strong>According</strong> 
to <strong>Formating</strong>.}

Not quite the problem I was stating!

search for a series of capitalised words and strong them

Ah. Very easy modification.

bolden-word: func [
    s [string!]
    /local len
][
    either 5 < len: length? s [
        s: rejoin ["<strong>" s </strong>]
    ][
        s
    ]
 ]

enhance-text: func [
    s [string!]
    /local result word-rule alpha non-alpha w c
][
    result: copy {}
    alpha: charset [#"A" - #"Z"]
    non-alpha: complement alpha

    word-rule: [copy w [some alpha] (insert tail result bolden-word w)]
    other-rule: [copy c non-alpha (insert tail result c)]
    parse/all s [some [word-rule | other-rule] end]
    result
]

Thanks Jaime.

capitals: charset ["#"A" - #"Z"]
alpha: charset ["#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any non-alpha any [
    a: 5 capitals any capitals b: non-alpha (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha any non-alpha
] to end]

This is the Parse group after all.

ohhhh... shorter :)

; A few fixes
capitals: charset ["#"A" - #"Z"]
alpha: charset ["#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any non-alpha any [
    a: 5 capitals any capitals b: [non-alpha | end] (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha any non-alpha
] to end]

capitals: charset ["#"A" - #"Z"] ... remove  leading "

I think I missunderstood the problem. I thought the the emphasis 
was not for words all in uppercase. Just ther first char.

Yeah ... it was a way to mark up text wherever a sequence of CAPS 
occurs

Any how you got the idea. This type of problem could actually use 
the rewrite rules engine from gabriele. The principle is the same.

; Sorry, more fixes
capitals: charset ["#"A" - #"Z"]
alpha: charset ["#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any [

    any non-alpha a: 5 capitals any capitals b: [non-alpha | end] (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha
] to end]

Brian ... your rules are incorrect.

you have extra " in the charset defiitions

Right. I was running this in my head, as I don't have test data. 
REBOL usually catches syntax errors :)

Actually I would like to add a parse problem to the weeklyblog and 
get people to submit answers :)

I use parse quite a bit. It's funny, I've never needed the GUI of 
View, but I use parse daily.

And give a prize for the shortest answer

say a copy of Microsoft VB :)

By shortest, go for most efficient. Otherwise variable naming becomes 
an issue.

Shorter may not be clearer or abstract enough. I prefer the something 
that can become an API an reused. But we will need to exclude the 
rewrite-rule of Gabriel. ;-)

Hey, I worked on those rules, they're pretty good :)

shortest .. I mean the least number of words, and operators - not 
in length

Hahaha, no offense Brian. ;-)

Can't use this problem though .. this group is web public!

It's too simple anyways.

I am hoping that it will be instructive ... as well.

so simple things are good to start with ... we can have harder ones 
once we see how people respond

Seriously though, three charsets and two temporary variables, there's 
got to be a more efficient way.

should non-alpha be non-captitals? (running in head too)

; Sorry, more fixes
capitals: charset [#"A" - #"Z"]
alpha: charset [#"A" - #"Z" #"a" - #"z"]
non-alpha: complement alpha
parse/all/case [any [to alpha [
    a: 5 capitals any capitals b: [non-alpha | end] (

        b: change/part a rejoin ["<strong>" copy/part a b "</strong>"] b
    ) :b |
    some alpha
]] to end]

No, because that would allow words like this: ABCDEFghij

it would collect as long as there are capitals?

and "g" is none

Well, that would be up to Graham. His original description would 
seem to exclude such words.

means all uppercase?

As far as I can tell.

Yeah .. all uppercase ..

because " a: 5 capitals any capitals b:" stops at "g" and friends.

More importantly, it fails at "g" and friends, backtracks and proceeds 
to the next alternate action, some alpha.