2

我整个早上都在绞尽脑汁想提出以下算法，这尤其令人沮丧，因为我确信这是可能的。

我需要的是一个具有返回函数的类boolean。它可以被调用任意次数，并且将返回 trueXX%的时间。这不能是随机分布，例如：

如果比率X设置为0.6并且函数被调用100次数，我们需要返回准确60的结果。使用“剩余”的顺序无关紧要，例如：如果函数被调用99多次，则可以返回其中一个59或60true 值。

这里的诀窍是比率需要是可变的。

对于某些设置，我在多线程环境中工作，因此我将我的“hitNumber”变量保留在 anAtomicLong中以避免出现synchronization问题。

谢谢！

4

5 回答 5

9

如果您只想保持总体百分比，只需跟踪到目前为止的百分比（可能作为明确的理性），true如果您低于目标百分比或false超过目标百分比，则返回。

于 2013-09-30T15:17:00.450 回答
3

为了建立 Ben 的答案，您可以维护静态类变量以跟踪过去的函数调用。就像是：

bool myFunc( float true_percentage ) {

  count++; // where count and count_true are class static variables initialized to zero.

  if ( float( count_true ) / count >= true_percentage )
    return false;

  count_true++;
  return true;

}
于 2013-09-30T15:22:01.940 回答
3

您认为它不能是随机的标准是非常不明确的。我想您的意思是数量 T/(T+F) 与整数 T 和 F 允许的比率一样接近。

所以你最终会得到这样的东西：

class TrueFalseGenerator {

  final double ratio;
  long nTrue, nFalse;

  TrueFalseGenerator(double ratio) {
    this.ratio = ratio;
    nTrue = nFalse = 0;
  }

  synchronized boolean next() {
    long den = nTrue + nFalse;
    if (den == 0 || (double)nTrue / den < ratio) {
      nTrue++;
      return true;
    } else {
      nFalse++;
      return false;
    }
  }
}
于 2013-09-30T15:24:13.113 回答
1

这个版本只使用整数运算，不需要任何计数器：

public class Distribution {
    private int numerator;
    private int denominator;
    private int error;

    public Distribution(int numerator, int denominator) {
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public synchronized boolean next() {
        error += numerator;
        if (error >= denominator) {
            error %= denominator;
            return true;
        }

        return false;
    }
}

用法：

Distribution dist = new Distribution(6, 10); // 6 trues out of 10
dist.next(); // get next bool
于 2013-09-30T15:34:53.713 回答
1 
//algorithm 
//1st call randomize(x) from main with x as percentage
//this calls fischershuffle to shuffle the boolean array
//den calls to return bool are randomized with x trues and 100-x falses per 100 calls

class A{
public static int count=0;
public static boolean fill[]=new boolean[100];

public static void randomize(double x)
{
double totaltrue=x*100;
double totalfalse=100-totaltrue;

for(int i=0;i<100;i++)
{
if(totaltrue>0.00)
{
   fill[i]=true;
totaltrue-=1.00;
}
else
{
fill[i]=false;
totalfalse-=1.00;
}
}

fill=fischershuffle(fill);

}

static boolean fischershuffle(boolean[] ar)
  {
    Random rnd = new Random();
    for (int i = ar.length - 1; i > 0; i--)
    {
      int index = rnd.nextInt(i + 1);
      boolean a = ar[index];
      ar[index] = ar[i];
      ar[i] = a;
    }
    return ar;
  }


     public static boolean retunbool()
     {
      if(count<=100)
      {
     count++;
     return fill[count];
       }
     else{
     count=0;//resets after 100 for next 100 calls
    }
于 2013-09-30T15:40:45.653 回答