椛的超级大份 - Ba☆Ka～

《咱们仨》

公告

公告就是没有公告喵

标签

AI baka 咱的女儿日常日记椛的小日记疯狂星期四神秘小项目

《咱们仨》

公告

公告就是没有公告喵

标签

AI baka 咱的女儿日常日记椛的小日记疯狂星期四神秘小项目

《咱们仨》

公告

公告就是没有公告喵

标签

AI baka 咱的女儿日常日记椛的小日记疯狂星期四神秘小项目

站点统计

文章

12

分类

4

标签

8

总字数

12,849

运行天数

0 天

最后活动

0 天前

720 字

2 分钟

椛的超级大份

2026-04-25

神秘小项目

今天闲来无事，突然想起来干爹之前说想写一个cf滚榜，然后咱想着闲着也是闲着就写了个洛谷的

先说一下咱的思路

graph TD A[咱 Arch 电脑] --> B[使用py抓取洛谷比赛排行榜json] B -->C[将抓取到的json简单改一下格式塞进本地json] C --> E[使用前端进行展示和滚榜功能]

抓取数据#

咱想了很多种滚榜方式，比如

获取全部排行榜，然后直接对这个总榜进行更改 —> 优点是展示的很全，所有人都能展示出来；缺点是如果人很多则会导致很慢
只获取五个，前后各两个，自己在中间 —> 优点是对于只查询自己的情况速度会快不少，如果有多个人也可考虑使用这个方式；缺点是获取数据的时候会稍微有一点麻烦（也可能是咱太菜了）
只查询特定人员，然后在这些人里面进行滚榜 —> 优点是对于《小团体》来说完全够用，比如说朋友间《切磋》之类的；缺点也很明显，他只能查这几个人的数据

咱选择了最后一个方式，因为咱是蒟蒻，写不出太高深的东西（（（

先来看一下代码

1
import requests
2
import json
3
import time
4
from datetime import datetime
5

6
url_id =  # 目标比赛id喵
7
uids = [用户id1,用户id2] # 目标用户id喵
8
cookies = { # 下面填成你的喵
9
    "__client_id": "你的__client_id喵",
10
    "_uid": "你的_uid喵",
11
    "C3VK": "你的C3VK喵",
12
}
13

14
position_cache = {}
15

16
def main():
17
    build_cache(url_id, uids, cookies)
18
    print(f"缓存: {position_cache}")
19

20
    while True:
21
        result = fetch_by_cache(url_id, uids, cookies)
22
        write_data(url_id, result)
23
        print(f"更新: {result['updateTime']}")
24
        time.sleep(10)
25

26
def fetch_page(url_id, page, headers, cookie):
27
    baseurl = f"https://www.luogu.com.cn/fe/api/contest/scoreboard/{url_id}?page={page}"
28
    try:
29
        response = requests.get(baseurl, headers=headers, cookies=cookie, timeout=30)
30
        if response.status_code == 200:
31
            return response.json()
32
        return None
33
    except Exception as e:
34
        print(f'第{page}页异常: {e}')
35
        return None
36

37
def build_cache(url_id, target_uids, cookie):
38
    headers = {
39
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
40
        'Accept': 'application/json, text/plain, */*',
41
        'Accept-Language': 'zh-CN,zh;q=0.9',
42
        'Referer': f'https://www.luogu.com.cn/contest/{url_id}',
43
        'X-Requested-With': 'XMLHttpRequest',
44
    }
45

46
    data = fetch_page(url_id, 1, headers, cookie)
47
    if data is None:
48
        return
49

50
    scoreboard = data.get('scoreboard', {})
51
    per_page = scoreboard.get('perPage', 50)
52
    total_count = scoreboard.get('count', 0)
53
    total_pages = (total_count - 1) // per_page + 1
54

55
    remaining = set(target_uids)
56

57
    for i, row in enumerate(scoreboard.get('result', [])):
58
        uid = row['user']['uid']
59
        if uid in remaining:
60
            position_cache[uid] = (1, i)
61
            remaining.remove(uid)
62

63
    for page_num in range(2, total_pages + 1):
64
        if not remaining:
65
            break
66

67
        page_data = fetch_page(url_id, page_num, headers, cookie)
68
        if page_data is None:
69
            continue
70

71
        for i, row in enumerate(page_data.get('scoreboard', {}).get('result', [])):
72
            uid = row['user']['uid']
73
            if uid in remaining:
74
                position_cache[uid] = (page_num, i)
75
                remaining.remove(uid)
76

77
def fetch_by_cache(url_id, target_uids, cookie):
78
    headers = {
79
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
80
        'Accept': 'application/json, text/plain, */*',
81
        'Accept-Language': 'zh-CN,zh;q=0.9',
82
        'Referer': f'https://www.luogu.com.cn/contest/{url_id}',
83
        'X-Requested-With': 'XMLHttpRequest',
84
    }
