चुनौती

लागू tetration पात्रों में से कम से कम राशि के साथ (उर्फ पावर टॉवर या Hyperexponentiation)।

शर्तें

'शक्ति' ऑपरेटर या इसके समकक्ष (जैसे का उपयोग न करें pow(x,y), x^y, x**y, आदि)
इनपुट के रूप में दिया गया: x y(एक स्थान से अलग)
xखुद के द्वारा yसमय की व्याख्या की जाती है ।
आपकी विधि कम से कम गणना करने में सक्षम होना चाहिए 4 3(4 घातांक 3 बार ही)

स्कोरिंग

सबसे कम स्कोर जीतता है: (# वर्णों का)
बोनस कटौती यदि आप गुणा ऑपरेटर (-5 अंक) का उपयोग नहीं करते हैं।
कोई गति / मेमोरी आवश्यकताओं। जब तक चाहो ले लो।

उदाहरण

x, 0 -> 1

2, 2 -> 2^2 = 4

2, 4 -> 2^(2^(2^2)) = 65536

4, 3 -> 4^(4^4) = 4^256 = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

सुझाव / परिवर्तन / प्रश्न के लिए खुला

code-golf math

— MrZander
स्रोत

4

एक परिवर्तन जो मुझे लगता है कि काफी महत्वपूर्ण है "ऑपरेटर" को "गुणन ऑपरेटर" से बदलना है। *कुछ संदर्भों में गोल्फस्क्रिप्ट गुणा है, लेकिन यह भी सरल लूपिंग ऑपरेटर है: {block}N*सी-स्टाइल के बराबर है for(i=0;i<N;i++){block}। मुश्किल बढ़त का मामला स्ट्रिंग / सरणी गुणन ( 'a'3*देता है 'aaa') है, लेकिन यह एक मुद्दा होने की संभावना नहीं है कि 4***3तत्वों की एक सरणी रैम को प्रवाहित करेगी।

— पीटर टेलर

3

किनारे मामले के लिए एक परीक्षण जोड़ने के लायक भी x 0=> 1. मेरा मूल समाधान उस मामले को संभाल नहीं पाया।

— पीटर टेलर

3

गुणा का उपयोग करने का दंड बहुत कम है। (: = इसका उपयोग नहीं करने के लिए बोनस)। मैंने एक समाधान बनाया जो इसका उपयोग नहीं करता था, और स्टैक ओवरफ्लो से बचने के लिए इसे बदलना पड़ा, और 5 मिलियन बोनस के नुकसान के लिए 7 चार जीत हासिल की।

— उपयोगकर्ता अज्ञात

2

@EngineerToast मैंने इस गोल्फ को 4 साल पहले पोस्ट किया था जो आपने लिंक किया था ...

— MrZander

2

स्थिति और स्कोरिंग अजीब तरह के हैं। आप बिजली के संचालन के उपयोग की अनुमति नहीं देते हैं? या आप उन्हें अनुमति देते हैं, लेकिन वे एक +10 अंक बोनस हैं?

— ब्यूटी आर्ट

16

J, स्कोर 7 है (12 वर्ण - गुणन से बचने के लिए 5 अंक)

+/@$/@$~/@$~

उपयोग:

   4 +/@$/@$~/@$~ 3
1.34078e154
t=.+/@$/@$~/@$~  NB. define a function
   4 t 3
1.34078e154
   2 t 2
4

बस कुछ नेस्टेड सिलवटों:

गुणा का उपयोग करना यह होगा */@$~/@$~
यह शक्ति का उपयोग करते हुए ^/@$~जहां यह $~सरणी बनाता है, /एक गुना कार्य है।

— defhlt
स्रोत

अच्छी तरह से किया। (पैड)

— गारेथ

@ गैरेथ धन्यवाद, लेकिन क्या padइसका मतलब यहाँ था? क्षमा करें, अंग्रेजी मेरी मातृभाषा नहीं है।

— defhlt

5

मेरा संदेश बहुत छोटा था इसलिए मुझे इसे बाहर करने की आवश्यकता थी। :-)

— गैरेथ

क्या आप केवल @$~संयोजन में एक और प्रदान करके पंचक प्राप्त कर सकते हैं ?

— योना

@ जोना आपको इसकी आवश्यकता होगी /, लेकिन हाँ। आप बस नेस्टेड फोल्डिंग फ़ंक्शन पर आवश्यकतानुसार कई बार तह कर रहे हैं।

— २३:४४ पर हाइपरएन्यूट्रीनो

15

हास्केल, 87 85 - 5 == 80 82

import Data.List
t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)

घातांक, गुणन या जोड़ (!) में से किसी का उपयोग नहीं करता है, बस सूची संचालन। प्रदर्शन:

Prelude> :m +Data.List
Prelude Data.List> let t x=genericLength.(iterate(sequence.map(const$replicate x[]))[[]]!!)
Prelude Data.List> t 2 2
4
Prelude Data.List> t 2 4
65536
Prelude Data.List> t 4 3

...
एहम ... आपने प्रदर्शन या स्मृति के बारे में कुछ नहीं कहा? लेकिन पर्याप्त मात्रा में अरबों साल और कुछ पेटाबाइट्स को देखते हुए, यह अभी भी सही परिणाम देगा (जेनेरिकलेंथ लिस्ट की लंबाई को गिनने के लिए एक बिगआईंट का उपयोग कर सकता है)।

— काउंटरक्लॉक को चालू करना बंद कर दिया
स्रोत

1

मुझे विश्वास है कि आपके पास 3012 का जवाब होगा? ;)

