Unlock hundreds more features
Save your Quiz to the Dashboard
View and Export Results
Use AI to Create Quizzes and Analyse Results

OR
Sign inSign in with Facebook
Sign inSign in with Google
Quizzes > Quizzes for Business > Technology

Take the Programming Aptitude Quiz Now

Sharpen Your Coding Logic with Questions

Difficulty: Moderate
Questions: 20
Learning OutcomesStudy Material
Colorful paper art depicting elements related to a Programming Aptitude Quiz

This Programming Aptitude Quiz helps you practice coding logic and algorithmic thinking with 15 multiple-choice questions. Work through quick questions on control flow, data types, and basic data structures, then see where you can improve before an exam or interview. For more practice, try the fundamentals quiz or the skills assessment .

Which data structure follows Last-In, First-Out (LIFO) principle?
LinkedList
Stack
Queue
Array
A stack follows LIFO, meaning the last element pushed is the first to be popped. Arrays, queues, and linked lists do not inherently enforce LIFO behavior like a stack.
What is the result of the expression 5 + 3 * 2 in most programming languages?
11
16
10
13
Due to operator precedence, multiplication is performed before addition, so 3 * 2 = 6 and then 5 + 6 = 11.
What is the time complexity of accessing an element in an array by its index?
O(log n)
O(n)
O(1)
O(n log n)
Arrays allow constant-time access to any index since the address can be computed directly. Other options involve iterative or logarithmic time.
Which control flow statement is best for choosing between multiple discrete cases based on the value of a single variable?
for loop
while loop
if-else
switch-case
Switch-case evaluates one variable against multiple possible values and jumps to the matching case efficiently. If-else can do similar but is less concise for many cases.
Which data structure follows First-In, First-Out (FIFO) principle?
Queue
Graph
Tree
Stack
A queue follows FIFO, meaning the first element enqueued is the first to be dequeued. Stacks, trees, and graphs do not inherently enforce FIFO behavior.
What is the time complexity of binary search on a sorted array of size n?
O(n)
O(1)
O(log n)
O(n log n)
Binary search halves the search interval on each comparison, yielding a logarithmic time complexity. This is much more efficient than linear scanning in large arrays.
What is the output of this pseudocode? function factorial(n): if n == 0 then return 1 else return n * factorial(n - 1) end print(factorial(4))
10
8
24
18
The recursive call multiplies 4 * 3 * 2 * 1 and returns 24. This follows the definition of factorial where 4! = 24.
Which of the following best describes an off-by-one error in loops?
Missing a break statement
Skipping the first iteration only
Accessing an array with incorrect type
Iterating one too many or one too few times
An off-by-one error occurs when loop boundaries are set incorrectly, causing the loop to execute one extra or one fewer time than intended. This often leads to incorrect results or index out-of-bounds errors.
Which sorting algorithm is most efficient for nearly sorted datasets?
Merge sort
Insertion sort
Quick sort
Bubble sort
Insertion sort performs very efficiently on datasets that are mostly sorted, as it only shifts a few elements per iteration. Other sorts like merge sort or quick sort have higher baseline overhead for small adjustments.
Which data structure allows insertion and deletion at both ends with O(1) complexity?
Array
Deque
Stack
Queue
A double-ended queue (deque) supports adding or removing elements from both front and back in constant time. Stacks and queues only support one end, and arrays may require shifting.
What is the time complexity of the naive recursive Fibonacci implementation?
O(2^n)
O(n²)
O(n)
O(log n)
The naive Fibonacci recursion makes two calls per invocation, leading to an exponential number of calls. This yields roughly O(2^n) time complexity.
Which of the following is a common hash table collision resolution technique?
Separate chaining
Graph traversal
Linear regression
Dynamic programming
Separate chaining handles collisions by storing multiple elements in the same bucket using a linked list or similar structure. The other options do not correctly describe a collision resolution technique.
What is the time complexity of the following pseudocode? for i from 1 to n do for j from 1 to n do perform O(1) operation end end
O(n log n)
O(n)
O(n²)
O(n³)
The code performs n iterations for i and, within each, n iterations for j, resulting in n * n = n² operations.
Which algorithm design strategy divides a problem into smaller subproblems, solves them independently, and combines their results?
Dynamic programming
Divide and conquer
Greedy algorithms
Backtracking
Divide and conquer breaks a problem into non-overlapping subproblems, solves each recursively, and merges their solutions. This differs from dynamic programming which stores overlapping subproblem results.
Which programming technique reduces redundant recursive calls by storing and reusing previously computed results?
Iterative refinement
Lazy evaluation
Memoization
Backtracking
Memoization caches the results of expensive function calls and returns the cached result when the same inputs occur again. This optimizes recursive algorithms by avoiding duplicate computations.
Which sorting algorithm guarantees O(n log n) worst-case time complexity?
Quick sort
Merge sort
Selection sort
Bubble sort
Merge sort consistently divides the list and merges sorted halves, ensuring n log n time in all cases. Quick sort has a worst-case of O(n²), and bubble and selection sorts are O(n²) at best.
Which problem is a classic example that is optimally solved using dynamic programming due to its overlapping subproblems and optimal substructure?
Tree traversal
Binary search
Linear search
0-1 knapsack
The 0-1 knapsack problem has both overlapping subproblems and an optimal substructure, making it ideal for a dynamic programming solution. Binary and linear searches or tree traversals do not require this technique.
Which data structure is most suitable for implementing a priority queue with O(log n) insertion and removal operations?
Array
Binary heap
Hash table
Linked list
A binary heap allows both insertion and removal of the highest (or lowest) priority element in logarithmic time by maintaining the heap property. Other structures either have linear time removals or lack efficient priority operations.
What is the time complexity of the following pseudocode? count = 0; for i from 1 to n do for j from 1 to i do for k from 1 to j do count = count + 1 end end end
O(n²)
O(n³)
O(n log n)
O(n❴)
The nested loops execute a total of roughly n³/6 iterations, which simplifies to O(n³). The decreasing inner bounds reduce the constant factor but not the cubic order.
What is the average-case time complexity of the Quickselect algorithm for finding the k-th smallest element?
O(n)
O(log n)
O(n²)
O(n log n)
Quickselect partitions the array around a pivot and recursively selects on one side, leading to linear average time. Worst-case can degrade to O(n²), but that is not average-case.
0
{"name":"Which data structure follows Last-In, First-Out (LIFO) principle?", "url":"https://www.quiz-maker.com/QPREVIEW","txt":"Which data structure follows Last-In, First-Out (LIFO) principle?, What is the result of the expression 5 + 3 * 2 in most programming languages?, What is the time complexity of accessing an element in an array by its index?","img":"https://www.quiz-maker.com/3012/images/ogquiz.png"}

