powerball program

Pages: 12

Write your question here.

#include <iostream>
#include <vector>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <string>

using namespace std;

int main()
{
	srand(time(NULL));
	
	ifstream infile("lotterydatabase.txt");
	vector<string> lotto;
	vector<string> newlotto;
	string line;
	
	if(!infile)
	{
		exit(EXIT_FAILURE);
	}
		
	while(infile.good())
	{
		getline(infile, line);
		lotto.push_back(line);
	}
	
	string storeline;
	string proxyline = "";
	char kind;
	vector<int> number;
	int beg;
	int convertletter;
	int limitcounter;
	vector<int> v;
	int counter = 1;
	int temp;
	vector<int> base;
	int pickindex;
	int randpair;
	int randset;
	int setbound;
	vector<int> endbound;
	vector<int> startbound;
	int esetup;
	int ssetup;
	int paircounter;
	int oddcounter, evencounter;
	ofstream outfile;
	outfile.open("Combo.txt"/*, ios::app*/);
	int linenumber = 1;
do{
	while(counter <= 1000000)
	{
		base.clear();
		v.clear();
		setbound = 6;
		startbound.clear();
		endbound.clear();
		esetup = 10;
		oddcounter = beg = evencounter = ssetup = paircounter = limitcounter = 0;
		for(int i = 0;i < 6;i++)
		{
			if(i == 5)
			{
				esetup -= 1;
				startbound.push_back(ssetup); //setup startbound
				endbound.push_back(esetup); //setup endbound
			}
			else
			{
				startbound.push_back(ssetup);
				endbound.push_back(esetup);
				if(i == 0)
				{
					esetup += 2;
				}
				if(i == 0)
				{
					ssetup += 10;
				}
				else
				{
					ssetup += 12;
				}
			}
		}
		randpair = rand() % 3;
		for(int i = 1;i < 70; i++)
		{
			base.push_back(i); // 1-69 reloading vector
		}
		
		randset = rand() % setbound;
		while(v.size() != 5)
		{
			if(randpair == 0)                            //generate 5 numbers depending on how many pairs
			{
				randset = rand() % setbound;
				pickindex = startbound[randset] + rand() % endbound[randset];
				v.push_back(base[pickindex]);
				startbound.erase(startbound.begin() + randset);
				endbound.erase(endbound.begin() + randset);
				setbound--;
			}
			else if(randpair == 1)
			{
				while(paircounter <= 2)
				{
					if(paircounter == 2)
					{
						startbound.erase(startbound.begin() + randset);
						endbound.erase(endbound.begin() + randset);
						setbound--;
						if(v.size() == 2)
						{
							randpair = 0;
							paircounter = 45234523;
						}
					}
					else
					{
						randset = rand() % setbound;
						while(paircounter < 2)
						{
							pickindex = startbound[randset] + rand() % endbound[randset];
							v.push_back(base[pickindex]);
							base.erase(base.begin() + pickindex);
							paircounter++;
							for(int i = 0;i < endbound.size();i++)
							{
								endbound[i] -= 1;
							}
						}
					}
				}
			}
			else
			{
				while(paircounter <= 2)
				{
					if(paircounter == 2)
					{
						startbound.erase(startbound.begin() + randset);
						endbound.erase(endbound.begin() + randset);
						setbound--;
						paircounter = 0;
						if(v.size() == 4)
						{
							randpair = 0;
							paircounter = 45234523;
						}
					}
					else
					{
						randset = rand() % setbound;
						while(paircounter < 2)
						{
							pickindex = startbound[randset] + rand() % endbound[randset];
							v.push_back(base[pickindex]);
							base.erase(base.begin() + pickindex);
							paircounter++;
							for(int i = 0;i < endbound.size();i++)
							{
								endbound[i] -= 1;
							}
						}
					}
				}
			}
		}
		
		for(int i = 0; i < v.size();i++)
		{
			if(v[i] % 2 == 0)
			{
				evencounter++;
			}
			if(v[i] % 2 != 0)
			{
				oddcounter++;
			}
		}
		if(evencounter == 1 || evencounter > 3 || oddcounter == 1 || oddcounter > 3 || v[0] > 22)
		{
			v.clear();
			counter--;
		}
		
		for(int i = 0; i < v.size();i++)
		{
			for(int j = i+1; j < v.size();j++)
			{
				if(v[i] > v[j])
				{
					temp = v[i];
					v[i] = v[j];
					v[j] = temp; //ascend loop
				}
			}
		}
		
		for(int i = 0;i < lotto.size();i++)
		{
			storeline = lotto[i];
			for(int j = 0;j < storeline.length();j++)
			{
				kind = storeline[j];
				if(kind == '_')
				{
					while(beg < j)//convert loop
					{
						proxyline += storeline[beg];
						beg++;
					}
					convertletter = atoi(proxyline.c_str());
					number.push_back(convertletter);
					proxyline.clear();
				}
			}
			for(int g = 0; g < number.size();g++)
			{
				if(v[g] == number[g])
				{
					limitcounter++;//check loop
				}
				if(limitcounter >= 3)
				{
					v.clear();
					counter--;
				}
			}
			number.clear();
			beg = 0;
		}
		cout << linenumber;
		for(int i = 0; i < v.size();i++)
		{
			outfile << v[i] << " ";
		}
		if(v.empty())
		{
		}
		else
		{
			outfile << endl;
		}
		counter++;
		linenumber++;
	}
	
	ifstream infile2("Combo.txt");
	string newline1,newline2;
	while(infile2.good())
	{
		getline(infile2, line);
		newlotto.push_back(line);
	}
	cout << newlotto.size() << endl;
	
	for(int i = 0;i < newlotto.size();i++)
	{
		for(int j = i + 1;j < newlotto.size();j++)
		{
			newline1 = newlotto[i];
			newline2 = newlotto[j];
			if(newline1 == newline2)
			{
				newlotto.erase(newlotto.begin() + j);
				counter--;
			}
		}
	}
	
}while(counter <= 1000000);
	return 0;
}

