> I am trying to process a sequence like:

> (0 1 2 3 0 1 2 3 0 1 2 3)

> and produce:

> ((0 1 2 3)(0 1 2 3)(0 1 2 3))

> i.e. create sub-sequences beginning whenever the value decreases.

> However, I am not having much luck (being pretty new to LISP). My
> attempt was to use a loop with two collect statements, collecting each
> number into one until its value decreases compared to the last one,
> which then gets collected into another, then reset. Something like
> this:

> (loop
>   for num in seq
>   when (and (not (null subseq)) (<= num (car (last subseq)))
>     collect subseq into answer and
>     do (setf subseq nil)
>   collect num into subseq
>   finally (return answer))

> But, subseq never seems to get reset, and it seems that there are
> references at work as the return value contains multiple copies of the
> original sequence.

> Would someone kindly be able to offer some advice or a nudge in the
> right direction?

> Best,
> Scott

> world.lisp.de> wrote:
> > (defun collect-sublists (list)
> >   (flet ((collect-sublist ()
> >            (loop for element = (pop list)
> >                  while element collect element
> >                  while (and list
> >                             (<= element (first list))))))
> >     (loop for sublist = (collect-sublist)
> >           while sublist collect sublist)))

> Thanks for the quick response! This does exactly what I need, although
> I will certainly have to look at it closely to see exactly how.

> Best,
> Scott

>>(defun collect-sublists (list)
>>  (flet ((collect-sublist ()
>>           (loop for element = (pop list)
>>                 while element collect element
>>                 while (and list
>>                            (<= element (first list))))))
>>    (loop for sublist = (collect-sublist)
>>          while sublist collect sublist)))

> Thanks for the quick response! This does exactly what I need, although
> I will certainly have to look at it closely to see exactly how.

>> (defun collect-sublists (list)
>>   (flet ((collect-sublist ()
>>            (loop for element = (pop list)
>>                  while element collect element
>>                  while (and list
>>                             (<= element (first list))))))
>>     (loop for sublist = (collect-sublist)
>>           while sublist collect sublist)))

> Nearly 15 minutes passed since you posted your solution, and William
> James still didn’t show his Ruby one-liner that outperforms the Lisp
> solution by a factor of 20 (speedwise). ;-)

> André

> > (defun collect-sublists (list)
> >  (flet ((collect-sublist ()
> >           (loop for element = (pop list)
> >                 while element collect element
> >                 while (and list
> >                            (<= element (first list))))))
> >    (loop for sublist = (collect-sublist)
> >          while sublist collect sublist)))

> Nearly 15 minutes passed since you posted your solution, and William
> James still didn’t show his Ruby one-liner that outperforms the Lisp
> solution by a factor of 20 (speedwise). ;-)

> André

> > > (defun collect-sublists (list)
> > >  (flet ((collect-sublist ()
> > >           (loop for element = (pop list)
> > >                 while element collect element
> > >                 while (and list
> > >                            (<= element (first list))))))
> > >    (loop for sublist = (collect-sublist)
> > >          while sublist collect sublist)))

> "We don't need no stinkin' loops!"

> Ruby:

> list = [0,1,2,3] * 3

> def collect_sublists list, prev=nil, accum=[[]]
>   return accum if not element = list.first
>   if prev and element < prev
>     accum << [element]
>   else
>     accum[-1] << element
>   end
>   collect_sublists( list[1..-1], element, accum )
> end

> > world.lisp.de> wrote:
> > > (defun collect-sublists (list)
> > >   (flet ((collect-sublist ()
> > >            (loop for element = (pop list)
> > >                  while element collect element
> > >                  while (and list
> > >                             (<= element (first list))))))
> > >     (loop for sublist = (collect-sublist)
> > >           while sublist collect sublist)))

> > Thanks for the quick response! This does exactly what I need,
> > although I will certainly have to look at it closely to see exactly
> > how.

> > Best,
> > Scott

> Here is a great function from "On Lisp"

