[New Exercise] Add high-scores exercise (#866)

* Add high-scores exercise

* Fixes

Author: Sencudra

config.json

@@ -528,6 +528,18 @@
         "prerequisites": [],
         "difficulty": 2
       },
+      {
+        "slug": "high-scores",
+        "name": "High Scores",
+        "uuid": "6492df34-e0be-4b67-9218-cd732dea2da7",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 2,
+        "topics": [
+          "arrays",
+          "stored-properties"
+        ]
+      },
       {
         "slug": "binary-search",
         "name": "Binary Search",

exercises/practice/high-scores/.docs/instructions.append.md

@@ -0,0 +1,12 @@
+# Instructions append
+ 
+## Some Additional Notes for Swift Implementation
+
+The tests for this exercise expect you to implement a couple of properties that return either a value of type `Int` or an [array][array] of type `[Int]`. Feel free to skim through the Array class documentation for useful methods that may help in your solution.
+
+The final tests check for [immutability][immutability]. None of the properties you are tasked with writing should modify the scores of the game.
+
+If you want some extra practice, you can implement a function that adds new scores to the game or handle empty array
+
+[array]: https://developer.apple.com/documentation/swift/array
+[immutability]: https://en.wikipedia.org/wiki/Immutable_object

exercises/practice/high-scores/.docs/instructions.md

@@ -0,0 +1,6 @@
+# Instructions
+
+Manage a game player's High Score list.
+
+Your task is to build a high-score component of the classic Frogger game, one of the highest selling and most addictive games of all time, and a classic of the arcade era.
+Your task is to write methods that return the highest score from the list, the last added score and the three highest scores.

exercises/practice/high-scores/.meta/Sources/HighScores/HighScoresExample.swift

@@ -0,0 +1,17 @@
+import Foundation
+
+struct HighScores {
+
+    let scores: [Int]
+    let latest: Int?
+    let personalBest: Int?
+    let topThree: [Int]
+
+    init(scores: [Int]) {
+        self.scores = scores
+        self.latest = scores.last
+        self.personalBest = scores.max()
+        self.topThree = Array(scores.sorted(by: >).prefix(3))
+    }
+
+}

exercises/practice/high-scores/.meta/config.json

@@ -0,0 +1,18 @@
+{
+  "authors": [
+    "Sencudra"
+  ],
+  "files": {
+    "solution": [
+      "Sources/HighScores/HighScores.swift"
+    ],
+    "test": [
+      "Tests/HighScoresTests/HighScoresTests.swift"
+    ],
+    "example": [
+      ".meta/Sources/HighScores/HighScoresExample.swift"
+    ]
+  },
+  "blurb": "Manage a player's High Score list.",
+  "source": "Tribute to the eighties' arcade game Frogger"
+}

exercises/practice/high-scores/.meta/template.swift

@@ -0,0 +1,40 @@
+import Testing
+import Foundation
+@testable import {{exercise | camelCase}}
+
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct {{exercise | camelCase}}Tests {
+    {% for case in cases %}
+    {% if not case.cases %}
+        {% if forloop.first %}
+            @Test("{{case.description}}")
+        {% else %}
+            @Test("{{case.description}}", .enabled(if: RUNALL))
+        {% endif -%}
+        func test{{case.description | camelCase}}() {
+            #expect(HighScores(scores: {{case.input.scores}}).{{case.property}} == {{case.expected}})
+        }
+    {%- elif case.cases %}
+        {% for subCase in case.cases %}
+            @Test("{{subCase.description}}", .enabled(if: RUNALL))
+            func test{{subCase.description | camelCase}}() {
+                var hs = HighScores(scores: {{subCase.input.scores}})
+                {%- if subCase.property == "latestAfterTopThree" or subCase.property == "scoresAfterTopThree"  %}
+                    hs.topThree
+                {% elif subCase.property == "latestAfterBest" or subCase.property == "scoresAfterBest" %}
+                    hs.personalBest  
+                {% endif -%}
+                #expect(hs.
+                {%- if subCase.property == "personalTopThree" -%}
+                    topThree
+                {%- elif subCase.property == "latestAfterTopThree" or subCase.property == "latestAfterBest" -%}
+                    latest
+                {%- elif subCase.property == "scoresAfterTopThree" or subCase.property == "scoresAfterBest" -%}
+                    scores
+                {%- endif %} == {{subCase.expected}})
+            }
+        {% endfor -%}
+    {%- endif %}
+    {% endfor -%}
+}

exercises/practice/high-scores/.meta/tests.toml

