C# 获取数字的子字符串

如果输入为6789，则输出应为 6,7,8,9,67,78,896787896789

这种逻辑应该适用于大数字 比如6789012345678等等

    static Int64 substrings(string n)
    {
        string p = string.Empty, q = string.Empty, r = string.Empty;
        char[] c = n.ToCharArray();
        string s = string.Empty;
        Int64 res = 0;

        for (int x = 0; x < n.Length; x++)
        {
            res += Convert.ToInt64(n[x].ToString());
        }

        for (int x = 0; x < n.Length; x++)
        {
            if (x > 0)
            {


                p = n[x - 1].ToString();
                q = n[x].ToString();
                r = p + "" + q;

                p = q;
                q = r[0].ToString();

                res += Convert.ToInt64(r);
            }
        }

        for(int x = 0; x < n.Length; x++)
        {
            if (n.Length > 2)
            {
                s += n[x];
            }
        }
        if (n.Length > 2)
        {
            return res + Convert.ToInt64(s);
        }
        else
        {
            return res;
        }
    }

static Int64子字符串（字符串n）
{
字符串p=string.Empty，q=string.Empty，r=string.Empty；
char[]c=n.ToCharArray（）；
string s=string.Empty；
Int64 res=0；
对于（int x=0；x0）
{
p=n[x-1].ToString（）；
q=n[x].ToString（）；
r=p+“”+q；
p=q；
q=r[0].ToString（）；
res+=转换为64（r）；
}
}
对于（int x=0；x2）
{
s+=n[x]；
}
}
如果（n.长度>2）
{
返回res+转换为64（s）；
}
其他的
{
返回res；
}
}

---

这是我为生成子字符串而编写的代码。此逻辑无法大量工作

您可以创建扩展并使用以下方式：

static class StringExtensions
{
    public static IEnumerable<String> SplitInMultipleParts(this String s)
    {
        if (s == null)
            throw new ArgumentNullException("s");

        for (var p = 0; p < s.Length; p++)
        {
            for (var i = 0; i < s.Length - p; i++)
                yield return s.Substring(i, p + 1);
        }
    }
}

您的结果是对

int64

的枚举，如果您想要列表，只需添加扩展名

.ToList（）

如果您不喜欢扩展，我认为转换为简单方法对您来说不是问题

public static IEnumerable<String> SplitInMultipleParts(String s)

ans call it : SplitInMultipleParts(num)

公共静态IEnumerable SplitinMultiparts（字符串s）
ans称之为：SplitInMultipleParts（num）

试试这个：

IEnumerable<string> Subsequences(string input)
{
    return
        Enumerable
            .Range(0, input.Length)
            .SelectMany(x =>
                Enumerable
                    .Range(1, input.Length - x),
                (x, y) => input.Substring(x, y));
}

---

可能重复：我的逻辑仅适用于3位数字。ex123 otuput是1,2,3,12,23123。我使用了用于fibbonoci系列的逻辑您遇到问题的代码是什么？你的代码有什么问题？你收到错误信息了吗？错误消息是什么？你得到的结果不是你期望的结果吗？你期望得到什么样的结果？为什么？你会得到什么样的结果？两者有什么不同？你观察到的行为是否不是期望的行为？期望的行为是什么？为什么？观察到的行为是什么？它们有什么不同？请提供一个。您的文本意味着输出应该是一个数组，但您的代码意味着输出应该是一个

Int64

-那么它是哪一个呢？我已经编写了代码来查找所有子字符串的总和。我使用了Int64，这样在出现大量数据时就不会造成任何问题。这个逻辑对6789不起作用。虽然答案是正确的，但为什么您认为有必要将其作为扩展方法！？如果你问我的话，这个案例非常具体，我确信这是一个家庭作业问题。@CSharpie，扩展方法与否不是问题，主要是分析，我认为将扩展转换为简单的循环或方法并不复杂

IEnumerable<string> Subsequences(string input)
{
    return
        Enumerable
            .Range(0, input.Length)
            .SelectMany(x =>
                Enumerable
                    .Range(1, input.Length - x),
                (x, y) => input.Substring(x, y));
}

6 67 678 6789 7 78 789 8 89 9