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

Question

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

Answer 1

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!

Answer 2

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

Answer 3

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:

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