मुझे यह पता लगाना है कि एक * कहाँ है जब यह बिल्कुल भी नहीं हो सकता है, पहली स्थिति | दूसरा स्थान | तीसरा स्थान।

पदों को पाइप द्वारा अलग किया जाता है |
इस प्रकार

नहीं *वाइल्डकार्ड होगा

`ABC|DEF|GHI` 

हालाँकि, जबकि यह १ परिदृश्य हो सकता है, अन्य ३ हैं

    string testPosition1 = "*|DEF|GHI";
    string testPosition2 = "ABC|*|GHI";
    string testPosition3 = "ABC|DEF|*";

मैं इंडेक्सऑफ का उपयोग करने की तुलना में इकट्ठा करता हूं, लेकिन ऐसा लगता है कि मुझे शामिल करना चाहिए | (पाइप) स्थिति जानने के लिए (न केवल लंबाई के रूप में मान 3 स्थानों में से प्रत्येक में लंबा या छोटा हो सकता है। इसलिए मैं सिर्फ यह जानना चाहता हूं कि क्या * पहले, दूसरे या तीसरे स्थान पर है (या बिल्कुल नहीं) )

इस प्रकार मैं यह कर रहा था लेकिन मुझे यह पता नहीं चल रहा है कि यह पहली या दूसरी पाइप से पहले है या नहीं

if(testPosition1.IndexOf("*") > 0) 
{
    // Look for pipes?  
}
1
Jeremy Miller 15 सितंबर 2020, 00:18

5 जवाब

सबसे बढ़िया उत्तर

ऐसे कई तरीके हैं जिनसे आप इस तक पहुंच सकते हैं। सबसे पठनीय वास्तव में इसे कठिन तरीके से करना हो सकता है (अर्थात पहले '*' वर्ण को खोजने के लिए स्ट्रिंग को स्कैन करें, यह ट्रैक करते हुए कि आप रास्ते में कितने '|' वर्ण देखते हैं)।

उस ने कहा, यह एक समान रूप से पठनीय और अधिक संक्षिप्त हो सकता है:

int wildcardPosition = Array.IndexOf(testPosition1.Split('|'), "*");

नहीं मिलने पर -1 लौटाता है, अन्यथा 0-आधारित अनुक्रमणिका जिसके लिए '|' सीमांकित स्ट्रिंग में वाइल्डकार्ड स्ट्रिंग है।

यह केवल तभी काम करता है जब वाइल्डकार्ड बिल्कुल एक-वर्ण वाली स्ट्रिंग "*" हो। यदि आपको उस पर अन्य विविधताओं का समर्थन करने की आवश्यकता है, तो भी आप स्ट्रिंग को विभाजित करना चाहेंगे, लेकिन फिर आप सरणी पर लूप कर सकते हैं जो आपको चाहिए।

3
Peter Duniho 15 सितंबर 2020, 00:27

आप पाइप वर्ण पर स्ट्रिंग को विभाजित करने वाले linq के साथ प्रयास कर सकते हैं और फिर उस तत्व की अनुक्रमणिका प्राप्त कर सकते हैं जिसमें केवल एक *

var x = testPosition2.Split('|').Select((k, i) => new { text = k, index = i}).FirstOrDefault(p => p.text == "*" );
if(x != null) Console.WriteLine(x.index);

तो पहली पंक्ति तार की एक सरणी बनाने वाले पाइप पर स्ट्रिंग को विभाजित करना शुरू कर देती है। यह अनुक्रम चयन एक्सटेंशन को पास किया जाता है जो स्ट्रिंग टेक्स्ट (के) और इंडेक्स (i) को पास करने वाले अनुक्रम की गणना करता है। इन दो मापदंडों के साथ हम दो गुणों (पाठ और सूचकांक) के साथ अनाम वस्तुओं का एक क्रम बनाते हैं। FirstOrDefault इस क्रम से टेक्स्ट के साथ ऑब्जेक्ट को * के बराबर करता है और हम उस ऑब्जेक्ट के प्रॉपर्टी इंडेक्स को प्रिंट कर सकते हैं।

1
Steve 15 सितंबर 2020, 00:40

अन्य उत्तर ठीक हैं (और बेहतर होने की संभावना है), हालांकि यहां एक और दृष्टिकोण है, अच्छे पुराने जमाने के लूप के लिए और कोशिश-प्राप्त पैटर्न

public bool TryGetStar(string input, out int index)
{
   var split = input.Split('|');
   for (index = 0; index < split.Length; index++)
      if (split[index] == "*")
         return true;
   return false;
}

या यदि आप बड़े स्ट्रिंग्स के साथ काम कर रहे थे और आवंटन को बचाने की कोशिश कर रहे थे। आप Split को पूरी तरह से हटा सकते हैं और एक पार्स O(n) . का उपयोग कर सकते हैं

public bool TryGetStar(string input, out int index)
{
   index = 0;
   for (var i = 0; i < input.Length; i++)
      if (input[i] == '|') index++;
      else if (input[i] == '*') return true;
   return false;
}

नोट : यदि प्रदर्शन पर विचार किया जाता है, तो आप unsafe और पॉइंटर्स, या Span<Char> का भी उपयोग कर सकते हैं, जो थोड़ी मात्रा में दक्षता प्रदान करते हैं।

1
The General 15 सितंबर 2020, 00:54

DotNETFiddle आज़माएं:

testPosition.IndexOf("*") - testPosition.Replace("|","").IndexOf("*")

वाइल्डकार्ड ("*") की अनुक्रमणिका खोजें और देखें कि यदि आप पाइप ("|") वर्णों को हटाते हैं तो यह कितनी दूर तक जाता है। परिणाम एक शून्य-आधारित सूचकांक है।

0
HABO 15 सितंबर 2020, 00:37

प्रश्न से आपके पास निम्न कोड खंड है:

if(testPosition1.IndexOf("*") > 0) 
{
}

यदि आप अब if स्टेटमेंट के अंदर हैं, तो आप सुनिश्चित हैं कि तारांकन मौजूद है।

उस बिंदु से, पहले दो वर्णों और अंतिम दो वर्णों की जाँच करने के लिए एक कुशल समाधान हो सकता है।

if (testPosition1.IndexOf("*") > 0) 
{
    if (testPosition1[0] == '*' && testPosition[1] == '|')
    {
        // First position.
    }
    else if (testPosition1[testPosition.Length - 1] == '*' && testPosition1[testPosition.Length - 2] == '|')
    {
        // Third (last) position.
    }
    else
    {
        // Second position.
    }
}

यह मानता है कि एक से अधिक * मौजूद नहीं हो सकते हैं, और यह भी मानते हैं कि यदि कोई * मौजूद है, तो यह केवल पाइपों से घिरा हो सकता है। उदाहरण के लिए, मुझे लगता है कि ABC|DEF|G*H जैसा इनपुट अमान्य है।

यदि आप इस धारणा को हटाना चाहते हैं, तो आप स्ट्रिंग पर एक-पास लूप कर सकते हैं और आवश्यक जानकारी के साथ ट्रैक कर सकते हैं।

0
Youssef13 15 सितंबर 2020, 00:40