— मिज़ांडर

6

मुझे मूर के कानून से कुछ मदद की आवश्यकता होगी, लेकिन यह मुझे दिया जा सकता है।

— को बंद करना

12

गोल्फस्क्रिप्ट, 15 18 वर्ण

~])*1\+{[]+*{*}*}*

हां, *एस में से एक गुणन ऑपरेटर है (व्यायाम: जो एक?) तो मैं 5 चार बोनस के लिए योग्य नहीं हूं। फिर भी, यह पीटर के समाधान की तुलना में मुश्किल से कम है ।

यह पहले वाला 15-चार संस्करण अन्यथा समान है, लेकिन दूसरा तर्क 0. आने पर बग को स्पॉट करने के लिए धन्यवाद करने के लिए कोई आउटपुट नहीं देता है।

~])*{[]+*{*}*}*

— इल्मरी करोनें
स्रोत

यह घातक त्रुटियों को पैदा करता है, जैसे कि "2 3" ~])*{[]+*{*}*}*।

— रेस

@res, यह मेरे लिए सही उत्तर पैदा करता है।

— पीटर टेलर

@res: यह मानता है कि स्टैक पर इनपुट के अलावा और कुछ नहीं है। यदि आप अपने उदाहरण में इनपुट इन-लाइन प्रदान करना चाहते हैं, तो पहले ;वास्तविक इनपुट स्ट्रिंग को हटाने के लिए उपयोग करें जो इंटरप्रेटर स्टार्ट-अप पर स्टैक पर रखता है। या बस [कोड के लिए एक प्रीपेंड करें : दोनों ;"2 3" ~])*{[]+*{*}*}*और "2 3" [~])*{[]+*{*}*}*मेरे लिए ठीक काम करें।

— इल्मरी करोनें

(+1) धन्यवाद! वे विविधताएँ मेरे लिए एक रहस्य का काम करती हैं और हल करती हैं। ट्यूटोरियल कहते हैं, "आप में पाइप इनपुट की जरूरत नहीं है, लेकिन यदि आप नहीं करते हैं, यह बजाय निवेश के लिए शीघ्र नहीं होगा, यह समझेंगे कोई इनपुट नहीं है ।" इसलिए मैं केवल ruby golfscript.rb my_script.gsकमांड लाइन पर उपयोग कर रहा हूं , बिना यह जाने कि यह स्क्रिप्ट चलने से पहले कुछ ("", जाहिरा तौर पर) स्टैक पर होता है - जो कभी-कभी काम करता है, कभी-कभी नहीं। (इसके अलावा, के साथ echo 2 3 | ruby golfscript.rb my_script.gs, अपने कार्यक्रम करता है के रूप में प्रदत्त काम करते हैं।)

— रेस

1

ideone.com/547LG

— Res

10

जे, १६ १ ९ १२ अक्षर

*/@$~/1,~$~/

या एक क्रिया के रूप में (17 वर्ण):

h=:[:*/@$~/1,~$~/

उपयोग:

   h 2 4
65536

या कीबोर्ड से इनपुट लेने ( 24 27 20 वर्ण):

*/@$~/1,~$~/".1!:1]1

मेरी मूर्खता की ओर इशारा करने के लिए फूज़ेक्नल के साथ धन्यवाद । :-)

स्पष्टीकरण:

J को दाएं से बाएं पढ़ा जाता है, इसलिए इसका उपयोग करते हुए 2 4:

/$~सूची में प्रत्येक जोड़ी के बीच क्रिया को सम्मिलित करने के लिए उपयोग किया जाता है । $~बाएं आइटम को ले जाता है और $सही आइटम का उपयोग करके इसे आकार ~देता है ( तर्कों को उलट देता है) - इसलिए यह बराबर होगा 4 $ 2जो आपको एस की एक सूची देता है 2जो चार आइटम लंबा है 2 2 2 2।

अब हम सूची में 1 जोड़ते हैं 1,~और फिर वही काम करते हैं; सूची में प्रत्येक जोड़ी वस्तुओं के बीच /एक क्रिया डालें */@$~। यह क्रिया उसी तरह से शुरू होती है, $~लेकिन इस बार यह नव निर्मित सूची के प्रत्येक आइटम के बीच /सम्मिलित *होती है। @बस सुनिश्चित करती है कि */@$~एक क्रिया के बजाय दो के रूप में काम करता है। यह 2अपने आप को गुणा करने के लिए पर्याप्त समय देता है 2^4।

जे का शब्दावली पृष्ठ - मुझे लगता है कि जे के साथ समस्याओं को हल करना अलग-अलग तरीके से होता है क्योंकि यह कभी-कभी चीजों को करता है।

*ऑपरेटर को हटाने के लिए एक और पुनरावृत्ति जोड़ने से 2 समस्याएं होती हैं

~~यह 17 अक्षरों ( +/@$~/,@$~/1,~$~/) पर आता है, जो -5 बोनस के साथ भी लंबा है~~
यदि संख्या बहुत बड़ी हो जाती है तो यह मेमोरी से बाहर चला जाता है इसलिए गणना करने में सक्षम होने की आवश्यकता को पूरा नहीं करता है 4 3

— गैरेथ
स्रोत

क्या आप एक स्पष्टीकरण प्रदान कर सकते हैं? यह दिलचस्प लग रहा है।

— मेज़ैंडर

@ श्रीजैंडर ने स्पष्टीकरण जोड़ने के लिए अपना उत्तर संपादित किया है।

— गारेथ

