C# 有没有办法将一个字符串随机分成不同的字符串数组，然后返回相同的字符串

比如我有

String Text = "ABCDEFGHIJKLMNOPQ";

运行一些代码以进入

String[] text1 = "AOCN";
String[] text2 = "JQBF";
String[] text3 = "DMG";
String[] text4 = "HPI";
String[] text5 = "KEL";

然后用一些代码把它恢复到

String Text=“ABCDEFGHIJKLMNOPQ”

这可能吗？

---

我试图实现的是将溢出的字符随机存储到5个不同的字符串数组中，并使用代码将其还原为原始文本

是的，您可以逐个字符进行迭代：

using System;

class Program
{
    static void Main()
    {
        const string s = "Hello!";
        // Option 1
        foreach (char c in s)
        {
            Console.WriteLine(c);           // Your treatment here
        }
        // Option 2
        for (int i = 0; i < s.Length; i++)
        {
            Console.WriteLine(s[i]);        // Your treatment here
        }
    }
}

然后在这里的治疗中，你可以使用C#提供的基本随机函数。只要不更改

种子

，就可以检索用于生成子字符串的序列，并可能将其还原

举例来说，可以是这样的：

int seed = 12;
List<int> lst = new List<int>();
// Repeat that until you processed the whole string
// At the mean time, skip the characters already indexed
while (lst.Count != s.Length) {
    int n = new Random(seed).Next(0, s.Length); 
    if (!lst.Contains(n)) {
        text1 += s[n];
        lst.Add(n);
    }
}

int-seed=12；
List lst=新列表（）；
//重复该操作，直到处理整个字符串为止
//同时，跳过已编入索引的字符
while（lst.Count！=s.Length）{
int n=新随机（种子）。下一个（0，s.长度）；
如果（！lst.包含（n））{
text1+=s[n]；
第1条增补（n）；
}
}

最后，

lst

是恢复流程的关键

然后，生成子字符串的方式以及恢复原始字符串的算法也取决于您。。。你完全自由了

---

注意：关于处理

块

，请参考

Simon

的答案。

对于任意字符串，假设您的分布是真正随机的，那么除非您以某种方式存储了随机因子，否则将无法重新组合原始字符串。这让我想起了只写内存。

假设请求将字母“随机”分配到数组是为了一种伪随机（或者，可能是一种表面上任意的）分配，因此是可逆的，实现这一点的一种技术是基本上使用

然后，算法将类似于：

对输入文本运行换位密码

将转置文本拆分为数组

然后，通过颠倒这两个步骤获得原文

（编辑）

换位密码密钥可以由从

1

到

n

的伪随机数流组成，其中

n

是要将输入字符串拆分成的字符串数。因此，扩展算法如下所示：

生成长度为

m

的伪随机数列表，

p

，其中

m

是输入字符串的长度

对于所有

i

，将输入字符串中的

i

第个字母指定给输出字符串编号

p[i]

要重新组装原始字符串：

对于所有

i

，从字符串编号

p[i]

中的下一个未使用的字母中获取字符串中的

i

第个字母

试试这个：

static void Main(string[] args)
    {
        string Text = "ABCDEFGHIJKLMNOPQ";


        int chunk = new Random().Next(1,Text.Length/2);

        var result= Split(Text,chunk);


        Console.WriteLine("Splited:");

        foreach (var word in result)
        {
            Console.WriteLine(word);
        }


        string toOld = "";
        Console.WriteLine("Returned:");

        toOld = result.Aggregate((i, j) => i + j);

        Console.WriteLine(toOld);

        Console.ReadLine();


    }

    static List<string> Split(string str, int chunkSize)
    {
        var re = Enumerable.Range(0, str.Length / chunkSize)
            .Select(i => str.Substring(i * chunkSize, chunkSize)).ToList() ;

        var temp = re.Aggregate((i, j) => i + j);

        if (temp.Length < str.Length)
        {
            var last = re.Last();
            last += str.Substring(temp.Length, str.Length - temp.Length);
            re[re.Count-1] = last;
        }
        return re;

    }

static void Main（字符串[]args）
{
string Text=“ABCDEFGHIJKLMNOPQ”；
int chunk=new Random（）.Next（1，Text.Length/2）；
var result=Split（文本、块）；
控制台。WriteLine（“拆分：”）；
foreach（结果中的var字）
{
控制台写入线（word）；
}
字符串工具d=“”；
Console.WriteLine（“返回：”）；
toOld=结果聚合（（i，j）=>i+j）；
控制台写入线（toOld）；
Console.ReadLine（）；
}
静态列表拆分（字符串str，int chunkSize）
{
var re=可枚举的范围（0，str.Length/chunkSize）
.Select（i=>str.Substring（i*chunkSize，chunkSize））.ToList（）；
var temp=骨料（（i，j）=>i+j）；
如果（温度长度<长度长度）
{
var last=re.last（）；
最后+=短链子串（短链长度，短链长度-短链长度）；
re[re.Count-1]=最后一次；
}
返回re；
}

---

您可以控制块大小

任何内容都可以possible@GrantWinney已编辑问题假设为字符串数组抱歉confusion@GrantWinney这样存储也很好

String[]splitText=new[]{“AOCN”、“JQBF”、…}但我需要能够在起始位置恢复原始字符串为什么要这样做？这是某种加密方案吗？“找回字符串”最简单的方法就是简单地使用原始字符串。你基本上是在要求可逆随机化吗？但是如果它是可逆的，并且有人知道或者可以对你的算法进行反向工程，那么它就不安全，除非你使用某种适当的加密方法。但如果你这样做，你最好只是使用标准库，而不是尝试使用你自己的库…如果你能“返回相同的字符串”，那么它就不是随机的，因为你知道怎么做，然而，随机性是不可预测的。这不是我想要实现的。我想要将拆分的字符随机存储到5个字符串数组中，并能够将其还原为原始文本。您可以使用任何类型的算法，现有算法或自制算法。请放心…我不知道使用的种子是什么这与根本不指定
种子
是一样的，但我明确使用了一个常量来警告您，在新的
随机
对象上调用
.Next（）
时，数字序列将始终相同。例如，如果前四次呼叫给出[18,2,5,12]。在一个新的
随机
对象上调用
Next（）
四次，在保持相同的
种子的同时将再次是[18,2,5,12]。这样您就可以随时检索随机序列，即使您没有将其存储在任何地方。阅读。你提供的代码不是随机化文本，而是随机化文本，我需要的是随机化文本，然后得到相同的文本。当我第一次想到这样做时，我已经想到使用某种密码，但我认为这可能会使我的程序太慢，所以我把它留给最后一种可能的方式，如果伪随机数列表是前基因的话
static void Main(string[] args)
    {
        string Text = "ABCDEFGHIJKLMNOPQ";


        int chunk = new Random().Next(1,Text.Length/2);

        var result= Split(Text,chunk);


        Console.WriteLine("Splited:");

        foreach (var word in result)
        {
            Console.WriteLine(word);
        }


        string toOld = "";
        Console.WriteLine("Returned:");

        toOld = result.Aggregate((i, j) => i + j);

        Console.WriteLine(toOld);

        Console.ReadLine();


    }

    static List<string> Split(string str, int chunkSize)
    {
        var re = Enumerable.Range(0, str.Length / chunkSize)
            .Select(i => str.Substring(i * chunkSize, chunkSize)).ToList() ;

        var temp = re.Aggregate((i, j) => i + j);

        if (temp.Length < str.Length)
        {
            var last = re.Last();
            last += str.Substring(temp.Length, str.Length - temp.Length);
            re[re.Count-1] = last;
        }
        return re;

    }