Question

I need to find the next available ID (or key) from a fixed list of possible IDs. In this case valid IDs are from 1 to 9999, inclusive. When finding the next available ID we start looking just after the last assigned ID, wrap around at the end – only once, of course – and need to check if each ID is taken before we return it as an available ID.

I have some code that does this but I think it is neither elegant nor efficient and am interested in a simpler way to accomplish the same thing. I’m using Ruby but my question is not specific to the language, so if you’d like to write an answer using any other language I will be just as appreciative of your input!

I have elided some details about checking if an ID is available and such, so just take it as a given that the functions incr_last_id, id_taken?(id), and set_last_id(id) exist. (incr_last_id will add 1 to the last assigned ID in a data store (Redis) and return the result. id_taken?(id) returns a boolean indicating if the ID is available or not. set_last_id(id) updates the data store with the new last ID.)

MaxId = 9999

def next_id
  id = incr_last_id

  # if this ID is taken or out of range, find the next available id
  if id > MaxId || id_taken?(id)
    id += 1 while id < MaxId && id_taken?(id)

    # wrap around if we've exhausted the ID space
    if id > MaxId
      id = 1
      id += 1 while id < MaxId && id_taken?(id)
    end

    raise NoAvailableIdsError if id > MaxId || id_taken?(id)

    set_last_id(id)
  end

  id
end

I’m not really interested in solutions that require me to build up a list of all possible IDs and then get the set or list difference between the assigned IDs and the available IDs. That doesn’t scale. I realize that this is a linear operation no matter how you slice it and that part is fine, I just think the code can be simplified or improved. I don’t like the repetition caused by having to wrap around but perhaps there’s no way around that.

Is there a better way? Please show me!

Answer 1

Since you’ve already searched from incr_last_id to MaxId in the first iteration, there isn’t really a need to repeat it again.

Searching from 1 to incr_last_id on the second round at least reduces the search to exactly O(n) instead of a worse case of O(2n)

If you want to do it in a single loop, use modulo,

MaxId = 9999
def next_id
  id = incr_last_id
  limit = id - 1 #This sets the modulo test to the id just before your start point
  id += 1 while (id_taken?(id) && (i % MaxId) != limit)
  raise NoAvailableIdsError if id_taken?(id)
  set_last_id(id)
  id
end