A. 抽奖概率的计算
/*
* 下面方法是在考虑奖项有名额限制的情况下
* 暂定一等奖1名 二等奖 2名 3等级3名 幸运奖10名
* 中奖方法适用math.random(1000)
*/
Integer one = 1;
Integer two = 2;
Integer three = 3;
Integer lucky = 10;
public Integer Lottery(){//返回值：1-一等奖 2-二等奖 3-三等奖 4-幸运奖 0-不中奖
Integer ranNum = (int)(Math.random()*1000);
System.out.println(ranNum);
if(ranNum>=0&&ranNum<10)//获奖范围内
{
if(ranNum==0)//获得0 概率为0.1%
{
if(one>0)
{
one--;
return 1;
}
if(two>0)
{
two--;
return 2;
}
if(three>0)
{
three--;
return 3;
}
if(lucky>0)
{
lucky--;
return 4;
}
}
if(ranNum>=0&&ranNum<2)
{
if(two>0)
{
two--;
return 2;
}
if(three>0)
{
three--;
return 3;
}
if(lucky>0)
{
lucky--;
return 4;
}
}
if(ranNum>=0&&ranNum<5)
{
if(three>0)
{
three--;
return 3;
}
if(lucky>0)
{
lucky--;
return 4;
}
}
if(lucky>0)
{
lucky--;
return 4;
}
}
return 0;
}
B. java编程 怎么判断它是质数 高手仔细讲下判断原因 初学者
如果数比较小，那就一个数一个数的除，很容易知道一个数是不是质数
比如我从2开始，除2，除3，除4。。。一个一个的除看有没有余数
但是如果数比较大，比方说几百位长，上千位长，那这种方法是算不过来的
java中BigInteger类有个isProbablePrime可以来判断某个数是否是质数，不过也是比较粗略的
当然对于小的数很容易遍历出来
public static boolean isPrime(int n) {
if((n%2) == 0) return false;
for(int i=3; i*i<=n; i+=2){
if(n%i==0)
return false;
}
return true;
}
大的可以用Miller-Rabin素数测试和Lucas-Lehmer测试，它是一个概率算法，返回的结果：一个数不是素数或者一个数可能是素数。
其实这都不是一个简单的java问题而是一个数学问题
C. java随机生成1-100之间的数10000次，计算出88出现得概率
package zhangyw.test;
import java.util.Random;
public class T {
public static void main(String[] args) throws Exception {
int count = 0;
Random random = new Random();
for (int i = 0; i < 10000; i++) {
int value = random.nextInt(100) + 1; //nextInt方法返回的值在0-99之间，所以需要加1
if (value == 88) {
count++;
}
}
System.out.println(count / 100.0 + "%");
}
}
D. 求一段JAVA的概率算法
public class Zhuq {
public static void main(String[] args) {
List<Person> listP=new ArrayList<Person>();
listP.add(new Person("小李", "1", 200));
listP.add(new Person("小王", "2", 210));
listP.add(new Person("小赵", "3", 230));
listP.add(new Person("小孙", "4", 100));
listP.add(new Person("小钱", "5", 3));
listP.sort(new Comparator<Person>() {
@Override
public int compare(Person o1, Person o2) {
// TODO Auto-generated method stub
return (((Person)o1).count)*(Math.random()*10+1)>(((Person)o2).count)*(Math.random()*10+1)?-1:1;
}
});
System.out.println(listP);
}
}
class Person {
String personName;
String id;
int count;
public Person(String personName, String id, int count) {
super();
this.personName = personName;
this.id = id;
this.count = count;
}
@Override
public String toString() {
return "Person [personName=" + personName + ", id=" + id + ", count=" + count + "]";
}
}
//本质还是随机数
E. JAVA中如何实现概率算法，比如打架小游戏，普通攻击概率为80%，暴击为20%。 谢谢啦
几率的算法,大家不信可以进游戏看看自己各种技能伤害加成是不是这样,例如鸟的大招... 觉醒+自身一共20%暴,2+4暴击套30%,这就是50%了
F. 概率 Java
想多了，java写出的双色球程序，红蓝球都只是一个限定范围的随机数，是不会有所谓出现的概率的。
算法只是取个随机数而已。靠什么想象。只能说能算出每个号的概率，不过是没有意义的，，因为都很小，而且一个双色球摇奖机罢了，国内生产最多几 W，为啥体彩中心是进口的几百W的设备，会多什么功能，你们自己都懂的
G. java中求概率怎么计算
我校的计算机专业介绍:
计算机科学与技术
计算机科学与技术专业面向国民经济信息化建设和发展的需要，培养具有良好的政治素质和科学素养，系统地掌握计算机科学与技术，包括计算机硬件、软件与应用的基本理论、基本知识和基本技能与方法，能在科研部门、教育部门、企事业单位、技术和行政管理部门等单位从事计算机教学、科学研究和工程应用的计算机科学与技术高级人才。主要课程有：高等数学、英语、模拟电子技术、数字逻辑、计算机原理、微型计算机技术、高级语言、汇编语言、数据结构、操作系统、数据库原理、软件工程、编译原理、计算机系统结构、通信系统原理、计算机图像处理、计算机网络、局域网工程、网络安全、电子商务、多媒体技术与应用、JAVA程序设计、计算机辅助设计等。该专业培养四年制普通本科生和民办本科生。
软件工程软件工程专业面向国民经济信息化建设和发展的需要，培养具有扎实的计算机软件基础、较强的软件开发和专业综合实践能力，并具备软件工程管理知识，具有团队合作素质，能在科研和教育部门、企事业单位、技术和行政管理部门中从事软件研发、管理和服务等工作，具有创新精神的软件工程技术人才和管理人才。主要课程有：高等数学、英语、离散数学、概率论与数理统计、C语言程序设计、面向对象程序设计、汇编语言、数据结构、数据库原理、操作系统、计算机网络、网络安全、软件工程、软件体系结构、软件测试技术、软件成熟度模型、软件质量控制、实用软件工程与项目管理、嵌入式软件设计、统一建模语言(UML)、人机交互设计、分布式系统、INTERNET程序设计、数据仓库与数据挖掘等。该专业培养四年制普通本科生和民办本科生。
网络工程网络工程本科专业培养基础扎实、知识面宽、实践应用能力强、综合素质高、适应信息时代要求的德、智、体、美全面发展的复合型网络工程高级技术人才。学生毕业后，可在政府机关、学校及其他企、事业单位从事计算机网络系统的规划与设计、网络工程的组织及实施、网络运行管理和分析、网络应用开发以及网络教学等工作。主要课程有：高等数学、英语、线性代数、概率论与数理统计、信号与系统、数据通信原理、计算机网络基础、网络操作系统、TCP/IP协议、协议分析、局域网工程、因特网及其应用、网络安全、入侵检测技术、网络系统设计与集成、Unix操作系统及应用、网络管理与维护、面向对象程序设计、数据结构、数据库系统与应用、Web技术与应用等。该专业培养四年制普通本科生和民办本科生。
H. 求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;
}
}
I. Java怎么用线性同余法跟取余法一起产生一个序列。
乱数是不重复的随机数吗?
很多算法的每一个计算步骤都是固定的，而在下面我们要讨论的概率算法，允许算法在执行的过程中随机选择下一个计算步骤。许多情况下，当算法在执行过程中面临一个选择时，随机性选择常比最优选择省时。因此概率算法可在很大程度上降低算法的复杂度。
概率算法的一个基本特征是对所求解问题的同一实例用同一概率算法求解两次可能得到完全不同的效果。这两次求解问题所需的时间甚至所得到的结果可能会有相当大的差别。一般情况下，可将概率算法大致分为四类:数值概率算法，蒙特卡罗(Monte Carlo)算法，拉斯维加斯(Las Vegas)算法和舍伍德(Sherwood)算法。
数值概率算法常用于数值问题的求解。这类算法所得到的往往是近似解。而且近似解的精度随计算时间的增加不断提高。在许多情况下，要计算出问题的精确解是不可能或没有必要的，因此用数值概率算法可得到相当满意的解。
蒙特卡罗算法用于求问题的准确解。对于许多问题来说，近似解毫无意义。例如，一个判定问题其解为“是”或“否”，二者必居其一，不存在任何近似解答。又如，我们要求一个整数的因子时所给出的解答必须是准确的，一个整数的近似因子没有任何意义。用蒙特卡罗算法能求得问题的一个解，但这个解未必是正确的。求得正确解的概率依赖于算法所用的时间。算法所用的时间越多，得到正确解的概率就越高。蒙特卡罗算法的主要缺点就在于此。一般情况下，无法有效判断得到的解是否肯定正确。
拉斯维加斯算法不会得到不正确的解，一旦用拉斯维加斯算法找到一个解，那么这个解肯定是正确的。但是有时候用拉斯维加斯算法可能找不到解。与蒙特卡罗算法类似。拉斯维加斯算法得到正确解的概率随着它用的计算时间的增加而提高。对于所求解问题的任一实例，用同一拉斯维加斯算法反复对该实例求解足够多次，可使求解失效的概率任意小。
舍伍德算法总能求得问题的一个解，且所求得的解总是正确的。当一个确定性算法在最坏情况下的计算复杂性与其在平均情况下的计算复杂性有较大差别时，可以在这个确定算法中引入随机性将它改造成一个舍伍德算法，消除或减少问题的好坏实例间的这种差别。舍伍德算法精髓不是避免算法的最坏情况行为，而是设法消除这种最坏行为与特定实例之间的关联性。
本文简要的介绍一下数值概率算法和舍伍德算法。
首先来谈谈随机数。随机数在概率算法设计中扮演着十分重要的角色。在现实计算机上无法产生真正的随机数，因此在概率算法中使用的随机数都是一定程度上随机的，即伪随机数。
产生随机数最常用的方法是线性同余法。由线性同余法产生的随机序列a1,a2,...,an满足
a0=d
an=(ban-1+c)mod m n=1,2.......
其中,b>=0, c>=0, d>=m。d称为该随机序列的种子。
下面我们建立一个随机数类RadomNumber，该类包含一个由用户初始化的种子randSeed。给定种子之后，既可产生与之相应的随机数序列。randseed是一个无符号长整型数，既可由用户指定也可由系统时间自动产生。
const unsigned long maxshort=65536L;
const unsigned long multiplier=1194211693L;
const unsigned long adder=12345L;
class RandomNumber
{
private:
//当前种子
unsigned long randseed;
public:
//构造函数，缺省值0表示由系统自动产生种子
RandomNumber(unsigned long s=0);
//产生0-n-1之间的随机整数
unsigned short Random(unsigned long n);
//产生[0，1)之间的随机实数
double fRandom(void);
};
RandomNumber::RandomNumber(unsigned long s)
{
if(s==0)
randseed=time(0);
else
randseed=s;
}
unsigned short RandomNumber::Random(unsigned long n)
{
randseed=multiplier*randseed+adder;
return (unsigned short)((randseed>>16)%n);
}
double RandomNumber::fRandom(void)
{
return Random(maxshort)/double(maxshort);
}
函数Random在每次计算时，用线性同余式计算新的种子。它的高16位的随机性较好，将randseed右移16位得到一个0-65535之间的随机整数然后再将此随机整数映射到0-n-1范围内。
对于函数fRandom,先用Random(maxshort)产生一个0-(maxshort-1之间的整型随机序列)，将每个整型随机数除以maxshort，就得到[0，1)区间中的随机实数。
下面来看看数值概率算法的两个例子:
1.用随机投点法计算π
设有一半径为r的圆及其外切四边形，如图所示。向该正方形随机投掷n个点。设落入圆内的点在正方形上均匀分布，因而所投入点落入圆内的概率为 πr^2/4r^2，所以当n足够大时，k与n之比就逼近这一概率，即π/4。由此可得使用随机投点法计算π值的数值概率算法。具体实现时，只需要在第一次象限计算即可。
double Darts(int n)
{
static RandomNumber dart;
int k=0;
for(int i=1;i<=n;i++){
double x=dart.fRandom();
double y=dart.fRandom();
if((x*x+y*y)<1)
k++;
}
return 4*k/double(n);
}
再简单举个舍伍德算法的例子。
我们在分析一个算法在平均情况下的计算复杂性时，通常假定算法的输入数据服从某一特定的概率分布。例如，在输入数据是均匀分布时，快速排序算法所需的平均时间是O(n logn)。但是如果其输入已经基本上排好序时，所用时间就大大增加了。此时，可采用舍伍德算法消除算法所需计算时间与输入实例间的这种联系。
在这里，我们用舍伍德型选择算法随机的选择一个数组元素作为划分标准。这样既能保证算法的线性时间平均性能又避免了计算拟中位数的麻烦。非递归的舍伍德型算法可描述如下:
template<class Type>
Type select(Type a[], int l, int r, int k)
{
static RandomNumber rnd;
while(true){
if(l>=r)
return a[l];
int i=l, j=l=rnd.Random(r-l+1);
Swap(a[i], a[j]);
j=r+1;
Type pivot=a[l];
while(true)
{
while(a[++i]<pivot);
while(a[--j]>pivot);
if(i>=j)
break;
Swap(a[i], a[j]);
}
if(j-l+1==k)
return pivot;
a[l]=a[j];
a[j]=pivot;
if(j-l+1<k)
{
k=k-j+l-1;
l=j+1;
}
else
r=j-1;
}
}
template <class Type>
Type Select(Type a[], int n, int k)
{
if(k<1||k>n)
throw OutOfBounds();
return select(a, 0, n-1, k);
}
平时我们一般开始考虑的是一个有着很好平均性能的选择算法，但在最坏情况下对某些实例算法效率较低。这时候我们用概率算法，将上述算法改造成一个舍伍德型算法，使得该算法对任何实例均有效。
不过在有些情况下，所给的确定性算法无法直接改造成舍伍德型算法。这时候就可以借助随机预处理技术，不改变原有的确定性算法，仅对其输入进行随机洗牌，同样可以得到舍伍德算法的效果。还是刚才的例子，换一种方法实现:
template<class Type>
void Shuffle(Type a[], int n)
{
static RandomNumber rnd;
for(int i=1;i<n;i++){
int j=rnd.Random(n-i)+i;
Swap(a[i], a[j]);
}
}
J. 如何用概率算法求根号2
想了一段时间，有一个方法，但不是太好需要使用圆周率PI！
原理：
在一个边长为1的正方形内，求下面的积分，
积分上下限为0和pi/4，被积函数为sinX
积分结果是（1-根号2/2）
应用蒙特卡罗模拟，落入上述函数内的次数为N，共试验M次，则有：
（1-根号2/2）= N/M，那么
根号2 = 2*（1-N/M）
java代码：
public static void main(String[] args) {
int CONSTANT = 1000000;
java.util.Random rnd1 = new java.util.Random(System.currentTimeMillis());
java.util.Random rnd2 = new java.util.Random(System.currentTimeMillis() / rnd1.nextLong());
int count = 0;
for(int i = 0; i < CONSTANT; i++) {
double x = rnd1.nextDouble();
double y = rnd2.nextDouble();
if(x > Math.PI / 4) {
continue;
}
if(Math.sin(x) < y) {
continue;
}
count++;
}
double value = (1 - 1.0 * count / CONSTANT) * 2;
System.out.println(value);
}
我再想想有什么其他方法，不用PI的！