Monopoly odds

In the game, Monopoly, the standard board is set up in the following way:

A player starts on the GO square and adds the scores on two 6-sided dice to determine the number of squares they advance in a clockwise direction. Without any further rules we would expect to visit each square with equal probability: 2.5%. However, landing on G2J (Go To Jail), CC (community chest), and CH (chance) changes this distribution.

In addition to G2J, and one card from each of CC and CH, that orders the player to go directly to jail, if a player rolls three consecutive doubles, they do not advance the result of their 3rd roll. Instead they proceed directly to jail.

At the beginning of the game, the CC and CH cards are shuffled. When a player lands on CC or CH they take a card from the top of the respective pile and, after following the instructions, it is returned to the bottom of the pile. There are sixteen cards in each pile, but for the purpose of this problem we are only concerned with cards that order a movement; any instruction not concerned with movement will be ignored and the player will remain on the CC/CH square.

• Community Chest (2/16 cards):
  1. Advance to GO
  2. Go to JAIL
• Chance (10/16 cards)
  1. Advance to GO
  2. Go to JAIL
  3. Go to C1
  4. Go to E3
  5. Go to H2
  6. Go to R1
  7. Go to next R (railway company)
  8. Go to next R
  9. Go to next U (utility company)
  10. Go back 3 squares

The heart of this problem concerns the likelihood of visiting a particular square. That is, the probability of finishing at that square after a roll. For this reason it should be clear that, with the exception of G2J for which the probability of finishing on it is zero, the CH squares will have the lowest probabilities, as 5/8 request a movement to another square, and it is the final square that the player finishes at on each roll that we are interested in. We shall make no distinction between “Just Visiting” and being sent to JAIL, and we shall also ignore the rule about requiring a double to “get out of jail”, assuming that they pay to get out on their next turn.

By starting at GO and numbering the squares sequentially from 00 to 39 we can concatenate these two-digit numbers to produce strings that correspond with sets of squares.

Statistically it can be shown that the three most popular squares, in order, are JAIL (6.24%) = Square 10, E3 (3.18%) = Square 24, and GO (3.09%) = Square 00. So these three most popular squares can be listed with the six-digit modal string: 102400.

If, instead of using two 6-sided dice, two 4-sided dice are used, find the six-digit modal string.

大富翁几率

大富翁游戏的标准棋盘大致如下图所示：

玩家从标记有“GO”的方格出发，掷两个六面的骰子并将点数和相加，作为本轮他们前进的步数。如果没有其它规则，那么落在每一格上的概率应该是2.5%。但是，由于“G2J”（入狱）、“CC”（宝箱卡）和“CH”（机会卡）的存在，这个分布会有所改变。

除了落在“G2J”上，或者在“CC”或“CH”上抽到入狱卡之外，如果玩家连续三次都掷出两个相同的点数，则在第三次时将会直接入狱。

游戏开始时，“CC”和“CH”所需的卡片将被洗牌打乱。当一个玩家落在“CC”或“CH”上时，他们从宝箱卡和机会卡的牌堆最上方取一张卡并遵循指令行事，并将该卡再放回牌堆的最下方。宝箱卡和机会卡都各有16张，但我们只关心会影响到移动的卡片，其它的卡片我们都将无视它们的效果。

• 宝箱卡 (2/16 张卡):
  • 1 回到起点“GO”
  • 2 进入*“JAIL”
• 机会卡 (10/16 张卡):
  • 1 回到起点“GO”
  • 2 进入*“JAIL”
  • 3 移动到“C1”
  • 4 移动到“E3”
  • 5 移动到“H2”
  • 6 移动到“R1”
  • 7 移动到下一个“R”（铁路公司）
  • 8 移动到下一个“R”
  • 9移动到下一个“U”（公共服务公司）
  • 10 后退三步

这道题主要考察掷出骰子后停在某个特定方格上的概率。显然，除了停在“G2J”上的可能性为0之外，停在“CH”格的可能性最小，因为有5/8的情况下玩家会移动到另一格。我们不区分是被送进*还是恰好落在*“JAIL”这一格，而且不考虑需要掷出两个相同的点数才能出狱的要求，而是假定进入*的第二轮就会自动出狱。

从起点“GO”出发，并将方格依次标记00到39，我们可以将这些两位数连接起来表示方格的序列。

