Fundamental Information Technology Engineer Examination cheat sheet

科目A is a broad-knowledge paper: roughly 60% of questions come from technology (algorithms, databases, networks, security), the rest from management, strategy, and law/standards; no partial credit, so one wrong option loses the whole question.

Time budget: 90 minutes / 60 questions = 1.5 minutes per question; answer every question because there is no penalty for guessing, and mark uncertain items for a second pass.

Number representation: n bits represent 2^n values; unsigned range 0 to 2^n−1; two's complement range −2^(n−1) to 2^(n−1)−1; negate by inverting all bits and adding 1.

Availability: MTBF/(MTBF+MTTR); MTBF = total operating time / number of failures; raising availability means lengthening MTBF (reliability) or shortening MTTR (maintainability).

Relational algebra and SQL: SELECT = projection, WHERE = selection; in SQL, COUNT(*) counts rows including NULLs, COUNT(col) and AVG(col) ignore NULLs; GROUP BY groups before HAVING filters groups.

Normalization: 1NF removes repeating groups, 2NF removes partial dependency on part of a composite key, 3NF removes transitive dependency on non-key attributes; BCNF requires every determinant to be a candidate key.

Network layer mapping: hub = layer 1, switch/bridge = layer 2 (MAC), router = layer 3 (IP), gateway/proxy = up to layer 7; TCP is connection-oriented and reliable, UDP is connectionless and unreliable; well-known ports 0–1023 (HTTP 80, HTTPS 443, SMTP 25, DNS 53).

Public-key cryptography: RSA security rests on the difficulty of factoring large integers, Diffie-Hellman on the discrete logarithm problem; a digital signature is created with the sender's private key and verified with the sender's public key, giving authentication and tamper detection, not confidentiality.

Project management formulas: expected duration = (optimistic + 4×most likely + pessimistic)/6; CPI = EV/AC, SPI = EV/PV; CPI < 1 means over budget, SPI < 1 means behind schedule; the critical path is the longest path and has zero total float.

科目B emphasizes program reading and applied reasoning: trace pseudocode or a short program by hand, tracking variable values line by line; 100 minutes for 20 questions gives about 5 minutes each, so write variable tables rather than guessing.

Loop invariants: for a loop summing 1..n the invariant is sum = k(k+1)/2 after k iterations; for a binary search on a sorted array of n elements the maximum number of comparisons is about ⌈log2 n⌉+1.

Array and list costs: array index access is O(1), insertion/deletion in the middle is O(n); a linked list gives O(1) insertion at a known node but O(n) search; a stack is LIFO (push/pop), a queue is FIFO (enqueue/dequeue).

Sorting: bubble, selection, and insertion sort are O(n²) worst case; quicksort averages O(n log n) but degrades to O(n²) on already-sorted input with a poor pivot; merge sort is stable O(n log n) but needs O(n) extra memory.

Tree facts: a binary tree of height h has at most 2^h−1 nodes; a binary search tree gives in-order traversal in ascending key order; search/insert cost equals tree height, O(log n) when balanced, O(n) when degenerate.

Recursion: every recursive procedure needs a base case and progress toward it; a call that recurses n times consumes O(n) stack frames, and naive Fibonacci recursion runs in O(2^n) while an iterative or memoized version runs in O(n).

Hash tables: average search/insert is O(1), worst case O(n) when all keys collide; the load factor = stored elements / table size, and open addressing versus chaining are the two standard collision resolutions.

Trace rules for exam code: evaluate expressions left to right unless precedence says otherwise; integer division truncates toward zero; a variable passed by value is copied, by reference shares the caller's storage, so changes inside the callee are visible after return.

Complexity reading: nested loops over the same n give O(n²); halving the range each step gives O(log n); two sequential loops give O(n)+O(n)=O(n); only the dominant term and constant factor are kept in big-O.

Decimal-to-binary: divide by 2 and read remainders bottom-up; hexadecimal uses 4 bits per digit, so 1 hex digit = 4 binary bits and 2 hex digits = 1 byte.

Logic: XOR is 1 when inputs differ; A AND 0 = 0, A OR 1 = 1; De Morgan: NOT(A AND B) = (NOT A) OR (NOT B).

