java計算概率

① java程序：編寫生成100個1-6之間的隨機數，統計1—6每個出現的概率，菜鳥看不懂程序

1.用內置方法Math.random()產生一個隨機數介於0～1。
2.強制轉化為int類型，根據int類型的特點，這個數是0～5之間的整數。
3.得到的數加1，這樣這個數就是介於1～6的整數，並且是隨機的。
4.將介於1～6之間的這個整數賦值給randomNum
5.（重點）probability是個數組，這個程序的演算法就是：利用probability這個數組記錄隨機數出現的次數，probability[0]記錄隨機數1出現的次數，就是當出現的隨機數為1時，數組的probability[randomNum-1]項加1（randomNum-1是為了表現演算法，實際的程序中是不需要先加1再減1的）。同理：其它的隨意數也做這樣的處理。這樣，probability這個數組中[0]項保存的是1的出現次數，[1]項保存的是2出現的次數…………
6.輸出隨機數的值（後面加個空格「\t」）
7.循環到步驟第1.個步驟.

② 初學java，突然想算一下買20年雙色球中一等獎概率，用java編譯時沒出錯，運行時出錯了。問一下哪錯了。

classSsq{
	publicstaticvoidmain(String[]args){
		//Gailvaa=newZonggailv();
		System.out.println(Zonggailv.g());
	}
}

java裡面一般用println輸出。

③ Java編程生成100個1~6之間的隨機數,統計1~6每個數出現的概率;

• 首先:關於隨機數的生成方法
  

java里生成隨機數主要有2個方法比較常用.

1.Random類. 在java.util.包里, 有多種方法可以隨機產生int, long, double,boolean等類型

2.Math 類,在java.lang.包里, 可以生成一個[0~1)之間的隨機浮點數

*備注* :a. )使用Random需要導包,但是使用Math無需導包.

b. )Math底層還是調用了Random類的nextDouble()方法

• 其次:關於隨機數的代碼

例如生成[1,6]之間的隨機數

1 .Random的方法,生成的隨機數

Randomr=newRandom();	
intnum1=r.nextInt(6)+1;//r.next(6)生成的是0~5之間的數字,需要+1,才是[1~6]之間的數字

2. Math的方法,進行隨機數的生成

intnum=(int)(Math.random()*6)+1;
//(int)(Math.random()*6)生成的是0~5之間的整數
//需要+1才是[1~6]的數字

• 關於次數統計的方案

  1, 可以使用HashMap<K,V>的方法進行存儲統計. 因為key不重復,所以key可以來存數字1~6, 而對應的V就可以用來存儲出現的次數

2. 可以使用數組的方法來存出現的次數. 數字1~6 是連續的, 數組下標也是連續的.我們可以用下標[0~5] 來代表數字[1~6], 數組的每個格子用來存數字數字出現的次數

• 完整的代碼

//本題使用數組來寫代碼比較方便,簡潔.
importjava.util.Random;

publicclassRandomDemo{
	publicstaticvoidmain(String[]args){
		int[]times=newint[6];//6個格子的數組,存儲出現的次數
		intn=100;//循環的次數
		Randomr=newRandom();
		for(inti=0;i<n;i++){
			intnum=r.nextInt(6)+1;//方法1隨機產生1~6的數字
			//intnum=(int)(Math.random()*6)+1;//方法2隨機產生1~6的數字
			times[num-1]=times[num-1]+1;//次數增加1
		}
		
		for(inti=0;i<times.length;i++){
			System.out.println((i+1)+"出現的次數"+times[i]);
		}
	}
}

輸出: 當n=100時

1出現的次數13
2出現的次數16
3出現的次數17
4出現的次數23
5出現的次數21
6出現的次數10

輸出: 當n=1000時

1出現的次數160
2出現的次數177
3出現的次數161
4出現的次數169
5出現的次數175
6出現的次數158

• 結論:

  n=100時, 6是次數是10, 4次數是23, 兩者的次數相差2倍多

  n=1000時, 6次數是158, 2次數是177, 兩者比較接近

  說明: 當隨機的次數越多. 那麼隨機數的概率也越來越接近~

④ java投擲骰子，求點數的出現概率

