cswork / OA打开练习工作台

OA 选择题 · 即时判分

OA 里的选择题，先在这里练。

621 道原创 OA 风格选择题，覆盖 CS 基础（数据结构与算法、操作系统、数据库、网络、并发、面向对象、Linux 命令行、Git、计算机体系结构、Web 安全、设计模式、Web 前端、机器学习）、读代码（时间复杂度、Python、JavaScript、Java、C++、SQL、NumPy）和数学统计（概率、逻辑推理、统计）。读代码题里问输出的（复杂度题和标为未定义行为的除外），答案都是实际运行得出的。提交后立即判分并给出解析；答过的题按 1、3、7、21 天的间隔回来复习。CPU 调度、页面置换、TCP 和拥塞控制的计算题，可以用操作系统与网络模拟器逐步核对。

题型
知识点
复习
621 道题
  1. 同一进程内的多个线程共享下列哪一项？
  2. 发生缺页（page fault）的直接原因是？
  3. 下列哪种调度算法可能让长作业一直得不到执行（饥饿）？
  4. 下列哪一项不是死锁的必要条件？
  5. 系统出现“抖动”（thrashing）时，最典型的现象是？
  6. 程序连续调用 3 次 fork()（都不检查返回值），最后一共有多少个进程（含原进程）？
  7. 同一进程内的线程切换通常比进程切换开销小，主要原因是？
  8. 分页（paging）内存管理消除了哪一种碎片？
  9. 有 3 个页框、初始为空，访问序列 1 2 3 4 1 2 5 1 2 3 4 5，用 LRU 置换一共发生多少次缺页？
  10. Belady 异常（增加页框反而缺页更多）会出现在哪种置换算法中？
  11. 下列哪个操作一定需要系统调用（进入内核态）？
  12. “僵尸进程”指的是？
  13. TLB 缓存的是什么？
  14. 32 位虚拟地址、页大小 4 KB，页内偏移占多少位？
  15. 时间片轮转（RR）调度中，如果时间片设得非常大，它会退化成？
  16. fork 使用写时复制（copy-on-write）的效果是？
  17. DMA（直接内存访问）的主要好处是？
  18. 在“多对一”用户级线程模型里，一个线程发起阻塞式系统调用，会怎样？
  19. 深度递归最常见的崩溃原因是？
  20. 父进程先于子进程退出后，子进程会怎样？
  21. ACID 中的 I 代表什么？
  22. 哪个隔离级别能防止脏读，但仍允许不可重复读？
  23. 按 SQL 标准，哪个隔离级别才能保证不出现幻读？
  24. 第二范式（2NF）要消除的是？
  25. 表 Employee(emp_id, dept_id, dept_name)，主键 emp_id，dept_id 决定 dept_name。它违反了哪个范式？
  26. 关于主键（PRIMARY KEY）和唯一约束（UNIQUE），哪些说法正确？（多选）
  27. 数据库更常用 B+ 树而不是哈希做通用索引，主要因为？
  28. 关于聚簇索引，哪项说法正确？
  29. A 表有 5 行。SELECT * FROM A LEFT JOIN B ON ... 至少返回多少行？
  30. 列 x 的值为 1、NULL、2、NULL。COUNT(*) 和 COUNT(x) 分别是？
  31. 要筛出“订单数超过 10 的客户”，条件应该写在哪里？
  32. 标准 SQL 中，哪个子句可以引用 SELECT 列表里定义的别名？
  33. SELECT * FROM t WHERE x = NULL 会返回什么？
  34. 两阶段锁协议（2PL）保证了什么？
  35. 预写日志（WAL）的核心规则是？
  36. 外键（FOREIGN KEY）约束的作用是？
  37. 关于给表加索引，哪项说法是错误的？
  38. UNION 和 UNION ALL 的区别是？
  39. 在 (a, b) 上建了复合 B+ 树索引。哪些查询条件能高效利用它？（多选）
  40. 按 CAP 定理，发生网络分区时，分布式系统只能在哪两者之间取舍？
  41. 乐观并发控制通常怎样发现冲突？
  42. 防止 SQL 注入最可靠的做法是？
  43. 下列哪种应用最常直接使用 UDP？
  44. TCP 三次握手的报文顺序是？
  45. IP 协议属于 TCP/IP 模型的哪一层？
  46. 服务器暂时过载、希望客户端稍后重试，最合适的 HTTP 状态码是？
  47. ARP 协议的作用是？
  48. 一个 /24 子网最多有多少个可分配给主机的地址？
  49. 一个 /26 子网最多有多少个可用主机地址？
  50. TCP 连接关闭后进入 TIME_WAIT 状态的是哪一方？
  51. HTTPS 默认使用哪个端口？
  52. 交换机和路由器分别主要工作在哪一层？
  53. TCP 的流量控制（flow control）主要防止什么？
  54. TCP 慢启动阶段，拥塞窗口 cwnd 大致怎样增长？
  55. TLS（HTTPS）提供了哪些保障？（多选）
  56. 按 HTTP 规范，下列哪些方法是幂等的？（多选）
  57. 下列哪些是私有（内网）IPv4 地址？（多选）
  58. 在 100 Mbps 的链路上发送 1 MB（10^6 字节）的数据，传输时延（不计传播时延）约为？
  59. HTTP/2 相比 HTTP/1.1 的主要改进是？
  60. ping 命令使用的是哪个协议？
  61. NAT（网络地址转换）主要解决什么问题？
  62. WebSocket 连接是怎样建立的？
  63. DHCP 的主要作用是？
  64. 两个线程各执行 1000 次 count++（count 初值 0，没有任何同步）。最终 count 的值？
  65. 线程 A 持有锁 L1 等待 L2，线程 B 持有 L2 等待 L1。最简单可靠的修复是？
  66. 初值为 3 的计数信号量保护一段代码，最多有几个线程能同时在里面？
  67. 使用条件变量时，wait() 为什么要放在 while 循环里检查条件？
  68. “活锁”（livelock）指的是？
  69. Java 中把计数器声明为 volatile int count，再在多个线程里执行 count++，结果会怎样？
  70. 读写锁（read-write lock）允许的情形是？
  71. 基于 CAS（compare-and-swap）的无锁栈可能遇到什么经典问题？
  72. 自旋锁（spinlock）在什么情况下比阻塞式互斥锁更合适？
  73. 在默认（带 GIL）的 CPython 中，想用多核加速 CPU 密集型计算，通常应该？
  74. 可重入锁（reentrant lock）的特点是？
  75. 一个线程对同一把不可重入的互斥锁连续调用两次 lock()，会发生什么？
  76. 用信号量实现有界缓冲区的生产者-消费者，通常需要哪几个信号量？
  77. 哲学家就餐问题中，哪种做法可以避免死锁？
  78. 程序 90% 的部分可以完美并行。按 Amdahl 定律，用 4 个核最多加速约多少倍？
  79. 单线程事件循环（如 Node.js、asyncio）提供的是？
  80. 优先级反转是指？
  81. Java 中双重检查锁定（double-checked locking）的单例，实例字段为什么要声明为 volatile？
  82. 屏障（barrier）同步的作用是？
  83. 使用线程池而不是每个任务新建线程，主要好处有哪些？（多选）
  84. Java 中 Thread.sleep() 和 Object.wait() 的关键区别是？
  85. “数据竞争”（data race）的准确定义是？
  86. 方法重写（override）和方法重载（overload）分别对应哪种多态？
  87. Java 中关于抽象类和接口，哪些说法正确？（多选）
  88. 里氏替换原则（LSP）要求什么？
  89. SOLID 中的 O（开闭原则）是指？
  90. 依赖倒置原则（DIP）建议？
  91. “组合优于继承”的主要理由是？
  92. Java 中子类定义了与父类同签名的 static 方法，会发生什么？
  93. 实现单例模式时，最关键的一步是？
  94. 观察者模式（Observer）适合哪种场景？
  95. Java 不支持类的多继承，主要是为了避免什么问题？
  96. 策略模式（Strategy）的作用是？
  97. Java 中重写 equals 时为什么必须同时重写 hashCode？
  98. 装饰器模式（Decorator）的特点是？
  99. Java 中 protected 成员可以被谁访问？
  100. 封装（encapsulation）最主要的目的是？
  101. 工厂方法模式（Factory Method）解决的问题是？
  102. 下面的 Python 代码输出什么？
    def add(x, items=[]):
    items.append(x)
    return items

add(1)
add(2)
print(add(3))
  103. 下面的 Python 代码输出什么？
    fs = [lambda: i for i in range(3)]