Last edited on

tpb (1495)

Wikipedia says:

Since October 7, 2015, the game has used a 5/69 (white balls) + 1/26 (Powerballs) matrix from which winning numbers are chosen, resulting in odds of 1 in 292,201,338 of winning a jackpot per play.

I don't understand how they get 292,201,338 since your calculation of 69!/64!*26 = 35,064,160,560 seems correct. The wikipedia value is exactly 120 times smaller

Anyway, why are you trying to produce all combinations?

EDIT: I figured it out. You need to divide by 5! = 120 in order to remove the permutations since the order of the "white" balls doesn't matter. So the number of possibilities is 292,201,338.

Last edited on

seungyeon (129)

So I can win the powerball.

I have a special arithmetic to winning.
I can use C++ to help me build a program. I am going to put all the randomly generated combinations and stored onto a file obviously it will check if there are any duplicates.

I also need another program to read the code and find the combination and remove it from the file every drawings.

Now all of you know my intentions
You guys are much better than me in c++ you can make a program in 2 hours max. It took me 2 hours too but I am only a beginner.

seungyeon (129)

Can you explain why I am doing
(69*68*67*66*65*26)/120?

I forgot the combination formula I learned in high school.

Like
a 4 digit lock
Each spot goes from 0-9
9 * 9 * 9 * 9 / 24?

helios (17506)

Why would you remove a combination when it's drawn?
Suppose there's a lottery that draws a single 0-9 ball every Friday. Is there anything preventing the same ball being drawn two Fridays in a row?

Likewise, is there anything preventing the exact same powerball sequence being drawn twice in a row?

tpb (1495)

The 4-digit lock from 0-9 (which is 10 possibilities in each position, not 9) is totally different. It would have 10000 possible combinations. It is different in two ways. Firstly, numbers can repeat, e.g., the combo could be 5555. Secondly, the order matters, e.g., 1234 and 4321 are different.

But in powerball, just considering the white balls, 1 2 3 4 5 and 5 4 3 2 1 are exactly the same. There are 5! = 120 ways to permute 5 numbers. Therefore you need to divide by 120 to discount them.

BTW, there is, of course, no way to "win" the powerball. If a particular sequence has come up before, it is just as likely as any other sequence to come up again, i.e., any given sequence is very unlikely.

You could print all possible powerball drawings like this, but it will produce well over 5 gigabytes of output. You can test it with smaller values for WhiteMax and PowMax. 8 and 2 are nice small values.

