trackler 2.2.1.60 → 2.2.1.61

data/tracks/swift/exercises/poker/Sources/PokerExample.swift

@@ -88,15 +88,15 @@ enum HandRank {
         let first = sorted[0].rank.rawValue
         for (index, each) in sorted.enumerated() {
             guard each.rank.rawValue != index + first else { continue }
-                // checks for Ace as the lowest card
-                guard let aceIndex = inputHand.hand.index(where: { $0.rank.rawValue == 14 })else { return (false, .ace) }
-                var replacedAced = inputHand.hand.map({ $0.rank.rawValue })
-                replacedAced[aceIndex] = 1 // swaps ace value to lowest
-                replacedAced.sort()
-                let firstVal = replacedAced[0]
-                for (idx, eachVal) in replacedAced.enumerated() {
-                    guard eachVal == firstVal + idx else { return (false, .ace) }
-                }
+            // checks for Ace as the lowest card
+            guard let aceIndex = inputHand.hand.index(where: { $0.rank.rawValue == 14 })else { return (false, .ace) }
+            var replacedAced = inputHand.hand.map({ $0.rank.rawValue })
+            replacedAced[aceIndex] = 1 // swaps ace value to lowest
+            replacedAced.sort()
+            let firstVal = replacedAced[0]
+            for (idx, eachVal) in replacedAced.enumerated() {
+                guard eachVal == firstVal + idx else { return (false, .ace) }
+            }
         }
         let last = sorted[sorted.count - 1].rank
         return (true, last)
@@ -144,104 +144,103 @@ enum HandRank {
     }
 }
 
