📝 Distributed Hash Table DHT in P2P (17 MCQs)

📖 Explanation: The alphabet consists of only two symbols, A and B. LZW starts with a dictionary that contains each individual symbol, so the initial number of entries equals the size of the alphabet, which is 2. This baseline is required before any multi‑character strings are added during encoding.

📖 Explanation: Consistent hashing assigns each key to the first node whose identifier is equal to or follows the key’s hash on the identifier circle. With IDs 0‑7, the interval for node 6 covers keys 6 up to 7, so the key with hash 6 is stored on node 6.

📖 Explanation: LZW adds a new entry for each previously unseen substring, leading to rapid (near‑exponential) growth for a short message. In contrast, a DHT only adds a single routing entry for each joining node, so the total number of entries increases linearly with the number of nodes.

📖 Explanation: Chord’s finger table gives a logarithmic search bound. With $N = 16$ nodes, the maximum number of hops is $\lceil \log_2 N \rceil = \lceil \log_2 16 \rceil = 4$. Each hop halves the remaining identifier space, guaranteeing the search completes within four steps.

📖 Explanation: When the decoder encounters an undefined code, it uses the rule: output = previous + first character(previous). The previous string is “AB”; its first character is “A”. Concatenating yields “ABA”, which is both the output and the new dictionary entry.

📖 Explanation: When finger tables contain obsolete pointers, a lookup may follow an incorrect hop and must fall back to slower corrective mechanisms, such as successor traversal. This extra work typically raises the overall latency rather than reducing it.

📖 Explanation: Compute the modulo: $22 \bmod 16 = 6$ and $38 \bmod 16 = 6$. Both keys therefore resolve to identifier 6, meaning the same node (ID 6) is responsible for storing each value.

📖 Explanation: When node 20 crashes, node 27 can use its finger table to jump directly to the next viable predecessor of the target, typically the node that would have been reached via the failed hop. This adds a single extra hop, moving from 27 straight to the successor of 20.

📖 Explanation: In the worst case, LZW can create a distinct entry for each new substring, giving a linear bound $O(L)$ where L is the input length. Chord’s routing table (finger table) stores $\lceil\log_2 N\rceil$ pointers, yielding a logarithmic space requirement $O(\log N)$.

📖 Explanation: Compressing data with LZW before transmission shrinks the payload size, so fewer bits travel across the network. This directly lowers bandwidth usage, which is especially valuable in bandwidth‑constrained environments or when many peers exchange large values.

📖 Explanation: The finger table’s purpose is to forward the request to the node with the largest identifier that precedes the target hash. Since node 12 is the closest preceding node to hash 3 (wrapping around the ring), the request is forwarded to node 12.

📖 Explanation: A DHT’s overlay maintains multiple routing paths and often replicates key‑value pairs across successors, giving it inherent fault tolerance. LZW is a compression technique that does not incorporate any redundancy; a lost or corrupted dictionary entry can corrupt the entire decoded stream.

📖 Explanation: When a node departs, its immediate successor inherits responsibility for the departing node’s identifier interval. The successor pointer guarantees that the interval is never orphaned, because the next node on the identifier circle automatically becomes the new owner of those keys.

📖 Explanation: When the decoder encounters a code not yet in the dictionary, it creates a new entry by appending the first character of the newly decoded string (“BAB”) to the previous output (“BA”). The resulting concatenation is “BAB”, which is then stored as the new dictionary entry.

📖 Explanation: A hierarchical tree structure provides logarithmic routing: each hop reduces the identifier space, yielding an average cost of $O(\log N)$. A flat hash table requires scanning or broadcasting across all nodes in the worst case, leading to linear cost $O(N)$.

📖 Explanation: Consistent hashing maps both nodes and keys onto the same identifier circle, then assigns each key to the first node encountered clockwise. This approach spreads keys evenly despite node joins or leaves, avoiding hot spots and ensuring balanced load distribution.

📖 Explanation: When bandwidth limits the system, transmitting fewer bits per operation directly raises the number of operations that can be completed per unit time. Although decompression adds CPU work, the dominant factor is the reduced volume of data moving across the network, so throughput improves.