print([f() for f in fs])
  104. 下面的 Python 代码输出什么？
    print(-7 // 2, -7 % 2)
  105. 下面的 Python 代码输出什么？
    a = [[0] * 2] * 2
a[0][0] = 1
print(a)
  106. 下面的 Python 代码输出什么？
    a = [1, 2]
b = a[:]
print(a == b, a is b)
  107. 下面的 Python 代码输出什么？
    s = "abcdef"
print(s[::-2])
  108. 下面的 Python 代码输出什么？
    d = {"a": 1, "b": 2}
d["a"] = 3
d["c"] = 4
print(list(d))
  109. 下面的 Python 代码输出什么？
    g = (x * x for x in range(4))
print(sum(g), sum(g))
  110. 下面的 Python 代码输出什么？
    t = ([1],)
try:
    t[0] += [2]
except TypeError:
    pass
print(t)
  111. 下面的 Python 代码输出什么？
    class A:
    items = []

    def add(self, x):
        self.items.append(x)

a, b = A(), A()
a.add(1)
b.add(2)
print(a.items)
  112. 下面的 Python 代码输出什么？
    def make():
    n = 0
    def inc():
        nonlocal n
        n += 1
        return n
    return inc

f = make()
f()
f()
print(f())
  113. 下面的 Python 代码输出什么？
    words = ["bb", "a", "ccc", "dd"]
print(sorted(words, key=len))
  114. 下面的 Python 代码输出什么？
    print(list(zip([1, 2, 3], "ab")))
  115. 下面的 Python 代码输出什么？
    print(True + True * 3)
  116. 下面的 Python 代码输出什么？
    print(1 < 3 > 2, 1 < 2 < 1)
  117. 下面的 Python 代码输出什么？
    def f():
    try:
        return "try"
    finally:
        print("finally", end=" ")

print(f())
  118. 下面的 Python 代码输出什么？
    a = {1, 2, 3}
b = {2, 3, 4}
print(sorted(a ^ b))
  119. 下面的 Python 代码输出什么？
    print("-".join("ab" * 2))
  120. 下面的 Python 代码输出什么？
    x = 10

def f():
    print(x)
    x = 5

try:
    f()
except UnboundLocalError:
    print("error")
  121. 下面的 Python 代码输出什么？
    print([x for x in range(10) if x % 3 == 0][-1])
  122. 下面的 Python 代码输出什么？
    d = {}
d.setdefault("k", []).append(1)
d.setdefault("k", []).append(2)
print(d)
  123. 下面的 Python 代码输出什么？
    import copy

a = [[1], [2]]
b = copy.copy(a)
b[0].append(9)
b.append([3])
print(len(a), a[0])
  124. 下面的 Python 代码输出什么？
    print(round(2.5), round(3.5))
  125. 下面的 Python 代码输出什么？
    print(0.1 + 0.2 == 0.3)
  126. 下面的 Python 代码输出什么？
    for i, c in enumerate("xyz", 1):
    pass
print(i, c)
  127. 下面的 Python 代码输出什么？
    def f(a, *rest, b=0):
    return a + sum(rest) + b

print(f(1, 2, 3, b=4))
  128. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(typeof null, typeof NaN);
  129. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
for (var i = 0; i < 3; i++) out.push(() => i);
console.log(out.map((f) => f()).join(" "));
  130. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(0 == "", 0 === "", null == undefined);
  131. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log([10, 9, 1, 2].sort().join(","));
  132. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const log = [];
log.push("A");
setTimeout(() => {
  log.push("B");
  console.log(log.join(" "));
}, 0);
Promise.resolve().then(() => log.push("C"));
log.push("D");
  133. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(typeof f, typeof g);
function f() {}
var g = function () {};
  134. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const obj = {
  name: "box",
  plain() {
    return [1].map(function () {
      return this?.name;
    })[0];
  },
  arrow() {
    return [1].map(() => this.name)[0];
  },
};
console.log(obj.plain(), obj.arrow());
  135. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    function counter() {
  let n = 0;
  return () => ++n;
}
const a = counter();
const b = counter();
a();
a();
console.log(a(), b());
  136. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log("5" + 3, "5" - 3, "5" * "2");
  137. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const arr = [1, 2, 3];
arr[5] = 6;
console.log(arr.length, arr.filter(() => true).length);
  138. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const o = { b: 1, 2: "x", a: 2, 1: "y" };
console.log(Object.keys(o).join(","));
  139. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const log = [];
async function f() {
  log.push(1);
  await null;
  log.push(3);
}
f();
log.push(2);
setTimeout(() => console.log(log.join(" ")), 0);
  140. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(["1", "2", "3"].map(parseInt).join(","));
  141. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const { a = 1, b = 2 } = { a: undefined, b: null };
console.log(a, b);
  142. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(NaN === NaN, Object.is(NaN, NaN), [NaN].includes(NaN), [NaN].indexOf(NaN));
  143. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
out.push(1);
setTimeout(() => out.push(2), 0);
Promise.resolve()
  .then(() => out.push(3))
  .then(() => out.push(4));
queueMicrotask(() => out.push(5));
out.push(6);
setTimeout(() => console.log(out.join(" ")), 10);
  144. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
async function a() {
  out.push("a1");
  await b();
  out.push("a2");
}
async function b() {
  out.push("b");
}
a();
Promise.resolve().then(() => out.push("p"));
out.push("s");
setTimeout(() => console.log(out.join(" ")), 0);
  145. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
new Promise((resolve) => {
  out.push(1);
  resolve();
  out.push(2);
}).then(() => out.push(3));
out.push(4);
setTimeout(() => console.log(out.join(" ")), 0);
  146. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
setTimeout(() => {
  out.push("t1");
  Promise.resolve().then(() => out.push("m"));
}, 0);
setTimeout(() => out.push("t2"), 0);
setTimeout(() => console.log(out.join(" ")), 5);
  147. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
[1, 2, 3].forEach(async (n) => {
  await null;
  out.push(n);
});
out.push("done");
setTimeout(() => console.log(out.join(" ")), 0);
  148. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    Promise.resolve(1)
  .then((x) => {
    throw new Error("x" + x);
  })
  .then(() => console.log("skipped"))
  .catch((e) => e.message)
  .then((v) => console.log(v, "after"));
  149. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    var x = 1;
function f() {
  console.log(x);
  var x = 2;
}
f();
  150. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    let x = 1;
function f() {
  try {
    console.log(x);
  } catch (e) {
    console.log(e.name);
  }
  let x = 2;
}
f();
  151. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [typeof notDeclared];
try {
  out.push(typeof later);
} catch (e) {
  out.push(e.name);
}
let later = 1;
console.log(out.join(" "));
  152. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const before = typeof foo;
var foo = 1;
function foo() {}
console.log(before, typeof foo);
  153. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    try {
  new Dog();
} catch (e) {
  console.log(e.name);
}
class Dog {}
  154. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const fs = [];
for (let i = 0; i < 3; i++) fs.push(() => i);
let j = 0;
const gs = [];
for (; j < 3; j++) gs.push(() => j);
console.log(fs.map((f) => f()).join(""), gs.map((g) => g()).join(""));
  155. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    let msg = "hi";
const say = () => msg;
msg = "bye";
console.log(say());
  156. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
for (var i = 0; i < 3; i++) {
  ((j) => setTimeout(() => out.push(j), 0))(i);
}
setTimeout(() => console.log(out.join(","), i), 0);
  157. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    function once(fn) {
  let done = false;
  let result;
  return (...args) => {
    if (!done) {
      done = true;
      result = fn(...args);
    }
    return result;
  };
}
const init = once((x) => x * 2);
console.log(init(5), init(10));
  158. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
class Counter {
  constructor() {
    this.n = 0;
  }
  inc() {
    return ++this.n;
  }
}
const c = new Counter();
const inc = c.inc;
try {
  inc();
} catch (e) {
  out.push(e.name);
}
out.push(c.inc());
console.log(out.join(" "));
  159. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    function who() {
  return this.name;
}
const a = { name: "a", who };
const b = { name: "b" };
const bound = who.bind(b);
a.bound = bound;
console.log(a.who(), bound(), a.bound(), bound.call(a));
  160. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    function Person(name) {
  this.name = name;
}
const p = new Person("Ann");
const q = Person.call({}, "Bo");
console.log(p.name, q);
  161. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const out = [];
const timer = {
  label: "T",
  start() {
    setTimeout(function () {
      out.push(this === timer);
    }, 0);
    setTimeout(() => out.push(this.label), 0);
  },
};
timer.start();
setTimeout(() => console.log(out.join(" ")), 5);
  162. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    const ctx = { id: 1 };
const fn = function () {
  return this;
};
const arrow = () => this;
console.log(fn.call(ctx) === ctx, arrow.call(ctx) === ctx);
  163. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(JSON.stringify([] + []), [] + {}, [1, 2] + [3]);
  164. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log([] == false, [0] == false, "0" == false, null == false);
  165. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(Number(""), Number(" 12 "), Number("1e3"), parseInt("12px"), Number("12px"));
  166. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(Boolean("0"), Boolean(""), !!NaN, !![], !!{});
  167. 下面的 JavaScript 代码（Node.js 运行）输出什么？
    console.log(true + 1, null + 1, undefined + 1, "3" * "4", [2] * [3]);
  168. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        String a = "hi";
        String b = new String("hi");
        System.out.println((a == b) + " " + a.equals(b));
    }
}
  169. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        Integer x = 127, y = 127, p = 128, q = 128;
        System.out.println((x == y) + " " + (p == q));
    }
}
  170. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        System.out.println(('a' + 1) + " " + (char) ('a' + 1));
    }
}
  171. 下面的 Java 程序输出什么？
    public class Main {
    static void f(Object o) { System.out.println("Object"); }
    static void f(String s) { System.out.println("String"); }

    public static void main(String[] args) {
        f(null);
    }
}
  172. 下面的 Java 程序输出什么？
    class A {
    String name = "A";
    String who() { return "A"; }
}

class B extends A {
    String name = "B";
    String who() { return "B"; }
}

public class Main {
    public static void main(String[] args) {
        A obj = new B();
        System.out.println(obj.name + " " + obj.who());
    }
}
  173. 下面的 Java 程序输出什么？
    public class Main {
    static void change(int[] arr, int n) {
        arr[0] = 9;
        n = 9;
        arr = new int[] {7};
    }

    public static void main(String[] args) {
        int[] a = {1};
        int n = 1;
        change(a, n);
        System.out.println(a[0] + " " + n);
    }
}
  174. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        int big = Integer.MAX_VALUE;
        System.out.println(big + 1);
    }
}
  175. 下面的 Java 程序输出什么？
    public class Main {
    static int f() {
        try {
            return 1;
        } finally {
            return 2;
        }
    }

    public static void main(String[] args) {
        System.out.println(f());
    }
}
  176. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        String s = "abc";
        s.toUpperCase();
        System.out.println(s + " " + s.concat("d"));
    }
}
  177. 下面的 Java 程序输出什么？
    class C {
    static int count = 0;
    C() { count++; }
}

public class Main {
    public static void main(String[] args) {
        new C();
        new C();
        C c = new C();
        System.out.println(C.count);
    }
}
  178. 下面的 Java 程序输出什么？
    import java.util.HashSet;
import java.util.Set;

class P {
    int x;
    P(int x) { this.x = x; }
}

