Expert Opinion on Ranheim vs Asane

The upcoming match between Ranheim and Asane on September 13, 2025, at 14:00 promises to be a thrilling encounter. Based on historical data and current team form, several betting predictions can be made. Ranheim has shown a tendency to score in the second half, while Asane has been consistent in maintaining a strong defense. This match is expected to have a moderate number of goals with a slight edge towards an attacking game.

zhangjiaqian/vscode-leetcode/src/leetcode/common/util.ts
import * as vscode from ‘vscode’;
import { leetcode } from ‘../extension’;
import { getLeetcode } from ‘./leetcode’;

export async function getWorkspaceDir(): Promise {
const workspaceFolder = vscode.workspace.workspaceFolders;
if (workspaceFolder) {
return workspaceFolder[0].uri.fsPath;
}
}

export async function getLeetcodeConfig(): Promise<Record> {
const workspaceDir = await getWorkspaceDir();
if (workspaceDir) {
const configPath = `${workspaceDir}/leetcode.json`;
if (fs.existsSync(configPath)) {
try {
return JSON.parse(fs.readFileSync(configPath));
} catch (e) {
vscode.window.showErrorMessage(`Invalid leetcode.json file: ${e}`);
}
}
}
return {};
}

export async function getCookie(): Promise {
const config = await getLeetcodeConfig();
return config.cookie;
}

export async function getCookieFromLeetcode(): Promise {
const leetcodeInstance = await getLeetcode();
if (!leetcodeInstance) return undefined;
return leetcodeInstance.cookie;
}

export function getProblemUrl(problemId: number): string {
return `https://leetcode.com/problems/${problemId}`;
}

export async function openProblem(problemId: number): Promise {
const url = getProblemUrl(problemId);
vscode.env.openExternal(vscode.Uri.parse(url));
}

export function getLocalFile(path: string): vscode.Uri {
return vscode.Uri.file(path);
}

export function getFileContent(uri: vscode.Uri): string | undefined {
try {
return fs.readFileSync(uri.fsPath).toString();
} catch (e) {
vscode.window.showErrorMessage(`Can’t read file ${uri.fsPath}: ${e}`);
}
}

export function saveFileContent(uri: vscode.Uri, content: string): void {
fs.writeFileSync(uri.fsPath, content);
}

const fs = require(‘fs’);
const path = require(‘path’);

export async function copyFile(from: vscode.Uri | string | Buffer | null | undefined, to: vscode.Uri | string): Promise;
export async function copyFile(from: vscode.Uri | string | Buffer | null | undefined, to: vscode.Uri | string, options?: { overwrite?: boolean }): Promise;
async function copyFile(from: any, to: any, options?: { overwrite?: boolean }): Promise {
if (!from || !to) return;
if (!options) options = {};
options.overwrite = options.overwrite || false;
if (typeof from === ‘string’) from = vscode.Uri.file(from);
if (typeof to === ‘string’) to = vscode.Uri.file(to);
if (!(from instanceof vscode.Uri)) return;
if (!(to instanceof vscode.Uri)) return;

let existsTo = false;
try {
existsTo = fs.statSync(to.fsPath).isFile();
} catch (e) {
existsTo = false;
}
if (existsTo && !options.overwrite) return;

if (from.scheme === ‘file’) {
let data;
try {
data = fs.readFileSync(from.fsPath);
} catch (e) {
vscode.window.showErrorMessage(`Can’t read file ${from.fsPath}: ${e}`);
return;
}
fs.mkdirSync(path.dirname(to.fsPath), { recursive: true });
fs.writeFileSync(to.fsPath, data);
} else if (from.scheme === ‘untitled’) {
let data;
try {
data = await from.with({ scheme: ‘file’ }).read();
} catch (e) {
vscode.window.showErrorMessage(`Can’t read file ${from.toString()}: ${e}`);
return;
}
fs.mkdirSync(path.dirname(to.fsPath), { recursive: true });
fs.writeFileSync(to.fsPath, data);
} else if (from instanceof Buffer) {
fs.mkdirSync(path.dirname(to.fsPath), { recursive: true });
fs.writeFileSync(to.fsPath, from);
}
}
zhangjiaqian/vscode-leetcode/src/leetcode/common/leetcode.ts
import * as vscode from ‘vscode’;
import axios from ‘axios’;
import * as cheerio from ‘cheerio’;
import * as _ from ‘lodash’;
import * as path from ‘path’;