85

86
    all_users = []
87
    pages_to_fetch = set()
88

89
    for uid in target_uids:
90
        if uid in position_cache:
91
            pages_to_fetch.add(position_cache[uid][0])
92

93
    page_data_cache = {}
94
    for page_num in pages_to_fetch:
95
        page_data_cache[page_num] = fetch_page(url_id, page_num, headers, cookie)
96

97
    for uid in target_uids:
98
        if uid not in position_cache:
99
            continue
100

101
        page_num, local_index = position_cache[uid]
102
        page_data = page_data_cache.get(page_num)
103

104
        if page_data is None:# Camellia
105
            continue
106

107
        rows = page_data.get('scoreboard', {}).get('result', [])
108
        if local_index >= len(rows):
109
            continue
110

111
        row = rows[local_index]
112
        if row['user']['uid'] == uid:
113
            # 处理每道题的分数
114
            problems = {}
115
            for pid, detail in row.get('details', {}).items():
116
                problems[pid] = {
117
                    'score': detail.get('score', 0),
118
                    'runningTime': detail.get('runningTime', 0)
119
                }
120

121
            all_users.append({
122
                'uid': row['user']['uid'],
123
                'name': row['user']['name'],
124
                'totalScore': row['score'],
125
                'runningTime': row['runningTime'],
126
                'problems': problems,
127
                'lastUpdate': datetime.now().strftime('%Y-%m-%d %H:%M:%S')
128
            })
129

130
    # all_users.sort(key=lambda x: (-x['totalScore'], x['runningTime']))
131

132
    return {
133
        'totalUsers': len(target_uids),
134
        'foundUsers': len(all_users),
135
        'updateTime': datetime.now().strftime('%Y-%m-%d %H:%M:%S'),
136
        'users': all_users
137
    }
138

139
def write_data(url_id, data):
140
    with open(f'BAKA.json', 'w', encoding='utf-8') as f:
141
        json.dump(data, f, ensure_ascii=False, indent=2)
142

143
if __name__ == "__main__":
144
    main()

原理很简单，首先先给排行榜全部遍历一遍找到要查的人，然后保存他们的页面和位置，然后创建BAKA.json给“查询总人数”，“最后修改json时间”，“各个用户的信息”塞进去

一开始是打算弄完之后给他们进行排序然后前端直接滚，然后后来发现，不如直接前端来弄来的实在

urlid直接在你要查询的比赛那里看就好了，就内个比赛编号
uids就直接放你要查的那些人的用户id cookies就去https://www.luogu.com.cn/fe/api/contest/scoreboard/比赛编号?page=1里面打开控制台找

然后运行就能给在代码同等目录之下创建BAKA.json,并且自动给数据塞进去

belike↓

1
{
2
  "totalUsers": 4,
3
  "foundUsers": 4,
4
  "updateTime": "2026-04-25 19:01:31",
5
  "users": [
6
    {
7
      "uid": 11451,
8
      "name": "椛",
9
      "totalScore": 300,
10
      "runningTime": 23496000,
11
      "problems": {
12
        "T671197": {
13
          "score": 100,
14
          "runningTime": 546000
15
        },
16
        "T695742": {
17
          "score": 100,
18
          "runningTime": 13445000
19
        },
20
        "T700904": {
21
          "score": 100,
22
          "runningTime": 9505000
23
        }
24
      },
25
      "lastUpdate": "2026-04-25 19:01:31"
26
    },
27
    {
28
      "uid": 12345,
29
      "name": "大椛",
30
      "totalScore": 200,
31
      "runningTime": 11908000,
32
      "problems": {
33
        "T671197": {
34
          "score": 100,
35
          "runningTime": 1733000
36
        },
37
        "T695742": {
38
          "score": 100,
39
          "runningTime": 10175000
40
        }
41
      },
42
      "lastUpdate": "2026-04-25 19:01:31"
43
    },
44
    {
45
      "uid": 4321,
46
      "name": "小椛",
47
      "totalScore": 155,
48
      "runningTime": 40490000,
49
      "problems": {
50
        "T671197": {
51
          "score": 100,
52
          "runningTime": 1507000
53
        },
54
        "T680242": {
55
          "score": 15,
56
          "runningTime": 13888000
57
        },
58
        "T695742": {
59
          "score": 30,
60
          "runningTime": 13262000
61
        },
62
        "T700904": {
63
          "score": 10,
64
          "runningTime": 11833000
65
        }
66
      },
67
      "lastUpdate": "2026-04-25 19:01:31"
68
    },
69
    {
70
      "uid": 2134,
71
      "name": "这还是椛",
72
      "totalScore": 120,
73
      "runningTime": 4109000,
74
      "problems": {
75
        "T671197": {
76
          "score": 100,
77
          "runningTime": 989000
78
        },
79
        "T695742": {
80
          "score": 20,
81
          "runningTime": 3120000
82
        }
83
      },
84
      "lastUpdate": "2026-04-25 19:01:31"
85
    }
86
  ]
87
}

前端展示和滚榜#

先上代码

1
<!DOCTYPE html>
2
<html lang="zh-CN">
3
<head>
4
    <meta charset="UTF-8">
5
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
6
    <title>BIG BAKA</title>
7
    <style>
8
        * {
9
            margin: 0;
10
            padding: 0;
11
            box-sizing: border-box;
12
        }
13

14
        body {
15
            background: #f5f5f5;
16
            color: #333;
17
            font-family: 'Microsoft YaHei', sans-serif;
18
            padding: 20px;
19
        }
20

21
        #userList {
22
            position: relative;
23
            height: 100vh;
24
        }
25

26
        .user-card {
27
            background: #fff;
28
            border-radius: 8px;
29
            padding: 15px;
30
            margin-bottom: 10px;
31
            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
32
            transition: all 0.5s ease;
33
            position: absolute;
34
            width: calc(100% - 40px);
35
            left: 20px;
36
        }
37

38
        .user-header {
39
            display: flex;
40
            justify-content: space-between;
41
            align-items: center;
42
            margin-bottom: 8px;
43
        }
44

45
        .user-name {
46
            font-size: 1.1em;
47
            font-weight: bold;
48
        }
49

50
        .user-score {
51
            color: #e94560;
52
            font-weight: bold;
53
        }
54

55
        .problems {
56
            display: flex;
57
            gap: 8px;
58
            flex-wrap: wrap;
59
        }
60

61
        .problem {
62
            background: #f0f0f0;
63
            padding: 4px 10px;
64
            border-radius: 4px;
65
            font-size: 0.9em;
66
        }
67

68
        .problem-score {
69
            color: #e94560;
70
            font-weight: bold;
71
        }
72
    </style>
73
</head>
74
<body>
75
    <div id="userList"></div>
76

77
    <script>
78
        let currentUsers = [];
79
        const cardHeight = 90;
80

81
        async function loadData() {
82
            try {
83
                const response = await fetch('BAKA.json');
84
                const data = await response.json();
85

86
                const sortedUsers = [...data.users].sort((a, b) => {
87
                    if (b.totalScore !== a.totalScore) {
88
                        return b.totalScore - a.totalScore;
89
                    }
90
                    return a.runningTime - b.runningTime;
91
                });
92

93
                updateDisplay(sortedUsers);
94

95
            } catch (error) {
96
                console.error('加载失败:', error);
97
            }
98
        }
99

100
        function updateDisplay(newUsers) {
101
            const container = document.getElementById('userList');
102

103
            if (currentUsers.length === 0) {
104
                container.innerHTML = '';
105
                newUsers.forEach((user, index) => {
106
                    const card = createCard(user, index);
107
                    container.appendChild(card);
108
                });
109
                currentUsers = newUsers;
110
                return;
111
            }
112

113
            newUsers.forEach((user, newIndex) => {
114
                let card = document.getElementById('card-' + user.uid);
115

116
                if (!card) {
117
                    card = createCard(user, newIndex);
118
                    container.appendChild(card);
119
                }
120

121
                card.style.top = (newIndex * cardHeight) + 'px';
122
                updateCardContent(card, user, newIndex);
123
            });
124

125
            currentUsers.forEach(user => {
126
                if (!newUsers.find(u => u.uid === user.uid)) {
127
                    const card = document.getElementById('card-' + user.uid);
128
                    if (card) card.remove();
129
                }
130
            });
131

132
            currentUsers = newUsers;
133
        }
134

135
        function createCard(user, index) {
136
            const div = document.createElement('div');
137
            div.id = 'card-' + user.uid;
138
            div.className = 'user-card';
139
            div.style.top = (index * cardHeight) + 'px';
140
            div.innerHTML = getCardHtml(user, index);
141
            return div;
142
        }
143

144
        function updateCardContent(card, user, index) {
145
            card.innerHTML = getCardHtml(user, index);
146
        }
147

148
        function getCardHtml(user, index) {
149
            re  turn `
150
                <div class="user-header">
151
                    <div>
152
                        <span class="user-name">#${index + 1} ${user.name}</span>
153
                    </div>
154
                    <div class="user-score">${user.totalScore} 分</div>
155
                </div>
156
                <div class="problems">
157
                    ${Object.entries(user.problems).map(([pid, p]) => `
158
                        <div class="problem">
159
                            ${pid}: <span class="problem-score">${p.score}</span>
160
                        </div>
161
                    `).join('')}
162
                </div>
163
            `;
164
        }
165

166
        loadData();
167
        setInterval(loadData, 5000);
168
    </script>
169
</body>
170
</html>