750 is the asymptotic limit for flag weight, but it is known that it can be reached thanks to rounding.

Suppose that a user has no invalid flags. How many flags does he need to reach the 750 limit?

Related questions : Flag weight 750 reached?

share|improve this question
The world may never know... –  Grace Note Jul 8 '11 at 15:12
will you provide more details? –  Yogesh Bhadauirya Jul 11 '11 at 10:43
Don't forget that flags aren't all created equal: "your flag weight increases by 10 points for flags on posts, and 5 points for flags on comments." –  Pops Jul 12 '11 at 15:03
Honestly, how have you missed all the comments that say flag weight doesn't matter? You've wasted more time trying to figure out the algorithm and create little graphs that you could actually be using to contribute something useful to the site or to yourself. I just can't understand why this is so important to you. Flagging is great, but the goal is to improve the site for everyone, not to raise a little number that no one even looks at. –  Cody Gray Jul 13 '11 at 13:10
@CodyGray You're a lot like this guy: meta.stackoverflow.com/questions/90882/… –  cbroughton Nov 13 '11 at 2:55
add comment

closed as too localized by Wesley Murch, yhw42, Al E., Toon Krijthe, jonsca Aug 24 '12 at 12:37

This question is unlikely to help any future visitors; it is only relevant to a small geographic area, a specific moment in time, or an extraordinarily narrow situation that is not generally applicable to the worldwide audience of the internet. For help making this question more broadly applicable, visit the help center.If this question can be reworded to fit the rules in the help center, please edit the question.

3 Answers

up vote 32 down vote accepted

I verified that the formula in Flag weight 750 reached? is correct (its prediction matches the flag value in my account exactly). I used the following Python snippet to calculate flag weight development after you reach flag weight 500:

x = 500
for i in range(1, 550):
  x += 10 ** (1 - (x - 500) * 0.008)
  print "%i. %f" % (i, x)

Some selected output lines:

 28. 600.201022
 80. 650.506963
209. 700.046145
253. 710.117574
305. 720.017317
368. 730.000972
444. 740.016107
536. 750.089601

So once you've reached flag weight 500 (which requires merely 40 valid flags) you will need at least another 536 flags to get to 750. Good luck!

share|improve this answer
I'm at 263 and only have a weight of 695 –  Simon Sheehan Nov 13 '11 at 22:43
@SimonSheehan: This would mean that some of your flags were declined - each declined flag carries a 10 point penalty on your flag weight which becomes very significant once you get over 500. –  Wladimir Palant Nov 14 '11 at 9:29
add comment

I was looking for a method to quickly calculate the flag weight, taking invalid flags into account. The result is shown below, together with this fiddle: http://jsfiddle.net/DHDuH/6/

TL;DR: Click at the fiddle for a dynamic flag weight calculator.

I have created two calculators:

Additional flags

  1. Specify the current flag weight (default 0).
  2. Enter the number of additional flags
  3. Optionally, enter a list of expected invalid flags
  4. Hit Calculate, and spectate your flag weight after correctly flagging __ additional times. During the calculation, when the flag weight has exceeded 750, the function will terminate earlier.

Desired flag weight

  1. Specify the current flag weight (default 0)
  2. Specify the desired flag weight
  3. Optionally, paste a list of invalid flags.
  4. Press Calculate. The result is required number of flags to reach a certain flag weight.

Extra: Code to count and calculate the number of flags + flag weight.

  1. First, paste snippet #1 in the developer console. Start at the last page of the flags, and execute the function at each page, backwards (e.g. page 9, 9, ...2, 1). After finishing these steps, localStorage.getItem("flagScript") will hold an array, holding the indexes of invalid flags. The first element counts the number of flags.

    localStorage.setItem("flagScript", JSON.stringify(getInvalid(JSON.parse(localStorage.getItem("flagScript"))||[0])));
    function getInvalid(current){if(!(current instanceof Array))current =[current];var flagged = document.getElementsByClassName("flag-outcome"),i=flagged.length-1,totalflags=0;for(;i>=0;i--){if(/Helpful/.test(flagged[i].className))totalflags++;if(/Declined/.test(flagged[i].className))current.push(current[0]+current.length-1+totalflags)}current[0]+=totalflags;return current}document.body.scrollIntoView(!1);localStorage.getItem("flagScript");
    /*End of #1 - localstorage.flagScript is modified*/
  2. Get the created array, and paste the contents at the form. The getScript's first element holds the count of the current number of calculated elements.

    var tmp=JSON.parse(localStorage.getItem("flagScript"));
    console.log("Counted flags " + tmp[0]);console.log(tmp.splice(1));
    /*End of #2 localStorage.flagScript is still existing*/
  3. Once you're finished, clear the temporary flagScript variable:


Bonus: JavaScript functions

Recursive formula to calculate the flag weight on-the-fly, after flagging n times, starting at flag weight 0.

function f(n) /* flag weight after flagging n times */
    {if(n<=500)return 10*n;var fn=f(n-1);return fn+Math.pow(10,1-(fn-500)*.008)}

Preparation #1

getInvalid([0]);function getInvalid(current){
    if(!(current instanceof Array)) current = [current];
    var flagged = document.getElementsByClassName("flag-outcome"),      
        i = flagged.length - 1,
        totalflags = 0;
    for(; i>=0; i--) {
        if(/Helpful/.test(flagged[i].className)) totalflags++;
        if(/Declined/.test(flagged[i].className)) {
            current.push(current[0] + current.length - 1 + totalflags);
    current[0] += totalflags;
    return current

Counting flag weight

The method to calculate flag weight is shown below. The function consists of two blocks. Below flag weight 510, a linear function is used. Once the flag weight (minus penalty for invalid flags) has reached 510, a different formula is used.
After reaching flag weight 750 or reaching the additional flagCount, the function terminates, and returns the number of flags and flagweight.

function countFlagWeight(flagweight, flagCount, invalid){
    flagweight = +flagweight || 0;
    if(!(invalid instanceof Array)) invalid = [];
    else invalid = invalid.splice(0).sort(function(x,y){return x-y});
    var flag = 1;
    for (; flag <= flagCount && flagweight < 510; flag++) {
        if (invalid.length && invalid[0] == flag) {
            flagweight -= 10;
            while (invalid.length && invalid[0] == flag) invalid.shift();
        } else {
            flagweight += 10;
    for(; flag <= flagCount && flagweight <= 750; flag++) {
        if (invalid.length && invalid[0] == flag) {
            flagweight -= 10;
            while (invalid.length && invalid[0] == flag) invalid.shift();
        } else {
            flagweight += Math.pow(10, 1 - (flagweight - 500) * 0.008)
    return [flag-1, flagweight];

Function flagsTillGoal(current, goal, invalid) looks similar to countFlagWeight(). For the exact function, have a look at the fiddle.

share|improve this answer
add comment

I took 13 days of using all my flags to get from 500 to 750. There might have been one or two invalid flags in that run. If you can find the formula for how many flags you get a day, you can work it out. I think it's fair to say that it's hundreds, but it's not thousands. (It's only 50 to get to 500.)

share|improve this answer
You probably had about 40 flags/day available between 500 and 750, so around 500 valid flags or so. Note that as you get close to 750, a single invalid flag can easily undo a day's worth of effort! –  McCannot Jul 8 '11 at 17:30
@camccann, Invalid flags are also seemingly capricious, I have at least two or three invalid flags, where the post in question was subsequently either migrated or deleted, as I asked –  Mike Pennington Jul 11 '11 at 12:53
add comment

Not the answer you're looking for? Browse other questions tagged .