DailyProgrammer 284：流浪的手指

#1 楼

foreach(var input in inputs)
{

var acceptable = reduce(words, inp);
foreach (int i in acceptable)
{

foreach(var wordIndex in GetCandidateWordIndicies(words, input))
{

int count = 0;
foreach(string word in list)
{
    // stuff
    count++;
}

#2 楼

string path = "C:\Users\px06\...";

#3 楼

var words = File.ReadAllLines(path);
var wordLookup = words.Where(word => word.Length >= 5)
                      .GroupBy(word => word[0])
                      .ToDictionary(group => group.Key, group => group.ToLookup(w => w[w.Length - 1]));

private static IEnumerable<string> GetCandidateWords(string input, Dictionary<char, ILookup<char, string>> candidateLookup)
{
    var firstChar = input[0];
    var lastChar = input[input.Length - 1];
    var maxLength = input.Length;
    return candidateLookup[firstChar][lastChar].Where(w => w.Length <= maxLength);
}

public static IEnumerable<string> GetValidWords(this string input, Dictionary<char, ILookup<char, string>> candidateLookup)
{
    var candidateWords = GetCandidateWords(input, candidateLookup);
    return candidateWords.Where(candidate => ValidateCandidateWord(input, candidate));
}

private static bool ValidateCandidateWord(string input, string word)
{
    int searchFrom = 0;
    foreach(var c in word)
    {
        var currentIndex = input.IndexOf(c, searchFrom);
        if(currentIndex == -1)
        {
            return false;
        }
        searchFrom = currentIndex + 1;
    }

    return true;
}

public static class StringSwipeExtentions
{
    private static IEnumerable<string> GetCandidateWords(string input, Dictionary<char, ILookup<char, string>> candidateLookup)
    {
        var firstChar = input[0];
        var lastChar = input[input.Length - 1];
        var maxLength = input.Length;
        return candidateLookup[firstChar][lastChar].Where(w => w.Length <= maxLength);
    }

    public static IEnumerable<string> GetValidWords(this string input, Dictionary<char, ILookup<char, string>> candidateLookup)
    {
        var candidateWords = GetCandidateWords(input, candidateLookup);
        return candidateWords.Where(candidate => ValidateCandidateWord(input, candidate));
    }

    private static bool ValidateCandidateWord(string input, string word)
    {
        int searchFrom = 0;
        foreach(var c in word)
        {
            var currentIndex = input.IndexOf(c, searchFrom);
            if(currentIndex == -1)
            {
                return false;
            }
            searchFrom = currentIndex + 1;
        }

        return true;
    }
}

#4 楼

int minimumWordLength = 5;

HashSet<string> words = new HashSet<string>();
foreach (string line in File.ReadLines(path).Where(p=>p.Length >= minimumWordLength))
{
    words.Add(line);
}

string input = "cghhjkkllooiuytrrdfdftgyuiuytrfdsaazzseertyuioppoiuhgfcxxcfvghujiiuytrfddeews";
int minimumWordLength = 5;
string firstChar = input[0].ToString();
string lastChar = input[input.Lenght-1].ToString();

foreach (string line in File.ReadLines(path)
                            .Where(p=>p.Length >= minimumWordLength)
                            .Where(p=>p.StartsWith(firstChar) && p.EndsWith(lastChar)))
{
    words.Add(line);
}

#5 楼

  // Changed to static because it implements an extension to IEnumerable<string>
  static class Program
  {
    // use @ to get rid of the \ as another commentor explained
    static string path = @"C:\Users\px06\Documents\Visual Studio 2015\Projects\swipe\swipe\words.txt";

    static void Main(string[] args)
    {
      string[] input = { "cghhjkkllooiuytrrdfdftgyuiuytrfdsaazzseertyuioppoiuhgfcxxcfvghujiiuytrfddeews" };

      string[] words = File.ReadAllLines(path);

      var watch = System.Diagnostics.Stopwatch.StartNew();

      foreach (string inp in input)
      {
        foreach (var validWord in words.Filter(inp))
        {
          Console.WriteLine(validWord);
        }
      }

      watch.Stop();
      Console.WriteLine("Run time(ms): " + watch.ElapsedMilliseconds);
      Console.ReadLine();
    }

    // This is combining reduce() and check() in one iteration
    static IEnumerable<string> Filter(this IEnumerable<string> words, string input)
    {
      foreach (string word in words)
      {
        // calling check() at the same time
        if (word.Length >= 5 && input[0] == word[0] && input[input.Length - 1] == word[word.Length - 1] && check(word, input))
        {
          yield return word;
        }
      }
    }

    static bool check(string word, string input)
    {
      int charcheck = 0;

      foreach (char c in word)
      {
        charcheck = input.IndexOf(c, charcheck);
        if (charcheck == -1)
        {
          return false;
        }
      }
      return true;
    }
  }

  // Changed to static because it implements an extension to IEnumerable<string>
  static class Program
  {
    // use @ to get rid of the \ as another commentor explained
    static string path = @"C:\Users\px06\Documents\Visual Studio 2015\Projects\swipe\swipe\words.txt";

    static void Main(string[] args)
    {
      string[] input = { "cghhjkkllooiuytrrdfdftgyuiuytrfdsaazzseertyuioppoiuhgfcxxcfvghujiiuytrfddeews" };

      string[] words = File.ReadAllLines(path);

      var watch = System.Diagnostics.Stopwatch.StartNew();

      foreach (string inp in input)
      {
        foreach (var validWord in words.Where(word => word.Length >= 5 && inp[0] == word[0] && inp[inp.Length - 1] == word[word.Length - 1] && check(word, inp)))
        {
          Console.WriteLine(validWord);
        }
      }

      watch.Stop();
      Console.WriteLine("Run time(ms): " + watch.ElapsedMilliseconds);
      Console.ReadLine();
    }

    static bool check(string word, string input)
    {
      int charcheck = 0;

      foreach (char c in word)
      {
        charcheck = input.IndexOf(c, charcheck);
        if (charcheck == -1)
        {
          return false;
        }
      }
      return true;
    }
  }

  // Changed to static because it implements an extension to IEnumerable<string>
  static class Program
  {
    // use @ to get rid of the \ as another commentor explained
    static string path = @"C:\Users\px06\Documents\Visual Studio 2015\Projects\swipe\swipe\words.txt";

    static void Main(string[] args)
    {
      string[] input = { "cghhjkkllooiuytrrdfdftgyuiuytrfdsaazzseertyuioppoiuhgfcxxcfvghujiiuytrfddeews", "ardidtrwekfsisuklms" };
      var words = File.ReadAllLines(path).GroupBy(str => str[0]).ToDictionary(gr => gr.Key);

      var watch = System.Diagnostics.Stopwatch.StartNew();

      foreach (string inp in input)
      {
        foreach (var validWord in words[inp[0]].Where(word => word.Length >= 5 && inp[0] == word[0] && inp[inp.Length - 1] == word[word.Length - 1] && check(word, inp)))
        {
          Console.WriteLine(validWord);
        }

        Console.WriteLine();
      }

      watch.Stop();
      Console.WriteLine("Run time(ms): " + watch.ElapsedMilliseconds);
      Console.ReadLine();
    }

    static bool check(string word, string input)
    {
      int charcheck = 0;

      foreach (char c in word)
      {
        charcheck = input.IndexOf(c, charcheck);
        if (charcheck == -1)
        {
          return false;
        }
      }
      return true;
    }
  }

#6 楼

{
    static void Main(string[] args)
    {
        string wordToMatch = "cghhjkkllooiuytrrdfdftgyuiuytrfdsaazzseertyuioppoiuhgfcxxcfvghujiiuytrfddeews";
        Stopwatch sw = new Stopwatch();
        sw.Start();
        List<string> wordMatches = WordMatches(wordToMatch); /*quen*/
        sw.Stop();
        //foreach (string s in wordMatches)
        //    Console.WriteLine(s);
        Console.WriteLine(string.Join(", ", wordMatches));
        Console.WriteLine("milliseconds first pass is high as has to build dictionary");
        Console.WriteLine("milliseconds  me " + sw.ElapsedMilliseconds.ToString() + Environment.NewLine);
        Console.ReadLine();
    }
    private static Dictionary<Int32, List<MajicWord>> wordSet;
    public static List<string> WordMatches(string input)
    {
        if (wordSet == null)
        {
            wordSet = new Dictionary<Int32, List<MajicWord>>();
            try
            {   // Open the text file using a stream reader.
                string line;
                using (StreamReader sr = new StreamReader(@"words.txt"))
                {
                    while ((line = sr.ReadLine()) != null)
                    {
                        if (line.Length < 5)
                            continue;
                        //Debug.WriteLine(line);
                        MajicWord mw = new MajicWord(line);
                        if (!wordSet.ContainsKey(mw.GetHashCode()))
                            wordSet.Add(mw.GetHashCode(), new List<MajicWord>());
                        wordSet[mw.GetHashCode()].Add(mw);
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine("The file could not be read:");
                Console.WriteLine(e.Message);
            }
            //foreach (List<MajicWord> lmw in wordSet.Values)
            //    Debug.WriteLine(lmw.Count.ToString());
            Debug.WriteLine("end ctro");
        }
        Stopwatch sw = new Stopwatch();
        sw.Start();
        List<string> wordMatches = new List<string>();
        MajicWord wtm = new MajicWord(input);
        List<MajicWord> candidates = wordSet[wtm.GetHashCode()];
        IEnumerable<MajicWord> matches = candidates.Where(x => x.IsMatchOrder(wtm));
        foreach (MajicWord mw in matches.OrderBy(x => x.Word))
            wordMatches.Add(mw.Word);
        sw.Stop();
        Console.WriteLine("milliseconds WordMatches " + sw.ElapsedMilliseconds.ToString() + Environment.NewLine);
        return wordMatches;
    }
}

public class MajicWord
{
    public override bool Equals(Object obj)
    {
        if (!(obj is MajicWord)) return false;

        MajicWord mw = (MajicWord)obj;
        return (string.Compare(mw.Word, this.Word, true) == 0);
    }
    public override int GetHashCode()
    {
        return (int)CharFirst * 17 ^ (int)CharLast;
        //((int)CharFirst - 97)*26 + (int)CharLast - 97; this hashes better for a-z
    }
    public bool IsMatch(MajicWord mwm)
    {
        if (mwm.GetHashCode() != this.GetHashCode())
            return false;
        return (this.MiddleHash).IsSubsetOf(mwm.MiddleHash);
    }
    public bool IsMatchOrder(MajicWord mwm)
    {
        //if (!IsMatch(mwm))  // this slowed it down
        //    return false;

        if (mwm.GetHashCode() != this.GetHashCode())
            return false;

        if (this.Word.Length > mwm.Word.Length)
            return false;

        int charcheck = 0;
        foreach (char c in this.WordMiddle)
        {
            charcheck = mwm.WordMiddle.IndexOf(c, charcheck);
            if (charcheck == -1)
            {
                return false;
            }
        }
        return true;
    }
    public string Word { get; private set; }
    private string wordMiddle = null;
    public string WordMiddle
    {
        get
        {
            if(wordMiddle == null)
            {
                StringBuilder sb = new StringBuilder();
                for (int i = 1; i < Word.Length - 1; i++)
                    sb.Append(Word[i]);
                wordMiddle = sb.ToString();
            }
            return wordMiddle;
        }
    }
    public char CharFirst { get; private set; }
    public char CharLast { get; private set; }
    HashSet<char> middleHash = null;
    public HashSet<char> MiddleHash
    {   
        get
        {
            if(middleHash == null)
            {
                middleHash = new HashSet<char>();
                for (int i = 1; i < Word.Length - 1; i++)
                    middleHash.Add(Word[i]);
            }
            return middleHash;
        }
    }
    public MajicWord(string word)
    {
        if (word.Length < 2)
            throw new IndexOutOfRangeException();
        Word = word.ToLower();
        CharFirst = Word[0];
        CharLast = Word[Word.Length-1];
    }
}