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

问题描述

我目前正在做一个项目，我有像 [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,G) -> Phe | (A,T) -> Leu  | (A,C) -> Leu
  | (G,A) -> Leu | (G,G) -> Leu | (G,T) -> Leu  | (G,C) -> Leu
  | (T,A) -> Ile | (T,G) -> Ile | (T,T) -> Ile  | (T,C) -> START
  | (C,A) -> Val | (C,G) -> Val | (C,T) -> Val  | (C,C) -> Val
  | (A,G,A) -> Ser | (A,G) -> Ser | (A,T) -> Ser  | (A,C) -> Ser
  | (G,A) -> Pro | (G,G) -> Pro | (G,T) -> Pro  | (G,C) -> Pro
  | (T,A) -> Thr | (T,G) -> Thr | (T,T) -> Thr  | (T,C) -> Thr
  | (C,A) -> Ala | (C,G) -> Ala | (C,T) -> Ala  | (C,C) -> Ala
  | (A,T,A) -> Tyr | (A,G) -> Tyr | (A,T) -> STOP | (A,C) -> STOP
  | (G,A) -> His | (G,G) -> His | (G,T) -> Gln  | (G,C) -> Gln
  | (T,A) -> Asn | (T,G) -> Asn | (T,T) -> Lys  | (T,C) -> Lys
  | (C,A) -> Asp | (C,G) -> Asp | (C,T) -> glu  | (C,C) -> glu
  | (A,C,A) -> Cys | (A,G) -> Cys | (A,C) -> Trp
  | (G,A) -> Arg | (G,G) -> Arg | (G,T) -> Arg  | (G,C) -> Arg
  | (T,A) -> Ser | (T,G) -> Ser | (T,T) -> Arg  | (T,C) -> Arg
  | (C,A) -> Gly | (C,G) -> Gly | (C,T) -> Gly  | (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 是链中的第一个？

解决方法

首先不要将 pf 放在 START 函数的结果列表中。您可以忽略它们，因为它们对您的其余问题毫无用处。

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

Split 以 dna_to_chain 和 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

,

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

这里是我在之前的回答中谈到的拆分代码的 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 之间的空列表

,

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

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,overall_acc))
    (false,[])
    lst
  in
  result

我们折叠了一个 'a list 类型的列表，其中提供了 'a 类型的开始和停止标记。我们对折叠的初始值是一个元组，包含是否已经看到开始标记、一个累加器和一个整体累加器。事实上，如果它在开始和停止令牌之间，它会添加到累加器中。当它停止时，该累加器被添加到整个累加器中。最后我们使用模式匹配来访问整个累积列表。

在没有遇到开始或停止的情况下，她没有什么可以处理的错误。我将把它留给你做进一步的练习。

我发现折叠的范围是一种很好的方式来查看哪些信息实际上需要通过列表的迭代进行交流。