예제 #1
0
        void _AddToTree(string key, Termin t)
        {
            if (key == null)
            {
                return;
            }
            CharNode nod = this._getRoot(t.Lang, t.Lang.IsUndefined && Pullenti.Morph.LanguageHelper.IsLatin(key));

            for (int i = 0; i < key.Length; i++)
            {
                short ch = (short)key[i];
                if (nod.Children == null)
                {
                    nod.Children = new Dictionary <short, CharNode>();
                }
                CharNode nn;
                if (!nod.Children.TryGetValue(ch, out nn))
                {
                    nod.Children.Add(ch, (nn = new CharNode()));
                }
                nod = nn;
            }
            if (nod.Termins == null)
            {
                nod.Termins = new List <Termin>();
            }
            if (!nod.Termins.Contains(t))
            {
                nod.Termins.Add(t);
            }
        }
예제 #2
0
        void _RemoveFromTree(string key, Termin t)
        {
            if (key == null)
            {
                return;
            }
            CharNode nod = this._getRoot(t.Lang, t.Lang.IsUndefined && Pullenti.Morph.LanguageHelper.IsLatin(key));

            for (int i = 0; i < key.Length; i++)
            {
                short ch = (short)key[i];
                if (nod.Children == null)
                {
                    return;
                }
                CharNode nn;
                if (!nod.Children.TryGetValue(ch, out nn))
                {
                    return;
                }
                nod = nn;
            }
            if (nod.Termins == null)
            {
                return;
            }
            if (nod.Termins.Contains(t))
            {
                nod.Termins.Remove(t);
            }
        }
예제 #3
0
        public CharNode AddChild(char c)
        {
            CharNode child = new CharNode(c);

            children.Add(child);
            return(child);
        }
예제 #4
0
        public void TestContainsInLeftRightSubTree()
        {
            CharNode        root         = ExampleTree;
            List <CharNode> leaves       = new List <CharNode>(root.Leaves);
            List <CharNode> leaf_parents = new List <CharNode>();

            foreach (CharNode n in leaves)
            {
                leaf_parents.Add(n.Parent);
            }
            Assert.IsTrue(root.ContainsInLeftSubTree(leaves[0]));  // 'd'
            Assert.IsFalse(root.ContainsInLeftSubTree(leaves[1])); // 'f'
            Assert.IsFalse(root.ContainsInLeftSubTree(leaves[2])); // 'h'

            Assert.IsTrue(leaf_parents[0].ContainsInLeftSubTree(leaves[0]));
            Assert.IsTrue(leaf_parents[1].ContainsInLeftSubTree(leaves[1]));
            Assert.IsFalse(leaf_parents[1].ContainsInRightSubTree(leaves[1]));
            Assert.IsTrue(leaf_parents[1].ContainsInRightSubTree(leaves[2]));

            // When query node is not part of subtree the method throws an exception
            NUnitExtensions.Assert.Throws(typeof(InvalidOperationException),
                                          delegate { leaf_parents[1].ContainsInRightSubTree(leaves[0]); });

            // When the query node is the same node as the node the query is executed on
            // an exception is thrown
            NUnitExtensions.Assert.Throws(typeof(InvalidOperationException),
                                          delegate { leaf_parents[1].ContainsInRightSubTree(leaf_parents[1]); });
            NUnitExtensions.Assert.Throws(typeof(InvalidOperationException),
                                          delegate { leaf_parents[1].ContainsInLeftSubTree(leaf_parents[1]); });
        }
예제 #5
0
    private void GetWordOccurence(string word, int index, CharNode currentNode, ref int count)
    {
        char currentChar = word[index];
        bool lastChar    = false;

        if (index == word.Length - 1)
        {
            lastChar = true;
        }
        foreach (var node in currentNode.Children)
        {
            if (node.Letter == currentChar)
            {
                if (lastChar)
                {
                    // If this is the last char of the string, set the count
                    count = node.Count;
                    return;
                }
                else
                {
                    // Go to the next level if there already exists a node with this char at the current one
                    this.GetWordOccurence(word, index + 1, node, ref count);
                    return;
                }
            }
        }

        // If no node with the current char exists at this level in the trie, add it:
        return;
    }
