Tugas Anda adalah menciptakan fungsi dengan pertumbuhan paling lambat yang Anda dapat tidak lebih dari 100 byte.

Program Anda akan mengambil sebagai bilangan bulat nonnegatif, dan menghasilkan bilangan bulat nonnegatif. Mari kita panggil program Anda P.

Itu harus memenuhi dua kriteria ini:

• Kode sumbernya harus kurang dari atau sama dengan 100 byte.
• Untuk setiap K, ada N, sehingga untuk setiap n> = N, P (n)> K. Dengan kata lain, lim _{(n-> ∞)} P (n) = ∞ . (Ini adalah apa artinya menjadi "tumbuh".)

"Skor" Anda adalah tingkat pertumbuhan dari fungsi dasar program Anda.

Lebih khusus, program P tumbuh lebih lambat dari Q jika ada N sedemikian rupa sehingga untuk semua n> = N, P (n) <= Q (n), dan setidaknya ada satu n> = N sedemikian rupa sehingga P (n ) <Q (n). Jika tidak ada program yang lebih baik dari yang lain, mereka terikat. (Pada dasarnya, program mana yang lebih lambat didasarkan pada nilai lim _{(n-> ∞)} P (n) -Q (n).)

Fungsi pertumbuhan paling lambat didefinisikan sebagai fungsi yang tumbuh lebih lambat daripada fungsi lainnya, menurut definisi pada paragraf sebelumnya.

Ini adalah golf tingkat pertumbuhan , sehingga program yang paling lambat menang akan menang!

Catatan:

• Untuk membantu dalam penilaian, cobalah untuk menempatkan fungsi apa yang dihitung oleh program Anda dalam jawabannya.
• Masukkan juga beberapa input dan output (teoretis), untuk membantu memberi orang gagasan tentang seberapa lambat Anda bisa melangkah.

Haskell, 98 byte, skor = f _{ε 0} ⁻¹ ( n )

