Algorithm to perform weighted shuffle with gradual bubbling up of list items

Question

I'm wondering if anyone knows of a simple algorithm for performing a shuffle of a list that permits a weight bias so that each item in the list works its way toward the top of the list at the same time.

I am working on a site with business listings in paginated directories and the listings need to display fairly so one business cannot always be above/below another listing. A pure shuffle of the directories is not really sufficient as the random nature of this may result in any given business randomly shuffling to a similar location within the list for an extended period of time, so I'd like to provide some weighting so that each listing is slowly nudged up the list so that they get a reasonably equal opportunity to display on the first page of the directory over time.

EDIT:

With thanks from Kevin - I'm attempting to formalise these rules:

1) for n listings each listing must display in position one once in n "quasi shuffles")

2) (fuzzy) the average (?) position of a listing should increase over time until it reaches position 1

3) for any two businesses (A and B) over n iterations of the shuffle A must not be above B more than 50% of the time?

I should also add that I work for a business that has an extremely complex and convoluted "Shuffler" that is necessary to pacify a large number of paying clients who insist on being fairly distributed across their business's respective categories within our directories. Complaints from customer is a "real" problem, given that users typically pick items from the first couple of paginated pages it is not fair to order clients by alphabetical order (by default), and given that users read from top to bottom, it's not fair that one business is always above another.

I'm interested to know whether anyone has a tidy solution to this problem that they may have implemented previously.

EDIT:

One thought I've had, given these items are stored in the database, I could have a column which is the sum of each listings position over time, which I could use for ordering (descending), when an item reaches the first position in the list I could then set it to 0 which would mean that every item in the list would eventually make it to the top of the list. The problem is that for a large number of listings, over time, this number could become rather large...

EDIT:

I don't want to slam the database and I need consistency whilst a user is browsing therefore I will only be performing the "pseudo shuffle" on a nightly basis (once a day) not on every display of the directories

Answer 1

The simplest answer that comes to me is to use a Least-Recently-Used (LRU) approach.

Update a timestamp for each element that gets displayed in the top page and render all the elements sorted from "least recently used/displayed" first to "most recently used/displayed" last.

That should do the trick, and involves updating the timestamp of just the elements displayed in the top page.

As new elements are added, and old elements are removed from the list this should keep circulating items gracefully.

You could fine-tune this by allowing items to stick to the front page for a few iterations before being sent back to the bottom of the pile. This would depend on the number of items in your database, rate of addition of new elements, rate of removal of old elements.

I hope this helps, Laurent.

Answer 2

for a database that has X companies, create an X by X grid, and populate each cell with a company name. Any given company name should appear exactly once in each row and column. For example, for a database of ten companies, each with a one character name, one such grid would look like this:

ABCDEFGHIJ
BCDEFGHIJA
CDEFGHIJAB
DEFGHIJABC
EFGHIJABCD
FGHIJABCDE
GHIJABCDEF
HIJABCDEFG
IJABCDEFGH
JABCDEFGHI

The company in the xth row and yth column will appear x units from the top of the list on the yth day. In other words, each day you refer to a different row for the ordering of your company names. This scheme satisfies two of your criteria: that each element must be in the #1 slot at least once every X days, and that any particular element should not stagnate in the same position for a long time. But there is still the problem that company B always appears below company A, so some additional work is needed.

Choose two columns at random and swap them around. Repeat this process until the columns are sufficiently randomized (See Fisher-Yates Shuffle for a linear-time way to do this). One such result might look like this:

HIDEJBGCAF
IJEFACHDBG
JAFGBDIECH
ABGHCEJFDI
BCHIDFAGEJ
CDIJEGBHFA
DEJAFHCIGB
EFABGIDJHC
FGBCHJEAID
GHCDIAFBJE

Now, on average A will be in front of B 50% of the time. The actual percentage will vary, but it will fall on a bell curve centered around 50%, and only rarely will it reach a very uneven proportion.

Company B might complain that it always appears in the #1 slot exactly one day after company A appears at #1. If this is a problem, then perform a shuffle on rows too:

GCDHBIFEAJ
HDEICJGFBA
BHICGDAJFE
JFGAEBIHDC
IEFJDAHGCB
AGHBFCJIED
CIJDHEBAGF
EABFJGDCIH
FBCGAHEDJI
DJAEIFCBHG

Now you have an ordering scheme with the following properties:

Pros

• over the course of an X-day-long cycle, all X companies appear in the #1 slot.
• over the course of an X-day-long cycle, no company will ever stagnate in the same slot. Once it occupies slot K, it will not return to that slot for the rest of the cycle. (In the worst case, it still might "hover" around the same area for a while, but eventually it will go everywhere on the list)
• no one company will appear over another much more than 50% of the time. The more companies you have, the closer to 50% it approaches.
• which company will appear in the #1 slot is unpredictable, so no one can legitimately claim a bias based on when a company is spotlighted.

Cons

• for a database of N companies, generating a grid takes O(N^2) time and memory. You only need to generate one every N days, and you can do it ahead of time, so you can amortize the cost down to O(N) time.
• Companies do not "bubble up" over time. I believe this constraint conflicts with the "no company should appear above another too much" constraint; if all companies bubble upwards with approximately equal velocity, then the ones that started higher will usually be above the ones that started lower. The method I've given is the result of discarding one requirement in order to satisfy another mutually exclusive requirement.
• for any X-day-long time period, there is a 1/N chance that a company will appear in the #1 slot two days in a row. This occurs, for example, when company A is in the #1 slot on the last day of the cycle, and when you generate a new grid, company A is in the #1 slot on the first day of the cycle. If this is undesirable, you can perform another shuffle until A isn't in the first slot.