Learning Outcomes

  1. Analyse algorithmic scenarios to determine optimal solutions.
  2. Evaluate code snippets for logical correctness and efficiency.
  3. Identify common programming patterns and potential pitfalls.
  4. Apply problem-solving strategies in coding challenges.
  5. Demonstrate understanding of data structures and control flow.
  6. Master basic computational thinking and logic skills.

Cheat Sheet

  1. Modularizing Your Code - Breaking your program into small, focused modules helps you avoid "spaghetti code" and makes your work feel more like a neat stack of LEGO bricks than a tangled ball of yarn. Each module can be tested and fixed independently, so you spend more time coding fun features and less time chasing mysterious bugs.
  2. Dodging the God Object - If you catch a single class handling every task under the sun, you've probably summoned the dreaded God Object anti-pattern. Applying the Single Responsibility Principle keeps each class laser-focused on one job, making your code more cooperative and way easier to debug.
  3. Don't Swing the Golden Hammer - Just because you've mastered a particular tool or pattern doesn't mean it's the answer for every problem in town. Before you reach for the same solution again, take a moment to weigh the pros and cons - your code and your future self will thank you!
  4. Beware of Overengineering - Design patterns can be magical, but sprinkling too many of them everywhere can turn your project into a complexity carnival. Use patterns judiciously and only when they truly simplify your work - not just to flex your programming muscles.
  5. Singleton Pitfalls - The Singleton pattern can feel like a quick fix for shared resources, but overusing it creates tight coupling and test headaches. Consider dependency injection or other alternatives to keep your code flexible and your tests happy.
  6. The Magic Number Trap - Hard-coded numbers sprinkled throughout your code are like secret handshakes nobody remembers - confusing and hard to change. Defining named constants makes your intentions crystal-clear and saves you from detective work later.
  7. Copy-Paste Code Chaos - Seeing the same block of code in multiple places is a red flag for maintenance nightmares. Refactor repeated logic into reusable functions or classes and watch your codebase shrink in size and bloat in elegance.
  8. Premature Optimization Peril - Tweaking performance before you even need to can turn simple code into a cryptic puzzle. Prioritize clean, readable code first, then optimize critical sections once you've measured real bottlenecks.
  9. Cleaning Up Lava Flow - Old, unused code that lingers like cooled lava clogs your project and confuses new contributors. Regularly sweep through your codebase, remove the dead weight, and keep everything running smoothly.
  10. Heaving the Boat Anchor - Holding onto code "just in case" is like chaining a boat anchor to your project - it drags you down with technical debt. If it's not solved now, it's not needed now: toss it and sail ahead faster!
Make a Quiz (FREE) Copy & Edit This Quiz Create a Quiz with AI

Technology Quizzes

Powered by: Quiz Maker