Twelve statements: Difference between revisions

{{task|Puzzles}}

{{omit from|Brlcad}}

{{omit from|GUISS}}

Print out a table of near misses, that is, solutions that are contradicted by only a single statement.

<br><br>

 

=={{header|Ada}}==

are very handy for this task.

 

 

procedure Twelve_Statements is

Ada.Text_IO.Put_Line("Near Misses:");

Try(T => (1..12 => False), Fail => 1);

 

{{out}}

Here is the definition the package Logic:

 

Number_Of_Statements: Positive;

package Logic is

function Half(T: Table; Which: Even_Odd) return Table;

 

And here is the implementation of the "convenience functions" in Logic:

 

function Sum(T: Table) return Natural is

end Half;

 

 

=={{header|ALGOL W}}==

% we have 12 statements to determine the truth/falsehood of (see task) %

 

printSolutions( 1, "Near solutions (incorrect values marked ""*"")" );

 

{{out}}

<pre>Solutions

T - - - T - - T - T T T*

</pre>

 

=={{header|AutoHotkey}}==

The code shows all cases where we have at least S-1 matches (where S = 12 statements).

 

; "Given the following twelve statements...", so the first statement

; should ignore the F1 flag and always be true (see "( N == 1 )").

Return ( C == 4 )

}

{{out}}

<pre>11 -> 1 0 0 1 0 0 0 1 0 0 0 0

=={{header|BBC BASIC}}==

{{works with|BBC BASIC for Windows}}

DIM Pass%(nStatements%), T%(nStatements%)

NEXT try%

{{out}}

<pre>

 

=={{header|Bracmat}}==

( number

= n done ntest oldFT

)

)

{{out}}

<pre> Solution:

=={{header|C sharp}}==

{{works with|C sharp|6}}

using System.Collections.Generic;

using System.Linq;

}

 

{{out}}

<pre>

=={{header|C++}}==

{{works with|gcc 5.1.0 c++11}}

#include <vector>

#include <string>

}

}

{{out}}

<pre>

 

=={{header|Clojure}}==

 

(defn xor? [& args]

: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))]

 

{{out}}

 

=={{header|Common Lisp}}==

(defparameter *state* (make-list 12))

 

 

(defun result (?)

<pre>

Missed by one

 

=={{header|D}}==

 

immutable texts = [

}

}

{{out}}

<pre>Missed by statement: 8

Missed by statement: 12

T F F F T F F T F T T T</pre>

 

=={{header|Eiffel}}==

class

APPLICATION

 

end

{{out}}

<pre>

 

=={{header|Elena}}==

import extensions;

import extensions'text;

printSolution(bits)

