Prediksi dan cari polanya setiap slot untuk hasil ...

python
from pathlib import Path
p=Path('/mnt/data/PRIZE.txt')
text=p.read_text(errors='replace')
len(text), text[:1000], text[-1000:]

(96829,
 '=== HASIL EKSTRAKSI DATA PRIZE ===\n\nTanggal: 10 Februari 2026 | Waktu: 21:30\n6112  0, 3, 4, 5, 7, 8, 9\n0236  1, 4, 5, 7, 8, 9\n7341  0, 2, 5, 6, 8, 9\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 03:30\n9876  0, 1, 2, 3, 4, 5\n2992  0, 1, 3, 4, 5, 6, 7, 8\n1685  0, 2, 3, 4, 7, 9\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 06:30\n2279  0, 1, 3, 4, 5, 6, 8\n9443  0, 1, 2, 5, 6, 7, 8\n1208  3, 4, 5, 6, 7, 9\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 11:30\n7453  0, 1, 2, 6, 8, 9\n8459  0, 1, 2, 3, 6, 7\n9350  1, 2, 4, 6, 7, 8\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 13:30\n7814  0, 2, 3, 5, 6, 9\n6407  1, 2, 3, 5, 8, 9\n7690  1, 2, 3, 4, 5, 8\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 17:30\n1965  0, 2, 3, 4, 7, 8\n3041  2, 5, 6, 7, 8, 9\n1575  0, 2, 3, 4, 6, 8, 9\n------------------------------\nTanggal: 11 Februari 2026 | Waktu: 21:30\n0329  1, 4, 5, 6, 7, 8\n1406  2, 3, 5, 7, 8, 9\n7820  1, 3, 4',
 ' 5, 6, 7, 8, 9\n------------------------------\nTanggal: 05 Juni 2026 | Waktu: 06:30\n3880  1, 2, 4, 5, 6, 7, 9\n6593  0, 1, 2, 4, 7, 8\n1287  0, 3, 4, 5, 6, 9\n------------------------------\nTanggal: 05 Juni 2026 | Waktu: 11:30\n0286  1, 3, 4, 5, 7, 9\n3289  0, 1, 4, 5, 6, 7\n2094  1, 3, 5, 6, 7, 8\n------------------------------\nTanggal: 05 Juni 2026 | Waktu: 13:30\n6509  1, 2, 3, 4, 7, 8\n1353  0, 2, 4, 6, 7, 8, 9\n8324  0, 1, 5, 6, 7, 9\n------------------------------\nTanggal: 05 Juni 2026 | Waktu: 17:30\n0161  2, 3, 4, 5, 7, 8, 9\n0732  1, 4, 5, 6, 8, 9\n2684  0, 1, 3, 5, 7, 9\n------------------------------\nTanggal: 05 Juni 2026 | Waktu: 21:30\n3556  0, 1, 2, 4, 7, 8, 9\n1825  0, 3, 4, 6, 7, 9\n7505  1, 2, 3, 4, 6, 8, 9\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 03:30\n4489  0, 1, 2, 3, 5, 6, 7\n2655  0, 1, 3, 4, 7, 8, 9\n6575  0, 1, 2, 3, 4, 8, 9\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 06:30\n1709  2, 3, 4, 5, 6, 8\n4932  0, 1, 5, 6, 7, 8\n8660  1, 2, 3, 4, 5, 7, 9')

python
import re, pandas as pd, numpy as np, math, itertools, statistics, json, textwrap, os
from pathlib import Path
text=Path('/mnt/data/PRIZE.txt').read_text(errors='replace')

months = {
    'Januari':1,'Februari':2,'Maret':3,'April':4,'Mei':5,'Juni':6,'Juli':7,
    'Agustus':8,'September':9,'Oktober':10,'November':11,'Desember':12
}
records=[]
blocks=re.split(r'-{10,}', text)
for block in blocks:
    header=re.search(r'Tanggal:\s*(\d{1,2})\s+(\w+)\s+(\d{4})\s*\|\s*Waktu:\s*(\d{2}:\d{2})', block)
    if not header: 
        continue
    day, mon, year, time = header.groups()
    date=pd.Timestamp(int(year), months[mon], int(day))
    lines=re.findall(r'(?m)^\s*(\d{4})\s+([0-9,\s]+)\s*$', block)
    # Sometimes last block no separator but ok
    for rank,(num, exclstr) in enumerate(lines, start=1):
        excl=tuple(int(x) for x in re.findall(r'\d', exclstr))
        records.append({
            'date':date, 'time':time, 'rank':rank, 'num':num,
            'd1':int(num[0]), 'd2':int(num[1]), 'd3':int(num[2]), 'd4':int(num[3]),
            'exclude':excl
        })
df=pd.DataFrame(records).sort_values(['date','time','rank']).reset_index(drop=True)
len(df), df.head(), df.tail(), df['time'].value_counts().sort_index()

