DEV Community: Diego Henrick

LeetCode 19 in Swift: Remove Nth Node From End of List

Diego Henrick — Mon, 15 Jun 2026 10:59:20 +0000

Second edition of my LeetCode journey :)

The problem

In this problem, we need to remove the n-th node from the end of a linked list.

For example, for the list:

[1, 2, 3, 4, 5]

and n = 2, the node 4 should be removed, leaving:

[1, 2, 3, 5]

First, we need to understand the concept of a singly linked list, which appears a lot in big tech interviews.

A singly linked list is a sequence of nodes where each node contains a value, val, and a reference to the next node, next.

The problem already gives us the node class:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init() { self.val = 0; self.next = nil; }
 *     public init(_ val: Int) { self.val = val; self.next = nil; }
 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 * }
 */

The idea

The idea for the solution is to use two pointers, first and second.

Both start pointing to the head of the list.

We also use an additional pointer, previous, which always points to the node before the one that will be removed.

var first: ListNode? = head
var second: ListNode? = head
var previous: ListNode? = nil

Now we need to move the first pointer n positions ahead of second.

for _ in 0..<n {
    first = first?.next
}

After that, we move both pointers forward until first reaches the end of the list.

while first != nil {
    previous = second
    first = first?.next
    second = second?.next
}

When this loop ends, second is pointing to the node that should be removed.

To finish, we delete the desired node.

If previous is nil, it means the node to be removed is the head of the list. So the new head should be head?.next.

If that is not the case, then previous?.next is adjusted to skip second, which is the node being removed.

Complete code

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     public var val: Int
 *     public var next: ListNode?
 *     public init() { self.val = 0; self.next = nil; }
 *     public init(_ val: Int) { self.val = val; self.next = nil; }
 *     public init(_ val: Int, _ next: ListNode?) { self.val = val; self.next = next; }
 * }
 */

class Solution {
    func removeNthFromEnd(_ head: ListNode?, _ n: Int) -> ListNode? {
        var first: ListNode? = head
        var second: ListNode? = head
        var previous: ListNode? = nil

        for _ in 0..<n {
            first = first?.next
        }

        while first != nil {
            previous = second
            first = first?.next
            second = second?.next
        }

        if previous == nil {
            return head?.next
        } else {
            previous?.next = second?.next
        }

        return head
    }
}

Time complexity

The time complexity is O(n).

The first pass is the for loop, which moves n steps.

The second pass is the while loop, which continues through the rest of the list.

In the worst case, the algorithm still visits the list linearly, where n is the total number of nodes in the list.

The space complexity is O(1) because we only use a few pointers.

It is a simple and efficient algorithm.

Thanks for reading!

Feel free to leave comments or suggestions :)

LeetCode 5 in Swift: Longest Palindromic Substring

Diego Henrick — Mon, 15 Jun 2026 10:49:04 +0000

LeetCode 5 in Swift: Longest Palindromic Substring

My first post of many showing my LeetCode journey :)

The problem

In this problem, we need to find the longest palindromic substring inside a given string.

A palindrome is a text that reads the same forward and backward, like "aba" or "abba".

My first approach

My first approach was to iterate through the received string and check each substring to see if it was a palindrome.

If it was, I checked if it was longer than the current longest palindrome found.

After that, I removed the first character from the received string and did everything again, covering the cases with different starting letters.

Here is the code:

class Solution {
    func longestPalindrome(_ s: String) -> String {
        var strInput = s
        var subStr = ""
        var longest = ""

        while strInput.count > longest.count {
            for char in strInput {
                subStr = subStr + String(char)

                if subStr == String(subStr.reversed()) {
                    if longest.count < subStr.count {
                        longest = subStr
                    }
                }
            }

            strInput = String(strInput.dropFirst())
            subStr = ""
        }

        return longest
    }
}

The code worked, but in one of LeetCode's test cases it timed out. It took too long to run.

This solution has a time complexity of O(n³).

The reason:

The while loop runs up to n times.
The for loop runs around n / 2 times on average for each while iteration.
Checking if the substring is a palindrome is also O(n), because it reverses and compares the string.

So:

O(n) * O(n) * O(n) = O(n³)

That is too inefficient for large strings.

A better approach

After researching an explanation of the problem and a better way to approach it, I discovered the idea of expanding around the center of each palindrome.

The reason this works is that every palindrome has at least one center:

One character in the center for odd-length palindromes, like "aba".
Two equal characters in the center for even-length palindromes, like "abba".

Here is the version I developed. It is still not the best possible solution, but it passed all test cases:

