Array expressions ($size, $arrayElemAt, $filter) in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to get the size of the array field 'scores'.

MongoDB

{ $size: "$ [1] " }

Drag options to blanks, or click blank then click option'

Avalues

Bscore

Cscores

Ditems

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong field name like 'score' instead of 'scores'.

Forgetting to use quotes around the field name.

The $size operator returns the number of elements in the array. Here, the array field is named scores.

2fill in blank

medium

Complete the code to get the first element of the 'grades' array using $arrayElemAt.

MongoDB

{ $arrayElemAt: [ "$grades", [1] ] }

Drag options to blanks, or click blank then click option'

A1

B0

C-1

D2

Attempts:

3 left

💡 Hint

Common Mistakes

Using 1 as the index which returns the second element.

Using negative indexes which are not supported here.

The $arrayElemAt operator uses zero-based indexing. To get the first element, use index 0.

3fill in blank

hard

Fix the error in the $filter expression to select elements greater than 10 from 'values'.

MongoDB

{ $filter: { input: "$values", as: "item", cond: { $gt: [ "$$ [1] ", 10 ] } } }

Drag options to blanks, or click blank then click option'

Avalue

Belement

Cval

Ditem

Attempts:

3 left

💡 Hint

Common Mistakes

Using a different variable name than declared in 'as'.

Forgetting the double dollar signs ($$) before the variable.

The variable name used in as is item. To refer to it inside cond, use $$item.

4fill in blank

hard

Fill both blanks to filter 'scores' array for values less than 50 and get its size.

MongoDB

{ $size: { $filter: { input: "$scores", as: "score", cond: { $lt: [ "$$ [1] ", [2] ] } } } }

Drag options to blanks, or click blank then click option'

Ascore

Bvalue

C50

D100

Attempts:

3 left

💡 Hint

Common Mistakes

Using a wrong variable name in the condition.

Using a wrong number for comparison.

The variable name is score as declared in as. The condition checks if score is less than 50.

5fill in blank

hard

Fill all three blanks to get the second element of filtered 'items' array where elements are greater than 5.

MongoDB

{ $arrayElemAt: [ { $filter: { input: "$items", as: "elem", cond: { $gt: [ "$$ [1] ", [2] ] } } }, [3] ] }

Drag options to blanks, or click blank then click option'

Aelem

B5

C1

D0

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong variable name in condition.

Using wrong comparison number.

Using wrong index for the second element.

The variable name is elem. The condition filters elements greater than 5. The second element has index 1.

Practice

1. What does the MongoDB expression $size do when used on an array field?

easy

A. Counts how many elements are in the array

B. Returns the first element of the array

C. Filters elements based on a condition

D. Sorts the array elements

Solution

1. Step 1: Understand the purpose of $size

   The $size operator counts the number of elements inside an array.

2. Step 2: Compare with other operators

   $arrayElemAt picks an element by position, $filter selects elements by condition, and sorting is unrelated.

3. Final Answer:

   Counts how many elements are in the array -> Option A

4. Quick Check:

   $size = count elements [OK]

Hint: Remember $size counts array length, not elements themselves [OK]

Common Mistakes:

• Confusing $size with $arrayElemAt
• Thinking $size filters elements
• Assuming $size sorts arrays

2. Which of the following is the correct syntax to get the third element of an array field named items using MongoDB aggregation?

easy

A. { $arrayElemAt: ["items", 3] }

B. { $size: ["$items", 2] }

C. { $arrayElemAt: ["$items", 2] }

D. { $filter: { input: "$items", as: "item", cond: { $eq: ["$$item", 2] } } }

Solution

1. Step 1: Recall zero-based indexing in $arrayElemAt

   The third element is at index 2 because counting starts at 0.

2. Step 2: Check syntax correctness

   The correct syntax uses $arrayElemAt with the array field prefixed by $ and the zero-based index.

3. Final Answer:

   { $arrayElemAt: ["$items", 2] } -> Option C

4. Quick Check:

   Third element index = 2 [OK]

Hint: Remember arrays start at 0, so third element is index 2 [OK]

Common Mistakes:

• Using 1-based index instead of 0-based
• Missing $ before field name
• Confusing $size with $arrayElemAt

3. Given the document { scores: [10, 20, 30, 40] }, what will the aggregation expression { $size: "$scores" } return?

medium

A. 4

B. 30

C. [10, 20, 30, 40]

D. Error

Solution

1. Step 1: Understand what $size does

   $size counts the number of elements in the array.

2. Step 2: Count elements in the array

   The array [10, 20, 30, 40] has 4 elements.

3. Final Answer:

   4 -> Option A

4. Quick Check:

   Array length = 4 [OK]

Hint: Count elements inside brackets for $size result [OK]

Common Mistakes:

• Returning the third element instead of count
• Returning the whole array instead of count
• Assuming syntax error

4. Identify the error in this MongoDB aggregation expression: { $arrayElemAt: ["$values", "1"] }

medium

A. Field name missing $ prefix

B. Index must be a number, not a string

C. Array must be inside an object

D. No error, expression is correct

Solution

1. Step 1: Check the type of index in $arrayElemAt

   The index must be a number, but here it is a string "1".

2. Step 2: Confirm correct field referencing

   The field name "$values" is correctly prefixed with $.

3. Final Answer:

   Index must be a number, not a string -> Option B

4. Quick Check:

   Index type = number, not string [OK]

Hint: Use number type for index in $arrayElemAt [OK]

Common Mistakes:

• Using string instead of number for index
• Omitting $ before field name
• Thinking array must be wrapped differently

5. You have documents with a field tags as an array of strings. How would you write a MongoDB aggregation expression to get the count of tags that start with the letter 'a'?

hard

A. { $size: "$tags" }

B. { $arrayElemAt: ["$tags", 0] }

C. { $filter: { input: "$tags", as: "tag", cond: { $eq: ["$$tag", "a"] } } }

D. { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } }

Solution

1. Step 1: Use $filter to select tags starting with 'a'

   The $filter operator creates a new array with tags matching the regex /^a/.

2. Step 2: Use $size to count filtered tags

   $size counts how many tags matched the condition.

3. Final Answer:

   { $size: { $filter: { input: "$tags", as: "tag", cond: { $regexMatch: { input: "$$tag", regex: /^a/ } } } } } -> Option D

4. Quick Check:

   Filter then count = correct approach [OK]

Hint: Filter first, then count with $size for conditional counts [OK]

Common Mistakes:

• Using $arrayElemAt instead of $filter
• Filtering with exact match instead of regex
• Counting whole array without filtering