#include <iostream>

const int WhiteMax = 69;
const int PowMax   = 26;

void print(int a, int b, int c, int d, int e, int p) {
  std::cout << a << ' ' << b << ' ' << c << ' '
            << d << ' ' << e << ' ' << p << '\n';
}

int main() {
  for (int a = 1; a <= WhiteMax-4; a++)
    for (int b = a + 1; b <= WhiteMax-3; b++)
      for (int c = b + 1; c <= WhiteMax-2; c++)
        for (int d = c + 1; d <= WhiteMax-1; d++)
          for (int e = d + 1; e <= WhiteMax; e++)
            for (int p = 1; p <= PowMax; p++)
              print(a,b,c,d,e,p);
}

Last edited on

icy1 (596)

yep, reasonable way to list the combinations. The math word you're looking for is "choose". Often people express the idea as grabbing balls from a bag in succession without putting them back. And, yeah, the final order is not considered, like drawing a hand from a deck of cards.

n choose k --> n!/k!/(n-k)!

https://en.wikipedia.org/wiki/Combination
https://en.wikipedia.org/wiki/Binomial_coefficient

(69 choose 5) * 26

icy1 (596)

Pascal's triangle showing some combinations. For efficiency purposes, one may want to cache already-calculated factorial values.

#include <iostream>

using namespace std;

template<typename T>
T Fact(const T n)
{
    if (n<2) { return 1; }
    
    T prod = 1;
    for (T x=2; x<=n; ++x)
        prod *= x;
    return prod;
}

template<typename T>
T ChooseInefficient(const T n, const T k)
{
    return Fact(n)/Fact(k)/Fact(n-k);
}

template<typename T>
T Choose(const T n, const T k)
{
    if (k<0 || k>n)   { return 0; }
    if (k==0 || k==n) { return 1; }

    T c { 1 };
    T kk { min(k, n-k) };
    for (T i {0}; i<kk; ++i)
        c = c * (n-i) / (i+1);
    return c;
}

int main() 
{
    // Pascal's triangle
    for (int n=0; n<=10; ++n)
    {
        for (int k=0; k<=n; ++k)
            cout << Choose(n,k) << ' ';
        cout << '\n';
    }

    return 0;
}

1 
1 1 
1 2 1 
1 3 3 1 
1 4 6 4 1 
1 5 10 10 5 1 
1 6 15 20 15 6 1 
1 7 21 35 35 21 7 1 
1 8 28 56 70 56 28 8 1 
1 9 36 84 126 126 84 36 9 1 
1 10 45 120 210 252 210 120 45 10 1

Edit: after some more reading, I found they have a more efficient way than calling the factorial function three times. I left the old one in there to showcase the concept.

Last edited on

tpb (1495)

Even with 64-bits you can only go up to 20!, so you may as well just make an array.

#include <iostream>
#include <iomanip>

int fact[] = {
    1, 1, 2, 6, 24, 120, 720, 5040, 40320,
    362880, 3628800, 39916800, 479001600,
/* 64-bit factorials
             6227020800
            87178291200
          1307674368000
         20922789888000
        355687428096000
       6402373705728000
     121645100408832000
    2432902008176640000 */
};

int Choose(int n, int k) {
    return fact[n] / fact[k] / fact[n - k];
}

int main()  {
    const int size = 12;
    for (int n = 0; n <= size; ++n) {
        for (int i = 0; i < size - n; i++)
            std::cout << "  ";
        for (int k = 0; k <= n; ++k)
            std::cout << std::setw(3) << Choose(n, k) << ' ';
        std::cout << '\n';
    }
}

                          1 
                        1   1 
                      1   2   1 
                    1   3   3   1 
                  1   4   6   4   1 
                1   5  10  10   5   1 
              1   6  15  20  15   6   1 
            1   7  21  35  35  21   7   1 
          1   8  28  56  70  56  28   8   1 
        1   9  36  84 126 126  84  36   9   1 
      1  10  45 120 210 252 210 120  45  10   1 
    1  11  55 165 330 462 462 330 165  55  11   1 
  1  12  66 220 495 792 924 792 495 220  66  12   1

icy1 (596)

