Nth हाइपरोपरेशन का मूल्यांकन करें

Question

मुझे पता है कि यह थोड़ा सा गणित-y है, लेकिन यहाँ जाता है।

गणित में, हाइपरोपरेशन अनुक्रम अंकगणितीय संचालन (जिसे हाइपरऑपरेशन कहा जाता है) का एक अनंत अनुक्रम है जो उत्तराधिकारी के एकजुट संचालन से शुरू होता है, फिर इसके अलावा, गुणा और घातांक के द्विआधारी संचालन के साथ जारी रहता है, जिसके बाद अनुक्रम आगे बाइनरी संचालन के साथ आगे बढ़ता है। घातांक, समकोणता का उपयोग करना।

आपका लक्ष्य एक प्रोग्राम लिखना है जो इनपुट के रूप में तीन पूर्णांक x, y और n लेता है और x और y पर nth हाइपरोपरेशन के परिणाम को आउटपुट करता है।

उदाहरण के लिए

1 1 1 आउटपुट 2

2 4 4 आउटपुट 65536

3 3 4 आउटपुट 7625597484987

• प्रोग्राम को सबसे कम कोड में लिखा जाना चाहिए।
• आप STDINफ़ाइल से या तो इनपुट ले सकते हैं ।
• पुस्तकालय कार्यों की अनुमति नहीं है।
• इनपुट बाधाएं: n। 1 होगी।

http://en.wikipedia.org/wiki/Tetration के बारे में अच्छी जानकारी है कि आप इस पर अपना सिर नहीं लपेट सकते।

Comments

क्या है n=1? यदि यह है , x+yया वापस लौटना चाहिएx+11 1 12

— जॉन ड्वोरक

मुझे पता था कि मैंने कहीं गलती की है :) फिक्स्ड, thx।

— सोहम चौधरी

मैंने मुझे एक छद्म कोड लिखा है, तब मुझे महसूस हुआ कि यह वास्तव में एक वैध रूबी कोड है (लगभग :-()

— जॉन ड्वोरक

नहीं, n> = 1 केवल।

— सोहम चौधरी

संबंधित ^ '^' के उपयोग के बिना हाइपरेक्सपॉइंटमेंट / टेट्रेशन को लागू करें

— हावर्ड

Answer 1

रूबी, धीमी, 86 84 83 अक्षर

def f x,y,n
n>1?(c=x;2.upto(y){c=f(x,c,n-1)};c):x+y
end
p f *gets.split.map(&:to_i)

रूबी, तेज, 96 94 93 वर्ण

def f x,y,n
n>1?(n>2?(c=x;2.upto(y){c=f(x,c,n-1)};c):x*y):x+y
end
p f *gets.split.map(&:to_i)

पहला संस्करण है जिस तरह से , पिछले परीक्षण मामले के साथ बहुत धीमी गति से तो मैं एक संस्करण कहा कि इसके अलावा के बजाय आधार मामले के रूप में उपयोग करता है गुणा। पहला संस्करण गणना करने के लिए उम्र लेता है 3 3 4; दूसरा एक तात्कालिक है (देशी आईआरबी कंसोल में; वेब संस्करण थोड़ा धीमा है)।

रूबी की कई सुंदरियां यहां दिखाई देती हैं:

लगभग हर कथन रूबी में एक अभिव्यक्ति है। इस प्रकार, आप टर्नरी ऑपरेटर के अंदर अर्धविरामों को भर सकते हैं, बशर्ते आपके पास पर्याप्त कोष्ठक पड़े हों। कॉफ़ीस्क्रिप्ट ने उधार लिया था। इसने रूबी की "नो पारेंस की जरूरत" कॉल सिंटैक्स भी उधार लिया था।

निहित प्रतिफल: यह एक अच्छी सुविधा है, और पिछले से इस प्रकार है। दरअसल, किसी समारोह की अंतिम पंक्ति को शुरू करना returnलंगड़ा माना जाता है, तब भी जब गोल्फ न हो।

संख्याएं माणिक में वस्तुएं हैं (यहां तक nullकि एक वस्तु है)। रूबी में, पूर्णांक में विधि होती है times, जो कई बार पारित ब्लॉक को निष्पादित करती है। यह रूबी के कई पुनरावृत्त तरीकों में से एक है। यहाँ, uptoविधि हमें क्या timesदेता है पर दो और अक्षर सहेजने देता है।

यूनाईटेड *यहां के स्पैट संचालक हैं। यह एक सरणी को तर्क सूची में बदल देता है। जावास्क्रिप्ट की तरह Function#apply, लेकिन यह छोटा और बेहतर है।

unary &एक प्रक्रिया को एक ब्लॉक में बदल देता है। जबकि :to_iएक प्रतीक है, यह बहुत अच्छी तरह से एक प्रक्रिया में परिवर्तित हो जाता है। अर्थात्, यह एक प्रक्रिया में बदल जाता है जो to_iअपने तर्क पर कॉल करता है और परिणाम देता है। स्टैक ओवरफ्लो पर अधिक जानकारी।

n=3बेस केस के रूप में उपयोग करके इसे और भी तेज करना संभव होगा , लेकिन मुझे डर है कि इसकी आवश्यकता नहीं है। यह केवल 11 पात्रों की लागत होगी, हालांकि, रूबी की एक और सुंदरता के लिए धन्यवाद: प्रतिपादक ऑपरेटर **। पायथन के पास यह ऑपरेटर है, लेकिन यह पहले वाला नहीं है (जैसा कि @ aka.nice ने कहा - धन्यवाद -, फोरट्रान पहले से ही इस ऑपरेटर के पास था)।

ऑनलाइन रूबी दुभाषिया यहाँ उपलब्ध है: http://repl.it/Ikj/1

Comments

अच्छा है, लेकिन मैं अभी भी आउटपुट का इंतजार कर रहा हूं 3 3 4:) यह बहुत धीमा है।

