सी # में निरंतर पात्र कैसे प्राप्त करें?

Question

मैं एक

List<String> MyList=new List<string>(); 

मैं n मूल्यों के साथ सूची MyList भरने की जरूरत है।

यदि n के मूल्य 2 है तो सूची MyList शामिल होंगे

"A","B" 

अगर 10 तो

"A","B","C"....."J" 

अगर 30 तो

"A"....."Z","AA","AB",AC","AD" 

यदि 1000 तो

"A",....."Z","AA","AB"......"AZ","BA","BB"......."BZ"........"YZ","AAA",AAB"..... 
and so on 

मुझे नहीं पता कि यह कैसे करें।

कृपया मेरी मदद करो यह किसी भी विधि LINQ या LAMBDA Expression

Answer 1

संपादित 2:

यह शायद यह लागू करने के लिए सबसे आसान तरीका है। मैंने इसका परीक्षण किया, यह ठीक काम करता है। आप तारों की एक अनंत संख्या उत्पन्न कर सकते हैं।

public IEnumerable<string> GenerateStrings() 
{ 
    foreach(string character in Alphabet()) 
    { 
     yield return character; 
    } 

    foreach (string prefix in GenerateStrings()) 
    { 
     foreach(string suffix in Alphabet()) 
     { 
     yield return prefix + suffix; 
     } 
    } 
} 

public IEnumerable<string> Alphabet() 
{ 
    for(int i = 0; i < 26; i++) 
    { 
     yield return ((char)('A' + i)).ToString(); 
    } 
} 

---

सामग्री मैंने लिखा से पहले:

तुम भी एक छोटे से पुनरावर्ती क्रिया जो एक निश्चित सूचकांक द्वारा किसी भी स्ट्रिंग रिटर्न लिख सकते हैं। यह इष्टतम प्रदर्शन के रूप में नहीं हो सकता है, क्योंकि कुछ दोहराव वाले विभाजन हैं, लेकिन यह आपके उद्देश्य के लिए पर्याप्त तेज़ हो सकता है।

यह काफी छोटा और आसान है:

string GetString(int index) 
{ 
    if (index < 26) 
    { 
    return ((char)('A' + index)).ToString(); 
    } 
    return GetString(index/26 - 1) + GetString(index % 26); 
} 