예제 #6
0
    public void Add(string oldStr)
    {
        char _char = oldStr [0];

        if (oldStr.Length == 1)
        {
            if (Dict.ContainsKey(_char))
            {
                return;
            }
            else
            {
                Dict.Add(_char, new CharNode(true));
            }
        }
        else
        {
            if (Dict.ContainsKey(_char))
            {
                oldStr = oldStr.Substring(1, oldStr.Length - 1);
                Dict [_char].Add(oldStr);
            }
            else
            {
                CharNode node = new CharNode(false);
                Dict.Add(_char, node);
                oldStr = oldStr.Substring(1, oldStr.Length - 1);
                node.Add(oldStr);
            }
        }
    }
예제 #7
0
        private Graph <Char> MockGraph()
        {
            var graph = new Graph <Char>();

            var a = new CharNode('A');
            var b = new CharNode('B');
            var c = new CharNode('C');
            var d = new CharNode('D');
            var e = new CharNode('E');
            var g = new CharNode('G');

            graph.AddNode(a);
            graph.AddNode(b);
            graph.AddNode(c);
            graph.AddNode(d);
            graph.AddNode(e);
            graph.AddNode(g);

            graph.AddUndirectedEdge(a, b);
            graph.AddUndirectedEdge(a, e);
            graph.AddUndirectedEdge(b, c);
            graph.AddUndirectedEdge(b, d);
            graph.AddUndirectedEdge(c, d);
            graph.AddUndirectedEdge(c, e);
            graph.AddUndirectedEdge(d, e);

            return(graph);
        }
예제 #8
0
            /// <inheritdoc/>
            public override (Node Head, Node Tail) Insert(Int32 index, Char element)
            {
                Node head;
                Node tail;

                if (index == 0)
                {
                    tail          = this;
                    head          = new CharNode(element, previous: null, next: tail);
                    tail.Previous = head;
                }
                else if (index == Count)
                {
                    head      = this;
                    tail      = new CharNode(element, previous: head, next: null);
                    head.Next = tail;
                }
                else
                {
                    head = Slice(0, index);
                    tail = Slice(index, Count - index);
                    Node mid = new CharNode(element, previous: head, next: tail);
                    head.Next     = mid;
                    tail.Previous = mid;
                }
                return(head, tail);
            }
예제 #9
0
        public void TestLeafVsIntermediateState()
        {
            CharNode root = ExampleTree;

            Assert.IsTrue(root.Intermediate);
            Assert.IsFalse(root.Leaf);
            Assert.AreEqual("dfh", MakeStringFromIteration(root.Leaves));
        }
예제 #10
0
 //potrzebne do niszczenia za sobą ścieżek przy przechodzeniu przez graf
 public void buildVirtualEdges()
 {
     virtualEdgesList = new List <CharNode>();
     foreach (var p in edgesList)
     {
         var tmp = new CharNode(p.key, p.value);
         virtualEdgesList.Add(tmp);
     }
 }
예제 #11
0
        List <Termin> _FindInTree(string key, Pullenti.Morph.MorphLang lang)
        {
            if (key == null)
            {
                return(null);
            }
            CharNode nod = this._getRoot(lang, ((lang == null || lang.IsUndefined)) && Pullenti.Morph.LanguageHelper.IsLatin(key));

            for (int i = 0; i < key.Length; i++)
            {
                short    ch = (short)key[i];
                CharNode nn = null;
                if (nod.Children != null)
                {
                    nod.Children.TryGetValue(ch, out nn);
                }
                if (nn == null)
                {
                    if (ch == 32)
                    {
                        if (nod.Termins != null)
                        {
                            string[]      pp  = key.Split(' ');
                            List <Termin> res = null;
                            foreach (Termin t in nod.Termins)
                            {
                                if (t.Terms.Count == pp.Length)
                                {
                                    int k;
                                    for (k = 1; k < pp.Length; k++)
                                    {
                                        if (!t.Terms[k].Variants.Contains(pp[k]))
                                        {
                                            break;
                                        }
                                    }
                                    if (k >= pp.Length)
                                    {
                                        if (res == null)
                                        {
                                            res = new List <Termin>();
                                        }
                                        res.Add(t);
                                    }
                                }
                            }
                            return(res);
                        }
                    }
                    return(null);
                }
                nod = nn;
            }
            return(nod.Termins);
        }