_#[]=0
k#(0:a)=k#a
k#(a:b)=1+(k#(([1..k]>>fst(span(>=a)b)++[a-1])++b))
f n=[k|k<-[0..],k#[k]>n]!!0

Bagaimana itu bekerja

Ini menghitung kebalikan dari fungsi yang tumbuh sangat cepat terkait dengan game cacing Beklemishev . Laju pertumbuhannya sebanding dengan f _{ε 0} , di mana f _α adalah hierarki yang tumbuh cepat dan ε ₀ adalah angka epsilon pertama .

Untuk perbandingan dengan jawaban lain, perhatikan itu

• eksponensial sebanding dengan f ₂ ;
• eksponensiasi iterasi ( tetrasi atau ↑↑ ) sebanding dengan f ₃ ;
• ↑↑ ⋯ ↑↑ dengan m panah sebanding dengan f _{m + 1} ;
• Fungsi Ackermann sebanding dengan f _ω ;
• pengulangan fungsi Ackermann (konstruksi seperti nomor Graham ) masih didominasi oleh f _{ω + 1} ;
• dan ε ₀ adalah batas semua menara ω ^{ω ω ⋰ ω} .

Brachylog , 100 byte

llllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllllll

Cobalah online!

Ini mungkin tidak ada di dekat kelambanan beberapa jawaban mewah lainnya, tetapi saya tidak percaya tidak ada yang mencoba pendekatan yang sederhana dan indah ini.

Sederhananya, kami menghitung panjang nomor input, lalu panjang hasil ini, lalu panjang hasil lainnya ini ... 100 kali total.

Ini tumbuh secepat log (log (log ... log (x), dengan 100 basis-10 log).

Jika Anda memasukkan nomor Anda sebagai string , ini akan berjalan sangat cepat pada setiap input yang dapat Anda coba, tetapi jangan berharap untuk melihat hasil yang lebih tinggi dari 1: D

JavaScript (ES6), Fungsi Ackermann Invers *, 97 byte

* Jika saya melakukannya dengan benar

A=(m,n)=>m?A(m-1,n?A(m,n-1):1):n+1
a=(m,n=m,i=1)=>{while(A(i,m/n|0)<=Math.log2(n))i++;return i-1}

Fungsi Aadalah fungsi Ackermann . Fungsi aseharusnya merupakan fungsi Inverse Ackermann . Jika saya menerapkannya dengan benar, Wikipedia mengatakan bahwa itu tidak akan mencapai 5sampai msama 2^2^2^2^16. Saya mendapatkan StackOverflowsekitar 1000.

Pemakaian:

console.log(a(1000))

Penjelasan:

Fungsi Ackermann

A=(m,n)=>                           Function A with parameters m and n
         m?                   :n+1  If m == 0, return n + 1; else,
           A(m-1,n?        :1)       If n == 0, return A(m-1,1); else,
                   A(m,n-1)          return A(m-1,A(m,n-1))

Fungsi Ackermann Terbalik

a=(m,n=m,i=1)=>{                                                Function a with parameter m, with n preinitialized to m and i preinitialized to 1
                while(A(i,m/n|0)<=Math.log2(n))                 While the result of A(i, floor(m/n)) is less than log₂ n,
                                               i++;             Increment i
                                                   return i-1}  Return i-1

Pure Evil: Eval

a=lambda x,y:(y<0)*x or eval("a("*9**9**9+"x**.1"+",y-1)"*9**9**9)
print a(input(),9**9**9**9**9)//1

Pernyataan di dalam eval menciptakan string dengan panjang 7 * 10 ^{10 10 10 10 10 8.57} yang hanya terdiri dari panggilan ke fungsi lambda yang masing-masing akan membangun string dengan panjang yang sama , terus dan terus hingga akhirnya ymenjadi 0. Seolah-olah ini memiliki kompleksitas yang sama dengan metode Eschew di bawah ini, tetapi daripada mengandalkan logika jika-dan-atau, itu hanya menghancurkan string raksasa bersama-sama (dan hasil bersihnya menjadi lebih banyak tumpukan ... mungkin?).

Nilai terbesar yang ydapat saya berikan dan hitung tanpa Python melemparkan kesalahan adalah 2 yang sudah cukup untuk mengurangi input max-float menjadi pengembalian 1.

Sebuah string panjang 7.625.597.484.987 terlalu besar: OverflowError: cannot fit 'long' into an index-sized integer.

Saya harus berhenti.

Eschew Math.log: Pergi ke root (ke-10) (dari masalah), Score: berfungsi secara efektif tidak dapat dibedakan dari y = 1.

Mengimpor perpustakaan matematika membatasi jumlah byte. Mari kita hilangkan itu dan ganti log(x)fungsinya dengan sesuatu yang kira-kira setara: x**.1dan yang harganya kira-kira jumlah karakter yang sama, tetapi tidak memerlukan impor. Kedua fungsi memiliki output sublinear sehubungan dengan input, tetapi x ^0,1 tumbuh lebih lambat . Namun kami tidak terlalu peduli, kami hanya peduli bahwa ia memiliki pola pertumbuhan basis yang sama sehubungan dengan jumlah besar sambil mengkonsumsi jumlah karakter yang sebanding (mis. x**.9Jumlah karakter yang sama, tetapi tumbuh lebih cepat, jadi ada adalah beberapa nilai yang akan menunjukkan pertumbuhan yang sama persis).

Sekarang, apa yang harus dilakukan dengan 16 karakter. Bagaimana kalau ... memperluas fungsi lambda kita untuk memiliki properti Sequence Ackermann? Jawaban untuk sejumlah besar ini menginspirasi solusi ini.

a=lambda x,y,z:(z<0)*x or y and a(x**.1,z**z,z-1)or a(x**.1,y-1,z)
print a(input(),9,9**9**9**99)//1

The z**zporsi disini mencegah saya dari menjalankan fungsi ini dengan di mana saja dekat dengan masukan waras untuk ydan z, nilai-nilai terbesar yang bisa saya gunakan adalah 9 dan 3 yang saya mendapatkan kembali nilai 1,0, bahkan untuk terbesar mendukung mengapung Python (catatan: sementara 1.0 secara numerik lebih besar dari 6,77538853089e-05, peningkatan level rekursi memindahkan output fungsi ini lebih dekat ke 1, sementara tetap lebih besar dari 1, sedangkan fungsi sebelumnya memindahkan nilai lebih dekat ke 0 sementara tetap lebih besar dari 0, sehingga bahkan rekursi moderat pada fungsi ini menghasilkan begitu banyak operasi sehingga angka floating point kehilangan semua bit signifikan).

Mengkonfigurasi ulang panggilan lambda asli untuk memiliki nilai rekursi 0 dan 2 ...

>>>1.7976931348623157e+308
1.0000000071

Jika perbandingan dibuat untuk "offset dari 0" alih-alih "offset dari 1" fungsi ini kembali 7.1e-9, yang pasti lebih kecil dari 6.7e-05.

Rekursi dasar program aktual (nilai z) adalah 10 ^{10 10 10 1,97} level, begitu y melelahkan, ia akan direset dengan 10 ^{10 10 10 10 1,97} (itulah sebabnya nilai awal 9 cukup), jadi saya tidak bahkan tidak tahu bagaimana menghitung dengan benar jumlah rekursi yang terjadi: saya telah mencapai akhir dari pengetahuan matematika saya. Demikian pula saya tidak tahu apakah memindahkan salah satu **neksponensial dari input awal ke sekunder z**zakan meningkatkan jumlah rekursi atau tidak (ditto reverse).

Mari kita lebih lambat dengan lebih banyak rekursi

import math
a=lambda x,y:(y<0)*x or a(a(a(math.log(x+1),y-1),y-1),y-1)
print a(input(),9**9**9e9)//1

• n//1 - menghemat 2 byte lebih int(n)
• import math, math.menghemat 1 byte lebihfrom math import*
• a(...) menghemat total 8 byte m(m,...)
• (y>0)*x menghemat satu byte lebihy>0and x
• 9**9**99meningkatkan jumlah byte sebanyak 4 dan meningkatkan kedalaman rekursi sekitar kira-kira di 2.8 * 10^xmana xkedalaman yang lama (atau kedalaman yang mendekati ukuran googolplex: 10 ^{10 94} ).
• 9**9**9e9meningkatkan jumlah byte sebesar 5 dan meningkatkan kedalaman rekursi sebesar ... jumlah yang gila. Kedalaman rekursi sekarang 10 ^{10 10 9,93} , untuk referensi, googolplex adalah 10 ^{10 10 2} .
• deklarasi lambda meningkatkan rekursi dengan langkah ekstra: m(m(...))dengan a(a(a(...)))biaya 7 byte

Nilai output baru (pada kedalaman 9 rekursi):

>>>1.7976931348623157e+308
6.77538853089e-05

Kedalaman rekursi telah meledak ke titik di mana hasil ini benar - benar tidak berarti kecuali dibandingkan dengan hasil sebelumnya menggunakan nilai input yang sama:

• Aslinya disebut log25 kali
• Perbaikan pertama menyebutnya 81 kali
  • Program yang sebenarnya akan menyebutnya 1e99 ² atau sekitar 10 ^{10 2,3} kali
• Versi ini menyebutnya 729 kali
  • Program yang sebenarnya akan menyebutnya (9 ^{9 99} ) ³ atau sedikit kurang dari 10 ^{10 95} kali).

Lambda Inception, skor: ???

Saya mendengar Anda suka lambdas, jadi ...

from math import*
a=lambda m,x,y:y<0and x or m(m,m(m,log(x+1),y-1),y-1)
print int(a(a,input(),1e99))

Saya bahkan tidak bisa menjalankan ini, saya menumpuk melimpah bahkan dengan 99 lapisan rekursi.

Metode lama (di bawah) mengembalikan (melewatkan konversi ke integer):

>>>1.7976931348623157e+308
0.0909072713593

Metode baru kembali, menggunakan hanya 9 lapisan serangan (bukan googol penuh dari mereka):

>>>1.7976931348623157e+308
0.00196323936205

Saya pikir ini bekerja dengan kompleksitas yang mirip dengan urutan Ackerman, hanya kecil, bukan besar.

Juga berkat produk ETH untuk penghematan 3 byte di ruang yang saya tidak sadari dapat dihapus.

Jawaban lama:

Pemotongan integer dari fungsi log (i + 1) iterasi 20 25 kali (Python) menggunakan lambda'd lambdas.

Jawaban PyRulez dapat dikompres dengan memperkenalkan lambda kedua dan menumpuknya:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(x(x(i)))))
print int(y(y(y(y(y(input()))))))

