Combined 3 Bank Assistant Programmer MCQ Test: 2018প্রশ্ন ও সমাধান

Correct answer: (b) more prone to deadlocks

A deadlock needs several agents that each hold a resource while waiting for one held by another, closing a cycle (mutual exclusion, hold-and-wait, no preemption, circular wait). A multi-threaded program creates exactly this setting: several threads run at once and acquire shared locks, often in different orders. If thread T1 holds lock A and waits for B while T2 holds B and waits for A, both stop forever. A single-threaded program has no second thread to complete such a cycle, so adding threads makes deadlock possible and more likely.

Why the other options are wrong

• (a) Less prone to deadlocks: more threads and more locks mean more chances of a circular wait, not fewer.
• (c) not at all prone to deadlock: the two-lock example above shows that multi-threaded code can deadlock.
• (d) always result in deadlocks: deadlock occurs only for certain lock orders and timings; well-designed code (for example, acquiring locks in one fixed global order) never deadlocks.

Exam note: Options (a) and (d) are repaired for grammar only ("Lesser" → "Less", "results" → "result").

Tip: Threads + shared locks ⇒ deadlock becomes possible; a fixed lock order breaks circular wait.

Sources: Deadlock — CS 3130, University of Virginia; Managed threading best practices — Microsoft Learn

Correct answer: (a) No proper subset is a super key

A super key is any set of attributes whose combined values never repeat across rows. A candidate key is a minimal super key: removing any attribute destroys uniqueness. Put another way, a super key K is a candidate key exactly when no proper subset of K is itself a super key.

Example: in course(crn, course_id, section, instructor), {course_id, section, instructor} is a super key but not a candidate key, because its proper subset {course_id, section} is still unique. {course_id, section} is a candidate key, because neither {course_id} nor {section} alone is unique.

Why the other options are wrong

• (b) All subsets are super keys: Single attributes such as {section} repeat, so they are not super keys. And if smaller subsets were super keys, the set would contain redundant attributes and would not be minimal.
• (c) Subset is a super key: If a proper subset is already a super key, the larger set has a redundant attribute, so it is not a candidate key. This is the opposite of the condition.
• (d) Each subset is a super key: Same idea as (b) in other words; it describes redundancy, not minimality.

Tip: Candidate key = super key + minimality (drop any attribute and uniqueness is lost).

Source: CSCI 403: Databases 2 - The Relational Model (Colorado School of Mines)

Correct answer: (d) all of the above

Iteration means executing a statement repeatedly while a condition holds. C has exactly three iteration (loop) statements, and every one of them is listed:

• for (init; condition; update): usually used when the number of passes is known; the condition is tested before each pass.
• while (condition): tests before each pass, so it may run zero times.
• do … while (condition);: tests after each pass, so it runs at least once.

Why the other options are wrong

• (a) for: A correct example of iteration, but choosing it alone leaves out while and do-while.
• (b) while: Also a loop statement, but not the only one offered.
• (c) do-while: Also a loop statement; picking it alone ignores the other two.

Because all three are iteration statements, the complete answer is (d).

Tip: C's loops are for, while and do-while; its selection statements are if, if-else and switch.

Source: Statements - cppreference.com

Correct answer: (d) Inorder sequence gives decreasing order of elements

The question asks for the FALSE statement. An inorder traversal (left subtree → node → right subtree) of a binary search tree visits the keys in increasing order, not decreasing. Example: inserting 50, 30, 70, 20, 40, 60, 80 and traversing inorder gives 20, 30, 40, 50, 60, 70, 80. (A reverse inorder, right → node → left, would give decreasing order.)

Why the other options are wrong

• (a) The left child is always less than its parent: true; every key in a node's left subtree is smaller than the node's key, so the left child certainly is.
• (b) The right child is always greater than its parent: true; every key in the right subtree is larger than the node's key.
• (c) The left and right subtrees should also be binary search trees: true; the BST property holds recursively at every node.

Tip: BST + inorder = sorted ascending; that is how tree sort works.

Source: CMSC 420 Lecture 4: Binary Search Trees (University of Maryland)

Correct answer: (d) When the list has only a few elements and when performing a single search in an unordered list

Linear (sequential) search checks the items one by one, so it needs no ordering and costs O(n) comparisons (about n/2 on average when the item is present). Faster methods such as binary search need a sorted list.

• If the list is small, n comparisons are already cheap, so extra machinery is not worth it.
• If you search an unordered list only once, sorting it first costs O(n log n), more than the single O(n) scan it would replace.

Both situations are valid, and option (d) states both.

Why the other options are wrong

• (a) When the list has only a few elements: true, but only half of the answer; (d) is more complete.
• (b) When performing a single search in an unordered list: also true, but incomplete for the same reason.
• (c) Used all the time: for large sorted lists or repeated searches, binary search (O(log n)) or hashing is far faster.

Tip: Small or unsorted data with few lookups → linear search; large sorted data with many lookups → binary search.

Source: linear search (NIST Dictionary of Algorithms and Data Structures); binary search (NIST Dictionary of Algorithms and Data Structures)