यकीन नहीं होता कि मेरे पास बेहतर समझ या अधिक भ्रम है, लेकिन धन्यवाद हाहा।

— मेज़ैंडर

व्याख्या का तात्पर्य है कि पूरी चीज़ टेट्रेशन के बजाय घातांकता कर रही है। हममें से कौन कुछ याद कर रहा है?

— पीटर टेलर

@PeterTaylor मुझे संदेह है कि मेरी व्याख्या बहुत स्पष्ट नहीं है। यदि यह टेट्रेशन कर रहा होता तो मैं सिर्फ उसका उपयोग ^/]$[करता जो सूची बनाता है 2 2 2 2और उनके बीच के एक्सपोनेंटेशन ऑपरेटर को चिपका देता है। यह क्या कर रहा है एक कदम आगे जा रहा है और बार-बार गुणा करके घातांक कर रहा है।

— गारेथ

8

GolfScript (24 वर्ण - 5 = 19 अंक)

~\1{1{0{+}?}?}{@\+@*}:?~

बहुत ही धीमा है।

(या 20 वर्ण)

~\1{1{*}?}{@\+@*}:?~

बहुत तेज है।

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

2

चूंकि गोल्फस्क्रिप्ट एक रूबी कार्यक्रम है, हम ideone :) ideone.com/GTIfP पर परीक्षण कर सकते हैं । मैंने यह भी सुझाव दिया है कि वे यह सुझाव दें कि वे गोल्फस्क्रिप्ट के लिए समर्थन जोड़ें।

— मेलमोकब

@mellamokb, यह अच्छा होगा अगर वे इसे जोड़ते हैं, लेकिन मैं बहुत आशावादी नहीं हूं क्योंकि उनकी बताई गई नीति उन भाषाओं को जोड़ना है जो उनके डिस्ट्रो द्वारा समर्थित हैं।

— पीटर टेलर

मैंने वह भी पढ़ा ... लेकिन जब से वे रूबी का समर्थन करते हैं, और गोल्फस्क्रिप्ट सिर्फ एक रूबी कार्यक्रम है, यह आसान होना चाहिए :) बस पैरामीटर में एक बैश स्क्रिप्ट बनाएं।

— मेलमोकब

+1 ideone.com/eW2F3 :)

— mellamokb

6

पायथन, 70

यह नेस्टेड evalकॉल का उपयोग करता है , अंततः एक स्ट्रिंग का उत्पादन करता है "a*a*a*a...*a"जिसका मूल्यांकन किया जाता है। लगभग आधे अंक बहस होने पर बर्बाद हो जाते हैं ... हालांकि मैंने देखा है कि कुछ अन्य समाधान इससे परेशान नहीं हैं।

a,b=map(int,raw_input().split())
exec"eval('*'.join('a'*"*b+'1'+'))'*b

— boothby
स्रोत

अगर हम यह मान लें कि तर्क अल्पविराम हैं, तो आप चीयर्स input()का उपयोग कर सकते हैं या उपयोग कर सकते हैंeval(raw_input())

— st0le

1

@ st0le, कृपया इस प्रश्न को पढ़ें

— बूथबिन

अच्छा है। दूसरी पंक्ति भी अधिक golfed जा सकता है: exec"eval('a*'*"*b+'1'+"+'1')"*b

— flornquake

@flornquake अच्छी पकड़! धन्यवाद!

— boothby

4

स्काला: 110

type B=BigInt
def r(a:B,b:B,f:(B,B)=>B):B=if(b>1)f(a,r(a,b-1,f))else a
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_))))

ungolfed:

type B=BigInt
def recursive (a:B, b:B, f:(B,B)=>B): B = 
  if (b>1) f (a, recursive (a, b-1, f)) 
  else a
recursive (2, 3, recursive (_, _, recursive (_, _, (_ + _))))

स्पष्टीकरण:

type B=BigInt
def p (a:B, b:B):B = a+b
def m (a:B, b:B):B = if (b>1) p (a, m (a, b-1)) else a
def h (a:B, b:B):B = if (b>1) m (a, h (a, b-1)) else a
def t (a:B, b:B):B = if (b>1) h (a, t (a, b-1)) else a

प्लस, mul, उच्च (: = pow), tetration सभी एक ही तरीके से काम करते हैं। सामान्य पैटर्न को पुनरावर्ती विधि के रूप में निकाला जा सकता है, जो दो BigInts और एक मूल फ़ंक्शन लेता है:

def r (a:B, b:B, f:(B,B)=>B):B = 
  if (b>1) f(a, r(a, b-1, f)) else a
r (4, 3, r (_,_, r(_,_, (_+_))))

अंडरलाइन्स किसी चीज़ के लिए प्लेसहोल्डर हैं जिसे इस क्रम में बुलाया जाता है, उदाहरण के लिए प्लस (ए, बी) = (ए + बी); इसलिए ( + ) एक फ़ंक्शन है जो दो तर्क लेता है और उन्हें जोड़ता है (a + b)।

दुर्भाग्य से, मुझे स्टैक आकार के साथ मुद्दे मिलते हैं। यह 4 के लिए छोटे मूल्यों के लिए काम करता है (उदाहरण के लिए: 2) या अगर मैं एक कदम के लिए गहराई कम कर देता हूं:

def h(a:B,b:B)=r(a,b,r(_,_,(_*_))) // size -7, penalty + 5
def h(a:B,b:B)=r(a,b,r(_,_,r(_,_,(_+_))))

