Apakah bahasa Anda memiliki kedalaman rekursi maksimum (MRD)?

Katakanlah bahasa Anda memiliki MRD = 500

Tulis kode yang menemukan kedalaman rekursi dan menampilkan nilai yang tepat

Untuk kasus di atas, program Anda (atau fungsi) harus menghasilkan 500

Kode-Golf Jawaban terpendek menang!

Mathematica, 15 byte

$RecursionLimit

¯ \ _ (ツ) _ / ¯

Cobalah online!

Python 3 , 40 byte

def f(x=2):
 try:f(x+1)
 except:print(x)

Cobalah online!

Tanpa hanya membacanya dari builtin. Kita mulai dari 2 bukannya 1 karena klausa kecuali dijalankan satu tingkat sebelum kesalahan. Ini adalah byte yang lebih pendek di python 2, tentu saja.

JavaScript (Babel) , 35 33 29 byte

f=_=>do{try{-~f()}catch(e){}}

• 2 byte disimpan berkat Neil.

Mencobanya di sini , atau gunakan Cuplikan di bawah ini untuk mengujinya dengan evalbukan do.

console.log((f=_=>eval(`try{-~f()}catch(e){}`))())

Port Japt , 24 byte

Tidak benar-benar layak memposting ini sebagai solusi terpisah karena pada dasarnya identik.

