Dummy Scrolling

Dummy scrolling doesn't work. There is a static success rate to each scroll. It's literally in the server code. There is proof.

 

Well that is not what I though when I saw this thread. If you took that as an attack I'm sorry.

Talking about 10% is over complicating this. So if we instead look at 50%, from what your saying you think that 20 fails at a 50% chance is less likely than 19 fails and 1 success? Or do I have this wrong?

I thought the coin toss analogy and the Wikipedia article posted here summed up why this is not the case quite nicely.

 

It's a different case for 50%s because of the fact that both outcomes are equally likely - dummy scrolling 50%s would be a bit silly IMO.

The series of events in which 19 fail and 1 pass would be equally as likely as all 20 failing.

 

This is true.

This is not.

The chances of passing at least 1 10% in 20 scrolls are completely different than failing 19 scrolls in a row and passing the 20th.

 

scrolling is all luck based.
do whatever feels right.
just know that everytime you fail a white scroll, that could have been a dummy scroll instead.

 

And my probability didn't represent the sequence of 19 scrolls passing and the 20th working. It showed the probability of AT LEAST 1 10% working in a sequence of 20.

Doesn't seem like this thread is going anywhere though, so I'll rest my case there

 

Exactly I agree. Same thing with religion, believe in anything you want. At the end of the day, if something makes you feel good then continue to do it and be happy . The only thing I am against is the people who claim something as a way of life and attribute it to their success and others failures if they don't follow it with zero actual proof.

 

Dummy scrolling is my religion

 

I suggest you re-read carefully what I quoted from you in my last post.

Saying that using a white scroll after 19 scrolls failed is not a bad idea because the probability of at least 1 pass in 20 10% scrolls is higher than the probability of 20 straight failed 10%s is a bad argument. When you are at your 20th scroll almost all of the favorable outcomes that made that 87% did not happened and you are left with one last chance with a success rate of 10%, so saying that the probability that the favorable sequence occurs is higher than the probability that the unfavorable sequence occurs is false when you are so far down the sequence and many of the outcomes have been already ruled out.

 

If you're like me, you'd want to test the theory yourself before deciding which side to believe. I'd prefer not to analyze the statistics myself nor take the time to buy all the scrolls on the server and use them one by one for this debate so I played around with Eclipse! You'll probably go brain dead if you think too hard about this theory.. Back to the topic, scrolling relies on pseudo-random numbers so simulating the scrolling process is simple as long as you have the correct variables for the experiment. I wrote the (really ugly) code below to do the work for me. It should be accurate enough for testing purposes.

Code:

import java.security.SecureRandom;

class Test {
    public static void main(String[] args) {
        SecureRandom rn = new SecureRandom();
        int dummyScrollsUsed = 0;
        int successes = 0;
        int fails = 0;
        int attempts = 0;

        for (; attempts < 1000; ++attempts) {
            int failsInARow = 0;

            while (failsInARow < 20) {
                ++dummyScrollsUsed;
                if (rn.nextInt(2) == 0)
                    ++failsInARow;
                else
                    failsInARow = 0;
            }

            if (rn.nextInt(2) == 1)
                ++successes;
            else
                ++fails;
        }
        System.out.println("Dummy Scrolls Used: " + dummyScrollsUsed);
        System.out.println("Successes: " + successes);
        System.out.println("Failures: " + fails);
        System.out.println("Success Rate: " + (double) successes / attempts * 100 + "%");
    }
}

Description:
This program counts the number of dummy scrolls used. For each attempt at scrolling without a dummy scroll, the program consecutively fails a specified number of dummy scrolls. Once the 'pre-scrolling' is completed for that attempt it uses the actual scroll on the item. If it passes, the number of successes increases by one. Consequently, if the scroll fails, the number of failures increases by one. Once all the data has been collected, it calculates the percentage of the number of successes to attempts to determine the scroll's estimated success rate.

Variables:
# of attempts = 1000
Scroll Type = 50%
Consecutive Failures before Attempting = 20

Results:
Dummy Scrolls Used: 2070176216
Successes: 507
Failures: 493
Success Rate: 50.7%

Notes:
If you modify the number of required consecutive failures, the success rate does not show a notable change. However, if you increase the number of attempts made, the success rate approaches 50%. Decreasing the number of attempts made will result in the success rate being much more arbitrary. Therefore, it is safe to assume that the use of dummy scrolls does not affect your scrolling success rate no matter how it is used. If you're @Saleh, these rules don't apply to you.

PS: @Nicko, you should come up with a symbol for your religion. Also, I have no idea why I wrote this even though everyone knows this doesn't work. I guess I'm just bored..
S>Def/MP Scrolls! These things are so useless..

 

Hey Succubus, you beat me to it...
I did the same too, except with C# and my code was longer with console input/output

Like Succubus, my results show that dummy scrolling has zero effect on the outcome of actual scrolling.
Although, at smaller quantity of WS10, it is noticeable that luck plays a huge role in passing them.
Like many have said before, each scroll is an independent event and has it's own passing chance.

Spoiler

Link if you wanna see fullscreen: imgur.com/a/DRZsg

What is noticeable is that as the total number of scrolls used increases, the passing percentage eventually evens out to it's said passing rate, say 10%, (aka long-term statistics).

Spoiler: sourcecode

