यह एक साधारण चुनौती होनी चाहिए।

एक संख्या को देखते हुए n >= 0, सुपर-लॉगरिथम (या लॉग *, लॉग-स्टार या इटेरेटेड लॉगरिथम , जो कि nइस चुनौती के लिए कभी भी नकारात्मक नहीं है) के बराबर है n।

यह टेट्रेशन के दो विलोम कार्यों में से एक है । दूसरा सुपर-रूट है , जो संबंधित प्रश्न में है ।

उदाहरण

Input       Output
0           0
1           0
2           1
3           2
4           2
...
15          2
16          3
...
3814279     3
3814280     4

नियम

आपको दशमलवों का समर्थन करने की आवश्यकता नहीं है, हालांकि आप कर सकते हैं।
आपको कम से कम इनपुट का समर्थन करने की आवश्यकता है 3814280 = ceiling(e^e^e)।
आप मानों को हार्ड-कोड नहीं कर सकते हैं 3814280। (आपके कार्यक्रम को सैद्धांतिक रूप से उच्च संख्या का समर्थन करना चाहिए ।) मैं चाहता हूं कि एक एल्गोरिदम लागू किया जाए।
सबसे छोटा कोड जीतता है।

संबंधित OEIS

code-golf math code-golf array-manipulation sorting code-golf math arithmetic matrix code-golf string kolmogorov-complexity code-golf string code-golf math sequence arithmetic recursion code-golf math ascii-art sequence code-golf math array-manipulation code-golf code-golf kolmogorov-complexity code-golf string code-golf string decision-problem code-golf array-manipulation tips javascript json code-golf math string number number-theory code-golf math sequence fibonacci number arithmetic fastest-code integer code-golf math sequence code-golf string file-system tips golfscript code-golf string code-golf string natural-language code-golf string file-system code-golf math array-manipulation code-challenge image-processing compression code-golf math number sequence code-golf math combinatorics regular-expression code-golf sequence pi code-golf ascii-art code-golf string array-manipulation sorting code-golf string graph-theory code-golf string code-golf string ascii-art code-challenge compression code-golf code-golf math sequence number-theory code-golf maze graph-theory code-golf math sequence

— mbomb007
स्रोत

सम्बंधित।

— ओलिवर नी

14

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

ÆlÐĿĊḊi1

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

पृष्ठभूमि

हम इनपुट के प्राकृतिक लॉगरिदम और बाद के परिणामों को क्रमिक रूप से लेने से शुरू करते हैं जब तक कि परिणाम में परिवर्तन न हो। यह काम करता है क्योंकि जटिल तल पर प्राकृतिक लघुगणक के विस्तार का एक निश्चित बिंदु है ; if z = e ^{-W (-1)} = 0.318 + 1.337i - जहां W लैम्बर्ट डब्ल्यू फ़ंक्शन को दर्शाता है - हमारे पास लॉग (z) = z है ।

इनपुट एन के लिए , कंप्यूटिंग के बाद [एन, लॉग (एन), लॉग (लॉग (एन)),…, जेड] , हम सबसे पहले प्रत्येक परिणाम के लिए सीलिंग फ़ंक्शन लागू करते हैं। जेली का कार्यान्वयन ( Ċ) वास्तव में ^{† के} बजाय जटिल संख्या के काल्पनिक भाग की गणना करता है , लेकिन हम वैसे भी इन में रुचि नहीं रखते हैं।

एक बार कश्मीर ^वें के आवेदन लॉग एक मूल्य के कम पैदावार या इसके बराबर 1 , Ċवापस आ जाएगी 1 पहली बार के लिए। उस पहले 1 का 0-आधारित सूचकांक वांछित परिणाम है।

सीधा कार्यान्वयन (गणना 1-आधारित इंडेक्स, डिक्रिमेंट) एज केस 0 की वजह से विफल हो जाता है , जिसके लॉगरिदम की सूची में 1 नहीं है । वास्तव में, इनपुट 0 के लिए , लघुगणक का क्रम है

[0, None]

इसका कारण यह है कि जेली का लघुगणक ( Æl) अतिभारित है; यह पहले math.log(वास्तविक लघुगणक) की कोशिश करता है , फिर cmath.log(जटिल लघुगणक), और अंत में "देता है" और वापस लौटता है None। सौभाग्य से, Ċइसी तरह अतिभारित है और बस इसे तर्क देता है यदि यह गोल नहीं हो सकता है या काल्पनिक भाग नहीं ले सकता है।