public class Main {
    public static void main(String[] args) {
        Set<P> s = new HashSet<>();
        s.add(new P(1));
        s.add(new P(1));
        System.out.println(s.size());
    }
}
  179. 下面的 Java 程序输出什么？
    public class Main {
    public static void main(String[] args) {
        Object o = true ? 1 : 2.0;
        System.out.println(o);
    }
}
  180. 掷两颗均匀的骰子，点数之和为 7 的概率是？
  181. 掷两颗均匀的骰子，至少有一个 6 的概率是？
  182. 均匀硬币抛 3 次，恰好 2 次正面的概率是？
  183. 从一副 52 张的标准扑克牌中不放回地抽 2 张，两张都是 A 的概率是？
  184. 抛均匀硬币直到第一次出现正面，期望要抛几次？
  185. 至少要多少人，才能让“有两人生日相同”的概率超过 50%（一年按 365 天、生日均匀分布）？
  186. 某病患病率 1%。检测对患者 99% 呈阳性，对健康人 5% 呈阳性（假阳性）。一个人检测阳性，他真正患病的概率约为？
  187. 三门问题：你选了一扇门，主持人（知道答案）打开另一扇空门。此时换门，赢的概率是？
  188. 掷一颗均匀骰子直到出现 6，期望要掷几次？
  189. 掷一颗均匀骰子，期望掷多少次才能让六个面都至少出现一次？
  190. 一个家庭有两个孩子，已知至少有一个是男孩，两个都是男孩的概率是？（每个孩子独立、男女各半）
  191. 把 1 到 n 随机排列，期望有多少个数恰好在自己的位置上（不动点）？
  192. 袋中有 3 个红球、5 个蓝球，不放回地取 2 个，两个都是红球的概率是？
  193. 掷两颗均匀骰子，点数之和的期望是？
  194. P(A) = 0.5，P(B) = 0.4，P(A∩B) = 0.2，则 P(A∪B) = ？
  195. 均匀硬币抛 10 次，正面次数的方差是？
  196. 掷两颗均匀骰子，较大点数的期望约是？
  197. 在一根木棍上均匀随机地选两个点把它折成三段，三段能拼成三角形的概率是？
  198. 公平赌博：你有 1 元，每局各以 1/2 概率赢或输 1 元，赢到 3 元或输光就停。赢到 3 元的概率是？
  199. 从 1 到 10 中随机选两个不同的数，它们的和为偶数的概率是？
  200. 单词 LEVEL 的字母有多少种不同的排列？
  201. 抛均匀硬币，期望抛多少次才第一次出现“连续两次正面”？
  202. 独立事件 A、B 满足 P(A) = 0.3，P(B) = 0.5，A 和 B 都不发生的概率是？
  203. 均匀硬币抛 4 次，正面次数多于反面次数的概率是？
  204. 数列 2, 6, 12, 20, 30, ? 的下一项是？
  205. 3:15 时，时针和分针之间的夹角是多少度？
  206. “所有 bloop 都是 razzie，所有 razzie 都是 lazzie。”由此可以确定？
  207. “如果下雨，地面就会湿。”与之逻辑等价的是？
  208. 岛上的人要么是永远说真话的骑士，要么是永远说假话的无赖。A 说：“我们两个都是无赖。”A 和 B 分别是？
  209. 12 个球里有 1 个比其他的重，用天平最少称几次一定能找出它？
  210. 甲单独完成一项工作要 6 小时，乙要 3 小时。两人一起做需要多久？
  211. 两列火车相距 300 km 相向而行，速度分别为 60 km/h 和 90 km/h，多久相遇？
  212. 球拍和球一共 1.10 美元，球拍比球贵 1 美元。球多少钱？
  213. 湖里的睡莲每天面积翻倍，第 48 天正好盖满整个湖。哪一天盖满一半？
  214. 5 台机器 5 分钟生产 5 个零件。100 台机器生产 100 个零件需要多久？
  215. NOT (A AND B) 等价于？
  216. 抽屉里有 10 只黑袜和 10 只白袜，摸黑拿，最少拿几只能保证有一双同色？
  217. 10 个人两两握手一次，一共握多少次手？
  218. 下列数中哪一个与其他的不同类？2, 3, 5, 9, 11
  219. 父亲现在的年龄是儿子的 4 倍，20 年后是儿子的 2 倍。儿子现在几岁？
  220. 100! 的末尾有多少个 0？
  221. 8×8 的国际象棋棋盘上，一共有多少个大小不同的正方形？
  222. 今天是星期三，100 天后是星期几？
  223. 数列 1, 4, 9, 16, 25, ? 的下一项是？
  224. 一个班 30 人，21 人会 Python，17 人会 Java，每人至少会一种。两种都会的有几人？
  225. 在长度为 n 的动态数组（如 Python list）下标 0 处插入一个元素，时间复杂度是？
  226. 动态数组满了以后按倍数扩容（比如容量翻倍），而不是每次固定多开 100 个位置，主要是为了什么？
  227. 用链地址法的哈希表里有 n 个键、m 个桶，负载因子 α = n/m。假设哈希函数把键均匀打散，一次查找失败（键不存在）的期望代价是？
  228. 关于哈希表，下面哪些说法正确？（多选）
  229. 在 Python 里拼一个很长的字符串，为什么推荐先把片段放进列表再 "".join(parts)，而不是循环里 s += part？
  230. 只含小写字母的两个长度为 n 的字符串，用一个大小为 26 的计数数组判断它们是否互为字母异位词。时间和额外空间分别是？
  231. 找两数之和等于 target 的对撞双指针（和太小就左指针右移，太大就右指针左移），在什么前提下才正确？
  232. 求「和不超过 K 的最长子数组」时，常用的滑动窗口是：右端每次扩一格，和超过 K 就收缩左端。这个做法依赖什么条件？
  233. 前缀和数组 P 定义为 P[0] = 0，P[i] = a[0] + … + a[i-1]。闭区间 a[l..r] 的和等于？
  234. 合并一组可能重叠的区间，标准做法和时间复杂度是？
  235. 对长度为 n 的数组做 q 次「给 a[l..r] 全部加 v」的操作，最后只读一次整个数组。用差分数组，总时间是？
  236. lo, hi = 0, len(a)；while lo < hi：mid = (lo + hi) // 2；若 a[mid] < x 则 lo = mid + 1，否则 hi = mid。对有序数组 a，循环结束时 lo 是什么？
  237. 「二分答案」（在答案的取值范围上二分，每次用 check(mid) 判断可行）需要满足什么条件？
  238. 在 Java 或 C++ 里，为什么常写 mid = lo + (hi - lo) / 2，而不是 mid = (lo + hi) / 2？
  239. 用「自底向上」的方法（从最后一个非叶子节点开始依次下沉）把 n 个无序元素建成二叉堆，时间复杂度是？
  240. 要在数据流里始终保留最大的 k 个数，用堆的标准做法是？
  241. 下列场景里，哪一个最适合用单调栈？
  242. 从一组区间中选出最多个互不重叠的区间，正确的贪心策略是每次选？
  243. 硬币面值是 {1, 3, 4}，要凑出 6。「每次拿不超过剩余金额的最大硬币」的贪心用几枚？最少需要几枚？
  244. Floyd 判圈算法（慢指针一次一步，快指针一次两步）中，两个指针在环里相遇后，怎样找到环的入口？
  245. 一个同时保存 head 和 tail 指针的单链表，下面哪个操作不是 O(1)？
  246. 链表题里常在头节点前加一个哑节点（dummy），它主要解决什么问题？
  247. 在 n 个节点、高度为 h 的二叉树上做递归 DFS，额外空间（调用栈）是？
  248. 满二叉树（每个节点要么有 0 个、要么有 2 个孩子）如果有 n 个内部节点，它有几个叶子？
  249. 要自底向上算出每棵子树的高度，需要先处理完左右子树再处理当前节点。这对应哪种 DFS 顺序？
  250. 「二叉树中任意两点间的最大路径和」：递归函数返回给父节点的值应该是什么？（L、R 是左右孩子返回的值）
  251. 统计二叉树里和为 target 的向下路径数，常用做法是 DFS 时用哈希表记录根到当前节点路径上各前缀和出现的次数。为什么回溯（离开节点）时要把当前前缀和的计数减 1？
  252. 节点值互不相同时，下面哪些遍历组合能唯一确定一棵二叉树？（多选）
  253. 由前序和中序重建二叉树时，先建一个「值 → 中序下标」的哈希表，带来的改变是？
  254. 验证二叉搜索树时，只检查每个节点满足「左孩子 < 当前节点 < 右孩子」为什么不够？
  255. 把 1, 2, …, n 按顺序插入一棵不做平衡的普通二叉搜索树，树高（边数）是多少？
  256. 从 BST 中删除一个有两个孩子的节点，标准做法是？
  257. 在无权网格上求从起点到终点的最少步数，哪种搜索直接给出答案？
  258. BFS 为什么通常在把格子加入队列时就标记为已访问，而不是出队时才标记？
  259. R×C 网格里有 k 个源点，要求每个格子到最近源点的距离。高效的做法是？
  260. 并查集同时使用路径压缩和按秩（或按大小）合并后，每次操作的均摊时间是？
  261. 用并查集判断无向图有没有环：依次处理每条边 (u, v)，什么时候说明出现了环？
  262. n 个顶点、处理完 m 条边后，并查集中成功合并（两端原本不在同一集合）的次数为 s。连通分量有几个？
  263. 用 Kahn 算法（反复取出入度为 0 的点）做拓扑排序，结束时输出的顶点数少于 n，说明什么？
  264. 基于 DFS 的拓扑排序，结果是哪个顺序？
  265. 有向图有负权边但没有负权环，求单源最短路，应该用哪个算法？
  266. 边权只有 0 和 1 的图上做「0-1 BFS」，用双端队列时边的处理规则是？
  267. Kruskal 算法按权值从小到大考虑每条边，什么情况下跳过这条边？
  268. 一个有 V 个顶点的连通无向带权图，下面哪些说法正确？（多选）
  269. 用回溯生成 n 个不同元素的所有子集，每个子集都复制成一个列表输出。总时间是？
  270. 生成 [1, 1, 2] 的不重复全排列，常用规则是：先排序，在同一层里遇到 nums[i] == nums[i-1] 且 nums[i-1] 没有被使用时跳过 nums[i]。这条规则保证了什么？
  271. 回溯生成 n 对括号的所有合法组合时，什么条件下可以追加一个右括号「)」？
  272. 3 对括号能组成多少个合法（配对正确）的括号串？
  273. N 皇后问题中，位于 (r1, c1) 和 (r2, c2) 的两个皇后恰好在同一条斜线上，当且仅当？
  274. 组合总和问题里，候选数都是正数并且已经升序排序。当 candidates[i] 大于剩余目标值时，为什么可以直接 break，而不只是跳过这一个？
  275. 哪两条性质让一个问题适合用动态规划？
  276. 关于记忆化搜索（自顶向下）和递推（自底向上），哪些说法正确？（多选）
  277. 在 3×3 的格子里，从左上角的格子走到右下角的格子，每步只能向右或向下，一共有多少条路径？
  278. 网格 DP 压缩成一维数组时，按 j 从左到右执行 dp[j] = dp[j] + dp[j-1]。赋值之前，dp[j] 和 dp[j-1] 分别代表什么？
  279. 0/1 背包压成一维时写作 for w in range(W, wt - 1, -1): dp[w] = max(dp[w], dp[w - wt] + val)。为什么容量要从大到小遍历？
  280. 0/1 背包的 O(n·W) 动态规划通常被称为「伪多项式时间」，原因是？
  281. 硬币 coins = [1, 2]，金额 3。执行 ways = [1, 0, 0, 0]；for c in coins: for a in range(c, 4): ways[a] += ways[a - c]。ways[3] 是多少？
  282. 最长递增子序列的 O(n log n) 解法维护一个数组 tails。tails[k] 表示什么？
  283. 数组 [8, 3, 6, 1, 7, 4, 9, 2] 的最长严格递增子序列长度是？
  284. 把 "abc" 变成 "yabd" 的编辑距离（插入、删除、替换各算一步）是？
  285. 求两个长度为 m、n 的字符串的最长公共子序列长度，二维 DP 需要 O(m·n) 空间。只要长度、不要具体子序列时，空间最少能压到多少？
  286. 用「中心扩展」找回文子串，长度为 n 的字符串一共要从多少个中心向两边扩展？
  287. 区间 DP 求最长回文子序列：dp[i][j] 依赖 dp[i+1][j-1]、dp[i+1][j] 和 dp[i][j-1]。下面哪种填表顺序是对的？
  288. 打家劫舍的环形版本（首尾两间房相邻，不能同时偷）通常怎么做？
  289. 股票买卖含一天冷冻期，用三个状态：hold（持有）、sold（今天刚卖出）、rest（不持有且不在冷冻期）。今天买入应该从昨天的哪个状态转移过来？
  290. 股价依次是 [6, 2, 9, 1, 4, 8]，可以买卖任意多次，但手里最多持有一股（卖出后才能再买）。最大利润是？
  291. 「最多交易 k 次」的股票问题，n 天价格。当 k ≥ n / 2 时可以怎么处理？
  292. 带权区间调度（选互不重叠的区间使权值和最大）：区间按结束时间排序后，dp[i] = max(dp[i-1], w[i] + dp[p(i)])。p(i) 是什么，整体复杂度是多少？
  293. 给一组会议时间段，最少需要几间会议室？下面哪个说法正确？
  294. 两人轮流从数组两端取数，都按最优策略。区间 DP 写作 dp[i][j] = max(a[i] - dp[i+1][j], a[j] - dp[i][j-1])。dp[i][j] 表示什么？
  295. 「矩阵中的最长递增路径」用带记忆化的 DFS 求解，为什么不需要 visited 数组防止走回头路？
  296. 实现一个支持 push、pop、top 和 O(1) getMin 的栈，常见做法是？
  297. Python 里做 BFS 的队列，为什么用 collections.deque 而不是 list 加 pop(0)？
  298. 要让 LRU 缓存的 get 和 put 都是 O(1)，标准结构是？
  299. LRU 缓存里的链表为什么要用双向链表，单向的不行吗？
  300. 字典树（Trie）里已经存了 N 个单词，查找一个长度为 L 的单词是否存在，时间是？
  301. 为什么把二叉树序列化成「带空节点标记（如 #）的前序遍历」就足以还原，而普通的前序遍历不行？
  302. 对正整数 x，x & (x - 1) == 0 成立意味着什么？
  303. [7, 3, 5, 3, 7] 中所有数的按位异或结果是？
  304. 在补码表示下，x & -x 的结果是什么？以 x = 12 为例。
  305. 「能否跳到最后一个下标」（a[i] 是从 i 出发最多能跳的步数）：贪心从左到右扫描，记录目前能到达的最远下标 far。什么时候可以判定跳不到？
  306. 回溯枚举字符串 s（长度 n）的所有回文划分时，先预处理一张表 pal[i][j]（s[i..j] 是否为回文），带来的改变是？
  307. 在网格里用回溯找单词时，为什么要在递归前把当前格子标记为「使用中」，返回后再恢复？
  308. 把 n 个互不相同的有序数建成一棵高度平衡的 BST（递归时传下标区间，不切片）。每个子区间选谁当根，总时间是多少？
  309. 二叉树的直径（任意两节点间最长路径的边数）一定经过根节点吗？
  310. 带手续费的股票买卖：每天写 hold = max(hold, cash - p)；cash = max(cash, hold + p - fee)，第二行用到的是刚更新过的 hold。为什么这样原地更新不会出错？
  311. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def reverse_copy(a):
    out = []
    for x in a:
        out.insert(0, x)
    return out
  312. 下面代码的时间复杂度是？（取最紧的界）
    def build(n):
    a = []
    for i in range(n):
        a.append(i)
    return a
  313. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def normalize(a):
    return [x / max(a) for x in a]
  314. 下面代码在最坏情况下的时间复杂度是？（n = len(a)）
    def count_repeats(a):
    seen = []
    repeats = 0
    for x in a:
        if x in seen:
            repeats += 1
        else:
            seen.append(x)
    return repeats
  315. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def has_pair(a, target):
    seen = set()
    for x in a:
        if target - x in seen:
            return True
        seen.add(x)
    return False
  316. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def most_common(a):
    best = None
    for x in a:
        if best is None or a.count(x) > a.count(best):
            best = x
    return best
  317. words 有 n 个词，vocab 是一个有 m 个键的 dict。时间复杂度是？
    def count_known(words, vocab):
    known = 0
    for w in words:
        if w in list(vocab):
            known += 1
    return known
  318. 下面代码在 s 是回文时的时间复杂度是？（n = len(s)）
    def is_pal(s):
    if len(s) <= 1:
        return True
    return s[0] == s[-1] and is_pal(s[1:-1])
  319. 下面 Java 方法的时间复杂度是？
    static String repeatX(int n) {
    String s = "";
    for (int i = 0; i < n; i++) {
        s += "x";
    }
    return s;
}
  320. a 里都是非负整数，k ≥ 0。下面代码的时间复杂度是？（n = len(a)）
    def longest(a, k):
    best = lo = total = 0
    for hi in range(len(a)):
        total += a[hi]
        while total > k:
            total -= a[lo]
            lo += 1
        best = max(best, hi - lo + 1)
    return best
  321. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def count_pairs(a, t):
    a.sort()
    i, j, count = 0, len(a) - 1, 0
    while i < j:
        if a[i] + a[j] <= t:
            count += j - i
            i += 1
        else:
            j -= 1
    return count
  322. a 长度为 n，queries 有 q 个 (l, r) 区间。时间复杂度是？
    def range_sums(a, queries):
    p = [0]
    for x in a:
        p.append(p[-1] + x)
    return [p[r + 1] - p[l] for l, r in queries]
  323. a 长度为 n，queries 有 q 个 (l, r) 区间。最坏情况下的时间复杂度是？
    def range_sums(a, queries):
    return [sum(a[l:r + 1]) for l, r in queries]
  324. 初始 hi - lo = n，每次调用 ok 需要 O(m)。时间复杂度是？
    def first_true(lo, hi, ok):
    while lo < hi:
        mid = (lo + hi) // 2
        if ok(mid):
            hi = mid
        else:
            lo = mid + 1
    return lo
  325. a 是有序列表。最坏情况下的时间复杂度是？（n = len(a)）
    def contains(a, x):
    if not a:
        return False
    mid = len(a) // 2
    if a[mid] == x:
        return True
    if a[mid] < x:
        return contains(a[mid + 1:], x)
    return contains(a[:mid], x)
  326. 下面代码在最坏情况下的时间复杂度是？（n = len(a)）
    from bisect import insort

