अंतिम अंक बड़ी संख्या

Question

संख्या की दी गई सूची के लिए का अंतिम अंक खोजें : उदाहरण:x x x … x n 3 2$[x_1, x_2, x_3, ..., x_n]$$x_1 ^{x_2 ^ {x_3 ^ {\dots ^ {x_n}}}}$

[3, 4, 2] == 1
[4, 3, 2] == 4
[4, 3, 1] == 4
[5, 3, 2] == 5   

क्योंकि ।$3 ^ {(4 ^ 2)} = 3 ^ {16} = 43046721$

क्योंकि ।$4 ^ {(3 ^ 2)} = 4 ^ {9} = 262144$

क्योंकि ।$4 ^ {(3 ^ 1)} = 4 ^ {3} = 64$

क्योंकि ।$5 ^ {(3 ^ 2)} = 5 ^ {9} = 1953125$

नियम:

यह कोड गोल्फ है, इसलिए सबसे कम बाइट जीतता है।

यदि आपकी भाषा में पूर्णांक आकार की सीमाएँ हैं (उदाहरण ) n तो पर्याप्त छोटी होगी कि योग पूर्णांक में फिट होगा।$2^{32}-1$

इनपुट किसी भी उचित रूप में हो सकता है (स्टडिन, फ़ाइल, कमांड लाइन पैरामीटर, पूर्णांक, स्ट्रिंग, आदि)।

आउटपुट कोई भी उचित रूप हो सकता है (स्टडआउट, फ़ाइल, चित्रमय उपयोगकर्ता तत्व जो संख्या प्रदर्शित करता है, आदि)।

कोड युद्धों पर देखा।

Comments

एक प्रश्न मेरे पास है: अपनी पोस्ट में आप केवल एस के बारे में बात करते हैं number। क्या आप सकारात्मक पूर्णांक विशेष रूप से मतलब है? मुझे लगता है कि इसकी व्याख्या कैसे की गई।

— जोनाथन फ्रीच

क्या इनपुट को रिवर्स में लेना उचित है? क्या इनपुट शून्य हो सकता है?

— निएडजेककोब

मुझे लगता है कि आप शर्तों की राशि के लिए सीमा का इरादा रखते हैं, और इस तरह दिनचर्या कि वास्तविक राशि की गणना करते हैं, तो इसे विफल होना चाहिए। जैसे इनपुट [999999,213412499,34532599,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]मान्य है और परिणाम होना चाहिए 1यदि हां, तो इस प्रश्न को स्पष्ट करने की आवश्यकता है क्योंकि आपके पास उत्तोलित उत्तर हैं जो इसे हल नहीं करते हैं (संकेत - modलूप के अंदर स्थानांतरित करें )। शायद कुछ उदाहरण जोड़ें जो इसे स्पष्ट करते हैं।

— नील स्लेटर

वास्तव में मेरे उदाहरण से परिणाम है 9। इसे लागू करने के लिए आवश्यक अंकों में कमी की योजना इस समस्या को हल करने वाले वास्तविक उत्तरों की तुलना में बहुत अधिक दिलचस्प है।

— नील स्लेटर

प्रिय ओपी, हमें और अधिक परीक्षण मामलों की आवश्यकता है।

— 12 बजकर

Answer 1

जावास्क्रिप्ट (ईएस 7), 22 बाइट्स

सीमित ।$2^{53}-1$

a=>eval(a.join`**`)%10

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

Comments

पृथ्वी पर क्या है, यह काम क्यों करता है ?!

— कालेब जय

@ komali_2: **जावास्क्रिप्ट का प्रतिपादक ऑपरेटर है। बाकी सब बहुत सीधा है।

— शैगी

@ komali_2 a.join`**` के बराबर है a.join(['**'])और ['**']करने के लिए मजबूर कर रहा है '**'द्वारा joinविधि।

— Arnauld

मुझे लगता है कि ओपी का इरादा है कि सीमा मूल्यों के योग पर है, इस मामले में यह समस्याओं को हल नहीं करता है।

— नील स्लेटर

@AJFaraday% 10 अंत में किसी भी संख्या को 10 से विभाजित करने पर, शेष (मापांक) हमेशा अंतिम अंक n % 10होगा , इसलिए अंतिम अंक वापस आ जाएगाn

