सेल संकेतन की गणना करें

Question

इसलिए हम सभी उम्मीद करते हैं कि स्प्रेडशीट 'A1' सेल नोटेशन से परिचित हो।

यह बस एक ग्रिड के भीतर उक्त सेल की स्थिति का एक अल्फ़ान्यूमेरिक प्रतिनिधित्व है। अक्षर (s) सेल के स्तंभ स्थिति का प्रतिनिधित्व करते हैं, और संख्या पंक्ति का प्रतिनिधित्व करती है।

'अक्षर' भाग में 26 अक्षर अंग्रेजी वर्णमाला के 1 या अधिक अक्षर शामिल हो सकते हैं, जिनमें से सभी में बड़े अक्षर होने चाहिए। ये मानचित्र 26-adic bijective numeration के उपयोग से संख्याओं में आते हैं। 'नंबर' भाग में कोई भी धनात्मक, गैर-शून्य पूर्णांक हो सकता है।

---

चुनौती, एक प्रोग्राम लिखिए जिसने किसी भी सेल को एक स्ट्रिंग के रूप में A1 संकेतन दिया है, एक संख्या के रूप में प्रतिनिधित्व स्तंभ स्थिति से युक्त स्ट्रिंग का उत्पादन कर सकता है, इसके बाद एक स्थान और फिर पंक्ति संख्या।

नीचे नमूना इनपुट / आउटपुट:

A1
>>1 1
B10
>>2 10
AC4 
>>29 4
AAC753
>>705 753
F123
>>6 123
GL93
>>194 93

यह मेरी पहली चुनौती है, इसलिए मानदंडों की सापेक्ष सादगी और संभावित दरिद्रता।

EDIT : स्ट्रिंग में अक्षरों के बाद नंबर होना चाहिए और जीतने का मापदंड सबसे कम कोड की लंबाई है (यदि वह चीज हो सकती है)

EDIT : इस से संबंधित है लेकिन एक अलग शुरुआत सूचकांक के साथ रिवर्स प्रक्रिया करता है। कुछ लोग यह तर्क दे सकते हैं कि यह तथ्य लिंक की गई पहेली को अधिक रोचक बनाता है।

Comments

क्या हम इनपुट के रूप में ले सकते हैं, उदाहरण के लिए, अक्षरों और संख्याओं से युक्त एक सरणी:["A", "1"]

— स्टीफन

@ स्टेपहेन नं। यह एक ही तार होना चाहिए जिसमें अक्षर और संख्या दोनों हों। मुझे शायद जोड़ना चाहिए, यह भी, कि संख्याओं के बाद पत्र के क्रम में स्ट्रिंग होना चाहिए।

— dbr

हम आम तौर पर अधिक लचीले इनपुट और आउटपुट फॉर्मेट की अनुमति देते हैं, जैसे कि आउटपुट सेपरेटर के रूप में स्पेस के बजाय न्यूलाइन चुनना

— लुइस मेंडो

@ डीनब्रंट यह आप पर निर्भर करता है, और निश्चित रूप से आप चुनौती को और अधिक कठिन बनाने के लिए एक सख्त प्रारूप लागू कर सकते हैं। लेकिन लोग आमतौर पर प्रारूप में की तुलना में वास्तविक गणना में कठिनाई का आनंद लेते हैं

— लुइस मेंडू

ऐसा इसलिए है क्योंकि स्वरूपण वास्तविक चुनौती के लिए स्वयं कोई मूल्य नहीं जोड़ता है

— अदनान

Answer 1

05AB1E , 12 11 बाइट्स

áÇ64-₂βð¹þJ

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

Answer 2

Microsoft Excel, 43 बाइट्स।

=COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A1))

मैं अपने आप को मदद नहीं कर सका, मुझे बस काम के लिए सही उपकरण का उपयोग करना पड़ा। A1 पर इनपुट लेता है।

परीक्षण के मामलों

Answer 3

Microsoft Excel, 40 बाइट्स

ब्राज़ीलियाई पुर्तगाली भाषा का संस्करण।

=COL(INDIRETO(A1))&" "&LIN(INDIRETO(A1))

ATaco के समाधान के अनुवादित (और इसलिए गोल्फ वाले) संस्करण ।

Comments

