Алгоритм вычисления вероятностей выпадения числа при открытии книги

У меня есть книга с N <10000 страниц и числом x (в диапазоне 1 <= x <= 40). Я хочу вычислить вероятность того, что при открытии книги наугад комбинация цифр на открытых страницах книги будет равна числу.

«Уровень комбинаций» может быть разным: от простой суммы цифр (событие стр. 234 верно для x = 9) до комбинации сумм и вычитаний до пар цифр [событие стр. 124 верно для x = 1, 2, 3 (4-1), 4, 5 (4 + 1), 6 (2 + 4), 7 (1 + 2 + 4), 8 (12-4), 12, 14, 16 (14 + 2), 23 (24-1), 24, 25 (24 + 1)]

Начнем с того, что если вы откроете книгу, вы всегда получите страницу n и страницу n + 1, поэтому вероятность должна быть рассчитана для пары (2n-1,2n), для каждого n, 1

Вот что я делаю

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;
}

Первый метод вычисляет сумму цифр числа, вторая - вероятность того, что номер открытой страницы равен x, или сумма их цифр. Третья проверка также включает пары цифр.

1) Я не беру в расчет сделанную мной ранее заметку.

2) Я запустил это на мобильном устройстве.

3) Сейчас я действительно чувствую, что результаты неверны.

Мне было интересно, подойдет ли лучше таблица с предварительно рассчитанными результатами.Я знаю, что N <10000, поэтому я могу использовать массив [40] [10000] для хранения результатов для загрузки во время выполнения, но я не увлекаюсь манипуляциями с файлами в Java, кроме того, мне нужно сохранить это, скажем, для 4 различных методов вычисления вероятности, так сколько памяти это потребует? И это проблема - вычислить это во время выполнения? Есть ли лучший подход (или, возможно, уже написанный алгоритм) для этого?