$limit and $skip stages in MongoDB - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ query_result

intermediate

What is the output of this aggregation pipeline?

Given a collection products with documents:

{ "name": "Pen", "price": 5 }

{ "name": "Pencil", "price": 2 }

{ "name": "Eraser", "price": 1 }

{ "name": "Notebook", "price": 10 }

What will be the result of this pipeline?

[{ $skip: 1 }, { $limit: 2 }]

MongoDB

db.products.aggregate([{ $skip: 1 }, { $limit: 2 }])

A [{ "name": "Pencil", "price": 2 }, { "name": "Eraser", "price": 1 }]

B [{ "name": "Eraser", "price": 1 }, { "name": "Notebook", "price": 10 }]

C [{ "name": "Notebook", "price": 10 }]

D [{ "name": "Pen", "price": 5 }, { "name": "Pencil", "price": 2 }]

💡 Hint

Remember, $skip removes the first N documents, then $limit picks the next M documents.

The pipeline skips the first document (Pen), then limits the output to the next two documents (Pencil and Eraser).

🧠 Conceptual

intermediate

How do $limit and $skip affect the order of documents?

Consider a collection users with documents ordered by age ascending. If you apply [{ $skip: 3 }, { $limit: 2 }] without a $sort stage, what will be the output order?

A The documents will be sorted by age ascending automatically before skipping and limiting.

B The documents will be in the original collection order, skipping first 3 and returning next 2.

C The documents will be sorted by age descending automatically before skipping and limiting.

D The output will be empty because $sort is missing.

💡 Hint

Think about whether $skip and $limit change order by themselves.

$skip and $limit do not reorder documents. They only skip and limit documents in the current order.

📝 Syntax

advanced

Which pipeline is syntactically correct to skip 5 documents and then limit to 10?

Choose the correct MongoDB aggregation pipeline syntax:

A [{ skip: 5 }, { limit: 10 }]

B [{ $skip: '5' }, { $limit: '10' }]

C [{ $limit: 10 }, { $skip: 5 }]

D [{ $skip: 5 }, { $limit: 10 }]

💡 Hint

Check the stage operator names and value types.

The correct operators are $skip and $limit with numeric values. Order matters for expected results but syntax only requires valid operators.

❓ optimization

advanced

Which pipeline is more efficient to get the 10th to 20th documents sorted by date?

You want documents 10 to 20 sorted by date ascending. Which pipeline is better?

A [{ $sort: { date: 1 } }, { $skip: 9 }, { $limit: 11 }]

B [{ $skip: 9 }, { $limit: 11 }, { $sort: { date: 1 } }]

C [{ $limit: 20 }, { $skip: 9 }, { $sort: { date: 1 } }]

D [{ $sort: { date: 1 } }, { $limit: 11 }, { $skip: 9 }]

💡 Hint

Think about when sorting happens and how $skip and $limit reduce data.

Sorting first then skipping and limiting is efficient. Sorting after skipping/limiting can produce wrong results or be inefficient.

🔧 Debug

expert

Why does this pipeline return fewer documents than expected?

Pipeline:

[{ $limit: 5 }, { $skip: 3 }]

Expected 2 documents but got 0. Why?

A The pipeline returns 0 because $skip after $limit skips documents from an empty set.

B $skip runs first but is ignored because $limit is before it.

C $limit runs first and returns only 5 documents, then $skip removes 3 from those 5, leaving 2 documents.

D The pipeline returns 0 because $skip after $limit skips 3 documents from the 5 limited, but $skip cannot be after $limit.

💡 Hint

Remember the order stages run in the pipeline.

Stages run in order. $limit first returns 5 documents, then $skip removes 3 from those 5, leaving 2 documents output.

Practice

1. What does the $limit stage do in a MongoDB aggregation pipeline?

easy

A. It skips a number of documents before returning results.

B. It groups documents by a specified field.

C. It sorts the documents in ascending order.

D. It restricts the number of documents returned.

Solution

1. Step 1: Understand the purpose of $limit

   The $limit stage restricts the number of documents that pass through the pipeline to a specified count.

2. Step 2: Compare with other stages

   $skip skips documents, $sort orders them, and $group groups them. Only $limit restricts count.

