Comment générer une distribution de k shots sur n ennemis

Je suppose que chaque coup a probablement atteint un mauvais bateau. Si h = 0, tous les coups vont manquer. Si h = 1, tous les coups vont frapper quelque chose em>.

Maintenant, disons que vous tirez des balles B. La valeur attendue des navires touch est simplement hs = h * b, mais ce ne sont pas des navires uniques em> hit. P>

Nous avons donc une liste de navires qui ont une liste de navires. La chance de tout navire ennemi spécifique étant frappé de Naviers ennemis est 1 / N. Par conséquent, la chance d'être dans les premiers emplacements K mais pas d'autres emplacements n'est p> xxx pré>

Notez que la réponse de Marko Topolnik. Le problème est qu'il s'agit d'un navire spécifique étant dans les premiers fentes K, contrairement à être dans n'importe quelle combinaison de lentes K. Nous devons la modifier en prenant sur le compte le nombre de combinaisons de klogs K dans les emplacements totaux HS: p> xxx pré>

Nous avons le risque d'un navire spécifique étant dans K emplacements. Eh bien, maintenant, nous devons envisager toute la flotte de N Navires: P>

(3 choose 1) * (1/2)^1 * (1-1/2)^(3-1) * 2
3 * 0.5 * 0.25 * 2 = 0.75

(3 choose 2) * (1/2)^2 * (1-1/2)^(3-2) * 2
3 * 0.5^2 * 0.5 * 2 = 0.75

(3 choose 3) * (1/2)^3 * (1-1/2)^(3-3) * 2
1 * 0.5^3 * 1 * 2 = 0.25

0.75 + 0.75*2 + 0.25*3 = 3 == Hs  **TRUE**

Si vous avez des navires et tirez des coups de feu, chaque numéro de hits de chaque navire suivra une distribution binominale où p = 1 / s et n = A:

http://fr.wikipedia.org/wiki/binomial_distribution

Vous pouvez interroger cette distribution et demander:

• Quelle est la probabilité qu'un navire soit frappé 0 fois?
• Quelle est la probabilité qu'un navire soit frappé 1 fois?
• Quelle est probablement que pour un navire d'être frappé 2 fois?
• Quelle est la probabilité qu'un navire soit frappé (santé max) ou plus? (Astuce: il suffit de soustraire 1,0 de tout ci-dessous)

  et multipliez-les par le nombre de navires, s, pour obtenir le nombre de navires que vous vous attendez à être frappé 0, 1, 2, 3, etc.. Cependant, comme il s'agit d'une attente et non d'un résultat rodé au hasard, les batailles iront exactement de la même manière à chaque fois.

  Si vous avez un faible nombre de navires, un nombre élevé de tirs, vous pouvez rouler une fois la distribution binominale une fois par bateau. Ou si vous avez un faible nombre de tirs, un nombre élevé de navires, vous pouvez placer au hasard chaque coup. Je n'ai pas encore pensé de manière cool d'obtenir la distribution aléatoire (ou une approximation aléatoire de celle-ci) du nombre élevé de tirs et de nombres élevés de coups de feu, mais il serait génial d'en savoir qu'un :)

a compris une façon de résoudre ce problème, et finalement jeté pour l'écrire à Java. Cela donne une solution exacte pour calculer la probabilité de M code> N'ayant pas été touchée donnée k code> navires et n code> coups. C'est cependant assez coûteux. Premièrement, un résumé de ce que j'ai fait:

La protabilité est égale au nombre total de façons de photographier les navires avec exactement m code> non frappé par le nombre total de façons de tirer des navires. xxx pré>

total est k ^ n code>, car chaque tir peut toucher l'un des navires k code> p>

Pour obtenir le numérateur, commencez par ncr (k, m) code>. Ceci est le nombre de façons de choisir m code> navires pour ne pas être touché. Ceci multiplié par le nombre de moyens de frapper km code> sans manquer est la probabilité totale. P> xxx pré>

maintenant pour calculer le second terme du numérateur . C'est la somme de toutes les distributions des plans de combien de façons qu'il existe pour une certaine distribution de tir. Par exemple, si 2 navires sont touchés par 3 balles, et chaque navire est touché au moins une fois, ils peuvent être touchés de la manière suivante: p> xxx pré>