def sorted_stream(a):
    out = []
    for x in a:
        insort(out, x)
    return out
  327. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def next_greater(a):
    res = [-1] * len(a)
    stack = []
    for i, x in enumerate(a):
        while stack and a[stack[-1]] < x:
            res[stack.pop()] = x
        stack.append(i)
    return res
  328. 下面代码在最坏情况下的时间复杂度是？（n = len(a)）
    import heapq

def build(a):
    h = []
    for x in a:
        heapq.heappush(h, x)
    return h
  329. 1 ≤ k ≤ n。时间复杂度是？（n = len(a)）
    import heapq

def top_k(a, k):
    h = []
    for x in a:
        heapq.heappush(h, x)
        if len(h) > k:
            heapq.heappop(h)
    return sorted(h, reverse=True)
  330. tasks 有 n 个元素。时间复杂度是？
    def drain(tasks):
    q = list(tasks)
    done = 0
    while q:
        q.pop(0)
        done += 1
    return done
  331. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def running_medians(a):
    out = []
    for i in range(1, len(a) + 1):
        s = sorted(a[:i])
        out.append(s[(i - 1) // 2])
    return out
  332. 链表有 n 个节点。suffix_lengths 的时间复杂度是？
    def length(node):
    n = 0
    while node:
        n += 1
        node = node.next
    return n

def suffix_lengths(head):
    out = []
    while head:
        out.append(length(head))
        head = head.next
    return out
  333. 树有 n 个节点、高度为 h。时间和额外空间分别是？
    def height(node):
    if not node:
        return 0
    return 1 + max(height(node.left), height(node.right))
  334. 在有 n 个节点的完全平衡二叉树上调用 balanced(root)，时间复杂度是？
    def height(node):
    if not node:
        return 0
    return 1 + max(height(node.left), height(node.right))

def balanced(node):
    if not node:
        return True
    if abs(height(node.left) - height(node.right)) > 1:
        return False
    return balanced(node.left) and balanced(node.right)
  335. 这是一棵不做平衡的普通二叉搜索树。循环部分的总时间是？
    def insert(node, key):
    if not node:
        return Node(key)
    if key < node.key:
        node.left = insert(node.left, key)
    else:
        node.right = insert(node.right, key)
    return node

root = None
for k in range(n):
    root = insert(root, k)
  336. 在 n 个节点、高度为 h 的 BST 上把 next() 调用 n 次走完整个中序。每次 next() 的代价是？
    class InorderIter:
    def __init__(self, root):
        self.stack = []
        self._push_left(root)

    def _push_left(self, node):
        while node:
            self.stack.append(node)
            node = node.left

    def next(self):
        node = self.stack.pop()
        self._push_left(node.right)
        return node.key
  337. 网格是 R 行 C 列。时间复杂度是？
    from collections import deque

def steps(grid, start):
    R, C = len(grid), len(grid[0])
    dist = {start: 0}
    q = deque([start])
    while q:
        r, c = q.popleft()
        for nr, nc in ((r + 1, c), (r - 1, c), (r, c + 1), (r, c - 1)):
            if 0 <= nr < R and 0 <= nc < C and grid[nr][nc] == '.' and (nr, nc) not in dist:
                dist[(nr, nc)] = dist[(r, c)] + 1
                q.append((nr, nc))
    return dist
  338. n 个元素上做 m 次 find 或 union（m ≥ n），总时间是？
    def find(p, x):
    while p[x] != x:
        p[x] = p[p[x]]
        x = p[x]
    return x

def union(p, size, a, b):
    a, b = find(p, a), find(p, b)
    if a == b:
        return False
    if size[a] < size[b]:
        a, b = b, a
    p[b] = a
    size[a] += size[b]
    return True
  339. n 个元素上做 m 次 find 或 union，最坏情况下总时间是？
    def find(p, x):
    while p[x] != x:
        x = p[x]
    return x

def union(p, a, b):
    p[find(p, a)] = find(p, b)
  340. 图有 V = n 个顶点、E 条边，用 n×n 邻接矩阵表示。时间复杂度是？
    def components(n, matrix):
    seen = [False] * n

    def dfs(u):
        seen[u] = True
        for v in range(n):
            if matrix[u][v] and not seen[v]:
                dfs(v)

    count = 0
    for u in range(n):
        if not seen[u]:
            count += 1
            dfs(u)
    return count
  341. V = n 个顶点，E = len(edges) 条边。时间复杂度是？
    from collections import deque

def topo(n, edges):
    adj = [[] for _ in range(n)]
    indeg = [0] * n
    for u, v in edges:
        adj[u].append(v)
        indeg[v] += 1
    q = deque(i for i in range(n) if indeg[i] == 0)
    order = []
    while q:
        u = q.popleft()
        order.append(u)
        for v in adj[u]:
            indeg[v] -= 1
            if indeg[v] == 0:
                q.append(v)
    return order
  342. 图有 V 个顶点、E 条边，边权非负。时间复杂度是？
    import heapq

def dijkstra(adj, s):
    dist = {s: 0}
    pq = [(0, s)]
    while pq:
        d, u = heapq.heappop(pq)
        if d > dist[u]:
            continue
        for v, w in adj[u]:
            if d + w < dist.get(v, float('inf')):
                dist[v] = d + w
                heapq.heappush(pq, (d + w, v))
    return dist
  343. V = n 个顶点，E = len(edges) 条边。时间复杂度是？
    def bellman_ford(n, edges, s):
    dist = [float('inf')] * n
    dist[s] = 0
    for _ in range(n - 1):
        for u, v, w in edges:
            if dist[u] + w < dist[v]:
                dist[v] = dist[u] + w
    return dist
  344. d 是 V×V 的距离矩阵。时间复杂度是？
    def all_pairs(d):
    n = len(d)
    for k in range(n):
        for i in range(n):
            for j in range(n):
                if d[i][k] + d[k][j] < d[i][j]:
                    d[i][j] = d[i][k] + d[k][j]
    return d
  345. V = n 个顶点，E = len(edges) 条边，图连通。时间复杂度是？
    def kruskal(n, edges):
    p = list(range(n))

    def find(x):
        while p[x] != x:
            p[x] = p[p[x]]
            x = p[x]
        return x

    total = 0
    for w, u, v in sorted(edges):
        ru, rv = find(u), find(v)
        if ru != rv:
            p[ru] = rv
            total += w
    return total
  346. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def subsets(a):
    out = []

    def go(i, cur):
        if i == len(a):
            out.append(cur[:])
            return
        go(i + 1, cur)
        cur.append(a[i])
        go(i + 1, cur)
        cur.pop()

    go(0, [])
    return out
  347. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def perms(a):
    out = []
    used = [False] * len(a)

    def go(cur):
        if len(cur) == len(a):
            out.append(cur[:])
            return
        for i in range(len(a)):
            if not used[i]:
                used[i] = True
                cur.append(a[i])
                go(cur)
                cur.pop()
                used[i] = False

    go([])
    return out
  348. 下面代码的时间复杂度是？
    def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)
  349. 第一次调用 fib(n) 的时间复杂度是？（把整数加法看作 O(1)）
    from functools import lru_cache

@lru_cache(maxsize=None)
def fib(n):
    if n < 2:
        return n
    return fib(n - 1) + fib(n - 2)
  350. 网格 g 是 m 行 n 列。时间和额外空间分别是？
    def min_path(g):
    m, n = len(g), len(g[0])
    dp = [float('inf')] * n
    dp[0] = 0
    for i in range(m):
        for j in range(n):
            left = dp[j - 1] if j else float('inf')
            dp[j] = g[i][j] + min(dp[j], left)
    return dp[-1]
  351. items 有 n 件物品，容量是 W。时间复杂度是？
    def knapsack(items, W):
    dp = [0] * (W + 1)
    for wt, val in items:
        for w in range(W, wt - 1, -1):
            dp[w] = max(dp[w], dp[w - wt] + val)
    return dp[W]
  352. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    from bisect import bisect_left

def lis(a):
    tails = []
    for x in a:
        i = bisect_left(tails, x)
        if i == len(tails):
            tails.append(x)
        else:
            tails[i] = x
    return len(tails)
  353. m = len(a)，n = len(b)。时间和额外空间分别是？
    def lcs(a, b):
    m, n = len(a), len(b)
    dp = [[0] * (n + 1) for _ in range(m + 1)]
    for i in range(m):
        for j in range(n):
            if a[i] == b[j]:
                dp[i + 1][j + 1] = dp[i][j] + 1
            else:
                dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])
    return dp[m][n]
  354. n = len(s)，把整数加法看作 O(1)。时间复杂度是？
    from functools import lru_cache

