Topic: Split String With String

[gile]

Talking about speed.

A simple F# implementation:

Code - F#: [Select]

1. open System.Text.RegularExpressions
2.  
3. let foo pat str =
4.     let rec loop acc = function
5.         | [] | [""] -> List.rev acc
6.         | [s]       -> List.rev (s :: acc)
7.         | "" :: l   -> loop (pat :: acc) l
8.         | s :: l    -> loop (pat :: s :: acc) l
9.     Regex.Split(str, Regex.Escape(pat))
10.     |> Array.toList
11.     |> loop []

A little bench for 65536 iterations give results about 10 times faster than AutoLISP

Code - F#: [Select]

1. let bench () =
2.     let sw = System.Diagnostics.Stopwatch()
3.     sw.Start()
4.     for i in 0..65535 do
5.         foo "$#*" "$#*ABC$#*DEF$#*GHIJKL$#*MNOP$#*" |> ignore
6.     sw.Stop()
7.     printfn "Elapsed milliseconds for 65536 iterations: %d" sw.ElapsedMilliseconds

Code: [Select]

> bench ();;
Elapsed milliseconds for 65536 iterations: 123
val it : unit = ()

EDIT: I was tired last night, Regular Expression can do it quite directly:

Code - F#: [Select]

1. let foo pat str =
2.     Regex.Split(str, "(" + Regex.Escape(pat) + ")")
3.     |> Array.filter(fun s -> s <> "")

[ronjonp]

Ok... take look at the arguments:

Code: [Select]

(_foo  Keys String)
(foo   Keys String)
(split String Keys)
(ALE   String Keys)


I see that now .. guess I should not assume that initial form would follow in testing.

[Marc'Antonio Alessi]

About recursion, with long string we can see more differences:

Code: [Select]

(progn
(setq Keys "$#*" String "$#*ABC$#*DEF$#*GHIJKL$#*MNOP$#*")
(repeat 8 (setq String (strcat String Keys String))) ; la ricorsione arriva fino a 11
(print (strlen String))
(princ)
)
Comando: (strlen String)
8701

Elapsed milliseconds / relative speed for 1024 iteration(s):
    (ALE STRING KEYS).....1531 / 4.34 <fastest>
    (ALE STRING KEYS).....1531 / 4.34
    (FOO KEYS STRING).....6547 / 1.01
    (FOO KEYS STRING).....6641 / 1 <slowest>



[VovKa]

Interesting enough I fixed the benchmark and Lee's split is still the fastest?

you've switched the arguments in Lee's function only once, but should've done it thrice

[gile]

ronjonp,

It looks like you have a wrong version of the 'split' routine.
With the version you psted

Code - Auto/Visual Lisp: [Select]

1. _$ (split "$#*" str)

returns ("" "$#*" "$#*")

Before hunting milliseconds with benchmarks, we should make sure that the routines work as expected.

[ronjonp]

Interesting enough I fixed the benchmark and Lee's split is still the fastest?

you've switched the arguments in Lee's function only once, but should've done it thrice

DOH! 

[Marc'Antonio Alessi]

Tested on Bricscad V17, recursion is very slow:

Code: [Select]

(progn
(setq Keys "$#*" String "$#*$#*ABC$#*DEF$#*$#*GHIJKL$#*MNOP$#*$#*")
(repeat 6 (setq String (strcat String Keys String)))
(print (strlen String)) (princ " strlen\n")
(princ)
)
2749  strlen
Elapsed milliseconds / relative speed for 16384 iteration(s):
    (ALE STRING KEYS)......2938 / 11.89 <fastest>
    (FOO KEYS STRING).....34922 / 1 <slowest>

...another bug with adjacent key, similar my first version:

Code: [Select]

(defun ALE (s d / p m l o r)
  ; 20170614 - version 1.03 for adjacent key (d)
  (cond
    ( (setq
        l (strlen d)          p 0
        m (vl-string-search d s 0)
      )
      (while m
        (if (zerop (- m p))
          (setq o (cons d o))
          (setq o (cons d (cons (substr s (1+ p) (- m p)) o)))
        )
        (setq
          p (+ m l)
          m (vl-string-search d s p)
        )
      )
      (if (= "" (setq r (substr s (1+ p))))
        (reverse o)
        (reverse (cons r o))
      )
    )
    ( (list s) )
  )
)