First of all, a serious question:

Is there some special reason that Ruby has (here and there)
a successor function (succ) but never a predecessor function
(pred)?



======= WARNING: A feeble attempt at humor follows =========

And now, a complete waste of your time:

I hereby invent the MURKY award (Most Useless Ruby Kode Yet)
and bestow the first one on myself.

The following method "pred" will find the predecessor of a
string.

It works by generating every string possible and then checking
each one to see if the successor is the correct one.

I restrict the characters to ASCII 32..126; this is done (ha!)
for efficiency; in other words, so that a four-letter string
can be processed before my lunch hour is over.

On the average, the number of iterations is 0.5 * 95**N where
N is the length of the string.

    
    def pred str
      nest = "def genstr()\n"
      keeping = ""
      ends = ""
      for i in 0..str.length-1 do
        nest += "#{' '*i}  for index#{i} in 32..126 do\n"
        keeping += "#{' '*str.length}  temp << index#{i}\n"
        ends += "#{' '*(str.length-i-1)}  end\n"
      end
      keeping += "#{' '*str.length}  yield temp"
      keeping += "#{' '*(str.length-1)}\n"
    
      expr = nest + "#{' '*str.length}  temp=''\n" + 
             keeping + ends + "end\n\n"
      # print expr
      eval(expr)
      x = nil
      genstr {|x| break if x.succ == str}
      x
    end
    
    print pred "Ham"   # Prints "Hal"
    print "\n"
    
This is certainly in a category with the infamous Bumblesort sorting
algorithm, which picks two elements at random and exchanges them, then
checks to see if the list is sorted yet.

So the next time you write a piece of code that is bloated, sluggish, 
or simply in poor taste, don't throw it away! 

Just ask yourself: "Could this turkey earn a MURKY?"


Have a nice day,
Hal