Agfdhyk

Original Question

I want to use F# to find the proximity of consonants to vowels in a collection of words. So for example in the word "top" T is (-1: 1) from a vowel and P is (1: 1) from the vowel.

The first number in the pair is the position and the second number is the number of times it's in that position, relative to the nearest vowel.

In "consonants", C is (-1:1), N is (1: 3) , (-2: 1), (-1, 1), S is (2: 1), (-1:1),(3: 1) and T is (2: 1).

I suspect that I have to use a combination of groupBy, findIndex and countBy.

type ConsonantPos = { Name: string

                      BeforeVowel: int

                      AfterVowel: int }



let isVowel (x:string) =

    List.contains x ["a";"e"; "i"; "o"; "u"]



let consonantPosVsVowel x lst = 

      let rec getConsonanatPos x beforeVowel afterVowel currentPos lst = 

          match lst with

            |  -> {Name = x; BeforeVowel = beforeVowel; AfterVowel = afterVowel}

            | h::t -> 

              if isVowel h then

                {Name = x; BeforeVowel = beforeVowel; AfterVowel = afterVowel}

              else 

                getConsonanatPos  x (beforeVowel - 1) (afterVowel + 1) (currentPos + 1) t



      getConsonanatPos x 0 0 0 lst





["b"; "a"; "c"] |> consonantPosVsVowel "b"

// val it : ConsonantPos = {Name = "b"; BeforeVowel = -1; AfterVowel = 1;}

["b"; "c"; "d"; "e"; "f"; "g"] |> consonantPosVsVowel "b"

// val it : ConsonantPos = {Name = "b"; BeforeVowel = -3; AfterVowel = 3;}

Revised Solution

As of 21/11/2018 both suggestions worked and worked well for the problem as I orginally specified.

Of course this question was just a part of the program that I was writing. As I have extended the program and explored the data, BEEP, one response proved easier to reuse: that is the one I have marked as the answer.

My problem, as it turned out, was my lack of understanding of and my inability to use collections.

Here's a slightly different approach, which breaks down the task differently.

• Map the element to itself with its tail (negative distance, forward) and heads
  (positive, backward). This is done with a recursive function and two
  accumulators


• Filter the resulting list for elements not being vowels


• Map it to pairs of options representing negative and positive distances, with
  another recursive function, and collect these pairs into a flat list
  again while transposing their values


• Group this list by the elements, and map the result to a tuple of distance and number of occurance

let genTail2 xss =

    let rec aux accl accr = function

    |  -> List.rev accr

    | x::xs -> aux (x::accl) ((x, (xs, accl))::accr) xs

    aux   xss

// val genTail2 : xss:'a list -> ('a * ('a list * 'a list)) list



let dist2 pred (x, (ls, rs)) =

    let rec aux n i = function

    |  -> None

    | y::ys -> if pred y then Some(x, n) else aux (n + i) i ys

    aux -1 -1 ls, aux 1 1 rs

// val dist2 :

//   pred:('a -> bool) ->

//     x:'b * ('a list * 'a list) -> ('b * int) option * ('b * int) option



let tuple2List = function

| None, None -> 

| Some x, None | None, Some x -> [x]

| Some x, Some y -> [y; x]

// val tuple2List : 'a option * 'a option -> 'a list



let isVowel = ResizeArray['a';'e';'i';'o';'u'].Contains

// val isVowel : (char -> bool)    



"consonants"

|> fun s -> s.ToLower()

|> Seq.toList

|> genTail2

|> List.filter (fst >> isVowel >> not)

|> List.collect (dist2 isVowel >> tuple2List)

|> Seq.groupBy fst

|> Seq.map (fun (x, xs) -> x, Seq.countBy snd xs)

|> Seq.iter (printfn "%A")

Try this:

let isVowel (x:char) =

    List.contains x ['a';'e'; 'i'; 'o'; 'u']



let countConsonants (word:string) =

    let vowelsp, consonants =

        word

        |> Seq.mapi(fun i c-> c,i )

        |> Seq.toArray

        |> Array.partition (fst >> isVowel)

    let vowels = vowelsp |> Array.map snd

    consonants

    |> Seq.collect (fun (c,i) -> 

        match vowels |> Array.tryFindIndex ((<) i) with

        | None   -> [ vowels.Length - 1 ]

        | Some j -> [ j - 1     ; j     ]

        |> Seq.choose (fun j -> 

            if j < 0 then None else

            Some(c, i - vowels.[j])

        )

    )

    |> Seq.countBy id

    |> Seq.map (fun ((l,p), c) -> (l,(p, c)) )

    |> Seq.groupBy fst

    |> Seq.map (fun (l, s) -> l, s |> Seq.map snd |> Seq.toArray)

    |> Seq.toArray



"consonants"

|> countConsonants

|> Seq.iter (printfn "%A")