예제 #12
0
        private CharNode AddNodeChild(CharNode target, char ch)
        {
            if (target.Children == null)
            {
                target.Children = new Dictionary <char, CharNode>();
            }
            CharNode child = new CharNode(ch);

            target.Children.Add(ch, child);
            NodeCount++;
            return(child);
        }
예제 #13
0
        public void TestAncestorTraversal()
        {
            CharNode root = ExampleTree;

            Assert.AreEqual("a", MakeStringFromIteration(root.Ancestors));

            List <CharNode> leaves = new List <CharNode>(root.Leaves);

            Assert.AreEqual("dcba", MakeStringFromIteration(leaves[0].Ancestors));
            Assert.AreEqual("fea", MakeStringFromIteration(leaves[1].Ancestors));
            Assert.AreEqual("hgea", MakeStringFromIteration(leaves[2].Ancestors));
        }
예제 #14
0
 /// <inheritdoc/>
 public override (Node Head, Node Tail) Replace(Char search, Char replace)
 {
     if (Equals(Char, search))
     {
         Node rep = new CharNode(replace, previous: null, next: null);
         return(rep, rep);
     }
     else
     {
         return(this, this);
     }
 }
예제 #15
0
        public void BuildTree(string compressMe)
        {
            foreach (char c in compressMe)
            {
                bool incremented = false;
                foreach (Node c_Nodes in nodes)
                {
                    if (c_Nodes.CompareTo(c) == 1)
                    {
                        incremented = true;
                        c_Nodes.incFreq();
                    }
                }
                if (!incremented)
                {
                    nodes.Add(new Node(c));
                }
            }
            List <Node> charNodes = nodes.OrderBy(node => node.m_Freq).ToList <Node>();

            treeInfos = "";
            while (nodes.Count > 1)
            {
                List <Node> orgNodes = nodes.OrderBy(node => node.m_Freq).ToList <Node>();


                if (orgNodes.Count >= 2)
                {
                    List <Node> twoChildNodes = orgNodes.Take(2).ToList <Node>();

                    Node newDaddyNode = new Node((twoChildNodes[0].getFreq() + twoChildNodes[1].getFreq()));
                    newDaddyNode.setLeftNode(twoChildNodes[0]);
                    newDaddyNode.setRightNode(twoChildNodes[1]);
                    nodes.Remove(twoChildNodes[0]);
                    nodes.Remove(twoChildNodes[1]);
                    nodes.Add(newDaddyNode);
                }
                this.m_Root = nodes.FirstOrDefault();
            }

            foreach (Node CharNode in charNodes)
            {
                List <bool> codedChar = this.m_Root.Traverse(CharNode.getChar(), new List <bool>());


                foreach (bool b in codedChar)
                {
                    treeInfos += Convert.ToInt16(b);
                }
                treeInfos += CharNode.getChar();
            }
        }
예제 #16
0
 public CharNode(int w, string z = "", CharNode left = null, CharNode right = null, string code = "")
 {
     character = z;
     value     = w;
     if (right != null && left != null)
     {
         rightSide = right; leftSide = left;
     }
     if (code != String.Empty)
     {
         codeValue = code;
     }
 }
예제 #17
0
파일: Program.cs 프로젝트: SpinDOS/Contests
        private static bool TryGetReplacement(CharNode tildaNode, out char newChar)
        {
            int x, y;

            if (!IsHex(tildaNode.Next?.Value, out x) || !IsHex(tildaNode.Next.Next?.Value, out y))
            {
                newChar = default(char);
                return(false);
            }

            newChar = char.ToUpper((char)(16 * x + y));
            return(true);
        }
예제 #18
0
        /// <summary>
        /// Initializes a new instance of the <see cref="TextMatchHelper"/> class.
        /// </summary>
        /// <param name="matches">The matches to match against.</param>
        /// <exception cref="System.ArgumentNullException"></exception>
        public TextMatchHelper(HashSet <string> matches)
        {
            if (matches == null)
            {
                throw new ArgumentNullException(nameof(matches));
            }
            var list = new List <string>(matches);

            root      = new CharNode();
            listCache = new ListCache();
            BuildMap(root, 0, list);
            listCache.Clear();
        }
