Swift DSA Lab

Given an array of integers `nums`, return the sum of all the even numbers in it. If there are no even numbers, return `0`.

Count how many integers in `nums` are strictly greater than `0`. A number like `0` itself does not count.

Return the single largest integer in `nums`. You may assume the array always has at least one element.

Return the single smallest integer in `nums`. You may assume the array always has at least one element.

Count how many times `target` appears inside `nums`, then return that count.

Given `nums`, add together every value from index `start` up to and including index `end`, and return the total. Both indexes are valid and `start` is never larger than `end`.

Return the last integer in `nums`. If the array is empty, return `-1`.

Return a new array where every integer in `nums` is negated: positive values become negative and negative values become positive. `0` stays `0`.

For a non-negative integer `n`, return the sum of its decimal digits. For `0`, return `0`.

Return a new array where every value in `nums` is clamped into the inclusive range `low...high`. Values already inside the range stay unchanged. You may assume `low` is at most `high`.

You recorded the temperature each day in `temps`. Return how many readings are strictly greater than `threshold`.

Return the average of the integers in `nums` as a `Double`. If the array is empty, return `0`.

Return `true` if `value` appears anywhere in `nums`, and `false` otherwise.

Return how many distinct integers appear in `nums`. Duplicates should be counted only once.

Return a single array formed by all of `a` followed by all of `b`.

Return the second largest *distinct* value in `nums`. If the array has fewer than two distinct values, return `nil`.

Return a new array containing the values of `nums` in reverse order. The original array must not be modified.

Given an array of integers `nums`, report whether any number shows up more than once. Return `true` when a repeat exists, and `false` when every value is distinct.

Return how many distinct values in `nums` appear exactly once. Values that repeat do not count at all.

Return the distinct integers of `nums` in the order of their first appearance. Each value appears exactly once in the result.

Return how many distinct integers appear in both `a` and `b`. A shared value is counted once, even if repeated.

Return the first value in `nums` that appears more than once. If every value is unique, return `nil`.

Return a dictionary that maps each distinct integer in `nums` to the number of times it appears.

Return the integer that appears more than `nums.count / 2` times. If no value is that frequent, return `-1`.

Return the integer that appears most often in `nums`. If several integers tie, return the smallest one. If `nums` is empty, return `nil`.

Add together every integer in `nums` that appears exactly once. Values that repeat contribute nothing. If nothing qualifies, return `0`.

Count every pair of indices `(i, j)` with `i < j` where `nums[i] + nums[j]` equals `target`. Different index pairs count separately.

Every integer in `nums` appears exactly twice, except for one integer that appears only once. Find and return that unique integer.

The array `nums` is sorted from smallest to largest. Return `true` if two different entries add up to `target`, and `false` otherwise.

Two strings are anagrams when one is just the other with its letters rearranged. Given `s` and `t`, return `true` if `t` is an anagram of `s`, and `false` otherwise.

You are given an array of integers `nums` and a `target`. Two distinct numbers in `nums` add up to `target`. Return the indices of those two numbers, in any order. You may assume exactly one valid pair exists, and you may not use the same index twice.

Given `nums` and a distance `k`, return `true` if the same integer appears at two different indices that are at most `k` apart. Return `false` otherwise.

For each position `i`, compute the product of every element of `nums` except `nums[i]`, and return those values in order. Solve it in linear time and without using division.

Given an array of strings `strs`, collect strings that are anagrams of each other into a single group and return all groups. The order of groups, and the order inside each group, does not matter.

Given an array of intervals `intervals` where each is `[start, end]` (inclusive), merge all overlapping intervals and return the resulting array of non-overlapping intervals.

A phrase reads the same forwards and backwards once you ignore anything that is not a letter or digit and ignore letter case. Given `s`, return `true` if it qualifies, and `false` otherwise.

You are given an array of integers `numbers`, sorted in non-decreasing order, and a `target`. Exactly two different entries add up to `target`. Return their 1-based positions (starting at `1`) as a two-element array, in any order. You may not reuse the same index twice.

Given an array of integers `nums` sorted in non-decreasing order, return a new array holding the square of every element, arranged in non-decreasing order. Solve it in `O(n)` time.

