检查文本文件中是否包含字符的排列

你错过了Show(d, line);我循环。

像这样改变

while ((line = Console.ReadLine()) != null)
        {
            char[] c2 = line.ToArray();
            p.setper(c2);
            Console.WriteLine(" combinations which are in Dictionary are:");
            Show(d, line);
        }

然后. .你不需要字典

  use List<string> Dic=new List<string>();// declare it in globally
  Dic.add(line); //each line in dictionary 

 if(Dic.contains(word))
   print it; 
 else{ //no printing }

当前状态不支持。

这是可能的，因为

1. 如果"dictionary.txt"是你的输入，那么你没有定义什么是有效的单词。您至少需要另一个字典来定义那些有效的单词，或者需要一个算法来决定哪些是有效的，哪些不是。

2. 如果输入来自UI并且"dictionary.txt"是定义的有效单词，则不需要对输入进行排序，只需从"dictionary.txt"中搜索输入即可。

然而，你的Read方法是可以改进的，如

static Dictionary<String, String> Read(String path) {
    return (
        from line in File.ReadAllLines(path)
        where false==String.IsNullOrEmpty(line)
        group line by Alphabet(line) into g
        select
            new {
                Value=String.Join(",", g.ToArray()),
                Key=g.Key
            }
        ).ToDictionary(x => x.Key, x => x.Value);
}

虽然对于有效的单词正如我在另一个答案中提到的，在您当前的状态下是不可能的，但我已经为您编写了相当清晰的代码。

它最后的代码，分为三个部分。它们是Permutable<T>, ConsoleHelper和ConsoleApplication1.Program，并具有实用的Permutation类。

• Permutable(Permutable.cs)

  using System.Collections.Generic;
  using System.Collections;
  using System;
  public partial class Permutable<T>: IEnumerable {
      public static explicit operator Permutable<T>(T[] array) {
          return new Permutable<T>(array);
      }
      static IEnumerable Permute<TElement>(IList<TElement> list, int depth, int count) {
          if(count==depth)
              yield return list;
          else {
              for(var i=depth; i<=count; ++i) {
                  Swap(list, depth, i);
                  foreach(var sequence in Permutable<T>.Permute(list, 1+depth, count))
                      yield return sequence;
                  Swap(list, depth, i);
              }
          }
      }
      static void Swap<TElement>(IList<TElement> list, int depth, int index) {
          var local=list[depth];
          list[depth]=list[index];
          list[index]=local;
      }
      IEnumerator IEnumerable.GetEnumerator() {
          return this.GetEnumerator();
      }
      public IEnumerator<IList<T>> GetEnumerator() {
          var list=this.m_List;
          if(list.Count>0)
              foreach(IList<T> sequence in Permutable<T>.Permute(list, 0, list.Count-1))
                  yield return sequence;
      }
      protected Permutable(IList<T> list) {
          this.m_List=list;
      }
      IList<T> m_List;
  }
  

• ConsoleHelper (ConsoleHelper.cs)

  using System.Runtime.InteropServices;
  using System.Windows.Forms;
  using System.Drawing;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  public static partial class ConsoleHelper {
      [StructLayout(LayoutKind.Sequential)]
      public struct RECT {
          public static explicit operator Rectangle(RECT rect) {
              return new Rectangle {
                  X=rect.Left,
                  Y=rect.Top,
                  Width=rect.Right-rect.Left,
                  Height=rect.Bottom-rect.Top
              };
          }
          public int Left;
          public int Top;
          public int Right;
          public int Bottom;
      }
      [DllImport("user32.dll", SetLastError=true)]
      static extern bool MoveWindow(IntPtr hWnd, int X, int Y, int Width, int Height, bool repaint);
      [DllImport("user32.dll", SetLastError=true)]
      static extern bool GetWindowRect(IntPtr hWnd, out RECT rect);
      [DllImport("kernel32.dll", SetLastError=true)]
      static extern IntPtr GetConsoleWindow();
      public static void CenterScreen() {
          RECT rect;
          var hWnn=ConsoleHelper.GetConsoleWindow();
          var workingArea=Screen.GetWorkingArea(Point.Empty);
          ConsoleHelper.GetWindowRect(hWnn, out rect);
          var rectangle=(Rectangle)rect;
          rectangle=
             new Rectangle {
                 X=(workingArea.Width-rectangle.Width)/2,
                 Y=(workingArea.Height-rectangle.Height)/2,
                 Width=rectangle.Width,
                 Height=rectangle.Height
             };
          ConsoleHelper.MoveWindow(
              hWnn,
              rectangle.Left, rectangle.Top, rectangle.Width, rectangle.Height,
              true
              );
      }
  }
  

• ConsoleApplication1。程序,排列(Program.cs)

  using System.Collections;
  using System.IO;
  using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Text;
  public partial class Permutation {
      public static Permutation FromFile(String path) {
          return new Permutation(path);
      }
      public static String GetSortedAlphabet(String text) {
          var array=text.ToArray();
          Array.Sort(array);
          return new String(array);
      }
      public Dictionary<String, String> Dictionary {
          private set;
          get;
      }
      public FileInfo SourceFile {
          private set;
          get;
      }
      public Permutation(String path) {
          this.Dictionary=(
              from line in File.ReadAllLines(path)
              where false==String.IsNullOrEmpty(line)
              group line by Permutation.GetSortedAlphabet(line) into g
              select
                  new {
                      Value=String.Join(", ", g.Distinct().ToArray()),
                      Key=g.Key
                  }
              ).ToDictionary(x => x.Key, x => x.Value);
          this.SourceFile=new FileInfo(path);
      }
  }
  namespace ConsoleApplication1 {
      partial class Program {
          static void ProcessLine(IList<char> input) {
              Console.WriteLine();
              if(input.Count>0) {
                  var inputArray=input.ToArray();
                  var key=Permutation.GetSortedAlphabet(new String(inputArray));
                  var dict=Program.Permutation.Dictionary;
                  var hasKey=dict.ContainsKey(key);
                  var source=Permutation.SourceFile;
                  Console.WriteLine("Possible permutations are: ");
                  foreach(var sequence in (Permutable<char>)inputArray)
                      Console.WriteLine("{0}", new String(sequence.ToArray()));
                  Console.WriteLine("Acceptable in file '{0}' are: ", source.FullName);
                  Console.WriteLine("{0}", hasKey?dict[key]:"<none>");
                  Console.WriteLine();
                  input.Clear();
              }
              Console.Write(Prompt);
          }
          static void ProcessChar(IList<char> input, char keyChar) {
              Console.Write(keyChar);
              input.Add(keyChar);
          }
          static void ProcessExit(IList<char> input, char keyChar) {
              Console.WriteLine();
              Console.Write("Are you sure to exit? (Press Esc again to exit)");
              input.Add(keyChar);
          }
          static bool ProcessLast(IList<char> input, char keyChar) {
              var last=input.Count-1;
              if(0>last||input[last]!=(char)ConsoleKey.Escape)
                  return false;
              input.Clear();
              return true;
          }
          public static Permutation Permutation {
              private set;
              get;
          }
          public static String Prompt {
              private set;
              get;
          }
      }
      partial class Program {
          static void Main(String[] args) {
              Console.BufferHeight=short.MaxValue-1;
              Console.SetWindowSize(120, 40);
              ConsoleHelper.CenterScreen();
              var input=new List<char>(char.MaxValue);
              Program.Permutation=Permutation.FromFile(@"c:'dictionary.txt");
              Program.Prompt="User>'x20";
              Program.ProcessLine(input);
              for(; ; ) {
                  var keyInfo=Console.ReadKey(true);
                  var keyChar=keyInfo.KeyChar;
                  var keyCode=keyInfo.Key;
                  if(ConsoleKey.Escape==keyCode) {
                      if(Program.ProcessLast(input, keyChar))
                          break;
                      Program.ProcessExit(input, keyChar);
                      continue;
                  }
                  if(ConsoleKey.Enter==keyCode) {
                      Program.ProcessLine(input);
                      continue;
                  }
                  if(default(ConsoleModifiers)!=keyInfo.Modifiers)
                      continue;
                  if(0x1f>keyChar||keyChar>0x7f)
                      continue;
                  if(Program.ProcessLast(input, keyChar))
                      Console.WriteLine();
                  Program.ProcessChar(input, keyChar);
              }
          }
      }
  }
  

ConsoleHelper类仅用于调整您的控制台窗口大小，以便您可以更舒适地测试程序。Permutable课程是我从你原来的课程中完全重新设计的;它现在有IEnumerable来排列，也是一个泛型类。

Permutation类，就像一个实用程序类，它本身提供了一个FromFile方法作为你原来的Read，并存储Dictionary<String, String>作为一个属性。原来的方法Alphabet被重命名为GetSortedAlphabet以获得更多的语义。

Program类有四个主要的静态ProcessXXX方法，它们是

• ProcessChar: char范围从0x20到0x7f的进程
• ProcessLine: Enter的进程按
• processsexit: Excape的进程按
• ProcessLast: ProcessLine和ProcessExit的附加处理

是的，我的意思是使它们具有相同长度的名称。更多地，Program类有两个静态属性;Permutation用于存储类Permutation的实例，Prompt是一个字符串，用于提示用户。

当您的输入没有在"c:'dictionary.txt"中定义时，"Acceptable in file .."的提示符将显示"<none>"。

退出命令是按两次escape键，你会看到

您确定要退出吗?(再次按Esc退出)

，如果您按下Enter或其他键，它将返回到初始状态。

。现在是时候发现你遇到的最后一个问题了。在你用这个程序测试之后，你可能会更清楚地描述你的问题和问题。

祝你好运!

感谢您的反馈。我终于弄明白了，找到了解决我遇到的问题的方法。静态void Main(string[] args)｛控制台。BufferHeight = Int16。

        Console.WindowHeight = 40;
        Console.WindowWidth = 120;
        Console.WriteLine("Enter your caracters for the anagram: ");
        //var d = Read();
        string line;
        //string DictionaryInput = System.IO.File.ReadAllText("Dictionary.txt");
        while ((line = Console.ReadLine()) != null)
        {
            Console.WriteLine("Your results are: ");
            char[] charArray = line.ToArray();
            //Show(d, line);                    //Using this to check that words found are the correct words in the dictionary.
            setper(charArray);
            Console.WriteLine("-----------------------------------------DONE-----------------------------------------");
            Console.WriteLine("Enter your caracters for the anagram: ");
            File.Delete("Permutations.txt");
        }
    }

    static void swap(ref char a, ref char b)
    {
        if (a == b) return;
        a ^= b;
        b ^= a;
        a ^= b;
    }
    static void setper(char[] list)
    {
        int x = list.Length - 1;
        permuteWords(list, 0, x);
    }
    static void permuteWords(char[] list1, int k, int m)
    {
        if (k == m)
        {
            StreamWriter sw = new StreamWriter("Permutations.txt", true);
            sw.WriteLine(list1);
            sw.Close();
            Regex permutationPattern = new Regex(new string(list1));
            string[] permutations = File.ReadAllLines("Permutations.txt");
            Regex pattern = new Regex(new string(list1));
            string[] lines = File.ReadAllLines("Dictionary.txt");
            foreach (string line in lines)
            {
                var matches = pattern.Matches(line);
                if (pattern.ToString() == line)
                {
                    Console.WriteLine(line);
                }
            }
        }
        else
        {
            for (int i = k; i <= m; i++)
            {
                swap(ref list1[k], ref list1[i]);
                permuteWords(list1, k + 1, m);
                swap(ref list1[k], ref list1[i]);
            }
        }

    }