14

इस कार्य में आपको A (10000 से कम अंक लंबा) और B (2 ^ 64 से कम) दिया जाएगा, और आपको (A · A · A · ... · A (B बार) के अंतिम अंक की गणना करनी होगी ))।

ए और बी इनपुट एक रिक्त द्वारा अलग लाइन में दिए गए हैं; इनपुट EOF द्वारा समाप्त किए जाते हैं।

इनपुट

34543232321323243242434544533445343432434311112223454323232132324324243454453344534343243431111222345432323213232432424345445334453434324343111122234543232321323243242434544533445343432434311112223454323232132324324243454453344534343243431111222345432323213232432424345445334453434324343111122234543232321323243242434544533445343432434311112223454323232132324324243454453344534343243431111222 22337254775808
38758436543765743875437656358764347568437658743658743454354645645543532487548758475847684756897548758457843758437584758478574857438758436587436587436587643875643856783478743658743658764387564387564378658437658743658743687564387564387564765746576475647564756475465746574675647654765476547534587545689475689748574385743765874585743857843765893748643587438957458754376543265874387564384764367584375874758943267632487564357 54545454123
6777744348435743587643756438765436574587564354375674365645643675 23232    
3875843654376574357 54545454

उत्पादन

प्रतिबन्ध

A ^{B की} गणना करने के लिए किसी इनबिल्ट फंक्शन या ओवरलोडेड ऑपरेटरों का उपयोग न करें (आपको वास्तव में यह गणना करने की आवश्यकता नहीं है)।
सबसे छोटा समाधान जीत!

code-golf math

— विलक्षण
स्रोत

2

क्या ए ** बी के अलावा अन्य चीजों की गणना करने के लिए घातांक ऑपरेटर का उपयोग करने की अनुमति है?

— लोजैकर

मुझे लगता है कि ए और बी दोनों गैर-नकारात्मक हैं?

— आआआआआआआआआआआ आआआआ

9

जे - ५२ अक्षर

wd,.10|(^12+12&|)/"1(".@{:`".;._2@,&'x ');._2(1!:1)3

दिए गए सभी परीक्षणों को पास करता है, हालांकि केवल तभी जब तीसरे इनपुट पर अनुगामी रिक्त स्थान हटा दिया जाता है (मुझे लगता है कि यह अनजाने में था)।

सॉल्यूशन मोड में j602 में सॉल्यूशन काम करेगा (जैसे टर्मिनल, ईमैक जे-शेल, आदि)। यह j701 (नहीं wd) में काम नहीं करेगा ।

स्पष्टीकरण और गणित:

'मैजिक नंबर' 12 अन्य उत्तरों में मिली "अंतिम अंक" टेबल की लंबाई का LCM है। सभी अंक 1,2,3 या 4 की अवधि के साथ दोहराए जाते हैं, इसलिए वे भी अवधि 12 के साथ दोहराएंगे। बारह को उन फिक्स मामलों में जोड़ना जहां b mod 12 = 0. मेरा समाधान गणना करता है (A का अंतिम अंक) ^ (12+ (B mod) 12)), एक ही अंतिम अंक के साथ एक संख्या दे रहा है। (मुझे एक छोटा सा टूटा हुआ घोल माना जाता है, उदाहरण के लिए B वर्ण 96 का उपयोग करके तीन वर्णों '12 + 'को समाप्त करना, जहाँ कोई उदाहरण टकराने की संभावना नहीं थी ...)

— जेसी मिलिकन
स्रोत

6

पायथन ~~125~~ 107 चार्ट

ओ (1) समाधान

while 1:a,b=map(int,raw_input().split());d=1;exec"d*=a;"*(b%4);c=a%5and d%5;print b/~b+1or c+[0,5][c%2-a%2]

— fR0DDY
स्रोत

अच्छा 1।

— Quixotic

6

गोल्फक्राफ्ट 21

~]2/{~.(4%)and?10%n}/

यह मूल रूप से गणना करता है A^C mod 10कि C कहाँ सीमा में है [1,4]और C mod 4 = B mod 4, B को छोड़कर यदि 0 है, तो C भी 0 है।

यह शॉर्टकट संभव है क्योंकि A^(B+4) mod 10 = A^B mod 10किसी भी गैर-नकारात्मक पूर्णांक A और धनात्मक पूर्णांक B के लिए।

— aaaaaaaaaaaa
स्रोत

5

जे, 79 ९

,._2(4 :'10|x^(+y&(|~))x{10$1 1 4 4 2')/\x:".(]_1&{.`];._2~(' ',LF)e.~])(1!:1)3

— Eelvex
स्रोत

वाह यह बदसूरत है! मुझे याद दिलाएं कि यह भाषा नहीं सीखनी चाहिए। इसके साथ लगाने के लिए +1।

— कालेब

5

रूबी, 97 93 72 71 67 61 60

मामले को भी संभालता है जहां b == 0।

#!ruby -nl
~/ /
p eval"#$`%10*"*($'>?0?($'.to_i-1)%4+1:0)+?1