Yeah, see the edit (10min before your last), which protects against the overflows while utilizing the symmetry of the combinations.

Although... damn... Choose(69,34), with various ULL specifiers, still comes out wrong

Last edited on

tpb (1495)

I was mostly just showing the output shaped like a triangle. :-)

You can approximate 69C34 using double. The highest 64-bit unsigned int is about 18.5 billion billion. 69C34 is about 56 billion billion. So it's definitely out of range, but not massively so.

EDIT:
Here's the exact answer using the following bc function based on yours:

56,093,138,908,331,422,716

define choose(n, k) {
    auto c
    c = 1
    if (k < 0 || k > n) return 0
    if (k > n - k) k = n - k
    for (i = 0; i < k; ++i)
        c = c * (n - i) / (i + 1)
    return c
}

Last edited on

lastchance (6980)

69C34 = 56093138908331422716

#include <iostream>
#include <vector>
using namespace std;

class BigInt
{
public:
   vector<short> digits;               // note: digits stored in REVERSE order;

   BigInt( long long n = 0 );          // construct from integer
};

//------------------

BigInt::BigInt( long long n )          // Construct from integer
{
   digits.clear();
   if ( n == 0 )
   {
      digits.push_back( 0 );
   }
   else
   {
      while ( n > 0 )
      {
         digits.push_back( n % 10 );
         n /= 10;
      }
   }
}

//------------------

BigInt operator + ( const BigInt &a, const BigInt &b )
{
   BigInt result = a;
   int bsize = b.digits.size();

   int i = 0;
   int carry = 0;
   while ( i < bsize || carry > 0 )
   {
      if ( i < result.digits.size() ) carry += result.digits[i];
      if ( i < b.digits.size()      ) carry += b.digits[i];
      int digit = carry % 10;
      carry /= 10;
      if ( i < result.digits.size() ) result.digits[i] = digit;
      else                            result.digits.push_back( digit );
      i++;
   }
   return result;
}

//------------------

ostream &operator << ( ostream &strm, const BigInt &a )
{
   for ( int i = a.digits.size() - 1; i >= 0; i-- ) strm << a.digits[i];
   return strm;
}

//------------------

int main()
{
   int nval = 69;
   int rval = 34;
   vector<BigInt> nCr, nCrOld;
   nCr.push_back( 1 );
   for ( int n = 1; n <= nval; n++ )
   {
      nCrOld = nCr;
      nCr.resize(n+1);
      nCr[0] = nCr[n] = 1;
      for ( int r = 1; r < n; r++ ) nCr[r] = nCrOld[r-1] + nCrOld[r];
   }

   for ( rval = 0; rval <= nval; rval++ ) cout << nval << "C" << rval << " = " << nCr[rval] << '\n';
}

//------------------

Last edited on

seungyeon (129)

To helios:
Removing a combination when drawn is part of my arithmetic.
If you see the whole powerball drawings. Not a single exactly the same combination has came out.
So that will conclude to say that if a combination came out we can hope that it doesn't come out again.

mbozzi (3909)

If you see the whole powerball drawings. Not a single exactly the same combination has came out.

After drawing only 20127 times, the chances of having drawn at least one duplicate reaches 50%.
After drawing only 51878 times, the chances of having drawn at least one duplicate reaches 99%.

How many powerball drawings have there been? A few thousand at most?

tpb (1495)

In a sense, you're proving his point. :-) It's unlikely that a repeat will occur (maybe about 1 to 1.5 percent). But of course any list of about 2500 random combos is just as unlikely to get a hit.

Since this is essentially the birthday problem, an (approximate) calculation to determine the number of previous drawings needed for the next drawing to have a 50 percent chance of matching a previous drawing is:
sqrt(-2*292201338*ln(1-.50)) = 20127
And just like the birthday problem, it's surprisingly low.
https://en.wikipedia.org/wiki/Birthday_problem

Another fly in the OP's ointment is that apparently the format has changed a few times:

     whites  reds
1992   54     42
2009   59     39
2012   59     35
2015   69     26

https://en.wikipedia.org/wiki/Powerball#History

Anyway, the OP is obviously a believer in the gambler's fallacy.
https://en.wikipedia.org/wiki/Gambler%27s_fallacy