— सोहम चौधरी

@SohamChowdhury आधार मामला इसके अलावा है। गुणन के आधार मामले के साथ, यह बहुत धीमी गति से (और लंबे समय तक) होगा। मैं इसके बजाय घातांक के साथ परीक्षण की सलाह देता हूं ;-)

— जॉन ड्वोरक

यह संस्मरण का उपयोग करने के लिए समय बचा सकता है , लेकिन यह कुछ बाइट्स (काफी कुछ) खर्च करेगा

— जॉन ड्वोरक

फिर एक और संस्करण जोड़ें :)

— सोहम चौधरी

ऑपरेटर ** पहले से ही 50 के दशक में FORTRAN में मौजूद था और ALGOL में 1 वर्ण कम ऊपर तीर के साथ होगा

— aka.nice

Answer 2

एपीएल, ६२

{1=3⌷⍵:2⌷+\⍵⋄0=2⌷⍵:(⍵[3]⌊3)⌷⍵[1],0,1⋄∇⍵[1],(∇⍵-0 1 0),3⌷⍵-1}⎕

{...}⎕: लिया मूल्यांकन इनपुट (अंतरिक्ष-अलग संख्या एक संख्यात्मक सरणी का मूल्यांकन करता है) और इसके लिए फ़ंक्शन लागू करता है।

1=3⌷⍵:: यदि n 1 के बराबर होता है ...
2⌷+\⍵: पहले 2 तत्वों (x + y) का रिटर्न योग ...
⋄0=2⌷⍵:: यदि 0 बराबर है तो y ...
(⍵[3]⌊3)⌷⍵[1],0,1: संख्यात्मक संख्या [x, 0,1] बनाएं और सूचकांक वापस करें min(n,3)...
⋄∇⍵[1],(∇⍵-0 1 0),3⌷⍵-1: एल्स रिटर्न y (एक्स, ∇ (एक्स, वाई -1, एन), एन -1)। (∇ स्व-संदर्भ है)

---

मुझे एक "हाइपर-राइस" ऑपरेटर मिला है, जो एक फ़ंक्शन लेता है और अगले हाइपरोपरेशन को वापस करता है

{⍺⍺/⊃⍴/⌽⍵}

उदाहरण के लिए, +{⍺⍺/⊃⍴/⌽⍵}गुणन फ़ंक्शन होगा और +{⍺⍺/⊃⍴/⌽⍵}5 3आउटपुट 15 होगा।

लेकिन इसे पुनः प्राप्त करने के लिए नहीं मिल सकता। शायद कोई और कर सकता है।

Comments

आह, एपीएल। किसी भी दिन सादगी के लिए अजगर को मारता है। </ कटाक्ष> मैं इसे कैसे चलाऊं?

— सोहम चौधरी

Answer 3

पायथन, 83

( फ्लॉर्नकेक के उत्तर पर आधारित )

def h(x,y,n):r=n>2;exec"r=h(x,r,n-1);"*y*(n>1);return(x+y,r)[n>1]
print h(*input())

बड़े परिणामों के लिए बहुत धीमी गति से।

के लिए 2, 4, 4उत्पादन होता है 65536।

Comments