99 100 karakter digunakan.

Ini menghasilkan iterasi 20 25, di atas yang asli 12. Selain itu ia menyimpan 2 karakter dengan menggunakan int()alih-alih floor()yang diizinkan untuk x()tumpukan tambahan . Jika spasi setelah lambda dapat dihapus (saya tidak dapat memeriksa saat ini) maka 5 y()dapat ditambahkan. Mungkin!

Jika ada cara untuk melewatkan from mathimpor dengan menggunakan nama yang sepenuhnya memenuhi syarat (mis. x=lambda i: math.log(i+1))), Itu akan menyimpan lebih banyak karakter dan memungkinkan setumpuk lagi x()tetapi saya tidak tahu apakah Python mendukung hal-hal seperti itu (saya curiga tidak). Selesai!

Ini pada dasarnya adalah trik yang sama yang digunakan dalam posting blog XCKD dalam jumlah besar , namun biaya overhead dalam mendeklarasikan lambdas menghalangi tumpukan ketiga:

from math import *
x=lambda i:log(i+1)
y=lambda i:x(x(x(i)))
z=lambda i:y(y(y(i)))
print int(z(z(z(input()))))

Ini adalah rekursi sekecil mungkin dengan 3 lambda yang melebihi tinggi tumpukan yang dihitung dari 2 lambdas (mengurangi setiap lambda menjadi dua panggilan menurunkan tinggi tumpukan menjadi 18, di bawah dari versi 2-lambda), tetapi sayangnya membutuhkan 110 karakter.

