C# :: Aufgabe #211

3 Lösungen Lösungen öffentlich

Programmierung eines Anagramm-Generators

Fortgeschrittener - C# von hollst - 31.05.2018 um 14:02 Uhr
Unter einem (vollständigen) Anagramm eines Basiswortes versteht man
sinnvolle Wörter, die aus den gleichen Buchstaben wie
das Basiswort zusammengesetzt sind. Z. B. sind zum Basiswort TOR die Wörter
ROT und ORT Anagramme. Die Folge OTR ist kein Anagramm (kein sinnvolles Wort).

Für den zu programmierenden Anagramm-Generator, der ein Basiswort entgegennehmen
und eine Liste sinnvoller Anagramme ausgeben soll (Bild 1), wird natürlich eine
Liste aller sinnvollen Wörter einer (natürlichen) Sprache benötigt. Mein Vorschlag
ist es, sich den Textfile germany.dic von

https://sourceforge.net/projects/germandict/

herunterzuladen. Er enthält knapp 2.000.000 Einträge "sinnvoller" deutscher Wörter,
darunter auch eines meiner Lieblingswörter:

Rindfleischetikettierungsüberwachungsaufgabenübertragungsgesetz.

Dieses Wort steht in der Tat sogar im Duden, allerdings nur an Stelle zwei der Wurmwörter,
den ersten Platz hat

Grundstücksverkehrsgenehmigungszuständigkeitsübertragungsverordnung.

Ja, aber das nur zum Schmunzeln am Rande. Viel Spaß!

Lösungen:

vote_ok
von Z3RP (440 Punkte) - 04.06.2018 um 11:50 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace AnagrammGenerator
{
    class Program
    {
        static List<String>[] words = new List<String>[1000];
        static void Main(string[] args)
        {
            loadWords();
            Console.Write("Search Anagramm for ?:");
            String word = Console.ReadLine();

            if (words[word.Length] == null)
            {
                Console.WriteLine("No Anagramms in Libary");
            }
            else
            {
                foreach(String s in words[word.Length])
                {
                    if (canBeAnagramm(word.ToLower(), s.ToLower()))
                    {
                        Console.WriteLine(s);
                    }
                }
            }

            Console.ReadKey();
        }

        public static Boolean canBeAnagramm(String s1, String s2)
        {
            var aSet = new HashSet<char>(s1);
            var bSet = new HashSet<char>(s2);
            return aSet.SetEquals(s2);
        }

        public static void loadWords()
        {
            string[] lines = System.IO.File.ReadAllLines(@"C:\Users\npreen.CARGOSOFT\Desktop\german.dic");

            foreach (string line in lines)
            {
                if (words[line.Length] == null)
                    words[line.Length] = new List<String>();

                words[line.Length].Add(line);
            }
        }
    }
}
vote_ok
von daniel59 (3710 Punkte) - 05.06.2018 um 11:29 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.Linq;

namespace ConsoleAnagrannGenerator
{
    class Program
    {
        static readonly string[] dictionary = Properties.Resources.german.Split('\r', '\n').Where(a => !string.IsNullOrWhiteSpace(a)).Select(a => a.ToLower()).Distinct().ToArray();
        static void Main(string[] args)
        {
            Console.WriteLine("----- Anagramm Generator -----");

            do
            {
                Console.Write("Wort eingeben: ");
                string word = Console.ReadLine();

                var anagramms = FindAnagramms(word);
                Console.WriteLine("Folgende Anagramme wurden gefunden:");
                if(anagramms.Count() == 0)
                {
                    Console.WriteLine("Keine Anagramme gefunden");
                }
                else
                {
                    foreach(string s in anagramms)
                    {
                        Console.WriteLine(s);
                    }
                }
                Console.WriteLine();
                Console.Write("Neues Wort eingeben? (J/N): ");
                if(Console.ReadKey().Key != ConsoleKey.J)
                {
                    break;
                }
                else
                {
                    Console.WriteLine();
                }


            } while (true);
        }

        static IEnumerable<string> FindAnagramms(string orig)
        {
            Dictionary<char, int> charCount = new Dictionary<char, int>();

            foreach (char c in orig.ToLower())
            {
                if (!charCount.ContainsKey(c))
                {
                    charCount.Add(c, 0);
                }

                charCount[c]++;
            }


            IEnumerable<string> tempDic = dictionary.Where(a => a.Length == orig.Length);
            foreach (var item in charCount)
            {
                tempDic = tempDic.Where(a => a.Count(b => b == item.Key) == item.Value);
            }

            return tempDic;
        }
    }
}
vote_ok
von DBqFetti (2340 Punkte) - 05.06.2018 um 22:05 Uhr
Quellcode ausblenden C#-Code
using System;
using System.Collections.Generic;
using System.IO;
using System.Reflection;

namespace TYP211 {
  class Program {
    static void Main() {
      Console.WriteLine("Erstelle Index");
      Dictionary<string, List<string>> Index = CreateIndex();
      Console.Clear();

      while(true) {
        Console.Write("Suche>");
        string key = BuildKey(Console.ReadLine());

        if(Index.ContainsKey(key)) {
          Console.WriteLine(string.Join("\n", Index[key]));
        } else {
          Console.WriteLine("Keine Ergebnisse");
        }

        Console.WriteLine();
      }
    }

    static Dictionary<string, List<string>> CreateIndex() {
      Dictionary<string, List<string>> Index = new Dictionary<string, List<string>>();

      Assembly Ass = Assembly.GetExecutingAssembly();

      using(Stream stream = Ass.GetManifestResourceStream("TYP211.resource.german.dic")) {
        using(StreamReader reader = new StreamReader(stream)) {
          while(!reader.EndOfStream) {
            string word = reader.ReadLine().ToUpper();
            string key = BuildKey(word);

            if(Index.ContainsKey(key) && !Index[key].Contains(word)) {
              Index[key].Add(word);
            } else {
              Index[key] = new List<string>() { word };
            }
          }
        }
      }

      return Index;
    }

    static string BuildKey(string word) {
      char[] key = word.ToLower().ToCharArray();
      Array.Sort(key);

      return new string(key);
    }
  }
}