Twelve statements: Difference between revisions
Rename Perl 6 -> Raku, alphabetize, minor clean-up
Thundergnat (talk | contribs) (Rename Perl 6 -> Raku, alphabetize, minor clean-up) |
|||
Line 767:
(12.false)
That's it. I made 220 true/false guesses in all. (A brute force method needs 2^12=4096 guesses.</pre>
=={{header|C sharp}}==
Line 1,121 ⟶ 1,011:
1:T 2:F 3:F 4:F 5:T 6:F 7:F 8:T 9:F 10:T 11:T 12:T
</pre>
=={{header|Clojure}}==
<lang clojure>(use '[clojure.math.combinatorics]
(defn xor? [& args]
(odd? (count (filter identity args))))
(defn twelve-statements []
(for [[a b c d e f g h i j k l] (selections [true false] 12)
:when (true? a)
:when (if (= 3 (count (filter true? [g h i j k l]))) (true? b) (false? b))
:when (if (= 2 (count (filter true? [b d f h j l]))) (true? c) (false? c))
:when (if (or (false? e) (every? true? [e f g])) (true? d) (false? d))
:when (if (every? false? [b c d]) (true? e) (false? e))
:when (if (= 4 (count (filter true? [a c e g i k]))) (true? f) (false? f))
:when (if (xor? (true? b) (true? c)) (true? g) (false? g))
:when (if (or (false? g) (every? true? [e f g])) (true? h) (false? h))
:when (if (= 3 (count (filter true? [a b c d e f]))) (true? i) (false? i))
:when (if (every? true? [k l]) (true? j) (false? j))
:when (if (= 1 (count (filter true? [g h i]))) (true? k) (false? k))
:when (if (= 4 (count (filter true? [a b c d e f g h i j k]))) (true? l) (false? l))]
[a b c d e f g h i j k l]))</lang>
{{out}}
<pre>
=> (twelve-statements)
([true false true true false true true false false false true false])
</pre>
=={{header|Common Lisp}}==
<lang lisp>
(defparameter *state* (make-list 12))
(defparameter *statements* '(t ; 1
(= (count-true '(7 8 9 10 11 12)) 3) ; 2
(= (count-true '(2 4 6 8 10 12)) 2) ; 3
(or (not (p 5)) (and (p 6) (p 7))) ; 4
(and (not (p 2)) (not (p 3)) (not (p 4))) ; 5
(= (count-true '(1 3 5 7 9 11)) 4) ; 6
(or (and (p 2) (not (p 3))) (and (not (p 2)) (p 3))) ; 7
(or (not (p 7)) (and (p 5) (p 6))) ; 8
(= (count-true '(1 2 3 4 5 6)) 3) ; 9
(and (p 11) (p 12)) ;10
(= (count-true '(7 8 9)) 1) ;11
(= (count-true '(1 2 3 4 5 6 7 8 9 10 11)) 4))) ;12
(defun start ()
(loop while (not (equal *state* '(t t t t t t t t t t t t)))
do (progn (let ((true-stats (check)))
(cond ((= true-stats 11) (result nil))
((= true-stats 12) (result t))))
(new-state))))
(defun check ()
(loop for el in *state*
for stat in *statements*
counting (eq el (eval stat)) into true-stats
finally (return true-stats)))
(defun count-true (lst)
(loop for i in lst
counting (nth (- i 1) *state*) into total
finally (return total)))
(defun p (n)
(nth (- n 1) *state*))
(defun new-state ()
(let ((contr t))
(loop for i from 0 to 11
do (progn (setf (nth i *state*) (not (eq (nth i *state*) contr)))
(setq contr (and contr (not (nth i *state*))))))))
(defun result (?)
(format t "~:[Missed by one~;Solution:~] ~%~{~:[F~;T~] ~}~%" ? *state*))</lang>
<pre>
Missed by one
T F F T F F F F F F F F
Missed by one
T F F F T F F F F F F F
Missed by one
T F F F T F F T F F F F
Missed by one
T F T T F T T F T F F F
Missed by one
T F T T F F F T T F F F
Missed by one
T F F T F T F T T F F F
Missed by one
T T F T F F T T T F F F
Missed by one
T T F T F F T F T T F F
Solution:
T F T T F T T F F F T F
Missed by one
F F F F T F F T F F T F
Missed by one
T F F F T F F T F F T F
Missed by one
T F F F T T F F T F T F
Missed by one
T T F T F F T F T F F T
Missed by one
F F F T F F F T F T T T
Missed by one
T F F T F F F T F T T T
Missed by one
F F F F T F F T F T T T
Missed by one
T F F F T F F T F T T T
NIL</pre>
=={{header|D}}==
Line 1,394 ⟶ 1,395:
1 solution found.
</pre>
=={{header|Elena}}==
ELENA 5.0 :
Line 1,628 ⟶ 1,630:
ok
</pre>
=={{header|Go}}==
<lang go>package main
Line 1,853 ⟶ 1,856:
Near Miss: [5, 8, 10, 11, 12] (failed 1)
Near Miss: [5, 8, 11] (failed 1)</pre>
=={{header|Haskell}}==
Line 2,664 ⟶ 2,666:
1 miss (8): true statements are 1 2 4 7 8 9
</pre>
=={{header|Phix}}==
Line 2,974 ⟶ 2,917:
</lang>
=={{header|Raku}}==
(formerly Perl 6)
{{Works with|rakudo|2016.07}}
<lang perl6>sub infix:<→> ($protasis, $apodosis) { !$protasis or $apodosis }
my @tests =
{ .end == 12 and all(.[1..12]) === any(True, False) },
{ 3 == [+] .[7..12] },
{ 2 == [+] .[2,4...12] },
{ .[5] → all .[6,7] },
{ none .[2,3,4] },
{ 4 == [+] .[1,3...11] },
{ one .[2,3] },
{ .[7] → all .[5,6] },
{ 3 == [+] .[1..6] },
{ all .[11,12] },
{ one .[7,8,9] },
{ 4 == [+] .[1..11] },
;
my @solutions;
my @misses;
for [X] (True, False) xx 12 {
my @assert = Nil, |$_;
my @result = Nil, |@tests.map({ ?.(@assert) });
my @true = @assert.grep(?*, :k);
my @cons = (@assert Z=== @result).grep(!*, :k);
given @cons {
when 0 { push @solutions, "<{@true}> is consistent."; }
when 1 { push @misses, "<{@true}> implies { "¬" if !@result[~$_] }$_." }
}
}
.say for @solutions;
say "";
say "Near misses:";
.say for @misses;</lang>
{{out}}
<pre><1 3 4 6 7 11> is consistent.
Near misses:
<1 2 4 7 8 9> implies ¬8.
<1 2 4 7 9 10> implies ¬10.
<1 2 4 7 9 12> implies ¬12.
<1 3 4 6 7 9> implies ¬9.
<1 3 4 8 9> implies 7.
<1 4 6 8 9> implies ¬6.
<1 4 8 10 11 12> implies ¬12.
<1 4> implies 8.
<1 5 6 9 11> implies 8.
<1 5 8 10 11 12> implies ¬12.
<1 5 8 11> implies 12.
<1 5 8> implies 11.
<1 5> implies 8.
<4 8 10 11 12> implies 1.
<5 8 10 11 12> implies 1.
<5 8 11> implies 1.</pre>
=={{header|REXX}}==
| |||