Haskell , 100 byte

f 0 a b=a^b
f c a b=foldr(f$c-1)a$[0..b]>>[a]
i=length.show
0#x=i x
y#x=i$(y-1)#x
g=(f(f 9 9 9)9 9#)

Cobalah online!

Solusi ini tidak mengambil kebalikan dari fungsi yang tumbuh cepat melainkan membutuhkan fungsi yang tumbuh agak lambat, dalam hal ini length.show, dan menerapkannya beberapa kali.

Pertama kita mendefinisikan suatu fungsi f. fadalah versi keparat dari notasi uparrow Knuth yang tumbuh sedikit lebih cepat (sedikit agak meremehkan, tetapi jumlah yang kita hadapi begitu besar sehingga dalam skema besar hal-hal ...). Kami mendefinisikan kasus dasar f 0 a bmenjadi a^batau adengan kekuatan b. Kami kemudian mendefinisikan kasus umum untuk (f$c-1)diterapkan pada b+2contoh a. Jika kita mendefinisikan notasi uparrow Knuth seperti konstruk, kita akan menerapkannya pada binstance a, tetapi b+2sebenarnya golfier dan memiliki keuntungan menjadi lebih cepat berkembang.

Kami kemudian mendefinisikan operator #. a#bdidefinisikan untuk length.showditerapkan ke b awaktu. Setiap aplikasi length.showkira-kira sama dengan log ₁₀ , yang bukan merupakan fungsi yang berkembang sangat cepat.

Kami kemudian mendefinisikan fungsi kami gyang mengambil dan integer dan berlaku length.showuntuk integer beberapa kali. Untuk lebih spesifik itu berlaku length.showuntuk input f(f 9 9 9)9 9. Sebelum kita masuk ke seberapa besar ini mari kita lihat f 9 9 9. f 9 9 9adalah lebih besar dari 9↑↑↑↑↑↑↑↑↑9 (sembilan anak panah), dengan margin besar. Saya percaya itu berada di antara 9↑↑↑↑↑↑↑↑↑9(sembilan panah) dan 9↑↑↑↑↑↑↑↑↑↑9(sepuluh panah). Sekarang ini adalah jumlah yang sangat besar, jauh ke besar untuk disimpan di komputer mana pun yang ada (dalam notasi biner). Kami kemudian mengambil itu dan menempatkan itu sebagai argumen pertama kami fyang berarti nilai kami lebih besar daripada 9↑↑↑↑↑↑...↑↑↑↑↑↑9denganf 9 9 9panah di antara keduanya. Saya tidak akan menjelaskan angka ini karena jumlahnya sangat besar, saya tidak berpikir saya bisa melakukannya dengan adil.

Masing length.show- masing kira-kira sama dengan mengambil basis log 10 dari integer. Ini berarti bahwa sebagian besar angka akan kembali 1 ketika fditerapkan padanya. Angka terkecil untuk mengembalikan sesuatu selain 1 adalah 10↑↑(f(f 9 9 9)9 9), yang mengembalikan 2. Mari kita pikirkan sejenak. Sebesar apa pun angka yang kita tentukan sebelumnya, angka terkecil yang mengembalikan 2 adalah 10 ke kekuatannya sendiri yang berkali-kali. Thats 1 diikuti oleh 10↑(f(f 9 9 9)9 9)nol.

Untuk kasus umum dari ninput terkecil yang dikeluarkan maka n harus diberikan (10↑(n-1))↑↑(f(f 9 9 9)9 9).

Perhatikan bahwa program ini membutuhkan sejumlah besar waktu dan memori untuk bahkan n kecil (lebih dari yang ada di alam semesta berkali-kali lipat), jika Anda ingin menguji ini saya sarankan mengganti f(f 9 9 9)9 9dengan jumlah yang jauh lebih kecil, coba 1 atau 2 jika Anda ingin pernah mendapatkan output selain 1.

APL, Terapkan log(n + 1), e^9^9...^9kali, di mana panjang rantai adalah e^9^9...^9panjang rantai minus 1 kali, dan sebagainya.

⌊((⍟1+⊢)⍣((*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣(*⍣⊢)))))))))))))))))))))9))⊢