(687,
         date   time  ...  d4                                            exclude
 0 2026-02-10  21:30  ...   2  (0, 3, 4, 5, 7, 8, 9, 0, 2, 3, 6, 1, 4, 5, 7, ...
 1 2026-02-11  03:30  ...   6  (0, 1, 2, 3, 4, 5, 2, 9, 9, 2, 0, 1, 3, 4, 5, ...
 2 2026-02-11  06:30  ...   9  (0, 1, 3, 4, 5, 6, 8, 9, 4, 4, 3, 0, 1, 2, 5, ...
 3 2026-02-11  11:30  ...   3  (0, 1, 2, 6, 8, 9, 8, 4, 5, 9, 0, 1, 2, 3, 6, ...
 4 2026-02-11  13:30  ...   4  (0, 2, 3, 5, 6, 9, 6, 4, 0, 7, 1, 2, 3, 5, 8, ...
 
 [5 rows x 9 columns],
           date   time  ...  d4                                            exclude
 682 2026-06-05  13:30  ...   9  (1, 2, 3, 4, 7, 8, 1, 3, 5, 3, 0, 2, 4, 6, 7, ...
 683 2026-06-05  17:30  ...   1  (2, 3, 4, 5, 7, 8, 9, 0, 7, 3, 2, 1, 4, 5, 6, ...
 684 2026-06-05  21:30  ...   6  (0, 1, 2, 4, 7, 8, 9, 1, 8, 2, 5, 0, 3, 4, 6, ...
 685 2026-06-06  03:30  ...   9  (0, 1, 2, 3, 5, 6, 7, 2, 6, 5, 5, 0, 1, 3, 4, ...
 686 2026-06-06  06:30  ...   9  (2, 3, 4, 5, 6, 8, 4, 9, 3, 2, 0, 1, 5, 6, 7, ...
 
 [5 rows x 9 columns],
 time
 03:30    116
 06:30    116
 11:30    115
 13:30    109
 17:30    115
 21:30    116
 Name: count, dtype: int64)

python
records=[]
for block in blocks:
    header=re.search(r'Tanggal:\s*(\d{1,2})\s+(\w+)\s+(\d{4})\s*\|\s*Waktu:\s*(\d{2}:\d{2})', block)
    if not header: continue
    day, mon, year, time=header.groups()
    date=pd.Timestamp(int(year),months[mon],int(day))
    # after header, split lines
    rank=0
    for line in block.splitlines():
        m=re.match(r'^\s*(\d{4})\s+((?:\d,\s*)*\d)\s*$', line)
        if m:
            rank+=1
            num=m.group(1)
            excl=tuple(int(x) for x in re.findall(r'\d', m.group(2)))
            records.append({'date':date,'time':time,'rank':rank,'num':num,
                            'd1':int(num[0]),'d2':int(num[1]),'d3':int(num[2]),'d4':int(num[3]),
                            'exclude':excl})
df=pd.DataFrame(records).sort_values(['date','time','rank']).reset_index(drop=True)
len(df), df.head(8), df.tail(8), df.groupby(['date','time']).size().value_counts(), df['time'].value_counts().sort_index()

(2061,
         date   time  rank   num  d1  d2  d3  d4                   exclude
 0 2026-02-10  21:30     1  6112   6   1   1   2     (0, 3, 4, 5, 7, 8, 9)
 1 2026-02-10  21:30     2  0236   0   2   3   6        (1, 4, 5, 7, 8, 9)
 2 2026-02-10  21:30     3  7341   7   3   4   1        (0, 2, 5, 6, 8, 9)
 3 2026-02-11  03:30     1  9876   9   8   7   6        (0, 1, 2, 3, 4, 5)
 4 2026-02-11  03:30     2  2992   2   9   9   2  (0, 1, 3, 4, 5, 6, 7, 8)
 5 2026-02-11  03:30     3  1685   1   6   8   5        (0, 2, 3, 4, 7, 9)
 6 2026-02-11  06:30     1  2279   2   2   7   9     (0, 1, 3, 4, 5, 6, 8)
 7 2026-02-11  06:30     2  9443   9   4   4   3     (0, 1, 2, 5, 6, 7, 8),
            date   time  rank   num  d1  d2  d3  d4                exclude
 2053 2026-06-05  21:30     2  1825   1   8   2   5     (0, 3, 4, 6, 7, 9)
 2054 2026-06-05  21:30     3  7505   7   5   0   5  (1, 2, 3, 4, 6, 8, 9)
 2055 2026-06-06  03:30     1  4489   4   4   8   9  (0, 1, 2, 3, 5, 6, 7)
 2056 2026-06-06  03:30     2  2655   2   6   5   5  (0, 1, 3, 4, 7, 8, 9)
 2057 2026-06-06  03:30     3  6575   6   5   7   5  (0, 1, 2, 3, 4, 8, 9)
 2058 2026-06-06  06:30     1  1709   1   7   0   9     (2, 3, 4, 5, 6, 8)
 2059 2026-06-06  06:30     2  4932   4   9   3   2     (0, 1, 5, 6, 7, 8)
 2060 2026-06-06  06:30     3  8660   8   6   6   0  (1, 2, 3, 4, 5, 7, 9),
 3    687
 Name: count, dtype: int64,
 time
 03:30    348
 06:30    348
 11:30    345
 13:30    327
 17:30    345
 21:30    348
 Name: count, dtype: int64)

python
# Prepare block-level per date-time with three ranks
slot_order=['03:30','06:30','11:30','13:30','17:30','21:30']
# Last observed per slot
last_rows = df.groupby('time').tail(3)[['date','time','rank','num']]
# count by date-time
block_count = df.groupby(['date','time']).ngroups
date_range=(df.date.min(), df.date.max())
df.date.min(), df.date.max(), len(df), block_count, df['time'].value_counts().sort_index().to_dict()


(Timestamp('2026-02-10 00:00:00'),
 Timestamp('2026-06-06 00:00:00'),
 2061,
 687,
 {'03:30': 348,
  '06:30': 348,
  '11:30': 345,
  '13:30': 327,
  '17:30': 345,
  '21:30': 348})

python
from collections import Counter, defaultdict
digits=list(range(10))
pos_cols=['d1','d2','d3','d4']

# Make a block dataframe with sequential slot occurrences; for each date/time/rank
df = df.sort_values(['date','time','rank']).reset_index(drop=True)
df['dow']=df['date'].dt.dayofweek # Mon=0
df['idx_in_rank_slot']=df.groupby(['time','rank']).cumcount()

def digit_probs_for_position(hist, pos, prev_digit=None, target_dow=None, all_slot_hist=None, alpha=1.0):
    # hist: same slot+rank sorted
    n=len(hist)
    # long frequencies
    counts=hist[pos].value_counts().reindex(digits, fill_value=0).astype(float) + alpha
    long=counts/counts.sum()
    # recent weighted, half-life

(Timestamp('2026-06-06 00:00:00'), '06:30')

python
from datetime import timedelta
latest_dt = pd.Timestamp(f"{df.iloc[-1].date.date()} {df.iloc[-1].time}") # df sorted by date time rank, last rank last block
latest_dt


Timestamp('2026-06-06 06:30:00')

python
def next_datetime_for_slot(slot):
    date=latest_dt.date()
    candidate=pd.Timestamp(f"{date} {slot}")
    if candidate <= latest_dt:
        candidate += pd.Timedelta(days=1)
    return candidate

targets={slot:next_datetime_for_slot(slot) for slot in slot_order}
targets


{'03:30': Timestamp('2026-06-07 03:30:00'),
 '06:30': Timestamp('2026-06-07 06:30:00'),
 '11:30': Timestamp('2026-06-06 11:30:00'),
 '13:30': Timestamp('2026-06-06 13:30:00'),
 '17:30': Timestamp('2026-06-06 17:30:00'),
 '21:30': Timestamp('2026-06-06 21:30:00')}

python
predictions={}
for slot in slot_order:
    predictions[slot]=[]
    for rank in [1,2,3]:
        predictions[slot].append(predict_for_slot_rank(slot,rank,targets[slot]))
        
# show top predictions
for slot, preds in predictions.items():
    print(slot, targets[slot])
    for pr in preds:
        print(" rank", pr['rank'], "last", pr['last_num'], "top", [(c, round(s,3), complement_digits(c)) for c,s in pr['top'][:3]], "digits", pr['top_digits'])
    print()

python
# Since previous run variables likely still in state, inspect ranks
df['rank'].value_counts().sort_index(), df.groupby(['time','rank']).size().unstack(fill_value=0)[:10]


(rank
 1    687
 2    687
 3    687
 Name: count, dtype: int64,
 rank     1    2    3
 time                
 03:30  116  116  116
 06:30  116  116  116
 11:30  115  115  115
 13:30  109  109  109
 17:30  115  115  115
 21:30  116  116  116)

python
for slot in slot_order:
    for rank in [1,2,3]:
        n=len(df[(df.time==slot)&(df.rank==rank)])
        if n==0:
            print("empty",slot,rank)
print(df.time.unique())

python
# Fix functions using bracket notation
def predict_for_slot_rank(time, rank, target_date):
    hist=df[(df['time']==time)&(df['rank']==rank)].sort_values(['date','time','rank']).copy()
    all_slot=df[df['time']==time].sort_values(['date','rank']).copy()
    prev_row=hist.iloc[-1]
    probs=[]
    detail={}
    for pos in pos_cols:
        p, comps=digit_probs_for_position(hist,pos,prev_digit=int(prev_row[pos]),target_dow=target_date.dayofweek, all_slot_hist=all_slot)
        probs.append(p)
        detail[pos]=p
    top_lists=[list(map(str,p.head(6).index)) for p in probs]
    candidates=[]
    recent_nums=set(hist.tail(10)['num']) | set(df.tail(60)['num'])
    for tup in itertools.product(*top_lists):
        cand=''.join(tup)
        sc=score_candidate(cand, probs)
        if cand in recent_nums: sc-=0.8
        if cand == prev_row['num']: sc-=1.0
        candidates.append((cand,sc))
    candidates=sorted(candidates, key=lambda x:x[1], reverse=True)
    top=[]
    seen=set()
    for cand,sc in candidates:
        if cand not in seen:
            seen.add(cand); top.append((cand,sc))
        if len(top)>=8: break
    return {
        'time':time,'rank':rank,'last_date':prev_row.date.date().isoformat(),'last_num':prev_row.num,
        'target_date':target_date.date().isoformat(),'target_dt': target_date,
        'probs':probs,'top':top,
        'top_digits': {pos: [int(x) for x in detail[pos].head(5).index] for pos in pos_cols},
        'top_probs': {pos: [float(x) for x in detail[pos].head(5).values] for pos in pos_cols}
    }

predictions={}
for slot in slot_order:
    predictions[slot]=[]
    for rank in [1,2,3]:
        predictions[slot].append(predict_for_slot_rank(slot,rank,targets[slot]))
        
for slot, preds in predictions.items():
    print(slot, targets[slot])
    for pr in preds:
        print(" rank", pr['rank'], "last", pr['last_num'], "top", [(c, round(s,3), ''.join(complement_digits(c))) for c,s in pr['top'][:3]], "digits", pr['top_digits'])
    print()

python
# verify exclude is complement of digits in num
bad=[]
for _,r in df.iterrows():
    comp=tuple(d for d in digits if str(d) not in set(r['num']))
    if tuple(r['exclude']) != comp:
        bad.append((r['date'],r['time'],r['rank'],r['num'],r['exclude'],comp))
len(bad), bad[:5]


(2,
 [(Timestamp('2026-05-16 00:00:00'),
   '06:30',
   2,
   '5993',
   (0, 1, 2, 4, 5, 6, 7, 8),
   (0, 1, 2, 4, 6, 7, 8)),
  (Timestamp('2026-05-18 00:00:00'),
   '11:30',
   3,
   '7089',
   (1, 2, 3, 4, 5, 6, 7),
   (1, 2, 3, 4, 5, 6))])

python
# Summary per slot
slot_summary=[]
for slot in slot_order:
    sub=df[df['time']==slot]
    all_digits = pd.concat([sub[c] for c in pos_cols])
    counts=all_digits.value_counts().reindex(digits, fill_value=0)
    hot=list(counts.sort_values(ascending=False).head(3).index.astype(int))
    cold=list(counts.sort_values().head(3).index.astype(int))
    # top position top 3 across all ranks
    pos_tops={}
    for pos in pos_cols:
        vc=sub[pos].value_counts().reindex(digits, fill_value=0).sort_values(ascending=False)
        pos_tops[pos]=list(vc.head(3).index.astype(int))
    # repeat stats etc
    uniq_count=sub['num'].apply(lambda s: len(set(s)))
    repeat_pct=(uniq_count<4).mean()*100
    odd_even=sub['num'].apply(lambda s: ''.join

[{'slot': '03:30',
  'records': 116,
  'numbers': 348,
  'hot': [1, 0, 2],
  'cold': [8, 3, 5],
  'pos_tops': {'d1': [1, 7, 4],
   'd2': [0, 3, 2],
   'd3': [3, 1, 8],
   'd4': [1, 0, 6]},
  'repeat_pct': np.float64(36.206896551724135),
  'last_nums': ['4489', '2655', '6575'],
  'target_dt': '07-06-2026 03:30'},
 {'slot': '06:30',
  'records': 116,
  'numbers': 348,
  'hot': [0, 1, 2],
  'cold': [7, 8, 9],
  'pos_tops': {'d1': [1, 4, 6],
   'd2': [2, 0, 5],
   'd3': [1, 4, 0],
   'd4': [0, 9, 1]},
  'repeat_pct': np.float64(29.310344827586203),
  'last_nums': ['1709', '4932', '8660'],
  'target_dt': '07-06-2026 06:30'},
 {'slot': '11:30',
  'records': 115,
  'numbers': 345,
  'hot': [7, 0, 1],
  'cold': [2, 3, 6],
  'pos_tops': {'d1': [7, 0, 5],
   'd2': [8, 1, 6],
   'd3': [0, 5, 9],
   'd4': [7, 1, 8]},
  'repeat_pct': np.float64(48.11594202898551),
  'last_nums': ['0286', '3289', '2094'],
  'target_dt': '06-06-2026 11:30'},
 {'slot': '13:30',
  'records': 109,
  'numbers': 327,
  'hot': [4, 6, 7],
  'cold': [2, 5, 9],
  'pos_tops': {'d1': [7, 0, 1],
   'd2': [3, 5, 6],
   'd3': [4, 7, 8],
   'd4': [6, 7, 1]},
  'repeat_pct': np.float64(21.712538226299692),
  'last_nums': ['6509', '1353', '8324'],
  'target_dt': '06-06-2026 13:30'},
 {'slot': '17:30',
  'records': 115,
  'numbers': 345,
  'hot': [2, 4, 1],
  'cold': [6, 8, 9],
  'pos_tops': {'d1': [1, 2, 4],
   'd2': [0, 5, 6],
   'd3': [4, 9, 2],
   'd4': [1, 2, 3]},
  'repeat_pct': np.float64(23.47826086956522),
  'last_nums': ['0161', '0732', '2684'],
  'target_dt': '06-06-2026 17:30'},
 {'slot': '21:30',
  'records': 116,
  'numbers': 348,
  'hot': [0, 1, 2],
  'cold': [9, 7, 4],
  'pos_tops': {'d1': [1, 2, 0],
   'd2': [8, 3, 5],
   'd3': [0, 1, 2],
   'd4': [6, 0, 1]},
  'repeat_pct': np.float64(28.160919540229884),
  'last_nums': ['3556', '1825', '7505'],
  'target_dt': '06-06-2026 21:30'}]

python
# Add chronological index
df=df.sort_values(['date','time','rank']).reset_index(drop=True)
df['chron_idx']=df.index

bt=[]
for slot in slot_order:
    for rank in [1,2,3]:
        hist_all=df[(df['time']==slot)&(df['rank']==rank)].sort_values(['date','time','rank']).reset_index(drop=True)
        n=len(hist_all)
        start=max(50,n-40)
        for i in range(start,n):
            target=hist_all.iloc[i]
            train=df[df['chron_idx'] < int(target['chron_idx'])].copy()
            # Need ensure enough past for that slot/rank
            if len(train[(train['time']==slot)&(train['rank']==rank)]) < 30:
                continue
            top, probs=predict_from_training(train, slot, rank, pd.Timestamp(f"{target['date'].date()} {slot}"))
            pred=top[0

(720,
     slot  rank  true  pred  ...  exact_top1  exact_top5  top3_pos  top5_pos
 0  03:30     1  9265  6991  ...       False       False         0         1
 1  03:30     1  7028  6841  ...       False       False         2         4
 2  03:30     1  4510  7721  ...       False       False         1         2
 3  03:30     1  6779  7821  ...       False       False         1         1
 4  03:30     1  0163  7821  ...       False       False         0         1
 
 [5 rows x 9 columns],
 pos_hits      0.380556
 top3_pos      1.223611
 top5_pos      2.043056
 exact_top1    0.001389
 exact_top5    0.001389
 dtype: float64)

python
bt_summary=bt_df.groupby('slot').agg(
    tests=('true','count'),
    avg_pos_hits=('pos_hits','mean'),
    top3_digit_coverage=('top3_pos','mean'),
    top5_digit_coverage=('top5_pos','mean'),
    exact_top1_rate=('exact_top1','mean'),
    exact_top5_rate=('exact_top5','mean')
).reset_index()
bt_summary


    slot  tests  ...  exact_top1_rate  exact_top5_rate
0  03:30    120  ...         0.000000         0.000000
1  06:30    120  ...         0.000000         0.000000
2  11:30    120  ...         0.008333         0.008333
3  13:30    120  ...         0.000000         0.000000
4  17:30    120  ...         0.000000         0.000000
5  21:30    120  ...         0.000000         0.000000

[6 rows x 7 columns]

python
from pathlib import Path

script = r'''# ============================================================
# PRIZE Slot Predictor - Google Colab Script
# Cara pakai:
# 1) Buka Google Colab
# 2) Jalankan script ini
# 3) Upload file PRIZE.txt saat diminta, atau letakkan PRIZE.txt di /content/
#
# Catatan:
# - Ini analisis statistik/pola historis, bukan jaminan hasil.
# - Daftar digit setelah 4D dihitung otomatis sebagai digit yang TIDAK muncul di angka 4D.
# ============================================================

import re
import math
import itertools
from pathlib import Path
from collections import Counter

import numpy as np
import pandas as pd

# -----------------------------
# 1. Upload / baca file
# -----------------------------
DATA_PATH = Path("/content/PRIZE.txt")

if not DATA_PATH.exists():
    try:
        from google.colab import files
        print("Upload file PRIZE.txt...")
        uploaded = files.upload()
        if uploaded:
            first_name = list(uploaded.keys())[0]
            DATA_PATH = Path("/content") / first_name
    except Exception:
        pass

if not DATA_PATH.exists():
    raise FileNotFoundError("File PRIZE.txt tidak ditemukan. Upload file atau set DATA_PATH dengan benar.")

text = DATA_PATH.read_text(encoding="utf-8", errors="replace")

# -----------------------------
# 2. Parser data
# -----------------------------
MONTHS = {
    "Januari": 1, "Februari": 2, "Maret": 3, "April": 4, "Mei": 5, "Juni": 6,
    "Juli": 7, "Agustus": 8, "September": 9, "Oktober": 10, "November": 11, "Desember": 12
}
DIGITS = list(range(10))
POS_COLS = ["d1", "d2", "d3", "d4"]
SLOT_ORDER = ["03:30", "06:30", "11:30", "13:30", "17:30", "21:30"]

def complement_digits(numstr):
    return [d for d in DIGITS if str(d) not in set(numstr)]

def parse_prize_text(text):
    records = []
    blocks = re.split(r"-{10,}", text)
    for block in blocks:
        header = re.search(
            r"Tanggal:\s*(\d{1,2})\s+(\w+)\s+(\d{4})\s*\|\s*Waktu:\s*(\d{2}:\d{2})",
            block
        )
        if not header:
            continue

        day, mon, year, time = header.groups()
        if mon not in MONTHS:
            continue

        date = pd.Timestamp(int(year), MONTHS[mon], int(day))
        rank = 0

        for line in block.splitlines():
            m = re.match(r"^\s*(\d{4})\s+((?:\d,\s*)*\d)\s*$", line)
            if not m:
                continue

            rank += 1
            num = m.group(1)
            listed_absent = tuple(int(x) for x in re.findall(r"\d", m.group(2)))
            records.append({
                "date": date,
                "time": time,
                "rank": rank,
                "num": num,
                "d1": int(num[0]),
                "d2": int(num[1]),
                "d3": int(num[2]),
                "d4": int(num[3]),
                "listed_absent": listed_absent,
                "calc_absent": tuple(complement_digits(num)),
            })

    df = pd.DataFrame(records)
    if df.empty:
        raise ValueError("Data tidak berhasil diparse. Cek format file PRIZE.txt.")

    df = df.sort_values(["date", "time", "rank"]).reset_index(drop=True)
    df["dow"] = df["date"].dt.dayofweek
    df["chron_idx"] = df.index
    return df

df = parse_prize_text(text)

print("Jumlah angka 4D:", len(df))
print("Jumlah draw/slot:", df.groupby(["date", "time"]).ngroups)
print("Rentang tanggal:", df["date"].min().date(), "s/d", df["date"].max().date())
print("\nJumlah data per slot:")
display((df.groupby("time").size() / 3).rename("jumlah_draw").astype(int).reindex(SLOT_ORDER).to_frame())

# Validasi daftar digit absen
invalid = df[df["listed_absent"] != df["calc_absent"]][["date", "time", "rank", "num", "listed_absent", "calc_absent"]]
if len(invalid):
    print("\nPeringatan: ditemukan baris dengan digit absen tidak konsisten. Prediksi tetap memakai angka 4D.")
    display(invalid)
else:
    print("\nSemua daftar digit absen konsisten dengan angka 4D.")

# -----------------------------
# 3. Ringkasan pola per slot
# -----------------------------
def summarize_slots(df):
    rows = []
    for slot in SLOT_ORDER:
        sub = df[df["time"] == slot]
        all_digits = pd.concat([sub[c] for c in POS_COLS])
        cnt = all_digits.value_counts().reindex(DIGITS, fill_value=0)

        pos_text = []
        for pos in POS_COLS:
            tops = sub[pos].value_counts().reindex(DIGITS, fill_value=0).sort_values(ascending=False).head(3)
            pos_text.append(f"{pos}: " + ",".join(map(str, tops.index.tolist())))

        uniq_count = sub["num"].apply(lambda s: len(set(s)))
        rows.append({
            "slot": slot,
            "jumlah_draw": int(len(sub) / 3),
            "hot_digit": ",".join(map(str, cnt.sort_values(ascending=False).head(3).index.tolist())),
            "cold_digit": ",".join(map(str, cnt.sort_values().head(3).index.tolist())),
            "top_posisi": " | ".join(pos_text),
            "repeat_digit_%": round(float((uniq_count < 4).mean() * 100), 1),
            "last_3": ", ".join(sub.tail(3)["num"].tolist()),
        })
    return pd.DataFrame(rows)

slot_summary = summarize_slots(df)
print("\nRingkasan pola per slot:")
display(slot_summary)

# -----------------------------
# 4. Model prediksi
# -----------------------------
# Bobot model:
# long_freq    = frekuensi historis slot+rank
# recent_freq  = frekuensi terbaru slot+rank, bobot makin besar untuk data baru
# markov       = transisi digit dari hasil sebelumnya ke hasil berikutnya
# slot_recent  = frekuensi terbaru semua rank di slot yang sama
# weekday      = kecenderungan hari yang sama
WEIGHTS = {
    "long_freq": 0.30,
    "recent_freq": 0.35,
    "markov": 0.20,
    "slot_recent": 0.10,
    "weekday": 0.05,
}

def digit_probs_for_position(hist, pos, prev_digit=None, target_dow=None, all_slot_hist=None, alpha=1.0):
    n = len(hist)

    # Frekuensi panjang
    counts = hist[pos].value_counts().reindex(DIGITS, fill_value=0).astype(float) + alpha
    long_freq = counts / counts.sum()

    # Frekuensi terbaru, exponential decay
    wcounts = pd.Series(0.0, index=DIGITS)
    if n:
        weights = np.array([0.94 ** (n - 1 - i) for i in range(n)])
        for val, w in zip(hist[pos], weights):
            wcounts[int(val)] += float(w)
    recent_freq = (wcounts + alpha) / (wcounts.sum() + alpha * 10)

    # Markov transition: digit posisi sebelumnya -> digit posisi target
    markov = pd.Series(1.0, index=DIGITS)
    if prev_digit is not None and n >= 2:
        prevs = hist[pos].shift(1)
        currs = hist[pos]
        trans = currs[prevs == prev_digit].value_counts()
        for k, v in trans.items():
            markov[int(k)] += float(v)
    markov = markov / markov.sum()

    # Recent semua rank dalam slot yang sama
    slot_recent = pd.Series(1.0, index=DIGITS)
    if all_slot_hist is not None and len(all_slot_hist):
        m = len(all_slot_hist)
        weights2 = np.array([0.985 ** (m - 1 - i) for i in range(m)])
        wc = pd.Series(0.0, index=DIGITS)
        for val, w in zip(all_slot_hist[pos], weights2):
            wc[int(val)] += float(w)
        slot_recent = (wc + alpha) / (wc.sum() + alpha * 10)

    # Hari yang sama
    weekday = pd.Series(1.0, index=DIGITS)
    if target_dow is not None and n >= 10:
        wd_hist = hist[hist["dow"] == target_dow]
        if len(wd_hist) >= 3:
            vc = wd_hist[pos].value_counts()
            for k, v in vc.items():
                weekday[int(k)] += float(v)
    weekday = weekday / weekday.sum()

    p = (
        WEIGHTS["long_freq"] * long_freq
        + WEIGHTS["recent_freq"] * recent_freq
        + WEIGHTS["markov"] * markov
        + WEIGHTS["slot_recent"] * slot_recent
        + WEIGHTS["weekday"] * weekday
    )
    p = p / p.sum()
    return p.sort_values(ascending=False)

def score_candidate(cand, probs):
    score = 0.0
    for ch, p in zip(cand, probs):
        score += math.log(max(float(p[int(ch)]), 1e-12))

    cnt = Counter(cand)
    maxcnt = max(cnt.values())
    uniq = len(cnt)

    # Penalti/penguat struktur digit
    if maxcnt == 4:
        score -= 1.20
    elif maxcnt == 3:
        score -= 0.35
    if uniq >= 3:
        score += 0.08

    even = sum(int(c) % 2 == 0 for c in cand)
    if even in [1, 2, 3]:
        score += 0.05
    else:
        score -= 0.15

    low = sum(int(c) <= 4 for c in cand)
    if low in [1, 2, 3]:
        score += 0.03
    else:
        score -= 0.10

    return score

def get_latest_datetime(df):
    last = df.sort_values(["date", "time", "rank"]).iloc[-1]
    return pd.Timestamp(f"{last['date'].date()} {last['time']}")

def next_datetime_for_slot(latest_dt, slot):
    candidate = pd.Timestamp(f"{latest_dt.date()} {slot}")
    if candidate <= latest_dt:
        candidate += pd.Timedelta(days=1)
    return candidate

def predict_for_slot_rank(df, slot, rank, target_dt, top_n=8):
    hist = df[(df["time"] == slot) & (df["rank"] == rank)].sort_values(["date", "time", "rank"]).copy()
    all_slot = df[df["time"] == slot].sort_values(["date", "rank"]).copy()
    if len(hist) < 10:
        raise ValueError(f"Data terlalu sedikit untuk slot={slot}, rank={rank}")

    prev_row = hist.iloc[-1]
    probs = []
    top_digits = {}

    for pos in POS_COLS:
        p = digit_probs_for_position(
            hist=hist,
            pos=pos,
            prev_digit=int(prev_row[pos]),
            target_dow=target_dt.dayofweek,
            all_slot_hist=all_slot
        )
        probs.append(p)
        top_digits[pos] = ",".join(map(str, p.head(5).index.tolist()))

    # Kandidat dari top 6 setiap posisi = maksimal 6^4 = 1296 kandidat
    top_lists = [list(map(str, p.head(6).index)) for p in probs]
    recent_nums = set(hist.tail(10)["num"]) | set(df.tail(60)["num"])

    candidates = []
    for tup in itertools.product(*top_lists):
        cand = "".join(tup)
        sc = score_candidate(cand, probs)

        # Hindari terlalu menempel pada angka yang baru keluar
        if cand in recent_nums:
            sc -= 0.80
        if cand == prev_row["num"]:
            sc -= 1.00

        candidates.append((cand, sc))

    candidates = sorted(candidates, key=lambda x: x[1], reverse=True)

    top = []
    seen = set()
    for cand, sc in candidates:
        if cand not in seen:
            seen.add(cand)
            top.append({
                "num": cand,
                "score": round(float(sc), 4),
                "absen": ",".join(map(str, complement_digits(cand))),
            })
        if len(top) >= top_n:
            break

    return {
        "slot": slot,
        "rank": rank,
        "target_dt": target_dt,
        "last_num": prev_row["num"],
        "top_digits": top_digits,
        "candidates": top,
    }

def predict_all_slots(df):
    latest_dt = get_latest_datetime(df)
    rows = []
    detail_rows = []

    for slot in SLOT_ORDER:
        target_dt = next_datetime_for_slot(latest_dt, slot)
        for rank in [1, 2, 3]:
            pred = predict_for_slot_rank(df, slot, rank, target_dt, top_n=8)
            best = pred["candidates"][0]
            rows.append({
                "slot": slot,
                "prediksi_untuk": target_dt.strftime("%Y-%m-%d %H:%M"),
                "rank": rank,
                "last_num": pred["last_num"],
                "prediksi_utama": best["num"],
                "digit_absen": best["absen"],
                "score": best["score"],
                "top_digit_posisi": " | ".join([f"{k}:{v}" for k, v in pred["top_digits"].items()])
            })

            for i, c in enumerate(pred["candidates"], start=1):
                detail_rows.append({
                    "slot": slot,
                    "prediksi_untuk": target_dt.strftime("%Y-%m-%d %H:%M"),
                    "rank": rank,
                    "urutan": i,
                    "num": c["num"],
                    "digit_absen": c["absen"],
                    "score": c["score"],
                })

    return pd.DataFrame(rows), pd.DataFrame(detail_rows)

pred_main, pred_detail = predict_all_slots(df)

print("\nPrediksi utama per slot dan rank:")
display(pred_main)

print("\nDetail kandidat top 8 per slot dan rank:")
display(pred_detail)

# -----------------------------
# 5. Backtest sederhana
# -----------------------------
def predict_from_training(train, slot, rank, target_dt, top_n=5):
    return predict_for_slot_rank(train, slot, rank, target_dt, top_n=top_n)["candidates"]

def run_backtest(df, last_n=40, min_history=30):
    tests = []

    for slot in SLOT_ORDER:
        for rank in [1, 2, 3]:
            hist_all = df[(df["time"] == slot) & (df["rank"] == rank)].sort_values(["date", "time", "rank"]).reset_index(drop=True)
            n = len(hist_all)
            start = max(min_history, n - last_n)

            for i in range(start, n):
                target = hist_all.iloc[i]
                train = df[df["chron_idx"] < int(target["chron_idx"])].copy()
                if len(train[(train["time"] == slot) & (train["rank"] == rank)]) < min_history:
                    continue

                target_dt = pd.Timestamp(f"{target['date'].date()} {slot}")
                top = predict_from_training(train, slot, rank, target_dt, top_n=5)
                pred = top[0]["num"]
                true = target["num"]

                tests.append({
                    "slot": slot,
                    "rank": rank,
                    "true": true,
                    "pred_top1": pred,
                    "posisi_tepat": sum(a == b for a, b in zip(pred, true)),
                    "exact_top1": pred == true,
                    "exact_top5": any(x["num"] == true for x in top),
                })

    bt = pd.DataFrame(tests)
    if bt.empty:
        return bt, pd.DataFrame()

    summary = bt.groupby("slot").agg(
        jumlah_test=("true", "count"),
        rata_posisi_tepat=("posisi_tepat", "mean"),
        exact_top1_rate=("exact_top1", "mean"),
        exact_top5_rate=("exact_top5", "mean"),
    ).reset_index()

    summary["rata_posisi_tepat"] = summary["rata_posisi_tepat"].round(3)
    summary["exact_top1_rate"] = (summary["exact_top1_rate"] * 100).round(2)
    summary["exact_top5_rate"] = (summary["exact_top5_rate"] * 100).round(2)

    return bt, summary

bt_detail, bt_summary = run_backtest(df)

print("\nBacktest ringkas pada data historis terbaru:")
display(bt_summary)

print("\nKesimpulan penting:")
print("- Exact 4D biasanya sangat sulit ditebak dari pola historis.")
print("- Gunakan prediksi sebagai shortlist statistik/digit prioritas, bukan jaminan.")
print("- Score makin tinggi atau makin tidak negatif berarti kandidat lebih disukai model.")
'''

out = Path("/mnt/data/prize_colab_predictor.py")
out.write_text(script, encoding="utf-8")
print(f"Script berhasil dibuat: {out}")