Weighting function for favorites

I've got a list of items. Users can occasionally select them. Now I want to order the items by their popularity. What's a good weighting function for that?

Constraints:

• The weight should be in [0,1)
• Recursive calculation is prefered (not required)
• 开发者_StackOverflow中文版Newer events must have more influence than old ones.
• I'd favor approved functions. As I've developped something like this once and it worked not as expected.

Now I want to order the items by their popularity.

So you order by the number of times some user selected the item.

The weight should be in [0,1).

Fine, divide by the total number of times some user selected some item plus one.

Recursive calculation is prefered

Why? Maybe I'm missing the point of what you're trying to do because otherwise this constraint is lost on me.

Edit:

Responding to your edit, try

sum ( 1 / age of vote ) / age of item

the sum being taken over all votes for a given item.

If you have a counter of votes per item, you can use a 'fading constant' in order to make older votes "fade away" with time. Something like:

Nvotes(i) = IsClicked(i) + Nvotes(i) * Kfade

where: 0 < Kfade < 1

Thus, whenever a new click is intercepted, all counters are advanced where only the selected item is incremented by 1.

EDIT: Since the total is less than 1, you may want to normalize Nvotes by the total number of clicks so far.

Keep a list items of the items that need sorting. Let each item have a score. Keep a list clicks of the N most recent clicks, in order of decreasing recency. Each item can appear more than once in the list. Choose a constant fade a little smaller than 1. Then do:

for item in items:
    item.score = 0.0
bonus = 1.0
for item in clicks:
    item.score += bonus
    bonus *= fade

Now sort the items by score, highest first.

The score isn't in the range 0 to 1, but i don't see why you actually need that. It would be straightforward to normalise the scores afterwards.

This isn't recursive, but it's straightforward to put in recursive form.

This isn't a known algorithm. I don't know of any known algorithms for this except move-to-front, which is almost certainly more aggressive than you want.