def count_decodings(s):
    @lru_cache(maxsize=None)
    def go(t):
        if not t:
            return 1
        ways = go(t[1:]) if t[0] != '0' else 0
        if len(t) >= 2 and '10' <= t[:2] <= '26':
            ways += go(t[2:])
        return ways

    return go(s)
  355. n = len(s)。最坏情况下的时间和额外空间分别是？
    def count_pal(s):
    n, total = len(s), 0
    for c in range(2 * n - 1):
        lo, hi = c // 2, c // 2 + c % 2
        while lo >= 0 and hi < n and s[lo] == s[hi]:
            total += 1
            lo -= 1
            hi += 1
    return total
  356. n = len(s)。时间复杂度是？
    def count_pal(s):
    n = len(s)
    return sum(s[i:j] == s[i:j][::-1]
               for i in range(n) for j in range(i + 1, n + 1))
  357. n = len(prices)，最多交易 k 次。时间和额外空间分别是？
    def max_profit(k, prices):
    buy = [float('-inf')] * (k + 1)
    sell = [0] * (k + 1)
    for p in prices:
        for t in range(1, k + 1):
            buy[t] = max(buy[t], sell[t - 1] - p)
            sell[t] = max(sell[t], buy[t] + p)
    return sell[k]
  358. jobs 是 n 个 (开始, 结束, 权值)。时间复杂度是？
    from bisect import bisect_right

def best(jobs):
    jobs.sort(key=lambda j: j[1])
    ends = [e for _, e, _ in jobs]
    dp = [0] * (len(jobs) + 1)
    for i, (s, e, w) in enumerate(jobs):
        k = bisect_right(ends, s, 0, i)
        dp[i + 1] = max(dp[i], dp[k] + w)
    return dp[-1]
  359. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    from functools import lru_cache

def first_player_margin(a):
    @lru_cache(maxsize=None)
    def go(i, j):
        if i > j:
            return 0
        return max(a[i] - go(i + 1, j), a[j] - go(i, j - 1))

    return go(0, len(a) - 1)
  360. 在空队列上执行任意 n 次 push 和 pop，每次操作的代价是？
    class Queue:
    def __init__(self):
        self.inbox, self.outbox = [], []

    def push(self, x):
        self.inbox.append(x)

    def pop(self):
        if not self.outbox:
            while self.inbox:
                self.outbox.append(self.inbox.pop())
        return self.outbox.pop()
  361. get 和 put 每次的时间复杂度是？
    from collections import OrderedDict