很簡單 。
int [] num = new int[3]; //數組長度為3
int diag=0; //統計出現5的次數
for(int i=0;i>3;i++){ //擲骰子三次 ,也就是三個骰子
隨機數字 num[i]=(int)(Math.random()*5)+1; //隨機1-6的數字
if(num[i]==5){
diag++; //當骰子等於5的時候，統計次數加1；
}
}
double a=diag/3; //骰子出現5的次數，除以骰子總數，得到概率。
System.out.println(a);

⑤ java中如何以不同概率產生隨機數1-30

Random rm = new Random();
int i = rm.nextInt(18);
int n = 0;
if(i > 8){
n = rm.nextInt(10)+1;
}else if(i > 2&&i <= 8){
n = rm.nextInt(11) + 10;
}else if(i<=2){
n = rm.nextInt(11) + 20;
}

這樣生成的整數n是 3/6的概率在1-10之間，2/6的概率是在10-20之間，1/6的概率是在20-30之間(這種都是偽隨機，但盡量接近概率)
你看看這樣行不行
希望對你有幫助

⑥ java集五福活動概率技術如何實現

• importjava.util.ArrayList;

• importjava.util.List;

• importjava.util.Random;

• /**

• *抽獎工具類,概率和可以不等於1

• *概率為百分數去掉百分號的部分，如10%，則為10

• *抽獎操作如下：

• *1.輸入抽獎概率集合，【抽獎概率集合為{10.0,20.0,30.0}】

• *2.生成連續集合，【生成的連續集合為{(0.0,10.0],(10.0,30.0],(30.0,60.0]}】

• *3.生成隨機數，【生成方法為random.nextDouble()*maxElement】

• *4.判斷隨機數在哪個區間內，返回該區間的index【生成了隨機數12.001，則它屬於(10.0,30.0]，返回index=1】

• *

• */

• publicclassLotteryUtil{

• /**

• *定義一個連續集合

• *集合中元素x滿足:(minElement,maxElement]

• *數學表達式為：minElement<x<=maxElement

• *

• */

• publicclassContinuousList{

• privatedoubleminElement;

• privatedoublemaxElement;

• publicContinuousList(doubleminElement,doublemaxElement){

• if(minElement>maxElement){

• ("區間不合理，minElement不能大於maxElement！");

• }

• this.minElement=minElement;

• this.maxElement=maxElement;

• }

• /**

• *判斷當前集合是否包含特定元素

• *@paramelement

• *@return

• */

• publicbooleanisContainKey(doubleelement){

• booleanflag=false;

• if(element>minElement&&element<=maxElement){

• flag=true;

• }

• returnflag;

• }

• }

• privateList<ContinuousList>lotteryList;//概率連續集合

• privatedoublemaxElement;//這里只需要最大值，最小值默認為0.0

• /**

• *構造抽獎集合

• *@paramlist為獎品的概率

• */

• publicLotteryUtil(List<Double>list){

• lotteryList=newArrayList<ContinuousList>();

• if(list.size()==0){

• ("抽獎集合不能為空！");

• }

• doubleminElement=0d;

• ContinuousListcontinuousList=null;

• for(Doubled:list){

• minElement=maxElement;

• maxElement=maxElement+d;

• continuousList=newContinuousList(minElement,maxElement);

• lotteryList.add(continuousList);

• }

• }

• /**

• *進行抽獎操作

• *返回：獎品的概率list集合中的下標

• */

• publicintrandomColunmIndex(){

• intindex=-1;

• Randomr=newRandom();

• doubled=r.nextDouble()*maxElement;//生成0-1間的隨機數

• if(d==0d){

• d=r.nextDouble()*maxElement;//防止生成0.0

• }

• intsize=lotteryList.size();

• for(inti=0;i<size;i++){

• ContinuousListcl=lotteryList.get(i);

• if(cl.isContainKey(d)){

• index=i;

• break;

• }

• }

• if(index==-1){

• ("概率集合設置不合理！");

• }

• returnindex;

• }

• publicdoublegetMaxElement(){

• returnmaxElement;

• }

• publicList<ContinuousList>getLotteryList(){

• returnlotteryList;

• }

• publicvoidsetLotteryList(List<ContinuousList>lotteryList){

• this.lotteryList=lotteryList;

• }

• }