— स्किड्सदेव

Answer 2

आर , 25 बाइट्स

Reduce(`^`,scan(),,T)%%10

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

Comments

यकीन नहीं होता कि लोगों को इस जवाब में क्या पसंद आया।

— एनजीएम

मैं व्यक्तिगत रूप Reduceसे इस्तेमाल होते देखना पसंद करता हूं ।

— JayCe

Answer 3

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

(`mod`10).foldr1(^)

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

Answer 4

एचपी 49 जी आरपीएल, 36.5 बाइट्स

इसे APPROX मोड में चलाएं (लेकिन EXACT मोड में प्रोग्राम दर्ज करें)। स्टैक पर इनपुट को स्टैक में पहले तत्व के साथ सबसे गहरे में ले जाता है, पूर्णांक या वास्तविक के रूप में।

WHILE DEPTH 1 - REPEAT ^ END 10 MOD

यह स्टैक पर सीधा एक्सफ़ोलिएंट करता है जैसे कि सोफिया के समाधान में जब तक एक मूल्य शेष नहीं होता है, तब अंतिम अंक प्राप्त करने के लिए इसे मॉड 10 लेता है।

गणना के लिए मैं APPROX का उपयोग करने का कारण यह है क्योंकि 0.0 ^ 0.0 = 1 (जब वे दोनों वास्तविक हैं), लेकिन 0 ^ 0 =? (जब वे दोनों पूर्णांक हैं)। APPROX सभी पूर्णांकों को वास्तविक बनाता है, इसलिए इनपुट या तो ठीक है। हालांकि, मैं प्रोग्राम में प्रवेश करने के लिए EXACT का उपयोग करता हूं क्योंकि 10 (पूर्णांक) अंक-बाई-डिजिट संग्रहीत है, और 6.5 बाइट्स है, लेकिन 10.0 (असली) एक पूर्ण वास्तविक संख्या के रूप में संग्रहीत है, और 10.5 बाइट्स है। मैं आरपीएल के कम (STREAM कहा जाता है) का उपयोग करने से भी बचता हूं क्योंकि यह एक अतिरिक्त प्रोग्राम ऑब्जेक्ट का परिचय देता है, जो ओवरहेड के 10 बाइट्स है। मेरे पास पहले से ही एक है और दूसरा नहीं चाहता।

HP 49G वास्तविक (12 दशमलव अंक) की सटीकता तक सीमित

-10 बाइट्स खाली सूची के बाद -> 1 आवश्यकता को हटा दिया गया था।

स्टैक पर इनपुट लेकर -2 बाइट्स।

Comments

अरे, क्या आप बता सकते हैं कि बायटेकाउंट की गणना कैसे की जाती है? बस उत्सुक है कि कैसे भाषा nibbles का उपयोग करता है ।

— जुंगह्वान मिन

@JungHwanMin HP 49G एक 4-बिट प्रोसेसर और BCD अंकगणित का उपयोग करता है, क्योंकि यह एक कैलकुलेटर है। अंतरिक्ष को बचाने के लिए आंतरिक रूप से अधिकांश कमांड 2.5 बाइट पॉइंटर्स में परिवर्तित हो जाते हैं, जिनका वे प्रतिनिधित्व करते हैं। छोटी संख्या (0-9) भी इस तरह से रूपांतरित होती हैं।

— जेसन

सैटर्न प्रोसेसर वास्तव में काम करने के लिए बहुत मजेदार है। एक लंबे समय पहले, मैंने लिखा BurgerTime के इस बंदरगाह हिमाचल प्रदेश 48G (एक्स) के लिए (विधानसभा में)। इसे बाद में 49G पर पोर्ट किया गया । अच्छी यादें!

— अरनुलद

Answer 5

डीसी , 17 15 बाइट्स

1[^z1<M]dsMxzA%

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

स्टैक से इनपुट लेता है, स्टैक को आउटपुट देता है। बहुत सीधा क्रियान्वयन - अंतिम अंक के लिए स्टैक और मॉड पर केवल एक मान छोड़े जाने तक एक्सपोर्टरमेट करता है।

दो बाइट बचाने के लिए brhfl का धन्यवाद!

Comments

