first post!

Hi there.

Now correct me if i'm wrong but your math is incorrect.

I'm referring to the 170 dittos required for 6 dittos, each one with a differing maxed IV.

the chance of finding a ditto with any given iv of 31 is, as you say, INITIALLY 17.3%. to have a 99% chance of finding that ditto though, with that percentage, you need to catch 25 dittos.

now then, because one stat is already cared for, there are only 5 remaining stats left to be caught, reducing the 17,3% to 14,6% and increasing number caught required to 30.

follow this up and you get.

4 stats, 12%, 36 dittos.

3 stats, 9%, 49 dittos.

2 stats, 6%, 75 dittos.

last stat, 3%, 152 dittos.

add it all up and you need around 367 dittos.

which is a bit of a drag if you ask me ;)

Hello there. Welcome to Smogon.

Okay, let's ask the question differently. How many dice rolls should be thrown so that, on average, all the numbers from 1 to 6 appear?

The first dice roll has a guarantee of producing a number from 1 to 6.

The second dice roll has a 5/6 chance of producing a number differing from the first one. That means that, on average, we'll need 6/5 dice rolls. (5 times out of 6, one dice roll is enough; 1/6 x 5/6, two dice rolls are enough; 1/6 x 1/6 x 5/6, three dice rolls are enough, etc. So we get 5/6 x 1 + 5/6 x 1/6 x 2 + 5/6 x (1/6)^2 x 3 + ... Adding these up to infinity gives us 6/5).

The third number requires 6/4 dice rolls on average to appear, working similarly. The fourth, fifth and sixth numbers require 6/3, 6/2 and 6/1 numbers to appear, on average. The answer, then, is 6/6 + 6/5 + 6/4 + 6/3 + 6/2 + 6/1 = 14.7 dice rolls.

Now this problem is very similar to ours. We need the average number of Ditto we need to catch to get one with 31 HP IV, one with 31 Atk IV, one with 31 Def IV, one with 31 SpAtk IV, one with 31 SpDef IV and one with 31 Spd IV. So there are six Dittos we want to catch, just like there are 6 numbers in the dice we want to roll. The only difference is that the probability of getting a Ditto with 31 IV in any stat is 1 - (31/32)^6 = 0.173, not 1. Adding the fact that we want the Ditto to have the same nature as our synchronizer (50%) means that the probability of getting a Ditto with 31 IV in any stat with the appropriate nature is 0.173 x 0.5 = 0.0865.

This means that getting the first Ditto requires 1/0.0865 caught Dittos on average (11.56). This contrasts with the one dice roll needed to produce the first number.

After catching another 11.56 Dittos on average, you'll get another good Ditto, but this time it could have the 31 IV in the same place as the first one. As we said before, in the dice analogy, this number must be multiplied by 6/5 to get the Ditto having a 31 IV in a different place as the first one.

Similarly for the third, fourth, fifth and sixth Dittos, we multiply the 11.56 by 6/4, 6/3, 6/2 and 6/1 respectively. Thus, the number of Dittos required is

(1 / (2 x (1 - (31/32)^6))) x (6/6 + 6/5 + 6/4 + 6/3 + 6/2 + 6/1) = 169.5 Ditto, which I rounded to 170 Dittos.

I didn't want to include this calculation in the guide, but, since you asked from where I got that number, here it is.

Also, so that I'm 100% sure of my calculations, I made a program that simulated Ditto catches and calculated how many catches are required to get all 6 Dittos 100,000 times, and found the average value. The answer was very near 170, thus confirming my working.

EDIT: Here is the code in Java:

Code:

```
public class Test {
public Test() {
int n=0,c=0,d=0;
long a=0;
boolean[] already = new boolean[6];
for (int j=0; j<100000; j++) {
for (int i=0; i<6; i++) already[i]=false;
while (d<6) {
int IV1 = (int) (Math.random()*32);
int IV2 = (int) (Math.random()*32);
int IV3 = (int) (Math.random()*32);
int IV4 = (int) (Math.random()*32);
int IV5 = (int) (Math.random()*32);
int IV6 = (int) (Math.random()*32);
int ab = (int) (Math.random()*2);
n=-1;
if (IV1==31 && ab==1) n=0;
if (IV2==31 && ab==1) n=1;
if (IV3==31 && ab==1) n=2;
if (IV4==31 && ab==1) n=3;
if (IV5==31 && ab==1) n=4;
if (IV6==31 && ab==1) n=5;
if (n>=0 && !already[n]) {
already[n]=true;
d++;
}
c++;
}
a += c;
c=d=0;
}
System.out.println((double) a/100000);
}
public static void main(String args[]) {
new Test();
}
}
```