Das deutsche Python-Forum

Code: Alles auswählen

import random

REPEATS = 6
CHECKS = 10000
result_counter = 0

for _ in range(0, CHECKS):
    throws = [random.choice("ZK") for throw in range(0,100)]
    old_element = "-"
    same_element_counter = 0
    
    for element in throws:
        if old_element == element:
            same_element_counter = same_element_counter + 1
        else:
            same_element_counter = 0

        old_element = element

        if same_element_counter >= REPEATS:
            result_counter = result_counter + 1
            break
        
print(f'Gefunden {result_counter} von {CHECKS} => {result_counter / CHECKS * 100} %')

Code: Alles auswählen

bj@s8n:~$ ./test
80.53% for inclusive or and at least n.
55.07% for inclusive or and exactly n.
54.50% for exclusive or and at least n.
32.58% for exclusive or and exactly n.
bj@s8n:~$ ./test
80.78% for inclusive or and at least n.
55.24% for inclusive or and exactly n.
54.73% for exclusive or and at least n.
32.41% for exclusive or and exactly n.
bj@s8n:~$ ./test
80.71% for inclusive or and at least n.
55.17% for inclusive or and exactly n.
54.45% for exclusive or and at least n.
32.50% for exclusive or and exactly n.

Code: Alles auswählen

private static string create_random_coin_flips (size_t count) {
    var result = new StringBuilder.sized (count);
    for (int i = 0; i < count; ++i) {
        result.append_c ((Random.boolean ()) ? 'H' : 'T');
    }
    return result.str;
}

private static uint count_runs (
    string text, size_t size, bool just_heads, bool exact_size
) {
    var result = 0;
    try {
        var regex = new Regex (
            "([%s])\\1{%u}".printf ((just_heads) ? "H" : "HT", (uint) size - 1)
        );
        MatchInfo match_info;
        
        regex.match (text, 0, out match_info);
        while (match_info.matches ()) {
            if (exact_size) {
                int start, end;
                match_info.fetch_pos (0, out start, out end);
                if (text[start] != text[end]) ++result;
            } else {
                ++result;
            }
            match_info.next ();
        }
    } catch (RegexError error) {
        print ("Error: %s\n", error.message);
        assert (false);
    }
    return result;
}

private static double run_experiment(
    uint repetition_count,
    uint flip_count,
    uint run_length,
    bool just_heads,
    bool exact_size
) {
    var has_run_count = 0;
    for (int i = 0; i < repetition_count; ++i) {
        var flip_results = create_random_coin_flips (flip_count);
        var run_count = count_runs (
            flip_results, run_length, just_heads, exact_size
        );
        if (run_count > 0) ++has_run_count;
    }
    return (double) has_run_count / repetition_count;
}

public static void main () {
    var repetition_count = 100000;
    var flip_count = 100;
    var run_length = 6;
    string[] or_description = {"inclusive or", "exclusive or"};
    string[] run_description = {"at least n", "exactly n"};
    
    for (var or_variant = 0; or_variant < 2; ++or_variant) {
        for (var run_variant = 0; run_variant < 2; ++run_variant) {
            print (
                "%.2f%% for %s and %s.\n",
                100 *run_experiment (
                    repetition_count,
                    flip_count,
                    run_length,
                    (bool) or_variant,
                    (bool) run_variant
                ),
                or_description[or_variant],
                run_description[run_variant]
            );
        }
    }
}

Code: Alles auswählen

import random

def werfe_muenze(anzahl):
    return [random.choice(["K", "Z"]) for i in range(0, anzahl)]
    
def zaehle_vorkommen(ergebnisse):
    buchstabenfolge = "".join(ergebnisse)
    return buchstabenfolge.count("KKKKKK"), buchstabenfolge.count("ZZZZZZ")

def main():      
    anzahl_sechserserie_kopf = 0
    anzahl_sechserserie_zahl = 0
    for i in range(0,10000):    
        anzahl_kopf, anzahl_zahl = zaehle_vorkommen(werfe_muenze(100))
        anzahl_sechserserie_kopf += anzahl_kopf
        anzahl_sechserserie_zahl += anzahl_zahl
    print(f"Kopf {anzahl_sechserserie_kopf}")
    print(f"Zahl {anzahl_sechserserie_zahl}")
    
main()

Code: Alles auswählen

#!/usr/bin/awk -f
function has_sixes(numbers,        i, repeats) {
    for (i=1; i<length(numbers); i++) {
        if (numbers[i] == numbers[i-1]) {
            repeats += 1;
        } else {
            repeats = 0;
        }
        # sic!
        if (repeats == 6) return 1;
    }
    # sic!
    if (repeats >= 6) {return 1} else {return 0};
}

BEGIN {
    srand();
    for (k=0; k<10000; k++) {
        for (j=0; j<100; j++) {
            p = rand();
            if (p<0.5) {
                numbers[j] = "K";
            } else {
                numbers[j] = "Z";
            }
        }
        stats[has_sixes(numbers)] += 1;
    }
    for (key in stats) {
        print key, stats[key]/100;
    }
}

Code: Alles auswählen

% ./flip.awk  
0 45.53
1 54.47

Code: Alles auswählen

#!/usr/bin/env python3
import random

def werfe_muenze(anzahl):
    return [random.choice(["K", "Z"]) for i in range(0, anzahl)]
    
def zaehle_vorkommen(ergebnisse):
    buchstabenfolge = "".join(ergebnisse)
    return buchstabenfolge.count("KKKKKK") > 0 or  buchstabenfolge.count("ZZZZZZ") > 0

def main():      
    sechser = 0
    for i in range(10_000):    
        resultat= zaehle_vorkommen(werfe_muenze(100))
        sechser += resultat
    print(sechser)
    
main()

Code: Alles auswählen

% ./jankie.py
8021

Code: Alles auswählen

import re
import random

pat = re.compile('1{6}')
runs = int(1e4)
choices = '0', '1'
sequence_size = 100

def has_match():
    return len(pat.findall(''.join(random.choice(choices) for _ in range(sequence_size))))

matches = sum(has_match() for _ in range(runs))
print(f'probability: {matches / runs * 100:4.1f} %')

Code: Alles auswählen

def has_match():
    return bool(pat.search(''.join(random.choice(choices) for _ in range(sequence_size))))