Two extra concept exercises (#180)

Author: keiravillekode

concepts/sequences/about.md

@@ -13,6 +13,8 @@ with the others.
 | `nth`       | `( n seq -- elt )` (0-based)      |
 | `head`      | `( seq n -- headseq )`            |
 | `tail`      | `( seq n -- tailseq )`            |
+| `pad-head`  | `( seq n elt -- padded )`         |
+| `pad-tail`  | `( seq n elt -- padded )`         |
 | `prefix`    | `( seq elt -- newseq )`           |
 | `suffix`    | `( seq elt -- newseq )`           |
 | `unclip`    | `( seq -- rest first )`           |

concepts/tabulation/.meta/config.json

@@ -0,0 +1,6 @@
+{
+  "authors": [
+    "keiravillekode"
+  ],
+  "blurb": "Build a sequence index by index using <iota> + map, and turn it into a string with >string."
+}

concepts/tabulation/about.md

@@ -0,0 +1,33 @@
+# About
+
+Factor's `<iota>` produces a *virtual* sequence of the integers
+`0, 1, …, n-1`. Walking it with `map` yields a tabulated sequence
+where each element is a function of its position:
+
+```factor
+USING: math sequences ;
+
+5 <iota> [ sq ] map .         ! => { 0 1 4 9 16 }
+8 <iota> [ 1 + ] map .        ! => { 1 2 3 4 5 6 7 8 }
+```
+
+Two pieces let you turn a sequence of integer codes into a
+string:
+
+| word      | role                                                    |
+|-----------|---------------------------------------------------------|
+| `CHAR:`   | parse-time literal that pushes a character's code point |
+| `>string` | convert a sequence of code points to a string           |
+
+Combined, they form the standard idiom for building a row of
+characters indexed by position:
+
+```factor
+USING: kernel math sequences strings ;
+
+10 <iota> [ 2 mod zero? [ CHAR: O ] [ CHAR: . ] if ] map >string .
+! => "O.O.O.O.O."
+```
+
+Choosing the character with `if` (or `?`) inside the quotation
+keeps the per-position decision close to the index it depends on.

concepts/tabulation/introduction.md

@@ -0,0 +1,26 @@
+# Introduction
+
+When you need a sequence of `n` values where each one depends on
+its index, Factor gives you `<iota>` — a virtual sequence of the
+integers `0, 1, …, n-1` — and `map`:
+
+```factor
+USING: math sequences ;
+
+5 <iota> [ 2 * ] map .   ! => { 0 2 4 6 8 }
+```
+
+`<iota>` doesn't allocate the integers up front; `map` walks
+through them in order, applying the quotation to each.
+
+If the per-position result is a character code, `>string` turns
+the result into a string — the natural way to assemble a row of
+characters from index-driven decisions:
+
+```factor
+USING: strings ;
+
+5 <iota> [ CHAR: a + ] map >string .   ! => "abcde"
+```
+
+[strings]: https://docs.factorcode.org/content/article-strings.html

concepts/tabulation/links.json

@@ -0,0 +1,10 @@
+[
+  {
+    "url": "https://docs.factorcode.org/content/article-sequences.html",
+    "description": "Sequences — Factor handbook"
+  },
+  {
+    "url": "https://docs.factorcode.org/content/article-strings.html",
+    "description": "Strings — Factor handbook"
+  }
+]

config.json

@@ -129,6 +129,20 @@
         ],
         "status": "beta"
       },
+      {
+        "slug": "bunting-builder",
+        "name": "Brooke's Bunting Builder",
+        "uuid": "f7c75218-7eb2-4985-9efe-f6cfd5a04b45",
+        "concepts": [
+          "tabulation"
+        ],
+        "prerequisites": [
+          "quotations",
+          "strings",
+          "conditionals"
+        ],
+        "status": "beta"
+      },
       {
         "slug": "backyard-birdwatcher",
         "name": "Backyard Birdwatcher",
@@ -138,7 +152,8 @@
         ],
         "prerequisites": [
           "stack-effect",
-          "conditionals"
+          "conditionals",
+          "tabulation"
         ],
         "status": "beta"
       },
@@ -899,7 +914,8 @@
           "strings",
           "higher-order-sequences",
           "unicode",
-          "locals"
+          "locals",
+          "quotations-call"
         ],
         "difficulty": 5
       },
@@ -1226,6 +1242,11 @@
       "slug": "bitwise-operations",
       "name": "Bitwise Operations"
     },
