创建基本文本文件中特定行的每种组合的文本文件

Question

好的，希望我能足够详细地解释这一点，以便有人能够帮助我。我正在用 C# 编写一个程序，该程序应该获取一个文本文件并替换特定的文本，这些文本恰好是文件的名称，并且为给定文件名的每个组合打印一个新的文本文件。更改文件名文本的特定位置有自己的一组可能的文件名，以数组形式列出，如下所述。无论每个位置有多少个文件名以及文件名的总位置有多少个，程序都应该运行。如果您真的想让它变得很棒，可以稍微优化它，因为知道任何单个文本文件中都不应重复文件名。

text 是构成整个文件基础的行数组。

lineNum 保存文件名条目的行位置数组。

previousFiles 是以前使用过的文件名的数组，从文件中已有的内容开始。

files 是可能文件名的锯齿状二维数组，其中 files[1] 是第二个位置的所有可能文件名的数组，

以下是一个示例将使用 3 个单独的文件名位置，第一个给出 3 个可能的文件名，第二个给出 8 个可能的文件名，第三个给出 3 个可能的文件名。

哦，假设 buildNewFile 有效。

        int iterator = 0;
        for (int a = 0; a < 3; a++)
        {
            for (int b = 0; b < 8; b++)
            {
                for (int c = 0; c < 3; c++)
                {
                    iterator++;
                    text[lineNums[0]] = text[lineNums[0]].Replace(previousFiles[0], files[0][a]);
                    text[lineNums[1]] = text[lineNums[1]].Replace(previousFiles[0], files[0][a]);
                    text[lineNums[2]] = text[lineNums[2]].Replace(previousFiles[1], files[1][b]);
                    text[lineNums[3]] = text[lineNums[3]].Replace(previousFiles[1], files[1][b]);
                    text[lineNums[4]] = text[lineNums[4]].Replace(previousFiles[2], files[2][c]);
                    text[lineNums[5]] = text[lineNums[5]].Replace(previousFiles[2], files[2][c]);
                    previousFiles = new string[] { files[0][a], files[1][b], files[2][c] };
                    buildNewFile(text, Info.baseFolder + "networks\\" + Info.dsnFilename + iterator + ".dsn");
                }
            }
        }

如果你们能帮助我，非常感谢，我只是不知道如何递归或其他什么。如果您有任何问题，我会回答并在此处进行编辑以反映这一点。

Answer 1

我花了一段时间才弄清楚你真正想做什么。这个问题可以不用递归来解决，诀窍是查看您拥有的数据并将其转换为更可用的格式。

您的“文件”数组是最不方便的数组。诀窍是将数据转换为可用的排列。为此，我建议利用 Yield 并使用返回 IEnumerable 的方法。它的代码如下：

public IEnumerable<string[]> GenerateFileNameStream(string[][] files)
{
    int[] current_indices = new int[files.Length];
    current_indices.Initialize();
    List<string> file_names = new List<string>();

    while (current_indices[0] < files[0].Length)
    {
        file_names.Clear();

        for (var index_index = 0; index_index < current_indices.Length; index_index++)
        {
            file_names.Add(files[index_index][current_indices[index_index]]);
        }

        yield return file_names.ToArray();

        // increment the indices, trickle down as needed
        for (var check_index = 0; check_index < current_indices.Length; check_index++)
        {
            current_indices[check_index]++;

            // if the index hasn't rolled over, we're done here
            if (current_indices[check_index] < files[check_index].Length) break;

            // if the last location rolls over, then we are totally done
            if (check_index == current_indices.Length - 1) yield break;

            // reset this index, increment the next one in the next iteration
            current_indices[check_index] = 0;
        }
    }
}

基本上，它跟踪 files 二维数组的每一行的当前索引，并返回每个当前索引处的文件名。然后它增加第一个索引。如果第一个索引翻转，则它会重置为 0 并递增下一个索引。这样我们就可以迭代文件名的每个排列。

现在，查看 lineNum 和 files 之间的关系，我假设文件中的每个位置都被复制到两行。其余的代码在这里：

public void MakeItWork(string[][] files, int[] lineNum, string[] text, string[] previousFiles)
{
    var iterator = 0;
    var filenames = GenerateFileNameStream(files);

    // work a copy of the text, assume the "previousFiles" are in this text
    var text_copy = new string[text.Length];

    foreach (var filenameset in filenames)
    {
        iterator++;
        Array.Copy(text, text_copy, text.Length);

        for (var line_index = 0; line_index < lineNum.Length; line_index++)
        {
            var line_number = lineNum[line_index];
            text[line_number] = text[line_number].Replace(previousFiles[line_index], filenameset[line_index / 2]);
        }

        buildNewFile(text_copy, Info.baseFolder + "networks\\" + Info.dsnFilename + iterator + ".dsn");
    }
}

此代码仅从枚举器获取结果并为您生成文件。基于示例代码的假设是每个文件名位置使用两次（因为 lineNum 数组的长度是 files 位置计数的两倍。

我没有全面测试了所有代码，但算法的关键在于将数据转换为更可用的形式，然后对其进行处理。在此处提出问题时，我的另一个建议是将问题描述为一个问题。 “问题”而不是当前解决方案的术语。如果您详细说明了要实现的目标而不是显示代码，则可以更深入地了解问题。