कॉलम संख्या (जैसे 127) को एक्सेल कॉलम (उदाहरण AA) में कैसे बदलें

Question

आप बिना Excel के सीधे मान प्राप्त किए बिना स्वचालन का उपयोग किए बिना एक संख्यात्मक संख्या को C # में Excel स्तंभ नाम में कैसे परिवर्तित करते हैं।

एक्सेल 2007 में 1 से 16384 तक की संभावित सीमा है, जो कि उन स्तंभों की संख्या है जो इसका समर्थन करते हैं। परिणामी मान एक्सेल कॉलम नाम, जैसे ए, एए, एएए आदि के रूप में होने चाहिए।

Comments

यह नहीं भूलना चाहिए कि उपलब्ध कॉलम की संख्या में सीमाएं हैं। जैसे * एक्सेल 2003 (v11) IV, 2 ^ 8 या 256 कॉलम तक जाता है। * एक्सेल 2007 (v12) XFD, 2 ^ 14 या 16384 कॉलम तक जाता है।

— बिना लाइसेंस के

संभव डुप्लिकेट मैं एक्सेल कॉलम नाम कैसे खोज सकता हूं जो किसी दिए गए पूर्णांक से मेल खाता है?

— डैनियल ट्रेबिएन

यह प्रश्न C # और एक्सेल को टैग किया गया है। मैं इस प्रश्न को पुराना मानता हूं , क्योंकि हम 2016 में रहते हैं और वहां EPPLUS है । सर्वर पर उन्नत एक्सेल स्प्रेडशीट बनाने के लिए आमतौर पर इस्तेमाल की जाने वाली C # लाइब्रेरी। जो निम्न के तहत उपलब्ध कराया गया है: GNU लाइब्रेरी जनरल पब्लिक लाइसेंस (LGPL)। EPPlus का उपयोग करके आप आसानी से कॉलम स्ट्रिंग प्राप्त कर सकते हैं।

— टोनी_किलो पापा मायकेगॉल्फ

ध्यान दें कि पंक्ति और स्तंभ सीमाएँ Excel संस्करण की तुलना में फ़ाइल प्रारूप पर अधिक निर्भर करती हैं, और प्रत्येक कार्यपुस्तिका के लिए भिन्न हो सकती हैं। यदि वे पुराने या नए प्रारूप में सहेजे जाते हैं तो वे उसी कार्यपुस्तिका के लिए भी बदल सकते हैं।

— स्लैई

Answer 1

यहां बताया गया है कि मैं इसे कैसे करता हूं:

private string GetExcelColumnName(int columnNumber)
{
    int dividend = columnNumber;
    string columnName = String.Empty;
    int modulo;

    while (dividend > 0)
    {
        modulo = (dividend - 1) % 26;
        columnName = Convert.ToChar(65 + modulo).ToString() + columnName;
        dividend = (int)((dividend - modulo) / 26);
    } 

    return columnName;
}

Comments

यह कोड अच्छी तरह से काम करता है। यह मानता है कि कॉलम A, कॉलम 1 है। मुझे कॉलम A के रूप में कॉलम A का उपयोग करके अपने सिस्टम के लिए एक त्वरित परिवर्तन करना था। मैंने लाइन को पूर्णांक में बदलकर int लाभांश = columnNumber + 1 कर दिया है; कीथ

— कीथ सिरमंस

@ जदुव ने सिर्फ इसका इस्तेमाल करके देखा StringBuilder। इसमें तकरीबन दोगुना समय लगता है। यह एक बहुत छोटा स्ट्रिंग है (अधिकतम 3 वर्ण - एक्सेल 2010 स्तंभ XFD तक जाता है), इसलिए अधिकतम 2 स्ट्रिंग संयोजन। (मैंने पूर्णांक 1 से 16384 यानी एक्सेल कॉलम ए से एक्सएफडी, परीक्षण के रूप में अनुवाद करने के 100 पुनरावृत्तियों का उपयोग किया)।

— ग्राहम

बेहतर समझ के लिए, मैं 65 को 'ए' के ​​साथ

— बदलूंगा

मुझे लगता है कि 65 के बजाय 'ए' का उपयोग करना बेहतर होगा। और 26 का मूल्यांकन ('जेड' - 'ए' + 1) के रूप में किया जा सकता है, उदाहरण के लिए: कॉन्स्टेंस इंट अल्फाबेटलिफ्ट = 'जेड' - 'ए' + 1;

— डेनिस ग्लैडकी

हालांकि मुझे गेम में देर हो गई है, कोड इष्टतम है। विशेष रूप से, आपको कास्ट का उपयोग करने modulo, कॉल करने ToString()और आवेदन करने की आवश्यकता नहीं है (int)। यह देखते हुए कि C # दुनिया में ज्यादातर मामलों में आप 0 से नंबर देना शुरू कर देंगे, यहाँ मेरा संशोधन है: <-! - भाषा: c # -> सार्वजनिक स्थैतिक स्ट्रिंग GetColumnName (int index) // शून्य-आधारित {const बाइट B = = 'Z '-' ए '+ 1; string name = String.Empty; do {name = Convert.ToChar ('A' + index% BASE) + नाम; index = index / BASE - 1; } जबकि (सूचकांक> = 0); वापसी का नाम; }