मूल कोड 112 वर्ण है और स्कोर होगा, यदि वैध हो, 107। हो सकता है मुझे पता चले कि स्टैक कैसे बढ़ाया जाए।

विस्तारित एल्गोरिथ्म को टेलरेस्किव कॉल में बदला जा सकता है:

type B=BigInt
def p(a:B,b:B):B=a+b
import annotation._
@tailrec
def m(a:B,b:B,c:B=0):B=if(b>0)m(a,b-1,p(a,c))else c
@tailrec
def h(a:B,b:B,c:B=1):B=if(b>0)h(a,b-1,m(a,c))else c
@tailrec
def t(a:B,b:B,c:B=1):B=if(b>0)t(a,b-1,h(a,c))else c

टेलरेस्क्युर कॉल मूल विधि की तुलना में लंबा है, लेकिन लंबे संस्करण में स्टैकओवरफ्लो नहीं बढ़ा - हालांकि यह उचित समय में परिणाम नहीं देता है। t (2,4) ठीक है, लेकिन t (3,3) पहले ही मेरे द्वारा 5 मिनट के बाद रोक दिया गया था। हालाँकि, यह बहुत सुंदर है, है ना?

// 124 = 119-5 bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,r(_,_,0,(_+_))))

और अब ऊपर जैसा ही है: बदबूदार गुणन का उपयोग करें (हम 5 के बोनस को खारिज करते हुए भी लाभ कमाते हैं, क्योंकि हम 7 वर्णों को बचाते हैं: जीत = 4 वर्ण :)

// 115 without bonus
type B=BigInt
def r(a:B,b:B,c:B,f:(B,B)=>B):B=if(b>0)r(a,b-1,f(a,c),f)else c
def t(a:B,b:B)=r(a,b,1,r(_,_,1,(_*_)))

मंगलाचरण:

timed ("t(4,3)")(t(4,3)) 
t(4,3): 1
scala> t(4,3)
res89: B = 13407807929942597099574024998205846127479365820592393377723561443721764030073546976801874298166903427690031858186486050853753882811946569946433649006084096

रनटाइम: 1ms।

— अज्ञात उपयोगकर्ता
स्रोत

4

Br ** nfuck, 128-5 = 123 बाइट्स

