World: r3wp

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.

Late, but got it. it would enclose "ABCDEF" but should ignore it 
because of the small letters..

Yup. Parse is fun.

You can drop one charset by changing [non-alpha | end] to [alpha 
end skip | end | none] .

would alpha break work?

No, that would break out of the enclosing all loop. The end skip 
will always fail and proceed to the next alternate.

capital: charset {ABCDEFGHIJKLMNOPQRSTUVWXYZ}
latipac: complement capital
rule: [
    any latipac here:
    copy token some capital there:
    (all[ 4 < length? token
        insert :there "</strong>"
        insert :here "<strong>"
        there: skip :there 16
    ])
    :there
]
parse/all/case txt [some rule]

problem is "Aa", thats aword, but notan all-uppcase-word. so it should 
be ignored.

capital: charset {ABCDEFGHIJKLMNOPQRSTUVWXYZ}
latipac:  complement capital
ws: charset { ^/^-}
rule: [
    any latipac here:
    copy token some capital there:
    opt [some ws
        (all[ 4 < length? token
            insert :there "</strong>"
            insert :here  "<strong>"
            there: skip :there 16]
        )
    ]
    :there
]
parse/all/case txt [some rule]

Fails on "aA".

The inserts are a nice touch though.

capital: charset {ABCDEFGHIJKLMNOPQRSTUVWXYZ}
ws: charset { ^/^-}
latipac: difference complement capital ws


sub-rule: [
	some capital there:
	[ws | end]
	(all[ 4 < length? copy/part :here :there
		insert :there "</strong>"
		insert :here  "<strong>"
		there: skip :there 17]
	)
]
rule: [
	any latipac 
	[	some ws here:
		sub-rule
	]|[skip there:]
	:there
]
parse/all/case txt [here: opt sub-rule some rule]

Doesn't take into account punctuation in the ws charset. This would 
fail on "HELLO, WORLD!"