【高中数学之古典概率】甲乙两人各有四张卡片,每张卡片上标有一个数字,甲的卡片上标有数字1,3,5,7,乙的卡片上标有数字2,4,6,8......2024年普通高等学校招生全国统一考试(全国新课标I卷)第14题

【题目】
甲乙两人各有四张卡片,每张卡片上标有一个数字,甲的卡片上标有数字1,3,5,7,乙的卡片上标有数字2,4,6,8,两人进行四轮比赛,在每轮比赛中,两人各自从自己持有的卡片中随机选一张,并比较所选卡片上数字的大小,数字大的人得1分,数字小的人得0分,然后各自弃置此轮所选的卡片,弃置的卡片在此后的轮次中不能使用,则四轮比赛后,甲的总得分不小于2的概率为多少?

【来源】

2024年普通高等学校招生全国统一考试(全国新课标I卷)第14题(最后一道填空题)

【解题思路】

此题暂时没找到窍门,实际解法是列表法

首先将甲四张牌全排列的24中方式列出,将乙固定为2,4,6,8的形式,比较完会发现甲得分不小于2有12次,占总数24次的50%;

其次将将乙固定为4,2,6,8的形式,再次进行两者比较,发现甲得分不小于2依然有12次,占总数24次的50%;

两轮比较后会得出总概率为50%的结论。

此法虽笨但有效,对已有事实进行归纳并推而广之也是数学能力的一部分。

【程序思路】

基本是列表法的拓展,即将甲乙全排列的方式进行全比较,发现总共比较576次,甲得分不小于2的有288次,概率确实是50%

【代码】

package test250423;

import java.util.List;

/**
 * 2024年普通高等学校招生全国统一考试(全国新课标I卷)第14题(最后一道填空题)
 * 题目:
 * 甲乙两人各有四张卡片,每张卡片上标有一个数字,
 * 甲的卡片上标有数字1,3,5,7
 * 乙的卡片上标有数字2,4,6,8
 * 两人进行四轮比赛,在每轮比赛中,两人各自从自己持有的卡片中随机选一张,
 * 并比较所选卡片上数字的大小,数字大的人得1分,数字小的人得0分
 * 然后各自弃置此轮所选的卡片,弃置的卡片在此后的轮次中不能使用,
 * 则四轮比赛后,甲的总得分不小于2的概率为多少?
 * 
 */
public class Test250423 {
    public static void main(String[] args) {
        int[] numsJia= {1,3,5,7};
        Arranger argerJia = new Arranger(numsJia,numsJia.length);
        
        int[] numsYi= {2,4,6,8};
        Arranger argerYi = new Arranger(numsYi,numsYi.length);
        int idx = 0;
        int sum=0;
        
        for (List<Integer> lineYi : argerYi.getResults()) {
            for (List<Integer> lineJia : argerJia.getResults()) {
                int score=0;
                score+=(lineJia.get(0)>lineYi.get(0))?1:0;
                score+=(lineJia.get(1)>lineYi.get(1))?1:0;
                score+=(lineJia.get(2)>lineYi.get(2))?1:0;
                score+=(lineJia.get(3)>lineYi.get(3))?1:0;
                
                if(score>=2) {
                    sum++;
                }
                System.out.println(String.format("%03d", ++idx) + "." + score);
            }
        }
        
        System.out.println("Win:"+sum+" Total:"+idx+" Probability:"+sum*100/idx+"%");
    }
}

用到的全排列工具类:

package test250423;

import java.util.ArrayList;
import java.util.List;

/**
 * 用于产生排列结果的工具类
 * 从n个元素中取出m个元素,按照一定的顺序排成一列。得到所有排列的方案
 */
class Arranger {
    // 保存在内部的对原始元素数组的引用
    private int[] arr;

    // 总计多少元素,此即数组长度
    private final int n;

    // 选多少个
    private final int m;

    // 返回结果
    private List<List<Integer>> results;

