d.h. in diesem Fall
Code: Alles auswählen
a=[(1,10),(1,10)]
Code: Alles auswählen
[2,11,11,20]
Code: Alles auswählen
a=[(1,10),(1,10)]
Code: Alles auswählen
[2,11,11,20]
Im Studium mussten wir so etwas ähnliches auch schon einmal rechnen. Aber nicht in Kombination mit den anderen Tupeln der Liste. Kannst Du uns ein praktisches Anwendungsbeispiel dafür nennen? Wie sieht z.B. die Lösung für folgende Listen aus:#(x*n, x*(n-1)+y, y*(n-2)+y*2, ..., x+y*(n-1), y*n)
=((n-a)*x + a*y) # für a = 0..n
Bei dem ersten würde[(1, 10), (4, 4), (4, 4), (1, 10)]
und
[(1, 10), (4, 4), (4, 4), (1, 10), (1, 10)]
Mal provokant gefragt: Warum hast du einen Lösungsansatz angeboten, ohne die Aufgabenstellung verstanden zu haben?Blackjack hat geschrieben:Und *darauf* hätte man aufgrund Deiner spärlichen Beschreibungen kommen sollen!? Das ist nicht Dein ernst, oder?
Code: Alles auswählen
def add_card(values, card):
result = [value + card for value in values]
if card == 1:
result += [value + 10 for value in values]
return set(result)
def calculate_hand(cards):
return sorted(reduce(add_card, cards, set([0])))
def main():
print calculate_hand([1, 4, 4, 1, 1])
print calculate_hand([1, 4, 4, 1])
Fällt mir nix ein, aber ich hätte einen Einzeiler:Michael Schneider hat geschrieben:Und JETZT können wir über Optimierungen reden. Also, die Runde ist eröffnet!
Code: Alles auswählen
calculate_hand=lambda c:sorted(set(reduce(lambda s,c:[v+c for v in s]+(c==1and[v+10for v in s]or[]),c,[0])))
Code: Alles auswählen
def calculate_hand(cards):
tmp = [0]
for c in cards:
tmp = [v + c for v in tmp] + (c == 1 and [v + 10 for v in tmp] or [])
return sorted(set(tmp))
ja doch nicht so falsch.=((n-a)*x + a*y) # für jedes a der Menge 0..n
Code: Alles auswählen
def calc_hand(l):
n = l.count(1)
return map(sum, zip([sum(l)-n]*(n+1), (9*a+n for a in range(n+1))))
l = [4, 1, 7, 10, 1]
calc_hand(l)
# [23, 32, 41]
Du hast es aber mit Glücksspielen.jo_hb hat geschrieben:Also worum es dabei geht: tatsächlich um Blackjack!
Ich habe noch einmal versucht, meinen Ansatz hinsichtlich der Berechnungsgeschwindigkeit für den mehrfachen Aufruf zu optimieren - d. h. möglichst viel aus der Funktion auszulagern, was nur einmal berechnet werden muss. Da die Kombinationsmöglichkeiten aufgrund der Austauschbarkeit der Asse in der Zählung doch arg begrenzt sind und es nur 8 Asse = 9 Möglichkeiten (0-8 auf der Hand) gibt, kann man alle Kombinationen schonmal vorher abspeichern. Sowas nennen die Hacker doch "Rainbow-Table", oder?jo_hb hat geschrieben:Das mit den tupeln für alle Karten, also auch zB (4,4) liegt daran dass ich mir dachte es wäre dann irgendwie einfacher, wenn ass und andere Karten sozusagen im selben format / typ vorliegen, aber vielleicht geht's dann anders doch einfacher?
Danke jedenfalls schonmal für eure Hilfe,
Code: Alles auswählen
# Mapping Dictionary berechnen, das fuer die Anzahl der Asse die
# moeglichen Punktzahl-Kombinationen liefert
dMap = {}
for iAces in xrange(9):
dMap[iAces] = [(9 * i + iAces) for i in xrange(iAces+1)]
print dMap
def calc_hand(lCards):
"Berechnung der Punktzahl-Kombinationen aus Assen und zusammengezogenem Rest"
iAces = lCards.count(1)
iStaticValue = sum(lCards)-iAces
return map(lambda iDynValue: iDynValue + iStaticValue, dMap[iAces])
l = [4, 1, 7, 10, 1]
print calc_hand(l)