Compressing a Swift array

Suppose you have an array of values in your Swift app and you need to compress it to a smaller size, with the intention of making it occupy less memory. If the array contains many consecutive repeated values it could be compressed by only including a repeated value once, and tracking the number of consecutive occurrences for that value.

How might that code work? What about the code to decompress an array, how can that be implemented in Swift?

If you are interested in figuring this out yourself, I posted a gist that you can use as a starting point to test your code:

import Foundation
/**
Returns a compacted array, with repeated values coalesced.
Example: [a, a, b, c, c, c] yields [(a, 2), (b, 1), (c, 3)]
*/
func compressArray<T: Comparable>(input: [T]) -> [(T, Int)] {
// TODO – implement this function
return []
}
/**
Returns the original, expanded form of a compressed array.
Example: [(a, 2), (b, 1), (c, 3)] yields [a, a, b, c, c, c]
*/
func decompressArray<T>(input: [(T, Int)]) -> [T] {
// TODO – implement this function
return []
}
let uncompressedInts = [
8, 8, 8,
2, 2, 2, 2, 2, 2, 2, 2, 2,
8,
3,
5, 5, 5, 5,
0, 0, 0, 0, 0, 0, 0,
9]
let expectedCompressedArray = [
(8, 3),
(2, 9),
(8, 1),
(3, 1),
(5, 4),
(0, 7),
(9, 1)]
let compressedArray = compressArray(uncompressedInts)
let isCompressionCorrect = compressedArray.elementsEqual(expectedCompressedArray) {
$0.0 == $1.0 && $0.1 == $1.1
}
if isCompressionCorrect {
print("Compression success!")
} else {
print("Compression failure: \(compressedArray)")
}
let decompressedArray = decompressArray(compressedArray)
let isDecompressionCorrect = decompressedArray == uncompressedInts
if isDecompressionCorrect {
print("Decompression success!")
} else {
print("Decompression failure: \(decompressedArray)")
}

view raw
compress.swift
hosted with ❤ by GitHub

My solution is shown below. It uses some slick Swift goodness, such as a where clause, the flatMap method, and tuple decomposition.

compression

The full source code is available, as a playground, here:

https://github.com/ijoshsmith/swift-array-compression

Happy Swifting!

About Josh Smith

Josh Smith is a musician at heart, and a software developer by obsession. He lives in Arizona, plays classical music on the piano, jazz on the guitar, and enjoys brutally long rides on his bicycle. He has a wonderful wife & son and thinks that, in general, life is good.
This entry was posted in Swift and tagged . Bookmark the permalink.

1 Response to Compressing a Swift array

  1. Pingback: Dew Drop – November 27, 2015 (#2140) | Morning Dew

Comments are closed.