    /**
     * 构造函数一
     * 这个构造函数是用于全排列的(n=m=数组长度)
     *
     * @arr 原始元素数组
     */
    public Arranger(int[] arr) {
        this.arr = arr;
        this.n = arr.length;
        this.m = arr.length;

        this.results = new ArrayList<>();
        doArrange(new ArrayList<>());
    }

    /**
     * 构造函数二
     * 这个构造函数是用于部分排列的(m<n=数组长度)
     *
     * @param arr    原始元素数组
     * @param selCnt 选多少个
     */
    public Arranger(int[] arr, int selCnt) {
        this.arr = arr;
        this.n = arr.length;
        this.m = selCnt;
        if (m > n) {
            throw new ArrayIndexOutOfBoundsException("m:" + m + " >n:" + n);
        }

        this.results = new ArrayList<>();
        doArrange(new ArrayList<>());
    }

    /**
     * 使用递归进行全排列,结果放在results中
     *
     * @param initialList 初始链表
     */
    private void doArrange(List<Integer> initialList) {
        List<Integer> innerList = new ArrayList<>(initialList);

        if (m == initialList.size()) {
            results.add(innerList);
        }

        for (int i = 0; i < arr.length; i++) {
            if (innerList.contains(arr[i])) {
                continue;
            }

            innerList.add(arr[i]);
            doArrange(innerList);
            innerList.remove(innerList.size() - 1);
        }
    }

    /**
     * 获得结果链表的引用
     *
     * @return
     */
    public List<List<Integer>> getResults() {
        return results;
    }

    // 测试
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4};
        Arranger arranger = new Arranger(numbers);

        System.out.println("四元素全排列示例:");
        int idx = 0;
        for (List<Integer> re : arranger.getResults()) {
            System.out.println(String.format("%02d", ++idx) + "." + re);
        }

        /*Arranger arranger2 = new Arranger(numbers, 2);
        System.out.println("\n四选二排列示例:");
        idx = 0;
        for (List<Integer> re : arranger2.getResults()) {
            System.out.println(String.format("%02d", ++idx) + "." + re);
        }*/
    }
}

 

【输出结果】