— हरमन कान

Answer 2

अगर किसी को VBA के बिना एक्सेल में यह करने की आवश्यकता है, तो यहां एक तरीका है:

=SUBSTITUTE(ADDRESS(1;colNum;4);"1";"")

जहां ColNum कॉलम संख्या है

और VBA में:

Function GetColumnName(colNum As Integer) As String
    Dim d As Integer
    Dim m As Integer
    Dim name As String
    d = colNum
    name = ""
    Do While (d > 0)
        m = (d - 1) Mod 26
        name = Chr(65 + m) + name
        d = Int((d - m) / 26)
    Loop
    GetColumnName = name
End Function

Comments

उदाहरण: = SUBSTITUTE (पाठ (ADDRESS (1,1000,4), ""), "1", "")

— डॉल्फ

हाँ, मैं एक्सेल का उपयोग एक लोकेल में करता हूँ जहाँ; एक्सेल में फ़ंक्शन तर्क को अलग करने के लिए, के स्थान पर उपयोग किया जाता है। इस पर ध्यान दिलाने के लिए धन्यवाद।

— vzczc 7

मैंने यह TEXT फंक्शन के बिना किया। TEXT फ़ंक्शन का उद्देश्य क्या है?

— दिनुली २oli

@dayuloli इस उत्तर के लिखे जाने के काफी समय बाद, आप सही हैं, TEXT फ़ंक्शन यहां किसी उद्देश्य की पूर्ति नहीं करता है। उत्तर को अपडेट करेगा।

— vzczc

Answer 3

क्षमा करें, यह C # के बजाय पायथन है, लेकिन कम से कम परिणाम सही हैं:

def ColIdxToXlName(idx):
    if idx < 1:
        raise ValueError("Index is too small")
    result = ""
    while True:
        if idx > 26:
            idx, r = divmod(idx - 1, 26)
            result = chr(r + ord('A')) + result
        else:
            return chr(idx + ord('A') - 1) + result


for i in xrange(1, 1024):
    print "%4d : %s" % (i, ColIdxToXlName(i))

Comments

हां, मैंने नीचे दिया, जब प्रश्न C # है तो पायथन को पोस्ट न करें। और हां, अधिक लोगों को ऐसा करना चाहिए।

— KyloRen

प्रश्न का शीर्षक C # नहीं है, इसलिए कई लोग यहां आ सकते हैं जो C # को एक्सपेक्ट नहीं करते हैं। इसलिए, पायथन में साझा करने के लिए धन्यवाद!

— टिम-इरविन

Answer 4

आपको एक्सेल कॉलम एड्रेस से जैसे एएजेड से पूर्णांक और किसी भी पूर्णांक से एक्सेल में रूपांतरण की आवश्यकता हो सकती है। नीचे दिए गए दो तरीके बस यही करेंगे। मान लें कि 1 आधारित अनुक्रमण, आपके "सरणियों" में पहला तत्व तत्व संख्या 1 है। यहां आकार की कोई सीमा नहीं है, इसलिए आप ERROR जैसे एड्रेसेस का उपयोग कर सकते हैं और यह कॉलम नंबर 2613824 होगा ...

public static string ColumnAdress(int col)
{
  if (col <= 26) { 
    return Convert.ToChar(col + 64).ToString();
  }
  int div = col / 26;
  int mod = col % 26;
  if (mod == 0) {mod = 26;div--;}
  return ColumnAdress(div) + ColumnAdress(mod);
}

public static int ColumnNumber(string colAdress)
{
  int[] digits = new int[colAdress.Length];
  for (int i = 0; i < colAdress.Length; ++i)
  {
    digits[i] = Convert.ToInt32(colAdress[i]) - 64;
  }
  int mul=1;int res=0;
  for (int pos = digits.Length - 1; pos >= 0; --pos)
  {
    res += digits[pos] * mul;
    mul *= 26;
  }
  return res;
}

Answer 5

मुझे अपनी पहली पोस्ट में एक त्रुटि का पता चला, इसलिए मैंने बैठकर गणित करने का फैसला किया। मैंने पाया कि एक्सेल कॉलम को पहचानने के लिए उपयोग की जाने वाली संख्या प्रणाली आधार 26 प्रणाली नहीं है, जैसा कि किसी अन्य व्यक्ति ने पोस्ट किया है। आधार 10 में निम्नलिखित पर विचार करें। आप वर्णमाला के अक्षरों के साथ भी ऐसा कर सकते हैं।

अंतरिक्ष: ......................... एस 1, एस 2, एस 3: एस 1, एस 2, एस 3
............ …………………… 0, 00, 000: .. ए, एए, एएए
…………। …………………… १, ०१, ००१: .. बी, एबी, आब
…………। ………………………,…:……,……
…………… ………………… ९, ९९, ९९९, १ ९९९: .. Z, ZZ, ZZZ
अंतरिक्ष में कुल राज्य: १०, १००, १०००: २००, २६, ६ ,६, १.५.६
कुल राज्य: ............... १११० ................ १ .२....