-extension HandRank : Equatable, Comparable {}
-
-func == (lhs: HandRank, rhs: HandRank) -> Bool {
-    switch (lhs, rhs) {
-    //straightFlush(Rank,Suit)
-    case (HandRank.straightFlush(let lRank, let lSuit), HandRank.straightFlush(let rRank, let rSuit)):
-        return lRank == rRank && lSuit == rSuit
-    //fourOfAKind(four:Rank)
-    case (HandRank.fourOfAKind(four: let lFour),
-          HandRank.fourOfAKind(four: let rFour)):
-        return lFour == rFour
-    //fullHouse(three:Rank)
-    case (HandRank.fullHouse(three: let lThree),
-          HandRank.fullHouse(three: let rThree)):
-        return lThree == rThree
-    //flush(Suit)
-    case (HandRank.flush(let lRank, let lSuit), HandRank.flush(let rRank, let rSuit)):
-        return lSuit == rSuit && lRank == rRank
-    //straight(high:Rank)
-    case (HandRank.straight(high: let lRank),
-          HandRank.straight(high: let rRank)):
-        return lRank == rRank
-    //threeOfAKind(three:Rank)
-    case (HandRank.threeOfAKind(three: let lRank),
-          HandRank.threeOfAKind(three: let rRank)):
-        return lRank == rRank
-    //twoPair(high:Rank,low:Rank, highCard:PlayingCard)
-    case (HandRank.twoPair(high: let lHigh, low: let lLow, highCard: let lCard), HandRank.twoPair(high: let rHigh, low: let rLow, highCard: let rCard)):
-        return lHigh == rHigh && lLow == rLow && lCard == rCard
-    //onePair(Rank)
-    case (HandRank.onePair(let lPairRank, card1: let lCard1, card2: let lCard2, card3: let lCard3),
-          HandRank.onePair(let rPairRank, card1: let rCard1, card2: let rCard2, card3: let rCard3)):
-        return lPairRank == rPairRank && lCard1 == rCard1 && lCard2 == rCard2 && lCard3 == rCard3
-    //highCard(PlayingCard)
-    case (HandRank.highCard(let lCard), HandRank.highCard(let rCard)):
-        return lCard == rCard
-    default:
-        return false
+extension HandRank: Equatable {
+    static func == (lhs: HandRank, rhs: HandRank) -> Bool {
+        switch (lhs, rhs) {
+        //straightFlush(Rank,Suit)
+        case (HandRank.straightFlush(let lRank, let lSuit), HandRank.straightFlush(let rRank, let rSuit)):
+            return lRank == rRank && lSuit == rSuit
+        //fourOfAKind(four:Rank)
+        case (HandRank.fourOfAKind(four: let lFour),
+              HandRank.fourOfAKind(four: let rFour)):
+            return lFour == rFour
+        //fullHouse(three:Rank)
+        case (HandRank.fullHouse(three: let lThree),
+              HandRank.fullHouse(three: let rThree)):
+            return lThree == rThree
+        //flush(Suit)
+        case (HandRank.flush(let lRank, let lSuit), HandRank.flush(let rRank, let rSuit)):
+            return lSuit == rSuit && lRank == rRank
+        //straight(high:Rank)
+        case (HandRank.straight(high: let lRank),
+              HandRank.straight(high: let rRank)):
+            return lRank == rRank
+        //threeOfAKind(three:Rank)
+        case (HandRank.threeOfAKind(three: let lRank),
+              HandRank.threeOfAKind(three: let rRank)):
+            return lRank == rRank
+        //twoPair(high:Rank,low:Rank, highCard:PlayingCard)
+        case (HandRank.twoPair(high: let lHigh, low: let lLow, highCard: let lCard), HandRank.twoPair(high: let rHigh, low: let rLow, highCard: let rCard)):
+            return lHigh == rHigh && lLow == rLow && lCard == rCard
+        //onePair(Rank)
+        case (HandRank.onePair(let lPairRank, card1: let lCard1, card2: let lCard2, card3: let lCard3),
+              HandRank.onePair(let rPairRank, card1: let rCard1, card2: let rCard2, card3: let rCard3)):
+            return lPairRank == rPairRank && lCard1 == rCard1 && lCard2 == rCard2 && lCard3 == rCard3
+        //highCard(PlayingCard)
+        case (HandRank.highCard(let lCard), HandRank.highCard(let rCard)):
+            return lCard == rCard
+        default:
+            return false
+        }
     }
 }
-// swiftlint:disable:next cyclomatic_complexity
-// swiftlint:disable:next empty_enum_arguments
-func < (lhs: HandRank, rhs: HandRank) -> Bool {
-    switch (lhs, rhs) {
-    case (_, _) where lhs == rhs:
-        return false
-
-    //straightFlush(Rank,Suit)
-    case (HandRank.straightFlush(let lRank, let lSuit), HandRank.straightFlush(let rRank, let rSuit)):
-        return lRank == rRank ? lSuit < rSuit : lRank < rRank
-
-    //fourOfAKind(four:Rank)
-    case (HandRank.fourOfAKind(four: let lFour),
-          HandRank.fourOfAKind(four: let rFour)):
-        return lFour < rFour
-
-    //fullHouse(three:Rank)
-    case (HandRank.fullHouse(three: let lRank),
-          HandRank.fullHouse(three: let rRank)):
-        return lRank < rRank
-
-    //flush(Suit)
-    case (HandRank.flush(let lRank, let lSuit), HandRank.flush(let rRank, let rSuit)):
-        return lRank == rRank ? lSuit < rSuit : lRank < rRank
-
-    //straight(high:Rank)
-    case (HandRank.straight(high: let lRank),
-          HandRank.straight(high: let rRank)):
-        return lRank < rRank
-
-    //threeOfAKind(three:Rank)
-    case (HandRank.threeOfAKind(three: let lRank),
-          HandRank.threeOfAKind(three: let rRank)):
-        return lRank < rRank
-
-    //twoPair(high:Rank,low:Rank, highCard:PlayingCard)
-    case (HandRank.twoPair(high: let lHigh, low: let lLow, highCard: let lCard), HandRank.twoPair(high: let rHigh, low: let rLow, highCard: let rCard)):
-        if lHigh == rHigh && lLow == rLow {
-            return lCard < rCard
-        } else {
-            return lHigh < rHigh
-        }
 
-    //onePair(Rank)
-    case (HandRank.onePair(let lPairRank, card1: let lCard1, card2: let lCard2, card3: let lCard3),
-          HandRank.onePair(let rPairRank, card1: let rCard1, card2: let rCard2, card3: let rCard3)):
-        return lPairRank == rPairRank ? (lCard1 == rCard1 ? (lCard2 == rCard2 ? lCard3 < rCard3 :lCard2 < rCard2):lCard1 < rCard1):lPairRank < rPairRank
+extension HandRank: Comparable {
+    static func < (lhs: HandRank, rhs: HandRank) -> Bool {
+        switch (lhs, rhs) {
+        case (_, _) where lhs == rhs:
+            return false
+
+        //straightFlush(Rank,Suit)
+        case (HandRank.straightFlush(let lRank, let lSuit), HandRank.straightFlush(let rRank, let rSuit)):
+            return lRank == rRank ? lSuit < rSuit : lRank < rRank
+
+        //fourOfAKind(four:Rank)
+        case (HandRank.fourOfAKind(four: let lFour),
+              HandRank.fourOfAKind(four: let rFour)):
+            return lFour < rFour
+
+        //fullHouse(three:Rank)
+        case (HandRank.fullHouse(three: let lRank),
+              HandRank.fullHouse(three: let rRank)):
+            return lRank < rRank
+
+        //flush(Suit)
+        case (HandRank.flush(let lRank, let lSuit), HandRank.flush(let rRank, let rSuit)):
+            return lRank == rRank ? lSuit < rSuit : lRank < rRank
+
+        //straight(high:Rank)
+        case (HandRank.straight(high: let lRank),
+              HandRank.straight(high: let rRank)):
+            return lRank < rRank
+
+        //threeOfAKind(three:Rank)
+        case (HandRank.threeOfAKind(three: let lRank),
+              HandRank.threeOfAKind(three: let rRank)):
+            return lRank < rRank
+
+        //twoPair(high:Rank,low:Rank, highCard:PlayingCard)
+        case (HandRank.twoPair(high: let lHigh, low: let lLow, highCard: let lCard), HandRank.twoPair(high: let rHigh, low: let rLow, highCard: let rCard)):
+            if lHigh == rHigh && lLow == rLow {
+                return lCard < rCard
+            } else {
+                return lHigh < rHigh
+            }
 
-    //highCard(PlayingCard)
-    case (HandRank.highCard(let lCard), HandRank.highCard(let rCard)):
-        return lCard < rCard
+        //onePair(Rank)
+        case (HandRank.onePair(let lPairRank, card1: let lCard1, card2: let lCard2, card3: let lCard3),
+              HandRank.onePair(let rPairRank, card1: let rCard1, card2: let rCard2, card3: let rCard3)):
+            return lPairRank == rPairRank ? (lCard1 == rCard1 ? (lCard2 == rCard2 ? lCard3 < rCard3 :lCard2 < rCard2):lCard1 < rCard1):lPairRank < rPairRank
 
-    default:
-        return lhs.order() < rhs.order()
-    }
+        //highCard(PlayingCard)
+        case (HandRank.highCard(let lCard), HandRank.highCard(let rCard)):
+            return lCard < rCard
 
+        default:
+            return lhs.order() < rhs.order()
+        }
+    }
 }
-// swiftlint:enable:next empty_enum_arguments
 
 struct PokerHand {
     let hand: [PlayingCard]
@@ -262,15 +261,19 @@ struct PokerHand {
         if handParsed.count == 5 { self.hand = handParsed } else { return nil }
     }
 }
-extension PokerHand : Equatable, Comparable {}
 
-func == (lhs: PokerHand, rhs: PokerHand) -> Bool {
-    return lhs.hand == rhs.hand
+extension PokerHand: Equatable {
+    static func == (lhs: PokerHand, rhs: PokerHand) -> Bool {
+        return lhs.hand == rhs.hand
+    }
 }
 
-func < (lhs: PokerHand, rhs: PokerHand) -> Bool {
-    return lhs.handRank() < rhs.handRank()
+extension PokerHand: Comparable {
+    static func < (lhs: PokerHand, rhs: PokerHand) -> Bool {
+        return lhs.handRank() < rhs.handRank()
+    }
 }
+
 struct PlayingCard {
     let rank: Rank
     let suit: Suit
@@ -290,15 +293,18 @@ struct PlayingCard {
     }
 }
 
-extension PlayingCard : Equatable, Comparable {}
-
-func == (lhs: PlayingCard, rhs: PlayingCard) -> Bool {
-    return lhs.rank == rhs.rank && lhs.suit == rhs.suit
+extension PlayingCard: Equatable {
+    static func == (lhs: PlayingCard, rhs: PlayingCard) -> Bool {
+        return lhs.rank == rhs.rank && lhs.suit == rhs.suit
+    }
 }
 
-func < (lhs: PlayingCard, rhs: PlayingCard) -> Bool {
-    return lhs.rank == rhs.rank ? lhs.suit < rhs.suit : lhs.rank < rhs.rank
+extension PlayingCard: Comparable {
+    static func < (lhs: PlayingCard, rhs: PlayingCard) -> Bool {
+        return lhs.rank == rhs.rank ? lhs.suit < rhs.suit : lhs.rank < rhs.rank
+    }
 }
+
 enum Rank: Int {
     case two = 2
     case three, four, five, six, seven, eight, nine, ten
@@ -333,28 +339,28 @@ enum Suit: String {
     }
 }
 
-extension Rank : Comparable {}
-
-func < (lhs: Rank, rhs: Rank) -> Bool {
-    switch (lhs, rhs) {
-    case (_, _) where lhs == rhs:
-        return false
-    default:
-        return lhs.rawValue < rhs.rawValue
+extension Rank: Comparable {
+    static func < (lhs: Rank, rhs: Rank) -> Bool {
+        switch (lhs, rhs) {
+        case (_, _) where lhs == rhs:
+            return false
+        default:
+            return lhs.rawValue < rhs.rawValue
+        }
     }
 }
 
-extension Suit: Comparable {}
-
-func < (lhs: Suit, rhs: Suit) -> Bool {
-    switch (lhs, rhs) {
-    case (_, _) where lhs == rhs:
-        return false
-    case (.spades, _),
-         (.hearts, .diamonds), (.hearts, .clubs),
-         (.diamonds, .clubs):
-        return false
-    default:
-        return true
+extension Suit: Comparable {
+    static func < (lhs: Suit, rhs: Suit) -> Bool {
+        switch (lhs, rhs) {
+        case (_, _) where lhs == rhs:
+            return false
+        case (.spades, _),
+             (.hearts, .diamonds), (.hearts, .clubs),
+             (.diamonds, .clubs):
+            return false
+        default:
+            return true
+        }
     }
 }

data/tracks/swift/exercises/rna-transcription/Sources/RnaTranscriptionExample.swift

@@ -13,9 +13,9 @@ struct Nucleotide {
         self.value = nucleotide
     }
 
-    private let dnaToRna: [Character:String] = [ "G": "C", "C": "G", "T": "A", "A": "U" ]
+    private let dnaToRna: [Character: String] = [ "G": "C", "C": "G", "T": "A", "A": "U" ]
 
-    private func transcribe(_ dict: [Character : String]) throws -> String {
+    private func transcribe(_ dict: [Character: String]) throws -> String {
         var tempText = ""
         for each in self.value.characters {
             if dict[each] == nil {

data/tracks/swift/exercises/rotational-cipher/Sources/RotationalCipherExample.swift

@@ -7,18 +7,18 @@ struct RotationalCipher {
         target.unicodeScalars.forEach { unicode in
 
             switch unicode.value {
-                case 65...90: // A to Z
-                    var scalar = unicode.value + UInt32(ROT)
-                    if scalar > 90 { scalar -= 26 }
-                    result.append(Character(UnicodeScalar(scalar)!))
-
-                case 97...122: // a to z
-                    var scalar = unicode.value + UInt32(ROT)
-                    if scalar > 122 { scalar -= 26 }
-                    result.append(Character(UnicodeScalar(scalar)!))
-
-                default:
-                    result.append(Character(unicode))
+            case 65...90: // A to Z
+                var scalar = unicode.value + UInt32(ROT)
+                if scalar > 90 { scalar -= 26 }
+                result.append(Character(UnicodeScalar(scalar)!))
+
+            case 97...122: // a to z
+                var scalar = unicode.value + UInt32(ROT)
+                if scalar > 122 { scalar -= 26 }
+                result.append(Character(UnicodeScalar(scalar)!))
+
+            default:
+                result.append(Character(unicode))
             }
 
         }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trackler
 version: !ruby/object:Gem::Version
-  version: 2.2.1.60
+  version: 2.2.1.61
 platform: ruby
 authors:
 - Katrina Owen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-11-05 00:00:00.000000000 Z
+date: 2017-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rubyzip
@@ -454,6 +454,7 @@ files:
 - problem-specifications/exercises/prime-factors/metadata.yml
 - problem-specifications/exercises/protein-translation/description.md
 - problem-specifications/exercises/protein-translation/metadata.yml
+- problem-specifications/exercises/proverb/canonical-data.json
 - problem-specifications/exercises/proverb/description.md
 - problem-specifications/exercises/proverb/metadata.yml
 - problem-specifications/exercises/pythagorean-triplet/description.md
@@ -652,6 +653,7 @@ files:
 - tracks/c/bin/verify-indent
 - tracks/c/config.json
 - tracks/c/config/exercise_readme.go.tmpl
+- tracks/c/config/maintainers.json
 - tracks/c/docs/ABOUT.md
 - tracks/c/docs/CONTRIBUTING.md
 - tracks/c/docs/C_STYLE_GUIDE.md
@@ -3464,6 +3466,10 @@ files:
 - tracks/ecmascript/exercises/hexadecimal/example.js
 - tracks/ecmascript/exercises/hexadecimal/hexadecimal.spec.js
 - tracks/ecmascript/exercises/hexadecimal/package.json
+- tracks/ecmascript/exercises/house/README.md
+- tracks/ecmascript/exercises/house/example.js
+- tracks/ecmascript/exercises/house/house.spec.js
+- tracks/ecmascript/exercises/house/package.json
 - tracks/ecmascript/exercises/isbn-verifier/README.md
 - tracks/ecmascript/exercises/isbn-verifier/example.js
 - tracks/ecmascript/exercises/isbn-verifier/isbn-verifier.spec.js
@@ -5774,7 +5780,9 @@ files:
 - tracks/go/exercises/isbn-verifier/README.md
 - tracks/go/exercises/isbn-verifier/example.go
 - tracks/go/exercises/isbn-verifier/isbn_verifier_test.go
+- tracks/go/exercises/isogram/.meta/gen.go
 - tracks/go/exercises/isogram/README.md
+- tracks/go/exercises/isogram/cases_test.go
 - tracks/go/exercises/isogram/example.go
 - tracks/go/exercises/isogram/isogram_test.go
 - tracks/go/exercises/kindergarten-garden/README.md
@@ -10564,6 +10572,10 @@ files:
 - tracks/python/exercises/diffie-hellman/diffie_hellman.py
 - tracks/python/exercises/diffie-hellman/diffie_hellman_test.py
 - tracks/python/exercises/diffie-hellman/example.py
+- tracks/python/exercises/dominoes/README.md
+- tracks/python/exercises/dominoes/dominoes.py
+- tracks/python/exercises/dominoes/dominoes_test.py
+- tracks/python/exercises/dominoes/example.py
 - tracks/python/exercises/error-handling/.meta/hints.md
 - tracks/python/exercises/error-handling/README.md
 - tracks/python/exercises/error-handling/error_handling.py
@@ -10741,6 +10753,10 @@ files:
 - tracks/python/exercises/raindrops/example.py
 - tracks/python/exercises/raindrops/raindrops.py
 - tracks/python/exercises/raindrops/raindrops_test.py
+- tracks/python/exercises/react/README.md
+- tracks/python/exercises/react/example.py
+- tracks/python/exercises/react/react.py
+- tracks/python/exercises/react/react_test.py
 - tracks/python/exercises/rectangles/README.md
 - tracks/python/exercises/rectangles/example.py
 - tracks/python/exercises/rectangles/rectangles.py
@@ -13053,6 +13069,12 @@ files:
 - tracks/swift/exercises/clock/Sources/ClockExample.swift
 - tracks/swift/exercises/clock/Tests/ClockTests/ClockTests.swift
 - tracks/swift/exercises/clock/Tests/LinuxMain.swift
+- tracks/swift/exercises/collatz-conjecture/Package.swift
+- tracks/swift/exercises/collatz-conjecture/README.md
+- tracks/swift/exercises/collatz-conjecture/Sources/CollatzConjecture.swift
+- tracks/swift/exercises/collatz-conjecture/Sources/CollatzConjectureExample.swift
+- tracks/swift/exercises/collatz-conjecture/Tests/CollatzConjectureTests/CollatzConjectureTests.swift
+- tracks/swift/exercises/collatz-conjecture/Tests/LinuxMain.swift
 - tracks/swift/exercises/crypto-square/.gitignore
 - tracks/swift/exercises/crypto-square/Package.swift
 - tracks/swift/exercises/crypto-square/README.md