How many flags to reach 750 flag-weight? [closed]

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 : https://meta.stackexchange.com/questions/84300/flag-weight-750-reached

• The world may never know...
– Grace Note StaffMod
Jul 8, 2011 at 15:12
• will you provide more details? Jul 11, 2011 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, 2011 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. Jul 13, 2011 at 13:10
• @CodyGray You're a lot like this guy: meta.stackexchange.com/questions/90882/… Nov 13, 2011 at 2:55

I verified that the formula in https://meta.stackexchange.com/questions/84300/flag-weight-750-reached/84569#84569 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!

• I'm at 263 and only have a weight of 695 Nov 13, 2011 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. Nov 14, 2011 at 9:29

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.)

• 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! Jul 8, 2011 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 Jul 11, 2011 at 12:53

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:

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:

``````localStorage.removeItem("flagScript");
``````

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(/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.