open System

    open System.Collections.Generic

​

    type CrossLetter = { Position : (int * int) option; Letter : char option; Words : Word list }

    and Word = 

        {   

            Text : string option; 

            Length: int; 

            CrossLetters: CrossLetter []; 

            Direction : Direction option; 

            WordPositions : (int * int) [] }

    and Direction = | Right | Down   

    ///Check if all elements are consecutive

    let consecArray (arr: int []) =

        let arr' = arr |> Array.sort

        let s = arr |> Array.head

        arr'

        |> Array.fold(

            fun (test, last) elem -> 

                if elem - last = 1 then (true, elem) else (false, elem)) (true, s)

        |> fst

    ///Reads the grid input with '-' for empty slot

    let readInput () = 

        let grid =

            Array.init 10 (

                fun i -> 

                    let str = Console.ReadLine()

                    str.ToCharArray()

                    |> Array.mapi(fun j c -> (i, j), c)

                    |> Array.filter(fun (_ , c) -> c = '-')

                    |> Array.map fst )

            |> Array.collect id

        //Word are consecutive coords

        grid

​

​

    let filterCoord = 

        function

            | Right -> snd

            | Down -> fst

    let filterGroup = 

        function

            | Right -> fst

            | Down -> snd

​

    let filterWords direction grid =

        grid

        |> Array.groupBy (filterGroup direction)

        //Keep groups with more than one element

        |> Array.filter(fun (key, grp) -> grp.Length > 1)

        //Keep groups with consecutive elements

        |> Array.filter(fun (key, grp) -> 

                            grp

                            |> Array.map (filterCoord direction)

                            |> consecArray)

    let buildWord direction (row, grp) =

        {

            Text = None;

            Length = grp |> Array.length;

            CrossLetters = [||];

            Direction = direction |> Some;

            WordPositions = grp

        }

​

    ///Scan grid Rows and build Words:

    let rowsToWord grid = 

        filterWords Right grid

        |> Array.map (buildWord Right)

    ///Scan grid Cols and build Words:    

    let colsToWord grid = 

        filterWords Down grid

        |> Array.map (buildWord Down)

    ///Concat Rows words & Cols words

    let allWords grid = Array.concat [ rowsToWord grid; colsToWord grid ]

​

    ///Add Cross Letters based on Positions

    let addCrossLetters (words: Word list) (w: Word)=

        let letters = 

            [| for p in w.WordPositions do 

                    //Look if one position exist in another word of the list

                    let l = 

                        words 

                        |> List.filter 

                            (fun word -> word <> w && word.WordPositions |> Array.contains p) 

                    //Return Cross Letter:

                    if l.Length  > 0 then 

                        yield { Position = Some p ; Letter = None ; Words = l}

            |]

        //Add letters to word

        { w with CrossLetters = letters }

​

​

    ///Builds dictionnary of letters and words containing the letter

    let letterDict (words:Word list) =

       ['A'..'Z'] 

       |> List.map 

            (fun char -> 

                char, 

                    words 

                    |> List.filter

                        (fun word -> 

                            match word.Text with

                                | Some t -> t.Contains (string char)

                                | None -> false))

       |> dict    

​

    let strToWord (words : string list) =

        [

            for word in words do

               yield {

                        Text = word |> Some; 

                        Length = word.Length; 

                        CrossLetters = [||] ; 

                        Direction = None; 

                        WordPositions = [||]

                }

        ]

​

    ///Add Cross Letters based on letters

    let addCrossLetters (w: Word) (dict:Map<char, Word list>) =

        let txt = Option.get(w.Text)

        let letters = 

            [| for c in txt.ToCharArray() do 

                    //Look if one position exist in another word of the list

                    let l = dict.TryFind(c)

                    if l.IsSome then

                        yield { Position = None ; Letter = Some c ; Words = Option.get l }

            |]

        //Add letters to word

        { w with CrossLetters = letters }

​

​

​

    let cross (dict:IDictionary<char, string list>) (str:string) = 

        let cs = 

            str.ToCharArray()

            |> Array.mapi 

                ( fun i c -> 

                {   Position = i; 

                    Letter = Some c; 

                    Words = List.filter(fun word -> word <> str) dict.[c] 

                } )

        { Text = str ; Length = str.Length ; Letters = cs}

​

    let crossLetters word = 

        word.Letters |> Array.filter (fun le -> le.Words <> [])

​