python
import pandas as pd, re, os, textwrap, numpy as np, math, statistics as stats
path='/mnt/data/data_history.txt'
print(os.path.exists(path), os.path.getsize(path))
# Read CSV
df=pd.read_csv(path, dtype=str)
df.head(), df.tail(), df.shape


(            Tanggal  Waktu 1st Prize 2nd Prize  ... Cons2 Cons3 Cons4 Cons5
 0  10 Februari 2026  21:30      6112      0236  ...  2500  6393  7533  9150
 1  11 Februari 2026  03:30      9876      2992  ...  7518  7253  9528  2514
 2  11 Februari 2026  06:30      2279      9443  ...  8064  8957  3583  9130
 3  11 Februari 2026  11:30      7453      8459  ...  3498  9558  7317  0120
 4  11 Februari 2026  13:30      7814      6407  ...  9497  5878  4385  1936
 
 [5 rows x 15 columns],
          Tanggal  Waktu 1st Prize 2nd Prize  ... Cons2 Cons3 Cons4 Cons5
 634  28 Mei 2026  13:30      9454      2091  ...  3397  3112  5501  4833
 635  28 Mei 2026  17:30      5132      6039  ...  7173  6501  7531  9170
 636  28 Mei 2026  21:30      9276      6327  ...  6856  6071  9093  9312
 637  29 Mei 2026  03:30      9506      5912  ...  4509  3969  0186  2087
 638  29 Mei 2026  06:30      1808      8976  ...  8135  5670  9684  4057
 
 [5 rows x 15 columns],
 (639, 15))

python
num_cols=[c for c in df.columns if c not in ['Tanggal','Waktu']]
num_cols


['1st Prize',
 '2nd Prize',
 '3rd Prize',
 'Lucky1',
 'Lucky2',
 'Lucky3',
 'Lucky4',
 'Lucky5',
 'Cons1',
 'Cons2',
 'Cons3',
 'Cons4',
 'Cons5']

python
from collections import Counter, defaultdict
def digit_freq(series):
    cnt=Counter()
    total=0
    for s in series.astype(str):
        ss=s.zfill(4)
        cnt.update(ss)
        total += len(ss)
    return cnt,total
def freq_all_rows(rows):
    vals=df.loc[rows,num_cols].values.flatten()
    return digit_freq(pd.Series(vals))
def normalize(cnt,total):
    return {d: cnt.get(str(d),0)/total for d in range(10)}
for N in [10,20,30,50,100,200,639]:
    rows=df.index[-N:]
    cnt,total=freq_all_rows(rows)
    print('All cols last',N, 'total digits', total, cnt.most_common())
print()
for N in [10,20,30,50,100,200,639]:
    cnt,total=digit_freq(df['1st Prize'].iloc[-N:])
    print('1st Prize last',N, total, cnt.most_common())

python
# Time-specific 11:30 rows
df_1130=df[df['Waktu']=='11:30']
print(df_1130.shape, df_1130.tail())
for N in [10,20,50,100]:
    dsub=df_1130.tail(N)
    cnt,total=digit_freq(dsub['1st Prize'])
    print('1st 11:30 last', min(N,len(dsub)), cnt.most_common())
# all cols 11:30 
for N in [10,20,50,100]:
    dsub=df_1130.tail(N)
    vals=dsub[num_cols].values.flatten()
    cnt,total=digit_freq(pd.Series(vals))
    print('All cols 11:30 last', min(N,len(dsub)), cnt.most_common())
# Position freq 1st prize at 11:30 all/time last
def pos_freq(series):
    ctr=[Counter() for _ in range(4)]
    for s in series.astype(str):
        s=s.zfill(4)
        for i,ch in enumerate(s):
            ctr[i][ch]+=1
    return ctr
