CS Fundamentals quiz answers

Average O(1), worst case O(n). A good hash function spreads keys evenly so each bucket holds only a few elements. When many keys collide into the same bucket, the operation degenerates into a linear scan of that bucket's list.

An array stores elements contiguously, so indexed access is O(1), but inserting/deleting in the middle requires shifting elements, so O(n). A linked list only needs to relink pointers for insert/delete — O(1) once you hold the pointer to the position — but accessing the k-th element must traverse from the head, so O(n).

The stack allocates by function call frame: entering a function pushes a frame, returning reclaims it automatically, and the cost is just moving a pointer. The heap allocates scattered blocks whose lifetime is decided by the programmer or the garbage collector, is slower, and can fragment. Local variables usually live on the stack; data that outlives the call lives on the heap.

A process owns its own address space and is isolated from others by the OS. A thread is a scheduling unit inside a process: threads share the heap, code, and file descriptors, with only their own stack and registers. Consequence: threads exchange data directly but need synchronization, while processes must go through IPC, but a fault in one process doesn't corrupt another.

When latency matters more than absolute integrity. TCP guarantees reliability and ordering by retransmitting lost packets, but that means one lost packet blocks the entire stream behind it. For voice, live video or games, data that arrives late has lost its value, so skipping a lost frame is better than waiting for it.

Because encryption is reversible. Anyone who gets the key — an attacker or an internal employee — can recover every password in plaintext. Hashing is one-way: the system only needs to hash what the user types and compare, never knowing the original value. You must use a password-specific hash function (bcrypt, scrypt, Argon2) with salt.

DNS resolution. Networks route by IP address, not by domain name, so the browser must ask a resolver to turn the domain into an IP first. Only then do the TCP handshake, TLS handshake, and the HTTP request follow.

Faster reads, slower writes, more storage. An index is a pre-sorted structure (usually a B-tree) that lets a query find rows without scanning the whole table. In exchange, every insert, update, or delete has to update both the table and every related index, and indexes take up extra disk and cache.

A class should have only one reason to change. Robert C. Martin later phrased it more precisely: a module should be responsible to only one group of users or one stakeholder. This is not the "a class does only one thing" rule in the sense of counting methods.

A stub returns canned answers so the test can run — it serves as input. A mock does more than answer: it records how it was called, and the test asserts on those interactions. In short: stubs verify state, mocks verify behavior.

DELETE /users/42. The core REST principle is that the path describes resources with nouns (usually plural), while the action is expressed by the HTTP method. Putting verbs in the path turns the API into a REST-flavoured RPC and loses the method's semantic guarantees.

To represent binary data using text characters, for channels that can only carry text such as email, JSON, or URLs. Base64 is not encryption: there is no key, anyone can decode it, and it also inflates the data by about 33%.

O(n²). The outer loop runs n times, each time performing all n steps of the inner loop, so the total number of operations is n × n. If the two loops are placed sequentially instead of nested, the cost is only n + n, i.e. O(n).

A stack is LIFO — the last element in is the first out, with operations at the same end. A queue is FIFO — first in first out, added at one end and removed at the other. Both have O(1) push and pop; the difference is in the removal order, not the cost.

A synchronous function blocks the calling thread until there's a result. An asynchronous function immediately returns an object representing the future result (promise, future, task), the calling thread continues, and the actual value is delivered once the task finishes. Asynchrony doesn't make the task faster, it just avoids wasting time waiting.