आधार संख्या के आधार पर अलग-अलग वर्णानुक्रमिक रिक्त स्थान में Excel संख्या स्तंभ। आप देख सकते हैं कि सामान्य तौर पर, राज्य अंतरिक्ष प्रगति एक आधार के लिए a, 2, ^ 3, ..., और कुछ राज्यों की कुल संख्या a + a है। ^ 2 + ए ^ 3 +…।

मान लीजिए कि आप पहले N रिक्त स्थान में राज्यों A की कुल संख्या ज्ञात करना चाहते हैं। ऐसा करने का सूत्र A = (a) (a ^ N - 1) / (a-1) है। यह महत्वपूर्ण है क्योंकि हमें उस स्थान N को खोजने की आवश्यकता है जो हमारी अनुक्रमणिका K से मेल खाती है। यदि मुझे यह पता लगाना है कि K उस संख्या प्रणाली में है जहाँ मुझे A को K से बदलना है और N के लिए हल करना है। समाधान N = log {है आधार ए} (ए (ए -1) / ए 1)। यदि मैं a = 10 और K = 192 के उदाहरण का उपयोग करता हूं, तो मुझे पता है कि N = 2.23804…। यह मुझे बताता है कि के तीसरे स्थान की शुरुआत में स्थित है क्योंकि यह दो से थोड़ा अधिक है।

अगला कदम यह है कि हम वर्तमान स्थान में कितनी दूर हैं। इसे खोजने के लिए, N के फर्श का उपयोग करके उत्पन्न K से A को घटाएं। इस उदाहरण में, N की मंजिल दो है। तो, ए = (१०) (१० ^ २ - १) / (१०-१) = ११०, जैसा कि अपेक्षित है जब आप पहले दो स्थानों के राज्यों को मिलाते हैं। इसे K से घटाने की आवश्यकता है क्योंकि ये पहले 110 राज्यों को पहले दो स्थानों के लिए पहले ही हिसाब दे चुके होंगे। यह हमें 82 राज्यों के साथ छोड़ देता है। तो, इस संख्या प्रणाली में, बेस 10 में 192 का प्रतिनिधित्व 082 है।

शून्य के आधार सूचकांक का उपयोग करने वाला C # कोड है

    private string ExcelColumnIndexToName(int Index)
    {
        string range = string.Empty;
        if (Index < 0 ) return range;
        int a = 26;
        int x = (int)Math.Floor(Math.Log((Index) * (a - 1) / a + 1, a));
        Index -= (int)(Math.Pow(a, x) - 1) * a / (a - 1);
        for (int i = x+1; Index + i > 0; i--)
        {
            range = ((char)(65 + Index % a)).ToString() + range;
            Index /= a;
        }
        return range;
    }

// पुरानी पोस्ट

C # में एक शून्य-आधारित समाधान।

    private string ExcelColumnIndexToName(int Index)
    {
        string range = "";
        if (Index < 0 ) return range;
        for(int i=1;Index + i > 0;i=0)
        {
            range = ((char)(65 + Index % 26)).ToString() + range;
            Index /= 26;
        }
        if (range.Length > 1) range = ((char)((int)range[0] - 1)).ToString() + range.Substring(1);
        return range;
    }

Comments

ओह, मुझे पता नहीं क्यों लेकिन मुझे यह समाधान पसंद है। कुछ भी नहीं फैंसी सिर्फ तर्क का अच्छा उपयोग ... प्रोग्रामर के स्तर के लिए आसानी से पठनीय कोड। एक बात हालांकि, मेरा मानना ​​है कि सी # में एक खाली स्ट्रिंग निर्दिष्ट करने के लिए इसका सबसे अच्छा अभ्यास स्ट्रिंग रेंज = स्ट्रिंग है। खाली;

— बेनामी टाइप

हाँ, बहुत अच्छी व्याख्या। लेकिन क्या आप यह भी बता सकते हैं कि यह आधार 27 भी नहीं है? अध्ययन के दौरान आपकी व्याख्या से यह पता चलता है, लेकिन शीर्ष पर एक त्वरित उल्लेख कुछ अन्य लोगों को कुछ समय बचा सकता है।

— मारियस

Answer 6

int nCol = 127;
string sChars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string sCol = "";
while (nCol >= 26)
{
    int nChar = nCol % 26;
    nCol = (nCol - nChar) / 26;
    // You could do some trick with using nChar as offset from 'A', but I am lazy to do it right now.
    sCol = sChars[nChar] + sCol;
}
sCol = sChars[nCol] + sCol;

अद्यतन : पीटर की टिप्पणी सही है। मुझे ब्राउज़र में कोड लिखने के लिए यही मिलता है। :-) मेरा समाधान संकलित नहीं हो रहा था, यह बाएं-सबसे अक्षर को याद कर रहा था और यह रिवर्स ऑर्डर में स्ट्रिंग का निर्माण कर रहा था - अब सब ठीक हो गया है।