for label, series in [('11:30_all',df_1130['1st Prize']),('11:30_last20',df_1130['1st Prize'].tail(20)),('all_last100',df['1st Prize'].tail(100))]:
    print(label)
    ctr=pos_freq(series)
    for i,c in enumerate(ctr):
        print(i, c.most_common(10))

python
digits=list('0123456789')
def freq_vector(cnt,total):
    return np.array([cnt.get(d,0)/total for d in digits])
def standardized(vec):
    # zscore relative among digits
    m=vec.mean(); s=vec.std()
    return (vec-m)/s if s>0 else np.zeros_like(vec)
features={}
# all cols last windows
for N in [10,20,30,50,100]:
    cnt,total=freq_all_rows(df.index[-N:])
    features[f'all_last{N}']=freq_vector(cnt,total)
# first prize windows
for N in [10,20,30,50,100]:
    cnt,total=digit_freq(df['1st Prize'].iloc[-N:])
    features[f'1st_last{N}']=freq_vector(cnt,total)
# 11:30 features
for N in [10,20,50,100]:
    dsub=df_1130.tail(N)
    cnt,total=digit_freq(dsub['1st Prize'])
    features[f'1st_1130_last{N}']=freq_vector(cnt,total)
    cnt,total=digit_freq(pd.Series(dsub[num_cols].values.flatten()))
    features[f'all_1130_last{N}']=freq_vector(cnt,total)