Last edited on

helios (17506)

This is so dumb. Even assuming that the same sequence can't be drawn twice (which is false) your chances of winning are one in 56 quintillion, minus a few thousand. Whoop-de-doo, those few thousand make a world of difference. If there was a drawing per second (there isn't), it would take 65 times the current age of the universe to reach 50% chance of winning.

Last edited on

seungyeon (129)

helios there is 292 million combinations

over 15 years of the powerball
the same combinations appeared 1-4 times

the powerball system has changed sooooo
I just test starting from 2016 til now

seungyeon (129)

lotterydatabase.txt

2 12 17 20 65
7 16 25 50 53
4 26 32 55 63
14 22 37 45 66
17 40 41 46 69
37 47 50 52 57
16 29 53 58 69
2 6 47 66 67
14 18 19 32 64
13 27 33 47 68
7 10 16 46 56
2 14 19 30 62
9 10 32 42 55
28 30 41 59 68
16 38 55 63 67
27 40 44 59 65
12 36 38 54 61
5 6 15 29 42
2 11 47 62 63
16 19 32 34 57
4 8 19 27 34
3 51 52 61 64
5 39 44 47 69
22 32 34 40 69
3 12 40 52 67
5 12 16 31 43
26 28 31 60 67
4 13 31 36 52
2 3 40 50 62
7 15 18 19 36
7 17 27 29 40
11 12 15 16 54
21 31 64 65 67
10 11 21 22 53
12 13 44 52 62
3 27 34 59 69
14 23 32 34 68
11 28 50 57 62
10 12 13 46 50
5 8 15 22 49
11 23 42 52 68
24 44 53 55 63
9 28 30 40 61
4 28 49 60 65
14 22 23 41 61
30 33 35 38 64
3 18 25 32 51
12 25 30 52 62
19 35 46 59 62
2 25 33 39 64
3 12 16 32 34
30 47 57 66 69
5 25 26 44 66
20 32 52 66 69
13 27 47 64 65
23 25 39 54 67
5 7 9 23 32
11 24 41 59 64
6 33 34 58 59
23 30 33 40 69
16 20 22 43 64
12 25 37 60 69
20 27 36 41 58
4 22 24 31 33
2 23 41 53 63
14 40 42 43 52
3 27 36 56 69
23 29 37 60 64
10 34 39 59 63
2 24 31 57 66
10 28 32 61 64
3 15 29 54 57
11 17 40 50 62
6 25 35 58 66
5 7 23 35 39
10 47 50 65 68
11 17 21 23 32
9 11 27 66 67
20 33 36 47 52
23 56 61 64 67
38 44 60 64 69
33 44 49 50 52 
3 6 21 60 68
9 11 12 64 65
4 32 48 49 63
5 10 24 56 61
7 39 50 59 67
22 23 29 33 55
3 17 49 55 68
10 11 23 28 31
9 19 51 55 62
1 28 63 67 69
7 15 20 29 41
30 38 52 53 62
2 12 50 61 64
8 18 27 29 60
3 54 61 64 68
16 30 34 37 44
23 49 57 64 67
10 16 38 43 63
1 28 33 55 56
2 3 16 48 56
19 20 21 42 48
13 18 37 54 61
21 31 50 51 69
1 25 28 31 54
8 17 20 27 52
28 41 61 63 65
16 24 28 43 61
7 32 41 47 61
17 19 21 37 44
3 14 18 25 45
8 10 26 27 33
41 48 49 53 64
12 21 32 44 66
18 26 37 39 66
1 8 16 40 48
25 33 40 54 68
28 38 42 51 52
16 23 30 44 58
1 3 28 57 67
16 17 29 41 42
3 12 24 37 63
1 3 13 16 43
23 55 59 64 69
9 40 41 52 58
23 25 45 52 67
18 28 62 66 68
12 20 39 49 69
9 43 57 60 64
6 13 16 17 52
14 20 42 49 66
5 9 17 37 64
5 28 33 38 42
3 7 9 31 33
10 13 28 52 61
6 32 47 62 65
10 16 40 52 55
2 18 19 26 63
23 33 42 46 59
1 26 41 50 57
16 30 41 48 53
13 25 44 54 67
2 9 27 29 42
18 31 32 45 48
8 15 31 36 62
9 32 36 44 65
8 20 46 53 54
23 36 51 53 60
8 14 61 63 68
5 22 26 45 61
1 19 37 40 52
21 39 41 48 63
1 5 18 26 51
22 23 24 45 62
17 18 49 59 66
11 21 31 41 59
29 31 46 56 62
17 20 32 63 68
4 11 39 45 48
5 22 45 47 54
28 32 33 38 62
5 10 28 55 67
4 33 39 46 60
3 9 21 41 54
5 21 59 66 69
20 26 32 38 58
5 22 43 57 63
10 13 32 53 62
14 46 61 65 68
10 22 32 36 58
29 37 46 53 68
19 42 45 48 53
4 9 16 54 68
8 10 29 40 59
1 2 18 23 61
9 40 63 64 66
50 51 59 61 63
5 32 44 53 65
7 19 21 42 69
1 28 40 45 48
1 16 54 63 69
11 21 28 33 60
12 30 16 47 62
20 24 26 35 49
9 15 43 60 64
17 19 39 43 68
6 7 16 23 26
7 15 32 38 66
19 28 43 67 69
17 24 35 57 63
17 18 24 25 31
39 48 53 67 68
24 45 55 56 57
8 10 21 23 25
8 12 25 41 64
22 23 62 63 66
10 49 61 63 65
1 3 13 19 69
32 37 56 66 69
30 49 54 66 69
14 41 42 45 69
18 22 29 54 57
27 35 38 57 66
3 6 19 26 34
12 14 26 48 51
12 14 20 21 34
4 6 16 30 56
23 32 44 48 50
17 28 31 32 59
35 37 46 51 61
8 13 27 53 54
24 26 28 59 63
28 30 32 36 58
19 20 50 55 62
25 36 37 55 60
2 24 28 51 58
9 35 37 50 63 
1 20 61 64 69
1 3 13 15 44
3 9 16 56 60
28 36 41 51 58
2 18 37 39 42
12 29 30 33 61
7 24 33 49 50
14 25 35 58 69
3 33 37 51 57
26 28 47 49 58
5 9 11 33 64
17 21 26 47 54
4 7 14 46 59
15 23 27 47 53
23 34 35 40 47
1 13 27 41 49
37 39 44 46 69
13 26 39 44 62
7 15 31 34 36
24 25 38 62 63
12 30 59 65 69
13 17 25 36 40
6 13 19 36 51
43 44 54 61 69
6 12 24 41 68
22 57 59 60 66
3 4 18 29 61
10 33 45 53 56
6 8 26 52 53
8 24 52 55 61
8 24 42 54 64
2 17 20 38 39
16 18 27 55 67
17 19 26 61 63
9 10 12 17 23
40 50 54 62 69
17 18 39 56 64
20 22 28 45 50
5 14 31 40 50 
14 29 36 57 61
11 16 38 50 69
22 42 45 55 56
17 19 21 22 51
3 6 9 17 56
20 54 56 61 64
1 21 31 45 49
17 23 26 46 68
23 25 37 44 64
23 28 41 53 56
6 10 15 25 36
13 20 38 45 55
9 45 57 58 65
4 14 23 27 56
16 29 43 45 56
7 28 37 62 63
3 9 20 42 61
4 7 15 41 44
1 10 43 45 64
19 21 27 46 47
22 41 42 49 67
1 10 27 28 36
9 23 56 58 68
2 18 41 44 64
22 27 46 56 65
5 22 32 38 58
3 11 38 44 58
10 21 30 43 63
5 43 56 62 68

seungyeon (129)

I am just using statistics to alter my strategy.

I try to see patterns and most common numbers.
I have posted my program and I think it's the most simplest way to make a program with my rules.

helios (17506)

helios there is 292 million combinations

Nevermind, I misread the thread.

Still, nothing about the rules of the game implies that you can increase your chances of winning by looking at past games.
I suggest you try writing your own simulator of the drawing mechanism. You will find that no matter how many games you run and how much data you accumulate, your chances of guessing the next result will not change. Like tpb said, you're falling prey to the gambler's fallacy. The result of a random process is unaffected by previous results.

Last edited on

Pages: 12