कीड़े एक तरफ, एल्गोरिथ्म मूल रूप से बेस 10 से बेस 26 तक की संख्या को परिवर्तित कर रहा है।

अपडेट 2 : जोएल कोएहॉर्न सही है - उपरोक्त कोड 27 के लिए एबी वापस आ जाएगा। अगर यह वास्तविक आधार 26 नंबर था, तो ए ए के बराबर होगा और जेड के बाद अगला नंबर बीए होगा।

int nCol = 127;
string sChars = "0ABCDEFGHIJKLMNOPQRSTUVWXYZ";
string sCol = "";
while (nCol > 26)
{
    int nChar = nCol % 26;
    if (nChar == 0)
        nChar = 26;
    nCol = (nCol - nChar) / 26;
    sCol = sChars[nChar] + sCol;
}
if (nCol != 0)
    sCol = sChars[nCol] + sCol;

Comments

कोड संकलित नहीं किया जाएगा (sCol आरंभीकृत नहीं)। यदि ऐसा होता है, तो यह सही जवाब नहीं देगा।

— पीटर

इस उत्तर गलत है। Base26 काफी अच्छा नहीं है। ज़ेड से एए तक आपके लपेटने पर क्या होता है, इसके बारे में सोचें। यदि A 0 अंक के बराबर है, तो यह 9 से 00 तक लपेटने जैसा है। यदि यह 1 अंक है, तो यह 9 से 11. तक लपेटने जैसा है

— जोएल कोएहॉर्न

मैं अपडेट के बाद स्पष्ट नहीं हूं ... या तो एल्गोरिदम अब सही है? और यदि हां, तो कौन सा, दूसरा? मैं इसे संपादित करता हूँ और इसे

— स्पष्टता के

Answer 7

पुनरावृत्ति के साथ आसान है।

public static string GetStandardExcelColumnName(int columnNumberOneBased)
{
  int baseValue = Convert.ToInt32('A');
  int columnNumberZeroBased = columnNumberOneBased - 1;

  string ret = "";

  if (columnNumberOneBased > 26)
  {
    ret = GetStandardExcelColumnName(columnNumberZeroBased / 26) ;
  }

  return ret + Convert.ToChar(baseValue + (columnNumberZeroBased % 26) );
}

Comments

.. या पाश। यहाँ पुनरावृत्ति का उपयोग करने का कोई वास्तविक कारण नहीं है।

— Blorgbeard

यह सिर्फ आधार 26 नहीं है, इसलिए पुनरावर्ती समाधान बहुत सरल है।

— जोएल कोएहॉर्न

यह दिनचर्या वास्तव में काम नहीं करती है। उदाहरण के लिए GetStandardExcelColumnName (26) रिटर्न @ GetStandardExcelColumnName (52) रिटर्न B @

— sgmoore

"सबसे सरल" समाधान के विपरीत सबसे स्पष्ट सबसे अच्छा है।

— बेनामी टाइप

Answer 8

बस एक सरल दो-लाइन सी # कार्यान्वयन में पुनरावृत्ति का उपयोग करके फेंकना, क्योंकि यहां सभी उत्तर आवश्यक से अधिक जटिल लगते हैं।

/// <summary>
/// Gets the column letter(s) corresponding to the given column number.
/// </summary>
/// <param name="column">The one-based column index. Must be greater than zero.</param>
/// <returns>The desired column letter, or an empty string if the column number was invalid.</returns>
public static string GetColumnLetter(int column) {
    if (column < 1) return String.Empty;
    return GetColumnLetter((column - 1) / 26) + (char)('A' + (column - 1) % 26);
}

Answer 9

.. और php में परिवर्तित:

function GetExcelColumnName($columnNumber) {
    $columnName = '';
    while ($columnNumber > 0) {
        $modulo = ($columnNumber - 1) % 26;
        $columnName = chr(65 + $modulo) . $columnName;
        $columnNumber = (int)(($columnNumber - $modulo) / 26);
    }
    return $columnName;
}

Comments

ord('A')65 के बजाय का उपयोग करें ।

— मुली

Answer 10

मुझे आश्चर्य है कि अब तक के सभी समाधानों में या तो पुनरावृत्ति या पुनरावृत्ति शामिल है।

यहां मेरा समाधान है जो निरंतर समय में चलता है (लूप नहीं)। यह समाधान सभी संभव एक्सेल कॉलम के लिए काम करता है और जाँचता है कि इनपुट को एक्सेल कॉलम में बदला जा सकता है। संभावित कॉलम [A, XFD] या [1, 16384] श्रेणी में हैं। (यह आपके एक्सेल के संस्करण पर निर्भर है)