इसी तरह, इनपुट 1 रिटर्न

[1, 0, None]

जो अन्य तरीकों में समस्याएँ पैदा कर सकता है जो इसमें शामिल होते हैं या शामिल नहीं होते हैं Ċ।

इस समस्या को ठीक करने का एक तरीका Ḋलॉगरिदम की सरणी के लिए लागू (dequeue; पहला तत्व निकालता है) है। यह नक्शे

0ÆlÐĿ -> [0, None]    -> [None]
1ÆlÐĿ -> [1, 0, None] -> [0, None]

इसलिए न तो सूची में अब 1 है। इस तरह, पहले 1 के सूचकांक को खोजने पर 0 वापस आएगा (नहीं मिला), जो कि इनपुट 0 और 1 के लिए वांछित आउटपुट है ।

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

ÆlÐĿĊḊi1  Main link. Argument: n (non-negative integer)

  ÐĿ      Apply the following link until the results are no longer unique.
Æl          Natural logarithm.
          Return the array of all unique results.
    Ċ     Round all resulting real numbers up to the nearest integer. This takes
          the imaginary part of complex numbers and does nothing for non-numbers.
     Ḋ    Dequeue; remove the first item (n) of the array of results.
      i1  Find the first index of 1 (0 if not found).

^Of _{यह जेली में केवल तीन परमाणुओं में से एक है जो गैर-स्पष्ट तरीके से अतिभारित हैं।}

— डेनिस
स्रोत

11

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

Æl>1$Ð¿L’

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

परीक्षण सूट। (ज़रा - सा संशोधित।)

व्याख्या

Æl>1$Ð¿L’
     Ð¿    while loop, collect all intermediate results.
  >1$      condition: z>1
Æl         body: natural logarithm.
       L   length of the array containing all intermediate results,
           meaning number of iterations
        ’  minus one.

— लीक नन
स्रोत

7

सी, 38 बाइट्स

f(double n){return n>1?1+f(log(n)):0;}

सुंदर आत्म-व्याख्यात्मक।

इसे आइडोन पर आज़माएं।

— owacoder
स्रोत

7

जावास्क्रिप्ट, 45 27 26 बाइट्स

l=a=>a>1&&1+l(Math.log(a))

यहाँ परीक्षण सूट (3 रेव) है

धन्यवाद @LeakyNun सशर्त के साथ 1 बाइट बचाने के लिए और फिर समारोह को लंबोदर में परिवर्तित करने के लिए, और @Nil को गलत इंगित करने के लिए ठीक है = <(1 के बदले = = के बदले परीक्षण =) के लिए ठीक रिटर्न मान है

— CShark
स्रोत

मैं इसे es6 के बिना कर रहा था, लेकिन हाँ जो 1 बाइट छोटा होगा, धन्यवाद।

— सीएसकेर

आप लंबोदर का उपयोग क्यों नहीं करेंगे?

— लीक नन

कोई अच्छा कारण नहीं है, मैंने अभी इसका इतना उपयोग नहीं किया है, इसलिए यह मेरी पहली वृत्ति नहीं है

— CShark

जाहिरा तौर पर हमें false0 के बजाय वापस जाने की अनुमति है (क्योंकि यह स्वतः पूर्णांक में 0 में परिवर्तित हो जाता है) जिस स्थिति में आप इसे छोड़ सकते हैं |0।

— नील

इससे 1 बाइट बचती है, लेकिन "ऑटो-कंवर्ट टू 0" से आपका क्या मतलब है? यह क्या है"?

— सीएसकेर

6

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

If[#>1,1+#0@Log@#,0]&

पुनरावर्ती अनाम फ़ंक्शन। एक पूर्णांक को इनपुट के रूप में लेता है और अपने सुपर-लॉगरिथम को आउटपुट के रूप में देता है। बस दी गई परिभाषा का उपयोग करता है।

— LegionMammal978
स्रोत

3

मैं वास्तव में समय से पहले यह देखने के लिए तैयार था कि क्या कोई बिल्ट-इन है। जब वहाँ नहीं था तो मैं हैरान था। : D

— mbomb007

5

दिल्लोग एपीएल , 13 बाइट्स

ओपी का सीधा अनुवाद:

{⍵≤1:0⋄1+∇⍟⍵}

TryAPL ऑनलाइन!

— एडम
स्रोत

5

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

L&>b1hy.lb

परीक्षण सूट।

यह एक फ़ंक्शन को परिभाषित करता है।

— लीक नन
स्रोत

मुझे आपके परीक्षण सूट में कोई आउटपुट नहीं दिख रहा है। आउटपुट में बस खाली लाइनों का एक गुच्छा।

— mbomb007

@ mbomb007 फिक्स्ड।

— लीक नून

वे कूलर: tl.u?>N1.l;-)