class LRU:
    def __init__(self, cap):
        self.cap, self.d = cap, OrderedDict()

    def get(self, key):
        if key not in self.d:
            return -1
        self.d.move_to_end(key)
        return self.d[key]

    def put(self, key, value):
        self.d[key] = value
        self.d.move_to_end(key)
        if len(self.d) > self.cap:
            self.d.popitem(last=False)
  362. 缓存里已有 cap 个键时，一次命中的 get 的时间复杂度是？
    class LRU:
    def __init__(self, cap):
        self.cap, self.d, self.order = cap, {}, []

    def get(self, key):
        if key not in self.d:
            return -1
        self.order.remove(key)
        self.order.append(key)
        return self.d[key]
  363. 把一组单词建成字典树，时间复杂度是？
    def build(words):
    root = {}
    for w in words:
        node = root
        for ch in w:
            node = node.setdefault(ch, {})
        node['$'] = True
    return root
  364. x 是非负整数。循环执行的次数等于？
    def ones(x):
    count = 0
    while x:
        x &= x - 1
        count += 1
    return count
  365. a、b 是正整数，把一次取模看作 O(1)。时间复杂度是？
    def gcd(a, b):
    while b:
        a, b = b, a % b
    return a
  366. n ≥ 1。时间复杂度是？（取最紧的界）
    def primes(n):
    is_p = [True] * (n + 1)
    is_p[0] = is_p[1] = False
    i = 2
    while i * i <= n:
        if is_p[i]:
            for j in range(i * i, n + 1, i):
                is_p[j] = False
        i += 1
    return [k for k in range(n + 1) if is_p[k]]
  367. bits 是低位在前的二进制计数器，从全 0 开始调用 increment n 次（位数足够）。总时间是？
    def increment(bits):
    i = 0
    while i < len(bits) and bits[i] == 1:
        bits[i] = 0
        i += 1
    if i < len(bits):
        bits[i] = 1
  368. 下面代码在最坏情况下的时间复杂度是？（把一次取模看作 O(1)）
    def is_prime(n):
    if n < 2:
        return False
    d = 2
    while d * d <= n:
        if n % d == 0:
            return False
        d += 1
    return True
  369. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def merge_sort(a):
    if len(a) <= 1:
        return a
    mid = len(a) // 2
    left, right = merge_sort(a[:mid]), merge_sort(a[mid:])
    out, i, j = [], 0, 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            out.append(left[i])
            i += 1
        else:
            out.append(right[j])
            j += 1
    return out + left[i:] + right[j:]
  370. 调用 range_max(a, 0, n - 1)。时间复杂度是？
    def range_max(a, lo, hi):
    if lo == hi:
        return a[lo]
    mid = (lo + hi) // 2
    return max(range_max(a, lo, mid), range_max(a, mid + 1, hi))
  371. 下面代码的时间复杂度是？（n = len(a)，取最紧的界）
    def halves(a):
    if len(a) <= 1:
        return 0
    return sum(a) + halves(a[:len(a) // 2])
  372. 下面代码的时间复杂度是？
    def work(n):
    if n <= 1:
        return 1
    total = 0
    for _ in range(n):
        total += 1
    return total + work(n // 2) + work(n // 2) + work(n // 2)
  373. 输入是已经升序排好的 n 个不同的数。时间复杂度是？
    def quick_sort(a):
    if len(a) <= 1:
        return a
    pivot = a[0]
    smaller = [x for x in a[1:] if x < pivot]
    larger = [x for x in a[1:] if x >= pivot]
    return quick_sort(smaller) + [pivot] + quick_sort(larger)
  374. 下面代码的时间复杂度是？
    def count(n):
    c = 0
    for i in range(n):
        j = 1
        while j < n:
            j *= 2
            c += 1
    return c
  375. 下面代码的时间复杂度是？
    def count(n):
    c = 0
    for i in range(1, n + 1):
        for j in range(i, n + 1, i):
            c += 1
    return c
  376. 下面代码的时间复杂度是？
    def count(n):
    c = 0
    for i in range(n):
        for j in range(i, n):
            c += 1
    return c
  377. -1 在 8 位补码中的二进制表示是？
  378. 8 位有符号整数（补码）能表示的范围是？
  379. 在 8 位补码加法器上计算 100 + 100，结果按有符号数解释是多少？
  380. 对正整数 x，表达式 x & (x - 1) 的效果是？
  381. x = 12 时，x & -x（补码）的值是？
  382. 数组里除了一个数只出现一次，其余数都恰好出现两次。把所有数异或（XOR）起来，结果是？
  383. 32 位整数 0x12345678 以小端序存放在地址 0x100 开始的 4 个字节里，地址 0x100 处的字节是？
  384. 网络协议（如 TCP/IP 报头）里的多字节整数使用哪种字节序？
  385. Java 中 -8 >> 1 和 -8 >>> 28 的值分别是？
  386. 对一个很大的 C/C++ 二维数组 int a[N][N] 求和，为什么按行遍历（外层 i、内层 j，访问 a[i][j]）通常比按列遍历快很多？
  387. 两个线程分别频繁写各自的计数器 a 和 b，没有共享数据，但比单线程还慢。最可能的原因是？
  388. 缓存命中时间 1 ns，缺失率 10%，缺失代价 100 ns。平均访存时间（AMAT）是多少？
  389. 把直接映射缓存改成 4 路组相联（总容量不变），主要能减少哪一类缓存缺失？
  390. 在使用 IEEE 754 双精度浮点数的语言里，0.1 + 0.2 == 0.3 为假，根本原因是？
  391. IEEE 754 单精度 float 的有效数字（含隐含位）是 24 位。下面哪个整数不能用 float 精确表示？
  392. JavaScript 的 Number.MAX_SAFE_INTEGER 是 2^53 - 1，这个 53 来自哪里？
  393. 在 IEEE 754 浮点运算中，x 是 NaN 时，下面哪个表达式为真？
  394. 双精度浮点下，(1e20 + -1e20) + 1 和 1e20 + (-1e20 + 1) 的值分别是？
  395. 同一段代码「if (a[i] >= 128) sum += a[i];」遍历同一个大数组，数组排好序后明显更快，主要原因是？
  396. 按访问速度从快到慢排列，下面哪一组顺序正确？
  397. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int a[] = {10, 20, 30, 40};
    int* p = a + 1;
    std::cout << *p + 1 << " " << *(p + 2) << "\n";
}
  398. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int x = 5;
    int& r = x;
    r += 3;
    int y = r;
    y *= 2;
    std::cout << x << " " << y << "\n";
}
  399. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

void f(int v) { v = 100; }
void g(int& v) { v = 200; }

int main() {
    int a = 1, b = 1;
    f(a);
    g(b);
    std::cout << a << " " << b << "\n";
}
  400. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

void swapPtr(int* a, int* b) {
    int* t = a;
    a = b;
    b = t;
}

int main() {
    int x = 1, y = 2;
    int* p = &x;
    int* q = &y;
    swapPtr(p, q);
    std::cout << *p << " " << *q << "\n";
}
  401. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct A {
    A() { std::cout << "D"; }
    A(const A&) { std::cout << "C"; }
};

void take(A a) {}

int main() {
    A a;
    take(a);
    A b = a;
    std::cout << "\n";
}
  402. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>
#include <utility>
#include <vector>

int main() {
    std::vector<int> a{1, 2, 3};
    std::vector<int> b = std::move(a);
    std::cout << a.size() << " " << b.size() << "\n";
}
  403. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct A {
    A() { std::cout << "D"; }
    A(const A&) { std::cout << "C"; }
    A(A&&) { std::cout << "M"; }
};

A make() { return A(); }

int main() {
    A a = make();
    std::cout << "\n";
}
  404. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>
#include <utility>

struct A {
    A() {}
    A(const A&) { std::cout << "C"; }
    A(A&&) { std::cout << "M"; }
};

int main() {
    const A a;
    A b = std::move(a);
    A c = std::move(b);
    std::cout << "\n";
}
  405. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Base {
    virtual void hi() { std::cout << "B"; }
    void plain() { std::cout << "b"; }
};
struct Derived : Base {
    void hi() override { std::cout << "D"; }
    void plain() { std::cout << "d"; }
};

int main() {
    Derived d;
    Base* p = &d;
    p->hi();
    p->plain();
    std::cout << "\n";
}
  406. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Base {
    virtual const char* name() const { return "Base"; }
};
struct Derived : Base {
    const char* name() const override { return "Derived"; }
};

void byValue(Base b) { std::cout << b.name() << " "; }
void byRef(const Base& b) { std::cout << b.name() << "\n"; }

int main() {
    Derived d;
    byValue(d);
    byRef(d);
}
  407. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Base {
    Base() { hello(); }
    virtual void hello() { std::cout << "Base\n"; }
};
struct Derived : Base {
    void hello() override { std::cout << "Derived\n"; }
};

int main() {
    Derived d;
}
  408. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct T {
    char c;
    T(char c) : c(c) { std::cout << c; }
    ~T() { std::cout << char(c - 'a' + 'A'); }
};

int main() {
    T a('a');
    T b('b');
    std::cout << "|";
}
  409. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Base {
    ~Base() { std::cout << "~B"; }
};
struct Derived : Base {
    ~Derived() { std::cout << "~D"; }
};

int main() {
    Base* p = new Derived;
    delete p;
    std::cout << "\n";
}
  410. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int counter() {
    static int n = 0;
    return ++n;
}

int main() {
    counter();
    counter();
    std::cout << counter() << "\n";
}
  411. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Dog {
    static int count;
    Dog() { ++count; }
};
int Dog::count = 0;

int main() {
    Dog a, b;
    {
        Dog c;
    }
    std::cout << Dog::count << "\n";
}
  412. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <cstdint>
#include <iostream>

int main() {
    std::uint32_t u = 0;
    u = u - 1;
    std::cout << u << "\n";
}
  413. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <climits>
#include <iostream>

int main() {
    int x = INT_MAX;
    x = x + 1;
    std::cout << x << "\n";
}
  414. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    unsigned char a = 200, b = 100;
    std::cout << a + b << "\n";
}
  415. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int a = -1;
    unsigned int b = 1;
    std::cout << (a < b ? "less" : "not less") << "\n";
}
  416. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    std::cout << -7 / 2 << " " << -7 % 2 << "\n";
}
  417. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int a[5] = {1, 2, 3, 4, 5};
    int* p = &a[4];
    int* q = a + 1;
    std::cout << p - q << " " << *q << "\n";
}
  418. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int x = 1, y = 2;
    const int* p = &x;
    p = &y;
    *p = 5;
    std::cout << *p << "\n";
}
  419. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int a = 1, b = 2;
    int& r = a;
    r = b;
    b = 3;
    std::cout << a << r << b << "\n";
}
  420. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct Box {
    int* v;
    Box(int x) : v(new int(x)) {}
};

int main() {
    Box a(1);
    Box b = a;
    *b.v = 9;
    std::cout << *a.v << "\n";
}
  421. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>
#include <memory>
#include <utility>

int main() {
    auto p = std::make_unique<int>(7);
    auto q = std::move(p);
    std::cout << (p ? "p" : "null") << " " << *q << "\n";
}
  422. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>
#include <memory>

int main() {
    auto a = std::make_shared<int>(1);
    auto b = a;
    {
        auto c = b;
        std::cout << a.use_count();
    }
    std::cout << a.use_count() << "\n";
}
  423. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

struct B {
    virtual void f(int x = 1) { std::cout << "B" << x; }
};
struct D : B {
    void f(int x = 2) override { std::cout << "D" << x; }
};

int main() {
    D d;
    B& b = d;
    b.f();
    std::cout << "\n";
}
  424. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int i = 5;
    int a = i++;
    int b = ++i;
    std::cout << a << " " << b << " " << i << "\n";
}
  425. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    long long x = 100000 * 100000;
    std::cout << x << "\n";
}
  426. 下面的 C++ 程序（g++ -std=c++17）输出什么？
    #include <iostream>

int main() {
    int n = 1;
    auto byVal = [n] { return n; };
    auto byRef = [&n] { return n; };
    n = 5;
    std::cout << byVal() << " " << byRef() << "\n";
}
  427. 你刚提交了一个改动，执行 git reset --soft HEAD~1 之后，仓库是什么状态？
  428. 不带选项执行 git reset HEAD~1（即 --mixed），上一次提交里的改动去哪了？
  429. 执行 git reset --hard HEAD~1 之后，被撤掉的那个提交还能找回来吗？
  430. main 上的一个提交已经推送并被同事拉取，现在要撤销它，最安全的做法是？
  431. feature 分支从 main 的提交 A 拉出，之后 feature 上有 B、C，main 没有新提交。在 main 上执行 git merge feature 的结果是？
  432. feature 从 A 拉出后有提交 B、C；main 在 A 之后有了 D。在 feature 上执行 git rebase main 之后，feature 的历史是？
  433. 为什么不要对已经推送、别人也在用的分支执行 rebase？
  434. 只改了上一次提交的提交信息，执行 git commit --amend 之后会怎样？
  435. git checkout <某个提交的哈希> 之后提示 detached HEAD。此时新建的提交会怎样？
  436. feature 上还有没合并到当前分支的提交，执行 git branch -d feature 会怎样？
  437. git fetch 和 git pull 的区别是？
  438. 在 main 上执行 git cherry-pick <hotfix 分支上的某个提交>，结果是？
  439. 修改 app.js 后执行 git add app.js，又接着修改了 app.js，然后直接 git commit（不加 -a）。这次提交里是哪个版本？
  440. 关于 git stash（不带参数），哪项正确？
  441. git log main..feature 列出的是哪些提交？
  442. umask 是 022 时，用 touch 新建的普通文件权限是多少？
  443. umask 是 027 时，mkdir 新建的目录权限是多少？
  444. 执行 chmod 754 report.sh 之后，ls -l 显示的权限是？
  445. 对一个目录来说，x（执行）权限意味着什么？
  446. 想把一个命令的标准输出和标准错误都写进 out.txt，应该用哪一条？
  447. cat access.log | grep " 404 " | wc -l 输出的是什么？
  448. 统计每个 IP 出现次数时常写 sort | uniq -c，为什么要先 sort？
  449. 关于 kill -9 <pid>，下面哪项正确？
  450. 在终端里运行一个程序时按下 Ctrl+Z，会发生什么？
  451. ps 里看到一个状态为 Z（defunct）的僵尸进程，它是怎么产生的？
  452. 父进程先退出了，它的子进程还在运行。子进程会怎样？
  453. 在 bash 里，$? 保存的是什么？
  454. 在 bash 里执行 false | true; echo $?（没有 set -o pipefail），输出什么？
  455. 执行 ln a.txt b 和 ln -s a.txt c 之后删除 a.txt，b 和 c 还能读出原来的内容吗？
  456. script.sh 没有执行权限（也不在 PATH 里），下面哪种方式仍然能运行它？
  457. 想在关掉 SSH 终端之后让一个长任务继续跑，下面哪种做法可行？
  458. find /var/log -name "*.log" -mtime +7 找的是什么文件？
  459. /tmp 的权限是 drwxrwxrwt，最后的 t（粘滞位）起什么作用？
  460. grep -c error app.log 输出的数字表示什么？
  461. 在 bash 里先执行 X=1，再执行 bash -c 'echo $X'，输出什么？
  462. 一个类把构造函数设为私有，提供静态方法 getInstance()，每次都返回同一个对象。这是哪种模式？
  463. 关于单例模式，下面哪项是常被批评的缺点？
  464. 要构造的 HttpRequest 有十几个可选参数，于是写成 HttpRequest.newBuilder().uri(u).header(k, v).timeout(t).build()。这是哪种模式？
  465. 系统里的支付代码都依赖自定义接口 PaymentGateway。要接入一个方法名、参数都不同的第三方 SDK，于是写一个实现 PaymentGateway、内部调用 SDK 的类。这是哪种模式？
  466. Java 里写 new BufferedInputStream(new GZIPInputStream(new FileInputStream(f)))，每层都是 InputStream，并各自加了一点功能。这是哪种模式？
  467. 一个 ImageProxy 和真实的 Image 实现同一个接口，只有第一次调用 display() 时才从磁盘加载图片。这是哪种模式？
  468. 下单要依次调用库存、支付、物流、通知四个子系统，于是写一个 OrderService.placeOrder() 把这些调用都包起来，调用方只需要调用它。这是哪种模式？
  469. 按钮的 addEventListener("click", handler)、消息系统的订阅与发布，体现的是哪种模式？
  470. 电商的运费计算有「按重量」「按件数」「包邮」三种算法，运行时根据活动配置切换，每种算法实现同一个 ShippingCost 接口。这是哪种模式？
  471. 文本编辑器把每次操作封装成带 execute() 和 undo() 的对象，放进历史栈里以支持撤销和重做。这是哪种模式？
  472. 抽象类 DataExporter 的 export() 依次调用 open()、writeHeader()、writeRows()、close()；CsvExporter 和 JsonExporter 只重写其中几个步骤。这是哪种模式？
  473. 自动售货机有「待投币」「已投币」「出货中」「售罄」几种状态，同样按下按钮在不同状态下行为不同。把每种状态写成一个类，由它决定下一步，这是哪种模式？
  474. 文件系统里，文件和文件夹都实现 getSize()，文件夹的 getSize() 把子项的大小加起来，调用方不用区分是文件还是文件夹。这是哪种模式？
  475. Python 里 for x in obj 能用于列表、字典、文件和自定义的类，只要它们提供 __iter__ 返回一个有 __next__ 的对象。这体现的是哪种模式？
  476. 根据配置里的字符串 "csv"、"json"、"xml"，由 ParserFactory.create(type) 返回对应的 Parser 实现，调用方只依赖 Parser 接口。这体现的是什么？
  477. 攻击者在论坛评论里写入一段 <script>，之后每个打开该帖子的用户浏览器都会执行它。这属于哪种攻击？
  478. 防御 XSS 最根本的做法是？
  479. 给会话 Cookie 加上 HttpOnly 属性，能起到什么作用？
  480. 响应头里设置了 Content-Security-Policy: script-src 'self'，下面哪种脚本会被浏览器拦下？
  481. 关于 CSRF（跨站请求伪造），下面哪项描述正确？
  482. 下面哪项不能有效防御 CSRF？
  483. 会话 Cookie 设置了 SameSite=Lax。用户在其他网站上，下面哪种请求会带上这个 Cookie？
  484. 后端代码是 "SELECT * FROM users WHERE name = '" + name + "'"，用户输入的 name 是 ' OR '1'='1，会发生什么？
  485. 防止 SQL 注入最可靠的做法是？
  486. 关于 CORS（跨域资源共享），哪项说法正确？
  487. 前端用 fetch 向另一个域名的 API 发送 POST，请求头 Content-Type: application/json。浏览器会先做什么？
  488. 跨域请求带上了 Cookie（credentials: 'include'），服务器返回 Access-Control-Allow-Origin: *。结果是？
  489. 下面哪个 URL 和 https://app.example.com/page 是同源的？
  490. 哈希和加密的主要区别是？
  491. 存储用户密码，下面哪种做法最合适？
  492. 密码哈希里的「盐」（salt）有什么作用？
  493. 关于常见的签名型 JWT（JWS，比如 HS256），下面哪项正确？
  494. 服务端校验收到的 JWT 时，最重要的是？
  495. 用无状态 JWT 做登录，用户点了「退出登录」或者账号被封，已经签发的 token 会怎样？
  496. HTTPS（TLS）建立连接后传输大量数据，用的是哪种加密方式？
  497. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE t (id INTEGER, bonus INTEGER);