मुझे याद नहीं है कि अगर एक्सेल शीट्स की अनुमति देता है, लेकिन क्या आप किसी अन्य उत्तर पर @ यूरील द्वारा सुझाव का उपयोग कर सकते हैं और अंतिम 2 कोष्ठक खो सकते हैं?

— dbr

यह सुझाव (दाएं पैरेंट को छोड़ना) एक्सेल में एक चेतावनी फेंकता है कि आपको आगे बढ़ने की पुष्टि करनी है, इसलिए मुझे नहीं लगता कि यह यहां अनुमति है।

— पाजोंक

ओह समझा। यह चादर के लिए अलग है।

— dbr

Answer 4

पायथन 2 , 94 91 73 बाइट्स

^{-3 बाइट्स धन्यवाद जोनाथन एलन
-18 बाइट्स टीटीएस के लिए धन्यवाद}

s=input().strip
a=s(`3**39`);t=0
for n in a:t=t*26+ord(n)-64
print t,s(a)

इसे ऑनलाइन आज़माएं!

यह उस तरीके का दुरुपयोग .stripकरता है जो काम करता है, सभी अंकों को हटाकर wtih a=s(`3**39`)जहां `3**39`से अंकों को उत्पन्न करने के लिए सिर्फ एक छोटा तरीका 0है 9, यह केवल उन वर्णों को संग्रहीत aकरेगा जिनका उपयोग संख्याओं से वर्णों को छीनने के लिए किया जाएगाs(a)

Comments

मुझे नहीं लगता stripकि अद्वितीय चरित्र होने के लिए इनपुट की आवश्यकता है , इसलिए 3**39समान काम करना चाहिए।

— जोनाथन एलन

73 बाइट्स

— tsh

Answer 5

Google शीट, 43 बाइट्स

=COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A1))

इसे ऑनलाइन आज़माएं!

A1इनपुट सेल है। उम्मीद है कि उपरोक्त लिंक काम करता है, मैंने पहले कभी भी Google शीट के साथ कोड गोल्फ की कोशिश नहीं की है।

Comments

@ATaco कोई कारण नहीं है, जैसा कि डुप्लिकेट उत्तर सह-अस्तित्व में हो सकता है।

— कॉनर ओ'ब्रायन

Google पत्रक और Microsoft Excel उत्तर की उपस्थिति मुझे प्रसन्न करती है।

— dbr