— जकूबे

@Jakube आप पोस्ट कर सकते हैं!

— लीके नन

5

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

l x|x>1=1+l(log x)|1<2=0

प्रयोग उदाहरण: l 3814280-> 4।

— nimi
स्रोत

4

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

import math
s=lambda x:x>1and-~s(math.log(x))

इसके लिए x <= 1, यह रिटर्न False( == 0पायथन में है)।

— लिन
स्रोत

हाँ, के Falseलिए इस्तेमाल किया जा सकता है 0।

— mbomb007

इसके अलावा, आपने मेरे भोले कार्यान्वयन ( andबजाय उपयोग करके if else) को हराया । Grats।

— mbomb007

4

05AB1E, 16 13 बाइट्स

[Dî2‹#¼žr.n]¾

व्याख्या

              # implicit input n
[          ]  # infinite loop
 Dî2‹#        # break if n rounded up is less than 2
      ¼       # else, increase counter
       žr.n   # set next n = log(n)
            ¾ # push counter and implicitly print

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

— Emigna
स्रोत

3

MATL , 15 12 बाइट्स

0`ZetG>~}x@q

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें (कई आदानों को संभालने के लिए थोड़ा संशोधित संस्करण)।

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

0 से शुरू, इनपुट से अधिक होने तक पुनरावृत्त घातांक लागू करें। आउटपुट पुनरावृत्तियों की संख्या माइनस 1 है।

0       % Push 0
`       % Do...while loop
  Ze    %   Exponential
  t     %   Duplicate
  G     %   Push input
  >~    %   Is current value less than or equal to the input? If so: next iteration
}       % Finally (code executed at the end of the last iteration)
  x     %   Delete
  @q    %   Iteration index minus 1
        % Implicitly end loop
        % Implicitly display stack

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

3

जे , 21 19 18 16 बाइट्स

लीकी नन को 2 बाइट्स, गैलन इवानोव को 1 बाइट और फ्रॉन्फ्रॉग को 2 बाइट्स दिए गए!

2#@}.(0>.^.)^:a:

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

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

ls =: >:@$:@^.`0:@.(<:&1)
   ls 0
0
   ls 1
0
   ls 2
1
   ls 3
2
   ls 4
2
   ls 15
2
   ls 16
3
   ls 3814280
4

— कोनोर ओ ब्रायन
स्रोत

यहाँ मेरा 18 बाइट्स समाधान है: 2#@}.^.^:(0<])^:a:(मैंने इस समस्या के बारे में जानने के लिए क्या करना शुरू कर दिया।)

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

2#@}.(0>.^.)^:a:काम करने लगता है।

— FrownyFrog

यकीन नहीं है अगर यह बराबर है।

— FrownyFrog

2

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

!x=x>1&&1+!log(x)

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

— डेनिस
स्रोत

2

MATLAB / ऑक्टेव, 44 बाइट्स

function a=g(n);a=0;if n>1;a=1+g(log(n));end

एक अनाम फ़ंक्शन के रूप में यह सब करने की कोशिश की, लेकिन मैं भूल गया कि MATLAB / ऑक्टेव अभिव्यक्ति का मूल्यांकन करना जारी रखता है, भले ही वे एक बूलियन झूठी (शून्य) मूल्य से गुणा कर रहे हों:

f=@(n)(n>1)*(1+f(log(n)))

— costrom
स्रोत

हां, शॉर्ट-सर्कुलेटिंग प्रोडक्ट का अच्छा होना :-)

— लुइस मेंडू

2

आर, 38 37 बाइट्स

f=function(x)if(x>1)1+f(log(x))else 0

अतिरिक्त बाइट के लिए @ user5957401 धन्यवाद !

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

> f(0)
[1] 0
> f(1)
[1] 0
> f(2)
[1] 1
> f(3)
[1] 2
> f(4)
[1] 2
> f(3814279)
[1] 3
> f(3814280)
[1] 4

— plannapus
स्रोत

मुझे लगता है कि आप एक बाइट को बचा सकते हैं यदि एक शाब्दिक का उपयोग करके, अन्य विवरण। यानी if(x>1)1+f(log(x))else 0एक बाइट कम है।

— user5957401

2

आर , 34 बाइट्स

f=pryr::f(`if`(n>1,1+f(log(n)),0))

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

एक गैर-पुनरावर्ती दृष्टिकोण संभव है: 36 बाइट्स और स्टड से इनपुट लेता है।

n=scan()
while((n=log(n))>0)F=F+1
+F

— rturnbull
स्रोत

2

जावा 7, 47 बाइट्स

int c(double n){return n>1?1+c(Math.log(n)):0;}

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

पुनरावर्ती जावा 7 शैली विधि ऊपर 2 बाइट्स है जो पुनरावृत्त जावा 8 शैली लैंबडा से छोटी है:

n->{int c=0;for(;n>1;c++)n=Math.log(n);return c;}

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

स्पष्टीकरण:

int c(double n){      // Method with double parameter and integer return-type
  return n>1?         //  If the input is larger than 1:
    1+                //   Return 1 +
      c(Math.log(n))  //   A recursive call with log(input)
   :                  //  Else:
    0;                //   Return 0 instead

n->{                  // Method with double parameter and integer return-type
  int c=0;            //  Create a counter, starting at 0
  for(;n>1;           //  Loop as long as the input is still larger than 1:
    c++)              //   Increase the counter by 1
    n=Math.log(n);    //   And update the input to log(input)
  return c;}          //  After the loop: return the counter as result

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

आप इसे Java 8 लैम्ब्डा के साथ छोटा कर सकते हैं।

— mbomb007

@ mbomb007 तीन साल बाद जवाब दे रहा है, हाहा .. (उस समय मैं केवल जावा 7 में कोड-गोल्फिंग कर रहा था), लेकिन अभी भी आपके सवाल का जवाब देने के लिए: नहीं, दुर्भाग्य से जावा 8 लैम्ब्डा पुनरावर्ती विधि से 2 बाइट्स लंबा है। मैंने इसे अपने उत्तर में जोड़ा है, और मैंने एक स्पष्टीकरण भी जोड़ा है।

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

तो आप पुनरावर्ती लम्बदास नहीं कर सकते?

— mbomb007

@ mbomb007 नहीं, जावा में दुर्भाग्य से नहीं। पायथन, जावास्क्रिप्ट में, और मुझे लगता है कि C # .NET के रूप में अच्छी तरह से, पुनरावर्ती लैम्ब्डा संभव हैं, लेकिन जावा में किसी कारण से नहीं ..

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

1

एमएसीएस लिस्प, 38 बाइट्स

(defun l(n)(if(> n 1)(1+(l(log n)))0))

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

(mapcar 'l '(0 1 2 3 4 15 16 3814279 3814280))
;; (0 0 1 2 2 2 3 3 4)

— भगवान युमा
स्रोत

1

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

-Ælß$Ị?‘

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

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

-Ælß$Ị?‘  Main link. Argument: x

     Ị    Insignificant; test if |x| ≤ 1.
      ?   If the result is 1:
-           Return -1.
          Else:
   $        Execute the monadic chain formed by the two links to the left.
Æl            Apply natural logarithm to x.
  ß           Recursively call the main link.
       ‘  Increment the result.

— डेनिस
स्रोत

1

पर्ल 5, 35 बाइट्स

अनाम पुनरावृत्ति के लिए कीवर्ड -M5.016को सक्षम करने के लिए बहुत सरल, आवश्यक (जो मुफ़्त है) __SUB__।

sub{$_[0]>1?1+__SUB__->(log pop):0}

एक और विकल्प है

sub{$_[0]>1?1+__SUB__->(log pop):0}

जो 34 बाइट्स है, और सभी इनपुट> 1 के लिए समान आउटपुट देता है, लेकिन इनपुट के लिए विशेष गलत मान देता है <= 1. झूठी संख्यात्मक रूप से शून्य के बराबर है, लेकिन "" (खाली स्ट्रिंग) के रूप में प्रिंट करता है, इसलिए यह संभव नहीं है ' टी क्वालीफाई।

— हॉब्स
स्रोत

बहुत बढ़िया जवाब। sub{($_=pop)>1?1+__SUB__->(log):0}हालांकि आप 1 बाइट जीत सकते हैं

— दादा

1

CJam (16 बाइट्स)

rd{_1>}{_ml}w],(

ऑनलाइन डेमो

पूर्व स्थिति के साथ लूप करते समय सरल। (क्या मैं वास्तव में यहाँ चाहता हूँ एक गोल्फस्क्रिप्ट शैली प्रकट ऑपरेशन है, लेकिन CJam एक नहीं है, और GolfScript में अस्थायी बिंदु गड़बड़ है और सभी गोल्फ में नहीं है)।

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

एक तरफ, यह गणित में मेरा 80 वां उत्तर है और आज मुझे अपना दूसरा टैग बैज मिला है।

— पीटर टेलर

1

PARI / GP , 24 बाइट्स

बस सीधी साधी पुनरावृत्ति।

f(n)=if(n>1,1+f(log(n)))

— चार्ल्स
स्रोत

1

रैकेट, 61 बाइट्स

(λ(x)(letrec([a(λ(b)(if(> b 1)(+ 1 (a(log b)))0))])(a x)))

— स्टीवन एच।
स्रोत

1

मेपल, 32,30 29 बाइट्स

f:=x->`if`(x>1,1+f(log(x)),0)

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

> f(0.);
  0
> f(1.);
  0
> f(2.);
  1
> f(3.);
  2
> f(4.);
  2
> f(3814279.);
  3
> f(3814280.);
  4

— DSkoog
स्रोत

1

आर, 36 बाइट्स

प्लेनैपस से थोड़ा अलग दृष्टिकोण

->n;a=0;while(n>1){a=a+1;n=log(n)};a

कोड को चलाने के लिए एक सही असाइनमेंट का उपयोग करता है - इसलिए वांछित संख्या को इसे पूर्ववर्ती करना होगा। अर्थात

10->n;a=0;while(n>1){a=a+1;n=log(n)};a

— user5957401
स्रोत

0

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

सभी नरक के रूप में सरल, और बड़े पैमाने पर नकारात्मक इनपुट के रूप में अच्छी तरह से काम करता है:

f[x_]:=If[x>1,1+f[Log[x]],0]

— Landak
स्रोत

0

रूबी, 29 बाइट्स

l=->n{n<=1?0:1+l[Math.log n]}

— सिम्स
स्रोत

-1 बाइट को पुनर्लेखन के n<=1?a:bरूप में n>1?b:aऔर -1 अधिक बाइट को अनाम लंबोदर फ़ंक्शन के साथ ।

— ब्यूटी आर्ट

0

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

{($_,*.log...1>=*)-1}

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

कोष्ठक अभिव्यक्ति एक क्रम है। $_फ़ंक्शन का तर्क, पहला तत्व है। *.logपिछले तत्व का लॉग लेकर प्रत्येक क्रमिक तत्व उत्पन्न करता है। अनुक्रम तब तक जारी रहता है जब तक कि समाप्त होने वाली स्थिति, 1 >= *सच है: 1 वर्तमान तत्व से अधिक या उसके बराबर है। अनुक्रम से 1 घटाना एक संख्या के लिए इसे जोड़ता है: इसकी लंबाई।

— शॉन
स्रोत

सुपर-लघुगणक की गणना करें

उदाहरण

नियम

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

पृष्ठभूमि

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

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

व्याख्या

सी, 38 बाइट्स

जावास्क्रिप्ट, 45 27 26 बाइट्स

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

दिल्लोग एपीएल , 13 बाइट्स

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

हास्केल, 23 ​​बाइट्स

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

05AB1E, 16 13 बाइट्स

MATL , 15 12 बाइट्स

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

जे , 21 19 18 16 बाइट्स

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

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

MATLAB / ऑक्टेव, 44 बाइट्स

आर, 38 37 बाइट्स

आर , 34 बाइट्स

जावा 7, 47 बाइट्स

एमएसीएस लिस्प, 38 बाइट्स

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

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

पर्ल 5, 35 बाइट्स

CJam (16 बाइट्स)

PARI / GP , 24 बाइट्स

रैकेट, 61 बाइट्स

मेपल, 32,30 29 बाइट्स

आर, 36 बाइट्स

रूबी, 29 बाइट्स

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

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