Créer des fichiers texte de toutes les combinaisons de lignes spécifiques dans un fichier texte de base

Question

Ok, donc je espère pouvoir expliquer cela de façon suffisamment détaillée pour quelqu'un pour être en mesure de me aider .. Je suis en train d'écrire un programme en C# qui est censé prendre un fichier texte et remplacer le texte spécifique, qui se trouve être les noms des fichiers, et imprimer un nouveau fichier texte pour chaque combinaison des noms de fichiers donnés. Les endroits spécifiques pour changer le texte des noms de fichiers ont leur propre ensemble de noms de fichiers possibles, répertoriés comme un tableau décrit ci-dessous. Le programme doit s'exécuter quel que soit le nombre de noms de fichiers disponibles pour chaque emplacement, ainsi que le nombre total d'emplacements pour les noms de fichiers. Si vous voulez vraiment le rendre génial, il peut être légèrement optimisé en sachant qu'aucun nom de fichier ne doit être dupliqué dans un seul fichier texte.

text est un réseau de lignes qui forment la base du fichier total.

lineNum contient un tableau des emplacements de ligne des entrées de nom de fichier.

previousFiles est un tableau de noms de fichiers utilisés précédemment, en commençant par ce qui est déjà dans le fichier.

files est un tableau à 2 dimensions en dents de scie de noms possibles où files[1] serait un tableau de tous les noms possibles pour le 2ème emplacement

Voici un exemple de la façon dont cela fonctionnerait avec 3 emplacements de noms de fichiers séparés, la le premier a donné 3 noms de fichiers possibles, le second a donné 8 noms de fichiers possibles, et le troisième a donné 3 noms de fichiers possibles.

Oh et supposons que buildNewFile fonctionne.

 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"); 
       } 
      } 
     } 

Si vous les gars peuvent me aider, je vous remercie beaucoup, je ne peux pas comprendre comment le faire ou quoi que ce soit récursive. Si vous avez des questions, je vais y répondre et les modifier ici pour refléter cela.

Answer 1

Il m'a fallu un peu de temps pour comprendre ce que vous vouliez vraiment faire. Ce problème peut être résolu sans récursion, l'astuce consiste à regarder les données que vous avez et à l'obtenir dans un format plus utilisable. Votre tableau de "fichiers" est celui qui est le plus incommode. L'astuce consiste à transformer les données en permutations utilisables. Pour ce faire, je suggère de tirer parti du rendement et d'utiliser une méthode qui renvoie IEnumerable. Le code est ici:

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; 
     } 
    } 
} 

Fondamentalement, il garde la trace de l'indice actuel pour chaque ligne du tableau 2D files et retourne le nom du fichier à chaque index en cours. Ensuite, il incrémente le premier index. Si le premier index revient, il se réinitialise à 0 et incrémente l'index suivant à la place. De cette façon, nous pouvons parcourir toutes les permutations des noms de fichiers. Maintenant, en regardant la relation entre lineNum et files, je suppose que chaque emplacement dans le fichier est copié sur deux lignes. Le reste du code est ici:

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"); 
    } 
} 

Ce code prend simplement les résultats de l'énumérateur et génère les fichiers pour vous. L'hypothèse basée sur votre exemple de code est que chaque emplacement de nom de fichier est utilisé deux fois par fichier (puisque le tableau lineNum était deux fois plus long que le nombre d'emplacements files.

Je n'ai pas entièrement testé tout le code, mais le noeud de l'algorithme est là. La clé est de transformer vos données en une forme plus utilisable, puis le traiter. L'autre suggestion que j'ai en posant une question ici est de décrire le problème plus comme un «problème» et non pas dans les termes de votre solution actuelle. Si vous avez détaillé l'objectif que vous essayez d'atteindre au lieu d'afficher du code, vous pouvez obtenir plus d'informations sur le problème.