MATL , 42 byte

iXI:`2*.]X{oXH1H/16L+XKxI:`Yl.]K+XKXdXzXGx

Cobalah online!

Program ini didasarkan pada seri harmonik dengan penggunaan konstanta Euler-Mascheroni. Ketika saya membaca dokumentasi @LuisMendo tentang bahasa MATL-nya (dengan huruf kapital, jadi ini terlihat penting) saya perhatikan konstanta ini. Ekspresi fungsi pertumbuhan yang lambat adalah sebagai berikut:

di mana εk ~ 1 / 2k

Saya menguji hingga 10.000 iterasi (di Matlab, karena terlalu besar untuk TIO) dan skornya di bawah 10, jadi sangat lambat.

Penjelasan:

 iXI      % ask user input (number of iterations)

:`2*.]    % do...while loop, multiply by 2

X{        % convert numeric array into cell array

o         % convert to double precision array 

XH1H/     % copy to clipboard H and divide by 1: now we have an array of 1/2k

16L       % Euler–Mascheroni constant 

+         % addition (element-wise, singleton expansion)

XKxI:`    % save, clear the stack, do...while loop again

  Yl      % logarithm 

  .]      % break, ends the loop

K+XK      % paste from clipboard K, sum all

Xd        % trim: keep the diagonal of the matrix 

Xz        % remove all zeros

XG        % plot (yes it plots on-line too!)

x         % clear the stack
          % (implicit) display

Bukti empiris: (ln k ) + 1 berwarna merah selalu di atas ln k + γ + εk dengan warna biru.

Program untuk (ln k ) +1 dibuat di

Matlab, 47 18 14 byte

n=input('')
A=(1:n)
for k=1:n
A(k)=log(k)+1
end

Menarik untuk dicatat bahwa waktu yang telah berlalu untuk n = 100 adalah 0,208693 pada laptop saya, tetapi hanya 0,121945 dengan d=rand(1,n);A=d*0;dan bahkan lebih sedikit, 0,112147 dengan A=zeros(1,n). Jika nol adalah pemborosan ruang, itu menghemat kecepatan! Tapi saya menyimpang dari topik (mungkin sangat lambat).

Sunting: terima kasih kepada Stewie untuk membantu mengurangi ekspresi Matlab ini menjadi, cukup:

 @(n)log(1:n)+1

Python 3 , 100 byte

Lantai log fungsi (i +1) iterasi 999999999999999999999999999999999999999 kali.

Seseorang dapat menggunakan eksponen untuk membuat angka di atas lebih besar ...

from math import *
s=input()
exec("s=log(s+1);"*99999999999999999999999999999999999)
print(floor(s))

Cobalah online!

Lantai log fungsi (i +1) iterasi 14 kali (Python)

import math
x=lambda i: math.log(i+1)
print int(x(x(x(x(x(x(x(x(x(x(x(x(x(x(input())))))))))))))))

Saya tidak berharap ini bekerja dengan sangat baik, tetapi saya pikir ini awal yang baik.

Contoh:

• e ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n ^ n - n ~> (kira-kira n)

Ruby, 100 byte, skor ^-1 = f _{ω ^{ω + 1}} (n ² )

