Initial commit: Streamlit UI for Gale-Shapley Algorithm

.gitignore

@@ -0,0 +1,153 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# OS generated files
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Editors
+.vscode/
+.idea/
+*.swp
+*.swo

.streamlit/config.toml

@@ -0,0 +1,10 @@
+[theme]
+primaryColor = "#6C63FF"
+backgroundColor = "#0E1117"
+secondaryBackgroundColor = "#1A1D29"
+textColor = "#E0E0E0"
+font = "sans serif"
+
+[server]
+headless = true
+port = 8501

README.md

@@ -0,0 +1,90 @@
+# 🏠 Roommate Allocation System — Python & Streamlit Edition
+
+[![Python](https://img.shields.io/badge/Python-3.9+-3776AB?logo=python&logoColor=white)](https://python.org)
+[![Streamlit](https://img.shields.io/badge/Streamlit-1.30+-FF4B4B?logo=streamlit&logoColor=white)](https://streamlit.io)
+[![Algorithm](https://img.shields.io/badge/Algorithm-Gale--Shapley-6C63FF)](https://en.wikipedia.org/wiki/Gale%E2%80%93Shapley_algorithm)
+
+A modern **Streamlit UI** for the Gale-Shapley Roommate Allocation algorithm.  
+This version uses **Python** for the algorithm and **file-system storage** (JSON) instead of MySQL.
+
+> 🔗 **For the original C + MySQL version**, see:  
+> [https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git](https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git)
+
+---
+
+## ✨ Features
+
+- **Stable Matching** via the Nobel Prize-winning Gale-Shapley algorithm
+- **Two-Stage Allocation**: Roommate matching → CGPA-ranked room assignment
+- **CSV Import**: Bulk-upload students & rooms via CSV files
+- **File-System Storage**: No database needed — data stored as JSON
+- **Interactive Charts**: Plotly visualizations of CGPA distributions
+- **Premium UI**: Dark theme with glassmorphism, gradients, and animations
+
+---
+
+## 🚀 Quick Start
+
+```bash
+# 1. Create virtual environment
+python -m venv venv
+venv\Scripts\activate        # Windows
+# source venv/bin/activate   # macOS/Linux
+
+# 2. Install dependencies
+pip install -r requirements.txt
+
+# 3. Run the app
+streamlit run app.py
+```
+
+---
+
+## 📁 Project Structure
+
+```
+streamlit_gale_shapely/
+├── app.py                  # Main Streamlit UI application
+├── gale_shapley.py         # Gale-Shapley algorithm (Python port)
+├── db.py                   # File-system database layer (JSON)
+├── requirements.txt        # Python dependencies
+├── .streamlit/
+│   └── config.toml         # Streamlit theme configuration
+├── data/
+│   ├── students.json       # Student records (replaces MySQL 'main' table)
+│   ├── rooms.json          # Room records (replaces MySQL 'RoomNum' table)
+│   └── allocations.json    # Allocation results
+└── sample_csv/
+    ├── sample_students_10.csv   # 10 students (5 pairs)
+    ├── sample_rooms_5.csv       # 5 rooms for 10 students
+    ├── sample_students_26.csv   # 26 students (13 pairs)
+    └── sample_rooms_13.csv      # 13 rooms for 26 students
+```
+
+---
+
+## 📊 CSV Format
+
+### Students CSV
+| Column | Type | Description |
+|--------|------|-------------|
+| id | int | Unique student ID (0-indexed) |
+| name | str | Student name |
+| cgpa | float | CGPA (0.0–10.0) |
+| pref_roommate | str | Space-separated preferred roommate IDs |
+| pref_room | str | Space-separated preferred room IDs |
+
+### Rooms CSV
+| Column | Type | Description |
+|--------|------|-------------|
+| room_id | int | Unique room ID (0-indexed) |
+| room_number | str | Room label (e.g., "A101") |
+
+---
+
+## 🧠 Algorithm
+
+1. **Stage 1 — Roommate Matching**: Gale-Shapley pairs students into stable roommate matches.
+2. **Stage 2 — Room Allocation**: Pairs ranked by max CGPA select rooms via Gale-Shapley.
+
+Higher CGPA pairs get priority in room selection.

app.py

@@ -0,0 +1,456 @@
+"""
+Roommate Allocation System — Streamlit UI
+Uses the Gale-Shapley algorithm (Python implementation).
+For the original C + MySQL version, see:
+https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git
+"""
+
+import streamlit as st
+import pandas as pd
+import os, json
+
+from db import (
+    get_all_students, get_all_rooms, get_all_allocations,
+    save_all_students, save_all_rooms, save_allocations,
+    clear_all_students, clear_all_rooms, clear_allocations,
+    add_student, delete_student, add_room, delete_room,
+    import_students_from_csv, import_rooms_from_csv,
+    get_student_count, get_room_count,
+)
+from gale_shapley import run_full_allocation
+
+# ── Page Config ───────────────────────────────────────────────────────────────
+st.set_page_config(
+    page_title="Roommate Allocation · Gale-Shapley",
+    page_icon="🏠",
+    layout="wide",
+    initial_sidebar_state="expanded",
+)
+
+# ── Custom CSS ────────────────────────────────────────────────────────────────
+st.markdown("""
+<style>
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700;800&display=swap');
+:root {
+    --accent: #6C63FF; --accent2: #00D2FF; --bg: #0E1117;
+    --card: #161B22; --card2: #1A1D29; --text: #E0E0E0;
+    --success: #00E676; --warn: #FFD600; --danger: #FF5252;
+}
+html, body, [class*="css"] { font-family: 'Inter', sans-serif; }
+
+/* Hero banner */
+.hero {
+    background: linear-gradient(135deg, #6C63FF 0%, #00D2FF 100%);
+    border-radius: 16px; padding: 2.5rem 2rem; margin-bottom: 1.5rem;
+    text-align: center; position: relative; overflow: hidden;
+}
+.hero::before {
+    content: ''; position: absolute; inset: 0;
+    background: radial-gradient(circle at 30% 50%, rgba(255,255,255,.12) 0%, transparent 60%);
+}
+.hero h1 { color: #fff; font-size: 2.2rem; font-weight: 800; margin: 0; position: relative; }
+.hero p  { color: rgba(255,255,255,.85); font-size: 1rem; margin: .5rem 0 0; position: relative; }
+
+/* Stat cards */
+.stat-row { display: flex; gap: 1rem; margin-bottom: 1.5rem; flex-wrap: wrap; }
+.stat-card {
+    flex: 1; min-width: 160px; background: var(--card); border-radius: 14px;
+    padding: 1.4rem; text-align: center; border: 1px solid rgba(108,99,255,.25);
+    transition: transform .2s, box-shadow .2s;
+}
+.stat-card:hover { transform: translateY(-4px); box-shadow: 0 8px 24px rgba(108,99,255,.2); }
+.stat-card .num { font-size: 2rem; font-weight: 700; background: linear-gradient(135deg,#6C63FF,#00D2FF);
+    -webkit-background-clip: text; -webkit-text-fill-color: transparent; }
+.stat-card .lbl { color: #9CA3AF; font-size: .85rem; margin-top: .3rem; }
+
+/* Section headers */
+.sec-hdr { font-size: 1.35rem; font-weight: 700; margin: 1.5rem 0 .8rem;
+    padding-left: .6rem; border-left: 4px solid var(--accent); }
+
+/* Info banner */
+.info-banner {
+    background: linear-gradient(135deg, rgba(108,99,255,.12), rgba(0,210,255,.08));
+    border: 1px solid rgba(108,99,255,.3); border-radius: 12px;
+    padding: 1rem 1.2rem; margin: 1rem 0; font-size: .9rem; color: var(--text);
+}
+
+/* Footer */
+.footer { text-align: center; padding: 2rem 0 1rem; color: #6B7280; font-size: .82rem; }
+.footer a { color: var(--accent); text-decoration: none; }
+.footer a:hover { text-decoration: underline; }
+
+/* Table tweaks */
+.stDataFrame { border-radius: 12px; overflow: hidden; }
+</style>
+""", unsafe_allow_html=True)
+
+# ── Sidebar ───────────────────────────────────────────────────────────────────
+with st.sidebar:
+    st.markdown("## 🧭 Navigation")
+    page = st.radio(
+        "Go to",
+        ["🏠 Dashboard", "👥 Manage Students", "🚪 Manage Rooms",
+         "📂 CSV Import", "⚙️ Run Allocation", "📊 Results"],
+        label_visibility="collapsed",
+    )
+    st.markdown("---")
+    st.markdown(
+        '<div class="info-banner">'
+        '<b>🐍 Python + Streamlit Edition</b><br>'
+        'File-system storage (no MySQL needed).<br><br>'
+        'For the <b>C + MySQL</b> version:<br>'
+        '<a href="https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git" '
+        'target="_blank">View on GitHub ↗</a></div>',
+        unsafe_allow_html=True,
+    )
+
+# ── Helper ────────────────────────────────────────────────────────────────────
+def stat_cards(items):
+    cols = st.columns(len(items))
+    for col, (num, lbl) in zip(cols, items):
+        col.markdown(
+            f'<div class="stat-card"><div class="num">{num}</div>'
+            f'<div class="lbl">{lbl}</div></div>',
+            unsafe_allow_html=True,
+        )
+
+# ══════════════════════════════════════════════════════════════════════════════
+#  PAGES
+# ══════════════════════════════════════════════════════════════════════════════
+
+# ── Dashboard ─────────────────────────────────────────────────────────────────
+if page == "🏠 Dashboard":
+    st.markdown(
+        '<div class="hero"><h1>🏠 Roommate Allocation System</h1>'
+        '<p>Gale-Shapley Stable-Matching Algorithm · Python &amp; Streamlit</p></div>',
+        unsafe_allow_html=True,
+    )
+    n_stu = get_student_count()
+    n_rm  = get_room_count()
+    allocs = get_all_allocations()
+    stat_cards([
+        (n_stu, "Students"), (n_rm, "Rooms"),
+        (n_stu // 2 if n_stu else 0, "Possible Pairs"),
+        (len(allocs), "Allocations"),
+    ])
+
+    st.markdown('<div class="sec-hdr">How It Works</div>', unsafe_allow_html=True)
+    c1, c2 = st.columns(2)
+    with c1:
+        st.markdown("""
+**Stage 1 — Roommate Matching**
+1. Each student submits an ordered preference list of roommates.
+2. The Gale-Shapley algorithm pairs students into **stable matches**
+   (no two students would rather swap partners).
+""")
+    with c2:
+        st.markdown("""
+**Stage 2 — Room Allocation**
+1. Pairs are ranked by the **higher CGPA** in each pair.
+2. Ranked pairs select rooms via Gale-Shapley, so top performers
+   get priority for their preferred rooms.
+""")
+
+    st.markdown('<div class="sec-hdr">Quick Start</div>', unsafe_allow_html=True)
+    st.markdown("""
+1. **Add Students** — manually or via CSV upload.
+2. **Add Rooms** — manually or via CSV upload.
+3. **Run Allocation** — click one button to get stable assignments.
+4. **View Results** — see the final roommate + room table & charts.
+""")
+
+    st.markdown(
+        '<div class="footer">Built with Python &amp; Streamlit · '
+        'Algorithm by Gale &amp; Shapley (1962) · '
+        '<a href="https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git" '
+        'target="_blank">Original C + MySQL version</a></div>',
+        unsafe_allow_html=True,
+    )
+
+# ── Manage Students ──────────────────────────────────────────────────────────
+elif page == "👥 Manage Students":
+    st.markdown('<div class="sec-hdr">👥 Manage Students</div>', unsafe_allow_html=True)
+
+    students = get_all_students()
+    stat_cards([(len(students), "Total Students")])
+
+    # Show current students
+    if students:
+        df = pd.DataFrame(students)
+        df["pref_roommate"] = df["pref_roommate"].apply(lambda x: " ".join(map(str, x)))
+        df["pref_room"]     = df["pref_room"].apply(lambda x: " ".join(map(str, x)))
+        st.dataframe(df, use_container_width=True, hide_index=True)
+    else:
+        st.info("No students yet. Add below or import via CSV.")
+
+    st.markdown("---")
+    st.markdown("#### ➕ Add a Student")
+    with st.form("add_student", clear_on_submit=True):
+        ac1, ac2, ac3 = st.columns(3)
+        sid  = ac1.number_input("Student ID", min_value=0, step=1)
+        name = ac2.text_input("Name")
+        cgpa = ac3.number_input("CGPA", min_value=0.0, max_value=10.0, step=0.1)
+        pref_r = st.text_input("Roommate Preferences (space-separated IDs)", placeholder="5 6 7 8 9 ...")
+        pref_rm = st.text_input("Room Preferences (space-separated room IDs)", placeholder="0 1 2 3 4 ...")
+        submitted = st.form_submit_button("Add Student", type="primary")
+        if submitted:
+            if not name.strip():
+                st.error("Name cannot be empty.")
+            else:
+                try:
+                    pr = [int(x) for x in pref_r.strip().split()] if pref_r.strip() else []
+                    pm = [int(x) for x in pref_rm.strip().split()] if pref_rm.strip() else []
+                    ok = add_student({"id": int(sid), "name": name.strip(), "cgpa": float(cgpa),
+                                      "pref_roommate": pr, "pref_room": pm})
+                    if ok:
+                        st.success(f"✅ Added **{name}** (ID {sid})")
+                        st.rerun()
+                    else:
+                        st.error(f"Student ID {sid} already exists.")
+                except ValueError:
+                    st.error("Preferences must be space-separated integers.")
+
+    # Delete
+    if students:
+        st.markdown("#### 🗑️ Remove a Student")
+        dc1, dc2 = st.columns([3, 1])
+        del_id = dc1.selectbox("Select student to remove",
+                               [(s["id"], s["name"]) for s in students],
+                               format_func=lambda x: f"ID {x[0]} — {x[1]}")
+        if dc2.button("Delete", type="secondary"):
+            delete_student(del_id[0])
+            st.success(f"Removed student ID {del_id[0]}")
+            st.rerun()
+
+        if st.button("🗑️ Clear ALL Students", type="secondary"):
+            clear_all_students()
+            st.warning("All students cleared.")
+            st.rerun()
+
+# ── Manage Rooms ──────────────────────────────────────────────────────────────
+elif page == "🚪 Manage Rooms":
+    st.markdown('<div class="sec-hdr">🚪 Manage Rooms</div>', unsafe_allow_html=True)
+
+    rooms = get_all_rooms()
+    stat_cards([(len(rooms), "Total Rooms")])
+
+    if rooms:
+        st.dataframe(pd.DataFrame(rooms), use_container_width=True, hide_index=True)
+    else:
+        st.info("No rooms yet. Add below or import via CSV.")
+
+    st.markdown("---")
+    st.markdown("#### ➕ Add a Room")
+    with st.form("add_room", clear_on_submit=True):
+        rc1, rc2 = st.columns(2)
+        rid  = rc1.number_input("Room ID", min_value=0, step=1)
+        rnum = rc2.text_input("Room Number", placeholder="e.g. A101")
+        if st.form_submit_button("Add Room", type="primary"):
+            if not rnum.strip():
+                st.error("Room number cannot be empty.")
+            else:
+                ok = add_room({"room_id": int(rid), "room_number": rnum.strip()})
+                if ok:
+                    st.success(f"✅ Added room **{rnum}** (ID {rid})")
+                    st.rerun()
+                else:
+                    st.error(f"Room ID {rid} already exists.")
+
+    if rooms:
+        st.markdown("#### 🗑️ Remove a Room")
+        drc1, drc2 = st.columns([3, 1])
+        del_rid = drc1.selectbox("Select room to remove",
+                                 [(r["room_id"], r["room_number"]) for r in rooms],
+                                 format_func=lambda x: f"ID {x[0]} — {x[1]}")
+        if drc2.button("Delete", type="secondary"):
+            delete_room(del_rid[0])
+            st.success(f"Removed room ID {del_rid[0]}")
+            st.rerun()
+
+        if st.button("🗑️ Clear ALL Rooms", type="secondary"):
+            clear_all_rooms()
+            st.warning("All rooms cleared.")
+            st.rerun()
+
+# ── CSV Import ────────────────────────────────────────────────────────────────
+elif page == "📂 CSV Import":
+    st.markdown('<div class="sec-hdr">📂 CSV Import</div>', unsafe_allow_html=True)
+    st.markdown(
+        '<div class="info-banner">Upload CSV files to bulk-import students and rooms. '
+        'This is useful when manual entry is tedious or when the allocation is complex.</div>',
+        unsafe_allow_html=True,
+    )
+
+    tab1, tab2, tab3 = st.tabs(["📥 Import Students", "📥 Import Rooms", "📄 Sample CSVs"])
+
+    with tab1:
+        st.markdown("**Expected columns:** `id, name, cgpa, pref_roommate, pref_room`")
+        st.caption("Preferences are space-separated integer IDs.")
+        f = st.file_uploader("Upload Students CSV", type=["csv"], key="stu_csv")
+        if f:
+            content = f.getvalue().decode("utf-8")
+            st.markdown("**Preview:**")
+            st.dataframe(pd.read_csv(f), use_container_width=True, hide_index=True)
+            f.seek(0)
+            if st.button("✅ Import Students", type="primary"):
+                cnt, errs = import_students_from_csv(content)
+                if errs:
+                    for e in errs:
+                        st.error(e)
+                st.success(f"Imported **{cnt}** students.")
+                st.rerun()
+
+    with tab2:
+        st.markdown("**Expected columns:** `room_id, room_number`")
+        f2 = st.file_uploader("Upload Rooms CSV", type=["csv"], key="room_csv")
+        if f2:
+            content2 = f2.getvalue().decode("utf-8")
+            st.markdown("**Preview:**")
+            st.dataframe(pd.read_csv(f2), use_container_width=True, hide_index=True)
+            f2.seek(0)
+            if st.button("✅ Import Rooms", type="primary"):
+                cnt2, errs2 = import_rooms_from_csv(content2)
+                if errs2:
+                    for e in errs2:
+                        st.error(e)
+                st.success(f"Imported **{cnt2}** rooms.")
+                st.rerun()
+
+    with tab3:
+        st.markdown("#### Sample CSV Files")
+        st.markdown("Download these to understand the expected format, then modify and re-upload.")
+        sample_dir = os.path.join(os.path.dirname(__file__), "sample_csv")
+        for fname in sorted(os.listdir(sample_dir)):
+            fpath = os.path.join(sample_dir, fname)
+            with open(fpath, "r") as sf:
+                st.download_button(f"⬇️  {fname}", sf.read(), file_name=fname, mime="text/csv")
+            with open(fpath, "r") as sf:
+                st.markdown(f"**`{fname}` preview:**")
+                st.code(sf.read(), language="csv")
+
+# ── Run Allocation ────────────────────────────────────────────────────────────
+elif page == "⚙️ Run Allocation":
+    st.markdown('<div class="sec-hdr">⚙️ Run Allocation</div>', unsafe_allow_html=True)
+
+    students = get_all_students()
+    rooms    = get_all_rooms()
+    n_stu = len(students)
+    n_rm  = len(rooms)
+
+    stat_cards([(n_stu, "Students"), (n_rm, "Rooms"), (n_stu // 2, "Pairs Needed")])
+
+    # Validation
+    issues = []
+    if n_stu < 2:
+        issues.append("Need at least 2 students.")
+    if n_stu % 2 != 0:
+        issues.append("Number of students must be even.")
+    if n_rm < n_stu // 2:
+        issues.append(f"Need at least {n_stu // 2} rooms (have {n_rm}).")
+
+    if issues:
+        for iss in issues:
+            st.error(f"❌ {iss}")
+        st.info("Fix the above issues before running the algorithm.")
+    else:
+        st.success("✅ All checks passed — ready to allocate!")
+        st.markdown(
+            '<div class="info-banner">'
+            '<b>Stage 1:</b> Gale-Shapley matches students into roommate pairs.<br>'
+            '<b>Stage 2:</b> Pairs ranked by CGPA select rooms via Gale-Shapley.</div>',
+            unsafe_allow_html=True,
+        )
+
+        if st.button("🚀  Run Gale-Shapley Allocation", type="primary", use_container_width=True):
+            with st.spinner("Running Gale-Shapley algorithm..."):
+                try:
+                    allocs = run_full_allocation(students, rooms)
+                    save_allocations(allocs)
+                    st.success(f"🎉 Allocation complete — **{len(allocs)} pairs** assigned!")
+                    st.balloons()
+
+                    df = pd.DataFrame(allocs)
+                    display_cols = ["roommate1_name", "roommate1_cgpa",
+                                    "roommate2_name", "roommate2_cgpa",
+                                    "room_number", "pair_max_cgpa"]
+                    st.dataframe(df[display_cols], use_container_width=True, hide_index=True)
+                except Exception as e:
+                    st.error(f"Allocation failed: {e}")
+                    st.info("Try importing data via CSV if manual entry is causing issues.")
+
+# ── Results ───────────────────────────────────────────────────────────────────
+elif page == "📊 Results":
+    st.markdown('<div class="sec-hdr">📊 Allocation Results</div>', unsafe_allow_html=True)
+
+    allocs = get_all_allocations()
+    if not allocs:
+        st.info("No allocation results yet. Go to **⚙️ Run Allocation** first.")
+    else:
+        df = pd.DataFrame(allocs)
+
+        stat_cards([
+            (len(df), "Pairs Allocated"),
+            (f"{df['pair_max_cgpa'].mean():.2f}", "Avg Pair CGPA"),
+            (df["room_number"].nunique(), "Rooms Used"),
+        ])
+
+        # Main table
+        st.markdown("#### 📋 Final Allocation Table")
+        display = df[["roommate1_name", "roommate1_cgpa",
+                       "roommate2_name", "roommate2_cgpa",
+                       "room_number", "pair_max_cgpa"]].copy()
+        display.columns = ["Roommate 1", "CGPA 1", "Roommate 2", "CGPA 2", "Room", "Pair CGPA"]
+        st.dataframe(display, use_container_width=True, hide_index=True)
+
+        # Download
+        csv_out = display.to_csv(index=False)
+        st.download_button("⬇️  Download Results CSV", csv_out,
+                           file_name="allocation_results.csv", mime="text/csv")
+
+        # Charts
+        st.markdown("#### 📈 CGPA Distribution")
+        import plotly.express as px
+
+        fig = px.bar(
+            display, x="Room", y="Pair CGPA",
+            color="Pair CGPA",
+            color_continuous_scale=["#6C63FF", "#00D2FF"],
+            title="Pair CGPA by Room Assignment",
+        )
+        fig.update_layout(
+            plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
+            font_color="#E0E0E0", title_font_size=16,
+        )
+        st.plotly_chart(fig, use_container_width=True)
+
+        # Roommate comparison
+        st.markdown("#### 🤝 Roommate CGPA Comparison")
+        comp = pd.DataFrame({
+            "Room": display["Room"],
+            "Roommate 1": display["CGPA 1"],
+            "Roommate 2": display["CGPA 2"],
+        })
+        fig2 = px.bar(
+            comp.melt(id_vars="Room", var_name="Roommate", value_name="CGPA"),
+            x="Room", y="CGPA", color="Roommate", barmode="group",
+            color_discrete_sequence=["#6C63FF", "#00D2FF"],
+            title="CGPA Comparison per Room",
+        )
+        fig2.update_layout(
+            plot_bgcolor="rgba(0,0,0,0)", paper_bgcolor="rgba(0,0,0,0)",
+            font_color="#E0E0E0", title_font_size=16,
+        )
+        st.plotly_chart(fig2, use_container_width=True)
+
+        if st.button("🗑️ Clear Results", type="secondary"):
+            clear_allocations()
+            st.warning("Results cleared.")
+            st.rerun()
+
+    st.markdown(
+        '<div class="footer">Built with <b>Python &amp; Streamlit</b> · '
+        'For the <b>C + MySQL</b> version, visit '
+        '<a href="https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git" '
+        'target="_blank">GitHub ↗</a></div>',
+        unsafe_allow_html=True,
+    )

data/allocations.json

@@ -0,0 +1,57 @@
+[
+  {
+    "roommate1_id": 2,
+    "roommate1_name": "Charlie",
+    "roommate1_cgpa": 9.5,
+    "roommate2_id": 7,
+    "roommate2_name": "Henry",
+    "roommate2_cgpa": 8.6,
+    "room_number": "A103",
+    "room_id": 2,
+    "pair_max_cgpa": 9.5
+  },
+  {
+    "roommate1_id": 1,
+    "roommate1_name": "Bob",
+    "roommate1_cgpa": 8.9,
+    "roommate2_id": 6,
+    "roommate2_name": "Grace",
+    "roommate2_cgpa": 9.3,
+    "room_number": "A102",
+    "room_id": 1,
+    "pair_max_cgpa": 9.3
+  },
+  {
+    "roommate1_id": 0,
+    "roommate1_name": "Alice",
+    "roommate1_cgpa": 9.2,
+    "roommate2_id": 5,
+    "roommate2_name": "Frank",
+    "roommate2_cgpa": 8.8,
+    "room_number": "A101",
+    "room_id": 0,
+    "pair_max_cgpa": 9.2
+  },
+  {
+    "roommate1_id": 3,
+    "roommate1_name": "Diana",
+    "roommate1_cgpa": 8.7,
+    "roommate2_id": 8,
+    "roommate2_name": "Ivy",
+    "roommate2_cgpa": 9.1,
+    "room_number": "B201",
+    "room_id": 3,
+    "pair_max_cgpa": 9.1
+  },
+  {
+    "roommate1_id": 4,
+    "roommate1_name": "Eve",
+    "roommate1_cgpa": 9.0,
+    "roommate2_id": 9,
+    "roommate2_name": "Jack",
+    "roommate2_cgpa": 8.5,
+    "room_number": "B202",
+    "room_id": 4,
+    "pair_max_cgpa": 9.0
+  }
+]

data/rooms.json

@@ -0,0 +1 @@
+[]

data/students.json

@@ -0,0 +1 @@
+[]

db.py

@@ -0,0 +1,266 @@
+"""
+File-System Database Layer
+
+Replaces MySQL with JSON file storage for students, rooms, and allocations.
+Mirrors the original MySQL schema:
+  - main table  → data/students.json
+  - RoomNum     → data/rooms.json
+  - results     → data/allocations.json
+"""
+
+import json
+import os
+from typing import List, Optional
+
+# ─── Paths ────────────────────────────────────────────────────────────────────
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+DATA_DIR = os.path.join(BASE_DIR, "data")
+
+STUDENTS_FILE = os.path.join(DATA_DIR, "students.json")
+ROOMS_FILE = os.path.join(DATA_DIR, "rooms.json")
+ALLOCATIONS_FILE = os.path.join(DATA_DIR, "allocations.json")
+
+
+def _ensure_data_dir():
+    """Create data directory if it doesn't exist."""
+    os.makedirs(DATA_DIR, exist_ok=True)
+
+
+def _read_json(filepath: str) -> list:
+    """Read a JSON file and return the parsed list."""
+    _ensure_data_dir()
+    if not os.path.exists(filepath):
+        with open(filepath, "w") as f:
+            json.dump([], f)
+        return []
+    try:
+        with open(filepath, "r") as f:
+            data = json.load(f)
+        return data if isinstance(data, list) else []
+    except (json.JSONDecodeError, IOError):
+        return []
+
+
+def _write_json(filepath: str, data: list):
+    """Write a list to a JSON file."""
+    _ensure_data_dir()
+    with open(filepath, "w") as f:
+        json.dump(data, f, indent=2)
+
+
+# ─── Student Operations ──────────────────────────────────────────────────────
+
+
+def get_all_students() -> List[dict]:
+    """Get all students from the database."""
+    return _read_json(STUDENTS_FILE)
+
+
+def get_student_by_id(student_id: int) -> Optional[dict]:
+    """Get a specific student by ID."""
+    students = get_all_students()
+    for s in students:
+        if s["id"] == student_id:
+            return s
+    return None
+
+
+def add_student(student: dict) -> bool:
+    """
+    Add a new student.
+
+    student dict should contain:
+      - id: int
+      - name: str
+      - cgpa: float
+      - pref_roommate: List[int]  (ordered list of preferred roommate IDs)
+      - pref_room: List[int]      (ordered list of preferred room IDs)
+    """
+    students = get_all_students()
+    # Check for duplicate ID
+    for s in students:
+        if s["id"] == student["id"]:
+            return False
+    students.append(student)
+    _write_json(STUDENTS_FILE, students)
+    return True
+
+
+def update_student(student_id: int, updated_data: dict) -> bool:
+    """Update an existing student's data."""
+    students = get_all_students()
+    for i, s in enumerate(students):
+        if s["id"] == student_id:
+            students[i].update(updated_data)
+            _write_json(STUDENTS_FILE, students)
+            return True
+    return False
+
+
+def delete_student(student_id: int) -> bool:
+    """Delete a student by ID."""
+    students = get_all_students()
+    new_students = [s for s in students if s["id"] != student_id]
+    if len(new_students) == len(students):
+        return False
+    _write_json(STUDENTS_FILE, new_students)
+    return True
+
+
+def clear_all_students():
+    """Remove all students."""
+    _write_json(STUDENTS_FILE, [])
+
+
+def save_all_students(students: List[dict]):
+    """Overwrite the entire students database."""
+    _write_json(STUDENTS_FILE, students)
+
+
+def get_student_count() -> int:
+    """Get the total number of students."""
+    return len(get_all_students())
+
+
+# ─── Room Operations ─────────────────────────────────────────────────────────
+
+
+def get_all_rooms() -> List[dict]:
+    """Get all rooms from the database."""
+    return _read_json(ROOMS_FILE)
+
+
+def add_room(room: dict) -> bool:
+    """
+    Add a new room.
+
+    room dict should contain:
+      - room_id: int
+      - room_number: str (e.g., 'A101')
+    """
+    rooms = get_all_rooms()
+    for r in rooms:
+        if r["room_id"] == room["room_id"]:
+            return False
+    rooms.append(room)
+    _write_json(ROOMS_FILE, rooms)
+    return True
+
+
+def delete_room(room_id: int) -> bool:
+    """Delete a room by ID."""
+    rooms = get_all_rooms()
+    new_rooms = [r for r in rooms if r["room_id"] != room_id]
+    if len(new_rooms) == len(rooms):
+        return False
+    _write_json(ROOMS_FILE, new_rooms)
+    return True
+
+
+def clear_all_rooms():
+    """Remove all rooms."""
+    _write_json(ROOMS_FILE, [])
+
+
+def save_all_rooms(rooms: List[dict]):
+    """Overwrite the entire rooms database."""
+    _write_json(ROOMS_FILE, rooms)
+
+
+def get_room_count() -> int:
+    """Get the total number of rooms."""
+    return len(get_all_rooms())
+
+
+# ─── Allocation Operations ───────────────────────────────────────────────────
+
+
+def get_all_allocations() -> List[dict]:
+    """Get all allocation results."""
+    return _read_json(ALLOCATIONS_FILE)
+
+
+def save_allocations(allocations: List[dict]):
+    """Save allocation results (overwrites previous results)."""
+    _write_json(ALLOCATIONS_FILE, allocations)
+
+
+def clear_allocations():
+    """Clear all allocation results."""
+    _write_json(ALLOCATIONS_FILE, [])
+
+
+# ─── Bulk Import from CSV ────────────────────────────────────────────────────
+
+
+def import_students_from_csv(csv_content: str) -> tuple:
+    """
+    Import students from CSV content.
+
+    Expected columns: id, name, cgpa, pref_roommate, pref_room
+    pref_roommate and pref_room should be space-separated integers.
+
+    Returns:
+        (success_count, error_messages)
+    """
+    import csv
+    import io
+
+    reader = csv.DictReader(io.StringIO(csv_content))
+    students = []
+    errors = []
+
+    for row_num, row in enumerate(reader, start=2):
+        try:
+            student = {
+                "id": int(row["id"].strip()),
+                "name": row["name"].strip(),
+                "cgpa": float(row["cgpa"].strip()),
+                "pref_roommate": [
+                    int(x) for x in row["pref_roommate"].strip().split()
+                ],
+                "pref_room": [
+                    int(x) for x in row["pref_room"].strip().split()
+                ],
+            }
+            students.append(student)
+        except (KeyError, ValueError) as e:
+            errors.append(f"Row {row_num}: {str(e)}")
+
+    if students:
+        save_all_students(students)
+
+    return len(students), errors
+
+
+def import_rooms_from_csv(csv_content: str) -> tuple:
+    """
+    Import rooms from CSV content.
+
+    Expected columns: room_id, room_number
+
+    Returns:
+        (success_count, error_messages)
+    """
+    import csv
+    import io
+
+    reader = csv.DictReader(io.StringIO(csv_content))
+    rooms = []
+    errors = []
+
+    for row_num, row in enumerate(reader, start=2):
+        try:
+            room = {
+                "room_id": int(row["room_id"].strip()),
+                "room_number": row["room_number"].strip(),
+            }
+            rooms.append(room)
+        except (KeyError, ValueError) as e:
+            errors.append(f"Row {row_num}: {str(e)}")
+
+    if rooms:
+        save_all_rooms(rooms)
+
+    return len(rooms), errors

gale_shapley.py

@@ -0,0 +1,254 @@
+"""
+Gale-Shapley Algorithm Implementation
+
+Python port of the C implementation from the original project.
+Implements the Stable Marriage Problem for roommate matching and room allocation.
+
+Original C version: https://github.com/Harshwardhan-Deshmukh03/Roommate-allocation-using-Gale-Shapley-Algorithm.git
+"""
+
+from typing import Dict, List, Tuple, Optional
+
+
+def gale_shapley(pref_matrix: List[List[int]], n: int) -> Dict[int, int]:
+    """
+    Run the Gale-Shapley algorithm for stable matching.
+
+    This is a direct Python translation of the C galeShapley() function.
+    Students 0..n-1 are "proposers" and students n..2n-1 are "acceptors".
+
+    Args:
+        pref_matrix: 2D preference list. pref_matrix[i] is the ordered preference 
+                     list for person i. For proposers (0..n-1), preferences are 
+                     indices in the acceptor range (n..2n-1). For acceptors, 
+                     preferences are proposer indices (0..n-1).
+        n: Number of pairs (half the total participants).
+
+    Returns:
+        Dictionary mapping each person to their matched partner.
+    """
+    # match[i] = partner of person i, -1 means unmatched
+    match = [-1] * (2 * n)
+    free_count = n
+
+    # Track which preference index each proposer is up to
+    next_proposal = [0] * n
+
+    while free_count > 0:
+        # Find the first free proposer
+        m = -1
+        for i in range(n):
+            if match[i] == -1:
+                m = i
+                break
+
+        if m == -1:
+            break
+
+        # Proposer m proposes to their next preferred acceptor
+        while next_proposal[m] < n:
+            w = pref_matrix[m][next_proposal[m]]
+            next_proposal[m] += 1
+
+            if match[w] == -1:
+                # w is free, accept the proposal
+                match[w] = m
+                match[m] = w
+                free_count -= 1
+                break
+            else:
+                # w is already matched, check if w prefers m over current partner
+                m1 = match[w]
+                if _prefers_new_over_current(pref_matrix, w, m, m1):
+                    # w prefers m over m1 — switch
+                    match[w] = m
+                    match[m] = w
+                    match[m1] = -1  # m1 becomes free
+                    break
+                # else w rejects m, m tries next preference
+
+    return match
+
+
+def _prefers_new_over_current(
+    pref_matrix: List[List[int]], w: int, m_new: int, m_current: int
+) -> bool:
+    """
+    Check if acceptor w prefers m_new over m_current.
+    
+    Mirrors the C function wPrefersm1Overm() but with clearer naming.
+    Returns True if w prefers m_new over m_current.
+    """
+    for pref in pref_matrix[w]:
+        if pref == m_new:
+            return True
+        if pref == m_current:
+            return False
+    return False
+
+
+def run_roommate_matching(students: List[dict]) -> List[Tuple[int, int]]:
+    """
+    Stage 1: Match students into roommate pairs using Gale-Shapley.
+
+    Args:
+        students: List of student dicts with 'id', 'name', 'cgpa', 'pref_roommate'.
+
+    Returns:
+        List of (student_id_1, student_id_2) roommate pairs.
+    """
+    n_students = len(students)
+    if n_students < 2 or n_students % 2 != 0:
+        raise ValueError(
+            f"Need an even number of students (≥ 2). Got {n_students}."
+        )
+
+    n = n_students // 2  # Number of pairs
+
+    # Build preference matrix: proposers are 0..n-1, acceptors are n..2n-1
+    # Each student's pref_roommate contains IDs of other students they prefer
+    pref_matrix = []
+    for student in students:
+        prefs = student["pref_roommate"]
+        # Filter out only valid preferences (should be IDs of other students)
+        # For proposers (0..n-1): their prefs should reference acceptors (n..2n-1)
+        # For acceptors (n..2n-1): their prefs should reference proposers (0..n-1)
+        sid = student["id"]
+        if sid < n:
+            # Proposer: filter prefs to only include acceptor IDs (n..2n-1)
+            filtered = [p for p in prefs if n <= p < 2 * n]
+        else:
+            # Acceptor: filter prefs to only include proposer IDs (0..n-1)
+            filtered = [p for p in prefs if 0 <= p < n]
+        pref_matrix.append(filtered)
+
+    # Run Gale-Shapley
+    match = gale_shapley(pref_matrix, n)
+
+    # Extract unique pairs (only from proposer side to avoid duplicates)
+    pairs = []
+    seen = set()
+    for i in range(n):
+        partner = match[i]
+        if partner != -1 and i not in seen and partner not in seen:
+            pairs.append((i, partner))
+            seen.add(i)
+            seen.add(partner)
+
+    return pairs
+
+
+def run_room_allocation(
+    students: List[dict],
+    roommate_pairs: List[Tuple[int, int]],
+    rooms: List[dict],
+) -> List[dict]:
+    """
+    Stage 2: Allocate rooms to roommate pairs based on CGPA ranking.
+
+    Higher CGPA pairs get priority in room selection (Gale-Shapley on rooms).
+
+    Args:
+        students: List of student dicts with 'id', 'name', 'cgpa', 'pref_room'.
+        roommate_pairs: List of (id1, id2) roommate pairs from Stage 1.
+        rooms: List of room dicts with 'room_id' and 'room_number'.
+
+    Returns:
+        List of allocation dicts: {roommate1, roommate2, room_number, room_id, pair_cgpa}
+    """
+    n = len(roommate_pairs)
+    n_rooms = len(rooms)
+
+    if n_rooms < n:
+        raise ValueError(
+            f"Not enough rooms ({n_rooms}) for {n} pairs."
+        )
+
+    # Build student lookup
+    student_map = {s["id"]: s for s in students}
+
+    # Rank pairs by the higher CGPA in each pair (descending)
+    pair_cgpas = []
+    for id1, id2 in roommate_pairs:
+        cgpa1 = student_map[id1]["cgpa"]
+        cgpa2 = student_map[id2]["cgpa"]
+        max_cgpa = max(cgpa1, cgpa2)
+        pair_cgpas.append((max_cgpa, id1, id2))
+
+    # Sort descending by max CGPA
+    pair_cgpas.sort(key=lambda x: x[0], reverse=True)
+
+    # Build room preference matrix for Gale-Shapley
+    # Proposers: ranked pairs (0..n-1) → these map to pair_cgpas indices
+    # Acceptors: rooms (n..2n-1) → these map to rooms indices (offset by n)
+    room_id_to_index = {rooms[j]["room_id"]: j + n for j in range(n)}
+
+    pref_matrix = [[] for _ in range(2 * n)]
+
+    # For each ranked pair, get the higher-CGPA student's room preferences
+    for rank_idx, (max_cgpa, id1, id2) in enumerate(pair_cgpas):
+        # Use the higher CGPA student's room preferences
+        if student_map[id1]["cgpa"] >= student_map[id2]["cgpa"]:
+            prefs = student_map[id1].get("pref_room", [])
+        else:
+            prefs = student_map[id2].get("pref_room", [])
+
+        # Map room IDs to room indices (offset by n for acceptor range)
+        mapped_prefs = []
+        for room_id in prefs:
+            if room_id in room_id_to_index:
+                mapped_prefs.append(room_id_to_index[room_id])
+        pref_matrix[rank_idx] = mapped_prefs
+
+    # Rooms accept any student in order (no real preference)
+    for j in range(n):
+        pref_matrix[n + j] = list(range(n))
+
+    # Run Gale-Shapley for room allocation
+    match = gale_shapley(pref_matrix, n)
+
+    # Build index-to-room mapping
+    index_to_room = {j + n: rooms[j] for j in range(n)}
+
+    # Build final allocation
+    allocations = []
+    for rank_idx, (max_cgpa, id1, id2) in enumerate(pair_cgpas):
+        room_index = match[rank_idx]
+        room = index_to_room.get(room_index, {"room_number": "N/A", "room_id": -1})
+
+        allocations.append({
+            "roommate1_id": id1,
+            "roommate1_name": student_map[id1]["name"],
+            "roommate1_cgpa": student_map[id1]["cgpa"],
+            "roommate2_id": id2,
+            "roommate2_name": student_map[id2]["name"],
+            "roommate2_cgpa": student_map[id2]["cgpa"],
+            "room_number": room["room_number"],
+            "room_id": room["room_id"],
+            "pair_max_cgpa": max_cgpa,
+        })
+
+    return allocations
+
+
+def run_full_allocation(students: List[dict], rooms: List[dict]) -> List[dict]:
+    """
+    Run the complete two-stage allocation pipeline.
+
+    Stage 1: Gale-Shapley for roommate matching.
+    Stage 2: CGPA-ranked Gale-Shapley for room allocation.
+
+    Args:
+        students: List of student dicts.
+        rooms: List of room dicts.
+
+    Returns:
+        List of allocation result dicts.
+    """
+    # Stage 1: Roommate matching
+    roommate_pairs = run_roommate_matching(students)
+
+    # Stage 2: Room allocation
+    allocations = run_room_allocation(students, roommate_pairs, rooms)
+
+    return allocations

requirements.txt

@@ -0,0 +1,3 @@
+streamlit>=1.30.0
+pandas>=2.0.0
+plotly>=5.18.0

sample_csv/sample_rooms_13.csv

@@ -0,0 +1,14 @@
+room_id,room_number
+0,A101
+1,A102
+2,A103
+3,A104
+4,A105
+5,B201
+6,B202
+7,B203
+8,B204
+9,B205
+10,C301
+11,C302
+12,C303

sample_csv/sample_rooms_5.csv

@@ -0,0 +1,6 @@
+room_id,room_number
+0,A101
+1,A102
+2,A103
+3,B201
+4,B202

sample_csv/sample_students_10.csv

@@ -0,0 +1,11 @@
+id,name,cgpa,pref_roommate,pref_room
+0,Alice,9.2,5 6 7 8 9 1 2 3 4,0 1 2 3 4
+1,Bob,8.9,5 6 7 8 9 0 2 3 4,1 0 2 3 4
+2,Charlie,9.5,5 6 7 8 9 3 1 0 4,2 1 0 3 4
+3,Diana,8.7,5 6 7 8 9 2 0 1 4,3 2 1 0 4
+4,Eve,9.0,5 6 7 8 9 0 1 2 3,4 3 2 1 0
+5,Frank,8.8,0 1 2 3 4 6 7 8 9,0 1 2 3 4
+6,Grace,9.3,0 1 2 3 4 7 5 8 9,1 0 2 3 4
+7,Henry,8.6,0 1 2 3 4 6 5 8 9,2 1 0 3 4
+8,Ivy,9.1,0 1 2 3 4 9 5 6 7,3 2 1 0 4
+9,Jack,8.5,0 1 2 3 4 8 5 6 7,4 3 2 1 0

sample_csv/sample_students_26.csv

@@ -0,0 +1,27 @@
+id,name,cgpa,pref_roommate,pref_room
+0,Aarav Sharma,9.4,13 14 15 16 17 18 19 20 21 22 23 24 25 1 2 3 4 5 6 7 8 9 10 11 12,0 1 2 3 4 5 6 7 8 9 10 11 12
+1,Priya Patel,8.8,13 14 15 16 17 18 19 20 21 22 23 24 25 0 2 3 4 5 6 7 8 9 10 11 12,1 0 2 3 4 5 6 7 8 9 10 11 12
+2,Rohan Mehta,9.1,13 14 15 16 17 18 19 20 21 22 23 24 25 3 0 1 4 5 6 7 8 9 10 11 12,2 1 0 3 4 5 6 7 8 9 10 11 12
+3,Sneha Kulkarni,8.5,13 14 15 16 17 18 19 20 21 22 23 24 25 2 0 1 4 5 6 7 8 9 10 11 12,3 2 1 0 4 5 6 7 8 9 10 11 12
+4,Vikram Singh,9.0,13 14 15 16 17 18 19 20 21 22 23 24 25 5 6 7 0 1 2 3 8 9 10 11 12,4 5 6 7 0 1 2 3 8 9 10 11 12
+5,Ananya Desai,8.7,13 14 15 16 17 18 19 20 21 22 23 24 25 4 6 7 0 1 2 3 8 9 10 11 12,5 4 6 7 0 1 2 3 8 9 10 11 12
+6,Karan Joshi,9.3,13 14 15 16 17 18 19 20 21 22 23 24 25 7 5 4 0 1 2 3 8 9 10 11 12,6 5 4 7 0 1 2 3 8 9 10 11 12
+7,Meera Nair,8.9,13 14 15 16 17 18 19 20 21 22 23 24 25 6 5 4 0 1 2 3 8 9 10 11 12,7 6 5 4 0 1 2 3 8 9 10 11 12
+8,Arjun Reddy,9.2,13 14 15 16 17 18 19 20 21 22 23 24 25 9 10 11 0 1 2 3 4 5 6 7 12,8 9 10 11 0 1 2 3 4 5 6 7 12
+9,Divya Iyer,8.6,13 14 15 16 17 18 19 20 21 22 23 24 25 8 10 11 0 1 2 3 4 5 6 7 12,9 8 10 11 0 1 2 3 4 5 6 7 12
+10,Nikhil Gupta,9.5,13 14 15 16 17 18 19 20 21 22 23 24 25 11 8 9 0 1 2 3 4 5 6 7 12,10 11 8 9 0 1 2 3 4 5 6 7 12
+11,Ritu Agarwal,8.4,13 14 15 16 17 18 19 20 21 22 23 24 25 10 8 9 0 1 2 3 4 5 6 7 12,11 10 8 9 0 1 2 3 4 5 6 7 12
+12,Siddharth Rao,8.3,13 14 15 16 17 18 19 20 21 22 23 24 25 0 1 2 3 4 5 6 7 8 9 10 11,12 0 1 2 3 4 5 6 7 8 9 10 11
+13,Pooja Verma,9.0,0 1 2 3 4 5 6 7 8 9 10 11 12 14 15 16 17 18 19 20 21 22 23 24 25,0 1 2 3 4 5 6 7 8 9 10 11 12
+14,Harsh Deshmukh,8.7,0 1 2 3 4 5 6 7 8 9 10 11 12 13 15 16 17 18 19 20 21 22 23 24 25,1 0 2 3 4 5 6 7 8 9 10 11 12
+15,Kavya Menon,9.2,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 16 17 18 19 20 21 22 23 24 25,2 1 0 3 4 5 6 7 8 9 10 11 12
+16,Aditya Bhatt,8.5,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 17 18 19 20 21 22 23 24 25,3 2 1 0 4 5 6 7 8 9 10 11 12
+17,Tanvi Shah,8.8,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 18 19 20 21 22 23 24 25,4 3 2 1 0 5 6 7 8 9 10 11 12
+18,Parth Mane,9.1,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 19 20 21 22 23 24 25,5 4 3 2 1 0 6 7 8 9 10 11 12
+19,Ishita Roy,8.6,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 20 21 22 23 24 25,6 5 4 3 2 1 0 7 8 9 10 11 12
+20,Jia Johnson,9.4,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 21 22 23 24 25,7 6 5 4 3 2 1 0 8 9 10 11 12
+21,Rahul Kapoor,8.3,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 22 23 24 25,8 7 6 5 4 3 2 1 0 9 10 11 12
+22,Neha Saxena,8.9,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 23 24 25,9 8 7 6 5 4 3 2 1 0 10 11 12
+23,Yash Tiwari,8.2,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 24 25,10 9 8 7 6 5 4 3 2 1 0 11 12
+24,Shweta Mishra,9.3,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 25,11 10 9 8 7 6 5 4 3 2 1 0 12
+25,Amit Pandey,8.0,0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24,12 11 10 9 8 7 6 5 4 3 2 1 0