Code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace dummyscrolling
{
    public class Program
    {
        private static Random rnd = new Random();
        private static int rand = 0;

        public static void Main(string[] args)
        {
            int no_WS10 = 0;
            int scrollsPassed = 0;
            int failureInput = 0;
            int dummyUsed = 0;
            int repeatition = 0;

            Console.Write("1) Enter Number of WS and 10% scrolls you have: ");
            while(!int.TryParse(Console.ReadLine(), out no_WS10))
            {
                Console.Write("Error! Enter a valid number: ");
            }

            Console.Write("2) Enter the number of failures before using WS and 10%: ");
            while (!int.TryParse(Console.ReadLine(), out failureInput))
                Console.Write("Error! Enter a valid number: ");

            Console.Write("3) Enter number of repeats: ");
            while (!int.TryParse(Console.ReadLine(), out repeatition))
                Console.Write("Error! Enter a valid number: ");

            for(int r = 0; r < repeatition; r++)
            {
                Console.WriteLine("Repeatition {0}", r);
                dummyUsed = 0;
                scrollsPassed = 0;

                for (int i = 0; i < no_WS10; i++)
                {
                    if (ScrollSomething())
                        scrollsPassed++;
                }

                Console.WriteLine("Use of WS + 10% without dummy scrolls, pass rate = {0:P}.", scrollsPassed / (double)no_WS10);

                scrollsPassed = 0;

                int consecutiveFailures;
                int WS10_Left = no_WS10; //Assign another variable for ws10 so won't divide by zero when calculating pass rate

                do
                {
                    consecutiveFailures = 0;
                    while (consecutiveFailures < failureInput)
                    {
                        if (ScrollSomething()) //Scroll passes
                            consecutiveFailures = 0;
                        else
                            consecutiveFailures++;

                        dummyUsed++;
                    }

                    bool repeat = true;
                    do
                    {
                        if (ScrollSomething())
                        {
                            scrollsPassed++;
                            repeat = false;
                        }
                        WS10_Left--;
                    } while (repeat == true && WS10_Left > 0);
                } while (WS10_Left > 0);

                Console.WriteLine("Use of WS + 10% after {0} consecutive (dummy) failures, pass rate = {1:P}. Dummy Scrolls used = {2}.", failureInput, (scrollsPassed / (double)no_WS10), dummyUsed);
            }

            Console.ReadKey();
        }

        public static bool ScrollSomething()
        {
            rand = rnd.Next(0, 100);
            if (rand < 10)
                return true;
            return false;
        }

    }

}

This took me over an hour plus xD (why did I even do it)

 

Thank you very much guys for the effort you went through it is much appreciated. I am glad more people then just me are interested in this topic.

 

i buy thousands of zimbabwean lottery tickets because it will help me win the us lottery

hf with ur day jobs idiots

 

I don't know how other people dummy scroll but that's not how I do it, @Succubus and @Riv. It's not as simple as failing a bunch of scrolls then scrolling when you feel like you've failed enough.

As inconceivable as it sounds, it's more in the direction of trying to predict the RNG.

Now how do you predict something random? It's computer-generated; it's not completely random. (this is the biggest hint I can give without giving away the secrets of my trade ). As @Riv said, the more you scroll, the closer it actually gets to the desired mean, so as a computer-generated outcome, it actually regresses towards the mean.

 

You're right, it's not completely random. I've read before from somewhere that Pseudo RNG (which most programming languages provides) is not entirely random and there are some "patterns" to it compared to True RNG (it was too high-level for me to understand). But I've no idea how you could predict the RNG ._. (can you share with me? LOL >_>)

Correct me if I understood the last sentence of your reply wrongly, what you meant was that after scrolling strictly 10% for 50 times and only 1 passed (2% passing rate), if one was to continue to scroll another 50 WS + 10%, by regression towards the mean, one should pass 9 scrolls out of these 50WS10 (18% passing rate). While I find there's a certain reason to it, the small program I've written proved me otherwise. There is no real trend that it increases your passing rate. It is possible to fail the 50 WS + 10% altogether (0% passing rate).

Think of scrolling using strictly 10% as Event A, while using strictly 10% and white scrolls as Event B. If one was to keep a long record of his/her scrolling sessions, Event A will eventually regress towards the 10% passing rate. Similarly, Event B will also regress towards the 10% passing rate. This means that somewhere down the long road, if one plays this server long enough, or rather, scroll enough WS + 10%, one is going to fail enough WS + 10% to turn his total passing rate for Event B into 10%.

But we're humans and we have an instinctive nature. Sometimes, our instincts may tell us correctly that this is the right moment to do something and we will end up doing it and, profiting from it. I'm inclined to think this phenomenon is why people believe dummy scrolling works. Also, this "regression towards the mean" only takes place after a very large number of tries. So it's not all too bad I guess.

TLR: if one was to perform 2 activities, throw a six-faced dice and blindly pick a ball out of a basket of 6. After enough attempts, all possible events from both activities will occur the same number of times.

 

I meant this, but at the same time I didn't. This regression over the mean doesn't happen too closely over such a small number (yes, 100 is small)

This is true, which is why I find dummying to be a pain. I can tell you that there have been many times when I have used over 200/300+ scrolls for a single slot, reaching almost 500.

I'd say human-based random events are different

 

This.

 

Well, if dummying doesn't work, you can't really blame it if you end up failing lots, no?

 

Have u ever even scrolled anything bro ?

 

I don't know what that's supposed to mean but as @ImCanadian said, you don't have to take anyone's word. You can just view the source code and see how it works and the formulas for yourself.