private static string Turn(uint col)
{
    if (col < 1 || col > 16384) //Excel columns are one-based (one = 'A')
        throw new ArgumentException("col must be >= 1 and <= 16384");

    if (col <= 26) //one character
        return ((char)(col + 'A' - 1)).ToString();

    else if (col <= 702) //two characters
    {
        char firstChar = (char)((int)((col - 1) / 26) + 'A' - 1);
        char secondChar = (char)(col % 26 + 'A' - 1);

        if (secondChar == '@') //Excel is one-based, but modulo operations are zero-based
            secondChar = 'Z'; //convert one-based to zero-based

        return string.Format("{0}{1}", firstChar, secondChar);
    }

    else //three characters
    {
        char firstChar = (char)((int)((col - 1) / 702) + 'A' - 1);
        char secondChar = (char)((col - 1) / 26 % 26 + 'A' - 1);
        char thirdChar = (char)(col % 26 + 'A' - 1);

        if (thirdChar == '@') //Excel is one-based, but modulo operations are zero-based
            thirdChar = 'Z'; //convert one-based to zero-based

        return string.Format("{0}{1}{2}", firstChar, secondChar, thirdChar);
    }
}

Comments

FYI करें: @ ग्राहम का उत्तर (और शायद अन्य) आपकी तुलना में अधिक सामान्य हैं: वे कॉलम नामों में 4+ वर्णों का समर्थन करते हैं। और यही कारण है कि वे पुनरावृत्त हैं।

— बर्नार्ड पाउलस

वास्तव में, यदि वे असीमित पूर्णांक का उपयोग करते हैं और intएस नहीं करते हैं , तो परिणामस्वरूप स्तंभ का नाम मनमाने ढंग से लंबा हो सकता है (उदाहरण के लिए, अजगर जवाब का मामला है)

— बर्नार्ड पॉलस

यदि मेरा डेटा कभी भी 16,384-कॉलम स्प्रेडशीट के लिए बहुत बड़ा है, तो मैं खुद को सिर में गोली मार लूंगा। वैसे भी, एक्सेल सभी संभावित तीन-अक्षर स्तंभों का समर्थन नहीं करता है (यह X89D में 1,894 स्तंभों को छोड़ देता है)। अभी वैसे भी। मैं भविष्य में अपने उत्तर को आवश्यकतानुसार अपडेट करूंगा।

— user2023861

:) नहीं पता था कि! मेरी टिप्पणी विभिन्न एल्गोरिदम के सैद्धांतिक गुणों पर थी।

— बर्नार्ड पौलस

यह शायद सबसे सरल और स्पष्ट समाधान है।

— जुआन

Answer 11

यह उत्तर javaScript में है:

function getCharFromNumber(columnNumber){
    var dividend = columnNumber;
    var columnName = "";
    var modulo;

    while (dividend > 0)
    {
        modulo = (dividend - 1) % 26;
        columnName = String.fromCharCode(65 + modulo).toString() + columnName;
        dividend = parseInt((dividend - modulo) / 26);
    } 
    return  columnName;
}

Answer 12

जावा में समान कार्यान्वयन

public String getExcelColumnName (int columnNumber) 
    {     
        int dividend = columnNumber;   
        int i;
        String columnName = "";     
        int modulo;     
        while (dividend > 0)     
        {        
            modulo = (dividend - 1) % 26;         
            i = 65 + modulo;
            columnName = new Character((char)i).toString() + columnName;        
            dividend = (int)((dividend - modulo) / 26);    
        }       
        return columnName; 
    }  

Answer 13

यहाँ सभी आपूर्ति किए गए संस्करणों को देखने के बाद, मैंने पुनरावृत्ति का उपयोग करते हुए, खुद को करने के लिए उतरा।

यहाँ मेरा vb.net संस्करण है:

Function CL(ByVal x As Integer) As String
    If x >= 1 And x <= 26 Then
        CL = Chr(x + 64)
    Else
        CL = CL((x - x Mod 26) / 26) & Chr((x Mod 26) + 1 + 64)
    End If
End Function

Answer 14

