what is the best way to take a string with inegers interspersed with
non-integer chars and split it into a list of integers and chars?

in my particular case the ints are all (supposed to be) non-neg.
and there should be at most one non-digit-p char between ints.

i've looked into cycling thru with parse-integer for the ints, grabbing
the next char (if any) and looping like that until the string is done.

or looping across the string, builing up ints via (+(* 10 ..)..).

is there a better way?

i'm avoiding external libs for this code, so i need to do this w/o using
cl-ppcre or the like...

thanks,

-JimC
--
James Cloos <cloos@jhcloos.com> OpenPGP: 0x997A9F17ED7DAEA6

On 7/6/2022 3:07 PM, James Cloos wrote:
> what is the best way to take a string with inegers interspersed with
> non-integer chars and split it into a list of integers and chars?
>
> in my particular case the ints are all (supposed to be) non-neg.
> and there should be at most one non-digit-p char between ints.
>
> i've looked into cycling thru with parse-integer for the ints, grabbing
> the next char (if any) and looping like that until the string is done.
>
> or looping across the string, builing up ints via (+(* 10 ..)..).
>
> is there a better way?
>
> i'm avoiding external libs for this code, so i need to do this w/o using
> cl-ppcre or the like...
>
> thanks,

(loop for elm in list
when num-elm(elm) collect elm in num-list
else collect elm in other-list
finally return (values num-list other-list))
--
Jeff Barnett

On 7/6/2022 3:45 PM, Jeff Barnett wrote:
> On 7/6/2022 3:07 PM, James Cloos wrote:
>> what is the best way to take a string with inegers interspersed with
>> non-integer chars and split it into a list of integers and chars?
>>
>> in my particular case the ints are all (supposed to be) non-neg.
>> and there should be at most one non-digit-p char between ints.
>>
>> i've looked into cycling thru with parse-integer for the ints, grabbing
>> the next char (if any) and looping like that until the string is done.
>>
>> or looping across the string, builing up ints via (+(* 10 ..)..).
>>
>> is there a better way?
>>
>> i'm avoiding external libs for this code, so i need to do this w/o using
>> cl-ppcre or the like...
>>
>> thanks,
>
> (loop for elm in list
>     when num-elm(elm) collect elm in num-list
>     else collect elm in other-list
>     finally return (values num-list other-list))
Sorry I misread the problem.
--
Jeff Barnett

* James Cloos <m38rp654ra.fsf@carbon.jhcloos.org> :
Wrote on Wed, 06 Jul 2022 17:07:53 -0400:

> what is the best way to take a string with inegers interspersed with
> non-integer chars and split it into a list of integers and chars?
>
> in my particular case the ints are all (supposed to be) non-neg.
> and there should be at most one non-digit-p char between ints.
>
> i've looked into cycling thru with parse-integer for the ints, grabbing
> the next char (if any) and looping like that until the string is done.
>
> or looping across the string, builing up ints via (+(* 10 ..)..).
>
> is there a better way?
>
> i'm avoiding external libs for this code, so i need to do this w/o using
> cl-ppcre or the like...

Personally I'd do it with an external function.

```
(setq $s "foo 2030 29393 xyz 13 42 bar 666")

(let (a b) (string-split-map #(#\Space #\Tab) $s :map-fn (lambda (line p q) (if (digit-char-p (char line p)) (push (parse-integer line :start p :end q) a) (push (subseq line p q ) b)))) (list a b))

((666 42 13 29393 2030) ("bar" "xyz" "foo"))
```

with string-split-map from my lisp init file

```
(defun string-split-map (charbag line &key (start 0) end map-fn escape-char)
(let ((p start) (q 0) #+nil (i 0) ret (end (or end (length line))))
(declare (fixnum p q #+nil i))
(loop
;; skip whitespace at left
(loop (cond ((or (= p end) (or (not (find (elt line p) charbag))
(and escape-char (>= (1- p) start) (eql (elt line (1- p)) escape-char))))
(return))
(t (incf p))))
;; find word end
(setq q p)
(loop (cond ((and (< q end) (or (not (find (elt line q) charbag))
(and escape-char (>= (1- q) p) (eql (elt line (1- q)) escape-char))))
(incf q))
(t (return))))
(cond ((and (< p q))
(cond (map-fn (funcall map-fn line p q))
(t (push (subseq line p q) ret)))
(setq p q) #+nil
(incf i))
(t (return (nreverse ret)))))))
```

On Wed, 06 Jul 2022 17:07:53 -0400
James Cloos <cloos@jhcloos.com> wrote:
> what is the best way to take a string with inegers interspersed with
> non-integer chars and split it into a list of integers and chars?
>
> in my particular case the ints are all (supposed to be) non-neg.
> and there should be at most one non-digit-p char between ints.

Do you mean DIGIT-CHAR-P ? If instead of "at most one" of whatever there are
0 , how are the integers going to be separated ?

