在 ocaml 中一次匹配 3 个元素并将核苷酸转换为酸

Question

我目前正在做一个项目，其中我有像

[T;A;C;G;G;C;T;A;G;A;T;T;T;A;C;G;C;T;A;A;T;A;T;C]

这样的核苷酸的DNA列表，我需要将第一条链（“START”和“STOP”）之间的核苷酸转换成相应的酸。因此，我需要获取 3×3 的核苷酸并将它们传递到这个函数中：

type acid = Ala | Arg | Asn | Asp | Cys
           | Glu | Gln | Gly | His | Ile
           | Leu | Lys | Phe | Pro | Ser
           | Thr | Trp | Tyr | Val | START | STOP

let convert_acid (n1 : nucleotide) (n2 : nucleotide) (n3 : nucleotide) : acid =
  begin match (n1, n2, n3) with
  | (A, A, A) -> Phe | (A, A, G) -> Phe | (A, A, T) -> Leu  | (A, A, C) -> Leu
  | (G, A, A) -> Leu | (G, A, G) -> Leu | (G, A, T) -> Leu  | (G, A, C) -> Leu
  | (T, A, A) -> Ile | (T, A, G) -> Ile | (T, A, T) -> Ile  | (T, A, C) -> START
  | (C, A, A) -> Val | (C, A, G) -> Val | (C, A, T) -> Val  | (C, A, C) -> Val
  | (A, G, A) -> Ser | (A, G, G) -> Ser | (A, G, T) -> Ser  | (A, G, C) -> Ser
  | (G, G, A) -> Pro | (G, G, G) -> Pro | (G, G, T) -> Pro  | (G, G, C) -> Pro
  | (T, G, A) -> Thr | (T, G, G) -> Thr | (T, G, T) -> Thr  | (T, G, C) -> Thr
  | (C, G, A) -> Ala | (C, G, G) -> Ala | (C, G, T) -> Ala  | (C, G, C) -> Ala
  | (A, T, A) -> Tyr | (A, T, G) -> Tyr | (A, T, T) -> STOP | (A, T, C) -> STOP
  | (G, T, A) -> His | (G, T, G) -> His | (G, T, T) -> Gln  | (G, T, C) -> Gln
  | (T, T, A) -> Asn | (T, T, G) -> Asn | (T, T, T) -> Lys  | (T, T, C) -> Lys
  | (C, T, A) -> Asp | (C, T, G) -> Asp | (C, T, T) -> Glu  | (C, T, C) -> Glu
  | (A, C, A) -> Cys | (A, C, G) -> Cys | (A, C, T) -> STOP | (A, C, C) -> Trp
  | (G, C, A) -> Arg | (G, C, G) -> Arg | (G, C, T) -> Arg  | (G, C, C) -> Arg
  | (T, C, A) -> Ser | (T, C, G) -> Ser | (T, C, T) -> Arg  | (T, C, C) -> Arg
  | (C, C, A) -> Gly | (C, C, G) -> Gly | (C, C, T) -> Gly  | (C, C, C) -> Gly
  end

所以我的想法是获取列表的前3个核苷酸，通过将它们传递到函数中来转换它们，并将返回的列表连接到一个新列表中，但我不知道该怎么做。这是我到目前为止在伪代码中所做的事情：

let rec dna_to_chain (x : dna) : acid list =
  match with x
  | hd::tl -> convert_acid hd
  | _ -> do nothing

我想获取列表x的前3个元素，将它们传递到convert_acid函数中，然后使用列表的其余部分调用dna_to_chain，直到到达“STOP”acid。

之后我需要做另一个函数将每个DNA转换成链（START和STOP之间的每个核苷酸序列），并将它们放入具有类似函数的酸列表列表中，而不使用递归（我猜我需要使用我需要首先执行的递归函数）。

有人知道我如何完成我的代码并使其正常工作吗？谢谢！

编辑： 我现在有以下功能

let rec dna_to_chain (x : dna) : acid list =
      match with x
      | n1::n2::n3::tl -> (convert_acid n1 n2 n3) :: dna_to_chain tl
      | [] -> [] ;;

dna_to_chain [T;A;C;G;G;C;T;A;G;A;T;T ; T;A;C;G;C;T;A;A;T;A;T;C]

返回

[START; Pro; Ile; STOP ; START;Arg;Leu;STOP]

但如何在第一个 START 和 STOP 之间获得第一个酸？我正在考虑创建另一个函数并再次进行模式匹配，但是我如何知道我正在匹配的 START 是链中的第一个函数？

Answer 1

首先不要将

START

放入

dna_to_chain

函数的结果列表中。您可以忽略它们，因为它们对解决您的其余问题毫无用处。

然后你只需要编写一个“split”函数，这是一个很好的练习。

Split 将

l ('a list)

和

v ('a)

作为参数，并返回列表中每次出现

v

之间的子列表。例如：

split [2;3;3;1;2;3;4;5;1;2;1;3;1;8;9] 1;;
- : int list list = [[2; 3; 3]; [2; 3; 4; 5]; [2]; [3]; [8; 9]]

一旦你这样做了，你只需在

 的结果上使用 

List.map

 和 

dna to chain function

即可

split (dna_to_chain (*your dna*)) STOP

Answer 2

免责声明：我不知道这是否是回答问题的好方法，所以如果我应该编辑旧答案而不是编写新答案，请告诉我。

所以这是我在之前的回答中谈到的分割代码的两个版本。我希望它能帮助您了解如何实现修改后的分割功能。第一个使用 2 递归函数，第二个是尾递归

let rec split v = function
  | [] -> []
  | t -> let a, b = goNext v t in 
      if a <> [] then a :: split v b else split v b
and goNext v = function
  | x :: xs -> if x = v then [], xs else 
      let a, b = goNext v xs in x :: a, b
  | [] -> ([], []);;
  
let split2 l v = 
    let rec aux acc buff = function 
        | x :: xs -> if x = v 
            then
              aux [] (if acc <> [] then List.rev  acc :: buff else buff) xs
            else
              aux (x :: acc) buff xs
        | [] -> List.rev @@ if acc <> [] then List.rev acc :: buff else buff
     in aux [] [] l;;

两个函数都会忽略两次出现

v

之间的空列表

Answer 3

希望这作为答案有用，因为评论对于详细说明这一点有点有限。

let between start_tok stop_tok lst =
  let (_, _, result) = List.fold_left 
    (fun (start_seen, acc, overall_acc) x -> 
      if start_seen && x = start_tok then 
        (true, [], overall_acc) 
      else if start_seen && x = stop_tok then
        (false, [], overall_acc @ [acc])
      else if start_seen then
        (true, acc @ [x], overall_acc)
      else if x = start_tok then
        (true, [], overall_acc)
      else
        (false, acc, overall_acc))
    (false, [], [])
    lst
  in
  result

我们折叠了

'a list

类型的列表，并提供了

'a

类型的开始和停止标记。我们对折叠的初始值是一个元组，其中包含是否已看到起始标记、累加器和总体累加器。这样，如果它位于开始标记和停止标记之间，它就会添加到累加器中。当它停止时，该累加器将添加到整个累加器中。最后，我们使用模式匹配来访问整个累积列表。

当未遇到开始或停止时，这里没有任何内容可以处理错误。我将把它作为进一步的练习留给你。

我发现折叠的限制是查看列表迭代中实际需要传达哪些信息的好方法。