class Solution {
    func longestPalindrome(_ s: String) -> String {
        guard s.count > 1 else { return s }

        let s = Array(s)

        // Function to expand from a center point
        func palindrome(_ center: Int) -> (start: Int, end: Int) {
            var l = center - 1
            var r = center + 1

            var res = (center, center)

            while l >= 0 && r < s.count {
                guard s[l] == s[r] else { break }

                res = (l, r)
                l -= 1
                r += 1
            }

            // For even-length palindromes
            var res1 = (center, center)

            if center < s.count - 1 && s[center] == s[center + 1] {
                l = center
                r = center + 1

                while l >= 0 && r < s.count {
                    guard s[l] == s[r] else { break }

                    res1 = (l, r)
                    l -= 1
                    r += 1
                }
            }

            // Return the longest palindrome found
            return res.1 - res.0 > res1.1 - res1.0 ? res : res1
        }

        var res = (0, 0)

        for i in 0..<s.count {
            let pal = palindrome(i)

            if pal.1 - pal.0 > res.1 - res.0 {
                res = pal
            }
        }

        return String(s[res.0...res.1])
    }
}

In this case, we do not create unnecessary substrings or reverse them, which results in a time complexity of O(n²).

The space complexity is O(n) because I convert the string into an array of characters to make indexing easier in Swift.

There is also a more advanced algorithm that solves this problem in O(n), called Manacher's Algorithm. But I will leave that one to study another time.

Thanks for following along until here! Feel free to leave comments or suggestions.

See you next time :)

Trying Apple Foundation Models with On-Device AI

Diego Henrick — Mon, 15 Jun 2026 10:11:46 +0000

Apple’s Foundation Models framework gives iOS developers a native way to experiment with generative AI features powered by the on-device language model behind Apple Intelligence.

In this guide I'll walk through a small SwiftUI experiment: an ambient sound mixer that turns a natural language prompt into a list of sounds with different volume levels that create an ambient soundscape.

Before starting

To try this, you need:

Xcode 27 with the Foundation Models framework available.
A device that supports Apple Intelligence.
Apple Intelligence enabled on the device.

For this we will build:

A structured Swift type that describes the model output.
An availability check before asking the model for anything.
A model session with developer instructions and a user prompt.
A SwiftUI button that triggers generation and plays the selected sounds.

Step 1: Model the response with `@Generable`

The most interesting part of the framework is guided generation. Instead of asking a model to return JSON and then hoping it formats the output correctly, you describe the Swift type you want the model to generate.

For this sound mixer, the result can be simple: a list of sound components. Each component has a local file name and a volume.

import FoundationModels

@Generable
struct AmbientMix: Equatable {
    @Guide(description: "Sounds that should be layered together for the requested ambience.")
    @Guide(.count(1...4))
    var components: [AmbientSoundComponent]
}

@Generable
struct AmbientSoundComponent: Equatable {
    @Guide(description: "The exact local sound file name without the file extension.")
    var fileName: String

    @Guide(description: "Playback volume between 0.1 and 1.0.")
    var volume: Float
}

The @Generable macro tells the framework that this type can be generated by the model. The @Guide annotations give the model extra context and constraints.

In this case, the model should return between 1 and 4 sounds. That matters because an ambient mix with 20 sounds would probably be noisy and hard to control.

This is the part that feels different from the usual cloud LLM flow. Normally, I would write something like:

Return a valid JSON object with this shape...

Then I would still need to parse the response, handle malformed JSON, retry, validate missing fields, and protect the app from bad output.

With guided generation, the framework can generate a Swift value that matches the type I described.

Step 2: Check model availability

Before using the model, the app needs to check whether it is actually available.

Foundation Models depends on Apple Intelligence support and model readiness. The user may be on an unsupported device, Apple Intelligence may not be enabled, or the model may not be ready yet.

A simple availability check can look like this:

import FoundationModels

func canUseFoundationModels() -> Bool {
    let model = SystemLanguageModel.default

    switch model.availability {
    case .available:
        return true

    case .unavailable(let reason):
        print("Foundation Models unavailable: \(reason)")
        return false
    }
}

For a real app, I would avoid only printing the reason. I would use this result to decide what the UI should do.

For example:

Hide the AI feature if it is not supported.
Show a message explaining that Apple Intelligence is required.
Fall back to a manual sound picker.
Fall back to a server-based model if the product supports that.

The important part is: do not assume the model is always available.

Step 3: Create the language model session

Now we can create a LanguageModelSession.

The session receives developer-controlled instructions. These instructions should tell the model how to behave and what constraints to follow.

For this app, I want the model to act like a small soundscape assistant. It should choose only from my local sound catalog and avoid inventing file names.

import FoundationModels

func generateAmbientMix(
    prompt: String,
    availableSounds: [String]
) async throws -> AmbientMix {
    let instructions = """
    You create ambient sound mixes for a relaxation app.

    Choose only from the available local sound files.
    Do not invent file names.
    Prefer simple mixes that match the user prompt.

    Available sounds:
    \(availableSounds.joined(separator: ", "))
    """

    let session = LanguageModelSession(
        model: SystemLanguageModel.default,
        instructions: instructions
    )

    let response = try await session.respond(
        to: prompt,
        generating: AmbientMix.self
    )

    return response.content
}

