C# 使用受限需求反转字符串

我刚开始学习C#，我需要一些帮助。我必须反转字符串并仅使用

if

、

else

、

开关

、

s.Length

、

s.Substring

和

s[]

：

    static string MyReverseString(string s)
    {
        int len = s.Length;
        string NewS= "";
        if (len != 0)
        {
            NewS = NewS + s[len];

            return MyReverseString(s.Substring(0, (len - 1)));
        }
        else
        {
            return NewS;

        }
    }    

我得到

“索引超出了数组的边界。”

---

你的总体想法是正确的，但你并不完全正确

当使用递归时，首先编码不需要递归的情况。当反转字符串时，最简单的情况是什么？嗯，当字符串为空或只有一个字符长时。好的，让我们这样做：

public static string Reverse(string s)
{
    if (s.Length <= 1)
        return s;

    //do something else
}

那是什么东西？嗯，它必须是

s

的反面，没有最后一个字母，我们已经处理好了，记得吗？但是哦，等等！我已经知道如何反转字符串了，不是吗<代码>反向（s.Substring（0，s.Length-1）（递归不是很神奇吗？）

维奥拉：

public static string Reverse(string s)
{
    if (s.Length <= 1)
        return s;

    return s[s.Length - 1] + Reverse(s.Substring(0, s.Length - 1));
}

公共静态字符串反转（字符串s）
{
如果（s.Length这里，s[len]抛出一个indexoutfrange异常。假设-如果您有字符串s=“abc”，那么索引从0开始。所以s[2]将是“c”，字符串的长度是3。所以，如果您试图得到s[len]即s[3]，它将抛出一个异常

看看-
要将字符串对半，请交换对半，并以这种方式递归反转，直到大小为1或0个字符

要检查回文，请检查第一个和最后一个字符是否相同。如果不相同，则字符串肯定不是回文。如果为真，则以相同的方式递归检查原始字符串的较小部分（除第一个和最后一个字符外）是否是回文

    static string Reverse(string s)
    {
        if (s.Length >= 2)
            return Reverse(s.Substring(s.Length / 2)) + Reverse(s.Substring(0, s.Length / 2));
        else
            return s;
    }

    static bool IsPalindrome(string s)
    {
        if (s.Length <= 1)
            return true;

        if (s[0] == s[s.Length - 1] && IsPalindrome(s.Substring(1, s.Length-2)))
            return true;
        else
            return false;
    }

静态字符串反转（字符串s）
{
如果（s.长度>=2）
返回反向（s.Substring（s.Length/2））+反向（s.Substring（0，s.Length/2））；
其他的
返回s；
}
静态bool IsPalindrome（字符串s）
{
如果（s.Length尝试以下方法：

public static string MyReverseString(string s)
{
    return MyReverseString(s, s.Length - 1);
}

private static string MyReverseString(string s, int index)
{
    if (index > 0)
    {
        return s[index] + MyReverseString(s, index - 1);
    }
    else
    {
        return s[index].ToString();
    }
}

这避免了使用
.Substring
（这略微提高了效率）

如果要查找回文，而不关心字符串的反转，请尝试以下操作：

public static bool IsPalindrome(string s)
{
    return IsPalindrome(s, 0, s.Length - 1);
}

private static bool IsPalindrome(string s, int start, int finish)
{
    if (finish - start <= 0)
    {
        return true;
    }
    else
    {
        if (s[start] != s[finish])
        {
            return false;
        }
        else
        {
            return IsPalindrome(s, start + 1, finish - 1);
        }
    }
}

公共静态bool IsPalindrome（字符串s）
{
返回isAlindrome（s，0，s.长度-1）；
}
私有静态bool IsPalindrome（字符串s，int start，int finish）
{
if（finish-start LINQ:
Reverse（）
method。正如我在文章中提到的，除了if，else，我不能使用Switch、s.Length、s.Substring和s[]。通过向后循环字符串将字符分配给新字符串有什么用？@Stijn我已经尝试了“int len=s.Length-1”和“if（len>0）”但仍然不起作用。谢谢你的评论，但我可以自己搜索。我建议你慢慢来，仔细阅读副本。然后你就会明白为什么你的代码不起作用，以及为什么你对
-1
的其他尝试也不起作用。你是最好的！谢谢！愉快的案例条件可以稍微优化到
s.Length@Ňuf true！将更新。
public static bool IsPalindrome(string s)
{
    return IsPalindrome(s, 0, s.Length - 1);
}

private static bool IsPalindrome(string s, int start, int finish)
{
    if (finish - start <= 0)
    {
        return true;
    }
    else
    {
        if (s[start] != s[finish])
        {
            return false;
        }
        else
        {
            return IsPalindrome(s, start + 1, finish - 1);
        }
    }
}

private static bool IsPalindrome(string s, int start, int finish)
{
    return (finish - start <= 0) || (s[start] == s[finish]) && IsPalindrome(s, start + 1, finish - 1);
}