+<<+<<,<,[>[>+>>+<<<-]>[<+>-]>[>[>>+>+<<<-]>>>[<<<+>>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>[-]>[<<+>>-]<<<<-]>>[<<+>>-]+<[-]<<<<-]>>>.

इनपुट वर्णों के रूप में है, जो इनपुट के रूप में वांछित संख्याओं के कोड बिंदुओं के साथ है। आउटपुट समान है।

नीचे ~~समय होने पर~~ स्पष्टीकरण ~~आ रहा है~~ । क्या मुझे घातांक, गुणा, या इसके अलावा का उपयोग नहीं करने के लिए बोनस अंक मिलते हैं?

Cell 3 (0-indexed) is the running total x.
This calculates the nth tetration of a.

+<<+<<,<,                                       Initialize tape with [n, a, 0, 1, 0, 1]
[                                               While n:
  >[>+>>+<<<-]>[<+>-]                             Copy a 3 cells to right: [n, a, 0, x, a, 1]
  >[                                              While x:
    >[>>+>+<<<-]>>>[<<<+>>>-]                       Copy a 2 cells to right: [n, a, 0, x, a, 1, a, 0]
    <<[>[>+>+<<-]>>[<<+>>-]<<<-]                    Cell 7 = prod(cell 5, cell 6)
    >[-]>[<<+>>-]<<<<-]                             Move this value to cell 5. End while.
  >>[<<+>>-]+<[-]<<<<-]                           Update x to result of exponentiation. End while.
>>>.                                            Print the result!

इस के लिए काम करता है (परीक्षण किया) x 0, 0 x, x 1, 1 x, x 2, 2 3, और 2 4। मैंने कोशिश की 3 3, लेकिन यह बिना परिष्करण के कई घंटों तक चला (मेरे जावा कार्यान्वयन में- शायद इष्टतम नहीं) (EDIT: in @ Timwi's EsotericIDE [यह बहुत अच्छा है! आपको यह कोशिश करनी चाहिए] साथ ही साथ। कोई भाग्य नहीं।)। सिद्धांत रूप में, यह विशिष्ट कार्यान्वयन के सेल आकार तक काम करता है।

— खुल्द्रेसथ न’बैरी
स्रोत

1

"Br ** nfuck" हाँ "मस्तिष्क" एक बहुत ही आक्रामक शब्द है XD। खेद है कि मुझे जरूरत है

— फायरक्यूबेज़

3

पायथन, 161 - 5 (नहीं * ऑपरेटर) = 156

r=xrange
def m(x,y):
 i=0
 for n in r(y):i+=x
 return i
def e(x,y):
 i=1
 for n in r(1,y+1):i=m(i,x)
 return i
def t(x,y):
 i=1
 for n in r(y):i=e(x,i)
 return i

आह्वान:

t(2, 4)

— रंगीन जाकेट
स्रोत

1

मूल्यांकन के साथ पुनरावृत्त इसके अलावा गुणा वास्तव में काफी तेज है 4***3?

— पीटर टेलर

2

@PeterTaylor हाँ? यह मेरे लिए एक सेकंड से भी कम समय में पूरा होता है

— ब्लेजर

वाह। समतुल्य गोल्फस्क्रिप्ट संस्करण आआआआआआआगसस्स।

— पीटर टेलर

जैसे, मैंने इसे रात भर चलाना छोड़ दिया है और यह अभी भी समाप्त नहीं हुआ है।

— पीटर टेलर

1

छह साल बाद, आप अपने mफंक्शन को बदलकर कुछ बाइट्स भी बचा सकते हैंm=lambda x,y:sum(x for _ in r(y))

— जैक ब्रूनस्टीन

3

पर्ल, 61 वर्ण

यहाँ एक विचित्र है

sub t
{
  ($x,$y,$z)=@_;
  $y>1&&t($x,$y-1,eval$x."*$x"x($z-1||1))||$z
}

उपयोग:

print t(2,4,1)

— ardnew
स्रोत

4

एक गलत भी

— ardnew

3

गणितज्ञ , ४० ३३

यह नियमों के अनुरूप नहीं है, लेकिन यह वैसे भी सबसे छोटे कोड के लिए विवाद में नहीं है, और मुझे उम्मीद है कि यह किसी के लिए भी हितकारी होगा।

m@f_:=Fold[f,1,#2~Table~{#}]&;

m[m@Sum]

जब इसे चलाया जाता है तो यह "टेट्रेशन" फ़ंक्शन बनाता है, लेकिन तर्कों को उल्टे क्रम में दिया जाना चाहिए। उदाहरण:

m[m@Sum][3, 4]

1340780792994259709957402499820584612747936582059239337772356144372176 4030073546976801874298166903427690031858186486050853753882811946569946 433649006084096

— Mr.Wizard
स्रोत

क्या आप कोड की व्याख्या करेंगे? या संख्या के बजाय प्रतीकों पर परिणाम प्रदर्शित करें? मैं नोटिस करता हूं कि उदाहरण के लिए Fold[g, 1, #2~Table~{#}] &[3, 4]उत्पादन करेगा g[g[g[1, 4], 4], 4]।

— डेविड ऑग

@ डेविड m[Times]उत्पादन करता है Fold[Times, 1, Table[#2, {#1}]] &, जो कि एक पावर फंक्शन है: m[Times][5, x]---> x^5; एक ही विधि का उपयोग इस नए पावर फंक्शन के लिए टेट्रेशन फंक्शन का निर्माण करने के लिए किया जाता है। तार्किक रूप से कोई भी शुरुआत कर सकता है Plusलेकिन यह लगभग तुरंत विफल हो जाता है।

— Mr.Wizard

टाइम्स को खत्म करने के लिए, यह प्रयास करें t[h_, n_] := Sum[h, {i, n}]:। फिर चला m[m@t][3, 4]।

— डेविड ऑग

@ डेविड, हां, यह काम करना चाहिए, लेकिन कोड-गोल्फ के लिए नहीं। ;-) (BTW आप लिख सकते हैं Sum[h, n]।)

— Mr.Wizard

स्कोरिंग नियमों को देखें। आप टाइम्स का उपयोग नहीं करके 9 अंक बचाते हैं। कुल स्कोर अभी भी आपकी तुलना में बेहतर नहीं है लेकिन करीब हो रहा है।

— डेविड

3

हास्केल: 58 51 वर्ण, गुणन के साथ या उसके बिना।

i f x 1=x;i f x n=f$i f x$n-1
t=i(\o n->i(o n)n)(+)4

Ungolfed:

bump op n a = iterate (op n) n !! (fromIntegral $ a-1)
tetrate = iterate bump (+) !! 3

कम परिभाषा "टकराहट" को बढ़ाने और "पुनरावृति" के एक कस्टम संस्करण को परिभाषित करने से आती है। दुर्भाग्य से परिणाम असंभव रूप से अक्षम है, लेकिन (+) के बजाय (*) के साथ शुरू करना सभ्य गति देता है। इन ghci:

Prelude> let i f x 1=x;i f x n=f$i f x$n-1
(0.00 secs, 1564024 bytes)
Prelude> let t=i(\o n->i(o n)n)(*)3
(0.00 secs, 1076200 bytes)
Prelude> t 4 3
13407807929942597099574024998205846127479365820592393377723561443721764030073546
976801874298166903427690031858186486050853753882811946569946433649006084096
(0.01 secs, 1081720 bytes)

— पीएलएल
स्रोत

3

रूबी 66 59 अक्षर

def e(x,y)
r=1
(1..y).each{t=x
(2..r).each{t*=x}
r=t}
r
end

— क्रिस्टियन लुपस्कू
स्रोत

दुर्भाग्य से, यह स्क्रिप्ट 1दूसरी इनपुट संख्या होने पर सही आउटपुट ( ) का उत्पादन नहीं करती है 0; बल्कि, e(x,0)का मूल्य लौटाता है x।

— रेस

@ आप सही हैं। मैंने कोड तय किया। धन्यवाद!

— क्रिस्टियान लुपस्कू

2

पायथन, 112 वर्ण

नंबर 1 और 2 तर्क होना चाहिए: python this.py 4 3
**ऑपरेटर का उपयोग नहीं किया गया।
*उपयोग किया गया। यह लागू करने के लिए काफी तुच्छ है, बिल्कुल पसंद है **, लेकिन लागत 5 से अधिक है।

import sys
p=lambda y:y and x*p(y-1)or 1
t=lambda y:y>1 and p(t(y-1))or x
x,y=map(long,sys.argv[1:])
print t(y)

— ugoren
स्रोत

मैं 4 3 की गणना करने के लिए कोड का उपयोग कैसे करूं? और, बस जिज्ञासा की: क्या आपने इस तरह से * लागू करने की कोशिश की है, और फिर 4 3 की गणना करने के लिए?

— उपयोगकर्ता अज्ञात

@userunknown, इनपुट मापदंडों द्वारा है। मैंने जवाब में एक स्पष्टीकरण जोड़ा। मैंने *कार्यान्वयन को जोड़ने की कोशिश नहीं की , मेरा मानना है कि पुनरावृत्ति की गहराई बहुत बड़ी होगी 4 3।

— बदसूरत

2

सी, 117 105 99 चार्ट

संपादित करें: कुछ कार्यों को सहेजते हुए, दो कार्यों pऔर rएक में विलय कर दिया।
99 वर्णों में से, 52 वास्तविक गणना करते हैं (चर परिभाषाओं सहित)। अन्य 47 इनपुट और आउटपुट से निपटने के लिए हैं।
बग: बुरी तरह से 0 की शक्तियों को संभालता है (जैसे 0 2)। एक न्यूनतम लागत तय करना चाहिए। यह एक बग नहीं है, मैं भूल गया कि 0 2अपरिभाषित है।

सफलतापूर्वक संभालता है 4 3, और यहां तक कि एक सटीक परिणाम भी देता है। हालांकि, कुछ छोटी संख्या के लिए गलत हो सकता है।
एक अनुगामी के साथ संख्या प्रिंट करता है .000000।

x,y,z;
double R(){return--y?!z?y=R(),R(z=1):x*R():x;}
main(){
    scanf("%d%d",&x,&y);
    printf("%f\n",R());
}

— ugoren
स्रोत

लगता है मेरे लिए ११.com/ चरस

— mellamokb

4 3 के साथ यह परीक्षण केवल 18 स्थानों के लिए सटीक है, डबल में सटीक प्रतिनिधित्व का समर्थन करने के लिए लगभग पर्याप्त सटीकता नहीं है।

— Sir_Lagsalot

@Sir_Lagsalot, डबल में 4 ^ 256 के लिए पर्याप्त सटीकता से अधिक है। इसमें केवल एक महत्वपूर्ण अंक है।

— बदसूरत

आह अच्छी बात है, मैं बाइनरी में नहीं सोच रहा था। क्या यह वास्तव में आपके लिए सटीक मूल्य का प्रिंट आउट लेता है? यह मेरी मशीन पर पहले 18 या इतने दशमलव अंकों के बाद छोटा हो जाता है, लेकिन मैं यह स्वीकार करना चाहता हूं कि यह सिस्टम विशिष्ट है।

— Sir_Lagsalot

@Sir_Lagsalot: मेरे द्वारा प्रदान की गई विचारधारा लिंक देखें। यह पूरी संख्या को प्रिंट करता है।

— मेलमोकब

2

कारक, 187 वर्ण

USING: eval io kernel locals math prettyprint sequences ;
IN: g
:: c ( y x o! -- v )
o 0 = [ x y * ] [ o 1 - o!
y x <repetition> 1 [ o c ] reduce ] if ;
contents eval( -- x y ) swap 2 c .

गोल्फ से पहले:

USING: eval io kernel locals math prettyprint sequences ;
IN: script

! Calculate by opcode:
!   0 => x * y, multiplication
!   1 => x ^ y, exponentiation
!   2 => x ^^ y, tetration
:: calculate ( y x opcode! -- value )
    opcode 0 = [
        x y *
    ] [
        ! Decrement the opcode. Tetration is repeated exponentiation,
        ! and exponentiation is repeated multiplication.
        opcode 1 - opcode!

        ! Do right-associative reduction. The pattern is
        !   seq reverse 1 [ swap ^ ] reduce
        ! but a repetition equals its own reverse, and 'calculate'
        ! already swaps its inputs.
        y x <repetition> 1 [ opcode calculate ] reduce
    ] if ;

contents eval( -- x y )         ! Read input.
swap 2 calculate .              ! Calculate tetration. Print result.

मैंने गुणन ऑपरेटर को नहीं हटाया *। यदि मैंने ऐसा किया है, तो मुझे कुछ तर्क जोड़ने की आवश्यकता होगी जो यह कहते हैं कि एक खाली अनुक्रम का योग 0 है, न कि 1. इस अतिरिक्त तर्क की लागत -5 बोनस से अधिक होगी।

नियम तोड़ने वाला, 124 + 10 = 134 वर्ण

USING: eval kernel math.functions prettyprint sequences ;
contents eval( -- x y ) swap <repetition> 1 [ swap ^ ] reduce .

इस कार्यक्रम का स्कोर कम है, लेकिन प्रतिपादक ऑपरेटर ^नियमों को तोड़ता है। नियम कहते हैं "(# वर्णों का) + (10 * (# 'शक्ति' ऑपरेटरों) का", इसलिए मैंने +10 जुर्माना लगाया। हालांकि, नियम यह भी कहते हैं कि "पॉवर 'ऑपरेटर का उपयोग न करें", इसलिए इस दंड को लेने वाला कोई भी कार्यक्रम नियमों को तोड़ता है। इसलिए, 134 वर्णों का यह कार्यक्रम एक सही उत्तर नहीं है, और मुझे अपने उत्तर के रूप में अपने 187 पात्रों के लंबे कार्यक्रम को प्रस्तुत करना होगा।

— kernigh
स्रोत

2

हास्केल 110 - 5 = 105

टेट्रेशन पीनो स्टाइल। यह केवल एक चेतावनी है, सबसे पागलपनपूर्ण समाधान संभव है, लेकिन इसके अलावा भी बचता है।

data N=Z|S N
a&+Z=a
a&+S b=S$a&+b
_&*Z=Z
a&*S b=a&+(a&*b)
_&^Z=S Z
a&^S b=a&*(a&^b)
_&>Z=S Z
a&>S b=a&^(a&>b)

यह आप पर निर्भर करता है कि आप पीनो नंबर टाइप करने का धैर्य रखते हैं (और इसका जवाब नहीं दिखाएगा, यदि आप वास्तव में इसे चलाना चाहते हैं, तो इन कुछ पंक्तियों (90 वर्णों) को जोड़ें:

f 0=Z
f a=S$f$a-1
t Z=0
t(S a)=1+t a
main=interact$show.f.(\[x,y]->x&>y).map(f.read).words

— walpen
स्रोत

2

रूबी, 47 46 45

t=->x,n{r=x;2.upto(n){r=([x]*r).inject :*};r}

— defhlt
स्रोत

2

लुआ: 133 चार्ट, गुणा-भाग

a,b=io.read():match"(%d+) (%d+)"a,b,ba=a+0,b+0,a for i=1,b-1 do o=1 for i=1,a do o=o+o for i=1,ba-b do o=o+o end end a=o end print(o)

मैं मूल रूप से नकली गुणन करने के लिए स्ट्रिंग पुनरावृत्ति हैक का उपयोग करने जा रहा था, लेकिन यह बड़े मूल्यों पर विफल होना पसंद करता है। मैं संभवतः इसे छोटे बनाने के लिए गतिशील संकलन और लोडस्ट्रिंग का उपयोग कर सकता हूं, लेकिन यहां देर हो रही है ... मुझे नींद की आवश्यकता है।

स्टड आउटपुट में "4 3" दर्ज करना:

1.3407807929943e+154

— ड्वेन स्लेटर
स्रोत

2

VBA, 90 शुल्क

* शायद कोई गुणा बोनस पर्याप्त अच्छा नहीं है। मुझे लगता है कि कोई गुणन उत्तर अधिक दिलचस्प नहीं है, लेकिन यह कोड गोल्फ है, इसलिए यह सबसे अच्छा नहीं है। यहाँ एक जवाब के बिना है* , और इसके साथ एक बेहतर (कम, और बेहतर स्कोरिंग) उत्तर है:

90 वर्ण, कोई बिजली ऑपरेटर, गुणन = 90 का उपयोग नहीं करता है

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:b=b*x:Next:f=b:Next:MsgBox f
End Sub

116 चार्ट, कोई बिजली ऑपरेटर, कोई गुणा बोनस (-5) = 111 नहीं

Sub c(x,y)
f=IIf(y,x,1):For l=2 To y:b=x:For j=2 To f:For i=1 To x:a=a+b:Next:b=a:a=0:Next:f=b:Next:MsgBox f
End Sub

नोट: जब परिणाम बहुत बड़ा होता है (यानी 4, 3), तो वीबीए ने संख्या को प्रिंट करने के मुद्दे जारी किए हैं , लेकिन यह सही ढंग से गणना करता है, इसलिए, उदाहरण के लिए, आप उस नंबर का उपयोग करना चाहते थे, तो आप जाना अच्छा होगा। इसके अलावा, यहां तक कि बड़ी संख्या में अतिप्रवाह (यानी 3, 4)।

— Gaffi
स्रोत

2

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

->\a,\b{(1,{[*] a xx$_}...*)[b]}

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

(1, { [*] a xx $_ } ... *)एक आलसी अनुक्रम है जो पावर टॉवर को उत्पन्न करता है, प्रत्येक तत्व एक सूची है जिसमें पहले इनपुट पैरामीटर की aप्रतिकृति ( xx) पिछले तत्व ( $_) के बराबर कई बार होती है , उस सूची को गुणा ( [*]) के साथ कम किया जा रहा है । इस क्रम से हम केवल b-थ तत्व को बाहर निकाल देते हैं ।

— शॉन
स्रोत

2

लैम्ब्डा कैलकुलस, 10-5

( चर्च एन्कोडिंग और डी ब्रुइजन इण्डोल का उपयोग करके )
λλ(1λ13)λ1

व्याख्या

डी ब्रूजन इंडोल के बिना λa,b.(b λc.ca)λc.c:

λa,b.                                                 define the anonymous function f(a,b)=
     (b                                                apply the following function b times
        λc.                                                    the anonymous function g(c)=
           ca)                 apply c to a because of church encoding this is equal to a^c
              λc.c                              the identity function, 1 in church encoding

यदि आप परिभाषित करते हैं कि exp_a(x)=a^xयह कार्यक्रम a↑↑b=exp_a^b(1)कहां परिभाषित करता है^b फ़ंक्शन पुनरावृत्ति को दर्शाता है।

मुझे यकीन नहीं है कि अगर इसकी अनुमति दी गई है क्योंकि caतकनीकी रूप से a^cयह बराबर है कि यह कभी भी वास्तविक अंतर्निहित नहीं है और केवल एक ही तरह से पूर्णांक लैंबडा कैलकुलस में एन्कोडेड हैं।

— fejfo
स्रोत

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

— आउटगोल्फर

1

जावास्क्रिप्ट: 116 वर्ण

function t(i){y=i.split(' ');a=y[0];b=y[1];return+b&&p(a,t(a+' '+(b-1)))||1}function p(a,b){return+b&&a*p(a,b-1)||1}

टी ('4 3') आउटपुट:

1.3407807929942597e+154

— पॉल
स्रोत

1

अजगर (111) (113) नहीं *

r=lambda x,y:(x for _ in range(y));t=lambda x,y:reduce(lambda y,x:reduce(lambda x,y:sum(r(x,y)),r(x,y)),r(x,y),1)

6 *** 3 - 36k अंक))

अद्यतन: टी (एक्स, 0) = 1 फिट करने के लिए प्रारंभिक मूल्य जोड़ना है

— Ev_genus
स्रोत

प्रभावशाली, 36k को कितना समय लगा?

— मेज़ैंडर

1

9.375 सेकंड प्रिंट सहित।

— Ev_genus

1

हास्केल: 88-5 वर्ण गुणा के बिना, 59 वर्ण गुणा के साथ

गुणन के बिना:

h x y=foldr(\x y->foldl(\x y->foldl(+)0(replicate x y))1(replicate y x))1(replicate y x)

वहाँ शायद तरीके हैं कि मैं थोड़ा नीचे गोल्फ सकता है।

गुणा के साथ:

h x y=foldr(\x y->foldl(*)1(replicate y x))1(replicate y x)

और अंत में, अनगुल्ड प्रोग्राम:

mult x y = foldl (+) 0 (replicate x y)
expo x y = foldl (mult) 1 (replicate y x)
h x y = foldr (expo) 1 (replicate y x)

यह संभवतः इस समस्या को करने का सबसे सरल तरीका है, जो बार-बार जोड़ के रूप में गुणन को परिभाषित कर रहा है, दोहराया दोहराव के रूप में घातांक और दोहराया घातांक के रूप में टेट्रेशन।

— Aearnus
स्रोत

1

रैकेट 58 (नहीं *)

(define(t x y)(if(= y 0)1(for/product([i(t x(- y 1))])x)))

— मैथ्यू बटरिक
स्रोत

के लिए / उत्पाद "कोई गुणन" नियम पर एक अच्छी लाइन चल रहा है, हाहा।

— मेज़ैंडर

1

आम लिस्प, 85 वर्ण

(lambda(b c)(let((r b)u)(dotimes(c c r)(setf u 1 r(dotimes(c b u)(setf u(* u r)))))))

मैंने दोहराया गुणा के माध्यम से गुणा करने की कोशिश की, लेकिन यह 5 से अधिक वर्णों का रास्ता था। मैक्रोलेट्स के साथ एक ही बात, घोषणाएं लाभ के लायक नहीं थीं।

एक अन्य समाधान, बूथबी के अजगर समाधान से प्रेरित है। यह उपरोक्त समाधान से 1 वर्ण कम है।

(lambda(a b)(eval`(*,@(loop for x below b nconc(loop for x below a nconc`(,a,a))))))

— एरिक हैलिकिज़
स्रोत

1

पायथन 3 - 68

(बिजली ऑपरेटर के लिए 10 सूत्री जुर्माना सहित)

a,b=input().split()
r=1
exec("r=%s**r;"%a*int(b))
print(r)

— flornquake
स्रोत

1

Yabasic , 71 बाइट्स

एक फ़ंक्शन जो इनपुट लेता है aऔर bएक अंतरिक्ष सीमांकित स्ट्रिंग के रूप में।

Input""a,b
d=a^(b>0)
For i=2To b
c=a
For j=2To d
c=c*a
Next
d=c
Next
?d

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

— टेलर स्कॉट
स्रोत

1

आर , 71 - 5 = 66 बाइट्स

function(x,y,b=x){for(i in 2:y)b=cumprod(z<-rep(x,b))[sum(z|1)];cat(b)}

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

-5 * से बचने के लिए, जो मुझे उम्मीद से ज्यादा कठिन था। यह वास्तव में तेजी से विस्फोट करता है और काम नहीं करेगा (जब तक कि इसमें अधिक मेमोरी नहीं थी) लेकिन यह सभी आवश्यक मानदंडों को पूरा करता है।

— Sumner18
स्रोत

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

चुनौती

शर्तें

स्कोरिंग

उदाहरण

J, स्कोर 7 है (12 वर्ण - गुणन से बचने के लिए 5 अंक)

हास्केल, 87 85 - 5 == 80 82

गोल्फस्क्रिप्ट, 15 18 वर्ण

जे, १६ १ ९ १२ अक्षर

GolfScript (24 वर्ण - 5 = 19 अंक)

(या 20 वर्ण)

पायथन, 70

स्काला: 110

Br ** nfuck, 128-5 = 123 बाइट्स

पायथन, 161 - 5 (नहीं * ऑपरेटर) = 156

पर्ल, 61 वर्ण

गणितज्ञ , ४० ३३

हास्केल: 58 51 वर्ण, गुणन के साथ या उसके बिना।

रूबी 66 59 अक्षर

पायथन, 112 वर्ण

सी, 117 105 99 चार्ट

कारक, 187 वर्ण

हास्केल 110 - 5 = 105

रूबी, 47 46 45

लुआ: 133 चार्ट, गुणा-भाग

VBA, 90 शुल्क

90 वर्ण, कोई बिजली ऑपरेटर, गुणन = 90 का उपयोग नहीं करता है

116 चार्ट, कोई बिजली ऑपरेटर, कोई गुणा बोनस (-5) = 111 नहीं

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

लैम्ब्डा कैलकुलस, 10-5

व्याख्या

अजगर (111) (113) नहीं *

हास्केल: 88-5 वर्ण गुणा के बिना, 59 वर्ण गुणा के साथ

रैकेट 58 (नहीं *)

आम लिस्प, 85 वर्ण

पायथन 3 - 68

Yabasic , 71 बाइट्स

आर , 71 - 5 = 66 बाइट्स