= self.zipBy(bits,

 

toBit()

(bits => bits.Length == 12),

(bits => bits.zipBy(new Range(1, 12),

(bits => bits[4].iif(bits[5] && bits[6],true) ),

(bits => bits.zipBy(new Range(1, 12),

(bits => bits[1].xor(bits[2]) ),

(bits => bits[6].iif(bits[5] && bits[4],true) ),

(bits => bits[10] && bits[11] ),

(bits => (bits[6].toBit() + bits[7].toBit() + bits[8].toBit())==1 ),

};

 

console.writeLine();

{

var bits := BitArray32.load(n).top(12).toArray();

 

counts =>

};

console.readChar()

{{out}}

<pre>

 

=={{header|ERRE}}==

PROGRAM TWELVE_STMS

 

 

END FOR ! TRY%

{{out}}<pre>

Near miss with statements 1 4 true (failed 8 ).

=={{header|Forth}}==

Forth is excellently suited to solve this, because it has excellent support for manipulating bitpatterns.

dup if 1 swap begin dup 1 <> while swap 1+ swap 1 rshift repeat drop then

;

;

 

{{out}}

<pre>

ok

</pre>

 

=={{header|Go}}==

 

import "fmt"

solution <- tz

}

{{out}}

<pre>

=={{header|Groovy}}==

Solution:

r01( 1, { r()*.num == (1..12) }),

r02( 2, { r(7..12).count { it.truth } == 3 }),

}

 

 

{{out}}

Shows answers with 1 for true, followed by list of indices of contradicting elements in each set of 1/0s (index is 0-based).

 

 

tf :: [[Int] -> Bool] -> [[Int]]

mapM_ print $ t 0

putStrLn "Near misses"

{{out}}

<pre>

=={{header|J}}==

In the following 'apply' is the foreign conjunction:

128!:2

 

NB. example

'*:' apply 1 2 3

This enables us to apply strings (left argument) being verbs to the right argument, mostly a noun.

12&=@# NB. 1. This is a numbered list of twelve statements.

3=+/@:{.~&_6 NB. 2. Exactly 3 of the last 6 statements are true.

)

 

 

The output follows the Haskell convention: true/false bitstring followed by the index of a contradiction

 

'''All true'''

┌───────────────────────┬┐

│1 0 1 1 0 1 1 0 0 0 1 0││

Or, numerically:

 

'''Near misses'''

┌───────────────────────┬──┐

│0 0 0 0 1 0 0 1 0 0 1 0│0 │

├───────────────────────┼──┤

│1 1 0 1 0 0 1 1 1 0 0 0│7 │

 

'''Iterative for all true'''

<br>A repeat while true approach: x f^:(p)^:_ y

 

Here is an alternative representation of the statements which might be slightly easier to read. (The behavior is identical):

 

 

S=: <;._2 (0 :0)

1 (= +/) 7 8 9 true NB. 11. Exactly 1 of statements 7, 8 and 9 are true.

4 (= +/) }: NB. 12. Exactly 4 of the preceding statements are true.

 

And here is an approach which does not use the verb apply, but instead mostly relies on simple arithmetic.

 

0; 0; 0 0 0 0 0 0 0 0 0 0 0 0 NB. 1. This is a numbered list of twelve statements.

3; 0; 0 0 0 0 0 0 1 1 1 1 1 1 NB. 2. Exactly 3 of the last 6 statements are true.

propositions=: |:#:i.2^#sum

 

 

Now, as before, we can find the consistent set of true and false values:

 

1 0 1 1 0 1 1 0 0 0 1 0

1+I.#:I.0=+/errors NB. true propositions for the consistent case

 

And, we can find the set which is inconsistent for only one proposition:

 

'Statement ',"1 (":1+I.|: offby1 #"1 errors),"1 ' is inconsistent with exactly ',"1 ((1":@:+I.)"1 #:I.offby1),"1 ' being true'

Statement 1 is inconsistent with exactly 5 8 11 being true

Statement 12 is inconsistent with exactly 1 2 4 7 9 12 being true

Statement 10 is inconsistent with exactly 1 2 4 7 9 10 being true

 

=={{header|Java}}==

The following Java code uses brute force. It tries to translate the logical statements as naturally as possible. The run time is almost zero.

 

public class LogicPuzzle

{

}

}

{{out}}

<pre>

for a specific "select every nth item" filter, but also for a

generic "with_index" annotator.

. as $in

| reduce range(0;length) as $i ([]; if ($i | filter) then . + [$in[$i]] else . end);

# number of exact and off-by-one solutions:

 

{{out}}

$ jq -M -n -f Twelve_statements.jq

=={{header|Julia}}==

This task involves only 12 statements, so an exhaustive search of the 2^12 possible statement value combinations is quite feasible. The program shows "total misses" and the distribution of numbers of hits in addition to solutions and near misses.

 

function showflaggedbits{T<:BitArray{1}}(a::T, f::T)

println(@sprintf " %2d => %4d" i-1 mhist[i])

end

 

{{out}}

 

=={{header|Kotlin}}==

 

typealias Predicate = (String) -> Boolean

}

}

 

{{out}}

</pre>

 