统计学上来说，三个最有可能停下的方格分别是“JAIL”（6.24%）或方格10，E3（3.18%）或方格24以及“GO”（3.09%）或方格00。这三个方格可以用一个六位数字串表示：102400。

如果我们不用两个六面的骰子而是用两个四面的骰子，求出三个最有可能停下的方格构成的数字串。

解题：

通俗的说就是根据*的点数，来判断下一个步棋子应该在那里。然后根据上面说的实现就好了了

将上面的20个位置转换成数子00-39的表示形式

下面看程序吧

Java

package Level3;

import java.util.Random;

public class PE084{

    static void run() {

        double result[] = new double[40];

        int cnt =0;

        int pos = 0;

        int num =0;

        int limit = 100000;

        while(cnt <limit){

            int r1 = new Random().nextInt(4) + 1;

            int r2 = new Random().nextInt(4) + 1;

            pos += r1 + r2;

            if(pos > 39) pos -= 40;

            if(r1 == r2) num += 1;

            else num = 0;

            if(pos == 2 || pos == 17 || pos ==33){

                int r3 = new Random().nextInt(16) + 1;

                if(r3 == 1) pos = 0;

                if(r3 == 2) pos = 10;

            }

            if( pos ==7 || pos ==22 || pos ==36){

                int r4 = new Random().nextInt(15) + 1;

                if(r4 == 1) pos = 0;

                if(r4 == 2) pos = 10;

                if(r4 == 3) pos = 11;

                if(r4 == 4) pos = 24;

                if(r4 == 5) pos = 39;

                if(r4 == 6) pos = 5;

                if(r4 == 7 || r4== 8){

                    if(pos == 7) pos = 12;

                    if(pos == 22) pos = 25;

                    if(pos == 36) pos = 5;

                }

                if(r4 == 9){

                    if(pos ==7) pos = 12;

                    if(pos ==22) pos = 28;

                    if(pos ==36) pos = 12;

                }

                if(r4 == 10) pos -=3;

            }

            if(pos == 30 || num ==3) pos = 10;

            result[pos] +=1;

            cnt +=1;

            if(num ==3) num =0;

        }

        for(int i=0;i<40;i++){

            result[i] = result[i]*1.0/limit *100;

            if(result[i] > 3)

                System.out.println(i+"....."+ result[i]+"%");

        }

    }

    public static void main(String[] args){

        long t0 = System.currentTimeMillis();

        run();

        long t1 = System.currentTimeMillis();

        long t = t1 - t0;

        System.out.println("running time="+t/1000+"s"+t%1000+"ms");

//        101524

//        running time=0s187ms

    }

}

Python

# coding=gbk

import time ;

import random;

t0 = time.time()

result = [0 for i in range(40)]

cnt = 0

pos = 0

num = 0

limit = 1000000

while cnt<limit:

#     两枚4面体筛子

    r1 = random.randint(1, 4)

    r2 = random.randint(1, 4)

#     和

    pos += r1 + r2

#     循环

    if pos >39:pos-=40

#     筛子是否相等

    if r1==r2:num+=1

    else:num = 0

    if pos ==2 or pos == 17 or pos ==33:

        r3 = random.randint(1,16)

        if r3 == 1:pos = 0

        if r3 == 2:pos = 10

    if pos ==7 or pos == 22 or pos == 36:

        r4 = random.randint(1,16)

        if r4 == 1:pos = 0

        if r4 == 2:pos = 10

        if r4 == 3:pos = 11

        if r4 == 4:pos = 24

        if r4 == 5:pos = 39

        if r4 == 6:pos = 5

        if r4 ==7 or r4==8:

            if pos ==7:pos =12

            if pos ==22:pos =25

            if pos ==36:pos =5

        if r4 == 9:

            if pos == 7:pos =12

            if pos ==22:pos =28

            if pos ==36:pos =12

        if r4 ==10:

            pos -=3

    if pos == 30 or num==3:

        pos = 10

    if num == 3: num=0

    result[pos]+=1

    cnt+=1

result = [1.0*re/limit for re in result]

for i in range(40):

    if result[i]>0.03:

        print i ,result[i]

t1 = time.time()

print "running time=",(t1-t0),"s"

# 10 0.070172

# 15 0.033969

# 16 0.032726

# 19 0.030785

# 21 0.030135

# 23 0.030071

# 24 0.033082

# 25 0.031051

# running time= 5.16399979591 s
            

答案：101524