World: r3wp

>> a: [a a a b b c d e e] b: [] foreach x unique a [repend b [x 1 
+ offset? find a x find/last a x]] b
== [a 3 b 2 c 1 d 1 e 2]

Or you could use REDUCE/into or map! if you are using R3.

Awsome...

If you preallocate the result it might be faster in some cases - 
it should be twice the length of the UNIQUE a (or the saame length 
in map)

...same length if map!.

Other tricks can be used if you can't sort a.

unique remove-each x a [(find a x) = find/last a x]

not that I want to do nit-picking, but it should be noted, that the 
algorithms presented above are all O(n * n), while an O(n * log-e 
n) algorithm can be written, although such an algorithm is likely 
to be a bit more complicated

I'd just SORT then PARSE...

Sounds like a new puzzle entry! ;)

hehe

Puzzle entry.. Is there a code golf website for REBOL? Like codegolf.com 
? I did those with Ruby, that was pretty fun.

No really.....There is Puzzles and Puzzle Answers here, but they 
aren't very web-public.

There have been some nice puzzles on the mailing list:
   http://www.rebol.org/ml-topic-detail.r?l=p&topic=puzzle

The big problem with most code golf puzzles is they only ever play 
one one......It'd be better to have puzzles that are rolled out in 
stages: each stage being a modification to the previous puzzle spec. 
that way, generality and flexibility would be rewarded.

Yeah, usually the focus lies on code size (who writes the tiniest 
solution) which isn't always the best solution to a problem. Well, 
there aren't "best solutions" anyhow because it always depends on 
what you need (speed/stability/security/readability/etc.), often 
enough you need to make a tradeoff there so you can't really say 
one is best. But your idea would be a good start to improve code 
golfing. Now you just need to make a nice website that I can visit 
;)

...switching to [All] for the code golf discussion.....

Is there a simple way to convert a number to its binary representation?

This is what I want, but without the limit of 255 that char! types 
have:
>> enbase/base to-binary to-char 7 2
== "00000111"

This does it, though there may be faster native ways for the specific 
case of decimal-->binary@
   http://www.rebol.org/documentation.r?script=base-convert.r

found a bug in 'FOR when used in series... it becomes an endless 
loop..

>> s: "12345"
== "12345"
>> for c s tail s 1 [probe c]
12345
2345
345
45
5
; <----- it should stop here 




....

Izkata, it's a little tricky with R2, but this works for any integer:

>> enbase/base debase/base to-hex 546 16 2
== "00000000000000000000001000100010"

Thanks Sunanda, Steeve - I had a loop to generate it manually, but 
an enbase/debase-based solution is far faster  ;)

Izkata, there's a library of bit operations with several useful functions, 
also one that can do, what you need:

>> do http://www.fys.ku.dk/~niclasen/rebol/libs/bit.r
>> enbit 546
== "00000000000000000000001000100010"

It's BSD license, so you can use it in your work.

Max, I think that has been reported many times, eg. http://www.rebol.net/cgi-bin/rambo.r?id=4121&

Normal zero padding of decimals:

>> to-string .48
== "0.48"

Is it possible do to something like this:

>> magic-function .48
== ".48"


This would help in cases where you need to build a query string to 
search for plain text.

maybe something like:

magic-function: func [num [number!] /local result] [
    result: form num
    if #"0" = first result [remove result]
    result
]

you may want to handle cases like "0" specially, depending on what 
your exact needs are.

hmm... thanks. it seems that the problem is a little different than 
that, however.


I'm just loading a string: "this-column contains 001" which is loaded 
incorrectly to [this-column contains 1], so I have to do this differently 
in the loading phase.

Ah, the user should just use quotes.

I've forgotten .. is there a sort that sorts on the basis of the 
length of strings?

>> sort/compare ["1" "22" "333"] func [a b] [greater? length? :a 
length? :b]
== ["333" "22" "1"]

Actually, to make that a stable sort it should be greater-or-equal? 
instead.

cool ...

to make that a stable sort it needs to return -1, 0 or 1, not true 
or false. sign? on the difference would do the trick.

reboltutorial claims, that copying files larger than 1GB fails with 
R2? Anyone having similar experience? http://reboltutorial.com/blog/do-you-need-to-copy-big-files/

Perhaps he means 2GB, which is a known consequence of using 32bit 
signed integers for file indexes.

Fixed in R3, due to the switch to 64bit signed integers.

is it possible to cascade error throws through several functions?

never mind, I did something wrong. got it now.

Ubuntu 9.04; rebcore (2.7.6) can     devmem: open/read/binary %/dev/mem
rebview hangs.


Do I need to care?   I don't need View for this little informational 
gathering app, but ...


We are planning for an embedded system BIOS tweak so we can label 
an Asset Tag in the SMBIOS;  REBOL won the race getting the information 
decoded for everyone to see; beat Python development by a few minutes 
(in a highly uncompetitive sharing information back and forth development 
"race")

try /direct or /seek

/seek does not work

are you sure View didn't just pop up its security requestor behind 
the terminal so you couldn't see it?

Has anyone got a routine that calcuates the difference between two 
dates as an age in a format appropriate to that age.

So, age is displayed as a days for under a week, in weeks for under 
3 months, and as months upto 3 years, and then as years/months after 
that.

I've used 'case for that in the past, rough example:

	age: case [
		1 > diff: d2 - d1 ["less than a day"]
		7 > diff [reform [diff "days"]]
		... etc ...
	]

That way, you can tune it as fine as you need it.

I ended up using case .. and just straight subtraction of years etc 
instead of using 'difference which can sometimes lead to numeric 
overflow.

Something similar I've used:
   DayConv: func [Days /local Ret Tip][
      Ret: copy {}
      Tip: false
      foreach Val [[365 y] [31 m] [7 w] [1 d]] [
         if Days >= Val/1 [
            append Ret join to-integer divide Days Val/1 Val/2
            Days: mod Days Val/1
            if Tip [return Ret]
            Tip: true
         ]
      ]
      return Ret
   ]


'Tip was to make it stop at just two time-indicators (So 2 months, 
1 week, and 3 days would display just as 2m1w, omitting the days, 
for example)

(Messy looking implementation is due to being reeaally tired at the 
time, just never felt like fixing it up...)

Interesting.