Ox`try\{-~rp()}¯t®(e)\{}

Menguji

Penjelasan

JavaScript itu sendiri tidak memiliki batas rekursi per se, melainkan batas yang dikenakan oleh penerjemah (yaitu, browser) - hal yang baik kita mendefinisikan bahasa berdasarkan babak penerjemah mereka di sini! Di antara faktor-faktor lain, batas dapat bervariasi berdasarkan browser dan memori yang tersedia, yang dipengaruhi oleh operasi yang dilakukan. Cuplikan berikut menggambarkan poin terakhir, menggunakan 5 versi berbeda dari solusi ini yang saya lalui. Seperti yang dapat Anda lihat dari 2 tes terakhir, di Chrome, setidaknya, bahkan urutan operasi dapat membuat perbedaan.

console.log((f=(i=0)=>eval(`try{f(i+1)}catch(e){i}`))())
console.log((f=i=>eval(`try{f(-~i)}catch(e){i}`))())
console.log((f=(i=0)=>eval(`try{f(++i)}catch(e){i}`))())
console.log((f=_=>eval(`try{-~f()}catch(e){}`))())
console.log((f=_=>eval(`try{f()+1}catch(e){0}`))())
console.log((f=_=>eval(`try{1+f()}catch(e){0}`))())

Oleh karena itu, kami tidak memiliki kenyamanan konstanta atau metode untuk bekerja dengannya. Sebagai gantinya, kita akan membuat fungsi yang memanggil dirinya sendiri secara terus-menerus sebelum, akhirnya, keluar. Dalam bentuknya yang paling sederhana yaitu:

f=_=>f()

Tapi itu tidak banyak berguna bagi kami untuk tantangan ini karena hanya melemparkan kesalahan meluap tanpa indikasi berapa kali fmenyebut dirinya. Kita bisa menghindari kesalahan dengan trying panggilan fterus menerus dan catching ketika gagal:

f=_=>{try{f()}catch(e){}}

Tidak ada kesalahan, tetapi masih tidak ada nilai balik berapa kali fungsi berhasil memanggil dirinya sendiri sebelum gagal, karena catchsebenarnya tidak melakukan apa-apa. Mari kita coba mengevaluasi try / catchpernyataan:

f=_=>eval(`try{f()}catch(e){}`)

Sekarang kita punya nilai yang dikembalikan (dan, karena ini adalah kode golf, menyelamatkan diri beberapa byte dari penggunaan yang sebenarnya return). Nilai yang dikembalikan adalah undefined, sekali lagi karena catchtidak melakukan apa-apa. Untungnya bagi kita -~undefined==1dan -~n==n+1, dengan muncul -~di depan panggilan untuk f, pada dasarnya kita punya -~-~ ... -~-~undefined, dengan yang lain -~diawali dengan setiap panggilan, memberi kita berapa kali fdipanggil.

f=_=>eval(`try{-~f()}catch(e){}`)

Mathematica (tidak ada built-in), 20 byte

#0[#+1];&@1
%[[1,1]]

Menghilangkan ;akan menghitung 1+$IterationLimit(mungkin karena Mathematica tail-mengoptimalkan fungsi). Alternatifnya, 0 //. x_ -> x + 1menghitung ReplaceRepeateddefault MaxIteration, yaitu 65536(yang lebih besar dari kedua nilai di atas).

(Ini adalah potongan kode yang mengevaluasi hasilnya. Namun solusi Mathematica lainnya juga)

J, 8 byte

1+$: ::]

Cobalah online!

Jadi, saya tidak benar-benar tahu bagaimana mengeksekusi kata kerja tanpa input dan beberapa pencarian singkat (serta intuisi pribadi) membuatnya tampak seperti itu tidak mungkin. Jika ya, beri tahu saya cara melakukannya dan saya akan menghapus atau memperbarui jawaban saya. Namun tidak masuk akal jika kata kerja tidak diberi input. Sehubungan dengan ini, fungsi yang diberikan mengharapkan 0, input "kosong" default untuk bilangan bulat. Saya mungkin bisa mengubahnya untuk menggunakan array kosong (0$0 ) jika Anda pikir itu lebih cocok.

Sunting: OP telah memungkinkan fungsi untuk mengambil 0.

Penjelasan

1+$: ::]
     ::]  Assign adverse: if an error occurs, call ] (the identify function)
1+        Add one to
  $:      Recursive call to self

Ini panggilan itu sendiri secara rekursif, menambahkan 1 ke input (0 diharapkan) hingga hits kesalahan tumpukan. Ketika kesalahan, itu memanggil yang merugikan ( ]identitas-kanan) pada input, yang hanya 0.

Ngomong-ngomong, ruang itu perlu .

Python 3 , 41 32 byte

import sys
sys.getrecursionlimit

Cobalah online!

Disimpan 9 byte berkat @FryAmTheEggman!

34 byte

from sys import*
getrecursionlimit

35 byte

__import__('sys').getrecursionlimit

2 yang terakhir adalah terima kasih kepada @totallyhuman

C (gcc, Linux x64), 180 133 byte

-4 byte terima kasih kepada @scottinet

c;f(){f(++c);}h(){exit(printf("%d",c));}main(){int b[512];f(sigaction(11,(int*[]){h,[17]=1<<27},sigaltstack((int*[]){b,0,2048},0)));}

Cobalah online!

Menginstal handler SIGSEGV (sinyal 11) dengan tumpukan sinyal alternatif (ukuran minimum MINSIGSTKSZadalah 2 KB, flag SA_ONSTACK0x08000000), kemudian memanggil fungsi tanpa argumen dan tidak ada variabel lokal secara rekursif sampai stack meluap. Sangat menarik bahwa kedalaman rekursi maksimum bervariasi di seluruh lintasan, mungkin karena ASLR.

Kedalaman rekursi maksimum dalam C tergantung pada banyak faktor, tentu saja. Pada sistem Linux 64-bit yang tipikal, ukuran stack default adalah 8 MB, dan alignment stack adalah 16 byte, sehingga Anda mendapatkan kedalaman rekursi sekitar 512K untuk fungsi-fungsi sederhana.

Perhatikan juga bahwa program di atas tidak berfungsi -O2karena pengoptimalan panggilan ekor.

Java 8, 131 51 48 47 43 byte

int d;int c(){try{c();}finally{return++d;}}

-80 byte terima kasih kepada @Nevay . Saya mencoba metode bukan program juga, tetapi membuat kesalahan sehingga berakhir dengan program penuh .. Sekarang metode.
-3 byte terima kasih kepada @Neil dengan memanfaatkan finallybukannya catch(Error e).
-5 byte terima kasih kepada @Nevay lagi.

Penjelasan:

Coba di sini.

int d;                 // Depth-integer `d` on class-level (implicit 0)
int c(){               // Method without parameter and integer return-type
  try{c();}            //  Recursive call
  finally{return++d;}  //  Increase depth-integer `d` and always return it,
                       //   whether a StackOverflowError occurs or not
}                      // End of method

Oktaf, 19 byte

max_recursion_depth

Pemakaian:

octave:1> max_recursion_depth
ans =  256

R, 32 26 18 bytes

-8 bytes thanks to Sven Hohenstein : $ will do partial matching, so we can just use exp instead of the full expressions.

cat(options()$exp)

The options command can also be used to set the recursion depth, i.e., options(expressions=500) for 500.

Try it online!

Octave, 25 22 20 bytes

2 bytes removed thanks to a suggestion by Sanchises

@max_recursion_depth

Anonymous function that outputs the value.

Try it online!

zsh, 24 bytes

f(){f $[++i];f};set -x;f

Try it online! (See under debug)

bash, 24 bytes

f(){ f $[++i];};set -x;f

Try it online! (See under debug)

ksh93, 27 bytes

f(){ f $(($1+1));};set -x;f

Try it online! (See under debug)

dash, 27 bytes

f(){ f $(($1+1));};set -x;f

Try it online! (Exceeds tio debug output, run it in your own shell)

Lua, 52 bytes

f=load"b,e=pcall(f,(...or 3)+1)return b and e or..."

Try it online!

q/kdb+, 16 bytes

Solution:

{@[.z.s;x+1;x]}0

Example:

/ solution
q){@[.z.s;x+1;x]}0
2000

/ without apply (try/catch)
q){.z.s x+1}0
'stack
@
{.z.s x+1}
2001

Explanation:

Try to recurse, increase x by one each time, if error, return x.

{@[.z.s;x+1;x]}0 / the solution
{             }0 / call lambda function with 0
 @[    ;   ; ]   / @[function;argument;catch]
   .z.s          / call self (ie recurse)
        x+1      / increment x
            x    / return x if function returns error

Excel-VBA, 26 Bytes

?Application.MaxIterations

Not recursion depth per-se, this actually outputs the maximum number of iterations for a cell in an Excel worksheet. Given that the output pertains to a language other than the language in which this is written, perhaps this is more appropriate:

Excel + Excel-Vba, 3 + 38 = 41 Bytes

Function f:f=Application.MaxIterations

As that can be called from a cell with

=f(

For VBA with no built in:

Excel-VBA, 53 44 40 bytes

-9 as variable no longer needs to be initialised or printed

-4 as code execution no longer has to be ended to avoid multiple prints

Sub s:[A1]=[A1]+1:On Error Resume Next:s

Call with s in the immediate window, outputs to cell A1 of the worksheet

(warning takes a while to run now, add Application.ScreenUpdating = False first)

Lua, 45 37 bytes

x=2
f=load"x=x+1;f()"pcall(f)print(x)

Try it online!

I don't know which value to initialize x with as I don't know the number of intermediary calls there are...

Clojure, 72 55 48 bytes

-23 bytes by getting rid of the atom

-7 bytes thanks to @madstap. Switched to using fn over def and #(), and pr over println.

((fn f[i](try(f(inc i))(catch Error e(pr i))))0)

Wrote and tested on my phone. The Clojure REPL app gave me a depth of 13087.

Basic solution. Recurse until a SO is thrown, incrementing a counter each recurse. When it's thrown, the value of the counter is printed.

VBA, any type, 41 39 bytes

Function A:On Error Resume Next:A=A()+1

Call using ?A() in the Immediate window, or as worksheet function.

Note: Returns 4613 in Excel-VBA, while the answer by @Greedo returns 3666 on my system (highest should be the max). Apparently also varies between Office programs (Access-VBA returns 4622, Word-VBA 4615)

Edit: Guess VBA auto-adds parantheses, so removed them.

Pyth - 9 bytes

L.xyhbbyZ

If I can run it like the J answer above, this is 7 bytes because you can take out the last yZ.

Try it online here.

Forth, 48 bytes

Loops until it hits the limit.

: m 1+ recurse ;
: f 0 ['] m catch drop ; f .

Try it online

Tcl, 18 bytes

puts [interp r {}]

Try it online!

recursionlimit can be abbreviated to r

puts [interp recursionlimit {}]

Try it online!

Tcl, 49 bytes

proc R {i\ 1} {if [catch {R [incr i]}] {puts $i}}

Try it online!

Ruby, 39 bytes

END{p$.}
$stderr=$<
f=->{$.+=1;f[]}
f[]

Suppressing the error message is a little shorter than rescuing it, since by default rescue doesn't catch SystemStackError.

There's a cheesier answer if I can output in unary, representing n with n consecutive newline characters:

Ruby, 35 bytes

$stderr=$<
f=->{puts;$.+=1;f[]}
f[]

Jelly, 18 bytes

:( ^*

“¡żuẋ×HẒpƙ7"8!ƭ»ŒV

Try it online!

How?

* Since Jelly as far as I am aware:
(1) sets the Python recursion limit prior to setting up much of its own interpreter and parsing the code to be run; and
(2) has no way of catching Python errors
I'm not sure if there is a way to either reliably evaluate the recursion limit or to print it out as it is discovered other than to actually ask Python what the value was set to (I'd love to see if it can be done though!) so that's what the code here does:

“¡żuẋ×HẒpƙ7"8!ƭ»ŒV - Link: no arguments
“¡żuẋ×HẒpƙ7"8!ƭ»   - compression of "sys."+"get"+"recursion"+"limit"+"()"
                ŒV - evaluate as Python code