codee
diff --git a/‎Bucket Sort/BucketSort.playground/Contents.swift
Lines changed: 2 additions & 5 deletions b/‎Bucket Sort/BucketSort.playground/Contents.swift
Lines changed: 2 additions & 5 deletions
diff --git a/‎Bucket Sort/BucketSort.playground/Sources/BucketSort.swift
Lines changed: 7 additions & 8 deletions b/‎Bucket Sort/BucketSort.playground/Sources/BucketSort.swift
Lines changed: 7 additions & 8 deletions
@@ -20,9 +20,6 @@
 //
 //
 
-
-
-
 //////////////////////////////////////
 // MARK: Extensions
 //////////////////////////////////////
@@ -38,8 +35,8 @@ extension Int: IntConvertible, Sortable {
 //////////////////////////////////////
 
 let input = [1, 2, 4, 6, 10]
-let buckets = [Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15)]
+var buckets = [Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15), Bucket<Int>(capacity: 15)]
 
-let sortedElements = bucketSort(input, distributor: RangeDistributor(), sorter: InsertionSorter(), buckets: buckets)
+let sortedElements = bucketSort(elements: input, distributor: RangeDistributor(), sorter: InsertionSorter(), buckets: &buckets)
 
 print(sortedElements)
@@ -27,16 +27,15 @@ import Foundation
 //////////////////////////////////////
 
 
-public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {
-  var bucketsCopy = buckets
+public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: inout [Bucket<T>]) -> [T] {
   for elem in elements {
-    distributor.distribute(elem, buckets: &bucketsCopy)
+    distributor.distribute(element: elem, buckets: &buckets)
   }
 
   var results = [T]()
 
   for bucket in buckets {
-    results += bucket.sort(sorter)
+    results += bucket.sort(algorithm: sorter)
   }
 
   return results
@@ -48,7 +47,7 @@ public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sor
 
 
 public protocol Distributor {
-  func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>])
+  func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>])
 }
 
 /*
@@ -70,12 +69,12 @@ public struct RangeDistributor: Distributor {
 
   public init() {}
 
-  public func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>]) {
+  public func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>]) {
     let value = element.toInt()
     let bucketCapacity = buckets.first!.capacity
 
     let bucketIndex = value / bucketCapacity
-    buckets[bucketIndex].add(element)
+    buckets[bucketIndex].add(item: element)
   }
 }
 
@@ -139,6 +138,6 @@ public struct Bucket<T:Sortable> {
   }
 
   public func sort(algorithm: Sorter) -> [T] {
-    return algorithm.sort(elements)
+    return algorithm.sort(items: elements)
   }
 }
Original file line number	Diff line number	Diff line change
`@@ -27,16 +27,15 @@ import Foundation`
`27`	`27`	`//////////////////////////////////////`
`28`	`28`
`29`	`29`
`30`		`-public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: [Bucket<T>]) -> [T] {`
`31`		`- var bucketsCopy = buckets`
	`30`	`+public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sorter: Sorter, buckets: inout [Bucket<T>]) -> [T] {`
`32`	`31`	`for elem in elements {`
`33`		`- distributor.distribute(elem, buckets: &bucketsCopy)`
	`32`	`+ distributor.distribute(element: elem, buckets: &buckets)`
`34`	`33`	`}`
`35`	`34`
`36`	`35`	`var results = [T]()`
`37`	`36`
`38`	`37`	`for bucket in buckets {`
`39`		`- results += bucket.sort(sorter)`
	`38`	`+ results += bucket.sort(algorithm: sorter)`
`40`	`39`	`}`
`41`	`40`
`42`	`41`	`return results`
`@@ -48,7 +47,7 @@ public func bucketSort<T: Sortable>(elements: [T], distributor: Distributor, sor`
`48`	`47`
`49`	`48`
`50`	`49`	`public protocol Distributor {`
`51`		`- func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>])`
	`50`	`+ func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>])`
`52`	`51`	`}`
`53`	`52`
`54`	`53`	`/*`
`@@ -70,12 +69,12 @@ public struct RangeDistributor: Distributor {`
`70`	`69`
`71`	`70`	`public init() {}`
`72`	`71`
`73`		`- public func distribute<T: Sortable>(element: T, inout buckets: [Bucket<T>]) {`
	`72`	`+ public func distribute<T: Sortable>(element: T, buckets: inout [Bucket<T>]) {`
`74`	`73`	`let value = element.toInt()`
`75`	`74`	`let bucketCapacity = buckets.first!.capacity`
`76`	`75`
`77`	`76`	`let bucketIndex = value / bucketCapacity`
`78`		`- buckets[bucketIndex].add(element)`
	`77`	`+ buckets[bucketIndex].add(item: element)`
`79`	`78`	`}`
`80`	`79`	`}`
`81`	`80`
`@@ -139,6 +138,6 @@ public struct Bucket<T:Sortable> {`
`139`	`138`	`}`
`140`	`139`
`141`	`140`	`public func sort(algorithm: Sorter) -> [T] {`
`142`		`- return algorithm.sort(elements)`
	`141`	`+ return algorithm.sort(items: elements)`
`143`	`142`	`}`
`144`	`143`	`}`