Data commit

Task/Twelve-statements/Racket/twelve-statements.rkt

@@ -0,0 +1,66 @@
+#lang racket
+
+;; A quick `amb' implementation
+(define failures null)
+(define (fail)
+  (if (pair? failures) ((first failures)) (error "no more choices!")))
+(define (amb/thunks choices)
+  (let/cc k (set! failures (cons k failures)))
+  (if (pair? choices)
+    (let ([choice (first choices)]) (set! choices (rest choices)) (choice))
+    (begin (set! failures (rest failures)) (fail))))
+(define-syntax-rule (amb E ...) (amb/thunks (list (lambda () E) ...)))
+(define (assert condition) (unless condition (fail)))
+
+;; just to make things more fun
+(define (⇔ x y) (assert (eq? x y)))
+(require (only-in racket [and ∧] [or ∨] [implies ⇒] [xor ⊻] [not ¬]))
+(define (count xs)
+  (let loop ([n 0] [xs xs])
+    (if (null? xs) n (loop (if (car xs) (add1 n) n) (cdr xs)))))
+;; even more fun, make []s infix
+(require (only-in racket [#%app r:app]))
+(define-syntax (#%app stx)
+  (if (not (eq? #\[ (syntax-property stx 'paren-shape)))
+    (syntax-case stx () [(_ x ...) #'(r:app x ...)])
+    (syntax-case stx ()
+      ;; extreme hack on next two cases, so it works for macros too.
+      [(_ x op y) (syntax-property #'(op x y) 'paren-shape #f)]
+      [(_ x op y op1 z) (free-identifier=? #'op #'op1)
+       (syntax-property #'(op x y z) 'paren-shape #f)])))
+;; might as well do more
+(define-syntax-rule (define-booleans all x ...)
+  (begin (define x (amb #t #f)) ...
+         (define all (list x ...))))
+
+(define (puzzle)
+  (define-booleans all q1 q2 q3 q4 q5 q6 q7 q8 q9 q10 q11 q12)
+  ;; 1.  This is a numbered list of twelve statements.
+  [q1 ⇔ [12 = (length all)]]
+  ;; 2.  Exactly 3 of the last 6 statements are true.
+  [q2 ⇔ [3 = (count (take-right all 6))]]
+  ;; 3.  Exactly 2 of the even-numbered statements are true.
+  [q3 ⇔ [2 = (count (list q2 q4 q6 q8 q10 q12))]]
+  ;; 4.  If statement 5 is true, then statements 6 and 7 are both true.
+  [q4 ⇔ [q5 ⇒ [q6 ∧ q7]]]
+  ;; 5.  The 3 preceding statements are all false.
+  [q5 ⇔ (¬ [q2 ∨ q3 ∨ q4])]
+  ;; 6.  Exactly 4 of the odd-numbered statements are true.
+  [q6 ⇔ [4 = (count (list q1 q3 q5 q7 q9 q11))]]
+  ;; 7.  Either statement 2 or 3 is true, but not both.
+  [q7 ⇔ [q2 ⊻ q3]]
+  ;; 8.  If statement 7 is true, then 5 and 6 are both true.
+  [q8 ⇔ [q7 ⇒ (and q5 q6)]]
+  ;; 9.  Exactly 3 of the first 6 statements are true.
+  [q9 ⇔ [3 = (count (take all 3))]]
+  ;; 10. The next two statements are both true.
+  [q10 ⇔ [q11 ∧ q12]]
+  ;; 11. Exactly 1 of statements 7, 8 and 9 are true.
+  [q11 ⇔ [1 = (count (list q7 q8 q9))]]
+  ;; 12. Exactly 4 of the preceding statements are true.
+  [q12 ⇔ [4 = (count (drop-right all 1))]]
+  ;; done
+  (for/list ([i (in-naturals 1)] [q all] #:when q) i))
+
+(puzzle)
+;; -> '(1 3 4 6 7 11)