> Hi Sharon,
Everyone says that...
I'm actually Dave, but I use my wife's email :)

> Many many thanks for your kind response. As you guessed I'm new to
> programming. The code works fine. Only it doesn't display messages
> asking for user input, for instance "Enter the valuation" message
> doesn't appear.
What sort of environment are you running this on?
Perhaps you could alter get_num to include STDOUT.flush (like your  
original)

def get_num msg
   print "#{msg} >"
   STDOUT.flush
   gets.to_i
end


Probably the most important thing I'd like to get across is that  
whenever you see yourself writing something like
a_margin = max_price_A - reservePrice
b_margin = max_price_B - reservePrice
c_margin = max_price_C - reservePrice
d_margin = max_price_D - reservePrice
e_margin = max_price_E - reservePrice

you're repeating yourself unnecessarily and making it difficult to  
change the programme (what if we had an extra investor? what if we had  
100?)
Ruby (unlike a number of other languages) makes it very simple to  
manage lists of things.

Here's your original code again, but all I've done is put all the  
a_margin (etc) bits into a list  and change the bidding section to use  
this list

Cheers,
Dave

# set up list (array) to hold our investor information
investors= []

# Change the number of bidders by changing this value
BIDDER_COUNT=5

#Get the valuation price i.e the Auctioneer's expected price of the  
property
puts"Enter the valuation: "
STDOUT.flush
valuation = gets.to_i

#Get the Reserve price i.e. the minimum acceptable price of the property
puts "Enter the reserve price: "
STDOUT.flush
reservePrice = gets.to_i

# get the max_price for each investor
for index in (1..BIDDER_COUNT)
   # we'll use a hash to keep all the information we need about this  
investor
   # much tidier than having sperate lists for bids, margins and  
max_prices
   this_investor= {:index => index}

   #Each agent knows the maximun amount it can afford to pay for the  
property
   puts "How much is invester #{index} willing to spend? "
   STDOUT.flush
   this_investor[:max_price]= gets.to_i

   # add the new investor to our list
   investors << this_investor
end

investors.each do |investor|
   #Calculate invester bid magins
   #i.e. difference btw an agent's max willing price and the reserve  
price
   investor[:margin] = investor[:max_price] - reservePrice

   #Initialize bids for the investers here. First bid is reserve price  
plus half of the margin.
   #The other half will be incrementally bidded at 50% per round of  
bidding
   investor[:bid] = reservePrice + investor[:margin]/2
end

=begin
Assumptions
1. Probability of two or more investers having the same max price is  
negligible
2. Investers do not know each other's willing prices
3. A margin can't be zero...to be explained later
=end

#Continue bidding as long as the highest bid is less or equal to  
valuation price.
#Trivially, the property will be sold to the agent that reaches or  
exceeds the valuation price

# keep going untill we have a winner.
# NOTE ** this will continue forever if none of the bidders has a  
max_price
# >= the valuation
# You'll need to add a check for this as well
# Hint: you'll reach a round where those_still_bidding will be empty
# (everyone has dropped out)

#initialize out winner as no one
winner= nil

while winner.nil? do
   # check who should bid first
   # we need to find the lowest bid that's not greater than that  
investors'
   # max_price

   # To do this, let's take out list of investors, and narrow it down  
to only
   # those still bidding (bid <= max_price)


   those_still_bidding= investors.select do |investor|
     # if the following evaluates as true, this investor will join our  
new list
     investor[:bid] <= investor[:max_price]
   end

   # Now, from those let's find the lowest bidder.
   # One way to do this is to sort the list by bid, then pick the  
first one
   # Step 1: sort them
   those_still_bidding.sort! do |investor_a, investor_b|
     investor_a[:bid] <=> investor_b[:bid]
   end
   # Step 2: get the first
   lowest_bidder= those_still_bidding.first

   puts "Investor #{lowest_bidder[:index]} is bidding  
#{lowest_bidder[:bid]}"

   # Two possibilities now:
   # 1: This bid wins, and the action ends
   # 2: This bid doesn't win, this investor raises their bid and we  
continue
   if lowest_bidder[:bid]>= valuation then
     # Only need to set winner here.
     # This will cause the while loop to stop (winner is no longer nil)
     # We'll display the winning details at the end
     winner= lowest_bidder
   else
     lowest_bidder[:bid]+= lowest_bidder[:margin] * 0.25
   end

end # whle

# The programme will only get to here once a winner has been declared

puts "\nThis property has been sold to Invester #{winner[:index]} for  
#{winner[:bid]}"