代码：
import java.util.Scanner;
class GaiLv
{
        public static void main(String []args) {
                System.out.println("请输入参与抽奖的人数");
                Scanner scanner=new Scanner(System.in);
        int num=scanner.nextInt();
                float n=num;
                float g=0;
                float sum=0;
        for(float i=0;i<num;i++) {
                  g=1-1/(n-i);
                  sum=sum+g;
                }
        }
}


思路

1.思路
假设总共有n个人抽奖,第一个抽不中自己的概率是1-（1/n），第二个抽不中自己的概率是1-(1/n-1)，第三个就是
1-（1/n-2）...第n-1个抽不中概率是
1/2,第n个抽不中概率是0
最后所有求到的概率相加

反正你出概率的题我就不想做了 高中概率没及格过

我网上找了一下公式，发现确实是你的那个答案，不过21的时候并不是趋近于0。我也想通了我原来的想法哪里出问题了，哈哈。

boboyuwu 发表于 2016-2-13 21:57
反正你出概率的题我就不想做了 高中概率没及格过

你都那么多分了，不做也行了。赏我点{:2_38:}

wusiyi 发表于 2016-2-13 22:23
我网上找了一下公式，发现确实是你的那个答案，不过21的时候并不是趋近于0。我也想通了我原来的想法哪里出 ...

楼主，这个公式也做出来了，分就给我把。啊哈哈。

boboyuwu 发表于 2016-2-13 21:17
代码：
import java.util.Scanner;
class GaiLv

啊哈哈，这想法是错的，我之前也是这么想的。

wusiyi 发表于 2016-2-13 23:07
楼主，这个公式也做出来了，分就给我把。啊哈哈。

我让洋葱给你分了。。。

都未中奖概率   初中学的还给老师了        占楼编辑概率是硬伤 初学不易
import java.util.Scanner;
public class Test1 {
        public static void main(String[] args) {
                System.out.println("请输入参与抽奖的人数");
                Scanner PP=new Scanner(System.in);
                float p=PP.nextFloat();
                double chance;
                //double chance= "!!!求中奖概率!!!!!";
                chance*=100;       
                System.out.printf("所有人都没中奖的概率为%.2f",chance);
                System.out.println("%");
                }
}

酱油 发表于 2016-2-15 21:30
我让洋葱给你分了。。。

{:2_32:}楼主你真棒！哈哈。

概率公用程序直接写上去貌似有点简单，所以用递归模拟了下这个过程。
根据概率定义写的，算出事件总数sum，再算出每个人都抽不到自己的事件数signal， signal/sum就是所求概率
假设有n个人，n就代表第n个人的名字，可以用集合模拟，只要第n个人不抽到数字n也就是不抽到自己，
例如有4个人, 3,2,1,0 对应抽到的名字 0,1,2,3这就算一种情况，用递归先抽第n个人的卡片，接着n-1，直到第1个人
。但是貌似这样内存有点吃不消，有人能帮忙修改下吗，实在没办法优化。

1. package com.heima;
   
2. 
   
3. import java.util.ArrayList;
   
4. import java.util.Scanner;
   
5. 
   
6. /*问题要求：用键盘输入一个整数P表示参加抽奖活动的人数。
   
7. 程序运行，输出结果为所有人都没中奖的概率。用百分号表示，四舍五入保留两位小数。
   
8. 如输入2，结果运行输出答案应该是50.00%*/
   
9. 
   
10. //总的思路，就使用集合模拟抽取过程，用集合索引n对应第n个人，集合中元素则装载着对应卡片
    