आप =COLUMN(INDIRECT(A1))&" "&ROW(INDIRECT(A141 बाइट्स के लिए कर सकते हैं । चादरें दाएं पैरेंस को गायब कर देती हैं।

— यूरेल

Answer 6

जावास्क्रिप्ट, 72 बाइट्स

x=>x.replace(/\D+/,s=>[...s].reduce((n,v)=>n*26+parseInt(v,36)-9,0)+' ')

Answer 7

प्रोटॉन , 113 बाइट्स

k=>{b=(s=k.strip)('0123456789');str(sum(map((a=>26**a[1][0]*(ord(a[1][1])-64)),enumerate(b[to by-1]))))+' '+s(b)}

इसे ऑनलाइन आज़माएं!

-19 बाइट्स रॉड के एल्गोरिथ्म को उधार ( स्वयं पर ध्यान दें: सूची जोड़ें )

Answer 8

दिल्लोग एपीएल, 44 बाइट्स

(26⊥¯65+⎕AV⍳(a~⎕D)),⎕A~⍨a←⍞

इसे ऑनलाइन आज़माएं!

Comments

चारों ओर कोष्ठक निकालें (a~⎕D)। के ⎕Aबजाय देखो ⎕AV। टेकिट करें। का स्वैप तर्क ,। केवल 16 बाइट्स तक जाता है:~∘⎕A,⍨26⊥⎕A⍳~∘⎕D

— Adám

Answer 9

पायथ - 31 बाइट्स

पहला प्रयास, बहुत भोला।

jd,s*V.u*26NQ1_hMxLGr-QK@`UTQZK

इसे यहाँ ऑनलाइन आज़माएँ ।

Answer 10

पर्ल 5 , 35 + 1 (-पी) = 36 बाइट्स

map$r=$r*26-64+ord,/\D/g;s/\D*/$r /

इसे ऑनलाइन आज़माएं!

mapबयान व्यवहार करता है एक base26 संख्या है और रूपांतरित यह दशमलव में तरह स्तंभ। प्रतिस्थापन संख्याओं के साथ अक्षरों को बदलता है। इनपुट और आउटपुट -pध्वज में निहित हैं ।

Answer 11

गणितज्ञ, 108 बाइट्स

StringReplace[c:LetterCharacter..~~r:DigitCharacter..:>ToString@FromDigits[ToCharacterCode@c-64,26]<>" "<>r]

ऑपरेटर रूप, StringReplaceजो cस्ट्रिंग के अल्फ़ाबेटिक भाग को लेता है , इसे वर्ण कोड की सूची में परिवर्तित करता है, 64प्रत्येक कोड बिंदु से घटाता है, परिणाम को आधार 26पूर्णांक के रूप में व्याख्या करता है, उस पूर्णांक को a में परिवर्तित करता है String, फिर StringJoinएक स्थान को संख्यात्मक भाग के द्वारा परिवर्तित करता है r।

एक रेगीक्स का उपयोग करना ( 108बाइट्स भी ):

StringReplace[RegularExpression["([A-Z]+)(.+)"]:>ToString@FromDigits[ToCharacterCode@"$1"-64,26]<>" "<>"$2"]

Comments

ToCharacterCode@c-64कभी-कभी कम किया जा सकता है LetterNumber@c। जब इनपुट एकल वर्ण है, LetterNumberतो आउटपुट को लपेटता नहीं है List।

— जंघवान मिन

Answer 12

जेली ,  16  15 बाइट्स

ØAɓi@€ḟ0ḅ26,⁸Kḟ

एक पूर्ण कार्यक्रम एक स्ट्रिंग को तर्क के रूप में स्वीकार करता है और परिणाम को प्रिंट करता है

इसे ऑनलाइन आज़माएं!

कैसे?

ØAɓi@€ḟ0ḅ26,⁸Kḟ - Main link: list of characters, ref  e.g. "AAC753"
ØA              - uppercase alphabet yield               = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  ɓ             - dyadic chain separation, call that B and place it on the right
   i@€          - first index for €ach (swap arguments)    [1,1,3,0,0,0]
      ḟ0        - filter discard zeros                     [1,1,3]
        ḅ26     - convert from base 26 to integer           705
            ⁸   - chain's left argument (ref)              "AAC753"
           ,    - pair                                     [705,['A','A','C','7','5','3']]
             K  - join with spaces                         [705,' ','A','A','C','7','5','3']
              ḟ - filter discard those in right (B)        [705,' ','7','5','3']
                - implicit print                        >>>705 753

नोट: आधार रूपांतरण परमाणु का उपयोग करके संख्याओं की सूची से रूपांतरण ḅस्थानों को अपेक्षित सीमा से बाहर होने की अनुमति देता है, इसलिए, रूपांतरण, कहते हैं, [2,26,1]( "BZA") का उपयोग करके 2 × 26 ² + 26 × 26 ¹ + 1 × 26 ⁰ = केḅ26 रूप में गणना की जाती है। 2029 भले ही "अपेक्षित" प्रतिनिधित्व रहा हो ।[3,0,1]

Comments

@ डीन ब्रंट किसी उत्तर को इतनी जल्दी स्वीकार करना सामान्य नहीं है (अधिकांश इसे सप्ताह में छोड़ते हैं) - यह दूसरों को प्रतिस्पर्धा से हतोत्साहित कर सकता है। मुझे यह देखकर आश्चर्य नहीं होगा कि इसे 05AB1E या किसी अन्य गोल्फ भाषा द्वारा पीटा गया है ...

— जोनाथन एलन

मुद्दा लेना। अभी भी मेरी तरह से सीखना

— dbr

कोई दिक्कत नहीं है! PPCG में आपका स्वागत है, और अच्छी पहली पोस्ट :)

— जोनाथन एलन

Answer 13

गणितज्ञ, 77 72 69 68 बाइट्स

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&

पात्रों की एक सूची लेता है।

इसे वुल्फ्राम सैंडबॉक्स पर आज़माएं

प्रयोग

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[{"G", "L", "9", "3"}]

{194, 93}

या

#/.{a__,b__?DigitQ}:>{f=FromDigits;f[LetterNumber@{a},26],f[b<>""]}&[Characters["GL93"]]

{194, 93}

व्याख्या

#/.

इनपुट में बदलें ...

{a__,b__?DigitQ}

दो अनुक्रमों वाली एक सूची aऔर b(1 या अधिक तत्वों के साथ), जहांb केवल अंकों के अक्षर होते हैं ... (गणितज्ञ आलसी पैटर्न मिलान का उपयोग करता है, इसलिए किसी भी चेक की आवश्यकता नहीं है a)

:>

में ...

f=FromDigits;

सेट fडिजिट-से-पूर्णांक रूपांतरण फ़ंक्शन पर ।

LetterNumber@{a}

धर्मांतरित aअक्षर संख्या (a -> 1, b -> 2, आदि) में ।

{f[ ... ,26],f[b<>""]}

ऊपर के बेस -26 को दशमलव में बदलें, और bदशमलव में परिवर्तित करें।

Answer 14

हास्केल, 67 बाइट्स

(\(l,n)->show(foldl(\a->(a*26-64+).fromEnum)0l)++" "++n).span(>'9')

इसे ऑनलाइन आज़माएं।

Answer 15

रेटिना , 85 बाइट्स

[A-Z]
$& 
[T-Z]
2$&
[J-S]
1$&
T`_L`ddd
\d+
$*
{`\G1(?=.* .* )
26$*
}` (.* )
$1
1+
$.&

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

[A-Z]
$& 

अक्षरों को एक दूसरे से और अंतिम संख्या से अलग करें।

[T-Z]
2$&
[J-S]
1$&
T`_L`ddd

अक्षरों को दशमलव में बदलें।

\d+
$*

सबकुछ एकतरफा कर दो।

{`\G1(?=.* .* )
26$*
}` (.* )
$1

जबकि कम से कम तीन संख्याएँ हैं, पहले को 26 से गुणा करें और दूसरे में जोड़ें।

1+
$.&

सब कुछ दशमलव में परिवर्तित करें।

Answer 16

रूबी , 50 48 + 1 = 51 49 बाइट्स

-pझंडे का उपयोग करता है । -2 बाइट्स से m-chrzan।

sub(/\D+/){i=0;$&.bytes{|b|i=26*i+b-64};"#{i} "}

इसे ऑनलाइन आज़माएं!

Comments

i=i*26+b-642 बाइट्स बचाता है।

— m-chrzan

Answer 17

> <>, 42 बाइट्स

0i88*-:0(?\$2d**+!
$n88*+48*o\
oi:0(?;   >

यह ऑनलाइन की कोशिश करो

स्पष्टीकरण:

0i88*-:0(?\$2d**+! Read in the Letters part of the input
0                  Push an initial 0 to the stack
 i                 Read a character of input
  88*-             Subtract 64 to get from the ascii code to its value ('A'=1,'B'=2 etc.)
      :0(?\        If the value is less than 0, break out of this loop
           $2d**   Multiply our accumulator by 26
                +  Add our new number to the accumulator
                 ! don't add a new zero to the stack

उपरोक्त लूप टूटने से पहले संख्या भाग के भाग (उदाहरण के लिए "AB34" में "3 '") को पढ़ेगा, और इससे पहले ही 64 घटा देगा, इसलिए अगले बिट कोड से निपटना होगा

$n88*+48*o\        Output a space, and prepare to output the first number we read in during the previous loop
          \        Loop round to the left end of this line
$n                 Output the value of the letters part as a number
  88*+             Add the 64 we subtracted from the first number
      48*o         Output a space
          \        Enter the next loop

यह लूप एक चरित्र को आउटपुट करने से शुरू होता है जो या तो पहले लूप द्वारा पढ़ा गया वर्ण होगा, या इस लूप के पिछले पुनरावृत्ति द्वारा पढ़ा गया चरित्र।

oi:0(?;   >        Output the numbers part, by just echoing it
          >        Loop round to the start of the line
o                  Output the character
 i                 Read in the next character
  :0(?;            If the value read in was less than 0, terminate

Answer 18

रूबी, 64 61 59 बाइट्स

->s{s.sub(/\D+/){"#{$&.bytes.reduce(0){|t,b|t*26+b-64}} "}}

मूल्य स्याही के लिए 2 बाइट्स सहेजे गए।

Comments

$&अंतिम रेगेक्स मैच है, इसलिए m2 बाइट बचाने के लिए इसका उपयोग करें ।

— मूल्य इंक

Answer 19

एक्सेल- VBA तत्काल विंडो, 44 45 बाइट्स ( 36 35)

Set v=Range([A1]):?trim(v.Column &" "&v.Row);

अनुगामी न्यूलाइन को दबाने के लिए 1 बाइट जोड़ी गई

---

या प्रमुख व्हाट्सएप के साथ 35 के लिए

Set v=Range([A1]):?v.Column""&v.Row

1 बाइट ने @TaylorScott को धन्यवाद दिया!

दोनों सेल A1 से इनपुट लेते हैं, आउटपुट VBE इमीडिएट विंडो में जाते हैं

Comments

मैं आगे जा रहा हूं और कहता हूं कि प्रमुख व्हाट्सएप उत्तर एक वैध प्रतिक्रिया है क्योंकि इसे हटाने के लिए Trim()लगभग सभी संख्यात्मक उत्तरों का उपयोग करने के लिए मजबूर किया जाएगा - और उस पर मैं Set v=Range([A1]):?v.Column""&v.Rowआपके वर्तमान समाधान के साथ नहीं जाऊंगा

— टेलर स्कॉट

भी, झल्लाहट, मुझे विश्वास नहीं हो रहा है कि मैं इस सवाल से चूक गया जब यह सामने आया!

— टेलर स्कॉट

@TaylorScott "" का उपयोग करके ओह अच्छी चाल - मुझे लगता है कि एक्सेल को पता है कि ;जब चरित्र निम्नलिखित Columnनियमित नाम का हिस्सा नहीं हो सकता है। मुझे आश्चर्य है कि अगर एक ही चरित्र है जो एक ही काम कर सकता है, तो शायद नहीं। हां, मैंने अनुमान लगाया होगा कि अग्रणी स्थान अधिकांश क्यूस के लिए स्वीकार्य होगा, लेकिन इसके लिए मुझे लगता है कि यह " सटीक स्ट्रिंग का प्रिंट" अधिक है । मैंने पूछा (प्रश्न पर अंतिम टिप्पणी) और कहा गया था कि कोई प्रमुख स्थान या न्यूलाइन नहीं है।

— लालडू

इसके अलावा, जब मैंने प्रश्न शीर्षक देखा, तो मुझे तुरंत पता था कि मुझे जाना चाहिए अगर आप या कोई और पहले से ही नहीं था! जैसा कि अन्य एक्सेल-आधारित उत्तर कहते हैं, नौकरी के लिए सही उपकरण ।

— गिडो

Answer 20

लूआ, 127 बाइट्स

कुछ अच्छे स्ट्रिंग जोड़तोड़ वहाँ जा रहे हैं, मैं कुछ फ़ंक्शन का उपयोग कर रहा हूं जो आमतौर पर लुआ में गोल्फ करते समय कभी भी उपयोग नहीं किए जाते हैं: डी। गोल्फ का सबसे अच्छा तरीका यह होगा कि इनपुट के स्तंभ भाग पर पुनरावृति करने का एक और तरीका ढूंढा जाए, जबकि प्रत्येक अक्षर की स्थिति को बनाए रखने में सक्षम हो। मैंने ^ ^ नहीं किया।

इसे ऑनलाइन आज़माएं!

I=...l=I:gsub("%d",""):reverse()r=0
for i=1,#l
do
r=r+(l:sub(i,i):byte()-64)*math.pow(26,i-1)end
print(r.." "..I:gsub("%a",""))

व्याख्या

I=...                       -- shorthand for the input
l=I:gsub("%d","")           -- shorthand for the column part
   :reverse()               -- letters are put in reverse order to calculate their weight
r=0                         -- column number
for i=1,#l                  -- iterate over the letters of the input
do
  r=r+                      -- add to the column number
      (l:sub(i,i):byte()-64)-- the byte value of the current letter minus 64 (A=1 this way)
      *math.pow(26,i-1)     -- then apply its weight in base 26
end
print(r                     -- output the column number
        .." "               -- a space
        ..I:gsub("%a",""))  -- and the row number