The important line is this one:

let response = try await session.respond(
    to: prompt,
    generating: AmbientMix.self
)

The model is not just returning text. It is generating an AmbientMix.

That means the rest of the app can work with normal Swift values:

let components = response.content.components

No JSONDecoder, no regex, and no manual string parsing for the model response.

Prompting note

I would keep the instructions mostly static and pass the user's text as the prompt.

The instructions are controlled by the app. The prompt is controlled by the user.

That separation makes the feature easier to reason about.

Step 4: Validate the generated result

Guided generation helps a lot, but I would still validate the result before playing anything.

For this sound mixer, there are two simple checks I would not skip:

Make sure the generated file name exists in the local catalog.
Clamp the volume to the range the app supports.

func validatedComponents(
    from mix: AmbientMix,
    availableSounds: [String]
) -> [AmbientSoundComponent] {
    let soundCatalog = Set(availableSounds)

    return mix.components.compactMap { component in
        guard soundCatalog.contains(component.fileName) else {
            return nil
        }

        let safeVolume = min(max(component.volume, 0.1), 1.0)

        return AmbientSoundComponent(
            fileName: component.fileName,
            volume: safeVolume
        )
    }
}

Even when the output shape is correct, the app should still protect its own domain rules.

The model can suggest, but the app should decide what is allowed.

Step 5: Use it from SwiftUI

From SwiftUI, we can trigger generation inside a Task.

The UI should show a loading state, avoid multiple requests at the same time, and handle errors clearly.

Here is a simplified example:

import SwiftUI

struct AmbientMixerView: View {
    @State private var userPrompt = ""
    @State private var isGenerating = false
    @State private var errorMessage: String?

    private let availableSounds = [
        "rain",
        "fire",
        "wind",
        "cafe"
    ]

    var body: some View {
        VStack(spacing: 16) {
            TextField(
                "Describe the ambience you want",
                text: $userPrompt,
                axis: .vertical
            )
            .textFieldStyle(.roundedBorder)

            Button {
                generateMix()
            } label: {
                if isGenerating {
                    ProgressView()
                } else {
                    Text("Generate Ambience")
                }
            }
            .disabled(userPrompt.isEmpty || isGenerating)

            if let errorMessage {
                Text(errorMessage)
                    .foregroundStyle(.red)
            }
        }
        .padding()
    }

    private func generateMix() {
        isGenerating = true
        errorMessage = nil

        Task {
            defer { isGenerating = false }

            do {
                guard canUseFoundationModels() else {
                    errorMessage = "Apple Intelligence is not available on this device."
                    return
                }

                let mix = try await generateAmbientMix(
                    prompt: userPrompt,
                    availableSounds: availableSounds
                )

                let safeComponents = validatedComponents(
                    from: mix,
                    availableSounds: availableSounds
                )

                playAmbientMix(safeComponents)
            } catch {
                errorMessage = "Could not generate a mix right now."
                print(error)
            }
        }
    }

    private func playAmbientMix(_ components: [AmbientSoundComponent]) { ... }
}

That was the new native way to add AI to you projects.

My takeaway

Foundation Models is not a replacement for every AI feature.

For complex reasoning, very large context, heavy multimodal tasks, or features that need to work on every device, a server-side model will probably make more sense.

But for focused, privacy-friendly app features with clear inputs and structured outputs, the framework is really cool.

The sound mixer example is intentionally small, but it shows the core flow:

Define a structured output with @Generable.
Check model availability.
Create a LanguageModelSession.
Ask for a generated Swift value.
Validate the result.
Connect it to your UI.

That is a nice developer experience, and I think this is where Foundation Models can be useful in real iOS apps.

Sources:

Apple Developer Documentation — Foundation Models: https://developer.apple.com/documentation/FoundationModels
Apple WWDC25 — Meet the Foundation Models framework: https://developer.apple.com/videos/play/wwdc2025/286/
Apple Developer Documentation — Generable: https://developer.apple.com/documentation/foundationmodels/generable

DEV Community: Diego Henrick

LeetCode 19 in Swift: Remove Nth Node From End of List

The problem

The idea

Complete code

Time complexity

LeetCode 5 in Swift: Longest Palindromic Substring

LeetCode 5 in Swift: Longest Palindromic Substring

The problem

My first approach

A better approach

Trying Apple Foundation Models with On-Device AI

Before starting

Step 1: Model the response with @Generable

Step 2: Check model availability

Step 3: Create the language model session

Prompting note

Step 4: Validate the generated result

Step 5: Use it from SwiftUI

My takeaway

Step 1: Model the response with `@Generable`