INSERT INTO t VALUES (1, 100), (2, NULL), (3, 50), (4, NULL);
SELECT COUNT(*), COUNT(bonus), SUM(bonus), MAX(bonus) FROM t;
  498. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE t (id INTEGER, bonus INTEGER);
INSERT INTO t VALUES (1, 100), (2, NULL), (3, 50), (4, NULL);
SELECT
  (SELECT COUNT(*) FROM t WHERE bonus <> 100),
  (SELECT COUNT(*) FROM t WHERE bonus IS NULL);
  499. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE a (x INTEGER);
INSERT INTO a VALUES (1), (2), (3);
CREATE TABLE b (y INTEGER);
INSERT INTO b VALUES (2), (NULL);
SELECT COUNT(*) FROM a WHERE x NOT IN (SELECT y FROM b);
  500. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE orders (id INTEGER PRIMARY KEY, user_id INTEGER, amount INTEGER);
INSERT INTO users VALUES (1, 'ann'), (2, 'bo'), (3, 'cy');
INSERT INTO orders VALUES (1, 1, 30), (2, 1, 80), (3, 2, 20);
SELECT u.name, COUNT(o.id)
FROM users u
LEFT JOIN orders o ON o.user_id = u.id AND o.amount > 25
GROUP BY u.id
ORDER BY u.id;
  501. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);
CREATE TABLE orders (id INTEGER PRIMARY KEY, user_id INTEGER, amount INTEGER);
INSERT INTO users VALUES (1, 'ann'), (2, 'bo'), (3, 'cy');
INSERT INTO orders VALUES (1, 1, 30), (2, 1, 80), (3, 2, 20);
SELECT u.name, COUNT(o.id)
FROM users u
LEFT JOIN orders o ON o.user_id = u.id
WHERE o.amount > 25
GROUP BY u.id
ORDER BY u.id;
  502. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE p (id INTEGER, tag TEXT);
INSERT INTO p VALUES (1, 'a'), (1, 'b'), (2, 'c');
CREATE TABLE q (id INTEGER, v INTEGER);
INSERT INTO q VALUES (1, 10), (1, 20), (3, 30);
SELECT COUNT(*) FROM p JOIN q ON p.id = q.id;
  503. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE sales (region TEXT, amount INTEGER);
INSERT INTO sales VALUES ('east', 10), ('east', 30), ('west', 5), ('west', 6), ('north', 50);
SELECT region, SUM(amount)
FROM sales
GROUP BY region
HAVING COUNT(*) > 1
ORDER BY region;
  504. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE sales (region TEXT, amount INTEGER);
INSERT INTO sales VALUES ('east', 10), ('east', 30), ('west', 5), ('west', 6), ('north', 50);
SELECT region, SUM(amount)
FROM sales
WHERE amount > 8
GROUP BY region
ORDER BY region;
  505. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE a (x INTEGER);
INSERT INTO a VALUES (1), (2), (2);
CREATE TABLE b (x INTEGER);
INSERT INTO b VALUES (2), (3);
SELECT
  (SELECT COUNT(*) FROM (SELECT x FROM a UNION SELECT x FROM b)),
  (SELECT COUNT(*) FROM (SELECT x FROM a UNION ALL SELECT x FROM b));
  506. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE emp (name TEXT, salary INTEGER);
INSERT INTO emp VALUES ('a', 100), ('b', 300), ('c', 300), ('d', 200);
SELECT DISTINCT salary FROM emp ORDER BY salary DESC LIMIT 1 OFFSET 1;
  507. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE s (name TEXT, score INTEGER);
INSERT INTO s VALUES ('a', 90), ('b', 80), ('c', 90), ('d', 70);
SELECT name,
  RANK() OVER (ORDER BY score DESC),
  DENSE_RANK() OVER (ORDER BY score DESC)
FROM s
ORDER BY score DESC, name;
  508. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE tx (day INTEGER, amount INTEGER);
INSERT INTO tx VALUES (1, 5), (2, -2), (3, 10);
SELECT day, SUM(amount) OVER (ORDER BY day) FROM tx ORDER BY day;
  509. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    SELECT 7 / 2, 7 / 2.0, 7 % 3;
  510. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    SELECT 'a' || NULL, COALESCE(NULL, NULL, 'z'), NULL + 1;
  511. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE g (score INTEGER);
INSERT INTO g VALUES (95), (72), (88), (60);
SELECT
  SUM(CASE WHEN score >= 80 THEN 1 ELSE 0 END),
  COUNT(CASE WHEN score < 70 THEN 1 END)
FROM g;
  512. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE e (v INTEGER);
SELECT COUNT(*), SUM(v), MAX(v) FROM e;
  513. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE emp (name TEXT, dept TEXT, salary INTEGER);
INSERT INTO emp VALUES ('a', 'x', 100), ('b', 'x', 200), ('c', 'y', 150), ('d', 'y', 150), ('e', 'y', 300);
SELECT name FROM emp e1
WHERE salary > (SELECT AVG(salary) FROM emp e2 WHERE e2.dept = e1.dept)
ORDER BY name;
  514. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE staff (id INTEGER PRIMARY KEY, name TEXT, manager_id INTEGER);
INSERT INTO staff VALUES (1, 'ann', NULL), (2, 'bo', 1), (3, 'cy', 1), (4, 'di', 2);
SELECT s.name, m.name
FROM staff s
LEFT JOIN staff m ON s.manager_id = m.id
ORDER BY s.id;
  515. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE emails (id INTEGER, email TEXT);
INSERT INTO emails VALUES (1, 'a@x'), (2, 'b@x'), (3, 'a@x'), (4, 'c@x'), (5, 'b@x'), (6, 'a@x');
SELECT email, COUNT(*)
FROM emails
GROUP BY email
HAVING COUNT(*) > 1
ORDER BY COUNT(*) DESC;
  516. 在 SQLite 里依次执行下面的语句，最后一条查询返回什么？（每行一条记录，列之间用 | 分隔）
    CREATE TABLE t (id INTEGER PRIMARY KEY, v INTEGER);