लगता है कि वास्तव में लुकअप टेबल का उपयोग करना बदतर है।

— Lowjacker
स्रोत

यह 2 5इनपुट के रूप में देने पर 1 के रूप में आउटपुट देता है और ऊपर के नमूना मामलों के लिए सही आउटपुट भी नहीं देता है। ideone.com/2cOPy

— fR0DDY

1

@ fR0DDY: यह 1.9.2 के साथ पूरी तरह से मेरे सिस्टम पर काम करता है।

— लोजैकेर

4

विंडोज पॉवरशेल, 85

ओ (1) समाधान। Lowjacker के रूबी समाधान से एक संकेत लिया ;-)

$input|%{$a,$b=-split$_
'0000111162481397646455556666179368421919'[4*$a[-1]%48+$b%4]}

— एक छोटा सा सिक्का
स्रोत

3

पायथन 149 चार्ट

p=[[0],[1],[6,2,4,8],[1,3,9],[6,4],[5],[6],[1,7,9,3],[6,8,4,2],[1,9]]
while 1:a,b=map(int,raw_input().split());print b/~b+1or p[a%10][b%len(p[a%10])]

— fR0DDY
स्रोत

3

अजगर ( 119 134 109)

मुझे विश्वास है कि अंतर्निहित कार्यों के खिलाफ निषेध I / O पर लागू नहीं होता है।

आयात sys
p = लंबोदर b, e: e और p (b * b% 10, e / 2) * (~ e & 1or b)% 10or 1
sys.stdin में l के लिए: प्रिंट p (* नक्शा (int, l.split ()))

संपादित करें: पायथन के प्रतिपादक ऑपरेटर के उपयोग को हटा दें।

संपादित करें: शॉर्ट-सर्कुलेटेड बूलियन ऑपरेटरों के साथ प्रतिस्थापित टर्नरी ऑपरेटर।

— होआ लॉन्ग टैम
स्रोत

हां, आप इनपुट लेने के लिए I / O फ़ंक्शंस का उपयोग / कर सकते हैं, लेकिन आप इस कार्य के लिए '**' का उपयोग करने वाले नहीं हैं।

— क्विक्सोटिक

हालांकि यह काम करेगा, लेकिन मैं वास्तव में एक क्रूर-मजबूर मॉड्यूलर घातांक समाधान के लिए इस कार्य का इरादा नहीं करता हूं, वास्तव में एक ओ (1) एल्गोरिथ्म है और यह बहुत कम है :-)

— क्विक्सोटिक

2

पायथन 3k

121 शुल्क

def p(a,b):
  if b<1:return 1
  return p(a*a%10,b//2)*[1,a][b%2]%10
while 1:
  a,b=map(int,input().split())
  print(p(a%10,b))

यह (a*a)%10आवश्यक नहीं है, लेकिन यह इसे गति देता है, इसलिए इसे रखने का फैसला किया।

संपादित करें: जाहिर है, कोष्ठकों की आवश्यकता नहीं है।

इस बीच, O(1)समाधान के बारे में सोच रही थी । :)

— st0le
स्रोत

EOF के बाद लूप त्रुटि नहीं होगी?

— होआ लॉन्ग टैम

2

जावास्क्रिप्ट ( 117 84 79 60 वर्ण)

@JiminP और @NoOneIsHere से सुझाए गए सुधार के साथ 60 वर्णों तक पहुंच गया। धन्यवाद!

~~d = function (s, n) {a = Math.pow (s [s.length -1], n% = = 0; 1: n% 4) + ';' a '.length -1 }~~

d=(s,n)=>{return(Math.pow(s.slice(-1),n%4||1)+'').slice(-1)}

परीक्षा करना:

console.log(d('243242434544533445343432434311112223454323232132324324243454453344534343243431111222345432323213232432424345445334453434324343111122234543232321323243242434544533445343432434311112223454323232132324324243454453344534343243431111222345432323213232432424345445334453434324343111122234543232321323243242434544533445343432434311112223454323232132324324243454453344534343243431111222', 22337254775808));
console.log(d('38758436543765743875437656358764347568437658743658743454354645645543532487548758475847684756897548758457843758437584758478574857438758436587436587436587643875643856783478743658743658764387564387564378658437658743658743687564387564387564765746576475647564756475465746574675647654765476547534587545689475689748574385743765874585743857843765893748643587438957458754376543265874387564384764367584375874758943267632487564357', 54545454123));
console.log(d('6777744348435743587643756438765436574587564354375674365645643675', 23232));
console.log(d('3875843654376574357', 54545454));

परिणाम:

— स्टीफन पेरेलसन
स्रोत

1

d=function(s,n){return(Math.pow(s.slice(-1),n%4||1)+'').slice(-1)}: P

— JiminP

1

मैं जावास्क्रिप्ट का अधिक उपयोग नहीं करता, लेकिन क्या आप उसका उपयोग d=s,n=>(Math.pow(s.slice(-1),n%4||1)+'').slice(-1)या उपयोग नहीं कर सकते थे =>?

— NoOneIsHere 22

एक घातांक में अंतिम अंक