예제 #19
0
 //[Benchmark]
 public void CharNode()
 {
     foreach (var(t, p) in TestData.TypeNames.Take(1))
     {
         // 追加は1回限り
         var items = p.Select(x => new KeyValuePair <string, string>(x, x));
         var d     = new CharNode <string>();
         foreach (var(key, value) in items)
         {
             d.Add(key, value);
         }
         Bench(items, allKeys.Except(p), d);
     }
 }
        private WeightedGraph <Char> TestCharGraph()
        {
            var graph = new WeightedGraph <Char>();

            var a = new CharNode('A');
            var b = new CharNode('B');

            graph.AddNode(a);
            graph.AddNode(b);

            graph.AddUndirectedEdge(a, b, 10);

            return(graph);
        }
예제 #21
0
            public void AddNode(CharNode node)
            {
                // 是也可以不管順序直接 add 到尾端就好,反正 rol col 的索引都已經有了
                // 假如要轉成二維陣列存的話,也可以找出需要的rold col 數,
                // 填入陣列後,再掃一次陣列,把字元挑出來就好
                // 只是目前是希望可以省空間複雜度,從 n^2 變成 n

                //Console.WriteLine("Add [ {0}, {1} ] = {2}", node.RowIndex, node.ColIndex, node.Character);

                CharNode current = this;

                // 假如是 head,先 next(一開始 head 是空的情況,第一次 add 跑 while 迴圈就會失敗)
                // if (current.Character == '\0')
                // {
                //     current = current.Next;
                // }

                while (current.Next != null)
                {
                    // 遇到同 row
                    if (node.RowIndex == current.RowIndex)
                    {
                        // 找出同 row 中,正確的 col 位置
                        while (node.ColIndex > current.ColIndex &&
                               node.RowIndex == current.RowIndex &&
                               current.Next != null)
                        {
                            current = current.Next;
                        }

                        if (node.RowIndex != current.RowIndex)
                        {
                            current.Previous.Next = node;
                            node.Previous         = current.Previous;
                            node.Next             = current;
                            current.Previous      = node;

                            return;
                        }
                    }
                    else
                    {
                        current = current.Next;
                    }
                }
                // 執行到這邊,表示 此 node 就是要接在最尾端
                current.Next  = node;
                node.Previous = current;
            }
예제 #22
0
            private void TraverseNodes <TSelect>(string word, int maxCount, Func <string, string, TSelect, int> evalQuality) where TSelect : T
            {
                while (stack.Count > 0)
                {
                    CharNode current = stack.Pop();
                    if (current.Items != null)
                    {
                        foreach (NodeItem item in current.Items)
                        {
                            if (item.Item is TSelect)
                            {
                                int quality = evalQuality(item.Key, word, (TSelect)item.Item);
                                if (quality > 0)
                                {
                                    Matched match;
                                    bool    exists = matchLookup.TryGetValue(item, out match);

                                    if (unique.Add(item))
                                    {
                                        if (!exists)
                                        {
                                            match.Value = item;
                                            maxCount--;
                                        }
                                        match.Rank       += quality;
                                        matchLookup[item] = match;
                                    }
                                    else if (exists && match.Rank < quality)
                                    {
                                        match.Rank        = quality;
                                        matchLookup[item] = match;
                                    }
                                }
                            }
                            if (maxCount == 0)
                            {
                                return;
                            }
                        }
                    }
                    if (current.Children != null)
                    {
                        foreach (var child in current.Children)
                        {
                            stack.Push(child.Value);
                        }
                    }
                }
            }
예제 #23
0
 private static CharNode GetBestMatchChildNode(CharNode current, string word)
 {
     for (int idx = 0; idx < word.Length; idx++)
     {
         if (current.Children != null && current.Children.TryGetValue(word[idx], out CharNode next))
         {
             current = next;
         }
         else
         {
             break;
         }
     }
     return(current);
 }
예제 #24
0
        private void AddLetters(CharNode currentNode, char letterToAdd, string word, int position)
        {
            currentNode.Add(letterToAdd);
            char letter = letterToAdd;

            position++;

            if (position == word.Length)
            {
                currentNode.Add('|');
                return;
            }
            letterToAdd = word[position];

            AddLetters(currentNode[letter], letterToAdd, word, position);
        }