Column@Cases[#, {s_, 1} :> s]] &[{#,

Count[Boole /@ {Length@# == 12, Total@#[[7 ;;]] == 3,

Total@#[[;; 6]] == 3, #[[11]] + #[[12]] == 2,

Total@#[[7 ;; 9]] == 1, Total@#[[;; 11]] == 4} - #,

{{Out}}

<pre>Answer:

{1,0,1,1,0,1,1,0,0,0,1,0}

 

Near misses:

{0,0,0,0,1,0,0,1,0,1,1,1}

{0,0,0,0,1,0,0,1,0,0,1,0}</pre>

 

=={{header|Pascal}}==

Inspired by the C++ implementation, this version makes extensive use of Pascal's built-in set handling capabilities.

 

 

{

writeln('Done. Press ENTER.');

readln

 

{{Out}}

 

=={{header|Perl}}==

 

my @condition = (

print "1 miss (",$no[0],"): true statements are ", join( " ", grep { $truth[$_] } 1..12), "\n" if 1 == @no;

}

{{out}}

<pre>1 miss (1): true statements are 5 8 11

 

=={{header|Phix}}==

{{out}}

<pre>

</pre>

 

=={{header|Prolog}}==

Works with '''SWI-Prolog''' and '''library(clpfd)'''.

% 1. This is a numbered list of twelve statements.

L = [A1, A2, A3, A4, A5, A6, A7, A8, A9, A10, A11, A12],

 

my_write(_N, 0).

{{out}}

<pre> ?- puzzle.

Python's boolean type <tt>bool</tt>is a subclass of <tt>int</tt>, so boolean values True, False can be used as integers (1, 0, respectively) in numerical contexts.

This fact is used in the lambda expressions that use function sum.

from itertools import product

#from pprint import pprint as pp

 

for stm in full + partial:

 

{{out}}

This question really begs to be done with <tt>amb</tt>

 

#lang racket

 

;; -> '(1 3 4 6 7 11)

 

 

=={{header|Raku}}==

(formerly Perl 6)

{{Works with|rakudo|2016.07}}

my @tests =

say "";

say "Near misses:";

 

{{out}}

=={{header|REXX}}==

===generalized logic===

q=12; @stmt=right('statement',20) /*number of statements in the puzzle. */

m=0 /*[↓] statement one is TRUE by fiat.*/

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

'''output'''

<pre>

 

===discrete logic===

q=12; @stmt=right('statement',20) /*number of statements in the puzzle. */

m=0 /*[↓] statement one is TRUE by fiat.*/

end /*tell*/

end /*e*/

'''output''' &nbsp; is the same as the 1^st version.

<br><br>

 

===optimized===

q=12; @stmt=right('statement',20) /*number of statements in the puzzle. */

m=0 /*[↓] statement one is TRUE by fiat.*/

end /*j*/

end /*e*/

'''output''' &nbsp; is the same as the 1^st version.

<br><br>

 

=={{header|Ruby}}==

->(st) { st.size == 12 },

->(st) { st.last(6).count(true) == 3 },

near_misses.each do |r|

puts "missed by statement #{r.consistency.index(false) + 1}", r.truths.to_s

 

{{out}}

===Imperative Programming (Ugly)===

{{trans|Java}}

val s = new Array[Boolean](13)

var count = 0

println(s"${p.count} Solutions found.")

 

{{Out}}See it in running in your browser by [https://scastie.scala-lang.org/XaRsz8gOQxavQ5rwMxi9ZA Scastie (JVM)] or

by [https://scalafiddle.io/sf/x73tnT6/1 ScalaFiddle (JavaScript)].

=={{header|Sidef}}==

{{trans|Perl}}

{ false },

{|a| a.len == 13 },

no.len == 0 && say "Solution: true statements are #{1..12->grep{t[_]}.join(' ')}"

no.len == 1 && say "1 miss (#{no[0]}): true statements are #{1..12->grep{t[_]}.join(' ')}"

{{out}}

<pre>

=={{header|Tcl}}==

{{works with|Tcl|8.6}} <!-- but not 8.6b3; the lmap command post-dates that release -->

 

# Function to evaluate the truth of a statement

foreach {state j} $differ {

puts "almost found\t[renderstate $state] \u21d2 [expr {[lindex $state $j-1]?"\u00ac":{}}]S($j)"

{{out}}

<pre>

=={{header|TXR}}==

 

^(progn (defvar ,size-name ,(length forms))

(defun ,name (,var)

 

(each ((r results))

 

{{out}}

close 1 2 4 7 9 10 (wrong 10)

close 1 2 4 7 8 9 (wrong 8)</pre>

 

=={{header|uBasic/4tH}}==

{{trans|BBC Basic}}

For T = 0 To (2^S)-1

 

Loop

 

Output:

<pre>Near miss with statements 1 4 true (failed 8).

Near miss with statements 5 8 10 11 12 true (failed 1).

Near miss with statements 1 5 8 10 11 12 true (failed 12).</pre>

 

=={{header|VBA}}==

Public t As Integer '-- scratch

Next

Next

<pre>Found solution:101101100010</pre>

 

=={{header|Yabasic}}==

{{trans|Phix}}

sub s2() local t, i : t=0 : for i=7 to 12 : t = t + (mid$(s$, i, 1) <> "0") : next : return t=3 end sub

sub s3() local t, i : t=0 : for i=2 to 12 step 2 : t = t + (mid$(s$, i, 1) <> "0") : next : return t=2 end sub

if b=12 print s$

next

 

=={{header|zkl}}==

fcn s0 { False } // dummy for padding

fcn s1 { True }

(12).pump(List,'wrap(n){ statements[n] and n or Void.Skip })

.concat(",").println(" : ",vm.pasteArgs());

{{out}}

<pre>