Matematik statistik hjælp

Mit bud:

P(halvtreds) = 1 - 10/60*...*1/60 = 1 - 10!/60^10 = 0,99999999999399862825788751714678

P(tier) = P(halvtreds)*9/10 + (1-P(halvtreds))*1 = 0,9000000000006001371742112482861

Tak arne_v, det lyder meget sandsynligt - i hvert fald at de 10 andre har ca. 90% chance for at vinde!

Kan du evt. forklare udregningerne?

Hvad ville der ske hvis én person havde 50 tilmeldte, en person havde 33, to personer havde 10 tilmeldte og de sidste 7 havde 1 tilmeldt?

P(tier)=P(halvtreds)*P(tier|halvtreds) + P(ikke halvtreds)*P(tier|ikke halvtreds)

Det sidste bliver vist en lidt lang udregning, men den maa kunne laves paa lignende vis.

Hej Arne igen!

Jeg har aldrig rodet med kombinatorik og det niveau indenfor matematik, kan du evt. uddybe hvad det er du gør igen?

Evt. forklare det som et .NET programmerings-script. Meningen er nemlig, at jeg dynamisk skal kunne udregne dette (altså at det ikke er en matematikopgave) :-)

Jeg har lavet et C# program.

Det ser stærkt ud som om min udregning ovenfor er forkert.

using System;
using System.Collections.Generic;
using System.Linq;

namespace E
{
    public class Program
    {
        private static void Find(int[] n, int m, long[] good, ref long total)
        {
            if(m > 0)
            {
                for(int i = 0; i < n.Length; i++)
                {
                    if(n[i] > 0)
                    {
                        int sav = n[i];
                        n[i] = 0;
                        long[] good2 = new long[n.Length];
                        long total2 = 0;
                        Find(n, m - 1, good2, ref total2);
                        n[i] = sav;
                        for(int ix = 0; ix < n.Length; ix++)
                        {
                            good[ix] += (n[i] * good2[ix]);
                        }
                        total += (n[i] * total2);
                    }
                }
            }
            else
            {
                for(int ix = 0; ix < n.Length; ix++)
                {
                    if(n[ix] == 0)
                    {
                        good[ix]++;
                    }
                }
                total++;
            }
        }
        public static void Calc(int[] n, int m)
        {
            long[] good = new long[n.Length];
            long total = 0;
            Find(n, m, good, ref total);
            double[] p = new double[n.Length];
            for(int i = 0; i < n.Length; i++)
            {
                p[i] = good[i] / (double)total;
            }
            double sum = 0;
            for(int i = 0; i < n.Length; i++)
            {
                Console.WriteLine(n[i] + " => " + p[i]);
                sum += p[i];
            }
            Console.WriteLine(m + "=" + sum);
        }
        public static void Main(string[] args)
        {
            Calc(new int[] { 10, 1 }, 2);
            Calc(new int[] { 10, 1, 1 }, 2);
            Calc(new int[] { 50, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Calc(new int[] { 50, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Calc(new int[] { 50, 33, 10, 10, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Console.ReadKey();
        }
    }
}

En lettere optimeret udgave:

using System;
using System.Collections.Generic;

namespace E
{
    public class Program
    {
        private static void Find(int[] n, int m, long scale, long[] good, ref long total)
        {
            if(m > 0)
            {
                for(int i = 0; i < n.Length; i++)
                {
                    if(n[i] > 0)
                    {
                        int sav = n[i];
                        n[i] = 0;
                        Find(n, m - 1, scale * sav, good, ref total);
                        n[i] = sav;
                    }
                }
            }
            else
            {
                for(int ix = 0; ix < n.Length; ix++)
                {
                    if(n[ix] == 0)
                    {
                        good[ix] += scale;
                    }
                }
                total += scale;
            }
        }
        public static void Calc(int[] n, int m)
        {
            long[] good = new long[n.Length];
            long total = 0;
            Find(n, m, 1, good, ref total);
            double[] p = new double[n.Length];
            for(int i = 0; i < n.Length; i++)
            {
                p[i] = good[i] / (double)total;
            }
            double sum = 0;
            for(int i = 0; i < n.Length; i++)
            {
                Console.WriteLine(n[i] + " => " + p[i]);
                sum += p[i];
            }
            Console.WriteLine(m + "=" + sum);
        }
        public static void Main(string[] args)
        {
            Calc(new int[] { 10, 1 }, 2);
            Calc(new int[] { 10, 1, 1 }, 2);
            Calc(new int[] { 50, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Calc(new int[] { 50, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Calc(new int[] { 50, 33, 10, 10, 1, 1, 1, 1, 1, 1, 1 }, 10);
            Console.ReadKey();
        }
    }
}

og et svar fra mig