예제 #25
0
    private void AddChars(string word, int index, CharNode currentNode)
    {
        if (word == string.Empty)
        {
            return;
        }
        char currentChar = word[index];
        bool lastChar    = false;

        if (index == word.Length - 1)
        {
            lastChar = true;
        }

        foreach (var node in currentNode.Children)
        {
            if (node.Letter == currentChar)
            {
                if (lastChar)
                {
                    // If this is the last char of the string, increase the count of this string occurences
                    node.Count++;
                    return;
                }
                else
                {
                    // Go to the next level if there already exists a node with this char at the current one
                    this.AddChars(word, index + 1, node);
                    return;
                }
            }
        }

        // If no node with the current char exists at this level in the trie, add it:
        CharNode newNode = new CharNode(currentChar);

        currentNode.Children.Add(newNode);
        if (!lastChar)
        {
            // If the word is not finished, continue
            this.AddChars(word, index + 1, newNode);
        }
        else
        {
            newNode.Count++;
        }
    }
 public CharNode(char c, List<char> chars)
 {
     //Console.WriteLine("In constructor, array length is: {0}", chars.Count);
     data = c;
     chars.Remove(c);
     if (chars.Count > 1) {
         children = new CharNode[chars.Count];
         for (int i = 0; i < chars.Count; i++) {
             char nextchar = chars[i];
             children[i] = new CharNode(nextchar, chars.ToList<char>());
         }
     }
     else {
         children = new CharNode[1];
         children[0] = new CharNode(chars[0]);
     }
 }
예제 #27
0
    private void AddChars(string word, int index, CharNode currentNode)
    {
        if (word == string.Empty)
        {
            return;
        }
        char currentChar = word[index];
        bool lastChar = false;
        if (index == word.Length - 1)
        {
            lastChar = true;
        }

        foreach (var node in currentNode.Children)
        {
            if (node.Letter == currentChar)
            {
                if (lastChar)
                {
                    // If this is the last char of the string, increase the count of this string occurences
                    node.Count++;
                    return;
                }
                else
                {
                    // Go to the next level if there already exists a node with this char at the current one
                    this.AddChars(word, index + 1, node);
                    return;
                }
            }
        }

        // If no node with the current char exists at this level in the trie, add it:
        CharNode newNode = new CharNode(currentChar);
        currentNode.Children.Add(newNode);
        if (!lastChar)
        {
            // If the word is not finished, continue
            this.AddChars(word, index + 1, newNode);
        }
        else
        {
            newNode.Count++;
        }
    }
        static List<long> buildPermutations()
        {
            char[] chars = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}; //
            List<long> perms = new List<long>();

            List<CharNode> tree = new List<CharNode>();
            foreach (char c in chars) {
                CharNode cn = new CharNode(c, chars.ToList<char>());
                tree.Add(cn);
            }
            foreach (CharNode cn in tree) {
                //Console.WriteLine(cn.getTree().Count);
                foreach (string s in cn.getTree()) {
                    //Console.WriteLine(s);
                    perms.Add(long.Parse(s));
                }
            }
                return perms;
        }
예제 #29
0
        private void FindOccurence(CharNode currentNode, string word, int position, ref int occurences)
        {
            position++;

            if (position == word.Length - 1)
            {
                occurences = currentNode.Occurences;
                return;
            }
            else if (!currentNode.ContainsLetter(word[position]))
            {
                occurences = 0;
                return;
            }
            else
            {
                FindOccurence(currentNode[word[position]], word, position, ref occurences);
            }
        }
예제 #30
0
        private void BuildMap(CharNode node, int index, List <string> list)
        {
            // TODO(lazy): This code for building the nodes is not very efficient in terms of memory usage and could be optimized (using structs and indices)
            // At least, we are using a cache for the temporary objects build (List<string>)
            for (var i = 0; i < list.Count; i++)
            {
                var str = list[i];
                var c   = str[index];

                CharNode nextNode;
                if (!node.TryGetValue(c, out nextNode))
                {
                    nextNode = new CharNode();
                    node.Add(c, nextNode);
                }

                // We have found a string for this node
                if (index + 1 == str.Length)
                {
                    nextNode.Content = str;
                }
                else
                {
                    if (nextNode.NextList == null)
                    {
                        nextNode.NextList = listCache.Get();
                    }

                    nextNode.NextList.Add(str);
                }
            }

            foreach (var charList in node)
            {
                if (charList.Value.NextList != null)
                {
                    BuildMap(charList.Value, index + 1, charList.Value.NextList);
                    listCache.Release(charList.Value.NextList);
                    charList.Value.NextList = null;
                }
            }
        }