3. Final Answer:

   It restricts the number of documents returned. -> Option D

4. Quick Check:

   $limit = restrict count [OK]

Hint: Remember: limit = how many results you get [OK]

Common Mistakes:

• Confusing $limit with $skip
• Thinking $limit sorts data
• Mixing $limit with $group

2. Which of the following is the correct syntax to skip 5 documents and then limit the result to 10 documents in a MongoDB aggregation pipeline?

easy

A. [{ $skip: 5 }, { $limit: 10 }]

B. [{ $limit: 10 }, { $skip: 5 }]

C. [{ $skip: 10 }, { $limit: 5 }]

D. [{ $limit: 5 }, { $skip: 10 }]

Solution

1. Step 1: Identify correct order of stages

   To skip first, use $skip then limit results with $limit.

2. Step 2: Match syntax with values

   Skipping 5 then limiting to 10 matches [{ $skip: 5 }, { $limit: 10 }].

3. Final Answer:

   [{ $skip: 5 }, { $limit: 10 }] -> Option A

4. Quick Check:

   Skip first, then limit [OK]

Hint: Skip first, then limit for paging [OK]

Common Mistakes:

• Reversing $limit and $skip order
• Using wrong numbers for skip and limit
• Confusing syntax with find() options

3. Given a collection with documents numbered 1 to 10, what will be the output of this aggregation pipeline?

[{ $skip: 3 }, { $limit: 4 }]

medium

A. [1, 2, 3, 4]

B. [4, 5, 6, 7]

C. [3, 4, 5, 6]

D. [5, 6, 7, 8]

Solution

1. Step 1: Apply $skip: 3 on documents 1 to 10

   Skipping 3 documents removes 1, 2, 3; remaining are 4 to 10.

2. Step 2: Apply $limit: 4 on remaining documents

   Limit to 4 documents returns 4, 5, 6, 7.

3. Final Answer:

   [4, 5, 6, 7] -> Option B

4. Quick Check:

   Skip 3, then take 4 [OK]

Hint: Skip removes first N, limit picks next M [OK]

Common Mistakes:

• Counting skip as inclusive
• Mixing skip and limit values
• Assuming skip resets numbering

4. You wrote this aggregation pipeline but it returns only 2 documents instead of skipping the first 3 from the full collection and limiting to 5:

[{ $limit: 5 }, { $skip: 3 }]

What is the problem?

medium

A. You need to use find() instead of aggregation for skip and limit.

B. The syntax is invalid; $skip cannot be used in aggregation.

C. $skip must come before $limit to work correctly.

D. The pipeline is missing a $match stage before $limit.

Solution

1. Step 1: Understand stage order effect

   $limit first restricts to 5 documents, then $skip tries to skip 3 from those 5.

2. Step 2: Why it returns only 2 documents

   Because $skip after $limit skips from a smaller set (first 5), not the full collection.

3. Final Answer:

   $skip must come before $limit to work correctly. -> Option C

4. Quick Check:

   Skip first, then limit [OK]

Hint: Order matters: skip before limit [OK]

Common Mistakes:

• Placing $limit before $skip
• Thinking $skip is invalid in aggregation
• Confusing aggregation with find()

5. You want to implement pagination on a collection with 100 documents, showing 10 documents per page. Which aggregation pipeline correctly gets the 3rd page of results?

hard

A. [{ $skip: 20 }, { $limit: 10 }]

B. [{ $skip: 30 }, { $limit: 10 }]

C. [{ $limit: 10 }, { $skip: 20 }]

D. [{ $limit: 30 }, { $skip: 10 }]

Solution

1. Step 1: Calculate skip value for page 3

   Each page shows 10 documents, so page 3 skips 2 pages x 10 = 20 documents.

2. Step 2: Apply skip and limit in correct order

   Skip 20 documents, then limit to 10 documents to get page 3 results.

3. Final Answer:

   [{ $skip: 20 }, { $limit: 10 }] -> Option A

4. Quick Check:

   Skip (page-1)*size, then limit size [OK]

Hint: Skip (page-1)*size, then limit size [OK]

Common Mistakes:

• Using wrong skip calculation
• Reversing skip and limit order
• Confusing page number with skip count