Free and Premium Apple App-Development-with-Swift-Certified-User Dumps Questions Answers

This question belongs to Swift Programming Language , specifically the domains covering control flow , loops , and range operators .

The code starts with:

var count = 0

var answer = 0

So both variables begin with the value 0.

In the first loop:

for index in 1...5 {

count = index

}

the closed range 1...5 includes 1, 2, 3, 4, and 5 . During each iteration, count is updated to the current value of index. After the loop finishes, the final value assigned to count is 5 .

Then the second loop runs:

for index in 1.. < count {

answer = index

}

Here, the half-open range 1.. < count means values starting at 1 up to, but not including , count. Since count is 5, this loop runs with index equal to 1, 2, 3, and 4 . Each time through the loop, answer is updated to the current index. After the last iteration, answer becomes 4 .

So the final value of answer is 4 . This question tests understanding of the difference between the closed range operator ... and the half-open range operator .. < , which is a key Swift control-flow concept.

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 .

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 View Building with SwiftUI , especially the objective domain on using List views to iterate through collections and displaying model data in SwiftUI. In the code, animals is the data source passed into List(animals) { animal in ... }. That closure iterates through each element of the collection one at a time, and the parameter animal represents the current Animal instance for that row. To show the name of the current animal in the UI, the correct statement is Text(animal.name). SwiftUI’s list documentation explains that each row inside a List must be a SwiftUI View, and a Text view is a standard way to display a string value for each item in the collection.

Option D is therefore correct because it accesses the name property of the current animal object being processed by the List closure. This is the standard SwiftUI pattern when iterating over identifiable model objects: pass the collection into List, receive each item in the closure, and build a row view from that item’s properties. Apple’s SwiftUI tutorials repeatedly use this collection-driven row-building pattern for lists and navigation.

The other options are incorrect for clear reasons. A incorrectly refers to the type name Animal instead of the current instance. B uses Animals with the wrong identifier and an invalid indexing approach. C also treats animal as an index rather than the current element object. Since the closure already gives you the current Animal, you directly access its property with animal.name.

This question is from Swift Programming Language , especially the domains for Optional types , safe and unsafe unwrapping , and control flow . The code uses the ternary conditional operator :

nextApplePhone.releaseDate != nil ? _____

In Swift, the ternary operator follows this structure:

condition ? valueIfTrue : valueIfFalse

So if nextApplePhone.releaseDate != nil is true, the expression must return the new release date. If it is false, it must keep lastReleaseDate unchanged. That means the missing part must be:

nextApplePhone.releaseDate! : lastReleaseDate

which is option D .

This works because nextApplePhone.releaseDate is declared as String?, so it is an optional. Once the condition confirms it is not nil, the code force-unwraps it with ! to access the underlying String value. If the optional is nil, the expression returns lastReleaseDate instead. Apple’s Swift documentation describes the ternary conditional operator as a shortcut for choosing one of two expressions based on a condition, and it explains that force unwrapping with ! accesses an optional’s wrapped value when you know it is not nil.

The other options are incorrect because they reverse the true/false logic, omit the needed unwrap, or contain invalid identifiers. Therefore, the correct completion is D .

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 .

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 belongs to Swift Programming Language , specifically the domain covering structs, properties, methods, and initializers .

A computed property does not store a value directly. Instead, it returns a value calculated from other data. That is why description is a computed property: it returns a string based on content.

A memberwise initializer is automatically provided by Swift for structs when their stored properties are initialized through parameters. So Document(content: " Greetings! " ) is using the struct’s memberwise initializer.

A type property belongs to the type itself rather than to an instance. In Swift, static var docCount = 0 is a type property because it is declared with static.

An instance method is a function that belongs to an instance of the struct or class. The display() method uses the instance’s content, so it is an instance method.

A type method is a method declared with static and belongs to the type itself. So static func increment() is a type method because it changes the shared type property docCount.

This question belongs to View Building with SwiftUI , specifically the objective on positioning and laying out a single SwiftUI view with standard views and modifiers.

The correct answer is D because it uses the right combination of SwiftUI image modifiers for all three requirements:

the image is made resizable with .resizable()

it is given rounded corners with .clipShape(RoundedRectangle(cornerRadius: 50))

it displays the entire image with .aspectRatio(contentMode: .fit)

it is sized with .frame(width: 300)

The key part is .aspectRatio(contentMode: .fit) . In SwiftUI, .fit scales the image so the whole image remains visible inside the available frame. That matches the requirement “displays the entire image, regardless of size.” By contrast, .fill may crop part of the image, so options using .fill do not satisfy the requirement.

Why the others are wrong:

Option A uses .fill, so the full image may not remain visible.

Option B uses invalid modifiers such as .sizablc() and .size(width: 300), and also uses Rectangle(cornerRadius: 50), which is not the correct rounded-rectangle shape syntax.

Option C also uses invalid syntax and .fill, which can crop the image.

Option D uses valid SwiftUI syntax and the correct content mode.

So the correct choice is D , because it is the only option that correctly creates a 300-width image with rounded corners while ensuring the entire image is shown.

This question belongs to View Building with SwiftUI , specifically the domain on creating a multi-view app with navigation stacks, links, and sheets .

To present a modal view in SwiftUI when a Boolean state changes, the correct modifier is .sheet . The matching sheet API for a Boolean binding is:

sheet(isPresented: $showInfo) {

// modal content

}

So the first blank must be .sheet , and the second blank must be (isPresented: .

The logic works like this:

@State stores the local Boolean that controls presentation.

Pressing the button calls showInfo.toggle(), changing the value from false to true.

When that Boolean becomes true, the .sheet(isPresented:) modifier presents the modal view.

When the modal is dismissed, SwiftUI updates the Boolean back as needed.

There is also a typing issue in the screenshot: the state variable appears as ShowInfo, while the button and binding use showInfo. Swift is case-sensitive, so those names must match. The corrected code should use the same identifier consistently, such as:

@State var showInfo = false

Therefore, the correct dropdown selections are:

sheet

(isPresented:

This question belongs to View Building with SwiftUI , especially the domain on creating multiple views to implement app logic and sharing values between views. In FirstView, the value typed into the TextField is stored in number, which is a String. When the NavigationLink is tapped, the code passes Int(number) ?? 0 into SecondView. In Swift, converting a string to an integer with Int(...) uses an optional initializer, which means it returns an optional value and will produce nil if the string cannot be converted. The ?? 0 nil-coalescing operator then supplies 0 if conversion fails.

Inside SecondView, the body is:

Color(passedNumber == 3 ? .blue : .red)

This uses the ternary conditional operator. If passedNumber equals 3, the displayed color is blue; otherwise, it is red. Therefore, entering 3 into the TextField causes Int(number) to become 3, which makes the condition passedNumber == 3 true and displays a blue canvas. Any other listed number results in red.

So the correct answer is A. 3 . This matches the SwiftUI pattern of taking user input, converting it to the needed type, passing it into another view, and rendering UI conditionally based on that value.