Pada dasarnya meminjam dari Nomor Terbesar saya yang Dapat Dicetak , inilah program saya:

->k{n=0;n+=1 until(H=->z,a=[0]*z{b,*c=a;z.times{z+=b ?H[z,b==1?c:[b>1?b-1:z]*z+c]:z};z};H[n*n]>k);n}

Cobalah online

Pada dasarnya menghitung kebalikan dari f _{ω ^{ω + 1}} (n ² ) dalam hierarki yang berkembang cepat. Beberapa nilai pertama adalah

x[0] = 1
x[1] = 1
x[2] = 1
x[3] = 1
x[4] = 2

Dan kemudian terus menghasilkan 2untuk waktu yang sangat lama. Bahkan x[G] = 2, di mana Gnomor Graham.

Mathematica, 99 byte

(dengan asumsi ± membutuhkan 1 byte)

0±x_=1±(x-1);y_±0=y+1;x_±y_:=(y-1)±x±(x-1);(i=0;NestWhile[(++i;#±#±#±#±#±#±#±#)&,1,#<k&/.k->#];i)&

3 perintah pertama menentukan x±yuntuk mengevaluasi Ackermann(y, x).

Hasil dari fungsi ini adalah berapa kali f(#)=#±#±#±#±#±#±#±#harus diterapkan ke 1 sebelum nilai sampai ke nilai parameter. Karena f(#)=#±#±#±#±#±#±#±#(yaitu, f(#)=Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[Ackermann[#, #], #], #], #], #], #], #]) tumbuh sangat cepat, fungsinya tumbuh sangat lambat.

Clojure, 91 byte

(defn f (apply +(for[n(range %)](/(loop[r 1 v n](if(< v 1)r(recur(* r v)(Math/log v))))))))

Jenis menghitung sum 1/(n * log(n) * log(log(n)) * ...), yang saya temukan dari sini . Tetapi fungsinya berakhir 101 byte jadi saya harus menjatuhkan jumlah iterasi yang eksplisit, dan sebaliknya iterasi selama angkanya lebih besar dari satu. Contoh output untuk input dari 10^i:

0 1
1 3.3851305685279143
2 3.9960532565317575
3 4.232195089969394
4 4.370995106860574
5 4.466762285601703
6 4.53872567524327
7 4.595525574477128
8 4.640390570825608

Saya berasumsi seri yang dimodifikasi ini masih menyimpang tetapi sekarang tahu bagaimana membuktikannya.

Seri ketiga sebenarnya membutuhkan jumlah istilah googolplex sebelum persyaratan parsial melebihi 10.

Javascript (ES6), 94 byte

(p=j=>i=>h=>g=>f=>x=>x<2?0:1+p(p(j))(j(i))(i(h))(h(g))(g(f))(f(x)))(_=x=>x)(_)(_)(_)(Math.log)

Penjelasan :

Idmengacu x => xpada berikut ini.

Mari kita lihat dulu:

p = f => x => x < 2 ? 0 : 1 + p(p(f))(f(x))

p(Math.log)kira-kira sama dengan log*(x).

p(p(Math.log))kira-kira sama dengan log**(x)(berapa kali Anda dapat mengambillog* sampai nilai paling banyak 1).

p(p(p(Math.log)))kira-kira sama dengan log***(x).

Fungsi Ackermann terbalik alpha(x)kira-kira sama dengan jumlah minimum kali yang Anda butuhkan untuk menulis phingga nilainya paling banyak 1.

Jika kita menggunakan:

p = g => f => x => x < 2 ? 0 : 1 + p(p(g))(g(f))(f(x))

maka kita bisa menulis alpha = p(Id)(Math.log).

Namun, itu cukup membosankan, jadi mari kita tingkatkan jumlah level:

p = h => g => f => x => x < 2 ? 0 : 1 + p(p(h))(h(g))(g(f))(f(x))

Ini seperti bagaimana kita membangun alpha(x), kecuali alih-alih melakukan log**...**(x), kita sekarang lakukan alpha**...**(x).

Kenapa berhenti di sini?

p = i => h => g => f => x => x < 2 ? 0 : 1 + p(p(i))(i(h))(h(g))(g(f))(f(x))

Jika fungsi sebelumnya adalah f(x)~alpha**...**(x), yang ini sekarang ~ f**...**(x). Kami melakukan satu level lagi untuk mendapatkan solusi akhir kami.