[prev in list] [next in list] [prev in thread] [next in thread] 

List:       ruby-talk
Subject:    Re: Working through Ch.10 for learning to program 2.0 (Chris Pine)
From:       sto.mar () web ! de
Date:       2013-07-31 9:45:09
Message-ID: 51F8DC9F.3060601 () web ! de
[Download RAW message or body]

Am 31.07.2013 05:02, schrieb JD JD:
> So, I am just taking a detour away from the book for a bit and trying
> something else and will go back to it.  I glanced at the solution for
> one you all wrote out.  The book didn't really go over a lot of what you
> all are doing.

Please do not take these one-liners as examples on how you should
write your code. I consider them more as riddles or katas than
as good solutions for a beginning programmer (or maybe even for
an expert programmer). They are cryptic and not too easy to
understand, and good "real" code should be neither.

Considering your pseudo code (I do not know how your real code looks
like, but just to make sure): beware of using one letter variable
names! The additional time for typing is only spent once, but
cryptic code causes extra time spent every time you need to re-read
through it when searching for bugs, etc.

> Marcus, it sounds like you read the same book.  Could you maybe give me
> a hint based off what I should know from the book?  It looks like many
> people here are using things that weren't taught in the book.  Not
> saying they are wrong, but it not something I probably know from what I
> read in the book.  I might be wrong though.  I'm still learning either
> way.

Matthew gave very good advice. Think in small steps, write them down,
break them up even more. I would like to add that IMO the selection
sort algorithm I described earlier is even a bit simpler than
insertion sort (of course, it's partially a matter of taste).
The biggest subtask there is to find the smallest element of the
array and its index.

I'll give an example implementation below, you can ignore it for
the time being, or have a peak and then try on your own, whatever.
It uses only the most basic array operations (like accessing,
pushing or deleting elements).
There is another versions that uses Array#min (which could be
considered cheating, but it's an exercise and you make the rules).
It might help further in understanding how the algorithm works.

BTW. Don't be discouraged by chapter 10. Not without reason
Chris Pine calls it a "rite of passage". And: you know that
the appendix has suggestions for possible solutions, often
more than one?

Regards,
Marcus


Without Array#min (the biggest block is only for finding
of the smallest value):

  unsorted = [8, 4, 0, 9, 2, 6, 5, 9, 2, 7]
  sorted = []

  while unsorted.size > 0 do  # more rubyish: until unsorted.empty? do
    smallest = unsorted[0]
    index_of_smallest = 0

    1.upto(unsorted.size - 1) do |index| # more rubyish: each_with_index
      if unsorted[index] < smallest
        smallest = unsorted[index]
        index_of_smallest = index
      end
    end

    sorted << smallest
    unsorted.delete_at(index_of_smallest)
  end

  p sorted  # => [0, 2, 2, 4, 5, 6, 7, 8, 9, 9]


The same using Array#min:

  unsorted = [8, 4, 0, 9, 2, 6, 5, 9, 2, 7]
  sorted = []

  while unsorted.size > 0 do
    smallest = unsorted.min
    index_of_smallest = unsorted.index(smallest)

    sorted << smallest
    unsorted.delete_at(index_of_smallest)
  end

  p sorted


-- 
GitHub: https://github.com/stomar/
PGP:    0x6B3A101A

[prev in list] [next in list] [prev in thread] [next in thread]