टेट्रेशन, जैसा कि दर्शाया गया है a^^b, दोहराया घातांक है। उदाहरण के लिए, 2^^3है 2^2^2जो 16 है।

दो संख्याओं ए और बी को देखते हुए प्रिंट करें a^^b।

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

1 2 -> 1
2 2 -> 4
5 2 -> 3125
3 3 -> 7625597484987
etc.

^{वैज्ञानिक संकेतन स्वीकार्य है।}

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

code-golf math number

— ओलिवर नी
स्रोत

2

किस तरह की संख्या? सकारात्मक आंकड़े?

— xnor

Dyalog एपीएल, 3 बाइट्स

*/⍴

TryAPL।

व्याख्या

*/⍴  Input: b (LHS), a (RHS)
  ⍴  Create b copies of a
*/   Reduce from right-to-left using exponentation

— मील की दूरी पर
स्रोत

1

अरे, कोई है जो धड़कता है @ डेनिस! अब यह दुर्लभ है! (:: पी

— हाइपरन्यूट्रिनो 22

10

जे, 5 4 बाइट्स

^/@#

यह वस्तुतः टेट्रेशन की परिभाषा है।

प्रयोग

व्याख्या

^/@#  Input: b (LHS), a (RHS)
   #  Make b copies of a
^/@   Reduce from right-to-left using exponentation

— मील की दूरी पर
स्रोत

ठीक है ^ ^ b ऊपर से उलटा है b ^ ^ a ...

— RosLuP

@RosLuP हां, J और APL दाएं-बाएं 2 ^ 2 ^ 2से मूल्यांकन करते हैं , इसलिए मूल्यांकन किया जाता है 2 ^ (2 ^ 2)और इसी तरह

— मील

9

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

a%b=iterate(a^)1!!b

1सूची का निर्माण करने के लिए शुरू करने वाले घातांक को Iterates करता है [1,a,a^a,a^a^a,...], फिर b'th एलिमेंट' लेता है ।

एक ही लंबाई सीधे:

a%0=1;a%b=a^a%(b-1)

बिंदु-मुक्त लंबा है:

(!!).(`iterate`1).(^)

— XNOR
स्रोत

9

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

Power@@Table@##&

व्याख्या

Table@##

की प्रतियां बनाओ।

Power@@...

घातांक।

— जंगहवान मिन
स्रोत

8

पायथन, 30 बाइट्स

f=lambda a,b:b<1or a**f(a,b-1)

पुनरावर्ती परिभाषा का उपयोग करता है।

— XNOR
स्रोत

5

पायथन, 33 बाइट्स

lambda a,b:eval('**'.join([a]*b))

यह एक अनाम फ़ंक्शन का मूल्यांकन करता है, जो एक संख्या और एक संख्या का स्ट्रिंग प्रतिनिधित्व करता है। उदाहरण के लिए:

>>> f=lambda a,b:eval('**'.join([a]*b))
>>> f('5',2)
3125
>>>

अगर इस तरह के इनपुट फॉर्मेट की गणना नहीं होती है, तो यह 38 बाइट संस्करण भी है:

lambda a,b:eval('**'.join([str(a)]*b))

— DJMcMayhem
स्रोत

2

क्या मस्त विधि है!

— xnor

5

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

x*@/

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

x*@/  Main link. Arguments: a, b

x     Repeat [a] b times.
 *@/  Reduce the resulting array by exponentation with swapped arguments.

— डेनिस
स्रोत

3

पर्ल, 19 बाइट्स

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

STDIN पर अलग लाइनों पर नंबर दें

tetration.pl
2
3
^D

tetration.pl

#!/usr/bin/perl -p
$_=eval"$_**"x<>.1

— टन हास्पेल
स्रोत

3

आर, 39 बाइट्स

पुनरावर्ती समारोह:

f=function(a,b)ifelse(b>0,a^f(a,b-1),1)

— Billywob
स्रोत

2

तत्व , 11 बाइट्स

__2:':1[^]`

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

यह एक लूप में सिर्फ "सीधा" प्रतिपादक है।

__2:':1[^]`
__              take two values as input (x and y)
  2:'           duplicate y and send one copy to the control stack
     :          make y copies of x
      1         push 1 as the initial value
       [ ]      loop y times
        ^       exponentiate
          `     print result

— PhiNotPi
स्रोत

2

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

f=(a,b)=>b?a**f(a,b-1):1

ES6 संस्करण 33 बाइट्स है:

f=(a,b)=>b?Math.pow(a,f(a,b-1)):1

— ETHproductions
स्रोत

1 बाइट बचाएं:f=a=>b=>b?a**f(a,b-1):1

— प्रोग्रामर

2

डीसी, 35 29 बाइट्स:

?dsdsa?[ldla^sa1-d1<b]dsbxlap

यहाँ मेरा पहला पूरा कार्यक्रम है dc।

— आर। कप
स्रोत

1

पर्ल, 40 बाइट्स

map{$a=$ARGV[0]**$a}0..$ARGV[1];print$a;

फ़ंक्शन के इनपुट के रूप में दो पूर्णांकों को स्वीकार करता है और परिणाम को आउटपुट करता है

— गेब्रियल बेनामी
स्रोत

1

का प्रयोग करें popप्राप्त करने के लिए $ARGV[1], तो का उपयोग "@ARGV"पाने के लिए $ARGV[0]। के sayबजाय का उपयोग करें print(विकल्प -M5.010या -Eमुफ्त है)। लेकिन फिर भी, ARGVबहुत लंबा है। एक -pकार्यक्रम लगभग हमेशा जीतता है

— टन हास्पेल

1

दरअसल , 6 बाइट्स

n`ⁿ)`Y

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

इनपुट के रूप में लिया गया है b\na( \nएक नई पंक्ति है)

स्पष्टीकरण:

n`ⁿ)`Y
n       a copies of b
 `ⁿ)`Y  while stack changes between each call (fixed-point combinator):
  ⁿ       pow
   )      move top of stack to bottom (for right-associativity)

— मै जाऊं
स्रोत

1

CJam , 9 बाइट्स

q~)*{\#}*

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

व्याख्या

q~          e# Take input (array) and evaluate
  )         e# Pull off last element
   *        e# Array with the first element repeated as many times as the second
    {  }*   e# Reduce array by this function
     \#     e# Swap, power

— लुइस मेंडो
स्रोत

1

PHP, 51 बाइट्स

for($b=$p=$argv[1];++$i<$argv[2];)$p=$b**$p;echo$p;

— जार्ग हुल्सरमन
स्रोत

1

गेममेकर लैंग्वेज, 52 50 बाइट्स

d=a=argument0;for(c=1;c<b;c++)d=power(a,d)return d

— Timtech
स्रोत

यह मेरा 300 वां उत्तर है: ओ

— टाइमटेक

गेममेकर wtf? योग्य

— बस सुंदर कला

@SimplyBeautifulArt हाँ, और जब मैं इस पर हूँ तो मैं आपके लिए 2 बाइट ले जाऊँगा।

— टिमटेक

हाहा अच्छा है। =) मेरा +1 है, काफी सरल लगता है और मैं इसे समझता हूं।

— बस सुंदर कला

@SimplyBeautifulArt की प्रशंसा

— टिमटेक

0

अजगर, 6 बाइट्स

u^QGE1

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

व्याख्या

          (implicit: input a to Q)
     1    Start from 1.
u   E     b times,
 ^GQ      raise the previous number to power a.

— PurkkaKoodari
स्रोत

0

मिंकोलंग 0.15 , 12 11 बाइट्स

nnDI1-[;]N.

यहाँ यह कोशिश करो!

व्याख्या

nn             Read two integers from input
  D            Pop top of stack and duplicate next element that many times
   I1-         Push length of stack, minus 1
      [        Pop top of stack and repeat for loop that many times
       ;       Pop b, a and push a^b
        ]      Close for loop
         N.    Output as number and stop.

— एलेंडिया स्ट्राटन
स्रोत

0

रैकेट 51 बाइट्स

(define ans 1)(for((i b))(set! ans(expt a ans)))ans

Ungolfed:

(define (f a b)
  (define ans 1)
  (for((i b))
    (set! ans
          (expt a ans)))
  ans)

परिक्षण:

(f 1 2)
(f 2 2)
(f 5 2)
(f 3 3)

आउटपुट:

1
4
3125
7625597484987

— rnso
स्रोत

0

स्काला, 45 बाइट्स

Seq.fill(_:Int)(_:Double)reduceRight math.pow

Ungolfed:

(a:Int,b:Double)=>Seq.fill(a)(b).reduceRight(math.pow)

तत्वों के aसाथ एस का एक क्रम बनाएँ b, और math.powदाएं से बाएं से लागू करें ।

— corvus_192
स्रोत

0

टीआई-बेसिक, 19 बाइट्स

Prompt A,B
A
For(C,2,B
A^Ans
End

— Timtech
स्रोत

0

जावा 7, 71 57 बाइट्स

double c(int a,int b){return b>0?Math.pow(a,c(a,b-1)):1;}

Ungolfed और परीक्षण कोड:

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

class M{
  static double c(int a, int b){
    return b > 0
            ? Math.pow(a, c(a, b-1))
            :1;
  }

  public static void main(String[] a){
    System.out.println(c(1, 2));
    System.out.println(c(2, 2));
    System.out.println(c(5, 2));
    System.out.println(c(3, 3));
  }
}

आउटपुट:

1.0
4.0
3125.0
7.625597484987E12

— केविन क्रूज़सेन
स्रोत

0

सी, 50 बाइट्स

double t(int x,int n){return n?pow(x,t(x,n-1)):1;}

टेट्रेटेशन की परिभाषा से सीधा ।

— कार्ल नेफ
स्रोत

0

05AB1E , 4 बाइट्स

sF¹m

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

s     # Swap input arguments.
 F    # N times...
  ¹m  # Top of the stack ^ the first argument.

अगर तर्क दिया जा सकता है तो 3 बाइट्स:

F¹m

— जादू ऑक्टोपस Urn
स्रोत

2 2 परिणाम 16 नहीं 4 = 2 ^ 2

— RosLuP

a=5, b=2आउटपुट चाहिए 3125। मुझे यकीन नहीं है कि आप किस क्रम में इनपुट ले रहे हैं, लेकिन फिर भी मैंने 5 और 2 में डाल दिया, मुझे गलत परिणाम मिला।

— FlipTack

0

बैश, 50 बाइट्स

(बैश पूर्णांक डेटा प्रकार की सीमा के भीतर)

golfed

E() { echo $(($(printf "$1**%.0s" `seq 1 $2`)1));}

व्याख्या

Printf के साथ अभिव्यक्ति बनाएँ, जैसे E 2 5:

  2**2**2**2**2**1

फिर परिणाम की गणना करने के लिए बैश बिल्ट-इन अंकगणितीय विस्तार का उपयोग करें

परीक्षा

E 1 2
1

E 2 2
4

E 5 2
3125

E 3 3
7625597484987

— टसेपेल्लिन
स्रोत

0

पॉवरशेल, 68 बाइट्स

filter p ($a){[math]::Pow($a,$_)};iex (,$args[0]*$args[1]-join"|p ")

यह उन तीन दृष्टिकोणों में से सबसे छोटा है, जिनकी मैंने कोशिश की थी, हालांकि यह बहुत अच्छा नहीं था, लेकिन मुझे लगता है कि 100% यकीन है कि एक छोटा दृष्टिकोण है, लेकिन कुछ चीजें जो मैंने किसी तरह की कोशिश की, वे थोड़े अधिक बाइट्स के साथ समाप्त हुईं।

PS C:\++\golf> (1,2),(2,2),(5,2),(3,3) | % {.\sqsq $_[0] $_[1]}
1
4
3125
7625597484987

अफसोस की बात है कि Powershell का कोई अंतर्निहित ^या **ऑपरेटर नहीं है, या यह एक साफ 32/33 बाइट उत्तर होगा, अर्थात

iex (,$args[0]*$args[1]-join"^")

— colsw
स्रोत

0

Axiom 70 बाइट्स

l(a,b)==(local i;i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1);r)

यह कम गोल्फ वाला है

l(a,b)==
  local i
  i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1)
  r


(3) ->  [l(1,2),l(2,2),l(5,2),l(3,3),l(4,3)]

     (3)
     [1, 4, 3125, 7625597484987,
      13407807929942597099574024998205846127479365820592393377723561443721764030_
       0735469768018742981669034276900318581864860508537538828119465699464336490_
       06084096
       ]
                                                   Type: List PositiveInteger

— RosLuP
स्रोत

0

आश्चर्य है , 21 बाइट्स

f\@@[#0?^#1f#1-#0 1?1

पुनरावर्ती दृष्टिकोण का उपयोग करता है। उपयोग:

f\@@[#0?^#1f#1-#0 1?1];f 2 3

बोनस समाधान, 22 बाइट्स

@@:^ -#0 1(genc ^#1)#1

थोड़ा अपरंपरागत दृष्टिकोण। उपयोग:

t\@@+>#[^;#1]tk -#0 1rpt#1;t 2 3

अधिक पठनीय:

@@
  iget
    - #0 1
    (genc ^#1) #1

मान लेना a^^b:

टेटेड की एक अनंत सूची बनाता है a; के लिए a=2, यह सूची कुछ इस तरह दिखाई देगी [2 4 16 65536...]। तब अनुक्रमित होता है b-1क्योंकि वंडर शून्य-अनुक्रमित होता है।

— मामा फन रोल
स्रोत

0

क्लोजर, 56 बाइट्स

(fn[a b](last(take a(iterate #(apply *(repeat % b))b))))

शायद वहाँ के माध्यम से एक छोटा रास्ता है apply comp?

— NikoNyrh
स्रोत

टेट्रेशन प्रिंट करें

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

Dyalog एपीएल, 3 बाइट्स

व्याख्या

जे, 5 4 बाइट्स

प्रयोग

व्याख्या

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

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

व्याख्या

पायथन, 30 बाइट्स

पायथन, 33 बाइट्स

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

यह काम किस प्रकार करता है

पर्ल, 19 बाइट्स

आर, 39 बाइट्स

तत्व , 11 बाइट्स

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

डीसी, 35 29 बाइट्स:

पर्ल, 40 बाइट्स

दरअसल , 6 बाइट्स

CJam , 9 बाइट्स

व्याख्या

PHP, 51 बाइट्स

गेममेकर लैंग्वेज, 52 50 बाइट्स

अजगर, 6 बाइट्स

व्याख्या

मिंकोलंग 0.15 , 12 11 बाइट्स

व्याख्या

रैकेट 51 बाइट्स

स्काला, 45 बाइट्स

टीआई-बेसिक, 19 बाइट्स

जावा 7, 71 57 बाइट्स

सी, 50 बाइट्स

05AB1E , 4 बाइट्स

बैश, 50 बाइट्स

पॉवरशेल, 68 बाइट्स

आश्चर्य है , 21 बाइट्स

बोनस समाधान, 22 बाइट्स

क्लोजर, 56 बाइट्स