Les distributions de tir sont égales à la longueur des compositions de K. Dans ce cas, nous aurions [2,1] et [1,2], la longueur 2 compositions de 3. P>

pour la première composition, [2,1], nous pouvons calculer le nombre de façons de générer ceci en choisissant 2 coups sur les 3 tirs pour frapper le premier navire, puis 1 des 1 tirs restants pour frapper le second, c'est-à-dire NCR (3,2) * NCR (1,1) . Notez que nous pouvons simplifier cela à 3! / (2! * 1!) Code>. Ce motif s'applique à toutes les pattes de tir, de sorte que le nombre de manières qu'un certain motif, p code> peut se produire peut être écrit comme n! / Prodsum (j = 1, km, p_j!) code>, dans lequel la notation indique la somme du produit de 1 à km code>, j code> est un index et p_j code> représente le J code> thème terme dans p code>. p>

si nous définissons p code> comme jeu de toutes les longueurs km code> COMPOSITIONS DE N CODE>, La probabilité de M CODE> Navires non frappés est alors: p>

import java.util.ArrayList;
import java.util.Arrays;
import org.apache.commons.math3.util.ArithmeticUtils;

class Prob{
    public boolean listsEqual(Integer[] integers, Integer[] rootComp){
        if(integers.length != rootComp.length){
            return false;
        }
        for (int i = 0; i < integers.length; i++){
            if(integers[i] != rootComp[i]){return false;};
        }       
        return true;
    }

    public Integer[] firstComp(int base, int length){
        Integer[] comp = new Integer[length];
        Arrays.fill(comp, 1);
        comp[0] = base - length + 1;
        return comp;        
    }

    public Integer[][] enumerateComps(int base, int length){
        //Provides all compositions of base of size length

        if(length > base){return null;};
        Integer[] rootComp = firstComp(base, length);
        ArrayList<Integer[]> compsArray = new ArrayList<Integer[]>();

        do {
            compsArray.add(rootComp);
            rootComp = makeNextComp(rootComp);
        } while(!listsEqual(compsArray.get(compsArray.size() - 1), rootComp));

        Integer[][] newArray = new Integer[compsArray.size()][length];

        int i = 0;
        for (Integer[] comp : compsArray){
            newArray[i] = comp;
            i++;
        }

        return newArray;
    }

    public double getProb(int k, int n, int m){
        //k = # of bins
        //n = number of objects
        //m = number of empty bins

        //First generate list of length k-m compositions of n

        if((n < (k-m)) || (m >= k)){
            return 0;
        }

        int[] comp = new int[n-1];

        Arrays.fill(comp, 1);

        comp[0] = n - (k-m) + 1;

        //Comp is now the first 
        Integer[][] L = enumerateComps(n, k-m);

        double num = 0;
        double den = Math.pow(k, n);
        double prodSum;
        int remainder;

        for(Integer[] thisComp : L){
            remainder = n;
            prodSum = 1;
            for(Integer thisVal : thisComp){
                prodSum = prodSum * ArithmeticUtils.binomialCoefficient(remainder, thisVal);

                remainder -= thisVal;
            }

            num += prodSum;
        }

        return num * ArithmeticUtils.binomialCoefficient(k, m) / den;
    }

    public Integer[] makeNextComp(Integer[] rootComp){
        Integer[] comp = rootComp.clone();

        int i = comp.length - 1;
        int lastVal = comp[i];
        i--;

        for(; i >=0 ; i--){
            if (comp[i] != 1){
                //Subtract 1 from comp[i]
                comp[i] -= 1;
                i++;
                comp[i] = lastVal + 1;
                i++;
                for(;i < comp.length; i++){
                    comp[i] = 1;
                };
                return comp;                
            }
        }
        return comp;
    }
}


public class numbersTest {
    public static void main(String[] args){
        //System.out.println(ArithmeticUtils.binomialCoefficient(100,50));
        Prob getProbs = new Prob();

        Integer k = 10; //ships
        Integer n = 10; //shots
        Integer m = 4; //unscathed

        double myProb = getProbs.getProb(k,n,m);

        System.out.printf("Probability of %s ships,  %s hits, and %s unscathed: %s",k,n,m,myProb);
    }
}