उपयोग (यह भी एक और तरीका में डाल दिया जा सकता है:।

List<string> strings = Enumerable.Range(0, 1000) 
    .Select(x => GetString(x)) 
    .ToList(); 

यह काम कर कोड, बस एक परीक्षण को लिखी है

---

संपादित करें: उदाहरण के लिए, GetString का "पूर्ण linq रास्ता" अनुप्रयोग:

public void IEnumerale<string> GenerateStrings() 
{ 
    int index = 0; 
    // generate "infinit" number of values ... 
    while (true) 
    { 
    // ignoring index == int.MaxValue 
    yield return GetString(index++); 
    } 
} 

List<string> strings = GenerateStrings().Take(1000).ToList(); 

Answer 2

इस के समान है का उपयोग का उपयोग कर ऐसा करने के लिए this question (लेकिन काफी पर्याप्त डुप्लिकेट नहीं के रूप में चिह्नित करने के लिए, और इसे किसी तरह के लिए खोज करने के लिए एक कठिन समस्या है)।

काम कर IEnumerable<string> जवाब में से कोई भी (या कम से कम, किसी भी जो सीमा की जरूरत को कवर), और फिर अगर आप तत्वों की एक निश्चित संख्या के साथ एक सूची बनाने की जरूरत है, बस का उपयोग करें का उपयोग करें:

List<string> list = GenerateSequence().Take(count).ToList(); 

Answer 3

यह कोड ठीक काम कर रहा है, लेकिन मुझे यकीन नहीं है कि यह "LINQ पर्याप्त" है या नहीं।

char[] validChars = Enumerable.Range(0, 26).Select(i => (char)('A' + i)).ToArray(); 
List<string> result = new List<string>(); 
List<string> generator = validChars.Select(ch => ch.ToString()).ToList(); 

int n = 1000; 

while (result.Count < n) 
{ 
    result.AddRange(generator); 
    generator = generator.Take((n - result.Count)/validChars.Length + 1) 
         .SelectMany(s => validChars.Select(ch => s + ch)) 
         .ToList(); 
} 

var output = result.Take(n); 

Answer 4

मैंने कुछ समय पहले एसक्यूएल में something similar किया था।

public static string GetCode(int id) { 
    string code, chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"; 
    if (id <= chars.Length) { 
    code = chars.Substring(id - 1, 1); 
    } else { 
    id--; 
    int value = chars.Length, adder = 0; 
    while (id >= value * (chars.Length + 1) + adder) { 
     adder += value; 
     value *= chars.Length; 
    } 
    code = chars.Substring((id - adder)/value - 1, 1); 
    id = ((id - adder) % value); 
    while (value > 1) { 
     value /= chars.Length; 
     code += chars.Substring(id/value, 1); 
     id = id % value; 
    } 
    } 
    return code; 
} 

तो फिर तुम सिर्फ 1 से नंबर प्राप्त और ऊपर, और कोड में अनुवाद:

var codes = Enumerable.Range(1, 1000).Select(n => GetCode(n)); 

सीमा

सी # करने के लिए अनूदित इस एक नंबर से एक कोड बनाने के लिए एक समारोह है फ़ंक्शन का वर्तमान में "ZZZZZZ" या 321272406 है। (उसके बाद आपको शून्य से विभाजन मिलता है।)

ध्यान दें कि यह फ़ंक्शन सभी संयोजनों का उपयोग करता है और "ए" .. "Z", "AA" .. " जेडजेड "," एएए ".. "एबी" और "एबीसी" शुरू करने के बजाय "ZZZ"।

Answer 5

@DannyChen यह है। थोड़ा सा परिवर्तन के साथ आपका कोड ..

char[] validChars = Enumerable.Range(0, 26).Select(i => (char)('A' + i)).ToArray(); 

int n = 30; 
int pointer = 0; 
int pointerSec = 0; 
int Deg = 0; 
string prefix = string.Empty; 
string prefixMore = string.Empty; 
List<string> result = new List<string>(); 

while (n > 0) 
{ 
    result.AddRange(validChars.Skip(pointer).Select(ch => prefix + ch).Take(n)); 
    if (pointer == 26) 
    { 
     pointer = -1; 
     Deg += 1; 
     prefixMore = "" + validChars[pointerSec]; 
     pointerSec++; 
     n++; 
    } 
    else 
    { 
     if (Deg == 0) 
     { 
      prefix = "" + validChars[pointer]; 
     } 
     else 
     { 
      prefix = prefixMore + validChars[pointer]; 
     } 
    } 
    n--; 
    pointer++; 
} 

यह 100% सही है।

Answer 6

नीचे आज़माएं ..मैं स्रोत बनाने के लिए एक संघ उपयोग कर रहा हूँ क्रॉस में शामिल हों और और फिर लें विस्तार विधि

char[] charArray = "ABCDEFGHIJKLMNOPQRSTUVWXYZ".ToCharArray(); 

List<String> MyList = new List<string>(); 
int n = 1000; 

         (from value1 in charArray 
         select new 
         { 
          newString = value1.ToString() 
         }) 
        .Union 
        (
         (from value1 in charArray 
         from value2 in charArray 

         select new 
         { 
          newString = string.Concat(value1, value2) 
         }) 
        ) 
        .Union 
        (
         (from value1 in charArray 
         from value2 in charArray 
         from value3 in charArray 

         select new 
         { 
          newString = string.Concat(value1, value2, value3) 
         }) 
        ) 
        .Take(n) 
        .ToList()       
        .ForEach(i => MyList.Add(i.newString)); 

आशा यह आप Linq के संयोजन का उपयोग के कुछ विचार दे देंगे का उपयोग करके रिकॉर्ड को छानने, Lambda और विस्तार विधि।