├── .gitignore ├── LICENSE ├── Package.swift ├── README.md ├── Sources └── AtCoderSupport │ ├── Array2D.swift │ ├── Array3D.swift │ ├── ArrayND.swift │ ├── BFS.swift │ ├── BellmanFord.swift │ ├── BinarySearch.swift │ ├── Combinations.swift │ ├── DFS.swift │ ├── Deque.swift │ ├── Dijkstra.swift │ ├── Divisors.swift │ ├── GCD.swift │ ├── Input.swift │ ├── IsPrime.swift │ ├── ModInt.swift │ ├── ModOperators.swift │ ├── NCR.swift │ ├── Permutations.swift │ ├── Pow.swift │ ├── Primes.swift │ ├── PriorityQueue.swift │ ├── RangeSum.swift │ ├── SafeOverflow.swift │ ├── SafeRange.swift │ ├── TSP.swift │ ├── UnionFind.swift │ ├── Vectors.swift │ └── WarshallFloyd.swift └── Tests ├── AtCoderSupportTests ├── Array2DTests.swift ├── Array3DTests.swift ├── ArrayNDTests.swift ├── AtCoderSupportTests.swift ├── BFSTests.swift ├── BellmanFordTests.swift ├── BinarySearchTests.swift ├── CombinationsTests.swift ├── DFSTests.swift ├── DequeTests.swift ├── DijkstraTests.swift ├── DivisorsTests.swift ├── GCDTests.swift ├── InputTests.swift ├── IsPrimeTests.swift ├── ModIntTests.swift ├── ModOperatorsTests.swift ├── NCRTests.swift ├── PermutationsTests.swift ├── PowTests.swift ├── PrimesTests.swift ├── PriorityQueueTests.swift ├── RangeSumTests.swift ├── SafeOverflowTests.swift ├── SafeRangeTests.swift ├── TSPTests.swift ├── UnionFindTests.swift ├── VectorsTests.swift ├── WarshallFloydTests.swift └── XCTestManifests.swift ├── Input └── LinuxMain.swift /.gitignore: -------------------------------------------------------------------------------- 1 | .DS_Store 2 | /.build 3 | /Packages 4 | /*.xcodeproj 5 | xcuserdata/ 6 | /.swiftpm 7 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Creative Commons Legal Code 2 | 3 | CC0 1.0 Universal 4 | 5 | CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE 6 | LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN 7 | ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS 8 | INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES 9 | REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS 10 | PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM 11 | THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED 12 | HEREUNDER. 13 | 14 | Statement of Purpose 15 | 16 | The laws of most jurisdictions throughout the world automatically confer 17 | exclusive Copyright and Related Rights (defined below) upon the creator 18 | and subsequent owner(s) (each and all, an "owner") of an original work of 19 | authorship and/or a database (each, a "Work"). 20 | 21 | Certain owners wish to permanently relinquish those rights to a Work for 22 | the purpose of contributing to a commons of creative, cultural and 23 | scientific works ("Commons") that the public can reliably and without fear 24 | of later claims of infringement build upon, modify, incorporate in other 25 | works, reuse and redistribute as freely as possible in any form whatsoever 26 | and for any purposes, including without limitation commercial purposes. 27 | These owners may contribute to the Commons to promote the ideal of a free 28 | culture and the further production of creative, cultural and scientific 29 | works, or to gain reputation or greater distribution for their Work in 30 | part through the use and efforts of others. 31 | 32 | For these and/or other purposes and motivations, and without any 33 | expectation of additional consideration or compensation, the person 34 | associating CC0 with a Work (the "Affirmer"), to the extent that he or she 35 | is an owner of Copyright and Related Rights in the Work, voluntarily 36 | elects to apply CC0 to the Work and publicly distribute the Work under its 37 | terms, with knowledge of his or her Copyright and Related Rights in the 38 | Work and the meaning and intended legal effect of CC0 on those rights. 39 | 40 | 1. Copyright and Related Rights. A Work made available under CC0 may be 41 | protected by copyright and related or neighboring rights ("Copyright and 42 | Related Rights"). Copyright and Related Rights include, but are not 43 | limited to, the following: 44 | 45 | i. the right to reproduce, adapt, distribute, perform, display, 46 | communicate, and translate a Work; 47 | ii. moral rights retained by the original author(s) and/or performer(s); 48 | iii. publicity and privacy rights pertaining to a person's image or 49 | likeness depicted in a Work; 50 | iv. rights protecting against unfair competition in regards to a Work, 51 | subject to the limitations in paragraph 4(a), below; 52 | v. rights protecting the extraction, dissemination, use and reuse of data 53 | in a Work; 54 | vi. database rights (such as those arising under Directive 96/9/EC of the 55 | European Parliament and of the Council of 11 March 1996 on the legal 56 | protection of databases, and under any national implementation 57 | thereof, including any amended or successor version of such 58 | directive); and 59 | vii. other similar, equivalent or corresponding rights throughout the 60 | world based on applicable law or treaty, and any national 61 | implementations thereof. 62 | 63 | 2. Waiver. To the greatest extent permitted by, but not in contravention 64 | of, applicable law, Affirmer hereby overtly, fully, permanently, 65 | irrevocably and unconditionally waives, abandons, and surrenders all of 66 | Affirmer's Copyright and Related Rights and associated claims and causes 67 | of action, whether now known or unknown (including existing as well as 68 | future claims and causes of action), in the Work (i) in all territories 69 | worldwide, (ii) for the maximum duration provided by applicable law or 70 | treaty (including future time extensions), (iii) in any current or future 71 | medium and for any number of copies, and (iv) for any purpose whatsoever, 72 | including without limitation commercial, advertising or promotional 73 | purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each 74 | member of the public at large and to the detriment of Affirmer's heirs and 75 | successors, fully intending that such Waiver shall not be subject to 76 | revocation, rescission, cancellation, termination, or any other legal or 77 | equitable action to disrupt the quiet enjoyment of the Work by the public 78 | as contemplated by Affirmer's express Statement of Purpose. 79 | 80 | 3. Public License Fallback. Should any part of the Waiver for any reason 81 | be judged legally invalid or ineffective under applicable law, then the 82 | Waiver shall be preserved to the maximum extent permitted taking into 83 | account Affirmer's express Statement of Purpose. In addition, to the 84 | extent the Waiver is so judged Affirmer hereby grants to each affected 85 | person a royalty-free, non transferable, non sublicensable, non exclusive, 86 | irrevocable and unconditional license to exercise Affirmer's Copyright and 87 | Related Rights in the Work (i) in all territories worldwide, (ii) for the 88 | maximum duration provided by applicable law or treaty (including future 89 | time extensions), (iii) in any current or future medium and for any number 90 | of copies, and (iv) for any purpose whatsoever, including without 91 | limitation commercial, advertising or promotional purposes (the 92 | "License"). The License shall be deemed effective as of the date CC0 was 93 | applied by Affirmer to the Work. Should any part of the License for any 94 | reason be judged legally invalid or ineffective under applicable law, such 95 | partial invalidity or ineffectiveness shall not invalidate the remainder 96 | of the License, and in such case Affirmer hereby affirms that he or she 97 | will not (i) exercise any of his or her remaining Copyright and Related 98 | Rights in the Work or (ii) assert any associated claims and causes of 99 | action with respect to the Work, in either case contrary to Affirmer's 100 | express Statement of Purpose. 101 | 102 | 4. Limitations and Disclaimers. 103 | 104 | a. No trademark or patent rights held by Affirmer are waived, abandoned, 105 | surrendered, licensed or otherwise affected by this document. 106 | b. Affirmer offers the Work as-is and makes no representations or 107 | warranties of any kind concerning the Work, express, implied, 108 | statutory or otherwise, including without limitation warranties of 109 | title, merchantability, fitness for a particular purpose, non 110 | infringement, or the absence of latent or other defects, accuracy, or 111 | the present or absence of errors, whether or not discoverable, all to 112 | the greatest extent permissible under applicable law. 113 | c. Affirmer disclaims responsibility for clearing rights of other persons 114 | that may apply to the Work or any use thereof, including without 115 | limitation any person's Copyright and Related Rights in the Work. 116 | Further, Affirmer disclaims responsibility for obtaining any necessary 117 | consents, permissions or other rights required for any use of the 118 | Work. 119 | d. Affirmer understands and acknowledges that Creative Commons is not a 120 | party to this document and has no duty or obligation with respect to 121 | this CC0 or use of the Work. 122 | -------------------------------------------------------------------------------- /Package.swift: -------------------------------------------------------------------------------- 1 | // swift-tools-version:5.3 2 | // The swift-tools-version declares the minimum version of Swift required to build this package. 3 | 4 | import PackageDescription 5 | 6 | let package = Package( 7 | name: "AtCoderSupport", 8 | products: [ 9 | // Products define the executables and libraries a package produces, and make them visible to other packages. 10 | .library( 11 | name: "AtCoderSupport", 12 | targets: ["AtCoderSupport"]), 13 | ], 14 | dependencies: [ 15 | // Dependencies declare other packages that this package depends on. 16 | // .package(url: /* package url */, from: "1.0.0"), 17 | ], 18 | targets: [ 19 | // Targets are the basic building blocks of a package. A target can define a module or a test suite. 20 | // Targets can depend on other targets in this package, and on products in packages this package depends on. 21 | .target( 22 | name: "AtCoderSupport", 23 | dependencies: []), 24 | .testTarget( 25 | name: "AtCoderSupportTests", 26 | dependencies: ["AtCoderSupport"]), 27 | ] 28 | ) 29 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # AtCoderSupport 2 | 3 | Swift で AtCoder に取り組むためのサポートライブラリです。標準ライブラリや Foundation に不足しているアルゴリズムやデータ構造等が実装されています。 4 | 5 | Swift Package 形式になっていますが、 AtCoder で利用する際には必要なものをコピペして利用して下さい。 Swift Package を採用しているのはテストの実行が容易なためです。 6 | 7 | コピペを前提としているため、すべての API は `public` でなく無印の `internal` として実装されています。また、本パッケージ内も含めて極力他の API に依存なく、関数や `extension` 単体でコピペできるようにしています。 8 | 9 | ## 利用例 10 | 11 | | アルゴリズム・データ構造 | API | 利用例 | 12 | |:--|:--|:--| 13 | | 二次元配列 | `Array2D` | [ABC 182 E - Akari](https://atcoder.jp/contests/abc182/submissions/17978677) | 14 | | 三次元配列 | `Array3D` | [ABC 184 D - increment of coins](https://atcoder.jp/contests/abc184/submissions/18377096) | 15 | | N次元配列 | `ArrayND` | [ABC 184 D - increment of coins](https://atcoder.jp/contests/abc184/submissions/18377137) | 16 | | 順列 | `permutations()` | [ABC 145 C - Average Length](https://atcoder.jp/contests/abc145/submissions/17547859) | 17 | | nCr | `NCR` | [ABC 151 E - Max-Min Sums](https://atcoder.jp/contests/abc151/submissions/17937622) | 18 | | 二分探索 | `values(_:_:)` | [ABC 077 C - Snuke Festival](https://atcoder.jp/contests/abc077/submissions/17547635) | 19 | | 深さ優先探索 | `dfs(edges:startedAt:_:)` | [ABC 138 D - Ki](https://atcoder.jp/contests/abc138/submissions/17661705) | 20 | | 幅優先探索 | `bfs(edges:startedAt:,_:)` | [ABC 190 E - Magical Ornament](https://atcoder.jp/contests/abc190/submissions/24337525) | 21 | | 素数判定 | `isPrime` | [ABC 149 C - Next Prime](https://atcoder.jp/contests/abc149/submissions/17548101) | 22 | | ベルマン–フォード法 | `bellmanFord(graph:startedAt)` | [ABC 061 D - Score Attack](https://atcoder.jp/contests/abc061/submissions/18111027) | 23 | | ダイクストラ法 | `dijkstra(graph:startedAt:)` | [ABC 035 D - トレジャーハント](https://atcoder.jp/contests/abc035/submissions/17662367) | 24 | | ワーシャル–フロイド法 | `warshallFloyd(graph:)` | [ABC 143 E - Travel by Car](https://atcoder.jp/contests/abc143/submissions/18082582) | 25 | | 巡回セールスマン問題 | `tsp(distances:startedAt:)` | [ABC 180 E - Traveling Salesman among Aerial Cities](https://atcoder.jp/contests/abc180/submissions/17561600) | 26 | | Union-Find | `UnionFind` | [ARC 032 B - 道路工事](https://atcoder.jp/contests/arc032/submissions/17591100) | 27 | | mod | `ModInt` | [ARC 107 A - Simple Math](https://atcoder.jp/contests/arc107/submissions/17766344) | 28 | | mod | `%+`, `%*`, `%+=` 等 | [ABC 151 E - Max-Min Sums](https://atcoder.jp/contests/abc151/submissions/17937622) | 29 | | 範囲の和 | `ClosedRange.sum(modulus:)` | [ARC 107 A - Simple Math](https://atcoder.jp/contests/arc107/submissions/17766344) | 30 | | 安全な範囲演算子 | `.. Void) { 56 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 57 | // 省略 58 | } 59 | 60 | dfs(edges: [[1, 2], [], []], startedAt: -1) { _ in } 61 | ``` 62 | 63 | ``` 64 | $ swift main.swift 65 | Precondition failed: `start` index is out of bounds: -1 66 | ``` 67 | 68 | ## License 69 | 70 | CC0 71 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Array2D.swift: -------------------------------------------------------------------------------- 1 | struct Array2D: Sequence, CustomStringConvertible { 2 | let width: Int 3 | let height: Int 4 | private(set) var elements: [Element] 5 | let outside: Element? 6 | init(width: Int, height: Int, elements: [Element], outside: Element? = nil) { 7 | precondition(elements.count == width * height) 8 | self.width = width 9 | self.height = height 10 | self.elements = elements 11 | self.outside = outside 12 | } 13 | init(width: Int, height: Int, element: Element, outside: Element? = nil) { 14 | self.init(width: width, height: height, elements: [Element](repeating: element, count: width * height), outside: outside) 15 | } 16 | var count: Int { elements.count } 17 | var xRange: Range { 0 ..< width } 18 | var yRange: Range { 0 ..< height } 19 | private func indexAt(x: Int, y: Int) -> Int? { 20 | guard xRange.contains(x) else { return nil } 21 | guard yRange.contains(y) else { return nil } 22 | return y * width + x 23 | } 24 | subscript(x: Int, y: Int) -> Element { 25 | get { 26 | guard let i = indexAt(x: x, y: y) else { return outside! } 27 | return elements[i] 28 | } 29 | set { 30 | guard let i = indexAt(x: x, y: y) else { 31 | precondition(outside != nil) 32 | return 33 | } 34 | elements[i] = newValue 35 | } 36 | } 37 | subscript(position: (Int, Int)) -> Element { 38 | get { self[position.0, position.1] } 39 | set { self[position.0, position.1] = newValue } 40 | } 41 | func makeIterator() -> IndexingIterator<[Element]> { 42 | elements.makeIterator() 43 | } 44 | func map(_ transform: (Element) throws -> T) rethrows -> Array2D { 45 | try Array2D(width: width, height: height, elements: elements.map(transform)) 46 | } 47 | var description: String { 48 | var result: String = "" 49 | for y in yRange { 50 | for x in xRange { 51 | if x > 0 { 52 | result.append(" ") 53 | } 54 | result.append("\(self[x, y])") 55 | } 56 | result.append("\n") 57 | } 58 | return result 59 | } 60 | } 61 | extension Array2D where Element: CustomStringConvertible { 62 | var description: String { 63 | var result: String = "" 64 | for y in yRange { 65 | for x in xRange { 66 | if x > 0 { 67 | result.append(" ") 68 | } 69 | result.append(self[x, y].description) 70 | } 71 | result.append("\n") 72 | } 73 | return result 74 | } 75 | } 76 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Array3D.swift: -------------------------------------------------------------------------------- 1 | struct Array3D: Sequence, CustomStringConvertible { 2 | let width: Int 3 | let height: Int 4 | let depth: Int 5 | private(set) var elements: [Element] 6 | let outside: Element? 7 | init(width: Int, height: Int, depth: Int, elements: [Element], outside: Element? = nil) { 8 | precondition(elements.count == width * height * depth) 9 | self.width = width 10 | self.height = height 11 | self.depth = depth 12 | self.elements = elements 13 | self.outside = outside 14 | } 15 | init(width: Int, height: Int, depth: Int, element: Element, outside: Element? = nil) { 16 | self.init(width: width, height: height, depth: depth, elements: [Element](repeating: element, count: width * height * depth), outside: outside) 17 | } 18 | var count: Int { elements.count } 19 | var xRange: Range { 0 ..< width } 20 | var yRange: Range { 0 ..< height } 21 | var zRange: Range { 0 ..< depth } 22 | private func indexAt(x: Int, y: Int, z: Int) -> Int? { 23 | guard xRange.contains(x) else { return nil } 24 | guard yRange.contains(y) else { return nil } 25 | guard zRange.contains(z) else { return nil } 26 | return (z * height + y) * width + x 27 | } 28 | subscript(x: Int, y: Int, z: Int) -> Element { 29 | get { 30 | guard let i = indexAt(x: x, y: y, z: z) else { return outside! } 31 | return elements[i] 32 | } 33 | set { 34 | guard let i = indexAt(x: x, y: y, z: z) else { 35 | precondition(outside != nil) 36 | return 37 | } 38 | elements[i] = newValue 39 | } 40 | } 41 | subscript(position: (Int, Int, Int)) -> Element { 42 | get { self[position.0, position.1, position.2] } 43 | set { self[position.0, position.1, position.2] = newValue } 44 | } 45 | func makeIterator() -> IndexingIterator<[Element]> { 46 | elements.makeIterator() 47 | } 48 | func map(_ transform: (Element) throws -> T) rethrows -> Array3D { 49 | try Array3D(width: width, height: height, depth: depth, elements: elements.map(transform)) 50 | } 51 | var description: String { 52 | var result: String = "" 53 | for z in zRange { 54 | if z > 0 { 55 | result.append("\n") 56 | } 57 | for y in yRange { 58 | for x in xRange { 59 | if x > 0 { 60 | result.append(" ") 61 | } 62 | result.append("\(self[x, y, z])") 63 | } 64 | result.append("\n") 65 | } 66 | } 67 | return result 68 | } 69 | } 70 | extension Array3D where Element: CustomStringConvertible { 71 | var description: String { 72 | var result: String = "" 73 | for z in zRange { 74 | if z > 0 { 75 | result.append("\n") 76 | } 77 | for y in yRange { 78 | for x in xRange { 79 | if x > 0 { 80 | result.append(" ") 81 | } 82 | result.append(self[x, y, z].description) 83 | } 84 | result.append("\n") 85 | } 86 | } 87 | return result 88 | } 89 | } 90 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/ArrayND.swift: -------------------------------------------------------------------------------- 1 | struct ArrayND: Sequence { 2 | let lengths: [Int] 3 | private(set) var elements: [Element] 4 | let outside: Element? 5 | init(lengths: [Int], elements: [Element], outside: Element? = nil) { 6 | precondition(lengths.allSatisfy { $0 >= 0 }) 7 | precondition(elements.count == lengths.reduce(1, *)) 8 | self.lengths = lengths 9 | self.elements = elements 10 | self.outside = outside 11 | } 12 | init(lengths: [Int], element: Element, outside: Element? = nil) { 13 | self.init(lengths: lengths, elements: [Element](repeating: element, count: lengths.reduce(1, *)), outside: outside) 14 | } 15 | var count: Int { elements.count } 16 | private func indexAt(_ indices: [Int]) -> Int? { 17 | precondition(indices.count == lengths.count) 18 | var result = 0 19 | for (i, index) in indices.enumerated().reversed() { 20 | guard (0 ..< lengths[i]).contains(index) else { return nil } 21 | result += index 22 | if i > 0 { 23 | result *= lengths[i - 1] 24 | } 25 | } 26 | return result 27 | } 28 | subscript(indices: Int...) -> Element { 29 | get { 30 | guard let i = indexAt(indices) else { return outside! } 31 | return elements[i] 32 | } 33 | set { 34 | guard let i = indexAt(indices) else { 35 | precondition(outside != nil) 36 | return 37 | } 38 | elements[i] = newValue 39 | } 40 | } 41 | func makeIterator() -> IndexingIterator<[Element]> { 42 | elements.makeIterator() 43 | } 44 | func map(_ transform: (Element) throws -> T) rethrows -> ArrayND { 45 | try ArrayND(lengths: lengths, elements: elements.map(transform)) 46 | } 47 | } 48 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/BFS.swift: -------------------------------------------------------------------------------- 1 | // ❗ 利用時に `Deque` のコピーが必要 2 | 3 | func bfs(edges: [[Int]], startedAt start: Int, _ operation: (Int) -> Void) { 4 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 5 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 6 | var destinations: Deque = [start] 7 | while let current = destinations.popFirst() { 8 | if isVisited[current] { continue } 9 | operation(current) 10 | isVisited[current] = true 11 | for destination in edges[current] { 12 | destinations.append(destination) 13 | } 14 | } 15 | } 16 | 17 | func bfs(edges: [[Int]], startedAt start: Int, _ operation: (_ current: Int, _ prev: Int?) -> Void) { 18 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 19 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 20 | var destinations: Deque<(current: Int, prev: Int?)> = [(start, nil)] 21 | while let (current, prev) = destinations.popFirst() { 22 | if isVisited[current] { continue } 23 | operation(current, prev) 24 | isVisited[current] = true 25 | for destination in edges[current] { 26 | destinations.append((destination, current)) 27 | } 28 | } 29 | } 30 | 31 | func bfs(edges: [[Int]], startedAt start: Int, _ operation: (_ current: Int, _ prev: Int?, _ depth: Int) -> Void) { 32 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 33 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 34 | var destinations: Deque<(current: Int, prev: Int?, depth: Int)> = [(start, nil, 0)] 35 | while let (current, prev, depth) = destinations.popFirst() { 36 | if isVisited[current] { continue } 37 | operation(current, prev, depth) 38 | isVisited[current] = true 39 | for destination in edges[current] { 40 | destinations.append((destination, current, depth + 1)) 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/BellmanFord.swift: -------------------------------------------------------------------------------- 1 | /// ベルマン-フォード法を用いて、始点となる頂点からグラフ中の各頂点への最短距離を求めます。 2 | /// 3 | /// - Parameters: 4 | /// - graph: 最短距離を求める対象となるグラフ。 5 | /// `graph.count` はグラフの頂点の数を表す。 6 | /// `graph.edges` はグラフの辺を表し、 `from` 、 `to` はそれぞれ始点、終点の頂点のインデックスを表す。 7 | /// `distance` はその辺の距離を表す。 8 | /// - start: 始点となる頂点のインデックス。 9 | /// - Returns: `start` から各頂点への最短距離と、その頂点への経路が負の閉路を持つかを表すフラグ。 10 | func bellmanFord(graph: (count: Int, edges: [(from: Int, to: Int, distance: Distance)]), startedAt start: Int) -> [(Distance, hasNegativeWeightCycles: Bool)?] where Distance: Comparable, Distance: AdditiveArithmetic { 11 | precondition(graph.count > 0) 12 | 13 | var totalDistances: [Distance?] = .init(repeating: nil, count: graph.count) 14 | totalDistances[start] = .zero 15 | 16 | let finalRound = graph.count - 1 17 | for _ in 0 ..< finalRound { 18 | for (i, j, distance) in graph.edges { 19 | guard let totalDistanceToI = totalDistances[i] else { continue } 20 | let newTotalDistanceToJ = totalDistanceToI + distance 21 | if let totalDistanceToJ = totalDistances[j] { 22 | if newTotalDistanceToJ < totalDistanceToJ { 23 | totalDistances[j] = newTotalDistanceToJ 24 | } 25 | } else { 26 | totalDistances[j] = newTotalDistanceToJ 27 | } 28 | } 29 | } 30 | 31 | var isUpdated: [Bool] = .init(repeating: false, count: graph.count) 32 | for (i, j, distance) in graph.edges { 33 | guard let totalDistanceToI = totalDistances[i] else { continue } 34 | let newTotalDistanceToJ = totalDistanceToI + distance 35 | if let totalDistanceToJ = totalDistances[j] { 36 | if newTotalDistanceToJ < totalDistanceToJ { 37 | totalDistances[j] = newTotalDistanceToJ 38 | isUpdated[j] = true 39 | } 40 | } else { 41 | totalDistances[j] = newTotalDistanceToJ 42 | isUpdated[j] = true 43 | } 44 | } 45 | 46 | func _dfs(edges: [[Int]], startedAt start: Int, _ body: (Int) -> Void) { 47 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 48 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 49 | var destinations: [Int] = [start] 50 | while let current = destinations.popLast() { 51 | if isVisited[current] { continue } 52 | body(current) 53 | isVisited[current] = true 54 | for destination in edges[current].reversed() { 55 | destinations.append(destination) 56 | } 57 | } 58 | } 59 | 60 | var edges: [[Int]] = .init(repeating: [], count: graph.count) 61 | for (from, to, _) in graph.edges { 62 | edges[from].append(to) 63 | } 64 | 65 | var hasNegativeWeightCycles: [Bool] = .init(repeating: false, count: graph.count) 66 | for (i, isUpdated) in isUpdated.enumerated() { 67 | guard isUpdated else { continue } 68 | if hasNegativeWeightCycles[i] { continue } 69 | _dfs(edges: edges, startedAt: i) { j in hasNegativeWeightCycles[j] = true } 70 | } 71 | 72 | return zip(totalDistances, hasNegativeWeightCycles).map { d, f in d.map { ($0, f) } } 73 | } 74 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/BinarySearch.swift: -------------------------------------------------------------------------------- 1 | enum LessThanElement {} 2 | func <(lhs: LessThanElement, rhs: LessThanElement) {} 3 | extension RandomAccessCollection where Element: Comparable, Index == Int { 4 | func values(_: (LessThanElement, LessThanElement) -> (), _ value: Element) -> SubSequence { 5 | var low = startIndex - 1 6 | var high = endIndex 7 | while high - low > 1 { 8 | let mid = low + (high - low) / 2 9 | if self[mid] < value { 10 | low = mid 11 | } else { 12 | high = mid 13 | } 14 | } 15 | return self[.. (), _ predicate: (Element) throws -> Bool) rethrows -> SubSequence { 20 | var low = startIndex - 1 21 | var high = endIndex 22 | while high - low > 1 { 23 | let mid = low + (high - low) / 2 24 | if try predicate(self[mid]) { 25 | low = mid 26 | } else { 27 | high = mid 28 | } 29 | } 30 | return self[.. (), _ value: Element) -> SubSequence { 38 | var low = startIndex - 1 39 | var high = endIndex 40 | while high - low > 1 { 41 | let mid = low + (high - low) / 2 42 | if self[mid] <= value { 43 | low = mid 44 | } else { 45 | high = mid 46 | } 47 | } 48 | return self[.. (), _ predicate: (Element) throws -> Bool) rethrows -> SubSequence { 53 | var low = startIndex - 1 54 | var high = endIndex 55 | while high - low > 1 { 56 | let mid = low + (high - low) / 2 57 | if try predicate(self[mid]) { 58 | low = mid 59 | } else { 60 | high = mid 61 | } 62 | } 63 | return self[..(lhs: GreaterThanElement, rhs: GreaterThanElement) {} 69 | extension RandomAccessCollection where Element: Comparable, Index == Int { 70 | func values(_: (GreaterThanElement, GreaterThanElement) -> (), _ value: Element) -> SubSequence { 71 | var low = startIndex - 1 72 | var high = endIndex 73 | while high - low > 1 { 74 | let mid = low + (high - low) / 2 75 | if self[mid] > value { 76 | high = mid 77 | } else { 78 | low = mid 79 | } 80 | } 81 | return self[high...] 82 | } 83 | } 84 | extension RandomAccessCollection where Index == Int { 85 | func values(_: (GreaterThanElement, GreaterThanElement) -> (), _ predicate: (Element) throws -> Bool) rethrows -> SubSequence { 86 | var low = startIndex - 1 87 | var high = endIndex 88 | while high - low > 1 { 89 | let mid = low + (high - low) / 2 90 | if try predicate(self[mid]) { 91 | high = mid 92 | } else { 93 | low = mid 94 | } 95 | } 96 | return self[high...] 97 | } 98 | } 99 | 100 | enum GreaterThanOrEqualToElement {} 101 | func >=(lhs: GreaterThanOrEqualToElement, rhs: GreaterThanOrEqualToElement) {} 102 | extension RandomAccessCollection where Element: Comparable, Index == Int { 103 | func values(_: (GreaterThanOrEqualToElement, GreaterThanOrEqualToElement) -> (), _ value: Element) -> SubSequence { 104 | var low = startIndex - 1 105 | var high = endIndex 106 | while high - low > 1 { 107 | let mid = low + (high - low) / 2 108 | if self[mid] >= value { 109 | high = mid 110 | } else { 111 | low = mid 112 | } 113 | } 114 | return self[high...] 115 | } 116 | } 117 | extension RandomAccessCollection where Index == Int { 118 | func values(_: (GreaterThanOrEqualToElement, GreaterThanOrEqualToElement) -> (), _ predicate: (Element) throws -> Bool) rethrows -> SubSequence { 119 | var low = startIndex - 1 120 | var high = endIndex 121 | while high - low > 1 { 122 | let mid = low + (high - low) / 2 123 | if try predicate(self[mid]) { 124 | high = mid 125 | } else { 126 | low = mid 127 | } 128 | } 129 | return self[high...] 130 | } 131 | } 132 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Combinations.swift: -------------------------------------------------------------------------------- 1 | func ncr(_ n: Integer, _ r: Integer, modulus: Integer?) -> Integer where Integer: BinaryInteger, Integer.Stride: SignedInteger { 2 | precondition(n >= 0) 3 | precondition(r >= 0) 4 | precondition(n >= r) 5 | if let modulus = modulus { 6 | precondition(modulus >= 1) 7 | func npr(_ n: Integer, _ r: Integer, modulus: Integer) -> Integer { 8 | (n - r + 1 ..< n + 1).reduce(into: 1) { $0 = ($0 * $1) % modulus } 9 | } 10 | func pow(_ a: Integer, _ b: Integer, modulus: Integer) -> Integer { 11 | var result: Integer = .init(1) 12 | var a = a 13 | var b = b 14 | while true { 15 | if b & 0x1 != .zero { 16 | result = (result * a) % modulus 17 | } 18 | b >>= 1 19 | guard b > .zero else { break } 20 | a = (a * a) % modulus 21 | } 22 | return result 23 | } 24 | let numerator = npr(n, r, modulus: modulus) 25 | let denominator = npr(r, r, modulus: modulus) 26 | return (numerator * pow(denominator, modulus - 2, modulus: modulus)) % modulus 27 | } else { 28 | let range: Range = 1 ..< r + 1 29 | return range.reduce(into: 1 as Integer) { $0 = $0 * (n - $1 + 1) / $1 } 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/DFS.swift: -------------------------------------------------------------------------------- 1 | func dfs(edges: [[Int]], startedAt start: Int, _ body: (Int) -> Void) { 2 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 3 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 4 | var destinations: [Int] = [start] 5 | while let current = destinations.popLast() { 6 | if isVisited[current] { continue } 7 | body(current) 8 | isVisited[current] = true 9 | for destination in edges[current].reversed() { 10 | destinations.append(destination) 11 | } 12 | } 13 | } 14 | 15 | func dfs(edges: [[Int]], startedAt start: Int, _ body: (_ current: Int, _ prev: Int?) -> Void) { 16 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 17 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 18 | var destinations: [(current: Int, prev: Int?)] = [(start, nil)] 19 | while let (current, prev) = destinations.popLast() { 20 | if isVisited[current] { continue } 21 | body(current, prev) 22 | isVisited[current] = true 23 | for destination in edges[current].reversed() { 24 | destinations.append((destination, current)) 25 | } 26 | } 27 | } 28 | 29 | func dfs(edges: [[Int]], startedAt start: Int, _ body: (_ current: Int, _ prev: Int?, _ depth: Int) -> Void) { 30 | precondition(edges.indices.contains(start), "`start` index is out of bounds: \(start)") 31 | var isVisited: [Bool] = .init(repeating: false, count: edges.count) 32 | var destinations: [(current: Int, prev: Int?, depth: Int)] = [(start, nil, 0)] 33 | while let (current, prev, depth) = destinations.popLast() { 34 | if isVisited[current] { continue } 35 | body(current, prev, depth) 36 | isVisited[current] = true 37 | for destination in edges[current].reversed() { 38 | destinations.append((destination, current, depth + 1)) 39 | } 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Deque.swift: -------------------------------------------------------------------------------- 1 | struct Deque: MutableCollection, RandomAccessCollection, ExpressibleByArrayLiteral { 2 | private var buffer: Buffer 3 | init(_ values: [Element]) { 4 | buffer = Buffer(from: values, capacity: Swift.max(values.count, 16)) 5 | } 6 | init(_ values: ArraySlice) { 7 | buffer = Buffer(from: values, capacity: Swift.max(values.count, 16)) 8 | } 9 | init(_ sequence: S) where S: Sequence, S.Element == Element { 10 | self.init([Element](sequence)) 11 | } 12 | init(arrayLiteral values: Element...) { 13 | self.init(values) 14 | } 15 | subscript(index: Int) -> Element { 16 | get { buffer[index] } 17 | set { 18 | copyIfNeed() 19 | buffer[index] = newValue 20 | } 21 | } 22 | var startIndex: Int { 0 } 23 | var endIndex: Int { buffer.count } 24 | mutating func append(_ element: Element) { 25 | copyIfNeed() 26 | buffer.append(element) 27 | } 28 | mutating func popLast() -> Element? { 29 | copyIfNeed() 30 | return buffer.popLast() 31 | } 32 | @discardableResult mutating func removeLast() -> Element { popLast()! } 33 | mutating func prepend(_ element: Element) { 34 | copyIfNeed() 35 | buffer.prepend(element) 36 | } 37 | mutating func popFirst() -> Element? { 38 | copyIfNeed() 39 | return buffer.popFirst() 40 | } 41 | @discardableResult mutating func removeFirst() -> Element { popFirst()! } 42 | private mutating func copyIfNeed() { 43 | if !isKnownUniquelyReferenced(&buffer) { 44 | buffer = Buffer(from: buffer, capacity: Swift.max(buffer.count, 16)) 45 | } 46 | } 47 | private final class Buffer { 48 | private var buffer: UnsafeMutablePointer 49 | private var capacity: Int 50 | private var start: Int 51 | private(set) var count: Int 52 | init(from values: [Element], capacity: Int) { 53 | precondition(capacity >= values.count) 54 | self.capacity = capacity 55 | self.start = 0 56 | self.count = values.count 57 | self.buffer = .allocate(capacity: capacity) 58 | buffer.initialize(from: values, count: count) 59 | } 60 | init(from values: ArraySlice, capacity: Int) { 61 | precondition(capacity >= values.count) 62 | self.capacity = capacity 63 | self.start = 0 64 | self.count = values.count 65 | self.buffer = .allocate(capacity: capacity) 66 | values.withUnsafeBufferPointer { buffer.initialize(from: $0.baseAddress!, count: count) } 67 | } 68 | init(from values: Buffer, capacity: Int) { 69 | precondition(capacity >= values.count) 70 | self.capacity = capacity 71 | self.start = 0 72 | self.count = values.count 73 | self.buffer = .allocate(capacity: capacity) 74 | if values.start + values.count <= values.capacity { 75 | buffer.initialize(from: values.buffer.advanced(by: values.start), count: values.count) 76 | } else { 77 | let n = values.capacity - values.start 78 | buffer.initialize(from: values.buffer.advanced(by: values.start), count: n) 79 | buffer.advanced(by: n).initialize(from: values.buffer, count: values.count - n) 80 | } 81 | } 82 | deinit { 83 | buffer.deallocate() 84 | } 85 | subscript(index: Int) -> Element { 86 | get { 87 | precondition((0 ..< count).contains(index)) 88 | return buffer[(start + index) % capacity] 89 | } 90 | set { 91 | precondition((0 ..< count).contains(index)) 92 | buffer[(start + index) % capacity] = newValue 93 | } 94 | } 95 | func append(_ element: Element) { 96 | if count == capacity { doubleCapacity() } 97 | buffer.advanced(by: (start + count) % capacity).initialize(to: element) 98 | count += 1 99 | } 100 | func popLast() -> Element? { 101 | if count == 0 { return nil } 102 | count -= 1 103 | let pointer = buffer.advanced(by: (start + count) % capacity) 104 | let value = pointer.pointee 105 | pointer.deinitialize(count: 1) 106 | return value 107 | } 108 | func prepend(_ element: Element) { 109 | if count == capacity { doubleCapacity() } 110 | start = (start - 1 + capacity) % capacity 111 | buffer.advanced(by: start).initialize(to: element) 112 | count += 1 113 | } 114 | func popFirst() -> Element? { 115 | if count == 0 { return nil } 116 | let pointer = buffer.advanced(by: start) 117 | let value = pointer.pointee 118 | pointer.deinitialize(count: 1) 119 | start = (start + 1) % capacity 120 | count -= 1 121 | return value 122 | } 123 | private func doubleCapacity() { 124 | let newCapacity = capacity * 2 125 | let newBuffer: UnsafeMutablePointer = .allocate(capacity: newCapacity) 126 | if start + count <= capacity { 127 | newBuffer.initialize(from: buffer.advanced(by: start), count: count) 128 | } else { 129 | let n = capacity - start 130 | newBuffer.initialize(from: buffer.advanced(by: start), count: n) 131 | newBuffer.advanced(by: n).initialize(from: buffer, count: count - n) 132 | } 133 | buffer.deallocate() 134 | buffer = newBuffer 135 | capacity = newCapacity 136 | start = 0 137 | } 138 | } 139 | } 140 | extension Deque: Equatable where Element: Equatable { 141 | static func == (lhs: Deque, rhs: Deque) -> Bool { 142 | guard lhs.count == rhs.count else { return false } 143 | return zip(lhs, rhs).allSatisfy { $0 == $1 } 144 | } 145 | } 146 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Dijkstra.swift: -------------------------------------------------------------------------------- 1 | // ❗ 利用時に `PriorityQueue` のコピーが必要 2 | 3 | /// ダイクストラ法を用いて、始点となる頂点からグラフ中の各頂点への最短距離を求めます。 4 | /// 5 | /// - Parameters: 6 | /// - graph: 最短距離を求める対象となるグラフ。 7 | /// `graph[i][j]` はグラフの `i` 番目の頂点から他の頂点への `j` 番目の辺を表す。 8 | /// 辺の行き先となる頂点のインデックスを `index` で、辺の距離を `distance` で表す。 9 | /// - start: 始点となる頂点のインデックス。 10 | /// - Returns: `start` から各頂点への最短距離。到達不能な頂点への最短距離は `nil` 。 11 | func dijkstra(graph: [[(index: Int, distance: Distance)]], startedAt start: Int) -> [Distance?] where Distance: Comparable, Distance: AdditiveArithmetic { 12 | var result: [Distance?] = .init(repeating: nil, count: graph.count) 13 | result[start] = .zero 14 | var queue = PriorityQueue<(Distance, Int)>(by: { $0.0 < $1.0 }) 15 | queue.append((.zero, start)) 16 | while let (totalDistanceToI, i) = queue.popFirst() { 17 | guard let minTotalDistanceToI = result[i] else { preconditionFailure("Never reaches here.") } 18 | if minTotalDistanceToI < totalDistanceToI { continue } 19 | assert(totalDistanceToI == minTotalDistanceToI) 20 | for (j, distance) in graph[i] { 21 | if let totalDistanceToJ = result[j] { 22 | let newTotalDistanceToJ = totalDistanceToI + distance 23 | if newTotalDistanceToJ < totalDistanceToJ { 24 | result[j] = newTotalDistanceToJ 25 | queue.append((newTotalDistanceToJ, j)) 26 | } 27 | } else { 28 | let newTotalDistanceToJ = totalDistanceToI + distance 29 | result[j] = newTotalDistanceToJ 30 | queue.append((newTotalDistanceToJ, j)) 31 | } 32 | } 33 | } 34 | return result 35 | } 36 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Divisors.swift: -------------------------------------------------------------------------------- 1 | #if os(Linux) 2 | import Glibc // FIXME: 現状では必要ですが、不要になった段階で除去 3 | #endif 4 | extension BinaryInteger where Stride: SignedInteger { 5 | func divisors() -> [Self] { 6 | precondition(self > 0) 7 | if self == 1 { return [1] } 8 | var result: [Self] = [] 9 | let sqrtn = Self(Double(self).squareRoot()) 10 | for i in 1 ... sqrtn { 11 | if self.isMultiple(of: i) { 12 | result.append(i) 13 | result.append(self / i) 14 | } 15 | } 16 | if sqrtn * sqrtn == self { 17 | result.removeLast() 18 | } 19 | result.sort() 20 | return result 21 | } 22 | } 23 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/GCD.swift: -------------------------------------------------------------------------------- 1 | func gcd(_ m: T, _ n: T) -> T where T: BinaryInteger { 2 | precondition(m > 0) 3 | precondition(n > 0) 4 | var m = m 5 | var n = n 6 | if m < n { 7 | swap(&m, &n) 8 | } 9 | repeat { 10 | m = m % n 11 | swap(&m, &n) 12 | } while n > 0 13 | return m 14 | } 15 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Input.swift: -------------------------------------------------------------------------------- 1 | func readInt1() -> Int { 2 | Int(readLine()!)! 3 | } 4 | 5 | func readInt2() -> (Int, Int) { 6 | let values = readLine()!.split(separator: " ").map { Int(String($0))! } 7 | precondition(values.count == 2) 8 | return (values[0], values[1]) 9 | } 10 | 11 | func readInt3(line: Int = #line, file: String = #file) -> (Int, Int, Int) { 12 | let values = readLine()!.split(separator: " ").map { Int(String($0))! } 13 | precondition(values.count == 3) 14 | return (values[0], values[1], values[2]) 15 | } 16 | 17 | func readInt4(line: Int = #line, file: String = #file) -> (Int, Int, Int, Int) { 18 | let values = readLine()!.split(separator: " ").map { Int(String($0))! } 19 | precondition(values.count == 4) 20 | return (values[0], values[1], values[2], values[3]) 21 | } 22 | 23 | func readIntN(line: Int = #line, file: String = #file) -> [Int] { 24 | readLine()!.split(separator: " ").map { Int(String($0))! } 25 | } 26 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/IsPrime.swift: -------------------------------------------------------------------------------- 1 | #if os(Linux) 2 | import Glibc // FIXME: 現状では必要ですが、不要になった段階で除去 3 | #endif 4 | extension BinaryInteger { 5 | var isPrime: Bool { 6 | let value = Int(self) 7 | if value < 2 { return false } 8 | if value <= 3 { return true } 9 | if value.isMultiple(of: 2) { return false } 10 | for n in stride(from: 3, through: Int(Double(value).squareRoot() + 1.5), by: 2) { 11 | if value.isMultiple(of: n) { return false } 12 | } 13 | return true 14 | } 15 | } 16 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/ModInt.swift: -------------------------------------------------------------------------------- 1 | struct ModInt: AdditiveArithmetic, ExpressibleByIntegerLiteral, CustomStringConvertible, Hashable { 2 | static var modulus: UInt! // FIXME: 問題に合わせて修正 3 | let value: UInt 4 | init(_ value: UInt) { 5 | self.value = value % Self.modulus 6 | } 7 | init(_ value: Int) { 8 | if value < 0 { 9 | self.init(UInt(value % Int(Self.modulus) + Int(Self.modulus))) 10 | } else { 11 | self.init(UInt(value)) 12 | } 13 | } 14 | init(integerLiteral value: Int) { 15 | self.init(value) 16 | } 17 | static func +(lhs: Self, rhs: Self) -> Self { 18 | let r = lhs.value + rhs.value 19 | if r < modulus { 20 | return Self(r) 21 | } else { 22 | return Self(r - modulus) 23 | } 24 | } 25 | static func -(lhs: Self, rhs: Self) -> Self { 26 | if lhs.value < rhs.value { 27 | return Self(lhs.value + modulus - rhs.value) 28 | } else { 29 | return Self(lhs.value - rhs.value) 30 | } 31 | } 32 | static func *(lhs: Self, rhs: Self) -> Self { 33 | Self((lhs.value * rhs.value) % modulus) 34 | } 35 | static func +=(lhs: inout Self, rhs: Self) { 36 | lhs = lhs + rhs 37 | } 38 | static func -=(lhs: inout Self, rhs: Self) { 39 | lhs = lhs - rhs 40 | } 41 | static func *=(lhs: inout Self, rhs: Self) { 42 | lhs = lhs * rhs 43 | } 44 | var description: String { value.description } 45 | } 46 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/ModOperators.swift: -------------------------------------------------------------------------------- 1 | var modulus: Int! // FIXME: 問題に合わせて修正 2 | private var _modulus: Int { modulus } 3 | extension BinaryInteger { 4 | static var modulus: Self { Self(_modulus) } 5 | } 6 | infix operator %+: AdditionPrecedence 7 | infix operator %-: AdditionPrecedence 8 | infix operator %*: MultiplicationPrecedence 9 | infix operator %/: MultiplicationPrecedence 10 | infix operator %+=: AssignmentPrecedence 11 | infix operator %-=: AssignmentPrecedence 12 | infix operator %*=: AssignmentPrecedence 13 | infix operator %/=: AssignmentPrecedence 14 | extension BinaryInteger { 15 | static func %+(lhs: Self, rhs: Self) -> Self { 16 | let r = (lhs + rhs) % modulus 17 | return r < 0 ? r + modulus : r 18 | } 19 | static func %-(lhs: Self, rhs: Self) -> Self { 20 | let r = (lhs - rhs) % modulus 21 | return r < 0 ? r + modulus : r 22 | } 23 | static func %*(lhs: Self, rhs: Self) -> Self { 24 | let r = (lhs * rhs) % modulus 25 | return r < 0 ? r + modulus : r 26 | } 27 | static func %/(lhs: Self, rhs: Self) -> Self { 28 | precondition(lhs >= 0) 29 | return (lhs * pow(rhs, modulus - 2, modulus: modulus)) % modulus 30 | } 31 | static func %+=(lhs: inout Self, rhs: Self) { 32 | lhs = lhs %+ rhs 33 | } 34 | static func %-=(lhs: inout Self, rhs: Self) { 35 | lhs = lhs %- rhs 36 | } 37 | static func %*=(lhs: inout Self, rhs: Self) { 38 | lhs = lhs %* rhs 39 | } 40 | static func %/=(lhs: inout Self, rhs: Self) { 41 | lhs = lhs %/ rhs 42 | } 43 | private static func pow(_ a: Self, _ b: Self, modulus: Self) -> Self { 44 | var result: Self = .init(1) 45 | var a = a 46 | var b = b 47 | while true { 48 | if b & 0x1 != .zero { 49 | result = (result * a) % modulus 50 | } 51 | b >>= 1 52 | guard b > .zero else { break } 53 | a = (a * a) % modulus 54 | } 55 | return result 56 | } 57 | } 58 | extension UnsignedInteger { 59 | static func %-(lhs: Self, rhs: Self) -> Self { 60 | if lhs < rhs { 61 | return modulus - (rhs - lhs) % modulus 62 | } else { 63 | return (lhs - rhs) % modulus 64 | } 65 | } 66 | static func %-=(lhs: inout Self, rhs: Self) { 67 | lhs = lhs %- rhs 68 | } 69 | } 70 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/NCR.swift: -------------------------------------------------------------------------------- 1 | struct NCR { 2 | let maxN: Int 3 | let modulus: Int 4 | private let factorials: [Int] 5 | private let inverses: [Int] 6 | private let inverseFactorials: [Int] 7 | 8 | init(maxN: Int, modulus: Int) { 9 | precondition(maxN >= 0) 10 | precondition(modulus >= 2) 11 | var factorials: [Int] = [1, 1] 12 | var inverses: [Int] = [1, 1] 13 | var inverseFactorials: [Int] = [1, 1] 14 | factorials.reserveCapacity(maxN + 1) 15 | inverses.reserveCapacity(maxN + 1) 16 | inverseFactorials.reserveCapacity(maxN + 1) 17 | if maxN >= 2 { 18 | for i in 2 ... maxN { 19 | factorials.append(factorials[i - 1] * i % modulus) 20 | inverses.append(modulus - inverses[modulus % i] * (modulus / i) % modulus) 21 | inverseFactorials.append(inverseFactorials[i - 1] * inverses[i] % modulus) 22 | } 23 | } 24 | 25 | self.maxN = maxN 26 | self.modulus = modulus 27 | self.factorials = factorials 28 | self.inverses = inverses 29 | self.inverseFactorials = inverseFactorials 30 | } 31 | 32 | func factorial(of n: Int) -> Int { 33 | precondition(n >= 0) 34 | precondition(n <= maxN) 35 | return factorials[n] 36 | } 37 | 38 | func npr(_ n: Int, _ r: Int) -> Int { 39 | precondition(n >= 0) 40 | precondition(n <= maxN) 41 | precondition(r >= 0) 42 | precondition(r <= n) 43 | return factorials[n] * inverseFactorials[n - r] % modulus 44 | } 45 | 46 | func ncr(_ n: Int, _ r: Int) -> Int { 47 | precondition(n >= 0) 48 | precondition(n <= maxN) 49 | precondition(r >= 0) 50 | precondition(r <= n) 51 | return factorials[n] * (inverseFactorials[n - r] * inverseFactorials[r] % modulus) % modulus 52 | } 53 | 54 | func callAsFunction(_ n: Int, _ r: Int) -> Int { 55 | ncr(n, r) 56 | } 57 | } 58 | 59 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Permutations.swift: -------------------------------------------------------------------------------- 1 | extension Sequence { 2 | func permutations() -> [[Element]] { 3 | func _permutations(of values: [T], indices: Range, result: inout [[T]]) { 4 | if indices.isEmpty { 5 | result.append(values) 6 | return 7 | } 8 | var values = values 9 | for i in indices { 10 | values.swapAt(indices.lowerBound, i) 11 | _permutations(of: values, indices: (indices.lowerBound + 1) ..< indices.upperBound, result: &result) 12 | } 13 | } 14 | 15 | var result: [[Element]] = [] 16 | let values = Array(self) 17 | _permutations(of: values, indices: values.indices, result: &result) 18 | return result 19 | } 20 | } 21 | 22 | func npr(_ n: Integer, _ r: Integer, modulus: Integer?) -> Integer where Integer: BinaryInteger, Integer.Stride: SignedInteger { 23 | precondition(n >= 0) 24 | precondition(r >= 0) 25 | precondition(n >= r) 26 | if let modulus = modulus { 27 | precondition(modulus >= 1) 28 | return (n - r + 1 ..< n + 1).reduce(into: 1 as Integer) { $0 = ($0 * $1) % modulus } 29 | } else { 30 | return (n - r + 1 ..< n + 1).reduce(into: 1 as Integer) { $0 *= $1 } 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Pow.swift: -------------------------------------------------------------------------------- 1 | func pow(_ a: Integer, _ b: Integer, modulus: Integer?) -> Integer where Integer: BinaryInteger { 2 | var result: Integer = 1 3 | var a = a 4 | var b = b 5 | if let modulus = modulus { 6 | while true { 7 | if b & 0x1 != 0 { 8 | result = (result * a) % modulus 9 | } 10 | b >>= 1 11 | guard b > 0 else { break } 12 | a = (a * a) % modulus 13 | } 14 | } else { 15 | while true { 16 | if b & 0x1 != 0 { 17 | result *= a 18 | } 19 | b >>= 1 20 | guard b > 0 else { break } 21 | a *= a 22 | } 23 | } 24 | return result 25 | } 26 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Primes.swift: -------------------------------------------------------------------------------- 1 | #if os(Linux) 2 | import Glibc // FIXME: 現状では必要ですが、不要になった段階で除去 3 | #endif 4 | func primes(upTo number: Int) -> [Int] { 5 | precondition(number >= 0) 6 | if number < 2 { return [] } 7 | var sieve: [Bool] = .init(repeating: false, count: number + 1) 8 | for m in stride(from: 3, through: Int(Double(number).squareRoot() + 1.5), by: 2) { 9 | if sieve[m] { continue } 10 | let maxK = number / m 11 | if maxK < 2 { continue } 12 | for k in 2 ... maxK { 13 | sieve[k * m] = true 14 | } 15 | } 16 | var result: [Int] = [2] 17 | for m in stride(from: 3, through: number, by: 2) { 18 | if sieve[m] { continue } 19 | result.append(m) 20 | } 21 | return result 22 | } 23 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/PriorityQueue.swift: -------------------------------------------------------------------------------- 1 | struct PriorityQueue { 2 | private var elements: [Element] = [] 3 | private let areInIncreasingOrder: (Element, Element) -> Bool 4 | 5 | init(_ elements: S, by areInIncreasingOrder: @escaping (Element, Element) -> Bool) where S: Sequence, S.Element == Element { 6 | self.areInIncreasingOrder = areInIncreasingOrder 7 | for element in elements { 8 | append(element) 9 | } 10 | } 11 | 12 | init(by areInIncreasingOrder: @escaping (Element, Element) -> Bool) { 13 | self.init(EmptyCollection(), by: areInIncreasingOrder) 14 | } 15 | 16 | var isEmpty: Bool { elements.isEmpty } 17 | var count: Int { elements.count } 18 | var first: Element? { elements.first } 19 | 20 | mutating func append(_ element: Element) { 21 | var i = elements.count 22 | elements.append(element) 23 | elements.withUnsafeMutableBufferPointer { elements in 24 | while i > 0 { 25 | let parentIndex = (i - 1) >> 1 26 | let parent = elements[parentIndex] 27 | guard areInIncreasingOrder(element, parent) else { break } 28 | elements[parentIndex] = element 29 | elements[i] = parent 30 | i = parentIndex 31 | } 32 | } 33 | } 34 | 35 | mutating func popFirst() -> Element? { 36 | guard let element = elements.popLast() else { return nil } 37 | guard let first = elements.first else { return element } 38 | 39 | elements.withUnsafeMutableBufferPointer { elements in 40 | elements[0] = element 41 | 42 | var i = 0 43 | while true { 44 | var childIndex: Int = (i << 1) + 1 45 | guard childIndex < elements.count else { break } 46 | var child: Element = elements[childIndex] 47 | let rightIndex = childIndex + 1 48 | if rightIndex < elements.count { 49 | let right = elements[rightIndex] 50 | if areInIncreasingOrder(right, child) { 51 | childIndex = rightIndex 52 | child = right 53 | } 54 | } 55 | if areInIncreasingOrder(element, child) { break } 56 | elements[childIndex] = element 57 | elements[i] = child 58 | i = childIndex 59 | } 60 | } 61 | 62 | return first 63 | } 64 | } 65 | extension PriorityQueue where Element: Comparable { 66 | init(_ elements: S) where S: Sequence, S.Element == Element { 67 | self.init(elements, by: <) 68 | } 69 | 70 | init() { 71 | self.init(by: <) 72 | } 73 | 74 | } 75 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/RangeSum.swift: -------------------------------------------------------------------------------- 1 | extension ClosedRange where Bound: BinaryInteger { 2 | func sum(modulus: Bound? = nil) -> Bound { 3 | let n: Bound = upperBound - lowerBound + 1 4 | let result = (lowerBound + upperBound) * n / 2 5 | guard let modulus = modulus else { return result } 6 | if result < 0 { 7 | return result % modulus + modulus 8 | } else { 9 | return result % modulus 10 | } 11 | } 12 | } 13 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/SafeOverflow.swift: -------------------------------------------------------------------------------- 1 | infix operator +?: AdditionPrecedence 2 | extension FixedWidthInteger { 3 | static func +? (lhs: Self, rhs: Self) -> Self? { 4 | let (result, overflows) = lhs.addingReportingOverflow(rhs) 5 | if overflows { return nil } 6 | return result 7 | } 8 | } 9 | 10 | infix operator -?: AdditionPrecedence 11 | extension FixedWidthInteger { 12 | static func -? (lhs: Self, rhs: Self) -> Self? { 13 | let (result, overflows) = lhs.subtractingReportingOverflow(rhs) 14 | if overflows { return nil } 15 | return result 16 | } 17 | } 18 | 19 | infix operator *?: MultiplicationPrecedence 20 | extension FixedWidthInteger { 21 | static func *? (lhs: Self, rhs: Self) -> Self? { 22 | let (result, overflows) = lhs.multipliedReportingOverflow(by: rhs) 23 | if overflows { return nil } 24 | return result 25 | } 26 | } 27 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/SafeRange.swift: -------------------------------------------------------------------------------- 1 | infix operator ..(lhs: T, rhs: T) -> Range? where T: Comparable { 3 | guard lhs <= rhs else { return nil } 4 | return lhs ..< rhs 5 | } 6 | 7 | infix operator ...?: RangeFormationPrecedence 8 | func ...?(lhs: T, rhs: T) -> ClosedRange? where T: Comparable { 9 | guard lhs <= rhs else { return nil } 10 | return lhs ... rhs 11 | } 12 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/TSP.swift: -------------------------------------------------------------------------------- 1 | func tsp(distances: [[Distance]], startedAt start: Int) -> Distance where Distance: Comparable, Distance: AdditiveArithmetic { 2 | precondition(!distances.isEmpty) 3 | var results: [Distance?] = .init(repeating: nil, count: (1 << distances.count) * distances.count) 4 | for position in distances.indices { 5 | results[((1 << distances.count) - 1) * distances.count + position] = distances[position][start] 6 | } 7 | for visited in (0 ..< (1 << distances.count) - 1).reversed() { 8 | if visited & (1 << start) == 0 { continue } 9 | for position in distances.indices { 10 | var minDistance: Distance? 11 | if visited & (1 << position) == 0 { continue } 12 | for next in distances.indices { 13 | if visited & (1 << next) != 0 { continue } 14 | let distanceToNext: Distance = distances[position][next] 15 | let distance = distanceToNext + results[(visited | (1 << next)) * distances.count + next]! 16 | minDistance = minDistance.map { Swift.min($0, distance) } ?? distance 17 | } 18 | results[visited * distances.count + position] = minDistance! 19 | } 20 | } 21 | return results[(1 << start) * distances.count + start]! 22 | } 23 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/UnionFind.swift: -------------------------------------------------------------------------------- 1 | struct UnionFind { 2 | private var parents: [Int] 3 | private var ranks: [Int] 4 | private var counts: [Int] 5 | 6 | init(count: Int) { 7 | precondition(count >= 0) 8 | self.parents = Array(0 ..< count) 9 | self.ranks = Array(repeating: 0, count: count) 10 | self.counts = Array(repeating: 1, count: count) 11 | } 12 | 13 | func root(of i: Int) -> Int { 14 | var current = i 15 | while true { 16 | let parent = parents[current] 17 | if current == parent { break } 18 | current = parent 19 | } 20 | return current 21 | } 22 | 23 | func count(of i: Int) -> Int { 24 | counts[root(of: i)] 25 | } 26 | 27 | mutating func unite(_ x: Int, _ y: Int) { 28 | let x = root(of: x) 29 | let y = root(of: y) 30 | if x == y { return } 31 | if ranks[x] < ranks[y] { 32 | counts[y] += counts[x] 33 | parents[x] = y 34 | } else { 35 | counts[x] += counts[y] 36 | parents[y] = x 37 | if ranks[x] == ranks[y] { 38 | ranks[x] += 1 39 | } 40 | } 41 | } 42 | 43 | func areInSameSet(_ x: Int, _ y: Int) -> Bool { 44 | root(of:x) == root(of:y) 45 | } 46 | } 47 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/Vectors.swift: -------------------------------------------------------------------------------- 1 | func + (lhs: (T, T), rhs: (T, T)) -> (T, T) { 2 | (lhs.0 + rhs.0, lhs.1 + rhs.1) 3 | } 4 | func += (lhs: inout (T, T), rhs: (T, T)) { 5 | lhs = lhs + rhs 6 | } 7 | func - (lhs: (T, T), rhs: (T, T)) -> (T, T) { 8 | (lhs.0 - rhs.0, lhs.1 - rhs.1) 9 | } 10 | func -= (lhs: inout (T, T), rhs: (T, T)) { 11 | lhs = lhs - rhs 12 | } 13 | func * (lhs: (T, T), rhs: T) -> (T, T) { 14 | (lhs.0 * rhs, lhs.1 * rhs) 15 | } 16 | func *= (lhs: inout (T, T), rhs: T) { 17 | lhs = lhs * rhs 18 | } 19 | func / (lhs: (T, T), rhs: T) -> (T, T) { 20 | (lhs.0 / rhs, lhs.1 / rhs) 21 | } 22 | func /= (lhs: inout (T, T), rhs: T) { 23 | lhs = lhs / rhs 24 | } 25 | func / (lhs: (T, T), rhs: T) -> (T, T) { 26 | (lhs.0 / rhs, lhs.1 / rhs) 27 | } 28 | func /= (lhs: inout (T, T), rhs: T) { 29 | lhs = lhs / rhs 30 | } 31 | prefix func - (operand: (T, T)) -> (T, T) { 32 | (-operand.0, -operand.1) 33 | } 34 | -------------------------------------------------------------------------------- /Sources/AtCoderSupport/WarshallFloyd.swift: -------------------------------------------------------------------------------- 1 | func warshallFloyd(graph: inout [[Distance?]]) where Distance: Comparable, Distance: AdditiveArithmetic { 2 | for k in graph.indices { 3 | for i in graph.indices { 4 | for j in graph.indices { 5 | if let new1 = graph[i][k], let new2 = graph[k][j] { 6 | let new = new1 + new2 7 | if let current = graph[i][j] { 8 | if new < current { 9 | graph[i][j] = new 10 | } 11 | } else { 12 | graph[i][j] = new 13 | } 14 | } 15 | } 16 | } 17 | } 18 | } 19 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/Array2DTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class Array2DTests: XCTestCase { 5 | func testInit() { 6 | do { 7 | let a: Array2D = .init(width: 3, height: 2, element: 42) 8 | 9 | XCTAssertEqual(a[0, 0], 42) 10 | XCTAssertEqual(a[1, 0], 42) 11 | XCTAssertEqual(a[2, 0], 42) 12 | 13 | XCTAssertEqual(a[0, 1], 42) 14 | XCTAssertEqual(a[1, 1], 42) 15 | XCTAssertEqual(a[2, 1], 42) 16 | } 17 | } 18 | 19 | func testCount() { 20 | do { 21 | let a: Array2D = .init(width: 4, height: 3, element: 42) 22 | let r = a.count 23 | XCTAssertEqual(r, 12) 24 | } 25 | } 26 | 27 | func testSubscriptGet() { 28 | do { 29 | let a: Array2D = .init(width: 4, height: 3, elements: [ 30 | 1, 2, 3, 4, 31 | 5, 6, 7, 8, 32 | 9, 10, 11, 12, 33 | ]) 34 | 35 | XCTAssertEqual(a[0, 0], 1) 36 | XCTAssertEqual(a[1, 0], 2) 37 | XCTAssertEqual(a[2, 0], 3) 38 | XCTAssertEqual(a[3, 0], 4) 39 | 40 | XCTAssertEqual(a[0, 1], 5) 41 | XCTAssertEqual(a[1, 1], 6) 42 | XCTAssertEqual(a[2, 1], 7) 43 | XCTAssertEqual(a[3, 1], 8) 44 | 45 | XCTAssertEqual(a[0, 2], 9) 46 | XCTAssertEqual(a[1, 2], 10) 47 | XCTAssertEqual(a[2, 2], 11) 48 | XCTAssertEqual(a[3, 2], 12) 49 | } 50 | do { 51 | let a: Array2D = .init(width: 4, height: 3, elements: [ 52 | 1, 2, 3, 4, 53 | 5, 6, 7, 8, 54 | 9, 10, 11, 12, 55 | ], outside: -1) 56 | 57 | XCTAssertEqual(a[0, 0], 1) 58 | XCTAssertEqual(a[1, 0], 2) 59 | XCTAssertEqual(a[2, 0], 3) 60 | XCTAssertEqual(a[3, 0], 4) 61 | 62 | XCTAssertEqual(a[0, 1], 5) 63 | XCTAssertEqual(a[1, 1], 6) 64 | XCTAssertEqual(a[2, 1], 7) 65 | XCTAssertEqual(a[3, 1], 8) 66 | 67 | XCTAssertEqual(a[0, 2], 9) 68 | XCTAssertEqual(a[1, 2], 10) 69 | XCTAssertEqual(a[2, 2], 11) 70 | XCTAssertEqual(a[3, 2], 12) 71 | 72 | XCTAssertEqual(a[-1, -1], -1) 73 | XCTAssertEqual(a[4, -1], -1) 74 | XCTAssertEqual(a[-1, 3], -1) 75 | XCTAssertEqual(a[4, 3], -1) 76 | 77 | XCTAssertEqual(a[-1, 0], -1) 78 | XCTAssertEqual(a[0, -1], -1) 79 | XCTAssertEqual(a[4, 0], -1) 80 | XCTAssertEqual(a[0, 3], -1) 81 | } 82 | } 83 | 84 | func testSubscriptSet() { 85 | do { 86 | var a: Array2D = .init(width: 4, height: 3, elements: [ 87 | 1, 2, 3, 4, 88 | 5, 6, 7, 8, 89 | 9, 10, 11, 12, 90 | ], outside: -1) 91 | 92 | a[0, 0] = 100 93 | a[1, 0] = 200 94 | a[2, 0] = 300 95 | a[3, 0] = 400 96 | 97 | a[0, 1] = 500 98 | a[1, 1] = 600 99 | a[2, 1] = 700 100 | a[3, 1] = 800 101 | 102 | a[0, 2] = 900 103 | a[1, 2] = 1000 104 | a[2, 2] = 1100 105 | a[3, 2] = 1200 106 | 107 | a[-1, -1] = -100 108 | a[4, -1] = -100 109 | a[-1, 3] = -100 110 | a[4, 3] = -100 111 | 112 | a[-1, 0] = -100 113 | a[0, -1] = -100 114 | a[4, 0] = -100 115 | a[0, 3] = -100 116 | 117 | XCTAssertEqual(a[0, 0], 100) 118 | XCTAssertEqual(a[1, 0], 200) 119 | XCTAssertEqual(a[2, 0], 300) 120 | XCTAssertEqual(a[3, 0], 400) 121 | 122 | XCTAssertEqual(a[0, 1], 500) 123 | XCTAssertEqual(a[1, 1], 600) 124 | XCTAssertEqual(a[2, 1], 700) 125 | XCTAssertEqual(a[3, 1], 800) 126 | 127 | XCTAssertEqual(a[0, 2], 900) 128 | XCTAssertEqual(a[1, 2], 1000) 129 | XCTAssertEqual(a[2, 2], 1100) 130 | XCTAssertEqual(a[3, 2], 1200) 131 | 132 | XCTAssertEqual(a[-1, -1], -1) 133 | XCTAssertEqual(a[4, -1], -1) 134 | XCTAssertEqual(a[-1, 3], -1) 135 | XCTAssertEqual(a[4, 3], -1) 136 | 137 | XCTAssertEqual(a[-1, 0], -1) 138 | XCTAssertEqual(a[0, -1], -1) 139 | XCTAssertEqual(a[4, 0], -1) 140 | XCTAssertEqual(a[0, 3], -1) 141 | } 142 | } 143 | } 144 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/Array3DTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class Array3DTests: XCTestCase { 5 | func testInit() { 6 | do { 7 | let a: Array3D = .init(width: 4, height: 3, depth: 2, element: 42) 8 | 9 | XCTAssertEqual(a[0, 0, 0], 42) 10 | XCTAssertEqual(a[1, 0, 0], 42) 11 | XCTAssertEqual(a[2, 0, 0], 42) 12 | XCTAssertEqual(a[3, 0, 0], 42) 13 | 14 | XCTAssertEqual(a[0, 1, 0], 42) 15 | XCTAssertEqual(a[1, 1, 0], 42) 16 | XCTAssertEqual(a[2, 1, 0], 42) 17 | XCTAssertEqual(a[3, 1, 0], 42) 18 | 19 | XCTAssertEqual(a[0, 2, 0], 42) 20 | XCTAssertEqual(a[1, 2, 0], 42) 21 | XCTAssertEqual(a[2, 2, 0], 42) 22 | XCTAssertEqual(a[3, 2, 0], 42) 23 | 24 | XCTAssertEqual(a[0, 0, 1], 42) 25 | XCTAssertEqual(a[1, 0, 1], 42) 26 | XCTAssertEqual(a[2, 0, 1], 42) 27 | XCTAssertEqual(a[3, 0, 1], 42) 28 | 29 | XCTAssertEqual(a[0, 1, 1], 42) 30 | XCTAssertEqual(a[1, 1, 1], 42) 31 | XCTAssertEqual(a[2, 1, 1], 42) 32 | XCTAssertEqual(a[3, 1, 1], 42) 33 | 34 | XCTAssertEqual(a[0, 2, 1], 42) 35 | XCTAssertEqual(a[1, 2, 1], 42) 36 | XCTAssertEqual(a[2, 2, 1], 42) 37 | XCTAssertEqual(a[3, 2, 1], 42) 38 | } 39 | } 40 | 41 | func testCount() { 42 | do { 43 | let a: Array3D = .init(width: 5, height: 4, depth: 3, element: 42) 44 | let r = a.count 45 | XCTAssertEqual(r, 60) 46 | } 47 | } 48 | 49 | func testSubscriptGet() { 50 | do { 51 | let a: Array3D = .init(width: 4, height: 3, depth: 2, elements: [ 52 | 1, 2, 3, 4, 53 | 5, 6, 7, 8, 54 | 9, 10, 11, 12, 55 | 56 | 13, 14, 15, 16, 57 | 17, 18, 19, 20, 58 | 21, 22, 23, 24, 59 | ]) 60 | 61 | XCTAssertEqual(a[0, 0, 0], 1) 62 | XCTAssertEqual(a[1, 0, 0], 2) 63 | XCTAssertEqual(a[2, 0, 0], 3) 64 | XCTAssertEqual(a[3, 0, 0], 4) 65 | 66 | XCTAssertEqual(a[0, 1, 0], 5) 67 | XCTAssertEqual(a[1, 1, 0], 6) 68 | XCTAssertEqual(a[2, 1, 0], 7) 69 | XCTAssertEqual(a[3, 1, 0], 8) 70 | 71 | XCTAssertEqual(a[0, 2, 0], 9) 72 | XCTAssertEqual(a[1, 2, 0], 10) 73 | XCTAssertEqual(a[2, 2, 0], 11) 74 | XCTAssertEqual(a[3, 2, 0], 12) 75 | 76 | XCTAssertEqual(a[0, 0, 1], 13) 77 | XCTAssertEqual(a[1, 0, 1], 14) 78 | XCTAssertEqual(a[2, 0, 1], 15) 79 | XCTAssertEqual(a[3, 0, 1], 16) 80 | 81 | XCTAssertEqual(a[0, 1, 1], 17) 82 | XCTAssertEqual(a[1, 1, 1], 18) 83 | XCTAssertEqual(a[2, 1, 1], 19) 84 | XCTAssertEqual(a[3, 1, 1], 20) 85 | 86 | XCTAssertEqual(a[0, 2, 1], 21) 87 | XCTAssertEqual(a[1, 2, 1], 22) 88 | XCTAssertEqual(a[2, 2, 1], 23) 89 | XCTAssertEqual(a[3, 2, 1], 24) 90 | } 91 | do { 92 | let a: Array3D = .init(width: 4, height: 3, depth: 2, elements: [ 93 | 1, 2, 3, 4, 94 | 5, 6, 7, 8, 95 | 9, 10, 11, 12, 96 | 97 | 13, 14, 15, 16, 98 | 17, 18, 19, 20, 99 | 21, 22, 23, 24, 100 | ], outside: -1) 101 | 102 | XCTAssertEqual(a[0, 0, 0], 1) 103 | XCTAssertEqual(a[1, 0, 0], 2) 104 | XCTAssertEqual(a[2, 0, 0], 3) 105 | XCTAssertEqual(a[3, 0, 0], 4) 106 | 107 | XCTAssertEqual(a[0, 1, 0], 5) 108 | XCTAssertEqual(a[1, 1, 0], 6) 109 | XCTAssertEqual(a[2, 1, 0], 7) 110 | XCTAssertEqual(a[3, 1, 0], 8) 111 | 112 | XCTAssertEqual(a[0, 2, 0], 9) 113 | XCTAssertEqual(a[1, 2, 0], 10) 114 | XCTAssertEqual(a[2, 2, 0], 11) 115 | XCTAssertEqual(a[3, 2, 0], 12) 116 | 117 | XCTAssertEqual(a[0, 0, 1], 13) 118 | XCTAssertEqual(a[1, 0, 1], 14) 119 | XCTAssertEqual(a[2, 0, 1], 15) 120 | XCTAssertEqual(a[3, 0, 1], 16) 121 | 122 | XCTAssertEqual(a[0, 1, 1], 17) 123 | XCTAssertEqual(a[1, 1, 1], 18) 124 | XCTAssertEqual(a[2, 1, 1], 19) 125 | XCTAssertEqual(a[3, 1, 1], 20) 126 | 127 | XCTAssertEqual(a[0, 2, 1], 21) 128 | XCTAssertEqual(a[1, 2, 1], 22) 129 | XCTAssertEqual(a[2, 2, 1], 23) 130 | XCTAssertEqual(a[3, 2, 1], 24) 131 | 132 | XCTAssertEqual(a[-1, -1, -1], -1) 133 | XCTAssertEqual(a[4, -1, -1], -1) 134 | XCTAssertEqual(a[-1, 3, -1], -1) 135 | XCTAssertEqual(a[4, 3, -1], -1) 136 | XCTAssertEqual(a[-1, -1, 2], -1) 137 | XCTAssertEqual(a[4, -1, 2], -1) 138 | XCTAssertEqual(a[-1, 3, 2], -1) 139 | XCTAssertEqual(a[4, 3, 2], -1) 140 | 141 | XCTAssertEqual(a[-1, 0, 0], -1) 142 | XCTAssertEqual(a[0, -1, 0], -1) 143 | XCTAssertEqual(a[0, 0, -1], -1) 144 | XCTAssertEqual(a[4, 0, 0], -1) 145 | XCTAssertEqual(a[0, 3, 0], -1) 146 | XCTAssertEqual(a[0, 0, 2], -1) 147 | } 148 | } 149 | 150 | func testSubscriptSet() { 151 | do { 152 | var a: Array3D = .init(width: 4, height: 3, depth: 2, elements: [ 153 | 1, 2, 3, 4, 154 | 5, 6, 7, 8, 155 | 9, 10, 11, 12, 156 | 157 | 13, 14, 15, 16, 158 | 17, 18, 19, 20, 159 | 21, 22, 23, 24, 160 | ], outside: -1) 161 | 162 | a[0, 0, 0] = 100 163 | a[1, 0, 0] = 200 164 | a[2, 0, 0] = 300 165 | a[3, 0, 0] = 400 166 | 167 | a[0, 1, 0] = 500 168 | a[1, 1, 0] = 600 169 | a[2, 1, 0] = 700 170 | a[3, 1, 0] = 800 171 | 172 | a[0, 2, 0] = 900 173 | a[1, 2, 0] = 1000 174 | a[2, 2, 0] = 1100 175 | a[3, 2, 0] = 1200 176 | 177 | a[0, 0, 1] = 1300 178 | a[1, 0, 1] = 1400 179 | a[2, 0, 1] = 1500 180 | a[3, 0, 1] = 1600 181 | 182 | a[0, 1, 1] = 1700 183 | a[1, 1, 1] = 1800 184 | a[2, 1, 1] = 1900 185 | a[3, 1, 1] = 2000 186 | 187 | a[0, 2, 1] = 2100 188 | a[1, 2, 1] = 2200 189 | a[2, 2, 1] = 2300 190 | a[3, 2, 1] = 2400 191 | 192 | a[-1, -1, -1] = -100 193 | a[4, -1, -1] = -100 194 | a[-1, 3, -1] = -100 195 | a[4, 3, -1] = -100 196 | a[-1, -1, 2] = -100 197 | a[4, -1, 2] = -100 198 | a[-1, 3, 2] = -100 199 | a[4, 3, 2] = -100 200 | 201 | a[-1, 0, 0] = -100 202 | a[0, -1, 0] = -100 203 | a[0, 0, -1] = -100 204 | a[4, 0, 0] = -100 205 | a[0, 3, 0] = -100 206 | a[0, 0, 2] = -100 207 | 208 | XCTAssertEqual(a[0, 0, 0], 100) 209 | XCTAssertEqual(a[1, 0, 0], 200) 210 | XCTAssertEqual(a[2, 0, 0], 300) 211 | XCTAssertEqual(a[3, 0, 0], 400) 212 | 213 | XCTAssertEqual(a[0, 1, 0], 500) 214 | XCTAssertEqual(a[1, 1, 0], 600) 215 | XCTAssertEqual(a[2, 1, 0], 700) 216 | XCTAssertEqual(a[3, 1, 0], 800) 217 | 218 | XCTAssertEqual(a[0, 2, 0], 900) 219 | XCTAssertEqual(a[1, 2, 0], 1000) 220 | XCTAssertEqual(a[2, 2, 0], 1100) 221 | XCTAssertEqual(a[3, 2, 0], 1200) 222 | 223 | XCTAssertEqual(a[0, 0, 1], 1300) 224 | XCTAssertEqual(a[1, 0, 1], 1400) 225 | XCTAssertEqual(a[2, 0, 1], 1500) 226 | XCTAssertEqual(a[3, 0, 1], 1600) 227 | 228 | XCTAssertEqual(a[0, 1, 1], 1700) 229 | XCTAssertEqual(a[1, 1, 1], 1800) 230 | XCTAssertEqual(a[2, 1, 1], 1900) 231 | XCTAssertEqual(a[3, 1, 1], 2000) 232 | 233 | XCTAssertEqual(a[0, 2, 1], 2100) 234 | XCTAssertEqual(a[1, 2, 1], 2200) 235 | XCTAssertEqual(a[2, 2, 1], 2300) 236 | XCTAssertEqual(a[3, 2, 1], 2400) 237 | 238 | XCTAssertEqual(a[-1, -1, -1], -1) 239 | XCTAssertEqual(a[4, -1, -1], -1) 240 | XCTAssertEqual(a[-1, 3, -1], -1) 241 | XCTAssertEqual(a[4, 3, -1], -1) 242 | XCTAssertEqual(a[-1, -1, 2], -1) 243 | XCTAssertEqual(a[4, -1, 2], -1) 244 | XCTAssertEqual(a[-1, 3, 2], -1) 245 | XCTAssertEqual(a[4, 3, 2], -1) 246 | 247 | XCTAssertEqual(a[-1, 0, 0], -1) 248 | XCTAssertEqual(a[0, -1, 0], -1) 249 | XCTAssertEqual(a[0, 0, -1], -1) 250 | XCTAssertEqual(a[4, 0, 0], -1) 251 | XCTAssertEqual(a[0, 3, 0], -1) 252 | XCTAssertEqual(a[0, 0, 2], -1) 253 | } 254 | } 255 | } 256 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/ArrayNDTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class ArrayNDTests: XCTestCase { 5 | func testInit() { 6 | do { 7 | let a: ArrayND = .init(lengths: [3, 2], element: 42) 8 | 9 | XCTAssertEqual(a[0, 0], 42) 10 | XCTAssertEqual(a[1, 0], 42) 11 | XCTAssertEqual(a[2, 0], 42) 12 | 13 | XCTAssertEqual(a[0, 1], 42) 14 | XCTAssertEqual(a[1, 1], 42) 15 | XCTAssertEqual(a[2, 1], 42) 16 | } 17 | do { 18 | let a: ArrayND = .init(lengths: [4, 3, 2], element: 42) 19 | 20 | XCTAssertEqual(a[0, 0, 0], 42) 21 | XCTAssertEqual(a[1, 0, 0], 42) 22 | XCTAssertEqual(a[2, 0, 0], 42) 23 | XCTAssertEqual(a[3, 0, 0], 42) 24 | 25 | XCTAssertEqual(a[0, 1, 0], 42) 26 | XCTAssertEqual(a[1, 1, 0], 42) 27 | XCTAssertEqual(a[2, 1, 0], 42) 28 | XCTAssertEqual(a[3, 1, 0], 42) 29 | 30 | XCTAssertEqual(a[0, 2, 0], 42) 31 | XCTAssertEqual(a[1, 2, 0], 42) 32 | XCTAssertEqual(a[2, 2, 0], 42) 33 | XCTAssertEqual(a[3, 2, 0], 42) 34 | 35 | XCTAssertEqual(a[0, 0, 1], 42) 36 | XCTAssertEqual(a[1, 0, 1], 42) 37 | XCTAssertEqual(a[2, 0, 1], 42) 38 | XCTAssertEqual(a[3, 0, 1], 42) 39 | 40 | XCTAssertEqual(a[0, 1, 1], 42) 41 | XCTAssertEqual(a[1, 1, 1], 42) 42 | XCTAssertEqual(a[2, 1, 1], 42) 43 | XCTAssertEqual(a[3, 1, 1], 42) 44 | 45 | XCTAssertEqual(a[0, 2, 1], 42) 46 | XCTAssertEqual(a[1, 2, 1], 42) 47 | XCTAssertEqual(a[2, 2, 1], 42) 48 | XCTAssertEqual(a[3, 2, 1], 42) 49 | } 50 | } 51 | 52 | func testCount() { 53 | do { 54 | let a: ArrayND = .init(lengths: [4, 3], element: 42) 55 | let r = a.count 56 | XCTAssertEqual(r, 12) 57 | } 58 | do { 59 | let a: ArrayND = .init(lengths: [5, 4, 3], element: 42) 60 | let r = a.count 61 | XCTAssertEqual(r, 60) 62 | } 63 | } 64 | 65 | func testSubscriptGet() { 66 | do { 67 | let a: ArrayND = .init(lengths: [4, 3], elements: [ 68 | 1, 2, 3, 4, 69 | 5, 6, 7, 8, 70 | 9, 10, 11, 12, 71 | ]) 72 | 73 | XCTAssertEqual(a[0, 0], 1) 74 | XCTAssertEqual(a[1, 0], 2) 75 | XCTAssertEqual(a[2, 0], 3) 76 | XCTAssertEqual(a[3, 0], 4) 77 | 78 | XCTAssertEqual(a[0, 1], 5) 79 | XCTAssertEqual(a[1, 1], 6) 80 | XCTAssertEqual(a[2, 1], 7) 81 | XCTAssertEqual(a[3, 1], 8) 82 | 83 | XCTAssertEqual(a[0, 2], 9) 84 | XCTAssertEqual(a[1, 2], 10) 85 | XCTAssertEqual(a[2, 2], 11) 86 | XCTAssertEqual(a[3, 2], 12) 87 | } 88 | do { 89 | let a: ArrayND = .init(lengths: [4, 3, 2], elements: [ 90 | 1, 2, 3, 4, 91 | 5, 6, 7, 8, 92 | 9, 10, 11, 12, 93 | 94 | 13, 14, 15, 16, 95 | 17, 18, 19, 20, 96 | 21, 22, 23, 24, 97 | ]) 98 | 99 | XCTAssertEqual(a[0, 0, 0], 1) 100 | XCTAssertEqual(a[1, 0, 0], 2) 101 | XCTAssertEqual(a[2, 0, 0], 3) 102 | XCTAssertEqual(a[3, 0, 0], 4) 103 | 104 | XCTAssertEqual(a[0, 1, 0], 5) 105 | XCTAssertEqual(a[1, 1, 0], 6) 106 | XCTAssertEqual(a[2, 1, 0], 7) 107 | XCTAssertEqual(a[3, 1, 0], 8) 108 | 109 | XCTAssertEqual(a[0, 2, 0], 9) 110 | XCTAssertEqual(a[1, 2, 0], 10) 111 | XCTAssertEqual(a[2, 2, 0], 11) 112 | XCTAssertEqual(a[3, 2, 0], 12) 113 | 114 | XCTAssertEqual(a[0, 0, 1], 13) 115 | XCTAssertEqual(a[1, 0, 1], 14) 116 | XCTAssertEqual(a[2, 0, 1], 15) 117 | XCTAssertEqual(a[3, 0, 1], 16) 118 | 119 | XCTAssertEqual(a[0, 1, 1], 17) 120 | XCTAssertEqual(a[1, 1, 1], 18) 121 | XCTAssertEqual(a[2, 1, 1], 19) 122 | XCTAssertEqual(a[3, 1, 1], 20) 123 | 124 | XCTAssertEqual(a[0, 2, 1], 21) 125 | XCTAssertEqual(a[1, 2, 1], 22) 126 | XCTAssertEqual(a[2, 2, 1], 23) 127 | XCTAssertEqual(a[3, 2, 1], 24) 128 | } 129 | do { 130 | let a: ArrayND = .init(lengths: [4, 3], elements: [ 131 | 1, 2, 3, 4, 132 | 5, 6, 7, 8, 133 | 9, 10, 11, 12, 134 | ], outside: -1) 135 | 136 | XCTAssertEqual(a[0, 0], 1) 137 | XCTAssertEqual(a[1, 0], 2) 138 | XCTAssertEqual(a[2, 0], 3) 139 | XCTAssertEqual(a[3, 0], 4) 140 | 141 | XCTAssertEqual(a[0, 1], 5) 142 | XCTAssertEqual(a[1, 1], 6) 143 | XCTAssertEqual(a[2, 1], 7) 144 | XCTAssertEqual(a[3, 1], 8) 145 | 146 | XCTAssertEqual(a[0, 2], 9) 147 | XCTAssertEqual(a[1, 2], 10) 148 | XCTAssertEqual(a[2, 2], 11) 149 | XCTAssertEqual(a[3, 2], 12) 150 | 151 | XCTAssertEqual(a[-1, -1], -1) 152 | XCTAssertEqual(a[4, -1], -1) 153 | XCTAssertEqual(a[-1, 3], -1) 154 | XCTAssertEqual(a[4, 3], -1) 155 | 156 | XCTAssertEqual(a[-1, 0], -1) 157 | XCTAssertEqual(a[0, -1], -1) 158 | XCTAssertEqual(a[4, 0], -1) 159 | XCTAssertEqual(a[0, 3], -1) 160 | } 161 | do { 162 | let a: ArrayND = .init(lengths: [4, 3, 2], elements: [ 163 | 1, 2, 3, 4, 164 | 5, 6, 7, 8, 165 | 9, 10, 11, 12, 166 | 167 | 13, 14, 15, 16, 168 | 17, 18, 19, 20, 169 | 21, 22, 23, 24, 170 | ], outside: -1) 171 | 172 | XCTAssertEqual(a[0, 0, 0], 1) 173 | XCTAssertEqual(a[1, 0, 0], 2) 174 | XCTAssertEqual(a[2, 0, 0], 3) 175 | XCTAssertEqual(a[3, 0, 0], 4) 176 | 177 | XCTAssertEqual(a[0, 1, 0], 5) 178 | XCTAssertEqual(a[1, 1, 0], 6) 179 | XCTAssertEqual(a[2, 1, 0], 7) 180 | XCTAssertEqual(a[3, 1, 0], 8) 181 | 182 | XCTAssertEqual(a[0, 2, 0], 9) 183 | XCTAssertEqual(a[1, 2, 0], 10) 184 | XCTAssertEqual(a[2, 2, 0], 11) 185 | XCTAssertEqual(a[3, 2, 0], 12) 186 | 187 | XCTAssertEqual(a[0, 0, 1], 13) 188 | XCTAssertEqual(a[1, 0, 1], 14) 189 | XCTAssertEqual(a[2, 0, 1], 15) 190 | XCTAssertEqual(a[3, 0, 1], 16) 191 | 192 | XCTAssertEqual(a[0, 1, 1], 17) 193 | XCTAssertEqual(a[1, 1, 1], 18) 194 | XCTAssertEqual(a[2, 1, 1], 19) 195 | XCTAssertEqual(a[3, 1, 1], 20) 196 | 197 | XCTAssertEqual(a[0, 2, 1], 21) 198 | XCTAssertEqual(a[1, 2, 1], 22) 199 | XCTAssertEqual(a[2, 2, 1], 23) 200 | XCTAssertEqual(a[3, 2, 1], 24) 201 | 202 | XCTAssertEqual(a[-1, -1, -1], -1) 203 | XCTAssertEqual(a[4, -1, -1], -1) 204 | XCTAssertEqual(a[-1, 3, -1], -1) 205 | XCTAssertEqual(a[4, 3, -1], -1) 206 | XCTAssertEqual(a[-1, -1, 2], -1) 207 | XCTAssertEqual(a[4, -1, 2], -1) 208 | XCTAssertEqual(a[-1, 3, 2], -1) 209 | XCTAssertEqual(a[4, 3, 2], -1) 210 | 211 | XCTAssertEqual(a[-1, 0, 0], -1) 212 | XCTAssertEqual(a[0, -1, 0], -1) 213 | XCTAssertEqual(a[0, 0, -1], -1) 214 | XCTAssertEqual(a[4, 0, 0], -1) 215 | XCTAssertEqual(a[0, 3, 0], -1) 216 | XCTAssertEqual(a[0, 0, 2], -1) 217 | } 218 | } 219 | 220 | func testSubscriptSet() { 221 | do { 222 | var a: ArrayND = .init(lengths: [4, 3], elements: [ 223 | 1, 2, 3, 4, 224 | 5, 6, 7, 8, 225 | 9, 10, 11, 12, 226 | ], outside: -1) 227 | 228 | a[0, 0] = 100 229 | a[1, 0] = 200 230 | a[2, 0] = 300 231 | a[3, 0] = 400 232 | 233 | a[0, 1] = 500 234 | a[1, 1] = 600 235 | a[2, 1] = 700 236 | a[3, 1] = 800 237 | 238 | a[0, 2] = 900 239 | a[1, 2] = 1000 240 | a[2, 2] = 1100 241 | a[3, 2] = 1200 242 | 243 | a[-1, -1] = -100 244 | a[4, -1] = -100 245 | a[-1, 3] = -100 246 | a[4, 3] = -100 247 | 248 | a[-1, 0] = -100 249 | a[0, -1] = -100 250 | a[4, 0] = -100 251 | a[0, 3] = -100 252 | 253 | XCTAssertEqual(a[0, 0], 100) 254 | XCTAssertEqual(a[1, 0], 200) 255 | XCTAssertEqual(a[2, 0], 300) 256 | XCTAssertEqual(a[3, 0], 400) 257 | 258 | XCTAssertEqual(a[0, 1], 500) 259 | XCTAssertEqual(a[1, 1], 600) 260 | XCTAssertEqual(a[2, 1], 700) 261 | XCTAssertEqual(a[3, 1], 800) 262 | 263 | XCTAssertEqual(a[0, 2], 900) 264 | XCTAssertEqual(a[1, 2], 1000) 265 | XCTAssertEqual(a[2, 2], 1100) 266 | XCTAssertEqual(a[3, 2], 1200) 267 | 268 | XCTAssertEqual(a[-1, -1], -1) 269 | XCTAssertEqual(a[4, -1], -1) 270 | XCTAssertEqual(a[-1, 3], -1) 271 | XCTAssertEqual(a[4, 3], -1) 272 | 273 | XCTAssertEqual(a[-1, 0], -1) 274 | XCTAssertEqual(a[0, -1], -1) 275 | XCTAssertEqual(a[4, 0], -1) 276 | XCTAssertEqual(a[0, 3], -1) 277 | } 278 | do { 279 | var a: ArrayND = .init(lengths: [4, 3, 2], elements: [ 280 | 1, 2, 3, 4, 281 | 5, 6, 7, 8, 282 | 9, 10, 11, 12, 283 | 284 | 13, 14, 15, 16, 285 | 17, 18, 19, 20, 286 | 21, 22, 23, 24, 287 | ], outside: -1) 288 | 289 | a[0, 0, 0] = 100 290 | a[1, 0, 0] = 200 291 | a[2, 0, 0] = 300 292 | a[3, 0, 0] = 400 293 | 294 | a[0, 1, 0] = 500 295 | a[1, 1, 0] = 600 296 | a[2, 1, 0] = 700 297 | a[3, 1, 0] = 800 298 | 299 | a[0, 2, 0] = 900 300 | a[1, 2, 0] = 1000 301 | a[2, 2, 0] = 1100 302 | a[3, 2, 0] = 1200 303 | 304 | a[0, 0, 1] = 1300 305 | a[1, 0, 1] = 1400 306 | a[2, 0, 1] = 1500 307 | a[3, 0, 1] = 1600 308 | 309 | a[0, 1, 1] = 1700 310 | a[1, 1, 1] = 1800 311 | a[2, 1, 1] = 1900 312 | a[3, 1, 1] = 2000 313 | 314 | a[0, 2, 1] = 2100 315 | a[1, 2, 1] = 2200 316 | a[2, 2, 1] = 2300 317 | a[3, 2, 1] = 2400 318 | 319 | a[-1, -1, -1] = -100 320 | a[4, -1, -1] = -100 321 | a[-1, 3, -1] = -100 322 | a[4, 3, -1] = -100 323 | a[-1, -1, 2] = -100 324 | a[4, -1, 2] = -100 325 | a[-1, 3, 2] = -100 326 | a[4, 3, 2] = -100 327 | 328 | a[-1, 0, 0] = -100 329 | a[0, -1, 0] = -100 330 | a[0, 0, -1] = -100 331 | a[4, 0, 0] = -100 332 | a[0, 3, 0] = -100 333 | a[0, 0, 2] = -100 334 | 335 | XCTAssertEqual(a[0, 0, 0], 100) 336 | XCTAssertEqual(a[1, 0, 0], 200) 337 | XCTAssertEqual(a[2, 0, 0], 300) 338 | XCTAssertEqual(a[3, 0, 0], 400) 339 | 340 | XCTAssertEqual(a[0, 1, 0], 500) 341 | XCTAssertEqual(a[1, 1, 0], 600) 342 | XCTAssertEqual(a[2, 1, 0], 700) 343 | XCTAssertEqual(a[3, 1, 0], 800) 344 | 345 | XCTAssertEqual(a[0, 2, 0], 900) 346 | XCTAssertEqual(a[1, 2, 0], 1000) 347 | XCTAssertEqual(a[2, 2, 0], 1100) 348 | XCTAssertEqual(a[3, 2, 0], 1200) 349 | 350 | XCTAssertEqual(a[0, 0, 1], 1300) 351 | XCTAssertEqual(a[1, 0, 1], 1400) 352 | XCTAssertEqual(a[2, 0, 1], 1500) 353 | XCTAssertEqual(a[3, 0, 1], 1600) 354 | 355 | XCTAssertEqual(a[0, 1, 1], 1700) 356 | XCTAssertEqual(a[1, 1, 1], 1800) 357 | XCTAssertEqual(a[2, 1, 1], 1900) 358 | XCTAssertEqual(a[3, 1, 1], 2000) 359 | 360 | XCTAssertEqual(a[0, 2, 1], 2100) 361 | XCTAssertEqual(a[1, 2, 1], 2200) 362 | XCTAssertEqual(a[2, 2, 1], 2300) 363 | XCTAssertEqual(a[3, 2, 1], 2400) 364 | 365 | XCTAssertEqual(a[-1, -1, -1], -1) 366 | XCTAssertEqual(a[4, -1, -1], -1) 367 | XCTAssertEqual(a[-1, 3, -1], -1) 368 | XCTAssertEqual(a[4, 3, -1], -1) 369 | XCTAssertEqual(a[-1, -1, 2], -1) 370 | XCTAssertEqual(a[4, -1, 2], -1) 371 | XCTAssertEqual(a[-1, 3, 2], -1) 372 | XCTAssertEqual(a[4, 3, 2], -1) 373 | 374 | XCTAssertEqual(a[-1, 0, 0], -1) 375 | XCTAssertEqual(a[0, -1, 0], -1) 376 | XCTAssertEqual(a[0, 0, -1], -1) 377 | XCTAssertEqual(a[4, 0, 0], -1) 378 | XCTAssertEqual(a[0, 3, 0], -1) 379 | XCTAssertEqual(a[0, 0, 2], -1) 380 | } 381 | } 382 | } 383 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/AtCoderSupportTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | import AtCoderSupport 3 | 4 | final class AtCoderSupportTests: XCTestCase { 5 | func testExample() { 6 | } 7 | } 8 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/BFSTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class BFSTests: XCTestCase { 5 | func testBFS() { 6 | do { // Trees 7 | // 0 --+-> 1 --+-> 3 8 | // | +-> 4 9 | // +-> 2 --+-> 5 10 | // +-> 6 11 | let edges = [ 12 | [1, 2], 13 | [3, 4], 14 | [5, 6], 15 | [], 16 | [], 17 | [], 18 | [], 19 | ] 20 | 21 | do { 22 | var r: [Int] = [] 23 | bfs(edges: edges, startedAt: 0) { i in 24 | r.append(i) 25 | } 26 | XCTAssertEqual(r, [0, 1, 2, 3, 4, 5, 6]) 27 | } 28 | do { // Subtrees 29 | var r: [Int] = [] 30 | bfs(edges: edges, startedAt: 2) { i in 31 | r.append(i) 32 | } 33 | XCTAssertEqual(r, [2, 5, 6]) 34 | } 35 | do { // Leaves 36 | var r: [Int] = [] 37 | bfs(edges: edges, startedAt: 4) { i in 38 | r.append(i) 39 | } 40 | XCTAssertEqual(r, [4]) 41 | } 42 | } 43 | 44 | do { // Complex Graphs 45 | // 0 <-+-> 1 <-+-> 3 --> 0 46 | // ^^ | +-> 4 --> 0 47 | // || +-> 2 <-+-> 5 --> 0 48 | // ++ +-> 6 --> 0 49 | let edges = [ 50 | [0, 1, 2], 51 | [0, 3, 4], 52 | [0, 5, 6], 53 | [1, 0], 54 | [1, 0], 55 | [2, 0], 56 | [2, 0], 57 | ] 58 | 59 | do { 60 | var r: [Int] = [] 61 | bfs(edges: edges, startedAt: 0) { i in 62 | r.append(i) 63 | } 64 | XCTAssertEqual(r, [0, 1, 2, 3, 4, 5, 6]) 65 | } 66 | do { 67 | var r: [Int] = [] 68 | bfs(edges: edges, startedAt: 2) { i in 69 | r.append(i) 70 | } 71 | XCTAssertEqual(r, [2, 0, 5, 6, 1, 3, 4]) 72 | } 73 | do { 74 | var r: [Int] = [] 75 | bfs(edges: edges, startedAt: 4) { i in 76 | r.append(i) 77 | } 78 | XCTAssertEqual(r, [4, 1, 0, 3, 2, 5, 6]) 79 | } 80 | } 81 | } 82 | 83 | func testBFSWithPrev() { 84 | do { // Trees 85 | // 0 --+-> 1 --+-> 3 86 | // | +-> 4 87 | // +-> 2 --+-> 5 88 | // +-> 6 89 | let edges = [ 90 | [1, 2], 91 | [3, 4], 92 | [5, 6], 93 | [], 94 | [], 95 | [], 96 | [], 97 | ] 98 | 99 | do { 100 | var currents: [Int] = [] 101 | var prevs: [Int?] = [] 102 | bfs(edges: edges, startedAt: 0) { current, prev in 103 | currents.append(current) 104 | prevs.append(prev) 105 | } 106 | XCTAssertEqual(currents, [0, 1, 2, 3, 4, 5, 6]) 107 | XCTAssertEqual(prevs, [nil, 0, 0, 1, 1, 2, 2]) 108 | } 109 | do { // Subtrees 110 | var currents: [Int] = [] 111 | var prevs: [Int?] = [] 112 | bfs(edges: edges, startedAt: 2) { current, prev in 113 | currents.append(current) 114 | prevs.append(prev) 115 | } 116 | XCTAssertEqual(currents, [2, 5, 6]) 117 | XCTAssertEqual(prevs, [nil, 2, 2]) 118 | } 119 | do { // Leaves 120 | var currents: [Int] = [] 121 | var prevs: [Int?] = [] 122 | bfs(edges: edges, startedAt: 4) { current, prev in 123 | currents.append(current) 124 | prevs.append(prev) 125 | } 126 | XCTAssertEqual(currents, [4]) 127 | XCTAssertEqual(prevs, [nil]) 128 | } 129 | } 130 | 131 | do { // Complex Graphs 132 | // 0 <-+-> 1 <-+-> 3 --> 0 133 | // ^^ | +-> 4 --> 0 134 | // || +-> 2 <-+-> 5 --> 0 135 | // ++ +-> 6 --> 0 136 | let edges = [ 137 | [0, 1, 2], 138 | [0, 3, 4], 139 | [0, 5, 6], 140 | [1, 0], 141 | [1, 0], 142 | [2, 0], 143 | [2, 0], 144 | ] 145 | 146 | do { 147 | var currents: [Int] = [] 148 | var prevs: [Int?] = [] 149 | bfs(edges: edges, startedAt: 0) { current, prev in 150 | currents.append(current) 151 | prevs.append(prev) 152 | } 153 | XCTAssertEqual(currents, [0, 1, 2, 3, 4, 5, 6]) 154 | XCTAssertEqual(prevs, [nil, 0, 0, 1, 1, 2, 2]) 155 | } 156 | do { 157 | var currents: [Int] = [] 158 | var prevs: [Int?] = [] 159 | bfs(edges: edges, startedAt: 2) { current, prev in 160 | currents.append(current) 161 | prevs.append(prev) 162 | } 163 | XCTAssertEqual(currents, [2, 0, 5, 6, 1, 3, 4]) 164 | XCTAssertEqual(prevs, [nil, 2, 2, 2, 0, 1, 1]) 165 | } 166 | do { 167 | var currents: [Int] = [] 168 | var prevs: [Int?] = [] 169 | bfs(edges: edges, startedAt: 4) { current, prev in 170 | currents.append(current) 171 | prevs.append(prev) 172 | } 173 | XCTAssertEqual(currents, [4, 1, 0, 3, 2, 5, 6]) 174 | XCTAssertEqual(prevs, [nil, 4, 4, 1, 0, 2, 2]) 175 | } 176 | } 177 | } 178 | 179 | func testBFSWithPrevDepth() { 180 | do { // Trees 181 | // 0 --+-> 1 --+-> 3 182 | // | +-> 4 183 | // +-> 2 --+-> 5 184 | // +-> 6 185 | let edges = [ 186 | [1, 2], 187 | [3, 4], 188 | [5, 6], 189 | [], 190 | [], 191 | [], 192 | [], 193 | ] 194 | 195 | do { 196 | var currents: [Int] = [] 197 | var prevs: [Int?] = [] 198 | var depths: [Int] = [] 199 | bfs(edges: edges, startedAt: 0) { current, prev, depth in 200 | currents.append(current) 201 | prevs.append(prev) 202 | depths.append(depth) 203 | } 204 | XCTAssertEqual(currents, [0, 1, 2, 3, 4, 5, 6]) 205 | XCTAssertEqual(prevs, [nil, 0, 0, 1, 1, 2, 2]) 206 | XCTAssertEqual(depths, [0, 1, 1, 2, 2, 2, 2]) 207 | } 208 | do { // Subtrees 209 | var currents: [Int] = [] 210 | var prevs: [Int?] = [] 211 | var depths: [Int] = [] 212 | bfs(edges: edges, startedAt: 2) { current, prev, depth in 213 | currents.append(current) 214 | prevs.append(prev) 215 | depths.append(depth) 216 | } 217 | XCTAssertEqual(currents, [2, 5, 6]) 218 | XCTAssertEqual(prevs, [nil, 2, 2]) 219 | XCTAssertEqual(depths, [0, 1, 1]) 220 | } 221 | do { // Leaves 222 | var currents: [Int] = [] 223 | var prevs: [Int?] = [] 224 | var depths: [Int] = [] 225 | bfs(edges: edges, startedAt: 4) { current, prev, depth in 226 | currents.append(current) 227 | prevs.append(prev) 228 | depths.append(depth) 229 | } 230 | XCTAssertEqual(currents, [4]) 231 | XCTAssertEqual(prevs, [nil]) 232 | XCTAssertEqual(depths, [0]) 233 | } 234 | } 235 | 236 | do { // Complex Graphs 237 | // 0 <-+-> 1 <-+-> 3 --> 0 238 | // ^^ | +-> 4 --> 0 239 | // || +-> 2 <-+-> 5 --> 0 240 | // ++ +-> 6 --> 0 241 | let edges = [ 242 | [0, 1, 2], 243 | [0, 3, 4], 244 | [0, 5, 6], 245 | [1, 0], 246 | [1, 0], 247 | [2, 0], 248 | [2, 0], 249 | ] 250 | 251 | do { 252 | var currents: [Int] = [] 253 | var prevs: [Int?] = [] 254 | var depths: [Int] = [] 255 | bfs(edges: edges, startedAt: 0) { current, prev, depth in 256 | currents.append(current) 257 | prevs.append(prev) 258 | depths.append(depth) 259 | } 260 | XCTAssertEqual(currents, [0, 1, 2, 3, 4, 5, 6]) 261 | XCTAssertEqual(prevs, [nil, 0, 0, 1, 1, 2, 2]) 262 | XCTAssertEqual(depths, [0, 1, 1, 2, 2, 2, 2]) 263 | } 264 | do { 265 | var currents: [Int] = [] 266 | var prevs: [Int?] = [] 267 | var depths: [Int] = [] 268 | bfs(edges: edges, startedAt: 2) { current, prev, depth in 269 | currents.append(current) 270 | prevs.append(prev) 271 | depths.append(depth) 272 | } 273 | XCTAssertEqual(currents, [2, 0, 5, 6, 1, 3, 4]) 274 | XCTAssertEqual(prevs, [nil, 2, 2, 2, 0, 1, 1]) 275 | XCTAssertEqual(depths, [0, 1, 1, 1, 2, 3, 3]) 276 | } 277 | do { 278 | var currents: [Int] = [] 279 | var prevs: [Int?] = [] 280 | var depths: [Int] = [] 281 | bfs(edges: edges, startedAt: 4) { current, prev, depth in 282 | currents.append(current) 283 | prevs.append(prev) 284 | depths.append(depth) 285 | } 286 | XCTAssertEqual(currents, [4, 1, 0, 3, 2, 5, 6]) 287 | XCTAssertEqual(prevs, [nil, 4, 4, 1, 0, 2, 2]) 288 | XCTAssertEqual(depths, [0, 1, 1, 2, 2, 3, 3]) 289 | } 290 | } 291 | } 292 | 293 | #if !DEBUG 294 | func testBFSPerformance() { 295 | let n = (1 << 20) - 1 296 | let edges: [[Int]] = (1 ... n).map { 297 | let left = $0 << 1 298 | let right = left + 1 299 | if right <= n { 300 | return [left - 1, right - 1] 301 | } else if left <= n { 302 | return [left - 1] 303 | } else { 304 | return [] 305 | } 306 | } 307 | measure { 308 | var count = 0 309 | bfs(edges: edges, startedAt: 0) { _ in count += 1 } 310 | XCTAssertEqual(count, edges.count) 311 | } 312 | } 313 | 314 | func testBFSWithPrevPerformance() { 315 | let n = (1 << 20) - 1 316 | let edges: [[Int]] = (1 ... n).map { 317 | let left = $0 << 1 318 | let right = left + 1 319 | if right <= n { 320 | return [left - 1, right - 1] 321 | } else if left <= n { 322 | return [left - 1] 323 | } else { 324 | return [] 325 | } 326 | } 327 | measure { 328 | var count = 0 329 | bfs(edges: edges, startedAt: 0) { _, _ in count += 1 } 330 | XCTAssertEqual(count, edges.count) 331 | } 332 | } 333 | 334 | func testBFSWithPrevDepthPerformance() { 335 | let n = (1 << 20) - 1 336 | let edges: [[Int]] = (1 ... n).map { 337 | let left = $0 << 1 338 | let right = left + 1 339 | if right <= n { 340 | return [left - 1, right - 1] 341 | } else if left <= n { 342 | return [left - 1] 343 | } else { 344 | return [] 345 | } 346 | } 347 | measure { 348 | var count = 0 349 | bfs(edges: edges, startedAt: 0) { _, _, _ in count += 1 } 350 | XCTAssertEqual(count, edges.count) 351 | } 352 | } 353 | #endif 354 | } 355 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/BellmanFordTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class BellmanFordTests: XCTestCase { 5 | func testBellmanFord() { 6 | do { 7 | // A -- 5 -> B <-- 4 --> C 8 | // | | ^ 9 | // | | | 10 | // 3 2 1 ----- 11 | // | | | 12 | // V V | 13 | // D <- 7 -> E <---- 14 | // 15 | // F <- 6 -> G 16 | let graph = (count: 7, edges: [ 17 | (from: 0, to: 1, distance: 5), 18 | (from: 0, to: 3, distance: 3), 19 | (from: 1, to: 2, distance: 4), 20 | (from: 1, to: 4, distance: 2), 21 | (from: 2, to: 1, distance: 4), 22 | (from: 2, to: 4, distance: 1), 23 | (from: 3, to: 4, distance: 7), 24 | (from: 4, to: 2, distance: 1), 25 | (from: 4, to: 3, distance: 7), 26 | (from: 5, to: 6, distance: 6), 27 | (from: 6, to: 5, distance: 6), 28 | ]) 29 | do { 30 | let r = bellmanFord(graph: graph, startedAt: 0) 31 | XCTAssertEqual(r, [(0, false), (5, false), (8, false), (3, false), (7, false), nil, nil]) 32 | } 33 | do { 34 | let r = bellmanFord(graph: graph, startedAt: 1) 35 | XCTAssertEqual(r, [nil, (0, false), (3, false), (9, false), (2, false), nil, nil]) 36 | } 37 | do { 38 | let r = bellmanFord(graph: graph, startedAt: 2) 39 | XCTAssertEqual(r, [nil, (4, false), (0, false), (8, false), (1, false), nil, nil]) 40 | } 41 | do { 42 | let r = bellmanFord(graph: graph, startedAt: 3) 43 | XCTAssertEqual(r, [nil, (12, false), (8, false), (0, false), (7, false), nil, nil]) 44 | } 45 | do { 46 | let r = bellmanFord(graph: graph, startedAt: 4) 47 | XCTAssertEqual(r, [nil, (5, false), (1, false), (7, false), (0, false), nil, nil]) 48 | } 49 | do { 50 | let r = bellmanFord(graph: graph, startedAt: 5) 51 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (0, false), (6, false)]) 52 | } 53 | do { 54 | let r = bellmanFord(graph: graph, startedAt: 6) 55 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (6, false), (0, false)]) 56 | } 57 | } 58 | do { // 負の辺 59 | // A -- 5 -> B <-- 4 --> C 60 | // | | ^ 61 | // | | | 62 | // 3 -2 1 ----- 63 | // | | | 64 | // V V | 65 | // D <- 7 -> E <---- 66 | // 67 | // F <- 6 -> G 68 | let graph = (count: 7, edges: [ 69 | (from: 0, to: 1, distance: 5), 70 | (from: 0, to: 3, distance: 3), 71 | (from: 1, to: 2, distance: 4), 72 | (from: 1, to: 4, distance: -2), 73 | (from: 2, to: 1, distance: 4), 74 | (from: 2, to: 4, distance: 1), 75 | (from: 3, to: 4, distance: 7), 76 | (from: 4, to: 2, distance: 1), 77 | (from: 4, to: 3, distance: 7), 78 | (from: 5, to: 6, distance: 6), 79 | (from: 6, to: 5, distance: 6), 80 | ]) 81 | do { 82 | let r = bellmanFord(graph: graph, startedAt: 0) 83 | XCTAssertEqual(r, [(0, false), (5, false), (4, false), (3, false), (3, false), nil, nil]) 84 | } 85 | do { 86 | let r = bellmanFord(graph: graph, startedAt: 1) 87 | XCTAssertEqual(r, [nil, (0, false), (-1, false), (5, false), (-2, false), nil, nil]) 88 | } 89 | do { 90 | let r = bellmanFord(graph: graph, startedAt: 2) 91 | XCTAssertEqual(r, [nil, (4, false), (0, false), (8, false), (1, false), nil, nil]) 92 | } 93 | do { 94 | let r = bellmanFord(graph: graph, startedAt: 3) 95 | XCTAssertEqual(r, [nil, (12, false), (8, false), (0, false), (7, false), nil, nil]) 96 | } 97 | do { 98 | let r = bellmanFord(graph: graph, startedAt: 4) 99 | XCTAssertEqual(r, [nil, (5, false), (1, false), (7, false), (0, false), nil, nil]) 100 | } 101 | do { 102 | let r = bellmanFord(graph: graph, startedAt: 5) 103 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (0, false), (6, false)]) 104 | } 105 | do { 106 | let r = bellmanFord(graph: graph, startedAt: 6) 107 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (6, false), (0, false)]) 108 | } 109 | } 110 | do { // 負の閉路 111 | // A -- 5 -> B <-- 2 --> C 112 | // | | ^ 113 | // | | | 114 | // 3 -4 1 ----- 115 | // | | | 116 | // V V | 117 | // D <- 7 -> E <---- 118 | // 119 | // F <- 6 -> G 120 | let graph = (count: 7, edges: [ 121 | (from: 0, to: 1, distance: 5), 122 | (from: 0, to: 3, distance: 3), 123 | (from: 1, to: 2, distance: 2), 124 | (from: 1, to: 4, distance: -4), 125 | (from: 2, to: 1, distance: 2), 126 | (from: 2, to: 4, distance: 1), 127 | (from: 3, to: 4, distance: 7), 128 | (from: 4, to: 2, distance: 1), 129 | (from: 4, to: 3, distance: 7), 130 | (from: 5, to: 6, distance: 6), 131 | (from: 6, to: 5, distance: 6), 132 | ]) 133 | do { 134 | let r = bellmanFord(graph: graph, startedAt: 0) 135 | XCTAssertEqual(r[0], (0, false)) 136 | XCTAssertEqual(r[1]!.1, true) 137 | XCTAssertEqual(r[2]!.1, true) 138 | XCTAssertEqual(r[3]!.1, true) 139 | XCTAssertEqual(r[4]!.1, true) 140 | XCTAssertEqual(r[5], nil) 141 | XCTAssertEqual(r[6], nil) 142 | } 143 | do { 144 | let r = bellmanFord(graph: graph, startedAt: 1) 145 | XCTAssertEqual(r[0], nil) 146 | XCTAssertEqual(r[1]!.1, true) 147 | XCTAssertEqual(r[2]!.1, true) 148 | XCTAssertEqual(r[3]!.1, true) 149 | XCTAssertEqual(r[4]!.1, true) 150 | XCTAssertEqual(r[5], nil) 151 | XCTAssertEqual(r[6], nil) 152 | } 153 | do { 154 | let r = bellmanFord(graph: graph, startedAt: 3) 155 | XCTAssertEqual(r[0], nil) 156 | XCTAssertEqual(r[1]!.1, true) 157 | XCTAssertEqual(r[2]!.1, true) 158 | XCTAssertEqual(r[3]!.1, true) 159 | XCTAssertEqual(r[4]!.1, true) 160 | XCTAssertEqual(r[5], nil) 161 | XCTAssertEqual(r[6], nil) 162 | print(r) 163 | } 164 | do { 165 | let r = bellmanFord(graph: graph, startedAt: 4) 166 | XCTAssertEqual(r[0], nil) 167 | XCTAssertEqual(r[1]!.1, true) 168 | XCTAssertEqual(r[2]!.1, true) 169 | XCTAssertEqual(r[3]!.1, true) 170 | XCTAssertEqual(r[4]!.1, true) 171 | XCTAssertEqual(r[5], nil) 172 | XCTAssertEqual(r[6], nil) 173 | } 174 | do { 175 | let r = bellmanFord(graph: graph, startedAt: 5) 176 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (0, false), (6, false)]) 177 | } 178 | do { 179 | let r = bellmanFord(graph: graph, startedAt: 6) 180 | XCTAssertEqual(r, [nil, nil, nil, nil, nil, (6, false), (0, false)]) 181 | } 182 | } 183 | } 184 | } 185 | 186 | // FIXME: SE-0283 でタプルが Equatable になったら除去 187 | private func XCTAssertEqual(_ expression1: [(T, Bool)?], _ expression2: [(T, Bool)?]) { 188 | XCTAssertEqual(expression1.count, expression2.count) 189 | guard expression1.count == expression2.count else { return } 190 | for (a, b) in zip(expression1, expression2) { 191 | XCTAssertEqual(a, b) 192 | } 193 | } 194 | private func XCTAssertEqual(_ expression1: (T, Bool)?, _ expression2: (T, Bool)?) { 195 | switch (expression1, expression2) { 196 | case (.some((let t1, let f1)), .some((let t2, let f2))): 197 | XCTAssertEqual(t1, t2) 198 | XCTAssertEqual(f1, f2) 199 | case (.some((let t1, let f1)), .none): 200 | XCTFail("(\(t1), \(f1)) != nil") 201 | case (.none, .some((let t2, let f2))): 202 | XCTFail("nil != (\(t2), \(f2))") 203 | case (.none, .none): 204 | break 205 | } 206 | } 207 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/BinarySearchTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class BinarySearchTests: XCTestCase { 5 | func testValuesLT() { 6 | do { 7 | let a = [0, 1, 1, 2, 3, 5, 8] 8 | do { 9 | let r = a.values(<, -1) 10 | XCTAssertEqual(r, []) 11 | } 12 | do { 13 | let r = a.values(<, 0) 14 | XCTAssertEqual(r, []) 15 | } 16 | do { 17 | let r = a.values(<, 1) 18 | XCTAssertEqual(r, [0]) 19 | } 20 | do { 21 | let r = a.values(<, 2) 22 | XCTAssertEqual(r, [0, 1, 1]) 23 | } 24 | do { 25 | let r = a.values(<, 3) 26 | XCTAssertEqual(r, [0, 1, 1, 2]) 27 | } 28 | do { 29 | let r = a.values(<, 4) 30 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 31 | } 32 | do { 33 | let r = a.values(<, 5) 34 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 35 | } 36 | do { 37 | let r = a.values(<, 6) 38 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 39 | } 40 | do { 41 | let r = a.values(<, 7) 42 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 43 | } 44 | do { 45 | let r = a.values(<, 8) 46 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 47 | } 48 | do { 49 | let r = a.values(<, 9) 50 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 51 | } 52 | do { 53 | let r = a.values(<, 10) 54 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 55 | } 56 | } 57 | do { // predicate 58 | let a = [0, 1, 1, 2, 3, 5, 8] 59 | do { 60 | let r = a.values(<) { $0 < -1 } 61 | XCTAssertEqual(r, []) 62 | } 63 | do { 64 | let r = a.values(<) { $0 < 0 } 65 | XCTAssertEqual(r, []) 66 | } 67 | do { 68 | let r = a.values(<) { $0 < 1 } 69 | XCTAssertEqual(r, [0]) 70 | } 71 | do { 72 | let r = a.values(<) { $0 < 2 } 73 | XCTAssertEqual(r, [0, 1, 1]) 74 | } 75 | do { 76 | let r = a.values(<) { $0 < 3 } 77 | XCTAssertEqual(r, [0, 1, 1, 2]) 78 | } 79 | do { 80 | let r = a.values(<) { $0 < 4 } 81 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 82 | } 83 | do { 84 | let r = a.values(<) { $0 < 5 } 85 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 86 | } 87 | do { 88 | let r = a.values(<) { $0 < 6 } 89 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 90 | } 91 | do { 92 | let r = a.values(<) { $0 < 7 } 93 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 94 | } 95 | do { 96 | let r = a.values(<) { $0 < 8 } 97 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 98 | } 99 | do { 100 | let r = a.values(<) { $0 < 9 } 101 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 102 | } 103 | do { 104 | let r = a.values(<) { $0 < 10 } 105 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 106 | } 107 | } 108 | do { // Collections but `Array`s 109 | let a: ArraySlice = [0, 1, 1, 2, 3, 5, 8, 13][1 ..< 7] 110 | do { 111 | let r = a.values(<, -1) 112 | XCTAssertEqual(r, []) 113 | } 114 | do { 115 | let r = a.values(<, 0) 116 | XCTAssertEqual(r, []) 117 | } 118 | do { 119 | let r = a.values(<, 1) 120 | XCTAssertEqual(r, []) 121 | } 122 | do { 123 | let r = a.values(<, 2) 124 | XCTAssertEqual(r, [1, 1]) 125 | } 126 | do { 127 | let r = a.values(<, 3) 128 | XCTAssertEqual(r, [1, 1, 2]) 129 | } 130 | do { 131 | let r = a.values(<, 4) 132 | XCTAssertEqual(r, [1, 1, 2, 3]) 133 | } 134 | do { 135 | let r = a.values(<, 5) 136 | XCTAssertEqual(r, [1, 1, 2, 3]) 137 | } 138 | do { 139 | let r = a.values(<, 6) 140 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 141 | } 142 | do { 143 | let r = a.values(<, 7) 144 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 145 | } 146 | do { 147 | let r = a.values(<, 8) 148 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 149 | } 150 | do { 151 | let r = a.values(<, 9) 152 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 153 | } 154 | do { 155 | let r = a.values(<, 10) 156 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 157 | } 158 | } 159 | do { // Overflow of `low + high` 160 | let a = (Int.max - 10) ..< Int.max 161 | let r = a.values(<, Int.max - 3) 162 | XCTAssertEqual(r.count, 7) 163 | } 164 | } 165 | 166 | func testValuesLE() { 167 | do { 168 | let a = [0, 1, 1, 2, 3, 5, 8] 169 | do { 170 | let r = a.values(<=, -2) 171 | XCTAssertEqual(r, []) 172 | } 173 | do { 174 | let r = a.values(<=, -1) 175 | XCTAssertEqual(r, []) 176 | } 177 | do { 178 | let r = a.values(<=, 0) 179 | XCTAssertEqual(r, [0]) 180 | } 181 | do { 182 | let r = a.values(<=, 1) 183 | XCTAssertEqual(r, [0, 1, 1]) 184 | } 185 | do { 186 | let r = a.values(<=, 2) 187 | XCTAssertEqual(r, [0, 1, 1, 2]) 188 | } 189 | do { 190 | let r = a.values(<=, 3) 191 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 192 | } 193 | do { 194 | let r = a.values(<=, 4) 195 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 196 | } 197 | do { 198 | let r = a.values(<=, 5) 199 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 200 | } 201 | do { 202 | let r = a.values(<=, 6) 203 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 204 | } 205 | do { 206 | let r = a.values(<=, 7) 207 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 208 | } 209 | do { 210 | let r = a.values(<=, 8) 211 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 212 | } 213 | do { 214 | let r = a.values(<=, 9) 215 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 216 | } 217 | do { 218 | let r = a.values(<=, 10) 219 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 220 | } 221 | } 222 | do { // predict 223 | let a = [0, 1, 1, 2, 3, 5, 8] 224 | do { 225 | let r = a.values(<=) { $0 <= -2 } 226 | XCTAssertEqual(r, []) 227 | } 228 | do { 229 | let r = a.values(<=) { $0 <= -1 } 230 | XCTAssertEqual(r, []) 231 | } 232 | do { 233 | let r = a.values(<=) { $0 <= 0 } 234 | XCTAssertEqual(r, [0]) 235 | } 236 | do { 237 | let r = a.values(<=) { $0 <= 1 } 238 | XCTAssertEqual(r, [0, 1, 1]) 239 | } 240 | do { 241 | let r = a.values(<=) { $0 <= 2 } 242 | XCTAssertEqual(r, [0, 1, 1, 2]) 243 | } 244 | do { 245 | let r = a.values(<=) { $0 <= 3 } 246 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 247 | } 248 | do { 249 | let r = a.values(<=) { $0 <= 4 } 250 | XCTAssertEqual(r, [0, 1, 1, 2, 3]) 251 | } 252 | do { 253 | let r = a.values(<=) { $0 <= 5 } 254 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 255 | } 256 | do { 257 | let r = a.values(<=) { $0 <= 6 } 258 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 259 | } 260 | do { 261 | let r = a.values(<=) { $0 <= 7 } 262 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5]) 263 | } 264 | do { 265 | let r = a.values(<=) { $0 <= 8 } 266 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 267 | } 268 | do { 269 | let r = a.values(<=) { $0 <= 9 } 270 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 271 | } 272 | do { 273 | let r = a.values(<=) { $0 <= 10 } 274 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 275 | } 276 | } 277 | do { // Collections but `Array`s 278 | let a: ArraySlice = [0, 1, 1, 2, 3, 5, 8, 13][1 ..< 7] 279 | do { 280 | let r = a.values(<=, -2) 281 | XCTAssertEqual(r, []) 282 | } 283 | do { 284 | let r = a.values(<=, -1) 285 | XCTAssertEqual(r, []) 286 | } 287 | do { 288 | let r = a.values(<=, 0) 289 | XCTAssertEqual(r, []) 290 | } 291 | do { 292 | let r = a.values(<=, 1) 293 | XCTAssertEqual(r, [1, 1]) 294 | } 295 | do { 296 | let r = a.values(<=, 2) 297 | XCTAssertEqual(r, [1, 1, 2]) 298 | } 299 | do { 300 | let r = a.values(<=, 3) 301 | XCTAssertEqual(r, [1, 1, 2, 3]) 302 | } 303 | do { 304 | let r = a.values(<=, 4) 305 | XCTAssertEqual(r, [1, 1, 2, 3]) 306 | } 307 | do { 308 | let r = a.values(<=, 5) 309 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 310 | } 311 | do { 312 | let r = a.values(<=, 6) 313 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 314 | } 315 | do { 316 | let r = a.values(<=, 7) 317 | XCTAssertEqual(r, [1, 1, 2, 3, 5]) 318 | } 319 | do { 320 | let r = a.values(<=, 8) 321 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 322 | } 323 | do { 324 | let r = a.values(<=, 9) 325 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 326 | } 327 | do { 328 | let r = a.values(<=, 10) 329 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 330 | } 331 | } 332 | do { // Overflow of `low + high` 333 | let a = (Int.max - 10) ..< Int.max 334 | let r = a.values(<=, Int.max - 3) 335 | XCTAssertEqual(r.count, 8) 336 | } 337 | } 338 | 339 | func testValuesGT() { 340 | do { 341 | let a = [0, 1, 1, 2, 3, 5, 8] 342 | do { 343 | let r = a.values(>, -2) 344 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 345 | } 346 | do { 347 | let r = a.values(>, -1) 348 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 349 | } 350 | do { 351 | let r = a.values(>, 0) 352 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 353 | } 354 | do { 355 | let r = a.values(>, 1) 356 | XCTAssertEqual(r, [2, 3, 5, 8]) 357 | } 358 | do { 359 | let r = a.values(>, 2) 360 | XCTAssertEqual(r, [3, 5, 8]) 361 | } 362 | do { 363 | let r = a.values(>, 3) 364 | XCTAssertEqual(r, [5, 8]) 365 | } 366 | do { 367 | let r = a.values(>, 4) 368 | XCTAssertEqual(r, [5, 8]) 369 | } 370 | do { 371 | let r = a.values(>, 5) 372 | XCTAssertEqual(r, [8]) 373 | } 374 | do { 375 | let r = a.values(>, 6) 376 | XCTAssertEqual(r, [8]) 377 | } 378 | do { 379 | let r = a.values(>, 7) 380 | XCTAssertEqual(r, [8]) 381 | } 382 | do { 383 | let r = a.values(>, 8) 384 | XCTAssertEqual(r, []) 385 | } 386 | do { 387 | let r = a.values(>, 9) 388 | XCTAssertEqual(r, []) 389 | } 390 | } 391 | do { // predict 392 | let a = [0, 1, 1, 2, 3, 5, 8] 393 | do { 394 | let r = a.values(>) { $0 > -2 } 395 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 396 | } 397 | do { 398 | let r = a.values(>) { $0 > -1 } 399 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 400 | } 401 | do { 402 | let r = a.values(>) { $0 > 0 } 403 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 404 | } 405 | do { 406 | let r = a.values(>) { $0 > 1 } 407 | XCTAssertEqual(r, [2, 3, 5, 8]) 408 | } 409 | do { 410 | let r = a.values(>) { $0 > 2 } 411 | XCTAssertEqual(r, [3, 5, 8]) 412 | } 413 | do { 414 | let r = a.values(>) { $0 > 3 } 415 | XCTAssertEqual(r, [5, 8]) 416 | } 417 | do { 418 | let r = a.values(>) { $0 > 4 } 419 | XCTAssertEqual(r, [5, 8]) 420 | } 421 | do { 422 | let r = a.values(>) { $0 > 5 } 423 | XCTAssertEqual(r, [8]) 424 | } 425 | do { 426 | let r = a.values(>) { $0 > 6 } 427 | XCTAssertEqual(r, [8]) 428 | } 429 | do { 430 | let r = a.values(>) { $0 > 7 } 431 | XCTAssertEqual(r, [8]) 432 | } 433 | do { 434 | let r = a.values(>) { $0 > 8 } 435 | XCTAssertEqual(r, []) 436 | } 437 | do { 438 | let r = a.values(>) { $0 > 9 } 439 | XCTAssertEqual(r, []) 440 | } 441 | } 442 | do { // Collections but `Array`s 443 | let a: ArraySlice = [0, 1, 1, 2, 3, 5, 8, 13][1 ..< 7] 444 | do { 445 | let r = a.values(>, -1) 446 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 447 | } 448 | do { 449 | let r = a.values(>, 0) 450 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 451 | } 452 | do { 453 | let r = a.values(>, 1) 454 | XCTAssertEqual(r, [2, 3, 5, 8]) 455 | } 456 | do { 457 | let r = a.values(>, 2) 458 | XCTAssertEqual(r, [3, 5, 8]) 459 | } 460 | do { 461 | let r = a.values(>, 3) 462 | XCTAssertEqual(r, [5, 8]) 463 | } 464 | do { 465 | let r = a.values(>, 4) 466 | XCTAssertEqual(r, [5, 8]) 467 | } 468 | do { 469 | let r = a.values(>, 5) 470 | XCTAssertEqual(r, [8]) 471 | } 472 | do { 473 | let r = a.values(>, 6) 474 | XCTAssertEqual(r, [8]) 475 | } 476 | do { 477 | let r = a.values(>, 7) 478 | XCTAssertEqual(r, [8]) 479 | } 480 | do { 481 | let r = a.values(>, 8) 482 | XCTAssertEqual(r, []) 483 | } 484 | do { 485 | let r = a.values(>, 9) 486 | XCTAssertEqual(r, []) 487 | } 488 | } 489 | do { // Overflow of `low + high` 490 | let a = (Int.max - 10) ..< Int.max 491 | let r = a.values(>, Int.max - 3) 492 | XCTAssertEqual(r.count, 2) 493 | } 494 | } 495 | 496 | func testValuesGE() { 497 | do { 498 | let a = [0, 1, 1, 2, 3, 5, 8] 499 | do { 500 | let r = a.values(>=, -2) 501 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 502 | } 503 | do { 504 | let r = a.values(>=, -1) 505 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 506 | } 507 | do { 508 | let r = a.values(>=, 0) 509 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 510 | } 511 | do { 512 | let r = a.values(>=, 1) 513 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 514 | } 515 | do { 516 | let r = a.values(>=, 2) 517 | XCTAssertEqual(r, [2, 3, 5, 8]) 518 | } 519 | do { 520 | let r = a.values(>=, 3) 521 | XCTAssertEqual(r, [3, 5, 8]) 522 | } 523 | do { 524 | let r = a.values(>=, 4) 525 | XCTAssertEqual(r, [5, 8]) 526 | } 527 | do { 528 | let r = a.values(>=, 5) 529 | XCTAssertEqual(r, [5, 8]) 530 | } 531 | do { 532 | let r = a.values(>=, 6) 533 | XCTAssertEqual(r, [8]) 534 | } 535 | do { 536 | let r = a.values(>=, 7) 537 | XCTAssertEqual(r, [8]) 538 | } 539 | do { 540 | let r = a.values(>=, 8) 541 | XCTAssertEqual(r, [8]) 542 | } 543 | do { 544 | let r = a.values(>=, 9) 545 | XCTAssertEqual(r, []) 546 | } 547 | do { 548 | let r = a.values(>=, 10) 549 | XCTAssertEqual(r, []) 550 | } 551 | } 552 | do { // predict 553 | let a = [0, 1, 1, 2, 3, 5, 8] 554 | do { 555 | let r = a.values(>=) { $0 >= -2 } 556 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 557 | } 558 | do { 559 | let r = a.values(>=) { $0 >= -1 } 560 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 561 | } 562 | do { 563 | let r = a.values(>=) { $0 >= 0 } 564 | XCTAssertEqual(r, [0, 1, 1, 2, 3, 5, 8]) 565 | } 566 | do { 567 | let r = a.values(>=) { $0 >= 1 } 568 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 569 | } 570 | do { 571 | let r = a.values(>=) { $0 >= 2 } 572 | XCTAssertEqual(r, [2, 3, 5, 8]) 573 | } 574 | do { 575 | let r = a.values(>=) { $0 >= 3 } 576 | XCTAssertEqual(r, [3, 5, 8]) 577 | } 578 | do { 579 | let r = a.values(>=) { $0 >= 4 } 580 | XCTAssertEqual(r, [5, 8]) 581 | } 582 | do { 583 | let r = a.values(>=) { $0 >= 5 } 584 | XCTAssertEqual(r, [5, 8]) 585 | } 586 | do { 587 | let r = a.values(>=) { $0 >= 6 } 588 | XCTAssertEqual(r, [8]) 589 | } 590 | do { 591 | let r = a.values(>=) { $0 >= 7 } 592 | XCTAssertEqual(r, [8]) 593 | } 594 | do { 595 | let r = a.values(>=) { $0 >= 8 } 596 | XCTAssertEqual(r, [8]) 597 | } 598 | do { 599 | let r = a.values(>=) { $0 >= 9 } 600 | XCTAssertEqual(r, []) 601 | } 602 | do { 603 | let r = a.values(>=) { $0 >= 10 } 604 | XCTAssertEqual(r, []) 605 | } 606 | } 607 | do { // Collections but `Array`s 608 | let a: ArraySlice = [0, 1, 1, 2, 3, 5, 8, 13][1 ..< 7] 609 | do { 610 | let r = a.values(>=, -1) 611 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 612 | } 613 | do { 614 | let r = a.values(>=, 0) 615 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 616 | } 617 | do { 618 | let r = a.values(>=, 1) 619 | XCTAssertEqual(r, [1, 1, 2, 3, 5, 8]) 620 | } 621 | do { 622 | let r = a.values(>=, 2) 623 | XCTAssertEqual(r, [2, 3, 5, 8]) 624 | } 625 | do { 626 | let r = a.values(>=, 3) 627 | XCTAssertEqual(r, [3, 5, 8]) 628 | } 629 | do { 630 | let r = a.values(>=, 4) 631 | XCTAssertEqual(r, [5, 8]) 632 | } 633 | do { 634 | let r = a.values(>=, 5) 635 | XCTAssertEqual(r, [5, 8]) 636 | } 637 | do { 638 | let r = a.values(>=, 6) 639 | XCTAssertEqual(r, [8]) 640 | } 641 | do { 642 | let r = a.values(>=, 7) 643 | XCTAssertEqual(r, [8]) 644 | } 645 | do { 646 | let r = a.values(>=, 8) 647 | XCTAssertEqual(r, [8]) 648 | } 649 | do { 650 | let r = a.values(>=, 9) 651 | XCTAssertEqual(r, []) 652 | } 653 | do { 654 | let r = a.values(>=, 10) 655 | XCTAssertEqual(r, []) 656 | } 657 | } 658 | do { // Overflow of `low + high` 659 | let a = (Int.max - 10) ..< Int.max 660 | let r = a.values(>=, Int.max - 3) 661 | XCTAssertEqual(r.count, 3) 662 | } 663 | } 664 | 665 | #if !DEBUG 666 | func testValuesLTPerformance() { 667 | let a = 0 ..< 10_000_000_000_000 668 | measure { 669 | let r = a.values(<, 9_000_000_000_000) 670 | XCTAssertEqual(r.count, 9_000_000_000_000) 671 | } 672 | } 673 | 674 | func testValuesLEPerformance() { 675 | let a = 0 ..< 10_000_000_000_000 676 | measure { 677 | let r = a.values(<=, 9_000_000_000_000) 678 | XCTAssertEqual(r.count, 9_000_000_000_001) 679 | } 680 | } 681 | 682 | func testValuesGTPerformance() { 683 | let a = 0 ..< 10_000_000_000_000 684 | measure { 685 | let r = a.values(>, 9_000_000_000_000) 686 | XCTAssertEqual(r.count, 999_999_999_999) 687 | } 688 | } 689 | 690 | func testValuesGEPerformance() { 691 | let a = 0 ..< 10_000_000_000_000 692 | measure { 693 | let r = a.values(>=, 9_000_000_000_000) 694 | XCTAssertEqual(r.count, 1_000_000_000_000) 695 | } 696 | } 697 | #endif 698 | } 699 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/CombinationsTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class CombinationsTests: XCTestCase { 5 | func testNcr() { 6 | XCTAssertEqual(ncr(7, 0, modulus: nil), 1) 7 | XCTAssertEqual(ncr(7, 1, modulus: nil), 7) 8 | XCTAssertEqual(ncr(7, 2, modulus: nil), 21) 9 | XCTAssertEqual(ncr(7, 3, modulus: nil), 35) 10 | XCTAssertEqual(ncr(7, 4, modulus: nil), 35) 11 | XCTAssertEqual(ncr(7, 5, modulus: nil), 21) 12 | XCTAssertEqual(ncr(7, 6, modulus: nil), 7) 13 | XCTAssertEqual(ncr(7, 7, modulus: nil), 1) 14 | 15 | XCTAssertEqual(ncr(0, 0, modulus: nil), 1) 16 | 17 | XCTAssertEqual(ncr(7, 0, modulus: 11), 1) 18 | XCTAssertEqual(ncr(7, 1, modulus: 11), 7) 19 | XCTAssertEqual(ncr(7, 2, modulus: 11), 10) 20 | XCTAssertEqual(ncr(7, 3, modulus: 11), 2) 21 | XCTAssertEqual(ncr(7, 4, modulus: 11), 2) 22 | XCTAssertEqual(ncr(7, 5, modulus: 11), 10) 23 | XCTAssertEqual(ncr(7, 6, modulus: 11), 7) 24 | XCTAssertEqual(ncr(7, 7, modulus: 11), 1) 25 | 26 | XCTAssertEqual(ncr(7 as UInt, 4, modulus: nil), 35) 27 | XCTAssertEqual(ncr(7, 4, modulus: 998244353), 35) 28 | } 29 | } 30 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/DFSTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class DFSTests: XCTestCase { 5 | func testDFS() { 6 | do { // Trees 7 | // 0 --+-> 1 --+-> 3 8 | // | +-> 4 9 | // +-> 2 --+-> 5 10 | // +-> 6 11 | let edges = [ 12 | [1, 2], 13 | [3, 4], 14 | [5, 6], 15 | [], 16 | [], 17 | [], 18 | [], 19 | ] 20 | 21 | do { 22 | var r: [Int] = [] 23 | dfs(edges: edges, startedAt: 0) { i in 24 | r.append(i) 25 | } 26 | XCTAssertEqual(r, [0, 1, 3, 4, 2, 5, 6]) 27 | } 28 | do { // Subtrees 29 | var r: [Int] = [] 30 | dfs(edges: edges, startedAt: 2) { i in 31 | r.append(i) 32 | } 33 | XCTAssertEqual(r, [2, 5, 6]) 34 | } 35 | do { // Leaves 36 | var r: [Int] = [] 37 | dfs(edges: edges, startedAt: 4) { i in 38 | r.append(i) 39 | } 40 | XCTAssertEqual(r, [4]) 41 | } 42 | } 43 | 44 | do { // Complex Graphs 45 | // 0 <-+-> 1 <-+-> 3 --> 0 46 | // ^^ | +-> 4 --> 0 47 | // || +-> 2 <-+-> 5 --> 0 48 | // ++ +-> 6 --> 0 49 | let edges = [ 50 | [0, 1, 2], 51 | [0, 3, 4], 52 | [0, 5, 6], 53 | [1, 0], 54 | [1, 0], 55 | [2, 0], 56 | [2, 0], 57 | ] 58 | 59 | do { 60 | var r: [Int] = [] 61 | dfs(edges: edges, startedAt: 0) { i in 62 | r.append(i) 63 | } 64 | XCTAssertEqual(r, [0, 1, 3, 4, 2, 5, 6]) 65 | } 66 | do { 67 | var r: [Int] = [] 68 | dfs(edges: edges, startedAt: 2) { i in 69 | r.append(i) 70 | } 71 | XCTAssertEqual(r, [2, 0, 1, 3, 4, 5, 6]) 72 | } 73 | do { 74 | var r: [Int] = [] 75 | dfs(edges: edges, startedAt: 4) { i in 76 | r.append(i) 77 | } 78 | XCTAssertEqual(r, [4, 1, 0, 2, 5, 6, 3]) 79 | } 80 | } 81 | } 82 | 83 | func testDFSWithPrev() { 84 | do { // Trees 85 | // 0 --+-> 1 --+-> 3 86 | // | +-> 4 87 | // +-> 2 --+-> 5 88 | // +-> 6 89 | let edges = [ 90 | [1, 2], 91 | [3, 4], 92 | [5, 6], 93 | [], 94 | [], 95 | [], 96 | [], 97 | ] 98 | 99 | do { 100 | var currents: [Int] = [] 101 | var prevs: [Int?] = [] 102 | dfs(edges: edges, startedAt: 0) { current, prev in 103 | currents.append(current) 104 | prevs.append(prev) 105 | } 106 | XCTAssertEqual(currents, [0, 1, 3, 4, 2, 5, 6]) 107 | XCTAssertEqual(prevs, [nil, 0, 1, 1, 0, 2, 2]) 108 | } 109 | do { // Subtrees 110 | var currents: [Int] = [] 111 | var prevs: [Int?] = [] 112 | dfs(edges: edges, startedAt: 2) { current, prev in 113 | currents.append(current) 114 | prevs.append(prev) 115 | } 116 | XCTAssertEqual(currents, [2, 5, 6]) 117 | XCTAssertEqual(prevs, [nil, 2, 2]) 118 | } 119 | do { // Leaves 120 | var currents: [Int] = [] 121 | var prevs: [Int?] = [] 122 | dfs(edges: edges, startedAt: 4) { current, prev in 123 | currents.append(current) 124 | prevs.append(prev) 125 | } 126 | XCTAssertEqual(currents, [4]) 127 | XCTAssertEqual(prevs, [nil]) 128 | } 129 | } 130 | 131 | do { // Complex Graphs 132 | // 0 <-+-> 1 <-+-> 3 --> 0 133 | // ^^ | +-> 4 --> 0 134 | // || +-> 2 <-+-> 5 --> 0 135 | // ++ +-> 6 --> 0 136 | let edges = [ 137 | [0, 1, 2], 138 | [0, 3, 4], 139 | [0, 5, 6], 140 | [1, 0], 141 | [1, 0], 142 | [2, 0], 143 | [2, 0], 144 | ] 145 | 146 | do { 147 | var currents: [Int] = [] 148 | var prevs: [Int?] = [] 149 | dfs(edges: edges, startedAt: 0) { current, prev in 150 | currents.append(current) 151 | prevs.append(prev) 152 | } 153 | XCTAssertEqual(currents, [0, 1, 3, 4, 2, 5, 6]) 154 | XCTAssertEqual(prevs, [nil, 0, 1, 1, 0, 2, 2]) 155 | } 156 | do { 157 | var currents: [Int] = [] 158 | var prevs: [Int?] = [] 159 | dfs(edges: edges, startedAt: 2) { current, prev in 160 | currents.append(current) 161 | prevs.append(prev) 162 | } 163 | XCTAssertEqual(currents, [2, 0, 1, 3, 4, 5, 6]) 164 | XCTAssertEqual(prevs, [nil, 2, 0, 1, 1, 2, 2]) 165 | } 166 | do { 167 | var currents: [Int] = [] 168 | var prevs: [Int?] = [] 169 | dfs(edges: edges, startedAt: 4) { current, prev in 170 | currents.append(current) 171 | prevs.append(prev) 172 | } 173 | XCTAssertEqual(currents, [4, 1, 0, 2, 5, 6, 3]) 174 | XCTAssertEqual(prevs, [nil, 4, 1, 0, 2, 2, 1]) 175 | } 176 | } 177 | } 178 | 179 | func testDFSWithPrevDepth() { 180 | do { // Trees 181 | // 0 --+-> 1 --+-> 3 182 | // | +-> 4 183 | // +-> 2 --+-> 5 184 | // +-> 6 185 | let edges = [ 186 | [1, 2], 187 | [3, 4], 188 | [5, 6], 189 | [], 190 | [], 191 | [], 192 | [], 193 | ] 194 | 195 | do { 196 | var currents: [Int] = [] 197 | var prevs: [Int?] = [] 198 | var depths: [Int] = [] 199 | dfs(edges: edges, startedAt: 0) { current, prev, depth in 200 | currents.append(current) 201 | prevs.append(prev) 202 | depths.append(depth) 203 | } 204 | XCTAssertEqual(currents, [0, 1, 3, 4, 2, 5, 6]) 205 | XCTAssertEqual(prevs, [nil, 0, 1, 1, 0, 2, 2]) 206 | XCTAssertEqual(depths, [0, 1, 2, 2, 1, 2, 2]) 207 | } 208 | do { // Subtrees 209 | var currents: [Int] = [] 210 | var prevs: [Int?] = [] 211 | var depths: [Int] = [] 212 | dfs(edges: edges, startedAt: 2) { current, prev, depth in 213 | currents.append(current) 214 | prevs.append(prev) 215 | depths.append(depth) 216 | } 217 | XCTAssertEqual(currents, [2, 5, 6]) 218 | XCTAssertEqual(prevs, [nil, 2, 2]) 219 | XCTAssertEqual(depths, [0, 1, 1]) 220 | } 221 | do { // Leaves 222 | var currents: [Int] = [] 223 | var prevs: [Int?] = [] 224 | var depths: [Int] = [] 225 | dfs(edges: edges, startedAt: 4) { current, prev, depth in 226 | currents.append(current) 227 | prevs.append(prev) 228 | depths.append(depth) 229 | } 230 | XCTAssertEqual(currents, [4]) 231 | XCTAssertEqual(prevs, [nil]) 232 | XCTAssertEqual(depths, [0]) 233 | } 234 | } 235 | 236 | do { // Complex Graphs 237 | // 0 <-+-> 1 <-+-> 3 --> 0 238 | // ^^ | +-> 4 --> 0 239 | // || +-> 2 <-+-> 5 --> 0 240 | // ++ +-> 6 --> 0 241 | let edges = [ 242 | [0, 1, 2], 243 | [0, 3, 4], 244 | [0, 5, 6], 245 | [1, 0], 246 | [1, 0], 247 | [2, 0], 248 | [2, 0], 249 | ] 250 | 251 | do { 252 | var currents: [Int] = [] 253 | var prevs: [Int?] = [] 254 | var depths: [Int] = [] 255 | dfs(edges: edges, startedAt: 0) { current, prev, depth in 256 | currents.append(current) 257 | prevs.append(prev) 258 | depths.append(depth) 259 | } 260 | XCTAssertEqual(currents, [0, 1, 3, 4, 2, 5, 6]) 261 | XCTAssertEqual(prevs, [nil, 0, 1, 1, 0, 2, 2]) 262 | XCTAssertEqual(depths, [0, 1, 2, 2, 1, 2, 2]) 263 | } 264 | do { 265 | var currents: [Int] = [] 266 | var prevs: [Int?] = [] 267 | var depths: [Int] = [] 268 | dfs(edges: edges, startedAt: 2) { current, prev, depth in 269 | currents.append(current) 270 | prevs.append(prev) 271 | depths.append(depth) 272 | } 273 | XCTAssertEqual(currents, [2, 0, 1, 3, 4, 5, 6]) 274 | XCTAssertEqual(prevs, [nil, 2, 0, 1, 1, 2, 2]) 275 | XCTAssertEqual(depths, [0, 1, 2, 3, 3, 1, 1]) 276 | } 277 | do { 278 | var currents: [Int] = [] 279 | var prevs: [Int?] = [] 280 | var depths: [Int] = [] 281 | dfs(edges: edges, startedAt: 4) { current, prev, depth in 282 | currents.append(current) 283 | prevs.append(prev) 284 | depths.append(depth) 285 | } 286 | XCTAssertEqual(currents, [4, 1, 0, 2, 5, 6, 3]) 287 | XCTAssertEqual(prevs, [nil, 4, 1, 0, 2, 2, 1]) 288 | XCTAssertEqual(depths, [0, 1, 2, 3, 4, 4, 2]) 289 | } 290 | } 291 | } 292 | 293 | #if !DEBUG 294 | func testDFSPerformance() { 295 | let n = (1 << 20) - 1 296 | let edges: [[Int]] = (1 ... n).map { 297 | let left = $0 << 1 298 | let right = left + 1 299 | if right <= n { 300 | return [left - 1, right - 1] 301 | } else if left <= n { 302 | return [left - 1] 303 | } else { 304 | return [] 305 | } 306 | } 307 | measure { 308 | var count = 0 309 | dfs(edges: edges, startedAt: 0) { _ in count += 1 } 310 | XCTAssertEqual(count, edges.count) 311 | } 312 | } 313 | 314 | func testDFSWithPrevPerformance() { 315 | let n = (1 << 20) - 1 316 | let edges: [[Int]] = (1 ... n).map { 317 | let left = $0 << 1 318 | let right = left + 1 319 | if right <= n { 320 | return [left - 1, right - 1] 321 | } else if left <= n { 322 | return [left - 1] 323 | } else { 324 | return [] 325 | } 326 | } 327 | measure { 328 | var count = 0 329 | dfs(edges: edges, startedAt: 0) { _, _ in count += 1 } 330 | XCTAssertEqual(count, edges.count) 331 | } 332 | } 333 | 334 | func testDFSWithPrevDepthPerformance() { 335 | let n = (1 << 20) - 1 336 | let edges: [[Int]] = (1 ... n).map { 337 | let left = $0 << 1 338 | let right = left + 1 339 | if right <= n { 340 | return [left - 1, right - 1] 341 | } else if left <= n { 342 | return [left - 1] 343 | } else { 344 | return [] 345 | } 346 | } 347 | measure { 348 | var count = 0 349 | dfs(edges: edges, startedAt: 0) { _, _, _ in count += 1 } 350 | XCTAssertEqual(count, edges.count) 351 | } 352 | } 353 | #endif 354 | } 355 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/DequeTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class DequeTests: XCTestCase { 5 | func testInitFromSequence() { 6 | let deque: Deque = .init(1 ... 3) 7 | XCTAssertEqual(deque.count, 3) 8 | XCTAssertEqual(deque.first, 1) 9 | XCTAssertEqual(deque.last, 3) 10 | } 11 | 12 | func testAppend() { 13 | var deque: Deque = [] 14 | for n in 1 ... 100 { 15 | deque.append(n) 16 | XCTAssertEqual(deque.count, n) 17 | XCTAssertEqual(deque[0], 1) 18 | XCTAssertEqual(deque[n - 1], n) 19 | XCTAssertEqual(Array(deque), Array(1 ... n)) 20 | } 21 | } 22 | 23 | func testPopLast() { 24 | var deque: Deque = .init(1 ... 100) 25 | var n = 100 26 | while let last = deque.popLast() { 27 | XCTAssertEqual(last, n) 28 | n -= 1 29 | if deque.isEmpty { continue } 30 | XCTAssertEqual(deque.count, n) 31 | XCTAssertEqual(deque[0], 1) 32 | XCTAssertEqual(deque[n - 1], n) 33 | XCTAssertEqual(Array(deque), Array(1 ... n)) 34 | } 35 | } 36 | 37 | func testPrepend() { 38 | var deque: Deque = [] 39 | for n in 1 ... 100 { 40 | deque.prepend(n) 41 | XCTAssertEqual(deque.count, n) 42 | XCTAssertEqual(deque[0], n) 43 | XCTAssertEqual(deque[n - 1], 1) 44 | XCTAssertEqual(Array(deque), Array((1 ... n).reversed())) 45 | } 46 | } 47 | 48 | func testPopFirst() { 49 | var deque: Deque = .init((1 ... 100).reversed()) 50 | var n = 100 51 | while let first = deque.popFirst() { 52 | XCTAssertEqual(first, n) 53 | n -= 1 54 | if deque.isEmpty { continue } 55 | XCTAssertEqual(deque.count, n) 56 | XCTAssertEqual(deque[0], n) 57 | XCTAssertEqual(deque[n - 1], 1) 58 | XCTAssertEqual(Array(deque), Array((1 ... n).reversed())) 59 | } 60 | } 61 | 62 | func testEqOperator() { 63 | do { 64 | let deque: Deque = [2, 3, 5] 65 | XCTAssertEqual(deque, [2, 3, 5]) 66 | } 67 | do { 68 | let deque: Deque = [] 69 | XCTAssertEqual(deque, []) 70 | } 71 | } 72 | 73 | #if !DEBUG 74 | func testAppendPerformance() { 75 | measure { 76 | var deque: Deque = [] 77 | for n in 1 ... 1_000_000 { 78 | if n.isMultiple(of: 2) { 79 | deque.append(n) 80 | } else { 81 | deque.prepend(n) 82 | } 83 | } 84 | XCTAssertEqual(deque.count, 1_000_000) 85 | } 86 | } 87 | #endif 88 | } 89 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/DijkstraTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class DijkstraTests: XCTestCase { 5 | func testDijkstra() { 6 | do { 7 | let graph: [[(index: Int, distance: Int)]] = [ 8 | [ 9 | (index: 1, distance: 7), 10 | (index: 2, distance: 9), 11 | (index: 5, distance: 14), 12 | ], 13 | [ 14 | (index: 0, distance: 7), 15 | (index: 2, distance: 10), 16 | (index: 3, distance: 15), 17 | ], 18 | [ 19 | (index: 0, distance: 9), 20 | (index: 1, distance: 10), 21 | (index: 3, distance: 11), 22 | (index: 5, distance: 2), 23 | ], 24 | [ 25 | (index: 1, distance: 15), 26 | (index: 2, distance: 11), 27 | (index: 4, distance: 6), 28 | ], 29 | [ 30 | (index: 3, distance: 6), 31 | (index: 5, distance: 9), 32 | ], 33 | [ 34 | (index: 0, distance: 14), 35 | (index: 4, distance: 9), 36 | ], 37 | ] 38 | let r = dijkstra(graph: graph, startedAt: 0) 39 | XCTAssertEqual(r, [0, 7, 9, 20, 20, 11]) 40 | } 41 | do { 42 | let graph: [[(index: Int, distance: Double)]] = [ 43 | [ 44 | (index: 1, distance: 2.0), 45 | (index: 2, distance: 3.0), 46 | ], 47 | [ 48 | (index: 0, distance: 2.0), 49 | (index: 2, distance: 5.0), 50 | ], 51 | [ 52 | (index: 0, distance: 3.0), 53 | (index: 1, distance: 5.0), 54 | ], 55 | ] 56 | let r = dijkstra(graph: graph, startedAt: 1) 57 | XCTAssertEqual(r, [2.0, 0.0, 5.0]) 58 | } 59 | do { // 到達不能ノード 60 | let graph: [[(index: Int, distance: Double)]] = [ 61 | [ 62 | (index: 1, distance: 2.0), 63 | (index: 2, distance: 3.0), 64 | ], 65 | [ 66 | (index: 0, distance: 2.0), 67 | (index: 2, distance: 5.0), 68 | ], 69 | [ 70 | (index: 0, distance: 3.0), 71 | (index: 1, distance: 5.0), 72 | ], 73 | [ 74 | ] 75 | ] 76 | let r = dijkstra(graph: graph, startedAt: 0) 77 | XCTAssertEqual(r, [0.0, 2.0, 3.0, nil]) 78 | } 79 | } 80 | 81 | #if !DEBUG 82 | func testDijkstraPerformance() { 83 | var graph: [[(index: Int, distance: Int)]] = .init(repeating: [], count: 1000) 84 | for from in graph.indices { 85 | for to in graph.indices { 86 | graph[from].append((index: to, distance: to == from ? 0 : to + from)) 87 | } 88 | } 89 | measure { 90 | let r = dijkstra(graph: graph, startedAt: 0) 91 | XCTAssertEqual(r.count, graph.count) 92 | } 93 | } 94 | #endif 95 | } 96 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/DivisorsTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class DivisorsTests: XCTestCase { 5 | func testDivisors() { 6 | do { 7 | let r = 12.divisors() 8 | XCTAssertEqual(r, [1, 2, 3, 4, 6, 12]) 9 | } 10 | do { // 平方数 11 | let r = 36.divisors() 12 | XCTAssertEqual(r, [1, 2, 3, 4, 6, 9, 12, 18, 36]) 13 | } 14 | do { // 素数 15 | let r = 127.divisors() 16 | XCTAssertEqual(r, [1, 127]) 17 | } 18 | do { // 2 ^ 10 19 | let r = 1024.divisors() 20 | XCTAssertEqual(r, [1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]) 21 | } 22 | do { // 2 * 3 * 5 * 7 23 | let r = (2 * 3 * 5 * 7).divisors() 24 | XCTAssertEqual(r, [1, 2, 3, 5, 2 * 3, 7, 2 * 5, 2 * 7, 3 * 5, 3 * 7, 2 * 3 * 5, 5 * 7, 2 * 3 * 7, 2 * 5 * 7, 3 * 5 * 7, 2 * 3 * 5 * 7]) 25 | } 26 | do { 27 | let r = 1.divisors() 28 | XCTAssertEqual(r, [1]) 29 | } 30 | do { 31 | let r = 2.divisors() 32 | XCTAssertEqual(r, [1, 2]) 33 | } 34 | do { 35 | let r = 3.divisors() 36 | XCTAssertEqual(r, [1, 3]) 37 | } 38 | do { 39 | let r = 4.divisors() 40 | XCTAssertEqual(r, [1 ,2, 4]) 41 | } 42 | } 43 | } 44 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/GCDTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class GCDTests: XCTestCase { 5 | func testGCD() { 6 | XCTAssertEqual(gcd(1071, 1029), 21) 7 | XCTAssertEqual(gcd(1, 1), 1) 8 | XCTAssertEqual(gcd(12, 12), 12) 9 | XCTAssertEqual(gcd(12, 1), 1) 10 | XCTAssertEqual(gcd(5, 7), 1) 11 | XCTAssertEqual(gcd(13, 26), 13) 12 | XCTAssertEqual(gcd(31 * 43, 31 * 47), 31) 13 | } 14 | } 15 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/InputTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class InputTest: XCTestCase { 5 | func testInput() { 6 | #if TEST_INPUT 7 | // 標準入力のテストを実行する場合は TEST_INPUT フラグを立て 8 | // Tests/Input に記載された内容を標準入力に渡して下さい。 9 | do { 10 | let r = readInt1() 11 | XCTAssertEqual(r, 2) 12 | } 13 | 14 | do { 15 | let (r1, r2) = readInt2() 16 | XCTAssertEqual(r1, 3) 17 | XCTAssertEqual(r2, 5) 18 | } 19 | 20 | do { 21 | let (r1, r2, r3) = readInt3() 22 | XCTAssertEqual(r1, 7) 23 | XCTAssertEqual(r2, 11) 24 | XCTAssertEqual(r3, 13) 25 | } 26 | 27 | do { 28 | let (r1, r2, r3, r4) = readInt4() 29 | XCTAssertEqual(r1, 17) 30 | XCTAssertEqual(r2, 19) 31 | XCTAssertEqual(r3, 23) 32 | XCTAssertEqual(r4, 29) 33 | } 34 | 35 | do { 36 | let r = readIntN() 37 | XCTAssertEqual(r, [31, 37, 41, 43, 47]) 38 | } 39 | #endif 40 | } 41 | } 42 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/IsPrimeTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class IsPrimeTests: XCTestCase { 5 | func testIsPrime() { 6 | let primes: Set = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97] 7 | for n in 0 ... 100 { 8 | if primes.contains(n) { 9 | XCTAssertTrue(n.isPrime) 10 | } else { 11 | XCTAssertFalse(n.isPrime) 12 | } 13 | } 14 | XCTAssertFalse((-1).isPrime) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/ModIntTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class ModIntTests: XCTestCase { 5 | override class func setUp() { 6 | ModInt.modulus = 998244353 7 | } 8 | 9 | func testInit() { 10 | do { 11 | let r: ModInt = 0 12 | XCTAssertEqual(r.value, 0) 13 | } 14 | do { 15 | let r: ModInt = 1 16 | XCTAssertEqual(r.value, 1) 17 | } 18 | do { 19 | let r: ModInt = .init(ModInt.modulus - 1) 20 | XCTAssertEqual(r.value, ModInt.modulus - 1) 21 | } 22 | do { 23 | let r: ModInt = .init(ModInt.modulus) 24 | XCTAssertEqual(r.value, 0) 25 | } 26 | do { 27 | let r: ModInt = .init(ModInt.modulus + 1) 28 | XCTAssertEqual(r.value, 1) 29 | } 30 | do { 31 | let r: ModInt = .init(ModInt.modulus * 10 + 42) 32 | XCTAssertEqual(r.value, 42) 33 | } 34 | do { 35 | let r: ModInt = -1 36 | XCTAssertEqual(r.value, ModInt.modulus - 1) 37 | } 38 | do { 39 | let r: ModInt = .init(Int(ModInt.modulus) * -10 - 42) 40 | XCTAssertEqual(r.value, ModInt.modulus - 42) 41 | } 42 | } 43 | 44 | func testPlus() { 45 | do { 46 | let n = ModInt.modulus - 1 47 | let a: ModInt = .init(n) 48 | let r = a + a 49 | XCTAssertEqual(r.value, (n + n) % ModInt.modulus) 50 | } 51 | do { 52 | let a: ModInt = 3 53 | let r = a + 1 54 | XCTAssertEqual(r.value, 4) 55 | } 56 | do { 57 | let a: ModInt = .init(ModInt.modulus - 1) 58 | let r = a + 1 59 | XCTAssertEqual(r.value, 0) 60 | } 61 | } 62 | 63 | func testMinus() { 64 | do { 65 | let a: ModInt = .init(ModInt.modulus - 1) 66 | let r = 1 - a 67 | XCTAssertEqual(r.value, 2) 68 | } 69 | do { 70 | let a: ModInt = 3 71 | let r = a - 1 72 | XCTAssertEqual(r.value, 2) 73 | } 74 | do { 75 | let a: ModInt = 3 76 | let r = a - a 77 | XCTAssertEqual(r.value, 0) 78 | } 79 | } 80 | 81 | func testTimes() { 82 | do { 83 | let n = ModInt.modulus - 1 84 | let a: ModInt = .init(n) 85 | let r = a * a 86 | XCTAssertEqual(r.value, (n * n) % ModInt.modulus) 87 | } 88 | do { 89 | let n = ModInt.modulus - 1 90 | let a: ModInt = .init(n) 91 | let r = a * 2 92 | XCTAssertEqual(r.value, (n + n) % ModInt.modulus) 93 | } 94 | } 95 | 96 | func testPlusEqual() { 97 | do { 98 | let n = ModInt.modulus - 1 99 | var r: ModInt = .init(n) 100 | r += r 101 | XCTAssertEqual(r.value, (n + n) % ModInt.modulus) 102 | } 103 | do { 104 | var r: ModInt = 3 105 | r += 1 106 | XCTAssertEqual(r.value, 4) 107 | } 108 | do { 109 | var r: ModInt = .init(ModInt.modulus - 1) 110 | r += 1 111 | XCTAssertEqual(r.value, 0) 112 | } 113 | } 114 | 115 | func testMinusEqual() { 116 | do { 117 | var r: ModInt = 1 118 | r -= ModInt(ModInt.modulus - 1) 119 | XCTAssertEqual(r.value, 2) 120 | } 121 | do { 122 | var r: ModInt = 3 123 | r -= 1 124 | XCTAssertEqual(r.value, 2) 125 | } 126 | do { 127 | var r: ModInt = 3 128 | r -= r 129 | XCTAssertEqual(r.value, 0) 130 | } 131 | } 132 | 133 | func testTimesEqual() { 134 | do { 135 | let n = ModInt.modulus - 1 136 | var r: ModInt = .init(n) 137 | r *= r 138 | XCTAssertEqual(r.value, (n * n) % ModInt.modulus) 139 | } 140 | do { 141 | let n = ModInt.modulus - 1 142 | var r: ModInt = .init(n) 143 | r *= 2 144 | XCTAssertEqual(r.value, (n + n) % ModInt.modulus) 145 | } 146 | } 147 | 148 | func testDescription() { 149 | XCTAssertEqual(ModInt(0).description, 0.description) 150 | XCTAssertEqual(ModInt(42).description, 42.description) 151 | XCTAssertEqual(ModInt(-1).description, (ModInt.modulus - 1).description) 152 | } 153 | } 154 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/ModOperatorsTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class ModOperatorsTests: XCTestCase { 5 | override class func setUp() { 6 | modulus = 998244353 7 | } 8 | 9 | func testPlus() { 10 | XCTAssertEqual(1 %+ 1, 2) 11 | XCTAssertEqual((Int.modulus - 1) %+ 1, 0) 12 | XCTAssertEqual((Int.modulus - 2) %+ 1, Int.modulus - 1) 13 | XCTAssertEqual((Int.modulus - 1) %+ (Int.modulus - 1), Int.modulus - 2) 14 | XCTAssertEqual(-2 %+ 1, Int.modulus - 1) 15 | XCTAssertEqual(-(Int.modulus - 1) %+ -2, Int.modulus - 1) 16 | 17 | XCTAssertEqual((UInt.modulus - 1) %+ (UInt.modulus - 1), UInt.modulus - 2) 18 | } 19 | 20 | func testMinus() { 21 | XCTAssertEqual(5 %- 3, 2) 22 | XCTAssertEqual(1 %- 2, Int.modulus - 1) 23 | XCTAssertEqual(1 %- (Int.modulus - 1), 2) 24 | XCTAssertEqual((Int.modulus - 3) %- (Int.modulus - 2), Int.modulus - 1) 25 | XCTAssertEqual(-2 %- 3, Int.modulus - 5) 26 | XCTAssertEqual(-(Int.modulus - 1) %- 2, Int.modulus - 1) 27 | 28 | XCTAssertEqual((UInt.modulus - 3) %- (UInt.modulus - 2), UInt.modulus - 1) 29 | } 30 | 31 | func testTimes() { 32 | XCTAssertEqual(2 %* 3, 6) 33 | XCTAssertEqual((Int.modulus - 1) %* 5, Int.modulus - 5) 34 | XCTAssertEqual((Int.modulus / 2) %* 2, Int.modulus - 1) 35 | XCTAssertEqual((Int.modulus - 1) %* (Int.modulus - 1), ((Int.modulus - 1) * (Int.modulus - 1)) % Int.modulus) 36 | XCTAssertEqual(-2 %* 3, Int.modulus - 6) 37 | XCTAssertEqual(2 %* -3, Int.modulus - 6) 38 | XCTAssertEqual((Int.modulus - 1) %* -2, 2) 39 | 40 | XCTAssertEqual((UInt.modulus - 1) %* (UInt.modulus - 1), ((UInt.modulus - 1) * (UInt.modulus - 1)) % UInt.modulus) 41 | } 42 | 43 | func testDivide() { 44 | XCTAssertEqual(6 %/ 3, 2) 45 | XCTAssertEqual(((Int.modulus - 1) * 6) %/ ((Int.modulus - 1) * 2), 3) 46 | //XCTAssertEqual((Int.modulus * 6) %/ (Int.modulus * 2), 3) 47 | 48 | XCTAssertEqual(((UInt.modulus - 1) * 6) %/ ((UInt.modulus - 1) * 2), 3) 49 | } 50 | 51 | func testPlusEqual() { 52 | do { 53 | var a = Int.modulus - 1 54 | a %+= Int.modulus - 1 55 | XCTAssertEqual(a, Int.modulus - 2) 56 | } 57 | do { 58 | var a = UInt.modulus - 1 59 | a %+= UInt.modulus - 1 60 | XCTAssertEqual(a, UInt.modulus - 2) 61 | } 62 | } 63 | 64 | func testMinusEqual() { 65 | do { 66 | var a = Int.modulus - 3 67 | a %-= Int.modulus - 2 68 | XCTAssertEqual(a, Int.modulus - 1) 69 | } 70 | do { 71 | var a = UInt.modulus - 3 72 | a %-= UInt.modulus - 2 73 | XCTAssertEqual(a, UInt.modulus - 1) 74 | } 75 | } 76 | 77 | func testTimesEqual() { 78 | do { 79 | var a = Int.modulus - 1 80 | a %*= Int.modulus - 1 81 | XCTAssertEqual(a, ((Int.modulus - 1) * (Int.modulus - 1)) % Int.modulus) 82 | } 83 | do { 84 | var a = UInt.modulus - 1 85 | a %*= UInt.modulus - 1 86 | XCTAssertEqual(a, ((UInt.modulus - 1) * (UInt.modulus - 1)) % UInt.modulus) 87 | } 88 | } 89 | 90 | func testDivideEqual() { 91 | do { 92 | var a = (Int.modulus - 1) * 6 93 | a %/= (Int.modulus - 1) * 2 94 | XCTAssertEqual(a, 3) 95 | } 96 | do { 97 | var a = (UInt.modulus - 1) * 6 98 | a %/= (UInt.modulus - 1) * 2 99 | XCTAssertEqual(a, 3) 100 | } 101 | } 102 | } 103 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/NCRTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class NCRTests: XCTestCase { 5 | func testFactorial() { 6 | let a: NCR = .init(maxN: 10000, modulus: 998244353) 7 | 8 | XCTAssertEqual(a.factorial(of: 0), 1) 9 | XCTAssertEqual(a.factorial(of: 1), 1) 10 | XCTAssertEqual(a.factorial(of: 2), 2) 11 | XCTAssertEqual(a.factorial(of: 3), 6) 12 | XCTAssertEqual(a.factorial(of: 4), 24) 13 | XCTAssertEqual(a.factorial(of: 5), 120) 14 | XCTAssertEqual(a.factorial(of: 6), 720) 15 | XCTAssertEqual(a.factorial(of: 7), 5_040) 16 | XCTAssertEqual(a.factorial(of: 8), 40_320) 17 | XCTAssertEqual(a.factorial(of: 9), 362_880) 18 | 19 | XCTAssertEqual(a.factorial(of: 18), 6_402_373_705_728_000 % 998244353) 20 | 21 | XCTAssertEqual(a.factorial(of: 10000), 777990065) 22 | } 23 | 24 | func testNPR() { 25 | let a: NCR = .init(maxN: 10000, modulus: 998244353) 26 | 27 | XCTAssertEqual(a.npr(0, 0), 1) 28 | XCTAssertEqual(a.npr(1, 1), 1) 29 | XCTAssertEqual(a.npr(2, 2), 2) 30 | XCTAssertEqual(a.npr(3, 3), 6) 31 | XCTAssertEqual(a.npr(4, 4), 24) 32 | XCTAssertEqual(a.npr(5, 5), 120) 33 | XCTAssertEqual(a.npr(6, 6), 720) 34 | XCTAssertEqual(a.npr(7, 7), 5_040) 35 | XCTAssertEqual(a.npr(8, 8), 40_320) 36 | XCTAssertEqual(a.npr(9, 9), 362_880) 37 | 38 | XCTAssertEqual(a.npr(18, 18), 6_402_373_705_728_000 % 998244353) 39 | 40 | for n in 0 ... 9 { 41 | for r in 0 ... n { 42 | XCTAssertEqual(a.npr(n, r), a.factorial(of: n) / a.factorial(of: n - r)) 43 | } 44 | } 45 | 46 | XCTAssertEqual(a.npr(18, 7), 6_402_373_705_728_000 / 39_916_800 % 998244353) 47 | 48 | XCTAssertEqual(a.npr(10000, 2000), 168757127) 49 | } 50 | 51 | func testNCR() { 52 | let a: NCR = .init(maxN: 10000, modulus: 998244353) 53 | 54 | XCTAssertEqual(a.ncr(0, 0), 1) 55 | 56 | for n in 0 ... 9 { 57 | for r in 0 ... n { 58 | XCTAssertEqual(a.ncr(n, r), a.factorial(of: n) / (a.factorial(of: n - r) * a.factorial(of: r))) 59 | } 60 | } 61 | 62 | XCTAssertEqual(a.ncr(18, 7), 6_402_373_705_728_000 / (39_916_800 * 5_040) % 998244353) 63 | 64 | XCTAssertEqual(a.ncr(10000, 2000), 96147199) 65 | 66 | XCTAssertEqual(a.ncr(10000, 0), 1) 67 | XCTAssertEqual(a.ncr(10000, 1), 10000) 68 | XCTAssertEqual(a.ncr(10000, 9999), 10000) 69 | XCTAssertEqual(a.ncr(10000, 10000), 1) 70 | } 71 | 72 | func testCallAsFunction() { 73 | let ncr: NCR = .init(maxN: 10000, modulus: 998244353) 74 | 75 | XCTAssertEqual(ncr(0, 0), 1) 76 | 77 | for n in 0 ... 9 { 78 | for r in 0 ... n { 79 | XCTAssertEqual(ncr(n, r), ncr.factorial(of: n) / (ncr.factorial(of: n - r) * ncr.factorial(of: r))) 80 | } 81 | } 82 | 83 | XCTAssertEqual(ncr(18, 7), 6_402_373_705_728_000 / (39_916_800 * 5_040) % 998244353) 84 | 85 | XCTAssertEqual(ncr(10000, 2000), 96147199) 86 | 87 | XCTAssertEqual(ncr(10000, 0), 1) 88 | XCTAssertEqual(ncr(10000, 1), 10000) 89 | XCTAssertEqual(ncr(10000, 9999), 10000) 90 | XCTAssertEqual(ncr(10000, 10000), 1) 91 | } 92 | } 93 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/PermutationsTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class PermutationsTests: XCTestCase { 5 | func testPermutations() { 6 | do { 7 | let r = Set([Int]().permutations()) 8 | XCTAssertEqual(r.count, 1) 9 | XCTAssertTrue(r.contains([])) 10 | } 11 | do { 12 | let r = Set([1].permutations()) 13 | XCTAssertEqual(r.count, 1) 14 | XCTAssertTrue(r.contains([1])) 15 | } 16 | do { 17 | let r = Set([1, 2].permutations()) 18 | XCTAssertEqual(r.count, 2) 19 | XCTAssertTrue(r.contains([1, 2])) 20 | XCTAssertTrue(r.contains([2, 1])) 21 | } 22 | do { 23 | let r = Set([1, 2, 3].permutations()) 24 | XCTAssertEqual(r.count, 6) 25 | XCTAssertTrue(r.contains([1, 2, 3])) 26 | XCTAssertTrue(r.contains([1, 3, 2])) 27 | XCTAssertTrue(r.contains([2, 1, 3])) 28 | XCTAssertTrue(r.contains([2, 3, 1])) 29 | XCTAssertTrue(r.contains([3, 1, 2])) 30 | XCTAssertTrue(r.contains([3, 2, 1])) 31 | } 32 | do { 33 | let r = Set([1, 2, 3, 4].permutations()) 34 | XCTAssertEqual(r.count, 24) 35 | XCTAssertTrue(r.contains([1, 2, 3, 4])) 36 | XCTAssertTrue(r.contains([1, 2, 4, 3])) 37 | XCTAssertTrue(r.contains([1, 3, 2, 4])) 38 | XCTAssertTrue(r.contains([1, 3, 4, 2])) 39 | XCTAssertTrue(r.contains([1, 4, 2, 3])) 40 | XCTAssertTrue(r.contains([1, 4, 3, 2])) 41 | XCTAssertTrue(r.contains([2, 1, 3, 4])) 42 | XCTAssertTrue(r.contains([2, 1, 4, 3])) 43 | XCTAssertTrue(r.contains([2, 3, 1, 4])) 44 | XCTAssertTrue(r.contains([2, 3, 4, 1])) 45 | XCTAssertTrue(r.contains([2, 4, 1, 3])) 46 | XCTAssertTrue(r.contains([2, 4, 3, 1])) 47 | XCTAssertTrue(r.contains([3, 1, 2, 4])) 48 | XCTAssertTrue(r.contains([3, 1, 4, 2])) 49 | XCTAssertTrue(r.contains([3, 2, 1, 4])) 50 | XCTAssertTrue(r.contains([3, 2, 4, 1])) 51 | XCTAssertTrue(r.contains([3, 4, 1, 2])) 52 | XCTAssertTrue(r.contains([3, 4, 2, 1])) 53 | XCTAssertTrue(r.contains([4, 1, 2, 3])) 54 | XCTAssertTrue(r.contains([4, 1, 3, 2])) 55 | XCTAssertTrue(r.contains([4, 2, 1, 3])) 56 | XCTAssertTrue(r.contains([4, 2, 3, 1])) 57 | XCTAssertTrue(r.contains([4, 3, 1, 2])) 58 | XCTAssertTrue(r.contains([4, 3, 2, 1])) 59 | } 60 | do { // `Sequence`s of `Character`s 61 | let r = Set("ABC".permutations()) 62 | XCTAssertEqual(r.count, 6) 63 | XCTAssertTrue(r.contains(["A", "B", "C"])) 64 | XCTAssertTrue(r.contains(["A", "C", "B"])) 65 | XCTAssertTrue(r.contains(["B", "A", "C"])) 66 | XCTAssertTrue(r.contains(["B", "C", "A"])) 67 | XCTAssertTrue(r.contains(["C", "A", "B"])) 68 | XCTAssertTrue(r.contains(["C", "B", "A"])) 69 | } 70 | do { // Reverse order inputs 71 | let r = Set([3, 2, 1].permutations()) 72 | XCTAssertEqual(r.count, 6) 73 | XCTAssertTrue(r.contains([1, 2, 3])) 74 | XCTAssertTrue(r.contains([1, 3, 2])) 75 | XCTAssertTrue(r.contains([2, 1, 3])) 76 | XCTAssertTrue(r.contains([2, 3, 1])) 77 | XCTAssertTrue(r.contains([3, 1, 2])) 78 | XCTAssertTrue(r.contains([3, 2, 1])) 79 | } 80 | do { // Collections but `Array`s 81 | let r = Set([0, 1, 2, 3, 4][1 ..< 4].permutations()) 82 | XCTAssertEqual(r.count, 6) 83 | XCTAssertTrue(r.contains([1, 2, 3])) 84 | XCTAssertTrue(r.contains([1, 3, 2])) 85 | XCTAssertTrue(r.contains([2, 1, 3])) 86 | XCTAssertTrue(r.contains([2, 3, 1])) 87 | XCTAssertTrue(r.contains([3, 1, 2])) 88 | XCTAssertTrue(r.contains([3, 2, 1])) 89 | } 90 | } 91 | 92 | func testNpr() { 93 | XCTAssertEqual(npr(5, 0, modulus: nil), 1) 94 | XCTAssertEqual(npr(5, 1, modulus: nil), 5) 95 | XCTAssertEqual(npr(5, 2, modulus: nil), 20) 96 | XCTAssertEqual(npr(5, 3, modulus: nil), 60) 97 | XCTAssertEqual(npr(5, 4, modulus: nil), 120) 98 | XCTAssertEqual(npr(5, 5, modulus: nil), 120) 99 | 100 | XCTAssertEqual(npr(0, 0, modulus: nil), 1) 101 | 102 | XCTAssertEqual(npr(5, 0, modulus: 7), 1) 103 | XCTAssertEqual(npr(5, 1, modulus: 7), 5) 104 | XCTAssertEqual(npr(5, 2, modulus: 7), 6) 105 | XCTAssertEqual(npr(5, 3, modulus: 7), 4) 106 | XCTAssertEqual(npr(5, 4, modulus: 7), 1) 107 | XCTAssertEqual(npr(5, 5, modulus: 7), 1) 108 | 109 | XCTAssertEqual(npr(5 as UInt, 3, modulus: nil), 60) 110 | XCTAssertEqual(npr(5, 3, modulus: 998244353), 60) 111 | } 112 | 113 | #if !DEBUG 114 | func testPermutatinsPerformance() { 115 | measure { 116 | let r = (1 ... 8).permutations() 117 | XCTAssertEqual(r.count, 40320) 118 | } 119 | } 120 | #endif 121 | } 122 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/PowTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class PowTests: XCTestCase { 5 | func testPow() { 6 | XCTAssertEqual(pow(2, 0, modulus: nil), 1) 7 | XCTAssertEqual(pow(2, 1, modulus: nil), 2) 8 | XCTAssertEqual(pow(2, 2, modulus: nil), 4) 9 | XCTAssertEqual(pow(2, 3, modulus: nil), 8) 10 | XCTAssertEqual(pow(2, 4, modulus: nil), 16) 11 | XCTAssertEqual(pow(2, 5, modulus: nil), 32) 12 | XCTAssertEqual(pow(2, 6, modulus: nil), 64) 13 | XCTAssertEqual(pow(2, 7, modulus: nil), 128) 14 | XCTAssertEqual(pow(2, 8, modulus: nil), 256) 15 | XCTAssertEqual(pow(2, 9, modulus: nil), 512) 16 | XCTAssertEqual(pow(2, 10, modulus: nil), 1024) 17 | 18 | XCTAssertEqual(pow(2, 16, modulus: nil), 65536) 19 | XCTAssertEqual(pow(2, 32, modulus: nil), 1 << 32) 20 | XCTAssertEqual(pow(2, 62, modulus: nil), 1 << 62) 21 | XCTAssertEqual(pow(2 as UInt, 63, modulus: nil), 1 << 63) 22 | 23 | XCTAssertEqual(pow(2, 0, modulus: 7), 1) 24 | XCTAssertEqual(pow(2, 1, modulus: 7), 2) 25 | XCTAssertEqual(pow(2, 2, modulus: 7), 4) 26 | XCTAssertEqual(pow(2, 3, modulus: 7), 1) 27 | XCTAssertEqual(pow(2, 4, modulus: 7), 2) 28 | XCTAssertEqual(pow(2, 5, modulus: 7), 4) 29 | XCTAssertEqual(pow(2, 6, modulus: 7), 1) 30 | XCTAssertEqual(pow(2, 7, modulus: 7), 2) 31 | XCTAssertEqual(pow(2, 8, modulus: 7), 4) 32 | XCTAssertEqual(pow(2, 9, modulus: 7), 1) 33 | XCTAssertEqual(pow(2, 10, modulus: 7), 2) 34 | 35 | XCTAssertEqual(pow(123456789, 2, modulus: 998244353), (123456789 * 123456789) % 998244353) 36 | XCTAssertEqual((6 * pow(3, 998244353 - 2, modulus: 998244353)) % 998244353, 2) // 6 / 3 = 2 37 | } 38 | } 39 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/PrimesTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class PrimesTests: XCTestCase { 5 | func testPrimes() { 6 | do { 7 | let r = primes(upTo: 100) 8 | XCTAssertEqual(r, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]) 9 | } 10 | do { 11 | let r = primes(upTo: 101) 12 | XCTAssertEqual(r, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101]) 13 | } 14 | do { 15 | let r = primes(upTo: 0) 16 | XCTAssertEqual(r, []) 17 | } 18 | do { 19 | let r = primes(upTo: 1) 20 | XCTAssertEqual(r, []) 21 | } 22 | do { 23 | let r = primes(upTo: 2) 24 | XCTAssertEqual(r, [2]) 25 | } 26 | do { 27 | let r = primes(upTo: 3) 28 | XCTAssertEqual(r, [2, 3]) 29 | } 30 | do { 31 | let r = primes(upTo: 4) 32 | XCTAssertEqual(r, [2, 3]) 33 | } 34 | do { 35 | let r = primes(upTo: 5) 36 | XCTAssertEqual(r, [2, 3, 5]) 37 | } 38 | } 39 | 40 | #if !DEBUG 41 | func testPrimesPerformance() { 42 | measure { 43 | let r = primes(upTo: 10_000_000) 44 | XCTAssertEqual(r.count, 664_579) 45 | } 46 | } 47 | #endif 48 | } 49 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/PriorityQueueTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class PriorityQueueTests: XCTestCase { 5 | func testAppend() { 6 | do { 7 | var queue: PriorityQueue = .init([3, 7, 2, 8, 5, 2]) 8 | 9 | XCTAssertEqual(queue.first, 2) 10 | XCTAssertEqual(queue.count, 6) 11 | 12 | queue.append(1) 13 | 14 | XCTAssertEqual(queue.first, 1) 15 | XCTAssertEqual(queue.count, 7) 16 | 17 | queue.append(4) 18 | 19 | XCTAssertEqual(queue.first, 1) 20 | XCTAssertEqual(queue.count, 8) 21 | 22 | queue.append(1) 23 | 24 | XCTAssertEqual(queue.first, 1) 25 | XCTAssertEqual(queue.count, 9) 26 | 27 | queue.append(0) 28 | 29 | XCTAssertEqual(queue.first, 0) 30 | XCTAssertEqual(queue.count, 10) 31 | } 32 | do { 33 | var queue: PriorityQueue = .init() 34 | 35 | XCTAssertEqual(queue.isEmpty, true) 36 | 37 | let elements = Array(1 ... 100).shuffled() 38 | for (i, element) in elements.enumerated() { 39 | XCTAssertEqual(queue.count, i) 40 | XCTAssertEqual(queue.first, elements[0 ..< i].min()) 41 | 42 | queue.append(element) 43 | 44 | XCTAssertEqual(queue.isEmpty, false) 45 | } 46 | 47 | XCTAssertEqual(queue.count, elements.count) 48 | } 49 | } 50 | 51 | func testPopFirst() { 52 | do { 53 | var queue: PriorityQueue = .init([5, 9, 2, 0, 3, 6, 2, 5]) 54 | 55 | XCTAssertEqual(queue.popFirst(), 0) 56 | XCTAssertEqual(queue.popFirst(), 2) 57 | XCTAssertEqual(queue.popFirst(), 2) 58 | XCTAssertEqual(queue.popFirst(), 3) 59 | XCTAssertEqual(queue.popFirst(), 5) 60 | XCTAssertEqual(queue.popFirst(), 5) 61 | XCTAssertEqual(queue.popFirst(), 6) 62 | XCTAssertEqual(queue.popFirst(), 9) 63 | XCTAssertEqual(queue.popFirst(), nil) 64 | } 65 | do { 66 | var queue: PriorityQueue = .init() 67 | XCTAssertEqual(queue.popFirst(), nil) 68 | } 69 | do { 70 | var queue: PriorityQueue<(Double, Int)> = .init([ 71 | (3.0, 4), 72 | (2.0, 7), 73 | (9.0, 8), 74 | (3.0, 2), 75 | (2.5, 6), 76 | (2.0, 7), 77 | (1.0, 9), 78 | (1.5, 6), 79 | (2.0, 5), 80 | (2.0, 8), 81 | (3.0, 2), 82 | (7.0, 1), 83 | (3.0, 3), 84 | ], by: <) 85 | 86 | XCTAssertEqual(queue.popFirst(), (1.0, 9)) 87 | XCTAssertEqual(queue.popFirst(), (1.5, 6)) 88 | XCTAssertEqual(queue.popFirst(), (2.0, 5)) 89 | XCTAssertEqual(queue.popFirst(), (2.0, 7)) 90 | XCTAssertEqual(queue.popFirst(), (2.0, 7)) 91 | XCTAssertEqual(queue.popFirst(), (2.0, 8)) 92 | XCTAssertEqual(queue.popFirst(), (2.5, 6)) 93 | XCTAssertEqual(queue.popFirst(), (3.0, 2)) 94 | XCTAssertEqual(queue.popFirst(), (3.0, 2)) 95 | XCTAssertEqual(queue.popFirst(), (3.0, 3)) 96 | XCTAssertEqual(queue.popFirst(), (3.0, 4)) 97 | XCTAssertEqual(queue.popFirst(), (7.0, 1)) 98 | XCTAssertEqual(queue.popFirst(), (9.0, 8)) 99 | XCTAssertNil(queue.popFirst()) 100 | } 101 | do { 102 | var elements = Array(1 ... 100).shuffled() 103 | var queue: PriorityQueue = .init(elements) 104 | elements.sort() 105 | 106 | for (i, element) in elements.enumerated() { 107 | XCTAssertEqual(queue.count, elements.count - i) 108 | XCTAssertEqual(queue.isEmpty, false) 109 | XCTAssertEqual(queue.first, element) 110 | XCTAssertEqual(queue.popFirst(), element) 111 | } 112 | 113 | XCTAssertEqual(queue.count, 0) 114 | XCTAssertEqual(queue.isEmpty, true) 115 | XCTAssertEqual(queue.first, nil) 116 | XCTAssertEqual(queue.popFirst(), nil) 117 | } 118 | } 119 | 120 | #if !DEBUG 121 | func testAppendPerformance() { 122 | let elements = (1 ... 100_000).shuffled() 123 | measure { 124 | var queue: PriorityQueue = .init() 125 | for element in elements { 126 | queue.append(element) 127 | } 128 | XCTAssertEqual(queue.count, elements.count) 129 | } 130 | } 131 | 132 | func testPopFirstPerformance() { 133 | let elements = (1 ... 100_000).shuffled() 134 | let queue: PriorityQueue = .init(elements) 135 | measure { 136 | var queue = queue 137 | while !queue.isEmpty { 138 | _ = queue.popFirst() 139 | } 140 | XCTAssertTrue(queue.isEmpty) 141 | } 142 | 143 | } 144 | #endif 145 | } 146 | 147 | // FIXME: SE-0283 が導入されたら取り除く 148 | private func XCTAssertEqual(_ expression1: (T, U)?, _ expression2: (T, U)?) { 149 | switch (expression1, expression2) { 150 | case (.some(let expression1), .some(let expression2)): 151 | XCTAssertEqual(expression1.0, expression2.0) 152 | XCTAssertEqual(expression1.1, expression2.1) 153 | case (.some(_), .none), (.none, .some(_)): 154 | XCTFail() 155 | case (.none, .none): 156 | break 157 | } 158 | } 159 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/RangeSumTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class RangeSumTests: XCTestCase { 5 | func testSum() { 6 | XCTAssertEqual((1 ... 10).sum(), 55) 7 | XCTAssertEqual((-10 ... 100).sum(), 4995) 8 | XCTAssertEqual((-10 ... -1).sum(), -55) 9 | XCTAssertEqual((-100 ... 10).sum(), -4995) 10 | XCTAssertEqual((1 ... 10).sum(modulus: 13), 55 % 13) 11 | XCTAssertEqual((-10 ... 100).sum(modulus: 13), 4995 % 13) 12 | XCTAssertEqual((-10 ... -1).sum(modulus: 13), -55 % 13 + 13) 13 | XCTAssertEqual((-100 ... 10).sum(modulus: 13), -4995 % 13 + 13) 14 | XCTAssertEqual((1 ... 1000000000).sum(modulus: 998244353), (1000000000 * 1000000001 / 2) % 998244353) 15 | } 16 | } 17 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/SafeOverflowTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class SafeOverflowTests: XCTestCase { 5 | func testAddition() { 6 | do { 7 | let a: Int? = 2 +? 3 8 | XCTAssertEqual(a, 5) 9 | } 10 | do { 11 | let a: Int? = Int.max +? 1 12 | XCTAssertNil(a) 13 | } 14 | do { 15 | let a: Int? = Int.min +? -1 16 | XCTAssertNil(a) 17 | } 18 | } 19 | 20 | func testSubtraction() { 21 | do { 22 | let a: Int? = 2 -? 3 23 | XCTAssertEqual(a, -1) 24 | } 25 | do { 26 | let a: Int? = Int.min -? 1 27 | XCTAssertNil(a) 28 | } 29 | do { 30 | let a: Int? = Int.max -? -1 31 | XCTAssertNil(a) 32 | } 33 | } 34 | 35 | func testMultiplication() { 36 | do { 37 | let a: Int? = 2 *? 3 38 | XCTAssertEqual(a, 6) 39 | } 40 | do { 41 | let a: Int? = (Int.max / 2) *? 2 42 | XCTAssertEqual(a, (Int.max / 2) * 2) 43 | } 44 | do { 45 | let a: Int? = (Int.max / 2 + 1) *? 2 46 | XCTAssertNil(a) 47 | } 48 | do { 49 | let a: Int? = (Int.min / 2) *? 2 50 | XCTAssertEqual(a, (Int.min / 2) * 2) 51 | } 52 | do { 53 | let a: Int? = (Int.min / 2 - 1) *? 2 54 | XCTAssertNil(a) 55 | } 56 | } 57 | } 58 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/SafeRangeTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class SafeRangeTests: XCTestCase { 5 | func testRange() { 6 | do { 7 | let a: Range? = 2 ..? = 2 ..? = 2 ..? = 2 ...? 5 23 | XCTAssertEqual(a, 2 ... 5) 24 | } 25 | do { 26 | let a: ClosedRange? = 2 ...? 2 27 | XCTAssertEqual(a, 2 ... 2) 28 | } 29 | do { 30 | let a: ClosedRange? = 2 ...? 1 31 | XCTAssertNil(a) 32 | } 33 | } 34 | } 35 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/TSPTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class TSPTests: XCTestCase { 5 | func testTSP() { 6 | do { 7 | let distances: [[Int]] = [ 8 | [0, 6], 9 | [3, 0], 10 | ] 11 | do { 12 | let r = tsp(distances: distances, startedAt: 0) 13 | XCTAssertEqual(r, 9) 14 | } 15 | do { 16 | let r = tsp(distances: distances, startedAt: 1) 17 | XCTAssertEqual(r, 9) 18 | } 19 | } 20 | do { 21 | let distances: [[Int]] = [ 22 | [0, 3, 2], 23 | [2, 0, 4], 24 | [3, 6, 0], 25 | ] 26 | do { 27 | let r = tsp(distances: distances, startedAt: 0) 28 | XCTAssertEqual(r, 10) 29 | } 30 | do { 31 | let r = tsp(distances: distances, startedAt: 1) 32 | XCTAssertEqual(r, 10) 33 | } 34 | do { 35 | let r = tsp(distances: distances, startedAt: 1) 36 | XCTAssertEqual(r, 10) 37 | } 38 | } 39 | do { 40 | let distances: [[Int]] = [ 41 | [0, 6, 5, 5], 42 | [6, 0, 7, 4], 43 | [5, 7, 0, 3], 44 | [5, 4, 3, 0] 45 | ] 46 | do { 47 | let r = tsp(distances: distances, startedAt: 0) 48 | XCTAssertEqual(r, 18) 49 | } 50 | } 51 | } 52 | 53 | #if !DEBUG 54 | func testTSPPerformance() { 55 | let positions: [(Int, Int, Int)] = [ 56 | (14142, 13562, 373095), 57 | (-17320, 508075, 68877), 58 | (223606, -79774, 9979), 59 | (-24494, -89742, 783178), 60 | (26457, 513110, -64591), 61 | (-282842, 7124, -74619), 62 | (31622, -77660, -168379), 63 | (-33166, -24790, -3554), 64 | (346410, 16151, 37755), 65 | (-36055, 51275, 463989), 66 | (37416, -573867, 73941), 67 | (-3872, -983346, 207417), 68 | (412310, 56256, -17661), 69 | (-42426, 40687, -119285), 70 | (43588, -989435, -40674), 71 | (-447213, -59549, -99579), 72 | (45825, 7569, 45584), 73 | ] 74 | func distance(from p1: (Int, Int, Int), to p2: (Int, Int, Int)) -> Int { 75 | abs(p2.0 - p1.0) + abs(p2.1 - p1.1) + Swift.max(0, p2.2 - p1.2) 76 | } 77 | let distances: [[Int]] = positions.indices.map { i in positions.indices.map { j in distance(from: positions[i], to: positions[j]) } } 78 | 79 | measure { 80 | let r = tsp(distances: distances, startedAt: 0) 81 | XCTAssertEqual(r, 6519344) 82 | } 83 | } 84 | #endif 85 | } 86 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/UnionFindTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class UnionFindTests: XCTestCase { 5 | func testUnionFind() { 6 | do { 7 | let n = 10 8 | var unionFind: UnionFind = .init(count: n) 9 | 10 | for i in 0 ..< n { 11 | XCTAssertEqual(unionFind.root(of: i), i) // root 12 | XCTAssertEqual(unionFind.count(of: i), 1) // count 13 | } 14 | for i in 0 ..< n { // areSame 15 | for j in 0 ..< n { 16 | if i == j { 17 | XCTAssertTrue(unionFind.areInSameSet(i, j)) 18 | } else { 19 | XCTAssertFalse(unionFind.areInSameSet(i, j)) 20 | } 21 | } 22 | } 23 | 24 | unionFind.unite(2, 3) 25 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 3)) 26 | XCTAssertEqual(unionFind.count(of: 2), 2) 27 | XCTAssertEqual(unionFind.count(of: 3), 2) 28 | do { 29 | let groups: [Set] = [[0], [1], [4], [5], [6], [7], [8], [9], [2, 3]] 30 | for i in 0 ..< n { 31 | if groups.first(where: { $0.contains(i) })!.count > 1 { continue } 32 | XCTAssertEqual(unionFind.root(of: i), i) // root 33 | XCTAssertEqual(unionFind.count(of: i), 1) // count 34 | } 35 | for i in 0 ..< n { // areSame 36 | for j in 0 ..< n { 37 | if groups.reduce(false, { $0 || $1.contains(i) && $1.contains(j)}) { 38 | XCTAssertTrue(unionFind.areInSameSet(i, j)) 39 | } else { 40 | XCTAssertFalse(unionFind.areInSameSet(i, j)) 41 | } 42 | } 43 | } 44 | } 45 | 46 | unionFind.unite(5, 7) 47 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 7)) 48 | XCTAssertEqual(unionFind.count(of: 5), 2) 49 | XCTAssertEqual(unionFind.count(of: 7), 2) 50 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 3)) 51 | XCTAssertEqual(unionFind.count(of: 2), 2) 52 | XCTAssertEqual(unionFind.count(of: 3), 2) 53 | do { 54 | let groups: [Set] = [[0], [1], [4], [6], [8], [9], [2, 3], [5, 7]] 55 | for i in 0 ..< n { 56 | if groups.first(where: { $0.contains(i) })!.count > 1 { continue } 57 | XCTAssertEqual(unionFind.root(of: i), i) // root 58 | XCTAssertEqual(unionFind.count(of: i), 1) // count 59 | } 60 | for i in 0 ..< n { // areSame 61 | for j in 0 ..< n { 62 | if groups.reduce(false, { $0 || $1.contains(i) && $1.contains(j)}) { 63 | XCTAssertTrue(unionFind.areInSameSet(i, j)) 64 | } else { 65 | XCTAssertFalse(unionFind.areInSameSet(i, j)) 66 | } 67 | } 68 | } 69 | } 70 | 71 | unionFind.unite(1, 2) 72 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 2)) 73 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 3)) 74 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 3)) 75 | XCTAssertEqual(unionFind.count(of: 1), 3) 76 | XCTAssertEqual(unionFind.count(of: 2), 3) 77 | XCTAssertEqual(unionFind.count(of: 3), 3) 78 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 7)) 79 | XCTAssertEqual(unionFind.count(of: 5), 2) 80 | XCTAssertEqual(unionFind.count(of: 7), 2) 81 | do { 82 | let groups: [Set] = [[0], [4], [6], [8], [9], [1, 2, 3], [5, 7]] 83 | for i in 0 ..< n { 84 | if groups.first(where: { $0.contains(i) })!.count > 1 { continue } 85 | XCTAssertEqual(unionFind.root(of: i), i) // root 86 | XCTAssertEqual(unionFind.count(of: i), 1) // count 87 | } 88 | for i in 0 ..< n { // areSame 89 | for j in 0 ..< n { 90 | if groups.reduce(false, { $0 || $1.contains(i) && $1.contains(j)}) { 91 | XCTAssertTrue(unionFind.areInSameSet(i, j)) 92 | } else { 93 | XCTAssertFalse(unionFind.areInSameSet(i, j)) 94 | } 95 | } 96 | } 97 | } 98 | 99 | unionFind.unite(3, 7) 100 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 2)) 101 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 3)) 102 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 5)) 103 | XCTAssertEqual(unionFind.root(of: 1), unionFind.root(of: 7)) 104 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 1)) 105 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 3)) 106 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 5)) 107 | XCTAssertEqual(unionFind.root(of: 2), unionFind.root(of: 7)) 108 | XCTAssertEqual(unionFind.root(of: 3), unionFind.root(of: 1)) 109 | XCTAssertEqual(unionFind.root(of: 3), unionFind.root(of: 2)) 110 | XCTAssertEqual(unionFind.root(of: 3), unionFind.root(of: 5)) 111 | XCTAssertEqual(unionFind.root(of: 3), unionFind.root(of: 7)) 112 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 1)) 113 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 2)) 114 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 3)) 115 | XCTAssertEqual(unionFind.root(of: 5), unionFind.root(of: 7)) 116 | XCTAssertEqual(unionFind.root(of: 7), unionFind.root(of: 1)) 117 | XCTAssertEqual(unionFind.root(of: 7), unionFind.root(of: 2)) 118 | XCTAssertEqual(unionFind.root(of: 7), unionFind.root(of: 3)) 119 | XCTAssertEqual(unionFind.root(of: 7), unionFind.root(of: 5)) 120 | XCTAssertEqual(unionFind.count(of: 1), 5) 121 | XCTAssertEqual(unionFind.count(of: 2), 5) 122 | XCTAssertEqual(unionFind.count(of: 3), 5) 123 | XCTAssertEqual(unionFind.count(of: 5), 5) 124 | XCTAssertEqual(unionFind.count(of: 7), 5) 125 | do { 126 | let groups: [Set] = [[0], [4], [6], [8], [9], [1, 2, 3, 5, 7]] 127 | for i in 0 ..< n { 128 | if groups.first(where: { $0.contains(i) })!.count > 1 { continue } 129 | XCTAssertEqual(unionFind.root(of: i), i) // root 130 | XCTAssertEqual(unionFind.count(of: i), 1) // count 131 | } 132 | for i in 0 ..< n { // areSame 133 | for j in 0 ..< n { 134 | if groups.reduce(false, { $0 || $1.contains(i) && $1.contains(j)}) { 135 | XCTAssertTrue(unionFind.areInSameSet(i, j)) 136 | } else { 137 | XCTAssertFalse(unionFind.areInSameSet(i, j)) 138 | } 139 | } 140 | } 141 | } 142 | } 143 | } 144 | 145 | #if !DEBUG 146 | func testUnionFindPerformance() { 147 | let n = 10_000_000 148 | measure { 149 | var unionFind: UnionFind = .init(count: n) 150 | for i in 1 ..< n { 151 | unionFind.unite(i - 1, i) 152 | } 153 | XCTAssertTrue(unionFind.areInSameSet(0, n - 1)) 154 | } 155 | } 156 | #endif 157 | } 158 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/VectorsTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class VectorsTests: XCTestCase { 5 | func testPlus() { 6 | XCTAssertEqual((2, 3) + (5, 7), (7, 10)) 7 | XCTAssertEqual((2.0, 3.0) + (5.0, 7.0), (7.0, 10.0)) 8 | } 9 | 10 | func testMinus() { 11 | XCTAssertEqual((2, 3) - (5, 7), (-3, -4)) 12 | XCTAssertEqual((2.0, 3.0) - (5.0, 7.0), (-3.0, -4.0)) 13 | } 14 | 15 | func testTimes() { 16 | XCTAssertEqual((2, 3) * 5, (10, 15)) 17 | XCTAssertEqual((2.0, 3.0) * 5.0, (10.0, 15.0)) 18 | } 19 | 20 | func testDivide() { 21 | XCTAssertEqual((12, 15) / 3, (4, 5)) 22 | XCTAssertEqual((12.0, 15.0) / 3.0, (4.0, 5.0)) 23 | } 24 | 25 | func testPlusEqual() { 26 | do { 27 | var a = (2, 3) 28 | a += (5, 7) 29 | XCTAssertEqual(a, (7, 10)) 30 | } 31 | do { 32 | var a = (2.0, 3.0) 33 | a += (5.0, 7.0) 34 | XCTAssertEqual(a, (7.0, 10.0)) 35 | } 36 | } 37 | 38 | func testMinusEqual() { 39 | do { 40 | var a = (2, 3) 41 | a -= (5, 7) 42 | XCTAssertEqual(a, (-3, -4)) 43 | } 44 | do { 45 | var a = (2.0, 3.0) 46 | a -= (5.0, 7.0) 47 | XCTAssertEqual(a, (-3.0, -4.0)) 48 | } 49 | } 50 | 51 | func testTimesEqual() { 52 | do { 53 | var a = (2, 3) 54 | a *= 5 55 | XCTAssertEqual(a, (10, 15)) 56 | } 57 | do { 58 | var a = (2.0, 3.0) 59 | a *= 5.0 60 | XCTAssertEqual(a, (10.0, 15.0)) 61 | } 62 | } 63 | 64 | func testDivideEqual() { 65 | do { 66 | var a = (12, 15) 67 | a /= 3 68 | XCTAssertEqual(a, (4, 5)) 69 | } 70 | do { 71 | var a = (12.0, 15.0) 72 | a /= 3.0 73 | XCTAssertEqual(a, (4.0, 5.0)) 74 | } 75 | } 76 | } 77 | 78 | // FIXME: SE-0283 でタプルが Equatable になったら除去 79 | private func XCTAssertEqual(_ expression1: (T, T), _ expression2: (T, T)) { 80 | XCTAssertEqual(expression1.0, expression2.0) 81 | XCTAssertEqual(expression1.1, expression2.1) 82 | } 83 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/WarshallFloydTests.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | @testable import AtCoderSupport 3 | 4 | final class WarshallFloydTests: XCTestCase { 5 | func testWarshallFloyd() { 6 | do { 7 | // A -- 5 -> B <-- 4 --> C 8 | // | | ^ 9 | // | | | 10 | // 3 2 1 ----- 11 | // | | | 12 | // V V | 13 | // D <- 7 -> E <---- 14 | // 15 | // F <- 6 -> G 16 | var graph: [[Int?]] = [ 17 | [0, 5, nil, 3, nil, nil, nil], 18 | [nil, 0, 4, nil, 2, nil, nil], 19 | [nil, 4, 0, nil, 1, nil, nil], 20 | [nil, nil, nil, 0, 7, nil, nil], 21 | [nil, nil, 1, 7, 0, nil, nil], 22 | [nil, nil, nil, nil, nil, 0, 6], 23 | [nil, nil, nil, nil, nil, 6, 0], 24 | ] 25 | warshallFloyd(graph: &graph) 26 | 27 | XCTAssertEqual(graph, [ 28 | [0, 5, 8, 3, 7, nil, nil], 29 | [nil, 0, 3, 9, 2, nil, nil], 30 | [nil, 4, 0, 8, 1, nil, nil], 31 | [nil, 12, 8, 0, 7, nil, nil], 32 | [nil, 5, 1, 7, 0, nil, nil], 33 | [nil, nil, nil, nil, nil, 0, 6], 34 | [nil, nil, nil, nil, nil, 6, 0], 35 | ]) 36 | } 37 | do { // 負の辺 38 | // A -- 5 -> B <-- 4 --> C 39 | // | | ^ 40 | // | | | 41 | // 3 -2 1 ----- 42 | // | | | 43 | // V V | 44 | // D <- 7 -> E <---- 45 | // 46 | // F <- 6 -> G 47 | var graph: [[Int?]] = [ 48 | [0, 5, nil, 3, nil, nil, nil], 49 | [nil, 0, 4, nil, -2, nil, nil], 50 | [nil, 4, 0, nil, 1, nil, nil], 51 | [nil, nil, nil, 0, 7, nil, nil], 52 | [nil, nil, 1, 7, 0, nil, nil], 53 | [nil, nil, nil, nil, nil, 0, 6], 54 | [nil, nil, nil, nil, nil, 6, 0], 55 | ] 56 | warshallFloyd(graph: &graph) 57 | 58 | XCTAssertEqual(graph, [ 59 | [0, 5, 4, 3, 3, nil, nil], 60 | [nil, 0, -1, 5, -2, nil, nil], 61 | [nil, 4, 0, 8, 1, nil, nil], 62 | [nil, 12, 8, 0, 7, nil, nil], 63 | [nil, 5, 1, 7, 0, nil, nil], 64 | [nil, nil, nil, nil, nil, 0, 6], 65 | [nil, nil, nil, nil, nil, 6, 0], 66 | ]) 67 | } 68 | do { // 負の閉路 69 | // A -- 5 -> B <-- 2 --> C 70 | // | | ^ 71 | // | | | 72 | // 3 -4 1 ----- 73 | // | | | 74 | // V V | 75 | // D <- 7 -> E <---- 76 | // 77 | // F <- 6 -> G 78 | var graph: [[Int?]] = [ 79 | [0, 5, nil, 3, nil, nil, nil], 80 | [nil, 0, 2, nil, -4, nil, nil], 81 | [nil, 2, 0, nil, 1, nil, nil], 82 | [nil, nil, nil, 0, 7, nil, nil], 83 | [nil, nil, 1, 7, 0, nil, nil], 84 | [nil, nil, nil, nil, nil, 0, 6], 85 | [nil, nil, nil, nil, nil, 6, 0], 86 | ] 87 | warshallFloyd(graph: &graph) 88 | 89 | XCTAssertTrue(graph[1][1]! < 0) 90 | XCTAssertTrue(graph[2][2]! < 0) 91 | XCTAssertTrue(graph[4][4]! < 0) 92 | XCTAssertEqual(graph[5], [nil, nil, nil, nil, nil, 0, 6]) 93 | XCTAssertEqual(graph[6], [nil, nil, nil, nil, nil, 6, 0]) 94 | } 95 | } 96 | } 97 | -------------------------------------------------------------------------------- /Tests/AtCoderSupportTests/XCTestManifests.swift: -------------------------------------------------------------------------------- 1 | #if !canImport(ObjectiveC) 2 | import XCTest 3 | 4 | extension AtCoderSupportTests { 5 | // DO NOT MODIFY: This is autogenerated, use: 6 | // `swift test --generate-linuxmain` 7 | // to regenerate. 8 | static let __allTests__AtCoderSupportTests = [ 9 | ("testExample", testExample), 10 | ] 11 | } 12 | 13 | extension PermutationsTests { 14 | // DO NOT MODIFY: This is autogenerated, use: 15 | // `swift test --generate-linuxmain` 16 | // to regenerate. 17 | static let __allTests__PermutationsTests = [ 18 | ("testPermutatinsPerformance", testPermutatinsPerformance), 19 | ("testPermutations", testPermutations), 20 | ] 21 | } 22 | 23 | public func __allTests() -> [XCTestCaseEntry] { 24 | return [ 25 | testCase(AtCoderSupportTests.__allTests__AtCoderSupportTests), 26 | testCase(PermutationsTests.__allTests__PermutationsTests), 27 | ] 28 | } 29 | #endif 30 | -------------------------------------------------------------------------------- /Tests/Input: -------------------------------------------------------------------------------- 1 | 2 2 | 3 5 3 | 7 11 13 4 | 17 19 23 29 5 | 31 37 41 43 47 6 | -------------------------------------------------------------------------------- /Tests/LinuxMain.swift: -------------------------------------------------------------------------------- 1 | import XCTest 2 | 3 | import AtCoderSupportTests 4 | 5 | var tests = [XCTestCaseEntry]() 6 | tests += AtCoderSupportTests.__allTests() 7 | 8 | XCTMain(tests) 9 | --------------------------------------------------------------------------------