```On Jul 27, 2013, at 8:26 PM, JD JD <lists / ruby-forum.com> wrote:

> So, I have been working through this book, and have been doing ok up
> until ch. 10.
>=20
> I'm in the part of the chapter where it asks us to generate our own
> sorting method (once with recurssion and once without).
>=20
> They gave a shell example of code.  However, I'm completely lost.  =
This
> is what I came up with so far, however I really have no idea what to =
do
> at this point.  Could someone possibly point me in the right =
direction?
> Recurrsion also is very confusing.  I get the idea of it with
> factorials, but beyond that and it gets a little confusing.  Here is
> what I have so far, and I would appriciate any help:
> --------------------------------------
> puts "Enter some words"
> some_array=3D[]
>=20
> while true
>  some_array=3Dgets.chomp
>  if some_array=3D=3D""
>    break
>  end
>=20
>  sort some_array
> end
> #This is where I would print out after this puts the solution
> puts "Here is the sorted list"
>=20
> #Wrapper method suggested in the book
> def sort some_array
>  recursive_sort some_array, []
> end
>=20
> #Actual method used to make this happen, and also where I'm confused
> def recursive_sort unsorted_array, sorted_array
>        #Probably doing this wrong.  Basically, I want to
>        #either push the smallest word into sorted_array
>        #or go down the list and find the smallest, then add it and
>        start
wrong
>        #Could someone point me in the right direction with this?
>  if unsorted_array[0]>unsorted_array[1]
>    sorted_array.push unsorted_array[1]
>  else
>    recursive_sort
> end
>=20
> --=20
> Posted via http://www.ruby-forum.com/.
>=20

Confusion is certainly understandable at this point -- recursion can be =
a tricky subject to understand. While it is generally true that you can =
write algorithms in either a looping or recursive fashion, *how* to do =
so isn't necessarily clear. Also, some sort algorithms lend themselves =
quite well to one or the other, but not both.

I haven't read Learning to Program, so I'm not sure what Chris is =
including in this. Sort algorithms would be a natural I'd think. If he =
doesn't include the algorithms, WikiPedia does describe standard =
algorithms pretty well.=20

If you'd like something to look at to get you over the hump, so to =
speak, let me know.

If you've gotten the iterative (non-recursive) sorting method working, =
maybe show that.

```