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:

(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}}==

{{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>

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|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>

1 solution found.

</pre>

=={{header|Elena}}==

extension op

{

}

counts =>

{{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}}

Near Miss: [5, 8, 10, 11, 12] (failed 1)

Near Miss: [5, 8, 11] (failed 1)</pre>

 

=={{header|Haskell}}==

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

 

 

 

{{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)

tf = map(x->x ? "T" : "F", a)

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

</pre>

 

 

 

 

 

 

 

 

 

{{out}}

 

=={{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|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>

</pre>

 

 

<pre>

 

 

 

internal enum PaddingOption {

case Right

}

extension Array {

func pad(element: Element, times: Int, toThe: PaddingOption) -> Array<Element> {

switch(toThe) {

case .Left:

}

}

func take(n: Int) -> Array<Element> {

if n <= 0 {

return []

return Array(self[0..<Swift.min(n, self.count)])

}

func drop(n: Int) -> Array<Element> {

if n <= 0 {

return []

}

return Array(self[n..<self.count])

}

func stride(n: Int) -> Array<Element> {

var result:[Element] = []

return result

}

func zipWithIndex() -> Array<(Element, Int)> {

}

}

extension Int {

func binaryRepresentationOfLength(length: Int) -> [Int] {

value /= 2

}

}

}

let problem = [

"1. This is a numbered list of twelve statements.",

"11. Exactly 1 of statements 7, 8 and 9 are true.",

"12. Exactly 4 of the preceding statements are true."]

{ s in s.count == 12 },

{ s in s[4] ? (s[5] && s[6]) : true },

{ s in [s[1], s[2]].filter({ $0 }).count == 1 },

{ s in s[6] ? (s[4] && s[5]) : true },

{ s in [s[10], s[11]].filter({ $0 }).count == 2 },

{ s in [s[6], s[7], s[8]].filter({ $0 }).count == 1 },

]

for variant in 0..<(1<<statements.count) {

if statements.map({ $0(attempt) }) == attempt {

let trueAre = attempt.zipWithIndex().filter { $0.0 }.map { $0.1 + 1 }

}

</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|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>