BASIC BETTING THE MICRO BYTES BACK GRAHAM KENDALL. Copyright

Transcription

1

2 BASIC BETTING THE MICRO BYTES BACK By GRAHAM KENDALL Copyright Edition: 2 nd, Version 1.02 Date: 05 Sep 2016

3

4 PREFACE I wrote the first edition of this book in That edition was a self-published, spiral bound book that was distributed by word of mouth. Technology has moved on a lot since then and the book can now be offered in electronic form. Having a web site ( that supports the book is another benefit that technology offers. The computer programs that were distributed on a 3.5 floppy disc can now be made available via the Internet. The main elements of the book remain the same. I describe why bookmakers and casinos always win, and why this is the case. Next I present some betting systems, focusing on roulette, horse racing and football. I provide computer programs so that you can run them for yourself. The systems/programs that I present are the same that were presented in the first edition. The programs are written in GW-BASIC. This was the predominant language back in 1993 and it is still possible to run these programs today. Although GW-BASIC is not supplied as a matter of course now, there is an excellent emulator available and I have found that it runs the programs perfectly. How to download and use the emulator is detailed on the web site, describing the process for both PCs and Macs. The book comprises 13 chapters, following the same structure as the first edition. The first two chapters explain why bookmakers (and casinos) win. Chapters 3 to 8 present roulette systems. Chapters 9 to 11 considers football (in the UK sense), presenting three systems that we could use to predict the outcome of matches. In chapters 12 and 13 I consider horse racing. Chapters 3-13 comes with a computer program that you can run to see how good (or bad) the system is. Some of the systems that are presented benefit from having a computer program to test it. This is especially true of the roulette systems where it is useful having a computer program simulate a roulette wheel and make, perhaps, thousands of spins. Other systems demonstrate that technology has moved on a little. Chapters 9 and 10, for example, could easily be tested using the basic functionality that is now available on a spreadsheet and if I was to implement these systems today, I would certainly use that tool rather than developing a bespoke program. The book also has a theme that runs through it that talks about the problems of data entry, data security and the problems we may have it trying to fit all of the data on a 3.5 floppy disc drive. These issues are no longer of concern today. Any data you require can be downloaded, either freely or through a suitable subscription. The ability to store high volumes of data is unlikely to be a concern and how do you back it up is probably covered through automated backups and/or utilizing cloud technology. I have largely left these discussions in place just to show how technology has moved on and also to provide some historical perspective. It should be noted that I am presenting the systems for testing. I am not suggesting that the systems will make you money. Indeed, some of them will definitely lose money, which we know before even running the system. If this were not the case then bookmakers and

5 casinos would be out of business. Your task is to decide whether any of the systems have any potential and then, perhaps, develop the ideas further into something that you are happy to test out in the real world. There are support pages for this book on the Internet, see: These web pages show how you can run a GWBASIC emulator running on a modern computer, which is what you need to run the programs listed in this book. The web pages also enable you to download the programs, and associated data files, so that you do not have to key them in. I have not listed the programs as part of the book as it seemed a waste of space when they are easily accessible via the book s web site. In the final section, the book is concluded, and I have included a recommended reading list. This is a collection of titles that I have found useful in compiling this book, as well as books I have read which has increased my knowledge of gambling. It is not necessary to read the book from beginning to end. If you already understand how the gambling industry works you can skip over the opening chapters. Each chapter largely stands alone, if you are just interested in one particular system. It would be remiss of me not to say that the gambling industry exists to make money. Somebody must lose. If the loser turns out to be you, make sure that the money you lose is money you can afford. DO NOT BET WITH MONEY THAT YOU ARE NOT WILLING TO LOSE. Finally, I hope that the systems in this book enable you to eventually profit from gambling. However, the author cannot accept any responsibility for any losses that might occur as a result of using the ideas in this book. Good luck, and please let me know what you think. Graham Kendall September 2016

6

7 INTRODUCTION In this book I investigate gambling systems, by implementing them on a computer. This enables us to experiment with various parameters to see if it is possible to consistently profit from the system. It is important that we understand how the betting industry (both bookmakers and casinos) operates. By experimenting with systems we are trying to turn the tables on the bookmakers and casinos and give us a slight edge that we can exploit, rather than us being exploited by the edge that they have over us. If we understand what profit they expect to take from us, then we will know what advantage we are trying to reverse. So how does the bookmaker (and casino) make a profit? Quite simply, they fix (or make) the book so that they win, no matter what happens. More accurately, they will win in the long run. They may have bad days but the odds are stacked in their favor so that they will take more money than they lose, in the long run. How do they do this? I will consider this in detail in Chapter 2 but, in essence, a bookmaker (and casino) pays you less than they should when you make a winning bet. The difference between what they should pay you, and what they actually do, represents their profit. But that does not stop people trying to come up with systems that can beat the bookie or casino. This book investigates some systems, and enables you to run them on a computer so that you can test them out before you risk real money. I hope that you will develop the systems, incorporating your own ideas, in the hope that you can hit a winning streak. The bookmaker will always have an edge. If nothing else this book will show you that, and prevent you wasting your money on a system that is doomed to failure. Maybe, after reading this book, this may change. Just for once you might be able to go into the local betting shop or casino and know that you are going to win, or at least you will know that the odds are a little fairer than they normally are, even if just for a short time. We will never beat the mathematics in the long run, but is there a way to get an occasional advantage? Whatever happens, I hope that it is fun trying, and you could save money. After running the systems/programs you might decide that the system is not worth bothering with, and you will have discovered this without having to part with real cash to test the system; apart from the cost of this book, of course, but that could turn out to be the best investment you have ever made.

8

9 TABLE OF CONTENTS Preface Introduction Table of Contents Legal Notes Chapter 1: So You Want to Write a System? Chapter 2: You Never See a Poor Bookmaker Chapter 3: Why Roulette? Chapter 4: A Waiting Game Chapter 5: Strike While the Iron is Hot Chapter 6: Double or Nothing Chapter 7: Thirteen Against the Bank Chapter 8: Short and Simple Chapter 9: Take a Tip from the Experts Chapter 10: Long Division Chapter 11: Averages Will Out? Chapter 12: Cooking the Books Chapter 13: My Favourite System and Finally Recommended Reading About the author Other books by Graham Kendall

10

11 LEGAL NOTES This book is intended as an instructive medium and the author accepts no responsibility for any actions taken as a result of reading this book. The programs are provided in good faith but the author offers no guarantee as to their correctness. If the reader decides to base any gambling or investment decisions, using the ideas in this book, the author accepts no responsibility or liability for any losses that might result.

12

13

14 CHAPTER 1: SO YOU WANT TO WRITE A SYSTEM? When gambling somebody, other than the bookmaker, must win. If everybody lost, nobody would bet any more. Consider a lottery. The reason that so many people participate is because they think they might just land the big win. The fact that such a small percentage of people win life changing amounts of money does not seem to discourage people from betting. It would be a different story if nobody won. The lottery companies would soon go bankrupt as everybody stopped buying tickets. There are people who make their living by betting on horses, or playing poker and blackjack. What sets these sports/games aside from many other forms of gambling is that there is some skill required, so the informed gambler can either win money from other players (poker), turn the advantage that the casino has in their favor (blackjack) or use their knowledge to make value bets (horse racing). Roulette is governed by the laws of mathematics and you cannot get an advantage by using your skill and judgement. Not unless you bend the rules a little, but that is generally frowned upon. There are reports of people that have exploited the bias in a roulette wheel, as well as players using Newton s laws of motion to predict where the ball will end up ( but professional roulette players are difficult to find. However, the fact that roulette is governed by the laws of mathematics, rather than allowing us to exercise our skill and judgement, does not stop us trying to develop a roulette system that is able to win us money. If nothing else, it will demonstrate that the mathematics is right, and that we cannot win. Using a computer is an ideal way of testing out an idea that we have for a system, whether that idea is your own, a system you have bought or one that you have read about. As an example, one of the roulette systems that we investigate in this book is the system reported in the book Thirteen Against the Bank by Norman Leigh. Apart from being a great read, the book is about a roulette system that reportedly made a lot of money for the people who used it. Chapter 7 discusses this system and provides a computer program that enables you to experiment with it. One of the easiest ways to test a potential system is to think up an idea and go to the nearest betting shop, or casino, and try it out. This has one major flaw - it is expensive, potentially very expensive. Your first attempt at a system is unlikely to win you money, in fact, it is almost guaranteed that it will lose money. Your second, third and fourth systems are likely to do much the same. Before long you will not be able to finance any more systems, no matter how good they are. The answer, of course, is to try a dry run of your system. You can do this from the comfort of your armchair, with a pad and paper. When you accumulate huge losses you can wipe them out by throwing the piece of paper into the nearest waste paper bin. This approach has the disadvantage that it is relatively time consuming. It all depends on the system of course, but the more complex it is, the longer it takes you to work out if you are onto a winner or not. It is depressing to see six hours of intricate work prove that you would have to sell your house if you implemented the system. This is where the computer comes in. It is the ideal tool for investigating whether or not an

15 idea can be turned into a profitable system. It has the advantage of speed, not making mistakes and remaining unemotional. We all know that speed is one of the main benefits of using a computer. The other two reasons, though, should not be ignored. If you are working for long stretches with a pen, pad and even a calculator you will inevitably make mistakes. Sometimes these will not matter but, at other times, it may mean that you discard a system that has potential, or, even worse, you may think a system will make you money when in fact it won t. It could prove to be very expensive. Remaining unemotional is another important factor. Your computer is not able to make emotional bets as it can only follow the instructions that you give it. It will be incapable of betting on a horse because it likes the name, or putting money on a particular roulette number because it is the same number as your house. Some other reasons for using a computer are: We can quickly test a system. It is relatively easy to write a program to test an idea that we have. Nine times out of ten the system will prove to be useless and can be quickly discarded. This can be depressing, but it is not as depressing as spending five times as long manually testing the same idea, only to reach the same conclusion. We can easily change factors within the system to judge its effectiveness. A computer enables us to quickly change variables within the program to see what effect it has on the overall outcome; that is, money won or lost. The same type of manipulation is possible with paper and pencil, but it becomes impractical when you have to test the system on 100 horse races or 10,000 spins of the roulette wheel. A computer makes this type of testing easy. Using a computer, it is easy to test your money management system. You may think that when betting on roulette that you should use the same stake each time, or even double your bet after a win or a loss. However, by re-running the computer program you may find that a staking plan of the form may be more profitable. It is possible to perform tests than could not be performed with paper and pencil. It is possible to leave your computer running overnight spinning a roulette wheel. In this way you can see how the system performs over thousands, or even hundreds of thousands, of spins. In fact, using a computer can simulate many months, or even years, of live running. Despite the benefits of using a microcomputer there are also problems. [I should note here that, the information discussed below (and in some other places in the book) is based on the situation in I leave it largely as is, as I find it historically interesting as it shows how much times have changed. With the Internet, data is now much more widely available, storing data is now a lot easier with the larger disc storage being freely available and backing up data is now almost a non-issue with concepts such as cloud storage.] When developing gambling applications, data collection can be a problem. Despite the daily papers being full of football results and horse racing information, sometimes the data you require is just not there. For example, unless you take a recognised racing paper you

16 are unlikely to find the complete horse racing results. Many daily papers only give the places. In practical terms this means that only the first three or four horses are listed. If your system relies on you keeping detailed information about every horse you will need to invest in either the Sporting Life or The Racing Post. The football pools have a similar lack of information. You will be able to find the results of all the top divisions in England and Scotland, but minor divisions are not always given. This will not cause a problem until these clubs appear on the football coupon, either in their respective leagues or in a competition such as the FA Cup. As an example, three minor leagues regularly appear on the football coupons. These are the GM Vauxhall Conference League, the HFS Loans League and the Beazer Homes Premier League, but these are not the only minor leagues that may appear. It is noticeable, sometimes, how many exotic teams the pools companies have had to draw from to get their 58 matches. I can almost guarantee that none of the national daily papers will give the result of every division that could form part of the pools coupon. Therefore, if you are serious about collecting every football result, you need to find a source where every result is available. Finally, roulette. If you want to test your system against numbers that actually appeared on a real roulette wheel you will have to get yourself down to a casino and note them all down. The average wheel will do about 30 spins an hour. If you are looking at performing long tests you will have to stand at the wheel for a long time to collect, say, 1,000 numbers. Assuming that you can solve the problems of data collection your next problem is data input or, more precisely, the amount of data that has to be input. I know from bitter experience how long it takes to input the result of every football match that is played. A later chapter will go into more detail about this, but here are some figures for you to ponder. Assume that there is an average of 20 teams in each division. Each team has to play every other team both home and away; a total of 38 games for every team. Multiply that figure by the number of teams in the division and divide by two (20*38/2) and you arrive at the number of matches played in one division: matches is a lot of data to input, but that is only for one division. At a minimum you will be following the English first, second, third and fourth divisions, as well as the two top Scottish divisions. You will also probably want to record other divisions such as the Scottish second division, the GM Vauxhall Conference and the Beazer Homes Premier. If we stop there we are already up to 8 divisions. At 380 matches in each division this means that we are recording results for 3,040 matches. In an eight month football season this means an average of 13 matches a day. However, this figure will peak on a Saturday and you will be faced with inputting, perhaps, 80 matches. And when you have input this information what have you got to show for it? Nothing as yet and maybe you never will have.

17 I am not trying to discourage you from typing in the result of every football match. I am just warning you that it is a vast undertaking. A task I know, that many have started, and almost as many have given up, with nothing to show for their efforts. Horse racing is, if anything, worse. Not only are there more horse races than football matches, but the data collection is even greater. Do you go the whole hog and collect details of every horse, jockey, track conditions and race times, plus more besides? Or do you only collect details of the placed horses? If you do not collect all the details you may regret it later when you devise a system that relies on more information than you have collected. On the other hand, you may collect data that you will never use. In fact, you may collect it, have to read it into every program, but never actually use it to decide which horse to back. Again, I am not saying do not do it. Just think about it before you decide to do it. Be clear about what you want to achieve. If you start collecting a lot of data without having any clear idea about what you are going to do with it, I would suggest that you are wasting your time. If you do decide to take on this immense data input task you must also consider where you will keep the data, how you will access it and how you will secure it. Security is probably the most important aspect. The last thing you want, after spending hours keying in the data, is to lose it. Backing up the data is essential, but this is a major task if the data is stored on floppy disks. Even more so if you only have one floppy disk drive. It is slow and frustrating to have to swap disks every few seconds. Imagine having to do that every day after you have input football or horse racing results. Once your data is backed up you should consider keeping one copy at a different location from your computer. Just because you have three copies does not necessarily mean you are secure against any event. The proverbial Jumbo Jet could land on your house. Admittedly, the last thing on your mind at this time would be a computer system, but for Jumbo Jet read spilt cup of coffee and you could still have a house, but no longer have disks with readable data on Accessing the data is also a problem, especially if the data is held on floppy disks. Apart from all the disk swapping there is also the time required simply to access it. Have you ever tried to read a file that is spread across ten floppy disks? It is slow, tediously slow. If you have a hard disk, consider yourself lucky. Data storage and data access will be easier, at least for a while. Eventually, though, you will fill up the disk. What do you do then? Overflow onto floppies; delete data? This is a problem, and one that will come sooner than you think. In the past I have tried to develop systems that depended on reams of data being input. The systems may have eventually worked but they always fell at the first hurdle. I simply could not keep up with the data that required inputting. This was either through lack of time or simply laziness. At one time I belonged to a pools syndicate that aimed to win the football pools by using computers. The syndicate lasted for about six months. In that time numerous letters went round the members discussing how we could part Littlewoods from their money.

18 Unfortunately, most of the systems relied on each football result being held in a database. The syndicate eventually folded. The main reason was due to the fact that nobody was willing to input the results and send the disks to everybody else so that they could get on with the real business of developing the winning system. I can t say I blame them. I was not prepared to supply a database to five or six other people which may have helped them to win money, out of which I would be unlikely to profit (despite assurances to the contrary). You will be pleased to know that none of the systems in this book rely on vast quantities of data input. Some require none at all. Some require just a little. And some require data input that will take no more than half an hour a week. The programs that are presented as part of this book are written in GWBASIC. This was the version of the programming language that was provided as part of an MS-DOS installation. This made it a very popular language and many would be programmers started out using this language. GWBASIC is quite easy to use and learn. It does not have any of the complexities that exist in today s languages. It is not object oriented and you just need a basic text editor to alter the programs. But, if you only want to run the programs, then you do not need any programming skill at all. The web site accompanying this book: has details about how to install a GWBASIC emulator and how to run the programs. Once you have installed the GWBASIC emulator, it really is just a case of LOADing the relevant program and RUNing it. Literally two commands. I would suggest that you could download GWBASIC, download the programs from the book s web site and be running your first GWBASIC program inside ten minutes. If you are familiar with BASIC, but not GWBASIC, do not worry. The programs should be easily understandable, and therefore will be easy to modify for your own machine. If you have never come across any form of BASIC before, again, don t worry you can still run the programs without understand the programming language. Finally, the systems are there to be developed. Play around with them. Amend them as much as you like. And, if possible, take the bookmakers for every penny you can. Given the chance they will do the same to you.

19

20

21 CHAPTER 2: YOU NEVER SEE A POOR BOOKMAKER When you pass your money and betting slip over the bookmaker s counter, how is the bookmaker going to ensure that he makes a profit? He could, I suppose, leave it in the lap of the gods and hope that your horse loses. If it did, all of your stake would go down as profit. However, if your horse won, depending on the odds, the bookmaker would have to pay you many times your original stake. And then, to rub salt into the wounds, he would also have to give you back your original stake. You will not be surprised to learn that bookmaking operates like any other business. The bookmaker aims to profit from every race, regardless of how you, as an individual, did. And, like any other business, bookmaking has a profit margin. This means that the bookmaker aims to make a certain profit from every race. This can be likened to somebody selling widgets. They may buy widgets at one price and then aim to make 20% from every one that they sell. How a bookmaker achieves his profit margin is not so obvious, but it is there. Consider these two horse races: Table 2.1: Race 1 - odds Horse Odds Table 2.2: Race 2 - odds Horse Odds

22 Try to work out a staking plan so that you can bet on every horse so that no matter which one wins you will make a profit. To get you started I suggest you place 16.5 units on a horse whose odds are 5-1. In Race 1 it is possible to bet on all the horses and ensure that you come out winning. For those of you that did not reach that conclusion take a look at following table. Table 2.3: Race 1 odds, stake and return Horse Odds Stake Money won (incl. returned stake) Total Staked You can see that no matter which horse wins you will profit by about 31 units (100-69). The second race is a different matter. No matter how you juggle the stake you will find it impossible to bet on every horse and guarantee that you will win money. Not surprisingly every race that is run is similar to the second race in that you can never profit by backing every horse. And this is the key to how the bookmaker makes his profit. If we could bet on a race in such a way that we could guarantee to make profit the bookmaker would soon be out of business. The question still remains though, as to how the bookmaker sets the odds so that he is guaranteed to make a profit instead of us. Bookmakers are not called bookmakers for nothing. They get their name because that is what they do; they make a book, which is in their favor. It is easier to understand if you consider a two horse race where both horses have an equal chance of winning. The odds for each horse should be evens (1-1). Right? Wrong. If you were a bookmaker and offered even odds on both horses you would end up all square. All the money that came in would be paid out, and ending up even is no way to run a business. If a two horse race did take place, where both horses had an equal chance of winning, the starting prices for both horses might be 4-5 (for every five units you bet, you win four). It is now easy to see that the bookmaker is not offering the correct odds. By doing this, assuming that there is an equal amount bet on each horse, the bookmaker will make a

23 profit no matter which horse wins. Looking at it from your point of view makes it easier to see the mathematics working against you. If you placed 5 on a horse that has an evens chance of winning you could expect to win 5 if your horse crosses the line first. However, if the bookmaker is only offering 4-5 you would only make 4. What has happened to the other pound? I ll give you three guesses but the saying You never see a poor bookmaker springs to mind. This principle, of making a book in their favor, is the backbone of the betting industry. This applies, not only in horse racing, but also in casinos, fruit machines, football pools, bingo, lotteries, scratch cards and any other gambling institution you can think of. Every one of them knows that they will retain a certain percentage of all the money that is bet. There is nothing we can do about this, and in fact we should be glad the industry works in this way. If it did not, there would be no betting industry as the gambling institutions could not make a profit. It can be likened to our widget retailer buying widgets at twenty pence each and selling them at twenty pence each. It just would not make business sense. The way this idea is implemented varies from one sport/game to another. In a game like roulette the odds of the various bets stay the same. If you place a chip on the betting cloth you know what your winnings will be if your number turns up. Horse racing is different in that the odds are adjusted depending on how much money has been placed on each horse. Normally when you place a bet you do not know what odds you will eventually get. You can take the odds on offer at the time you place the bet but many people take the starting price, which is the price on offer when the race gets under way. In horse racing the odds are being continually adjusted, but not, as you might think to give you a better return for your money. The odds are adjusted to try and maintain some sort of balance between the amount of money placed on a horse and the odds being offered. The more money that is placed on a horse the shorter the odds become. In practical terms this means that the more heavily backed a horse is, the less you will receive if the horse should win. But that is not the whole story. The bookmaker is not all bad. He does not mind some people winning just as long as he gets his fair share. He is aiming to take a certain percentage of all money that passes across his counter. To do this he must adjust the odds to reflect the amount of money that is being bet on the race. Take a look at the races again. This time I have not only given the odds, but have also converted the odds into percentages. This gives us further information as to how the system works in favor of the bookmaker. Table 2.4: Race 1 odds and percentages Horse Odds Percentage % %

24 % % % Total 68.96% Table 2.5: Race 2 odds and percentages Horse Odds Percentage % % % % % Total % The total percentage is the key. If it totals over 100% you cannot back every horse and win money. If the total percentage ever falls below 100% you will be able to make money by backing all the horses. As I said before though, there is never a race where the book allows you to make such an easy profit. When the book totals over 100% it is said to be over round. The amount by which it is over round represents the bookmaker s profit margin. Similarly, in races that total under 100%, our profit would be the amount by which the book was under round. Unfortunately, we also have betting tax to take into account and this makes the mathematics work even harder against us. You can also see from Race 1 how I calculated the stakes. It is simply the percentage converted to money (with a little rounding). Just a little more mathematics. We need to know how to convert odds to percentages. Once armed with that information we can work out the bookmaker s profit on any horse race. The same applies whenever the bookmaker offers you odds, regardless of whether the event is horse racing, greyhound racing, the World Cup, snooker or the result of a football match. The total of the odds expressed as percentages will total over 100%, and from that we can calculate the bookmaker s profit. The formula to convert odds to percentages is as follows:

25 (RHS of odds / (LHS of odds + RHS of odds)) *100 Therefore 3-1 would be calculated thus: (1/(3+1))*100 Working through the formula we arrive at the following: (1/4)* *100 = 25% So that you fully understand how this works, I have listed Race 2 again. This time with the odds, the percentages and also the formula to arrive at that figure. Table 2.6: Race 2 odds, percentages and calculation Horse Odds Percentage % (4/(5+4))* % (1/(3+1))* % (1/(4+1))* % (1/(8+1))* % (1/(10+1))*100 To further demonstrate the principle I have shown below some actual races. They are all taken from Saturday 26th January 1991 and, as you can see, without exception, the total percentage is over 100%. The winning horse is shown by an asterisk. Table 2.7: Ayr 1.00 Horse Odds Percentage Burgoyne Abnegation Northants Young Miner Kambalda Rambler

26 *Bowlands Way Kangaroo Court Les Parvenus Abercromby Chief Gydaros Southeby Sound Amaze Me Balinglance Caithness Bell Master Woodville Total Table 2.8: Doncaster 3.15 Horse Odds Percentage Native Mission *Silken Fan Tres Amigos Haroon Emeritus Roy Hobbs Marsh s Law Total Table 2.9: Cheltenham 4.10

27 Horse Odds Percentage Fighting Words Jungle Knife La Cienaga *Sabaki River Wicket Shadow Run One to Note Mercury Moon Brilliant Bay Total If you want to look at some races for yourself, I have listed below some of the more frequently used odds to save you having to work out the percentage figures. Table 2.10: Typical odds and percentages Odds Percentage

28 You might find it interesting to work out the over round for The Grand National. This is the race that everyone bets on. After you have worked out the bookmaker s profit margin, you might ask yourself why? What I have said about home racing applies equally to greyhound racing. The book is made in the same way; the percentages will always total over 100% and you will have just as many problems extracting money from the bookmaker backing greyhounds as you will when backing horses.

29 Throughout the rest of this book I will only refer to horse racing. However, the text and accompanying programs apply as much to greyhound racing as they do to horse racing. In fact, many people prefer to concentrate solely on greyhound racing because there are always the same number of runners; six dogs per race. What of the casino owners? How do they go about ensuring that they will make a profit? Chapter 3 explains roulette in greater detail. For our discussion on the house edge though, we need to understand just one of the bets that is available. The rest are just variations, with the same mathematical underpinnings. The house edge is the profit the casino expects to make from one of its gambling games, and is similar to the over round in horse racing. We shall see in a moment that the profit a casino makes is a lot less than the typical 12% for a horse race, but casino games tend to be a lot faster so they are making their profit more often. In roulette there is a wheel that can select one of 37 numbers (0 36). Some wheels, in the United States, have a double zero as well as a single zero which gives a possible 38 numbers that can be thrown up. However, for our discussions we will concentrate on a wheel with 37 numbers. Your job, as a punter, is to decide which number the roulette wheel will choose. If you can do that successfully you will receive odds of For example, you place one chip on the number 17, and if it turns up the croupier will give you 36 chips as a reward. This represents odds of 35-1 plus your original chip. If you do pick the winning number, you will probably not worry too much about the fairness of the odds. After all, 35-1 is not bad odds is it? Furthermore, if you could pick the correct number every time, getting 35-1 would not be too upsetting. However, life is not like that, and you will not be able to pick the correct number every time. In fact, you should only be able to do it once every 37 spins. Here lies the problem. If you can only choose the correct number once in 37 attempts, you will have lost 37 chips but only received thirty six, which means that for every 37 spins you will lose one chip. To look at it another way, you could consider putting a chip on each of the 37 numbers. When the wheel is spun you will receive thirty six chips back, effectively losing one chip. After 37 spins you will be 37 chips down. Hardly a winning formula is it? This is the same problem we had with horse racing. We cannot back every horse and guarantee to win. Similarly, we cannot cover every roulette number and ensure that we make a profit. In roulette, like horse racing, if we try to do this we are playing to the casino s strengths and demonstrating the house edge that is operating against us. In horse racing we can find the profit margin by calculating the over round of the book. In roulette it is a little easier. All we need to do is work out what percentage one chip represents of 37 chips. In formula terms this is: 1/37*100 This works out to be 2.7%. As you can see, this is a lot less than the bookmaker s profit in a typical horse race. These often come out at 12%. Bear in mind that a horse race happens every half an hour, whereas a roulette wheel is spun every couple of minutes.

30 In roulette, if we assume that you are betting in 25 pence units, you would lose 9.25 in about half an hour (37*.25). It is reasonable to assume that somebody betting on the horses might also be willing to lose a similar amount in half an hour. In this instance the house edge is irrelevant. It is how much the punter is willing to lose that is the important factor. Even if that were not the case we could say, with some certainty, that anybody willing to back 25 pence on one spin of a roulette wheel would not be happy betting 25 pence on one horse race. They would want to take similar risks over a similar timescale. Anyway, the main point is not how much you are willing to risk; it is how the house edge or profit margin can appear deceptive. The 2.7% in roulette may seem small compared to horse racing, but remember that it is working against you more frequently. The bet I have described above allows you to select one number that you think will turn up. As we shall see in the next chapter there are many more bets that can be made in roulette but the house edge remains the same at 2.7%. It you ever have the misfortune to come across an American roulette wheel, that has a double zero on it, my advice would be to leave well alone. The house edge for this wheel is 5.26%. This type of wheel has 38 numbers on it and the odds for picking the correct one are still 35-1 which is the reason for the larger house edge. Whereas before you could expect to lose one chip in 37 spins you can now expect to lose two chips in 38 spins. This gives us the following formula to calculate the house edge for a wheel with a double zero. 2/38*100 = 5.26% Why bother trying to win money against a house edge of 5.26% when we can go elsewhere and play against a house edge of 2.7%? Although roulette is fairly simple in its mathematics, I should say that the sorts of figures I have described above are the mathematical probabilities. If you sat at a roulette wheel for 37 spins you would be unlikely to see each number come up once. Although probability says that this should be the case, that is in the long run. Over a period of time each number will appear an equal number of times. The problem, from our point of view, is that the period of time is an unknown quantity. It could be 74 spins (2*37) or it could take millions of spins for the numbers to balance out. In fact, probability plays a long game, certainly longer than we would probably like. The most important thing to keep in mind is that each spin of the wheel is an independent event. The wheel has no memory so it does not know that the last six spins were red, so black is due. Over time, red and black will appear an equal number of times, but the wheel does not keep track as to what is due, red and black are equally likely to come up on any single spin of the wheel. Another factor to keep in mind is that you are not there for every spin of the wheel. You might start betting and see the number 14 appear twice in succession. You might reason that the same number should not appear for at least another 74 spins What you do not know is that the number 14 may not have shown for the last 500 spins. In fact, it could show a few more times and still be due to show yet again to correct the balance. So, although probability, ultimately, is the master of roulette we cannot rely on it as the ultimate system for winning at the game.

31 We must have something as the basis for our systems, however, and so probability, does come into it. Some of the systems we shall look at will appear to work against probability in that we will back numbers that seem to be having more than their fair share of luck. But who is to say they are not simply readjusting the odds. Or maybe it is going against probability for the time being and will only be brought to order after a few thousand spins, or more. So, some of our roulette systems will try to back numbers that are, hopefully, running with the laws of probability. Others will try to ride their luck and stick with numbers that seem to be enjoying more shows that probability suggests. I will leave it to you to draw your own conclusions of the effectiveness of these type of systems. So much for horse racing and roulette. The other form of betting that we shall be looking at is the football pools. This, too, has a house edge, although it is more properly called a profit margin. The football pools is probably the easiest industry to see how the companies make their money. They collect money from the would-be millionaires and only pay out a proportion of it in prize money. I do not know what profit margin the pools companies operate on, but, as in any business, once they have paid out the prize money, they must have enough money to pay for things like rent, rates, wages, heating, lighting and all the other things it takes to run a business. They also hope to show a profit at the end of the year. Operating a profit margin in this way can be seen in many other sports and games. Fruit machines, bingo, lotteries and scratch cards follow exactly the same principles. They take in the money and pay out some of it to the lucky winners. The rest is profit. As in roulette and horse racing, if you covered every bet (by buying every bingo card, lottery ticket or scratch card) you would lose. The amount you would lose is the profit margin the organisers are planning to make. By reading this chapter I hope you can see how the various gambling institutions make their money. I also hope you can see how the profit margin or house edge is calculated. If we are going to develop a system that will allow us to win money we must find a way to get the house edge working in our favor. Our aim should be to win small amounts of money over a period of time. An exception are lottery type games (and I include the football pools in this), where you invest relatively little but the potential returns are enormous, but the chance of a huge win are millions to one. Our best hope is to do to the bookmakers what they do to us. That is, win little and often. If we can achieve that we need not concern ourselves with the big win., just be content with small, regular, consistent wins.

32

33

34 CHAPTER 3: WHY ROULETTE? No one can win at roulette unless he steals money from the table while the croupier isn t looking, Albert Einstein The first systems we shall develop in this book will concentrate on roulette. You may ask why choose roulette? Surely football pools and horse racing are more accessible to most people, and perhaps we should consider these first? Maybe so, but roulette has a major advantage when it comes to developing systems. That is, the mathematics is straightforward. When you place a chip on one number you know the odds you are getting (35-1). You also know the house edge that is operating against you (2.7% on a European wheel). This is not the case with the football pools or horse racing. With horse racing we have two things to consider and, to make matters worse, they are constantly changing. Firstly, the odds change as money is placed, or not, on a particular horse. The more money that goes on the horse the less you can expect to get back if the horse wins. Of course, this could work in your favor. You could bet on a horse and then have its odds lengthen. Assuming it wins, you will receive more than you earlier expected. Additionally, as the odds change so does the bookmaker s profit margin. What, at first sight, may have looked like a reasonable profit margin (from your point of view) may not look so good later in the day. The fact that the odds and the bookmaker s profit margin are forever changing is not necessarily a bad thing, but with roulette at least you know where you are as the odds are fixed. Once you have worked them out they stay the same and it is for this reason I thought it best to start our investigations with this game. The football pools are similar to horse racing in that you do not know how much you will win, always assuming that you are lucky enough to win anything. Therefore, you do not know what odds you are taking when you hand over your money to the local pools collector. The only thing you can say about the football pools is that the odds can be amazingly good. In fact, you will probably not find better odds anywhere else in the UK, or even the world. In theory, you could bet one penny and win anything up to one and a half million pounds. I don t think anybody would argue with those odds. Of course, these big wins have their down side as the odds you receive may seem huge, but so are the odds against you actually winning. Another advantage with roulette is that we can easily simulate the spinning of a roulette wheel on our computer. It is simply a case of using the random number generator to pick a number between zero and 36 so we do not have to do any form of data entry. As far as the system developer is concerned this is a bonus. We can simply develop the program and let it run. We do not have to concern ourselves with data input routines or file handling utilities, or worry about data storage. Horse racing and football pools do not give us this luxury. If we want to develop a system for these, we need to input some sort of data. This

35 raises all the associated problems such as the storage of the data, accessing it and the complications that come when we have to consider these activities. As we shall see later, we can do our best to limit these problems but we cannot eliminate them altogether. All of that is for later, though, because for now we are concentrating on roulette. Roulette is a simple game. It is a case of picking the next number the wheel is going to select. If you can do that, you will win. You simply place your bet, the wheel spins and the winners are paid. The next spin of the wheel is a different bet. There are no complications such as doubles, trebles or permutations. There are different types of bet, but these are easily understood. Roulette is a fast game. Each spin takes about two minutes. No waiting until Saturday to check a coupon, in the case of football. No waiting for the horses to come under orders and then waiting while they run two miles round a track, jumping over fences. Roulette is immediate. You place your money and before you know it the chips are being dragged away or a pile is being pushed towards you. As I said before, there are a few more bets than just trying to pick a single number, and it might be worth understanding some of the other bets we can make, just so that we have a deeper appreciation of the game. Roulette comprises two pieces of equipment. There is the wheel and a betting table. The wheel is used to select the number and is divided into 37 slots (38 on a USA wheel, but we are ignoring that for the sake of our discussions). A small ball is sent in the opposite direction to the spinning wheel. As the wheel slows the ball comes to rest in one of the 37 compartments. This is the number that the croupier calls out. Figure 3.1 shows you what a roulette wheel looks like. It shows each number, the order they appear (the USA wheel has the numbers in a different order) and the colour of the number. Fig 3.1 A European Roulette wheel (CC BY-SA To play roulette you also require an area where the players can place their bets. This is done on the betting table. Each number is represented on this table, as are the other bets that are available.

36 Six bets are specifically designed to allow you to bet at even money (1-1). This is made possible as the 36 numbers (zero is not included) fall into various categories. For example, every number is either odd or even. Each number is either 18 or below (low), or 19 and over (high) and each number is coloured either red or black. These six attributes (odd, even, low, high, red and black) give us our six even chance bets, although they are not really even chance because if zero turns up it is classed as neither odd, even, high, low, red or black, and you effectively lose some or all of your money. Casinos have different ways of dealing with zero when it turns up and players have bet on an even chance bet. Some casinos allow your stake to stay on the table until the next spin. If that spin wins you keep your stake (without winning any extra). If the spin loses the casino keeps your chip. Other casinos allow you to take back half the stake from even money bets when zero turns up, while others assume that zero is a losing bet and collect your chips. Throughout this book we will assume the worst possible case. That is, if zero appears on an even chance bet we will take that as a loss. By doing this we keep the house edge to the usual 2.7%. The other options effectively halve the house edge. This is why the even chance bets are often seen as the ideal medium for system players. Instead of playing against a house edge of 2.7% you are only playing against a house edge of 1.35%. If you wish to change any of the systems in this book to reduce the house edge on even chance bets to 1.35% it does not matter which method you choose in order to do this. Whether you amend the programs to leave the stake until the next spin, or retain half the stake while giving up the other half, it does not alter the house edge. From a programming point of view it is probably easier to retain half the stake and give up the other half. Doing it that way you will not have to remember that there is a bet left over from the previous spin. The other bets that are available can best be seen by looking at Figure 3.2

37 Fig 3.2 A European Roulette Table (CC0 You can see the individual numbers. Chips may be placed on these squares to back that number. You can also see the even chance bets down the sides. The area marked Manque is where you place your chips if you want to gamble that the next number is going to be 18 or less (excluding zero). Passe is for betting on the numbers 19 to 36. Pair and Impair, as their name suggests, are for betting on odd and even numbers. Betting on Red and Black is done by placing your chips in the areas marked by the diamonds. The squares at the bottom of the 37 numbers allow you to bet on 12 numbers at one time. For example, if you placed a chip in the left hand square you would be backing the numbers 1, 4, 7, 10, 13, 16, 19, 22, 25, 28, 31 and 34. If zero turns up you lose. The odds for this bet are paid at 2-1 and they are known as column bets. If you care to work out the house edge you will find that it is 2.7%. By placing on the line between two columns you can back 24 numbers at one time. For this bet the odds are 1-2. House edge, need I tell you, is 2.7%. The areas marked P, M and D, at the very bottom of the table, also allow you to back 12 or 24 numbers in one go. If you place a chip on the letter P, you are gambling that a number between 1 and 12 will come up (notice the exclusion of zero). Betting on M is gambling on the numbers 13 to 24. D backs the numbers 25 to 36. By placing a chip on the lines between the letters allows coverage of 24 numbers. For example, a chip on the line

38 separating P and M gives a bet on the numbers 1 to 24. Like the column bet the odds for the dozen bet are 2-1 and 1-2. The house edge remains at that stubborn 2.7%. As well as betting on single numbers it is possible to bet on several numbers at one time without resorting to the bets I have already described. For example, by placing a chip on a line intersecting two numbers you can bet on them both. The odds you receive are You can bet on three numbers by placing a chip on the outside of a row of numbers. You could, therefore, back the numbers 7, 8 and 9 by putting your chip on the left hand line of the number seven. The odds for this bet are Four numbers can be backed by placing a chip on the central cross that joins the numbers. 14, 15, 17 and 18 could be backed using this bet. If you win you receive odds of 8-1. Finally, you can back six numbers and receive odds of 5-1. To make this bet the chip is placed in a similar way to backing three numbers, that is, on the line down the outside edge of the 37 numbers. However, to back six numbers, as opposed to three, you place your chip so that it crosses two rows. In this way it would be possible to back the numbers 10, 11, 12, 13, 14 and 15. You might think that zero is excluded from the bets I have just described. In fact, it can be included in many of the bets. The only ones in which zero cannot be included is where the chip cannot physically be placed to combine the required numbers. For example, you cannot bet on six numbers and include zero as the no way the chip can be placed to achieve this bet. Now that we understand the various bets available to us we can start to think about our first system. It would seem sensible to try for the bet that gives us the best return. At 35-1 betting on a single number is best odds we can get, so we might as well concentrate our efforts on that aim. The problem is how do we decide which number to back? You could record every number that turns up and then apply the laws of probability to work out which number is due. For example, if, after 36 spins, the only number that has not shown is 14 you might feel justified in having a bet on that number. What do you do, though, when there is no clear cut number on which to place your chips? What do you do, if after 36 spins, three numbers have not shown? Do you keep spinning the wheel, without betting, until only one number remains that has not shown? Or do you back all three? I am afraid I have no solution to that one, but if you feel that type of system is worth pursuing then one of the programs I have supplied can be easily modified to achieve that aim. I have decided to use a different approach. I decided to base the selection of the number on three criteria. There s no magical reason for this, I just decided to try out the system using this method. It will be for you to see, when you run the program, how successful the method is. As each number appears I store three things about it. I store its colour, which dozen it belongs to and which column it comes from. To do this I update three counters for every spin. In the case of, say, 16 I would increment the red counter, the second dozen counter and the first column counter. Before each spin I then try to find a number to back using the information I have previously stored. To do this I compare the three types of information against each other and come up with three ideal criteria for a number to back. Let me give you an example:

39 assume that the stored criteria are as follows. Table 3.1: Sample Data Bet Data Red 12 Black 15 First Dozen 10 Second Dozen 9 Third Dozen 8 First Column 11 Second Column 7 Third Column 9 According to the rules of the system we would look for a number that is red, in the third dozen and in the second column. We do this because each of those criteria has appeared less than their counterparts. If you look at the betting layout, the number 32 meets this criteria. So that is the number we would back. Occasionally there may be more than one number that fits the criteria. For example, if we wanted a number that is black, in the third dozen and in the second column we have three numbers that fit the bill (26, 29 and 35). I decided at the outset that once I had found a number that we can bet on I would stop the search. Therefore, when I come across number 26 I would stop searching and bet on 26. This does mean certain numbers will never be backed as the search will always stop before that number is reached. The reason I decided to adopt this method is because I was not sure what to do if I did find two (or more) numbers that matched the criteria. Should I not bet at all? Or should I split the stake between the numbers I have found? You might like to change the program to try both these ideas. So, that is the idea in theory, but how does it work in practice? The BASIC program supplied on the web site is an implementation of the system I have described above. However, before I explain the program in more detail, I need to explain of the conventions used in this program, and in the other programs throughout the book. All the programs have been written using GWBASIC. They were mainly developed on an Acorn A3000 using the PC emulator. Once developed, they were then tested on a true PC.

40 The web site accompanying this book provides details how you can get a GWBSIC emulator running on your PC. The programs have been written using a structured approach. This has achieved by making extensive use of subroutines, many of which are used in more than one program. It is hoped that these repeated subroutines will not only make the programs easier to understand but also make the programs more resilient as they are fully tested pieces of code. I should also point out that the programs have been written as simply as possible. I could have reduced the length of the programs quite considerably, but readability would have suffered. I decided it was better to have programs that readers understood rather than have fewer program lines. Also, on occasions, I have used simplicity at the cost of efficiency. Again I decided the programs should be as readable as possible, even if the program ran more slowly than it might otherwise have done. Because the programs have been written in a modular way it should be fairly easy to modify the programs to run on other dialects of BASIC. Unfortunately, it has not been possible to ensure total compatibility between different versions of BASIC. For example, GWBASIC uses WEND to terminate a WHILE statement. Other versions of BASIC use ENDWHILE as a terminator. These differences are impossible to cater for. However, by writing the programs under GWBASIC it is hoped the majority of people will be able to run them. For those that use a different dialect of BASIC the conversion procedure should not be too horrendous, because of the way the programs have been written. As mentioned above, there are some subroutines that appear in several of the programs. You will find that they are identical in each program in which they appear and that they perform the same function. You will also find that they have the same line numbers in the programs in which they are used. This, again, is an attempt to make the programs as easy to understand as possible. The subroutines that fall into this category are listed below. If you have no interest in the innards of the programs, or how they work, you can skip this section and just go straight to the web site and run the programs. Init_1 and Init_2: Initialization Procedures I have just said that the standard routines all perform the same function and have the same line numbers. Well, nearly all. The Init_1 and Init_2 routines are the exceptions, but I have included them in this section as you will see them in almost every program. Because they are initialization routines I always place them near the beginning of the program which is the reason I cannot give them the same line numbers within each program and because they perform the initialization for the program they will obviously differ from one program to the next. Init_1 will perform program initialization that needs to be done once, and once only. DIM ing arrays and READ ing DATA statements would fall into this category. Init_2 will be called after Init_1 and then called again if the user decides to run the program again. The function of this routine will be to reset counters, typically to zero, and initialise other variables.

41 Line 5000: Centre Text Routine This routine prints text, on a given line, and ensures that it is central. Before calling this routine two variables have to be set: DOWN% tells the subroutine on which line to print the output. TEXT$ contains the text you want to output. Line 5500: Print Text Routine This routine is similar to the Centre Text Routine in that it outputs text. The difference is that this routine does not ensure that it is centralised. Instead it takes an additional variable (ACROSS%) which is used in a TAB statement to print the text starting at a certain column. Like the center text routine the variables TEXT$ and DOWN% tell the routine what to output and which line to output it on. Line 6000: Press Space Routine This procedure outputs a message asking the user to press the space key to continue. The message is output on line 22 of the screen and uses the Centre Text Routine to ensure that it is output centrally. It is normally used when the program is outputting information for the user to read. To move from one screen to another the user is invited to press the space key. No variables need to be set before calling this routine. Line 6500: Print Heading Routine This procedure prints a standard heading, typically the program identifier, on line two of the screen. To actually print the text it uses the Centre Text Routine to ensure that the text is printed centrally. No variables need to be set before calling this routine. Line 7000: Ask Question Routine This routine asks the user if they want to play again. The question is output on line 10 and the Centre Text Routine is used to display the message. The routine waits for a Y or N to be pressed and sets the variable NEWGAME% accordingly. NEWGAME% will be tested in the controlling part of the program. Line 7500: Random Number Routine This subroutine returns a random number between 0 and 36, simulating a roulette wheel. The random number is returned in the variable NUM%. As well as these subroutines there are others which will have the same names in many of the programs, but which will do different things. For example, a Win routine will be found in many of the programs. This routine will always be called when a winning bet is made. However, the coding within this routine will vary from one program to the next. Back to our system. If you run the program at the end of this chapter, you will be asked

42 how many spins you would like the wheel to make. Validation is performed to check that you input a number between one and 5,000, The only reason I limited the number of spins to 5,000 is to stop huge figures having to be input, as this could make the program run for an unacceptable amount of time. If you want to increase the number of spins the wheel is allowed to make, the Number of Spins Routine can be amended. As far as data input is concerned, that is it. The program will now run and will spin the roulette wheel the required number of times. As each spin takes place, the information I described above is collected and a number is selected based on the conditions also outlined above. Once the program has completed the required number of spins, three screens of information are output. The first screen, (the Print Routine), gives details of the number of reds and blacks that appeared. It also reports the breakdown of the dozens and columns. Probably more interesting, is the information at the bottom of this screen as it not only tells you how many bets were placed but also how many times no bet was placed. The number of wins and the number of losses are also reported, but the most important thing it tells you is how much you have won or lost. I probably should point out that the program bets in units of ten, and it starts with a bank of zero. I know you would never go into a casino with nothing in your pocket, but it suits our purpose to start with nothing. It makes it easy to see if we have won or lost. A positive value means we have beaten the casino. A negative value means we have lost If we started with, say, 100 units, a finishing balance of 50 units would mean that we have lost but that is not as obvious as seeing a minus sign in front of the final balance. The next two screens display various statistics and the information they show is detailed later in the chapter. The easiest way to understand what the program is doing is to look at the main parts of the program. The section up to line 130 is the controlling part of the program. Init_1 is only called once, and it DIMs the arrays and reads in the DATA statements held at the end of the program. There are two sets of DATA statements. The DATA at lines 7560 to 7620 is effectively held in sets of three. If you look at the first three items on line 7570, these all relate to the number one. The first item (R) tells the program that the number one is Red. The second item informs the program the number falls in the first column. The third item shows that the number is in the first dozen. Looking at the next three items you should be able to see that the number two is Black, is in the second column and in the first dozen. Line 7560 is used to show that zero has none of the attributes associated with the other numbers. The DATA statements at lines 7650 to 7690 are the headings used on one of the information screens. Lines 50 to 120 are repeated until the user decides not to continue running the program. The remainder of the program is made up from subroutines. Their function is described below. Game Control Routine (Line 460) This routine controls the spinning of the wheel and deciding whether to bet on a number. It

43 also manages the money by working out if the number selected by the program won or not. It then adjusts the player s bank accordingly. Lastly, this procedure updates the counters that the program uses to keep track of the occurrences of the Red, Black and the various Dozens and Columns. Pick Number Routine (Line 640) The Pick Number Routine controls the selection of a number to bet upon. This procedure calls three other routines: What Colour, What Column and What Dozen. Each of these subroutines returns the selection for that category. Therefore, once these routines have been called the program knows whether to look for a Red or Black number, if it should be in the first second or third column and which dozen should fall in. If any of the procedures fail to return a selection, then no bet is made (courtesy of line 690). This would happen if, say, the number of Reds that appeared is equal to the number of Blacks. Assuming a number is found on which to bet it is returned in the variable NOTOBACK% (Number to Back). If no suitable number is found this variable will contain -1. Print Routine (Line 740) The output produced from the Print Routine has already been described above. The most important thing it shows is the current level of the bank (MONEY%). Stats_1 and Stats_2 Routine (Line 1040 and Line 1340) These two routines have a similar function. They both show a screen detailing a breakdown of numbers. Stats_1 gives details of the numbers that were selected by the wheel. Each number is listed, together with the number of times that it occurred. Stats_2 shows a similar screen, but this time it shows the number of bets placed on each number. The main arrays and integers used in the program are detailed below. Arrays TABLE$: This array holds information about each number on the roulette wheel, that is, Colour, Column and Dozen. These details are read from the DATA statements at the end of the program. BET$: This holds the criteria for the ideal number to bet upon. Element one holds the colour, element two holds the column and element three holds the dozen. Therefore, if this array held R, 1, 3 the number we should bet upon would be Red first column and in the third dozen. If any item of this array is null (i.e. ) then no bet is made. The routines What Colour, What Column and What Dozen are responsible for updating this array. STATS1%: Every number that the wheel spins increments one item of this array. For example, if the number 14 comes up then STATS1%(14) is incremented by one. This array is used within the Stats_1 Routine. STATS2%: This array operates in a similar way to the STATS1% array but holds details of numbers that were bet upon. This array is used in the Stats_2 Routine. COLUMNS%: This array holds details of the columns that appear. For example, if the

44 number 14 comes up COLUMNS%(2) would be incremented by one as number 14 is in the second column. DOZENS%: This array performs exactly the same function as the COLUMNS% array but keeps track of the Dozens that have appeared. SCREEN1$: This array holds the headings that are used in Print routine. The headings are read from the DATA statements at the end of the program. Integers I%, M%, N% and R% are general purpose integers and are used for various functions such as loop control. RED%: This integer keeps a tally of the number of Red numbers that have appeared. It works in a similar way to the Dozens and Columns arrays. BLACK%: This integer records the number of Black numbers that have appeared, in a similar way to RED%. NULLBETS%: This integer is incremented every time no bet is made. NOOFBETS%: This integer is incremented every time a bet is placed. MONEY%: The MONEY% integer records how much we are currently winning (or losing) NOTOBACK%: This variable holds the number on which we will place our money. If it equals -1, no bet is made. WINS%: This integer is incremented every time we win. LOSSES%: This integer is incremented every time we lose. NOOFSPINS%: The NOOFSPINS% variable holds the number of spins we have told the roulette wheel to make. SPINCNT%: This is used to count the spins as they are made. NUM%: NUM% holds the number the wheel has just spun. It is essentially a random number between 0 and 36. Now all you have to do is run the program to see how our first system does in practice. Once you have a view of how successful the system is I would urge you to try one thing. Change line 490 from GOSUB 640 to NOTOBACK% = INT(RND(1)*36*100)/100. This will remove our system and make the picking of the number to place upon totally random. It will also make us bet every time, so you can expect quite a large outlay.

45

46

47 CHAPTER 4: A WAITING GAME I hope you found the time to test the program in Chapter 3. If you have run the program I would also hope that you have modified it, to experiment with your ideas. But most of all, I hope you found the results encouraging. I would hate to think you have been discouraged because you made huge losses (if indeed you did). The next system we shall consider is slightly different to the last one in that we are going to back two numbers at a time. We are still going to place chips on single numbers, but we are going to bet on two numbers at once. The question, as before, is how do we know which numbers to place our chips upon? We are going to experiment with the idea that if a number has not shown for a while then it must be due to come up. But we shall take the idea one stage further and work with two numbers. Once we know that two numbers have not appeared for a given number of spins we shall wait for them. When one of them shows, we back them both, but only for a limited period. When developing a roulette system it is important that we have some method that stops us throwing good money after bad. That is why this system backs two numbers, but only for a limited period. If we are still losing after that we have to consider the money lost. Once you have seen how this system works you might like to remove the safety mechanism. I would like to think it demonstrates that such a mechanism is needed. The probability part of the system comes into play as we will wait to see which numbers we should back. When you sit down at a roulette table you have no way of knowing which numbers have come up before, apart from a limited list that is displayed at many roulette tables. Therefore, it is impossible to base selections on, say, the last hundred spins. We could guess, I suppose, or we could make the assumption that the moment we sit down the laws of probability are perfectly balanced. This would be most unlikely, but we could make that assumption if we were keen to bet. Alternatively, we could record a certain number of spins so that we have some idea how probability is performing. Armed with this information we can start to bet, happy that we are at least doing something to try and beat the wheel. Before we describe the system more fully let us consider what we can expect when a roulette wheel spins. If we spin the wheel 37 times we could expect each number to appear once. Very unlikely to happen, but in theory, we might expect that to be the case. After 74 spins each number should have shown twice and after 111 spins we could expect to see each number three times. Would it be unusual if after, say 100 spins one of the numbers had not appeared at all? Or how about two numbers? In 100 spins would you expect to see all the numbers or is it reasonable for two numbers not to have shown? Assume for a moment that it is not unusual. When one of those numbers does show what are the chances of it, or the other number, coming up again? In short, is it worth backing

48 these numbers to see if they get probability back to some sort of order? And if one does come up, what then? Is it worth backing them again to see if they come up again? And then again? There are two ways to try out the idea. We can either go down to the local casino and put our money where our mouth is, or we can write a program to test the idea out. I don t need to tell you which method I favor. Before I introduce you to the program let me summarise the system we are going to test and also elaborate on how to deal with both wins and losses. We will spin the wheel until only two numbers remain that have not shown. If we have not reached a certain number of spins, say 100, we will continue to spin the wheel to see if either of the two numbers show. If we can reach our specified number of spins (say 100) with only two numbers remaining as no shows we shall wait for one of the numbers to come up. When that happens we shall bet on both numbers. We place one unit on each of the numbers. If they both lose we bet one unit again. We continue to do this for a certain number of spins. If after that number of spins we have not won we stop betting and consider the money as lost. If we win, we double our stake and continue betting following the same rules as above. If we lose n number of times we stop betting. If we win again, we double our stake once more (we are now betting four units). If we win this time we stop. If we lose n times in a succession we also stop betting. Just to make it crystal clear how the system works, let me give you an example of how it would work in practice. After 78 spins we reach a point where every number has shown except for two. As the number of spins is below our target we carry on spinning. If we reach 100 spins and the two numbers have still not appeared, we can enter the second phase of the system. If we had reached the 100 spins and one of the previously no show numbers had appeared we would treat that as a null sequence. In this case we would start again. We might arrive at a position where 100 spins have passed but we have more than two numbers that have still not appeared. In this case we would keep spinning the wheel until we had just two numbers that had not shown. We would then go straight to the second phase of the system. Assuming we have gone at least 100 spins and have exactly two numbers that have not shown we can enter the second phase of the system. We keep watching the wheel, waiting for one of the numbers to show. If the two numbers that had not shown were 14 and 26 we would wait for one of these numbers to appear. Only when one of them comes up do we bet. For example, if number 26 showed we would place one chip on both 14 and 26 on the next spin. We continue to bet on these two numbers for a certain number of spins, say ten. If we lose all ten bets we put the 20 units down to experience and start again. If, at any time, in those ten spins we win on either number, we double our stakes and start the sequence again. That is, bet two units on both numbers for up to ten spins. If we lose ten

49 consecutive spins, we cut our losses and stop. If we win, we double our stake for a further, and final, ten spins. If we win during these ten spins we stop and count our money. If we go ten spins without a win we also stop. The sequence ends on the four units bet whether you win or not. The problem we have is to decide how many losing bets we will allow before stopping betting. A small number of spins will stop our increasing too much, but may mean we miss out on wins that are a few spins in the future. On the other hand, if we set the spin limit too high we can lose a lot of money if one of our two numbers does not appear. To aid in your evaluation of the system I have allowed the program to have this factor varied at run time. I have, however, hard coded the number of spins the wheel makes whilst reducing the now show numbers to two. If you wanted to experiment with this variable you can change lines 420 and 630 to increase or decrease this value. The other change you could consider making is not to set MONEY% to zero during the lnit_2 routine (line 220). By removing this you will keep a running total of your bank instead of starting from scratch each time. If you run the program you will firstly be asked to enter a spin limit. This is the number of losing spins the wheel will make before the system stops. You will note that the Spin Limit Routine is called from within the Init_1 Routine. This means that once you set the Spin Limit, it will remain effective throughout the run of that program. If you wish to set the Spin Limit every time, you should move the call of this routine to the Init_2 Routine. Once you have entered the Spin Limit the program will begin to spin the wheel. This is done via the Initial Spin Routine which is called via the Game Routine. The Initial Spins Routine keeps spinning the wheel until only two numbers are left. Once this condition has been met the number of spins that have so far been made are displayed. Control is then returned to the Game Routine. The Game Routine now checks if 100 or more spins have been made. If not, the Extra Spins Routine is called and this spins the wheel so that 100 spins are made. Before leaving the Extra Spins Routine, a display shows how many numbers have yet to turn up. We are now in the position where we have made at least 100 spins and have two or fewer numbers left. The Game Routine checks on the numbers remaining. If this does not equal two the system will end by calling the No Bets Routine. It does this by checking to see if any bets have been made. The No Bets Routine displays a message informing the user that no bets were made. Assuming that we are in a position to bet, three routines are called: Get Numbers Routine, Wait for Numbers and Bet Control. The Get Numbers Routine searches through the TABLE% array and finds the two entries still set to -1. Initially all elements within this array are set to -1, but as each number appears the elements are set to zero. This is done within the Initial and Extra Spins routines. When the numbers have been found they are placed in elements one and two of NUMTOBACK%. The routine Wait for Number, as its name suggests, waits for one of the two remaining numbers to appear. When the number does appear the number of spins the wheel has made

50 is displayed. The Bet Control Routine is the third phase of the system. It calls the Bet Routine, passing it two parameters. BET% is used to tell this routine how much to bet each time. PHASE% is used for display purposes and shows you which phase of betting is currently underway (one, two or three). The Bet Routine controls the spinning of the wheel and decides if the bet is a winner or a loser. It also updates the variables needed to control this routine. Depending on the bets made, the Win and Lose routines are called. These update the money as well as a history of the winning and losing sequence. As you run the program you will see a display that is continually updated at the bottom of the screen. The left hand part of this display shows the winning and losing sequence. For example, LLLWLLLLLWLL means that there have been three losses, one win, five losses, one win and two losses. The right hand side of this display provides a continual update on the bank. The easiest way to see how the program works is to run it. The displays that are shown provide all the information you require to follow how the system is doing. The continual update of wins, losses and the bank is the most interesting piece of information. It will also provide a bit of excitement as you will find yourself willing a W to appear.

51

52

53 CHAPTER 5: STRIKE WHILE THE IRON IS HOT In the last chapter we investigated the idea of numbers getting back on terms with probability. To do this we backed numbers that had not appeared for a specified number of spins. There is another way of looking at this idea. Think about what is happening when a number (or more probably numbers) is sleeping. Other numbers must be coming up more than probability would suggest. To take a simple case, in 37 spins if every number showed except for one then another number must have taken its place. For example, if number 14 is the only number not to show then one of the other numbers, say 10, must have come up twice. If you had managed to back the number ten both times you would be showing a handsome profit. Of course it is not as easy as this. As we said previously, the wheel does not seem to obey the laws of probability, at least not in the short term. In 37 spins you would be unlikely to see every number once, similarly, you would be unlikely to see every number except one. But the fact that we do not see every number, no matter how many are missing, means that other numbers are appearing more than their fair share. If we can get in on the act and back these numbers, we might be able to walk away with more money than we had when we sat down. The problem is finding the numbers that are having more than their fair share of the wheel. To do this we need to watch the wheel and if we find a number that keeps coming up then we should back it for a certain number of spins to see if we can get one more win out of it. Whilst watching to see if a number is repeating it would also seem sensible to know that it has not appeared for a certain number before its first show. If we do not know that, we might think that the number is showing for the third time in 30 spins when, in fact, it might be showing for the fifth time in 35 spins. Another factor we need to consider is how long to back the number for. Do we back it five times, ten times, or more or less? Luckily we have our computer, so that we can experiment in order to answer this type of question. So, we have an idea for a system. We are going to try to back numbers that are having more than their fair share of luck and which we also know have not appeared for a certain number of spins before the first show. The program in this chapter tests this system. I describe below exactly what the system does, followed by how the program is structured. If a number does not show for a certain number of spins it is placed into a monitoring status. Once a number is being monitored, it is checked to see if it wins three times within a given number of spins. If the number does not win, monitoring stops and it must sleep before it can be monitored again. If the number wins three times it is backed to see if it can win once more. The number of times the number is backed is something we can experiment with. If no wins are recorded during these spins the money is lost and the number must not appear for n number of spins before being monitored again. If the number wins we will continue to back it for the requested number of spins. You never know, we might get another win.

54 To make it totally clear, consider this example. The number 12 sleeps for at least (say) 30 spins. When it finally appears we monitor the number for another, say, 25 spins. Within those 25 spins the number 12 must appear three times before we back it. It has already shown once, which put it onto monitor status, so we need another two appearances. If the number does not oblige, it is taken off monitor status and must sleep for another 30 spins before being monitored again. If the number shows three times in the 25 spins we start backing it in the hope that it will show again. If we lose all ten (say) spins we stop betting and the number must sleep further 30 spins before it is monitored again. If the number shows again, say on the fifth spin of the ten, we take our winnings and continue to back it for a further five spins. Once betting has stopped the number must sleep before being monitored again. You will see from the above description that there are three variables. These are the number of spins a number must sleep before being monitored, the number of spins a number is monitored for and the number of times a number will be backed. All these variables are asked for at the beginning of the program, along with the number of spins the wheel is to make. With the exception of the number of spins a number is monitored for, these values are displayed on the screen as a reminder to the user of the values that have been selected. This is done as part of the Initial Screen Routine. The wheel now starts to spin. As numbers are moved to monitoring status they are shown on the screen. If they come up three times they move from monitoring status to betting status. An area is reserved on the screen to display these numbers. Like other programs within this book, the bank (MONEY%) starts at zero and betting is made in units of ten. Therefore, each bet decreases the bank by ten units and a win increases it by 360 units (35-1 plus your returned stake). One important aspect of this program is the array BETCTRL%. It controls each number and decides if the number is sleeping, monitoring or being bet upon. Some explanation of this array will make the program a lot easier to understand. The size of the array is 36 x 5. This allows each number on the wheel to have five pieces of information stored against it. The first element of the array (BETCTRL%(n,1)) tells the program the current status of that number. -1 indicates that the number is currently not being monitored or bet upon. The status for a particular number will remain at -1 until it has slept for the required number of spins. When a number is being monitored its status changes to 0 (line 1100) and if it reaches the status of being bet upon, it will be given a status of 1 (line 1260). BETCTRL%(n 2) is used as a pointer to the next three elements. When a number is being monitored elements three, four and five are used to hold the spin numbers where the number appeared. Element two is used to point at the next available slot so that the program runs as quickly as possible. We need to store the actual spin as the program needs this information. It is not enough just to know that the number has appeared three times. We need to know when it appeared, or else we will not know when to stop monitoring. This may sound rather cumbersome but an example will, hopefully, make it clearer. At the beginning of the program the elements of the array will contain -1, 2, 0, 0, 0. Minus one shows that the number is not being monitored or bet upon, and the two is ready to point at

55 the third element. If the number sleeps for the required number of spins the minus one will be changed to zero and the spin number at which the number appeared will be written into element three. This is done by reading element two, (containing two) adding one to it and storing the spin number in that element. Finally, element two is re-stored so that it now contains three. This is all done within the Monitor Numbers Routine. Assuming that the number continues to show, this process is repeated. Finally, the number in element two will contain five. This indicates that the number has come up three times and should now be bet upon. In this case the status is changed to one (line 1260). By looking at the program you can see that the Monitor Numbers Routine updates the BETCTRL% array as and when required. It is a simple process for the Spin Wheel Routine to check each number to see if numbers being monitored should continue to be monitored, and also to control the betting. This is done at lines 1140 to If the status of a number is zero the Keep Monitoring Routine is called. This checks if the number has been monitored for more than the number of spins specified at the beginning of the program. If it has, then the BETCTRL% array is reset for that number (Reset Bet Control Routine). If the status of a number is one (i.e. being bet upon) the Bet Routine is called. This routine controls variables which are displayed later, including MONEY%, and it also works out when to stop betting. The variables used throughout the program are displayed on the screen using Update Screen Routine. The numbers that are being monitored and bet upon are shown. The current balance of the bank is displayed, followed by the losses and the number of wins. Finally, the last number to win is shown. The screen is updated after each spin and so provides a continuous update on how the system is performing. Now all you have to do is evaluate the system by running the program. You need to run the program a number of times, each time supplying different values at the beginning of the program. If you want to evaluate the program properly, you will have to run the program many, many times and record each result until you arrive at the optimum values. I could tell you the results I obtained from the system, but why should I spoil the fun and, more to the point, you should also have to endure the pains and sorrows of sitting up till the early hours watching the screen.

56

57

58 CHAPTER 6: DOUBLE OR NOTHING Many people consider the double or nothing system to be the perfect system and, at first sight, it might appear so. Let me give you the theory and see what you think. Take an even chance bet, say Red, and bet one unit on it. If you lose you are down by one unit. To put matters right, you place two units on Red. Overall, you have now risked three units, but if you win you will receive four units, giving profit of one unit. If this second bet loses you are down three units so you bet four units (making a total of seven units staked). If you win, you receive eight units and make an overall profit of one unit. The theory says that every time you lose you double your stake. When you eventually win you will get back all the money you have previously lost, along with a one unit profit. A perfect system? Let us take a closer look. If you start betting at one unit and keep losing, your stakes will double like this: 1, 4, 8, 16, 32, 64, 128, 256, 512 and so on. You can see that after nine losing spins you are placing 512 units on the table. Not only that, but your outlay so far will be 1,023 units. Admittedly, if you win you will get all this money back; but what if you lose again? You are now staking 1,024 units, with your total outlay being 2,047 units. And if you do win you will only make a profit of one unit. Can you say, hand on heart, that you can afford to risk 2,047 units in an attempt to win one unit? And of course you have no guarantee that you will win on this spin. You might lose again and have to bet 2,048 units, with your outlay totaling 4,095 units. Many people would argue that nine losses in a row would not happen, and you could expect to win before your stakes got too high. I can assure you that you cannot rely on this, but I do not expect everybody to believe me. What I would ask you to do is to run the program that forms part of this chapter. I hope it will show you that these adverse sequences are not uncommon. There is also another factor which works against this system. It is something called the house limit. Even if you have unlimited resources, enabling you to keep doubling indefinitely, there will come a time when the casino will stop you betting. This is because every casino sets a limit above which you cannot bet. At the casino it will be a monetary value but for our discussions we will say it is 511 units. This presents us with a problem when we have had nine consecutive losses. Our next bet should be 512 units but the casino rules state we can only place 511 units on the table. So we do? Do we forget the money we have bet so far? Do we bet at the house limit until we win? Or do we do something else? Walking out of the casino would probably be the best idea but that might be seen as defeatist. One thing is certain. Whichever course we choose we can almost guarantee we will lose money - and not just small amounts. The problem can be summarised by restating that whenever we win we only win one unit. When we lose we can lose a lot more. It can very easily be as much as the house limit. Still not convinced about the dangers of this system? Then I beg you to run the program before you try the system on an unsuspecting (and welcoming) casino.

59 The program asks three questions before it spins the wheel. It asks you how many spins would you like the wheel to make, which colour you would like to back and finally asks what you want to do once the house limit has been reached. The Number of Spins Routine is self-explanatory and is the same routine which appears in some of the other programs. The Which Colour Routine asks if you want to bet on Red or Black. It also sets a variable (OPCOL$) to the opposite colour to the one you choose. This is used later in the program for display purposes. The Option Routine asks what you want to do if, and when, the house limit is reached. You have three options. You can decide to keep doubling the stake as if no house limit was in force. This may be of interest if you wish to see just how much you might bet when you get an adverse run against you. Alternatively, you can keep betting at the house limit until you win. Or you can revert to a one unit bet. Within the program, the house limit is set to 31 units. This can be amended by changing line 190, so that you can experiment with different values. The Control Routine spins the wheel. It selects a random number and updates the various variables which are output later in the program. It decides on the number by looking at the array TABLE$. This contains 37 elements (0 to 36) which are read from DATA statements. Each element of TABLE$ contains either R or B, showing if the number is Red or Black. The only exception to this is zero, which is neither colour. When the spins have completed, the Stats Routine is called. This outputs a screen full of information which I hope you find interesting and informative. It tells you how much money was actually placed on the table. In some ways this figure is irrelevant but it does demonstrate the huge figures that we are dealing with, and all to win one unit. The next piece of information is more useful. It tells you the largest stake you placed on the table. Bear in mind that when this bet was made, no matter how large, all you were trying to do was win one unit. The next item on the screen tells you the largest adverse sequence that ran against you. You may think you can work this out as a bet of 512 units means an adverse sequence of nine. However, if you have chosen to bet at the house limit, or revert to a 1 bet then this may not necessarily be true. Finally, you are told how much money you have won or lost. When you run the program I hope it will show that you make huge losses. Not because I want you to lose money but because I want you to know how dangerous this system is so that you are not tempted to try it in a casino. You have been warned.

60

61

62 CHAPTER 7: THIRTEEN AGAINST THE BANK The problem with the system in the last chapter was that we were always chasing our own money. We lost it to the casino and then spent most of our time trying to win it back again. We can never totally overcome this. If we walk up to a roulette table, play and lose we are immediately trying to win our money back. Indeed, as soon as we put money on the table we are in debt. This is true of any system. What we can try to do, though, is to make sure we are making our larger bets when we are playing with the casino s money rather than making large bets in pursuit of our own money. At least if we lose, we are only giving the casino back what they had at the start of the session. One easy way to do this is to reverse the previous system by doubling our stake when we win. Therefore, we bet one unit. If we win we bet two units. If we win again we bet four units. If we lose we revert to a stake of one unit. The system might not win us money but it will stop us losing as much as a system that doubles our stake when we lose. The idea of increasing stakes after a win is the basis of many roulette systems. They nearly always operate on even chance bets, and not all of them double the stake. Some systems aim for a gradual increase, but all the time are trying to play with the bank s money when the stakes are at their largest. The system we are going to test goes by the name of Reverse Labouchere and it uses this idea of increasing stakes. If you want a first class description of this system I urge you to read a book entitled Thirteen Against the Bank by Norman Leigh. This book tells the story of how he took twelve people to France in 1966 and was banned from every casino simply for winning. As well as telling you how the system works, it is also an extremely enjoyable story. For those of you who do not have the book to hand here is my, inferior, description. The system starts with you choosing an even chance bet on which to bet. You need a pad and pencil, on which you write the numbers Your first bet is the total of the outside numbers; in this case 1+4=5. If you win you add the winning stake onto the end of the line. Therefore, the line will now say Again your stake is the end two figures added together (1+5=6). If you win you write 6 at the end of the line and your next stake will be seven units (6+1). You can see that as you win the stakes gradually increase. If you lose you somehow have to find a way of controlling your betting. To do this you cross out the two end numbers before calculating your next stake. If we continue our above example our line of figures currently says We place seven units on our chosen even chance bet. If we lose we cross out the two end figures so that we now have Our stake for the next spin will be seven units but, as we shall see, we are building

63 in some form of control. If we lose again our line of figures will read 3 4 and we again place seven units on the table. If we lose yet again we cross out the remaining two figures and have now crossed out all the figures. This means we have lost ten units. We know this as the figures we started with ( ) add up to ten. However, when we only had 3 4 left on our notepad if we had won we would have written seven at the end so that our figures would read making our next bet ten units. A loss on the next spin and our bet would be four units. A win and our next stake would be thirteen. That is all there is to it. All, that is, except when to stop betting and take our profit. We will be stopped anyway when our stakes reach the table limit. Let us say the limit is 512 units. Once the two end figures total more than 512 we cannot place that amount on the table and so we have reached the end of the sequence. At this point we write a new line of on our pad and start again. At any time we can work out how much profit we have made by adding up figures left on our pad. That is how many units we have won but we must take away ten units which represents our initial stake. Of course, we do not have to take the casino s house limit as the stop point of our system. We can set our own limit, and this will be one of the variables we can test with the program accompanying this chapter. Before I describe the program, and how it works, it would be worthwhile practicing the system so that you are totally familiar with how it operates. In order to help you to do this I have listed below a sequence of wins and losses. On a piece of paper write the figures By obeying the rules of the system outlined above see if you can operate the system so that you end up with the same results as I do. The sequence is as follows. W represents a win and L is a loss. W W W L W W W L W W L L W W L W L L W W W L W W L W W W After working through this sequence the numbers that are not crossed off should be 25,35, 50,75,100 and 125. This means that we are currently in profit by 400 units. You can calculate this by adding together the numbers and taking off ten, representing our starting stake. You should also be able to see that it is good to have a number of losses. This has the effect of deleting the smaller numbers from our pad. This enables us to make larger bet, which should mean that we reach the house limit more quickly. To give you an extreme example; if all the above spins had been wins (29 in total), although we would be in profit by 551 units our next bet would only be 34 units. If the run continues in this way it will take a long time to reach the table limit and enable us to take our profit. If the table turns against us, we are crossing out two numbers each time and it does not take long for the numbers on the notepad to all be crossed out. On the bright side

64 when, (and if), we do reach the table limit we will have a nice profit. If we have a few losses we might not win as much, but we should reach the limit a little more quickly. If you care to experiment with the system you will see that there is a balance between the number of wins and the number of losses. Too many wins and you find the stakes rise slowly. This is okay if it continues in this way, but a few losses and your line could be wiped out. This would be very annoying if you have been sitting there watching it slowly grow for the past hour or so. Alternatively, too many losses without winning spins at strategic points can wipe out line after line. And although you only lose ten units for each line that is wiped out, they quickly mount up if the losing spins heavily outweigh the winning spins. Which brings us nicely onto another benefit of the system. So far we have assumed that we are backing one even chance bet, but what is the effect if we back two even chance bets. And more to the point, what if the bets are the opposite of each other. Red and Black for example. The theory is that whilst you are losing lots of ten units on one bet, the other one is winning. More to the point, it is winning more than the ten units you are losing on the other even chance bet. The flaw in the system is that if both bets lose over a period of time, so that you consistently lose ten units on each of the bets. But is this likely to happen in practice? Bad news I m afraid; it is. The good news is that you only need the occasional winnings, that reach the table limit, to offset all the losses. If you look at our practice spins again you can see that our next bet will be 150 units. If we have our limit set at 199 units we only need two more spins to win before we take our profit. And if we manage that we will have an overall profit of 725 units. That winning sequence will allow us to have 72 losing sequences without going into debt. Enough of the theory. Does it work in practice? You will not be surprised to learn that there is a program to test the idea. It goes one stage further than the ideas I have described above. It does not back just two even chance bets, it bets on all six. In real life you would be unable to do this (unless you had a team of people, which is what Norman Leigh had in his book Thirteen Against the Bank) as you could not keep up with calculations, but it is simple for a computer program to do this, so it seemed pointless to confine our betting to just one or two even chance bets. I think the easiest way for you to understand the program is for me to give brief overview and then describe each of the variables and routines. At first sight it may look a little complicated but after you have read the descriptions you should find it understandable. When you run the program you will be asked for the number of spins you want the wheel to make, and the table limit. The table limit will accept a value between 31 and 1024.

65 Once a stake goes over this limit the sequence is considered as complete and the profit is taken. I have allowed you to input a table limit so that you can experiment with different values. Once the spins and the table limit have been entered an initial screen is displayed. This displays the table limit and also shows the different even chance bets. These are headings for the information that follows. Under each of these headings various counters are displayed, and these show how the different bets are performing. This information is described below. Wins and Losses This shows the number of times each bet has won or lost. Limit Reached This counter is incremented each time the bet reaches the table limit. It shows how many successful sequences you have had. Losing Sequences This shows how many times all the figures have been crossed out on the notepad. Each time this happens you lose ten units. Largest Bet This shows the largest bet on that particular even chance bet. It will always be below the table limit as you are not allowed to bet above this figure. No s on Notepad This shows the number of figures on the notepad. The more figures there are the longer you can expect the sequence to last. At times you may find that the betting is in the hundreds, but there are only one or two numbers on the notepad. This means that the sequence is in danger of petering out. If you are lucky it could just last long enough to reach the table limit. I can guarantee that this counter, along with the Next Bet counter (see below), will have you riveted to the screen. Money This shows the current state of the bank with regard to that particular even chance bet. As in other programs in the book the bank starts at zero, even though in real life you would start with at least ten units. Next Bet This counter shows the next bet that is to be made on that even chance bet. This counter is of particular interest when it is gradually increasing and getting near the limit. Eventually you will see the bet revert to five units. This means that either that all the numbers have been crossed off, or that the sequence has successfully reached the table limit. You can tell which of these is the case by looking at the Limit Reached figure. If this

66 counter was incremented then the sequence ended successfully. At the bottom of the screen you are shown the overall bank total, how many times zero has appeared and the current spin number. Main Variables NOTEPAD%(6,n): This array is used as our notepad. The six even chance bets are represented by one dimension of the array. The other dimension is DIM ed to the size of the variable NPSIZE%. This is done so that if you ever fill this array (and get a subscript error) by changing NPSIZE% the program will work again. I should point out that this was put in during early development of the program. I have run it many times and have never hit the array limits. In fact, during one of the runs I monitored how much of the array was used and it was rare for it to fill more than 15 elements. The 100 that have been set aside, therefore, should be more than enough. The even chance bets are represented by the first dimension of the array. These bets are set up in the following order. Even, Odd, Low, High, Red and Black. You will see that many of the arrays are DIM ed to have six elements. All these arrays are controlling or monitoring the six bets in the order given above. NPCTRL%(6,3): This array is used as a pointer to the main NOTEPAD% array. Element n,0 points to the first uncrossed number on the notepad. Element n,1 points to the last uncrossed number. Element n,2 holds the number of uncrossed numbers on the notepad. As an example, if this array held the following values: NPCTRL%(4,0) = 2 NPCTRL%(4,1) = 6 NPCTRL%(4,2) = 6 it would mean that the Red notepad array could hold the following values If you take zeroes as representing numbers that have been crossed off you can see that the first uncrossed number is in element two, the last uncrossed in element six and the number of uncrossed numbers is six. If you can understand how the NOTEPAD% and NPCTRL% arrays work, the remainder of the program will make more sense. BETCTRL%(6): This array is used to control whether each spin of the wheel is a winner or loser for the six even chance bets. After the wheel has been spun, this array is updated with zero or -1 to show if the bet won or lost. For example, if BETCTRL%(5) held zero this would show that the last spin resulted in a win for black. BIGBET%(6): This array is used to store the largest bet placed on each of the even chance bets. It will always hold a value less than, or equal to, the table limit. LIMITREACHED%(6), LOSINGSEQ%(6), LOSSES%(6), MONEY%(6) WINs% (6): All these arrays perform a similar function to BIGBET%. They are incremented when

67 certain conditions are met and are displayed after each spin. LIMITREACHED%(6): This array is incremented when a successful sequence comes to an end. LOSINGSEQ%(6): This array holds the number of times all the numbers were crossed off notepad. MONEY%(6): This array keeps a tally of the bank for the relevant even chance bet. LOSSES%(6): This array stores the number of times that a particular even chance bet has lost. WINS%(6) does the same thing, but records the number of wins. COLOURS$(36): This array holds the colour of each number. R indicates that the number is Red. B shows that the number is Black. Zero is assigned X as it is neither Red or Black. This information is read into the array from DATA statements held at the end program. DESC$(6): This array holds a description of the even chance bets. It is used to print headings on the display screen. These descriptions are held in DATA statements held at the end of the program. INDEX%: This integer is used throughout the program and is used to show which even chance bet is being referenced. It is used as a subscript to most of the other arrays. For example, if INDEX%=3, the Low bet would be in the process being updated. ZEROTOTAL%: This variable contains the number of times zero has appeared. TOTALMONEY%: This is a total of all the money from all the even chance bets. It is a sum of all the elements of the MONEY% array. TABLELIMIT%: This integer holds the table limit, its value coming from the question at the beginning of the program. NOOFSPINS%: This variable is assigned at the start of the program when the user is asked how many spins he/she would like the wheel to make. SPINCNT%: This variable contains the current spin number. It is used as a loop counter and increments from one to NOOFSPINS% Program Routines The routines Init_1, Init_2, Number of Spins and Table Limit are all self-explanatory and a glance at the code should be enough to see what they do. The routines from line 5000 are the standard routines you will find in many of the other programs and their functions have been described in an earlier chapter. Initial Screen Routine (Line 560) This routine displays fixed information which never changes throughout the running of the program. This includes the table limit and a description of the six even chance bets which are used as headings.

68 Reset Notepad Routine (Line 670) This routine is called whenever all the numbers on a notepad have been crossed out or when a successful sequence has been completed. Its function is to reset NOTEPAD%(x,y) and NPCTRL%(x,y) to their initial values. Game Control Routine (Line 760) This routine spins the wheel and works out which routines to call as a result of the number which appears. It does this by using the array BETCTRL%. It sets all six elements to -1. It then checks each of the six even chance bets and if they have won it sets the relevant element of BETCTRL% to zero. Once this has been completed, three elements will have been set to zero and three will remain at -1. This array is referenced again and the win or lose routine called depending on whether the array is set to zero or -1. After the Win and Lose Routines have been called the Update Screen Routine is called, and this displays the counters that I described above. You will see that. if zero appears all bets are taken as losing. This is done by setting all elements of BETCTRL% to zero before calling the Win or Lose Routines. Win Routine (Line 960) This routine updates MONEY%(n) and works out the new NOTEPAD% and NPCTRL% values. The previous bet is written to the next available slot in the NOTEPAD% array and NPCTRL% is updated so that its pointers are correct. Lastly, this routine checks if the next bet will exceed the table limit. If it will, the notepad is reset which has the effect of ending the sequence and allows us to take the profit. Lose Routine (Line 1050) This routine updates MONEY% and sets the two end notepad entries to zero. This has the effect of crossing out the figures on our notepad. NPCTRL% is next updated to reflect the quantity of numbers remaining on notepad. If this figure is less than one (indicating that all the numbers have crossed off) the Reset Notepad Routine is called. This is the end of an unsuccessful sequence. If we still have numbers on our notepad the routine Work Out New Notepad Figures is called. This routine looks through the NOTEPAD% array and resets NPCTRL% array. Work Out New Notepad Figures Array (Line 1140) This routine resets the NPCTRL% array. It searches through NOTEPAD% array looking for the first number and the last number. As it does this it counts up how many numbers remain and eventually stores this value in NPCTRL%(n,2). Update Screen Routine (Line 1230)

69 This routine is called after every spin and displays the various counters on the screen so that the user can monitor the progress of, the system. As I said earlier, the program may look rather confusing. This is due to the array processing as we are controlling six bets instead of one. The program is quite simple once you have got to grips with the array handling. But also bear in mind that it is a fully working program and provided that you understand the system you can run the program without having to understand its inner workings.

70

71

72 CHAPTER 8: SHORT AND SIMPLE Some of the roulette systems we have considered have involved spinning the roulette wheel many times. Sometimes we have waited, perhaps, 200 spins before even placing a bet. Assuming that the wheel averages two minutes for each spin you could find that half your evening at the casino is spent recording numbers instead of betting on them. If you prefer something a little faster then this system is the one for you. At most you will only ever have to wait three spins before starting to bet and a lot of the time you will only wait two. In addition, the system will only expect you to bet for, perhaps, 20 spins. This is dependent on the parameters you apply to the system, and with the help of the computer I hope you will find an ideal combination. The last factor in favor of this system is its ease of use. This system is about the only one in the book that is probably easier to operate manually than to program a computer to emulate. The only redeeming feature is that the computer version enables us to test many variations of the parameters. Once you have found the ideal way to operate the system you will find it extremely easy to operate at the casino. The system operates on the idea that if a pattern starts to emerge we can rely on it to repeat. Or at least repeat enough for us to make a profit. What do we mean by a pattern? As with so many systems, we are going to concentrate on even chance bets. If we see two colours appearing together we shall try to follow that pattern by betting on that colour. So, if two blacks appear, we shall bet on black. Similarly, if two high numbers appear we will bet that it will continue. The other pattern we shall look for is an alternation. This is where, for example, a red appears followed by a black followed by another red. If this happens we bet that this will continue; so we bet on a black, then red, then black and so on. So we only ever need three spins before we start betting. If the first two spins are from the same even chance bet, we bet on that state of affairs continuing. If three spins alternate on an even chance bet we bet on that sequence continuing. Another possibility is that the first two spins are different and the third is the same as the second. For example odd, even and even. In this we would bet on even as we have seen a sequence of two evens, despite the fact that an odd number appeared first. The only other thing that can happen is that a zero turns up before we have decided which bet to follow. In this case we forget what have seen before and start again on the next number. Knowing when to start betting is only half the story. We also need to know when to stop betting and how much to bet. We will stop betting after we have had a certain number of losses on a particular bet. How many losses is something we shall determine via experimentation. One of the questions you are asked at the beginning of the program is how many losses are allowed. The question of staking is a little more difficult. Not only do we have to consider what our starting stake should be but also what we should do after a loss and after a win. The program allows you to input a starting stake and validates that it is greater than zero. The next two questions ask what you would like to do after a win and after a loss. In response you can enter a value between 100 and The value you enter

73 is added to the stake once the program has worked out if the spin won or lost. By entering a negative number you are decreasing the stake. Let me give you an example. Assume that you decide on a starting stake of ten, a value of three to be added after each win and a value of minus one to be added after a loss. If your first bet is a win your next stake will be 10+3=13. If it is a loss your next stake will be 10+ (-1)=9. Whatever your ideas about increasing stakes after winning or losing, this program will enable you to test your ideas. You can even enter zero, which means that your stake will remain the same. The program which tests this system, like all the programs, is available from the web site that accompanies this book. You will be asked four questions when you run it. The first question is how many losses you are prepared to take before you stop betting. When I first heard about this system it was recommended that you stop betting after only one loss. This seemed a little short sighted to me, so I decided to allow the number of losses to be a variable rather than having it hard coded. During my tests I sometimes found it beneficial to only allow one loss, but on many occasions I have made a profit when allowing for three or four losses. Your own tests will give you your preferred value. The only advice I would offer is not to allow too many losses before you stop betting. Doing this, in some ways, defeats the object of the system. The next three questions ask about your staking habits. You must first enter your starting stake. This is not the initial balance of your bank but the number of units you place on the table for your first bet. As with other systems in this book, the bank will start at zero so that it is easy to see if you win or lose. You are now asked what to do after a win. The value you enter can be positive or negative and will be added to the stake after a win. The final question asks what should happen after a loss. Just as is the case after a win, you can enter a positive or negative value. The four routines which ask these questions are all called from the Init_2 routine. The code for all these routines is straightforward and is similar to the Number of Spins Routine that appears in many of the other programs. The next routine that is called is the Initial Screen Routine. This routine displays the values that have just been entered as a reminder to the user. Headings are also displayed, under which information will be displayed as it becomes available. Before discussing the other routines, it would be worthwhile looking, in detail, at one of the arrays used in the program. BETCTRL%(3,7): This is used to control many aspects of the program. The first dimension represents the three even chance bets. They are used in the order: Even/Odd, High/Low, Red/Black. The seven elements in the other dimensions have the following uses. Element 0 - This shows the current state of that even chance bet with regard to betting. A value of -1 tells the program that the betting has stopped. This means that it has had the number of losses specified at the beginning of program. A value of zero indicates that the even chance bet is not yet betting. This will be the value when we are waiting for a pattern

74 to emerge. If the value is 1 it shows that we have seen a repeating sequence and that we are following the same bet. For example, we might have seen two red numbers. If we see an alternating sequence emerge we set the value to 2. This tells the program to alternate the betting between the two types of bet available on that even chance bet. Element 1 - This element is used as a pointer to elements 4, 5 and 6. See below for more details of its use. Element 2- Not Used. Element 3 - This holds the number of losses for the particular even chance bet. When it reaches the value specified at the beginning of the program betting stops on that particular even chance bet. When that happens, element zero is set to -1. Elements 4, 5 and 6 - These elements hold the last three spins for that particular even chance bet. The program knows which element to store the spin in as it uses element 1 as a pointer. Element 1 initially contains a value of 4 (set in the Reset Routine) and is incremented as each number is stored. We only need three elements to store the various spins, as by that time we will be able to work out whether we have seen a repeating or an alternating sequence. The spins are stored in such a way as to give each of the even chance bets a value. Even, High and Red are assigned a value of one. Odd, Low and Black are given a value of two. Therefore, if the first spin is red then BETCTRL%(2,4) will be given a value of one. Assigning values in this way makes it easier to look for the various sequences. If elements five and six are the same, we are seeing a repeating sequence. As an example, if we have seen two blacks, elements five and six will both be equal to two. In this case we can set element one of BETCTRL% to one, which means that next time we will start betting. This is the purpose of the first two statements in the Work Out Bet Routine (lines 1380 and 1390). If elements five or six add up to two or four we know that we are seeing a repeating sequence. If elements five and seven are the same we know that we are seeing an alternating sequence. This must be the case because if elements five and six had been the same we would never have got to the position where we had a stored value in element seven. You can see this is the purpose of the third statement of the Work Out Bet Routine (line 1400). The only other thing that can happen is that we have a repeating sequence that happens on the second and third spin. The last statement in the Work Out Bet Routine (line 1410) caters for this situation. To consolidate what you have read above you should be able to understand the following: BETCTRL%(2,1) = 1: This means that we are currently betting on a repetition type of bet on the High/Low bet. BETCTRL%(1,2) = 6: This means that the next spin for Even/Odd will be stored in element six. BETCTRL%(3,4) = 3: This shows that we have had three losses on Red/Black.

75 The final point I should explain about the BETCTRL% array is, once we have worked out which type of sequence we have seen, how we determine which type of bet to back. If we know that we have seen a repeating sequence we can find out which bet to back by looking at element six. No matter how the numbers have repeated we can be sure that the bet to follow will be stored in this element. If we had a repeating sequence on the first two spins the second spin will be stored in element six. If the repeating sequence occurred on the second and third spin the spins will be stored in elements six and seven. So, no matter how the repeating sequence manifested itself we know that the bet to follow will always be in element six. If you look at the first statement in the Back Same Bet Routine (line 1490) you can see the program using element six to determine whether it has won or not. When we have seen an alternating sequence we can use element seven to determine our bet. As an alternating sequence always takes three spins to show itself, the last spin, which showed it to be an alternation, must be stored in element seven. We can use this element to flip between the two bets and then check if we have won. The first statement in the Alternate Bet Routine (line 1530) performs this switching between the two states, with the rest of the routine working out whether we won or lost. You will note that the routine performs a switch when it is first entered. This is so that the first time it is entered we back the correct even chance bet. For example, if we have seen Red, Black and then Red this will be represented in elements five, six and seven as 1,2,1. When we make our first bet we therefore need to back Black which is represented by a two. By switching BETCTRL%(3,7) to two on entry to the Alternate Bet Routine we ensure that we are betting on Black and not Red. The next time the routine is called the switch will be reversed we bet on Red. As with the previous program, if you can understand the BETCTRL% array the rest of the program will fall into place. The following explanations will explain some of the routines not already discussed. Game Control Routine (Line 990) This routine controls the program whilst we are still in a position to bet. Once the variable STOPBETTING% is set to minus one the program ends and asks if you want to play again. This is done when BETCTRL%(n,1) = -1. This happens when all the even chance bets have had the specified number of losses. The other main function for this procedure is to spin the wheel (via the Random Number Routine) and decide whether to make a bet or continue to monitor the numbers. This is done within the loop at lines 1050 and After each spin of the wheel the Update Screen Routine is called. This routine, which is explained below, displays the current status of the system. Classify Numbers Routine (Line l130) This routine classifies each number that appears and stores the result in the NUMCTRL%. Element one of this array is used to indicate if the number is even. A value of one shows that the number is even. A value of two shows that the number is odd. Elements two and three perform a similar process for High/Low and Red/Black. If the wheel throws up a zero all elements of this array are set to zero.

76 Monitor Bets Routine (Line 1200) This routine controls element two of the BETCTRL% array. This is the element that is used as a pointer to elements five, six and seven. It also calls the Work Out Bet Routine if element two of the BETCTRL% array contains a value of six or greater. When this condition arises we are in a position to start looking for a sequence. Reset Routine (Line 127O) This routine sets the BETCTRL% array to its initial value. All elements are set to zero, except element two which is set to five. This is to ensure that it is pointing at element five ready to store the first spin. Work Out Bet Routine (Line 1370) This routine looks at the spins that have taken place and works out the sequence. The way the routine does this has been described above. Bet Control Routine (Line 1440) This routine is called from within the Game Control Routine. It is called when bets are being made on a particular even chance bet. The only function of this routine is to look at element one of BETCTRL% and decide whether to bet on the same bet again, or to bet in an alternating manner. Back Same Bet Routine and Alternate Bet Routine (Line 1480 Line 1520) Both these routines have been described above. Win and Lose Routines (Line 1570 and 1640) As their name suggests, these routines are called if the last bet won or lost. Both these routines increment counters that are displayed later in the program. They also make the necessary adjustment to the bank and work out the next stake. If either routine finds that the next stake will be below zero the stake is set back to the initial stake you entered at the start of the program (lines 1610 and 1680). The lose routine also increments element four of BETCTRL%. If this counter becomes equal number of losses you specified at the start of the program, betting is stopped by setting element one of BETCTRL% to minus one. Update Screen Routine (line 1730) This routine is called after each spin. It displays counters that are updated during that spin. The information shown is as follows: Each type of bet is listed and it shows the current status of that particular even chance bet. Each bet can be in one of four states. These are: not yet betting, betting on the same bet, alternating between the even chance bets, or stopped betting. You are told how many wins and losses that even chance bet has suffered, as the current value of the bank. You are also shown what the next bet will be. The bottom of the screen shows the total value of the bank and the numbers that are appearing. The remaining routines are the standard routines that appear in every progam.

77

78

79 CHAPTER 9: TAKE A TIP FROM THE EXPERTS In an earlier chapter I said I had my doubts about developing a football system that relied on us inputting the football results. The problem is not the type of system we would end up with, but the fact that we have to input and access so much data. In case you are still not convinced let me give you a few figures that might persuade you. If, after that, you still think that a database is the way to go then you have my best wishes, but I will not be joining you! Take a look at these figures. It shows the information we might want to hold. Table 9.1: Suggested data for a football system Data # of bytes Team Name 20 League Indicator 1 Results of a Match Home Score 2 Away Score 2 Home Team Indicator Away Team Indicator 3 3 Date of Match 5 The team name and league indicator would only be entered once. The result of a match information would be needed for every match that is played. In chapter one I suggested that you might want to monitor eight leagues with an average of 20 teams in each. That is a total of 160 teams which require a total of 3,360 (21x 160) bytes to store the team names and league indicators. The number of matches played in a season would total 3,040. For each of those matches we are going to store 15 bytes. In total that takes 45,600 bytes. Add that to the fixed information and we arrive at a total number of bytes needed as 48,960.

80 If you convert this to actual disk space required it is not all that much. In fact, it would easily fit onto one 1.2 megabyte floppy disk. But when you consider the problem more closely, you can see that it may not really be such a small amount of data. If we assume that the football season is eight months long this gives us about 240 days when football is played. On average we will have to input about 200 bytes of data each day. Not only input it, but back it up, access it and use it in our prediction process. The equation is further complicated by the fact that there will not be the same number of games played every day. We know that the majority of games will be played on a Saturday, and if every team plays we will have to input 80 results, or over 1,600 bytes. You may think that you can cope with that, and indeed you may be right, but if you have to do it week in week out you may find that it becomes a little tedious. There is also the problem that you may want to store more information than I have shown above. You might want to record the results of cup matches as well as league matches. I do not know how many games are played in the various cup competitions, but I would not be surprised if it increased your data by 50%. You may also want to store other leagues, or store data such as crowd attendance or weather conditions. All add to the data input problems. Some would argue that all this is worthwhile if you win a first dividend. I would be the first to eat humble pie if this happened, but I would want something more than a hope before I gave up a large chunk of my life in pursuit of it. Lecture over - at least until we reach the horse racing section. For now we will assume that we do not want to input a lot of data but would still like to win the football pools. One avenue worth investigating are the professional tipsters. They, after all, earn their living by telling us how the teams are going to do that weekend. You will find their predictions in nearly every national newspaper, normally on a Tuesday. A football match, as far as the pools companies are concerned, can have four possible outcomes. These being a no score draw, a score draw, a home win and an away win. For some strange reason, some of the pools tipsters only give predictions for a draw, a home win and an away win. They do not differentiate between the two types of draw. I can only assume that this is due to the difficulties that this type of prediction poses. Some tipsters do put their necks on the line though, and try to decide if match will result in a goalless draw, or if both teams are likely to get on the score sheet. Whichever type of tipster you follow, the system we develop must cater for both types of predictions. The only constraint the system will have is that you can only process one type of prediction at a time. Therefore, you cannot process one tipster who predicts no score draws and score draws with another who only predicts draws. System might be the wrong word for the program that we are going to look at, it is really an analysis. The analysis we are going to perform is to look at the tipster s predictions and see how they compare against the actual results. The aim is to find a tipster who regularly outperforms the others, or a mixture of a number of tipsters who

81 have their own areas of speciality. For example, you might find one tipster who finds a high percentage of home wins, whilst another finds a lot of away wins. Or we might find predictions where all the tipsters agree and turn out to be correct a lot of the time One thing is certain, we are going to need data to work on. Unfortunately, we cannot simulate the data, as we could with roulette. The data we require is in two parts. We need the tipsters predictions and we need the results. It would seem sensible to hold this data in two files. The results file will simply be a file containing one record of a certain number of characters. The number of characters is dictated by the number of matches on the pools coupon. This is currently 58, but as this could change a variable (NOOFMATCHES%) is used to hold this value. This is set at line 140. Each character in the record represents the result of one match. The following characters are used to indicate each result 1 = Home Win 2 = No Score Draw 3 = Score Draw A = Away Win You will notice that, with the exception of the away win, the results are represented by the number of points the pool companies give to each type of result. The reason we use an A to show an away win is because the pools companies give that result a value of one and a half points. 1.5 cannot be held in one character, so we chose a single character, in this case A. When I created the results file I used the built in editor available on my version of DOS, but I also tested the program using the COPY command specifying the input file as CON (e.g. COPY CON A: RESULTS). This saved me having to write program to do a job which, quite honestly, was not worth the effort. The easiest place to get the results is from any Sunday newspaper. They all have a coupon check list which gives each match with the result expressed in the way that I have outlined above. The only conversion you may have to make is to change an X which is sometimes used to indicate a score draw, to a 3 and 1.5 to an A. The tipsters file is similar to the results file, but differs in two ways. Firstly, it can contain more than one record. Each record will represent one tipster s predictions. The second difference is that the records are 60 characters long instead of 58 (assuming NOOFMATCHES% = 58). The first two characters of each record are used to identify the tipster, and displayed on the screen at the end of the program. The next 58 characters are predictions and follow the conventions given above.

82 When you start the program the first question you are asked is whether the tipsters separate score draws and no score draws. In reply you can type Y or N (in upper or lower case). You are next asked for the name of the file holding the results information, and the name of the file containing the tipsters predictions. The three routines that ask these questions are the Confirm Draw Routine, Get Results Filename Routine and Get Tips Filename Routine. Once you have answered these questions the Open Files Routine opens the two files you have specified. The Validate Results File Routine, as its name suggests, validates the results file. The result record is read into a string RESREC$) and is validated to ensure that its length is equal to the figure held in the NOOFMATCHES% variable. It is checked to ensure that it contains valid characters (i.e. 1, 2, 3 and A). If an error is found a suitable message is output and the program terminates. As the characters are validated, the number of home wins, away wins, etc. are accumulated. These figures are used in later calculations. It is during this routine that your answer to the first question is taken into consideration. If you said that your tipsters distinguish between score draws and no score draws, no action is taken. If, though, your tipsters only predict draws and make no attempt to separate the two types the results record is changed to take this into account. This is done by changing any no score draws (indicated by a 2) to a score draw (shown by a 3). As your tipster records will only contain 3 s this will have the effect of matching their predictions against any draw as there will now only be 3 s on the result record. This change takes place at line The Control Routine controls the rest of the program. It reads each tipster record until either the end of the file is reached or until eight tipster records have been read. I have limited the number of tipster records to eight as this is the maximum number of records that the output screen would comfortably accommodate. You can easily change this routine to allow more than eight records to be processed, but you will also have to do some work on the screen that is eventually displayed. Before calling any other routines, the Control Routine checks if it is reading the first tipster record (line 220). If so, it initialises the array AGREEDRES$ by reading the first tipster record into it. This array is used to indicate matches where all the tipsters agree on the result. After the first record has been read into this array subsequent records are compared against it. If they agree, that element of the array is left intact. If a difference is found the element is set to Void. This processing is done at line 370. Once all the tipster records have been processed any elements not set to Void are the matches that all the tipsters agree on. I thought it would be a good idea to store this information as we might find that matches where all the tipsters agree are ones worth betting on. The Control Routine now calls the Validate Tipsters Routine. It checks that the record length is equal to the value held in NOOFMATCHES% plus two. This ensures that it

83 contains the correct number of predictions, with a two-character header that identifies the tipster. If the record is not the correct length the Error Routine is called, and this prints a suitable message and terminates the program. The Stats_1 Routine, which is the next routine called from the Control Routine, firstly stores the tipster s identifier in the array NAMES$. The routine then performs further validation on the tipster records. It checks that the record does not contain any invalid characters (line 350). In performing this validation the string NSD$ is used. This was built during the Confirm Draw Routine which asked if you separated between score draws and no score draws. The effect of using this string is to make 2 a valid character only if your tipsters predict no score draws separately from score draws. The Stats _1 Routine finally compares the actual result against the tipsters prediction (line 360). If the results match the Correct Results Routine is called. This keeps a count of the number of results that the tipster has predicted correctly; broken down into the four types of result. An overall count is also stored in the array COUNTER%. The penultimate routine to be called is the Work Out Percentage Routine. This takes each type of bet, for each tipster, and calculates the percentage that he/she has predicted correctly. The way this calculation is done is to take the number of homes (for example) that a tipster has predicted correctly and calculate that figure as a percentage of the number of results that ended in home wins. For example, if 28 of the games had finished as home wins and the tipster predicted 14 of them he would be awarded a score of 50%. This calculation is performed for each type of result and for each tipster. The total number of games predicted correctly is also calculated. Finally, the Output Routine shows three types of information. The top part of the screen displays the results. This is shown as the number of homes, aways, no score draws and score draws. This part of the screen is built between lines 510 and 590. The middle part of the screen shows how successful each tipster was. Headings are displayed first. This is done by lines 600 to 710. Under these headings the statistics for each tipster are shown. Each type of result is shown both as the number of games and as a percentage. Lines 720 to 850 perform this function. The last part of the screen gives details of the marches in which all the tipsters agreed. Two lines of numbers are printed across the screen which represent the coupon numbers (lines 860 to 950). Under these numbers the matches where the tipsters agree are displayed. If nothing appears under the coupon number it indicates that the tipsters are not in agreement. If a character appears it shows that the tipsters are in agreement. The character which is displayed shows which type of result is predicted. For example, an A would show that all the tipsters think the match will end as an away win. The information for this display is taken from the AGREEDRES$ (lines 960 to 1000). Finally, under the predictions an asterisk or a space is printed. An asterisk shows that the result of the match ended as the tipsters predicted. A space shows that the result of the march was not as the tipsters hoped.

84 When you use this program you may be surprised at the results. Before you use it guess what percentage of results you think the professional tipsters will predict correctly. You might be in for a shock (pleasant or otherwise).

85

86

87 CHAPTER 10: LONG DIVISION When I ran the program in chapter 9, I must admit to being rather surprised by the results. I will not spoil things for you by telling you why I was surprised. If you want to find out why you will have to run the program yourself. The one problem with following the tipsters is that if we do win a first dividend we are likely to be sharing it with a number of other people. This is due to the fact that there are likely to be other people who are following their advice and putting X s against the same numbers that you are. The system in this chapter allows us more flexibility in that we are going to have to do a bit of decision making ourselves. If you like the ideas outlined in this chapter you could extend the program to make the predictions for you, but as it stands it will simply give you information, with the last stage being down to you. The system does an analysis of the league tables. This means that you have got to key them on. I know what you are thinking, that after all that I said at the beginning of the last chapter, here I am telling you to key in vast amounts of data. I accept the criticism, but let me say something in my defense. All the data input can be done in one step. Therefore, you could sit down for an hour on Sunday morning and do the whole lot. You do not have to input data every week. We are not accumulating data, just keying it in when we want it. So, if you want to miss a couple of weeks, you can do. When you come back to it in a few weeks time you will not have any data to key in to catch up. Finally, the data is easily accessible. It is all in one place and all leagues will be shown in the national papers. If, one week, the HFS Loans League forms part of the league coupon, this league should be found in at least one of the Sunday papers. The system splits into three main parts. Part one is the data input and will prove, I am afraid, to be the most tedious part of the system. Once the data has been input you can do one of two things with it. You can either display the data in the form of a league table, or you can compare two teams to try and decide who will win. During a normal week you would key in the data for one league and then compare the teams that are playing against each other. Once you had completed one league you would enter the data for the next league, and so on until you had analyzed every match on the coupon. If teams from different leagues are playing each other, in, say, the FA Cup, there is no reason why all the teams cannot be entered as one big league and the matches compared from there. The only limit on the number of teams that can be entered is controlled by the variable NOOFTEAMS% which is set at line 140. This is currently set to 50, but you can set it to whatever value you require. The only restriction is the amount of memory available as NOOFTEAMS% is used DIM two of the arrays in line 150. When you enter the data you have to input all the data shown in a national newspaper with the exception of the number of games played and the number of points. These two pieces of information are calculated by the program. You can see the questions you are asked in the DATA statements at lines 7140 to 7240.

88 In addition, you are asked, at the beginning of the program, how many points teams are awarded for a win. This is asked because in Scotland the teams only get two points for a win. In England three points are awarded. We obviously need this information when we are calculating the number of points. The Data Input Control Routine is responsible for collecting the data. Before passing control to the League Table Data Input Routine it asks for the name of the team you enter. If you enter end or the number of matches entered reaches the limit held in the NOOFTEAMS% variable, the data input phase of the program terminates (see line 410). As well as accepting the next team the routine also displays, near the top the screen, the last team that you entered. This is done in case you forget where you were up to (lines 420 to 440). Once a team name has been input the League Table Data Input Routine is called (line 500). This routine loops round each of questions held in the array QUES$ and validates that the answer is zero or greater. To aid the data input as each question is answered the reply is redisplayed so you do not forget where you are up to. When you have finished entering the data (by typing end to the team name) the league table is built via the Build League Table Routine. The table is held in the array TABLE%. The first dimension of this array controls the teams that have been entered. Therefore TABLE%(3,n) holds information regarding the third team you entered. The second dimension of the array holds the table data. The element (TABLE%(3,n) holds the total number of games played. The last element (TABLE%(n,12)) holds the number of points that team have won. The elements in between (2-11) hold the information you previously entered. The purpose of Build League Table Routine is to calculate the values of the first and last elements (i.e.1 and 12) using the information you supplied. Once the tables have been calculated the Control Routine is called (line 80). This is simply a menu which gives you three options, these being T, C or E. If you choose T, the league table will be shown. Each screen will show 14 teams, and if there more to follow the message more follows will appear at the bottom of the screen. Pressing the space bar will show the next screen, with another 14 teams displayed. The routine that controls the displaying of the league tables is the Display Table Routine. If you look at it the coding may appear rather complicated, but most of code is concerned with controlling the number of lines that are displayed so that the screen does not scroll. From the menu shown as part of the Control Routine, if you choose E you will exit from this section of the program. You will be asked if you want to play again (Ask Question Routine). If you say yes you will be able to enter another league. Answering no will exit the program completely. The remaining choice on the menu is the C option. By selecting this option you compare two teams. This option is controlled by the Compare Teams Routine. This calls the Get Team Name Routine, once with the variable IND% set to one, once with IND% equal to two. This is done under the control of FOR/NEXT loop. The Get Team Name Routine asks for the home team (when IND% = 1) and then the away team (IND% = 2). When you have entered the team name a search is made through the array TEAMS$ until the team is found. The element at which the match was made is stored in TEAMIND%(I) for the

89 home ream and TEAMIND%(2) the away team. If a team name that cannot be found is entered a suitable error message is displayed and you are asked to re-enter. Assuming that the teams you entered are found, the Home/Away Stats Routine is called. This is done from the Compare Teams Routine and, similar to the Get Team Name Routine, is called twice under the control of a FOR/NEXT loop using IND% as a control mechanism. If we are calculating the statistics for the home team IND% will be equal to one. In this case we base our calculations on the home information which is stored in elements two to six of the TABLE% array. For example, the home information for the first team you entered will be held in TABLE%(1,2) to TABLE%(1,6). If IND% is not equal to one (and therefore equal to two) we must be calculating the away team. In this case a pointer is set to point at the start of the away information within the league table array, i.e. elements seven to eleven. This decision is made at line The remainder of this routine calculates the statistics that will eventually be displayed. Line 1700 adds together the games played at home to arrive at the total played at home. Line 1710 calculates the percentage of games won at home. For example, if the team had played 12 games and won three they would score 25%. Lines 1720 and 1730 perform a similar function but calculate the percentages for the Draw and Lost games. Line 1740 works out the average number of goals scored whilst playing at home. If a team had played seven games and scored 21 goals they would have averaged three goals per game. Line 1750 does the same thing as line 1740, but calculates the average number of goals scored against the team whilst playing at home. The same calculations are also performed for the away team. This is done the second time the routine is called when IND% equals two. You should also be able to see that throughout these calculations the variable TEAMIND%(IND%) is used to point at the correct team. This was set during the Get Team Name Routine. When the Home/Away Stats Routine has finished, control is returned to the Teams Routine. The last function performed by this routine is to display the statistics on the screen. Again the control is in two parts controlled by a FOR/NEXT loop. The top half of the screen shows the statistics for the home team with the bottom half showing details of the away team. By using this program you will find it very easy to compare the relative merits of two teams. By merely looking at their home and away record you might be able to spot some surprise results. Even if you are sceptical about this system I urge you to try it for at least one week. And just for fun, make a prediction for each match based on the information that the program gives, and see if, together with your judgement, you can do better than the professional tipsters.

90

91

92 CHAPTER 11: AVERAGES WILL OUT? Some people think that the law of averages plays a part in the football pools. They argue that each of the coupon numbers should yield the same proportion of results over a given period. As there can be four results to a football match (home win, away win, score draw and no score draw) it follows that each result should happen once every four weeks. You could argue that a home win is more likely due to home advantage and that a score draw is more likely than a no score draw, but the theory stays the same. Each type of result should appear a proportionate number of times against each number. We could probably go further than that and say that if a coupon number has had, say, three draws in a row it has less of a chance of being a draw the following week. Alternatively, you could argue that the draws form part of a sequence so a draw is more likely. Whatever your opinions about these theories, they are at least worth investigating, if for no other reason than to prove that they are wrong. I advised you in the last chapter to try the system and see if you could do better than the professional tipsters. I would advise you to do the same with this system. Try it for a couple of weeks to see how you fare. You can place your own interpretation on the figures the program gives you, and if you come up with a suitable selection process you could amend the program to actually make recommendations. This program is another analysis program. This time, our base data is the coupon check numbers. You can find these in any Sunday newspaper and most Monday papers as well. The coupon check numbers represent the result of each match in the way that the pools companies judge the result In fact we are going to use the same representation that we used in chapter nine. This is as follows: Table 11.1: How results are represented 1 = Home Win 2 = No Score Draw 3 = Score Draw A= Away Win Each week s results are held as one record in a file. The file can have as many records as you have collected. You can see that there is very little data collection. In fact, only 60 characters a week. Each record in the file is actually sixty six bytes long. The first eight bytes are used as a reference. You can place any characters you like in these bytes. During my tests I used them to hold the date (in the format DD/MM/YY). These eight reference bytes are not used by the program at all, not even for display purposes, so you are free to use them for whatever purpose you like.

93 To create the results file you can either use a word processor that saves the file as text (i.e. with no control characters), a text editor (such as the one supplied with some versions of DOS) or the COPY command. Once you have created the file, you only need to add to it each week, a task which should take no more than five minutes. When you run the program you are asked for the name of the file holding the results. Once you have entered it the program will process the file and then give you a menu from which you can select one of three choices. The first choice (L) displays the coupon numbers in two columns. Next to each number are the last ten weeks results for that number. For example, the display: 10 AA12223A33 shows that coupon number ten has had two score draws in the last two weeks. Previous to that it ended in an away win and before that another score draw. You could decide that as this coupon number has ended in a score draw for the two weeks, it is likely to do so again. Or maybe you think it will not be a score draw as it is due to change. That part of the system is up to you, but further analysis may help you decide which is more likely. Pressing the space bar will return you to the main menu. If you choose the N option you are shown how many weeks have passed since a certain result has come up for that number. Each of the four results is reported upon. For example: Table 1l.2: Example display from Number of Weeks option No Home Away Draw NSD shows that number ten has gone two weeks without hone win, three weeks without an away win, last week was a score draw and ten weeks have passed without a no score draw. You might deduce from this that a no score draw is due or that another score draw could be on the cards. Again, further analysis might show you which is more likely. The last option on the menu is the Percentage Figures (P) option. This again shows the coupon numbers and shows the four types of result expressed in percentages. For example, if you had been collecting data for ten weeks and coupon number ten had resulted in the following results: Table 11.3: Example data before percentage calculations Homes = 5 Aways = 2

94 Draws = 1 NSD = 2 The display from the P screen would look like this Table 11.4: Example display from Percentage option No Home Away Draw NSD If you run the program on a reasonable amount of data (say 15 weeks) you should be able to start building a picture as to how the average coupon number looks. By judging other coupon numbers against it you should be able to see which numbers are deviating from the average. The decision you have to make is whether you think they will start to compensate to bring it back to the average. The program supplied here is a full working program. There is a lot of potential for development, though. If you agree with the idea that the pools numbers have some bearing on future results you could change the program to actually give you a list of predictions. I have listed the main routines below to assist anybody who wants to develop the Program further. Control Routine (Line 140) This routine is the main control of the program. It calls the other main routines as they are required. After asking for the filename and opening the file, both via other routines, this program loops through the Read Next Record and Process Record Routine until the end of the file is reached. Read Next Record Routine (Line 360) This routine increments a counter to keep track of how many records it has read, reads the next record from the results file, and also displays this value on the screen. Process Record Routine (Line 420) This routine is called for every record that is read. It performs three functions. Lines 430 to 460 validate the record. First the record is checked to ensure that it is the correct length. This is done by ensuring that it is equal to the variable NOOFMATCHES% plus eight. This allows for the coupon numbers and the eight byte header on the front of each record. The validation at lines 450 and 460 checks that the record does not have any invalid characters within it. If any character other than 1, 2, 3 or A are found, the error routine is called and a suitable message is displayed. You will notice that the record is only checked from character nine onwards. This means that the eight character header can contain any characters.

95 Lines 470 to 500 build up the statistics for the relevant results. The home details are calculated in line 470. The array HOMES is used to store the number of games that have ended in a home win for a particular coupon number. You will notice that the first element of the second dimension is used to hold this total. The second element of this dimension is later used to hold the percentage figure. The LASTHOME% array is used to hold the record number when the last home win was seen. This figure is used later to calculate how many weeks it is since a particular number has ended in a home win. Lines 480 to 500 perform a similar function for the no score draws, away wins and no score draw results. The last function performed by the Process Record Routine is to build the string that will be used to display the last ten results for each coupon number. This string is built at line 510. Calculate Percentage Routine (Line 550) This routine is called from within the Control Routine. It converts the number of each result to a percentage value. It is calculated to one decimal place. You can see that we store the value in the second element of the second dimension. Display Control Routine (Line 640) This is the last routine called from the Control Routine. It is a menu that allow to select which screen you wish to view. Display Last Ten Weeks Routine (Line 880) Display Weeks Since Last Win Routine (Line 1060) Display Percentage Figures Routine (Line 1270) These three routines display the screens that were described earlier in the chapter with all the display routines. They may look rather daunting, but this is due to the amount of formatting that has to be done. I have to apologise about some of the screen layouts. I am afraid some of information has had to be printed rather closely together due to the amount that had to be shown. This is particularly apparent on the percentage screen. I hope you understand why this had to be the case and why the usual headings could not be used.

96

97

98 CHAPTER 12: COOKING THE BOOKS At the risk of boring you I want you to look at some figures concerned with developing a horse racing system. I am making the assumption that we do not yet know what our system will do, so we are going to collect a variety of information just in case we need it. The type of information we require is in two parts, the first type we only need to store once. For example: Table 12.1: Horse Racing data we only need to store once Description # of Items Bytes per Item Total Bytes Courses Jockeys ,100 Horses ,000 Owners ,000 Trainers ,000 Total 33,000 The second type of information we need is the detail of each race. This data might be as follows: Table 12.2: Horse racing data we must store for every race Description # Bytes Date 6 Time 4 Course Indicator 2 Type of Going 2 Length of Race 2 Number of Runners 2

99 Prize Money 5 Horse Indicator 2 Jockey Indicator 2 Owner Indicator 2 Trainer Indicator 2 Weight Carried 2 Starting Price 6 Finishing Position 2 The top half of table 12.2 will only be required once for each race. The data at the bottom half of the table will not be repeated for each horse that takes part in the race. Where I have said that a particular piece of information is an indicator it means that it references the items in table 12.1 I do not claim that the data I have listed above is exhaustive, nor do I claim that it is totally accurate. In Table 12.1 I have estimated that we will store data for 500 horses. This figure is purely an estimate but it gives some idea of the amount of data that we need to store. There may be other factors that you wish to store and some of the data may appear to be unnecessary. If you decide to develop your own system you would have to make your own decisions about the data you will collect. I am merely giving a rough estimate as to the amount of data involved. You must also bear in mind how you will access the data. The descriptions I have given above give no consideration to efficient access. One thing is certain; a serial read of the data would almost certainly be too slow. We would have to use some form of indexed files so that we could key into the data we require. But what would we use as a key? We would definitely need to locate a horse quickly. But we would need some sort of access to jockeys, trainers and owners. Already we are building quite a complicated file structure. Returning to the volume of data; a few calculations will reinforce the points I have been making above. Before we even start we are committed to storing 33,000 bytes of data (table 12.1). This is just our base data of horses, jockeys etc. Forgetting the problems of maintaining such a database, you can imagine how much work would be required just to key it in.

100 For each race we also have to store data. Assume that there are, on average, three race meetings a day and that racing takes place six days a week. That will give us racing on 313 days of the year (365-52). If a race card averages six races we are dealing with 5,634 races a year (313*3*6). For each race we are storing 23 bytes of fixed information (top half of table 12.2) and a further 18 bytes for each horse (bottom half of table 12.2). Allowing for eight horses per race, we need 144 bytes to store the second part of table 2 (8*18). Add this to the fixed data (first part of table 12.2) and we average 167 bytes of data for each race. 5,634 races requiring 167 bytes of data adds up to 940,878 bytes. Add this to the 33,000 for the fixed data from table 12.1 and we end up with a total figure of 973,878 bytes. On average we would have to input about 3,100 bytes of data each day (973,878/313). That is bad enough in itself, but can you imagine the problems we would have in accessing the data. How would you evaluate a six horse race? Unless we thought a great deal about our file structures we will find that half our time is spent keying in the data, with the remainder of our time trying to access it. And, as yet, we have not even thought about how we are going to use the data. In fact we have no guarantee that there will ever be a pay day at the end of it all. We could spend a year of our life collecting data and then still lose money to the local bookie. If that sounds like your idea of fun, go ahead, but count me out. Unless I can get a ready supplied database I will try to find another method to beat the bookie. I may still lose, but at least I will not have wasted hours doing it. My philosophy says that if we are going to lose we might as well lose quickly rather than prolonging the agony. The system in this chapter relies on no historical data, and as such there is no file handling as all the data required is requested at run time. The system attempts to turn the bookmaker s profit margin to our advantage. You will recall that I explained how the profit margin worked in Chapter 2. If you have forgotten how it operates, re-read the chapter so that you are familiar with the ideas given. In Chapter 2, I said that if we can get the bookmakers percentage to under 100% then we can bet on every horse in the race without any fear of being out of pocket. The problem is that no race will ever have an overall percentage of less than 100%. You may have worked out one or two races, and if so you should have found that a typical profit margin is about 12%. In fact, if you look at the results service in The Sporting Life or The Racing Post you will see that the overall percentage is given for each race, and this saves you the trouble of having to calculate it. My theory is this. If we can look at the race in percentage terms, even though we cannot bet on every horse, we might be able to eliminate enough of them to make a profit from the race. For example, if the overall percentage for a race is % and one of the horses is 2-1 (33.33%) we can get the overall percentage down to 79.43% ( ) by eliminating that horse. We can now bet on every other horse and make a profit of 20.57% ( ). The one

101 big assumption that we are making is that the 2-1 horse does not win. If it does we will make a 100% loss. We also have tax to consider, but we shall look at that in a moment If we accept that on some races we will lose we might like to look at races that start with an odds on favourite. What would the effect be if we backed every horse except for the odds on favourite? We know that there will be races where the favourite will win, but can we make a profit anyway? If a horse starts at 1-2 (66.66%) we could get the overall percentage as low as 46%, giving us a profit of 54%. Sometimes the favourite will win, but can our 54% profit balance out these losses? In fact it will not, (I know, because that is one study I have done), but it gives you an idea of the way in which we could use the system. Another idea we could try is to leave out the horses that have the longest odds we could keep reducing the number of horses until we get the overall percentage to, say, 88% and back the remaining horses. Would this method win us money in the long run? I have not done the research on this idea, but this could be a suitable place for you to start your investigations. After reading the above you will not be surprised to learn that the program for this chapter uses the odds as its base data. The data input screen looks similar to the input screen when you had to type in the football league tables. You are asked for a horse name or number followed by the odds, left hand side first and then the right hand side. When you enter the horse identifier you can use either a name or number. It is important that each entry is different so that the horses are unique. This is so that you can recognise them later. I always use the number that appears alongside the horse in the daily newspaper. It is only three digits long, and will uniquely identify each horse. To terminate the input routine you have to enter end in response to a horse name. The arrays within the program will allow for up to 100 horses to be input for each race. I doubt that you will ever exceed this limit, but if you do you can increase the size of the arrays to allow for this. When you have finished typing in the race card it is displayed, allowing you to see the odds for each horse, the suggested bet, the suggested bet with tax included, and the return if the horse wins. The suggested bet is the odds expressed as a percentage. For example, a 2-1 horse would have a suggested bet of (36.66 with tax). If you convert 2-1 to a percentage you will find that it is 33.33%. You will also see that the return you can expect if the horse wins is about 100 units. Every horse will always give a return of approximately 100 units. Each screen will show 14 horses at a time. If there are more than this number of runners a message will appear at the bottom of the screen saying more follows. Pressing the space bar will show the next screen. At the end of the race card the overall totals are displayed. From this you can see the total amount you will have to bet to get a return of 100 units. You can also see the total amount

102 you will have to bet including tax. For us to win money, the suggested bet, with tax, must be below 100, and one of the horses we back must win. When you first enter a race card, you will inevitably find that the overall percentage is over 100. Therefore, if we back every horse we will lose money. This is where the second part of the system comes in. At the bottom of the screen you will see four options. These being: (D)elete a Horse (E)xit (R)einstate a Horse (S)tart Again If you choose the E option you will exit from that race. You will be asked if you wish to play again. Answering N will leave the program. A reply of Y will allow you to enter another race The D option allows a horse to be deleted for the purpose of betting. When you choose this option you will be asked which horse you wish to delete. At the left hand side of each horse you will see a number. This is the number you must enter, not the horse number you entered during the input phase. Once the horse to be deleted has been entered the race card is redisplayed. This time you will see that the horse you deleted has zero against the suggested bet and that the totals do not include this horse. By repeatedly deleting horses, you can decide which horses you should leave out of your betting to get the percentage to below 100. I should also point out that you should be looking at the total that includes tax not just the suggested bet total. The R option performs a similar function to the D option, except that it allows a horse to be brought back into the calculations. If you have deleted a horse you can reinstate it using the R option. The S option allows you to start all over again. It resets all the horses so that they are included in the betting. You could achieve the same effect by repeatedly using the R command but the S command is a lot faster, especially if you have deleted a lot of horses. If you think this type of system has as much potential as I do, I suggest that you type in a few races and experiment with deleting and reinstating horses. For those of you who would like to develop the system further, I have described the main routines below. Input Horse Routine (Line 360) This routine asks for the names of the horses and stores them in the array HORSES$. Its other main function is to control the variable HORSECNT% which is used to store the number of horses that have been entered. Once a horse name or number has been input,

103 the Odds Input Routine is called. Odds Input Routine (Line 540) The purpose of this routine is to request the odds from the user. It asks for this data in two parts first, the left hand side of the odds and then the right hand side. To enter odds of 2-1 you would enter 2, followed by 1. As you enter the odds each part is validated to ensure that it is greater than zero. The last function of this routine is to call the Calculate Money Routine. Calculate Money Routine (Line 700) This routine performs three functions. It calculates the stake, with and without tax and it also calculates the potential winnings. These values are held in the STAKE, TAX and WIN arrays. The stake is simply the odds converted to percentages. The tax is the same figure but with 10% added. This is the current rate of tax if you bet with an off-course bookmaker. If this rate should change you should amend line 740. The WIN array holds the amount you will receive should that particular horse You may notice that the values I have described above are held twice. For example, the stake for horse three is held in STAKE(3,l) and STAKE(3,2) (see line730). TAX and WIN are similarly duplicated. STAKE(n,1) is actually used in the display routine. If you decide you want to delete this horse this element is set to zero. When you want to reinstate the horse the program needs to retrieve the information from somewhere, and this is the purpose of STAKE(n,2). This is copied to STAKE(n,1) which can then be displayed. The TAX and WIN arrays operate in exactly the same way. Decide Bet Routine (Line 1160) This routine controls the part of the program that allows you to manipulate horses. The first function it performs is to call the Display Race Routine (see below). Next, at the bottom of the screen, are displayed the various options available. Once the user has made a selection the appropriate routine is called. This routine keeps displaying the race card and asking what you would like to do until you use the exit option. Display Race Routine (Line 810) This routine, like most of the other display routines in the book, looks horrific you first see it. As I have said in previous chapters, this is due to the formatting that has to be done so that the screen looks tidy. When you look more closely at this routine it is quite simple. The only complication is that the program must check how many horses it has displayed. If it has reached 14, it has

104 to say that more follows and wait for the user to press the space bar. T then redisplays the screen headings before continuing to output the other horses. This is done at line 980. Delete Horse Routine (Line 1320) This routine asks which horse you wish to delete and checks that it is a valid value. It does this by checking that the value is between one and the value held in HORSECNT%. The value that is entered is used to access the arrays STAKE, TAX and WIN and to set the relevant elements to zero. For example, if you wish to delete horse five the elements STAKE(5,1),TAX and WIN would all be set to zero. As these values are used in the display routine it effectively deletes the horse from the betting. Re-instate Horse Routine (Line 1450) This routine performs the opposite of the delete routine. If we had previously deleted horse five, we could reinstate it using the R option. You would do this if you to see the effect this horse now had on the overall percentage. The routine reinstates a horse by copying the value in STAKE(n,2) to STAKE(n,1). This resets the array to its original value before the delete option set it to zero. The TAX and WIN array are treated in the same way. Start Again Routine (Line 1580) This routine will be called if you choose the S option. It copies all the saved values to element one (i.e. STAKE(n,2) to STAKE(n,1)). It does this in a loop from the value stored in HORSECNT% so that every horse is reinstated. The remaining routines in the program are either self-explanatory or are the standard routines used throughout this book.

105

106

107 CHAPTER 13: A FAVOURITE SYSTEM If you have any interest in horse racing systems it will not be long before you come across one that uses favourites as its basis. The system in this chapter takes one such system and allows us to experiment with it in two important ways. The aim, as usual, is to find the happy medium where we win and the bookmaker loses. As a starting point consider this. If we back the favourite in every race, will we win money? Not surprisingly the answer is no. There are times when the indiscriminate backing of favourites will result in a profit in the short term, but over a whole season this strategy would almost certainly make a loss. However, this assumes that we are backing with level stakes (the same amount on each race). If we implemented some sort of staking system we might be able to make the system pay. After each loss we could gradually increase (or decrease) our stake until we win. Alternatively, we could consider doubling our stake after each loss until we back a winner. When looking at roulette I advised against a doubling up method of staking. Now that you know the dangers of such a system you can decide for yourself whether or not the same dangers apply to horse racing as they do to roulette. Using the program in this chapter you can easily test a staking system where you double your stake after a loss. Another thing that we should consider when backing favourites is to ensure that we get value for money. Some people argue that you should never back a horse when it is odds on. Others will say never back anything unless it is greater than 2-1. My view is that if it wins it is worth backing. A naïve view, I know, as you cannot be certain that a horse has won until it has passed the post, but nobody can argue that if a horse wins it was not worth backing, whatever the odds. However, any system that backs favourites should allow us to choose what odds we regard as giving us value for money. Any horse that falls below those odds should not be backed. To back favourites we therefore have two factors that we might wish to manipulate. We must be able to follow a certain staking system, and we must be able to limit ourselves to the odds we take as being acceptable to bet upon. The program for this chapter allows us to experiment with these variables. We can take a number of races, bet on the favourites, and see what happens if we change these two factors. As an example you might try testing a complete season s results by only backing favourites that start at 2-1 or greater. You could try this using a staking system 1, 2, 3, 4, 5. This means that your stakes will follow these values until you win. When you do, your stake reverts to the first value. If you suffer five losses in succession you will also start again with a stake of one unit. You could also try the same races with different factors. Perhaps you could set the odds

108 limit at 3-1 and have a staking method of 1, 2, 3, 4, 5, 9, 10. To test this system requires a data file. This file holds the starting price of every favourite. The file also needs to indicate if the horse won or lost, and also to show if the horse started as joint favourite. I have deliberately kept the records as short as possible in order to save on data input. An example of a record is: WJ This signifies the favourite started at , it won and it was joint favourite. The program does not require the various parts of the record to fall in particular columns. Therefore, a small data file could be as follows: Table 13.1: Example data file needed by program Race W 9-2LJ 85-40L You can see that the win/loss indicator can be in any column. The program will use the odds to work out which column it is in. It can then use this information to find the joint favourite indicator, if it is present. When you input the race results you must place a hyphen between the two parts of the odds. The win/loss indicator can either be in upper or lower case, but must be an L or a W. Similarly, the joint favourite indicator can be in either case but can also be null string (i.e. nothing) I should point out that the program will store the joint favourite indicator within string (JTFAV$). But apart from this, it is not used. If you wish to use this information you will have to amend the program. The reason I have not written any code to deal with joint favourites is because I could not decide what to do. Should I ignore the horse or should I split the stake in some way? In the end, I decided to ignore joint favourites and treat them as if they were the only favourites in the race. When you input the file you can use any of the methods I have described in earlier chapters. For example, you can use the copy command or, a text editor. Personally, I use a text editor as I find it easier to use than the copy command (at least for this application). When you enter the results you should store the records in the order you would have bet upon them. I always store the races in time order and, if there is a clash of times, I use the course

109 name to decide which race to enter first. For example, I would enter these results in the following order. Table 13.2: Example of order in which races are input Course Time Doncaster 3-20 Newbury 3-20 Ascot 3-30 Newbury 3-50 Doncaster 3-55 Ascot 4-00 To make life easier, I type in three extra pieces of information during the data entry phase. This information being the date of the race, the course name and the time of the race. This allows the file to be sorted, thus saving the worry of having to enter the records in the correct order. Although this method increases the amount of data input, I have found that it saves time in the long run. When you run the program you will be asked what are the lowest odds you prepared to bet at. You have to answer the question in two parts. First, supplying the left hand side of the odds and then, the right hand side. The answer you give to this question will determine the horses that you will back. For example, if you answer 2-1 you will back any favourite that starts at 2-1 greater. Therefore, you will back favourites with starting prices of 11-4, 3-1, 2-1 or 5-2. You will not back horses with odds of 1-2, 7-4, and 6-4. You can see from the program listing that this question is asked in the Odds Limit Routine (line 210). You will notice that line 340 converts the odds you supply to a percentage figure. This makes comparison with the odds supplied in the data file a lot easier. The program next asks for the filename that holds the data records. This is done via the Get Filename Routine at line 370. The file is then opened by the routine at line 440. The remainder of the program is controlled by the Control Routine which is called at line 80. The routines called from within the Control Routine are fully explained later in the chapter. What follows is a more general explanation of how the rest of the program works. Each record of the data file is read. It is first validated to ensure that the program can

110 interpret it. If any errors are found, a suitable message is output and the program terminates. Assuming that the record passes the validation, the odds are converted to a percentage figure. The percentage figure is now compared against the value supplied at the beginning of the program. If the program decides that this race is one you wish to bet on, the win/loss indicator for that race is examined. Depending on this, the relevant routine is called. If the horse loses, the stake is deducted from the bank and set to the next value in the staking system. If you have reached the end of the staking system, the stake is set to the initial value so that the sequence can start again. If your horse wins, the return is calculated and added to the bank. The stake is set to the initial value of the staking system. Whether you win or lose, tax is automatically taken into account. Once all the records from the data file have been processed the program displays the results on the screen. You are shown the following information: Table 13.3: Information displayed from program Race13 Odds needed before you bet Number of races in the file Number of wins Number of losses Longest losing sequence Longest winning sequence Number of races not backed Bank total It is hoped that this information will be useful in planning different staking systems and also help in deciding on the odds required before you bet The program given below is a fully working version of the system I have described above. The only other thing you need to know is how to change the staking system. It is held in a DATA statement at the end of the program (line 6550). To use a different staking system you should enter new values, ensuring that they are terminated with a zero. The zero will not be used as part of the system, but is is needed so that the Init_1 Routine knows when it has read all the values making up the staking system (see lines 140 to 170).

111 If you would like to develop the system further, I have given below details of the main routines below. Control Routine (Line 480) Once the data file has been opened this routine controls the rest of the program. It reads each record from the data file and calls the relevant routines. Once the file is exhausted the Output Routine is called, and it displays the results. The Read and Validate Routine, called at line 500, will return the next record from the file. The odds for each record are converted to a percentage (line 510). This makes comparison with the odds entered at the start of the program easier than if the odds were held in the usual format. Lines 520 and 530 will call the Win or Lose Routine depending on whether the horse won or lost. The program also checks if the horse is a suitable one to bet upon by comparing the odds you entered at the start of the program with the odds of the current horse. A count is also kept of the number of horses that are not bet upon. This is done at line 540. Read and Validate Routine (Line 590) This routine reads the next record from the data file and increments a counter tallying the number of records (RECCNT%). The remainder of the routine validates the record and stores the relevant parts into variables. The record is firstly validated to check that it does not contain a space (line 630 and 640). If it does, a suitable message is displayed and the program terminates. The position of the hyphen is now found (line 650). If the record does not contain a hyphen the program terminates with an error message (line 660). Using the position of the hyphen as an indicator, the left and right hand side of the odds can be split off into the variables ODDSLEFT% and ODDSRIGHT%. This is done between lines 670 and 710. The Win/Loss Indicator and Joint Favourite Indicator can now be extracted (lines 720 and 730). The final lines of this routine validate these indicators. Win Routine (Line 800) The Win Routine is responsible for updating the variable MONEY% which represents the bank. In performing this calculation the effect of tax is taken into account (line 820). If the tax rate should change for off-course betting you will have to amend this line (and also line 920). Three variables are updated, and will be displayed later. The WINS% variable is used to show how many wins, in total, we have had. The WINSEQ% variable tracks our longest winning sequence. You will see that the Lose Routine sets this variable to zero which effectively restarts the sequence. Line 860 will, if necessary, update the variable TOTWINSEQ% which will the largest winning sequence. The other variable this routine updates is STAKECNT%. This is used as a pointer to the staking system. In effect, it points to the various figures you supply in the DATA statement

112 at the end of the program. These figures are read into the array STAKEPLAN% within the Init_1 routine. The STAKECNT% variable is used as a pointer to this array. By setting it to one (line 840) we are effectively starting the staking system again. Lose Routine (Line 900) This routine performs a similar function to the Win Routine, but it deducts money from the bank, taking into account the effect of tax (lines 920 and 930). The STAKECNT% indicator is incremented by one. This allows us to increase our stake after a loss. If STAKEPLAN%(STAKECNT%) equals zero (line 950) this shows that the current staking system is at an end. Setting STAKECNT% to one restarts the staking system. The remainder of the routine updates variables that will be used for display purposes later. Output Routine (Line 1010) The figures displayed via this routine have been shown above. This routine is the same as all the other output routines in all the other chapters. The bulk of the code is concerned with formatting the output.

113

114 AND FINALLY I hope that you have found this book useful, whether you read it from cover to cover, or just dipped in and out. If you have run the programs, I hope that you get some sense of excitement as you watch the various systems run on the screen. If you have just read the book, without installing the GWBASIC emulator, I hope that it has given you some ideas that you will develop for yourself in the future. Perhaps the main message that I want you to take home from this book is that roulette cannot be beaten (not unless you cheat) as the mathematical odds built into the game cannot be overcome by using your skill. In the long run, the house edge will wear you down and take your money. In other games, such as football and horse racing, there is scope to use your skill and, perhaps, win in the long run. We have only scratched the surface of some of the possibilities for these sports and perhaps, with your feedback and ideas, we can develop them further. There are other casino games that we have not considered in the book that also have an element of skill. Blackjack is one such game where you may be able to reverse the house edge by using card counting. Poker is another game where you are really playing against the other players, rather than the casino. The casino takes a certain amount from each hand, after which they don t care who wins, or who loses, as they have made their money with absolutely no risk at all. Both blackjack and poker might be worthy of investigation in a follow up edition to this book? A FINAL REQUEST Given that I wrote this book more than 25 years ago, I am sure that there are many ideas as to how it could be developed. For example, test other systems, investigate different sports/games, use a more modern programming language etc. I would be delighted to hear about any ideas you have. Please let me know (basicbetting@graham-kendall.com) and it might make it into the next edition.

115

116 RECOMMENDED READING Below is a list of books that I have found useful in compiling this book, or that have increased my knowledge of gambling generally. They are listed in no particular order. Betting for Profit by David Duncan. ISBN Betting for Fun and Profit by Tony Hill. ISBN Braddocks Complete Guide to Horse Racing Selection and Betting by Peter Braddock. ISBN The Newtonian Casino by Thomas Bass. ISBN The Punters Friend (A Guide to Betting) by Jack Waterman. ISBN G Systematic Betting by C Van Der Wheil. ISBN Thirteen Against the Bank by Norman Leigh. ISBN Q Winning by Computer by Dr. Donald Sullivan. ISBN Winning the Pools by Dennis Jones. ISBN Win at Roulette by Gordon Cromwell. ISBN

117

118 ABOUT THE AUTHOR Graham Kendall is now a Professor of Computer Science but when he wrote the first edition of this book, in 1993, he was an IT Manager who had spent about 15 years in the industry. He started as a Computer Operator (1977), working on ICL mainframes, and ended up as an IT Support Manager overseeing a variety of projects for large UK based companies. In 1994 Graham decided to put his industrial career on hold and go to university to take a degree in Computer Science. He studied at UMIST (University of Manchester Institute for Science and Technology), graduating in 1997 with a 1 st Class Honours degree in Computation. The plan was to return industry, in a consultancy role, and help prepare for the problems that would arise the world approached 2000, and the problems that would be experienced with the Y2K (Year 2000) bug. In fact, he was offered the opportunity to do a PhD at the University of Nottingham, which he did between 1997 and In 1999, he was offered a lectureship in the School of Computer Science. Graham has remained in academia ever since, being made a full Professor in 2007 and then moving to their Malaysia Campus in 2011, which is where he is currently located. Since becoming an academic Graham has published over 200 peer reviewed scientific articles (see with almost 100 of those in leading scientific journals. His research interests are many and varied and include Operational Research, Scheduling, Games, Sports and Evolutionary Computation. In the context of this book, he has retained an interest in games such as Blackjack and Poker and has published on these topics in the scientific literature. For example: Kendall, G and Smith, C The evolution of blackjack strategies. In Proceedings of the IEEE 2003 Congress on Evolutionary Computation (CEC2003), pages , Canberra, Australia, 2003 Kendall, G and Willdig, M An Investigation of an Adaptive Poker player. In Proceedings of the 14th Australian Joint Conference on Artificial Intelligence (AI 01), pages , Springer-Verlag, Adelaide, Australia, December, Lecture Notes in Artificial Intelligence 2256, 2001 He also has an interest in other types of games, sports and puzzles. For example: Kendall, G and Lenten, L. J. A When Sports Rules Go Awry. European Journal of Operational Research, in Press