Gibt es einen prägnanteren / pythonischen Weg, dies zu tun? (Zählen der längsten Sequenz von Kopf und Zahl bei Münzwürfen)

Question

Zähle die längste Folge von Kopf und Zahl bei 200 Münzwürfen.
Ich habe dies getan - gibt es einen raffinierteren Weg, um es in Python zu tun (ohne zu verdeckt zu sein)?

import random

def toss(n):
    count = [0,0]
    longest = [0,0]
    for i in xrange(n):
        coinface = random.randrange(2)
        count[coinface] += 1
        count[not coinface] = 0

        if count[coinface] > longest[coinface]:
            longest[coinface] = count[coinface]      
        #print coinface, count, longest  

    print "longest sequence heads %d, tails %d" %tuple(longest)

if __name__ == '__main__':
    toss(200)

voir diese für das, was mich zum Spielen veranlasst hat

Answer 1

def coins(num):
    lst = [random.randrange(2) for i in range(num)]
    lst = [(i, len(list(j))) for i, j in itertools.groupby(lst)]
    tails = max(j for i, j in lst if i)
    heads = max(j for i, j in lst if not i)
    return {1: tails, 0: heads}

Answer 2

import collections, itertools, random

def makesequence(choices=2, length=200):
  return [random.randrange(choices) for _ in itertools.repeat(None, length)]

def runlengths(sequence):
  runlength_by_item = collections.defaultdict(set)
  for key, group in itertools.groupby(sequence):
    runlength_by_item[key].add(sum(1 for _ in group))
  return dict((k, max(v)) for k, v in runlength_by_item.items())

Wie Sie feststellen werden, ist dies viel mehr "entkoppelt" -- runlengths ist ein völlig allgemeiner Weg, um die maximalen Lauflängen verschiedener hashbarer Elemente in einer beliebigen Iterable zu bestimmen (sehr wiederverwendbar, wenn Sie solche Lauflängen in einer Vielzahl von verschiedenen Zusammenhängen benötigen), ebenso wie makesequence ist ein ganz allgemeiner Weg, eine Liste von Zufallszahlen zu erstellen, wenn man die Länge der Liste und die Anzahl der Auswahlmöglichkeiten für jede Zufallszahl angibt. Die Kombination dieser beiden Methoden bietet vielleicht keine optimale Punktlösung für ein bestimmtes, sehr spezifisches Problem, aber sie kommt dem schon sehr nahe, und der Aufbau einer kleinen Bibliothek wiederverwendbarer "Bausteine" wird sich langfristig viel mehr lohnen als die Lösung jedes spezifischen Problems durch vollständig eigenen Code.

Answer 3

Sie können verwenden itertools was eine viel pythonischere Art ist, dies zu tun:

def toss(n):
    rolls = [random.randrange(2) for i in xrange(n)]
    maximums = [0, 0]
    for which, grp in itertools.groupby(rolls):
        maximums[which] = max(len(list(grp)), maximums[which])

    print "Longest sequence of heads %d, tails %d" % tuple(maximums)

Answer 4

Eine weitere ineffiziente Lösung :-)

import random, re
s = ''.join(str(random.randrange(2)) for c in range(10))
print s
print max(re.findall(r'0+', s))
print max(re.findall(r'1+', s))

>>> 
0011100100
00
111
>>>

Answer 5

>>> def toss(count):
        result = []
        for i in range(count):
            result.append("HT"[random.randrange(0, 2)])
        return ''.join(result)

>>> s = toss(200)
>>> h_max = max(len(x) for x in s.split("T"))
>>> t_max = max(len(x) for x in s.split("H"))
>>> print h_max, t_max
4 6