예제 #31
0
 public CharNode(char c, List <char> chars)
 {
     //Console.WriteLine("In constructor, array length is: {0}", chars.Count);
     data = c;
     chars.Remove(c);
     if (chars.Count > 1)
     {
         children = new CharNode[chars.Count];
         for (int i = 0; i < chars.Count; i++)
         {
             char nextchar = chars[i];
             children[i] = new CharNode(nextchar, chars.ToList <char>());
         }
     }
     else
     {
         children    = new CharNode[1];
         children[0] = new CharNode(chars[0]);
     }
 }
예제 #32
0
        static bool IsPalindrome(CharLinkedList linkedList)
        {
            StringBuilder sb1     = new StringBuilder();
            StringBuilder sb2     = new StringBuilder();
            CharStack     stack   = new CharStack(new CharLinkedList());
            CharNode      current = linkedList.Head;

            while (current != null)
            {
                char value = current.Value;
                sb1.Append(value);
                stack.Push(value);
                current = current.Next;
            }
            while (!stack.IsEmpty())
            {
                sb2.Append(stack.Pop());
            }
            return(sb1.ToString() == sb2.ToString());
        }
예제 #33
0
        static public void createCode(ref List <CharNode> nodes, string input)
        {
            foreach (char letter in input)
            {
                charsToNodes(letter.ToString(), ref nodes);
            }
            IEnumerable <CharNode> nodeIE = nodes.OrderBy(node => node.value).Reverse();

            while (nodeIE.Count() > 1)
            {
                CharNode left = nodeIE.Last();
                nodeIE = nodeIE.Where(node => node != left).Select(node => node);
                CharNode right = nodeIE.Last();
                nodeIE = nodeIE.Where(node => node != right).Select(node => node);
                nodeIE = nodeIE.Append(new CharNode(left.value + right.value, left: left, right: right));
                nodeIE = nodeIE.OrderBy(node => node.value).Reverse();
            }
            nodeIE.Last().Code();
            nodes.Clear();
            nodeIE.Last().Transfer(ref nodes);
        }
예제 #34
0
        private void FindOccurence(CharNode currentNode, string word, int position, ref int occurences)
        {
            position++;

            if (position == word.Length - 1)
            {
                occurences = currentNode.Occurences;
                return;
            }
            else if (!currentNode.ContainsLetter(word[position]))
            {
                occurences = 0;
                return;
            }
            else
            {
                FindOccurence(currentNode[word[position]], word, position, ref occurences);
            }
        }
예제 #35
0
 public SuffixTrie()
 {
     this.root = new CharNode('$');
 }
예제 #36
0
    private void GetWordOccurence(string word, int index, CharNode currentNode, ref int count)
    {
        char currentChar = word[index];
        bool lastChar = false;
        if (index == word.Length - 1)
        {
            lastChar = true;
        }
        foreach (var node in currentNode.Children)
        {
            if (node.Letter == currentChar)
            {
                if (lastChar)
                {
                    // If this is the last char of the string, set the count
                    count = node.Count;
                    return;
                }
                else
                {
                    // Go to the next level if there already exists a node with this char at the current one
                    this.GetWordOccurence(word, index + 1, node, ref count);
                    return;
                }
            }
        }

        // If no node with the current char exists at this level in the trie, add it:
        return;
    }
예제 #37
0
        private void AddLetters(CharNode currentNode, char letterToAdd, string word, int position)
        {
            currentNode.Add(letterToAdd);
            char letter = letterToAdd;
            position++;

            if (position == word.Length)
            {
                currentNode.Add('|');
                return;
            }
            letterToAdd = word[position];

            AddLetters(currentNode[letter], letterToAdd, word, position);
        }
예제 #38
0
 public CharNode(CharNode rhs)
 {
     Value = rhs.Value;
 }
예제 #39
0
 public CharNode(CharNode rhs)
 {
     value = rhs.value;
 }