> i've looked into cycling thru with parse-integer for the ints, grabbing
> the next char (if any) and looping like that until the string is done.
>
> or looping across the string, builing up ints via (+(* 10 ..)..).
>
> is there a better way?

So you want "123a5t789i412v" to return the list
(123 #\a 5 #\t 789 #\i 412 #\v) , yes ? I would use PARSE-INTEGER .

> i'm avoiding external libs for this code, so i need to do this w/o using
> cl-ppcre or the like...

* I <m35yk91y8v.fsf @leonis4.robolove.meer.net> :
Wrote on Thu, 07 Jul 2022 07:26:48 +0530:

> * James Cloos <m38rp654ra.fsf @carbon.jhcloos.org> :
> Wrote on Wed, 06 Jul 2022 17:07:53 -0400:
>
>> what is the best way to take a string with inegers interspersed with
>> non-integer chars and split it into a list of integers and chars?
>>
>> in my particular case the ints are all (supposed to be) non-neg.
>> and there should be at most one non-digit-p char between ints.
>>
>> i've looked into cycling thru with parse-integer for the ints, grabbing
>> the next char (if any) and looping like that until the string is done.
>>
>> or looping across the string, builing up ints via (+(* 10 ..)..).
>>
>> is there a better way?
>>
>> i'm avoiding external libs for this code, so i need to do this w/o using
>> cl-ppcre or the like...
>
> Personally I'd do it with an external function.
>
> ```
> (setq $s "foo 2030 29393 xyz 13 42 bar 666")
>
> (let (a b) (string-split-map #(#\Space #\Tab) $s :map-fn (lambda (line p q) (if (digit-char-p (char line p)) (push (parse-integer line :start p :end q) a) (push (subseq line p q ) b)))) (list a b))
>
> ((666 42 13 29393 2030) ("bar" "xyz" "foo"))
> ```
>
>
> with string-split-map from my lisp init file

Sorry, Like Jeff Barnett I misread the question too. You should have
given an example to make it clear. If as I understand there are no white
spaces in the string then I'd slightly modify string-split-map I posted
(now snipped)

```
(defun parse-cloos (line &key (start 0) end)
(let ((p start) i (q 0) ret (end (or end (length line))) retnum)
(loop
(setq i p)
(loop (cond ((or (= p end) (or (not (digit-char-p (elt line p)))))
(return))
(t (incf p))))
(if (> p i) (push (parse-integer line :start i :end p) retnum))
(setq q p)
(loop (cond ((and (< q end) (or (not (digit-char-p (elt line q)))))
(incf q))
(t (return))))
(cond ((and (< p q))
(push (subseq line p q) ret)
(setq p q))
(t (return (values (nreverse ret) (nreverse retnum))))))))

(setq $a "a123c4445c223")
(parse-cloos $a)
; => ("a" "c" "c"), (123 4445 223)
```

James Cloos <cloos@jhcloos.com> wrote:
> what is the best way to take a string with inegers interspersed with
> non-integer chars and split it into a list of integers and chars?
>

This assumes base 10, could be changed not to (digit-char-p). Obviously
would be better with some macrology on it.

(defun tok (s)
(let ((l (length s)))
(labels
((nak->num (nak n e b)
(if (null nak)
n
(nak->num (rest nak)
(+ n (* (first nak) e))
(* e b)
b)))
(toker (i nak tak)
(if (= i l)
(if (not (null nak))
(nreverse (cons (nak->num nak 0 1 10) tak))
(nreverse tak))
(let ((c (char s i)))
(cond ((digit-char-p c)
(toker (+ i 1) (cons (- (char-code c)
(load-time-value (char-code
#\0)))
nak)
tak))
((not (null nak))
(toker (+ i 1) '() (cons (nak->num nak 0 1 10) tak)))
(t (toker (+ i 1) nak (cons c tak))))))))
(toker 0 '() '()))))

> (tok "82abc12dkgdf")
(82 #\b #\c 12 #\k #\g #\d #\f)

--
the small snake

Zyni Moë <no_email@invalid.invalid> wrote:
> [wrong thing]

Dirty that was buggy (lost char after num) this is right i think:

(defun tok (s)
(let ((l (length s)))
(labels
((nak->num (nak n e b)
(if (null nak)
n
(nak->num (rest nak)
(+ n (* (first nak) e))
(* e b)
b)))
(toker (i nak tak)
(if (= i l)
(if (not (null nak))
(nreverse (cons (nak->num nak 0 1 10) tak))
(nreverse tak))
(let ((c (char s i)))
(cond ((digit-char-p c)
(toker (+ i 1) (cons (- (char-code c)
(load-time-value (char-code
#\0)))
nak)
tak))
((not (null nak))
(toker (+ i 1) '() (list* c (nak->num nak 0 1 10)
tak)))
(t (toker (+ i 1) nak (cons c tak))))))))
(toker 0 '() '()))))

--
the small snake

Spiros Bousbouras <spibou@gmail.com> writes:

> So you want "123a5t789i412v" to return the list
> (123 #\a 5 #\t 789 #\i 412 #\v) , yes ? I would use PARSE-INTEGER .

(let ((string "123a5t789i412v"))
(let ((start 0) (end (length string)) char list)
(loop
(unless (< start end)
(return))
(setf char (aref string start))
(cond ((digit-char-p char)
(multiple-value-bind (int pos)
(parse-integer string :start start :junk-allowed t)
(push int list)
(setf start pos)))
(t
(push char list)
(incf start))))
(nreverse list)))
==> (123 #\a 5 #\t 789 #\i 412 #\v)

Or, if reading from a stream:

(ql:quickload "read-number")
(let ((string "123a5t789i412v"))
(with-input-from-string (stream string)
(let (char list)
(loop
(setf char (peek-char nil stream nil stream))
(when (eq char stream)
(return))
(push (if (digit-char-p char)
(read-number:read-integer stream)
(read-char stream))
list))
(nreverse list))))
==> (123 #\a 5 #\t 789 #\i 412 #\v)

--
Ralph

Ralph Schleicher <rs+usenet@ralph-schleicher.de> writes:

> Spiros Bousbouras <spibou@gmail.com> writes:
>
>> So you want "123a5t789i412v" to return the list
>> (123 #\a 5 #\t 789 #\i 412 #\v) , yes ? I would use PARSE-INTEGER .
>
> (let ((string "123a5t789i412v"))
> (let ((start 0) (end (length string)) char list)
> (loop
> (unless (< start end)
> (return))
> (setf char (aref string start))
> (cond ((digit-char-p char)
> (multiple-value-bind (int pos)
> (parse-integer string :start start :junk-allowed t)
> (push int list)
> (setf start pos)))
> (t
> (push char list)
> (incf start))))
> (nreverse list)))
> ==> (123 #\a 5 #\t 789 #\i 412 #\v)

Using extended loop:

(defun extract-chars-and-integers (string)
(loop with limit = (1- (length string))
for pos = 0 then next-pos
while (<= pos limit)
for pair = (or (multiple-value-bind (num end)
(parse-integer string :start pos :junk-allowed t)
(when num
(cons num end)))
(cons (char string pos) (1+ pos)))
for (value . next-pos) = pair
collect value))

(defvar *test-string* "123a5t789i412v")

(extract-chars-and-integers *test-string*)
=> (123 #\a 5 #\t 789 #\i 412 #\v)

* Raymond Wiker <m2h73p49pk.fsf @MacBook-Pro.home> :
Wrote on Sun, 10 Jul 2022 11:07:35 +0200:
> Ralph Schleicher <rs+usenet @ralph-schleicher.de> writes:
>
>> Spiros Bousbouras <spibou @gmail.com> writes:
>>
>>> So you want "123a5t789i412v" to return the list
>>> (123 #\a 5 #\t 789 #\i 412 #\v) , yes ? I would use PARSE-INTEGER .
>>
>> (let ((string "123a5t789i412v"))
>> (let ((start 0) (end (length string)) char list)
>> (loop
>> (unless (< start end)
>> (return))
>> (setf char (aref string start))
>> (cond ((digit-char-p char)
>> (multiple-value-bind (int pos)
>> (parse-integer string :start start :junk-allowed t)
>> (push int list)
>> (setf start pos)))
>> (t
>> (push char list)
>> (incf start))))
>> (nreverse list)))
>> ==> (123 #\a 5 #\t 789 #\i 412 #\v)
>
> Using extended loop:
>
> (defun extract-chars-and-integers (string)
> (loop with limit = (1- (length string))
> for pos = 0 then next-pos
> while (<= pos limit)
> for pair = (or (multiple-value-bind (num end)
> (parse-integer string :start pos :junk-allowed t)
> (when num
> (cons num end)))
> (cons (char string pos) (1+ pos)))
> for (value . next-pos) = pair
> collect value))
>
> (defvar *test-string* "123a5t789i412v")
>
> (extract-chars-and-integers *test-string*)
> => (123 #\a 5 #\t 789 #\i 412 #\v)

If there are no "strings" to be parsed from the input then
parse-integer may be overkill.

For your endless (no pun) LOOP entertainment, here is a slightly obscure
version with NCONC, which assumes nconc is implemented with
tail-consing.

```
(defun parse-cloos (string &key (radix 10))
(loop with tail-cons for c across string for d = (digit-char-p c radix)
nconc
(etypecase (car tail-cons)
((or null character)
(setq tail-cons (cons (if d d c) nil)))
(number
(cond (d (setf (car tail-cons) (+ d (* (car tail-cons) radix)))
nil)
(t (setq tail-cons (cons c nil))))))))

(equal (parse-cloos "123a5t789i412v") '(123 #\a 5 #\t 789 #\i 412 #\v))
```