@@ -0,0 +1,46 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[1035eb93-2208-4c22-bab8-fef06769a73c]
+description = "List of scores"
+
+[6aa5dbf5-78fa-4375-b22c-ffaa989732d2]
+description = "Latest score"
+
+[b661a2e1-aebf-4f50-9139-0fb817dd12c6]
+description = "Personal best"
+
+[3d996a97-c81c-4642-9afc-80b80dc14015]
+description = "Top 3 scores -> Personal top three from a list of scores"
+
+[1084ecb5-3eb4-46fe-a816-e40331a4e83a]
+description = "Top 3 scores -> Personal top highest to lowest"
+
+[e6465b6b-5a11-4936-bfe3-35241c4f4f16]
+description = "Top 3 scores -> Personal top when there is a tie"
+
+[f73b02af-c8fd-41c9-91b9-c86eaa86bce2]
+description = "Top 3 scores -> Personal top when there are less than 3"
+
+[16608eae-f60f-4a88-800e-aabce5df2865]
+description = "Top 3 scores -> Personal top when there is only one"
+
+[2df075f9-fec9-4756-8f40-98c52a11504f]
+description = "Top 3 scores -> Latest score after personal top scores"
+
+[809c4058-7eb1-4206-b01e-79238b9b71bc]
+description = "Top 3 scores -> Scores after personal top scores"
+
+[ddb0efc0-9a86-4f82-bc30-21ae0bdc6418]
+description = "Top 3 scores -> Latest score after personal best"
+
+[6a0fd2d1-4cc4-46b9-a5bb-2fb667ca2364]
+description = "Top 3 scores -> Scores after personal best"

exercises/practice/high-scores/Package.swift

@@ -0,0 +1,21 @@
+// swift-tools-version:6.0
+
+import PackageDescription
+
+let package = Package(
+    name: "HighScores",
+    products: [
+        .library(
+            name: "HighScores",
+            targets: ["HighScores"]),
+    ],
+    dependencies: [],
+    targets: [
+        .target(
+            name: "HighScores",
+            dependencies: []),
+        .testTarget(
+            name: "HighScoresTests",
+            dependencies: ["HighScores"]),
+    ]
+)

exercises/practice/high-scores/Sources/HighScores/HighScores.swift

@@ -0,0 +1,7 @@
+import Foundation
+
+struct HighScores {
+
+    // Write your code for the 'High Scores' exercise here.
+
+}

exercises/practice/high-scores/Tests/HighScoresTests/HighScoresTests.swift

@@ -0,0 +1,83 @@
+import Foundation
+import Testing
+
+@testable import HighScores
+
+let RUNALL = Bool(ProcessInfo.processInfo.environment["RUNALL", default: "false"]) ?? false
+
+@Suite struct HighScoresTests {
+
+  @Test("List of scores")
+  func testListOfScores() {
+    #expect(HighScores(scores: [30, 50, 20, 70]).scores == [30, 50, 20, 70])
+  }
+
+  @Test("Latest score", .enabled(if: RUNALL))
+  func testLatestScore() {
+    #expect(HighScores(scores: [100, 0, 90, 30]).latest == 30)
+  }
+
+  @Test("Personal best", .enabled(if: RUNALL))
+  func testPersonalBest() {
+    #expect(HighScores(scores: [40, 100, 70]).personalBest == 100)
+  }
+
+  @Test("Personal top three from a list of scores", .enabled(if: RUNALL))
+  func testPersonalTopThreeFromAListOfScores() {
+    var hs = HighScores(scores: [10, 30, 90, 30, 100, 20, 10, 0, 30, 40, 40, 70, 70])
+    #expect(hs.topThree == [100, 90, 70])
+  }
+
+  @Test("Personal top highest to lowest", .enabled(if: RUNALL))
+  func testPersonalTopHighestToLowest() {
+    var hs = HighScores(scores: [20, 10, 30])
+    #expect(hs.topThree == [30, 20, 10])
+  }
+
+  @Test("Personal top when there is a tie", .enabled(if: RUNALL))
+  func testPersonalTopWhenThereIsATie() {
+    var hs = HighScores(scores: [40, 20, 40, 30])
+    #expect(hs.topThree == [40, 40, 30])
+  }
+
+  @Test("Personal top when there are less than 3", .enabled(if: RUNALL))
+  func testPersonalTopWhenThereAreLessThan3() {
+    var hs = HighScores(scores: [30, 70])
+    #expect(hs.topThree == [70, 30])
+  }
+
+  @Test("Personal top when there is only one", .enabled(if: RUNALL))
+  func testPersonalTopWhenThereIsOnlyOne() {
+    var hs = HighScores(scores: [40])
+    #expect(hs.topThree == [40])
+  }
+
+  @Test("Latest score after personal top scores", .enabled(if: RUNALL))
+  func testLatestScoreAfterPersonalTopScores() {
+    var hs = HighScores(scores: [70, 50, 20, 30])
+    hs.topThree
+    #expect(hs.latest == 30)
+  }
+
+  @Test("Scores after personal top scores", .enabled(if: RUNALL))
+  func testScoresAfterPersonalTopScores() {
+    var hs = HighScores(scores: [30, 50, 20, 70])
+    hs.topThree
+    #expect(hs.scores == [30, 50, 20, 70])
+  }
+
+  @Test("Latest score after personal best", .enabled(if: RUNALL))
+  func testLatestScoreAfterPersonalBest() {
+    var hs = HighScores(scores: [20, 70, 15, 25, 30])
+    hs.personalBest
+    #expect(hs.latest == 30)
+  }
+
+  @Test("Scores after personal best", .enabled(if: RUNALL))
+  func testScoresAfterPersonalBest() {
+    var hs = HighScores(scores: [20, 70, 15, 25, 30])
+    hs.personalBest
+    #expect(hs.scores == [20, 70, 15, 25, 30])
+  }
+
+}