001.0
002.1
003.1
004.2
005.1
006.1
007.1
008.2
009.2
010.3
011.2
012.2
013.1
014.2
015.1
016.2
017.2
018.2
019.1
020.1
021.1
022.1
023.2
024.2
025.1
026.0
027.2
028.1
029.1
030.1
031.2
032.1
033.3
034.2
035.2
036.2
037.2
038.1
039.2
040.1
041.2
042.2
043.1
044.1
045.1
046.1
047.2
048.2
049.1
050.1
051.0
052.1
053.1
054.2
055.2
056.2
057.1
058.2
059.2
060.3
061.1
062.2
063.1
064.2
065.2
066.2
067.1
068.2
069.1
070.2
071.1
072.1
073.1
074.1
075.1
076.0
077.2
078.1
079.2
080.2
081.2
082.1
083.3
084.2
085.2
086.1
087.2
088.1
089.2
090.2
091.2
092.1
093.2
094.1
095.1
096.1
097.2
098.1
099.1
100.1
101.0
102.1
103.3
104.2
105.2
106.2
107.1
108.2
109.2
110.2
111.2
112.2
113.1
114.1
115.1
116.2
117.1
118.2
119.1
120.1
121.1
122.2
123.1
124.1
125.1
126.0
127.2
128.3
129.2
130.2
131.2
132.1
133.2
134.2
135.2
136.2
137.1
138.1
139.2
140.1
141.2
142.1
143.1
144.1
145.1
146.2
147.1
148.2
149.1
150.1
151.0
152.1
153.1
154.2
155.1
156.1
157.1
158.2
159.2
160.3
161.2
162.2
163.1
164.1
165.2
166.2
167.2
168.2
169.2
170.1
171.2
172.1
173.1
174.1
175.1
176.0
177.2
178.1
179.1
180.1
181.2
182.1
183.3
184.2
185.2
186.2
187.1
188.1
189.2
190.2
191.2
192.2
193.1
194.1
195.1
196.1
197.2
198.2
199.1
200.1
201.0
202.1
203.1
204.2
205.2
206.2
207.1
208.2
209.2
210.3
211.2
212.2
213.1
214.2
215.1
216.2
217.1
218.1
219.1
220.1
221.2
222.2
223.1
224.1
225.1
226.0
227.2
228.1
229.2
230.2
231.2
232.1
233.3
234.2
235.2
236.2
237.2
238.1
239.2
240.1
241.2
242.1
243.2
244.1
245.1
246.1
247.2
248.1
249.1
250.1
251.0
252.1
253.3
254.2
255.2
256.2
257.1
258.2
259.2
260.2
261.1
262.2
263.1
264.2
265.1
266.2
267.1
268.2
269.1
270.1
271.1
272.2
273.1
274.1
275.1
276.0
277.2
278.3
279.2
280.2
281.2
282.1
283.2
284.2
285.2
286.1
287.2
288.1
289.2
290.2
291.1
292.2
293.1
294.2
295.1
296.1
297.1
298.2
299.1
300.2
301.0
302.1
303.1
304.2
305.1
306.1
307.1
308.2
309.2
310.3
311.2
312.2
313.2
314.2
315.2
316.1
317.2
318.1
319.1
320.1
321.2
322.1
323.2
324.1
325.1
326.0
327.2
328.1
329.1
330.1
331.2
332.1
333.3
334.2
335.2
336.2
337.1
338.1
339.2
340.2
341.2
342.2
343.1
344.1
345.1
346.2
347.1
348.2
349.1
350.1
351.0
352.1
353.1
354.2
355.2
356.2
357.1
358.2
359.2
360.3
361.1
362.1
363.2
364.2
365.2
366.2
367.1
368.1
369.2
370.1
371.2
372.1
373.1
374.1
375.1
376.0
377.2
378.1
379.2
380.2
381.2
382.1
383.3
384.2
385.2
386.2
387.2
388.1
389.2
390.1
391.2
392.2
393.1
394.1
395.1
396.1
397.2
398.1
399.1
400.1
401.0
402.1
403.3
404.2
405.2
406.2
407.1
408.2
409.2
410.2
411.1
412.2
413.1
414.2
415.2
416.2
417.1
418.1
419.1
420.1
421.1
422.2
423.1
424.1
425.1
426.0
427.2
428.3
429.2
430.2
431.2
432.1
433.3
434.2
435.2
436.2
437.1
438.2
439.2
440.1
441.2
442.2
443.1
444.2
445.1
446.1
447.2
448.2
449.1
450.1
451.0
452.1
453.1
454.2
455.1
456.1
457.2
458.3
459.2
460.2
461.2
462.1
463.1
464.2
465.2
466.2
467.2
468.1
469.1
470.1
471.2
472.2
473.1
474.1
475.1
476.0
477.2
478.1
479.1
480.1
481.2
482.1
483.3
484.2
485.2
486.2
487.2
488.1
489.2
490.2
491.1
492.2
493.2
494.1
495.1
496.1
497.1
498.2
499.1
500.1
501.0
502.1
503.1
504.2
505.1
506.2
507.2
508.3
509.2
510.2
511.1
512.2
513.2
514.2
515.2
516.1
517.1
518.2
519.1
520.1
521.2
522.1
523.1
524.1
525.1
526.0
527.2
528.1
529.2
530.2
531.2
532.1
533.3
534.2
535.2
536.2
537.1
538.1
539.2
540.2
541.2
542.1
543.1
544.1
545.1
546.2
547.2
548.1
549.1
550.1
551.0
552.1
553.2
554.2
555.1
556.2
557.2
558.3
559.2
560.2
561.1
562.1
563.2
564.2
565.1
566.2
567.1
568.1
569.2
570.1
571.1
572.2
573.1
574.1
575.1
576.0
Win:288 Total:576 Probability:50%

END

posted @ 2018-05-08 07:00  逆火狂飙  阅读(133)  评论(0)    收藏  举报
生当作人杰 死亦为鬼雄 至今思项羽 不肯过江东