Apple App-Development-with-Swift-Certified-User Exam With Confidence Using Practice Dumps

This question belongs to Swift Programming Language , specifically the objective on variable scope and shadowing .

The code first declares:

let even = 2

This creates a constant named even in the outer scope with the value 2.

Inside the for loop, the code declares another constant with the same name:

let even = num * 2

This inner even exists only inside the loop body. It shadows the outer even, which means that within the loop, the name even refers to the loop’s local constant, not the original one. However, that inner constant goes out of scope at the end of each loop iteration.

After the loop finishes, the inner even no longer exists. So when the final line runs:

print(even)

Swift uses the original outer constant, which is still 2.

So the output is:

2

This question tests two important Swift concepts:

Scope : where a variable or constant can be accessed

Shadowing : when a local declaration temporarily hides another declaration with the same name

Therefore, the correct answer is 2 .

This question belongs to Swift Programming Language , specifically the domain on functions , including internal and external parameter names and default parameter values .

The function is defined as:

func rightSum(_ num1: Int, by num2: Int, and num3: Int = 25) - > Int {

return num1 + num2 + num3

}

This means:

the first parameter uses _, so it has no external label

the second parameter must use the external label by

the third parameter must use the external label and

the third parameter also has a default value of 25, so it may be omitted

Now evaluate each option:

A is invalid because it uses num2: instead of the required external label by:

B is valid because it correctly uses no label for the first argument, then by: and and:

C is invalid because the first parameter cannot be called with num1: since the external label is omitted with _

D is valid because it correctly passes the first argument unlabeled and the second with by:, while omitting the third argument so Swift uses the default value 25

E is invalid because it uses num1: and num2: instead of the required calling syntax

So the two correct function calls are B and D .

This question belongs to Swift Programming Language , especially the domains covering control flow , loops , logical operators , and guard . The loop runs through 0.. < max, and since max = 101, the values of num are 0 through 100. Inside the loop, the guard statement keeps only values that satisfy both conditions:

num % 5 == 0 → the number must be divisible by 5

num % 2 != 0 → the number must be odd

So the code counts numbers from 0 to 100 that are odd multiples of 5 . Those values are:

5, 15, 25, 35, 45, 55, 65, 75, 85, 95

That gives a total of 10 numbers. Therefore count becomes 10, and the printed output is:

Total count: 10

The key Swift concept here is that guard ... else { continue } skips any loop iteration that does not meet the required condition. Only matching values reach count += 1. This is a standard use of guard for early exit and of the remainder operator % for divisibility checks. Therefore, the correct answer is B .