c# - 文字の順列がテキストファイルに含まれているかどうかを確認します

Question

簡単な質問。私は、アプリケーションに入力した一連の文字のすべての順列を見つけるプログラムを書いています。この部分は完全に機能します。私の問題は、辞書として使用するテキストファイルに対して文字のすべての順列をチェックする必要があることです。元。TSTEの文字を入力すると、出力givinはtset、ttse、ttes、tets、test、stte、stet、sett ... tset、sett、stet、test、tetsなどの有効な単語のみを出力します。ttse、ttes、stteは印刷されません。

私がこれまでに持っているコードは次のとおりです。私は過去数日間、スカルの端を引っ掻いてきましたが、それを行う方法を見つけることができないようです。私が見逃していることがわかるものがあれば教えてください。

ありがとうございました

static void Main(string[] args)
        {
            Console.BufferHeight = Int16.MaxValue - 1;

            Console.WindowHeight = 40;
            Console.WindowWidth = 120;

            Permute p = new Permute();            
            var d = Read();
            string line;
            string str = System.IO.File.ReadAllText("Dictionary.txt");
            while ((line = Console.ReadLine()) != null)
            {                
                char[] c2 = line.ToArray();                
                p.setper(c2);
                           }
        }
        static Dictionary<string, string> Read()
        {
            var d = new Dictionary<string, string>();
            using (StreamReader sr = new StreamReader("Dictionary.txt"))
            {
                string line;
                while ((line = sr.ReadLine()) != null)
                {
                    string a = Alphabet(line);
                    string v;
                    if (d.TryGetValue(a, out v))
                    {
                        d[a] = v + "," + line;
                    }
                    else
                    {
                        d.Add(a, line);
                    }
                }
            }
            return d;
        }
        static string Alphabet(string s)
        {
            char[] a = s.ToCharArray();
            Array.Sort(a);
            return new string(a);
        }
        static void Show(Dictionary<string, string> d, string w)
        {
            string v;
            if (d.TryGetValue(Alphabet(w), out v))
            {
                Console.WriteLine(v);
            }
            else
            {
                Console.WriteLine("-----------");
            }
        }
    }
    class Permute
    {
        private void swap(ref char a, ref char b)
        {
            if (a == b) return;
            a ^= b;
            b ^= a;
            a ^= b;
        }
        public void setper(char[] list)
        {
            int x = list.Length - 1;
            go(list, 0, x);
        }
        public void go(char[] list1, int k, int m)
        {
            if (k == m)
            {

                Console.WriteLine(list1);
                Console.WriteLine(" ");

            }
            else
            {
                for (int i = k; i <= m; i++)
                {
                    swap(ref list1[k], ref list1[i]);
                    go(list1, k + 1, m);
                    swap(ref list1[k], ref list1[i]);
                }
            }
        }

Answer 1

現状では無理。

可能だから

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

Answer 2

フィードバックをお寄せいただきありがとうございます。私はついにそれを理解し、私が抱えていた問題の解決策を見つけました。static void Main(string[] args) { Console.BufferHeight = Int16.MaxValue - 1;

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


    }

Answer 3

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 }

Answer 4

有効な言葉は別の回答で述べたとおりですが、現在の状態では不可能ですが、コードをかなり明確にしました。

最後に、コードは 3 つの部分に分かれています。Permutable<T>でConsoleHelperありConsoleApplication1.Program、ユーティリティPermutationクラスを備えています。

• Permutable<T> (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 & Permutation (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クラスには 4 つの主な静的ProcessXXXメソッドがあります。

• ProcessChar:からまでcharの範囲のプロセス0x200x7f
• ProcessLine:Enterプレスのプロセス
• ProcessExit:Excape押されたプロセス
• ProcessLast:ProcessLineおよびの追加処理ProcessExit

はい、同じ長さの名前にするつもりでした。さらに、Programクラスには 2 つの静的プロパティがあります。Permutationclass のインスタンスを格納するためのPermutationものPromptで、ユーザーにプロンプ​​トを表示するための文字列です。

入力が で定義されていない場合"c:\dictionary.txt"、 のプロンプトが表示され"Acceptable in file .."ます"<none>"。

終了コマンドは、Escape キーを 2 回押すことです。

終了してもよろしいですか？(終了するにはもう一度 Esc キーを押します)

またはその他のキーを押すEnterと、初期状態に戻ります。

それで全部です。ここで、遭遇した最終的な問題を発見する時が来ました。このプログラムでテストした後、質問や問題をより明確に説明できます。

幸運を！