खेल के लिए थोड़ा देर से, लेकिन यहाँ मैं कोड का उपयोग करता हूं (सी # में):

private static readonly string _Alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
public static int ColumnNameParse(string value)
{
    // assumes value.Length is [1,3]
    // assumes value is uppercase
    var digits = value.PadLeft(3).Select(x => _Alphabet.IndexOf(x));
    return digits.Aggregate(0, (current, index) => (current * 26) + (index + 1));
}

Comments

आपने जो माँगा था उसका उलटा किया, लेकिन आपके लंबो-फू के लिए +1।

— nurettin

IndexOfयह काफी धीमा है, आप रिवर्स मैपिंग को बेहतर तरीके से पूरा करेंगे।

— व्लाद

Answer 15

मैं अपने स्थिर वर्ग में उपयोग करना चाहता था, कर्नल इंडेक्स और कोल लेबल के बीच में अंतर करने के लिए। मैं अपने ColumnLabel विधि के लिए संशोधित स्वीकार किए गए उत्तर का उपयोग करता हूं

public static class Extensions
{
    public static string ColumnLabel(this int col)
    {
        var dividend = col;
        var columnLabel = string.Empty;
        int modulo;

        while (dividend > 0)
        {
            modulo = (dividend - 1) % 26;
            columnLabel = Convert.ToChar(65 + modulo).ToString() + columnLabel;
            dividend = (int)((dividend - modulo) / 26);
        } 

        return columnLabel;
    }
    public static int ColumnIndex(this string colLabel)
    {
        // "AD" (1 * 26^1) + (4 * 26^0) ...
        var colIndex = 0;
        for(int ind = 0, pow = colLabel.Count()-1; ind < colLabel.Count(); ++ind, --pow)
        {
            var cVal = Convert.ToInt32(colLabel[ind]) - 64; //col A is index 1
            colIndex += cVal * ((int)Math.Pow(26, pow));
        }
        return colIndex;
    }
}

ऐसे करें इस्तेमाल ...

30.ColumnLabel(); // "AD"
"AD".ColumnIndex(); // 30

Answer 16

यदि आप इसे कोड के बिना एक सेल सूत्र के लिए चाहते हैं, तो इसके लिए एक सूत्र यहां दिया गया है:

IF(COLUMN()>=26,CHAR(ROUND(COLUMN()/26,1)+64)&CHAR(MOD(COLUMN(),26)+64),CHAR(COLUMN()+64))

Answer 17

डेल्फी (पास्कल) में:

function GetExcelColumnName(columnNumber: integer): string;
var
  dividend, modulo: integer;
begin
  Result := '';
  dividend := columnNumber;
  while dividend > 0 do begin
    modulo := (dividend - 1) mod 26;
    Result := Chr(65 + modulo) + Result;
    dividend := (dividend - modulo) div 26;
  end;
end;

Answer 18

private String getColumn(int c) {
    String s = "";
    do {
        s = (char)('A' + (c % 26)) + s;
        c /= 26;
    } while (c-- > 0);
    return s;
}

इसका ठीक आधार 26 नहीं है, सिस्टम में 0 नहीं है। अगर वहाँ था, तो 'जेड' के बाद 'बीए' का नहीं 'एए' का होगा।

Answer 19

पर्ल में, 1 (ए), 27 (एए), आदि के इनपुट के लिए।

sub excel_colname {
  my ($idx) = @_;       # one-based column number
  --$idx;               # zero-based column index
  my $name = "";
  while ($idx >= 0) {
    $name .= chr(ord("A") + ($idx % 26));
    $idx   = int($idx / 26) - 1;
  }
  return scalar reverse $name;
}

Answer 20

मूल समाधान को परिष्कृत करना (C # में):

public static class ExcelHelper
{
    private static Dictionary<UInt16, String> l_DictionaryOfColumns;

    public static ExcelHelper() {
        l_DictionaryOfColumns = new Dictionary<ushort, string>(256);
    }

    public static String GetExcelColumnName(UInt16 l_Column)
    {
        UInt16 l_ColumnCopy = l_Column;
        String l_Chars = "0ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        String l_rVal = "";
        UInt16 l_Char;


        if (l_DictionaryOfColumns.ContainsKey(l_Column) == true)
        {
            l_rVal = l_DictionaryOfColumns[l_Column];
        }
        else
        {
            while (l_ColumnCopy > 26)
            {
                l_Char = l_ColumnCopy % 26;
                if (l_Char == 0)
                    l_Char = 26;

                l_ColumnCopy = (l_ColumnCopy - l_Char) / 26;
                l_rVal = l_Chars[l_Char] + l_rVal;
            }
            if (l_ColumnCopy != 0)
                l_rVal = l_Chars[l_ColumnCopy] + l_rVal;

            l_DictionaryOfColumns.ContainsKey(l_Column) = l_rVal;
        }

        return l_rVal;
    }
}

Answer 21

यहाँ एक एक्टीशनस्क्रिप्ट संस्करण है:

private var columnNumbers:Array = ['A', 'B', 'C', 'D', 'E', 'F' , 'G', 'H', 'I', 'J', 'K' ,'L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'];

    private function getExcelColumnName(columnNumber:int) : String{
        var dividend:int = columnNumber;
        var columnName:String = "";
        var modulo:int;

        while (dividend > 0)
        {
            modulo = (dividend - 1) % 26;
            columnName = columnNumbers[modulo] + columnName;
            dividend = int((dividend - modulo) / 26);
        } 

        return columnName;
    }

Answer 22

जावास्क्रिप्ट समाधान

/**
 * Calculate the column letter abbreviation from a 1 based index
 * @param {Number} value
 * @returns {string}
 */
getColumnFromIndex = function (value) {
    var base = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.split('');
    var remainder, result = "";
    do {
        remainder = value % 26;
        result = base[(remainder || 26) - 1] + result;
        value = Math.floor(value / 26);
    } while (value > 0);
    return result;
};

Comments

सूचकांक 26 और 27 का प्रयास करें। यह बहुत करीब है, लेकिन एक से दूर।

— एरिक

value = Math.floor (मान / 26); मूल्य होना चाहिए = Math.ceil (मूल्य / 26) - 1;

— हेनरी लियू

Answer 23

ये मेरे कोड विशिष्ट संख्या (1 से सूचकांक शुरू) को एक्सेल कॉलम में बदलने के लिए हैं।

    public static string NumberToExcelColumn(uint number)
    {
        uint originalNumber = number;

        uint numChars = 1;
        while (Math.Pow(26, numChars) < number)
        {
            numChars++;

            if (Math.Pow(26, numChars) + 26 >= number)
            {
                break;
            }               
        }

        string toRet = "";
        uint lastValue = 0;

        do
        {
            number -= lastValue;

            double powerVal = Math.Pow(26, numChars - 1);
            byte thisCharIdx = (byte)Math.Truncate((columnNumber - 1) / powerVal);
            lastValue = (int)powerVal * thisCharIdx;

            if (numChars - 2 >= 0)
            {
                double powerVal_next = Math.Pow(26, numChars - 2);
                byte thisCharIdx_next = (byte)Math.Truncate((columnNumber - lastValue - 1) / powerVal_next);
                int lastValue_next = (int)Math.Pow(26, numChars - 2) * thisCharIdx_next;

                if (thisCharIdx_next == 0 && lastValue_next == 0 && powerVal_next == 26)
                {
                    thisCharIdx--;
                    lastValue = (int)powerVal * thisCharIdx;
                }
            }

            toRet += (char)((byte)'A' + thisCharIdx + ((numChars > 1) ? -1 : 0));

            numChars--;
        } while (numChars > 0);

        return toRet;
    }

मेरा यूनिट टेस्ट:

    [TestMethod]
    public void Test()
    {
        Assert.AreEqual("A", NumberToExcelColumn(1));
        Assert.AreEqual("Z", NumberToExcelColumn(26));
        Assert.AreEqual("AA", NumberToExcelColumn(27));
        Assert.AreEqual("AO", NumberToExcelColumn(41));
        Assert.AreEqual("AZ", NumberToExcelColumn(52));
        Assert.AreEqual("BA", NumberToExcelColumn(53));
        Assert.AreEqual("ZZ", NumberToExcelColumn(702));
        Assert.AreEqual("AAA", NumberToExcelColumn(703));
        Assert.AreEqual("ABC", NumberToExcelColumn(731));
        Assert.AreEqual("ACQ", NumberToExcelColumn(771));
        Assert.AreEqual("AYZ", NumberToExcelColumn(1352));
        Assert.AreEqual("AZA", NumberToExcelColumn(1353));
        Assert.AreEqual("AZB", NumberToExcelColumn(1354));
        Assert.AreEqual("BAA", NumberToExcelColumn(1379));
        Assert.AreEqual("CNU", NumberToExcelColumn(2413));
        Assert.AreEqual("GCM", NumberToExcelColumn(4823));
        Assert.AreEqual("MSR", NumberToExcelColumn(9300));
        Assert.AreEqual("OMB", NumberToExcelColumn(10480));
        Assert.AreEqual("ULV", NumberToExcelColumn(14530));
        Assert.AreEqual("XFD", NumberToExcelColumn(16384));
    }

Comments

+1 यह दिखाने के लिए कि आपके परीक्षण (XFD) में अधिकतम सेल संदर्भ क्या है - आपको विश्वास नहीं होगा कि वेब पर उस जानकारी को खोजना कितना मुश्किल है।

— कंट्रोलबॉक्स

Answer 24

हालांकि मुझे खेल के लिए देर हो चुकी है, ग्राहम का जवाब इष्टतम होने से बहुत दूर है। विशेष रूप से, आपको moduloकॉल का उपयोग करने ToString()और कॉल करने की आवश्यकता नहीं है (int)। यह देखते हुए कि C # दुनिया में ज्यादातर मामलों में आप 0 से नंबर देना शुरू कर देंगे, यहाँ मेरा संशोधन है:

public static string GetColumnName(int index) // zero-based
{
    const byte BASE = 'Z' - 'A' + 1;
    string name = String.Empty;

    do
    {
        name = Convert.ToChar('A' + index % BASE) + name;
        index = index / BASE - 1;
    }
    while (index >= 0);

    return name;
}

Answer 25

एक और VBA तरीका

Public Function GetColumnName(TargetCell As Range) As String
    GetColumnName = Split(CStr(TargetCell.Cells(1, 1).Address), "$")(1)
End Function

Answer 26

यहाँ PHP में मेरा सुपर लेट कार्यान्वयन है। यह एक पुनरावर्ती है। मैंने यह पोस्ट मिलने से ठीक पहले लिखा था। मैं यह देखना चाहता था कि क्या दूसरों ने पहले से ही इस समस्या को हल कर लिया है ...

public function GetColumn($intNumber, $strCol = null) {

    if ($intNumber > 0) {
        $intRem = ($intNumber - 1) % 26;
        $strCol = $this->GetColumn(intval(($intNumber - $intRem) / 26), sprintf('%s%s', chr(65 + $intRem), $strCol));
    }

    return $strCol;
}

Answer 27

मैं जावा में एक ही काम करने की कोशिश कर रहा हूं ... मैंने निम्नलिखित कोड लिखा है:

private String getExcelColumnName(int columnNumber) {

    int dividend = columnNumber;
    String columnName = "";
    int modulo;

    while (dividend > 0)
    {
        modulo = (dividend - 1) % 26;

        char val = Character.valueOf((char)(65 + modulo));

        columnName += val;

        dividend = (int)((dividend - modulo) / 26);
    } 

    return columnName;
}

अब एक बार जब मैंने इसे कॉलमनंबर = 29 के साथ चलाया, तो यह मुझे परिणाम देता है = "सीए" ("एसी" के बजाय) कोई भी टिप्पणी जो मुझे याद आ रही है? मुझे पता है कि मैं इसे StringBuilder द्वारा उल्टा कर सकता हूं .... लेकिन ग्राहम के जवाब को देखते हुए, मैं थोड़ा भ्रमित हूं ...।

Comments

ग्राहम कहते हैं: columnName = Convert.ToChar(65 + modulo).ToString() + columnName(अर्थात मान + ColName)। हसन कहते हैं: columnName += val;(यानी ColName + मूल्य)

— mcalex

आप इसे प्रस्तुत करने के बजाय नए वर्ण को जोड़ रहे हैं। होना चाहिए columnName = columnName + val।

— द्वि।

Answer 28

सिक्का और सुरुचिपूर्ण रूबी संस्करण:

def col_name(col_idx)
    name = ""
    while col_idx>0
        mod     = (col_idx-1)%26
        name    = (65+mod).chr + name
        col_idx = ((col_idx-mod)/26).to_i
    end
    name
end

Answer 29

यह सभी अन्य लोगों के साथ-साथ Google का भी पुनर्निर्देशन है, इसलिए मैं इसे यहां पोस्ट कर रहा हूं।

इनमें से कई उत्तर सही हैं, लेकिन साधारण परिस्थितियों के लिए बहुत ही बोझिल हैं जैसे कि आपके पास 26 से अधिक कॉलम नहीं हैं। यदि आपको कोई संदेह है कि क्या आप दोहरे चरित्र स्तंभों में जा सकते हैं, तो इस उत्तर को अनदेखा करें, लेकिन यदि आप सुनिश्चित हैं कि आप नहीं करेंगे, तो आप इसे C # में भी उतना ही सरल बना सकते हैं:

public static char ColIndexToLetter(short index)
{
    if (index < 0 || index > 25) throw new ArgumentException("Index must be between 0 and 25.");
    return (char)('A' + index);
}

बिल्ली, यदि आप इस बात को लेकर आश्वस्त हैं कि आप क्या कर रहे हैं तो आप सत्यापन को हटा सकते हैं और इस इनलाइन का उपयोग कर सकते हैं:

(char)('A' + index)

यह कई भाषाओं में बहुत समान होगा ताकि आप इसे आवश्यकतानुसार अनुकूलित कर सकें।

यदि आप 100% सुनिश्चित हैं कि आपके पास 26 से अधिक कॉलम नहीं हैं , तो केवल इसका उपयोग करें ।

Answer 30

यहाँ जवाब के लिए धन्यवाद !! Google शीट एपीआई के साथ कुछ बातचीत के लिए इन सहायक कार्यों के साथ आने में मेरी मदद की जो कि मैं अमृत और फीनिक्स में काम कर रहा हूं

यहाँ मैं क्या साथ आया था (शायद कुछ अतिरिक्त सत्यापन और त्रुटि से निपटने का उपयोग कर सकता है)

अमृत ​​में:

def number_to_column(number) do
  cond do
    (number > 0 && number <= 26) ->
      to_string([(number + 64)])
    (number > 26) ->
      div_col = number_to_column(div(number - 1, 26))
      remainder = rem(number, 26)
      rem_col = cond do
        (remainder == 0) ->
          number_to_column(26)
        true ->
          number_to_column(remainder)
      end
      div_col <> rem_col
    true ->
      ""
  end
end

और उलटा कार्य:

def column_to_number(column) do
  column
    |> to_charlist
    |> Enum.reverse
    |> Enum.with_index
    |> Enum.reduce(0, fn({char, idx}, acc) ->
      ((char - 64) * :math.pow(26,idx)) + acc
    end)
    |> round
end

और कुछ परीक्षण:

describe "test excel functions" do
  @excelTestData [{"A", 1}, {"Z",26}, {"AA", 27}, {"AB", 28}, {"AZ", 52},{"BA", 53}, {"AAA", 703}]

  test "column to number" do
    Enum.each(@excelTestData, fn({input, expected_result}) ->
      actual_result = BulkOnboardingController.column_to_number(input)
      assert actual_result == expected_result
    end)
  end

  test "number to column" do
    Enum.each(@excelTestData, fn({expected_result, input}) ->
      actual_result = BulkOnboardingController.number_to_column(input)
      assert actual_result == expected_result
    end)
  end
end