hide solutions

Author: votroto

.vitepress/components/SolutionHider.vue

@@ -0,0 +1,34 @@
+<script setup>
+    import { onMounted } from 'vue'
+    import { useRoute } from 'vitepress'
+
+    const FIRST_LAB = new Date('2025-02-18T11:00:00+01:00').getTime();
+
+    const route = useRoute()
+
+    onMounted(() => { handlePageChange() })
+
+    function hide_details(reveal_date) {
+        const detailsElements = document.querySelectorAll('details[hideme]');
+        for (const details of detailsElements) {
+            const summary = details.querySelector('summary');
+            const summaryContent = summary ? summary.outerHTML : '';
+            details.innerHTML = `${summaryContent} Solutions will be revealed at ${reveal_date}.`;
+        }
+    }
+    function handlePageChange() {
+        const now = new Date(Date.now()).getTime();
+        const page_week_no = parseInt(route.path.match(/\d+/)[0]) - 1;
+        const millis_in_day = 24 * 60 * 60 * 1000;
+        const reveal_at = FIRST_LAB + (3 + 7 * page_week_no) * millis_in_day;
+        const days_left = Math.floor((reveal_at - now) / millis_in_day);
+        const should_reveal = days_left <= 0;
+
+        if (!should_reveal) {
+            hide_details(new Date(reveal_at).toLocaleDateString());
+        }
+    }
+</script>
+
+<template>
+</template>

.vitepress/config.mts

