精华内容
下载资源
问答
  • Java:在圆的周长上均匀分布节点
    2021-03-04 03:06:18

    我正在用Java开发一个简单的游戏,一切都很好,除了我有一个情况,我需要在一个圆的圆周上均匀地分布节点。

    例如,如果正好有4个节点,那么一个将直接指向北方,一个指向南方,一个指向东方,一个指向西方。当然,也可能存在“偏移”,即第一个节点会稍微偏离北方,但两个相邻节点与圆心之间的90度角必须保持不变。

    下面是我得到的代码。

    private void randomizePositions(Set set)

    {

    Random rand = new Random();

    for(Node n : set)

    {

    n.x = XCENTER + rand.nextDouble() * MINRADIUS;

    n.y = YCENTER + rand.nextDouble() * MINRADIUS;

    System.out.println("for node : " + n.lbl + " x = " + n.x + " y = " +n.y);

    }

    }

    是,集合中节点的位置是随机的,如测试输出所示:

    ~/Desktop/applet$javac Graph.java

    图形.java

    节点:Bird_Food x=

    200.97455004134613 y=205.0805621943253

    204.4727596409387 y=206.26252504672223

    对于节点:鱼食x=

    203.22828002758823 y=202.30400672172576

    208.8749664329499 y=203.43454377979435

    207.72724954244495 y=202.9273879239392

    节点:猫食x=

    209.55574149936908 y=209.61827066724257

    ================================================

    所以我想知道,如果只给定一个集合中的节点总数,如何才能正确计算位置?知道吗?

    非常感谢提前提出的建议。

    更多相关内容
  • 参见英文答案 >Why does a HashMap rehash the hashcode supplied by the key object?4个以下是从简介到Java编程(Liang)的示例:import java.util.LinkedList;public class MyHashSet implements...

    参见英文答案 >

    Why does a HashMap rehash the hashcode supplied by the key object?                                    4个

    以下是从简介到Java编程(Liang)的示例:

    import java.util.LinkedList;

    public class MyHashSet implements MySet {

    // Define the default hash table size. Must be a power of 2

    private static int DEFAULT_INITIAL_CAPACITY = 16;

    // Define the maximum hash table size. 1 << 30 is same as 2^30

    private static int MAXIMUM_CAPACITY = 1 << 30;

    // Current hash table capacity. Capacity is a power of 2

    private int capacity;

    // Define default load factor

    private static float DEFAULT_MAX_LOAD_FACTOR = 0.75f;

    // Specify a load factor threshold used in the hash table

    private float loadFactorThreshold;

    // The number of entries in the set

    private int size = 0;

    // Hash table is an array with each cell that is a linked list

    private LinkedList[] table;

    /** Construct a set with the default capacity and load factor */

    public MyHashSet() {

    this(DEFAULT_INITIAL_CAPACITY, DEFAULT_MAX_LOAD_FACTOR);

    }

    /** Construct a set with the specified initial capacity and

    * default load factor */

    public MyHashSet(int initialCapacity) {

    this(initialCapacity, DEFAULT_MAX_LOAD_FACTOR);

    }

    /** Construct a set with the specified initial capacity

    * and load factor */

    public MyHashSet(int initialCapacity, float loadFactorThreshold) {

    if (initialCapacity > MAXIMUM_CAPACITY)

    this.capacity = MAXIMUM_CAPACITY;

    else

    this.capacity = trimToPowerOf2(initialCapacity);

    this.loadFactorThreshold = loadFactorThreshold;

    table = new LinkedList[capacity];

    }

    /** Remove all elements from this set */

    public void clear() {

    size = 0;

    removeElements();

    }

    /** Return true if the element is in the set */

    public boolean contains(E e) {

    int bucketIndex = hash(e.hashCode());

    if (table[bucketIndex] != null) {

    LinkedList bucket = table[bucketIndex];

    for (E element: bucket)

    if (element.equals(e))

    return true;

    }

    return false;

    }

    /** Add an element to the set */

    public boolean add(E e) {

    if (contains(e))

    return false;

    if (size > capacity * loadFactorThreshold) {

    if (capacity == MAXIMUM_CAPACITY)

    throw new RuntimeException("Exceeding maximum capacity");

    rehash();

    }

    int bucketIndex = hash(e.hashCode());

    // Create a linked list for the bucket if it is not created

    if (table[bucketIndex] == null) {

    table[bucketIndex] = new LinkedList();

    }

    // Add e to hashTable[index]

    table[bucketIndex].add(e);

    size++; // Increase size

    return true;

    }

    /** Remove the element from the set */

    public boolean remove(E e) {

    if (!contains(e))

    return false;

    int bucketIndex = hash(e.hashCode());

    // Create a linked list for the bucket if it is not created

    if (table[bucketIndex] != null) {

    LinkedList bucket = table[bucketIndex];

    for (E element: bucket)

    if (e.equals(element)) {

    bucket.remove(element);

    break;

    }

    }

    size--; // Decrease size

    return true;

    }

    /** Return true if the set contains no elements */

    public boolean isEmpty() {

    return size == 0;

    }

    /** Return the number of elements in the set */

    public int size() {

    return size;

    }

    /** Return an iterator for the elements in this set */

    public java.util.Iterator iterator() {

    return new MyHashSetIterator(this);

    }

    /** Inner class for iterator */

    private class MyHashSetIterator implements java.util.Iterator {

    // Store the elements in a list

    private java.util.ArrayList list;

    private int current = 0; // Point to the current element in list

    MyHashSet set;

    /** Create a list from the set */

    public MyHashSetIterator(MyHashSet set) {

    this.set = set;

    list = setToList();

    }

    /** Next element for traversing? */

    public boolean hasNext() {

    if (current < list.size())

    return true;

    return false;

    }

    /** Get the current element and move cursor to the next */

    public E next() {

    return list.get(current++);

    }

    /** Remove the current element and refresh the list */

    public void remove() {

    // Delete the current element from the hash set

    set.remove(list.get(current));

    list.remove(current); // Remove the current element from the list

    }

    }

    /** Hash function */

    private int hash(int hashCode) {

    return supplementalHash(hashCode) & (capacity - 1);

    }

    /** Ensure the hashing is evenly distributed */

    private static int supplementalHash(int h) {

    h ^= (h >>> 20) ^ (h >>> 12);

    return h ^ (h >>> 7) ^ (h >>> 4);

    }

    /** Return a power of 2 for initialCapacity */

    private int trimToPowerOf2(int initialCapacity) {

    int capacity = 1;

    while (capacity < initialCapacity) {

    capacity <<= 1;

    }

    return capacity;

    }

    /** Remove all e from each bucket */

    private void removeElements() {

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

    if (table[i] != null) {

    table[i].clear();

    }

    }

    }

    /** Rehash the set */

    private void rehash() {

    java.util.ArrayList list = setToList(); // Copy to a list

    capacity <<= 1; // Double capacity

    table = new LinkedList[capacity]; // Create a new hash table

    size = 0;

    for (E element: list) {

    add(element); // Add from the old table to the new table

    }

    }

    /** Copy elements in the hash set to an array list */

    private java.util.ArrayList setToList() {

    java.util.ArrayList list = new java.util.ArrayList();

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

    if (table[i] != null) {

    for (E e: table[i]) {

    list.add(e);

    }

    }

    }

    return list;

    }

    /** Return a string representation for this set */

    public String toString() {

    java.util.ArrayList list = setToList();

    StringBuilder builder = new StringBuilder("[");

    // Add the elements except the last one to the string builder

    for (int i = 0; i < list.size() - 1; i++) {

    builder.append(list.get(i) + ", ");

    }

    // Add the last element in the list to the string builder

    if (list.size() == 0)

    builder.append("]");

    else

    builder.append(list.get(list.size() - 1) + "]");

    return builder.toString();

    }

    }

    我不太关注这一部分:

    /** Ensure the hashing is evenly distributed */

    private static int supplementalHash(int h) {

    h ^= (h >>> 20) ^ (h >>> 12);

    return h ^ (h >>> 7) ^ (h >>> 4);

    }

    操作都很清楚,但是它们如何确保均匀分布的散列?

    关于此代码的另一个问题,在这部分:

    /** Add an element to the set */

    public boolean add(E e) {

    if (contains(e))

    return false;

    if (size > capacity * loadFactorThreshold) {

    if (capacity == MAXIMUM_CAPACITY)

    throw new RuntimeException("Exceeding maximum capacity");

    rehash();

    }

    int bucketIndex = hash(e.hashCode());

    // Create a linked list for the bucket if it is not created

    if (table[bucketIndex] == null) {

    table[bucketIndex] = new LinkedList();

    }

    // Add e to hashTable[index]

    table[bucketIndex].add(e);

    size++; // Increase size

    return true;

    }

    为什么不在尺寸后放置尺寸检查和重复块?

    展开全文
  • 抽奖算法 在Java中,java.lang.Math.Random()方法本身基本可以保证大量测试的情况下避免高重复,且概率分布比较平均。所以我们根据奖品的概率列表基于java.lang.Math.Random()方法实现一个抽奖的工具类: 根据奖品...

    在电商促销或一些直播小游戏中,抽奖是一种比较常见的玩法。很多时候,展现给用户的可能是一个大转盘,如下:

    3053146fa542a20e51dc5a8758165fa3.png

    通常我们会给出一堆奖品,每个奖品有各自的中奖概率,而且每个奖品可能还有库存的概念,就是说已经被抽完了的奖品是不再参与抽奖的。就拿陌陌里的这个大转盘来举例,奖品列表有爱心火箭、私人飞机、旋转木马、梦幻香水、口红、暖心奶茶、糖果、未中奖(未中奖可以看着是特殊的奖品)等8个奖品,每个奖品会根据其价值有不同的中奖概率,比如中糖果和暖心奶茶的概率高些,但中火箭的概率可能低很多。如果让你用java实现一个抽奖,你会怎么实现它呢?这正是我们今天要探讨的内容。

    抽奖算法

    在Java中,java.lang.Math.Random()方法本身基本可以保证大量测试的情况下避免高重复,且概率分布比较平均。所以我们根据奖品的概率列表基于java.lang.Math.Random()方法实现一个抽奖的工具类:

    根据奖品的中奖概率列表probabilityList计算总概率sumRate;

    根据总概率和各个奖品的概率对概率进行分块,得到分块列表blockList,比如传过来的概率列表是{0.25,0.15,0.6},那么分块区间就是0-0.25,0.25-0.4,0.4-1.0,blockList的集合就是{0.25,0.4,1.0};

    根据java.lang.Math.Random()平均概率返回0到1之间数字的特性得到nextDouble;

    把nextDouble的值按大小顺序插入到blockList中;

    返回nextDouble插入的位置

    抽奖逻辑

    有了上面的抽奖算法,接下来我们分析下抽奖的逻辑是怎么实现的。为了更贴近使用场景,除了每个奖品有中奖概率外,增加一个库存的概念。因为有时候大奖并不是无限的,可能只有一个。在促销活动进行过程中,运营人员不一定一开始就把大奖的库存放出来,毕竟留在后面才更有悬念,如果大奖一放出来就被抽走了,用户的参与热情估计就没了,因为大家都是冲着大奖来的,就跟买彩票只想中500万一个道理。

    定义一个奖品类Award,属性包含奖品名称、中奖概率、库存等。

    接下来,我们模拟一下抽奖逻辑:

    运行结果类似:

    抽奖逻辑注意事项

    上面的抽奖逻辑只是简单的单线程模拟抽奖算法的有效性,在生产环境中,还需要注意线程安全性、分布式事务等问题,抽奖都是高并发场景下,所以要处理好库存扣减以及库存扣减失败重抽等细节。

    展开全文
  • java平均分配算法

    千次阅读 2021-02-13 02:03:14
    public class Fenpei {static List listCus = new ArrayList();static List persons = new ArrayList();// static Map result = new HashMap();static List result = new ArrayList();/*** @param args*/public stat...

    public class Fenpei {

    static List listCus = new ArrayList();

    static List persons = new ArrayList();

    // static Map result = new HashMap();

    static List result = new ArrayList();

    /**

    * @param args

    */

    public static void main(String[] args) {

    int k = 0;

    List l = new ArrayList();

    // 发、数量

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

    listCus.add(i);

    }

    // 人

    for (int j = 0; j < 5; j++) {

    persons.add("person" + j);

    }

    // System.out.println(persons.size());

    int personSize = persons.size();

    for (int i = 0; i < listCus.size(); i++) {

    // System.out.println(i);

    // System.out.println(persons.get(i%personSize));

    Persons p = new Persons();

    p.setI(i);

    p.setPersonname(persons.get(i % personSize));

    result.add(p);

    }

    Iterator it = result.iterator();

    while (it.hasNext()) {

    Persons p = (Persons) it.next();

    System.out.println("哪个人 => " + p.getI() + " 分配到 "

    + p.getPersonname());

    }

    // for (int j = 1; j < persons.size() + 1; j++) {

    // System.out.println(j);

    // }

    }

    public static class Persons {

    private Integer i;

    private String personname;

    public Integer getI() {

    return i;

    }

    public void setI(Integer i) {

    this.i = i;

    }

    public String getPersonname() {

    return personname;

    }

    public void setPersonname(String personname) {

    this.personname = personname;

    }

    }

    }

    第二种方法

    public class FenpeiRen {

    /**

    * @param args

    */

    public static void main(String[] args) {

    Person p1 = new Person("NAME1", 201);

    Person p2 = new Person("NAME2", 233);

    Person p3 = new Person("NAME3", 189);

    Person p4 = new Person("NAME4", 198);

    Person p5 = new Person("NAME5", 164);

    Person p6 = new Person("NAME6", 181);

    Person p7 = new Person("NAME7", 212);

    Person p8 = new Person("NAME8", 205);

    Person p9 = new Person("NAME9", 192);

    Person p10 = new Person("NAME10", 241);

    Person p11 = new Person("NAME11", 136);

    Person p12 = new Person("NAME12", 201);

    Person p13 = new Person("NAME13", 142);

    Person p14 = new Person("NAME14", 127);

    Person p15 = new Person("NAME15", 189);

    Person p16 = new Person("NAME16", 221);

    List personList = new ArrayList();

    personList.add(p1);

    personList.add(p2);

    personList.add(p3);

    personList.add(p4);

    personList.add(p5);

    personList.add(p6);

    personList.add(p7);

    personList.add(p8);

    personList.add(p9);

    personList.add(p10);

    personList.add(p11);

    personList.add(p12);

    personList.add(p13);

    personList.add(p14);

    personList.add(p15);

    personList.add(p16);

    sort(personList,5);

    }

    /**

    * 分组函数

    *

    * @param personList

    * 总人数列表

    * @param groupCount

    * 分组数量

    */

    static void sort(List personList, int groupCount) {

    // 取得总人数

    int personSize = personList.size();

    // 如果分组数量小于personsize,则分组

    if (groupCount <= personSize) {

    // 先排序

    Collections.sort(personList, new Comparator() {

    public int compare(Person p1, Person p2) {

    return p1.get_capability().compareTo(p2.get_capability());

    }

    });

    // 可以取多少次

    int qU = (personSize / groupCount) + 1;

    List> pList = new ArrayList>();

    // 排序后的数量

    List> sortList = new ArrayList>();

    // 分组排序后的数据

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

    List getPerson = new ArrayList();

    for (int j = 0; j < groupCount; j++) {

    int index = 0;

    if (j == 0) {

    index = i + j;

    } else {

    index = (j) * groupCount + i;

    }

    if(index

    getPerson.add(personList.get(index));

    }

    }

    if(getPerson.size()>0){

    sortList.add(getPerson);

    }

    }

    //开始分配

    for (int j = 0; j < groupCount; j++) {

    List listPerson = new ArrayList();

    boolean sort = true;

    for (int i = 0; i < sortList.size(); i++) {

    //正向分

    if(sort){

    if(j

    listPerson.add(sortList.get(i).get(j));

    }

    sort=false;

    }

    else{//反向分

    if(groupCount-(j+1)=0){

    listPerson.add(sortList.get(i).get(groupCount-(j+1)));

    }

    sort=true;

    }

    }

    if(listPerson.size()>0){

    pList.add(listPerson);

    }

    }

    int m = 0;

    for (List lp : pList) {

    m++;

    System.out.print("当前第 "+m+" 组\r\n");

    int totalCa = 0;

    for(Person p : lp){

    totalCa = totalCa + p.get_capability();

    System.out.print("能力 "+p.get_capability()+" 名字 "+p.get_name());

    }

    System.out.print("总能力 "+totalCa+"\r\n");

    System.out.print("结束\r\n");

    }

    }else{

    System.out.println("无法分组,分组数量大于总人数\r\n");

    }

    // Collection.sort();

    }

    }

    分享到:

    18e900b8666ce6f233d25ec02f95ee59.png

    72dd548719f0ace4d5f9bca64e1d7715.png

    2010-05-07 13:26

    浏览 9489

    评论

    1 楼

    qiankai86

    2013-01-06

    Thank you!

    展开全文
  • Java 随机数详解

    2021-03-08 02:22:53
    Java 随机数详解## 概述Java随机数的产生方法有2种,一种是Math.random()方法,一种是Random类。Math.random()可以随机生成一个0-1的double类型浮点数。Random类需要一个随机数种子来产生一个随机数,默认构造函数...
  • 如何生成均匀分布随机整数

    万次阅读 2013-03-03 14:24:37
    之间的随机整数,并且理论上来说生成的随机整数是均匀分布的。我们就以此为基础来构造一个 [0, N-1]  的均匀分布的随机整数。 要生成 [0, N-1]  的随机整数,大多数的书上给出的方法是这样的: rand() ...
  • Java对List列表做均匀抽样算法

    千次阅读 2017-12-19 14:53:00
    * 从给定的list中做数据抽样,需要保证采样数据的均匀分布 * 步骤: * 1:将原数据分 m 份, * 2:取得每份的最小index和最大index * 3:从最小index到最大index之间取 n 个list id * 4:从原list中取出对应的id数据 ...
  • java随机数种子怎么设置

    千次阅读 2021-02-13 00:49:11
    java随机数种子怎么设置引导语:Java技术具有卓越的通用性、高效性、平台移植性和安全性,广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网,同时拥有全球最大的开发者专业社群。以下是小编...
  • 产生0-1之间一个均匀分布随机数 方法:参见《常用算法程序集》317页,徐士良。 传入参数:r--双精度实型变量指针,指向的单元存放随机数种子值//
  • java语言产生泊松分布

    2021-03-11 17:33:24
    java 语言产生符合泊松分布的随机数一、实验目的利用随机数函数rand 来产生的随机数具有一定局限性,rand 函数运用线性同余法产生的是伪随机数,即每次都一样。必须加上时间作为种子,因此不直接利用rand 函数二、...
  • 正态分布随机数生成法(java版)

    万次阅读 2013-05-13 00:34:21
    要编程得到服从均匀分布的伪随机数是容易的。C语言、Java语言等都提供了相应的函数。但是要想生成服从正态分布的随机数就没那么容易了。   得到服从正态分布的随机数的基本思想是先得到服从均匀分布的随机数,...
  • 众所周知,Java的Math.random()产生的是服从均匀分布的随机数,但是其他分布的应用也相当广泛,例如泊松分布和高斯分布(正态分布),而这些分布Java没有很好的提供(高斯分布可以利用Random类),我们需要自己编写。...
  • 均匀分布随机数 1.变换法 变换法主要分为两种:逆变换法和函数变换法 (1)逆变换法 逆变换法:如果我们希望生成服从的分布,那么可以通过U~U(0,1),Y=~F(x) (2)函数变换法 函数变换法分为一维与二维。 ...
  • Java平均分配算法

    千次阅读 2019-08-09 15:07:01
    文章目录需求算法示例多次实验结果 ...算法来自文章【数据结构与算法】一致性Hash算法及Java实践 public static int FnvHash(String key) { final int p = 16777619; long hash = (int) 2166136261L; ...
  • 以此类推,并将得到的随机整数都除以10N10^N10N ,得到一系列均匀分布的随机数 例:取w0=1234w_0=1234w0​=1234 w0=1234w02=1522756w1=2275u1=0.2275w_0=1234\qquad w_0^2=1522756\qquad w_1=2275\qquad u_1=
  • Java中实现正态随机分布

    万次阅读 2018-08-24 17:00:52
    这次内容分为两部分,如果你对算法怎么实现没兴趣的话,...如果不想自己写的话,Java util库中早就有提供好的标准正态分布的随机函数: //标准正态随机分布 public static double StandardNormalDistribution(){ ...
  • 主要介绍了Java随机数算法原理与实现方法,简单分析了随机数算法的原理并结合具体实例形式给出了java编程计算随机数的具体操作技巧,需要的朋友可以参考下
  • 使用0-1分布构建均匀分布

    千次阅读 2018-03-26 22:16:13
    1.有一个随机数发生器,能以概率p生成0,以概率1-p生成1,问如何做一个随机数发生器&...的数在1…N之间均匀分布。&nbsp; &nbsp;第一题比较简单,可以用原发生器周期性地产生2个数...
  • java-生成随机数

    2022-01-28 21:32:23
    Java 中要生成一个指定范围之内的随机数字有两种方法:一种是调用 Math 类的 random() 方法,一种是使用 Random 类。 Random 类提供了丰富的随机数生成方法,可以产生 boolean、int、long、float、byte 数组以及 ...
  • 各位大佬们,可以告诉我一下怎么解决这个问题吗? 做了好久没做出来。 N=100个点,均匀分布在一个球面上,求各点的坐标。
  • 一、概念混合同余法:用一常数与已产生的伪随机数之积的同余式做递推公式,产生均匀伪随机数的...1、混合同余法(0,1)均匀分布的随机数L=60,取k=2,c=1,n=5,l=60,x*0=1公式原理:见上第一第二步。程序:clearclck=8;c=...
  • /** * * @param totalNum 传入的数值 * @param count 分配的集合数量 * @return 返回集合 */ public static List<Integer> random(int totalNum, int count) { List<Integer>...
  • 有关算法,实验以及SLAM均匀分布关键点的重要性的更多详细信息,请参阅。 怎么跑 克隆此存储库: git clone https://github.com/BAILOOL/ANMS-Codes.git 选择您的语言: , , 或 。 确保的设置正确。 运行C ++...
  • 假如说我们目前已有一亿个注册用户,要把这些用户平均分配到10张表中,并且后续注册的用户也要均匀分配到这10张表, 表名是:user_0,user_1,user_2,user_3,user_4,...... 首先当用户注册时,如用户名为“username...
  • 正态分布的随机数

    2021-03-01 09:04:08
    一、功能产生正态分布\(N(\mu, \ \sigma^2)\)。二、方法简介正态分布的概率密度函数为\[f(x)=\frac{1}{\sqrt{2\pi}\sigma}e^{-(x-\mu)^{2}/2\sigma^{2}}\]通常用\(N(\mu, \ \sigma^2)\)表示。式中\(\mu\)是均值,\(\...
  • 泊松分布随机数

    2021-03-01 09:11:53
    一、功能产生泊松分布的随机数。二、方法简介泊松分布的概率密度函数为[f(x)=frac{lambda ^{x}e^{-lambda }}{x!} qquad xin left { 0,1,...,lambda ight }]用(P(lambda))表示。泊松分布的均值为(lambda),方差为...
  • JAVA自定义算法产生正态分布随机数

    万次阅读 2017-09-24 01:15:42
    原文章地址:http://www.cnblogs.com/zztt/p/4025207.html一、为什么需要服从正态分布的随机函数一般我们经常使用的随机数函数 Math.random() 产生的是服从均匀分布的随机数,能够模拟等概率出现的情况,例如 扔一个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 42,203
精华内容 16,881
关键字:

java均匀分布

java 订阅