Einfache Möglichkeit zur Suche nach einem string für Zeichenketten

Sollten Sie definieren, wenn Sie wollen, um zu finden, gleich Saiten, oder suchen Sie einen passenden Teilstring. Beide Wege sind leicht pre-LINQ und LINQ.

string myName = "rahkim";
string[] names = new string[] { "joe", "bob", "chris" };

Gleich Zeichenfolgen, LINQ

bool contains = names.Contains(myName);

Gleich Zeichenfolgen, Pre-LINQ

bool contains = new List<string>(name).Contains(myName);

Teilstrings, LINQ

bool contains = names.Any(name => name.Contains(myName));

Substring, Pre-LINQ

bool contains = false;
foreach(string name in names)
  if (name.Contains(myName))
    contains = true;

InformationsquelleAutor Samuel

int IndexOfAny(String[] rgs) wäre in der Tat schön, aber es ist nominell ein O(n^2) - operation. Wenn Sie in Ihrer Anwendung den Satz von Saiten rgs ist groß und immer die gleichen, die die meisten effizienter Ansatz ist, laden Sie Sie in ein trie Datenstruktur einmal, und verwenden Sie dann die versuche wiederholt, um die Suche für Sie innerhalb der unbekannte angegebenen Zeichenfolgen zur Laufzeit.

Hier ist der relevante code, angepasst von einem C# - trie-Quelle, die ich im web gefunden, zurückzuführen auf "Kerry D. Wong." In meiner version, jede Zeichenfolge im trie hat eine "Nutzlast" von generischen Typ TValue. Dies zu nutzen versuchten, um einfach die Suche nach Teilzeichenfolgen ist, werden die Nutzdaten könnten immer auf wahr, wie abgebildet, mit simple_trie.

Die andere Sache, die ich geändert habe ist, dass diese versuchten passt sich automatisch erlauben, speichern Sie beliebige Unicode-Zeichenfolgen. Das array an jedem Knoten—was charakterisiert eine trie—passt seine Basis und Länge, um Platz für die Auswahl von Unicode-Zeichen, die gespeichert werden müssen in diesem Knoten. Dies ermöglicht eine case-sensitive matching, zum Beispiel.

C# - 3.0-Initialisierung syntax ist praktisch für die dies versuchten, aber die Aktivierung erfordert es eine dummy-Implementierung von IEnumerable, um zu kompilieren. Die CLR-scheint nicht zu nennen GetEnumerator() und ich schlage vor, dass Sie nicht versuchen, aufzuzählen, mit deren Ergebnis entweder.

using System;
using System.Collections.Generic;
using System.Linq;  //only used in Main()

class Program
{
    //trie with payload of type <String>
    static Trie<String> value_trie = new Trie<String>
    {
        { "rabbit", "cute" },
        { "giraffe", "tall" },
        { "ape", "smart" },
        { "hippo", "large" },
    };

    //degenerate case of a trie without payload
    static Trie<bool> simple_trie = new Trie<bool>
    {
        { "rabbit", true },
        { "giraffe", true },
        { "ape", true },
        { "hippo", true },
    };

    static void Main(String[] args)
    {
        String s = "Once upon a time, a rabbit met an ape in the woods.";

        //Retrieve payloads for words in the string.
        //
        //output:
        //     cute
        //     smart
        foreach (String word in value_trie.AllSubstringValues(s))
            Console.WriteLine(word);

        //Simply test a string for any of the words in the trie.
        //Note that the Any() operator ensures that the input is no longer
        //traversed once a single result is found.
        //
        //output:
        //     True
        Console.WriteLine(simple_trie.AllSubstringValues(s).Any(e=>e));

        s = "Four score and seven years ago.";
        //output:
        //     False
        Console.WriteLine(simple_trie.AllSubstringValues(s).Any(e => e));
    }
}

class TrieNode<TValue>
{
    private TrieNode<TValue>[] nodes = null;
    private TValue m_value = default(TValue);
    private Char m_base;

    public Char Base { get { return m_base; } }
    public bool IsEnd { get { return !m_value.Equals(default(TValue)); } }

    public TValue Value
    {
        get { return m_value; }
        set { m_value = value; }
    }

    public IEnumerable<TrieNode<TValue>> Nodes { get { return nodes; } }

    public TrieNode<TValue> this[char c]
    {
        get
        {
            if (nodes != null && m_base <= c && c < m_base + nodes.Length)
                return nodes[c - m_base];
            return null;
        }
    }

    public TrieNode<TValue> AddChild(char c)
    {
        if (nodes == null)
        {
            m_base = c;
            nodes = new TrieNode<TValue>[1];
        }
        else if (c >= m_base + nodes.Length)
        {
            Array.Resize(ref nodes, c - m_base + 1);
        }
        else if (c < m_base)
        {
            Char c_new = (Char)(m_base - c);
            TrieNode<TValue>[] tmp = new TrieNode<TValue>[nodes.Length + c_new];
            nodes.CopyTo(tmp, c_new);
            m_base = c;
            nodes = tmp;
        }

        TrieNode<TValue> node = nodes[c - m_base];
        if (node == null)
        {
            node = new TrieNode<TValue>();
            nodes[c - m_base] = node;
        }
        return node;
    }
};

class Trie<TValue> : System.Collections.IEnumerable
{
    private TrieNode<TValue> _root = new TrieNode<TValue>();

    //This dummy enables C# 3.0 initialization syntax
    public System.Collections.IEnumerator GetEnumerator()
    {
        return null;
    }

    public void Add(String s, TValue v)
    {
        TrieNode<TValue> node = _root;
        foreach (Char c in s)
            node = node.AddChild(c);

        node.Value = v;
    }

    public bool Contains(String s)
    {
        TrieNode<TValue> node = _root;
        foreach (Char c in s)
        {
            node = node[c];
            if (node == null)
                return false;
        }
        return node.IsEnd;
    }

    public TValue Find(String s_in)
    {
        TrieNode<TValue> node = _root;
        foreach (Char c in s_in)
        {
            node = node[c];
            if (node == null)
                return default(TValue);
        }
        return node.Value;
    }

    public IEnumerable<TValue> FindAll(String s_in)
    {
        TrieNode<TValue> node = _root;
        foreach (Char c in s_in)
        {
            node = node[c];
            if (node == null)
                break;
            if (node.Value != null)
                yield return node.Value;
        }
    }

    public IEnumerable<TValue> AllSubstringValues(String s)
    {
        int i_cur = 0;
        while (i_cur < s.Length)
        {
            TrieNode<TValue> node = _root;
            int i = i_cur;
            while (i < s.Length)
            {
                node = node[s[i]];
                if (node == null)
                    break;
                if (node.Value != null)
                    yield return node.Value;
                i++;
            }
            i_cur++;
        }
    }
};

InformationsquelleAutor Glenn Slayden

if (names.Contains(myName)) 
{
//success code//
}

InformationsquelleAutor TStamper