Java 一种计算数字打开书本概率的算法

我有一本写着N的书，下面是我该怎么做

使用单个方法定义一个接口

DigitCombinationStragtegy

：

Set CombinedGits（int pageNumber）

为每种组合数字的方式编写此接口的实现：SumDigitCombinationStragtegy、SubstractionDigitCombinationStragtegy等。每个策略返回它生成的组合集。这实际上是问题中最困难的部分。但是，只实现小部分要比整个过程容易，而且您可以轻松地对每个策略进行单元测试

写一个这个策略的实现，它只需要一组其他策略，并结合它们返回的所有策略

当要求一本书和一个数字N时，将两个数字初始化为0:

命中

和

未命中

。举例说明适当的策略。遍历页面（或几页），并向策略询问它生成的一组数字。对于本页（或这两页）。如果集合包含N，则增量命中。否则，增量将丢失

---

概率是hits/（hits+misses）。

计算从1中得到的总数（1）{ int maxPageNumber=Integer.valueOf（args[0]）； int randomSum=Integer.valueOf（args[1]）； PageSumPerbability psp=新的PageSumPerbability（maxPageNumber）； System.out.println（psp.getPageNumberSum（））； System.out.println（psp.getSumPageNumbers（））； System.out.printf（“随机和：%d打开页面的概率#等于随机和：%5.3f%%\n”， randomSum，100*psp.getProbabilityOfSum（randomSum））； }否则{ 系统输出打印（“用法：PageProbabilitySum”）； } } 公共页面使用概率（int maxPageNumber）{ this.pageNumberSum=新树映射（）； this.sumPageNumbers=newtreemap（）；

---

对于（int i=1；我认为我在算法方面帮不了你多少忙，尤其是当我发现你的代码很难阅读时（语言障碍），但如果您愿意预先计算它并从文件中读取，这将非常简单，而且有很多方法。也许最简单的方法是将它们放在x.y=…的形式中，并将其作为属性文件读取。（ResourceBundle.getBundle（FileNameMinsExtension.getString（“x.y”））。虽然启动时可能会将整个文件加载到内存中。@Makers_F:+1，有趣的问题。需求问题：N的最大值是多少？@user988052 N值可能设置为9999，但我几乎不认为它会设置为大于400ever@Makers_F：第127页x=15算吗（取“1”和“7”并减去“2”）？在你的第124页中，你只取相邻的数字组成数字（12和14），但你也能把非相邻的数字组合起来吗？如果可以，你能把它们倒过来吗？（比如说17，如果你有第71页，它算吗）？@Makers\u F:还有，比如说，第1479页，52算吗？（1+4）=5和（9-7）=2，然后结合5和2得到52？有趣的方法，但问题是代码不会那么可重用。我的意思是：在p.1234中，我不能在12和34上使用简单的求和实现，但我应该定义一个新的实现，只将一个数求和到“选定的对”（前3和后4，然后输出15和16），然后对所有其他相邻的夫妇都这样做。这就是为什么我会遇到一些问题，以这样一种“非主题”的方式组合数字这种方式会导致代码中存在大量冗余，而不可能重用它，但这正是我所需要的..非常好！我可以创建一个接口，该接口具有CalculateComposition方法，并将其实现作为参数传递给类，以便它可以根据我的需要管理多种类型的和/减系统

static protected int sommaCifreNumero(int numero){
    int retnum=0;
    for (char c : Integer.valueOf(numero).toString().toCharArray()){
        retnum += c - 48;
    }
    return retnum;
}

static public float calcolaProbabilitàSemplice(int da_interrogare, int ne_interroga)
{
    return (float)ne_interroga/(float)da_interrogare*100f;
}

/*
 * Questo sistema calcola le probabilità che aprendo un libro a caso, 
 * la somma delle cifre delle pagine diano il tuo numero nell'elenco del registro.
 * Se il tuo numero non può essere raggiunto, avrai sempre probabilità 0%.
 */

static public float calcolaProbabilitàLibroSemplice(int nPagine, int nRegistro)
{
    int maxNumberInterrogabile = 0;
    float retProb;
    maxNumberInterrogabile = sommaCifreNumero (nPagine);
    maxNumberInterrogabile = ((Integer.valueOf(nPagine).toString().length() == 2) && (Integer.valueOf(nPagine).toString().toCharArray()[1] -48 -1 + 9*1)>maxNumberInterrogabile) ? (Integer.valueOf(nPagine).toString().toCharArray()[1] -48 -1 + 9*1) : maxNumberInterrogabile;
    maxNumberInterrogabile = ((Integer.valueOf(nPagine).toString().length() == 3) && (Integer.valueOf(nPagine).toString().toCharArray()[2] -48 -1 + 9*2)>maxNumberInterrogabile) ? (Integer.valueOf(nPagine).toString().toCharArray()[1] -48 -1 + 9*2) : maxNumberInterrogabile;
    maxNumberInterrogabile = ((Integer.valueOf(nPagine).toString().length() == 4) && (Integer.valueOf(nPagine).toString().toCharArray()[3] -48 -1 + 9*3)>maxNumberInterrogabile) ? (Integer.valueOf(nPagine).toString().toCharArray()[1] -48 -1 + 9*3) : maxNumberInterrogabile;

    if(nRegistro>maxNumberInterrogabile)
    {
        retProb = 0.f;
        return 0.f;
    }//il numero massimo raggiungibile è inferiore al numero in registro -> non puoi essere chiamato
    int favorevoli = 0;
    for(int i=1; i<=nPagine; i++)
    {
        if(sommaCifreNumero(i)==nRegistro || i==nRegistro)
            favorevoli++;
    }

    retProb = (float) favorevoli / (float) nPagine * 100f;
    return retProb;
}

/*
 * Questo sistema è un'estensione del precedente: somma le cifre 
 * di una pagina aperta a caso, ma anche a coppie(es: p.124 può dare 12, 16, 24, 25).
 */

static public float calcolaProbabilitàLibroComplessa(int nPagine, int nRegistro)
{
    String pagstring;
    float retProb;
    int nRegLength = String.valueOf(nRegistro).length();
    int favorevoli = 0;
    int totali = 0;
    Vector<Integer> possibili;
    int number_to_add;
    int number_added;
    for(int i = 1;i<=nPagine; i++)
    {
        possibili = new Vector<Integer>();
        pagstring = Integer.valueOf(i).toString();
        for(int a=0; a+nRegLength<=pagstring.length(); a++)
        {
            String numero_selezionato = pagstring.substring(a,a+nRegLength);

            if (Integer.parseInt(numero_selezionato)<=31)  possibili.add(Integer.parseInt(numero_selezionato));
            //somma le parti prima
            for(int b=0; b<a; b++)
            {//b è l'indice iniziale della sottostringa che verrà sommata
                for(int c=1; c<=nRegLength; c++)
                {//c è l'indice +1 finale della sottostringa che verrà sommata
                    if(b+c<=a)
                    {
                        number_to_add = Integer.parseInt(pagstring.substring(b,b+c));
                        if (number_to_add!=0)
                        {
                            number_added = Integer.parseInt(numero_selezionato) + number_to_add;
                            if (number_added <31) possibili.add(number_added);
                        }
                    }
                }
            }
            //somma le parti dopo
            for(int b=a+nRegLength; b<pagstring.length(); b++)
            {
                for(int c=1; c<=nRegLength; c++)
                {
                    if(b+c<=pagstring.length())
                    {
                        number_to_add = Integer.parseInt(pagstring.substring(b,b+c));
                        if (number_to_add!=0)
                        {
                            number_added = Integer.parseInt(numero_selezionato) + number_to_add;
                            if (number_added <31) possibili.add(number_added);
                        }
                    }
                }
            }
            totali += possibili.size();
            for(int numero: possibili) favorevoli+= numero==nRegistro ? 1:0;

        }
    }
    retProb = (float)favorevoli/(float)totali * 100f;
    return retProb;
}

package misc;

import java.util.*;

/**
 * PageSumProbability
 *
 * @author Michael
 * @since 10/14/11
 */
public class PageSumProbability {

    private Map<Integer, Integer> pageNumberSum;
    private Map<Integer, List<Integer>> sumPageNumbers;

    public static void main(String[] args) {
        if (args.length > 1) {
            int maxPageNumber = Integer.valueOf(args[0]);            
            int randomSum = Integer.valueOf(args[1]);
            PageSumProbability psp = new PageSumProbability(maxPageNumber);
            System.out.println(psp.getPageNumberSum());
            System.out.println(psp.getSumPageNumbers());
            System.out.printf("random sum: %d probability of opening page # that equals random sum: %5.3f%%\n",
                    randomSum, 100*psp.getProbabilityOfSum(randomSum));
        } else {
            System.out.print("Usage: PageProbabilitySum <# pages> <random sum>");
        }
    }

    public PageSumProbability(int maxPageNumber) {
        this.pageNumberSum = new TreeMap<Integer, Integer>();
        this.sumPageNumbers = new TreeMap<Integer, List<Integer>>();

        for (int i = 1; i <= maxPageNumber; ++i) {
            int sum = this.calculateSumOfDigits(i);
            this.pageNumberSum.put(i, sum);
            List<Integer> pages = this.sumPageNumbers.get(sum);
            if (pages == null) {
                pages = new LinkedList<Integer>();
            }
            pages.add(i);
            this.sumPageNumbers.put(sum, pages);
        }
    }

    public static int calculateSumOfDigits(int pageNumber) {
        int sum = 0;
        String pageNumberAsString = String.valueOf(Math.abs(pageNumber));
        for (int i = 0; i < pageNumberAsString.length(); ++i) {
            StringBuilder digit = new StringBuilder();
            digit.append(pageNumberAsString.charAt(i));
            sum += Integer.valueOf(digit.toString());
        }

        return sum;
    }

    public double getProbabilityOfSum(int randomSum) {
        if (randomSum <= 0)
            throw new IllegalArgumentException("random sum must be greater than zero");
        double probability = 0.0;
        List<Integer> pages = this.sumPageNumbers.get(randomSum);
        if (pages != null) {
            probability = (double) pages.size()/this.pageNumberSum.size();
        }

        return probability;
    }

    public Map<Integer, Integer> getPageNumberSum() {
        return Collections.unmodifiableMap(this.pageNumberSum);
    }

    public Map<Integer, List<Integer>> getSumPageNumbers() {
        return Collections.unmodifiableMap(this.sumPageNumbers);
    }
}