"बहुत धीमा" कारण है कि मेरा 86-चरित्र समाधान खराब माना जाता था।

— जॉन ड्वोरक

@JDDvorak: आपको क्यों लगता है कि इसे बुरा माना गया था? सोहम चौधरी ने कहा कि यह धीमा है और आपको एक और संस्करण जोड़ना चाहिए, न कि यह कि आप अपने समाधान की जगह लें। (लेकिन शायद मैं गलत समझ रहा हूं।)

— मोनिका

आप सही हे; लघु संस्करण को पुनर्स्थापित किया। अब मैं आपसे सिर्फ एक चार साल लंबा हूं।

— जॉन ड्वोरक

@WolframH बिल्कुल। हमेशा संस्करणों के लिए अच्छा है।

— सोहम चौधरी

Answer 4

पायथन, 96 92

def h(x,y,n):r=1;exec(n>2)*y*"r=h(x,r,n-1);";return(r,(x+y,x*y)[n>1])[n<3]
print h(*input())

इनपुट: 3, 3, 4
आउटपुट:7625597484987

@ WolframH के विचारों के एक जोड़े का उपयोग करते हुए लघु ।

Answer 5

गोल्फस्क्रिप्ट, धीमा, 39 अक्षर

 ~{\(.{3${[4$\2$4$.~}4$(*}{;;+}if])\;}.~

(लाइव लिंक)

यह n = 1 (जोड़) (यानी धीमा) के आधार मामले के साथ मानक पुनरावर्ती एल्गोरिदम है। वही मैंने अपने रूबी समाधान में उपयोग किया है

यहाँ मेरे एनोटेशन (ज्यादातर स्टैक-कीपिंग) के साथ एक संस्करण है। इसमें एक अनुकूलन शामिल नहीं है जिसे मैंने बाद में जोड़ा है:

~{            #read the input and do (x y n f)
 \(.{         #(x y f n-1); if(n-1)
  3${         #(x y f n-1 c)
   4$\2$4$.~  #(x y f n-1 x c n-1 f); call
  }3$(*       #y-1 times
  {\;}4*
 }{           #else
  ;;+         #return (x+y)
 }if
}.~           #once

~eval ऑपरेटर है। स्ट्रिंग्स के मामले में, यह स्ट्रिंग को गोल्फस्क्रिप्ट प्रोग्राम के रूप में मानता है। सौभाग्य से, पूर्णांक की एक अलग-अलग सूची एक मान्य गोल्फस्क्रिप्ट प्रोग्राम है जो स्टैक पर उन पूर्णांकों को धकेलता है। इसकी तुलना में, इनपुट रूटीन के मेरे पिछले संस्करण ( " "/{~}/, अंतरिक्ष द्वारा विभाजित और प्रत्येक को हटाना) बहुत ही लचर है। फ़ंक्शन के मामले में, यह फ़ंक्शन को कॉल करता है। जब .(क्लोन) से पहले , यह फ़ंक्शन को पहले तर्क के रूप में कहता है।

गोल्फस्क्रिप्ट पुनरावर्ती एल्गोरिदम बनाने के लिए बिल्कुल उपयुक्त नहीं लगता है। यदि आप एक पुनरावर्ती एल्गोरिदम चाहते हैं जो कि पूंछ-कॉल के लिए अनुकूल नहीं है, तो आपको अपने चर को संरक्षित करने के लिए स्टैक फ्रेम बनाने और नष्ट करने की आवश्यकता है। अधिकांश भाषाओं में, यह स्वचालित रूप से किया जाता है। गोल्फस्क्रिप्ट में, आपको वास्तव में चर (वास्तव में, स्टैक प्रविष्टियों) को क्लोन करना होगा, और स्टैक प्रविष्टियों को नष्ट करना होगा जिनकी आपको अब आवश्यकता नहीं है। गोल्फस्क्रिप्ट में स्टैक फ्रेम की कोई अवधारणा नहीं है। क्या मैंने कहा है कि गोल्फस्क्रिप्ट एक स्टैक-आधारित भाषा है?

पहली आवश्यकता समझ में आती है। आपको किसी तरह तर्क निर्दिष्ट करना होगा। यह केवल अच्छा है अगर वे अपने मूल पदों को भी बनाए रखें। दूसरी आवश्यकता दुर्भाग्यपूर्ण है, खासकर जब से वापसी मूल्य स्टैक के शीर्ष पर है, और गोल्फस्क्रिप्ट में केवल किसी भी स्टैक तत्व को हटाने की क्षमता का अभाव है। आप स्टैक को घुमा सकते हैं और नए शीर्ष तत्व को छोड़ सकते हैं, लेकिन यह जल्दी से बनाता है। \;ठीक है। \;\;\;\;\;नहीं है। आप \;एक लूप में कर सकते हैं ( {\;}9*; लागत: 9 तत्वों को छोड़ने के लिए 6 चार्ट, या 99 तत्वों को छोड़ने के लिए 7 चार्ट), लेकिन हम बेहतर कर सकते हैं:

गोल्फस्क्रिप्ट में प्रथम श्रेणी के सरणियाँ हैं। इसमें ऐरे शाब्दिक वाक्य-विन्यास भी है [1 2 3 4]। क्या अप्रत्याशित है कि है [और ]वास्तव में वाक्य रचना का एक हिस्सा नहीं हैं। वे केवल दो ऑपरेटर हैं: [स्टैक पर वर्तमान स्थिति को चिह्नित ]करता है , और हर तत्व को इकट्ठा करता है जब तक कि यह स्टार्ट-ऑफ-सरणी चिह्न नहीं पाता है या स्टैक से बाहर निकल जाता है, और चिह्न को छोड़ देता है। आप भी इन दोनों को फाड़ सकते हैं और देख सकते हैं कि क्या होता है। खैर, काफी दिलचस्प बात:

क्या मैंने कहा कि गोल्फस्क्रिप्ट में स्टैक फ्रेम की कोई अवधारणा नहीं है? मैंने झूठ बोला। यह एक स्टैक फ्रेम है [:। आप इसे एक ही बार में छोड़ सकते हैं ];:। लेकिन क्या होगा अगर हम रिटर्न वैल्यू रखना चाहते हैं? आप फंक्शन एंट्री पर स्टैक फ्रेम को बंद कर सकते हैं (तब हमारे पास पास-बाय-अरेंज का एक छोटा सा संस्करण है - एक दिलचस्प अवधारणा नहीं), या हम स्टैक फ्रेम को बंद कर सकते हैं और इसे पूरी तरह से छोड़ने के बजाय इसका अंतिम तत्व ले सकते हैं: ]-1=या हम इसके बजाय अंतिम तत्व को अनचेक कर सकते हैं, और फिर फ्रेम को छोड़ दें ])\;:। वे समान लंबाई वाले हैं, लेकिन बाद वाला थोड़ा ठंडा है, इसलिए मैं इसका उपयोग कर रहा हूं।