Cache: hit rate h, cache access time t1, main memory time t2 → average access time = h×t1 + (1−h)×t2; locality of reference is why caches work.

IP addressing: an IPv4 address is 32 bits; a /24 prefix leaves 8 host bits = 254 usable hosts; private ranges are 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16.

Symmetric vs asymmetric: AES is fast and shared-key; RSA is slow and key-pair based, so it is used to exchange a session key in TLS hybrid encryption.

SQL aggregate rules: WHERE filters rows before grouping, HAVING filters groups after; ORDER BY sorts the final result; DISTINCT removes duplicate result rows.

Legal/management: a work made for hire belongs to the employer unless otherwise agreed; personal data must be handled under the applicable protection law with purpose limitation and security measures.

Estimation and queueing: total cost = fixed + variable×quantity; break-even quantity = fixed cost / (price − variable cost per unit).

Reliability of redundancy: two independent units each with failure probability p in parallel fail together with probability p², so parallel redundancy sharply lowers system failure probability.

Binary search precondition: the array must be sorted; each comparison halves the search range, so n = 1000 needs at most about 10 comparisons.

Stack applications: expression evaluation, parenthesis matching, depth-first search, and function call management; queue applications: breadth-first search, print spooling, and buffering.

DFS uses a stack (or recursion) and goes deep first; BFS uses a queue and visits level by level; both are O(V+E) on a graph with V vertices and E edges.

Dynamic programming stores overlapping subproblem results in a table; the number of ways to climb n steps taking 1 or 2 at a time satisfies f(n)=f(n−1)+f(n−2).

Trace checklist: write each variable's value after each iteration, check the loop exit condition, and confirm what the function returns for boundary inputs such as n=0 or an empty array.

String handling: a substring from index i of length L occupies positions i to i+L−1; compare characters one by one, and count from 0 for arrays and from 1 for 1-based pseudocode as stated.

Modular arithmetic in code: (a×b) mod m = ((a mod m)×(b mod m)) mod m, which prevents overflow in large multiplications.

Sorting stability: stable sorts (insertion, merge) preserve the relative order of equal keys; selection sort and quicksort are typically unstable.

Error detection: a parity bit detects an odd number of bit errors only; a checksum or CRC detects burst errors, and CRC with r check bits detects all bursts of length ≤ r.

If the question asks for the smallest number of bits to represent values 0..N, the answer is ⌈log2(N+1)⌉; for signed values −N..N use one more bit for the sign.

If a question names a protocol, place it by layer: Ethernet/ARP = layer 2, IP/ICMP = layer 3, TCP/UDP = layer 4, HTTP/DNS/SMTP = layer 7.

If confidentiality is required, encrypt with the receiver's public key; if authentication of the sender is required, sign with the sender's private key.

If asked which normal form a table violates, look first for repeating groups (1NF), then partial key dependency (2NF), then non-key-to-non-key dependency (3NF).

If a schedule question gives optimistic/most likely/pessimistic values, use the beta (PERT) formula; if it gives a network diagram, the critical path is the longest path.

If asked about RAID: RAID 0 stripes with no redundancy, RAID 1 mirrors, RAID 5 stripes with distributed parity and tolerates one disk failure.

If an answer option claims a firewall blocks viruses inside allowed traffic or that antivirus replaces access control, it is wrong: firewalls filter traffic by rule, not content semantics.

If the code halves or doubles a counter each iteration, the complexity is O(log n); if it loops over all pairs, it is O(n²).

If a problem asks for shortest path with non-negative weights, use Dijkstra; with negative weights, use Bellman-Ford; for all-pairs, Floyd-Warshall is O(n³).

If a trace question asks how many times the body executes, count iterations of the loop condition, not the number of statements inside the body.

If a recursive function has two calls per level and depth n without memoization, the call count grows as 2^n; adding a memo table reduces it to O(n).

If a data structure must support last-in-first-out undo behavior, choose a stack; for first-come-first-served scheduling, choose a queue.

If a search must run on unsorted data, linear search O(n) is required; binary search is valid only after sorting, total O(n log n) plus O(log n).

If a question asks for the output of integer division or modulo with negative operands, apply the language's stated rule (truncation toward zero) rather than assuming floor division.

If a program's inner loop bound depends on the outer index (triangular loops), the count is n(n+1)/2, which is O(n²).