मैं अपने ट्राई को और अधिक कुशल कैसे बना सकता हूं?

Question

मैं हैकर रैंक समस्या पर काम कर रहा हूं और मानता है मेरा समाधान सही है। हालांकि, मेरे अधिकांश परीक्षण मामलों का समय समाप्त हो रहा है। क्या कोई सुझाव दे सकता है कि मेरे कोड की दक्षता में सुधार कैसे किया जाए?

कोड का महत्वपूर्ण हिस्सा "ट्री क्लास" से शुरू होता है।

सही प्रश्न का यहां पाया जा सकता: https://www.hackerrank.com/challenges/contacts

using System; 
using System.Collections.Generic; 
using System.IO; 
class Solution 
{ 
    static void Main(String[] args) 
    { 
     int N = Int32.Parse(Console.ReadLine()); 
     string[,] argList = new string[N, 2]; 
     for (int i = 0; i < N; i++) 
     { 
      string[] s = Console.ReadLine().Split(); 
      argList[i, 0] = s[0]; 
      argList[i, 1] = s[1]; 
     } 

     Trie trie = new Trie(); 

     for (int i = 0; i < N; i++) 
     { 
      switch (argList[i, 0]) 
      { 
       case "add": 
        trie.add(argList[i, 1]); 
        break; 
       case "find": 
        Console.WriteLine(trie.find(argList[i, 1])); 
        break; 
       default: 
        break; 
      } 
     } 
    } 
} 

class Trie 
{ 
    Trie[] trieArray = new Trie[26]; 
    private int findCount = 0; 
    private bool data = false; 
    private char name; 

    public void add(string s) 
    { 
     s = s.ToLower(); 
     add(s, this); 
    } 

    private void add(string s, Trie t) 
    { 
     char first = Char.Parse(s.Substring(0, 1)); 
     int index = first - 'a'; 

     if(t.trieArray[index] == null) 
     { 
      t.trieArray[index] = new Trie(); 
      t.trieArray[index].name = first; 
     } 

     if (s.Length > 1) 
     { 
      add(s.Substring(1), t.trieArray[index]); 
     } 
     else 
     { 
      t.trieArray[index].data = true; 
     } 
    } 

    public int find(string s) 
    { 
     int ans; 
     s = s.ToLower(); 
     find(s, this); 

     ans = findCount; 
     findCount = 0; 
     return ans; 
    } 

    private void find(string s, Trie t) 
    { 
     if (t == null) 
     { 
      return; 
     } 
     if (s.Length > 0) 
     { 
      char first = Char.Parse(s.Substring(0, 1)); 
      int index = first - 'a'; 
      find(s.Substring(1), t.trieArray[index]); 
     } 
     else 
     { 
      for(int i = 0; i < 26; i++) 
      { 
       if (t.trieArray[i] != null) 
       { 
        find("", t.trieArray[i]); 
       } 
      } 

      if (t.data == true) 
      { 
       findCount++; 
      } 
     } 
    } 

} 

संपादित करें: मैं टिप्पणी में कुछ सुझाव दिए गए थे, लेकिन एहसास हुआ कि मैं (1) के साथ s.Substring को बदल नहीं सकते [0] ... क्योंकि मुझे वास्तव में एस [1. एनएन] की जरूरत है। और एस [0] एक char लौटाता है इसलिए मुझे करने की आवश्यकता होगी। वैसे भी इसे चालू करना।

इसके अलावा, थोड़ा और जानकारी जोड़ने के लिए। विचार यह है कि उदाहरण के लिए उपसर्ग के बाद इसे सभी नामों की गणना करने की आवश्यकता है।

Input: "He" 
Trie Contains: 
"Hello" 
"Help" 
"Heart" 
"Ha" 
"No" 
Output: 3 

Answer 1

मैं सिर्फ एक समाधान पोस्ट कर सकता हूं जो आपको 40 अंक देता है लेकिन मुझे लगता है कि यह कोई मजेदार नहीं होगा। गणनाकार < चार की

• उपयोग करें किसी भी स्ट्रिंग आपरेशन के बजाय >
• गणना करते हुए मूल्यों
• किसी भी चरित्र शून्य से 'एक' एक अच्छा arrayindex बनाता जोड़ने

(आप 0 और 25 के बीच मूल्यों देता है)

Answer 2

मुझे लगता है, this link बहुत मददगार होना चाहिए

वहां, आप एक त्रि डेटा संरचना का अच्छा कार्यान्वयन पा सकते हैं, लेकिन यह एक जावा कार्यान्वयन है। मैंने एक साल पहले उस महान लेख के साथ सी # पर त्रिभुज लागू किया था, और मैंने एक और हैकरैंक कार्य को हल करने का प्रयास किया) यह सफल रहा।

मेरे काम में, मैं एक ही था बस trie (मेरा मतलब मेरी वर्णमाला 2 के बराबर होती है) नई नोड्स जोड़ने के लिए और केवल एक ही विधि:

public class Trie 
{ 
    //for integer representation in binary system 2^32 
    public static readonly int MaxLengthOfBits = 32; 
    //alphabet trie size 
    public static readonly int N = 2; 

    class Node 
    { 
     public Node[] next = new Node[Trie.N]; 
    } 

    private Node _root; 
} 

public void AddValue(bool[] binaryNumber) 
{ 
    _root = AddValue(_root, binaryNumber, 0); 
} 

private Node AddValue(Node node, bool[] val, int d) 
{ 
    if (node == null) node = new Node(); 

    //if least sagnificient bit has been added 
    //need return 
    if (d == val.Length) 
    { 
     return node; 
    } 

    // get 0 or 1 index of next array(length 2) 
    int index = Convert.ToInt32(val[d]); 
    node.next[index] = AddValue(node.next[index], val, ++d); 
    return node; 
}