इसलिए, एक सफाई करने के लिए 6 या 7 पात्रों के बजाय, हम 5 के साथ कर सकते हैं। मुझे अभी भी लगता है कि यह अधिक गोल्फ हो सकता है, लेकिन हे, हमने एक चरित्र को बचा लिया है।

Comments

"फ़ंक्शन को पहले तर्क के रूप में कहता है" - पुनरावृत्ति के लिए दिलचस्प विचार

— एडित्सु छोड़ दें क्योंकि एसई ईवीआईएल

Answer 6

स्मॉलटाक स्क्वैक 4.x स्वाद कई बाइट्स!

मैं 71 चार्जर में इंटेगर में एक पुनरावर्ती रूप को लागू कर सकता था

f:y n:n n=1or:[^(2to:y)inject:self into:[:x :i|self f:x n:n-1]].^self+y

फिर एक फ़ाइल या FileStream स्टड से पढ़ने से मुझे एक हाथ खर्च होगा ... स्क्वेक स्पष्ट रूप से स्क्रिप्टिंग भाषा के रूप में डिज़ाइन नहीं किया गया था। इसलिए मैं समस्या से असंबंधित अपनी सामान्य उद्देश्य उपयोगिताओं को बनाने के लिए कई बाइट्स खर्च करूंगा:

स्ट्रीम में इस 21 चार विधि को लागू करें (सीपैटर्स को छोड़ने के लिए)

s self skipSeparators

व्यवहार में इस 20 चार विधि को लागू करें (एक स्ट्रीम से एक उदाहरण पढ़ने के लिए)

<s^self readFrom:s s

फिर स्ट्रिंग में 28 वर्ण (फ़ाइल हैंडल बनाने के लिए)

f^FileDirectory default/self

फिर FileDirectory में 59 चार्ट्स (एक readStream बनाने के लिए)

r^FileStream concreteStream readOnlyFileNamed:self fullName

फिर ब्लॉक क्लोजर में 33 बार (इसका मूल्यांकन करने के लिए n बार)

*n^(1to:n)collect:[:i|self value]