Given an array `nums`, move every `0` to the end of the array while keeping the relative order of all non-zero numbers. Modify the array in place; return nothing.

Given strings `s` and `t`, return `true` if `s` is a subsequence of `t` — that is, you can delete some characters from `t` (possibly zero) and be left with exactly `s` — otherwise return `false`.

Given an array `nums` and an integer `val`, remove every occurrence of `val` in place and return the number of remaining elements. The first `count` slots of `nums` should hold those remaining elements in their original relative order; ignore the rest.

A text editor treats '#' as a backspace: it deletes the character immediately before it (consecutive '#' delete more). Given two strings s and t, return true if both strings end up identical after all backspaces are applied. An empty string stays empty when its last character is deleted.

You are given `nums1` (length `m + n` where the last `n` slots are zero placeholders) and `nums2` (length `n`), each sorted in non-decreasing order. Merge `nums2` into `nums1` in place so the whole array ends up sorted. The first `m` slots of `nums1` hold the real values. Return nothing.

Given an integer `x`, return `true` if it reads the same forwards and backwards (ignoring the sign), otherwise `false`.

Given an array of non-negative integers `height` where each value is a bar width of 1, return how many units of water can be trapped above the bars after it rains.

Given an array `nums`, return an array where the element at each position is the sum of all elements up to and including that position.

Given an array `nums` and an integer `k`, return the largest average value of any contiguous subarray of length exactly `k`. You can assume `1 <= k <= nums.count`.

Given a string `s`, return the length of the longest substring (contiguous block of characters) that contains every character at most once.

Given an array `nums` of positive integers and a positive `target`, return the length of the shortest contiguous subarray whose sum is at least `target`. If no such subarray exists, return `0`.

Given a string `s` and an integer `k`, return the length of the longest substring that contains at most `k` distinct characters. If `k` is zero, no character may appear, so the answer is `0`.

Given an array `nums` and two indices `left` and `right` (inclusive), return the sum of the elements between those indices. If the array is empty, return `0`.

You know a stock price for each day in `prices`. You may buy on one day and sell on a strictly later day. Return the largest profit possible, or `0` if no profitable trade exists.

You are scoring a game round by round. The input is a list of strings where each entry is one of: an integer (a score for that round), "C" (remove the previous round's score), "D" (add twice the previous round's score), or "+" (add the sum of the two most recent scores). Return the sum of all scores left at the end.

Given a string `s` containing balanced round brackets `()` alongside other characters, return the maximum nesting depth of the parentheses. Unbalanced strings are not possible in the input.

Given a string `s`, repeatedly remove adjacent equal pairs. Removing a pair can make two new characters adjacent, which may form another pair — keep going until no adjacent equal pairs remain. Return the final string.

Given an array `nums`, return an array where the value at each position is the next element to its right that is strictly greater than the value at that position, or `-1` if no such element exists.

Given a string `s` made of valid ("primitive") parentheses, split it into primitives (each is a non-empty balanced block that cannot be split further) and return the concatenation of every primitive with its outermost pair of parentheses removed.

Given an absolute Unix-style path `path`, return its canonical form. Rules: a single slash separates directories, a trailing slash is dropped, "." refers to the current directory (ignore it), and ".." moves up one directory. The canonical path always starts with "/".

A string built from the brackets `()`, `{}`, and `[]` is balanced when every opener is closed by a matching bracket of the same kind, in the correct nested order. Given `s`, return `true` if it is balanced.

Given an array of strings `tokens` formed from integers and the operators `+`, `-`, `*`, `/` in Reverse Polish notation, evaluate it and return the resulting integer. Division truncates toward zero.

`nums` is sorted from smallest to largest. Find `target` using binary search and return its index, or `-1` when it is not present.

Given a sorted array of distinct integers `nums` and a `target`, return the index where `target` would be, keeping the order sorted if it were inserted. If `target` is already present, return its index.

You have `n` versions numbered `1` through `n`. A helper `isBad(version)` returns `true` once a version is broken, and stays broken for every later version. Return the smallest version that is broken.

A number between `1` and `n` is chosen. A guess helper returns `-1` if your guess is too low, `1` if too high, and `0` on a match. Return the chosen number.