> (defun group (source n)
>   (if (zerop n) (error "zero length"))
>   (labels ((rec (source acc)
>            (let ((rest (nthcdr n source)))
>              (if (consp rest)
>                  (rec rest (cons (subseq source 0 n) acc))
>                (nreverse (cons source acc))))))
>     (if source (rec source nil) nil)))

> > > > (defun collect-sublists (list)
> > > >  (flet ((collect-sublist ()
> > > >           (loop for element = (pop list)
> > > >                 while element collect element
> > > >                 while (and list
> > > >                            (<= element (first list))))))
> > > >    (loop for sublist = (collect-sublist)
> > > >          while sublist collect sublist)))

> > "We don't need no stinkin' loops!"

> > Ruby:

> > list = [0,1,2,3] * 3

> > def collect_sublists list, prev=nil, accum=[[]]
> >   return accum if not element = list.first
> >   if prev and element < prev
> >     accum << [element]
> >   else
> >     accum[-1] << element
> >   end
> >   collect_sublists( list[1..-1], element, accum )
> > end

>  3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1,
> 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0,
> 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3,
> 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
> >> p collect_sublists( list )
> SystemStackError: stack level too deep
>    from (irb):8:in `collect_sublists'
>    from (irb):8:in `collect_sublists'
>    from (irb):11
>    from :0

> Oops, you don't need loops?

> You need Lisp.

> ) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3
> 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3
> 4) (1 2 3 4) (1 2 3 4) (1 2 3 4) (1 2 3 4))

> CL-USER 3 >

> > I am trying to process a sequence like:

> > (0 1 2 3 0 1 2 3 0 1 2 3)

> > and produce:

> > ((0 1 2 3)(0 1 2 3)(0 1 2 3))

> > i.e. create sub-sequences beginning whenever the value decreases.

> > However, I am not having much luck (being pretty new to LISP). My
> > attempt was to use a loop with two collect statements, collecting
> > each number into one until its value decreases compared to the last
> > one, which then gets collected into another, then reset. Something
> > like this:

> > (loop
> >   for num in seq
> >   when (and (not (null subseq)) (<= num (car (last subseq)))
> >     collect subseq into answer and
> >     do (setf subseq nil)
> >   collect num into subseq
> >   finally (return answer))
...

> (defun collect-sublists (list)
>   (flet ((collect-sublist ()
>            (loop for element = (pop list)
>                  while element collect element
>                  while (and list
>                             (<= element (first list))))))
>     (loop for sublist = (collect-sublist)
>           while sublist collect sublist)))

> > On Dec 8, 1:08 am, Scott <jsam...@gmail.com> wrote:
> > > Hi All,

> > > I am trying to process a sequence like:

> > > (0 1 2 3 0 1 2 3 0 1 2 3)

> > > and produce:

> > > ((0 1 2 3)(0 1 2 3)(0 1 2 3))

> > > i.e. create sub-sequences beginning whenever the value decreases.

> > > However, I am not having much luck (being pretty new to LISP). My
> > > attempt was to use a loop with two collect statements, collecting
> > > each number into one until its value decreases compared to the last
> > > one, which then gets collected into another, then reset. Something
> > > like this:

> > > (loop
> > >   for num in seq
> > >   when (and (not (null subseq)) (<= num (car (last subseq)))
> > >     collect subseq into answer and
> > >     do (setf subseq nil)
> > >   collect num into subseq
> > >   finally (return answer))
> ...

> > (defun collect-sublists (list)
> >   (flet ((collect-sublist ()
> >            (loop for element = (pop list)
> >                  while element collect element
> >                  while (and list
> >                             (<= element (first list))))))
> >     (loop for sublist = (collect-sublist)
> >           while sublist collect sublist)))

> JavaScript (SpiderMonkey):

> function clump(a){
>   var c=[[a[0]]]
>   a.reduce(function(p,x){x<p ? c.push([x]) : c.slice(-1)[0].push(x)
>     return x})
>   return c }