2011-03-21 8 views
7

मैं कोड है कि एक सरणी उत्पन्न कर सकते हैं जहां पहला आइटम एकबी है, तो रहा हूँ उत्कृष्टता प्राप्त करने के लिए समान है का निर्माण कर सकते हैं, फिर सी। । इसके बाद जेड यह एए पर जाएं, फिर एबी फिर एसी। । । तक सभी तरह से ZZ, मैं कैसे जेडजेड करने के लिए एक से सरणी कि जिस तरह से है कि आदेश कॉलम

सी # में ऐसा करने का सबसे अच्छा तरीका क्या है?

उत्तर

20

तरीकों में से एक है:

IEnumerable<string> generate() 
{ 
    for (char c = 'A'; c <= 'Z'; c++) 
     yield return new string(c, 1); 
    for (char c = 'A'; c <= 'Z'; c++) 
     for (char d = 'A'; d <= 'Z'; d++) 
      yield return new string(new[] { c, d }); 
} 

संपादित करें:
आप वास्तव में उत्पादन कर सकते हैं "अनंत" अनुक्रम कुछ और अधिक जटिल कोड के साथ (अधिक से अधिक long मूल्य से घिरा):

string toBase26(long i) 
{ 
    if (i == 0) return ""; i--; 
    return toBase26(i/26) + (char)('A' + i % 26); 
} 

IEnumerable<string> generate() 
{ 
    long n = 0; 
    while (true) yield return toBase26(++n); 
} 

यह एक ऐसा होता है: ए, बी, ..., जेड, एए, एबी, ..., जेडजेड, एएए, एएबी, ... आदि:

foreach (var s in generate().Take(200)) Console.WriteLine(s); 
+2

बहुत सुरुचिपूर्ण समाधान! – Zebi

+1

यह इतना आसान और सुरुचिपूर्ण है यह डरावना है :) – kprobst

+0

मैं दूसरे मामले में 'नई स्ट्रिंग (नया [] {सी, डी}) वापस कर दूंगा – Snowbear

0

ASCII table पर एक नज़र डालें और पात्रों के मूल्यों पर ध्यान दें। आप वर्णों को दोहराने की आवश्यकता के रूप में कई बार ए से ज़ेड के चरित्र को बढ़ाने के लिए एक लूप को काम करने में सक्षम होना चाहिए। :)

1

आप Enumerable.Range का उपयोग करके संख्याएं उत्पन्न कर सकते हैं और उन्हें ए-जेड उत्पन्न करने के लिए char पर कास्ट कर सकते हैं। अगला कदम उन्हें गठबंधन करना है।

1
var q = Enumerable.Range(Convert.ToInt32('A'),26).Select(x => Convert.ToChar(x)); 
var result = (
    q.Select(x => x.ToString()) 
    .Concat( 
     q.SelectMany(
     x => q.Select(y => x.ToString() + y.ToString()) 
    ) 
    ) 
); 
+2

कोड को पठनीय बनाने के लिए लिंक का उपयोग किया जाना चाहिए, कोड बनाने के लिए लिंकनिश – Snowbear

+1

मुझे लगता है कि वह जो पूछ रहा था उसकी कार्यात्मक अभिव्यक्ति के रूप में यह बिल्कुल ठीक है।व्लाड को देखने के लिए अच्छा है, सच है, लेकिन केवल इसलिए कि संकलक यह काम करने के लिए बनाता है जो सभी क्रुद्ध छुपाता है। – Kilanash

1
class Program 
{ 
    public static string IntegerToExcelColumn(int col) 
    { 
     // I've put a 256 upper bound here because Excel 2003 
     // allows only 256 columns. Change it if you're using 
     // Excel 2007 or 2010. 
     Debug.Assert(col >= 1 && col <= 256); 

     if (col >= 1 && col <= 26) 
     { 
      return ((char)(((int)'A') + (col - 1))).ToString(); 
     } 

     // I've put a 256 upper bound here because Excel 2003 
     // allows only 256 columns. Change it if you're using 
     // Excel 2007 or 2010. 
     if (col > 26 && col <= 256) 
     { 
      int rem = col % 26; 
      int pri = col/26; 
      if (rem == 0) 
      { 
       rem = 26; 
       pri--; 
      } 
      char[] buffer = new char[2]; 
      buffer[0] = (char)(((int)'A') + (pri - 1)); 
      buffer[1] = (char)(((int)'A') + (rem - 1)); 
      return new string(buffer); 
     } 

     return ""; 
    } 

    static void Main(string[] args) 
    { 
     string[] columns= new string[255]; 
     for (int i = 1; i <= 255; i++) 
      columns[i-1] = IntegerToExcelColumn(i); 
     foreach(var col in columns) 
      Console.WriteLine(col); 
    } 
} 
1

यहाँ एक तरीका है। :)

string[] values = 
    Enumerable.Range(0, 27 * 26) 
    .Select(
    n => new String(
     new[] { (char)('@' + n/26), (char)('A' + n % 26) }, 
     n < 26 ? 1 : 0, n < 26 ? 1 : 2 
    ) 
) 
    .ToArray(); 
3

Vlad का शानदार जवाब।

यहाँ उस पर एक और भिन्नता है:

static IEnumerable<string> generate() { 
    for (char c = 'A'; c <= 'Z'; c++) { 
    yield return c.ToString(); 
    } 

    foreach (string s in generate()) { 
    for (char c = 'A'; c <= 'Z'; c++) { 
     yield return s + c; 
    } 
    } 
} 

आप कोई रिक्त स्ट्रिंग के साथ अनुक्रम शुरू करने से परहेज नहीं करते, तो आप इसे लिख सकता है इस प्रकार है:

static IEnumerable<string> generate() { 
    yield return ""; 

    foreach (string s in generate()) { 
    for (char c = 'A'; c <= 'Z'; c++) { 
     yield return s + c; 
    } 
    } 
} 
+1

वाह, अच्छा अनंत रिकर्सन उपयोग! काश मैं इसका आविष्कार किया था। अगर पहले लूप को केवल 'उपज रिटर्न' के साथ प्रतिस्थापित करें तो यह और भी आसान हो सकता है; "। – Vlad

+0

दरअसल, यह बहुत साफ होगा। मैंने वास्तव में इसके बारे में भी सोचा लेकिन इस के साथ चला गया क्योंकि सवाल 'ए' से शुरू होने की मांग करता है। एक एल्गोरिदम में सौंदर्य देखने के लिए +1 :) – Jan

संबंधित मुद्दे