該工具類的基本思想是，將抽獎概率分布到數軸上，如現有三個抽獎概率10、20、30，將三者依次添加到概率集合中，則構造的數軸為：0~10范圍內表示概率10，10~30范圍內表示概率為20，30~60范圍內表示概率為30，數軸上的長度對應著相應的概率。由這種處理方式可知，概率總和並不需要等於1。該工具類的成功與否在於Random.nextDouble()能否等概率地生成0~1之間的任意一個數。

對該抽獎工具進行測試，測試類如下：

[java]view plain

• packagecom.lottery;

• importjava.util.ArrayList;

• importjava.util.HashMap;

• importjava.util.List;

• importjava.util.Map;

• importjava.util.Map.Entry;

• classResult{

• privateintindex;

• privateintsumTime;

• privateinttime;

• privatedoubleprobability;

• privatedoublerealProbability;

• publicintgetIndex(){

• returnindex;

• }

• publicvoidsetIndex(intindex){

• this.index=index;

• }

• publicintgetTime(){

• returntime;

• }

• publicvoidsetTime(inttime){

• this.time=time;

• }

• publicintgetSumTime(){

• returnsumTime;

• }

• publicvoidsetSumTime(intsumTime){

• this.sumTime=sumTime;

• }

• publicdoublegetProbability(){

• returnprobability;

• }

• (){

• returnrealProbability;

• }

• publicvoidsetRealProbability(doublerealProbability){

• this.realProbability=realProbability;

• }

• publicResult(){

• }

• publicResult(intindex,intsumTime,inttime,doublerealProbability){

• this.setIndex(index);

• this.setTime(time);

• this.setSumTime(sumTime);

• this.setRealProbability(realProbability);

• }

• publicStringtoString(){

• return"索引值："+index+"，抽獎總數："+sumTime+"，抽中次數："+time+"，概率："

• +realProbability+"，實際概率："+(double)time/sumTime;

• }

• }

• publicclassTestLottery{

• staticfinalintTIME=100000;

• publicstaticvoiditeratorMap(Map<Integer,Integer>map,List<Double>list){

• for(Entry<Integer,Integer>entry:map.entrySet()){

• intindex=entry.getKey();

• inttime=entry.getValue();

• Resultresult=newResult(index,TIME,time,list.get(index));

• System.out.println(result);

• }

• }

• publicstaticvoidmain(String[]args){

• //構造概率集合

• List<Double>list=newArrayList<Double>();

• list.add(20d);

• list.add(80d);

• list.add(50d);

• list.add(30d);

• LotteryUtilll=newLotteryUtil(list);

• doublesumProbability=ll.getMaxElement();

• Map<Integer,Integer>map=newHashMap<Integer,Integer>();

• for(inti=0;i<TIME;i++){

• intindex=ll.randomColunmIndex();

• if(map.containsKey(index)){

• map.put(index,map.get(index)+1);

• }else{

• map.put(index,1);

• }

• }

• for(inti=0;i<list.size();i++){

• doubleprobability=list.get(i)/sumProbability;

• list.set(i,probability);

• }

• iteratorMap(map,list);

• }

• }


運行結果：




由結果可知，抽獎100000時， 得到的實際概率基本與正式概率相當。

以下說明此類調用方式：

[java]view plain

• publicLotteryUtil(List<Double>list)

• 說明：構造方法，傳入參數為一個概率集合

[java]view plain

• publicintrandomColunmIndex()

• 功能：進行抽獎操作，返回List集合的索引下標，此下標對應的概率的獎品即為抽中的獎品

⑦ 求java演算法：根據物品的數量來確定抽獎的概率(當物品數量為0時無論如何都不可能選到)

public class Lottery {

private int m = 1000;//發放獎券的數量
private int n = 2;//獎品的數量

public boolean getLottery(){
boolean isLottery = false;
double d = (double)n/(double)m;//中獎概率
double r = Math.random();//0~1之間的隨機數，包括0
if(r<d){//如果隨機數小於概率 那麼中獎
n--;//獎品數量-1
isLottery = true;
}
m--;//獎券數量-1
return isLottery;
}

}