Skip to content

Commit 0d57474

Browse files
author
liguanliang1
committed
chore: core
1 parent 3500614 commit 0d57474

9 files changed

+1188
-17
lines changed

‎DOM/darkmode.js

+4
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,10 @@ const hack = () => {
99
fontSize: '16px',
1010
};
1111
Array.from(document.querySelectorAll('*')).forEach((item) => {
12+
const ignoreElmReg = /p-4|button|input|textarea/gi;
13+
if (ignoreElmReg.test(item.tagName) || ignoreElmReg.test(item.className)) {
14+
return;
15+
}
1216
Object.entries(customStyle).forEach(([key, value]) => {
1317
item.style[key] = value;
1418
});

‎leetcode/newwater.js

Whitespace-only changes.

‎leetcode/ts_interview.js

+391
Large diffs are not rendered by default.

‎leetcode/ts_interview.ts

+354
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,354 @@
1+
// // 注意: 题目有四道, 请认真仔细读题,
2+
// // 如果有不理解的地方, 请联系 HR 或面试官,
3+
// // 如果有不会的, 请留空, 不要求做完, 不要盲目答题.
4+
// // 注意: 可以使用任意版本的 ECMAScript 提供的标准 API, 不允许使用历史遗留的非标准或被弃用的 API.
5+
6+
// declare const require: any;
7+
8+
// /**
9+
// * Q1: 对象浅拷贝, 需要保留原型链
10+
// *
11+
// * @param src 需要被拷贝的对象, 不需要考虑内部类, 如 Date, Array, Map 等
12+
// * @return {T} 返回拷贝结果
13+
// */
14+
function shallowCopy<T>(src: T): T {
15+
// 首先通过Object.create()方法创建一个新对象，并将原对象的原型链复制到新对象上
16+
let newObj = Object.create(Object.getPrototypeOf(src));
17+
18+
// 然后使用Object.assign()方法将原对象的属性和方法浅拷贝到新对象上
19+
return Object.assign(newObj, src);
20+
}
21+
22+
// /**
23+
// * Q2: 加权随机函数生成器
24+
// *
25+
// * 给定一个正整数数组 input, 返回一个随机函数,
26+
// * 该函数被调用时, 随机返回一个该数组的下标, 下标 i 被返回的概率为该下标对应的元素的值 / 所有元素之和.
27+
// *
28+
// * 要求: 返回的随机函数的时间复杂度不超过 O(log(N))
29+
// */
30+
function createWeightedRandom(input: number[]): () => number {
31+
const n: number = input.length;
32+
const sum = input.reduce((acc, cur) => acc + cur, 0);
33+
const prob = input.map(val => val / sum);
34+
35+
const alias: number[] = new Array(n);
36+
const probScaled: number[] = new Array(n);
37+
const small: number[] = [];
38+
const large: number[] = [];
39+
40+
for (let i = 0; i < n; i++) {
41+
probScaled[i] = prob[i] * n;
42+
if (probScaled[i] < 1) {
43+
small.push(i);
44+
} else {
45+
large.push(i);
46+
}
47+
}
48+
49+
while (small.length && large.length) {
50+
const s: number = small.pop() || 0;
51+
const l: number = large.pop() || 0;
52+
53+
alias[s] = l;
54+
probScaled[l] -= 1 - probScaled[s];
55+
56+
if (probScaled[l] < 1) {
57+
small.push(l);
58+
} else {
59+
large.push(l);
60+
}
61+
}
62+
63+
while (large.length) {
64+
const l: number = large.pop() || 0;
65+
probScaled[l] = 1;
66+
}
67+
68+
while (small.length) {
69+
const s = small.pop() || 0;
70+
probScaled[s] = 1;
71+
}
72+
73+
return function () {
74+
const i = Math.floor(Math.random() * n);
75+
return Math.random() < probScaled[i] ? i : alias[i];
76+
};
77+
}
78+
79+
/**
80+
* Q3: Function Currying
81+
*
82+
* In mathematics and computer science, currying is the technique of converting a function
83+
* that takes multiple arguments into a sequence of functions that each takes a single argument.
84+
* For example, currying transform can make f(a,b,c) callable as f(a)(b)(c).
85+
*
86+
* Here, we define a curry function which takes multi arguments,
87+
* the first argument is the function(fn) that needs to be called finally,
88+
* the rest arguments are curried already.
89+
*
90+
* If the number of all curried arguments is equal to or more than the number of the arguments of the original fn,
91+
* the called result should be returned, otherwise it will
92+
* return a new function which accept the rest arguments just like the demo.
93+
*
94+
* Please refer to the test cases to determine the return value type and parameter list.
95+
*/
96+
function curry(fn, ...args) {
97+
const arity = fn.length;
98+
const curried = (...newArgs) => {
99+
const allArgs = args.concat(newArgs);
100+
if (allArgs.length >= arity) {
101+
return fn(...allArgs);
102+
} else {
103+
return curry(fn, ...allArgs);
104+
}
105+
};
106+
return curried;
107+
};
108+
109+
/**
110+
* Q4: 异步并发控制器
111+
*
112+
* 该函数返回一个执行函数(executor), 该执行函数接收一个异步任务函数(task),
113+
* executor 被调用时, 会根据 capacity 来执行 task: 如果正在执行的异步任务数不超过 capacity,
114+
* 则立即执行, 否则会等到任意一个正在执行的 task 结束后再执行. 并返回值为 task 的返回值的 Promise.
115+
*/
116+
117+
type Queue = () => Promise<void>
118+
119+
function asyncConcurrenceController(capacity) {
120+
let runningCount = 0;
121+
const queue: Queue[] = [];
122+
123+
async function executor(task) {
124+
if (runningCount < capacity) {
125+
runningCount++;
126+
try {
127+
const result = await task();
128+
runningCount--;
129+
if (queue.length > 0) {
130+
const nextTask = queue.shift();
131+
executor(nextTask);
132+
}
133+
return result;
134+
} catch (error) {
135+
runningCount--;
136+
throw error;
137+
}
138+
} else {
139+
return new Promise((resolve, reject) => {
140+
queue.push(async () => {
141+
try {
142+
const result = await task();
143+
resolve(result);
144+
} catch (error) {
145+
reject(error);
146+
}
147+
});
148+
});
149+
}
150+
}
151+
152+
return executor;
153+
}
154+
155+
// 定义一个异步任务函数，它会在一定的时间后返回一个随机数
156+
async function generateRandomNum() {
157+
const delay = Math.floor(Math.random() * 3000);
158+
await new Promise(resolve => setTimeout(resolve, delay));
159+
const randomNum = Math.floor(Math.random() * 100);
160+
console.log(`Generated random num: ${randomNum} (delay ${delay} ms)`);
161+
return randomNum;
162+
}
163+
164+
// 创建一个并发控制器，限制最多同时执行 2 个任务
165+
const control = asyncConcurrenceController(2);
166+
167+
// 依次执行 6 个异步任务，观察输出顺序
168+
control(generateRandomNum)
169+
.then(result => console.log(result));
170+
control(generateRandomNum)
171+
.then(result => console.log(result));
172+
control(generateRandomNum)
173+
.then(result => console.log(result));
174+
control(generateRandomNum)
175+
.then(result => console.log(result));
176+
control(generateRandomNum)
177+
.then(result => console.log(result));
178+
control(generateRandomNum)
179+
.then(result => console.log(result));
180+
181+
182+
function testCreateWeightedRandom(createWeightedRandomImpl: typeof createWeightedRandom) {
183+
const assert = require("assert");
184+
185+
const input: number[] = [4, 5, 2, 3, 2];
186+
// ts-error
187+
const counts: number[] = Array(input.length).fill(0);
188+
189+
const random = createWeightedRandomImpl(input);
190+
191+
assert.strictEqual(typeof random, "function");
192+
for (let i = 0; i < 10000; i++) {
193+
const v = random();
194+
assert.ok(typeof v === "number" && v < input.length && v > -1 && (v | 0) === v, `invalid random value: ${JSON.stringify(v)}`);
195+
counts[v]++;
196+
}
197+
const sum = input.reduce((v, c) => v + c, 0);
198+
for (let i = 0; i < input.length; i++) {
199+
const expected = input[i] / sum;
200+
const real = counts[i] / 10000;
201+
// 误差不超过 0.01
202+
assert.ok(Math.abs(expected - real) < 0.01, `invalid weight ${real} for ${i}, expected is ${expected}`);
203+
}
204+
}
205+
// Generated random num: 9(delay 1012 ms)
206+
// Generated random num: 43(delay 1276 ms)
207+
// Generated random num: 73(delay 2101 ms)
208+
// 9
209+
// 43
210+
// Generated random num: 40(delay 1247 ms)
211+
// Generated random num: 82(delay 2205 ms)
212+
// 73
213+
// 40
214+
// Generated random num: 26(delay 2123 ms)
215+
// 82
216+
// 26
217+
218+
// /* ----------------- 以下是测试用例 -----------------*/
219+
220+
// function testShallowCopy(shallowCopyImpl: typeof shallowCopy) {
221+
// const assert = require('assert');
222+
223+
// class UserModel {
224+
// constructor(public firstName, public lastName) {
225+
// assert.strictEqual(typeof firstName, 'string');
226+
// assert.strictEqual(typeof lastName, 'string');
227+
// }
228+
229+
// public fullName() {
230+
// return this.firstName + ' ' + this.lastName;
231+
// }
232+
// }
233+
234+
// const src = new UserModel('Tony', 'Jaa');
235+
// const dst = shallowCopyImpl(src);
236+
237+
// assert.deepStrictEqual(dst, src);
238+
// assert.notStrictEqual(dst, src);
239+
// assert.strictEqual(dst.fullName(), src.fullName());
240+
// }
241+
242+
// function testCreateWeightedRandom(createWeightedRandomImpl: typeof createWeightedRandom) {
243+
// const assert = require('assert');
244+
245+
// const input: number[] = [4, 5, 2, 3, 2];
246+
// const counts = Array(input.length).fill(0);
247+
248+
// const random = createWeightedRandomImpl(input);
249+
250+
// assert.strictEqual(typeof random, 'function');
251+
// for (let i = 0; i < 10000; i++) {
252+
// const v = random();
253+
// assert.ok(
254+
// typeof v === 'number' && v < input.length && v > -1 && (v | 0) === v,
255+
// `invalid random value: ${JSON.stringify(v)}`,
256+
// );
257+
// counts[v]++;
258+
// }
259+
// const sum = input.reduce((v, c) => v + c, 0);
260+
// for (let i = 0; i < input.length; i++) {
261+
// const expected = input[i] / sum;
262+
// const real = counts[i] / 10000;
263+
// // 误差不超过 0.01
264+
// assert.ok(Math.abs(expected - real) < 0.01, `invalid weight ${real} for ${i}, expected is ${expected}`);
265+
// }
266+
// }
267+
268+
// function testCurry(curryImpl: typeof curry) {
269+
// const assert = require('assert');
270+
271+
// function makeArray5(a, b, c, d, e) {
272+
// return [a, b, c, d, e];
273+
// }
274+
275+
// let curriedMakeArray5 = curryImpl(makeArray5, 1, 2, 3, 4, 5);
276+
// assert.deepStrictEqual(curriedMakeArray5, [1, 2, 3, 4, 5]);
277+
278+
// curriedMakeArray5 = curryImpl(makeArray5, 1);
279+
280+
// assert.deepStrictEqual(curriedMakeArray5(2, 3, 4, 5), [1, 2, 3, 4, 5]);
281+
// assert.deepStrictEqual(curriedMakeArray5(2)(3, 4, 5), [1, 2, 3, 4, 5]);
282+
// assert.deepStrictEqual(curriedMakeArray5(2)(3)(4, 5), [1, 2, 3, 4, 5]);
283+
// assert.deepStrictEqual(curriedMakeArray5(2)(3)(4)(5), [1, 2, 3, 4, 5]);
284+
// }
285+
286+
// function testCreateAsyncWorker(createParallelTaskExecutorImpl: typeof createAsyncWorker) {
287+
// const assert = require('assert');
288+
289+
// const executor = createParallelTaskExecutorImpl(2);
290+
291+
// const runTask = (id: number, delay: number, expectedDelay: number, fail: boolean) => {
292+
// const start = Date.now();
293+
// const check = (rejected: boolean) => (v: number) => {
294+
// assert.strictEqual(rejected, fail, `promise status of task ${id} should be ${fail}, received ${rejected}`);
295+
// const realDelay = Date.now() - start;
296+
// assert.strictEqual(
297+
// Math.round(realDelay / 100) * 100,
298+
// expectedDelay,
299+
// `delay of task ${id} should be ${expectedDelay}, received ${realDelay}`,
300+
// );
301+
// assert.strictEqual(
302+
// v,
303+
// delay,
304+
// `${rejected ? 'error of rejected' : 'result of resolved'} task ${id} should be ${delay}, received ${v}`,
305+
// );
306+
// };
307+
// executor(
308+
// () =>
309+
// new Promise<number>((resolve, reject) => {
310+
// setTimeout(() => {
311+
// if (fail) {
312+
// reject(delay);
313+
// } else {
314+
// resolve(delay);
315+
// }
316+
// }, delay);
317+
// }),
318+
// )
319+
// .then(check(false), check(true))
320+
// .catch((e) => {
321+
// console.error(e);
322+
// });
323+
// };
324+
325+
// runTask(1, 100, 100, false);
326+
// runTask(2, 200, 200, true);
327+
// runTask(3, 300, 400, false);
328+
// runTask(4, 400, 600, true);
329+
// runTask(5, 100, 500, false);
330+
// runTask(6, 200, 700, true);
331+
// runTask(7, 100, 700, false);
332+
// runTask(8, 200, 900, false);
333+
// }
334+
335+
// try {
336+
// testShallowCopy(shallowCopy);
337+
// } catch (error) {
338+
// console.error(error);
339+
// }
340+
// try {
341+
// testCreateWeightedRandom(createWeightedRandom);
342+
// } catch (error) {
343+
// console.error(error);
344+
// }
345+
// try {
346+
// testCurry(curry);
347+
// } catch (error) {
348+
// console.error(error);
349+
// }
350+
// try {
351+
// testCreateAsyncWorker(createAsyncWorker);
352+
// } catch (error) {
353+
// console.error(error);
354+
// }

0 commit comments

Comments
 (0)