Prediksi untuk hasil selanjutnya menggunakan paito...

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


(97663,
 '=== 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 ',
 '\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\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 11:30\n4339  0, 1, 2, 5, 6, 7, 8\n4925  0, 1, 3, 6, 7, 8\n6097  1, 2, 3, 4, 5, 8\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 13:30\n2098  1, 3, 4, 5, 6, 7\n9726  0, 1, 3, 4, 5, 8\n1473  0, 2, 5, 6, 8, 9\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 17:30\n5663  0, 1, 2, 4, 7, 8, 9\n8650  1, 2, 3, 4, 7, 9\n9724  0, 1, 3, 5, 6, 8\n------------------------------\nTanggal: 06 Juni 2026 | Waktu: 21:30\n5113  0, 2, 4, 6, 7, 8, 9\n1359  0, 2, 4, 6, 7, 8\n8641  0, 2, 3, 5, 7, 9\n------------------------------\nTanggal: 07 Juni 2026 | Waktu: 03:30\n8304  1, 2, 5, 6, 7, 9\n4068  1, 2, 3, 5, 7, 9\n9668  0, 1, 2, 3, 4, 5, 7\n------------------------------\nTanggal: 07 Juni 2026 | Waktu: 06:30\n4278  0, 1, 3, 5, 6, 9\n4829  0, 1, 3, 5, 6, 7\n5370  1, 2, 4, 6, 8, 9')

