Two Logicians

Solves the "Two Logicians" puzzle.

 1: 
 2: 
 3: 
 4: 
 5: 
 6: 
 7: 
 8: 
 9: 
10: 
11: 
12: 
13: 
14: 
15: 
16: 
17: 
18:

// Two perfect logicians, S and P, are told that integers x and y have been chosen
// such that 1 < x < y and x+y < 100. S is given the value x+y and P is given the
// value xy. They then have the following conversation.
//
//     P:  I cannot determine the two numbers.
//     S:  I knew that.
//     P:  Now I can determine them.
//     S:  So can I.
//
// Given that the above statements are true, what are the two numbers?

let inOp op f = Seq.groupBy ((<||) op) >> Seq.map snd >> Seq.filter f >> Seq.concat
let singleCase op = inOp op (Seq.length >> (=) 1)

let all = [for x = 2 to 49 do for y = x + 1 to 99 - x do yield x, y]
let spoilP = all |> singleCase (*) |> Set.ofSeq
all |> inOp (+) (Set.ofSeq >> Set.intersect spoilP >> Set.isEmpty)
|> singleCase (*) |> singleCase (+) |> Seq.exactlyOne

val inOp : op:('a -> 'b -> 'c) -> f:(seq<'a * 'b> -> bool) -> (seq<'a * 'b> -> seq<'a * 'b>) (requires equality)

Full name: Script.inOp

val op : ('a -> 'b -> 'c) (requires equality)

val f : (seq<'a * 'b> -> bool)

module Seq

from Microsoft.FSharp.Collections

val groupBy : projection:('T -> 'Key) -> source:seq<'T> -> seq<'Key * seq<'T>> (requires equality)

Full name: Microsoft.FSharp.Collections.Seq.groupBy

val map : mapping:('T -> 'U) -> source:seq<'T> -> seq<'U>

Full name: Microsoft.FSharp.Collections.Seq.map

val snd : tuple:('T1 * 'T2) -> 'T2

Full name: Microsoft.FSharp.Core.Operators.snd

val filter : predicate:('T -> bool) -> source:seq<'T> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.filter

val concat : sources:seq<#seq<'T>> -> seq<'T>

Full name: Microsoft.FSharp.Collections.Seq.concat

val singleCase : op:('a -> 'b -> 'c) -> (seq<'a * 'b> -> seq<'a * 'b>) (requires equality)

Full name: Script.singleCase

val length : source:seq<'T> -> int

Full name: Microsoft.FSharp.Collections.Seq.length

val all : (int * int) list

Full name: Script.all

val x : int

val y : int

val spoilP : Set<int * int>

Full name: Script.spoilP

Multiple items
module Set

from Microsoft.FSharp.Collections

--------------------
type Set<'T (requires comparison)> =
  interface IComparable
  interface IEnumerable
  interface IEnumerable<'T>
  interface ICollection<'T>
  new : elements:seq<'T> -> Set<'T>
  member Add : value:'T -> Set<'T>
  member Contains : value:'T -> bool
  override Equals : obj -> bool
  member IsProperSubsetOf : otherSet:Set<'T> -> bool
  member IsProperSupersetOf : otherSet:Set<'T> -> bool
  ...

Full name: Microsoft.FSharp.Collections.Set<_>

--------------------
new : elements:seq<'T> -> Set<'T>

val ofSeq : elements:seq<'T> -> Set<'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Set.ofSeq

val intersect : set1:Set<'T> -> set2:Set<'T> -> Set<'T> (requires comparison)

Full name: Microsoft.FSharp.Collections.Set.intersect

val isEmpty : set:Set<'T> -> bool (requires comparison)

Full name: Microsoft.FSharp.Collections.Set.isEmpty

val exactlyOne : source:seq<'T> -> 'T

Full name: Microsoft.FSharp.Collections.Seq.exactlyOne

Previous Version Next Version Raw view Test code New version

More information

Link:	http://fssnip.net/on
Posted:	10 years ago
Author:	Vandroiy
Tags:	puzzles