Free App Development with Swift Certified User Exam Practice Questions

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

The function is defined as:

func schedule(who name: String, from starting: String, to ending: String, _ place: String = " Zoom " ) {

print( " Appointment: meeting \(name) from \(starting) to \(ending) at \(place) " )

}

This means:

the external parameter names are who, from, and to

the internal parameter names are name, starting, and ending

the last parameter uses _, which means it has no external label

the last parameter also has a default value of " Zoom "

Now evaluate the options:

A is incorrect because it uses place: as an external label, but _ place means no external label is allowed.

B is correct because it uses the required external names who, from, and to, and it omits the last parameter, which is allowed because it has a default value.

C is incorrect because it uses who:, from:, and to: correctly, but this function’s first three parameters are not declared that way in the provided option set; the valid matching call style from the choices is not this one because the function’s labels are paired with internal names in the declaration syntax shown in the question.

D is incorrect because it uses the internal names name, starting, and ending as if they were external labels.

E is correct because it uses the external labels who, from, and to, and omits the final unlabeled parameter, letting Swift use the default " Zoom " .

So the two correct answers are B and E .

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question falls under Swift Programming Language , specifically the domain for managing data using collection types , with emphasis on dictionaries . In Swift, a dictionary stores data as key-value pairs , so in this example the country name is the key and the capital city is the value. To add a new entry, Swift supports two standard approaches. The first is subscript assignment , which is shown in option C : capitalCities[ " Italy " ] = " Rome " . Apple’s documentation explains that you can add a key-value pair to a dictionary by assigning a value for a new key through the dictionary subscript.

The second correct approach is option E : capitalCities.updateValue( " Rome " , forKey: " Italy " ). Apple documents that updateValue(_:forKey:) updates the value for an existing key, or adds a new key-value pair if the key does not already exist . That makes it equally valid for inserting " Italy " : " Rome " into the dictionary.

The incorrect options fail for different reasons. A reverses the key and value, making " Rome " the key and " Italy " the value. B is wrong because append is used with arrays, not dictionaries. D is not the standard valid insertion syntax for Swift dictionaries in this context; Swift’s documented mutation approaches here are subscript assignment and updateValue. Therefore, the two correct answers are C and E .

This question falls under View Building with SwiftUI , specifically the domain covering multi-view apps with navigation stacks, links, and sheets . The first blank must be NavigationLink because SwiftUI uses a navigation link inside a NavigationStack to push or present a destination view as part of the navigation hierarchy. Apple’s documentation states that people tap or click a NavigationLink to present a view inside a NavigationStack or NavigationSplitView. That matches the first code section, where tapping " Show Blue View " should navigate to BlueView().

The second blank must be .sheet because the code uses isPresented: $showRedView, which is the standard SwiftUI sheet modifier for modal presentation controlled by a Boolean binding. Apple documents sheet(isPresented:onDismiss:content:) as the modifier to use when you want to present a modal view when a Boolean becomes true. Since the button toggles showRedView, SwiftUI presents RedView() modally as a sheet.

So the completed structure is effectively:

NavigationLink( " Show Blue View " ) {

BlueView()

}

sheet(isPresented: $showRedView) {

RedView()

}

This directly aligns with SwiftUI navigation and modal presentation patterns in the App Development with Swift objective domains.

This question belongs to View Building with SwiftUI , particularly the domain involving positioning and/or laying out a single SwiftUI view with standard views and modifiers . To place text on top of a shape such as a Capsule, SwiftUI uses the overlay modifier. Apple documents overlay as a view modifier that layers one view in front of another, which is exactly what is needed here: the text should appear on top of the blue capsule rather than beside or below it. The second blank must therefore be Text , because SwiftUI uses a Text view to display string content like " Great! " .

The completed code is:

struct ContentView: View {

var body: some View {

Capsule()

.fill(.blue)

.frame(width: 200.0, height: 100.0)

.overlay(

Text( " Great! " )

.font(.largeTitle)

)

}

}

This works because Capsule() creates the shape, .fill(.blue) gives it the blue color, .frame(width:height:) sets its size, and .overlay(...) places the Text( " Great! " ) directly above that shape. This is a standard SwiftUI composition pattern: build a base view, then apply modifiers to style it and layer additional content. In App Development with Swift objectives, this aligns with understanding standard views, modifiers, and layout techniques in SwiftUI.

This question belongs to Swift Programming Language , especially the domains covering basic Swift types , operators , and constants versus variables .

There are two compile problems in the snippet. First, unitPrice and shipping are inferred as Double, while quantity is inferred as Int. In Swift, arithmetic operands must have compatible types; Swift does not automatically mix Int and Double in one arithmetic expression. So unitPrice * quantity fails unless quantity is changed to Double or explicitly converted. That makes A a correct fix.

Second, the line totalCost += ... uses the compound assignment operator +=, which stores a new value back into the left-hand side. Swift requires the left-hand side of += to be mutable, so totalCost must be declared with var, not let. That makes D the second correct fix.

The other choices do not solve the actual compile issues. B is unnecessary because totalCost is already explicitly declared as Double, so 0 is valid there. C would still leave shipping as Double, so the mixed-type arithmetic problem remains. E is irrelevant because shipping is never reassigned. Therefore, the two correct answers are A and D

This question belongs to View Building with SwiftUI , especially the domain covering positioning and/or layout a single SwiftUI View with standard Views and modifiers and the foundational structure of a SwiftUI view. In SwiftUI, a custom screen is typically declared as a struct that conforms to the View protocol. Apple’s SwiftUI documentation shows the standard pattern:

struct ScreenView: View {

var body: some View {

Text( " Hello " )

}

}

Here, struct is required because SwiftUI views are commonly defined as structures. View is required after the colon because the type must conform to the View protocol. body is the required computed property that returns the content of the view as some View. Apple documents that every conforming View type must provide a body property that describes its content.

So the completed code is:

import SwiftUI

struct ScreenView: View {

var body: some View {

Text( " Hello " )

}

}

This is the canonical SwiftUI view declaration pattern and is one of the most fundamental concepts in App Development with Swift.

This question belongs to Swift Programming Language , specifically the objectives covering functions , control flow , and default parameter values . The function is declared as func getAgeCategory(_ age: Int = 20) - > Int, which means if no argument is supplied, Swift uses the default value 20. Apple’s Swift documentation explains that you can define a default value for any parameter, and that value is used when the caller omits that argument. Since the code calls getAgeCategory() with no parameter, the function executes using age = 20.

The conditional logic is then evaluated in order:

if age > 64 → false, because 20 is not greater than 64

else if age > 19 → true, because 20 is greater than 19

so the function returns 2

Because Swift’s if / else if control flow stops at the first true condition, the later checks are never reached once age > 19 succeeds. Apple describes Swift as supporting standard control flow including conditional branching, and this example is a direct use of that branching behavior.

Therefore, print(getAgeCategory()) outputs 2 , which corresponds to option B .