mirror of
https://github.com/apple/swift-algorithms
synced 2026-11-22 04:10:39 +00:00
Compare commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
04d91803a2 | ||
|
|
36bcc5581b | ||
|
|
31d600a4f1 | ||
|
|
0e44ceb7bb | ||
|
|
78dd4b5b93 | ||
|
|
abc5559ef6 | ||
|
|
bcdbac800a | ||
|
|
718220d0f8 | ||
|
|
551b4af927 | ||
|
|
dca25448e0 | ||
|
|
1639c1e2c3 | ||
|
|
a61c3db4fb | ||
|
|
198eee004e | ||
|
|
4cca4895cc | ||
|
|
001247f8a5 | ||
|
|
0065c60a22 | ||
|
|
5cde0b1b67 | ||
|
|
220649e999 | ||
|
|
b171b81577 | ||
|
|
e652f01949 | ||
|
|
9783c1be91 | ||
|
|
e64cff7e1d | ||
|
|
98b6e26d8d | ||
|
|
ca8af77420 | ||
|
|
e077f67639 | ||
|
|
ed38a2dac4 | ||
|
|
18ec8500b7 | ||
|
|
ab0ec2adf4 | ||
|
|
e7c6716499 | ||
|
|
d2546b8740 | ||
|
|
1e761dd787 | ||
|
|
bd64bef3d2 | ||
|
|
32837b9ad6 | ||
|
|
f91638bba6 | ||
|
|
914e626e23 | ||
|
|
d91723bd4b | ||
|
|
63311ae0ab | ||
|
|
cc20b55cc6 | ||
|
|
5be792abcf | ||
|
|
bf1de3240d | ||
|
|
dd564ca517 | ||
|
|
44d359b429 | ||
|
|
bdf36ad23d | ||
|
|
7ca12bed60 | ||
|
|
4f7cd340cd | ||
|
|
1a3c7061de | ||
|
|
d8a11e0d51 | ||
|
|
d2a1ca5f7b | ||
|
|
52e1e0e45a | ||
|
|
3b511072a6 | ||
|
|
cda6fddada | ||
|
|
f9a4f79027 | ||
|
|
2f8f798d0c | ||
|
|
60bad3bbf4 | ||
|
|
08e424ea07 | ||
|
|
813ea7905e | ||
|
|
1acc2136d9 | ||
|
|
9ef531f23f | ||
|
|
d872b648f4 | ||
|
|
9836a4f80b | ||
|
|
34d7a55d1a | ||
|
|
ad8d6ed7a1 | ||
|
|
14f09e4228 | ||
|
|
622703b97f | ||
|
|
5b7993ca8d | ||
|
|
b18a659ab5 | ||
|
|
f89fe8fad1 | ||
|
|
f0dba1433f | ||
|
|
05df988369 | ||
|
|
afac704540 | ||
|
|
79aeb24e9d | ||
|
|
3092eb1304 | ||
|
|
e0fed41419 | ||
|
|
505b57369f | ||
|
|
3864606e00 | ||
|
|
e1c421c568 | ||
|
|
638869256a | ||
|
|
99152ecc68 | ||
|
|
7af7ac2599 | ||
|
|
ff01a02c07 | ||
|
|
93c8724c72 | ||
|
|
ad6dc7a143 | ||
|
|
fd189aa078 | ||
|
|
6933a3157b | ||
|
|
dfcc611e1d | ||
|
|
3669ff0c11 | ||
|
|
0a6bcc3c68 | ||
|
|
92b2846345 | ||
|
|
377bb72f0a | ||
|
|
28bbed8776 | ||
|
|
6f7148d966 | ||
|
|
dcdef508c0 | ||
|
|
4a194ca811 | ||
|
|
6df6133ab7 | ||
|
|
17cb07e38f | ||
|
|
b28d248cab | ||
|
|
f11d398c98 | ||
|
|
34c0a0b34a | ||
|
|
66ec96812a | ||
|
|
009393dccb |
No files matched your search
@@ -1,5 +0,0 @@
|
||||
<?xml version="1.0" encoding="UTF-8"?>
|
||||
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
|
||||
<plist version="1.0">
|
||||
<array/>
|
||||
</plist>
|
||||
+139
-3
@@ -8,7 +8,7 @@ This project follows semantic versioning. While still in major version `0`,
|
||||
source-stability is only guaranteed within minor versions (e.g. between
|
||||
`0.0.3` and `0.0.4`). If you want to guard against potentially source-breaking
|
||||
package updates, you can specify your package dependency using
|
||||
`.upToNextMinor(from: "0.0.1")` as the requirement.
|
||||
`.upToNextMinor(from: "0.1.0")` as the requirement.
|
||||
|
||||
## [Unreleased]
|
||||
|
||||
@@ -16,6 +16,100 @@ package updates, you can specify your package dependency using
|
||||
|
||||
---
|
||||
|
||||
## [0.1.0] - 2021-04-13
|
||||
|
||||
### Additions
|
||||
|
||||
- The `compacted()` method lazily finds the non-`nil` elements of a sequence or
|
||||
collection ([#112]).
|
||||
|
||||
### Changes
|
||||
|
||||
- The `uniqued()` method now lazily computes the unique elements of a sequence
|
||||
or a collection ([#71]). Pass this resulting sequence to an `Array`
|
||||
initializer to recover the behavior of the previous release.
|
||||
- Calling `cycled(times:)` now returns a new `FiniteCycle` type, which has the
|
||||
same conformances as its underlying collection ([#106]).
|
||||
- The base collections of the sequence and collection wrapper types are no
|
||||
longer public ([#85], [#125]), and the wrapper types no longer conform to the
|
||||
`Equatable` or `Hashable` protocols ([#124]). If you need those conformances,
|
||||
convert the wrapper type to an `Array` or other collection currrency type
|
||||
before storing. Please file an issue if these changes pose a problem for your
|
||||
use case.
|
||||
|
||||
The 0.1.0 release includes contributions from [LemonSpike], [LucianoPAlmeida],
|
||||
[natecook1000], and [timvermeulen]. Thank you!
|
||||
|
||||
---
|
||||
|
||||
## [0.0.4] - 2021-03-29
|
||||
|
||||
### Additions
|
||||
|
||||
More new algorithms to join the party:
|
||||
|
||||
- A lazy version of the standard library's two `split` methods. ([#78])
|
||||
- `firstNonNil(_:)` returns the first non-`nil` element from an
|
||||
optional-generating transform. ([#31])
|
||||
- `uniquePermutations()` skips duplicates when generating permutations of a
|
||||
collection. ([#91])
|
||||
- The `reductions` methods return all the in-between states of reducing a
|
||||
sequence or collection. ([#46])
|
||||
|
||||
### Fixes
|
||||
|
||||
- Methods and computed properties are more consistently marked as inlinable,
|
||||
resolving a performance regression.
|
||||
- The `Stride` type now efficiently calculates distances between positions,
|
||||
supported by the underlying collection.
|
||||
- Better test coverage and improved diagnostics for comparing sequences.
|
||||
- Fixed links and improved documentation.
|
||||
|
||||
The 0.0.4 release includes contributions from [bjhomer], [danielctull],
|
||||
[hashemi], [karwa], [kylemacomber], [LucianoPAlmeida], [mdznr], [natecook1000],
|
||||
[ollieatkinson], [Qata], [timvermeulen], and [toddthomas]. Thank you!
|
||||
|
||||
## [0.0.3] - 2021-02-26
|
||||
|
||||
### Additions
|
||||
|
||||
An exciting group of new algorithms, contributed by the community:
|
||||
|
||||
- `trimming(while:)` returns a subsequence of a bidirectional collection with
|
||||
the matching elements removed from the start and end. ([#4])
|
||||
- `min(ofCount:)` and `max(ofCount:)` find the smallest or largest elements in
|
||||
a collection. ([#9], [#77])
|
||||
- `windows(ofCount:)` lets you iterate over all the overlapping subsequences of
|
||||
a particular length. ([#20])
|
||||
- `striding(by:)` iterates over every *n*th element of a sequence or collection.
|
||||
([#24])
|
||||
- `interspersed(with:)` places a new element between every pair of elements in
|
||||
a sequence or collection. ([#35])
|
||||
- `chunks(ofCount:)` breaks a collection into subsequences of the given number
|
||||
of elements. ([#54])
|
||||
- `suffix(while:)` matches the standard library's `prefix(while:)`, by
|
||||
returning the suffix of all matching elements from a bidirectional collection.
|
||||
([#65])
|
||||
- Variations of `combinations(ofCount:)` and `permutations(ofCount:)` that take
|
||||
a range expression as a parameter, returning combinations and permutations of
|
||||
multiple lengths. ([#51], [#56])
|
||||
|
||||
### Changes
|
||||
|
||||
- The `LazyChunked` type now precomputes its `startIndex`, making performance
|
||||
more predictable when using the collection.
|
||||
|
||||
### Fixes
|
||||
|
||||
- `randomSample(count:)` no longer traps in rare circumstances.
|
||||
- Index calculations have been improved in a variety of collection wrappers.
|
||||
- A variety of documentation improvements and corrections.
|
||||
|
||||
The 0.0.3 release includes contributions from [benrimmington], [danielctull],
|
||||
[dhruvshah8], [karwa], [LucianoPAlmeida], [markuswntr], [mdznr], [michiboo],
|
||||
[natecook1000], [ollieatkinson], [rakaramos], [rockbruno], [Roshankumar350],
|
||||
[sidepelican], and [timvermeulen]. Thank you!
|
||||
|
||||
## [0.0.2] - 2020-10-23
|
||||
|
||||
### Changes
|
||||
@@ -32,7 +126,7 @@ package updates, you can specify your package dependency using
|
||||
|
||||
### Fixes
|
||||
|
||||
- Swift Algorithms now builds under SwiftPM on Windows.
|
||||
- `Algorithms` now builds under SwiftPM on Windows.
|
||||
- A wide variety of errors, misspellings, and ommissions in the documentation
|
||||
and guides have been fixed.
|
||||
- Index/distance calculations for the `Product2` and `Chain` types have been
|
||||
@@ -44,6 +138,7 @@ The 0.0.2 release includes contributions from [AustinConlon], [egorzhdan],
|
||||
[IanKeen], [iSame7], [karwa], [kylemacomber], [natecook1000], [nordicio],
|
||||
[pmtao], [schlagelk], [stephentyrone], and [timvermeulen]. Thank you!
|
||||
|
||||
|
||||
## [0.0.1] - 2020-10-07
|
||||
|
||||
- **Swift Algorithms** initial release.
|
||||
@@ -54,23 +149,64 @@ This changelog's format is based on [Keep a Changelog](https://keepachangelog.co
|
||||
|
||||
<!-- Link references for releases -->
|
||||
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/0.0.2...HEAD
|
||||
[Unreleased]: https://github.com/apple/swift-algorithms/compare/0.1.0...HEAD
|
||||
[0.1.0]: https://github.com/apple/swift-algorithms/compare/0.0.4...0.1.0
|
||||
[0.0.4]: https://github.com/apple/swift-algorithms/compare/0.0.3...0.0.4
|
||||
[0.0.3]: https://github.com/apple/swift-algorithms/compare/0.0.2...0.0.3
|
||||
[0.0.2]: https://github.com/apple/swift-algorithms/compare/0.0.1...0.0.2
|
||||
[0.0.1]: https://github.com/apple/swift-algorithms/releases/tag/0.0.1
|
||||
|
||||
<!-- Link references for pull requests -->
|
||||
|
||||
[#4]: https://github.com/apple/swift-algorithms/pull/4
|
||||
[#9]: https://github.com/apple/swift-algorithms/pull/9
|
||||
[#20]: https://github.com/apple/swift-algorithms/pull/20
|
||||
[#24]: https://github.com/apple/swift-algorithms/pull/24
|
||||
[#31]: https://github.com/apple/swift-algorithms/pull/31
|
||||
[#35]: https://github.com/apple/swift-algorithms/pull/35
|
||||
[#46]: https://github.com/apple/swift-algorithms/pull/46
|
||||
[#51]: https://github.com/apple/swift-algorithms/pull/51
|
||||
[#54]: https://github.com/apple/swift-algorithms/pull/54
|
||||
[#56]: https://github.com/apple/swift-algorithms/pull/56
|
||||
[#65]: https://github.com/apple/swift-algorithms/pull/65
|
||||
[#71]: https://github.com/apple/swift-algorithms/pull/71
|
||||
[#77]: https://github.com/apple/swift-algorithms/pull/77
|
||||
[#78]: https://github.com/apple/swift-algorithms/pull/78
|
||||
[#85]: https://github.com/apple/swift-algorithms/pull/85
|
||||
[#91]: https://github.com/apple/swift-algorithms/pull/91
|
||||
[#106]: https://github.com/apple/swift-algorithms/pull/106
|
||||
[#112]: https://github.com/apple/swift-algorithms/pull/112
|
||||
[#124]: https://github.com/apple/swift-algorithms/pull/124
|
||||
[#125]: https://github.com/apple/swift-algorithms/pull/125
|
||||
|
||||
<!-- Link references for contributors -->
|
||||
|
||||
[AustinConlon]: https://github.com/apple/swift-algorithms/commits?author=AustinConlon
|
||||
[benrimmington]: https://github.com/apple/swift-algorithms/commits?author=benrimmington
|
||||
[bjhomer]: https://github.com/apple/swift-algorithms/commits?author=bjhomer
|
||||
[danielctull]: https://github.com/apple/swift-algorithms/commits?author=danielctull
|
||||
[dhruvshah8]: https://github.com/apple/swift-algorithms/commits?author=dhruvshah8
|
||||
[egorzhdan]: https://github.com/apple/swift-algorithms/commits?author=egorzhdan
|
||||
[hashemi]: https://github.com/apple/swift-algorithms/commits?author=hashemi
|
||||
[IanKeen]: https://github.com/apple/swift-algorithms/commits?author=IanKeen
|
||||
[iSame7]: https://github.com/apple/swift-algorithms/commits?author=iSame7
|
||||
[karwa]: https://github.com/apple/swift-algorithms/commits?author=karwa
|
||||
[kylemacomber]: https://github.com/apple/swift-algorithms/commits?author=kylemacomber
|
||||
[LemonSpike]: https://github.com/apple/swift-algorithms/commits?author=LemonSpike
|
||||
[LucianoPAlmeida]: https://github.com/apple/swift-algorithms/commits?author=LucianoPAlmeida
|
||||
[markuswntr]: https://github.com/apple/swift-algorithms/commits?author=markuswntr
|
||||
[mdznr]: https://github.com/apple/swift-algorithms/commits?author=mdznr
|
||||
[michiboo]: https://github.com/apple/swift-algorithms/commits?author=michiboo
|
||||
[natecook1000]: https://github.com/apple/swift-algorithms/commits?author=natecook1000
|
||||
[nordicio]: https://github.com/apple/swift-algorithms/commits?author=nordicio
|
||||
[ollieatkinson]: https://github.com/apple/swift-algorithms/commits?author=ollieatkinson
|
||||
[pmtao]: https://github.com/apple/swift-algorithms/commits?author=pmtao
|
||||
[Qata]: https://github.com/apple/swift-algorithms/commits?author=Qata
|
||||
[rakaramos]: https://github.com/apple/swift-algorithms/commits?author=rakaramos
|
||||
[rockbruno]: https://github.com/apple/swift-algorithms/commits?author=rockbruno
|
||||
[Roshankumar350]: https://github.com/apple/swift-algorithms/commits?author=Roshankumar350
|
||||
[schlagelk]: https://github.com/apple/swift-algorithms/commits?author=schlagelk
|
||||
[sidepelican]: https://github.com/apple/swift-algorithms/commits?author=sidepelican
|
||||
[stephentyrone]: https://github.com/apple/swift-algorithms/commits?author=stephentyrone
|
||||
[timvermeulen]: https://github.com/apple/swift-algorithms/commits?author=timvermeulen
|
||||
[toddthomas]: https://github.com/apple/swift-algorithms/commits?author=toddthomas
|
||||
+27
-9
@@ -4,7 +4,10 @@
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/ChunkedTests.swift)]
|
||||
|
||||
Break a collection into subsequences where consecutive elements pass a binary
|
||||
predicate, or where all elements in each chunk project to the same value.
|
||||
predicate, or where all elements in each chunk project to the same value.
|
||||
|
||||
Also, includes a `chunks(ofCount:)` that breaks a collection into subsequences
|
||||
of a given `count`.
|
||||
|
||||
There are two variations of the `chunked` method: `chunked(by:)` and
|
||||
`chunked(on:)`. `chunked(by:)` uses a binary predicate to test consecutive
|
||||
@@ -26,17 +29,32 @@ let chunks = names.chunked(on: \.first!)
|
||||
// [["David"], ["Kyle", "Karoy"], ["Nate"]]
|
||||
```
|
||||
|
||||
These methods are related to the [existing SE proposal][proposal] for chunking a
|
||||
collection into subsequences of a particular size, potentially named something
|
||||
like `chunked(length:)`. Unlike the `split` family of methods, the entire
|
||||
collection is included in the chunked result — joining the resulting chunks
|
||||
recreates the original collection.
|
||||
The `chunks(ofCount:)` takes a `count` parameter (required to be > 0) and separates
|
||||
the collection into `n` chunks of this given count. If the `count` parameter is
|
||||
evenly divided by the count of the base `Collection` all the chunks will have
|
||||
the count equals to the parameter. Otherwise, the last chunk will contain the
|
||||
remaining elements.
|
||||
|
||||
```swift
|
||||
let names = ["David", "Kyle", "Karoy", "Nate"]
|
||||
let evenly = names.chunks(ofCount: 2)
|
||||
// equivalent to [["David", "Kyle"], ["Karoy", "Nate"]]
|
||||
|
||||
let remaining = names.chunks(ofCount: 3)
|
||||
// equivalent to [["David", "Kyle", "Karoy"], ["Nate"]]
|
||||
```
|
||||
|
||||
The `chunks(ofCount:)` is the method of the [existing SE proposal][proposal].
|
||||
Unlike the `split` family of methods, the entire collection is included in the
|
||||
chunked result — joining the resulting chunks recreates the original collection.
|
||||
|
||||
```swift
|
||||
c.elementsEqual(c.chunked(...).joined())
|
||||
// true
|
||||
```
|
||||
|
||||
Check the [proposal][proposal] detailed design section for more info.
|
||||
|
||||
[proposal]: https://github.com/apple/swift-evolution/pull/935
|
||||
|
||||
## Detailed Design
|
||||
@@ -58,15 +76,15 @@ extension Collection {
|
||||
extension LazyCollectionProtocol {
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> LazyChunked<Elements>
|
||||
) -> Chunked<Elements>
|
||||
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> LazyChunked<Elements>
|
||||
) -> Chunked<Elements>
|
||||
}
|
||||
```
|
||||
|
||||
The `LazyChunked` type is bidirectional when the wrapped collection is
|
||||
The `Chunked` type is bidirectional when the wrapped collection is
|
||||
bidirectional.
|
||||
|
||||
### Complexity
|
||||
|
||||
+24
-3
@@ -36,6 +36,27 @@ for combo in numbers2.combinations(ofCount: 2) {
|
||||
// [10, 10]
|
||||
```
|
||||
|
||||
Given a range, the `combinations(ofCount:)` method returns a sequence of all
|
||||
the different combinations of the given sizes of a collection’s elements in
|
||||
increasing order of size.
|
||||
|
||||
```swift
|
||||
let numbers = [10, 20, 30, 40]
|
||||
for combo in numbers.combinations(ofCount: 2...3) {
|
||||
print(combo)
|
||||
}
|
||||
// [10, 20]
|
||||
// [10, 30]
|
||||
// [10, 40]
|
||||
// [20, 30]
|
||||
// [20, 40]
|
||||
// [30, 40]
|
||||
// [10, 20, 30]
|
||||
// [10, 20, 40]
|
||||
// [10, 30, 40]
|
||||
// [20, 30, 40]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `combinations(ofCount:)` method is declared as a `Collection` extension,
|
||||
@@ -56,9 +77,9 @@ array at every index advancement. `Combinations` does conform to
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling `combinations(ofCount:)` accesses the count of the collection, so it’s an
|
||||
O(1) operation for random-access collections, or an O(_n_) operation otherwise.
|
||||
Creating the iterator for a `Combinations` instance and each call to
|
||||
Calling `combinations(ofCount:)` accesses the count of the collection, so it’s
|
||||
an O(1) operation for random-access collections, or an O(_n_) operation
|
||||
otherwise. Creating the iterator for a `Combinations` instance and each call to
|
||||
`Combinations.Iterator.next()` is an O(_n_) operation.
|
||||
|
||||
### Naming
|
||||
|
||||
@@ -0,0 +1,47 @@
|
||||
# Compacted
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Compacted.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/CompactedTests.swift)]
|
||||
|
||||
A convenience method that lazily flattens the `nil`s out of a sequence
|
||||
or collection.
|
||||
|
||||
The new method matches one of the most common uses of `compactMap`,
|
||||
which is to only remove `nil`s without transforming the elements
|
||||
(e.g. `collection.lazy.compactMap { $0 }`).
|
||||
|
||||
```swift
|
||||
let array: [Int?] = [10, nil, 30, nil, 2, 3, nil, 5]
|
||||
let withNoNils = array.compacted()
|
||||
// Array(withNoNils) == [10, 30, 2, 3, 5]
|
||||
```
|
||||
|
||||
The type returned by `compacted()` lazily computes the non-`nil` elements
|
||||
without requiring a user to provide a closure or use the `.lazy` property.
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `compacted()` methods has two overloads:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
|
||||
where Element == Unwrapped?
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
|
||||
where Element == Unwrapped?
|
||||
}
|
||||
```
|
||||
|
||||
The `Sequence` version of `compacted()` returns a `CompactedSequence` type,
|
||||
while the `Collection` version returns `CompactedCollection`. The collection
|
||||
has conditional conformance to `BidirectionalCollection` and
|
||||
`LazyCollectionProtocol` when the base collection conforms.
|
||||
|
||||
### Naming
|
||||
|
||||
The name `compacted()` matches the existing method `compactMap`,
|
||||
which is commonly used to extract only the non-`nil` values
|
||||
without mapping them to a different type.
|
||||
+9
-8
@@ -16,9 +16,9 @@ for x in (1...3).cycled(times: 3) {
|
||||
// Prints 1 through 3 three times
|
||||
```
|
||||
|
||||
`cycled(times:)` combines two other existing standard library functions
|
||||
(`repeatElement` and `joined`) to provide a more expressive way of repeating a
|
||||
collection's elements a limited number of times.
|
||||
`cycled(times:)` provides a more expressive way of repeating a
|
||||
collection's elements a limited number of times than
|
||||
combining `repeatElement(_:count:)` and `joined()`.
|
||||
|
||||
## Detailed Design
|
||||
|
||||
@@ -28,7 +28,7 @@ Two new methods are added to collections:
|
||||
extension Collection {
|
||||
func cycled() -> Cycle<Self>
|
||||
|
||||
func cycled(times: Int) -> FlattenSequence<Repeated<Self>>
|
||||
func cycled(times: Int) -> FiniteCycle<Self>
|
||||
}
|
||||
```
|
||||
|
||||
@@ -36,9 +36,10 @@ The new `Cycle` type is a sequence only, given that the `Collection` protocol
|
||||
design makes infinitely large types impossible/impractical. `Cycle` also
|
||||
conforms to `LazySequenceProtocol` when the base type conforms.
|
||||
|
||||
Note that despite its name, the returned `FlattenSequence` will always have
|
||||
`Collection` conformance, and will have `BidirectionalCollection` conformance
|
||||
when called on a bidirectional collection.
|
||||
The `FiniteCycle` type always has `Collection` conformance, with
|
||||
`BidirectionalCollection` conformance
|
||||
when called on a bidirectional collection. `FiniteCycle` also
|
||||
conforms to `LazyCollectionProtocol` when the base type conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
@@ -61,4 +62,4 @@ anything that matches the `cycled(times:)` behavior.
|
||||
`cycled(times:)` here.
|
||||
|
||||
**Python:** Python’s `itertools` includes a `cycle` method, which caches the
|
||||
elements of the iterator on the first pass.
|
||||
elements of the iterator on the first pass.
|
||||
@@ -0,0 +1,85 @@
|
||||
# First Non-Nil
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/FirstNonNil.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/FirstNonNilTests.swift)]
|
||||
|
||||
Returns the first non-`nil` result obtained from applying the given
|
||||
transformation to the elements of the sequence.
|
||||
|
||||
```swift
|
||||
let strings = ["three", "3.14", "-5", "2"]
|
||||
if let firstInt = strings.firstNonNil({ Int($0) }) {
|
||||
print(firstInt)
|
||||
// -5
|
||||
}
|
||||
```
|
||||
|
||||
Like `first(where:)`, this method stops iterating the sequence once a match is
|
||||
found. Use `firstNonNil(_:)` to avoid having to apply a transformation twice:
|
||||
|
||||
```swift
|
||||
let strings = ["three", "3.14", "-5", "2"]
|
||||
if let firstIntAsString = strings.first(where: { Int($0) != nil }) {
|
||||
let firstInt = Int(firstIntAsString)! // :(
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
This method's behavior can also be approximated using `compactMap(_:)`:
|
||||
|
||||
```swift
|
||||
let strings = ["three", "3.14", "-5", "2"]
|
||||
if let firstInt = strings.compactMap({ Int($0) }).first {
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
However, unlike `firstNonNil(_:)` and `first(where:)`, `compactMap(_:)` does not
|
||||
stop iterating the sequence once the first match is found. Adding `.lazy` fixes
|
||||
this, at the cost of requiring an escaping closure that you cannot `throw` from:
|
||||
|
||||
```swift
|
||||
let strings = ["three", "3.14", "-5", "2"]
|
||||
if let firstInt = strings.lazy.compactMap({ Int($0) }).first {
|
||||
// ...
|
||||
}
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `firstNonNil(_:)` method is added as an extension method on the `Sequence`
|
||||
protocol:
|
||||
|
||||
```swift
|
||||
public extension Sequence {
|
||||
func firstNonNil<Result>(
|
||||
_ transform: (Element) throws -> Result?
|
||||
) rethrows -> Result?
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
`firstNonNil(_:)` is an O(*n*) operation, where *n* is the number of
|
||||
elements at the start of the sequence that result in `nil` when applying the
|
||||
transformation.
|
||||
|
||||
### Naming
|
||||
|
||||
Some alternative names were considered:
|
||||
|
||||
* `compactMapFirst(_:)`
|
||||
* `first(mapping:)`
|
||||
* `firstSome(_:)`
|
||||
* `firstMap(_:)`
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**Haskell**: Haskell includes the `firstJust` method, which has the same
|
||||
semantics as the `firstNonNil(_:)` method.
|
||||
|
||||
**Rust**: Rust includes the `find_map` method, which has the same semantics as
|
||||
the `firstNonNil(_:)` method.
|
||||
|
||||
**Scala**: Scala includes the `collectFirst` method, which has the same
|
||||
semantics as the `firstNonNil(_:)` method.
|
||||
+2
-2
@@ -30,6 +30,6 @@ extension Collection {
|
||||
```
|
||||
|
||||
`Indexed` scales from a collection up to a random-access collection, depending on
|
||||
its base type. `Indexed` also conforms to `LazySequenceProtocol` when the base type
|
||||
conforms.
|
||||
its base type. `Indexed` also conforms to `LazySequenceProtocol` and
|
||||
`LazyCollectionProtocol` when the base type conforms.
|
||||
|
||||
@@ -0,0 +1,58 @@
|
||||
# Intersperse
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Intersperse.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/IntersperseTests.swift)]
|
||||
|
||||
Place a given value in between each element of the sequence.
|
||||
|
||||
```swift
|
||||
let numbers = [1, 2, 3].interspersed(with: 0)
|
||||
// Array(numbers) == [1, 0, 2, 0, 3]
|
||||
|
||||
let letters = "ABCDE".interspersed(with: "-")
|
||||
// String(letters) == "A-B-C-D-E"
|
||||
|
||||
let empty = [].interspersed(with: 0)
|
||||
// Array(empty) == []
|
||||
```
|
||||
|
||||
`interspersed(with:)` takes a separator value and inserts it in between every
|
||||
element in the sequence.
|
||||
|
||||
## Detailed Design
|
||||
|
||||
A new method is added to sequence:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
func interspersed(with separator: Element) -> Intersperse<Self>
|
||||
}
|
||||
```
|
||||
|
||||
The new `Intersperse` type represents the sequence when the separator is
|
||||
inserted between each element. `Intersperse` conforms to `Collection`,
|
||||
`BidirectionalCollection`, `RandomAccessCollection`, `LazySequenceProtocol` and
|
||||
`LazyCollectionProtocol` when the base sequence conforms to those respective
|
||||
protocols.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling these methods is O(_1_).
|
||||
|
||||
### Naming
|
||||
|
||||
This method’s and type’s name match the term of art used in other languages
|
||||
and libraries.
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**[Haskell][Haskell]:** Has an `intersperse` function which takes an element
|
||||
and a list and 'intersperses' that element between the elements of the list.
|
||||
|
||||
**[Rust][Rust]:** Has a function called `intersperse` to insert a particular
|
||||
value between each element.
|
||||
|
||||
<!-- Link references for other languages -->
|
||||
|
||||
[Haskell]: https://hackage.haskell.org/package/base-4.14.0.0/docs/Data-List.html#v:intersperse
|
||||
[Rust]: https://docs.rs/itertools/0.9.0/itertools/trait.Itertools.html#method.intersperse
|
||||
@@ -0,0 +1,80 @@
|
||||
# LazySplit
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/LazySplit.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/LazySplitTests.swift)]
|
||||
|
||||
Lazily-evaluating versions of
|
||||
[`split(maxSplits:omittingEmptySubsequences:whereSeparator:)`](https://developer.apple.com/documentation/swift/sequence/3128814-split)
|
||||
and [`split(separator:maxSplits:omittingEmptySubsequences:)`](https://developer.apple.com/documentation/swift/sequence/3128818-split),
|
||||
performing the same operation as their counterparts defined on
|
||||
`Sequence` and `Collection`, are added to `LazySequence` and
|
||||
`LazyCollection`. The `LazyCollection` methods allow splitting a
|
||||
collection without allocating additional storage on the heap.
|
||||
|
||||
```swift
|
||||
// Splitting a lazy sequence.
|
||||
let numbers = stride(from: 1, through: 16, by: 1)
|
||||
for subsequence in numbers.lazy.split(
|
||||
whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
) {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints:
|
||||
[1, 2]
|
||||
[4]
|
||||
[7, 8]
|
||||
[11]
|
||||
[13, 14]
|
||||
[16]
|
||||
*/
|
||||
|
||||
// Splitting a lazy collection.
|
||||
let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
for subsequence in line.lazy.split(separator: " ") {
|
||||
print(subsequence)
|
||||
}
|
||||
/* Prints
|
||||
BLANCHE:
|
||||
I
|
||||
don't
|
||||
want
|
||||
realism.
|
||||
I
|
||||
want
|
||||
magic!
|
||||
*/
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
`LazySequence` and `LazyCollection` are each extended with
|
||||
`split(maxSplits:omittingEmptySubsequences:whereSeparator:)` and
|
||||
`split(separator:maxSplits:omittingEmptySubsequences:)`.
|
||||
|
||||
The `LazySequence` versions of those methods return an instance of
|
||||
`LazySplitSequence`. The `LazyCollection` versions return an instance of
|
||||
`LazySplitCollection`.
|
||||
|
||||
`LazySplitSequence` wraps the sequence to be split, and provides an
|
||||
iterator whose `next` method returns a newly-allocated array containing
|
||||
the elements of each subsequence in the split sequence in turn.
|
||||
|
||||
`LazySplitCollection` wraps the collection to be split. Its `Index`
|
||||
wraps a range of base collection indices. `startIndex` is computed at
|
||||
initialization. Subscripting a `LazySplitCollection` instance returns
|
||||
the slice of the original collection which is the subsequence of the
|
||||
split collection at the given index's position.
|
||||
|
||||
### Complexity
|
||||
|
||||
Iterating a `LazySplitSequence` instance is O(_n_) in time and space,
|
||||
since each subsequence returned is a newly-allocated array.
|
||||
|
||||
Iterating a `LazySplitCollection` instance is O(_n_) in time and O(1) in
|
||||
space, since each subsequence returned is a slice of the base
|
||||
collection. Since `startIndex` is computed at initialization, some or
|
||||
all of the time cost may be paid at initialization. For example, if the
|
||||
base collection contains no elements determined to be separators, it
|
||||
will be iterated entirely on initialization of the split collection, and
|
||||
all subsequent operations on the split collection, such as
|
||||
`index(after:)`, will have complexity O(1).
|
||||
@@ -0,0 +1,58 @@
|
||||
# Min/Max with Count
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/MinMax.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/MinMaxTests.swift)]
|
||||
|
||||
Returns the smallest or largest elements of this collection, sorted by a predicate or in the order defined by `Comparable` conformance.
|
||||
|
||||
If you need to sort a collection but only need access to a prefix or suffix of the sorted elements, using these methods can give you a performance boost over sorting the entire collection. The order of equal elements is guaranteed to be preserved.
|
||||
|
||||
```swift
|
||||
let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
let smallestThree = numbers.min(count: 3, sortedBy: <)
|
||||
// [1, 2, 3]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
This adds the `Collection` methods shown below:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func min(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element]
|
||||
|
||||
public func max(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element]
|
||||
}
|
||||
```
|
||||
|
||||
Additionally, versions of these methods for `Comparable` types are also provided:
|
||||
|
||||
```swift
|
||||
extension Collection where Element: Comparable {
|
||||
public func min(count: Int) -> [Element]
|
||||
|
||||
public func max(count: Int) -> [Element]
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The algorithm used is based on [Soroush Khanlou's research on this matter](https://khanlou.com/2018/12/analyzing-complexity/). The total complexity is `O(k log k + nk)`, which will result in a runtime close to `O(n)` if *k* is a small amount. If *k* is a large amount (more than 10% of the collection), we fall back to sorting the entire array. Realistically, this means the worst case is actually `O(n log n)`.
|
||||
|
||||
Here are some benchmarks we made that demonstrates how this implementation (SmallestM) behaves when *k* increases (before implementing the fallback):
|
||||
|
||||

|
||||

|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**C++:** The `<algorithm>` library defines a `partial_sort` function where the entire array is returned using a partial heap sort.
|
||||
|
||||
**Python:** Defines a `heapq` priority queue that can be used to manually achieve the same result.
|
||||
|
||||
+59
-12
@@ -3,7 +3,7 @@
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Permutations.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/PermutationsTests.swift)]
|
||||
|
||||
A type that computes permutations of a collection’s elements, or of a subset of
|
||||
Methods that compute permutations of a collection’s elements, or of a subset of
|
||||
those elements.
|
||||
|
||||
The `permutations(ofCount:)` method, when called without the `ofCount`
|
||||
@@ -60,23 +60,67 @@ for perm in numbers2.permutations() {
|
||||
// [10, 10, 20]
|
||||
```
|
||||
|
||||
To generate only unique permutations, use the `uniquePermutations(ofCount:)` method:
|
||||
|
||||
```swift
|
||||
for perm in numbers2.uniquePermutations() {
|
||||
print(perm)
|
||||
}
|
||||
// [20, 10, 10]
|
||||
// [10, 20, 10]
|
||||
// [10, 10, 20]
|
||||
```
|
||||
|
||||
Given a range, the methods return a sequence of all the different permutations of the given sizes of a collection’s elements in increasing order of size.
|
||||
|
||||
```swift
|
||||
let numbers = [10, 20, 30]
|
||||
for perm in numbers.permutations(ofCount: 0...) {
|
||||
print(perm)
|
||||
}
|
||||
// []
|
||||
// [10]
|
||||
// [20]
|
||||
// [30]
|
||||
// [10, 20]
|
||||
// [10, 30]
|
||||
// [20, 10]
|
||||
// [20, 30]
|
||||
// [30, 10]
|
||||
// [30, 20]
|
||||
// [10, 20, 30]
|
||||
// [10, 30, 20]
|
||||
// [20, 10, 30]
|
||||
// [20, 30, 10]
|
||||
// [30, 10, 20]
|
||||
// [30, 20, 10]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `permutations(ofCount:)` method is declared as a `Collection` extension,
|
||||
and returns a `Permutations` type:
|
||||
The `permutations(ofCount:)` and `uniquePermutations(ofCount:)` methods are declared as `Collection` extensions,
|
||||
and return `Permutations` and `UniquePermutations` instances, respectively:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func permutations(ofCount k: Int? = nil) -> Permutations<Self>
|
||||
public func permutations<R>(ofCount kRange: R) -> Permutations<Self>
|
||||
where R: RangeExpression, R.Bound == Int
|
||||
}
|
||||
|
||||
extension Collection where Element: Hashable {
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutations<Self>
|
||||
public func uniquePermutations<R>(ofCount kRange: R) -> UniquePermutations<Self>
|
||||
where R: RangeExpression, R.Bound == Int
|
||||
}
|
||||
```
|
||||
|
||||
Since the `Permutations` type needs to store an array of the collection’s
|
||||
indices and mutate the array to generate each permutation, `Permutations` only
|
||||
has `Sequence` conformance. Adding `Collection` conformance would require
|
||||
Since both result types need to store an array of the collection’s
|
||||
indices and mutate the array to generate each permutation, they only
|
||||
have `Sequence` conformance. Adding `Collection` conformance would require
|
||||
storing the array in the index type, which would in turn lead to copying the
|
||||
array at every index advancement. `Combinations` does conform to
|
||||
`LazySequenceProtocol` when the base type conforms.
|
||||
array at every index advancement. The `Permutations` type
|
||||
conforms to `LazySequenceProtocol` when its base type conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
@@ -84,6 +128,10 @@ Calling `permutations()` is an O(1) operation. Creating the iterator for a
|
||||
`Permutations` instance and each call to `Permutations.Iterator.next()` is an
|
||||
O(_n_) operation.
|
||||
|
||||
Calling `uniquePermutations()` is an O(_n_) operation, because it preprocesses the
|
||||
collection to find duplicate elements. Creating the iterator for and each call to
|
||||
`next()` is also an O(_n_) operation.
|
||||
|
||||
### Naming
|
||||
|
||||
See the ["Naming" section for `combinations(ofCount:)`](Combinations.md#naming) for detail.
|
||||
@@ -92,9 +140,8 @@ See the ["Naming" section for `combinations(ofCount:)`](Combinations.md#naming)
|
||||
|
||||
**C++:** The `<algorithm>` library defines a `next_permutation` function that
|
||||
advances an array of comparable values through their lexicographic orderings.
|
||||
This function is tricky to use and understand, so while it’s included in
|
||||
`swift-algorithms` as an implementation detail of the `Permutations` type, it
|
||||
isn’t public.
|
||||
This function is very similar to the `uniquePermutations(ofCount:)` method.
|
||||
|
||||
**Rust/Ruby/Python:** Rust, Ruby, and Python all define functions with
|
||||
essentially the same semantics as the method described here.
|
||||
essentially the same semantics as the `permutations(ofCount:)` method
|
||||
described here.
|
||||
@@ -0,0 +1,134 @@
|
||||
# Reductions
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Reductions.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/ReductionsTests.swift)]
|
||||
|
||||
Produces all the intermediate results of reducing a sequence's elements using a closure.
|
||||
|
||||
```swift
|
||||
let exclusiveRunningTotal = (1...5).reductions(0, +)
|
||||
print(exclusiveRunningTotal)
|
||||
// prints [0, 1, 3, 6, 10, 15]
|
||||
|
||||
let intoRunningTotal = (1...5).reductions(into: 0, +=)
|
||||
print(intoRunningTotal)
|
||||
// prints [0, 1, 3, 6, 10, 15]
|
||||
|
||||
let inclusiveRunningTotal = (1...5).reductions(+)
|
||||
print(inclusiveRunningTotal)
|
||||
// prints [1, 3, 6, 10, 15]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
One trio of methods are added to `LazySequenceProtocol` for a lazily evaluated
|
||||
sequence and another trio are added to `Sequence` which are eagerly evaluated.
|
||||
|
||||
```swift
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductions<Result, Self>
|
||||
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductions<Result, Self>
|
||||
|
||||
public func reductions(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductions<Self>
|
||||
}
|
||||
```
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result]
|
||||
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result]
|
||||
|
||||
public func reductions(
|
||||
_ transform: (Element, Element) throws -> Element
|
||||
) rethrows -> [Element]
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling the lazy methods, those defined on `LazySequenceProtocol`, is O(_1_).
|
||||
Calling the eager methods, those returning an array, is O(_n_).
|
||||
|
||||
### Naming
|
||||
|
||||
While the name `scan` is the term of art for this function, it has been
|
||||
discussed that `reductions` aligns better with the existing `reduce` function
|
||||
and will aid newcomers that might not know the existing `scan` term.
|
||||
|
||||
Deprecated `scan` methods have been added for people who are familiar with the
|
||||
term, so they can easily discover the `reductions` methods via compiler
|
||||
deprecation warnings.
|
||||
|
||||
Below are two quotes from the Swift forum [discussion about SE-0045][SE-0045]
|
||||
which proposed adding `scan` to the standard library and one from
|
||||
[issue #25][Issue 25] on the swift-algorithms GitHub project. These provide
|
||||
the reasoning to use the name `reductions`.
|
||||
|
||||
[Brent Royal-Gordon][Brent_Royal-Gordon]:
|
||||
> I really like the `reduce`/`reductions` pairing instead of `reduce`/`scan`;
|
||||
it does a really good job of explaining the relationship between the two
|
||||
functions.
|
||||
|
||||
[David Rönnqvist][David Rönnqvist]:
|
||||
> As other have already pointed out, I also feel that `scan` is the least
|
||||
intuitive name among these and that the `reduce`/`reductions` pairing would do
|
||||
a good job at explaining the relation between the two.
|
||||
|
||||
[Kyle Macomber][Kyle Macomber]:
|
||||
> As someone unfamiliar with the prior art, `reductions` strikes me as very
|
||||
approachable—I feel like I can extrapolate the expected behavior purely from my
|
||||
familiarity with `reduce`.
|
||||
|
||||
As part of early discussions, it was decided to have two variants, one which
|
||||
takes an initial value to use for the first element in the returned sequence,
|
||||
and another which uses the first value of the base sequence as the initial
|
||||
value. C++ calls these variants exclusive and inclusive respectively and so
|
||||
these terms carry through as the name for the lazy sequences;
|
||||
`ExclusiveReductions` and `InclusiveReductions`.
|
||||
|
||||
[SE-0045]: https://forums.swift.org/t/review-se-0045-add-scan-prefix-while-drop-while-and-iterate-to-the-stdlib/2382
|
||||
[Issue 25]: https://github.com/apple/swift-algorithms/issues/25
|
||||
[Brent_Royal-Gordon]: https://forums.swift.org/t/review-se-0045-add-scan-prefix-while-drop-while-and-iterate-to-the-stdlib/2382/6
|
||||
[David Rönnqvist]: https://forums.swift.org/t/review-se-0045-add-scan-prefix-while-drop-while-and-iterate-to-the-stdlib/2382/8
|
||||
[Kyle Macomber]: https://github.com/apple/swift-algorithms/issues/25#issuecomment-709317894
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
**C++:** As of C++17, the `<algorithm>` library includes both
|
||||
[`exclusive_scan`][C++ Exclusive] and [`inclusive_scan`][C++ Inclusive]
|
||||
functions.
|
||||
|
||||
**[Clojure][Clojure]:** Clojure 1.2 added a `reductions` function.
|
||||
|
||||
**[Haskell][Haskell]:** Haskell includes a `scan` function for its
|
||||
`Traversable` type, which is akin to Swift's `Sequence`.
|
||||
|
||||
**Python:** Python’s `itertools` includes an `accumulate` method. In version
|
||||
3.3, a function parameter was added. Version 3.8 added the optional initial
|
||||
parameter.
|
||||
|
||||
**[Rust][Rust]:** Rust provides a `scan` function.
|
||||
|
||||
[C++ Exclusive]: https://en.cppreference.com/w/cpp/algorithm/exclusive_scan
|
||||
[C++ Inclusive]: https://en.cppreference.com/w/cpp/algorithm/inclusive_scan
|
||||
[Clojure]: http://clojure.github.io/clojure/clojure.core-api.html#clojure.core/reductions
|
||||
[Haskell]: http://hackage.haskell.org/package/base-4.8.2.0/docs/Prelude.html#v:scanl
|
||||
[Rust]: https://doc.rust-lang.org/std/iter/trait.Iterator.html#method.scan
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 74 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
@@ -0,0 +1,63 @@
|
||||
# Stride
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Stride.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/StrideTests.swift)]
|
||||
|
||||
A type that steps over sequence elements by the specified amount.
|
||||
|
||||
This is available through the `striding(by:)` method on any `Sequence`.
|
||||
|
||||
```swift
|
||||
(0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
```
|
||||
|
||||
If the stride is larger than the count, the resulting wrapper only contains the
|
||||
first element.
|
||||
|
||||
The stride amount must be a positive value.
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `striding(by:)` method is declared as a `Sequence` extension, and returns a
|
||||
`Stride` type:
|
||||
|
||||
```swift
|
||||
extension Sequence {
|
||||
public func striding(by step: Int) -> Stride<Self>
|
||||
}
|
||||
```
|
||||
|
||||
A custom `Index` type is defined so that it's not possible to get confused when trying
|
||||
to access an index of the stride collection.
|
||||
|
||||
```swift
|
||||
[0, 1, 2, 3, 4].striding(by: 2)[1] // == 1
|
||||
[0, 1, 2, 3, 4].striding(by: 2).map { $0 }[1] // == 2
|
||||
```
|
||||
|
||||
A careful thought was given to the composition of these strides by giving a custom
|
||||
implementation to `index(_:offsetBy:limitedBy)` which multiplies the offset by the
|
||||
stride amount.
|
||||
|
||||
```swift
|
||||
base.index(i.base, offsetBy: distance * stride, limitedBy: base.endIndex)
|
||||
```
|
||||
|
||||
The following two lines of code are equivalent, including performance:
|
||||
|
||||
```swift
|
||||
(0...10).striding(by: 6)
|
||||
(0...10).striding(by: 2).stride(by: 3)
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The call to `striding(by: k)` is always O(_1_) and access to the next value in the stride
|
||||
is O(_1_) if the collection conforms to `RandomAccessCollection`, otherwise O(_k_).
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
[rust has `Strided`](https://docs.rs/strided/0.2.9/strided/) available in a crate.
|
||||
[c++ has std::slice::stride](http://www.cplusplus.com/reference/valarray/slice/stride/)
|
||||
|
||||
The semantics of `striding` described in this documentation are equivalent.
|
||||
@@ -0,0 +1,39 @@
|
||||
# Suffix
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Suffix.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/SuffixTests.swift)]
|
||||
|
||||
|
||||
This function returns a subsequence containing the elements from the end of the collection until predicate returns `false` and skipping the remaining elements.
|
||||
|
||||
This example uses `suffix(while: )` to iterate through collection of integers from the end until the predicate returns false, in this case when `$0 <= 5`
|
||||
```swift
|
||||
(0...10).suffix(while: { $0 > 5 } // == [6,7,8,9,10]
|
||||
```
|
||||
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `suffix(while:)` function is added as a method on an extension of `BidirectionalCollection`.
|
||||
|
||||
|
||||
```swift
|
||||
extension BidirectionalCollection {
|
||||
|
||||
public func suffix(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
}
|
||||
```
|
||||
|
||||
This method requires `BidirectionalCollection` for an efficient implementation which visits as few elements as possible. Swift's protocol allows for backward traversal of a collection as well as access to *last* property of a collection.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling this method is O(*n*), where *n* is the length of the collection.
|
||||
|
||||
|
||||
### Naming
|
||||
|
||||
The function's name resembles that of an existing Swift function `prefix(while:)`, which performs same operation however in the forward direction of the collection. Hence, as this function traverses from the end of the collection, `suffix(while:)` is an appropriate name.
|
||||
|
||||
|
||||
|
||||
+114
@@ -0,0 +1,114 @@
|
||||
# Trim
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Trim.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/TrimTests.swift)]
|
||||
|
||||
Returns a `SubSequence` formed by discarding all elements at the start and end of the collection
|
||||
which satisfy the given predicate.
|
||||
|
||||
This example uses `trimming(while:)` to get a substring without the white space at the beginning and end of the string.
|
||||
|
||||
```swift
|
||||
let myString = " hello, world "
|
||||
print(myString.trimming(while: \.isWhitespace)) // "hello, world"
|
||||
|
||||
let results = [2, 10, 11, 15, 20, 21, 100].trimming(while: { $0.isMultiple(of: 2) })
|
||||
print(results) // [11, 15, 20, 21]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
A new method is added to `BidirectionalCollection`:
|
||||
|
||||
```swift
|
||||
extension BidirectionalCollection {
|
||||
|
||||
public func trimming(while predicate: (Element) throws -> Bool) rethrows -> SubSequence
|
||||
}
|
||||
```
|
||||
|
||||
This method requires `BidirectionalCollection` for an efficient implementation which visits as few elements as possible.
|
||||
|
||||
A less-efficient implementation is _possible_ for any `Collection`, which would involve always traversing the
|
||||
entire collection. This implementation is not provided, as it would mean developers of generic algorithms who forget
|
||||
to add the `BidirectionalCollection` constraint will receive that inefficient implementation:
|
||||
|
||||
```swift
|
||||
func myAlgorithm<Input>(input: Input) where Input: Collection {
|
||||
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses least-efficient implementation.
|
||||
}
|
||||
|
||||
func myAlgorithm2<Input>(input: Input) where Input: BidirectionalCollection {
|
||||
|
||||
let trimmedInput = input.trimming(while: { ... }) // Uses most-efficient implementation.
|
||||
}
|
||||
```
|
||||
|
||||
Swift provides the `BidirectionalCollection` protocol for marking types which support reverse traversal,
|
||||
and generic types and algorithms which want to make use of that should add it to their constraints.
|
||||
|
||||
### Complexity
|
||||
|
||||
Calling this method is O(_n_).
|
||||
|
||||
### Naming
|
||||
|
||||
The name `trim` has precedent in other programming languages. Another popular alternative might be `strip`.
|
||||
|
||||
| Example usage | Languages |
|
||||
|-|-|
|
||||
| ''String''.Trim([''chars'']) | C#, VB.NET, Windows PowerShell |
|
||||
| ''string''.strip(); | D |
|
||||
| (.trim ''string'') | Clojure |
|
||||
| ''sequence'' [ predicate? ] trim | Factor |
|
||||
| (string-trim '(#\Space #\Tab #\Newline) ''string'') | Common Lisp |
|
||||
| (string-trim ''string'') | Scheme |
|
||||
| ''string''.trim() | Java, JavaScript (1.8.1+), Rust |
|
||||
| Trim(''String'') | Pascal, QBasic, Visual Basic, Delphi |
|
||||
| ''string''.strip() | Python |
|
||||
| strings.Trim(''string'', ''chars'') | Go |
|
||||
| LTRIM(RTRIM(''String'')) | Oracle SQL, T-SQL |
|
||||
| string:strip(''string'' [,''option'', ''char'']) | Erlang |
|
||||
| ''string''.strip or ''string''.lstrip or ''string''.rstrip | Ruby |
|
||||
| trim(''string'') | PHP, Raku |
|
||||
| [''string'' stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]] | Objective-C/Cocoa |
|
||||
| ''string'' withBlanksTrimmed ''string'' withoutSpaces ''string'' withoutSeparators | Smalltalk |
|
||||
| string trim ''$string'' | Tcl |
|
||||
| TRIM(''string'') or TRIM(ADJUSTL(''string'')) | Fortran |
|
||||
| TRIM(''string'') | SQL |
|
||||
| String.trim ''string'' | OCaml 4+ |
|
||||
|
||||
Note: This is an abbreviated list from Wikipedia. [Full table](https://en.wikipedia.org/wiki/Comparison_of_programming_languages_(string_functions)#trim)
|
||||
|
||||
The standard library includes a variety of methods which perform similar operations:
|
||||
|
||||
- Firstly, there are `dropFirst(Int)` and `dropLast(Int)`. These return slices but do not support user-defined predicates.
|
||||
If the collection's `count` is less than the number of elements to drop, they return an empty slice.
|
||||
- Secondly, there is `drop(while:)`, which also returns a slice and is equivalent to a 'left-trim' (trimming from the head but not the tail).
|
||||
If the entire collection is dropped, this method returns an empty slice.
|
||||
- Thirdly, there are `removeFirst(Int)` and `removeLast(Int)` which do not return slices and actually mutate the collection.
|
||||
If the collection's `count` is less than the number of elements to remove, this method triggers a runtime error.
|
||||
- Lastly, there are the `popFirst()` and `popLast()` methods, which work like `removeFirst()` and `removeLast()`,
|
||||
except they do not trigger a runtime error for empty collections.
|
||||
|
||||
The closest neighbours to this function would be the `drop` family of methods. Unfortunately, unlike `dropFirst(Int)`,
|
||||
the name `drop(while:)` does not specify which end(s) of the collection it operates on. Moreover, one could easily
|
||||
mistake code such as:
|
||||
|
||||
```swift
|
||||
let result = myString.drop(while: \.isWhitespace)
|
||||
```
|
||||
|
||||
With a lazy filter that drops _all_ whitespace characters regardless of where they are in the string.
|
||||
Besides that, the root `trim` leads to clearer, more concise code, which is more aligned with other programming
|
||||
languages:
|
||||
|
||||
```swift
|
||||
// Does `result` contain the input, trimmed of certain elements?
|
||||
// Or does this code mutate `input` in-place and return the elements which were dropped?
|
||||
let result = input.dropFromBothEnds(while: { ... })
|
||||
|
||||
// No such ambiguity here.
|
||||
let result = input.trimming(while: { ... })
|
||||
```
|
||||
+14
-7
@@ -5,7 +5,7 @@
|
||||
|
||||
Methods to strip repeated elements from a sequence or collection.
|
||||
|
||||
The `uniqued()` method returns an array, dropping duplicate elements
|
||||
The `uniqued()` method returns a sequence, dropping duplicate elements
|
||||
from a sequence. The `uniqued(on:)` method does the same, using
|
||||
the result of the given closure to determine the "uniqueness" of each
|
||||
element.
|
||||
@@ -14,29 +14,36 @@ element.
|
||||
let numbers = [1, 2, 3, 3, 2, 3, 3, 2, 2, 2, 1]
|
||||
|
||||
let unique = numbers.uniqued()
|
||||
// unique == [1, 2, 3]
|
||||
// Array(unique) == [1, 2, 3]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
Both methods are available for sequences, with the simplest limited to
|
||||
when the element type conforms to `Hashable`. Both methods preserve
|
||||
the relative order of the elements.
|
||||
the relative order of the elements. `uniqued(on:)` has a matching lazy
|
||||
version that is added to `LazySequenceProtocol`.
|
||||
|
||||
```swift
|
||||
extension Sequence where Element: Hashable {
|
||||
func uniqued() -> [Element]
|
||||
func uniqued() -> Uniqued<Self, Element>
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
func uniqued<T>(on: (Element) throws -> T) rethrows -> [Element]
|
||||
where T: Hashable
|
||||
func uniqued<Subject>(on projection: (Element) throws -> Subject) rethrows -> [Element]
|
||||
where Subject: Hashable
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
func uniqued<Subject>(on projection: @escaping (Element) -> Subject) -> Uniqued<Self, Subject>
|
||||
where Subject: Hashable
|
||||
}
|
||||
```
|
||||
|
||||
### Complexity
|
||||
|
||||
The `uniqued` methods are O(_n_) in both time and space complexity.
|
||||
The eager `uniqued(on:)` method is O(_n_) in both time and space complexity.
|
||||
The lazy versions are O(_1_).
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
# Windows
|
||||
|
||||
[[Source](https://github.com/apple/swift-algorithms/blob/main/Sources/Algorithms/Windows.swift) |
|
||||
[Tests](https://github.com/apple/swift-algorithms/blob/main/Tests/SwiftAlgorithmsTests/WindowsTests.swift)]
|
||||
|
||||
Break a collection into overlapping subsequences where
|
||||
elements are slices from the original collection.
|
||||
|
||||
The `windows(ofCount:)` method takes a size as a parameter and returns a collection of subsequences. Each element of the returned collection is a successive overlapping slice of the given size.
|
||||
|
||||
```swift
|
||||
let swift = "swift"
|
||||
|
||||
let windowed = swift.windows(ofCount: 2)
|
||||
// Array(windowed) == [ "sw", "wi", "if", "ft" ]
|
||||
```
|
||||
|
||||
## Detailed Design
|
||||
|
||||
The `windows(ofCount:)` method is added as an extension `Collection` method:
|
||||
|
||||
```swift
|
||||
extension Collection {
|
||||
public func windows(ofCount count: Int) -> Windows<Self>
|
||||
}
|
||||
```
|
||||
|
||||
If a size larger than the collection's length is specified, the returned collection is empty.
|
||||
|
||||
```swift
|
||||
[1, 2, 3].windows(ofCount: 5).isEmpty // true
|
||||
```
|
||||
|
||||
The resulting `Windows` type is a collection, with conditional conformance to the
|
||||
`BidirectionalCollection`, `RandomAccessCollection`, and
|
||||
`LazyCollectionProtocol` protocols when the base collection conforms.
|
||||
|
||||
### Complexity
|
||||
|
||||
The call to `windows(ofCount: k)` is O(1) if the collection conforms to
|
||||
`RandomAccessCollection`, otherwise O(_k_). Access to each successive window is O(1).
|
||||
|
||||
### Naming
|
||||
|
||||
The method and type name take their names from the sliding windows algorithm.
|
||||
|
||||
The `ofCount` parameter label was chosen to create a consistent feel with other
|
||||
APIs in the `Algorithms` package, specifically with `combinations(ofCount:)`
|
||||
and `permutations(ofCount:)`.
|
||||
|
||||
### Comparison with other languages
|
||||
|
||||
[rust](https://doc.rust-lang.org/std/slice/struct.Windows.html) has
|
||||
`std::slice::Windows` which is a method available on slices. It has the same
|
||||
semantics as described here.
|
||||
@@ -8,8 +8,9 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
|
||||
#### Combinations / permutations
|
||||
|
||||
- [`combinations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of a particular size of the elements in a collection.
|
||||
- [`combinations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Combinations.md): Combinations of particular sizes of the elements in a collection.
|
||||
- [`permutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a particular size of the elements in a collection, or of the full collection.
|
||||
- [`uniquePermutations(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Permutations.md): Permutations of a collection's elements, skipping any duplicate permutations.
|
||||
|
||||
#### Mutating algorithms
|
||||
|
||||
@@ -24,15 +25,27 @@ Read more about the package, and the intent behind it, in the [announcement on s
|
||||
|
||||
#### Subsetting operations
|
||||
|
||||
- [`compacted()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Compacted.md): Drops the `nil`s from a sequence or collection, unwrapping the remaining elements.
|
||||
- [`randomSample(count:)`, `randomSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection.
|
||||
- [`randomStableSample(count:)`, `randomStableSample(count:using:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/RandomSampling.md): Randomly selects a specific number of elements from a collection, preserving their original relative order.
|
||||
- [`striding(by:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Stride.md): Returns every nth element of a collection.
|
||||
- [`suffix(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Suffix.md): Returns the suffix of a collection where all element pass a given predicate.
|
||||
- [`trimming(while:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Trim.md): Returns a slice by trimming elements from a collection's start and end.
|
||||
- [`uniqued()`, `uniqued(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Unique.md): The unique elements of a collection, preserving their order.
|
||||
|
||||
#### Partial sorting
|
||||
|
||||
- [`min(count:)`, `max(count:)`, `min(count:sortedBy:)`, `max(count:sortedBy:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/MinMax.md): Returns the smallest or largest elements of a collection, sorted by a predicate.
|
||||
|
||||
#### Other useful operations
|
||||
|
||||
- [`chunked(by:)`, `chunked(on:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chunked.md): Eager and lazy operations that break a collection into chunks based on either a binary predicate or when the result of a projection changes.
|
||||
- [`chunked(by:)`, `chunked(on:)`, `chunks(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Chunked.md): Eager and lazy operations that break a collection into chunks based on either a binary predicate or when the result of a projection changes or chunks of a given count.
|
||||
- [`firstNonNil(_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/FirstNonNil.md): Returns the first non-`nil` result from transforming a sequence's elements.
|
||||
- [`indexed()`](https://github.com/apple/swift-algorithms/blob/main/Guides/Indexed.md): Iterate over tuples of a collection's indices and elements.
|
||||
|
||||
- [`interspersed(with:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Intersperse.md): Place a value between every two elements of a sequence.
|
||||
- [`reductions(_:)`, `reductions(_:_:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Reductions.md): Returns all the intermediate states of reducing the elements of a sequence or collection.
|
||||
- [`split(maxSplits:omittingEmptySubsequences:whereSeparator)`, `split(separator:maxSplits:omittingEmptySubsequences)`](https://github.com/apple/swift-algorithms/blob/main/Guides/LazySplit.md): Lazy versions of the Standard Library's eager operations that split sequences and collections into subsequences separated by the specified separator element.
|
||||
- [`windows(ofCount:)`](https://github.com/apple/swift-algorithms/blob/main/Guides/Windows.md): Breaks a collection into overlapping subsequences where elements are slices from the original collection.
|
||||
|
||||
## Adding Swift Algorithms as a Dependency
|
||||
|
||||
@@ -49,7 +62,7 @@ If you don't want potentially source-breaking package updates,
|
||||
use this dependency specification instead:
|
||||
|
||||
```swift
|
||||
.package(url: "https://github.com/apple/swift-algorithms", .upToNextMinor(from: "0.0.1")),
|
||||
.package(url: "https://github.com/apple/swift-algorithms", .upToNextMinor(from: "0.1.0")),
|
||||
```
|
||||
|
||||
Finally, include `"Algorithms"` as a dependency for your executable target:
|
||||
@@ -58,7 +71,7 @@ Finally, include `"Algorithms"` as a dependency for your executable target:
|
||||
let package = Package(
|
||||
// name, platforms, products, etc.
|
||||
dependencies: [
|
||||
.package(url: "https://github.com/apple/swift-algorithms", from: "0.0.1"),
|
||||
.package(url: "https://github.com/apple/swift-algorithms", from: "0.1.0"),
|
||||
// other dependencies
|
||||
],
|
||||
targets: [
|
||||
|
||||
@@ -14,11 +14,14 @@ public struct Chain2<Base1: Sequence, Base2: Sequence>
|
||||
where Base1.Element == Base2.Element
|
||||
{
|
||||
/// The first sequence in this chain.
|
||||
public let base1: Base1
|
||||
@usableFromInline
|
||||
internal let base1: Base1
|
||||
|
||||
/// The second sequence in this chain.
|
||||
public let base2: Base2
|
||||
@usableFromInline
|
||||
internal let base2: Base2
|
||||
|
||||
@inlinable
|
||||
internal init(base1: Base1, base2: Base2) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
@@ -26,7 +29,7 @@ public struct Chain2<Base1: Sequence, Base2: Sequence>
|
||||
}
|
||||
|
||||
extension Chain2: Sequence {
|
||||
/// The iterator for a `Chain` sequence.
|
||||
/// The iterator for a `Chain2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator1: Base1.Iterator
|
||||
@@ -34,7 +37,7 @@ extension Chain2: Sequence {
|
||||
@usableFromInline
|
||||
internal var iterator2: Base2.Iterator
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(_ concatenation: Chain2) {
|
||||
iterator1 = concatenation.base1.makeIterator()
|
||||
iterator2 = concatenation.base2.makeIterator()
|
||||
@@ -53,7 +56,7 @@ extension Chain2: Sequence {
|
||||
}
|
||||
|
||||
extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
/// A position in a `Chain` collection.
|
||||
/// A position in a `Chain2` collection.
|
||||
public struct Index: Comparable {
|
||||
// The internal index representation, which can either be an index of the
|
||||
// first collection or the second. The `endIndex` of the first collection
|
||||
@@ -70,13 +73,13 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
internal let position: Representation
|
||||
|
||||
/// Creates a new index into the first underlying collection.
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(first i: Base1.Index) {
|
||||
position = .first(i)
|
||||
}
|
||||
|
||||
/// Creates a new index into the second underlying collection.
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(second i: Base2.Index) {
|
||||
position = .second(i)
|
||||
}
|
||||
@@ -98,8 +101,8 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
|
||||
/// Converts an index of `Base1` to the corresponding `Index` by mapping
|
||||
/// `base1.endIndex` to `base2.startIndex`.
|
||||
@usableFromInline
|
||||
internal func convertIndex(_ i: Base1.Index) -> Index {
|
||||
@inlinable
|
||||
internal func normalizeIndex(_ i: Base1.Index) -> Index {
|
||||
i == base1.endIndex ? Index(second: base2.startIndex) : Index(first: i)
|
||||
}
|
||||
|
||||
@@ -107,7 +110,7 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
public var startIndex: Index {
|
||||
// if `base1` is empty, this will return `base2.startIndex` - if `base2` is
|
||||
// also empty, this will correctly equal `base2.endIndex`
|
||||
convertIndex(base1.startIndex)
|
||||
normalizeIndex(base1.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
@@ -130,109 +133,116 @@ extension Chain2: Collection where Base1: Collection, Base2: Collection {
|
||||
switch i.position {
|
||||
case let .first(i):
|
||||
assert(i != base1.endIndex)
|
||||
return convertIndex(base1.index(after: i))
|
||||
return normalizeIndex(base1.index(after: i))
|
||||
case let .second(i):
|
||||
return Index(second: base2.index(after: i))
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy n: Int) -> Index {
|
||||
if n == 0 { return i }
|
||||
return n > 0
|
||||
? offsetForward(i, by: n, limitedBy: endIndex)!
|
||||
: offsetBackward(i, by: -n, limitedBy: startIndex)!
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy n: Int,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if n == 0 { return i }
|
||||
return n > 0
|
||||
? offsetForward(i, by: n, limitedBy: limit)
|
||||
: offsetBackward(i, by: -n, limitedBy: limit)
|
||||
if distance >= 0 {
|
||||
return limit >= i
|
||||
? offsetForward(i, by: distance, limitedBy: limit)
|
||||
: offsetForward(i, by: distance)
|
||||
} else {
|
||||
return limit <= i
|
||||
? offsetBackward(i, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by n: Int, limitedBy limit: Index
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= i)
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
if limit >= i {
|
||||
// `limit` is relevant, so `base2` cannot be reached
|
||||
return base1.index(i, offsetBy: n, limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
} else if let j = base1.index(i, offsetBy: n, limitedBy: base1.endIndex) {
|
||||
// the offset stays within the bounds of `base1`
|
||||
return convertIndex(j)
|
||||
} else {
|
||||
// the offset overflows the bounds of `base1` by `n - d`
|
||||
let d = base1.distance(from: i, to: base1.endIndex)
|
||||
return Index(second: base2.index(base2.startIndex, offsetBy: n - d))
|
||||
}
|
||||
return base1.index(i, offsetBy: distance, limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
|
||||
case let (.first(i), .second(limit)):
|
||||
if let j = base1.index(i, offsetBy: n, limitedBy: base1.endIndex) {
|
||||
if let j = base1.index(i, offsetBy: distance, limitedBy: base1.endIndex) {
|
||||
// the offset stays within the bounds of `base1`
|
||||
return convertIndex(j)
|
||||
return normalizeIndex(j)
|
||||
} else {
|
||||
// the offset overflows the bounds of `base1` by `n - d`
|
||||
let d = base1.distance(from: i, to: base1.endIndex)
|
||||
return base2.index(base2.startIndex, offsetBy: n - d, limitedBy: limit)
|
||||
return base2.index(base2.startIndex, offsetBy: distance - d, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
|
||||
case let (.second(i), .first):
|
||||
// `limit` has no effect here
|
||||
return Index(second: base2.index(i, offsetBy: n))
|
||||
case (.second, .first):
|
||||
// impossible because `limit >= i`
|
||||
fatalError()
|
||||
|
||||
case let (.second(i), .second(limit)):
|
||||
return base2.index(i, offsetBy: n, limitedBy: limit)
|
||||
return base2.index(i, offsetBy: distance, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by n: Int, limitedBy limit: Index
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= i)
|
||||
|
||||
switch (i.position, limit.position) {
|
||||
case let (.first(i), .first(limit)):
|
||||
return base1.index(i, offsetBy: -n, limitedBy: limit)
|
||||
return base1.index(i, offsetBy: -distance, limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
|
||||
case let (.first(i), .second):
|
||||
// `limit` has no effect here
|
||||
return Index(first: base1.index(i, offsetBy: -n))
|
||||
case (.first, .second):
|
||||
// impossible because `limit <= i`
|
||||
fatalError()
|
||||
|
||||
case let (.second(i), .first(limit)):
|
||||
if let j = base2.index(i, offsetBy: -n, limitedBy: base2.startIndex) {
|
||||
if let j = base2.index(i, offsetBy: -distance, limitedBy: base2.startIndex) {
|
||||
// the offset stays within the bounds of `base2`
|
||||
return Index(second: j)
|
||||
} else {
|
||||
// the offset overflows the bounds of `base2` by `n - d`
|
||||
let d = base2.distance(from: base2.startIndex, to: i)
|
||||
return base1.index(base1.endIndex, offsetBy: -(n - d), limitedBy: limit)
|
||||
return base1.index(base1.endIndex, offsetBy: -(distance - d), limitedBy: limit)
|
||||
.map(Index.init(first:))
|
||||
}
|
||||
|
||||
case let (.second(i), .second(limit)):
|
||||
if limit <= i {
|
||||
// `limit` is relevant, so `base1` cannot be reached
|
||||
return base2.index(i, offsetBy: -n, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
} else if let j = base2.index(i, offsetBy: -n, limitedBy: base2.startIndex) {
|
||||
// the offset stays within the bounds of `base2`
|
||||
return Index(second: j)
|
||||
} else {
|
||||
// the offset overflows the bounds of `base2` by `n - d`
|
||||
let d = base2.distance(from: base2.startIndex, to: i)
|
||||
return Index(first: base1.index(base1.endIndex, offsetBy: -(n - d)))
|
||||
}
|
||||
// `limit` is relevant, so `base1` cannot be reached
|
||||
return base2.index(i, offsetBy: -distance, limitedBy: limit)
|
||||
.map(Index.init(second:))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -273,9 +283,6 @@ extension Chain2: BidirectionalCollection
|
||||
extension Chain2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
extension Chain2: Equatable where Base1: Equatable, Base2: Equatable {}
|
||||
extension Chain2: Hashable where Base1: Hashable, Base2: Hashable {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// chain(_:_:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -306,6 +313,7 @@ extension Chain2: Hashable where Base1: Hashable, Base2: Hashable {}
|
||||
/// then over the elements of `s2`.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func chain<S1, S2>(_ s1: S1, _ s2: S2) -> Chain2<S1, S2> {
|
||||
Chain2(base1: s1, base2: s2)
|
||||
}
|
||||
|
||||
@@ -9,129 +9,131 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
public struct LazyChunked<Base: Collection> {
|
||||
/// A collection wrapper that breaks a collection into chunks based on a
|
||||
/// predicate or projection.
|
||||
public struct Chunked<Base: Collection, Subject> {
|
||||
/// The collection that this instance provides a view onto.
|
||||
public let base: Base
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// The projection function.
|
||||
@usableFromInline
|
||||
internal var belongInSameGroup: (Base.Element, Base.Element) -> Bool
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
/// The predicate.
|
||||
@usableFromInline
|
||||
internal init(base: Base, belongInSameGroup: @escaping (Base.Element, Base.Element) -> Bool) {
|
||||
internal let belongInSameGroup: (Subject, Subject) -> Bool
|
||||
|
||||
/// The upper bound of the first chunk.
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
projection: @escaping (Base.Element) -> Subject,
|
||||
belongInSameGroup: @escaping (Subject, Subject) -> Bool
|
||||
) {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
self.belongInSameGroup = belongInSameGroup
|
||||
self.firstUpperBound = base.startIndex
|
||||
|
||||
if !base.isEmpty {
|
||||
firstUpperBound = endOfChunk(startingAt: base.startIndex)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension LazyChunked: LazyCollectionProtocol {
|
||||
extension Chunked: LazyCollectionProtocol {
|
||||
/// A position in a chunked collection.
|
||||
public struct Index: Comparable {
|
||||
/// The lower bound of the chunk at this position.
|
||||
/// The range corresponding to the chunk at this position.
|
||||
@usableFromInline
|
||||
internal var lowerBound: Base.Index
|
||||
internal var baseRange: Range<Base.Index>
|
||||
|
||||
/// The upper bound of the chunk at this position.
|
||||
///
|
||||
/// `upperBound` is optional so that computing `startIndex` can be an O(1)
|
||||
/// operation. When `upperBound` is `nil`, the actual upper bound is found
|
||||
/// when subscripting or calling `index(after:)`.
|
||||
@usableFromInline
|
||||
internal var upperBound: Base.Index?
|
||||
|
||||
@usableFromInline
|
||||
internal init(lowerBound: Base.Index, upperBound: Base.Index? = nil) {
|
||||
self.lowerBound = lowerBound
|
||||
self.upperBound = upperBound
|
||||
@inlinable
|
||||
internal init(_ baseRange: Range<Base.Index>) {
|
||||
self.baseRange = baseRange
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
// Only use the lower bound to test for equality, since sometimes the
|
||||
// `startIndex` will have an upper bound of `nil` and sometimes it won't,
|
||||
// such as when retrieved by:
|
||||
// `c.index(before: c.index(after: c.startIndex))`.
|
||||
//
|
||||
// Since each index represents the range of a disparate chunk, no two
|
||||
// unique indices will have the same lower bound.
|
||||
lhs.lowerBound == rhs.lowerBound
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
// Only use the lower bound to test for ordering, as above.
|
||||
lhs.lowerBound < rhs.lowerBound
|
||||
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the index in the base collection for the first element that
|
||||
/// doesn't match the current chunk.
|
||||
@usableFromInline
|
||||
internal func endOfChunk(from i: Base.Index) -> Base.Index {
|
||||
guard i != base.endIndex else { return base.endIndex }
|
||||
return base[base.index(after: i)...]
|
||||
.firstIndex(where: { !belongInSameGroup($0, base[i]) }) ?? base.endIndex
|
||||
/// Returns the index in the base collection of the end of the chunk starting
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func endOfChunk(startingAt start: Base.Index) -> Base.Index {
|
||||
let subject = projection(base[start])
|
||||
return base[base.index(after: start)...]
|
||||
.endOfPrefix(while: { belongInSameGroup(subject, projection($0)) })
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(lowerBound: base.startIndex)
|
||||
Index(base.startIndex..<firstUpperBound)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(lowerBound: base.endIndex, upperBound: base.endIndex)
|
||||
Index(base.endIndex..<base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
let upperBound = i.upperBound ?? endOfChunk(from: i.lowerBound)
|
||||
let end = endOfChunk(from: upperBound)
|
||||
return Index(lowerBound: upperBound, upperBound: end)
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
let upperBound = i.baseRange.upperBound
|
||||
guard upperBound != base.endIndex else { return endIndex }
|
||||
let end = endOfChunk(startingAt: upperBound)
|
||||
return Index(upperBound..<end)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.SubSequence {
|
||||
let upperBound = position.upperBound
|
||||
?? endOfChunk(from: position.lowerBound)
|
||||
return base[position.lowerBound..<upperBound]
|
||||
precondition(position != endIndex, "Can't subscript using endIndex")
|
||||
return base[position.baseRange]
|
||||
}
|
||||
}
|
||||
|
||||
extension LazyChunked.Index: Hashable where Base.Index: Hashable {}
|
||||
extension Chunked.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
extension LazyChunked: BidirectionalCollection
|
||||
extension Chunked: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
/// Returns the index in the base collection for the element that starts
|
||||
/// the chunk ending at the given index.
|
||||
@usableFromInline
|
||||
/// Returns the index in the base collection of the start of the chunk ending
|
||||
/// at the given index.
|
||||
@inlinable
|
||||
internal func startOfChunk(endingAt end: Base.Index) -> Base.Index {
|
||||
// Get the projected value of the last element in the range ending at `end`.
|
||||
let lastOfPreviousChunk = base[base.index(before: end)]
|
||||
let indexBeforeEnd = base.index(before: end)
|
||||
|
||||
// Search backward from `end` for the first element whose projection isn't
|
||||
// equal to `lastOfPreviousChunk`.
|
||||
if let firstMismatch = base[..<end]
|
||||
.lastIndex(where: { !belongInSameGroup($0, lastOfPreviousChunk) })
|
||||
{
|
||||
// If we found one, that's the last element of the _next_ previous chunk,
|
||||
// and therefore one position _before_ the start of this chunk.
|
||||
return base.index(after: firstMismatch)
|
||||
} else {
|
||||
// If we didn't find such an element, this chunk extends back to the start
|
||||
// of the collection.
|
||||
return base.startIndex
|
||||
}
|
||||
// Get the projected value of the last element in the range ending at `end`.
|
||||
let subject = projection(base[indexBeforeEnd])
|
||||
return base[..<indexBeforeEnd]
|
||||
.startOfSuffix(while: { belongInSameGroup(projection($0), subject) })
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
let start = startOfChunk(endingAt: i.lowerBound)
|
||||
return Index(lowerBound: start, upperBound: i.lowerBound)
|
||||
precondition(i != startIndex, "Can't advance before startIndex")
|
||||
let start = startOfChunk(endingAt: i.baseRange.lowerBound)
|
||||
return Index(start..<i.baseRange.lowerBound)
|
||||
}
|
||||
}
|
||||
|
||||
@available(*, deprecated, renamed: "Chunked")
|
||||
public typealias LazyChunked<Base: Collection, Subject> = Chunked<Base, Subject>
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.chunked(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -140,29 +142,29 @@ extension LazyCollectionProtocol {
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Complexity: O(1). When iterating over the resulting collection,
|
||||
/// accessing each successive chunk has a complexity of O(*m*), where *m*
|
||||
/// is the length of the chunk.
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: @escaping (Element, Element) -> Bool
|
||||
) -> LazyChunked<Elements> {
|
||||
LazyChunked(base: elements, belongInSameGroup: belongInSameGroup)
|
||||
) -> Chunked<Elements, Element> {
|
||||
Chunked(
|
||||
base: elements,
|
||||
projection: { $0 },
|
||||
belongInSameGroup: belongInSameGroup)
|
||||
}
|
||||
|
||||
/// Returns a lazy collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to the same value.
|
||||
///
|
||||
/// - Complexity: O(1). When iterating over the resulting collection,
|
||||
/// accessing each successive chunk has a complexity of O(*m*), where *m*
|
||||
/// is the length of the chunk.
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> LazyChunked<Elements> {
|
||||
LazyChunked(
|
||||
) -> Chunked<Elements, Subject> {
|
||||
Chunked(
|
||||
base: elements,
|
||||
belongInSameGroup: { projection($0) == projection($1) })
|
||||
projection: projection,
|
||||
belongInSameGroup: ==)
|
||||
}
|
||||
}
|
||||
|
||||
@@ -172,27 +174,28 @@ extension LazyCollectionProtocol {
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
/// grouping elements that project to the same value according to the given
|
||||
/// predicate.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: (Element, Element) -> Bool
|
||||
) -> [SubSequence] {
|
||||
internal func chunked<Subject>(
|
||||
on projection: (Element) throws -> Subject,
|
||||
by belongInSameGroup: (Subject, Subject) throws -> Bool
|
||||
) rethrows -> [SubSequence] {
|
||||
guard !isEmpty else { return [] }
|
||||
var result: [SubSequence] = []
|
||||
|
||||
var start = startIndex
|
||||
var current = startIndex
|
||||
while true {
|
||||
let next = index(after: current)
|
||||
if next == endIndex { break }
|
||||
|
||||
if !belongInSameGroup(self[current], self[next]) {
|
||||
result.append(self[start..<next])
|
||||
start = next
|
||||
var subject = try projection(self[start])
|
||||
|
||||
for (index, element) in indexed().dropFirst() {
|
||||
let nextSubject = try projection(element)
|
||||
if try !belongInSameGroup(subject, nextSubject) {
|
||||
result.append(self[start..<index])
|
||||
start = index
|
||||
subject = nextSubject
|
||||
}
|
||||
current = next
|
||||
}
|
||||
|
||||
if start != endIndex {
|
||||
@@ -201,6 +204,17 @@ extension Collection {
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// the given predicate.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
public func chunked(
|
||||
by belongInSameGroup: (Element, Element) throws -> Bool
|
||||
) rethrows -> [SubSequence] {
|
||||
try chunked(on: { $0 }, by: belongInSameGroup)
|
||||
}
|
||||
|
||||
/// Returns a collection of subsequences of this collection, chunked by
|
||||
/// grouping elements that project to the same value.
|
||||
@@ -208,9 +222,300 @@ extension Collection {
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
@inlinable
|
||||
public func chunked<Subject: Equatable>(
|
||||
on projection: (Element) -> Subject
|
||||
) -> [SubSequence] {
|
||||
chunked(by: { projection($0) == projection($1) })
|
||||
on projection: (Element) throws -> Subject
|
||||
) rethrows -> [SubSequence] {
|
||||
try chunked(on: projection, by: ==)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// chunks(ofCount:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection that presents the elements of its base collection
|
||||
/// in `SubSequence` chunks of any given count.
|
||||
///
|
||||
/// A `ChunkedByCount` is a lazy view on the base Collection, but it does not implicitly confer
|
||||
/// laziness on algorithms applied to its result. In other words, for ordinary collections `c`:
|
||||
///
|
||||
/// * `c.chunks(ofCount: 3)` does not create new storage
|
||||
/// * `c.chunks(ofCount: 3).map(f)` maps eagerly and returns a new array
|
||||
/// * `c.lazy.chunks(ofCount: 3).map(f)` maps lazily and returns a `LazyMapCollection`
|
||||
public struct ChunkedByCount<Base: Collection> {
|
||||
|
||||
public typealias Element = Base.SubSequence
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let chunkCount: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var startUpperBound: Base.Index
|
||||
|
||||
/// Creates a view instance that presents the elements of `base`
|
||||
/// in `SubSequence` chunks of the given count.
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
internal init(_base: Base, _chunkCount: Int) {
|
||||
self.base = _base
|
||||
self.chunkCount = _chunkCount
|
||||
|
||||
// Compute the start index upfront in order to make
|
||||
// start index a O(1) lookup.
|
||||
self.startUpperBound = _base.index(
|
||||
_base.startIndex, offsetBy: _chunkCount,
|
||||
limitedBy: _base.endIndex
|
||||
) ?? _base.endIndex
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount: Collection {
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
internal let baseRange: Range<Base.Index>
|
||||
|
||||
@inlinable
|
||||
internal init(_baseRange: Range<Base.Index>) {
|
||||
self.baseRange = _baseRange
|
||||
}
|
||||
}
|
||||
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(_baseRange: base.startIndex..<startUpperBound)
|
||||
}
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(_baseRange: base.endIndex..<base.endIndex)
|
||||
}
|
||||
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Element {
|
||||
precondition(i < endIndex, "Index out of range")
|
||||
return base[i.baseRange]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i < endIndex, "Advancing past end index")
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.upperBound, offsetBy: chunkCount,
|
||||
limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
return Index(_baseRange: i.baseRange.upperBound..<baseIdx)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount.Index: Comparable {
|
||||
@inlinable
|
||||
public static func == (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
lhs.baseRange.lowerBound == rhs.baseRange.lowerBound
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: ChunkedByCount.Index,
|
||||
rhs: ChunkedByCount.Index) -> Bool {
|
||||
lhs.baseRange.lowerBound < rhs.baseRange.lowerBound
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount:
|
||||
BidirectionalCollection, RandomAccessCollection
|
||||
where Base: RandomAccessCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i > startIndex, "Advancing past start index")
|
||||
|
||||
var offset = chunkCount
|
||||
if i.baseRange.lowerBound == base.endIndex {
|
||||
let remainder = base.count%chunkCount
|
||||
if remainder != 0 {
|
||||
offset = remainder
|
||||
}
|
||||
}
|
||||
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.lowerBound, offsetBy: -offset,
|
||||
limitedBy: base.startIndex
|
||||
) ?? base.startIndex
|
||||
return Index(_baseRange: baseIdx..<i.baseRange.lowerBound)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount {
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
let distance =
|
||||
base.distance(from: start.baseRange.lowerBound,
|
||||
to: end.baseRange.lowerBound)
|
||||
let (quotient, remainder) =
|
||||
distance.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
let (quotient, remainder) =
|
||||
base.count.quotientAndRemainder(dividingBy: chunkCount)
|
||||
return quotient + remainder.signum()
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index, offsetBy offset: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard offset != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
if offset > 0 {
|
||||
return limit > i
|
||||
? offsetForward(i, offsetBy: offset, limit: limit)
|
||||
: offsetForward(i, offsetBy: offset)
|
||||
} else {
|
||||
return limit < i
|
||||
? offsetBackward(i, offsetBy: offset, limit: limit)
|
||||
: offsetBackward(i, offsetBy: offset)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
let idx = distance > 0
|
||||
? offsetForward(i, offsetBy: distance)
|
||||
: offsetBackward(i, offsetBy: distance)
|
||||
guard let index = idx else {
|
||||
fatalError("Out of bounds")
|
||||
}
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, offsetBy distance: Int, limit: Index? = nil
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
|
||||
return makeOffsetIndex(
|
||||
from: i, baseBound: base.endIndex,
|
||||
distance: distance, baseDistance: distance * chunkCount,
|
||||
limit: limit, by: >
|
||||
)
|
||||
}
|
||||
|
||||
// Convenience to compute offset backward base distance.
|
||||
@inlinable
|
||||
internal func computeOffsetBackwardBaseDistance(
|
||||
_ i: Index, _ distance: Int
|
||||
) -> Int {
|
||||
if i == endIndex {
|
||||
let remainder = base.count%chunkCount
|
||||
// We have to take it into account when calculating offsets.
|
||||
if remainder != 0 {
|
||||
// Distance "minus" one(at this point distance is negative)
|
||||
// because we need to adjust for the last position that have
|
||||
// a variadic(remainder) number of elements.
|
||||
return ((distance + 1) * chunkCount) - remainder
|
||||
}
|
||||
}
|
||||
return distance * chunkCount
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, offsetBy distance: Int, limit: Index? = nil
|
||||
) -> Index? {
|
||||
assert(distance < 0)
|
||||
let baseDistance =
|
||||
computeOffsetBackwardBaseDistance(i, distance)
|
||||
return makeOffsetIndex(
|
||||
from: i, baseBound: base.startIndex,
|
||||
distance: distance, baseDistance: baseDistance,
|
||||
limit: limit, by: <
|
||||
)
|
||||
}
|
||||
|
||||
// Helper to compute index(offsetBy:) index.
|
||||
@inlinable
|
||||
internal func makeOffsetIndex(
|
||||
from i: Index, baseBound: Base.Index, distance: Int, baseDistance: Int,
|
||||
limit: Index?, by limitFn: (Base.Index, Base.Index) -> Bool
|
||||
) -> Index? {
|
||||
let baseIdx = base.index(
|
||||
i.baseRange.lowerBound, offsetBy: baseDistance,
|
||||
limitedBy: baseBound
|
||||
)
|
||||
|
||||
if let limit = limit {
|
||||
if baseIdx == nil {
|
||||
// If we past the bounds while advancing forward and the
|
||||
// limit is the `endIndex`, since the computation on base
|
||||
// don't take into account the remainder, we have to make
|
||||
// sure that passing the bound was because of the distance
|
||||
// not just because of a remainder. Special casing is less
|
||||
// expensive than always use count(which could be O(n) for
|
||||
// non-random access collection base) to compute the base
|
||||
// distance taking remainder into account.
|
||||
if baseDistance > 0 && limit == endIndex {
|
||||
if self.distance(from: i, to: limit) < distance {
|
||||
return nil
|
||||
}
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
// Checks for the limit.
|
||||
let baseStartIdx = baseIdx ?? baseBound
|
||||
if limitFn(baseStartIdx, limit.baseRange.lowerBound) {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
let baseStartIdx = baseIdx ?? baseBound
|
||||
let baseEndIdx = base.index(
|
||||
baseStartIdx, offsetBy: chunkCount, limitedBy: base.endIndex
|
||||
) ?? base.endIndex
|
||||
|
||||
return Index(_baseRange: baseStartIdx..<baseEndIdx)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a `ChunkedCollection<Self>` view presenting the elements
|
||||
/// in chunks with count of the given count parameter.
|
||||
///
|
||||
/// - Parameter size: The size of the chunks. If the count parameter
|
||||
/// is evenly divided by the count of the base `Collection` all the
|
||||
/// chunks will have the count equals to size.
|
||||
/// Otherwise, the last chunk will contain the remaining elements.
|
||||
///
|
||||
/// let c = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
/// print(c.chunks(ofCount: 5).map(Array.init))
|
||||
/// // [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]]
|
||||
///
|
||||
/// print(c.chunks(ofCount: 3).map(Array.init))
|
||||
/// // [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]
|
||||
///
|
||||
/// - Complexity: O(*n*), because the start index is pre-computed.
|
||||
@inlinable
|
||||
public func chunks(ofCount count: Int) -> ChunkedByCount<Self> {
|
||||
precondition(count > 0, "Cannot chunk with count <= 0!")
|
||||
return ChunkedByCount(_base: self, _chunkCount: count)
|
||||
}
|
||||
}
|
||||
|
||||
extension ChunkedByCount.Index: Hashable where Base.Index: Hashable {}
|
||||
|
||||
// Lazy conditional conformance.
|
||||
extension ChunkedByCount: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension ChunkedByCount: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
@@ -2,28 +2,65 @@
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Copyright (c) 2020-2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A collection wrapper that generates combinations of a base collection.
|
||||
public struct Combinations<Base: Collection> {
|
||||
/// The collection to iterate over for combinations.
|
||||
public let base: Base
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal var k: Int
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The range of accepted sizes of combinations.
|
||||
/// - Note: This may be `nil` if the attempted range entirely exceeds the
|
||||
/// upper bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>?
|
||||
|
||||
/// Initializes a `Combinations` for all combinations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for combinations.
|
||||
/// - k: The expected size of each combination.
|
||||
@inlinable
|
||||
internal init(_ base: Base, k: Int) {
|
||||
self.base = base
|
||||
self.k = base.count < k ? -1 : k
|
||||
self.init(base, kRange: k...k)
|
||||
}
|
||||
|
||||
|
||||
/// Initializes a `Combinations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for combinations.
|
||||
/// - kRange: The range of accepted sizes of combinations.
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(
|
||||
_ base: Base, kRange: R
|
||||
) where R.Bound == Int {
|
||||
let range = kRange.relative(to: 0 ..< .max)
|
||||
self.base = base
|
||||
let baseCount = base.count
|
||||
self.baseCount = baseCount
|
||||
let upperBound = baseCount + 1
|
||||
self.kRange = range.lowerBound < upperBound
|
||||
? range.clamped(to: 0 ..< upperBound)
|
||||
: nil
|
||||
}
|
||||
|
||||
/// The total number of combinations.
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
guard let k = self.kRange else { return 0 }
|
||||
let n = baseCount
|
||||
if k == 0 ..< (n + 1) {
|
||||
return 1 << n
|
||||
}
|
||||
|
||||
func binomial(n: Int, k: Int) -> Int {
|
||||
switch k {
|
||||
case n, 0: return 1
|
||||
@@ -33,29 +70,39 @@ public struct Combinations<Base: Collection> {
|
||||
}
|
||||
}
|
||||
|
||||
return k >= 0
|
||||
? binomial(n: base.count, k: k)
|
||||
: 0
|
||||
return k.map {
|
||||
binomial(n: n, k: $0)
|
||||
}.reduce(0, +)
|
||||
}
|
||||
}
|
||||
|
||||
extension Combinations: Sequence {
|
||||
/// The iterator for a `Combinations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// The current range of accepted sizes of combinations.
|
||||
/// - Note: The range is contracted until empty while iterating over
|
||||
/// combinations of different sizes. When the range is empty, iteration is
|
||||
/// finished.
|
||||
@usableFromInline
|
||||
internal var kRange: Range<Int>
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty)
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@usableFromInline
|
||||
internal var finished: Bool
|
||||
|
||||
@inlinable
|
||||
internal init(_ combinations: Combinations) {
|
||||
self.base = combinations.base
|
||||
self.finished = combinations.k < 0
|
||||
self.indexes = combinations.k < 0
|
||||
? []
|
||||
: Array(combinations.base.indices.prefix(combinations.k))
|
||||
self.kRange = combinations.kRange ?? 0..<0
|
||||
self.indexes = Array(combinations.base.indices.prefix(kRange.lowerBound))
|
||||
}
|
||||
|
||||
/// Advances the current indices to the next set of combinations. If
|
||||
@@ -76,26 +123,37 @@ extension Combinations: Sequence {
|
||||
/// [2, 3, 4] *
|
||||
/// // Can't advance without needing to go past `base.endIndex`,
|
||||
/// // so the iteration is finished.
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal mutating func advance() {
|
||||
/// Advances `kRange` by incrementing its `lowerBound` until the range is
|
||||
/// empty, when iteration is finished.
|
||||
func advanceKRange() {
|
||||
if kRange.lowerBound < kRange.upperBound {
|
||||
let advancedLowerBound = kRange.lowerBound + 1
|
||||
kRange = advancedLowerBound ..< kRange.upperBound
|
||||
indexes.removeAll(keepingCapacity: true)
|
||||
indexes.append(contentsOf: base.indices.prefix(kRange.lowerBound))
|
||||
}
|
||||
}
|
||||
|
||||
guard !indexes.isEmpty else {
|
||||
// Initial state for combinations of 0 elements is an empty array with
|
||||
// `finished == false`. Even though no indexes are involved, advancing
|
||||
// from that state means we are finished with iterating.
|
||||
finished = true
|
||||
advanceKRange()
|
||||
return
|
||||
}
|
||||
|
||||
|
||||
let i = indexes.count - 1
|
||||
base.formIndex(after: &indexes[i])
|
||||
if indexes[i] != base.endIndex { return }
|
||||
|
||||
|
||||
var j = i
|
||||
while indexes[i] == base.endIndex {
|
||||
j -= 1
|
||||
guard j >= 0 else {
|
||||
// Finished iterating over combinations
|
||||
finished = true
|
||||
// Finished iterating over combinations of this size.
|
||||
advanceKRange()
|
||||
return
|
||||
}
|
||||
|
||||
@@ -111,7 +169,7 @@ extension Combinations: Sequence {
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
if finished { return nil }
|
||||
guard !isFinished else { return nil }
|
||||
defer { advance() }
|
||||
return indexes.map { i in base[i] }
|
||||
}
|
||||
@@ -123,22 +181,88 @@ extension Combinations: Sequence {
|
||||
}
|
||||
|
||||
extension Combinations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
extension Combinations: Equatable where Base: Equatable {}
|
||||
extension Combinations: Hashable where Base: Hashable {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// combinations(count:)
|
||||
// combinations(ofCount:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of combinations of this collection's elements, with
|
||||
/// each combination having the specificed number of elements.
|
||||
/// each combination having the specified number of elements.
|
||||
///
|
||||
/// This example prints the different combinations of 1 and 2 from an array of
|
||||
/// four colors:
|
||||
///
|
||||
/// let colors = ["fuchsia", "cyan", "mauve", "magenta"]
|
||||
/// for combo in colors.combinations(ofCount: 1...2) {
|
||||
/// print(combo.joined(separator: ", "))
|
||||
/// }
|
||||
/// // fuchsia
|
||||
/// // cyan
|
||||
/// // mauve
|
||||
/// // magenta
|
||||
/// // fuchsia, cyan
|
||||
/// // fuchsia, mauve
|
||||
/// // fuchsia, magenta
|
||||
/// // cyan, mauve
|
||||
/// // cyan, magenta
|
||||
/// // mauve, magenta
|
||||
///
|
||||
/// The returned collection presents combinations in a consistent order, where
|
||||
/// the indices in each combination are in ascending lexicographical order.
|
||||
/// That is, in the example above, the combinations in order are the elements
|
||||
/// at `[0]`, `[1]`, `[2]`, `[3]`, `[0, 1]`, `[0, 2]`, `[0, 3]`, `[1, 2]`,
|
||||
/// `[1, 3]`, and finally `[2, 3]`.
|
||||
///
|
||||
/// This example prints _all_ the combinations (including an empty array and
|
||||
/// the original collection) from an array of numbers:
|
||||
///
|
||||
/// let numbers = [10, 20, 30, 40]
|
||||
/// for combo in numbers.combinations(ofCount: 0...) {
|
||||
/// print(combo)
|
||||
/// }
|
||||
/// // []
|
||||
/// // [10]
|
||||
/// // [20]
|
||||
/// // [30]
|
||||
/// // [40]
|
||||
/// // [10, 20]
|
||||
/// // [10, 30]
|
||||
/// // [10, 40]
|
||||
/// // [20, 30]
|
||||
/// // [20, 40]
|
||||
/// // [30, 40]
|
||||
/// // [10, 20, 30]
|
||||
/// // [10, 20, 40]
|
||||
/// // [10, 30, 40]
|
||||
/// // [20, 30, 40]
|
||||
/// // [10, 20, 30, 40]
|
||||
///
|
||||
/// If `kRange` is `0...0`, the resulting sequence has exactly one element, an
|
||||
/// empty array. The given range is limited to `0...base.count`. If the
|
||||
/// limited range is empty, the resulting sequence has no elements.
|
||||
///
|
||||
/// - Parameter kRange: The range of numbers of elements to include in each
|
||||
/// combination.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since `Combinations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func combinations<R: RangeExpression>(
|
||||
ofCount kRange: R
|
||||
) -> Combinations<Self> where R.Bound == Int {
|
||||
return Combinations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Returns a collection of combinations of this collection's elements, with
|
||||
/// each combination having the specified number of elements.
|
||||
///
|
||||
/// This example prints the different combinations of three from an array of
|
||||
/// four colors:
|
||||
///
|
||||
/// let colors = ["fuchsia", "cyan", "mauve", "magenta"]
|
||||
/// for combo in colors.combinations(ofCount k: 3) {
|
||||
/// for combo in colors.combinations(ofCount: 3) {
|
||||
/// print(combo.joined(separator: ", "))
|
||||
/// }
|
||||
/// // fuchsia, cyan, mauve
|
||||
@@ -157,10 +281,12 @@ extension Collection {
|
||||
///
|
||||
/// - Parameter k: The number of elements to include in each combination.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since `Combinations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func combinations(ofCount k: Int) -> Combinations<Self> {
|
||||
assert(k >= 0, "Can't have combinations with a negative number of elements.")
|
||||
precondition(k >= 0, "Can't have combinations with a negative number of elements.")
|
||||
return Combinations(self, k: k)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,181 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A `Sequence` that iterates over every non-nil element from the original `Sequence`.
|
||||
public struct CompactedSequence<Base: Sequence, Element>: Sequence
|
||||
where Base.Element == Element? {
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
@inlinable
|
||||
init(base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
var base: Base.Iterator
|
||||
|
||||
@inlinable
|
||||
init(base: Base.Iterator) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
while let wrapped = base.next() {
|
||||
guard let some = wrapped else { continue }
|
||||
return some
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
return Iterator(base: base.makeIterator())
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a new `Sequence` that iterates over every non-nil element
|
||||
/// from the original `Sequence`.
|
||||
/// It produces the same result as `c.compactMap { $0 }`.
|
||||
///
|
||||
/// let c = [1, nil, 2, 3, nil]
|
||||
/// for num in c.compacted() {
|
||||
/// print(num)
|
||||
/// }
|
||||
/// // 1
|
||||
/// // 2
|
||||
/// // 3
|
||||
///
|
||||
/// - Returns: A `Sequence` where the element is the unwrapped original
|
||||
/// element and iterates over every non-nil element from the original
|
||||
/// `Sequence`.
|
||||
///
|
||||
/// Complexity: O(1)
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedSequence<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
CompactedSequence(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
/// A `Collection` that iterates over every non-nil element from the original `Collection`.
|
||||
public struct CompactedCollection<Base: Collection, Element>: Collection
|
||||
where Base.Element == Element? {
|
||||
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
|
||||
@inlinable
|
||||
init(base: Base) {
|
||||
self.base = base
|
||||
let idx = base.firstIndex(where: { $0 != nil }) ?? base.endIndex
|
||||
self.startIndex = Index(base: idx)
|
||||
}
|
||||
|
||||
public struct Index {
|
||||
@usableFromInline
|
||||
let base: Base.Index
|
||||
|
||||
@inlinable
|
||||
init(base: Base.Index) {
|
||||
self.base = base
|
||||
}
|
||||
}
|
||||
|
||||
public var startIndex: Index
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index { Index(base: base.endIndex) }
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Element {
|
||||
base[position.base]!
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Index out of bounds")
|
||||
|
||||
let baseIdx = base.index(after: i.base)
|
||||
guard let idx = base[baseIdx...].firstIndex(where: { $0 != nil })
|
||||
else { return endIndex }
|
||||
return Index(base: idx)
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Index out of bounds")
|
||||
|
||||
guard let idx =
|
||||
base[startIndex.base..<i.base]
|
||||
.lastIndex(where: { $0 != nil })
|
||||
else { fatalError("Index out of bounds") }
|
||||
return Index(base: idx)
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection.Index: Comparable {
|
||||
@inlinable
|
||||
public static func < (lhs: CompactedCollection.Index,
|
||||
rhs: CompactedCollection.Index) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
}
|
||||
|
||||
extension CompactedCollection.Index: Hashable
|
||||
where Base.Index: Hashable {}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a new `Collection` that iterates over every non-nil element
|
||||
/// from the original `Collection`.
|
||||
/// It produces the same result as `c.compactMap { $0 }`.
|
||||
///
|
||||
/// let c = [1, nil, 2, 3, nil]
|
||||
/// for num in c.compacted() {
|
||||
/// print(num)
|
||||
/// }
|
||||
/// // 1
|
||||
/// // 2
|
||||
/// // 3
|
||||
///
|
||||
/// - Returns: A `Collection` where the element is the unwrapped original
|
||||
/// element and iterates over every non-nil element from the original
|
||||
/// `Collection`.
|
||||
///
|
||||
/// Complexity: O(*n*) where *n* is the number of elements in the
|
||||
/// original `Collection`.
|
||||
@inlinable
|
||||
public func compacted<Unwrapped>() -> CompactedCollection<Self, Unwrapped>
|
||||
where Element == Unwrapped? {
|
||||
CompactedCollection(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Protocol Conformances
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension CompactedSequence: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension CompactedCollection: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
extension CompactedCollection: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
@@ -12,19 +12,25 @@
|
||||
/// A collection wrapper that repeats the elements of a base collection.
|
||||
public struct Cycle<Base: Collection> {
|
||||
/// The collection to repeat.
|
||||
public let base: Base
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
}
|
||||
|
||||
extension Cycle: Sequence {
|
||||
/// The iterator for a `Cycle` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
let base: Base
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
var current: Base.Index
|
||||
internal var current: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
self.current = base.startIndex
|
||||
@@ -43,6 +49,7 @@ extension Cycle: Sequence {
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base)
|
||||
}
|
||||
@@ -50,6 +57,112 @@ extension Cycle: Sequence {
|
||||
|
||||
extension Cycle: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
|
||||
/// A collection wrapper that repeats the elements of a base collection for a
|
||||
/// finite number of times.
|
||||
public struct FiniteCycle<Base: Collection> {
|
||||
/// A Product2 instance for iterating the Base collection.
|
||||
@usableFromInline
|
||||
internal let product: Product2<Range<Int>, Base>
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, times: Int) {
|
||||
self.product = Product2(0..<times, base)
|
||||
}
|
||||
}
|
||||
|
||||
extension FiniteCycle: LazySequenceProtocol, LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol { }
|
||||
|
||||
extension FiniteCycle: Collection {
|
||||
|
||||
public typealias Element = Base.Element
|
||||
|
||||
public struct Index: Comparable {
|
||||
/// The index corresponding to the Product2 index at this position.
|
||||
@usableFromInline
|
||||
internal let productIndex: Product2<Range<Int>, Base>.Index
|
||||
|
||||
@inlinable
|
||||
internal init(_ productIndex: Product2<Range<Int>, Base>.Index) {
|
||||
self.productIndex = productIndex
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.productIndex == rhs.productIndex
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.productIndex < rhs.productIndex
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(product.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(product.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(_ index: Index) -> Element {
|
||||
product[index.productIndex].1
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
let productIndex = product.index(after: i.productIndex)
|
||||
return Index(productIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
product.distance(from: start.productIndex, to: end.productIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
let productIndex = product.index(i.productIndex, offsetBy: distance)
|
||||
return Index(productIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard let productIndex = product.index(i.productIndex,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.productIndex) else {
|
||||
return nil
|
||||
}
|
||||
return Index(productIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
product.count
|
||||
}
|
||||
}
|
||||
|
||||
extension FiniteCycle: BidirectionalCollection
|
||||
where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
let productIndex = product.index(before: i.productIndex)
|
||||
return Index(productIndex)
|
||||
}
|
||||
}
|
||||
|
||||
extension FiniteCycle: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// cycled()
|
||||
//===----------------------------------------------------------------------===//
|
||||
@@ -80,6 +193,7 @@ extension Collection {
|
||||
/// forever.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func cycled() -> Cycle<Self> {
|
||||
Cycle(base: self)
|
||||
}
|
||||
@@ -101,7 +215,8 @@ extension Collection {
|
||||
/// times.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
public func cycled(times: Int) -> FlattenSequence<Repeated<Self>> {
|
||||
repeatElement(self, count: times).joined()
|
||||
@inlinable
|
||||
public func cycled(times: Int) -> FiniteCycle<Self> {
|
||||
FiniteCycle(base: self, times: times)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,43 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// firstNonNil(_:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
public extension Sequence {
|
||||
/// Returns the first non-`nil` result obtained from applying the given
|
||||
/// transformation to the elements of the sequence.
|
||||
///
|
||||
/// let strings = ["three", "3.14", "-5", "2"]
|
||||
/// if let firstInt = strings.firstNonNil({ Int($0) }) {
|
||||
/// print(firstInt)
|
||||
/// // -5
|
||||
/// }
|
||||
///
|
||||
/// - Parameter transform: A closure that takes an element of the sequence as
|
||||
/// its argument and returns an optional transformed value.
|
||||
/// - Returns: The first non-`nil` return value of the transformation, or
|
||||
/// `nil` if no transformation is successful.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements at the start of
|
||||
/// the sequence that result in `nil` when applying the transformation.
|
||||
func firstNonNil<Result>(
|
||||
_ transform: (Element) throws -> Result?
|
||||
) rethrows -> Result? {
|
||||
for value in self {
|
||||
if let value = try transform(value) {
|
||||
return value
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
@@ -16,9 +16,10 @@ public struct Indexed<Base: Collection> {
|
||||
public typealias Element = (index: Base.Index, element: Base.Element)
|
||||
|
||||
/// The base collection.
|
||||
public let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base) {
|
||||
self.base = base
|
||||
}
|
||||
@@ -70,8 +71,7 @@ extension Indexed: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
|
||||
extension Indexed: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension Indexed: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
extension Indexed: Equatable where Base: Equatable {}
|
||||
extension Indexed: Hashable where Base: Hashable {}
|
||||
extension Indexed: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// indexed()
|
||||
|
||||
@@ -0,0 +1,236 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that presents the elements of a base sequence of elements
|
||||
/// with a separator between each of those elements.
|
||||
public struct Intersperse<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Base.Element
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, separator: Base.Element) {
|
||||
self.base = base
|
||||
self.separator = separator
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: Sequence {
|
||||
/// The iterator for an `Intersperse` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal let separator: Base.Element
|
||||
|
||||
@usableFromInline
|
||||
internal var state = State.start
|
||||
|
||||
@inlinable
|
||||
internal init(iterator: Base.Iterator, separator: Base.Element) {
|
||||
self.iterator = iterator
|
||||
self.separator = separator
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
enum State {
|
||||
case start
|
||||
case element(Base.Element)
|
||||
case separator
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
// After the start, the state flips between element and separator. Before
|
||||
// returning a separator, a check is made for the next element as a
|
||||
// separator is only returned between two elements. The next element is
|
||||
// stored to allow it to be returned in the next iteration.
|
||||
switch state {
|
||||
case .start:
|
||||
state = .separator
|
||||
return iterator.next()
|
||||
case .separator:
|
||||
guard let next = iterator.next() else { return nil }
|
||||
state = .element(next)
|
||||
return separator
|
||||
case .element(let element):
|
||||
state = .separator
|
||||
return element
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Intersperse<Base>.Iterator {
|
||||
Iterator(iterator: base.makeIterator(), separator: separator)
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: Collection where Base: Collection {
|
||||
/// A position in an `Intersperse` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
enum Representation: Equatable {
|
||||
case element(Base.Index)
|
||||
case separator(next: Base.Index)
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal let representation: Representation
|
||||
|
||||
@inlinable
|
||||
init(representation: Representation) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
switch (lhs.representation, rhs.representation) {
|
||||
case let (.element(li), .element(ri)),
|
||||
let (.separator(next: li), .separator(next: ri)),
|
||||
let (.element(li), .separator(next: ri)):
|
||||
return li < ri
|
||||
case let (.separator(next: li), .element(ri)):
|
||||
return li <= ri
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
static func element(_ index: Base.Index) -> Self {
|
||||
Self(representation: .element(index))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
static func separator(next: Base.Index) -> Self {
|
||||
Self(representation: .separator(next: next))
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
base.startIndex == base.endIndex ? endIndex : .element(base.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
.separator(next: base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
switch i.representation {
|
||||
case let .element(index):
|
||||
return .separator(next: base.index(after: index))
|
||||
case let .separator(next):
|
||||
return .element(next)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Element {
|
||||
switch position.representation {
|
||||
case .element(let index): return base[index]
|
||||
case .separator: return separator
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
switch (i.representation, distance.isMultiple(of: 2)) {
|
||||
case (let .element(index), true):
|
||||
return .element(base.index(index, offsetBy: distance / 2))
|
||||
case (let .element(index), false):
|
||||
return .separator(next: base.index(index, offsetBy: (distance + 1) / 2))
|
||||
case (let .separator(next: index), true):
|
||||
return .separator(next: base.index(index, offsetBy: distance / 2))
|
||||
case (let .separator(next: index), false):
|
||||
return .element(base.index(index, offsetBy: (distance - 1) / 2))
|
||||
}
|
||||
}
|
||||
|
||||
// TODO: Implement index(_:offsetBy:limitedBy:)
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case let (.element(element), .separator(next: separator)):
|
||||
return 2 * base.distance(from: element, to: separator) - 1
|
||||
case let (.separator(next: separator), .element(element)):
|
||||
return 2 * base.distance(from: separator, to: element) + 1
|
||||
case let (.element(start), .element(end)),
|
||||
let (.separator(start), .separator(end)):
|
||||
return 2 * base.distance(from: start, to: end)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: BidirectionalCollection
|
||||
where Base: BidirectionalCollection
|
||||
{
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i != startIndex, "Can't move before startIndex")
|
||||
switch i.representation {
|
||||
case let .element(index):
|
||||
return .separator(next: index)
|
||||
case let .separator(next):
|
||||
return .element(base.index(before: next))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Intersperse: RandomAccessCollection
|
||||
where Base: RandomAccessCollection {}
|
||||
|
||||
extension Intersperse: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension Intersperse: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns a sequence containing elements of this sequence with the given
|
||||
/// separator inserted in between each element.
|
||||
///
|
||||
/// Any value of the sequence's element type can be used as the separator.
|
||||
///
|
||||
/// ```
|
||||
/// for value in [1,2,3].interspersed(with: 0) {
|
||||
/// print(value)
|
||||
/// }
|
||||
/// // 1
|
||||
/// // 0
|
||||
/// // 2
|
||||
/// // 0
|
||||
/// // 3
|
||||
/// ```
|
||||
///
|
||||
/// The following shows a String being interspersed with a Character:
|
||||
/// ```
|
||||
/// let result = "ABCDE".interspersed(with: "-")
|
||||
/// print(String(result))
|
||||
/// // "A-B-C-D-E"
|
||||
/// ```
|
||||
///
|
||||
/// - Parameter separator: Value to insert in between each of this sequence’s
|
||||
/// elements.
|
||||
/// - Returns: The interspersed sequence of elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func interspersed(with separator: Element) -> Intersperse<Self> {
|
||||
Intersperse(base: self, separator: separator)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,750 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LazySplitSequence
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// A sequence that lazily splits a base sequence into subsequences separated by
|
||||
/// elements that satisfy the given `whereSeparator` predicate.
|
||||
///
|
||||
/// - Note: This type is the result of
|
||||
///
|
||||
/// x.split(maxSplits:omittingEmptySubsequences:whereSeparator)
|
||||
/// x.split(separator:maxSplits:omittingEmptySubsequences)
|
||||
///
|
||||
/// where `x` conforms to `LazySequenceProtocol`.
|
||||
public struct LazySplitSequence<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let isSeparator: (Base.Element) -> Bool
|
||||
|
||||
@usableFromInline
|
||||
internal let maxSplits: Int
|
||||
|
||||
@usableFromInline
|
||||
internal let omittingEmptySubsequences: Bool
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
isSeparator: @escaping (Base.Element) -> Bool,
|
||||
maxSplits: Int,
|
||||
omittingEmptySubsequences: Bool
|
||||
) {
|
||||
self.base = base
|
||||
self.isSeparator = isSeparator
|
||||
self.maxSplits = maxSplits
|
||||
self.omittingEmptySubsequences = omittingEmptySubsequences
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySplitSequence {
|
||||
public struct Iterator {
|
||||
public typealias Element = [Base.Element]
|
||||
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal let isSeparator: (Base.Element) -> Bool
|
||||
|
||||
@usableFromInline
|
||||
internal let maxSplits: Int
|
||||
|
||||
@usableFromInline
|
||||
internal let omittingEmptySubsequences: Bool
|
||||
|
||||
/// The number of splits performed.
|
||||
@usableFromInline
|
||||
internal var splitCount = 0
|
||||
|
||||
/// The number of subsequences returned.
|
||||
@usableFromInline
|
||||
internal var sequenceLength = 0
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base.Iterator,
|
||||
whereSeparator: @escaping (Base.Element) -> Bool,
|
||||
maxSplits: Int,
|
||||
omittingEmptySubsequences: Bool
|
||||
) {
|
||||
self.base = base
|
||||
self.isSeparator = whereSeparator
|
||||
self.maxSplits = maxSplits
|
||||
self.omittingEmptySubsequences = omittingEmptySubsequences
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySplitSequence.Iterator: IteratorProtocol {
|
||||
@inlinable
|
||||
public mutating func next() -> Element? {
|
||||
var currentElement = base.next()
|
||||
var subsequence: Element = []
|
||||
|
||||
// Add the next elements of the base sequence to this subsequence, until we
|
||||
// reach a separator, unless we've already split the maximum number of
|
||||
// times. In all cases, stop at the end of the base sequence.
|
||||
while currentElement != nil {
|
||||
if splitCount < maxSplits && isSeparator(currentElement!) {
|
||||
if omittingEmptySubsequences && subsequence.isEmpty {
|
||||
// Keep going if we don't want to return an empty subsequence.
|
||||
currentElement = base.next()
|
||||
continue
|
||||
} else {
|
||||
splitCount += 1
|
||||
break
|
||||
}
|
||||
} else {
|
||||
subsequence.append(currentElement!)
|
||||
currentElement = base.next()
|
||||
}
|
||||
}
|
||||
|
||||
// We're done iterating when we've reached the end of the base sequence,
|
||||
// and we've either returned the maximum number of subsequences (one more
|
||||
// than the number of separators), or the only subsequence left to return is
|
||||
// empty and we're omitting those.
|
||||
if currentElement == nil
|
||||
&& (sequenceLength == splitCount + 1
|
||||
|| omittingEmptySubsequences && subsequence.isEmpty)
|
||||
{
|
||||
return nil
|
||||
} else {
|
||||
sequenceLength += 1
|
||||
return subsequence
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySplitSequence: LazySequenceProtocol {
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
return Iterator(
|
||||
base: base.makeIterator(),
|
||||
whereSeparator: self.isSeparator,
|
||||
maxSplits: self.maxSplits,
|
||||
omittingEmptySubsequences: self.omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
/// Lazily returns the longest possible subsequences of the sequence, in
|
||||
/// order, that don't contain elements satisfying the given predicate.
|
||||
///
|
||||
/// The resulting lazy sequence consists of at most `maxSplits + 1`
|
||||
/// subsequences. Elements that are used to split the sequence are not
|
||||
/// returned as part of any subsequence (except possibly the last one, in the
|
||||
/// case where `maxSplits` is less than the number of separators in the
|
||||
/// sequence).
|
||||
///
|
||||
/// The following examples show the effects of the `maxSplits` and
|
||||
/// `omittingEmptySubsequences` parameters when lazily splitting a sequence of
|
||||
/// integers using a closure that matches numbers evenly divisible by 3 or 5.
|
||||
/// The first use of `split` returns each subsequence that was originally
|
||||
/// separated by one or more such numbers.
|
||||
///
|
||||
/// let numbers = stride(from: 1, through: 16, by: 1)
|
||||
/// for subsequence in numbers.lazy.split(
|
||||
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
/// ) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [4]
|
||||
/// [7, 8]
|
||||
/// [11]
|
||||
/// [13, 14]
|
||||
/// [16]
|
||||
/// */
|
||||
///
|
||||
/// The second example passes `1` for the `maxSplits` parameter, so the
|
||||
/// original sequence is split just once, into two subsequences.
|
||||
///
|
||||
/// for subsequence in numbers.lazy.split(
|
||||
/// maxSplits: 1,
|
||||
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
/// ) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]
|
||||
/// */
|
||||
///
|
||||
/// The final example passes `false` for the `omittingEmptySubsequences`
|
||||
/// parameter, so the sequence of returned subsequences contains empty
|
||||
/// subsequences where numbers evenly divisible by 3 or 5 were repeated.
|
||||
///
|
||||
/// for subsequence in numbers.lazy.split(
|
||||
/// omittingEmptySubsequences: false,
|
||||
/// whereSeparator: { $0 % 3 == 0 || $0 % 5 == 0 }
|
||||
/// ) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [4]
|
||||
/// []
|
||||
/// [7, 8]
|
||||
/// []
|
||||
/// [11]
|
||||
/// [13, 14]
|
||||
/// [16]
|
||||
/// */
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - maxSplits: The maximum number of times to split the sequence, or
|
||||
/// one less than the number of subsequences to return. If
|
||||
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
|
||||
/// of the original sequence containing the remaining elements.
|
||||
/// `maxSplits` must be greater than or equal to zero. The default value
|
||||
/// is `Int.max`.
|
||||
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
|
||||
/// returned in the result for each pair of consecutive elements
|
||||
/// satisfying the `isSeparator` predicate and for each element at the
|
||||
/// start or end of the sequence satisfying the `isSeparator`
|
||||
/// predicate. The default value is `true`.
|
||||
/// - whereSeparator: A closure that takes an element as an argument and
|
||||
/// returns a Boolean value indicating whether the sequence should be
|
||||
/// split at that element.
|
||||
/// - Returns: A lazy sequence of subsequences, split from this sequence's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func split(
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true,
|
||||
whereSeparator isSeparator: @escaping (Element) -> Bool
|
||||
) -> LazySplitSequence<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return LazySplitSequence(
|
||||
base: elements,
|
||||
isSeparator: isSeparator,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol where Element: Equatable {
|
||||
/// Lazily returns the longest possible subsequences of the sequence, in
|
||||
/// order, around elements equal to the given element.
|
||||
///
|
||||
/// The resulting lazy sequence consists of at most `maxSplits + 1`
|
||||
/// subsequences. Elements that are used to split the sequence are not
|
||||
/// returned as part of any subsequence (except possibly the last one, in the
|
||||
/// case where `maxSplits` is less than the number of separators in the
|
||||
/// sequence).
|
||||
///
|
||||
/// The following examples show the effects of the `maxSplits` and
|
||||
/// `omittingEmptySubsequences` parameters when splitting a sequence of
|
||||
/// integers at each zero (`0`). The first use of `split` returns each
|
||||
/// subsequence that was originally separated by one or more zeros.
|
||||
///
|
||||
/// let numbers = AnySequence([1, 2, 0, 3, 4, 0, 0, 5])
|
||||
/// for subsequence in numbers.lazy.split(separator: 0) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [3, 4]
|
||||
/// [5]
|
||||
/// */
|
||||
///
|
||||
/// The second example passes `1` for the `maxSplits` parameter, so the
|
||||
/// original sequence is split just once, into two subsequences.
|
||||
///
|
||||
/// for subsequence in numbers.lazy.split(
|
||||
/// separator: 0,
|
||||
/// maxSplits: 1
|
||||
/// ) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [3, 4, 0, 0, 5]
|
||||
/// */
|
||||
///
|
||||
/// The final example passes `false` for the `omittingEmptySubsequences`
|
||||
/// parameter, so the sequence of returned subsequences contains empty
|
||||
/// subsequences where zeros were repeated.
|
||||
///
|
||||
/// for subsequence in numbers.lazy.split(
|
||||
/// separator: 0,
|
||||
/// omittingEmptySubsequences: false
|
||||
/// ) {
|
||||
/// print(subsequence)
|
||||
/// }
|
||||
/// /* Prints:
|
||||
/// [1, 2]
|
||||
/// [3, 4]
|
||||
/// []
|
||||
/// [5]
|
||||
/// */
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - separator: The element that should be split upon.
|
||||
/// - maxSplits: The maximum number of times to split the sequence, or
|
||||
/// one less than the number of subsequences to return. If
|
||||
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
|
||||
/// of the original sequence containing the remaining elements.
|
||||
/// `maxSplits` must be greater than or equal to zero. The default value
|
||||
/// is `Int.max`.
|
||||
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
|
||||
/// returned in the result for each consecutive pair of `separator`
|
||||
/// elements in the sequence and for each instance of `separator` at
|
||||
/// the start or end of the sequence. If `true`, only nonempty
|
||||
/// subsequences are returned. The default value is `true`.
|
||||
/// - Returns: A lazy sequence of subsequences, split from this sequence's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func split(
|
||||
separator: Element,
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true
|
||||
) -> LazySplitSequence<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return LazySplitSequence(
|
||||
base: elements,
|
||||
isSeparator: { $0 == separator },
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// LazySplitCollection
|
||||
//===----------------------------------------------------------------------===//
|
||||
/// A collection that lazily splits a base collection into subsequences
|
||||
/// separated by elements that satisfy the given `whereSeparator` predicate.
|
||||
///
|
||||
/// - Note: This type is the result of
|
||||
///
|
||||
/// x.split(maxSplits:omittingEmptySubsequences:whereSeparator)
|
||||
/// x.split(separator:maxSplits:omittingEmptySubsequences)
|
||||
///
|
||||
/// where `x` conforms to `LazyCollectionProtocol`.
|
||||
public struct LazySplitCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let isSeparator: (Base.Element) -> Bool
|
||||
|
||||
@usableFromInline
|
||||
internal let maxSplits: Int
|
||||
|
||||
@usableFromInline
|
||||
internal let omittingEmptySubsequences: Bool
|
||||
|
||||
@usableFromInline
|
||||
internal var _startIndex: Index
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
isSeparator: @escaping (Base.Element) -> Bool,
|
||||
maxSplits: Int,
|
||||
omittingEmptySubsequences: Bool
|
||||
) {
|
||||
self.base = base
|
||||
self.isSeparator = isSeparator
|
||||
self.maxSplits = maxSplits
|
||||
self.omittingEmptySubsequences = omittingEmptySubsequences
|
||||
|
||||
// We precalculate `startIndex`. There are three possibilities:
|
||||
// 1. `base` is empty and we're _not_ omitting empty subsequences, in which
|
||||
// case the following index describes the sole element of this collection;
|
||||
self._startIndex = Index(
|
||||
baseRange: base.startIndex..<base.startIndex,
|
||||
sequenceLength: 1,
|
||||
splitCount: 0
|
||||
)
|
||||
if base.isEmpty {
|
||||
if omittingEmptySubsequences {
|
||||
// 2. `base` is empty and we _are_ omitting empty subsequences, so this
|
||||
// collection has no elements;
|
||||
_startIndex = endIndex
|
||||
}
|
||||
} else {
|
||||
// 3. `base` isn't empty, so we must iterate it to determine the start
|
||||
// index.
|
||||
_startIndex = indexForSubsequence(
|
||||
atOrAfter: base.startIndex,
|
||||
sequenceLength: 0,
|
||||
splitCount: 0
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySplitCollection: LazyCollectionProtocol {
|
||||
/// Position of a subsequence in a split collection.
|
||||
public struct Index: Comparable {
|
||||
/// The range corresponding to the subsequence at this position.
|
||||
@usableFromInline
|
||||
internal let baseRange: Range<Base.Index>
|
||||
|
||||
/// The number of subsequences up to and including this position in the
|
||||
/// collection.
|
||||
@usableFromInline
|
||||
internal let sequenceLength: Int
|
||||
|
||||
/// The number splits performed up to and including this position in the
|
||||
/// collection.
|
||||
@usableFromInline
|
||||
internal let splitCount: Int
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
baseRange: Range<Base.Index>,
|
||||
sequenceLength: Int,
|
||||
splitCount: Int
|
||||
) {
|
||||
self.baseRange = baseRange
|
||||
self.sequenceLength = sequenceLength
|
||||
self.splitCount = splitCount
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
// `sequenceLength` is equivalent to the index's 1-based position in the
|
||||
// collection of indices.
|
||||
lhs.sequenceLength == rhs.sequenceLength
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.sequenceLength < rhs.sequenceLength
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns the index of the subsequence starting at or after the given base
|
||||
/// collection index.
|
||||
@inlinable
|
||||
internal func indexForSubsequence(
|
||||
atOrAfter lowerBound: Base.Index,
|
||||
sequenceLength: Int,
|
||||
splitCount: Int
|
||||
) -> Index {
|
||||
var start = lowerBound
|
||||
// If we don't have any more splits to do (which we'll determine shortly),
|
||||
// the end of this subsequence will be the end of the base collection.
|
||||
var end = base.endIndex
|
||||
|
||||
if splitCount < maxSplits {
|
||||
// The non-inclusive end of this subsequence is marked by the next
|
||||
// separator, or the end of the base collection.
|
||||
end =
|
||||
base[start...].firstIndex(where: isSeparator)
|
||||
?? base.endIndex
|
||||
|
||||
if base[start..<end].isEmpty {
|
||||
if omittingEmptySubsequences {
|
||||
// Find the next subsequence of non-separators.
|
||||
start =
|
||||
base[end...].firstIndex(where: { !isSeparator($0) })
|
||||
?? base.endIndex
|
||||
if start == base.endIndex {
|
||||
// No non-separators left in the base collection. We're done.
|
||||
return endIndex
|
||||
}
|
||||
end = base[start...].firstIndex(where: isSeparator) ?? base.endIndex
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var updatedSplitCount = splitCount
|
||||
if end < base.endIndex {
|
||||
// This subsequence ends on a separator (and perhaps includes other
|
||||
// separators, if we're omitting empty subsequences), so we've performed
|
||||
// another split.
|
||||
updatedSplitCount += 1
|
||||
}
|
||||
|
||||
return Index(
|
||||
baseRange: start..<end,
|
||||
sequenceLength: sequenceLength + 1,
|
||||
splitCount: updatedSplitCount
|
||||
)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
_startIndex
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(
|
||||
baseRange: base.endIndex..<base.endIndex,
|
||||
sequenceLength: Int.max,
|
||||
splitCount: Int.max
|
||||
)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i != endIndex, "Can't advance past endIndex")
|
||||
|
||||
var subsequenceStart = i.baseRange.upperBound
|
||||
if subsequenceStart < base.endIndex {
|
||||
// If we're not already at the end of the base collection, the previous
|
||||
// susequence ended with a separator. Start searching for the next
|
||||
// subsequence at the following element.
|
||||
subsequenceStart = base.index(after: i.baseRange.upperBound)
|
||||
}
|
||||
|
||||
guard subsequenceStart != base.endIndex else {
|
||||
if !omittingEmptySubsequences
|
||||
&& i.sequenceLength < i.splitCount + 1
|
||||
{
|
||||
// The base collection ended with a separator, so we need to emit one
|
||||
// more empty subsequence. This one differs from `endIndex` in its
|
||||
// `sequenceLength` (except in an extreme edge case!), which is the
|
||||
// sole property tested for equality and comparison.
|
||||
return Index(
|
||||
baseRange: base.endIndex..<base.endIndex,
|
||||
sequenceLength: i.sequenceLength + 1,
|
||||
splitCount: i.splitCount
|
||||
)
|
||||
} else {
|
||||
return endIndex
|
||||
}
|
||||
}
|
||||
|
||||
return indexForSubsequence(
|
||||
atOrAfter: subsequenceStart,
|
||||
sequenceLength: i.sequenceLength,
|
||||
splitCount: i.splitCount
|
||||
)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.SubSequence {
|
||||
precondition(position != endIndex, "Can't subscript using endIndex")
|
||||
return base[position.baseRange]
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySplitCollection.Index: Hashable {
|
||||
public func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(sequenceLength)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazyCollectionProtocol {
|
||||
/// Lazily returns the longest possible subsequences of the collection, in
|
||||
/// order, that don't contain elements satisfying the given predicate.
|
||||
///
|
||||
/// The resulting lazy collection consists of at most `maxSplits + 1`
|
||||
/// subsequences. Elements that are used to split the collection are not
|
||||
/// returned as part of any subsequence (except possibly the last one, in the
|
||||
/// case where `maxSplits` is less than the number of separators in the
|
||||
/// collection).
|
||||
///
|
||||
/// The following examples show the effects of the `maxSplits` and
|
||||
/// `omittingEmptySubsequences` parameters when lazily splitting a string
|
||||
/// using a closure that matches spaces. The first use of `split` returns each
|
||||
/// word that was originally separated by one or more spaces.
|
||||
///
|
||||
/// let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
/// for spaceless in line.lazy.split(whereSeparator: { $0 == " " }) {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// // I
|
||||
/// // don't
|
||||
/// // want
|
||||
/// // realism.
|
||||
/// // I
|
||||
/// // want
|
||||
/// // magic!
|
||||
///
|
||||
/// The second example passes `1` for the `maxSplits` parameter, so the
|
||||
/// original string is split just once, into two new strings.
|
||||
///
|
||||
/// for spaceless in line.lazy.split(
|
||||
/// maxSplits: 1,
|
||||
/// whereSeparator: { $0 == " " }
|
||||
/// ) {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// // I don't want realism. I want magic!
|
||||
///
|
||||
/// The final example passes `false` for the `omittingEmptySubsequences`
|
||||
/// parameter, so the returned array contains empty strings where spaces
|
||||
/// were repeated.
|
||||
///
|
||||
/// for spaceless in line.lazy.split(
|
||||
/// omittingEmptySubsequences: false,
|
||||
/// whereSeparator: { $0 == " " }
|
||||
/// ) {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// //
|
||||
/// //
|
||||
/// // I
|
||||
/// // don't
|
||||
/// // want
|
||||
/// // realism.
|
||||
/// // I
|
||||
/// // want
|
||||
/// // magic!
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - maxSplits: The maximum number of times to split the collection, or
|
||||
/// one less than the number of subsequences to return. If
|
||||
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
|
||||
/// of the original collection containing the remaining elements.
|
||||
/// `maxSplits` must be greater than or equal to zero. The default value
|
||||
/// is `Int.max`.
|
||||
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
|
||||
/// returned in the result for each pair of consecutive elements
|
||||
/// satisfying the `isSeparator` predicate and for each element at the
|
||||
/// start or end of the collection satisfying the `isSeparator`
|
||||
/// predicate. The default value is `true`.
|
||||
/// - whereSeparator: A closure that takes an element as an argument and
|
||||
/// returns a Boolean value indicating whether the collection should be
|
||||
/// split at that element.
|
||||
/// - Returns: A lazy collection of subsequences, split from this collection's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func split(
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true,
|
||||
whereSeparator isSeparator: @escaping (Element) -> Bool
|
||||
) -> LazySplitCollection<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return LazySplitCollection(
|
||||
base: elements,
|
||||
isSeparator: isSeparator,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazyCollectionProtocol
|
||||
where Element: Equatable {
|
||||
/// Lazily returns the longest possible subsequences of the collection, in
|
||||
/// order, around elements equal to the given element.
|
||||
///
|
||||
/// The resulting lazy collection consists of at most `maxSplits + 1`
|
||||
/// subsequences. Elements that are used to split the collection are not
|
||||
/// returned as part of any subsequence (except possibly the last one, in the
|
||||
/// case where `maxSplits` is less than the number of separators in the
|
||||
/// collection).
|
||||
///
|
||||
/// The following examples show the effects of the `maxSplits` and
|
||||
/// `omittingEmptySubsequences` parameters when splitting a string at each
|
||||
/// space character (" "). The first use of `split` returns each word that
|
||||
/// was originally separated by one or more spaces.
|
||||
///
|
||||
/// let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
/// for spaceless in line.lazy.split(separator: " ") {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// // I
|
||||
/// // don't
|
||||
/// // want
|
||||
/// // realism.
|
||||
/// // I
|
||||
/// // want
|
||||
/// // magic!
|
||||
///
|
||||
/// The second example passes `1` for the `maxSplits` parameter, so the
|
||||
/// original string is split just once, into two new strings.
|
||||
///
|
||||
/// for spaceless in line.lazy.split(separator: " ", maxSplits: 1) {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// // I don't want realism. I want magic!
|
||||
///
|
||||
/// The final example passes `false` for the `omittingEmptySubsequences`
|
||||
/// parameter, so the returned array contains empty strings where spaces
|
||||
/// were repeated.
|
||||
///
|
||||
/// for spaceless in line.lazy.split(
|
||||
/// separator: " ",
|
||||
/// omittingEmptySubsequences: false
|
||||
/// ) {
|
||||
/// print(spaceless)
|
||||
/// }
|
||||
/// // Prints
|
||||
/// // BLANCHE:
|
||||
/// //
|
||||
/// //
|
||||
/// // I
|
||||
/// // don't
|
||||
/// // want
|
||||
/// // realism.
|
||||
/// // I
|
||||
/// // want
|
||||
/// // magic!
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - separator: The element that should be split upon.
|
||||
/// - maxSplits: The maximum number of times to split the collection, or
|
||||
/// one less than the number of subsequences to return. If
|
||||
/// `maxSplits + 1` subsequences are returned, the last one is a suffix
|
||||
/// of the original collection containing the remaining elements.
|
||||
/// `maxSplits` must be greater than or equal to zero. The default value
|
||||
/// is `Int.max`.
|
||||
/// - omittingEmptySubsequences: If `false`, an empty subsequence is
|
||||
/// returned in the result for each consecutive pair of `separator`
|
||||
/// elements in the collection and for each instance of `separator` at
|
||||
/// the start or end of the collection. If `true`, only nonempty
|
||||
/// subsequences are returned. The default value is `true`.
|
||||
/// - Returns: A lazy collection of subsequences split from this collection's
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func split(
|
||||
separator: Element,
|
||||
maxSplits: Int = Int.max,
|
||||
omittingEmptySubsequences: Bool = true
|
||||
) -> LazySplitCollection<Elements> {
|
||||
precondition(maxSplits >= 0, "Must take zero or more splits")
|
||||
|
||||
return LazySplitCollection(
|
||||
base: elements,
|
||||
isSeparator: { $0 == separator },
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: omittingEmptySubsequences
|
||||
)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,385 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Implementation for min(count:areInIncreasingOrder:)
|
||||
@inlinable
|
||||
internal func _minImplementation(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
var iterator = makeIterator()
|
||||
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(count)
|
||||
while result.count < count, let e = iterator.next() {
|
||||
result.append(e)
|
||||
}
|
||||
try result.sort(by: areInIncreasingOrder)
|
||||
|
||||
while let e = iterator.next() {
|
||||
// To be part of `result`, `e` must be strictly less than `result.last`.
|
||||
guard try areInIncreasingOrder(e, result.last!) else { continue }
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
|
||||
assert(insertionIndex != result.endIndex)
|
||||
result.removeLast()
|
||||
result.insert(e, at: insertionIndex)
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Implementation for max(count:areInIncreasingOrder:)
|
||||
@inlinable
|
||||
internal func _maxImplementation(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
var iterator = makeIterator()
|
||||
|
||||
var result: [Element] = []
|
||||
result.reserveCapacity(count)
|
||||
while result.count < count, let e = iterator.next() {
|
||||
result.append(e)
|
||||
}
|
||||
try result.sort(by: areInIncreasingOrder)
|
||||
|
||||
while let e = iterator.next() {
|
||||
// To be part of `result`, `e` must be greater/equal to `result.first`.
|
||||
guard try !areInIncreasingOrder(e, result.first!) else { continue }
|
||||
let insertionIndex =
|
||||
try result.partitioningIndex { try areInIncreasingOrder(e, $0) }
|
||||
|
||||
assert(insertionIndex > 0)
|
||||
// Inserting `e` and then removing the first element (or vice versa)
|
||||
// would perform a double shift, so we manually shift down the elements
|
||||
// before dropping `e` in.
|
||||
var i = 1
|
||||
while i < insertionIndex {
|
||||
result[i - 1] = result[i]
|
||||
i += 1
|
||||
}
|
||||
result[insertionIndex - 1] = e
|
||||
}
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
/// Returns the smallest elements of this sequence, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// smallest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.min(count: 3, sortedBy: <)
|
||||
/// // [1, 2, 3]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its smallest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire sequence. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - count: The number of elements to return. If `count` is greater than
|
||||
/// the number of elements in this sequence, all of the sequence's
|
||||
/// elements are returned.
|
||||
/// - areInIncreasingOrder: A predicate that returns `true` if its
|
||||
/// first argument should be ordered before its second argument;
|
||||
/// otherwise, `false`.
|
||||
/// - Returns: An array of the smallest `count` elements of this sequence,
|
||||
/// sorted according to `areInIncreasingOrder`.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
Cannot find a minimum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
|
||||
// Do nothing if we're prefixing nothing.
|
||||
guard count > 0 else {
|
||||
return []
|
||||
}
|
||||
|
||||
return try _minImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this sequence, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its largest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire sequence. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - count: The number of elements to return. If `count` is greater than
|
||||
/// the number of elements in this sequence, all of the sequence's
|
||||
/// elements are returned.
|
||||
/// - areInIncreasingOrder: A predicate that returns `true` if its
|
||||
/// first argument should be ordered before its second argument;
|
||||
/// otherwise, `false`.
|
||||
/// - Returns: An array of the largest `count` elements of this sequence,
|
||||
/// sorted according to `areInIncreasingOrder`.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
Cannot find a maximum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
|
||||
// Do nothing if we're suffixing nothing.
|
||||
guard count > 0 else {
|
||||
return []
|
||||
}
|
||||
|
||||
return try _maxImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence where Element: Comparable {
|
||||
/// Returns the smallest elements of this sequence.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// smallest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.min(count: 3)
|
||||
/// // [1, 2, 3]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its smallest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire sequence. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameter count: The number of elements to return. If `count` is greater
|
||||
/// than the number of elements in this sequence, all of the sequence's
|
||||
/// elements are returned.
|
||||
/// - Returns: An array of the smallest `count` elements of this sequence.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(count: Int) -> [Element] {
|
||||
return min(count: count, sortedBy: <)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this sequence.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.max(count: 3)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a sequence but only need to access its largest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire sequence. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameter count: The number of elements to return. If `count` is greater
|
||||
/// than the number of elements in this sequence, all of the sequence's
|
||||
/// elements are returned.
|
||||
/// - Returns: An array of the largest `count` elements of this sequence.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// sequence and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(count: Int) -> [Element] {
|
||||
return max(count: count, sortedBy: <)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns the smallest elements of this collection, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// smallest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.min(count: 3, sortedBy: <)
|
||||
/// // [1, 2, 3]
|
||||
///
|
||||
/// If you need to sort a collection but only need to access its smallest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire collection. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - count: The number of elements to return. If `count` is greater than
|
||||
/// the number of elements in this collection, all of the collection's
|
||||
/// elements are returned.
|
||||
/// - areInIncreasingOrder: A predicate that returns `true` if its
|
||||
/// first argument should be ordered before its second argument;
|
||||
/// otherwise, `false`.
|
||||
/// - Returns: An array of the smallest `count` elements of this collection,
|
||||
/// sorted according to `areInIncreasingOrder`.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
Cannot find a minimum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
|
||||
// Do nothing if we're prefixing nothing.
|
||||
guard count > 0 else {
|
||||
return []
|
||||
}
|
||||
|
||||
// Make sure we are within bounds.
|
||||
let prefixCount = Swift.min(count, self.count)
|
||||
|
||||
// If we're attempting to prefix more than 10% of the collection, it's
|
||||
// faster to sort everything.
|
||||
guard prefixCount < (self.count / 10) else {
|
||||
return Array(try sorted(by: areInIncreasingOrder).prefix(prefixCount))
|
||||
}
|
||||
|
||||
return try _minImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this collection, as sorted by the given
|
||||
/// predicate.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.max(count: 3, sortedBy: <)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a collection but only need to access its largest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire collection. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - count: The number of elements to return. If `count` is greater than
|
||||
/// the number of elements in this collection, all of the collection's
|
||||
/// elements are returned.
|
||||
/// - areInIncreasingOrder: A predicate that returns `true` if its
|
||||
/// first argument should be ordered before its second argument;
|
||||
/// otherwise, `false`.
|
||||
/// - Returns: An array of the largest `count` elements of this collection,
|
||||
/// sorted according to `areInIncreasingOrder`.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(
|
||||
count: Int,
|
||||
sortedBy areInIncreasingOrder: (Element, Element) throws -> Bool
|
||||
) rethrows -> [Element] {
|
||||
precondition(count >= 0, """
|
||||
Cannot find a maximum with a negative count of elements!
|
||||
"""
|
||||
)
|
||||
|
||||
// Do nothing if we're suffixing nothing.
|
||||
guard count > 0 else {
|
||||
return []
|
||||
}
|
||||
|
||||
// Make sure we are within bounds.
|
||||
let suffixCount = Swift.min(count, self.count)
|
||||
|
||||
// If we're attempting to prefix more than 10% of the collection, it's
|
||||
// faster to sort everything.
|
||||
guard suffixCount < (self.count / 10) else {
|
||||
return Array(try sorted(by: areInIncreasingOrder).suffix(suffixCount))
|
||||
}
|
||||
|
||||
return try _maxImplementation(count: count, sortedBy: areInIncreasingOrder)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection where Element: Comparable {
|
||||
/// Returns the smallest elements of this collection.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// smallest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.min(count: 3)
|
||||
/// // [1, 2, 3]
|
||||
///
|
||||
/// If you need to sort a collection but only need to access its smallest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire collection. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameter count: The number of elements to return. If `count` is greater
|
||||
/// than the number of elements in this collection, all of the collection's
|
||||
/// elements are returned.
|
||||
/// - Returns: An array of the smallest `count` elements of this collection.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func min(count: Int) -> [Element] {
|
||||
return min(count: count, sortedBy: <)
|
||||
}
|
||||
|
||||
/// Returns the largest elements of this collection.
|
||||
///
|
||||
/// This example partially sorts an array of integers to retrieve its three
|
||||
/// largest values:
|
||||
///
|
||||
/// let numbers = [7, 1, 6, 2, 8, 3, 9]
|
||||
/// let smallestThree = numbers.max(count: 3)
|
||||
/// // [7, 8, 9]
|
||||
///
|
||||
/// If you need to sort a collection but only need to access its largest
|
||||
/// elements, using this method can give you a performance boost over sorting
|
||||
/// the entire collection. The order of equal elements is guaranteed to be
|
||||
/// preserved.
|
||||
///
|
||||
/// - Parameter count: The number of elements to return. If `count` is greater
|
||||
/// than the number of elements in this collection, all of the collection's
|
||||
/// elements are returned.
|
||||
/// - Returns: An array of the largest `count` elements of this collection.
|
||||
///
|
||||
/// - Complexity: O(*k* log *k* + *nk*), where *n* is the length of the
|
||||
/// collection and *k* is `count`.
|
||||
@inlinable
|
||||
public func max(count: Int) -> [Element] {
|
||||
return max(count: count, sortedBy: <)
|
||||
}
|
||||
}
|
||||
@@ -21,7 +21,7 @@ extension MutableCollection {
|
||||
/// - Complexity: O(*n* log *n*), where *n* is the number of elements.
|
||||
/// - Precondition:
|
||||
/// `n == distance(from: range.lowerBound, to: range.upperBound)`
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal mutating func stablePartition(
|
||||
count n: Int,
|
||||
subrange: Range<Index>,
|
||||
|
||||
@@ -9,140 +9,8 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence of all the permutations of a collection's elements.
|
||||
public struct Permutations<Base: Collection> {
|
||||
/// The base collection.
|
||||
public let base: Base
|
||||
|
||||
internal let baseCount: Int
|
||||
internal let countToChoose: Int
|
||||
|
||||
internal init(_ base: Base, k: Int? = nil) {
|
||||
self.base = base
|
||||
let baseCount = base.count
|
||||
self.baseCount = baseCount
|
||||
self.countToChoose = k ?? baseCount
|
||||
}
|
||||
|
||||
public var count: Int {
|
||||
return baseCount >= countToChoose
|
||||
? stride(from: baseCount, to: baseCount - countToChoose, by: -1).reduce(1, *)
|
||||
: 0
|
||||
}
|
||||
}
|
||||
|
||||
extension Permutations: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var base: Base
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
@usableFromInline
|
||||
internal var hasMorePermutations: Bool
|
||||
@usableFromInline
|
||||
internal var countToChoose: Int = 0
|
||||
|
||||
/// `true` if we're generating permutations of the full collection.
|
||||
@usableFromInline
|
||||
internal var permutesFullCollection: Bool {
|
||||
countToChoose == indexes.count
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base) {
|
||||
self.base = base
|
||||
self.indexes = Array(base.indices)
|
||||
self.countToChoose = self.indexes.count
|
||||
self.hasMorePermutations = true
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base, count: Int) {
|
||||
self.base = base
|
||||
self.countToChoose = count
|
||||
|
||||
// Produce exactly one empty permutation when `count == 0`.
|
||||
self.indexes = count == 0 ? [] : Array(base.indices)
|
||||
|
||||
// Can't produce any permutations when `count > base.count`.
|
||||
self.hasMorePermutations = count <= indexes.count
|
||||
}
|
||||
|
||||
/// Advances the `indexes` array such that the first `countToChoose`
|
||||
/// elements contain the next lexicographic ordering of elements.
|
||||
///
|
||||
/// Uses the SEP(n,k) algorithm, as described in:
|
||||
/// https://alistairisrael.wordpress.com/2009/09/22/simple-efficient-pnk-algorithm/
|
||||
///
|
||||
/// - Returns: A Boolean value indicating whether `indexes` still has
|
||||
/// remaining permutations. When this method returns `false`, `indexes`
|
||||
/// is in ascending order.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@usableFromInline
|
||||
internal mutating func nextState() -> Bool {
|
||||
let edge = countToChoose - 1
|
||||
|
||||
// Find first index greater than the one at `edge`.
|
||||
if let i = indexes[countToChoose...].firstIndex(where: { indexes[edge] < $0 }) {
|
||||
indexes.swapAt(edge, i)
|
||||
} else {
|
||||
indexes.reverse(subrange: countToChoose..<indexes.endIndex)
|
||||
|
||||
// Find last increasing pair below `edge`.
|
||||
// TODO: This could be indexes[..<edge].adjacentPairs().lastIndex(where: ...)
|
||||
var lastAscent = edge - 1
|
||||
while (lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1]) {
|
||||
lastAscent -= 1
|
||||
}
|
||||
if (lastAscent < 0) {
|
||||
return false
|
||||
}
|
||||
|
||||
// Find rightmost index less than that at `lastAscent`.
|
||||
if let i = indexes[lastAscent...].lastIndex(where: { indexes[lastAscent] < $0 }) {
|
||||
indexes.swapAt(lastAscent, i)
|
||||
}
|
||||
indexes.reverse(subrange: (lastAscent + 1)..<indexes.endIndex)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
if !hasMorePermutations { return nil }
|
||||
|
||||
if permutesFullCollection {
|
||||
// If we're permuting the full collection, each iteration is just a
|
||||
// call to `nextPermutation` on `indexes`.
|
||||
defer { hasMorePermutations = indexes.nextPermutation() }
|
||||
return indexes.map { base[$0] }
|
||||
} else {
|
||||
// Otherwise, return the items at the first `countToChoose` indices and
|
||||
// advance the state.
|
||||
defer { hasMorePermutations = nextState() }
|
||||
return indexes.prefix(countToChoose).map { base[$0] }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var permutesFullCollection: Bool {
|
||||
baseCount == countToChoose
|
||||
}
|
||||
|
||||
public func makeIterator() -> Iterator {
|
||||
permutesFullCollection
|
||||
? Iterator(base)
|
||||
: Iterator(base, count: countToChoose)
|
||||
}
|
||||
}
|
||||
|
||||
extension Permutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// nextPermutation(by:)
|
||||
// nextPermutation()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension MutableCollection
|
||||
@@ -160,25 +28,39 @@ extension MutableCollection
|
||||
/// is in ascending order according to `areInIncreasingOrder`.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@usableFromInline
|
||||
internal mutating func nextPermutation() -> Bool {
|
||||
// ensure we have > 1 element in the collection
|
||||
if isEmpty { return false }
|
||||
@inlinable
|
||||
internal mutating func nextPermutation(upperBound: Index? = nil) -> Bool {
|
||||
// Ensure we have > 1 element in the collection.
|
||||
guard !isEmpty else { return false }
|
||||
var i = index(before: endIndex)
|
||||
if i == startIndex { return false }
|
||||
|
||||
let upperBound = upperBound ?? endIndex
|
||||
|
||||
while true {
|
||||
let ip1 = i
|
||||
formIndex(before: &i)
|
||||
|
||||
// Find the last ascending pair (ie. ..., a, b, ... where a < b)
|
||||
if self[i] < self[ip1] {
|
||||
var j = index(before: endIndex)
|
||||
while self[i] >= self[j] {
|
||||
formIndex(before: &j)
|
||||
}
|
||||
// Find the last element greater than self[i]
|
||||
// This is _always_ at most `ip1` due to if statement above
|
||||
let j = lastIndex(where: { self[i] < $0 })!
|
||||
|
||||
// At this point we have something like this:
|
||||
// 0, 1, 4, 3, 2
|
||||
// ^ ^
|
||||
// i j
|
||||
swapAt(i, j)
|
||||
self.reverse(subrange: ip1..<endIndex)
|
||||
return true
|
||||
self.reverse(subrange: ip1 ..< endIndex)
|
||||
|
||||
// Only return if we've made a change within ..<upperBound region
|
||||
if i < upperBound {
|
||||
return true
|
||||
} else {
|
||||
i = index(before: endIndex)
|
||||
continue
|
||||
}
|
||||
}
|
||||
|
||||
if i == startIndex {
|
||||
@@ -189,11 +71,264 @@ extension MutableCollection
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// struct Permutations<Base>
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence of all the permutations of a collection's elements.
|
||||
public struct Permutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The range of accepted sizes of permutations.
|
||||
/// - Note: This may be empty if the attempted range entirely exceeds the
|
||||
/// bounds of the size of the `base` collection.
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>
|
||||
|
||||
/// Initializes a `Permutations` for all permutations of `base` of size `k`.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for permutations
|
||||
/// - k: The expected size of each permutation, or `nil` (default) to
|
||||
/// iterate over all permutations of the same size as the base collection.
|
||||
@inlinable
|
||||
internal init(_ base: Base, k: Int? = nil) {
|
||||
let kRange: ClosedRange<Int>?
|
||||
if let countToChoose = k {
|
||||
kRange = countToChoose ... countToChoose
|
||||
} else {
|
||||
kRange = nil
|
||||
}
|
||||
self.init(base, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Initializes a `Permutations` for all combinations of `base` of sizes
|
||||
/// within a given range.
|
||||
/// - Parameters:
|
||||
/// - base: The collection to iterate over for permutations.
|
||||
/// - kRange: The range of accepted sizes of permutations, or `nil` to
|
||||
/// iterate over all permutations of the same size as the base collection.
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(
|
||||
_ base: Base, kRange: R?
|
||||
) where R.Bound == Int {
|
||||
self.base = base
|
||||
let baseCount = base.count
|
||||
self.baseCount = baseCount
|
||||
let upperBound = baseCount + 1
|
||||
self.kRange = kRange?.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< upperBound) ??
|
||||
baseCount ..< upperBound
|
||||
}
|
||||
|
||||
/// The total number of permutations.
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
return kRange.map {
|
||||
stride(from: baseCount, to: baseCount - $0, by: -1).reduce(1, *)
|
||||
}.reduce(0, +)
|
||||
}
|
||||
}
|
||||
|
||||
extension Permutations: Sequence {
|
||||
/// The iterator for a `Permutations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let baseCount: Int
|
||||
|
||||
/// The current range of accepted sizes of permutations.
|
||||
/// - Note: The range is contracted until empty while iterating over
|
||||
/// permutations of different sizes. When the range is empty, iteration is
|
||||
/// finished.
|
||||
@usableFromInline
|
||||
internal var kRange: Range<Int>
|
||||
|
||||
/// Whether or not iteration is finished (`kRange` is empty)
|
||||
@inlinable
|
||||
internal var isFinished: Bool {
|
||||
return kRange.isEmpty
|
||||
}
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@inlinable
|
||||
internal init(_ permutations: Permutations) {
|
||||
self.base = permutations.base
|
||||
self.baseCount = permutations.baseCount
|
||||
self.kRange = permutations.kRange
|
||||
self.indexes = Array(permutations.base.indices)
|
||||
}
|
||||
|
||||
/// Advances the `indexes` array such that the first `countToChoose`
|
||||
/// elements contain the next lexicographic ordering of elements.
|
||||
///
|
||||
/// Uses the SEP(n,k) algorithm, as described in:
|
||||
/// https://alistairisrael.wordpress.com/2009/09/22/simple-efficient-pnk-algorithm/
|
||||
///
|
||||
/// - Returns: A Boolean value indicating whether `indexes` still has
|
||||
/// remaining permutations. When this method returns `false`, `indexes`
|
||||
/// is in ascending order.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
internal mutating func nextState() -> Bool {
|
||||
let countToChoose = self.kRange.lowerBound
|
||||
let edge = countToChoose - 1
|
||||
|
||||
// Find first index greater than the one at `edge`.
|
||||
if let i = indexes[countToChoose...].firstIndex(where: { indexes[edge] < $0 }) {
|
||||
indexes.swapAt(edge, i)
|
||||
} else {
|
||||
indexes.reverse(subrange: countToChoose ..< indexes.endIndex)
|
||||
|
||||
// Find last increasing pair below `edge`.
|
||||
// TODO: This could be indexes[..<edge].adjacentPairs().lastIndex(where: ...)
|
||||
var lastAscent = edge - 1
|
||||
while (lastAscent >= 0 && indexes[lastAscent] >= indexes[lastAscent + 1]) {
|
||||
lastAscent -= 1
|
||||
}
|
||||
if lastAscent < 0 {
|
||||
return false
|
||||
}
|
||||
|
||||
// Find rightmost index less than that at `lastAscent`.
|
||||
if let i = indexes[lastAscent...].lastIndex(where: { indexes[lastAscent] < $0 }) {
|
||||
indexes.swapAt(lastAscent, i)
|
||||
}
|
||||
indexes.reverse(subrange: (lastAscent + 1) ..< indexes.endIndex)
|
||||
}
|
||||
|
||||
return true
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
guard !isFinished else { return nil }
|
||||
|
||||
/// Advances `kRange` by incrementing its `lowerBound` until the range is
|
||||
/// empty, when iteration is finished.
|
||||
func advanceKRange() {
|
||||
kRange.removeFirst()
|
||||
indexes = Array(base.indices)
|
||||
}
|
||||
|
||||
let countToChoose = self.kRange.lowerBound
|
||||
if countToChoose == 0 {
|
||||
defer {
|
||||
advanceKRange()
|
||||
}
|
||||
return []
|
||||
}
|
||||
|
||||
let permutesFullCollection = (countToChoose == baseCount)
|
||||
if permutesFullCollection {
|
||||
// If we're permuting the full collection, each iteration is just a
|
||||
// call to `nextPermutation` on `indexes`.
|
||||
defer {
|
||||
let hasMorePermutations = indexes.nextPermutation()
|
||||
if !hasMorePermutations {
|
||||
advanceKRange()
|
||||
}
|
||||
}
|
||||
return indexes.map { base[$0] }
|
||||
} else {
|
||||
// Otherwise, return the items at the first `countToChoose` indices and
|
||||
// advance the state.
|
||||
defer {
|
||||
let hasMorePermutations = nextState()
|
||||
if !hasMorePermutations {
|
||||
advanceKRange()
|
||||
}
|
||||
}
|
||||
return indexes.prefix(countToChoose).map { base[$0] }
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(self)
|
||||
}
|
||||
}
|
||||
|
||||
extension Permutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// permutations(ofCount:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of the permutations of this collection with lengths
|
||||
/// in the specified range.
|
||||
///
|
||||
/// This example prints the different permutations of one to two elements from
|
||||
/// an array of three names:
|
||||
///
|
||||
/// let names = ["Alex", "Celeste", "Davide"]
|
||||
/// for perm in names.permutations(ofCount: 1...2) {
|
||||
/// print(perm.joined(separator: ", "))
|
||||
/// }
|
||||
/// // Alex
|
||||
/// // Celeste
|
||||
/// // Davide
|
||||
/// // Alex, Celeste
|
||||
/// // Alex, Davide
|
||||
/// // Celeste, Alex
|
||||
/// // Celeste, Davide
|
||||
/// // Davide, Alex
|
||||
/// // Davide, Celeste
|
||||
///
|
||||
/// This example prints _all_ the permutations (including an empty array) from
|
||||
/// an array of numbers:
|
||||
///
|
||||
/// let numbers = [10, 20, 30]
|
||||
/// for perm in numbers.permutations(ofCount: 0...) {
|
||||
/// print(perm)
|
||||
/// }
|
||||
/// // []
|
||||
/// // [10]
|
||||
/// // [20]
|
||||
/// // [30]
|
||||
/// // [10, 20]
|
||||
/// // [10, 30]
|
||||
/// // [20, 10]
|
||||
/// // [20, 30]
|
||||
/// // [30, 10]
|
||||
/// // [30, 20]
|
||||
/// // [10, 20, 30]
|
||||
/// // [10, 30, 20]
|
||||
/// // [20, 10, 30]
|
||||
/// // [20, 30, 10]
|
||||
/// // [30, 10, 20]
|
||||
/// // [30, 20, 10]
|
||||
///
|
||||
/// The returned permutations are in ascending order by length, and then
|
||||
/// lexicographically within each group of the same length.
|
||||
///
|
||||
/// - Parameter kRange: A range of the number of elements to include in each
|
||||
/// permutation. `kRange` can be any integer range expression, and is
|
||||
/// clamped to the number of elements in this collection. Passing a range
|
||||
/// covering sizes greater than the number of elements in this collection
|
||||
/// results in an empty sequence.
|
||||
///
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since `Permutations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func permutations<R: RangeExpression>(
|
||||
ofCount kRange: R
|
||||
) -> Permutations<Self> where R.Bound == Int {
|
||||
return Permutations(self, kRange: kRange)
|
||||
}
|
||||
|
||||
/// Returns a collection of the permutations of this collection of the
|
||||
/// specified length.
|
||||
///
|
||||
@@ -236,14 +371,212 @@ extension Collection {
|
||||
/// sequence, the resulting sequence has no elements.
|
||||
///
|
||||
/// - Parameter k: The number of elements to include in each permutation.
|
||||
/// If `count` is `nil`, the resulting sequence represents permutations
|
||||
/// of this entire collection.
|
||||
/// If `k` is `nil`, the resulting sequence represents permutations of this
|
||||
/// entire collection. If `k` is greater than the number of elements in
|
||||
/// this collection, the resulting sequence is empty.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
/// - Complexity: O(1) for random-access base collections. O(*n*) where *n*
|
||||
/// is the number of elements in the base collection, since `Permutations`
|
||||
/// accesses the `count` of the base collection.
|
||||
@inlinable
|
||||
public func permutations(ofCount k: Int? = nil) -> Permutations<Self> {
|
||||
assert(
|
||||
precondition(
|
||||
k ?? 0 >= 0,
|
||||
"Can't have permutations with a negative number of elements.")
|
||||
return Permutations(self, k: k)
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// uniquePermutations()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence of the unique permutations of the elements of a sequence or
|
||||
/// collection.
|
||||
///
|
||||
/// To create a `UniquePermutations` instance, call one of the
|
||||
/// `uniquePermutations` methods on your collection.
|
||||
public struct UniquePermutations<Base: Collection> {
|
||||
/// The base collection to iterate over for permutations.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@usableFromInline
|
||||
internal let kRange: Range<Int>
|
||||
}
|
||||
|
||||
extension UniquePermutations where Base.Element: Hashable {
|
||||
@inlinable
|
||||
internal static func _indexes(_ base: Base) -> [Base.Index] {
|
||||
let firstIndexesAndCountsByElement = Dictionary(
|
||||
base.indices.lazy.map { (base[$0], ($0, 1)) },
|
||||
uniquingKeysWith: { indexAndCount, _ in (indexAndCount.0, indexAndCount.1 + 1) })
|
||||
|
||||
return firstIndexesAndCountsByElement
|
||||
.values.sorted(by: { $0.0 < $1.0 })
|
||||
.flatMap { index, count in repeatElement(index, count: count) }
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal init(_ elements: Base) {
|
||||
self.indexes = Self._indexes(elements)
|
||||
self.base = elements
|
||||
self.kRange = self.indexes.count ..< (self.indexes.count + 1)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal init<R: RangeExpression>(_ base: Base, _ range: R)
|
||||
where R.Bound == Int
|
||||
{
|
||||
self.indexes = Self._indexes(base)
|
||||
self.base = base
|
||||
|
||||
let upperBound = self.indexes.count + 1
|
||||
self.kRange = range.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< upperBound)
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquePermutations: Sequence {
|
||||
/// The iterator for a `UniquePermutations` instance.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal var indexes: [Base.Index]
|
||||
|
||||
@usableFromInline
|
||||
internal var lengths: Range<Int>
|
||||
|
||||
@usableFromInline
|
||||
internal var initial = true
|
||||
|
||||
@inlinable
|
||||
internal init(_ elements: Base, indexes: [Base.Index], lengths: Range<Int>) {
|
||||
self.base = elements
|
||||
self.indexes = indexes
|
||||
self.lengths = lengths
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> [Base.Element]? {
|
||||
// In the end case, `lengths` is an empty range.
|
||||
if lengths.isEmpty {
|
||||
return nil
|
||||
}
|
||||
|
||||
// The first iteration must produce the original sorted array, before any
|
||||
// permutations. We skip the permutation the first time so that we can
|
||||
// always mutate the array _before_ returning a slice, which avoids
|
||||
// copying when possible.
|
||||
if initial {
|
||||
initial = false
|
||||
return indexes[..<lengths.lowerBound].map { base[$0] }
|
||||
}
|
||||
|
||||
if !indexes.nextPermutation(upperBound: lengths.lowerBound) {
|
||||
lengths.removeFirst()
|
||||
|
||||
if lengths.isEmpty {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
return indexes[..<lengths.lowerBound].map { base[$0] }
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base, indexes: indexes, lengths: kRange)
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquePermutations: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
extension Collection where Element: Hashable {
|
||||
/// Returns a sequence of the unique permutations of this sequence of the
|
||||
/// specified length.
|
||||
///
|
||||
/// Use this method to iterate over the unique permutations of a sequence
|
||||
/// with repeating elements. This example prints every unique two-element
|
||||
/// permutation of an array of numbers:
|
||||
///
|
||||
/// let numbers = [1, 1, 2]
|
||||
/// for perm in numbers.uniquePermutations(ofCount: 2) {
|
||||
/// print(perm)
|
||||
/// }
|
||||
/// // [1, 1]
|
||||
/// // [1, 2]
|
||||
/// // [2, 1]
|
||||
///
|
||||
/// By contrast, the `permutations(ofCount:)` method permutes a collection's
|
||||
/// elements by position, and can include permutations with equal elements
|
||||
/// in each permutation:
|
||||
///
|
||||
/// for perm in numbers.permutations(ofCount: 2)
|
||||
/// print(perm)
|
||||
/// }
|
||||
/// // [1, 1]
|
||||
/// // [1, 1]
|
||||
/// // [1, 2]
|
||||
/// // [1, 2]
|
||||
/// // [2, 1]
|
||||
/// // [2, 1]
|
||||
///
|
||||
/// The returned permutations are in lexicographically sorted order.
|
||||
///
|
||||
/// - Parameter k: The number of elements to include in each permutation.
|
||||
/// If `k` is `nil`, the resulting sequence represents permutations of this
|
||||
/// entire collection. If `k` is greater than the number of elements in
|
||||
/// this collection, the resulting sequence is empty.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
public func uniquePermutations(ofCount k: Int? = nil) -> UniquePermutations<Self> {
|
||||
if let k = k {
|
||||
return UniquePermutations(self, k ..< (k + 1))
|
||||
} else {
|
||||
return UniquePermutations(self)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a collection of the unique permutations of this sequence with
|
||||
/// lengths in the specified range.
|
||||
///
|
||||
/// Use this method to iterate over the unique permutations of a sequence
|
||||
/// with repeating elements. This example prints every unique permutation
|
||||
/// of an array of numbers with lengths through 2 elements:
|
||||
///
|
||||
/// let numbers = [1, 1, 2]
|
||||
/// for perm in numbers.uniquePermutations(ofCount: ...2) {
|
||||
/// print(perm)
|
||||
/// }
|
||||
/// // []
|
||||
/// // [1]
|
||||
/// // [2]
|
||||
/// // [1, 1]
|
||||
/// // [1, 2]
|
||||
/// // [2, 1]
|
||||
///
|
||||
/// The returned permutations are in ascending order by length, and then
|
||||
/// lexicographically within each group of the same length.
|
||||
///
|
||||
/// - Parameter kRange: A range of the number of elements to include in each
|
||||
/// permutation. `kRange` can be any integer range expression, and is
|
||||
/// clamped to the number of elements in this collection. Passing a range
|
||||
/// covering sizes greater than the number of elements in this collection
|
||||
/// results in an empty sequence.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the number of elements in this
|
||||
/// collection.
|
||||
public func uniquePermutations<R: RangeExpression>(ofCount kRange: R) -> UniquePermutations<Self>
|
||||
where R.Bound == Int
|
||||
{
|
||||
UniquePermutations(self, kRange)
|
||||
}
|
||||
}
|
||||
@@ -9,13 +9,17 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence that represents the product of two sequence's elements.
|
||||
/// A sequence that represents the product of two sequences' elements.
|
||||
public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
/// The outer sequence in the product.
|
||||
public let base1: Base1
|
||||
/// The inner sequence in the product.
|
||||
public let base2: Base2
|
||||
@usableFromInline
|
||||
internal let base1: Base1
|
||||
|
||||
/// The inner sequence in the product.
|
||||
@usableFromInline
|
||||
internal let base2: Base2
|
||||
|
||||
@inlinable
|
||||
internal init(_ base1: Base1, _ base2: Base2) {
|
||||
self.base1 = base1
|
||||
self.base2 = base2
|
||||
@@ -23,6 +27,8 @@ public struct Product2<Base1: Sequence, Base2: Collection> {
|
||||
}
|
||||
|
||||
extension Product2: Sequence {
|
||||
public typealias Element = (Base1.Element, Base2.Element)
|
||||
|
||||
/// The iterator for a `Product2` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
@@ -34,7 +40,7 @@ extension Product2: Sequence {
|
||||
@usableFromInline
|
||||
internal let base2: Base2
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(_ c: Product2) {
|
||||
self.base2 = c.base2
|
||||
self.i1 = c.base1.makeIterator()
|
||||
@@ -43,7 +49,8 @@ extension Product2: Sequence {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> (Base1.Element, Base2.Element)? {
|
||||
public mutating func next() -> (Base1.Element,
|
||||
Base2.Element)? {
|
||||
// This is the initial state, where i1.next() has never
|
||||
// been called, or the final state, where i1.next() has
|
||||
// already returned nil.
|
||||
@@ -89,7 +96,7 @@ extension Product2: Collection where Base1: Collection {
|
||||
@usableFromInline
|
||||
internal var i2: Base2.Index
|
||||
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal init(i1: Base1.Index, i2: Base2.Index) {
|
||||
self.i1 = i1
|
||||
self.i2 = i2
|
||||
@@ -120,32 +127,295 @@ extension Product2: Collection where Base1: Collection {
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.i1 != base1.endIndex, "Can't advance past endIndex")
|
||||
let newIndex2 = base2.index(after: i.i2)
|
||||
return newIndex2 == base2.endIndex
|
||||
? Index(i1: base1.index(after: i.i1), i2: base2.startIndex)
|
||||
: Index(i1: i.i1, i2: newIndex2)
|
||||
public subscript(position: Index) -> (Base1.Element,
|
||||
Base2.Element) {
|
||||
(base1[position.i1], base2[position.i2])
|
||||
}
|
||||
|
||||
// TODO: Implement index(_:offsetBy:) and index(_:offsetBy:limitedBy:)
|
||||
/// Forms an index from a pair of base indices, normalizing
|
||||
/// `(i, base2.endIndex)` to `(base1.index(after: i), base2.startIndex)` if
|
||||
/// necessary.
|
||||
@inlinable
|
||||
internal func normalizeIndex(_ i1: Base1.Index, _ i2: Base2.Index) -> Index {
|
||||
i2 == base2.endIndex
|
||||
? Index(i1: base1.index(after: i1), i2: base2.startIndex)
|
||||
: Index(i1: i1, i2: i2)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.i1 != base1.endIndex, "Can't advance past endIndex")
|
||||
return normalizeIndex(i.i1, base2.index(after: i.i2))
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
if start > end {
|
||||
return -distance(from: end, to: start)
|
||||
}
|
||||
if start.i1 == end.i1 {
|
||||
return base2[start.i2..<end.i2].count
|
||||
}
|
||||
guard start.i1 <= end.i1
|
||||
else { return -distance(from: end, to: start) }
|
||||
guard start.i1 != end.i1
|
||||
else { return base2.distance(from: start.i2, to: end.i2) }
|
||||
|
||||
return base2[start.i2...].count + base2[..<end.i2].count
|
||||
+ base2.count * (base1.distance(from: start.i1, to: end.i1) - 1)
|
||||
// The number of full cycles through `base2` between `start` and `end`,
|
||||
// excluding the cycles that `start` and `end` are on.
|
||||
let fullBase2Cycles = base1[start.i1..<end.i1].count - 1
|
||||
|
||||
if start.i2 <= end.i2 {
|
||||
// start.i2
|
||||
// v
|
||||
// start.i1 > [l l l|c c c c c c r r r]
|
||||
// [l l l c c c c c c r r r] >
|
||||
// ... > `fullBase2Cycles` times
|
||||
// [l l l c c c c c c r r r] >
|
||||
// end.i1 > [l l l c c c c c c|r r r]
|
||||
// ^
|
||||
// end.i2
|
||||
|
||||
let left = base2[..<start.i2].count
|
||||
let center = base2[start.i2..<end.i2].count
|
||||
let right = base2[end.i2...].count
|
||||
|
||||
return center + right
|
||||
+ fullBase2Cycles * (left + center + right)
|
||||
+ left + center
|
||||
} else {
|
||||
// start.i2
|
||||
// v
|
||||
// start.i1 > [l l l c c c c c c|r r r]
|
||||
// [l l l c c c c c c r r r] >
|
||||
// ... > `fullBase2Cycles` times
|
||||
// [l l l c c c c c c r r r] >
|
||||
// end.i1 > [l l l|c c c c c c r r r]
|
||||
// ^
|
||||
// end.i2
|
||||
|
||||
let left = base2[..<end.i2].count
|
||||
let right = base2[start.i2...].count
|
||||
|
||||
// We can avoid traversing `base2[end.i2..<start.i2]` if `start` and `end`
|
||||
// are on consecutive cycles.
|
||||
guard fullBase2Cycles > 0 else { return right + left }
|
||||
|
||||
let center = base2[end.i2..<start.i2].count
|
||||
return right
|
||||
+ fullBase2Cycles * (left + center + right)
|
||||
+ left
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if distance >= 0 {
|
||||
return limit >= i
|
||||
? offsetForward(i, by: distance, limitedBy: limit)
|
||||
: offsetForward(i, by: distance)
|
||||
} else {
|
||||
return limit <= i
|
||||
? offsetBackward(i, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> (Base1.Element, Base2.Element) {
|
||||
return (base1[position.i1], base2[position.i2])
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit >= i)
|
||||
|
||||
if limit.i1 == i.i1 {
|
||||
// Delegate to `base2` if the offset is limited to `i.i1`.
|
||||
//
|
||||
// i.i2 limit.i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
|
||||
return base2.index(i.i2, offsetBy: distance, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: i.i1, i2: i2) }
|
||||
}
|
||||
|
||||
|
||||
if let i2 = base2.index(i.i2, offsetBy: distance, limitedBy: base2.endIndex) {
|
||||
// `distance` does not overflow `base2[i.i2...]`.
|
||||
//
|
||||
// i.i2 i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
// [ |> > > > > >| ] (`distance`)
|
||||
|
||||
return normalizeIndex(i.i1, i2)
|
||||
}
|
||||
|
||||
let suffixCount = base2[i.i2...].count
|
||||
let remaining = distance - suffixCount
|
||||
let nextI1 = base1.index(after: i.i1)
|
||||
|
||||
if limit.i1 == nextI1 {
|
||||
// Delegate to `base2` if the offset is limited to `nextI1`.
|
||||
//
|
||||
// i.i2
|
||||
// v
|
||||
// i.i1 > [x x x|x x x x x x x x x]
|
||||
// nextI1 > [x x x x x x x x x|x x x]
|
||||
// ^
|
||||
// limit.i2
|
||||
|
||||
return base2.index(base2.startIndex, offsetBy: remaining, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: nextI1, i2: i2) }
|
||||
}
|
||||
|
||||
if let i2 = base2.index(base2.startIndex, offsetBy: remaining, limitedBy: i.i2) {
|
||||
// `remaining` does not overflow `base2[..<i.i2]`.
|
||||
//
|
||||
// i.i2
|
||||
// v
|
||||
// i.i1 > [x x x x x x x x x|x x x]
|
||||
// [ |> > >] (`suffixCount`)
|
||||
// [> > >| ] (`remaining`)
|
||||
// nextI1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i2
|
||||
|
||||
return Index(i1: nextI1, i2: i2)
|
||||
}
|
||||
|
||||
let prefixCount = base2[..<i.i2].count
|
||||
let base2Count = prefixCount + suffixCount
|
||||
let base1Distance = remaining / base2Count
|
||||
|
||||
guard let i1 = base1.index(nextI1, offsetBy: base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
// The distance from `base2.startIndex` to the target.
|
||||
let base2Distance = remaining % base2Count
|
||||
|
||||
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.endIndex
|
||||
return base2.index(base2.startIndex, offsetBy: base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance >= 0)
|
||||
assert(limit <= i)
|
||||
|
||||
if limit.i1 == i.i1 {
|
||||
// Delegate to `base2` if the offset is limited to `i.i1`.
|
||||
//
|
||||
// limit.i2 i.i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
|
||||
return base2.index(i.i2, offsetBy: -distance, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: i.i1, i2: i2) }
|
||||
}
|
||||
|
||||
if let i2 = base2.index(i.i2, offsetBy: -distance, limitedBy: base2.startIndex) {
|
||||
// `distance` does not underflow `base2[..<i.i2]`.
|
||||
//
|
||||
// i2 i.i2
|
||||
// v v
|
||||
// i.i1 > [x x x|x x x x x x|x x x]
|
||||
// [ |< < < < < <| ] (`distance`)
|
||||
|
||||
return Index(i1: i.i1, i2: i2)
|
||||
}
|
||||
|
||||
let prefixCount = base2[..<i.i2].count
|
||||
let remaining = distance - prefixCount
|
||||
let previousI1 = base1.index(i.i1, offsetBy: -1)
|
||||
|
||||
if limit.i1 == previousI1 {
|
||||
// Delegate to `base2` if the offset is limited to `previousI1`.
|
||||
//
|
||||
// limit.i2
|
||||
// v
|
||||
// previousI1 > [x x x|x x x x x x x x x]
|
||||
// i.i1 > [x x x x x x x x x|x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
return base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: limit.i2)
|
||||
.map { i2 in Index(i1: previousI1, i2: i2) }
|
||||
}
|
||||
|
||||
if let i2 = base2.index(base2.endIndex, offsetBy: -remaining, limitedBy: i.i2) {
|
||||
// `remaining` does not underflow `base2[i.i2...]`.
|
||||
//
|
||||
// i2
|
||||
// v
|
||||
// previousI1 > [x x x x x x x x x|x x x]
|
||||
// [ |< < <] (`remaining`)
|
||||
// [< < <| ] (`prefixCount`)
|
||||
// i.i1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
return Index(i1: previousI1, i2: i2)
|
||||
}
|
||||
|
||||
let suffixCount = base2[i.i2...].count
|
||||
let base2Count = prefixCount + suffixCount
|
||||
let base1Distance = remaining / base2Count
|
||||
|
||||
// The distance from `base2.endIndex` to the target.
|
||||
let base2Distance = remaining % base2Count
|
||||
|
||||
if base2Distance == 0 {
|
||||
// We end up exactly between two cycles, so `base1Distance` would
|
||||
// overshoot the target by 1.
|
||||
//
|
||||
// base2.startIndex
|
||||
// v
|
||||
// i1 > |x x x x x x x x x x x x] >
|
||||
// ... > `base1Distance` times
|
||||
// previousI1 > [x x x x x x x x x x x x] >
|
||||
// i.i1 > [x x x|x x x x x x x x x]
|
||||
// ^
|
||||
// i.i2
|
||||
|
||||
if let i1 = base1.index(previousI1, offsetBy: -(base1Distance - 1), limitedBy: limit.i1) {
|
||||
let index = Index(i1: i1, i2: base2.startIndex)
|
||||
return index < limit ? nil : index
|
||||
} else {
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
guard let i1 = base1.index(previousI1, offsetBy: -base1Distance, limitedBy: limit.i1)
|
||||
else { return nil }
|
||||
|
||||
let base2Limit = limit.i1 == i1 ? limit.i2 : base2.startIndex
|
||||
return base2.index(base2.endIndex, offsetBy: -base2Distance, limitedBy: base2Limit)
|
||||
.map { i2 in Index(i1: i1, i2: i2) }
|
||||
}
|
||||
}
|
||||
|
||||
@@ -170,8 +440,6 @@ extension Product2: RandomAccessCollection
|
||||
where Base1: RandomAccessCollection, Base2: RandomAccessCollection {}
|
||||
|
||||
extension Product2.Index: Hashable where Base1.Index: Hashable, Base2.Index: Hashable {}
|
||||
extension Product2: Equatable where Base1: Equatable, Base2: Equatable {}
|
||||
extension Product2: Hashable where Base1: Hashable, Base2: Hashable {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// product(_:_:)
|
||||
@@ -210,6 +478,7 @@ extension Product2: Hashable where Base1: Hashable, Base2: Hashable {}
|
||||
/// - s2: The second sequence to iterate over.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func product<Base1: Sequence, Base2: Collection>(
|
||||
_ s1: Base1, _ s2: Base2
|
||||
) -> Product2<Base1, Base2> {
|
||||
|
||||
@@ -94,7 +94,8 @@ internal func nextW<G: RandomNumberGenerator>(
|
||||
internal func nextOffset<G: RandomNumberGenerator>(
|
||||
w: Double, using rng: inout G
|
||||
) -> Int {
|
||||
Int(Double.log(.random(in: 0..<1, using: &rng)) / .log(1 - w))
|
||||
let offset = Double.log(.random(in: 0..<1, using: &rng)) / .log(onePlus: -w)
|
||||
return offset < Double(Int.max) ? Int(offset) : Int.max
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
@@ -201,10 +202,10 @@ extension Sequence {
|
||||
w *= nextW(k: k, using: &rng)
|
||||
|
||||
// Find the offset of the next element to swap into the reservoir.
|
||||
var offset = nextOffset(w: w, using: &rng) + 1
|
||||
var offset = nextOffset(w: w, using: &rng)
|
||||
|
||||
// Skip over `offset - 1` elements to find the selected element.
|
||||
while offset > 1, let _ = iterator.next() {
|
||||
// Skip over `offset` elements to find the selected element.
|
||||
while offset > 0, let _ = iterator.next() {
|
||||
offset -= 1
|
||||
}
|
||||
guard let nextElement = iterator.next() else { break }
|
||||
|
||||
@@ -0,0 +1,643 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
// MARK: - Exclusive Reductions
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
/// Returns a sequence containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].lazy.reductions(0, +)
|
||||
/// print(Array(runningTotal))
|
||||
///
|
||||
/// // prints [0, 1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
return reductions(into: initial) { result, element in
|
||||
result = transform(result, element)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns a sequence containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].lazy.reductions(into: 0, +)
|
||||
/// print(Array(runningTotal))
|
||||
///
|
||||
/// // prints [0, 1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the initial value followed by the reduced
|
||||
/// elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
ExclusiveReductions(base: self, initial: initial, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns an array containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].reductions(0, +)
|
||||
/// print(runningTotal)
|
||||
///
|
||||
/// // prints [0, 1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// When `reductions(_:_:)` is called, the following steps occur:
|
||||
///
|
||||
/// 1. The `initial` result is added to an array of results.
|
||||
/// 2. The `transform` closure is called with the `initial` result and the
|
||||
/// first element of the sequence, appending the result to the array.
|
||||
/// 3. The closure is called again repeatedly with the updated accumulating
|
||||
/// result and each element of the sequence, adding each result to the
|
||||
/// array.
|
||||
/// 4. When the sequence is exhausted, the results array is returned to the
|
||||
/// caller.
|
||||
///
|
||||
/// If the sequence has no elements, `transform` is never executed and
|
||||
/// an array containing only the `initial` result is returned.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the initial value followed by the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@inlinable
|
||||
public func reductions<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result] {
|
||||
return try reductions(into: initial) { result, element in
|
||||
result = try transform(result, element)
|
||||
}
|
||||
}
|
||||
|
||||
/// Returns an array containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].reductions(into: 0, +)
|
||||
/// print(runningTotal)
|
||||
///
|
||||
/// // prints [0, 1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// When `reductions(into:_:_)` is called, the following steps occur:
|
||||
///
|
||||
/// 1. The `initial` result is added to an array of results.
|
||||
/// 2. The `transform` closure is called with the `initial` result and the
|
||||
/// first element of the sequence, appending the result to the array.
|
||||
/// 3. The closure is called again repeatedly with the updated accumulating
|
||||
/// result and each element of the sequence, adding each result to the
|
||||
/// array.
|
||||
/// 4. When the sequence is exhausted, the results array is returned to the
|
||||
/// caller.
|
||||
///
|
||||
/// If the sequence has no elements, `transform` is never executed and
|
||||
/// an array containing only the `initial` result is returned.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - initial: The value to use as the initial value.
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the initial value followed by the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@inlinable
|
||||
public func reductions<Result>(
|
||||
into initial: Result,
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result] {
|
||||
|
||||
var output = [Result]()
|
||||
output.reserveCapacity(underestimatedCount + 1)
|
||||
output.append(initial)
|
||||
|
||||
var initial = initial
|
||||
for element in self {
|
||||
try transform(&initial, element)
|
||||
output.append(initial)
|
||||
}
|
||||
|
||||
return output
|
||||
}
|
||||
}
|
||||
|
||||
/// A sequence of applying a transform to the element of a sequence and the
|
||||
/// previously transformed result.
|
||||
public struct ExclusiveReductions<Result, Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let initial: Result
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (inout Result, Base.Element) -> Void
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
initial: Result,
|
||||
transform: @escaping (inout Result, Base.Element) -> Void
|
||||
) {
|
||||
self.base = base
|
||||
self.initial = initial
|
||||
self.transform = transform
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductions: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal var current: Result?
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (inout Result, Base.Element) -> Void
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
iterator: Base.Iterator,
|
||||
current: Result? = nil,
|
||||
transform: @escaping (inout Result, Base.Element) -> Void
|
||||
) {
|
||||
self.iterator = iterator
|
||||
self.current = current
|
||||
self.transform = transform
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Result? {
|
||||
guard let result = current else { return nil }
|
||||
current = iterator.next().map { element in
|
||||
var result = result
|
||||
transform(&result, element)
|
||||
return result
|
||||
}
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
current: initial,
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductions: Collection where Base: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let representation: ReductionsIndexRepresentation<Base.Index, Result>
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
_ representation: ReductionsIndexRepresentation<Base.Index, Result>
|
||||
) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.representation < rhs.representation
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index { Index(.start) }
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index { Index(.end) }
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Result {
|
||||
switch position.representation {
|
||||
case .start: return initial
|
||||
case .base(_, let result): return result
|
||||
case .end: fatalError("Cannot get element of end index.")
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
func index(base index: Base.Index, previous: Result) -> Index {
|
||||
guard index != base.endIndex else { return endIndex }
|
||||
var previous = previous
|
||||
transform(&previous, base[index])
|
||||
return Index(.base(index: index, result: previous))
|
||||
}
|
||||
switch i.representation {
|
||||
case .start:
|
||||
return index(base: base.startIndex, previous: initial)
|
||||
case let .base(i, result):
|
||||
return index(base: base.index(after: i), previous: result)
|
||||
case .end:
|
||||
fatalError("Cannot get index after end index.")
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case (.start, .start):
|
||||
return 0
|
||||
case let (.start, .base(index, _)):
|
||||
return base.distance(from: base.startIndex, to: index) + 1
|
||||
case (.start, .end):
|
||||
return base.distance(from: base.startIndex, to: base.endIndex) + 1
|
||||
case let (.base(index, _), .start):
|
||||
return base.distance(from: index, to: base.startIndex) - 1
|
||||
case let (.base(start, _), .base(end, _)):
|
||||
return base.distance(from: start, to: end)
|
||||
case let (.base(index, _), .end):
|
||||
return base.distance(from: index, to: base.endIndex)
|
||||
case (.end, .start):
|
||||
return base.distance(from: base.endIndex, to: base.startIndex) - 1
|
||||
case let (.end, .base(index, _)):
|
||||
return base.distance(from: base.endIndex, to: index)
|
||||
case (.end, .end):
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ExclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension ExclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
/// Returns a sequence containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].lazy.reductions(+)
|
||||
/// print(Array(runningTotal))
|
||||
///
|
||||
/// // prints [1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: A sequence of the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(1)
|
||||
@inlinable
|
||||
public func reductions(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductions<Self> {
|
||||
InclusiveReductions(base: self, transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
/// Returns an array containing the accumulated results of combining the
|
||||
/// elements of the sequence using the given closure.
|
||||
///
|
||||
/// This can be seen as applying the reduce function to each element and
|
||||
/// providing the initial value followed by these results as a sequence.
|
||||
///
|
||||
/// ```
|
||||
/// let runningTotal = [1, 2, 3, 4].reductions(+)
|
||||
/// print(runningTotal)
|
||||
///
|
||||
/// // prints [1, 3, 6, 10]
|
||||
/// ```
|
||||
///
|
||||
/// When `reductions(_:)` is called, the following steps occur:
|
||||
///
|
||||
/// 1. The `transform` closure is called with the first and second elements
|
||||
/// of the sequence, appending the result to an array of results.
|
||||
/// 2. The closure is called again repeatedly with the updated accumulating
|
||||
/// result and the next element of the sequence, adding each result to the
|
||||
/// array.
|
||||
/// 3. When the sequence is exhausted, the results array is returned to the
|
||||
/// caller.
|
||||
///
|
||||
/// If the sequence has no elements, `transform` is never executed and
|
||||
/// an empty array is returned.
|
||||
///
|
||||
/// If the sequence has one element, `transform` is never executed and
|
||||
/// an array containing only that first element is returned.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - transform: A closure that combines the previously reduced result and
|
||||
/// the next element in the receiving sequence.
|
||||
/// - Returns: An array of the reduced elements.
|
||||
///
|
||||
/// - Complexity: O(_n_), where _n_ is the length of the sequence.
|
||||
@inlinable
|
||||
public func reductions(
|
||||
_ transform: (Element, Element) throws -> Element
|
||||
) rethrows -> [Element] {
|
||||
var iterator = makeIterator()
|
||||
guard let initial = iterator.next() else { return [] }
|
||||
return try IteratorSequence(iterator).reductions(initial, transform)
|
||||
}
|
||||
}
|
||||
|
||||
public struct InclusiveReductions<Base: Sequence> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element, Base.Element) -> Base.Element
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
base: Base,
|
||||
transform: @escaping (Base.Element, Base.Element) -> Base.Element
|
||||
) {
|
||||
self.base = base
|
||||
self.transform = transform
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductions: Sequence {
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal var element: Base.Element?
|
||||
|
||||
@usableFromInline
|
||||
internal let transform: (Base.Element, Base.Element) -> Base.Element
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
iterator: Base.Iterator,
|
||||
element: Base.Element? = nil,
|
||||
transform: @escaping (Base.Element, Base.Element) -> Base.Element
|
||||
) {
|
||||
self.iterator = iterator
|
||||
self.element = element
|
||||
self.transform = transform
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
guard let previous = element else {
|
||||
element = iterator.next()
|
||||
return element
|
||||
}
|
||||
guard let next = iterator.next() else { return nil }
|
||||
element = transform(previous, next)
|
||||
return element
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(),
|
||||
transform: transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductions: Collection where Base: Collection {
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
|
||||
|
||||
@inlinable
|
||||
internal init(
|
||||
_ representation: ReductionsIndexRepresentation<Base.Index, Base.Element>
|
||||
) {
|
||||
self.representation = representation
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
lhs.representation < rhs.representation
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
guard base.startIndex != base.endIndex else { return endIndex }
|
||||
return Index(.start)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index { Index(.end) }
|
||||
|
||||
@inlinable
|
||||
public subscript(position: Index) -> Base.Element {
|
||||
switch position.representation {
|
||||
case .start: return base[base.startIndex]
|
||||
case .base(_, let result): return result
|
||||
case .end: fatalError("Cannot get element of end index.")
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
func index(after i: Base.Index, previous: Base.Element) -> Index {
|
||||
let index = base.index(after: i)
|
||||
guard index != base.endIndex else { return endIndex }
|
||||
return Index(.base(index: index, result: transform(previous, base[index])))
|
||||
}
|
||||
switch i.representation {
|
||||
case .start:
|
||||
return index(after: base.startIndex, previous: base[base.startIndex])
|
||||
case let .base(i, element):
|
||||
return index(after: i, previous: element)
|
||||
case .end:
|
||||
fatalError("Cannot get index after end index.")
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
switch (start.representation, end.representation) {
|
||||
case (.start, .start):
|
||||
return 0
|
||||
case let (.start, .base(index, _)):
|
||||
return base.distance(from: base.startIndex, to: index)
|
||||
case (.start, .end):
|
||||
return base.distance(from: base.startIndex, to: base.endIndex)
|
||||
case let (.base(index, _), .start):
|
||||
return base.distance(from: index, to: base.startIndex)
|
||||
case let (.base(start, _), .base(end, _)):
|
||||
return base.distance(from: start, to: end)
|
||||
case let (.base(index, _), .end):
|
||||
return base.distance(from: index, to: base.endIndex)
|
||||
case (.end, .start):
|
||||
return base.distance(from: base.endIndex, to: base.startIndex)
|
||||
case let (.end, .base(index, _)):
|
||||
return base.distance(from: base.endIndex, to: index)
|
||||
case (.end, .end):
|
||||
return 0
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension InclusiveReductions: LazySequenceProtocol
|
||||
where Base: LazySequenceProtocol {}
|
||||
|
||||
extension InclusiveReductions: LazyCollectionProtocol
|
||||
where Base: LazyCollectionProtocol {}
|
||||
|
||||
// MARK: - ReductionsIndexRepresentation
|
||||
|
||||
@usableFromInline
|
||||
enum ReductionsIndexRepresentation<BaseIndex: Comparable, Result> {
|
||||
case start
|
||||
case base(index: BaseIndex, result: Result)
|
||||
case end
|
||||
}
|
||||
|
||||
extension ReductionsIndexRepresentation: Equatable {
|
||||
@inlinable
|
||||
static func == (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (.start, .start): return true
|
||||
case (.end, .end): return true
|
||||
case let (.base(lhs, _), .base(rhs, _)): return lhs == rhs
|
||||
default: return false
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension ReductionsIndexRepresentation: Comparable {
|
||||
@inlinable
|
||||
static func < (lhs: Self, rhs: Self) -> Bool {
|
||||
switch (lhs, rhs) {
|
||||
case (_, .start): return false
|
||||
case (.start, _): return true
|
||||
case (.end, _): return false
|
||||
case (_, .end): return true
|
||||
case let (.base(lhs, _), .base(rhs, _)): return lhs < rhs
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// MARK: - Scan
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: @escaping (Result, Element) -> Result
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
reductions(initial, transform)
|
||||
}
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(into:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
into initial: Result,
|
||||
_ transform: @escaping (inout Result, Element) -> Void
|
||||
) -> ExclusiveReductions<Result, Self> {
|
||||
reductions(into: initial, transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
_ initial: Result,
|
||||
_ transform: (Result, Element) throws -> Result
|
||||
) rethrows -> [Result] {
|
||||
try reductions(initial, transform)
|
||||
}
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(into:_:) instead.")
|
||||
@inlinable
|
||||
public func scan<Result>(
|
||||
into initial: Result,
|
||||
_ transform: (inout Result, Element) throws -> Void
|
||||
) rethrows -> [Result] {
|
||||
try reductions(into: initial, transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:) instead.")
|
||||
@inlinable
|
||||
public func scan(
|
||||
_ transform: @escaping (Element, Element) -> Element
|
||||
) -> InclusiveReductions<Self> {
|
||||
reductions(transform)
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
|
||||
@available(*, deprecated, message: "Use reductions(_:) instead.")
|
||||
@inlinable
|
||||
public func scan(
|
||||
_ transform: (Element, Element) throws -> Element
|
||||
) rethrows -> [Element] {
|
||||
try reductions(transform)
|
||||
}
|
||||
}
|
||||
@@ -25,23 +25,23 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// Output:
|
||||
/// [p o n m e f g h i j k l d c b a]
|
||||
/// ^ ^
|
||||
/// f l
|
||||
/// lower upper
|
||||
///
|
||||
/// - Postcondition: For returned indices `(f, l)`:
|
||||
/// `f == limit || l == limit`
|
||||
@usableFromInline
|
||||
/// - Postcondition: For returned indices `(lower, upper)`:
|
||||
/// `lower == limit || upper == limit`
|
||||
@inlinable
|
||||
@discardableResult
|
||||
internal mutating func _reverse(
|
||||
subrange: Range<Index>, until limit: Index
|
||||
) -> (Index, Index) {
|
||||
var f = subrange.lowerBound
|
||||
var l = subrange.upperBound
|
||||
while f != limit && l != limit {
|
||||
formIndex(before: &l)
|
||||
swapAt(f, l)
|
||||
formIndex(after: &f)
|
||||
var lower = subrange.lowerBound
|
||||
var upper = subrange.upperBound
|
||||
while lower != limit && upper != limit {
|
||||
formIndex(before: &upper)
|
||||
swapAt(lower, upper)
|
||||
formIndex(after: &lower)
|
||||
}
|
||||
return (f, l)
|
||||
return (lower, upper)
|
||||
}
|
||||
|
||||
/// Reverses the elements within the given subrange.
|
||||
@@ -59,13 +59,12 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
@inlinable
|
||||
public mutating func reverse(subrange: Range<Index>) {
|
||||
if subrange.isEmpty { return }
|
||||
var lo = subrange.lowerBound
|
||||
var hi = subrange.upperBound
|
||||
|
||||
while lo < hi {
|
||||
formIndex(before: &hi)
|
||||
swapAt(lo, hi)
|
||||
formIndex(after: &lo)
|
||||
var lower = subrange.lowerBound
|
||||
var upper = subrange.upperBound
|
||||
while lower < upper {
|
||||
formIndex(before: &upper)
|
||||
swapAt(lower, upper)
|
||||
formIndex(after: &lower)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -95,7 +94,7 @@ extension MutableCollection {
|
||||
/// - distance(from: lhs.lowerBound, to: p) == distance(from:
|
||||
/// rhs.lowerBound, to: q)
|
||||
/// - p == lhs.upperBound || q == rhs.upperBound
|
||||
@usableFromInline
|
||||
@inlinable
|
||||
internal mutating func _swapNonemptySubrangePrefixes(
|
||||
_ lhs: Range<Index>, _ rhs: Range<Index>
|
||||
) -> (Index, Index) {
|
||||
@@ -213,7 +212,7 @@ extension MutableCollection {
|
||||
/// rotating.
|
||||
/// - Returns: The new index of the element that was first pre-rotation.
|
||||
///
|
||||
/// - Complexity: O(*n*)
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
@discardableResult
|
||||
public mutating func rotate(toStartAt newStart: Index) -> Index {
|
||||
@@ -273,7 +272,7 @@ extension MutableCollection where Self: BidirectionalCollection {
|
||||
/// rotating.
|
||||
/// - Returns: The new index of the element that was first pre-rotation.
|
||||
///
|
||||
/// - Complexity: O(*n*)
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
@discardableResult
|
||||
public mutating func rotate(toStartAt newStart: Index) -> Index {
|
||||
|
||||
@@ -0,0 +1,272 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// striding(by:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence {
|
||||
/// Returns a sequence stepping through the elements every `step` starting
|
||||
/// at the first value. Any remainders of the stride will be trimmed.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
///
|
||||
/// - Complexity: O(1). Access to successive values is O(k) where
|
||||
/// _k_ is the striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a sequence for stepping through the
|
||||
/// elements by the specified amount.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StrideSequence<Self> {
|
||||
StrideSequence(base: self, stride: step)
|
||||
}
|
||||
}
|
||||
|
||||
extension Collection {
|
||||
/// Returns a sequence stepping through the elements every `step` starting
|
||||
/// at the first value. Any remainders of the stride will be trimmed.
|
||||
///
|
||||
/// (0...10).striding(by: 2) // == [0, 2, 4, 6, 8, 10]
|
||||
/// (0...10).striding(by: 3) // == [0, 3, 6, 9]
|
||||
///
|
||||
/// - Complexity: O(1). Access to successive values is O(1) if the
|
||||
/// collection conforms to `RandomAccessCollection`; otherwise,
|
||||
/// O(_k_), where _k_ is the striding `step`.
|
||||
///
|
||||
/// - Parameter step: The amount to step with each iteration.
|
||||
/// - Returns: Returns a collection for stepping through the
|
||||
/// elements by the specified amount.
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> StrideCollection<Self> {
|
||||
StrideCollection(base: self, stride: step)
|
||||
}
|
||||
}
|
||||
|
||||
/// A wrapper that strides over a base sequence.
|
||||
public struct StrideSequence<Base: Sequence>: Sequence {
|
||||
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "striding must be greater than zero")
|
||||
self.base = base
|
||||
self.stride = stride
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideSequence {
|
||||
|
||||
/// An iterator over a `Stride` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var iterator: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var striding: Bool = false
|
||||
|
||||
@inlinable
|
||||
internal init(iterator: Base.Iterator, stride: Int) {
|
||||
self.iterator = iterator
|
||||
self.stride = stride
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
guard striding else {
|
||||
striding = true
|
||||
return iterator.next()
|
||||
}
|
||||
for _ in 0..<stride - 1 {
|
||||
guard iterator.next() != nil else { break }
|
||||
}
|
||||
return iterator.next()
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(iterator: base.makeIterator(), stride: stride)
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideSequence {
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> Self {
|
||||
Self(base: base, stride: stride * step)
|
||||
}
|
||||
}
|
||||
|
||||
/// A wrapper that strides over a base collection.
|
||||
public struct StrideCollection<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let stride: Int
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, stride: Int) {
|
||||
precondition(stride > 0, "striding must be greater than zero")
|
||||
self.base = base
|
||||
self.stride = stride
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideCollection {
|
||||
@inlinable
|
||||
public func striding(by step: Int) -> Self {
|
||||
Self(base: base, stride: stride * step)
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideCollection: Collection {
|
||||
|
||||
/// A position in a `Stride` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal let base: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
internal init(_ base: Base.Index) {
|
||||
self.base = base
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.base < rhs.base
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
Index(base.startIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(i: Index) -> Base.Element {
|
||||
base[i.base]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after i: Index) -> Index {
|
||||
precondition(i.base < base.endIndex, "Advancing past end index")
|
||||
return index(i, offsetBy: 1)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy n: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard n != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
return n > 0
|
||||
? offsetForward(i, offsetBy: n, limitedBy: limit)
|
||||
: offsetBackward(i, offsetBy: -n, limitedBy: limit)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index,
|
||||
offsetBy n: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
if limit < i {
|
||||
if let idx = base.index(
|
||||
i.base,
|
||||
offsetBy: n * stride,
|
||||
limitedBy: base.endIndex
|
||||
) {
|
||||
return Index(idx)
|
||||
} else {
|
||||
assert(distance(from: i, to: endIndex) == n, "Advancing past end index")
|
||||
return endIndex
|
||||
}
|
||||
} else if let idx = base.index(
|
||||
i.base,
|
||||
offsetBy: n * stride,
|
||||
limitedBy: limit.base
|
||||
) {
|
||||
return Index(idx)
|
||||
} else {
|
||||
return distance(from: i, to: limit) == n
|
||||
? endIndex
|
||||
: nil
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index,
|
||||
offsetBy n: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
let distance = i == endIndex
|
||||
? -((base.count - 1) % stride + 1) + (n - 1) * -stride
|
||||
: n * -stride
|
||||
return base.index(
|
||||
i.base,
|
||||
offsetBy: distance,
|
||||
limitedBy: limit.base
|
||||
).map(Index.init)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var count: Int {
|
||||
base.isEmpty ? 0 : (base.count - 1) / stride + 1
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
let distance = base.distance(from: start.base, to: end.base)
|
||||
return distance / stride + (distance % stride).signum()
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
precondition(distance <= 0 || i.base < base.endIndex, "Advancing past end index")
|
||||
precondition(distance >= 0 || i.base > base.startIndex, "Incrementing past start index")
|
||||
let limit = distance > 0 ? endIndex : startIndex
|
||||
let idx = index(i, offsetBy: distance, limitedBy: limit)
|
||||
precondition(idx != nil, "The distance \(distance) is not valid for this collection")
|
||||
return idx!
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideCollection: BidirectionalCollection
|
||||
where Base: RandomAccessCollection {
|
||||
|
||||
@inlinable
|
||||
public func index(before i: Index) -> Index {
|
||||
precondition(i.base > base.startIndex, "Incrementing past start index")
|
||||
return index(i, offsetBy: -1)
|
||||
}
|
||||
}
|
||||
|
||||
extension StrideCollection: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension StrideCollection.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -0,0 +1,88 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// suffix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns a subsequence containing the elements from the end until
|
||||
/// `predicate` returns `false` and skipping the remaining elements.
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the
|
||||
/// sequence as its argument and returns `true` if the element should
|
||||
/// be included or `false` if it should be excluded. Once the predicate
|
||||
/// returns `false` it will not be called again.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
public func suffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
try self[startOfSuffix(while: predicate)...]
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// endOfPrefix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns the exclusive upper bound of the prefix of elements that satisfy
|
||||
/// the predicate.
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the collection
|
||||
/// as its argument and returns `true` if the element is part of the prefix
|
||||
/// or `false` if it is not. Once the predicate returns `false` it will not
|
||||
/// be called again.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
internal func endOfPrefix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
var index = startIndex
|
||||
while try index != endIndex && predicate(self[index]) {
|
||||
formIndex(after: &index)
|
||||
}
|
||||
return index
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// startOfSuffix(while:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns the inclusive lower bound of the suffix of elements that satisfy
|
||||
/// the predicate.
|
||||
///
|
||||
/// - Parameter predicate: A closure that takes an element of the collection
|
||||
/// as its argument and returns `true` if the element is part of the suffix
|
||||
/// or `false` if it is not. Once the predicate returns `false` it will not
|
||||
/// be called again.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the collection.
|
||||
@inlinable
|
||||
internal func startOfSuffix(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> Index {
|
||||
var index = endIndex
|
||||
while index != startIndex {
|
||||
let after = index
|
||||
formIndex(before: &index)
|
||||
if try !predicate(self[index]) {
|
||||
return after
|
||||
}
|
||||
}
|
||||
return index
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,36 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension BidirectionalCollection {
|
||||
/// Returns a `SubSequence` formed by discarding all elements at the start and
|
||||
/// end of the collection which satisfy the given predicate.
|
||||
///
|
||||
/// This example uses `trimming(while:)` to get a substring without the white
|
||||
/// space at the beginning and end of the string:
|
||||
///
|
||||
/// let myString = " hello, world "
|
||||
/// print(myString.trimming(while: \.isWhitespace)) // "hello, world"
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - predicate: A closure which determines if the element should be
|
||||
/// omitted from the resulting slice.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of this collection.
|
||||
///
|
||||
@inlinable
|
||||
public func trimming(
|
||||
while predicate: (Element) throws -> Bool
|
||||
) rethrows -> SubSequence {
|
||||
let start = try endOfPrefix(while: predicate)
|
||||
let end = try self[start...].startOfSuffix(while: predicate)
|
||||
return self[start..<end]
|
||||
}
|
||||
}
|
||||
@@ -9,23 +9,107 @@
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
/// A sequence wrapper that leaves out duplicate elements of a base sequence.
|
||||
public struct Uniqued<Base: Sequence, Subject: Hashable> {
|
||||
/// The base collection.
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
/// The projection function.
|
||||
@usableFromInline
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
@usableFromInline
|
||||
internal init(base: Base, projection: @escaping (Base.Element) -> Subject) {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
}
|
||||
}
|
||||
|
||||
extension Uniqued: Sequence {
|
||||
/// The iterator for a `Uniqued` sequence.
|
||||
public struct Iterator: IteratorProtocol {
|
||||
@usableFromInline
|
||||
internal var base: Base.Iterator
|
||||
|
||||
@usableFromInline
|
||||
internal let projection: (Base.Element) -> Subject
|
||||
|
||||
@usableFromInline
|
||||
internal var seen: Set<Subject> = []
|
||||
|
||||
@usableFromInline
|
||||
internal init(
|
||||
base: Base.Iterator,
|
||||
projection: @escaping (Base.Element) -> Subject
|
||||
) {
|
||||
self.base = base
|
||||
self.projection = projection
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public mutating func next() -> Base.Element? {
|
||||
while let element = base.next() {
|
||||
if seen.insert(projection(element)).inserted {
|
||||
return element
|
||||
}
|
||||
}
|
||||
return nil
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func makeIterator() -> Iterator {
|
||||
Iterator(base: base.makeIterator(), projection: projection)
|
||||
}
|
||||
}
|
||||
|
||||
extension Uniqued: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// uniqued()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Sequence where Element: Hashable {
|
||||
/// Returns an array with only the unique elements of this sequence, in the
|
||||
/// order of the first occurence of each unique element.
|
||||
/// Returns a sequence with only the unique elements of this sequence, in the
|
||||
/// order of the first occurrence of each unique element.
|
||||
///
|
||||
/// let animals = ["dog", "pig", "cat", "ox", "dog", "cat"]
|
||||
/// let uniqued = animals.uniqued()
|
||||
/// print(Array(uniqued))
|
||||
/// // Prints '["dog", "pig", "cat", "ox"]'
|
||||
///
|
||||
/// - Returns: A sequence with only the unique elements of this sequence.
|
||||
/// .
|
||||
/// - Complexity: O(1).
|
||||
@inlinable
|
||||
public func uniqued() -> [Element] {
|
||||
uniqued(on: { $0 })
|
||||
public func uniqued() -> Uniqued<Self, Element> {
|
||||
Uniqued(base: self, projection: { $0 })
|
||||
}
|
||||
}
|
||||
|
||||
extension Sequence {
|
||||
/// Returns an array with the unique elements of this sequence (as determined
|
||||
/// by the given projection), in the order of the first occurence of each
|
||||
/// by the given projection), in the order of the first occurrence of each
|
||||
/// unique element.
|
||||
///
|
||||
/// This example finds the elements of the `animals` array with unique
|
||||
/// first characters:
|
||||
///
|
||||
/// let animals = ["dog", "pig", "cat", "ox", "cow", "owl"]
|
||||
/// let uniqued = animals.uniqued(on: { $0.first })
|
||||
/// print(uniqued)
|
||||
/// // Prints '["dog", "pig", "cat", "ox"]'
|
||||
///
|
||||
/// - Parameter projection: A closure that transforms an element into the
|
||||
/// value to use for uniqueness. If `projection` returns the same value
|
||||
/// for two different elements, the second element will be excluded
|
||||
/// from the resulting array.
|
||||
///
|
||||
/// - Returns: An array with only the unique elements of this sequence, as
|
||||
/// determined by the result of `projection` for each element.
|
||||
///
|
||||
/// - Complexity: O(*n*), where *n* is the length of the sequence.
|
||||
@inlinable
|
||||
public func uniqued<Subject: Hashable>(
|
||||
on projection: (Element) throws -> Subject
|
||||
@@ -40,3 +124,21 @@ extension Sequence {
|
||||
return result
|
||||
}
|
||||
}
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// lazy.uniqued()
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension LazySequenceProtocol {
|
||||
/// Returns a lazy sequence with the unique elements of this sequence (as
|
||||
/// determined by the given projection), in the order of the first occurrence
|
||||
/// of each unique element.
|
||||
///
|
||||
/// - Complexity: O(1).
|
||||
@inlinable
|
||||
public func uniqued<Subject: Hashable>(
|
||||
on projection: @escaping (Element) -> Subject
|
||||
) -> Uniqued<Self, Subject> {
|
||||
Uniqued(base: self, projection: projection)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,353 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// windows(ofCount:)
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
extension Collection {
|
||||
/// Returns a collection of all the overlapping slices of a given size.
|
||||
///
|
||||
/// Use this method to iterate over overlapping subsequences of this
|
||||
/// collection. This example prints every five character substring of `str`:
|
||||
///
|
||||
/// let str = "Hello, world!"
|
||||
/// for substring in str.windows(ofCount: 5) {
|
||||
/// print(substring)
|
||||
/// }
|
||||
/// // "Hello"
|
||||
/// // "ello,"
|
||||
/// // "llo, "
|
||||
/// // "lo, W"
|
||||
/// // ...
|
||||
/// // "orld!"
|
||||
///
|
||||
/// - Parameter count: The number of elements in each window subsequence.
|
||||
/// - Returns: A collection of subsequences of this collection, each with
|
||||
/// length `count`. If this collection is shorter than `count`, the
|
||||
/// resulting collection is empty.
|
||||
///
|
||||
/// - Complexity: O(1) if the collection conforms to
|
||||
/// `RandomAccessCollection`, otherwise O(*k*) where `k` is `count`.
|
||||
/// Access to successive windows is O(1).
|
||||
@inlinable
|
||||
public func windows(ofCount count: Int) -> Windows<Self> {
|
||||
Windows(base: self, size: count)
|
||||
}
|
||||
}
|
||||
|
||||
/// A collection wrapper that presents a sliding window over the elements of
|
||||
/// a collection.
|
||||
public struct Windows<Base: Collection> {
|
||||
@usableFromInline
|
||||
internal let base: Base
|
||||
|
||||
@usableFromInline
|
||||
internal let size: Int
|
||||
|
||||
@usableFromInline
|
||||
internal var firstUpperBound: Base.Index?
|
||||
|
||||
@inlinable
|
||||
internal init(base: Base, size: Int) {
|
||||
precondition(size > 0, "Windows size must be greater than zero")
|
||||
self.base = base
|
||||
self.size = size
|
||||
self.firstUpperBound =
|
||||
base.index(base.startIndex, offsetBy: size, limitedBy: base.endIndex)
|
||||
}
|
||||
}
|
||||
|
||||
extension Windows: Collection {
|
||||
/// A position in a `Windows` collection.
|
||||
public struct Index: Comparable {
|
||||
@usableFromInline
|
||||
internal var lowerBound: Base.Index
|
||||
|
||||
@usableFromInline
|
||||
internal var upperBound: Base.Index
|
||||
|
||||
@inlinable
|
||||
internal init(lowerBound: Base.Index, upperBound: Base.Index) {
|
||||
self.lowerBound = lowerBound
|
||||
self.upperBound = upperBound
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func == (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.lowerBound == rhs.lowerBound
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public static func < (lhs: Index, rhs: Index) -> Bool {
|
||||
lhs.lowerBound < rhs.lowerBound
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var startIndex: Index {
|
||||
if let upperBound = firstUpperBound {
|
||||
return Index(lowerBound: base.startIndex, upperBound: upperBound)
|
||||
} else {
|
||||
return endIndex
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public var endIndex: Index {
|
||||
Index(lowerBound: base.endIndex, upperBound: base.endIndex)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public subscript(index: Index) -> Base.SubSequence {
|
||||
precondition(
|
||||
index.lowerBound != index.upperBound,
|
||||
"Windows index is out of range")
|
||||
return base[index.lowerBound..<index.upperBound]
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(after index: Index) -> Index {
|
||||
precondition(index < endIndex, "Advancing past end index")
|
||||
guard index.upperBound < base.endIndex else { return endIndex }
|
||||
return Index(
|
||||
lowerBound: base.index(after: index.lowerBound),
|
||||
upperBound: base.index(after: index.upperBound)
|
||||
)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(_ i: Index, offsetBy distance: Int) -> Index {
|
||||
guard distance != 0 else { return i }
|
||||
|
||||
return distance > 0
|
||||
? offsetForward(i, by: distance)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func index(
|
||||
_ i: Index,
|
||||
offsetBy distance: Int,
|
||||
limitedBy limit: Index
|
||||
) -> Index? {
|
||||
guard distance != 0 else { return i }
|
||||
guard limit != i else { return nil }
|
||||
|
||||
if distance > 0 {
|
||||
return limit > i
|
||||
? offsetForward(i, by: distance, limitedBy: limit)
|
||||
: offsetForward(i, by: distance)
|
||||
} else {
|
||||
return limit < i
|
||||
? offsetBackward(i, by: -distance, limitedBy: limit)
|
||||
: offsetBackward(i, by: -distance)
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetForward(i, by: distance, limitedBy: endIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(_ i: Index, by distance: Int) -> Index {
|
||||
guard let index = offsetBackward(i, by: distance, limitedBy: startIndex)
|
||||
else { fatalError("Index is out of bounds") }
|
||||
return index
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetForward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit > i)
|
||||
|
||||
// `endIndex` and the index before it both have `base.endIndex` as their
|
||||
// upper bound, so we first advance to the base index _before_ the upper
|
||||
// bound of the output, in order to avoid advancing past the end of `base`
|
||||
// when advancing to `endIndex`.
|
||||
//
|
||||
// Advancing by 4:
|
||||
//
|
||||
// input: [x|x x x x x|x x x x] [x x|x x x x x|x x x]
|
||||
// |> > >|>| or |> > >|
|
||||
// output: [x x x x x|x x x x x] [x x x x x x x x x x] (`endIndex`)
|
||||
|
||||
if distance >= size {
|
||||
// Avoid traversing `self[i.lowerBound..<i.upperBound]` when the lower
|
||||
// bound of the output is greater than or equal to the upper bound of the
|
||||
// input.
|
||||
|
||||
// input: [x|x x x x|x x x x x x x]
|
||||
// |> >|> > >|>|
|
||||
// output: [x x x x x x x|x x x x|x]
|
||||
|
||||
guard limit.lowerBound >= i.upperBound,
|
||||
let lowerBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - size,
|
||||
limitedBy: limit.lowerBound),
|
||||
let indexBeforeUpperBound = base.index(
|
||||
lowerBound,
|
||||
offsetBy: size - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
|
||||
// `endIndex`.
|
||||
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
|
||||
|
||||
return Index(
|
||||
lowerBound: lowerBound,
|
||||
upperBound: base.index(after: indexBeforeUpperBound))
|
||||
} else {
|
||||
// input: [x|x x x x x x|x x x x x]
|
||||
// |> > > >| |> > >|>|
|
||||
// output: [x x x x x|x x x x x x|x]
|
||||
|
||||
guard let indexBeforeUpperBound = base.index(
|
||||
i.upperBound,
|
||||
offsetBy: distance - 1,
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
// If `indexBeforeUpperBound` equals the limit, the upper bound itself
|
||||
// exceeds it.
|
||||
guard indexBeforeUpperBound != limit.upperBound || limit == endIndex
|
||||
else { return nil }
|
||||
|
||||
// If `indexBeforeUpperBound` equals `base.endIndex`, we're advancing to
|
||||
// `endIndex`.
|
||||
guard indexBeforeUpperBound != base.endIndex else { return endIndex }
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(i.lowerBound, offsetBy: distance),
|
||||
upperBound: base.index(after: indexBeforeUpperBound))
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
internal func offsetBackward(
|
||||
_ i: Index, by distance: Int, limitedBy limit: Index
|
||||
) -> Index? {
|
||||
assert(distance > 0)
|
||||
assert(limit < i)
|
||||
|
||||
if i == endIndex {
|
||||
// Advance `base.endIndex` by `distance - 1`, because the index before
|
||||
// `endIndex` also has `base.endIndex` as its upper bound.
|
||||
//
|
||||
// Advancing by 4:
|
||||
//
|
||||
// input: [x x x x x x x x x x] (`endIndex`)
|
||||
// |< < < < <|< < <|
|
||||
// output: [x x|x x x x x|x x x]
|
||||
|
||||
guard let upperBound = base.index(
|
||||
base.endIndex,
|
||||
offsetBy: -(distance - 1),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
} else if distance >= size {
|
||||
// Avoid traversing `self[i.lowerBound..<i.upperBound]` when the upper
|
||||
// bound of the output is less than or equal to the lower bound of the
|
||||
// input.
|
||||
//
|
||||
// input: [x x x x x x x|x x x x|x]
|
||||
// |< < < <|< <|
|
||||
// output: [x|x x x x|x x x x x x x]
|
||||
|
||||
guard limit.upperBound <= i.lowerBound,
|
||||
let upperBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -(distance - size),
|
||||
limitedBy: limit.upperBound)
|
||||
else { return nil }
|
||||
|
||||
return Index(
|
||||
lowerBound: base.index(upperBound, offsetBy: -size),
|
||||
upperBound: upperBound)
|
||||
} else {
|
||||
// input: [x x x x x|x x x x x x|x]
|
||||
// |< < < <| |< < < <|
|
||||
// output: [x|x x x x x x|x x x x x]
|
||||
|
||||
guard let lowerBound = base.index(
|
||||
i.lowerBound,
|
||||
offsetBy: -distance,
|
||||
limitedBy: limit.lowerBound)
|
||||
else { return nil }
|
||||
|
||||
return Index(
|
||||
lowerBound: lowerBound,
|
||||
upperBound: base.index(i.lowerBound, offsetBy: -distance))
|
||||
}
|
||||
}
|
||||
|
||||
@inlinable
|
||||
public func distance(from start: Index, to end: Index) -> Int {
|
||||
guard start <= end else { return -distance(from: end, to: start) }
|
||||
guard start != end else { return 0 }
|
||||
guard end < endIndex else {
|
||||
// We add 1 here because the index before `endIndex` also has
|
||||
// `base.endIndex` as its upper bound.
|
||||
return base[start.upperBound...].count + 1
|
||||
}
|
||||
|
||||
if start.upperBound <= end.lowerBound {
|
||||
// The distance between `start.lowerBound` and `start.upperBound` is
|
||||
// already known.
|
||||
//
|
||||
// start: [x|x x x x|x x x x x x x]
|
||||
// |- - - -|> >|
|
||||
// end: [x x x x x x x|x x x x|x]
|
||||
|
||||
return size + base[start.upperBound..<end.lowerBound].count
|
||||
} else {
|
||||
// start: [x|x x x x x x|x x x x x]
|
||||
// |> > > >|
|
||||
// end: [x x x x x|x x x x x x|x]
|
||||
|
||||
return base[start.lowerBound..<end.lowerBound].count
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Windows: BidirectionalCollection where Base: BidirectionalCollection {
|
||||
@inlinable
|
||||
public func index(before index: Index) -> Index {
|
||||
precondition(index > startIndex, "Incrementing past start index")
|
||||
if index == endIndex {
|
||||
return Index(
|
||||
lowerBound: base.index(index.lowerBound, offsetBy: -size),
|
||||
upperBound: index.upperBound
|
||||
)
|
||||
} else {
|
||||
return Index(
|
||||
lowerBound: base.index(before: index.lowerBound),
|
||||
upperBound: base.index(before: index.upperBound)
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension Windows: LazySequenceProtocol where Base: LazySequenceProtocol {}
|
||||
extension Windows: LazyCollectionProtocol where Base: LazyCollectionProtocol {}
|
||||
extension Windows: RandomAccessCollection where Base: RandomAccessCollection {}
|
||||
extension Windows.Index: Hashable where Base.Index: Hashable {}
|
||||
@@ -13,14 +13,6 @@ import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
final class ChainTests: XCTestCase {
|
||||
// intentionally does not depend on `Chain.index(_:offsetBy:)` in order to
|
||||
// avoid making assumptions about the code being tested
|
||||
func index<A, B>(atOffset offset: Int, in chain: Chain2<A, B>) -> Chain2<A, B>.Index {
|
||||
offset < chain.base1.count
|
||||
? .init(first: chain.base1.index(chain.base1.startIndex, offsetBy: offset))
|
||||
: .init(second: chain.base2.index(chain.base2.startIndex, offsetBy: offset - chain.base1.count))
|
||||
}
|
||||
|
||||
func testChainSequences() {
|
||||
let run = chain((1...).prefix(10), 20...)
|
||||
XCTAssertEqualSequences(run.prefix(20), Array(1...10) + (20..<30))
|
||||
@@ -43,62 +35,17 @@ final class ChainTests: XCTestCase {
|
||||
XCTAssertEqualSequences(chain(s1.reversed(), s2), "JIHGFEDCBAklmnopqrstuv")
|
||||
}
|
||||
|
||||
func testChainIndexOffsetBy() {
|
||||
let s1 = "abcde"
|
||||
let s2 = "VWXYZ"
|
||||
let c = chain(s1, s2)
|
||||
|
||||
for (startOffset, endOffset) in product(0...c.count, 0...c.count) {
|
||||
let start = index(atOffset: startOffset, in: c)
|
||||
let end = index(atOffset: endOffset, in: c)
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(c.index(start, offsetBy: distance), end)
|
||||
}
|
||||
}
|
||||
|
||||
func testChainIndexOffsetByLimitedBy() {
|
||||
let s1 = "abcd"
|
||||
let s2 = "XYZ"
|
||||
let c = chain(s1, s2)
|
||||
|
||||
for (startOffset, limitOffset) in product(0...c.count, 0...c.count) {
|
||||
let start = index(atOffset: startOffset, in: c)
|
||||
let limit = index(atOffset: limitOffset, in: c)
|
||||
|
||||
// verifies that the target index corresponding to each offset in `range`
|
||||
// can or cannot be reached from `start` using
|
||||
// `c.index(start, offsetBy: _, limitedBy: limit)`, depending on the
|
||||
// value of `beyondLimit`
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, beyondLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
|
||||
XCTAssertEqual(
|
||||
c.index(start, offsetBy: distance, limitedBy: limit),
|
||||
beyondLimit ? nil : index(atOffset: targetOffset, in: c))
|
||||
}
|
||||
}
|
||||
|
||||
// forward
|
||||
if limit >= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(startOffset...limitOffset, beyondLimit: false)
|
||||
checkTargetRange((limitOffset + 1)...(c.count + 1), beyondLimit: true)
|
||||
} else {
|
||||
// the limit has no effect
|
||||
checkTargetRange(startOffset...c.count, beyondLimit: false)
|
||||
}
|
||||
|
||||
// backward
|
||||
if limit <= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(limitOffset...startOffset, beyondLimit: false)
|
||||
checkTargetRange(-1...(limitOffset - 1), beyondLimit: true)
|
||||
} else {
|
||||
// the limit has no effect
|
||||
checkTargetRange(0...startOffset, beyondLimit: false)
|
||||
}
|
||||
}
|
||||
func testChainIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
chain("abcd", "XYZ"),
|
||||
chain("abcd", ""),
|
||||
chain("", "XYZ"),
|
||||
chain("", ""),
|
||||
indices: { chain in
|
||||
chain.base1.indices.map { .init(first: $0) }
|
||||
+ chain.base2.indices.map { .init(second: $0) }
|
||||
+ [.init(second: chain.base2.endIndex)]
|
||||
})
|
||||
}
|
||||
|
||||
func testChainIndexOffsetAcrossBoundary() {
|
||||
@@ -121,19 +68,4 @@ final class ChainTests: XCTestCase {
|
||||
XCTAssertNil(j)
|
||||
}
|
||||
}
|
||||
|
||||
func testChainDistanceFromTo() {
|
||||
let s1 = "abcde"
|
||||
let s2 = "VWXYZ"
|
||||
let c = chain(s1, s2)
|
||||
|
||||
XCTAssertEqual(c.count, s1.count + s2.count)
|
||||
|
||||
for (startOffset, endOffset) in product(0...c.count, 0...c.count) {
|
||||
let start = index(atOffset: startOffset, in: c)
|
||||
let end = index(atOffset: endOffset, in: c)
|
||||
let distance = endOffset - startOffset
|
||||
XCTAssertEqual(c.distance(from: start, to: end), distance)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -73,7 +73,76 @@ final class ChunkedTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testChunkedLazy() {
|
||||
XCTAssertLazy(fruits.lazy.chunked(by: { $0.first == $1.first }))
|
||||
XCTAssertLazy(fruits.lazy.chunked(on: { $0.first }))
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(by: { $0.first == $1.first }))
|
||||
XCTAssertLazySequence(fruits.lazy.chunked(on: { $0.first }))
|
||||
}
|
||||
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `chunks(ofCount:)`
|
||||
//===----------------------------------------------------------------------===//
|
||||
func testChunksOfCount() {
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 1), [])
|
||||
XCTAssertEqualSequences([Int]().chunks(ofCount: 5), [])
|
||||
|
||||
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 1),
|
||||
[[1], [2], [3], [4], [5], [6], [7], [8], [9], [10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 5),
|
||||
[[1, 2, 3, 4, 5], [6, 7, 8, 9, 10]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 11),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
||||
XCTAssertEqualSequences(collection2.chunks(ofCount: 3),
|
||||
[[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11]])
|
||||
}
|
||||
|
||||
func testChunksOfCountBidirectional() {
|
||||
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 1).reversed(),
|
||||
[[10], [9], [8], [7], [6], [5], [4], [3], [2], [1]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 3).reversed(),
|
||||
[[10], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 5).reversed(),
|
||||
[[6, 7, 8, 9, 10], [1, 2, 3, 4, 5]])
|
||||
XCTAssertEqualSequences(collection1.chunks(ofCount: 11).reversed(),
|
||||
[[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]])
|
||||
|
||||
let collection2 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
|
||||
XCTAssertEqualSequences(collection2.chunks(ofCount: 3).reversed(),
|
||||
[[10, 11], [7, 8, 9], [4, 5, 6], [1, 2, 3]])
|
||||
}
|
||||
|
||||
func testChunksOfCountCount() {
|
||||
XCTAssertEqual([Int]().chunks(ofCount: 1).count, 0)
|
||||
XCTAssertEqual([Int]().chunks(ofCount: 5).count, 0)
|
||||
|
||||
let collection1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 1).count, 10)
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 3).count, 4)
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 5).count, 2)
|
||||
XCTAssertEqual(collection1.chunks(ofCount: 11).count, 1)
|
||||
|
||||
let collection2 = (1...50).map { $0 }
|
||||
XCTAssertEqual(collection2.chunks(ofCount: 9).count, 6)
|
||||
}
|
||||
|
||||
func testEmptyChunksOfCountTraversal() {
|
||||
let emptyChunks = [Int]().chunks(ofCount: 1)
|
||||
|
||||
validateIndexTraversals(emptyChunks)
|
||||
}
|
||||
|
||||
func testChunksOfCountTraversal() {
|
||||
for i in 1..<10 {
|
||||
let collection = (1...50).map { $0 }
|
||||
let chunks = collection.chunks(ofCount: i)
|
||||
|
||||
validateIndexTraversals(chunks)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -2,7 +2,7 @@
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Copyright (c) 2020-2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
@@ -13,33 +13,114 @@ import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class CombinationsTests: XCTestCase {
|
||||
func testCount() {
|
||||
let c = "ABCD"
|
||||
|
||||
let c0 = c.combinations(ofCount: 0).count
|
||||
XCTAssertEqual(c0, 1)
|
||||
|
||||
let c1 = c.combinations(ofCount: 1).count
|
||||
XCTAssertEqual(c1, 4)
|
||||
|
||||
let c2 = c.combinations(ofCount: 2).count
|
||||
XCTAssertEqual(c2, 6)
|
||||
|
||||
let c3 = c.combinations(ofCount: 3).count
|
||||
XCTAssertEqual(c3, 4)
|
||||
|
||||
let c4 = c.combinations(ofCount: 4).count
|
||||
XCTAssertEqual(c4, 1)
|
||||
|
||||
let c5 = c.combinations(ofCount: 0...0).count
|
||||
XCTAssertEqual(c5, 1)
|
||||
|
||||
let c6 = c.combinations(ofCount: 1...1).count
|
||||
XCTAssertEqual(c6, 4)
|
||||
|
||||
let c7 = c.combinations(ofCount: 1...2).count
|
||||
XCTAssertEqual(c7, 10)
|
||||
|
||||
let c8 = c.combinations(ofCount: 1...3).count
|
||||
XCTAssertEqual(c8, 14)
|
||||
|
||||
let c9 = c.combinations(ofCount: 2...4).count
|
||||
XCTAssertEqual(c9, 11)
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
let c10 = c.combinations(ofCount: 3...10).count
|
||||
XCTAssertEqual(c10, 5)
|
||||
|
||||
// `k` greater than element count results in same number of combinations
|
||||
let c11 = c.combinations(ofCount: 4...10).count
|
||||
XCTAssertEqual(c11, 1)
|
||||
|
||||
// `k` entirely greater than element count results in no combinations
|
||||
let c12 = c.combinations(ofCount: 5...10).count
|
||||
XCTAssertEqual(c12, 0)
|
||||
|
||||
let c13 = c.combinations(ofCount: 0...).count
|
||||
XCTAssertEqual(c13, 16)
|
||||
|
||||
let c14 = c.combinations(ofCount: ...3).count
|
||||
XCTAssertEqual(c14, 15)
|
||||
|
||||
let c15 = c.combinations(ofCount: 0...).count
|
||||
XCTAssertEqual(c15, 16)
|
||||
}
|
||||
|
||||
func testCombinations() {
|
||||
let c = "ABCD"
|
||||
|
||||
|
||||
let c1 = c.combinations(ofCount: 1)
|
||||
XCTAssertEqual(["A", "B", "C", "D"], c1.map { String($0) })
|
||||
|
||||
|
||||
let c2 = c.combinations(ofCount: 2)
|
||||
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD"], c2.map { String($0) })
|
||||
|
||||
|
||||
let c3 = c.combinations(ofCount: 3)
|
||||
XCTAssertEqual(["ABC", "ABD", "ACD", "BCD"], c3.map { String($0) })
|
||||
|
||||
|
||||
let c4 = c.combinations(ofCount: 4)
|
||||
XCTAssertEqual(["ABCD"], c4.map { String($0) })
|
||||
|
||||
let c5 = c.combinations(ofCount: 2...4)
|
||||
XCTAssertEqual(["AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c5.map { String($0) })
|
||||
|
||||
let c6 = c.combinations(ofCount: 0...4)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c6.map { String($0) })
|
||||
|
||||
let c7 = c.combinations(ofCount: 0...)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c7.map { String($0) })
|
||||
|
||||
let c8 = c.combinations(ofCount: ...4)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c8.map { String($0) })
|
||||
|
||||
let c9 = c.combinations(ofCount: ...3)
|
||||
XCTAssertEqual(["", "A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD"], c9.map { String($0) })
|
||||
|
||||
let c10 = c.combinations(ofCount: 1...)
|
||||
XCTAssertEqual(["A", "B", "C", "D", "AB", "AC", "AD", "BC", "BD", "CD", "ABC", "ABD", "ACD", "BCD", "ABCD"], c10.map { String($0) })
|
||||
}
|
||||
|
||||
func testEmpty() {
|
||||
// `k == 0` results in one zero-length combination
|
||||
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0))
|
||||
XCTAssertEqualSequences([[]], "".combinations(ofCount: 0...0))
|
||||
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0))
|
||||
|
||||
XCTAssertEqualSequences([[]], "ABCD".combinations(ofCount: 0...0))
|
||||
|
||||
// `k` greater than element count results in zero combinations
|
||||
XCTAssertEqualSequences([], "".combinations(ofCount: 5))
|
||||
XCTAssertEqualSequences([], "".combinations(ofCount: 5...10))
|
||||
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5))
|
||||
XCTAssertEqualSequences([], "ABCD".combinations(ofCount: 5...10))
|
||||
}
|
||||
|
||||
func testCombinationsLazy() {
|
||||
XCTAssertLazy("ABC".lazy.combinations(ofCount: 1))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...3))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 1...))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: ...3))
|
||||
XCTAssertLazySequence("ABC".lazy.combinations(ofCount: 0...))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class CompactedTests: XCTestCase {
|
||||
|
||||
let tests: [[Int?]] =
|
||||
[nil, nil, nil, 0, 1, 2]
|
||||
.uniquePermutations(ofCount: 0...)
|
||||
.map(Array.init)
|
||||
|
||||
func testCompactedCompacted() {
|
||||
for collection in self.tests {
|
||||
let seq = AnySequence(collection)
|
||||
XCTAssertEqualSequences(
|
||||
seq.compactMap({ $0 }), seq.compacted())
|
||||
XCTAssertEqualSequences(
|
||||
collection.compactMap({ $0 }), collection.compacted())
|
||||
}
|
||||
}
|
||||
|
||||
func testCompactedBidirectionalCollection() {
|
||||
for array in self.tests {
|
||||
XCTAssertEqualSequences(array.compactMap({ $0 }).reversed(),
|
||||
array.compacted().reversed())
|
||||
}
|
||||
}
|
||||
|
||||
func testCollectionTraversals() {
|
||||
for array in self.tests {
|
||||
validateIndexTraversals(array.compacted())
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -19,28 +19,70 @@ final class CycleTests: XCTestCase {
|
||||
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
|
||||
cycle.prefix(20)
|
||||
)
|
||||
}
|
||||
|
||||
func testCycleClosedRangePrefix() {
|
||||
let a = Array((0..<17).cycled().prefix(10_000))
|
||||
XCTAssertEqual(10_000, a.count)
|
||||
|
||||
}
|
||||
|
||||
func testEmptyCycle() {
|
||||
let empty = Array("".cycled())
|
||||
XCTAssert(empty.isEmpty)
|
||||
}
|
||||
|
||||
|
||||
func testCycleLazy() {
|
||||
XCTAssertLazySequence((1...4).lazy.cycled())
|
||||
}
|
||||
|
||||
func testRepeated() {
|
||||
let repeats = (1...4).cycled(times: 3)
|
||||
XCTAssertEqualSequences(
|
||||
[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4],
|
||||
repeats)
|
||||
|
||||
}
|
||||
|
||||
func testRepeatedClosedRange() {
|
||||
let repeats = Array((1..<5).cycled(times: 2500))
|
||||
XCTAssertEqual(10_000, repeats.count)
|
||||
}
|
||||
|
||||
func testRepeatedEmptyCollection() {
|
||||
let empty1 = Array("".cycled(times: 100))
|
||||
XCTAssert(empty1.isEmpty)
|
||||
|
||||
}
|
||||
|
||||
func testRepeatedZeroTimesCycle() {
|
||||
let empty2 = Array("Hello".cycled(times: 0))
|
||||
XCTAssert(empty2.isEmpty)
|
||||
}
|
||||
|
||||
func testCycleLazy() {
|
||||
XCTAssertLazy((1...4).lazy.cycled())
|
||||
|
||||
func testRepeatedLazy() {
|
||||
XCTAssertLazySequence((1...4).lazy.cycled(times: 3))
|
||||
}
|
||||
|
||||
func testRepeatedIndexMethods() {
|
||||
let cycle = (1..<5).cycled(times: 2)
|
||||
let startIndex = cycle.startIndex
|
||||
var nextIndex = cycle.index(after: startIndex)
|
||||
XCTAssertEqual(cycle.distance(from: startIndex, to: nextIndex), 1)
|
||||
|
||||
nextIndex = cycle.index(nextIndex, offsetBy: 5)
|
||||
XCTAssertEqual(cycle.distance(from: startIndex, to: nextIndex), 6)
|
||||
|
||||
nextIndex = cycle.index(nextIndex, offsetBy: 2, limitedBy: cycle.endIndex)!
|
||||
XCTAssertEqual(cycle.distance(from: startIndex, to: nextIndex), 8)
|
||||
|
||||
let outOfBounds = cycle.index(nextIndex, offsetBy: 1,
|
||||
limitedBy: cycle.endIndex)
|
||||
XCTAssertNil(outOfBounds)
|
||||
|
||||
let previousIndex = cycle.index(before: nextIndex)
|
||||
XCTAssertEqual(cycle.distance(from: startIndex, to: previousIndex), 7)
|
||||
}
|
||||
|
||||
func testRepeatedCount() {
|
||||
let cycle = (1..<5).cycled(times: 2)
|
||||
XCTAssertEqual(cycle.count, 8)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,23 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class FirstNonNilTests: XCTestCase {
|
||||
func testFirstNonNil() {
|
||||
XCTAssertNil([].firstNonNil { $0 })
|
||||
XCTAssertNil(["A", "B", "C"].firstNonNil { Int($0) })
|
||||
XCTAssertNil(["A", "B", "C"].firstNonNil { _ in nil })
|
||||
XCTAssertEqual(["A", "B", "10"].firstNonNil { Int($0) }, 10)
|
||||
XCTAssertEqual(["20", "B", "10"].firstNonNil { Int($0) }, 20)
|
||||
}
|
||||
}
|
||||
@@ -29,6 +29,6 @@ final class IndexedTests: XCTestCase {
|
||||
}
|
||||
|
||||
func testIndexedLazy() {
|
||||
XCTAssertLazy("ABCD".lazy.indexed())
|
||||
XCTAssertLazyCollection("ABCD".lazy.indexed())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class IntersperseTests: XCTestCase {
|
||||
func testSequence() {
|
||||
let interspersed = (1...).prefix(5).interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4,0,5])
|
||||
}
|
||||
|
||||
func testSequenceEmpty() {
|
||||
let interspersed = (1...).prefix(0).interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [])
|
||||
}
|
||||
|
||||
func testString() {
|
||||
let interspersed = "ABCDE".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "A-B-C-D-E")
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testStringEmpty() {
|
||||
let interspersed = "".interspersed(with: "-")
|
||||
XCTAssertEqualSequences(interspersed, "")
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testArray() {
|
||||
let interspersed = [1,2,3,4].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [1,0,2,0,3,0,4])
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testArrayEmpty() {
|
||||
let interspersed = [].interspersed(with: 0)
|
||||
XCTAssertEqualSequences(interspersed, [])
|
||||
validateIndexTraversals(interspersed)
|
||||
}
|
||||
|
||||
func testCollection() {
|
||||
let interspersed = ["A","B","C","D"].interspersed(with: "-")
|
||||
XCTAssertEqual(interspersed.count, 7)
|
||||
}
|
||||
|
||||
func testBidirectionalCollection() {
|
||||
let reversed = "ABCDE".interspersed(with: "-").reversed()
|
||||
XCTAssertEqualSequences(reversed, "E-D-C-B-A")
|
||||
validateIndexTraversals(reversed)
|
||||
}
|
||||
|
||||
func testIntersperseLazy() {
|
||||
XCTAssertLazySequence((1...).prefix(0).lazy.interspersed(with: 0))
|
||||
XCTAssertLazyCollection("ABCDE".lazy.interspersed(with: "-"))
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,840 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
//===----------------------------------------------------------------------===//
|
||||
// Tests for `LazySplitSequence` and `LazySplitCollection`
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
final class LazySplitTests: XCTestCase {
|
||||
func testEmpty() {
|
||||
Validator(
|
||||
subject: [],
|
||||
separator: .element(0),
|
||||
maxSplits: 1
|
||||
).validate()
|
||||
}
|
||||
|
||||
// The following test names indicate the sequence being split, using the
|
||||
// notation
|
||||
// S: Separator
|
||||
// E: Element
|
||||
//
|
||||
// Values of `maxSplit` are interesting when they're less than the number of
|
||||
// splits that would occur with the default. That varies depending on whether
|
||||
// empty subsequences are omitted or included. `Validator` tests both the
|
||||
// default and the value provided, but there are cases below where the
|
||||
// provided `maxSplit` isn't less than the number of splits when empty
|
||||
// subsequences are omitted.
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Length 1
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testE() {
|
||||
Validator(subject: [1], separator: .element(0), maxSplits: 0).validate()
|
||||
}
|
||||
|
||||
func testS() {
|
||||
Validator(subject: [0], separator: .element(0), maxSplits: 0).validate()
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Length 2
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testEE() {
|
||||
Validator(subject: [1, 1], separator: .element(0), maxSplits: 0).validate()
|
||||
}
|
||||
|
||||
func testSS() {
|
||||
Validator(subject: [0, 0], separator: .element(0), maxSplits: 1).validate()
|
||||
}
|
||||
|
||||
func testES() {
|
||||
Validator(subject: [1, 0], separator: .element(0), maxSplits: 0).validate()
|
||||
}
|
||||
|
||||
func testSE() {
|
||||
Validator(subject: [0, 1], separator: .element(0), maxSplits: 0).validate()
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Length 3
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testEEE() {
|
||||
Validator(subject: [1, 1, 1], separator: .element(0), maxSplits: 0)
|
||||
.validate()
|
||||
}
|
||||
|
||||
func testSSS() {
|
||||
Validator(subject: [0, 0, 0], separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
|
||||
func testAllEES() {
|
||||
let permutations = [[1, 1, 0], [1, 0, 1], [0, 1, 1]]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 0)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
func testAllESS() {
|
||||
let permutations = [[1, 0, 0], [0, 1, 0], [0, 0, 1]]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Length 4 with less than two separators.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testEEEE() {
|
||||
Validator(subject: [1, 1, 1, 1], separator: .element(0), maxSplits: 0)
|
||||
.validate()
|
||||
}
|
||||
|
||||
func testAllEEES() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 0], [1, 1, 0, 1], [1, 0, 1, 1], [0, 1, 1, 1]
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 0)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Unique permutations of sequences with at least two separators, so there can
|
||||
// be multiple adjacent separators at the beginning, middle, or end.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
// All separators.
|
||||
func testSSSS() {
|
||||
Validator(subject: [0, 0, 0, 0], separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
|
||||
// Equal numbers of elements and separators.
|
||||
func testAllEESS() {
|
||||
let permutations = [
|
||||
[1, 1, 0, 0], [1, 0, 1, 0], [1, 0, 0, 1],
|
||||
[0, 1, 1, 0], [0, 1, 0, 1], [0, 0, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
// More separators than elements.
|
||||
func testAllEESSS() {
|
||||
let permutations = [
|
||||
[1, 1, 0, 0, 0], [1, 0, 1, 0, 0], [1, 0, 0, 1, 0], [1, 0, 0, 0, 1],
|
||||
[0, 1, 1, 0, 0], [0, 1, 0, 1, 0], [0, 1, 0, 0, 1], [0, 0, 1, 1, 0],
|
||||
[0, 0, 1, 0, 1], [0, 0, 0, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
// More elements than separators.
|
||||
func testAllEEESS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 0, 0], [1, 1, 0, 1, 0], [1, 1, 0, 0, 1], [1, 0, 1, 1, 0],
|
||||
[1, 0, 1, 0, 1], [1, 0, 0, 1, 1], [0, 1, 1, 1, 0], [0, 1, 1, 0, 1],
|
||||
[0, 1, 0, 1, 1], [0, 0, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Unique permutations of sequences with at least three separators.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testAllESSS() {
|
||||
let permutations = [
|
||||
[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
func testAllEEEESSS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 1, 0, 0, 0], [1, 1, 1, 0, 1, 0, 0], [1, 1, 1, 0, 0, 1, 0],
|
||||
[1, 1, 1, 0, 0, 0, 1], [1, 1, 0, 1, 1, 0, 0], [1, 1, 0, 1, 0, 1, 0],
|
||||
[1, 1, 0, 1, 0, 0, 1], [1, 1, 0, 0, 1, 1, 0], [1, 1, 0, 0, 1, 0, 1],
|
||||
[1, 1, 0, 0, 0, 1, 1], [1, 0, 1, 1, 1, 0, 0], [1, 0, 1, 1, 0, 1, 0],
|
||||
[1, 0, 1, 1, 0, 0, 1], [1, 0, 1, 0, 1, 1, 0], [1, 0, 1, 0, 1, 0, 1],
|
||||
[1, 0, 1, 0, 0, 1, 1], [1, 0, 0, 1, 1, 1, 0], [1, 0, 0, 1, 1, 0, 1],
|
||||
[1, 0, 0, 1, 0, 1, 1], [1, 0, 0, 0, 1, 1, 1], [0, 1, 1, 1, 1, 0, 0],
|
||||
[0, 1, 1, 1, 0, 1, 0], [0, 1, 1, 1, 0, 0, 1], [0, 1, 1, 0, 1, 1, 0],
|
||||
[0, 1, 1, 0, 1, 0, 1], [0, 1, 1, 0, 0, 1, 1], [0, 1, 0, 1, 1, 1, 0],
|
||||
[0, 1, 0, 1, 1, 0, 1], [0, 1, 0, 1, 0, 1, 1], [0, 1, 0, 0, 1, 1, 1],
|
||||
[0, 0, 1, 1, 1, 1, 0], [0, 0, 1, 1, 1, 0, 1], [0, 0, 1, 1, 0, 1, 1],
|
||||
[0, 0, 1, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Unique permutations of sequences with at least four separators, so there
|
||||
// can be two runs of multiple adjacent separators: beginning and end,
|
||||
// beginning and middle, or end and middle.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
// Equal numbers of separators and elements.
|
||||
func testAllEEEESSSS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 0, 1, 0, 0, 0],
|
||||
[1, 1, 1, 0, 0, 1, 0, 0], [1, 1, 1, 0, 0, 0, 1, 0],
|
||||
[1, 1, 1, 0, 0, 0, 0, 1], [1, 1, 0, 1, 1, 0, 0, 0],
|
||||
[1, 1, 0, 1, 0, 1, 0, 0], [1, 1, 0, 1, 0, 0, 1, 0],
|
||||
[1, 1, 0, 1, 0, 0, 0, 1], [1, 1, 0, 0, 1, 1, 0, 0],
|
||||
[1, 1, 0, 0, 1, 0, 1, 0], [1, 1, 0, 0, 1, 0, 0, 1],
|
||||
[1, 1, 0, 0, 0, 1, 1, 0], [1, 1, 0, 0, 0, 1, 0, 1],
|
||||
[1, 1, 0, 0, 0, 0, 1, 1], [1, 0, 1, 1, 1, 0, 0, 0],
|
||||
[1, 0, 1, 1, 0, 1, 0, 0], [1, 0, 1, 1, 0, 0, 1, 0],
|
||||
[1, 0, 1, 1, 0, 0, 0, 1], [1, 0, 1, 0, 1, 1, 0, 0],
|
||||
[1, 0, 1, 0, 1, 0, 1, 0], [1, 0, 1, 0, 1, 0, 0, 1],
|
||||
[1, 0, 1, 0, 0, 1, 1, 0], [1, 0, 1, 0, 0, 1, 0, 1],
|
||||
[1, 0, 1, 0, 0, 0, 1, 1], [1, 0, 0, 1, 1, 1, 0, 0],
|
||||
[1, 0, 0, 1, 1, 0, 1, 0], [1, 0, 0, 1, 1, 0, 0, 1],
|
||||
[1, 0, 0, 1, 0, 1, 1, 0], [1, 0, 0, 1, 0, 1, 0, 1],
|
||||
[1, 0, 0, 1, 0, 0, 1, 1], [1, 0, 0, 0, 1, 1, 1, 0],
|
||||
[1, 0, 0, 0, 1, 1, 0, 1], [1, 0, 0, 0, 1, 0, 1, 1],
|
||||
[1, 0, 0, 0, 0, 1, 1, 1], [0, 1, 1, 1, 1, 0, 0, 0],
|
||||
[0, 1, 1, 1, 0, 1, 0, 0], [0, 1, 1, 1, 0, 0, 1, 0],
|
||||
[0, 1, 1, 1, 0, 0, 0, 1], [0, 1, 1, 0, 1, 1, 0, 0],
|
||||
[0, 1, 1, 0, 1, 0, 1, 0], [0, 1, 1, 0, 1, 0, 0, 1],
|
||||
[0, 1, 1, 0, 0, 1, 1, 0], [0, 1, 1, 0, 0, 1, 0, 1],
|
||||
[0, 1, 1, 0, 0, 0, 1, 1], [0, 1, 0, 1, 1, 1, 0, 0],
|
||||
[0, 1, 0, 1, 1, 0, 1, 0], [0, 1, 0, 1, 1, 0, 0, 1],
|
||||
[0, 1, 0, 1, 0, 1, 1, 0], [0, 1, 0, 1, 0, 1, 0, 1],
|
||||
[0, 1, 0, 1, 0, 0, 1, 1], [0, 1, 0, 0, 1, 1, 1, 0],
|
||||
[0, 1, 0, 0, 1, 1, 0, 1], [0, 1, 0, 0, 1, 0, 1, 1],
|
||||
[0, 1, 0, 0, 0, 1, 1, 1], [0, 0, 1, 1, 1, 1, 0, 0],
|
||||
[0, 0, 1, 1, 1, 0, 1, 0], [0, 0, 1, 1, 1, 0, 0, 1],
|
||||
[0, 0, 1, 1, 0, 1, 1, 0], [0, 0, 1, 1, 0, 1, 0, 1],
|
||||
[0, 0, 1, 1, 0, 0, 1, 1], [0, 0, 1, 0, 1, 1, 1, 0],
|
||||
[0, 0, 1, 0, 1, 1, 0, 1], [0, 0, 1, 0, 1, 0, 1, 1],
|
||||
[0, 0, 1, 0, 0, 1, 1, 1], [0, 0, 0, 1, 1, 1, 1, 0],
|
||||
[0, 0, 0, 1, 1, 1, 0, 1], [0, 0, 0, 1, 1, 0, 1, 1],
|
||||
[0, 0, 0, 1, 0, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
// More separators than elements.
|
||||
func testAllEEESSSS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 0, 0, 0, 0], [1, 1, 0, 1, 0, 0, 0], [1, 1, 0, 0, 1, 0, 0],
|
||||
[1, 1, 0, 0, 0, 1, 0], [1, 1, 0, 0, 0, 0, 1], [1, 0, 1, 1, 0, 0, 0],
|
||||
[1, 0, 1, 0, 1, 0, 0], [1, 0, 1, 0, 0, 1, 0], [1, 0, 1, 0, 0, 0, 1],
|
||||
[1, 0, 0, 1, 1, 0, 0], [1, 0, 0, 1, 0, 1, 0], [1, 0, 0, 1, 0, 0, 1],
|
||||
[1, 0, 0, 0, 1, 1, 0], [1, 0, 0, 0, 1, 0, 1], [1, 0, 0, 0, 0, 1, 1],
|
||||
[0, 1, 1, 1, 0, 0, 0], [0, 1, 1, 0, 1, 0, 0], [0, 1, 1, 0, 0, 1, 0],
|
||||
[0, 1, 1, 0, 0, 0, 1], [0, 1, 0, 1, 1, 0, 0], [0, 1, 0, 1, 0, 1, 0],
|
||||
[0, 1, 0, 1, 0, 0, 1], [0, 1, 0, 0, 1, 1, 0], [0, 1, 0, 0, 1, 0, 1],
|
||||
[0, 1, 0, 0, 0, 1, 1], [0, 0, 1, 1, 1, 0, 0], [0, 0, 1, 1, 0, 1, 0],
|
||||
[0, 0, 1, 1, 0, 0, 1], [0, 0, 1, 0, 1, 1, 0], [0, 0, 1, 0, 1, 0, 1],
|
||||
[0, 0, 1, 0, 0, 1, 1], [0, 0, 0, 1, 1, 1, 0], [0, 0, 0, 1, 1, 0, 1],
|
||||
[0, 0, 0, 1, 0, 1, 1], [0, 0, 0, 0, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
// More elements than separators.
|
||||
func testAllEEEEESSSS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 1, 1, 0, 0, 0, 0], [1, 1, 1, 1, 0, 1, 0, 0, 0],
|
||||
[1, 1, 1, 1, 0, 0, 1, 0, 0], [1, 1, 1, 1, 0, 0, 0, 1, 0],
|
||||
[1, 1, 1, 1, 0, 0, 0, 0, 1], [1, 1, 1, 0, 1, 1, 0, 0, 0],
|
||||
[1, 1, 1, 0, 1, 0, 1, 0, 0], [1, 1, 1, 0, 1, 0, 0, 1, 0],
|
||||
[1, 1, 1, 0, 1, 0, 0, 0, 1], [1, 1, 1, 0, 0, 1, 1, 0, 0],
|
||||
[1, 1, 1, 0, 0, 1, 0, 1, 0], [1, 1, 1, 0, 0, 1, 0, 0, 1],
|
||||
[1, 1, 1, 0, 0, 0, 1, 1, 0], [1, 1, 1, 0, 0, 0, 1, 0, 1],
|
||||
[1, 1, 1, 0, 0, 0, 0, 1, 1], [1, 1, 0, 1, 1, 1, 0, 0, 0],
|
||||
[1, 1, 0, 1, 1, 0, 1, 0, 0], [1, 1, 0, 1, 1, 0, 0, 1, 0],
|
||||
[1, 1, 0, 1, 1, 0, 0, 0, 1], [1, 1, 0, 1, 0, 1, 1, 0, 0],
|
||||
[1, 1, 0, 1, 0, 1, 0, 1, 0], [1, 1, 0, 1, 0, 1, 0, 0, 1],
|
||||
[1, 1, 0, 1, 0, 0, 1, 1, 0], [1, 1, 0, 1, 0, 0, 1, 0, 1],
|
||||
[1, 1, 0, 1, 0, 0, 0, 1, 1], [1, 1, 0, 0, 1, 1, 1, 0, 0],
|
||||
[1, 1, 0, 0, 1, 1, 0, 1, 0], [1, 1, 0, 0, 1, 1, 0, 0, 1],
|
||||
[1, 1, 0, 0, 1, 0, 1, 1, 0], [1, 1, 0, 0, 1, 0, 1, 0, 1],
|
||||
[1, 1, 0, 0, 1, 0, 0, 1, 1], [1, 1, 0, 0, 0, 1, 1, 1, 0],
|
||||
[1, 1, 0, 0, 0, 1, 1, 0, 1], [1, 1, 0, 0, 0, 1, 0, 1, 1],
|
||||
[1, 1, 0, 0, 0, 0, 1, 1, 1], [1, 0, 1, 1, 1, 1, 0, 0, 0],
|
||||
[1, 0, 1, 1, 1, 0, 1, 0, 0], [1, 0, 1, 1, 1, 0, 0, 1, 0],
|
||||
[1, 0, 1, 1, 1, 0, 0, 0, 1], [1, 0, 1, 1, 0, 1, 1, 0, 0],
|
||||
[1, 0, 1, 1, 0, 1, 0, 1, 0], [1, 0, 1, 1, 0, 1, 0, 0, 1],
|
||||
[1, 0, 1, 1, 0, 0, 1, 1, 0], [1, 0, 1, 1, 0, 0, 1, 0, 1],
|
||||
[1, 0, 1, 1, 0, 0, 0, 1, 1], [1, 0, 1, 0, 1, 1, 1, 0, 0],
|
||||
[1, 0, 1, 0, 1, 1, 0, 1, 0], [1, 0, 1, 0, 1, 1, 0, 0, 1],
|
||||
[1, 0, 1, 0, 1, 0, 1, 1, 0], [1, 0, 1, 0, 1, 0, 1, 0, 1],
|
||||
[1, 0, 1, 0, 1, 0, 0, 1, 1], [1, 0, 1, 0, 0, 1, 1, 1, 0],
|
||||
[1, 0, 1, 0, 0, 1, 1, 0, 1], [1, 0, 1, 0, 0, 1, 0, 1, 1],
|
||||
[1, 0, 1, 0, 0, 0, 1, 1, 1], [1, 0, 0, 1, 1, 1, 1, 0, 0],
|
||||
[1, 0, 0, 1, 1, 1, 0, 1, 0], [1, 0, 0, 1, 1, 1, 0, 0, 1],
|
||||
[1, 0, 0, 1, 1, 0, 1, 1, 0], [1, 0, 0, 1, 1, 0, 1, 0, 1],
|
||||
[1, 0, 0, 1, 1, 0, 0, 1, 1], [1, 0, 0, 1, 0, 1, 1, 1, 0],
|
||||
[1, 0, 0, 1, 0, 1, 1, 0, 1], [1, 0, 0, 1, 0, 1, 0, 1, 1],
|
||||
[1, 0, 0, 1, 0, 0, 1, 1, 1], [1, 0, 0, 0, 1, 1, 1, 1, 0],
|
||||
[1, 0, 0, 0, 1, 1, 1, 0, 1], [1, 0, 0, 0, 1, 1, 0, 1, 1],
|
||||
[1, 0, 0, 0, 1, 0, 1, 1, 1], [1, 0, 0, 0, 0, 1, 1, 1, 1],
|
||||
[0, 1, 1, 1, 1, 1, 0, 0, 0], [0, 1, 1, 1, 1, 0, 1, 0, 0],
|
||||
[0, 1, 1, 1, 1, 0, 0, 1, 0], [0, 1, 1, 1, 1, 0, 0, 0, 1],
|
||||
[0, 1, 1, 1, 0, 1, 1, 0, 0], [0, 1, 1, 1, 0, 1, 0, 1, 0],
|
||||
[0, 1, 1, 1, 0, 1, 0, 0, 1], [0, 1, 1, 1, 0, 0, 1, 1, 0],
|
||||
[0, 1, 1, 1, 0, 0, 1, 0, 1], [0, 1, 1, 1, 0, 0, 0, 1, 1],
|
||||
[0, 1, 1, 0, 1, 1, 1, 0, 0], [0, 1, 1, 0, 1, 1, 0, 1, 0],
|
||||
[0, 1, 1, 0, 1, 1, 0, 0, 1], [0, 1, 1, 0, 1, 0, 1, 1, 0],
|
||||
[0, 1, 1, 0, 1, 0, 1, 0, 1], [0, 1, 1, 0, 1, 0, 0, 1, 1],
|
||||
[0, 1, 1, 0, 0, 1, 1, 1, 0], [0, 1, 1, 0, 0, 1, 1, 0, 1],
|
||||
[0, 1, 1, 0, 0, 1, 0, 1, 1], [0, 1, 1, 0, 0, 0, 1, 1, 1],
|
||||
[0, 1, 0, 1, 1, 1, 1, 0, 0], [0, 1, 0, 1, 1, 1, 0, 1, 0],
|
||||
[0, 1, 0, 1, 1, 1, 0, 0, 1], [0, 1, 0, 1, 1, 0, 1, 1, 0],
|
||||
[0, 1, 0, 1, 1, 0, 1, 0, 1], [0, 1, 0, 1, 1, 0, 0, 1, 1],
|
||||
[0, 1, 0, 1, 0, 1, 1, 1, 0], [0, 1, 0, 1, 0, 1, 1, 0, 1],
|
||||
[0, 1, 0, 1, 0, 1, 0, 1, 1], [0, 1, 0, 1, 0, 0, 1, 1, 1],
|
||||
[0, 1, 0, 0, 1, 1, 1, 1, 0], [0, 1, 0, 0, 1, 1, 1, 0, 1],
|
||||
[0, 1, 0, 0, 1, 1, 0, 1, 1], [0, 1, 0, 0, 1, 0, 1, 1, 1],
|
||||
[0, 1, 0, 0, 0, 1, 1, 1, 1], [0, 0, 1, 1, 1, 1, 1, 0, 0],
|
||||
[0, 0, 1, 1, 1, 1, 0, 1, 0], [0, 0, 1, 1, 1, 1, 0, 0, 1],
|
||||
[0, 0, 1, 1, 1, 0, 1, 1, 0], [0, 0, 1, 1, 1, 0, 1, 0, 1],
|
||||
[0, 0, 1, 1, 1, 0, 0, 1, 1], [0, 0, 1, 1, 0, 1, 1, 1, 0],
|
||||
[0, 0, 1, 1, 0, 1, 1, 0, 1], [0, 0, 1, 1, 0, 1, 0, 1, 1],
|
||||
[0, 0, 1, 1, 0, 0, 1, 1, 1], [0, 0, 1, 0, 1, 1, 1, 1, 0],
|
||||
[0, 0, 1, 0, 1, 1, 1, 0, 1], [0, 0, 1, 0, 1, 1, 0, 1, 1],
|
||||
[0, 0, 1, 0, 1, 0, 1, 1, 1], [0, 0, 1, 0, 0, 1, 1, 1, 1],
|
||||
[0, 0, 0, 1, 1, 1, 1, 1, 0], [0, 0, 0, 1, 1, 1, 1, 0, 1],
|
||||
[0, 0, 0, 1, 1, 1, 0, 1, 1], [0, 0, 0, 1, 1, 0, 1, 1, 1],
|
||||
[0, 0, 0, 1, 0, 1, 1, 1, 1], [0, 0, 0, 0, 1, 1, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Permutations of a sequence with six separators, so there can be multiple
|
||||
// adjacent separators at the beginning, middle, _and_ end.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
// More separators than elements.
|
||||
func testAllEEESSSSSS() {
|
||||
let permutations = [
|
||||
[1, 1, 1, 0, 0, 0, 0, 0, 0], [1, 1, 0, 1, 0, 0, 0, 0, 0],
|
||||
[1, 1, 0, 0, 1, 0, 0, 0, 0], [1, 1, 0, 0, 0, 1, 0, 0, 0],
|
||||
[1, 1, 0, 0, 0, 0, 1, 0, 0], [1, 1, 0, 0, 0, 0, 0, 1, 0],
|
||||
[1, 1, 0, 0, 0, 0, 0, 0, 1], [1, 0, 1, 1, 0, 0, 0, 0, 0],
|
||||
[1, 0, 1, 0, 1, 0, 0, 0, 0], [1, 0, 1, 0, 0, 1, 0, 0, 0],
|
||||
[1, 0, 1, 0, 0, 0, 1, 0, 0], [1, 0, 1, 0, 0, 0, 0, 1, 0],
|
||||
[1, 0, 1, 0, 0, 0, 0, 0, 1], [1, 0, 0, 1, 1, 0, 0, 0, 0],
|
||||
[1, 0, 0, 1, 0, 1, 0, 0, 0], [1, 0, 0, 1, 0, 0, 1, 0, 0],
|
||||
[1, 0, 0, 1, 0, 0, 0, 1, 0], [1, 0, 0, 1, 0, 0, 0, 0, 1],
|
||||
[1, 0, 0, 0, 1, 1, 0, 0, 0], [1, 0, 0, 0, 1, 0, 1, 0, 0],
|
||||
[1, 0, 0, 0, 1, 0, 0, 1, 0], [1, 0, 0, 0, 1, 0, 0, 0, 1],
|
||||
[1, 0, 0, 0, 0, 1, 1, 0, 0], [1, 0, 0, 0, 0, 1, 0, 1, 0],
|
||||
[1, 0, 0, 0, 0, 1, 0, 0, 1], [1, 0, 0, 0, 0, 0, 1, 1, 0],
|
||||
[1, 0, 0, 0, 0, 0, 1, 0, 1], [1, 0, 0, 0, 0, 0, 0, 1, 1],
|
||||
[0, 1, 1, 1, 0, 0, 0, 0, 0], [0, 1, 1, 0, 1, 0, 0, 0, 0],
|
||||
[0, 1, 1, 0, 0, 1, 0, 0, 0], [0, 1, 1, 0, 0, 0, 1, 0, 0],
|
||||
[0, 1, 1, 0, 0, 0, 0, 1, 0], [0, 1, 1, 0, 0, 0, 0, 0, 1],
|
||||
[0, 1, 0, 1, 1, 0, 0, 0, 0], [0, 1, 0, 1, 0, 1, 0, 0, 0],
|
||||
[0, 1, 0, 1, 0, 0, 1, 0, 0], [0, 1, 0, 1, 0, 0, 0, 1, 0],
|
||||
[0, 1, 0, 1, 0, 0, 0, 0, 1], [0, 1, 0, 0, 1, 1, 0, 0, 0],
|
||||
[0, 1, 0, 0, 1, 0, 1, 0, 0], [0, 1, 0, 0, 1, 0, 0, 1, 0],
|
||||
[0, 1, 0, 0, 1, 0, 0, 0, 1], [0, 1, 0, 0, 0, 1, 1, 0, 0],
|
||||
[0, 1, 0, 0, 0, 1, 0, 1, 0], [0, 1, 0, 0, 0, 1, 0, 0, 1],
|
||||
[0, 1, 0, 0, 0, 0, 1, 1, 0], [0, 1, 0, 0, 0, 0, 1, 0, 1],
|
||||
[0, 1, 0, 0, 0, 0, 0, 1, 1], [0, 0, 1, 1, 1, 0, 0, 0, 0],
|
||||
[0, 0, 1, 1, 0, 1, 0, 0, 0], [0, 0, 1, 1, 0, 0, 1, 0, 0],
|
||||
[0, 0, 1, 1, 0, 0, 0, 1, 0], [0, 0, 1, 1, 0, 0, 0, 0, 1],
|
||||
[0, 0, 1, 0, 1, 1, 0, 0, 0], [0, 0, 1, 0, 1, 0, 1, 0, 0],
|
||||
[0, 0, 1, 0, 1, 0, 0, 1, 0], [0, 0, 1, 0, 1, 0, 0, 0, 1],
|
||||
[0, 0, 1, 0, 0, 1, 1, 0, 0], [0, 0, 1, 0, 0, 1, 0, 1, 0],
|
||||
[0, 0, 1, 0, 0, 1, 0, 0, 1], [0, 0, 1, 0, 0, 0, 1, 1, 0],
|
||||
[0, 0, 1, 0, 0, 0, 1, 0, 1], [0, 0, 1, 0, 0, 0, 0, 1, 1],
|
||||
[0, 0, 0, 1, 1, 1, 0, 0, 0], [0, 0, 0, 1, 1, 0, 1, 0, 0],
|
||||
[0, 0, 0, 1, 1, 0, 0, 1, 0], [0, 0, 0, 1, 1, 0, 0, 0, 1],
|
||||
[0, 0, 0, 1, 0, 1, 1, 0, 0], [0, 0, 0, 1, 0, 1, 0, 1, 0],
|
||||
[0, 0, 0, 1, 0, 1, 0, 0, 1], [0, 0, 0, 1, 0, 0, 1, 1, 0],
|
||||
[0, 0, 0, 1, 0, 0, 1, 0, 1], [0, 0, 0, 1, 0, 0, 0, 1, 1],
|
||||
[0, 0, 0, 0, 1, 1, 1, 0, 0], [0, 0, 0, 0, 1, 1, 0, 1, 0],
|
||||
[0, 0, 0, 0, 1, 1, 0, 0, 1], [0, 0, 0, 0, 1, 0, 1, 1, 0],
|
||||
[0, 0, 0, 0, 1, 0, 1, 0, 1], [0, 0, 0, 0, 1, 0, 0, 1, 1],
|
||||
[0, 0, 0, 0, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 1, 1, 0, 1],
|
||||
[0, 0, 0, 0, 0, 1, 0, 1, 1], [0, 0, 0, 0, 0, 0, 1, 1, 1],
|
||||
]
|
||||
|
||||
for permutation in permutations {
|
||||
Validator(subject: permutation, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Specific examples of interest.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
// The motivating example from
|
||||
// https://github.com/apple/swift-algorithms/issues/59.
|
||||
func testSplitFilenameComponents() {
|
||||
Validator(
|
||||
subject: "archive.tar.gz",
|
||||
separator: .element("."),
|
||||
maxSplits: 1
|
||||
).validate()
|
||||
}
|
||||
|
||||
// Examples from documentation.
|
||||
func testSequenceDocExamples() {
|
||||
// Closure version.
|
||||
let numbers = stride(from: 1, through: 16, by: 1)
|
||||
Validator(
|
||||
subject: Array(numbers),
|
||||
separator: .closure({ $0 % 3 == 0 || $0 % 5 == 0 }),
|
||||
maxSplits: 1
|
||||
).validate()
|
||||
|
||||
// Equatable element version.
|
||||
let numbers2 = [1, 2, 0, 3, 4, 0, 0, 5]
|
||||
Validator(subject: numbers2, separator: .element(0), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
|
||||
func testCollectionDocExample() {
|
||||
let line = "BLANCHE: I don't want realism. I want magic!"
|
||||
Validator(subject: line, separator: .element("."), maxSplits: 1).validate()
|
||||
}
|
||||
|
||||
// Patterns tested in a previous version of this file which aren't tested
|
||||
// above. Preserved to ensure we're not losing any test coverage.
|
||||
func testVintagePatterns() {
|
||||
let pattern1 = [1, 2, 42, 3, 4, 42, 5, 6, 42, 7]
|
||||
Validator(subject: pattern1, separator: .element(42), maxSplits: 2)
|
||||
.validate()
|
||||
Validator(subject: pattern1, separator: .element(42), maxSplits: 0)
|
||||
.validate()
|
||||
|
||||
let pattern2 = [42, 1, 2, 42, 3, 4, 42, 5, 6, 42, 7]
|
||||
Validator(subject: pattern2, separator: .element(42), maxSplits: 2)
|
||||
.validate()
|
||||
|
||||
let pattern3 = [1, 2, 42, 3, 4, 42, 42, 5, 6, 42, 7]
|
||||
Validator(subject: pattern3, separator: .element(42), maxSplits: 2)
|
||||
.validate()
|
||||
|
||||
let pattern4 = [1, 2, 42, 3, 4, 42, 42, 5, 6, 42, 7, 42, 42, 42]
|
||||
Validator(subject: pattern4, separator: .element(42), maxSplits: 1)
|
||||
.validate()
|
||||
}
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Protocol conformance.
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
func testLaziness() {
|
||||
let splitSequence = AnySequence([1, 2, 42, 3]).lazy.split(separator: 42)
|
||||
XCTAssertLazySequence(splitSequence)
|
||||
|
||||
let splitCollection = "foo.bar".lazy.split(separator: ".")
|
||||
XCTAssertLazySequence(splitCollection)
|
||||
XCTAssertLazyCollection(splitCollection)
|
||||
}
|
||||
|
||||
// TODO: Need a version of `validateIndexTraversals` that doesn't require
|
||||
// `BidirectionalCollection` conformance.
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// Validator
|
||||
//===--------------------------------------------------------------------===//
|
||||
|
||||
/// Splits a collection as both a lazy sequence and a lazy collection, using
|
||||
/// the provided separator, and compares the results to those of the Standard
|
||||
/// Library's eager splits, which are assumed to be correct.
|
||||
///
|
||||
/// Tests all combinations of default and provided `maxSplit` arguments and
|
||||
/// default (true) and explicit false for `omittingEmptySubsequences`.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - subject: The collection whose splits will be validated.
|
||||
/// - separator: The element of the collection--or a predicate function to
|
||||
/// determine the element--on which to split.
|
||||
/// - maxSplits: The value to pass for `maxSplits` during validation. The
|
||||
/// default value is also validated.
|
||||
fileprivate struct Validator<C: Collection>
|
||||
where C.Element: Equatable, C.SubSequence: Equatable {
|
||||
enum Separator {
|
||||
case element(C.Element)
|
||||
case closure((C.Element) -> Bool)
|
||||
}
|
||||
|
||||
let subject: C
|
||||
let separator: Separator
|
||||
let maxSplits: Int
|
||||
|
||||
func validate() {
|
||||
_validateAsSequence(AnySequence(subject))
|
||||
_validateAsCollection(subject)
|
||||
}
|
||||
|
||||
private enum MaxSplits: CustomStringConvertible {
|
||||
case provided(Int)
|
||||
case defaultValue
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .provided(let value):
|
||||
return "maxSplits: \(value)"
|
||||
case .defaultValue:
|
||||
return "maxSplits: default"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private enum OmittingEmptySubsequences: CustomStringConvertible {
|
||||
case provided(Bool)
|
||||
case defaultValue
|
||||
|
||||
var description: String {
|
||||
switch self {
|
||||
case .provided(let value):
|
||||
return "omittingEmptySubsequences: \(value)"
|
||||
case .defaultValue:
|
||||
return "omittingEmptySubsequences: default"
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private func failureMessage<L: LazySequenceProtocol, S: Sequence>(
|
||||
actual: L,
|
||||
expected: S,
|
||||
maxSplits: MaxSplits,
|
||||
omittingEmptySubsequences: OmittingEmptySubsequences
|
||||
) -> String {
|
||||
"for \(Array(subject).debugDescription), \(maxSplits), \(omittingEmptySubsequences): \(Array(actual).debugDescription) != \(Array(expected).debugDescription)"
|
||||
}
|
||||
|
||||
private func _validateAsSequence<T: Sequence>(_ s: T)
|
||||
where T.Element == C.Element {
|
||||
// Default max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = s.split(separator: element).map { Array($0) }
|
||||
let actual = s.lazy.split(separator: element)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = s.split(whereSeparator: closure).map { Array($0) }
|
||||
let actual = s.lazy.split(whereSeparator: closure)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
}
|
||||
|
||||
// Provided max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = s.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
}
|
||||
|
||||
// Default max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = s.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
}
|
||||
|
||||
// Provided max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = s.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = s.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
).map { Array($0) }
|
||||
let actual = s.lazy.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
private func _validateAsCollection(_ c: C) {
|
||||
// Default max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = c.split(separator: element)
|
||||
let actual = c.lazy.split(separator: element)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = c.split(whereSeparator: closure)
|
||||
let actual = c.lazy.split(whereSeparator: closure)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
}
|
||||
|
||||
// Provided max splits, omitting empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = c.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
maxSplits: maxSplits,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .defaultValue)
|
||||
)
|
||||
}
|
||||
|
||||
// Default max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
separator: element,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = c.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .defaultValue,
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
}
|
||||
|
||||
// Provided max splits, including empty sequences
|
||||
switch separator {
|
||||
case let .element(element):
|
||||
let expected = c.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
separator: element,
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
case let .closure(closure):
|
||||
let expected = c.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
let actual = c.lazy.split(
|
||||
maxSplits: maxSplits,
|
||||
omittingEmptySubsequences: false,
|
||||
whereSeparator: closure
|
||||
)
|
||||
XCTAssertEqualSequences(
|
||||
expected,
|
||||
actual,
|
||||
failureMessage(
|
||||
actual: actual, expected: expected, maxSplits: .provided(maxSplits),
|
||||
omittingEmptySubsequences: .provided(false))
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,187 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class SortedPrefixTests: XCTestCase {
|
||||
func testMinCount() {
|
||||
// Replacement at start and end
|
||||
let input = [10, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 0, 7, 8, 9]
|
||||
let min = input.min(count: 5)
|
||||
XCTAssertEqualSequences(min, 0..<5)
|
||||
|
||||
// Stability with all equal values
|
||||
let maxZeroes = Array(repeating: 0, count: 100)
|
||||
.enumerated()
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
}
|
||||
|
||||
func testMaxCount() {
|
||||
// Replacement at start and end
|
||||
let input = [0, 11, 12, 1, 13, 2, 14, 3, 4, 5, 6, 7, 8, 9, 10]
|
||||
let max = input.max(count: 5)
|
||||
XCTAssertEqualSequences(max, 10..<15)
|
||||
|
||||
// Stability with all equal values
|
||||
let maxZeroes = Array(repeating: 0, count: 100)
|
||||
.enumerated()
|
||||
.max(count: 5, sortedBy: { $0.element < $1.element })
|
||||
XCTAssertEqualSequences(maxZeroes.map { $0.offset }, 95..<100)
|
||||
}
|
||||
|
||||
func testEmpty() {
|
||||
let array = [Int]()
|
||||
XCTAssertEqual(array.min(count: 0), [])
|
||||
XCTAssertEqual(array.min(count: 100), [])
|
||||
|
||||
XCTAssertEqual(array.max(count: 0), [])
|
||||
XCTAssertEqual(array.max(count: 100), [])
|
||||
}
|
||||
|
||||
func testMinMaxSequences() {
|
||||
let input = (1...100).shuffled().interspersed(with: 50)
|
||||
let seq = AnySequence(input)
|
||||
|
||||
XCTAssertEqualSequences(seq.min(count: 0), [])
|
||||
XCTAssertEqualSequences(seq.min(count: 5), 1...5)
|
||||
|
||||
XCTAssertEqualSequences(seq.max(count: 0), [])
|
||||
XCTAssertEqualSequences(seq.max(count: 5), 96...100)
|
||||
}
|
||||
|
||||
func testSortedPrefixComparable() {
|
||||
let array: [Int] = [20, 1, 4, 70, 100, 2, 3, 7, 90]
|
||||
|
||||
XCTAssertEqual(array.min(count: 0), [])
|
||||
XCTAssertEqual(array.min(count: 1), [1])
|
||||
XCTAssertEqualSequences(array.min(count: 5), array.sorted().prefix(5))
|
||||
XCTAssertEqual(array.min(count: 10), array.sorted())
|
||||
}
|
||||
|
||||
func testMinMaxWithHugeCount() {
|
||||
XCTAssertEqual([4, 2, 1, 3].min(count: .max), [1, 2, 3, 4])
|
||||
XCTAssertEqual([4, 2, 1, 3].max(count: .max), [1, 2, 3, 4])
|
||||
}
|
||||
|
||||
func testMinCountWithHugeInput() {
|
||||
let range = 1...1000
|
||||
let input = range.shuffled()
|
||||
|
||||
XCTAssertEqual(input.min(count: 0, sortedBy: <), [])
|
||||
XCTAssertEqual(input.min(count: 0, sortedBy: >), [])
|
||||
|
||||
XCTAssertEqual(input.min(count: 1, sortedBy: <), [range.lowerBound])
|
||||
XCTAssertEqual(input.min(count: 1, sortedBy: >), [range.upperBound])
|
||||
|
||||
XCTAssertEqualSequences(input.min(count: 5, sortedBy: <), range.prefix(5))
|
||||
XCTAssertEqualSequences(
|
||||
input.min(count: 5, sortedBy: >),
|
||||
range.suffix(5).reversed())
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
input.min(count: 500, sortedBy: <),
|
||||
range.prefix(500))
|
||||
XCTAssertEqualSequences(
|
||||
input.min(count: 500, sortedBy: >),
|
||||
range.suffix(500).reversed())
|
||||
|
||||
XCTAssertEqualSequences(input.min(count: 1000, sortedBy: <), range)
|
||||
XCTAssertEqualSequences(
|
||||
input.min(count: 1000, sortedBy: >),
|
||||
range.reversed())
|
||||
}
|
||||
|
||||
func testMaxCountWithHugeInput() {
|
||||
let range = 1...1000
|
||||
let input = range.shuffled()
|
||||
|
||||
XCTAssertEqual(input.max(count: 0, sortedBy: <), [])
|
||||
XCTAssertEqual(input.max(count: 0, sortedBy: >), [])
|
||||
|
||||
XCTAssertEqual(input.max(count: 1, sortedBy: <), [range.upperBound])
|
||||
XCTAssertEqual(input.max(count: 1, sortedBy: >), [range.lowerBound])
|
||||
|
||||
XCTAssertEqualSequences(input.max(count: 5, sortedBy: <), range.suffix(5))
|
||||
XCTAssertEqualSequences(
|
||||
input.max(count: 5, sortedBy: >),
|
||||
range.prefix(5).reversed())
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
input.max(count: 500, sortedBy: <),
|
||||
range.suffix(500))
|
||||
XCTAssertEqualSequences(
|
||||
input.max(count: 500, sortedBy: >),
|
||||
range.prefix(500).reversed())
|
||||
|
||||
XCTAssertEqualSequences(input.max(count: 1000, sortedBy: <), range)
|
||||
XCTAssertEqualSequences(
|
||||
input.max(count: 1000, sortedBy: >),
|
||||
range.reversed())
|
||||
}
|
||||
|
||||
func testStability() {
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 3)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 6)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 20)
|
||||
assertStability([1,1,1,2,5,7,3,6,2,5,7,3,6], withCount: 1000)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 0)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 1)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 2)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 5)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 20)
|
||||
assertStability(Array(repeating: 0, count: 100), withCount: 100)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 2)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 5)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 20)
|
||||
assertStability(Array(repeating: 1, count: 50) + Array(repeating: 0, count: 50), withCount: 50)
|
||||
assertStability([0,0], withCount: 1)
|
||||
assertStability([0,0], withCount: 2)
|
||||
assertStability([0,1,0,1,0,1], withCount: 2)
|
||||
assertStability([0,1,0,1,0,1], withCount: 6)
|
||||
assertStability([0,0,0,1,1,1], withCount: 1)
|
||||
assertStability([0,0,0,1,1,1], withCount: 3)
|
||||
assertStability([0,0,0,1,1,1], withCount: 4)
|
||||
assertStability([0,0,0,1,1,1], withCount: 6)
|
||||
assertStability([1,1,1,0,0,0], withCount: 1)
|
||||
assertStability([1,1,1,0,0,0], withCount: 3)
|
||||
assertStability([1,1,1,0,0,0], withCount: 4)
|
||||
assertStability([1,1,1,0,0,0], withCount: 6)
|
||||
assertStability([1,1,1,0,0,0], withCount: 5)
|
||||
}
|
||||
|
||||
func assertStability(
|
||||
_ actual: [Int],
|
||||
withCount count: Int
|
||||
) {
|
||||
func stableOrder(
|
||||
a: (offset: Int, element: Int),
|
||||
b: (offset: Int, element: Int)) -> Bool
|
||||
{
|
||||
a.element == b.element
|
||||
? a.offset < b.offset
|
||||
: a.element < b.element
|
||||
}
|
||||
|
||||
do {
|
||||
let sorted = actual.enumerated()
|
||||
.min(count: count) { $0.element < $1.element }
|
||||
XCTAssert(sorted.isSorted(by: stableOrder))
|
||||
}
|
||||
|
||||
do {
|
||||
let sorted = actual.enumerated()
|
||||
.max(count: count) { $0.element < $1.element }
|
||||
XCTAssert(sorted.isSorted(by: stableOrder))
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -64,14 +64,17 @@ final class PartitionTests: XCTestCase {
|
||||
func testStablePartitionWithSubrange() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
for j in 0..<length {
|
||||
var b = a
|
||||
let partitionRange = 0..<j
|
||||
let condition = { $0 < j - 1 }
|
||||
let p = b.stablePartition(subrange: partitionRange, by: condition)
|
||||
XCTAssertEqual(p, partitionRange.count > 0 ? 1 : 0)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
for i in 0..<length {
|
||||
for j in 0...i {
|
||||
var b = a
|
||||
let partitionRange = j..<i
|
||||
let condition = { $0 < i - 1 }
|
||||
let p = b.stablePartition(subrange: partitionRange, by: condition)
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -88,4 +91,46 @@ final class PartitionTests: XCTestCase {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testPartitionWithSubrangeBidirectionalCollection() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
for i in 0..<length {
|
||||
for j in 0...i {
|
||||
var b = a
|
||||
let partitionRange = j..<i
|
||||
let condition = { $0 < i - 1 }
|
||||
let p = b.partition(subrange: partitionRange, by: condition)
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testPartitionWithSubrangeMutableCollection() {
|
||||
for length in 10...20 {
|
||||
let a = Array(0..<length)
|
||||
for i in 0..<length {
|
||||
for j in 0...i {
|
||||
var b = a.eraseToAnyMutableCollection()
|
||||
var bdc = a
|
||||
let partitionRange = j..<i
|
||||
let condition = { $0 < i - 1 }
|
||||
let p = b.partition(subrange: partitionRange, by: condition)
|
||||
let bdcp = bdc.partition(subrange: partitionRange, by: condition)
|
||||
|
||||
XCTAssertEqual(p, partitionRange.count == 0 ? j : j + 1)
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], a[partitionRange].filter { !condition($0) })
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], a[partitionRange].filter(condition))
|
||||
|
||||
// Must produce the same result as the `BidirectionalCollection` specialized overload.
|
||||
XCTAssertEqualSequences(b[partitionRange.lowerBound..<p], bdc[partitionRange.lowerBound..<bdcp])
|
||||
XCTAssertUnorderedEqualSequences(b[p..<partitionRange.upperBound], bdc[bdcp..<partitionRange.upperBound])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -26,27 +26,58 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertTrue(p.allSatisfy { $0.count == count })
|
||||
XCTAssertTrue(p.isSorted(by: { $0.lexicographicallyPrecedes($1) }))
|
||||
}
|
||||
|
||||
|
||||
func ts<R: RangeExpression>(count: R) where R.Bound == Int {
|
||||
let p = count.relative(to: 0 ..< .max)
|
||||
.clamped(to: 0 ..< c.count + 1)
|
||||
.flatMap {
|
||||
c.permutations(ofCount: $0)
|
||||
}
|
||||
|
||||
let p2 = c.permutations(ofCount: count)
|
||||
|
||||
XCTAssertEqual(p.count, p2.count)
|
||||
XCTAssertEqualSequences(p, Array(p2))
|
||||
}
|
||||
|
||||
t(count: 0)
|
||||
t(count: 1)
|
||||
t(count: 2)
|
||||
t(count: 3)
|
||||
t(count: 4)
|
||||
t(count: 5)
|
||||
t(count: nil)
|
||||
|
||||
ts(count: 0...0)
|
||||
ts(count: 1...1)
|
||||
ts(count: 0...1)
|
||||
ts(count: 0...2)
|
||||
ts(count: 0...3)
|
||||
ts(count: 1...3)
|
||||
ts(count: 2...3)
|
||||
ts(count: 0...)
|
||||
ts(count: ...5)
|
||||
ts(count: ...4)
|
||||
ts(count: ...6)
|
||||
}
|
||||
|
||||
func testEmpty() {
|
||||
// `k == 0` results in one zero-length permutation
|
||||
XCTAssertEqual(1, "".permutations().count)
|
||||
XCTAssertEqual(1, "ABCD".permutations(ofCount: 0).count)
|
||||
XCTAssertEqual(1, "ABCD".permutations(ofCount: 0...0).count)
|
||||
XCTAssertEqual(Array("".permutations()), [[]])
|
||||
XCTAssertEqual(Array("".permutations(ofCount: 0)), [[]])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0)), [[]])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 0...0)), [[]])
|
||||
|
||||
// `k` greater than element count results in zero permutations
|
||||
XCTAssertEqual(0, "".permutations(ofCount: 5).count)
|
||||
XCTAssertEqual(Array("".permutations(ofCount: 5)), [])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5)), [])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5..<6)), [])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5..<7)), [])
|
||||
XCTAssertEqual(Array("ABCD".permutations(ofCount: 5...)), [])
|
||||
}
|
||||
|
||||
func testNextPermutation() {
|
||||
@@ -64,13 +95,110 @@ final class PermutationsTests: XCTestCase {
|
||||
XCTAssertEqual([1, 2, 3, 4, 7, 6, 5], numbers)
|
||||
_ = numbers.nextPermutation()
|
||||
XCTAssertEqual([1, 2, 3, 5, 4, 6, 7], numbers)
|
||||
|
||||
|
||||
// Fast-forward to end of permutations.
|
||||
while numbers.nextPermutation() {}
|
||||
XCTAssertEqual([1, 2, 3, 4, 5, 6, 7], numbers)
|
||||
}
|
||||
|
||||
func testPermutationsLazy() {
|
||||
XCTAssertLazy("ABCD".lazy.permutations(ofCount: 2))
|
||||
XCTAssertLazySequence("ABCD".lazy.permutations(ofCount: 2))
|
||||
}
|
||||
|
||||
func testDocumentationExample1() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations()
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
}
|
||||
|
||||
func testDocumentationExample2() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations(ofCount: 2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
])
|
||||
}
|
||||
|
||||
func testDocumentationExample3() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers2 = [20, 10, 10]
|
||||
let permutations = numbers2.permutations()
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[20, 10, 10],
|
||||
[20, 10, 10],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
[10, 20, 10],
|
||||
[10, 10, 20],
|
||||
])
|
||||
}
|
||||
|
||||
func testDocumentationExample4() {
|
||||
// From Guides/Permutations.md
|
||||
let numbers = [10, 20, 30]
|
||||
let permutations = numbers.permutations(ofCount: 0...)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
[],
|
||||
[10],
|
||||
[20],
|
||||
[30],
|
||||
[10, 20],
|
||||
[10, 30],
|
||||
[20, 10],
|
||||
[20, 30],
|
||||
[30, 10],
|
||||
[30, 20],
|
||||
[10, 20, 30],
|
||||
[10, 30, 20],
|
||||
[20, 10, 30],
|
||||
[20, 30, 10],
|
||||
[30, 10, 20],
|
||||
[30, 20, 10],
|
||||
])
|
||||
}
|
||||
|
||||
func testDocumentationExample5() {
|
||||
// From Permutations.swift
|
||||
let names = ["Alex", "Celeste", "Davide"]
|
||||
let permutations = names.permutations(ofCount: 2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
}
|
||||
|
||||
func testDocumentationExample6() {
|
||||
// From Permutations.swift
|
||||
let names = ["Alex", "Celeste", "Davide"]
|
||||
let permutations = names.permutations(ofCount: 1...2)
|
||||
XCTAssertEqualSequences(permutations, [
|
||||
["Alex"],
|
||||
["Celeste"],
|
||||
["Davide"],
|
||||
["Alex", "Celeste"],
|
||||
["Alex", "Davide"],
|
||||
["Celeste", "Alex"],
|
||||
["Celeste", "Davide"],
|
||||
["Davide", "Alex"],
|
||||
["Davide", "Celeste"],
|
||||
])
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
@testable import Algorithms
|
||||
|
||||
final class ProductTests: XCTestCase {
|
||||
func testProduct() {
|
||||
@@ -37,4 +37,19 @@ final class ProductTests: XCTestCase {
|
||||
let p = product([1, 2], "abc")
|
||||
XCTAssertEqual(p.distance(from: p.startIndex, to: p.endIndex), 6)
|
||||
}
|
||||
|
||||
func testProductIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
product([1, 2, 3, 4], "abc"),
|
||||
product([1, 2, 3, 4], ""),
|
||||
product([], "abc"),
|
||||
product([], ""),
|
||||
indices: { product in
|
||||
product.base1.indices.flatMap { i1 in
|
||||
product.base2.indices.map { i2 in
|
||||
.init(i1: i1, i2: i2)
|
||||
}
|
||||
} + [.init(i1: product.base1.endIndex, i2: product.base2.startIndex)]
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -10,7 +10,7 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
@testable import Algorithms
|
||||
|
||||
func validateRandomSamples<S: Sequence>(
|
||||
_ samples: [Int: Int],
|
||||
@@ -26,11 +26,11 @@ func validateRandomSamples<S: Sequence>(
|
||||
}
|
||||
}
|
||||
|
||||
let n = 100
|
||||
let k = 12
|
||||
let iterations = 10_000
|
||||
let c = 0..<n
|
||||
let s = sequence(first: 0, next: { $0 == n - 1 ? nil : $0 + 1 })
|
||||
private let n = 100
|
||||
private let k = 12
|
||||
private let iterations = 10_000
|
||||
private let c = 0..<n
|
||||
private let s = sequence(first: 0, next: { $0 == n - 1 ? nil : $0 + 1 })
|
||||
|
||||
final class RandomSampleTests: XCTestCase {
|
||||
func testRandomStableSampleCollection() {
|
||||
@@ -95,4 +95,32 @@ final class RandomSampleTests: XCTestCase {
|
||||
let sample2c = c.randomStableSample(count: k, using: &generator)
|
||||
XCTAssertEqual(sample1c, sample2c)
|
||||
}
|
||||
|
||||
func testRandomSampleRandomEdgeCasesInternal() {
|
||||
struct ZeroGenerator: RandomNumberGenerator {
|
||||
mutating func next() -> UInt64 { 0 }
|
||||
}
|
||||
var zero = ZeroGenerator()
|
||||
_ = nextOffset(w: 1, using: &zero) // must not crash
|
||||
|
||||
struct AlmostAllZeroGenerator: RandomNumberGenerator {
|
||||
private var forward: SplitMix64
|
||||
private var count: Int = 0
|
||||
|
||||
init(seed: UInt64) {
|
||||
forward = SplitMix64(seed: seed)
|
||||
}
|
||||
|
||||
mutating func next() -> UInt64 {
|
||||
defer { count &+= 1 }
|
||||
if count % 1000 == 0 { return forward.next() }
|
||||
return 0
|
||||
}
|
||||
}
|
||||
|
||||
var almostAllZero = AlmostAllZeroGenerator(seed: 0)
|
||||
_ = s.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
almostAllZero = AlmostAllZeroGenerator(seed: 0)
|
||||
_ = c.randomSample(count: k, using: &almostAllZero) // must not crash
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,81 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class ReductionsTests: XCTestCase {
|
||||
|
||||
struct TestError: Error {}
|
||||
|
||||
// MARK: - Exclusive Reductions
|
||||
|
||||
func testExclusiveLazy() {
|
||||
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(0, +), [0, 1])
|
||||
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(0, +), [0])
|
||||
|
||||
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(0, +), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqualCollections([1].lazy.reductions(0, +), [0, 1])
|
||||
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(0, +), [0])
|
||||
|
||||
XCTAssertEqual([1, 2, 3, 4].lazy.reductions(into: 0, +=), [0, 1, 3, 6, 10])
|
||||
|
||||
XCTAssertEqual([1].lazy.reductions(into: 0, +=), [0, 1])
|
||||
|
||||
XCTAssertEqual(EmptyCollection<Int>().lazy.reductions(into: 0, +=), [0])
|
||||
|
||||
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(0, +))
|
||||
XCTAssertLazySequence([1].lazy.reductions(0, +))
|
||||
XCTAssertLazyCollection([1].lazy.reductions(0, +))
|
||||
}
|
||||
|
||||
func testExclusiveEager() {
|
||||
XCTAssertEqual([1, 2, 3, 4].reductions(0, +), [0, 1, 3, 6, 10])
|
||||
XCTAssertEqual([1].reductions(0, +), [0, 1])
|
||||
XCTAssertEqual(EmptyCollection<Int>().reductions(0, +), [0])
|
||||
|
||||
XCTAssertEqual([1, 2, 3, 4].reductions(into: 0, +=), [0, 1, 3, 6, 10])
|
||||
|
||||
XCTAssertEqual([1].reductions(into: 0, +=), [0, 1])
|
||||
|
||||
XCTAssertEqual(EmptyCollection<Int>().reductions(into: 0, +=), [0])
|
||||
|
||||
XCTAssertNoThrow(try [].reductions(0) { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1].reductions(0) { _, _ in throw TestError() })
|
||||
}
|
||||
|
||||
// MARK: - Inclusive Reductions
|
||||
|
||||
func testInclusiveLazy() {
|
||||
XCTAssertEqualSequences((1...).prefix(4).lazy.reductions(+), [1, 3, 6, 10])
|
||||
XCTAssertEqualSequences((1...).prefix(1).lazy.reductions(+), [1])
|
||||
XCTAssertEqualSequences((1...).prefix(0).lazy.reductions(+), [])
|
||||
|
||||
XCTAssertEqualCollections([1, 2, 3, 4].lazy.reductions(+), [1, 3, 6, 10])
|
||||
XCTAssertEqualCollections([1].lazy.reductions(+), [1])
|
||||
XCTAssertEqualCollections(EmptyCollection<Int>().lazy.reductions(+), [])
|
||||
|
||||
XCTAssertLazySequence((1...).prefix(1).lazy.reductions(+))
|
||||
XCTAssertLazySequence([1].lazy.reductions(+))
|
||||
XCTAssertLazyCollection([1].lazy.reductions(+))
|
||||
}
|
||||
|
||||
func testInclusiveEager() {
|
||||
XCTAssertEqual([1, 2, 3, 4].reductions(+), [1, 3, 6, 10])
|
||||
XCTAssertEqual([1].reductions(+), [1])
|
||||
XCTAssertEqual(EmptyCollection<Int>().reductions(+), [])
|
||||
|
||||
XCTAssertNoThrow(try [].reductions { _, _ in throw TestError() })
|
||||
XCTAssertNoThrow(try [1].reductions { _, _ in throw TestError() })
|
||||
XCTAssertThrowsError(try [1, 1].reductions { _, _ in throw TestError() })
|
||||
}
|
||||
}
|
||||
@@ -10,9 +10,70 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
@testable import Algorithms
|
||||
|
||||
final class RotateTests: XCTestCase {
|
||||
/// Tests the example given in `_reverse(subrange:until:)`’s documentation
|
||||
func testUnderscoreReverse() {
|
||||
var input = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p"]
|
||||
let limit: Int = 4
|
||||
let (lower, upper) = input._reverse(subrange: input.startIndex..<input.endIndex, until: input.startIndex.advanced(by: limit))
|
||||
let expected = ["p", "o", "n", "m", "e", "f", "g", "h", "i", "j", "k", "l", "d", "c", "b", "a"]
|
||||
XCTAssertEqual(input, expected)
|
||||
XCTAssertEqual(lower, input.startIndex.advanced(by: limit))
|
||||
XCTAssertEqual(upper, input.endIndex.advanced(by: -limit))
|
||||
}
|
||||
|
||||
/// Tests the example given in `reverse(subrange:)`’s documentation
|
||||
func testReverse() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
numbers.reverse(subrange: 0..<4)
|
||||
XCTAssertEqual(numbers, [40, 30, 20, 10, 50, 60, 70, 80])
|
||||
}
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty subrange
|
||||
/// The order of elements are unchanged
|
||||
func testRotateEmptySubrange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 3..<3, toStartAt: 3)
|
||||
XCTAssertEqual(numbers, [10, 20, 30, 40, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 40)
|
||||
}
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with an empty collection
|
||||
func testRotateSubrangeOnEmptyCollection() {
|
||||
var numbers = [Int]()
|
||||
let oldStart = numbers.rotate(subrange: 0..<0, toStartAt: 0)
|
||||
XCTAssertEqual(numbers, [])
|
||||
XCTAssertEqual(oldStart, numbers.startIndex)
|
||||
}
|
||||
|
||||
/// Tests `rotate(subrange:toStartAt:)` with the full range of the collection
|
||||
func testRotateFullRange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 0..<8, toStartAt: 1)
|
||||
XCTAssertEqual(numbers, [20, 30, 40, 50, 60, 70, 80, 10])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
/// Tests the example given in `rotate(subrange:toStartAt:)`’s documentation
|
||||
func testRotateSubrange() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(subrange: 0..<4, toStartAt: 2)
|
||||
XCTAssertEqual(numbers, [30, 40, 10, 20, 50, 60, 70, 80])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
/// Tests the example given in `rotate(toStartAt:)`’s documentation
|
||||
func testRotateExample() {
|
||||
var numbers = [10, 20, 30, 40, 50, 60, 70, 80]
|
||||
let oldStart = numbers.rotate(toStartAt: 3)
|
||||
XCTAssertEqual(numbers, [40, 50, 60, 70, 80, 10, 20, 30])
|
||||
XCTAssertEqual(numbers[oldStart], 10)
|
||||
}
|
||||
|
||||
/// Tests `rotate(toStartAt:)` on collections of varying lengths, at different
|
||||
/// starting points
|
||||
func testRotate() {
|
||||
for length in 0...15 {
|
||||
let a = Array(0..<length)
|
||||
|
||||
@@ -0,0 +1,131 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class StridingTests: XCTestCase {
|
||||
|
||||
func testStride() {
|
||||
let a = 0...10
|
||||
XCTAssertEqualSequences(a.striding(by: 1), (0...10))
|
||||
XCTAssertEqualSequences(a.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 3), [0, 3, 6, 9])
|
||||
XCTAssertEqualSequences(a.striding(by: 4), [0, 4, 8])
|
||||
XCTAssertEqualSequences(a.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(a.striding(by: 11), [0])
|
||||
|
||||
let s = (0...).prefix(11)
|
||||
XCTAssertEqualSequences(s.striding(by: 1), (0...10))
|
||||
XCTAssertEqualSequences(s.striding(by: 2), [0, 2, 4, 6, 8, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 3), [0, 3, 6, 9])
|
||||
XCTAssertEqualSequences(s.striding(by: 4), [0, 4, 8])
|
||||
XCTAssertEqualSequences(s.striding(by: 5), [0, 5, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 10), [0, 10])
|
||||
XCTAssertEqualSequences(s.striding(by: 11), [0])
|
||||
|
||||
let empty = (0...).prefix(0)
|
||||
XCTAssertEqualSequences(empty.striding(by: 2), [])
|
||||
}
|
||||
|
||||
func testStrideString() {
|
||||
let s = "swift"
|
||||
XCTAssertEqualSequences(s.striding(by: 2), ["s", "i", "t"])
|
||||
}
|
||||
|
||||
func testStrideReversed() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
XCTAssertEqualSequences(a.striding(by: 3).reversed(), [3, 0])
|
||||
XCTAssertEqualSequences(a.reversed().striding(by: 2), [5, 3, 1])
|
||||
}
|
||||
|
||||
func testStrideIndexes() {
|
||||
let a = [0, 1, 2, 3, 4, 5].striding(by: 2)
|
||||
var i = a.startIndex
|
||||
XCTAssertEqual(a[i], 0)
|
||||
a.formIndex(after: &i)
|
||||
XCTAssertEqual(a[i], 2)
|
||||
a.formIndex(after: &i)
|
||||
XCTAssertEqual(a[i], 4)
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqual(a[i], 2)
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqual(a[i], 0)
|
||||
// a.formIndex(before: &i) // Precondition failed: Incrementing past start index
|
||||
// a.index(after: a.endIndex) // Precondition failed: Advancing past end index
|
||||
}
|
||||
|
||||
func testStrideLast() {
|
||||
XCTAssertEqual((1...10).striding(by: 2).last, 9) // 1, 3, 5, 7, 9
|
||||
XCTAssertEqual((1...10).striding(by: 3).last, 10) // 1, 4, 7, 10
|
||||
XCTAssertEqual((1...10).striding(by: 4).last, 9) // 1, 5, 9
|
||||
XCTAssertEqual((1...10).striding(by: 5).last, 6) // 1, 6
|
||||
XCTAssertEqual((1...100).striding(by: 50).last, 51) // 1, 51
|
||||
XCTAssertEqual((1...5).striding(by: 2).last, 5) // 1, 3, 5
|
||||
XCTAssertEqual([Int]().striding(by: 2).last, nil) // empty
|
||||
}
|
||||
|
||||
func testCount() {
|
||||
let empty = [Int]().striding(by: 2)
|
||||
XCTAssertEqual(empty.count, 0)
|
||||
let a = (0...10)
|
||||
XCTAssertEqual(a.striding(by: 1).count, (0...10).count)
|
||||
XCTAssertEqual(a.striding(by: 2).count, [0, 2, 4, 6, 8, 10].count)
|
||||
XCTAssertEqual(a.striding(by: 3).count, [0, 3, 6, 9].count)
|
||||
XCTAssertEqual(a.striding(by: 4).count, [0, 4, 8].count)
|
||||
XCTAssertEqual(a.striding(by: 5).count, [0, 5, 10].count)
|
||||
XCTAssertEqual(a.striding(by: 10).count, [0, 10].count)
|
||||
XCTAssertEqual(a.striding(by: 11).count, [0].count)
|
||||
}
|
||||
|
||||
func testIndexTraversals() {
|
||||
let empty = [Int]()
|
||||
validateIndexTraversals(
|
||||
empty.striding(by: 1),
|
||||
empty.striding(by: 2)
|
||||
)
|
||||
let zero_to_one_hundered_range = 0...100
|
||||
validateIndexTraversals(
|
||||
zero_to_one_hundered_range.striding(by: 10),
|
||||
zero_to_one_hundered_range.striding(by: 11),
|
||||
zero_to_one_hundered_range.striding(by: 101)
|
||||
)
|
||||
let zero_to_one_hundered_array = Array(zero_to_one_hundered_range)
|
||||
validateIndexTraversals(
|
||||
zero_to_one_hundered_array.striding(by: 10),
|
||||
zero_to_one_hundered_array.striding(by: 11),
|
||||
zero_to_one_hundered_array.striding(by: 101)
|
||||
)
|
||||
let string = "swift rocks".map(String.init)
|
||||
validateIndexTraversals(
|
||||
string.striding(by: 1),
|
||||
string.striding(by: 2),
|
||||
string.striding(by: 10)
|
||||
)
|
||||
}
|
||||
|
||||
|
||||
func testOffsetBy() {
|
||||
let a = (0...100).striding(by: 22)
|
||||
let b = [0, 22, 44, 66, 88]
|
||||
for i in 0..<a.count {
|
||||
XCTAssertEqual(a[a.index(a.startIndex, offsetBy: i)], b[i])
|
||||
}
|
||||
}
|
||||
|
||||
func testOffsetByEndIndex() {
|
||||
let a = 1...5
|
||||
let b = a.striding(by: 3) // [1, 4]
|
||||
let i = b.index(b.startIndex, offsetBy: 2)
|
||||
XCTAssertEqual(i, b.endIndex)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2021 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
final class SuffixTests: XCTestCase {
|
||||
func testSuffix() {
|
||||
let a = 0...10
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 5 }), (6...10))
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 10 }), [])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > 9 }), [10])
|
||||
XCTAssertEqualSequences(a.suffix(while: { $0 > -1 }), (0...10))
|
||||
|
||||
let empty: [Int] = []
|
||||
XCTAssertEqualSequences(empty.suffix(while: { $0 > 10 }), [])
|
||||
}
|
||||
|
||||
func testEndOfPrefix() {
|
||||
let array = Array(0..<10)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { $0 < 3 }), 3)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { _ in false }), array.startIndex)
|
||||
XCTAssertEqual(array.endOfPrefix(while: { _ in true }), array.endIndex)
|
||||
|
||||
let empty = [Int]()
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { $0 < 3 }), 0)
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { _ in false }), empty.startIndex)
|
||||
XCTAssertEqual(empty.endOfPrefix(while: { _ in true }), empty.endIndex)
|
||||
}
|
||||
|
||||
func testStartOfSuffix() {
|
||||
let array = Array(0..<10)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { $0 >= 3 }), 3)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { _ in false }), array.endIndex)
|
||||
XCTAssertEqual(array.startOfSuffix(while: { _ in true }), array.startIndex)
|
||||
|
||||
let empty = [Int]()
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { $0 < 3 }), 0)
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { _ in false }), empty.endIndex)
|
||||
XCTAssertEqual(empty.startOfSuffix(while: { _ in true }), empty.startIndex)
|
||||
}
|
||||
}
|
||||
@@ -46,13 +46,69 @@ struct SplitMix64: RandomNumberGenerator {
|
||||
}
|
||||
}
|
||||
|
||||
// An eraser helper to any mutable collection
|
||||
struct AnyMutableCollection<Base> where Base: MutableCollection {
|
||||
var base: Base
|
||||
}
|
||||
|
||||
extension AnyMutableCollection: MutableCollection {
|
||||
typealias Index = Base.Index
|
||||
typealias Element = Base.Element
|
||||
|
||||
var startIndex: Base.Index { base.startIndex }
|
||||
var endIndex: Base.Index { base.endIndex }
|
||||
|
||||
func index(after i: Index) -> Index {
|
||||
return base.index(after: i)
|
||||
}
|
||||
|
||||
subscript(position: Base.Index) -> Base.Element {
|
||||
_read { yield base[position] }
|
||||
set { base[position] = newValue }
|
||||
}
|
||||
}
|
||||
|
||||
extension MutableCollection {
|
||||
func eraseToAnyMutableCollection() -> AnyMutableCollection<Self> {
|
||||
AnyMutableCollection(base: self)
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ expression1: @autoclosure () throws -> S1,
|
||||
_ expression2: @autoclosure () throws -> S2,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
|
||||
try XCTAssert(expression1().elementsEqual(expression2()), message(), file: file, line: line)
|
||||
try XCTAssertEqualSequences(expression1(), expression2(), by: ==,
|
||||
message(), file: file, line: line)
|
||||
}
|
||||
|
||||
// Two sequences contains exactly the same element but not necessarily in the same order.
|
||||
func XCTAssertUnorderedEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ expression1: @autoclosure () throws -> S1,
|
||||
_ expression2: @autoclosure () throws -> S2,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) rethrows where S1.Element: Equatable, S1.Element == S2.Element {
|
||||
var s1 = Array(try expression1())
|
||||
var missing: [S1.Element] = []
|
||||
for elt in try expression2() {
|
||||
guard let idx = s1.firstIndex(of: elt) else {
|
||||
missing.append(elt)
|
||||
continue
|
||||
}
|
||||
s1.remove(at: idx)
|
||||
}
|
||||
|
||||
XCTAssertTrue(
|
||||
missing.isEmpty, "first sequence missing '\(missing)' elements from second sequence",
|
||||
file: file, line: line
|
||||
)
|
||||
|
||||
XCTAssertTrue(
|
||||
s1.isEmpty, "first sequence contains \(s1) missing from second sequence",
|
||||
file: file, line: line
|
||||
)
|
||||
}
|
||||
|
||||
func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
@@ -62,7 +118,237 @@ func XCTAssertEqualSequences<S1: Sequence, S2: Sequence>(
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) rethrows where S1.Element == S2.Element {
|
||||
try XCTAssert(expression1().elementsEqual(expression2(), by: areEquivalent), message(), file: file, line: line)
|
||||
|
||||
func fail(_ reason: String) {
|
||||
let message = message()
|
||||
XCTFail(message.isEmpty ? reason : "\(message) - \(reason)",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
var iter1 = try expression1().makeIterator()
|
||||
var iter2 = try expression2().makeIterator()
|
||||
var idx = 0
|
||||
while true {
|
||||
switch (iter1.next(), iter2.next()) {
|
||||
case let (e1?, e2?) where areEquivalent(e1, e2):
|
||||
idx += 1
|
||||
continue
|
||||
case let (e1?, e2?):
|
||||
fail("element \(e1) on first sequence does not match element \(e2) on second sequence at position \(idx)")
|
||||
case (_?, nil):
|
||||
fail("second sequence shorter than first")
|
||||
case (nil, _?):
|
||||
fail("first sequence shorter than second")
|
||||
case (nil, nil): break
|
||||
}
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
func XCTAssertLazy<S: LazySequenceProtocol>(_: S) {}
|
||||
func XCTAssertLazySequence<S: LazySequenceProtocol>(_: S) {}
|
||||
func XCTAssertLazyCollection<S: LazyCollectionProtocol>(_: S) {}
|
||||
|
||||
/// Asserts two collections are equal by using their indices to access elements.
|
||||
func XCTAssertEqualCollections<C1: Collection, C2: Collection>(
|
||||
_ expression1: @autoclosure () throws -> C1,
|
||||
_ expression2: @autoclosure () throws -> C2,
|
||||
_ message: @autoclosure () -> String = "",
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) rethrows where C1.Element: Equatable, C1.Element == C2.Element {
|
||||
let c1 = try expression1()
|
||||
let c2 = try expression2()
|
||||
XCTAssertEqual(c1.indices.count, c2.indices.count, message(), file: file, line: line)
|
||||
for index in zip(c1.indices, c2.indices) {
|
||||
XCTAssertEqual(c1[index.0], c2[index.1], message(), file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
/// Tests that all index traversal methods behave as expected.
|
||||
///
|
||||
/// Verifies the correctness of the implementations of `startIndex`, `endIndex`,
|
||||
/// `indices`, `count`, `isEmpty`, `index(before:)`, `index(after:)`,
|
||||
/// `index(_:offsetBy:)`, `index(_:offsetBy:limitedBy:)`, and
|
||||
/// `distance(from:to:)` by calling them with just about all possible input
|
||||
/// combinations. When provided, the `indices` function is used to to test the
|
||||
/// collection methods against.
|
||||
///
|
||||
/// - Parameters:
|
||||
/// - collections: The collections to be validated.
|
||||
/// - indices: A closure that returns the expected indices of the given
|
||||
/// collection, including its `endIndex`, in ascending order. Only use this
|
||||
/// parameter if you are able to compute the indices of the collection
|
||||
/// independently of the `Collection` conformance, e.g. by using the
|
||||
/// contents of the collection directly.
|
||||
///
|
||||
/// - Complexity: O(*n*^3) for each collection, where *n* is the length of the
|
||||
/// collection.
|
||||
func validateIndexTraversals<C>(
|
||||
_ collections: C...,
|
||||
indices: ((C) -> [C.Index])? = nil,
|
||||
file: StaticString = #file, line: UInt = #line
|
||||
) where C: BidirectionalCollection {
|
||||
for c in collections {
|
||||
let indicesIncludingEnd = indices?(c) ?? (c.indices + [c.endIndex])
|
||||
let count = indicesIncludingEnd.count - 1
|
||||
|
||||
XCTAssertEqual(
|
||||
c.count, count,
|
||||
"Count mismatch",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c.isEmpty, count == 0,
|
||||
"Emptiness mismatch",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c.startIndex, indicesIncludingEnd.first,
|
||||
"`startIndex` does not equal the first index",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c.endIndex, indicesIncludingEnd.last,
|
||||
"`endIndex` does not equal the last index",
|
||||
file: file, line: line)
|
||||
|
||||
// `index(after:)`
|
||||
do {
|
||||
var index = c.startIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropFirst() {
|
||||
c.formIndex(after: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`startIndex` incremented \(offset) times does not equal index at \
|
||||
offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
// `index(before:)`
|
||||
do {
|
||||
var index = c.endIndex
|
||||
|
||||
for (offset, expected) in indicesIncludingEnd.enumerated().dropLast().reversed() {
|
||||
c.formIndex(before: &index)
|
||||
XCTAssertEqual(
|
||||
index, expected,
|
||||
"""
|
||||
`endIndex` decremented \(count - offset) times does not equal index \
|
||||
at offset \(offset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
// `indices`
|
||||
XCTAssertEqual(c.indices.count, count)
|
||||
for (offset, index) in c.indices.enumerated() {
|
||||
XCTAssertEqual(
|
||||
index, indicesIncludingEnd[offset],
|
||||
"Index mismatch at offset \(offset) in `indices`",
|
||||
file: file, line: line)
|
||||
}
|
||||
|
||||
// index comparison
|
||||
for (offsetA, a) in indicesIncludingEnd.enumerated() {
|
||||
XCTAssertEqual(
|
||||
a, a,
|
||||
"Index at offset \(offsetA) does not equal itself",
|
||||
file: file, line: line)
|
||||
XCTAssertFalse(
|
||||
a < a,
|
||||
"Index at offset \(offsetA) is less than itself",
|
||||
file: file, line: line)
|
||||
|
||||
for (offsetB, b) in indicesIncludingEnd[..<offsetA].enumerated() {
|
||||
XCTAssertNotEqual(
|
||||
a, b,
|
||||
"Index at offset \(offsetA) equals index at offset \(offsetB)",
|
||||
file: file, line: line)
|
||||
XCTAssertLessThan(
|
||||
b, a,
|
||||
"""
|
||||
Index at offset \(offsetB) is not less than index at offset \(offsetA)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
// `index(_:offsetBy:)` and `distance(from:to:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (endOffset, end) in indicesIncludingEnd.enumerated() {
|
||||
let distance = endOffset - startOffset
|
||||
|
||||
XCTAssertEqual(
|
||||
c.index(start, offsetBy: distance), end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) does not equal \
|
||||
index at offset \(endOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
XCTAssertEqual(
|
||||
c.distance(from: start, to: end), distance,
|
||||
"""
|
||||
Distance from index at offset \(startOffset) to index at offset \
|
||||
\(endOffset) does not equal \(distance)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
|
||||
// `index(_:offsetBy:limitedBy:)`
|
||||
for (startOffset, start) in indicesIncludingEnd.enumerated() {
|
||||
for (limitOffset, limit) in indicesIncludingEnd.enumerated() {
|
||||
// verifies that the target index corresponding to each offset in
|
||||
// `range` can or cannot be reached from `start` using
|
||||
// `chain.index(start, offsetBy: _, limitedBy: limit)`, depending on the
|
||||
// value of `pastLimit`
|
||||
func checkTargetRange(_ range: ClosedRange<Int>, pastLimit: Bool) {
|
||||
for targetOffset in range {
|
||||
let distance = targetOffset - startOffset
|
||||
let end = c.index(start, offsetBy: distance, limitedBy: limit)
|
||||
|
||||
if pastLimit {
|
||||
XCTAssertNil(
|
||||
end,
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) limited \
|
||||
by index at offset \(limitOffset) does not equal `nil`
|
||||
""",
|
||||
file: file, line: line)
|
||||
} else {
|
||||
XCTAssertEqual(
|
||||
end, indicesIncludingEnd[targetOffset],
|
||||
"""
|
||||
Index at offset \(startOffset) offset by \(distance) limited \
|
||||
by index at offset \(limitOffset) does not equal index at \
|
||||
offset \(targetOffset)
|
||||
""",
|
||||
file: file, line: line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// forward offsets
|
||||
if limit >= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(startOffset...limitOffset, pastLimit: false)
|
||||
checkTargetRange((limitOffset + 1)...(count + 1), pastLimit: true)
|
||||
} else {
|
||||
// the limit has no effect
|
||||
checkTargetRange(startOffset...count, pastLimit: false)
|
||||
}
|
||||
|
||||
// backward offsets
|
||||
if limit <= start {
|
||||
// the limit has an effect
|
||||
checkTargetRange(limitOffset...startOffset, pastLimit: false)
|
||||
checkTargetRange(-1...(limitOffset - 1), pastLimit: true)
|
||||
} else {
|
||||
// the limit has no effect
|
||||
checkTargetRange(0...startOffset, pastLimit: false)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,59 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import Algorithms
|
||||
import XCTest
|
||||
|
||||
final class TrimTests: XCTestCase {
|
||||
|
||||
func testEmpty() {
|
||||
let results_empty = ([] as [Int]).trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_empty, [])
|
||||
}
|
||||
|
||||
func testNoMatch() {
|
||||
// No match (nothing trimmed).
|
||||
let results_nomatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming {
|
||||
$0.isMultiple(of: 2)
|
||||
}
|
||||
XCTAssertEqual(results_nomatch, [1, 3, 5, 7, 9, 11, 13, 15])
|
||||
}
|
||||
|
||||
func testNoTailMatch() {
|
||||
// No tail match (only trim head).
|
||||
let results_notailmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 < 10 }
|
||||
XCTAssertEqual(results_notailmatch, [11, 13, 15])
|
||||
}
|
||||
|
||||
func testNoHeadMatch() {
|
||||
// No head match (only trim tail).
|
||||
let results_noheadmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { $0 > 10 }
|
||||
XCTAssertEqual(results_noheadmatch, [1, 3, 5, 7, 9])
|
||||
}
|
||||
|
||||
func testBothEndsMatch() {
|
||||
// Both ends match, some string of >1 elements do not (return that string).
|
||||
let results = [2, 10, 11, 15, 20, 21, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results, [11, 15, 20, 21])
|
||||
}
|
||||
|
||||
func testEverythingMatches() {
|
||||
// Everything matches (trim everything).
|
||||
let results_allmatch = [1, 3, 5, 7, 9, 11, 13, 15].trimming { _ in true }
|
||||
XCTAssertEqual(results_allmatch, [])
|
||||
}
|
||||
|
||||
func testEverythingButOneMatches() {
|
||||
// Both ends match, one element does not (trim all except that element).
|
||||
let results_one = [2, 10, 12, 15, 20, 100].trimming { $0.isMultiple(of: 2) }
|
||||
XCTAssertEqual(results_one, [15])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,122 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
import Algorithms
|
||||
|
||||
final class UniquePermutationsTests: XCTestCase {
|
||||
static let numbers = [1, 1, 1, 2, 3]
|
||||
|
||||
static let numbersPermutations: [[[Int]]] = [
|
||||
// k = 0
|
||||
[[]],
|
||||
// 1
|
||||
[[1], [2], [3]],
|
||||
// 2
|
||||
[[1, 1], [1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]],
|
||||
// 3
|
||||
[[1, 1, 1], [1, 1, 2], [1, 1, 3],
|
||||
[1, 2, 1], [1, 2, 3], [1, 3, 1], [1, 3, 2],
|
||||
[2, 1, 1], [2, 1, 3], [2, 3, 1],
|
||||
[3, 1, 1], [3, 1, 2], [3, 2, 1]],
|
||||
// 4
|
||||
[[1, 1, 1, 2], [1, 1, 1, 3],
|
||||
[1, 1, 2, 1], [1, 1, 2, 3],
|
||||
[1, 1, 3, 1], [1, 1, 3, 2],
|
||||
[1, 2, 1, 1], [1, 2, 1, 3], [1, 2, 3, 1],
|
||||
[1, 3, 1, 1], [1, 3, 1, 2], [1, 3, 2, 1],
|
||||
[2, 1, 1, 1], [2, 1, 1, 3], [2, 1, 3, 1], [2, 3, 1, 1],
|
||||
[3, 1, 1, 1], [3, 1, 1, 2], [3, 1, 2, 1], [3, 2, 1, 1]],
|
||||
// 5
|
||||
[[1, 1, 1, 2, 3], [1, 1, 1, 3, 2],
|
||||
[1, 1, 2, 1, 3], [1, 1, 2, 3, 1],
|
||||
[1, 1, 3, 1, 2], [1, 1, 3, 2, 1],
|
||||
[1, 2, 1, 1, 3], [1, 2, 1, 3, 1], [1, 2, 3, 1, 1],
|
||||
[1, 3, 1, 1, 2], [1, 3, 1, 2, 1], [1, 3, 2, 1, 1],
|
||||
[2, 1, 1, 1, 3], [2, 1, 1, 3, 1], [2, 1, 3, 1, 1], [2, 3, 1, 1, 1],
|
||||
[3, 1, 1, 1, 2], [3, 1, 1, 2, 1], [3, 1, 2, 1, 1], [3, 2, 1, 1, 1]]
|
||||
]
|
||||
}
|
||||
|
||||
extension UniquePermutationsTests {
|
||||
func testEmpty() {
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(), [[]])
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 0), [[]])
|
||||
XCTAssertEqualSequences(([] as [Int]).uniquePermutations(ofCount: 1), [])
|
||||
XCTAssertEqualSequences(
|
||||
([] as [Int]).uniquePermutations(ofCount: 1...3), [])
|
||||
}
|
||||
|
||||
func testSingleCounts() {
|
||||
for (k, expectation) in Self.numbersPermutations.enumerated() {
|
||||
XCTAssertEqualSequences(
|
||||
expectation,
|
||||
Self.numbers.uniquePermutations(ofCount: k))
|
||||
}
|
||||
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[5],
|
||||
Self.numbers.uniquePermutations())
|
||||
}
|
||||
|
||||
func testRanges() {
|
||||
for lower in Self.numbersPermutations.indices {
|
||||
// upper bounded
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[...lower].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: ...lower))
|
||||
|
||||
// lower bounded
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[lower...].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: lower...))
|
||||
|
||||
for upper in lower..<Self.numbersPermutations.count {
|
||||
XCTAssertEqualSequences(
|
||||
Self.numbersPermutations[lower..<upper].joined(),
|
||||
Self.numbers.uniquePermutations(ofCount: lower..<upper))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
extension UniquePermutationsTests {
|
||||
private final class IntBox: Hashable {
|
||||
var value: Int
|
||||
|
||||
init(_ value: Int) {
|
||||
self.value = value
|
||||
}
|
||||
|
||||
static func == (lhs: IntBox, rhs: IntBox) -> Bool {
|
||||
lhs.value == rhs.value
|
||||
}
|
||||
|
||||
func hash(into hasher: inout Hasher) {
|
||||
hasher.combine(value)
|
||||
}
|
||||
}
|
||||
|
||||
func testFirstUnique() {
|
||||
// When duplicate elements are encountered, all permutations use the first
|
||||
// instance of the duplicated elements.
|
||||
let numbers = Self.numbers.map(IntBox.init)
|
||||
for k in 0...numbers.count {
|
||||
for p in numbers.uniquePermutations(ofCount: k) {
|
||||
XCTAssertTrue(p.filter { $0.value == 1 }.allSatisfy { $0 === numbers[0] })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func testLaziness() {
|
||||
XCTAssertLazySequence("ABCD".lazy.uniquePermutations())
|
||||
}
|
||||
}
|
||||
@@ -17,10 +17,13 @@ final class UniqueTests: XCTestCase {
|
||||
let a = repeatElement(1...10, count: 15).joined().shuffled()
|
||||
let b = a.uniqued()
|
||||
XCTAssertEqual(b.sorted(), Set(a).sorted())
|
||||
XCTAssertEqual(10, b.count)
|
||||
XCTAssertEqual(10, Array(b).count)
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqual(c.uniqued(), [])
|
||||
XCTAssertEqualSequences(c.uniqued(), [])
|
||||
|
||||
let d = Array(repeating: 1, count: 10)
|
||||
XCTAssertEqualSequences(d.uniqued(), [1])
|
||||
}
|
||||
|
||||
func testUniqueOn() {
|
||||
@@ -30,5 +33,21 @@ final class UniqueTests: XCTestCase {
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqual(c.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
let d = Array(repeating: "Andromeda", count: 10)
|
||||
XCTAssertEqualSequences(d.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
|
||||
func testLazyUniqueOn() {
|
||||
let a = ["Albemarle", "Abeforth", "Astrology", "Brandywine", "Beatrice", "Axiom"]
|
||||
let b = a.lazy.uniqued(on: { $0.first })
|
||||
XCTAssertEqualSequences(b, ["Albemarle", "Brandywine"])
|
||||
XCTAssertLazySequence(b)
|
||||
|
||||
let c: [Int] = []
|
||||
XCTAssertEqualSequences(c.lazy.uniqued(on: { $0.bitWidth }), [])
|
||||
|
||||
let d = Array(repeating: "Andromeda", count: 10)
|
||||
XCTAssertEqualSequences(d.lazy.uniqued(on: { $0.first }), ["Andromeda"])
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
//===----------------------------------------------------------------------===//
|
||||
//
|
||||
// This source file is part of the Swift Algorithms open source project
|
||||
//
|
||||
// Copyright (c) 2020 Apple Inc. and the Swift project authors
|
||||
// Licensed under Apache License v2.0 with Runtime Library Exception
|
||||
//
|
||||
// See https://swift.org/LICENSE.txt for license information
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
import XCTest
|
||||
@testable import Algorithms
|
||||
|
||||
final class windowsTests: XCTestCase {
|
||||
|
||||
func testWindowsOfString() {
|
||||
let s = "swift"
|
||||
let w = s.windows(ofCount: 2)
|
||||
var i = w.startIndex
|
||||
|
||||
XCTAssertEqualSequences(w[i], "sw")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "wi")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "if")
|
||||
w.formIndex(after: &i)
|
||||
XCTAssertEqualSequences(w[i], "ft")
|
||||
|
||||
// w.index(after: w.endIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.index(before: w.startIndex) // ← Precondition failed: windows index is out of range
|
||||
// w.formIndex(after: &i); w[i] // ← Precondition failed: windows index is out of range
|
||||
}
|
||||
|
||||
func testWindowsOfRange() {
|
||||
let a = 0...100
|
||||
|
||||
XCTAssertTrue(a.windows(ofCount: 200).isEmpty)
|
||||
|
||||
let w = a.windows(ofCount: 10)
|
||||
|
||||
XCTAssertEqualSequences(w.first!, 0..<10)
|
||||
XCTAssertEqualSequences(w.last!, 91..<101)
|
||||
}
|
||||
|
||||
func testWindowsOfInt() {
|
||||
let a = [ 0, 1, 0, 1 ].windows(ofCount: 2)
|
||||
|
||||
XCTAssertEqual(a.count, 3)
|
||||
XCTAssertEqual(a.map { $0.reduce(0, +) }, [1, 1, 1])
|
||||
|
||||
let a2 = [0, 1, 2, 3, 4, 5, 6].windows(ofCount: 3).map {
|
||||
$0.reduce(0, +)
|
||||
}.reduce(0, +)
|
||||
|
||||
XCTAssertEqual(a2, 3 + 6 + 9 + 12 + 15)
|
||||
}
|
||||
|
||||
func testWindowsCount() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
XCTAssertEqual(a.windows(ofCount: 3).count, 4)
|
||||
|
||||
let a2 = [0, 1, 2, 3, 4]
|
||||
XCTAssertEqual(a2.windows(ofCount: 6).count, 0)
|
||||
|
||||
let a3 = [Int]()
|
||||
XCTAssertEqual(a3.windows(ofCount: 2).count, 0)
|
||||
}
|
||||
|
||||
func testWindowsSecondAndLast() {
|
||||
let a = [0, 1, 2, 3, 4, 5]
|
||||
let w = a.windows(ofCount: 4)
|
||||
let snd = w[w.index(after: w.startIndex)]
|
||||
XCTAssertEqualSequences(snd, [1, 2, 3, 4])
|
||||
|
||||
let w2 = a.windows(ofCount: 3)
|
||||
XCTAssertEqualSequences(w2.last!, [3, 4, 5])
|
||||
}
|
||||
|
||||
func testWindowsIndexAfterAndBefore() {
|
||||
let a = [0, 1, 2, 3, 4, 5].windows(ofCount: 2)
|
||||
var i = a.startIndex
|
||||
a.formIndex(after: &i)
|
||||
a.formIndex(after: &i)
|
||||
a.formIndex(before: &i)
|
||||
XCTAssertEqualSequences(a[i], [1, 2])
|
||||
}
|
||||
|
||||
func testWindowsIndexTraversals() {
|
||||
validateIndexTraversals(
|
||||
"".windows(ofCount: 1),
|
||||
"a".windows(ofCount: 1),
|
||||
"ab".windows(ofCount: 1),
|
||||
"abc".windows(ofCount: 1),
|
||||
"".windows(ofCount: 3),
|
||||
"a".windows(ofCount: 3),
|
||||
"abc".windows(ofCount: 3),
|
||||
"abcdefgh".windows(ofCount: 3),
|
||||
indices: { windows in
|
||||
let endIndex = windows.base.endIndex
|
||||
let indices = windows.base.indices + [endIndex]
|
||||
return zip(indices, indices.dropFirst(windows.size))
|
||||
.map { .init(lowerBound: $0, upperBound: $1) }
|
||||
+ [.init(lowerBound: endIndex, upperBound: endIndex)]
|
||||
})
|
||||
}
|
||||
|
||||
func testWindowsLazy() {
|
||||
XCTAssertLazyCollection([0, 1, 2, 3].lazy.windows(ofCount: 2))
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user