8

要素の属性によって分割する必要がseq<a>あります。seq<seq<a>>この属性が特定の値と等しい場合、その時点で「分割」する必要があります。FSharpでそれを行うにはどうすればよいですか?

そのアイテムで分割する必要があるかどうかにかかわらず、bool を返す「関数」を渡すとよいでしょう。

サンプル: 入力シーケンス: seq: {1,2,3,4,1,5,6,7,1,9} 1 に等しい場合、すべての項目で分割する必要があるため、結果は次のようになります。

seq
{
seq{1,2,3,4}
seq{1,5,6,7}
seq{1,9}
}
4

5 に答える 5

12

実際に行っているのは、グループ化 (値に遭遇するたびに新しいグループを作成する) だけです。

let splitBy f input =
  let i = ref 0
  input 
  |> Seq.map  (fun x -> 
    if f x then incr i
    !i, x)
  |> Seq.groupBy fst
  |> Seq.map (fun (_, b) -> Seq.map snd b)

例

let items = seq [1;2;3;4;1;5;6;7;1;9]
items |> splitBy ((=) 1)

繰り返しますが、スティーブンの素晴らしい改善により、短くなります。

let splitBy f input =
  let i = ref 0
  input
  |> Seq.groupBy (fun x ->
    if f x then incr i
    !i)
  |> Seq.map snd
于 2011-07-18T18:37:44.560 に答える
4

残念ながら、シーケンス（型）で機能する関数を書くseq<'T>のは少し難しいです。これらは、リストのパターンマッチングなどの機能概念ではうまく機能しません。代わりに、GetEnumeratorメソッドと結果のIEnumerator<'T>タイプを使用する必要があります。これにより、コードが非常に重要になることがよくあります。この場合、私は次のように書きます：

let splitUsing special (input:seq<_>) = seq { 
  use en = input.GetEnumerator()
  let finished = ref false
  let start = ref true
  let rec taking () = seq {
    if not (en.MoveNext()) then finished := true
    elif en.Current = special then start := true
    else 
      yield en.Current
      yield! taking() }

  yield taking()
  while not (!finished) do
    yield Seq.concat [ Seq.singleton special; taking()] }

これは非常に非効率的であるため、機能スタイルの使用はお勧めしません（たとえば、andを使用Seq.skipしますSeq.head）。これにより、他のシーケンスから値を取得して返すシーケンスのチェーンが作成されます（したがって、通常はO（N ^ 2）の複雑さがあります） 。

または、を操作するための計算ビルダーを使用してこれを作成することもできますが、これIEnumerator<'T>は標準ではありません。あなたがそれで遊びたいならば、あなたはそれをここで見つけることができます。

于 2011-07-18T17:37:00.117 に答える
4

以下は不純な実装ですが、不変のシーケンスを遅延して生成します。

let unflatten f s = seq {
    let buffer = ResizeArray()

    let flush() = seq { 
        if buffer.Count > 0 then 
            yield Seq.readonly (buffer.ToArray())
            buffer.Clear() }

    for item in s do
        if f item then yield! flush()
        buffer.Add(item)

    yield! flush() }

f要素が分割点であるべきかどうかをテストするために使用される関数です:

[1;2;3;4;1;5;6;7;1;9] |> unflatten (fun item -> item = 1)
于 2011-07-18T17:49:12.970 に答える
2

おそらく最も効率的な解決策ではありませんが、これは機能します：

let takeAndSkipWhile f s = Seq.takeWhile f s, Seq.skipWhile f s

let takeAndSkipUntil f = takeAndSkipWhile (f >> not)

let rec splitOn f s =
    if Seq.isEmpty s then
        Seq.empty
    else
        let pre, post =
            if f (Seq.head s) then
                takeAndSkipUntil f (Seq.skip 1 s)
                |> fun (a, b) ->
                    Seq.append [Seq.head s] a, b
            else
                takeAndSkipUntil f s
        if Seq.isEmpty pre then
            Seq.singleton post
        else
            Seq.append [pre] (splitOn f post)

splitOn ((=) 1) [1;2;3;4;1;5;6;7;1;9] // int list is compatible with seq<int>

splitOnのタイプは（'a-> bool）-> seq<'a>->seq>です。多くの入力でテストしていませんが、機能しているようです。

于 2011-07-18T17:36:55.700 に答える
0

文字列分割として実際に分割のように機能するものを探している場合（つまり、述語がtrueを返す項目が含まれていない場合）、以下は私が思いついたものです..可能な限り機能的にしようとしました:)

let fromEnum (input : 'a IEnumerator) = 
    seq {
        while input.MoveNext() do
            yield input.Current
    }

let getMore (input : 'a IEnumerator) = 
    if input.MoveNext() = false then None
    else Some ((input |> fromEnum) |> Seq.append [input.Current])

let splitBy (f : 'a -> bool) (input : 'a seq)  = 
    use s = input.GetEnumerator()
    let rec loop (acc : 'a seq seq) = 
        match s |> getMore with 
        | None -> acc
        | Some x ->[x |> Seq.takeWhile (f >> not) |> Seq.toList |> List.toSeq]
                   |> Seq.append acc
                   |> loop
    loop Seq.empty |> Seq.filter (Seq.isEmpty >> not)

seq [1;2;3;4;1;5;6;7;1;9;5;5;1]
|> splitBy ( (=) 1) |> printfn "%A"
于 2011-07-19T06:39:03.620 に答える