Question

问题如下：（需要在C＃中编写ReserveComplemenet方法）

序列的反向互补序列是通过将其所有核碱基与其碱基互补序列交换，然后反转所得序列而形成的。通过交换以下所有实例形成DNA序列的反向互补序列：

带有T的A
T与A
带有C的G
C与G
然后反转结果序列。

例如：

给定DNA序列AAGCT，反向互补为AGCTT

此方法ReverseComplement()必须采用以下参数：

参考DNA序列

此方法应返回void并将引用的DNA序列突变为其反向互补。

当前，这是我的代码，

string result = z.Replace('A', 'T').Replace('T', 'A').Replace('G', 'C').Replace('C', 'G');


    string before = (result);
    return before;

我被困住了，想知道我该怎么做？任何帮助将不胜感激。运行此命令时，我得到的是AAGGA而不是AGCTT

Answer 1

using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleApp8
{
    class Program
    {
        static void Main(string[] args)
        {
            var dict = new Dictionary<char, char>()
            {
                ['A'] = 'T',
                ['T'] = 'A',
                ['G'] = 'C',
                ['C'] = 'G',
            };

            var input = "AAGCT";
            var output = string.Concat(input.Select(c => dict[c]).Reverse()); // AGCTT

            Console.WriteLine(input);
            Console.WriteLine(output);
        }
    }
}

Answer 2

运行此命令时，我得到的是AAGGA而不是AGCTT

因为您将其视为单个替换，而不是多个替换：

z.Replace('A', 'T').Replace('T', 'A').Replace('G', 'C').Replace('C', 'G');

AAGCT
Replace('A', 'T')
TTGCT
Replace('T', 'A')
AAGCA
Replace('G', 'C')
AACCA
.Replace('C', 'G')
AAGGA

相反，我建议使用中介替换：

var z = "AAGCT";
var chars = z.Replace('A', '1')
  .Replace('T', 'A')
  .Replace('1', 'T')
  .Replace('G', '2')
  .Replace('C', 'G')
  .Replace('2', 'C')
  .Reverse()
  .ToArray();
var result = new string(chars);
Console.WriteLine(result);

收益：

AGCTT

DotNetFIddle Example

现在，如果要进行数百万次操作，则可能需要考虑使用StringBuilder。

推荐阅读：The Sad Tragedy of Micro-Optimization Theater

Answer 3

“替换”版本的小技巧：

using System;
using System.Linq;

namespace DNA
{
    public class Program
    {
        public static void Main()
        {
            var dna = "AAGCT";
            var reversed = new String(dna
                .ToLower()
                .Replace('a', 'T')
                .Replace('t', 'A')
                .Replace('g', 'C')
                .Replace('c', 'G')
                .Reverse()
                .ToArray());
            Console.WriteLine(reversed);
        }
    }
}

Answer 4

或者是旧的StringBuilder：

using System;
using System.Text;

namespace DNA
{
    public class Program
    {
        public static void Main()
        {
            var dna = "AAGCT";
            var sb = new StringBuilder(dna.Length);
            for(var i = dna.Length - 1; i >- 1; i--)
            {
                switch(dna[i])
                {
                    case 'A':
                        sb.Append('T');
                        break;
                    case 'T':
                        sb.Append('A');
                        break;
                    case 'G':
                        sb.Append('C');
                        break;
                    case 'C':
                        sb.Append('G');
                        break;
                }
            }
            var reversed = sb.ToString();
            Console.WriteLine(reversed);
        }
    }
}

Answer 5

与其替换每个字符，不如使用linq来实现：

void Translate(ref string dna)
{
    var map = new string[] {"AGTC", "TCAG"};
    dna = string.Join("", dna.Select(c => map[1][map[0].IndexOf(c)]).Reverse());
}

从代表映射的字符串数组开始-然后为字符串的每个字符选择映射的字符，反转从IEnumerable<char>获得的Select，然后使用{{1} }，将其转换回字符串。

问题中的代码首先将string.Join转换为A，然后将T转换为T，因此所有A都将返回为{ {1}}，也将所有A都返回为A（T和A也一样）。

还有一个基于for循环和字符串生成器的非linq解决方案（翻译逻辑相同）：

序列的反补

5 个答案: