একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া এন এবং একটি সংখ্যা একটি , এন -th tetration এর একটি হিসাবে সংজ্ঞায়িত করা হয় একটি ^ ( একটি ^ ( একটি ^ (... ^ একটি ))), যেখানে ^ exponentiation (অথবা ক্ষমতা) উল্লেখ করে এবং অভিব্যক্তি রয়েছে সংখ্যা একটি ঠিক এন বার।

অন্য কথায়, টিট্রেশন হ'ল ডান-অ্যাসোসিয়েটিভ ইটারেটেড এক্সপেনসিয়েনশন। জন্য এন = 4 এবং একটি = 1.6 tetration 1,6 ^ (1,6 ^ (1,6 ^ 1,6)) হয় ≈ 3,5743।

N এর সাথে সম্মতি সহ tetration এর বিপরীত ফাংশন হ'ল সুপার-লগারিদম । পূর্ববর্তী উদাহরণে, 4 হ'ল "সুপার-বেস" 1.6 সহ 3.5743 এর সুপার-লগারিদম।

চ্যালেঞ্জ

একটি ধনাত্মক পূর্ণসংখ্যা দেওয়া এন , খুঁজুন এক্স যেমন যে এন সুপার-বেস নিজেই সুপার লগারিদম হয় এক্স । অর্থাত্, x এর মতো x সন্ধান করুন ( x ^ ( x ^ (... ^ x ))) ( x বার এন প্রদর্শিত হবে ) এর সমান n ।

বিধি

প্রোগ্রাম বা ফাংশন অনুমোদিত।

ইনপুট এবং আউটপুট ফর্ম্যাটগুলি যথারীতি নমনীয়।

অ্যালগরিদম সমস্ত ধনাত্মক পূর্ণসংখ্যার জন্য তাত্ত্বিকভাবে কাজ করা উচিত। অনুশীলনে, ইনপুট মেমরি, সময় বা ডেটা-টাইপ বিধিনিষেধের কারণে সর্বাধিক মানের সীমাবদ্ধ হতে পারে। তবে কোডটি 100কমপক্ষে এক মিনিটেরও কম সময়ে ইনপুটগুলির জন্য কাজ করতে হবে।

অ্যালগরিদমের তাত্ত্বিকভাবে 0.001নির্ভুলতার সাথে ফলাফল দেওয়া উচিত । অনুশীলনে, আউটপুট যথাযথতা আরও খারাপ হতে পারে কারণ সংখ্যামূলক গণনাগুলিতে জমা হওয়া ত্রুটির কারণে। তবে 0.001নির্দেশিত পরীক্ষার ক্ষেত্রে আউটপুট অবশ্যই সঠিক হতে হবে ।

সংক্ষিপ্ততম কোড জিতেছে।

পরীক্ষার মামলা

1    ->  1
3    ->  1.635078
6    ->  1.568644
10   ->  1.508498
25   ->  1.458582
50   ->  1.448504
100  ->  1.445673

রেফারেন্স বাস্তবায়ন

মতলব / অষ্টাভে একটি রেফারেন্স প্রয়োগকরণ এখানে রয়েছে (এটি আইডিয়নে চেষ্টা করুন )।

N = 10; % input
t = .0001:.0001:2; % range of possible values: [.0001 .0002 ... 2]
r = t;
for k = 2:N
    r = t.^r; % repeated exponentiation, element-wise
end
[~, ind] = min(abs(r-N)); % index of entry of r that is closest to N
result = t(ind);
disp(result)

জন্য N = 10এই দেয় result = 1.5085।

নিম্নলিখিত কোডটি ভেরিয়েবল-স্পষ্টতা পাটিগণিত ব্যবহার করে আউটপুট নির্ভুলতার একটি চেক :

N = 10;
x = 1.5085; % result to be tested for that N. Add or subtract 1e-3 to see that
            % the obtained y is farther from N
s = num2str(x); % string representation
se = s;
for n = 2:N;
    se = [s '^(' se ')']; % build string that evaluates to iterated exponentiation
end
y = vpa(se, 1000) % evaluate with variable-precision arithmetic

এটি দেয়:

এর জন্য x = 1.5085:y = 10.00173...
এর জন্য x = 1.5085 + .001:y = 10.9075
জন্য x = 1.5085 - .001এটা দেয় y = 9.23248।

নির্ভুলতার 1.5085সাথে বৈধ সমাধানও তাই .001।

code-golf math number

— লুইস মেন্ডো
সূত্র

সম্পর্কিত । পার্থক্যগুলি হ'ল এখানে সুপার-লোগারিদমের (সুপার-) বেসটি স্থির নয়, এবং ফলাফলটি সাধারণভাবে পূর্ণসংখ্যার নয়।

— লুইস মেন্ডো

দেখে মনে হচ্ছে ফাংশনটি দ্রুত পরিবর্তিত হয়। যদি আমাদের অ্যালগরিদম কেবল 0.001 এর মধ্যে একটি বক্ররেখার ফিট হয় তবে সেই গণনাটি তাত্ত্বিকভাবে সমস্ত ধনাত্মক পূর্ণসংখ্যার জন্য কাজ করে?

— xnor

2

হুম, ওল্ফ্রামাল্ফায় ইতিমধ্যে পরীক্ষার কেস 6 নিয়ে সমস্যা রয়েছে .. " স্ট্যান্ডার্ড গণনার সময় অতিক্রম করেছে ... "

— কেভিন ক্রুইজসেন

@ কেভিন ক্রুজসেন আমার কাছে বাইনারি অনুসন্ধানের ভিত্তিতে মতলব-এ একটি রেফারেন্স বাস্তবায়ন রয়েছে যা যুক্তিসঙ্গত দ্রুত। এটি সহায়ক হলে আমি এটি পোস্ট করতে পারি

— লুইস মেন্ডো

1

নেই xমিলিত যেমন nঅনন্ত পন্থা?

— mbomb007

3

ডায়ালগ এপিএল , 33 25 বাইট

⎕IO←0অনেকগুলি সিস্টেমে ডিফল্ট হওয়া দরকার ।

⌈/⎕(⊢×⊣≥(*/⍴)¨)(1+⍳÷⊢)1E4

তাত্ত্বিকভাবে সমস্ত পূর্ণসংখ্যার জন্য গণনা করা হয়, তবে কার্যত কেবল খুব ছোট একটিতে সীমাবদ্ধ।

অনলাইনে চেষ্টা করুন!

— আদম
সূত্র

এটি কি ইনপুট 100 তে যথেষ্ট দ্রুত কাজ করে?

— গ্রেগ মার্টিন

@ গ্রেগমার্টিন যথেষ্ট স্মৃতি নেই।

— অ্যাডম

10

হাস্কেল, 55 54 52 বাইট

s n=[x|x<-[2,1.9999..],n>iterate(x**)1!!floor n]!!0

ব্যবহার:

> s 100
1.445600000000061

1 বাইটের জন্য @ নিমিকে ধন্যবাদ!
2 xxor কে ধন্যবাদ!

— BlackCap
সূত্র

1

[ ]!!0head[ ]বাইট সংরক্ষণ করার পরিবর্তে

— নিমি

1

s n=[x|x<-[2,1.9999..],n>iterate(x**)1!!n]!!0আপনি যদি হ্যাসেলকে এর ধরণগুলি গ্রহণ করতে পারেন তবে তা আরও কম হবে।

— xnor

@xnor আমি যখন এটি লিখেছিলাম তখন আমি পুনরাবৃত্তির সাথে খেলেছি তবে কোনওরকমে এটি আরও দীর্ঘ হয়ে উঠল

— ব্ল্যাকক্যাপ

6

জাভাস্ক্রিপ্ট, ES6: 77 বাইট / ES7: 57 53 বাইট

ES6

n=>eval("for(x=n,s='x';--x;s=`Math.pow(x,${s})`);for(x=2;eval(s)>n;)x-=.001")

ES7

**ড্যানথম্যানের পরামর্শ অনুসারে ব্যবহার করা:

n=>eval("for(x=2;eval('x**'.repeat(n)+1)>n;)x-=.001")

উদাহরণ

let f =
n=>eval("for(x=n,s='x';--x;s=`Math.pow(x,${s})`);for(x=2;eval(s)>n;)x-=.001")

console.log(f(25));

স্নিপেট প্রসারিত করুন

— Arnauld
সূত্র

আপনি যদি ES7 ব্যবহার করেন তবে আপনি ব্যবহার করতে পারেন ** পরিবর্তেMath.pow ।

— DanTheMan

4

গণিত, 40 33 বাইট

প্রায় 20% সাশ্রয়ের জন্য মারফিটিকে ধন্যবাদ!

1//.x_:>x+.001/;Nest[x^#&,1,#]<#&

Nest[x^#&,1,n]এক্স এর নবম টিটারেশন উত্পাদন করে। সুতরাং Nest[x^#&,1,#]<#x এর (ইনপুট) তম টিট্রেশন (ইনপুট) এর চেয়ে কম কিনা তা পরীক্ষা করে। আমরা কেবল x = 1 থেকে শুরু করি এবং টেটারেশন খুব বড় না হওয়া পর্যন্ত বারবার 0.001 যুক্ত করি, তারপরে শেষ x মানটি আউটপুট করে (সুতরাং উত্তরটি সঠিক মানের চেয়ে বড় হতে পারে তবে 0.001 এর মধ্যে গ্যারান্টিযুক্ত)।

যেহেতু আমি আস্তে আস্তে শিখছি: //.x_:>y/;zবা এর //.x_/;z:>yঅর্থ "টেমপ্লেট এক্সের সাথে মেলে এমন কোনও কিছুর সন্ধান করুন, তবে কেবলমাত্র সেই জিনিসগুলির জন্য যা পরীক্ষার জেড সত্য প্রত্যাবর্তন করে; এবং তারপরে এক্স নিয়মে y দ্বারা চালিত হয়; বারবার কিছুই পরিবর্তন না হওয়া পর্যন্ত"। এখানে টেমপ্লেটটি x_কেবল "আমি দেখতে পাই এমন কোনও সংখ্যার", যদিও অন্যান্য প্রসঙ্গে এটি আরও বাধা দেওয়া যেতে পারে।

যখন ইনপুট কমপক্ষে 45 হয়, টেটারেশনটি এত দ্রুত বৃদ্ধি পায় যে শেষ ধাপটি একটি ওভারফ্লো ত্রুটির কারণ হয়; তবে x এর মানটি এখনও আপডেট হয় এবং সঠিকভাবে আউটপুট দেয়। পদক্ষেপের আকারটি 0.001 থেকে 0.0001 থেকে কমিয়ে 112 অবধি ইনপুটগুলির জন্য এই সমস্যাটি সমাধান করে এবং বুটের আরও সুনির্দিষ্ট উত্তর দেয় (এবং এখনও প্রায় এক চতুর্থাংশের মধ্যে দ্রুত চলে) runs তবে এটি একটি অতিরিক্ত বাইট, তাই এটি ভুলে যান!

মূল সংস্করণ:

x=1;(While[Nest[x^#&,1,#]<#,x+=.001];x)&

— গ্রেগ মার্টিন
সূত্র

একটু Golfed:1//.x_:>x+.001/;Nest[x^#&,1,#]<#&

— মারফি

@ মুরফি: দুর্দান্ত! আমি শপথ করছি আমি এখনও সেই বিন্দুতে পৌঁছে যাব যেখানে আমি //.সাহায্য ছাড়াই ব্যবহার করতে পারি :)

— গ্রেগ মার্টিন

4

জে, 39 31 28 বাইট

(>./@(]*[>^/@#"0)1+i.%])&1e4

রেফারেন্স বাস্তবায়ন উপর ভিত্তি করে। এটি কেবলমাত্র তিনটি দশমিক জায়গায় সঠিক।

@ অ্যাডম থেকে পদ্ধতিটি ব্যবহার করে 8 বাইট সংরক্ষণ করা হয়েছে সমাধান ।

ব্যবহার

একাধিক ইনপুট / আউটপুট ফর্ম্যাট করতে অতিরিক্ত কমান্ড ব্যবহার করা হয়।

   f =: (>./@(]*[>^/@#"0)1+i.%])&1e4
   (,.f"0) 1 3 6 10 25 50 100
  1      0
  3  1.635
  6 1.5686
 10 1.5084
 25 1.4585
 50 1.4485
100 1.4456
   f 1000
1.4446

ব্যাখ্যা

(>./@(]*[>^/@#"0)1+i.%])&1e4  Input: n
                         1e4  The constant 10000
(                      )      Operate on n (LHS) and 10000 (RHS)
                   i.           The range [0, 10000)
                      ]         Get (RHS) 10000
                     %          Divide each in the range by 10000
                 1+             Add 1 to each
     (          )               Operate on n (LHS) and the range (RHS)
             #"0                  For each in the range, create a list of n copies
          ^/@                     Reduce each list of copies using exponentation
                                  J parses from right-to-left which makes this
                                  equivalent to the tetration
        [                         Get n
         >                        Test if each value is less than n
      ]                           Get the initial range
       *                          Multiply elementwise
 >./@                           Reduce using max and return

— মাইল
সূত্র

4

পাইথন, 184 বাইট

def s(n):
 def j(b,i):
  if i<0.1**12:
   return b
  m = b+i
  try:
   v = reduce(lambda a,b:b**a,[m]*n)
  except:
   v = n+1
  return j(m,i/2) if v<n else j(b,i/2)
 return j(1.0,0.5)

পরীক্ষার আউটপুট (প্রকৃত মুদ্রণ বিবৃতি এড়িয়ে যাওয়া):

   s(1) 1.0
   s(3) 1.63507847464
   s(6) 1.5686440646
  s(10) 1.50849792026
  s(25) 1.45858186605
  s(50) 1.44850389566
 s(100) 1.44567285047

— Vatine
সূত্র

গল্ফড 119 বাইট

— mbomb007

এটি s(1000000)বেশ দ্রুত গণনা করে

— mbomb007

3

র‌্যাকেট 187 বাইট

(define(f x n)(define o 1)(for((i n))(set! o(expt x o)))o)
(define(ur y(l 0.1)(u 10))(define t(/(+ l u)2))(define o(f t y))
(cond[(<(abs(- o y)) 0.1)t][(> o y)(ur y l t)][else(ur y t u)]))

পরীক্ষামূলক:

(ur 1)
(ur 3)
(ur 6)
(ur 10)
(ur 25)
(ur 50)
(ur 100)

আউটপুট:

1.028125
1.6275390625
1.5695312499999998
1.5085021972656247
1.4585809230804445
1.4485038772225378
1.4456728475168346

বিস্তারিত সংস্করণ:

(define (f x n)
  (define out 1)
  (for((i n))
    (set! out(expt x out)))
  out)

(define (uniroot y (lower 0.1) (upper 10))
  (define trying (/ (+ lower upper) 2))
  (define out (f trying y))
  (cond
    [(<(abs(- out y)) 0.1)
     trying]
    [(> out y)
     (uniroot y lower trying)]
    [else
      (uniroot y trying upper)]))

— rnso
সূত্র

2

পার্ল 6 , 42 বাইট

{(0,.0001…2).min:{abs $_-[**] $^r xx$_}}

(উদাহরণ মতলব কোড অনুবাদ)

টেস্ট:

#! /usr/bin/env perl6
use v6.c;
use Test;

my &code = {(0,.0001…2).min:{abs $_-[**] $^r xx$_}}

my @tests = (
  1   => 1,
  3   => 1.635078,
  6   => 1.568644,
  10  => 1.508498,
  25  => 1.458582,
  50  => 1.448504,
  100 => 1.445673,
);

plan +@tests + 1;

my $start-time = now;

for @tests -> $_ ( :key($input), :value($expected) ) {
  my $result = code $input;
  is-approx $result, $expected, "$result ≅ $expected", :abs-tol(0.001)
}

my $finish-time = now;
my $total-time = $finish-time - $start-time;
cmp-ok $total-time, &[<], 60, "$total-time.fmt('%.3f') is less than a minute";

1..8
ok 1 - 1 ≅ 1
ok 2 - 1.6351 ≅ 1.635078
ok 3 - 1.5686 ≅ 1.568644
ok 4 - 1.5085 ≅ 1.508498
ok 5 - 1.4586 ≅ 1.458582
ok 6 - 1.4485 ≅ 1.448504
ok 7 - 1.4456 ≅ 1.445673
ok 8 - 53.302 seconds is less than a minute

— ব্র্যাড গিলবার্ট বি 2 গিলস
সূত্র

1

পিএইচপি, 103 বাইট

$z=2;while($z-$a>9**-9){for($r=$s=($a+$z)/2,$i=0;++$i<$n=$argv[1];)$r=$s**$r;$r<$n?$a=$s:$z=$s;}echo$s;

— জার্গ হালসারম্যান
সূত্র

1

এক্সিয়াম 587 বাইট tes

l(a,b)==(local i;i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1);r);g(q,n)==(local r,y,y1,y2,t,v,e,d,i;n<=0 or n>1000 or q>1000 or q<0 => 0;e:=1/(10**(digits()-3));v:=0.01; d:=0.01;repeat(if l(v,n)>=q then break;v:=v+d;if v>=1 and n>25 then d:=0.001;if v>=1.4 and n>40 then d:=0.0001;if v>=1.44 and n>80 then d:=0.00001;if v>=1.445 and n>85 then d:=0.000001);if l(v-d,n)>q then y1:=0.0 else y1:=v-d;y2:=v;y:=l(v,n);i:=1;if abs(y-q)>e then repeat(t:=(y2-y1)/2.0;v:=y1+t;y:=l(v,n);i:=i+1;if i>100 then break;if t<=e then break;if y<q then y1:=v else y2:=v);if i>100 then output "#i#";v)

কম গল্ফড + সংখ্যা

l(a,b)==
  local i
  i:=1;r:=a;repeat(if i>=b then break;r:=a^r;i:=i+1)
  r
g(q,n)==
 local r, y, y1,y2,t,v,e,d, i
 n<=0 or n>1000 or q>1000 or q<0 => 0  
 e:=1/(10**(digits()-3))
 v:=0.01; d:=0.01  
 repeat  --cerco dove vi e' il punto di cambiamento di segno di l(v,n)-q
    if l(v,n)>=q then break
    v:=v+d 
    if v>=1     and n>25 then d:=0.001
    if v>=1.4   and n>40 then d:=0.0001
    if v>=1.44  and n>80 then d:=0.00001
    if v>=1.445 and n>85 then d:=0.000001
 if l(v-d,n)>q then y1:=0.0
 else               y1:=v-d 
 y2:=v; y:=l(v,n); i:=1  -- applico il metodo della ricerca binaria
 if abs(y-q)>e then      -- con la variabile i di sicurezza
    repeat 
       t:=(y2-y1)/2.0; v:=y1+t; y:=l(v,n)
       i:=i+1
       if i>100 then break
       if t<=e  then break 
       if  y<q  then y1:=v
       else          y2:=v
 if i>100 then output "#i#"
 v

(3) -> [g(1,1), g(3,3), g(6,6), g(10,10), g(25,25), g(50,50), g(100,100)]
   Compiling function l with type (Float,PositiveInteger) -> Float
   Compiling function g with type (PositiveInteger,PositiveInteger) ->
      Float

   (3)
   [1.0000000000 000000001, 1.6350784746 363752387, 1.5686440646 047324687,
    1.5084979202 595960768, 1.4585818660 492876919, 1.4485038956 661040907,
    1.4456728504 738144738]
                                                             Type: List Float

— RosLuP
সূত্র

1

কমন লিস্প, 207 বাইট

(defun superlog(n)(let((a 1d0)(i 0.5))(loop until(< i 1d-12)do(let((v(or(ignore-errors(reduce #'expt(loop for q below n collect(+ a i)):from-end t))(1+ n))))(when(< v n)(setq a (+ a i)))(setq i(/ i 2)))) a))

ব্যবহার reduceসঙ্গে :from-end tএড়াতে (একটি "reversing exponentiation" অন্তর্বর্তী ল্যামডা করছেন মূলত প্রয়োজন (lambda (x y) (expt y x)), 14 বাইট (12 সংরক্ষণ, যদি আপনি অপসারণযোগ্য স্পেস সরাতে)।

আমাদের এখনও ভাসা ওভারফ্লো পরিচালনা করতে হবে, তবে কোনও ত্রুটি ignore-errorsঘটলে একটি ফর্ম ফিরে আসে nil, তাই আমরা orএকটি ডিফল্ট মান সরবরাহ করতে পারি to

— Vatine
সূত্র

অটো-সুপার-লগারিদম করুন

চ্যালেঞ্জ

বিধি

পরীক্ষার মামলা

রেফারেন্স বাস্তবায়ন

ডায়ালগ এপিএল , 33 25 বাইট

হাস্কেল, 55 54 52 বাইট

জাভাস্ক্রিপ্ট, ES6: 77 বাইট / ES7: 57 53 বাইট

ES6

ES7

উদাহরণ

গণিত, 40 33 বাইট

জে, 39 31 28 বাইট

ব্যবহার

ব্যাখ্যা

পাইথন, 184 বাইট

র‌্যাকেট 187 বাইট

পার্ল 6 , 42 বাইট

টেস্ট:

পিএইচপি, 103 বাইট

কমন লিস্প, 207 বাইট