Given a non-negative integer x, return the largest integer whose square is less than or equal to x (the integer square root, rounded down). Do not use the built-in sqrt function.

Given a string `letters` of sorted lowercase letters (duplicates allowed) and a single-character `target`, return the smallest character in `letters` that is strictly greater than `target`. If none exists, wrap around and return the first character.

Given a sorted array of distinct positive integers `arr`, consider all positive integers not present in the array. Return the `k`th missing one.

Given an array `arr` that strictly increases up to one peak then strictly decreases, return the index of that peak. You may assume the array is a valid mountain (length at least 3, no plateau at the top).

Given two sorted arrays `nums1` and `nums2`, return the median of the combined sorted array. For even combined length, the median is the average of the two middle values.

Given the head of a singly linked list whose nodes hold integers, reverse the list in place and return the new head.

The heads of two sorted linked lists are given. Merge the two lists so the result is a single sorted list containing every node of both. Return its head.

Some linked lists never end: following `next` pointers eventually revisits an earlier node in a loop. Given its head, return `true` if a cycle exists and `false` if the list terminates.

Given the head of a singly linked list, return the node at the middle. If there are two middle nodes (even length), return the second one.

Given the head of a singly linked list, remove the node that is the `n`th from the end (1-based), and return the head of the updated list. You may assume `n` is always valid.

Given the head of a singly linked list and an integer `val` that appears in the list, remove every node whose value equals `val` and return the head.

Given the head of a sorted linked list, delete all nodes that appear more than once, keeping only one copy of each value. Return the head.

Given the head of a singly linked list, return `true` if the values form a palindrome (read the same forwards and backwards).

You are on the floor before index `0` of `cost`. From index `i` you may climb 1 or 2 steps into `i + 1` or `i + 2`, paying `cost[i]` when you land. Reach the floor past the last index (the top) at minimum total cost.

Houses in a row hold cash amounts in `nums`. You cannot rob two adjacent houses in the same night. Return the maximum you can collect.

To reach the top of a stairway with `n` steps you may climb exactly 1 or 2 steps at a time. Return the number of distinct sequences of climbs that reach the top.

A robot starts at the top-left of an `m` x `n` grid and may only move right or down. Return the number of distinct paths from the top-left corner to the bottom-right corner.

Given coin denominations `coins` (unlimited supply of each) and an `amount`, return the fewest number of coins that add up to exactly `amount`, or `-1` if it is impossible.

Given a string `s` and a dictionary of words `wordDict` (reusable any number of times), return `true` if `s` can be split into a sequence of dictionary words.

Given the root of a binary tree, mirror it vertically by swapping the left and right child of every node. Return the root of the inverted tree.

Given the root of a binary tree, return its maximum depth — the number of nodes along the longest path from the root down to the farthest leaf.

Given the roots of two binary trees `p` and `q`, return `true` if they are structurally identical — same shape, same values at every corresponding position.

Given the root of a binary tree, return `true` if, for every node, the heights of its two children differ by at most 1.

Given the root of a binary tree, return `true` if it is a mirror of itself (symmetric around its center).

Given the root of a binary tree and a `targetSum`, return `true` if there is a root-to-leaf path whose values add up to `targetSum`. A leaf is a node with no children.

Given the root of a binary tree, return the values of its nodes ordered by level, with each level as its own array (root first). Return an empty array for an empty tree.

Given an array of words, return a new array holding the length of each word in the same order.

Return `true` if the first character of `s` is an uppercase letter. An empty string or a string starting with a non-letter returns `false`.

Count how many of the letters `a`, `e`, `i`, `o`, and `u` appear in `s`. Both uppercase and lowercase count.

Return the number of space characters (`" "`) in `s`.

Return `s` with only its first character capitalized. If `s` is empty, return an empty string.

Return the number of distinct letters that appear in both `s` and `t`. A letter shared just once still counts as one.

Return a dictionary mapping each character of `s` to the number of times it appears.

The string `t` contains every character of `s` plus one extra character somewhere. Return that extra character as a single-character string.

A word is a palindrome when it reads the same forward and backward. Given a single word `word`, return `true` if it is one, ignoring letter case. There are no spaces or punctuation to worry about.

Given a string `s`, return the index of the first character that appears exactly once. If every character repeats, return `-1`.