आप को बदलने के द्वारा गोल्फ एक बाइट कर सकते हैं 10%करने के लिए A%-, और ढेर गहराई दो बार की जाँच नहीं द्वारा एक और बाइट सिर्फ एक डाल 1: के बाद से n ^ 1 == n निष्पादित करने से पहले ढेर के ऊपर1[^z1<M]dsMxA%

— brhfl

अच्छे विचार! मुझे नहीं पता था कि dc मुझे Aदशमलव इनपुट के लिए सेट करते समय शाब्दिक के रूप में उपयोग करने देगा। शुक्रिया @brhfl!

— सोफिया लेचनर

@SophiaLechner यह ट्रिक सभी इनपुट बेस के लिए काम करती है: codegolf.stackexchange.com/a/77728/11259

— डिजिटल ट्रॉमा

Answer 6

जे , 5 बाइट्स

-3 बाइट्स कोल करने के लिए धन्यवाद!

10|^/

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

Comments

करता है 10|^/काम नहीं?

— कोल

@ बेशक यह काम करता है, धन्यवाद!

— गैलेन इवानोव

अंत में, एक चुनौती जहां जे जैली की पिटाई करता है!

— योना

Answer 7

05AB1E , 4 बाइट्स

.«mθ

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

व्याख्या

.«     # fold
  m    # power
   θ   # take the last digit

Comments

जहाँ तक के रूप में मैं वाकिफ हूँ, ढेर-आधारित भाषाओं मान सकते हैं इनपुट STDIN या विकल्प के बजाय ढेर पर मौजूद है, तो कुछ इस 4 बाइट (वैकल्पिक रूप से, बस जगह के लिए काम करना चाहिए Eशीर्षक में)।

— श्री Xcoder

प्रासंगिक मेटा ।

— मिस्टर एक्सकोडर

मैंने भविष्य के उपयोग के लिए नवीनतम प्रतिबद्ध में इस मुद्दे को तय किया है ।

— अदनान

@ Mr.Xcoder: सही है! मुझे वह याद रखना चाहिए था। तो शायद ही कभी निहित इनपुट के साथ की जरूरत है। धन्यवाद :)

— Emigna

@ Mr.Xcoder उह, मुझे यकीन नहीं है कि अगर मेटा वास्तव में इसका मतलब है। 05AB1E में "फ़ंक्शन" क्या है? मुझे लगता है कि यह केवल एक स्ट्रिंग होना चाहिए, क्योंकि आप इसे एक चर को निर्दिष्ट कर सकते हैं, और इसके साथ eval-ed हो सकते हैं .V। .«mθस्निपेट की तरह अधिक दिखता है, चूंकि, स्वयं, आप इसे बाद के पुन: उपयोग के लिए एक चर को निर्दिष्ट नहीं कर सकते। खैर, अदनान ने अब इस मुद्दे को ठीक कर दिया, लेकिन एह।

— आउटगॉल्फ जूल

Answer 8

शुद्ध बैश (केवल बाहरी उपयोगिताओं का निर्माण), 21

