def get_partitions(n, max_value=None):
     """Generates all unique integer partitions of n in decreasing order."""
     if n == 0:
         yield []
         return
 
     if max_value is None or max_value > n:
         max_value = n
 
     for i in range(max_value, 0, -1):
         for sub_partition in get_partitions(n - i, i):
             yield [i] + sub_partition
 
import math
def count_partitions(n, group_sizes):
     # Total items must match sum of group sizes
     if sum(group_sizes) != n:
         return 0
 
     # Standard formula for multinomial coefficient
     num = math.factorial(n)
     den = 1
     for size in group_sizes:
         den *= math.factorial(size)
 
     multinomial = num // den
 
     # Adjust for identical group sizes since groups are usually unlabeled
     # Count frequencies of each group size
     from collections import Counter
     counts = Counter(group_sizes)
 
     for size, freq in counts.items():
         den *= math.factorial(freq) # multiplying the denominator by freq!
 
     # Correct calculation: multinomial divided by the product of factorials of frequencies
     freq_div = 1
     for size, freq in counts.items():
         freq_div *= math.factorial(freq)
 
     total_unlabeled = multinomial // freq_div
     return multinomial, totali_unlabeled
 
def calculate_odds(partition, leng):
     """calculate birth odds foreach partition"""
     sel_day=365
     odds = ''
     p = 1.0
     for idx in range(len(partition)):
         if idx == 0:
             if partition[idx] == 1:
                 odds += str(sel_day) + '/365'
                 p = p * sel_day / 365
                 sel_day = sel_day - 1
             else:
                 for i in range(partition[idx]):
                     if i == 0:
                         odds += str(sel_day) + '/365'
                         p = p * sel_day / 365
                         sel_day = sel_day - 1
                     else:
                         odds +=  ' * ' + '1/365'
                         p = p / 365
         else:
             if partition[idx] == 1:
                 odds += ' * ' + str(sel_day) + '/365'
                 p = p * sel_day / 365
                 sel_day = sel_day - 1
             else:
                 for i in range(partition[idx]):
                     if i == 0:
                         odds += ' * ' + str(sel_day) + '/365'
                         p = p * sel_day / 365
                         sel_day = sel_day - 1
                     else:
                         odds +=  ' * ' + '1/365'
                         p = p / 365
     multinomial, unlabeled = count_partitions(leng, partition)
     p = p * unlabeled
     return odds, p, unlabeled
 
def cal_occurrance(partition, target, occurrance_times):
     target = 3
     occurrance = partition.count(no_to_occur)
     if occurrance == occurrance_times:
         print(odds)
         multinomial, unlabeled = count_partitions(leng, partition)
         print(f"Unlabeled groups (just splitting them): {unlabeled}")
         p = p * unlabeled
         print('odds = ', p)
         print(f'{no_to_occur} in one group occurrance={occurrance}')
         return p
     else:
         print(f'{no_to_occur} in one group occurrance={occurrance}')
         return 0
 
target_number = 50
print(f"Partitions for {target_number}:")
cnt = 0
total_odds = 0.0
D = []
for partition in get_partitions(target_number):
    print('----', cnt+1)
    print(partition)
    odds, p, unlabeled = calculate_odds(partition, target_number)
    D.insert(0, {'partition': partition, 'cal_string': odds, 'odds': p, 'combinations': unlabeled})
    total_odds += p
    cnt = cnt + 1
print('----')
print(f"total number of partitions: {cnt}")
print(f"total odds:{total_odds}")
print('---')
sorted_D = sorted(D, key=lambda x: x['odds'])
cnt = 0
for d in sorted_D:
    print('+++ by odds', cnt+1)
    print(d)
    cnt += 1