+    {
+      "uuid": "0e95ebe8-0b9c-4b52-8f84-f3f04fc2fd83",
+      "slug": "tabulation",
+      "name": "Tabulation"
+    },
     {
       "uuid": "638e8893-fd14-4448-87c8-13029851f225",
       "slug": "sequences",

exercises/concept/backyard-birdcount/.docs/introduction.md

@@ -81,8 +81,8 @@ prefix ( seq elt -- newseq )
 ```
 
 ```factor
-{ 0 2 } 5 prefix .
-! => { 5 0 2 }
+{ 7 9 } 3 prefix .
+! => { 3 7 9 }
 ```
 
 [sequences]: https://docs.factorcode.org/content/vocab-sequences.html

exercises/concept/backyard-birdwatcher/.docs/hints.md

@@ -32,5 +32,12 @@
 - `count` takes a sequence and a predicate, like `any?` does, but
   returns *how many* elements matched.
 
+## 6. Pad missing days
+
+- `pad-tail` takes a sequence, a target length, and a fill element,
+  and extends the sequence to that length by appending copies of
+  the element. If the sequence is already long enough, it is
+  returned unchanged.
+
 [sequences]: https://docs.factorcode.org/content/vocab-sequences.html
 [math.statistics]: https://docs.factorcode.org/content/vocab-math.statistics.html

exercises/concept/backyard-birdwatcher/.docs/instructions.md

@@ -56,3 +56,20 @@ return the number of busy days in the array.
 { 2 5 0 7 4 1 } busy-days .
 ! => 2
 ```
+
+## 6. Pad missing days
+
+If you didn't watch on every day of an `n`-day stretch, fill the
+missing trailing days with `0`. Define `pad-missing-days` to take
+an array of counts and a target length `n`, and return an array
+of length at least `n` whose extra slots are `0`. Existing counts
+must be preserved unchanged; if the input is already at least `n`
+long, return it unchanged.
+
+```factor
+{ 2 5 0 } 7 pad-missing-days .
+! => { 2 5 0 0 0 0 0 }
+
+{ 4 1 6 8 } 3 pad-missing-days .
+! => { 4 1 6 8 }
+```

exercises/concept/backyard-birdwatcher/.docs/introduction.md

@@ -44,6 +44,32 @@ tail ( seq n -- tailseq )    ! drop first n
 { 1 2 3 4 5 } 3 tail .   ! => { 4 5 }
 ```
 
+## Padding
+
+```
+pad-head ( seq n elt -- padded )    ! prepend copies of elt
+pad-tail ( seq n elt -- padded )    ! append copies of elt
+```
+
+Both extend `seq` until its length is at least `n`. If `seq` is
+already that long, it is returned unchanged.
+
+```factor
+{ 2 5 0 } 6 0 pad-tail .   ! => { 2 5 0 0 0 0 }
+{ 4 1 } 5 9 pad-head .     ! => { 9 9 9 4 1 }
+```
+
+## The same words work on strings
+
+A string is a sequence of characters, so everything above works on
+strings too — the result is just another string instead of an array:
+
+```factor
+"hello" length .            ! => 5
+"hello" 3 head .             ! => "hel"
+"abc" 6 CHAR: . pad-tail .   ! => "abc..."
+```
+
 ## Aggregating
 
 `sum` (in [`math.statistics`][math.statistics]) adds the elements of
@@ -61,7 +87,7 @@ count ( seq quot -- n )
 ```
 
 ```factor
-{ 2 5 0 7 4 1 } [ 5 >= ] count .    ! => 2
+{ 2 5 0 7 4 1 } [ even? ] count .    ! => 3
 ```
 
 ## Predicates over the whole sequence
@@ -73,7 +99,7 @@ empty? ( seq -- ? )
 ```
 
 ```factor
-{ 2 5 0 7 } [ zero? ] any? .    ! => t
+{ 2 5 0 7 } [ 4 > ] any? .      ! => t
 { 2 5 0 7 } [ 0 > ] all? .      ! => f
 ```
 
@@ -89,8 +115,8 @@ suffix      ( seq elt -- newseq )
 ```
 
 ```factor
-{ 2 5 0 7 4 1 } unclip-last 1 + suffix .
-! => { 2 5 0 7 4 2 }
+{ 10 20 30 } unclip-last 2 * suffix .
+! => { 10 20 60 }
 ```
 
 [sequences]: https://docs.factorcode.org/content/vocab-sequences.html