echo $[${1//,/**}%10]

कमांड लाइन पर अल्पविराम से अलग सूची के रूप में इनपुट दिया गया है।

बैश पूर्णांक 64- और 32-बिट संस्करणों के लिए सामान्य हस्ताक्षरित पूर्णांक सीमा के अधीन हैं।

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

Comments

^बिटवॉयर XOR है, यही वजह है कि आप 5सही के बजाय टेस्ट केस से बाहर हो रहे हैं 1। आपको स्विच करने के लिए एक बाइट जोड़ना होगा**

— सोफिया लेचनर

@SophiaLechner हाँ - बेशक - अच्छी पकड़! यह निश्चित नहीं है कि उस ^क्रेप में - **मेरे देव चक्र के पिछले पुनरावृत्तियों में कैसे था ।

— डिजिटल ट्रॉमा

Answer 9

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 16 बाइट्स

Power@##~Mod~10&

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

Answer 10

पायथन 2 और पायथन 3 , 30 बाइट्स

lambda N:eval('**'.join(N))%10

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

इनपुट Nको संख्या शाब्दिकता के स्ट्रिंग निरूपण पर एक पुनरावृत्त वस्तु होने की उम्मीद है ।

Answer 11

रूबी, 41 47 बाइट्स

इनपुट ऐरे में किसी भी 0 को संभालने के कारण आकार में वृद्धि होती है, जिसे अतिरिक्त विचार की आवश्यकता होती है। का शुक्र हैrewritten

->a{a.reverse.inject{|t,n|n<2?n:n**(t%4+4)}%10}

इसे हल किया गया है क्योंकि मेरा मानना ​​है कि मूल स्रोत का इरादा है, यानी बहुत बड़े घातांक के लिए जो भाषा देशी पूर्णांक में फिट नहीं होंगे - प्रतिबंध यह है कि सरणी में योग होगा 2**32-1, न कि अंतरिम गणना भी फिट होने की गारंटी है। वास्तव में यह कोड युद्धों पर चुनौती का बिंदु प्रतीत होगा। हालांकि रूबी के मूल पूर्णांक बहुत बड़े हो सकते हैं, वे अंत में% 10 के साथ भोलेपन से संसाधित उदाहरण के साथ सामना नहीं कर सकते

उदाहरण के लिए

इनपुट: [999999,213412499,34532597,4125159,53539,54256439,353259,4314319,5325329,1242149,142219,1243219,14149,1242149,124419,999999999]

आउटपुट: 9

Comments

प्रभावशाली। एक 4 अधिक बाइट्स खर्च करके, आप बहुत अधिक टावरों के साथ सामना कर सकते हैं: की जगह n**(t%4+4)के साथ n**((t-1)%4+1)ताकि आप n**1के बजाय n**5आदि कुडोस अवलोकन है कि किसी भी स्तर 4 में एक अच्छा चक्र होगा।

— फिर से लिखा

वहाँ एक मुद्दा है अगर अनुक्रम 0s है

— फिर से लिखा

@ शराब पिलाई: अच्छी जगह! मुझे उसके बारे में सोचना पड़ेगा। सिद्धांत में अनुक्रम को पहले शून्य से पहले 2 चरणों को समाप्त करने के लिए मजबूर किया जाना चाहिए।

— नील स्लेटर

वास्तव में, लेकिन इसके लिए बहुत अधिक कोड की आवश्यकता होगी, ठीक 6 बाइट्स: n<2?n:पहले n**।

— फिर से लिखा

Answer 12

05AB1E , 8 बाइट्स

`.gGm}T%

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

Comments

मुझे लगता है कि आप ...gGm}10%(या कुछ गोल्फ खिलाड़ी) मतलब है ।

— जोनाथन एलन

Answer 13

पर्ल 6 , 14 बाइट्स

{([**] $_)%10}

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

ऑपरेटर **, modulo 10 के साथ कटौती मेटा स्क्वायर कोष्ठक का उपयोग करता है।

Answer 14

एपीएल (डायलॉग यूनिकोड) , 5 बाइट्स

10|*⌿

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

Answer 15

सी # (.NET कोर) , 84 बाइट्स

a=>{int i=a.Length-1,j=a[i];for(;i-->0;)j=(int)System.Math.Pow(a[i],j);return j%10;}

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

• -7 बाइट्स @raznagul की बदौलत

Comments

आप कुछ बाइट्स को आसपास के ब्रैकर्स को हटाकर aऔर लूप की स्थिति को डीक्रिमेंट ( for(var i=a.Lengt-1;i-->0;)) के साथ जोड़कर बचा सकते हैं । लेकिन usingबाइट को वह बाइट काउंट में शामिल करना चाहिए।

— raznagul

@raznagul: क्षमा करें, मैं C # में कोड-गोल्फ के लिए बहुत नया हूं, क्या यह अब ठीक है?

— digEmAll

कोई दिक्कत नहीं है। हाँ अब यह ठीक है।

— राजनागुल

आप परिणाम को धारण करने के लिए एक नए चर का उपयोग करके 3 और बाइट्स बचा सकते हैं और सरणी में अधिकांश इंडेक्स एक्सेस को हटा सकते हैं: इसे ऑनलाइन आज़माएं!

— राजनागुल

@raznagul: बढ़िया!

— digEmAll

Answer 16

सी (जीसीसी) , 56

• 4 बाइट्स @JonathanFrech की बदौलत सहेजे गए

r()मैक्रो से रिकर्सिव फ़ंक्शन f- सामान्य स्टैक सीमाएं लागू होती हैं।

R;r(int*n){R=pow(*n,n[1]?r(n+1):1);}
#define f(n)r(n)%10

इनपुट एक शून्य-समाप्त इंट सरणी के रूप में दिया गया है। यह इस धारणा के तहत है कि कोई भी x _n शून्य नहीं है।

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

Comments

) r(-> )r(।

— जोनाथन फ्रेच

इसके अलावा, आप यूबी उपयोग करना चाहते हैं, तो आप गोल्फ कर सकता r(int*n){return powकरने के लिए R;r(int*n){R=pow।

— जोनाथन फ्रेच

Answer 17

जूलिया 0.6 , 30 बाइट्स

first∘digits∘x->foldl(^,x)

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

यह एक आनन फंक्शन है function
कंपोजिशन ऑपरेटर है।
यह कई बाइट्स है

Answer 18

जाप -h , 7 बाइट्स

OvUqp)ì

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

स्पष्टीकरण:

OvUqp)ì
Ov   )    // Japt eval:
   q      //   Join
  U       //   Input with
    p     //   Power method
      ì   // Split into an array of numbers
-h        // Return the last number

Comments

अजीब, जो मेरे लिए काम नहीं करेगा।

— झबरा

6 बाइट्स

— झबरा

@ शैगी : पी

— ओलिवर

आह, जैसिस के लिए! : \ ज्यादा बार हो रहा है!

— झबरा

Answer 19

जाप -h , 7 6 बाइट्स

यदि इनपुट को रिवर्स ऑर्डर में लिया जा सकता है तो पहले वर्ण को हटाया जा सकता है।

तक सीमित है 2**53-1।

Ôr!p ì

कोशिश करो

---

व्याख्या

Ô          :Reverse the array
 r         :Reduce by
  !p       :  Raising the current element to the power of the current total, initially the first element
     ì     :Split to an array of digits
           :Implicitly output the last element

Comments

मुझे ध्वज के बिना सटीक एक ही उत्तर मिला, इसलिए यह अब के लिए सबसे इष्टतम तरीका है।

— लीख

@ निट: जब तक इसकी पुष्टि नहीं हो जाती है तब तक हम इनपुट उल्टा ले सकते हैं :)

— झबरा

@ ओलिवर हाँ, लेकिन आप अभी भी एक ध्वज का उपयोग कर रहे हैं। व्यक्तिगत रूप से मुझे लगता है कि झंडे के बिना बाइट की गिनती सबसे सटीक स्कोरिंग परिणाम है।

— लीख

@ मान मेटा सर्वसम्मति से 3 बाइट्स को जोड़ने वाला झंडा नहीं होना चाहिए?

— लीजनमोनमाल 978

@ LegionMammal978, कोई और नहीं ।

— शैगी

Answer 20

जेली , 6 बाइट्स

U*@/DṪ

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

Answer 21

पायथन 2 , 45 43 बाइट्स

lambda x:reduce(lambda b,a:a**b,x[::-1])%10

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

Answer 22

एक्सेल VBA, 60 बाइट्स

एक अनाम VBE तत्काल विंडो फ़ंक्शन जो रेंज से इनपुट लेता है [A1:XFD1]

s=1:For i=-[Count(1:1)]To-1:s=Cells(1,-i)^s:Next:?Right(s,1)

Answer 23

स्टैक्स , 7 बाइट्स

üT(Çó╖⌐

इसे चलाएं और डीबग करें

मेरे पायथन उत्तर में एल्गोरिथम पसंद है

Answer 24

CJam , 14 बाइट्स

q~_,({~#]}*~A%

किसी भी इनपुट के लिए काम करना चाहिए, क्योंकि CJam 64 बिट पूर्णांकों तक सीमित नहीं है

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

Answer 25

पायथन 3 , 55 बाइट्स

p=lambda l,i=-1:not l or f'{l[0]**int(p(l[1:],0))}'[i:] 

पुराने संस्करण

p=lambda l,i=-1:len(l)and f'{l[0]**int(p(l[1:],0))}'[i:]or 1    (60 bytes)

Comments

ऐसा नहीं होगा p=lambda...? पायथन पुनरावर्ती अनाम लंबोधों को संभाल नहीं सकता है, इसलिए यदि आपको अपने फ़ंक्शन को नाम देने की आवश्यकता है, तो इसे आपके समाधान का हिस्सा होने की आवश्यकता है, और नामकरण कोड-गोल्फ चुनौतियों के लिए अपने बाइट काउंट की ओर गिना जाता है।

— मैपलियन

Answer 26

पायथन 3 , 47 बाइट्स

f=lambda x,y=1:f(x[:-1],x[-1]**y)if x else y%10

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

Answer 27

ब्रेन-फ्लैक , 161 बाइट्स

के लिए +1 शामिल है -r

([][()]){({}[()]<({}<(({}))>[()]){({}<(({})<({}<>)({<({}[()])><>({})<>}{}<><{}>)>)>[()])}{}{}>)}{}({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

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

उदाहरण [3, 4, 2]60 सेकंड से अधिक समय लेता है, इसलिए TIO लिंक का उपयोग करता है [4, 3, 2]।

-rयदि इनपुट 160 की एक बाइट गिनती के लिए उलटे क्रम में लिया जा सकता है हटाया जा सकता है।

# Push stack size -1
([][()])

# While there are 2 numbers on the stack
{({}[()]<

    # Duplicate the second number on the stack (we're multiplying this number by itself)
    ({}<(({}))>[()])

    # For 0 .. TOS
    {({}<

        # Copy TOS
        (({})<

        # Multiple Top 2 numbers
        ({}<>)({<({}[()])><>({})<>}{}<><{}>)

        # Paste the old TOS
        >)

    # End for (and clean up a little)
    >[()])}{}{}

# End While (and clean up)
>)}{}

# Mod 10
({}((()()()()()){})(<>))<>{(({})){({}[()])<>}{}}{}<>([{}()]{})

Answer 28

परी / जीपी , 32 बाइट्स

a->fold((x,y)->y^x,Vecrev(a))%10

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

Answer 29

Z80Golf , 36 बाइट्स

00000000: cd03 80f5 30fa f1f1 57f1 280d 4f41 15af  ....0...W.(.OA..
00000010: 8110 fd47 1520 f818 ef7a d60a 30fc c60a  ...G. ...z..0...
00000020: cd00 8076                                ...v

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

जानवर बल परीक्षण हार्नेस

कच्चे बाइट्स के रूप में इनपुट लेता है। 2 से 8-1 तक सीमित।

व्याख्या

input:
    call $8003    ;      the input bytes
    push af       ; push                 on the stack
    jr nc, input  ;                                   until EOF
    pop af        ; the last byte is going to be pushed twice
    pop af
outer:
    ld d, a       ; d = exponentiation loop counter, aka the exponent
    pop af        ; pop the new base off the stack
    jr z, output  ; The flags are being pushed and popped together with the
                  ; accumulator. Since the Z flag starts as unset and no
                  ; instruction in the input loop modifies it, the Z flag is
                  ; going to be unset as long as there is input, so the jump
                  ; won't be taken. After input is depleted, a controlled stack
                  ; underflow will occur. Since SP starts at 0, the flags
                  ; register will be set to the $cd byte from the very beginning
                  ; of the program. The bit corresponding to the Z flag happens
                  ; to be set in that byte, so the main loop will stop executing
    ld c, a       ; C = current base
    ld b, c       ; B = partial product of the exponentiation loop
    dec d         ; if the exponent is 2, the loop should only execute once, so
                  ; decrement it to adjust that
pow:
    xor a         ; the multiplication loop sets A to B*C and zeroes B in the
mul:              ; process, since it's used as the loop counter
    add c         ; it's definitely not the fastest multiplication algorithm,
    djnz mul      ; but it is the smallest
    ld b, a       ; save the multiplication result as the partial product
    dec d         ; jump back to make the next iteration of either
    jr nz, pow    ; the exponentiation loop or the main loop, adjusting the
    jr outer      ; loop counter in the process
output:           ; after all input is processed, we jump here. We've prepared
    ld a, d       ; to use the result as the next exponent, so copy it back to A
mod:              ; simple modulo algorithm:
    sub 10        ;            subtract ten
    jr nc, mod    ; repeatedly              until you underflow,
    add 10        ; then undo the last subtraction by adding ten
    call $8000    ; output the result
    halt          ; and exit

Answer 30

रूबी , 24 20 बाइट्स

->a{eval(a*'**')%10}

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