# exponential weighted all numbers last 100
def exp_weighted_freq(rows, columns,

7    11.348874
5     7.049681
1     6.319189
8     4.212384
9    -0.224935
3    -0.941993
4    -2.884093
6    -3.621095
0    -5.694238
2   -15.563774
dtype: float64

python
# Build position scores
def pos_vec(series):
    ctr=pos_freq(series)
    arr=np.zeros((4,10))
    for i,c in enumerate(ctr):
        total=sum(c.values())
        arr[i]=[c.get(d,0)/total for d in digits]
    return arr
pos_features={}
pos_features['1st_1130_last20']=pos_vec(df_1130['1st Prize'].tail(20))
pos_features['1st_1130_last50']=pos_vec(df_1130['1st Prize'].tail(50))
pos_features['1st_all_last100']=pos_vec(df['1st Prize'].tail(100))
pos_features['1st_all_last30']=pos_vec(df['1st Prize'].tail(30))
# exponential pos last 100 first
def exp_pos_freq(rows, half_life=20):
    cnt=[{d:0.0 for d in digits} for _ in range(4)]
    totals=[0.0]*4
    selected=list(rows); L=len(selected)
    for idx,row in enumerate(selected):
        age=L-1-idx
        w=0.5**(age/half_life)
        s=str(df.loc[row,'1st Prize']).zfill(4)
        for i,ch in enumerate(s):
            cnt[i][ch]+=w
            totals[i]+=w
    arr=np.zeros((4,10))
    for i in range(4):
        arr[i]=[cnt[i][d]/totals[i] for d in digits]
    return arr
pos_features['exp_last100_hl20']=exp_pos_freq(df.index[-100:],20)
# standardize per position
pos_weight={'1st_1130_last20':1.3,'1st_1130_last50':0.7,'1st_all_last100':0.8,'1st_all_last30':0.7,'exp_last100_hl20':0.9}
pos_score=np.zeros((4,10))
for k,w in pos_weight.items():
    arr=pos_features[k]
    z=np.zeros_like(arr)
    for i in range(4):
        z[i]=standardized(arr[i])
    pos_score += w*z
for i in range(4):
    print(i, pd.Series(pos_score[i],index=digits).sort_values(ascending=False))
bbfs=list('75189')  # chosen
# overall digit base score from earlier, normalize positive? Use combined score z plus pos.
score_dict={d:score_series[d] for d in digits}
# generate top 4d with repetitions from BBFS, penalize too many repeats slightly, maybe prefer 3-4 unique
from itertools import product
cands=[]
for tup in product(bbfs, repeat=4):
    s=''.join(tup)
    unique=len(set(tup))
    # positional score plus 0.2 overall digit score, penalty if unique<3
    sc=sum(pos_score[i][digits.index(ch)] for i,ch in enumerate(tup)) + 0.18*sum(score_dict[ch] for ch in tup)
    if unique==1: sc-=5
    elif unique==2: sc-=1.5
    cands.append((sc,s,unique))
top=sorted(cands, reverse=True)[:30]
top[:20]


[(np.float64(30.140563032343273), '9558', 3),
 (np.float64(28.499460756147155), '9158', 4),
 (np.float64(26.385134094405803), '9518', 4),
 (np.float64(25.13547319618982), '7558', 3),
 (np.float64(25.132095630454586), '9758', 4),
 (np.float64(24.744031818209685), '9118', 3),
 (np.float64(24.73857082080554), '9557', 3),
 (np.float64(24.695640793823905), '9598', 3),
 (np.float64(24.451783244001454), '5558', 2),
 (np.float64(24.31068096780534), '5158', 3),
 (np.float64(23.995731780335177), '1558', 3),
 (np.float64(23.972541567551264), '9858', 3),
 (np.float64(23.4943709199937), '7158', 4),
 (np.float64(23.09746854460942), '9157', 4),
 (np.float64(23.054538517627783), '9198', 3),
 (np.float64(22.35462950413906), '1158', 3),
 (np.float64(22.196354306063984), '5518', 3),
 (np.float64(21.969607577000758), '9551', 3),
 (np.float64(21.455014052194425), '9588', 3),
 (np.float64(21.380044258252347), '7518', 4)]

python
import pandas as pd, os, re, numpy as np, math, itertools, statistics
path='/mnt/data/data_history.txt'
print(os.path.exists(path), os.path.getsize(path))
df=pd.read_csv(path, dtype=str)
df.head(), df.tail(), df.shape


(            Tanggal  Waktu 1st Prize 2nd Prize  ... Cons2 Cons3 Cons4 Cons5
 0  10 Februari 2026  21:30      6112      0236  ...  2500  6393  7533  9150
 1  11 Februari 2026  03:30      9876      2992  ...  7518  7253  9528  2514
 2  11 Februari 2026  06:30      2279      9443  ...  8064  8957  3583  9130
 3  11 Februari 2026  11:30      7453      8459  ...  3498  9558  7317  0120
 4  11 Februari 2026  13:30      7814      6407  ...  9497  5878  4385  1936
 
 [5 rows x 15 columns],
          Tanggal  Waktu 1st Prize 2nd Prize  ... Cons2 Cons3 Cons4 Cons5
 634  28 Mei 2026  13:30      9454      2091  ...  3397  3112  5501  4833
 635  28 Mei 2026  17:30      5132      6039  ...  7173  6501  7531  9170
 636  28 Mei 2026  21:30      9276      6327  ...  6856  6071  9093  9312
 637  29 Mei 2026  03:30      9506      5912  ...  4509  3969  0186  2087
 638  29 Mei 2026  06:30      1808      8976  ...  8135  5670  9684  4057
 
 [5 rows x 15 columns],
 (639, 15))

python
import pandas as pd, numpy as np, re, itertools, math, collections, os
df=pd.read_csv('/mnt/data/data_history.txt', dtype=str)

prize_cols=[c for c in df.columns if c not in ['Tanggal','Waktu']]
first_col='1st Prize'
digits=list('0123456789')

# ensure strings padded 4
for c in prize_cols:
    df[c]=df[c].str.zfill(4)

N=len(df)
# recency weights half-life 100 rows
ages=np.arange(N-1,-1,-1)  # age 0 latest
half=80
weights=np.exp(-np.log(2)*ages/half)
weights = weights / weights.mean()

def digit_counts(nums, weights=None):
    counts={d:0.0 for d in digits}
    if weights is None:
        weights=np.ones(len(nums))
    for num,w in zip(nums, weights):
        for ch in str(num).zfill(4):
            counts[ch]+=float(w)
    return counts

# Scores
all_nums = []
all_w=[]
# all prizes per row using row weight
for i,row in df.iterrows():
    w=weights[i]
    for c in prize_cols:
        all_nums.append(row[c])
        # prize rank weights maybe 1st=3, 2nd/3rd=1.5, lucky/cons=.75
        if c=='1st Prize':
            pw=3.0
        elif c in ['2nd Prize','3rd Prize']:
            pw=1.8
        else:
            pw=0.8
        all_w.append(w*pw)
all_counts=digit_counts(all_nums, all_w)

first_counts=digit_counts(df[first_col].tolist(), weights)

# recent windows first prize
windows=[20,50,100,200]
win_counts={w:digit_counts(df[first_col].tail(w).tolist()) for w in windows}

# same next slot 11:30 after 06:30 sequences (the target after latest time 06:30)
# pairs row i (06:30) -> i+1 (hopefully 11:30)
pairs=[]
for i in range(N-1):
    if df.loc[i,'Waktu']=='06:30' and df.loc[i+1,'Waktu']=='11:30':
        pairs.append(i+1)
len(pairs), pairs[-5:]


(107, [609, 615, 621, 627, 633])

python
same_slot_indices=pairs
same_slot_counts=digit_counts(df.loc[same_slot_indices, first_col].tolist())
# recent same slot, last 30
same_slot_recent_counts=digit_counts(df.loc[same_slot_indices[-30:], first_col].tolist())

# position counts for 1st Prize overall weighted, target slot, recent
pos_counts=[{d:0.0 for d in digits} for _ in range(4)]
for i,num in enumerate(df[first_col]):
    for p,ch in enumerate(num):
        pos_counts[p][ch]+=weights[i]

pos_slot_counts=[{d:0.0 for d in digits} for _ in range(4)]
for idx in same_slot_indices:
    num=df.loc[idx, first_col]
    for p,ch in enumerate(num):
        pos_slot_counts[p][ch]+=1

pos_slot_recent_counts=[{d:0.0 for d in digits} for _ in range(4)]
for idx in same_slot_indices[-30:]:
    num=df.loc[idx, first_col]
    for p,ch in enumerate(num):
        pos_slot_recent_counts[p][ch]+=1

# digit gap since last appeared in 1st prize any position
last_idx={d:None for d in digits}
for i,num in enumerate(df[first_col]):
    for ch in set(num):
        last_idx[ch]=i
gap={d:N-1-last_idx[d] if last_idx[d] is not None else N for d in digits}

# normalize counts to z-ish or min max
def norm_dict(counts):
    vals=np.array([counts[d] for d in digits], dtype=float)
    mn, mx=vals.min(), vals.max()
    if mx==mn:
        return {d:0.5 for d in digits}
    return {d:(counts[d]-mn)/(mx-mn) for d in digits}

features={}
for name, counts in [
    ('all_recent_weighted', all_counts),
    ('first_recent_weighted', first_counts),
    ('first20', win_counts[20]),
    ('first50', win_counts[50]),
    ('first100', win_counts[100]),
    ('target_slot_all', same_slot_counts),
    ('target_slot_recent', same_slot_recent_counts),
]:
    features[name]=norm_dict(counts)
# gap: maybe prefer hot (small gap) AND overdue? BBFS often use hot/recent. Let's compute recency presence = inverse gap normalized
maxgap=max(gap.values())
features['recent_presence']={d:1 - gap[d]/maxgap if maxgap else 0 for d in digits}

# weighted digit score
weights_feat={
    'all_recent_weighted':0.20,
    'first_recent_weighted':0.20,
    'first20':0.12,
    'first50':0.13,
    'first100':0.10,
    'target_slot_all':0.10,
    'target_slot_recent':0.10,
    'recent_presence':0.05
}
score={d:sum(weights_feat[k]*features[k][d] for k in weights_feat) for d in digits}
sorted_score=sorted(score.items(), key=lambda kv: kv[1], reverse=True)
sorted_score


[('1', np.float64(0.9833333333333334)),
 ('8', np.float64(0.6779585702839029)),
 ('5', np.float64(0.471736316541838)),
 ('7', np.float64(0.40454866080538987)),
 ('9', np.float64(0.3797314041197912)),
 ('0', np.float64(0.3702383186050295)),
 ('6', np.float64(0.34935696026557506)),
 ('4', np.float64(0.3207456959751745)),
 ('2', np.float64(0.2494052939215828)),
 ('3', np.float64(0.20783333333333337))]

python
# position recency for first50 and first20
def position_counts(nums, ws=None):
    pcs=[{d:0.0 for d in digits} for _ in range(4)]
    if ws is None:
        ws=np.ones(len(nums))
    for num,w in zip(nums,ws):
        for p,ch in enumerate(num):
            pcs[p][ch]+=float(w)
    return pcs

pos_first50=position_counts(df[first_col].tail(50).tolist())
pos_first20=position_counts(df[first_col].tail(20).tolist())

def norm_pos(pcs):
    return [norm_dict(pc) for pc in pcs]

np_overall=norm_pos(pos_counts)
np_slot=norm_pos(pos_slot_counts)
np_slot_recent=norm_pos(pos_slot_recent_counts)
np_first50=norm_pos(pos_first50)
np_first20=norm_pos(pos_first20)

pos_score=[]
for p in range(4):
    pos_score.append({
        d: 0.25*np_overall[p][d] + 0.20*np_slot[p][d] + 0.20*np_slot_recent[p][d] + 0.20*np_first50[p][d] + 0.15*np_first20[p][d] + 0.10*score[d]
        for d in digits
    })
for p,ps in enumerate(pos_score):
    print(p, sorted(ps.items(), key=lambda kv: kv[1], reverse=True)[:10])

bbfs=list('18579')
# all 4 digit candidates from bbfs allowing repeats? Typically 4D from BBFS can repeat? BBFS 5 digits means any number made with those digits, repeats? The source 4D can have repeated digits. If BBFS is digit set, repeats if digit in set maybe possible. Candidate list maybe can include repeats. We'll generate both distinct and allow repeat with penalty/bonus.
def cand_score(num):
    # positional + digit overall + pattern not too repeated
    s=sum(pos_score[p][ch] for p,ch in enumerate(num))
    s+=0.12*sum(score[ch] for ch in set(num))
    # slight penalty for over repeating more than 2 maybe
    cnt=collections.Counter(num)
    if max(cnt.values())>=3:
        s-=0.2
    # slight bonus if contains top 1 and 8
    if '1' in num: s+=0.05
    if '8' in num: s+=0.03
    return s

candidates=[]
for num in itertools.product(bbfs, repeat=4):
    s=cand_score(''.join(num))
    candidates.append((''.join(num),s))
top=sorted(candidates, key=lambda kv: kv[1], reverse=True)[:30]
top[:20]


[('9158', np.float64(4.035540944851757)),
 ('9118', np.float64(3.9879637503081744)),
 ('9518', np.float64(3.9226151163534726)),
 ('9198', np.float64(3.885582795249463)),
 ('9558', np.float64(3.745583952912034)),
 ('9188', np.float64(3.727125951338162)),
 ('9151', np.float64(3.671704342900726)),
 ('9598', np.float64(3.652234161294761)),
 ('9818', np.float64(3.6375761824386608)),
 ('9157', np.float64(3.6366870270577722)),
 ('7158', np.float64(3.6066200084690214)),
 ('9718', np.float64(3.59878881705817)),
 ('9117', np.float64(3.5891098325141897)),
 ('5118', np.float64(3.572678439444529)),
 ('5158', np.float64(3.5636472760030906)),
 ('7118', np.float64(3.5590428139254393)),
 ('9511', np.float64(3.558778514402442)),
 ('9551', np.float64(3.549747350961004)),
 ('9517', np.float64(3.5237611985594883)),
 ('9191', np.float64(3.5217461932984326))]

python
import os, sys, importlib.util, hashlib, csv, pandas as pd, numpy as np
print(os.path.exists('/mnt/data/data_history.txt'))
print(importlib.util.find_spec('Crypto') is not None, importlib.util.find_spec('cryptography') is not None)

python
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
from cryptography.hazmat.backends import default_backend
import pandas as pd, hashlib, csv, os, json, textwrap, numpy as np
path='/mnt/data/data_history.txt'
df=pd.read_csv(path, dtype=str)
df.tail(), df.shape, df.columns.tolist()[:5]


(         Tanggal  Waktu 1st Prize 2nd Prize  ... Cons2 Cons3 Cons4 Cons5
 634  28 Mei 2026  13:30      9454      2091  ...  3397  3112  5501  4833
 635  28 Mei 2026  17:30      5132      6039  ...  7173  6501  7531  9170
 636  28 Mei 2026  21:30      9276      6327  ...  6856  6071  9093  9312
 637  29 Mei 2026  03:30      9506      5912  ...  4509  3969  0186  2087
 638  29 Mei 2026  06:30      1808      8976  ...  8135  5670  9684  4057
 
 [5 rows x 15 columns],
 (639, 15),
 ['Tanggal', 'Waktu', '1st Prize', '2nd Prize', '3rd Prize'])

python
def aes_digits_from_seed(seed: bytes, nbytes=512):
    key = hashlib.sha256(seed).digest()  # AES-256
    nonce = hashlib.sha256(b'nonce|' + seed).digest()[:16]
    cipher = Cipher(algorithms.AES(key), modes.CTR(nonce), backend=default_backend())
    encryptor = cipher.encryptor()
    stream = encryptor.update(b'\x00'*nbytes) + encryptor.finalize()
    digits = [str(b % 10) for b in stream]
    return digits, key.hex(), nonce.hex(), stream.hex()[:64]

prize_cols = [c for c in df.columns if c not in ['Tanggal','Waktu']]
last_row = df.iloc[-1].to_dict()
target = "29 Mei 2026 11:30"
def seed_for(last_n):
    recent = df.tail(last_n).to_csv(index=False).encode()
    seed = b"AES-BBFS-5D|target=" + target.encode() + b"|last_n=" + str(last_n).encode() + b"|" + recent
    return seed

variants={}
for n in [1,6,24,60,120,639]:
    digits,key,nonce,streamhead=aes_digits_from_seed(seed_for(n))
    # unique order first 5, first 7
    uniq=[]
    for d in digits:
        if d not in uniq:
            uniq.append(d)
        if len(uniq)>=10: break
    # frequency first 128 digits
    from collections import Counter
    cnt=Counter(digits[:200])
    variants[n]={'uniq': ''.join(uniq[:7]), 'bbfs5': ''.join(uniq[:5]), 'cnt': cnt, 'keyprefix': key[:16], 'nonce':nonce[:16], 'streamhead':streamhead}
variants


{1: {'uniq': '4890613',
  'bbfs5': '48906',
  'cnt': Counter({'8': 23,
           '3': 23,
           '7': 23,
           '9': 22,
           '6': 21,
           '2': 20,
           '1': 19,
           '4': 17,
           '5': 17,
           '0': 15}),
  'keyprefix': 'f44810c8635fb249',
  'nonce': '881a48a077b0f0ca',
  'streamhead': '0e764fa0d8fbc1c5062f5b91ebffa6c53f6c06aeb6b508c1833f6b916371c67c'},
 6: {'uniq': '2530976',
  'bbfs5': '25309',
  'cnt': Counter({'1': 28,
           '4': 23,
           '8': 23,
           '5': 22,
           '3': 20,
           '2': 19,
           '0': 18,
           '9': 17,
           '7': 15,
           '6': 15}),
  'keyprefix': 'a99e38e913046996',
  'nonce': '36c7fca08a910314',
  'streamhead': '7a915f3f32a9021d25a67118fb0e1d18b13d7659ef6672a356798d2ad3a0f544'},
 24: {'uniq': '9135706',
  'bbfs5': '91357',
  'cnt': Counter({'0': 26,
           '9': 25,
           '5': 23,
           '8': 23,
           '3': 21,
           '6': 21,
           '4': 19,
           '2': 16,
           '1': 15,
           '7': 11}),
  'keyprefix': '5986ddb35dc8bc16',
  'nonce': 'f7f8ccdc8d918770',
  'streamhead': '130b17cb0f7fdce700c43ca0126c12a9804e9972bf8d280e0cc3919bc8799ee1'},
 60: {'uniq': '5714920',
  'bbfs5': '57149',
  'cnt': Counter({'7': 27,
           '1': 25,
           '4': 25,
           '6': 20,
           '5': 19,
           '2': 19,
           '8': 19,
           '0': 18,
           '9': 14,
           '3': 14}),
  'keyprefix': '517cc5a6d6d0146f',
  'nonce': '4c4a667ba0a31285',
  'streamhead': 'f5e3831845def75e8150e750d366a1848a89cc7281508591e7861a09285f1cf7'},
 120: {'uniq': '9804765',
  'bbfs5': '98047',
  'cnt': Counter({'8': 27,
           '4': 26,
           '2': 25,
           '5': 23,
           '9': 21,
           '6': 21,
           '3': 17,
           '0': 15,
           '1': 14,
           '7': 11}),
  'keyprefix': 'bc7fcc712119c741',
  'nonce': '6840394526c01874',
  'streamhead': 'ef08a0d6827f9c3aa54b0c78802a6d03d16f4bf8d848266091a1e76044b098c0'},
 639: {'uniq': '3914856',
  'bbfs5': '39148',
  'cnt': Counter({'9': 25,
           '8': 24,
           '3': 23,
           '0': 23,
           '2': 21,
           '4': 19,
           '6': 19,
           '1': 16,
           '5': 16,
           '7': 14}),
  'keyprefix': 'd83a6ab05b4dc621',
  'nonce': 'fff7483c6c0eb30e',
  'streamhead': 'fdc7a186c27cd03d696addab10d7ac2276c0313267b8453b1e42eb8f1ba86d4e'}}

python
from collections import Counter
bbfs_list=[v['bbfs5'] for v in variants.values()]
Counter(''.join(bbfs_list)), bbfs_list


(Counter({'9': 6,
          '4': 4,
          '8': 3,
          '0': 3,
          '5': 3,
          '3': 3,
          '1': 3,
          '7': 3,
          '6': 1,
          '2': 1}),
 ['48906', '25309', '91357', '57149', '98047', '39148'])

python
from collections import Counter, defaultdict
def weighted_digit_scores(last_n=120):
    scores=defaultdict(float)
    nrows=len(df)
    subset=df.tail(last_n)
    for idx,(i,row) in enumerate(subset.iterrows()):
        # older 0.. last_n-1. recency weight exponential/linear
        recency=(idx+1)/last_n
        w=0.5+1.5*recency
        for col in prize_cols:
            cw=2.5 if col=="1st Prize" else (1.5 if col in ["2nd Prize","3rd Prize"] else 1.0)
            for pos,ch in enumerate(str(row[col]).zfill(4)):
                scores[ch]+=w*cw
    return scores
for n in [24,60,120,639]:
    scores=weighted_digit_scores(n)
    print(n, sorted(scores.items(), key=lambda x: -x[1])[:10])