तब ऐरे में 63 चार्ट (रिसीवर से तर्क और एरे से ली गई दलीलों का मूल्यांकन करें)

`s^self first perform:s asSymbol withArguments:self allButFirst

तो x नाम की फ़ाइल से पढ़ने के लिए कहीं भी इस 31 चार स्निपेट का मूल्यांकन करके समस्या को हल करें

|s|s:='x'f r.[0class<s]*3`#f:n:

उपयोगिताओं की गिनती के बिना भी, यह 71 + 31 = 102 चार्ट पहले से ही है ...

अब, जब से मैं कोडगुल्फ को खोना सुनिश्चित कर रहा हूं, मेरे पास इंटेगर में एक मजेदार कार्यान्वयन है:

doesNotUnderstand:m
    (m selector allSatisfy:[:c|c=$+])or:[^super doesNotUnderstand:m].
    self class compile:
        m selector,'y y=0or:[^(2to:y)inject:self into:[:x :i|self'
        ,m selector allButLast,'x]].^'
        ,(Character digitValue:()asBit)
        ,(m selector size-2min:1)hex last.
    thisContext sender restart

यह विधि परिभाषित करेगी (संकलन) n + से बना एक द्विआधारी संदेश यदि यह मौजूद नहीं है (संदेश एम के रिसीवर द्वारा समझा नहीं जाता है), और प्रेषक संदर्भ की शुरुआत में निष्पादन को फिर से शुरू करेगा। मैंने पठनीयता के लिए अतिरिक्त गाड़ी वापसी और स्थान सम्मिलित किए।

ध्यान दें कि (m selector size-2min:1)hex lastएक छोटा रूप है (m selector size>2)asBit printString।

यदि यह स्मॉलटॉक बुराई महाशक्तियों को प्रदर्शित करने के लिए नहीं था, तो अंतिम विवरण को छोटे और सरल द्वारा प्रतिस्थापित किया जा सकता है

^m sendTo:self

अब वर्ण में 28 वर्ण उपयोगिता लागू करें (इसे स्ट्रिंग में n बार दोहराने के लिए)

*n^String new:n withAll:self

फिर इस 43 वर्ण अभिव्यक्ति का मूल्यांकन करें:

|i s|i:=0class.s:='x'f r.[i<s]*2`($+*(i<s))

हम इंटेगर में लागू करके 10 और चार्टों में तेजी ला सकते हैं:

++y^self*y

और इस मामले में हम भी है क्योंकि हम जगह ले सकता है कम कोड है ^',(m selector size-2min:1)hex lastसाथ^1'

इतनी अधिक कीमत के लिए, कोड दूसरे पूर्णांक के साथ काम करता है = 0 :)

Answer 7

ग्रूवी - 77

h={x,y,n->n<2?x+y:y<2?x:h(x,h(x,y-1,n),n-1)}
print h(args.collect{it as int})

नोट: इसमें गैर-छोटे तर्कों के लिए स्टैक (और समय) की अश्लील मात्रा की आवश्यकता होती है।

Answer 8

AXIOM कंप्यूटर बीजगणित प्रणाली, बाइट्स 69

p(x,y,n)==(n<=1=>y+x^n;n=2=>y*x;n=3=>x^y;y<=0=>1;p(x,p(x,y-1,n),n-1))

परीक्षा:

(2) -> p(1,1,1)
   (2)  2
                                                 Type: Expression Integer
                                   Time: 0.05 (IN) + 0.03 (OT) = 0.08 sec
(3) -> p(2,4,4)
   (3)  65536
                                                 Type: Expression Integer
                                                              Time: 0 sec
(4) -> p(3,3,4)
   (4)  7625597484987
                                                 Type: Expression Integer
                                                              Time: 0 sec

यह कुछ पुनरावृत्ति को समाप्त करेगा ... संभव है कि मैं कुछ रिटर्न में x और y में स्वैप करूं ... क्या अन्य परीक्षण मूल्य हैं?

Answer 9

एपीएल (एनएआरएस), चरस 61, बाइट्स 122

{(x y n)←⍵⋄n≤1:y+x*n⋄n=2:x×y⋄n=3:x*y⋄y≤0:1⋄∇x,(∇x(y-1)n),n-1}

परीक्षा:

  h←{(x y n)←⍵⋄n≤1:y+x*n⋄n=2:x×y⋄n=3:x*y⋄y≤0:1⋄∇x,(∇x(y-1)n),n-1}
  h 1 1 1
2
  h 2 4 4
65536
  h 3 4 4
∞
  h 3 3 4
7625597484987