INSERT INTO t VALUES (1, 1), (2, 2), (3, NULL);
UPDATE t SET v = v * 10 WHERE v >= 2 OR v IS NULL;
SELECT id, v FROM t ORDER BY id;
  517. 响应头 Cache-Control: no-cache 的含义是？
  518. 资源响应头是 Cache-Control: max-age=3600。半小时后再次请求，浏览器会怎么做？
  519. 浏览器带着 If-None-Match: "abc123" 请求资源，服务器上该资源的 ETag 仍是 "abc123"。服务器应该返回什么？
  520. 构建后的文件名带内容哈希（如 app.3f9a1c.js），HTML 引用新文件名。这些 JS 文件最合适的缓存头是？
  521. 返回用户个人资料的接口，响应头写 Cache-Control: private, max-age=60 表示什么？
  522. 关于 localStorage 和 sessionStorage，哪项正确？
  523. 执行 localStorage.setItem("user", { id: 1 }) 之后，localStorage.getItem("user") 返回什么？
  524. Cookie 设置了 Secure 和 HttpOnly 两个属性，分别起什么作用？
  525. 在 www.example.com 上设置 Cookie 时没有写 Domain 属性。它会被发给 api.example.com 吗？
  526. <body> 里有 <div>，<div> 里有 <button>，三者都用 addEventListener("click", …) 注册了处理函数（默认参数）。点击按钮时，处理函数的执行顺序是？
  527. 在 <ul> 上做事件委托：ul.addEventListener("click", e => …)。用户点击了某个 <li> 里的 <span>，事件处理函数中 e.target 和 e.currentTarget 分别是？
  528. 一个列表有上千项，而且会动态增减。用事件委托（在父元素上注册一个监听器）相比给每一项单独注册，主要好处是？
  529. 在链接 <a href="/next"> 的点击处理函数里只调用了 e.stopPropagation()，会发生什么？
  530. 父元素用 addEventListener("click", f, true) 注册，子元素用默认方式注册。点击子元素时谁先执行？
  531. 一个 div 的样式是 width: 200px; padding: 20px; border: 5px solid; box-sizing: content-box。它在页面上占的总宽度（不含 margin）是？
  532. 上下相邻的两个块级元素，上面的 margin-bottom: 20px，下面的 margin-top: 30px。它们之间的垂直间距是？
  533. 鼠标正悬停在一个链接上，它同时匹配三条规则（都没有 !important）：#nav a { color: red }；.menu .item a { color: blue }；a:hover { color: green }。最终显示什么颜色？
  534. 元素的行内样式是 style="color: red"，样式表里有 p { color: blue !important; }。最终颜色是？
  535. 容器是 display: flex; flex-direction: column;，想让子元素在垂直方向上居中，应该用哪个属性？
  536. flex 容器里三个子元素都写了 flex: 1，没有设置宽度。它们怎样分配宽度？
  537. 宽 300px 的容器设置 display: grid; grid-template-columns: 1fr 2fr;（没有 gap）。两列各宽多少？
  538. 容器 grid-template-columns: repeat(3, 1fr);，没有定义行，里面放了 7 个子元素。会形成几行？
  539. 下面哪个样式修改会触发重排（reflow / layout），而不仅仅是重绘？
  540. 在循环里对每个元素先写 el.style.width = …，紧接着读 el.offsetHeight，页面变得很卡。原因和改法是？
  541. 做动画时，为什么推荐改 transform 和 opacity，而不是 left、top？
  542. 关于关键渲染路径，下面哪项正确？
  543. <script defer src="a.js"> 和 <script async src="b.js"> 的区别是？
  544. 要一个可点击的按钮，下面哪种写法最好？
  545. 一个只有关闭图标（×，用 SVG 画的）、没有文字的按钮，怎样让读屏器用户知道它是做什么的？
  546. 表单保存成功后，页面上出现「已保存」的提示。想让读屏器自动读出它，又不打断用户正在听的内容，应该怎么做？
  547. 中心极限定理说的是什么？
  548. 总体标准差 σ = 20，随机抽取 n = 100 个样本。样本均值的标准误是多少？
  549. 一次检验得到 p = 0.03。下面哪种解读是对的？
  550. 某均值的 95% 置信区间是 [2.1, 3.4]。下面哪种说法是对的？
  551. 一个实验其实没有任何效果，你却同时检验了 20 个互相独立的指标，每个都用 α = 0.05。至少有一个指标「显著」的概率大约是？
  552. 要做 10 个检验，并把「至少一个误报」的总概率控制在 0.05 以内。按 Bonferroni 校正，每个检验的显著性阈值是？
  553. 按病情轻重分层后，A 疗法在轻症和重症里的治愈率都比 B 高；可把所有病人合在一起算，B 的治愈率反而更高。最可能的原因是？
  554. 假设检验的功效（power）指的是？
  555. 其他条件不变，想把均值置信区间的宽度缩小一半，样本量要变成原来的几倍？
  556. 数据显示冰淇淋销量和溺水人数高度正相关。最合理的解释是？
  557. 收入分布通常是右偏的（少数人收入很高）。均值和中位数的关系通常是？
  558. X 和 Y 相互独立，Var(X) = 4，Var(Y) = 9。Var(X - Y) 是多少？
  559. X ~ N(100, 15²)。P(X > 130) 大约是多少？
  560. 正态分布中，约 95% 的数据落在均值左右多少个标准差以内？
  561. 大数定律保证的是什么？
  562. A/B 测试每天看一次 p 值，一旦小于 0.05 就停止实验并宣布胜出。这会带来什么问题？
  563. 事先就预测新版本会提高转化率。双侧检验的 p 值是 0.08，观测到的效应方向和预测一致。对应的单侧 p 值是？
  564. 想检验两个分类变量是否独立，例如「设备类型」（手机、平板、电脑）和「是否下单」。该用什么检验？
  565. 同一批 30 名用户在改版前后各测了一次任务完成时间。比较两次的均值，最合适的检验是？
  566. 只分析「目前还在使用产品」的用户，发现用过功能 X 的人平均使用时长更长，于是认为功能 X 提升了留存。这个结论的主要问题是？
  567. 第一次考试成绩最差的 10% 学生参加了补课，第二次考试平均分明显上升。能否据此认为补课有效？
  568. 样本量不断增大时，下面哪个量会明显变小？
  569. 某病患病率 1%。检测的灵敏度 90%（患者 90% 测出阳性），健康人有 9% 会误测为阳性。一个人检测阳性，他真正患病的概率约是？
  570. 样本方差的公式除以 n - 1 而不是 n，原因是？
  571. 下面哪些做法能降低 A/B 测试得出假阳性结论的风险？（多选）
  572. 要预测「订单会不会在 30 天内被退货」，模型在下单那一刻打分。下面哪些特征会造成数据泄漏？（多选）
  573. 要预测「贷款申请人未来 12 个月会不会违约」，在审批时打分。下面哪些特征会泄漏？（多选）
  574. 医院想在入院分诊时预测病人是否患有肺炎。下面哪些特征会泄漏？（多选）
  575. 订阅产品要预测用户下个月会不会流失，每月 1 日用之前的数据打分。下面哪些特征会泄漏？（多选）
  576. 要预测「信用卡交易是不是盗刷」，在交易发生的瞬间实时打分。下面哪些特征会泄漏？（多选）
  577. 要预测「候选人会不会接受 offer」，在发 offer 当天打分。下面哪些特征会泄漏？（多选）
  578. 下面哪些做法会把测试集的信息泄漏进训练过程？（多选）
  579. 要预测明天的门店销量。下面哪些评估或特征构造方式存在泄漏？（多选）
  580. 数据集里同一个病人有多张 X 光片，你按图片随机划分训练集和测试集，测试准确率很高。问题出在哪？
  581. 模型训练误差 2%，验证误差 25%。最可能的诊断和对策是？
  582. L1 正则（Lasso）和 L2 正则（Ridge）最主要的区别是？
  583. 信用卡欺诈检测里，漏掉一笔欺诈的代价远高于误拦一笔正常交易。调阈值时应该更看重哪个指标？
  584. 数据里 99% 是负样本。为什么只看准确率不合适？
  585. ROC-AUC = 0.8 的含义是？
  586. 梯度下降时学习率设得太大，最典型的现象是？
  587. 下面哪些模型对特征的尺度（单位）敏感，通常需要先标准化？（多选）
  588. k-means 优化的目标函数是？
  589. 随机森林相比单棵决策树，主要降低的是什么？
  590. 用平方损失做梯度提升（gradient boosting）时，每一棵新树拟合的是什么？
  591. softmax 输出 p，配合交叉熵损失，真实类别的 one-hot 向量是 y。损失对 logits z 的梯度是？
  592. 很深的网络全用 sigmoid 激活，前几层几乎学不动。最主要的原因是？
  593. 关于 Dropout，下面哪种说法正确？
  594. 批归一化（Batch Normalization）在推理时用什么做归一化？
  595. 缩放点积注意力为什么要把 QKᵀ 除以 √d_k？
  596. 逻辑回归里某个特征的权重是 0.7。其他特征不变时，这个特征增加 1，会怎样？
  597. 一个分类器在测试集上 TP = 40、FP = 10、FN = 20。精确率和召回率分别是？
  598. 把二分类的判定阈值从 0.5 提高到 0.8，通常会怎样？
  599. 正样本只占 1%。下面哪些处理类别不平衡的做法是正确的？（多选）
  600. 对邮编这类高基数类别特征做目标编码（用该类别的平均标签替代类别）。下面哪些做法正确？（多选）
  601. 模型上线几个月后效果下降，排查发现线上某些特征的分布和训练时明显不同，而特征与标签的关系没变。这种情况叫什么？
  602. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.ones((3, 1))
b = np.ones(4)
print((a + b).shape)
  603. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.arange(5)
b = a[1:3]
b[0] = 99
print(a.tolist())
  604. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.arange(5)
b = a[[1, 2]]
b[0] = 99
print(a.tolist())
  605. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([3, -1, 4, -5])
a[a < 0] = 0
print(a.tolist())
  606. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([1, 2, 3])
a[0] = 2.9
print(a.tolist())
  607. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.arange(6).reshape(2, 3)
print(a.sum(axis=0).tolist())
  608. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.arange(6).reshape(2, 3)
print((a - a.mean(axis=1, keepdims=True)).tolist())
  609. 下面的 NumPy 代码输出什么？
    import numpy as np

print(int(np.argmax([1, 3, 3, 2])))
  610. 下面的 NumPy 代码输出什么？
    import numpy as np

print(np.arange(6).reshape(3, 2).T.tolist())
  611. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([[1, 2], [3, 4]])
print((a * a).tolist(), (a @ a).tolist())
  612. 下面的 NumPy 代码输出什么？
    import numpy as np

v = np.array([1, 2, 3])
print(int(v @ v), (v[:, None] @ v[None, :]).shape)
  613. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([200], dtype=np.uint8)
print((a + a).tolist())
  614. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([1.0, np.nan, 3.0])
print(float(np.sum(a)), float(np.nansum(a)))
  615. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.zeros(4)
b = a.reshape(2, 2)
b[0, 0] = 1
print(a.tolist())
  616. 下面的 NumPy 代码输出什么？
    import numpy as np

values, counts = np.unique([3, 1, 3, 2, 3], return_counts=True)
print(values.tolist(), counts.tolist())
  617. 下面的 NumPy 代码输出什么？
    import numpy as np

print((np.arange(3)[:, None] * np.arange(3)).tolist())
  618. 下面的 NumPy 代码输出什么？
    import numpy as np

print(np.argsort([30, 10, 20]).tolist())
  619. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([1, 2, 3])
print(bool((a > 1).any()), bool((a > 1).all()))
  620. 下面的 NumPy 代码输出什么？
    import numpy as np

print(0.1 + 0.2 == 0.3, bool(np.isclose(0.1 + 0.2, 0.3)))
  621. 下面的 NumPy 代码输出什么？
    import numpy as np

a = np.array([1, 2, 3])
try:
    a += 0.5
    print(a.tolist())
except TypeError:
    print("TypeError")

作答记录只保存在这台设备的浏览器里；登录后再打开本页，会存进账号。