11. public class Test10 {
    
12.         // 装载抽不到自己名字卡片的组合集合
    
13.         static ArrayList<Integer> list = new ArrayList<>();
    
14. 
    
15.         public static void main(String[] args) {
    
16.                 Scanner sc = new Scanner(System.in);
    
17.                 System.out.println("请输入参加活动人数:");
    
18.                 while (true) {
    
19.                         int n = sc.nextInt();
    
20.                         ArrayList<Integer> arr = new ArrayList<>();
    
21.                         // 模拟抽奖盒子有n张卡片,把n张卡片一一对应添加进集合arr，从0开始
    
22.                         init(arr, n);
    
23.                         // 是否打印所有抽不到自己名字卡片的排列组合
    
24.                         System.out.println("请选择是否打印结果('1'为'是'):");
    
25.                         int print = sc.nextInt();
    
26.                         // 计算所有人都抽不到自己名字卡片概率并精确到指定精度
    
27.                         double pro = (double) eventNotSelf(arr, print) / (double) eventSum(arr);
    
28.                         StringBuffer strPro = new StringBuffer(String.valueOf(Math.round(pro * 10000)));
    
29.                         System.out.println("所有人都没中奖概率:" + strPro.insert(2, ".") + "%");
    
30.                 }
    
31.         }
    
32. 
    
33.         // 模拟把n张卡片装进抽奖盒子
    
34.         public static void init(ArrayList<Integer> arr, int n) {
    
35. 
    
36.                 for (int i = 0; i < n; i++) {
    
37.                         arr.add(i);
    
38.                 }
    
39.         }
    
40. 
    
41.         // 计算n个人不放回地从盒子中抽1张卡片事件数总和
    
42.         public static int eventSum(ArrayList<Integer> arr) {
    
43.                 int count = 0;
    
44.                 // 卡片全抽完，事件数总和加1
    
45.                 if (arr.size() == 1) {
    
46.                         return 1;
    
47.                 }
    
48.                 // 模拟卡片抽取，第arr.size个人可以抽取盒子当前任意卡片，每种可能都要计算
    
49.                 for (int i = 0; i < arr.size(); i++) {
    
50.                         // 第arr.size个人拿出写着arr.get(i)名字卡片
    
51.                         int temp = arr.get(i);
    
52.                         // 盒子中去除此卡片
    
53.                         arr.remove(i);
    
54.                         // 第arr.size-1个人拿盒子中剩余的卡片，事件总数累加
    
55.                         count = count + eventSum(arr);
    
56.                         // 回到第arr.size个人，他还有可能抽写着非arr.get(i)名字卡片，所以放回arr.get(i)卡片，抽其他人名字卡片
    
57.                         arr.add(i, temp);
    
58.                 }
    
59.                 // 返回事件总和数
    
60.                 return count;
    
61.         }
    
62. 
    
63.         // 抽不到自己名字卡片的事件总和数,print=1打印每个人对应抽到的卡片
    
64.         public static int eventNotSelf(ArrayList<Integer> arr, int print) {
    
65.                 int count = 0;
    
66.                 // 模拟卡片抽取，第arr.size个人可以抽取盒子当前任意非自己名字卡片，每种可能都要计算
    
67.                 for (int i = 0; i < arr.size(); i++) {
    
68.                         // 第arr.size个人拿出写着arr.get(i)名字卡片
    
69.                         int temp = arr.get(i);
    
70.                         // 第arr.szie个人没拿到写着自己名字的卡片
    
71.                         if (temp != arr.size() - 1) {
    
72.                                 // 装载入list
    
73.                                 list.add(temp);
    
74.                                 // 如果是最后一个人，符合事件要求，每个人都没拿到自己名字卡片，事件数总和加1
    
75.                                 if (arr.size() == 1) {
    
76.                                         // 是否打印每个人抽的的卡片
    
77.                                         if (print == 1)
    
78.                                                 System.out.println(list);
    
79.                                         count = 1;
    
80.                                         // 如果不是最后一个人，则接着抽取盒子中卡片
    
81.                                 } else {
    
82.                                         // 首先从盒子中抽走arr.get(i)名字卡片
    
83.                                         arr.remove(i);
    
84.                                         // 第arr.size-1个人接着抽盒子剩余卡片,事件数总和累加
    
85.                                         count = count + eventNotSelf(arr, print);
    
86.                                         // 因为 第arr.size个人还有可能抽到非arr.get(i)名字卡片，所以放回卡片重新抽下一张
    
87.                                         arr.add(i, temp);
    
88.                                 }
    
89.                                 // 进入下一种情况，清除上一种情况
    
90.                                 list.remove(list.size() - 1);
    
91.                         }
    
92.                 }
    
93.                 return count;
    
94. 
    
95.         }
    
96. 
    
97. }
    

复制代码

666666666666666666666