Pass the Apple Apple App Development with Swift App-Development-with-Swift-Certified-User Questions and answers with CertsForce

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 , specifically stacking views and applying modifiers. A ZStack layers views from back to front, so the first item becomes the background and later items appear on top. To match the screenshot, the black background must be the back layer, so Color.black goes first. The large white circle sits above that, so Circle() followed by .foregroundStyle(.white) comes next. Finally, the red heart image sits on top of the circle, so Image(systemName: " heart " ).resizable() followed by .foregroundStyle(.red).frame(width: 200, height: 200) must be last. SwiftUI’s Image.resizable() allows the symbol image to scale to the frame you apply, and foregroundStyle sets the visible color styling for the shape and symbol.

So the intended structure is:

ZStack {

Color.black

Circle()

.foregroundStyle(.white)

Image(systemName: " heart " ).resizable()

.foregroundStyle(.red)

.frame(width: 200, height: 200)

}

This produces a black background, a white circular shape, and a centered red heart on top, exactly as shown.

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.

C:\Users\Waqas Shahid\Desktop\Mudassir\Untitled.jpg

This question belongs to View Building with SwiftUI , especially the objectives for using List views to iterate through collections and structuring views with standard SwiftUI containers. The screenshot shows two grouped sets of rows: one headed MY FRIENDS and one headed MY PETS . In SwiftUI, the correct container for a scrollable table-style presentation of rows is List, and the correct way to divide that list into labeled groups is Section. Apple documents List as a container that presents data in a single-column row-based layout, and Section as a way to organize list content into grouped areas with headers and optional footers. That is exactly the structure shown in the image. ( developer.apple.com , developer.apple.com )

The ForEach(names, id: \.self) and ForEach(pets, id: \.self) lines are already iterating through the arrays, so each ForEach should be wrapped inside a Section. The section labels such as " My Friends " and " My Pets " are provided with the header: label. So the intended code structure is:

List {

Section {

ForEach(names, id: \.self) { name in Text(name) }

} header: {

Text( " My Friends " )

}

Section {

ForEach(pets, id: \.self) { pet in Text(pet) }

} header: {

Text( " My Pets " )

}

}

This matches the UI shown in the image and aligns directly with SwiftUI list and section composition patterns in App Development with Swift.

This question belongs to Swift Programming Language , specifically the objective covering structs, properties, and initializers .

In the struct, both the property and the initializer parameter are named age:

struct person {

var age: Int

init(age: Int) {

self.age = age

}

}

Here, age inside the initializer could refer to either the property of the struct or the parameter passed into the initializer. Swift uses self.age to clearly mean the property that belongs to the current instance , while plain age refers to the initializer parameter . So self.age = age means: assign the parameter value to the instance property.

That is why C is correct. The keyword self is required here to remove ambiguity between two identifiers with the same name.

The other options are incorrect:

A is wrong because self here is not pointing to the parameter; it points to the instance property.

B is wrong because self is not always required in every initializer assignment. It is specifically needed here because of the naming conflict.

D is wrong because whether the property has a default value is not the reason self is needed in this example.

So the correct answer is C. self is needed to distinguish between the property and the parameter with the same name.

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 .

@AppStorage → This property wrapper reads and writes values from UserDefaults.

@Environment → This property wrapper allows you to access data from the system, such as knowing the size class of the device, or dismissing a view.

@Binding → When a variable is declared with this property wrapper, changes to its value will be returned to the calling view.

@State → When a variable is declared with this property wrapper, it is used to store small amounts of data local to the view whose value may affect the appearance of the view.

This question belongs to View Building with SwiftUI , specifically the objective about using @State, @Binding, @Environment, and related wrappers to share and manage data between views. @AppStorage is the wrapper that connects a SwiftUI value to UserDefaults, so it is the correct match for reading and writing persisted user defaults data. Apple documents AppStorage as a property wrapper type that reflects a value from UserDefaults and updates the view when that value changes.

@Environment is used to read values supplied by the system or ancestor views, including interface context like size classes and actions such as dismissing a presented view. Apple’s environment documentation explains that SwiftUI automatically sets and updates many environment values for layout and behavior, and App Dev Training materials show environment values being used to dismiss a view.

@Binding represents a two-way connection to a value owned elsewhere, typically in a parent view, so changes made through the binding are reflected back in the source of truth. Apple’s SwiftUI data-flow guidance describes bindings as the mechanism used when a child view needs shared control of state with another view.

@State is the correct wrapper for small, local, mutable view state. Apple describes State as the source of truth for data local to a view and recommends it for interface state that affects rendering.

This question belongs to Swift Programming Language , specifically the objectives covering arrays , loops , and range operators . The array has 6 elements, so menuItems.count is 6. The loop uses the half-open range operator:

for index in 1.. < (menuItems.count - 1)

That becomes:

for index in 1.. < 5

In Swift, the half-open range operator a.. < b includes the lower bound but does not include the upper bound. So this loop runs with index values 1, 2, 3, 4, not 0 and not 5.

Array subscripting uses those indexes to print:

menuItems[1] → " Burger "

menuItems[2] → " Chicken "

menuItems[3] → " Pasta "

menuItems[4] → " Salad "

That means " Pizza " at index 0 is skipped, and " Steak " at index 5 is also skipped. Swift arrays use zero-based indexing, and count returns the number of elements in the array.

Therefore, the program prints only " Burger " , " Chicken " , " Pasta " , and " Salad " , so the correct answer is A .

Comprehensive and Detailed Explanation From App Development with Swift domains:

This question belongs to View Building with SwiftUI , specifically the objective about using property wrappers such as @State, @Binding, and @Environment to manage and share data between views.

The correct answer is @Environment because it is used to read values provided by the system or the surrounding view environment. These values can include device-related or system-provided information such as size classes, color scheme, locale, and dismiss actions. In SwiftUI, @Environment gives a view access to contextual information that it does not own directly, but which is supplied by the framework or ancestor views.

The other options are not correct for this purpose:

@State is used for local mutable state owned by the current view.

@Binding is used to create a two-way connection to state owned elsewhere, usually in a parent view.

@StateObject is used to create and own an observable reference-type object for the lifetime of the view.

So if you want a SwiftUI view to read data coming from system or device settings, the correct property wrapper is @Environment .