@@ -6,6 +6,13 @@ import { withMermaid } from 'vitepress-plugin-mermaid'
 export default withMermaid(
   // https://vitepress.dev/reference/site-config
   defineConfig({
+    vue: {
+      template: {
+        compilerOptions: {
+          isCustomElement: (tag) => tag.startsWith('mjx-')
+        }
+      }
+    },
     title: "Functional Programming",
     description: "Course materials for the functional programming course at the Czech Technical University.",
     base: "/FUP/",

.vitepress/theme/index.js

@@ -1,4 +1,10 @@
 import DefaultTheme from 'vitepress/theme-without-fonts'
+import SolutionHider from '../components/SolutionHider.vue'
 import './custom.css'
 
-export default DefaultTheme
+export default {
+    ...DefaultTheme,
+    enhanceApp({ app }) {
+        app.component('SolutionHider', SolutionHider)
+      }
+}

labs/lab01.md

@@ -1,6 +1,7 @@
 ---
 outline: deep
 ---
+<SolutionHider/>
 
 # Lab 1: Introduction to Racket
 
@@ -110,7 +111,7 @@ Write a function `num-of-digits` that takes an integer `n` and computes the numb
 The number of digits can be computed by successively dividing the input number by 10. For integer division, you can use the function `quotient`.
 :::
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (num-of-digits n [acc 1])
   (define q (quotient n 10))
@@ -130,7 +131,7 @@ You can obtain the representation by consecutively dividing `n` by the `radix` a
 :::
 
 
-::: details Solution
+::: details Solution { hideme }
 ::: code-group
 ```racket [direct]
 (define (num->str n [radix 10])

labs/lab02.md

@@ -1,5 +1,6 @@
-# Lab 02: Lists & Trees
+<SolutionHider/>
 
+# Lab 02: Lists & Trees
 
 The main purpose of this lab is to practice elementary recursive manipulation with lists. Lists can be
 decomposed by functions `car` and `cdr`. On the other hand, lists can be built by functions
@@ -140,7 +141,7 @@ your implementation function can return precise rational numbers like `(average-
 1/2`. If you want to have the usual floating-point representation, use the function
 `exact->inexact`, transforming the result into the imprecise floating-point representation.
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (average-list lst)
   (define (iter l acc)
@@ -174,7 +175,7 @@ numbers and returns a list of averages of these `n`-tuples. E.g. `(n-block-avera
 built segment of consecutive elements. The second tracks how many elements we must read from the
 list to complete the `n`-tuple of consecutive elements.
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (split-list n lst)
   (define (iter l k segment)

labs/lab03.md

@@ -1,3 +1,5 @@
+<SolutionHider/>
+
 # Lab 3: Higher-order functions
 
 ## Exercise 1
@@ -144,7 +146,7 @@ multiplied by respective coefficients. Then it suffices to sum them component by
 :::
 
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (scalar-mult coef vec)
   (map (curry * coef) vec))
@@ -186,7 +188,7 @@ To define the matrix power, use the `foldl` function applied to a list composed
 ```
 
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (matrix-mult m1 m2)
   (map (linear-combination m2) m1))

labs/lab04.md

@@ -1,6 +1,7 @@
 ---
 outline: deep
 ---
+<SolutionHider/>
 
 # Lab 4: Higher-order functions and tree recursion
 
@@ -172,7 +173,7 @@ taking a list `lst` and returning a list of all its sublists/subsequences. E.g.
 Code it as a recursive function using the following facts. 1) There is only a single subsequence of the empty list, namely the empty list. 2) Subsequences of $(x_1,x_2,\ldots,x_n)$ are just subsequences of $(x_2,\ldots,x_n)$ together with subsequences starting with $x_1$ and following by a subsequence of $(x_2,\ldots,x_n)$.
 :::
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (sub-seq lst)
   (if (null? lst)
@@ -225,7 +226,7 @@ path labelled by the winner and collects the beaten teams along the path to an a
 use nested patterns in pattern matching to find out the losers.
 :::
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (beaten-teams tree [acc '()])
   (match tree

labs/lab05.md

@@ -1,6 +1,7 @@
 ---
 outline: deep
 ---
+<SolutionHider/>
 
 # Lab 5: Streams and graphs
 
@@ -166,7 +167,7 @@ elements:
 (apply + (stream->list (stream-take (exp-stream 1) 100)))
 ```
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 (define (stream-mul s1 s2)
   (stream-cons (* (stream-first s1) (stream-first s2))
@@ -246,7 +247,7 @@ first.
                 (lambda (x y) (< (length x) (length y)))))))
 ```
 
-::: details Solution
+::: details Solution { hideme }
 ```racket
 ; minimum vertex cover
 ; -> smallest subset of nodes such that each edge has one of its nodes in it

labs/lab06.md

@@ -1,3 +1,5 @@
+<SolutionHider/>
+
 # Lab 6: Interpreter of Brainf*ck
 
 This lab is closely related to the corresponding lecture. In that lecture, I showed how to implement

labs/lab07.md

@@ -1,5 +1,6 @@
-# Lab 7: Lambda calculus
+<SolutionHider/>
 
+# Lab 7: Lambda calculus
 
 This lab focuses on lambda calculus. First, we focus on the syntax of $\lambda$-expressions. Second,
 we focus on its semantics, i.e., the computation specified by $\lambda$-expressions whose one step

labs/lab08.md

@@ -1,3 +1,5 @@
+<SolutionHider/>
+
 # Lab 8: Haskell basics
 
 The aim of the lab is to practice function definitions using pattern matching and guarded equations together with the list comprehension.
@@ -103,7 +105,7 @@ a string consisting of `n` copies of `str`. E.g.
 copy 3 "abc" => "abcabcabc"
 ```
 
-::: details Solution
+::: details Solution { hideme }
 ```haskell
 copy :: Int -> String -> String
 copy n str | n <= 0 = ""
@@ -146,7 +148,7 @@ Since the numbers are processed from right to left, reverse first the list by th
 to be luhnDoubled and the rest.
 :::
 
-::: details Solution
+::: details Solution { hideme }
 ```haskell
 luhnDouble :: Int -> Int
 luhnDouble n | n > 4 = 2*n - 9

labs/lab09.md

@@ -1,10 +1,11 @@
-# Lab 9: Haskell types
+<SolutionHider/>
 
+# Lab 9: Haskell types
 
 ## Exercise 1
 Define a type representing binary trees storing data in leaves of a general type `a`. Each
 non-leaf node has always two children. Make your type an instance of the class `Show` so it can be
-displayed in an XML-like format. A leaf node containing a datum `x` 
+displayed in an XML-like format. A leaf node containing a datum `x`
 should be displayed as `<Leaf
 x/>` and an inner
 node `<Node>...children nodes...</Node>`. E.g., the following tree
@@ -40,7 +41,7 @@ data Tree a = Leaf a | Node (Tree a) (Tree a)
 
 To make `Tree a` an instance of the `Show` class.  We have to constrain type `a` to be an instance
 of `Show`; otherwise, it would not be clear how to display the data stored in the tree. The
-definition of the function `show` is then straightforward. 
+definition of the function `show` is then straightforward.
 ::: details Solution
 ```haskell
 instance (Show a) => Show (Tree a) where
@@ -85,11 +86,11 @@ For the tree from the previous exercise, we have
 ```
 
 ## Exercise 3
-Consider again the `Tree a` data type from Exercise 1. Write a function 
+Consider again the `Tree a` data type from Exercise 1. Write a function
 ```haskell
 labelTree :: Tree a -> Tree (a, Int)
 ```
-labeling the leaves of a tree by consecutive natural numbers in the infix order. So it should replace a leaf datum `x` 
+labeling the leaves of a tree by consecutive natural numbers in the infix order. So it should replace a leaf datum `x`
 with the pair `(x,n)` for some natural number. So we would like to obtain something like that:
 ```
      *                  *
@@ -102,13 +103,13 @@ with the pair `(x,n)` for some natural number. So we would like to obtain someth
 ```
 
 ::: tip
-The idea behind this function will be helpful to your homework assignment. So try to understand it well. 
+The idea behind this function will be helpful to your homework assignment. So try to understand it well.
 :::
 
 To traverse through the nodes (particularly leaves) can be easily done recursively. The problem is with the counter for labels.
 In an imperative programming language, we could introduce a variable `counter` and initialize it by 0. Once we encounter a leaf, we label
 it with `counter` and modify
-`counter = counter + 1`. Unfortunately, we cannot do that in a purely functional language like Haskell. 
+`counter = counter + 1`. Unfortunately, we cannot do that in a purely functional language like Haskell.
 
 We need an accumulator in the signature of the labeling function holding the counter value. So we could think of a helper function
 ```haskell
@@ -144,7 +145,7 @@ labelTree t = fst (labelHlp t 0)
 ## Task 1
 Define a recursive data type `Polynomial a` representing univariate polynomials with an
 indeterminate $x$ whose coefficients are of a general type `a`. The definition will have two data
-constructors. First, `Null` 
+constructors. First, `Null`
 represents the zero polynomial. Second, `Pol` whose parameters are a
 monomial and recursively the rest of the polynomial. Monomials should be represented as pairs of
 type `(a, Int)` where the first component is the coefficient and the second is the exponent. E.g.
@@ -180,14 +181,14 @@ has no `x^0`.  Then define the instance of `Show` for `Polynomial a`.  You need
 `show` function in the same way as `format`.
 :::
 
-::: details Solution
+::: details Solution { hideme }
 ```haskell
 type Monomial a = (a, Int)
 data Polynomial a = Null | Pol (Monomial a) (Polynomial a)
 
 format :: (Show a, Num a, Ord a) => Monomial a -> String
 format (c, e) | e == 0 = display c
-              | otherwise = display c ++ "x*^" ++ show e 
+              | otherwise = display c ++ "x*^" ++ show e
     where display k | k >= 0 = show k
                     | otherwise = "(" ++ show k ++ ")"
 
@@ -199,18 +200,18 @@ instance (Show a, Num a, Ord a) => Show (Polynomial a) where
 :::
 
 ## Task 2
-Write a function 
+Write a function
 ```haskell
-getDegree :: Polynomial a -> Int 
+getDegree :: Polynomial a -> Int
 ```
 returning the degree of a given polynomial. The zero polynomial has a degree $-1$ by definition. Otherwise, you have to find the highest exponent occurring in the polynomial.
 
-::: details Solution
+::: details Solution { hideme }
 ```haskell
 getDegree :: Polynomial a -> Int
 getDegree p = iter p (-1) where
     iter Null n = n
     iter (Pol (_, e) ms) n | e > n = iter ms e
-                           | otherwise = iter ms n 
+                           | otherwise = iter ms n
 ```
 :::