C# 替换4个不同的字符

我正在尝试接受用户输入，例如

ATCG

，并将字母替换为

TAGC

。这些是DNA互补碱基。例如，如果用户要输入

atcggc

，它将输出

TAGCCCG

。我成功地替换了一个字符，但我不确定如何让其他字符替换

namespace DNA_Replication_EASY
{
    class Program
    {

        static string input1;


        public static string InputBaseWithSpaces()
        {
            return string.Join(" ", input1.ToCharArray());
        }

        public static string OpposingBases()
        {
            string outputBases1 = input1.Replace("A", "T");
            return outputBases1;
        }

        static void Main(string[] args)
        {

            Console.WriteLine("Please type out your DNA strand bases E.g. A T C G C A T G");
            input1 = Console.ReadLine();
            Console.WriteLine(InputBaseWithSpaces());
            Console.WriteLine(OpposingBases());

            Console.ReadLine();
        }
    }
}

---

我将使用foreach和switch语句替换字符数组中的每个字母

foreach (char base in strand)
{
    switch (base.ToString())
    {
        case "g":
            //replace code
            break;
        case "c":
            //replace code
            break;
    }
}

---

一种方法是使用Switch语句

public static string OpposingBases()
    {
        string outputBases1;
        foreach(var s in input1)
        {            
          switch (s)
          {
            case "A":
              outputBases1 +="T";
              break;
            case "T":
              outputBases1 +="A";
              break;
            case "C":
              outputBases1 +="G";
              break;
            case "G":
              outputBases1 +="C";
              break;
            case " ":
              outputBases1 +=" ";
              break;
            default:
              break;
          }
         }
        return outputBases1;
    }

---

您应该编写一个例程来逐个字符地进行替换（不要使用string.replace方法）

---

请注意，如果您的原始字符串是某些形式的Unicode，那么这可能会带来一些有趣的事情。您应该在其他答案中使用stringbuilder而不是+=语法，因为它更有效。

使用

Regex.Replace

替换基于字典（映射）的字符串：

字典补充=新字典（）
{
{“A”，“T”}，
{“T”，“A”}，
{“C”，“G”}，
{“G”，“C”}
};
字符串输入=“ATCG”；
字符串结果=Regex.Replace（输入，“[ATCG]”，匹配=>互补的[match.Value]）；

这将用字典中的相应值替换任何“ATCG”字符匹配。

string makebackive（string sourceString）{
string MakeOpposite(string sourceString) {
    var opposites = new Dictionary<char, char> {
        { 'A', 'T' },
        { 'T', 'A' },
        { 'G', 'C' },
        { 'C', 'G' }
    };
    var oppositeString = new string(sourceString.Select(x => opposites[x]));
    return oppositeString;
}

var对立=新字典{
{'A'，'T'}，
{'T'，'A'}，
{'G'，'C'}，
{'C'，'G'}
};
var-oppositeString=新字符串（sourceString.Select（x=>opposites[x]）；
返回对立字符串；
}

简单的解决方案，但您可以做得更好：

code = code.Replace("A","x").Replace("C","y").Replace("T","A").Replace("G","C").Replace("x","T").Replace("y","G");

---

将其转换为字符数组并就地替换

string  input = "ATCG";
//TAGC

char[] inputChar = input.ToCharArray();

for(int i=0;i< inputChar.Length; i++)
{
    switch(inputChar[i])
    {
        case 'A':
            inputChar[i]='T';
            break;
        case 'T':
            inputChar[i]='A';
            break;
        case 'G':
            inputChar[i]='C';
            break;
        case 'C':
            inputChar[i]='G';
            break;
    }
}
var output =new string(inputChar);

string input=“ATCG”；
//TAGC
char[]inputChar=input.ToCharray（）；
for（int i=0；i

您可以这样做

    public static string OpposingBases()
    {
        var baseDictionary = new Dictionary<char, char>()
        {
            {'A', 'T'},
            {'T', 'A'},
            {'C', 'G'},
            {'G', 'C'}
        };
        return input1.Where(baseDictionary.ContainsKey).Aggregate("", (current, c) => current + baseDictionary[c]);
    }

publicstaticstringoppositingbases（）
{
var baseDictionary=newdictionary（）
{
{'A'，'T'}，
{'T'，'A'}，
{'C'，'G'}，
{'G'，'C'}
};
返回input1.Where（baseDictionary.ContainsKey）.Aggregate（“，（current，c）=>current+baseDictionary[c]）；
}

我已编辑了您的标题。请参阅“”，其中一致意见是“不，他们不应该”。根据所需的输出，逐个字符进行交换，因为如果我继续执行

outputBases2=input1。替换（“T”，“A”），等等，我只能返回其中一个。您可以使用临时替换，即：T->x，a->T，x->AThis returns
无法在每个案例中将类型字符串隐式转换为char
，如“a”@DunderMifflin11如果case语句中的双引号更改为单引号，这将修复错误“无法将类型字符串隐式转换为字符”。例如，
case'A'：
您的键入速度比我快得多。：）这不起作用，它肯定会累积工作，每次都会更改。对不起，我认为这是有效的。我不想让字符串“ATCG”被替换为“TAGC”“。我想让它与任何字符串一起工作，字母只是被替换。当我输入
ATTGCC
时，如果我用
ATTGCC
替换输入，它只返回“TAGC”，它会为我返回
TAACGG
。。但请记住保持
[ATCG]
参数不变，这是regex的模式。这是答案（以及我自己的答案）都比公认的答案好。
base
是C#中的一个关键字，因此我非常确定如果不将其更改为
@base
，它将无法编译。这与案例中的
string
s而不是
char
s也有相同的问题，就像另一个答案一样。
string  input = "ATCG";
//TAGC

char[] inputChar = input.ToCharArray();

for(int i=0;i< inputChar.Length; i++)
{
    switch(inputChar[i])
    {
        case 'A':
            inputChar[i]='T';
            break;
        case 'T':
            inputChar[i]='A';
            break;
        case 'G':
            inputChar[i]='C';
            break;
        case 'C':
            inputChar[i]='G';
            break;
    }
}
var output =new string(inputChar);

    public static string OpposingBases()
    {
        var baseDictionary = new Dictionary<char, char>()
        {
            {'A', 'T'},
            {'T', 'A'},
            {'C', 'G'},
            {'G', 'C'}
        };
        return input1.Where(baseDictionary.ContainsKey).Aggregate("", (current, c) => current + baseDictionary[c]);
    }