import { ProblemInfo } from ‘../extension’;
import { UserStatus } from ‘./user’;

const COOKIE_KEY_NAME = ‘__cfduid’;
const LEETCODE_COOKIE_KEY_NAME = ‘LEETCODE_SESSION’;
const LOGIN_URL = ‘https://leetcode.com/accounts/login/’;
const USER_URL = ‘https://leetcode.com/accounts/user/’;
const PROBLEM_URL_PREFIX = ‘https://leetcode.com/problems/’;
const STATUS_URL_PREFIX = ‘https://leetcode.com/api/submissions/status/’;

let leetcodeInstance: LeetcodeClient;

export async function getLeetcode(): Promise;
export async function getLeetcode(overwriteCookie?: boolean): Promise;
async function getLeetcode(overwriteCookie?: boolean): Promise {

const cookieKeyNames =
[COOKIE_KEY_NAME,
LEETCODE_COOKIE_KEY_NAME];

if (!overwriteCookie && leetcodeInstance && leetcodeInstance.cookie && cookieKeyNames.every(key => leetcodeInstance.cookie.includes(key))) return leetcodeInstance;

let cookieStr = ”;
for (const keyName of cookieKeyNames) {
const cookiesStrArry =
Object.entries(
document.cookie.split(‘;’).map(x => x.trim())
).filter(x => x[0].startsWith(keyName));
if (!cookiesStrArry.length) continue;

for (const [cookieKey] of cookiesStrArry) {
const cookieVal =
decodeURIComponent(cookiesStrArry[0][1]);
if (!cookieStr.length)
cookieStr += `${cookieKey}=${cookieVal};`;
else
cookieStr += `;${cookieKey}=${cookieVal};`;
}
break;
}

if (!cookieStr.length) return;

const axiosInstance =
axios.create({
baseURL:
LOGIN_URL,
headers:
{ Cookie:
cookieStr }
});

try {

const res =
await axiosInstance.get(USER_URL);

if (
res.data &&
res.data.username
) {

const $ =
cheerio.load(
res.data
);

const userStatusHtmlElm =
$(‘#user_status’);

const userStatusElmArry =
userStatusHtmlElm &&
userStatusHtmlElm.children();

const userStatusElm =
userStatusElmArry &&
userStatusElmArry[0];

const userStatusJsonStr =
userStatusElm &&
$(userStatusElm).attr(‘data-user-status’);

let userStatusObj:
UserStatus =
null;

if (
typeof userStatusJsonStr === ‘string’
) {

try {

userStatusObj =
JSON.parse(
userStatusJsonStr
);

} catch (_err) {

console.log(
`Failed to parse User Status JSON Str`
);

}

}

const leetCodeClient =
new LeetcodeClient(
userStatusObj,
res.headers[‘set-cookie’],
res.headers[‘x-csrftoken’]
);

return leetCodeClient;

}

return;

} catch (_err) {

console.log(
`Error when trying to create LeetCode Client`
);

return;

}

}

class LeetcodeClient {

private readonly _statusCache: Map;

constructor(private readonly _userStatus?: UserStatus,
private readonly _cookie?: string[],
private readonly _csrfToken?: string) {

this._statusCache =
new Map();

this._refreshUserStatus();

setInterval(
() => this._refreshUserStatus(),
ms(’15min’)
);

setInterval(
() => this._refreshProblemCache(),
ms(‘3min’)
);

setInterval(
() => this._updateProblemCache(),
ms(‘1min’)
);

setInterval(
() => this._updateSubmissionCache(),
ms(’30sec’)
);

setInterval(
() => this._updateAcceptanceRateCache(),
ms(‘3min’)
);

setInterval(
() => this._updateDifficultyCache(),
ms(‘3min’)
);

setInterval(
() => this._updateAcceptedCodeCache(),
ms(‘3min’)
);

setInterval(
() => this._updateTagsCache(),
ms(‘3min’)
);

setInterval(
() => this._updateQuestionMetaCache(),
ms(‘3min’)
);

setInterval(
() => this._updateSolutionsCache(),
ms(‘3min’)
);

setInterval(
() => this._updateSolutionTitlesCache(),
ms(‘3min’)
);

this._statusCache.set(-1,
new ProblemInfo({
id:
-1,
title:
”,
status:
”,
lang:
”,
runtime:
”,
timeCost:
”,
memoryCost:
”
}));

this._statusCache.set(-100,
new ProblemInfo({
id:
-100,
title:
”,
status:
”,
lang:
”,
runtime:
”,
timeCost:
”,
memoryCost:
”
}));

this._statusCache.set(-101,
new ProblemInfo({
id:
-101,
title:
”,
status:
”,
lang:
”,
runtime:
”,
timeCost:
”,
memoryCost:
”
}));

}

get cookie(): string[] {

return [
…this._cookie
];

}

public async getStatus(problemIdList?: number[]): Promise<Map> {

problemIdList =
problemIdList &&
Array.isArray(problemIdList)
? problemIdList
: [];

if (
!problemIdList.length
) {

return new Map(this._statusCache);

}

let statusMap =
new Map(this._statusCache);

for (
let i = problemIdList.length -1 ;
i >=0 ;
i —
) {

let problemId =
problemIdList[i];

if (
!problemId ||
!Number.isInteger(problemId)
) continue;

let problemInfo =
statusMap.get(problemId);

if (
!problemInfo ||
problemInfo.id !== problemId ||
problemInfo.status !== ”
) {

const [problemInfo] =
await this.fetchProblemInfo(problemId);

statusMap.set(problemId,
problemInfo);

}

}

return statusMap;

}

private async fetchProblemInfo(problemId: number): Promise {

if (
!problemId ||
!Number.isInteger(problemId)
) {

return [null,
null];

}

const url =
`${STATUS_URL_PREFIX}${problemId}`;

try {

const res =
await axios.get(url,
{ headers:
{ Cookie:
[…this.cookie],
‘X-CSRFToken’:
this.csrfToken
}
});

if (
res.status !==
axios.codes.ok
) {

console.log(
`Failed to fetch Status for Problem ID ${problemId}`
);

return [problemId,
null];

}

const $ =
cheerio.load(res.data);

let problemInfo:

ProblemInfo |
null |
undefined =

null;

let statusElm =

$(‘#status’);

if (
statusElm &&
statusElm.length >0
) {

const $statusHtmlElmArry =

$(statusElm).children();

if (
$statusHtmlElmArry &&
$statusHtmlElmArry.length >0
) {

const $statusHtmlElm =

$($statusHtmlElmArry[0]);

if (
$statusHtmlElm &&
$statusHtmlElm.attr(‘data-submission-id’)
) {

problemInfo =

new ProblemInfo({
id:
Number.parseInt($statusHtmlElm.attr(‘data-problem-id’)),
title:
$statusHtmlElm.attr(‘data-problem-title’),
status:
$statusHtmlElm.attr(‘data-submission-state’),
lang:

$statusHtmlElm.attr(‘data-submission-language’),
runtime:

$statusHtmlElm.attr(‘data-runtime’),
timeCost:

$statusHtmlElm.attr(‘data-time-cost’),
memoryCost:

$statusHtmlElm.attr(‘data-memory-cost’)

});

} else {

console.log(
`Failed to parse Status HTML Element for Problem ID ${problemId}`
);

problemInfo =

null;

}

} else {

console.log(
`No Children Elements found for Status HTML Element for Problem ID ${problemId}`
);

problemInfo =

null;

}

} else {

console.log(
`No Status HTML Element found for Problem ID ${problemId}`
);

problemInfo =

null;

}

return [problemId,
problemInfo];

} catch (_err) {

console.log(
`Error when fetching Status for Problem ID ${problemId}`
);

return [problemId,
null];

}

}

get csrfToken(): string | undefined {

return [
…this._csrfToken
]?.[0]?.split(‘=’)[1];

}

private async _refreshUserStatus(): Promise {

try {

const res =
await axios.get(USER_URL,
{ headers :
{ Cookie :
[…this.cookie],
‘X-CSRFToken’ :
this.csrfToken }});

if (
res.data &&
res.data.username
) {

const $ =