python
import re, pandas as pd, numpy as np, math, itertools, collections
from pathlib import Path
text=Path('/mnt/data/PRIZE.txt').read_text(encoding='utf-8', errors='ignore')
month_map={'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=[]
current_date=None; current_time=None; line_index=0
for line in text.splitlines():
    line=line.strip()
    m=re.match(r'Tanggal:\s*(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})\s*\|\s*Waktu:\s*(\d{2}:\d{2})', line)
    if m:
        day, mon, year, w = m.groups()
        current_date=f"{int(year):04d}-{month_map.get(mon,0):02d}-{int(day):02d}"
        current_time=w
        prize_rank=0
        continue
    m=re.match(r'^(\d{4})\s+([0-9,\s]+)$', line)
    if m and current_date and current_time:
        num=m.group(1)
        absent=[int(x) for x in re.findall(r'\d', m.group(2))]
        prize_rank+=1
        records.append(dict(date=current_date, time=current_time, prize_rank=prize_rank, number=num, absent=absent))
df=pd.DataFrame(records)
df['dt']=pd.to_datetime(df['date']+' '+df['time'])
df['seq']=range(len(df))
for i,pos in enumerate(['A','B','C','D']):
    df[pos]=df['number'].str[i].astype(int)
df.head(), df.tail(), len(df), df['dt'].nunique(), df['dt'].max(), df[df['dt']==df['dt'].max()]


(         date   time  prize_rank number  ...  A  B  C  D
 0  2026-02-10  21:30           1   6112  ...  6  1  1  2
 1  2026-02-10  21:30           2   0236  ...  0  2  3  6
 2  2026-02-10  21:30           3   7341  ...  7  3  4  1
 3  2026-02-11  03:30           1   9876  ...  9  8  7  6
 4  2026-02-11  03:30           2   2992  ...  2  9  9  2
 
 [5 rows x 11 columns],
             date   time  prize_rank number  ...  A  B  C  D
 2074  2026-06-07  03:30           2   4068  ...  4  0  6  8
 2075  2026-06-07  03:30           3   9668  ...  9  6  6  8
 2076  2026-06-07  06:30           1   4278  ...  4  2  7  8
 2077  2026-06-07  06:30           2   4829  ...  4  8  2  9
 2078  2026-06-07  06:30           3   5370  ...  5  3  7  0
 
 [5 rows x 11 columns],
 2079,
 693,
 Timestamp('2026-06-07 06:30:00'),
             date   time  prize_rank number  ...  A  B  C  D
 2076  2026-06-07  06:30           1   4278  ...  4  2  7  8
 2077  2026-06-07  06:30           2   4829  ...  4  8  2  9
 2078  2026-06-07  06:30           3   5370  ...  5  3  7  0
 
 [3 rows x 11 columns])

python
from collections import defaultdict, Counter
# determine schedule
times_sorted=sorted(df['time'].unique())
times_sorted


['03:30', '06:30', '11:30', '13:30', '17:30', '21:30']

python
last_dt=df['dt'].max()
last_time=df[df['dt']==last_dt]['time'].iloc[0]
idx=times_sorted.index(last_time)
if idx < len(times_sorted)-1:
    next_time=times_sorted[idx+1]
    next_date=last_dt.date()
else:
    next_time=times_sorted[0]
    next_date=(last_dt+pd.Timedelta(days=1)).date()
next_date, next_time


(datetime.date(2026, 6, 7), '11:30')

python
# Helper recency windows by timestamp
unique_dts=sorted(df['dt'].unique())
recent_dts=unique_dts[-30:]
recent=df[df['dt'].isin(recent_dts)].copy()
all_digits=''.join(recent['number'])
digit_counts=Counter(map(int, all_digits))
digit_freq={d: digit_counts[d] for d in range(10)}
digit_freq


{0: 44, 1: 30, 2: 40, 3: 42, 4: 35, 5: 36, 6: 30, 7: 27, 8: 40, 9: 36}

python
import numpy as np, pandas as pd, math
positions=['A','B','C','D']

def exp_weighted_counts(vals, half_life=120, digits=range(10)):
    n=len(vals)
    # oldest to newest; weight newest highest
    ages=np.arange(n-1,-1,-1)
    weights=0.5**(ages/half_life)
    c={d:0.0 for d in digits}
    for v,w in zip(vals,weights):
        c[int(v)]+=float(w)
    total=sum(c.values()) or 1.0
    return {d:c[d]/total for d in digits}

def freq_norm(vals, digits=range(10)):
    c=Counter(map(int, vals))
    total=sum(c.values()) or 1
    return {d:c[d]/total for d in digits}

def markov_counts_for_rank(rank, pos, prev_digit):
    sub=df[df['prize_rank']==rank].sort_values('dt')
    vals=sub[pos].tolist()
    c={d:1.0 for d in range(10)} # Laplace smoothing
    for a,b in zip(vals[:-1], vals[1:]):
        if int(a)==int(prev_digit):
            c[int(b)]+=1
    total=sum(c.values())
    return {d:c[d]/total for d in range(10)}

def next_rank_prediction(rank, topn_per_pos=6):
    sub=df[df['prize_rank']==rank].sort_values('dt').copy()
    same_time=sub[sub['time']==next_time].copy()
    last_row=sub[sub['dt']==last_dt].iloc[-1]
    rec_window=sub.tail(240)
    rank_window=sub.tail(120)
    pos_scores={}
    components={}
    for pos in positions:
        recent_probs=exp_weighted_counts(sub[pos].tolist(), half_life=120)
        slot_probs=exp_weighted_counts(same_time[pos].tolist(), half_life=36) if len(same_time)>0 else {d:0.1 for d in range(10)}
        global_probs=freq_norm(sub[pos].tolist())
        markov_probs=markov_counts_for_rank(rank, pos, int(last_row[pos]))
        # Convert to z? Just weighted probability.
        score={d:0.42*recent_probs[d] + 0.25*slot_probs[d] + 0.23*markov_probs[d] + 0.10*global_probs[d] for d in range(10)}
        # normalize
        tot=sum(score.values())
        score={d:score[d]/tot for d in range(10)}
        pos_scores[pos]=score
        components[pos]=(recent_probs, slot_probs, markov_probs, global_probs)
    # Generate candidate combos using top per pos
    top_digits={pos: sorted(range(10), key=lambda d: pos_scores[pos][d], reverse=True)[:topn_per_pos] for pos in positions}
    candidates=[]
    for digs in itertools.product(*[top_digits[pos] for pos in positions]):
        # base score = product
        prob=1.0
        for pos,d in zip(positions,digs):
            prob *= pos_scores[pos][d]
        num=''.join(map(str,digs))
        # Penalize exact repetition of recent numbers a little?
        recent_numbers=set(df.tail(200)['number'])
        if num in recent_numbers:
            prob *= 0.65
        # bonus/penalty for digit uniqueness? Use observed repeat distribution; don't overforce
        unique=len(set(num))
        # observed distribution for rank
        # (don't)
        candidates.append((num,prob,digs))
    candidates.sort(key=lambda x:x[1], reverse=True)
    return pos_scores, top_digits, candidates, last_row['number']

preds={}
for r in [1,2,3]:
    pos_scores, top_digits, candidates, lastnum=next_rank_prediction(r)
    preds[r]=dict(pos_scores=pos_scores, top_digits=top_digits, candidates=candidates, last=lastnum)
    print('Rank',r,'last',lastnum)
    print('top digits', top_digits)
    print('top candidates', candidates[:15])
    print()

python
# combined position scores for rank1 primary? also aggregate rank1-3
agg_digit_score={d:0 for d in range(10)}
for r in [1,2,3]:
    for pos in positions:
        for d,s in preds[r]['pos_scores'][pos].items():
            agg_digit_score[d]+=s
# average
agg_sorted=sorted(agg_digit_score.items(), key=lambda x:x[1], reverse=True)
agg_sorted


[(0, 1.3181899136121664),
 (1, 1.2567833147300522),
 (5, 1.2518555706828207),
 (4, 1.2270527053125768),
 (7, 1.2098334966007083),
 (8, 1.1630386731781235),
 (6, 1.157023685883064),
 (2, 1.1496081804995995),
 (3, 1.1345083132631009),
 (9, 1.1321061462377875)]

python
script = r'''# ============================================================
# Prediksi hasil berikutnya menggunakan paito warna
# Jalankan di Google Colab.
# Upload file PRIZE.txt saat diminta.
#
# Catatan: prediksi ini berbasis statistik historis/pola warna,
# bukan jaminan. Hasil undian acak tetap tidak bisa dipastikan.
# ============================================================

import re
import math
import itertools
from collections import Counter
import numpy as np
import pandas as pd

# --- 1) Upload file PRIZE.txt di Google Colab ---
try:
    from google.colab import files
    uploaded = files.upload()
    FILE_PATH = list(uploaded.keys())[0]
except Exception:
    # Kalau dijalankan lokal, ubah path ini sesuai lokasi file
    FILE_PATH = "PRIZE.txt"

MONTH_MAP = {
    "Januari": 1, "Februari": 2, "Maret": 3, "April": 4,
    "Mei": 5, "Juni": 6, "Juli": 7, "Agustus": 8,
    "September": 9, "Oktober": 10, "November": 11, "Desember": 12
}

def parse_prize_txt(path):
    text = open(path, "r", encoding="utf-8", errors="ignore").read()
    records = []
    current_date, current_time = None, None
    prize_rank = 0

    for raw_line in text.splitlines():
        line = raw_line.strip()

        m = re.match(
            r"Tanggal:\s*(\d{1,2})\s+([A-Za-z]+)\s+(\d{4})\s*\|\s*Waktu:\s*(\d{2}:\d{2})",
            line
        )
        if m:
            day, month_name, year, time_str = m.groups()
            current_date = f"{int(year):04d}-{MONTH_MAP[month_name]:02d}-{int(day):02d}"
            current_time = time_str
            prize_rank = 0
            continue

        m = re.match(r"^(\d{4})\s+([0-9,\s]+)$", line)
        if m and current_date and current_time:
            prize_rank += 1
            number = m.group(1)
            absent_digits = [int(x) for x in re.findall(r"\d", m.group(2))]
            records.append({
                "date": current_date,
                "time": current_time,
                "prize_rank": prize_rank,
                "number": number,
                "absent": absent_digits
            })

    df = pd.DataFrame(records)
    if df.empty:
        raise ValueError("Data tidak terbaca. Pastikan format file sama seperti PRIZE.txt.")

    df["dt"] = pd.to_datetime(df["date"] + " " + df["time"])
    for i, pos in enumerate(["A", "B", "C", "D"]):
        df[pos] = df["number"].str[i].astype(int)
    df = df.sort_values(["dt", "prize_rank"]).reset_index(drop=True)
    return df

df = parse_prize_txt(FILE_PATH)

# --- 2) Infer slot berikutnya ---
times_sorted = sorted(df["time"].unique())
last_dt = df["dt"].max()
last_time = df.loc[df["dt"] == last_dt, "time"].iloc[0]
idx = times_sorted.index(last_time)

if idx < len(times_sorted) - 1:
    next_date = last_dt.date()
    next_time = times_sorted[idx + 1]
else:
    next_date = (last_dt + pd.Timedelta(days=1)).date()
    next_time = times_sorted[0]

print("Data terbaca:", len(df), "baris")
print("Data terakhir:", last_dt.strftime("%d-%m-%Y %H:%M"))
print("Prediksi untuk:", pd.Timestamp(str(next_date) + " " + next_time).strftime("%d-%m-%Y %H:%M"))
print()

# --- 3) Paito warna digit: panas/sedang/dingin dari N slot terakhir ---
RECENT_SLOTS = 30
recent_dts = sorted(df["dt"].unique())[-RECENT_SLOTS:]
recent_df = df[df["dt"].isin(recent_dts)].copy()

digit_counter = Counter()
for n in recent_df["number"]:
    digit_counter.update([int(x) for x in n])

paito_rows = []
for d in range(10):
    paito_rows.append({"digit": d, "muncul_recent": digit_counter[d]})
paito = pd.DataFrame(paito_rows).sort_values("muncul_recent", ascending=False).reset_index(drop=True)

# Status warna relatif
# Merah: paling panas, Kuning: tengah, Biru: dingin
status_map = {}
for rank, row in paito.iterrows():
    d = int(row["digit"])
    if rank <= 2:
        status_map[d] = "MERAH/PANAS"
    elif rank <= 6:
        status_map[d] = "KUNING/SEDANG"
    else:
        status_map[d] = "BIRU/DINGIN"

paito["warna"] = paito["digit"].map(status_map)

print("=== PAITO WARNA DIGIT RECENT ===")
print(paito.to_string(index=False))
print()

# Opsional: tampilkan paito warna sebagai tabel HTML di Colab
def color_status(val):
    if "MERAH" in val:
        return "background-color:#ffcccc"
    if "KUNING" in val:
        return "background-color:#fff2cc"
    if "BIRU" in val:
        return "background-color:#cfe2f3"
    return ""

try:
    from IPython.display import display
    display(paito.style.applymap(color_status, subset=["warna"]))
except Exception:
    pass

# --- 4) Model prediksi statistik ---
POSITIONS = ["A", "B", "C", "D"]

def exp_weighted_counts(values, half_life=120, digits=range(10)):
    """
    Frekuensi dengan bobot lebih besar pada data terbaru.
    values harus urut dari lama -> baru.
    """
    values = list(values)
    n = len(values)
    ages = np.arange(n - 1, -1, -1)
    weights = 0.5 ** (ages / half_life)

    counts = {d: 0.0 for d in digits}
    for v, w in zip(values, weights):
        counts[int(v)] += float(w)

    total = sum(counts.values()) or 1.0
    return {d: counts[d] / total for d in digits}

def freq_norm(values, digits=range(10)):
    c = Counter(map(int, values))
    total = sum(c.values()) or 1
    return {d: c[d] / total for d in digits}

def markov_probs_for_rank(df, rank, pos, prev_digit):
    """
    Pola transisi sederhana:
    digit posisi sekarang -> digit posisi berikutnya pada prize_rank yang sama.
    """
    sub = df[df["prize_rank"] == rank].sort_values("dt")
    vals = sub[pos].tolist()

    counts = {d: 1.0 for d in range(10)}  # Laplace smoothing
    for a, b in zip(vals[:-1], vals[1:]):
        if int(a) == int(prev_digit):
            counts[int(b)] += 1.0

    total = sum(counts.values())
    return {d: counts[d] / total for d in range(10)}

def predict_for_rank(df, rank, next_time, topn_per_pos=6, max_candidates=20):
    sub = df[df["prize_rank"] == rank].sort_values("dt").copy()
    same_time = sub[sub["time"] == next_time].copy()
    last_dt = df["dt"].max()
    last_row = sub[sub["dt"] == last_dt].iloc[-1]

    pos_scores = {}
    for pos in POSITIONS:
        recent_probs = exp_weighted_counts(sub[pos].tolist(), half_life=120)
        slot_probs = exp_weighted_counts(same_time[pos].tolist(), half_life=36) if len(same_time) else {d: 0.1 for d in range(10)}
        markov_probs = markov_probs_for_rank(df, rank, pos, int(last_row[pos]))
        global_probs = freq_norm(sub[pos].tolist())

        # Bobot model:
        # recent 42%, slot waktu 25%, transisi 23%, global 10%
        score = {
            d: (
                0.42 * recent_probs[d] +
                0.25 * slot_probs[d] +
                0.23 * markov_probs[d] +
                0.10 * global_probs[d]
            )
            for d in range(10)
        }
        total = sum(score.values()) or 1.0
        pos_scores[pos] = {d: score[d] / total for d in range(10)}

    top_digits = {
        pos: sorted(range(10), key=lambda d: pos_scores[pos][d], reverse=True)[:topn_per_pos]
        for pos in POSITIONS
    }

    recent_numbers = set(df.tail(200)["number"])
    candidates = []
    for digs in itertools.product(*[top_digits[pos] for pos in POSITIONS]):
        number = "".join(map(str, digs))
        score = 1.0
        for pos, digit in zip(POSITIONS, digs):
            score *= pos_scores[pos][digit]

        # Sedikit penalti jika angka persis sudah sangat baru muncul
        if number in recent_numbers:
            score *= 0.65

        candidates.append((number, score))

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

    return {
        "rank": rank,
        "last_number": last_row["number"],
        "top_digits": top_digits,
        "candidates": candidates,
        "pos_scores": pos_scores
    }

predictions = [predict_for_rank(df, r, next_time) for r in sorted(df["prize_rank"].unique())]

# --- 5) Cetak hasil prediksi ---
print("=== PREDIKSI 4D PER PRIZE RANK ===")
for pred in predictions:
    print(f"\nPrize {pred['rank']} | angka terakhir rank ini: {pred['last_number']}")
    print("Digit kuat posisi:")
    for pos in POSITIONS:
        print(f"  {pos}: {pred['top_digits'][pos]}")
    print("Top kandidat:")
    for i, (num, score) in enumerate(pred["candidates"][:12], start=1):
        print(f"  {i:02d}. {num} | skor {score:.8f}")

# --- 6) Rangkuman BBFS, colok bebas, dan 2D ekor ---
# Agregasi skor digit dari semua posisi/rank
agg_digit_score = {d: 0.0 for d in range(10)}
for pred in predictions:
    for pos in POSITIONS:
        for d, s in pred["pos_scores"][pos].items():
            agg_digit_score[d] += s

bbfs = [d for d, s in sorted(agg_digit_score.items(), key=lambda x: x[1], reverse=True)[:7]]
colok_bebas = [d for d, s in sorted(agg_digit_score.items(), key=lambda x: x[1], reverse=True)[:4]]

# Ambil 2D ekor dari kandidat Prize 1 sebagai fokus utama
ekor_2d = []
for num, score in predictions[0]["candidates"][:20]:
    ekor = num[-2:]
    if ekor not in ekor_2d:
        ekor_2d.append(ekor)
    if len(ekor_2d) >= 8:
        break

print("\n=== RANGKUMAN ===")
print("BBFS 7 digit :", bbfs)
print("Colok bebas :", colok_bebas)
print("2D ekor kuat:", ekor_2d)

# --- 7) Simpan output CSV ---
out_rows = []
for pred in predictions:
    for rank, (num, score) in enumerate(pred["candidates"], start=1):
        out_rows.append({
            "target_date": str(next_date),
            "target_time": next_time,
            "prize_rank": pred["rank"],
            "candidate_rank": rank,
            "number": num,
            "score": score
        })

out = pd.DataFrame(out_rows)
out.to_csv("prediksi_paito.csv", index=False)
print("\nFile prediksi_paito.csv sudah dibuat.")
'''
Path('/mnt/data/prediksi_paito_colab.py').write_text(script, encoding='utf-8')
len(script), Path('/mnt/data/prediksi_paito_colab.py').exists()


(9660, True)

python
# Run script locally in /mnt/data to ensure no errors
import subprocess, textwrap, os, sys, json, pathlib, tempfile
res=subprocess.run([sys.executable, '/mnt/data/prediksi_paito_colab.py'], cwd='/mnt/data', capture_output=True, text=True, timeout=30)
print("return", res.returncode)
print(res.stdout[:2000])
print(res.stderr[:1000])

python
print(res.stdout[2000:4000])