Melacak berapa kali fungsi rekursif dipanggil

 function singleDigit(num) {
      let counter = 0
      let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

      if(number <= 9){
          console.log(number)
      }else{
          console.log(number)
          return singleDigit(number), counter += 1
      }
   }
singleDigit(39)

Kode di atas mengambil integer dan menguranginya menjadi satu digit dengan mengalikannya dengan digitnya sendiri.

Contohnya adalah 39.

3 x 9 = 27.
2 x 7 = 14.
1 x 4 = 4.

Konsol akan masuk:

27 
14 
4

Bagaimana saya melacak bahwa fungsi rekursif dipanggil 3 kali?

Saya telah mencoba menambahkan penghitung tetapi gagal memperbarui. Akan menghargai bantuan apa pun

Ini adalah varian yang hampir murni akademis, tetapi Anda dapat menggunakan kombinator titik tetap yang dimodifikasi untuk tujuan ini.

Mari kita persingkat dan tingkatkan fungsi asli Anda sedikit:

function singleDigit(n) {
    let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
    return digitProduct <= 9 ? digitProduct : singleDigit(digitProduct);
}

// singleDigit(123234234) == 0

Dari varian ini, kita dapat memfaktorkan dan mengeringkan panggilan rekursif:

function singleDigitF(recur) {
    return function (n) {
        let digitProduct = [...(n + '')].reduce((x, y) => x * y, 1);
        return digitProduct <= 9 ? digitProduct : recur()(digitProduct);
    };
}

Fungsi ini sekarang dapat digunakan dengan kombinator titik tetap; khusus saya menerapkan kombinator Y yang diadaptasi untuk JavaScript (ketat) sebagai berikut:

function Ynormal(f, ...args) {
    let Y = (g) => g(() => Y(g));
    return Y(f)(...args);
}

dimana kita miliki Ynormal(singleDigitF, 123234234) == 0.

Sekarang tibalah kiatnya. Karena kami telah memperhitungkan rekursi ke kombinator Y, kami dapat menghitung jumlah rekursi di dalamnya:

function Ycount(f, ...args) {
    let count = 1;
    let Y = (g) => g(() => {count += 1; return Y(g);});
    return [Y(f)(...args), count];
}

Pemeriksaan cepat di Node REPL memberi:

> Ycount(singleDigitF, 123234234)
[ 0, 3 ]
> let digitProduct = (n) => [...(n + '')].reduce((x, y) => x * y, 1)
undefined
> digitProduct(123234234)
3456
> digitProduct(3456)
360
> digitProduct(360)
0
> Ycount(singleDigitF, 39)
[ 4, 3 ]

Combinator ini sekarang akan berfungsi untuk menghitung jumlah panggilan dalam fungsi rekursif apa pun yang ditulis dengan gaya singleDigitF.

(Perhatikan bahwa ada dua sumber untuk mendapatkan nol sebagai jawaban yang sangat sering: pelimpahan numerik ( 123345456999999999menjadi 123345457000000000dll.), Dan fakta bahwa Anda hampir pasti akan mendapatkan nol sebagai nilai perantara di suatu tempat, ketika ukuran input bertambah.)

Anda harus menambahkan argumen balasan ke definisi fungsi Anda:

function singleDigit(num, counter = 0) {
    console.log(`called ${counter} times`)
    //...
    return singleDigit(number, counter+1)
}
singleDigit(39)

Solusi tradisional adalah melewatkan hitungan sebagai parameter ke fungsi seperti yang disarankan oleh jawaban lain.

Namun, ada solusi lain di js. Beberapa jawaban lain yang disarankan hanya menyatakan penghitungan di luar fungsi rekursif:

let counter = 0
function singleDigit(num) {
  counter++;
  // ..
}

Ini tentu saja berhasil. Namun ini membuat fungsi ini tidak reentrant (tidak dapat dipanggil dua kali dengan benar). Dalam beberapa kasus, Anda dapat mengabaikan masalah ini dan cukup memastikan Anda tidak menelepon singleDigitdua kali (javascript adalah utas tunggal sehingga tidak terlalu sulit untuk dilakukan) tetapi ini adalah bug yang menunggu untuk terjadi jika Anda memperbarui singleDigitkemudian menjadi asinkron dan juga terasa jelek.

Solusinya adalah mendeklarasikan countervariabel di luar tetapi tidak secara global. Ini dimungkinkan karena javascript memiliki penutupan:

function singleDigit(num) {
  let counter = 0; // outside but in a closure

  // use an inner function as the real recursive function:
  function recursion (num) {
    counter ++
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
      return counter            // return final count (terminate)
    }else{
      return recursion(number)  // recurse!
    }
  }

  return recursion(num); // start recursion
}

Ini mirip dengan solusi global tetapi setiap kali Anda menelepon singleDigit(yang sekarang bukan fungsi rekursif) itu akan membuat contoh baru dari countervariabel.

Pendekatan lain, karena Anda menghasilkan semua angka, adalah menggunakan generator.

Elemen terakhir adalah jumlah Anda ndikurangi menjadi satu digit angka dan untuk menghitung berapa kali Anda mengulanginya, cukup baca panjang array.

const digits = [...to_single_digit(39)];
console.log(digits);
//=> [27, 14, 4]

<script>
function* to_single_digit(n) {
  do {
    n = [...String(n)].reduce((x, y) => x * y);
    yield n;
  } while (n > 9);
}
</script>

Pikiran terakhir

Anda mungkin ingin mempertimbangkan untuk mengembalikan kondisi awal dalam fungsi Anda. Setiap angka dengan nol di dalamnya akan mengembalikan nol.

singleDigit(1024);       //=> 0
singleDigit(9876543210); //=> 0

// possible solution: String(n).includes('0')

Hal yang sama dapat dikatakan untuk angka apa pun yang dibuat 1hanya.

singleDigit(11);    //=> 1
singleDigit(111);   //=> 1
singleDigit(11111); //=> 1

// possible solution: [...String(n)].every(n => n === '1')

Akhirnya, Anda tidak mengklarifikasi apakah Anda hanya menerima bilangan bulat positif. Jika Anda menerima bilangan bulat negatif, maka melemparkannya ke string dapat berisiko:

[...String(39)].reduce((x, y) => x * y)
//=> 27

[...String(-39)].reduce((x, y) => x * y)
//=> NaN

Solusi yang mungkin:

const mult = n =>
  [...String(Math.abs(n))].reduce((x, y) => x * y, n < 0 ? -1 : 1)

mult(39)
//=> 27

mult(-39)
//=> -27

Ada banyak jawaban menarik di sini. Saya pikir versi saya menawarkan alternatif menarik tambahan.

Anda melakukan beberapa hal dengan fungsi yang diminta. Anda menguranginya menjadi satu digit secara rekursif. Anda mencatat nilai perantara, dan Anda ingin menghitung panggilan rekursif yang dilakukan. Salah satu cara untuk menangani semua ini adalah dengan menulis fungsi murni yang akan mengembalikan struktur data yang berisi hasil akhir, langkah-langkah yang diambil dan panggilan dihitung semuanya menjadi satu:

  {
    digit: 4,
    steps: [39, 27, 14, 4],
    calls: 3
  }

Anda kemudian dapat mencatat langkah-langkah jika diinginkan, atau menyimpannya untuk diproses lebih lanjut.

Berikut adalah versi yang melakukan itu:

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])

console .log (singleDigit (39))

Perhatikan bahwa kami melacak stepstetapi menurunkan calls. Meskipun kami dapat melacak jumlah panggilan dengan parameter tambahan, hal itu sepertinya tidak menghasilkan apa-apa. Kami juga melewatkan map(Number)langkah - ini akan dipaksa ke angka dalam hal apa pun oleh penggandaan.

Jika Anda khawatir tentang stepsparameter default yang diekspos sebagai bagian dari API Anda, cukup mudah untuk menyembunyikannya dengan menggunakan fungsi internal seperti ini:

const singleDigit = (n) => {
  const recur = (n, steps) => 
    n <= 9
      ? {digit: n, steps: [... steps, n], calls: steps .length}
      : recur ([... (n + '')] .reduce ((a, b) => a * b), [... steps, n])
  return recur (n, [])
}

Dan dalam kedua kasus itu, mungkin sedikit lebih bersih untuk mengekstrak perkalian digit menjadi fungsi pembantu:

const digitProduct = (n) => [... (n + '')] .reduce ((a, b) => a * b)

const singleDigit = (n, steps = []) =>
  n <= 9
    ? {digit: n, steps: [... steps, n], calls: steps .length}
    : singleDigit (digitProduct(n), [... steps, n])

Jika Anda hanya mencoba menghitung berapa kali berkurang dan tidak peduli tentang rekursi secara khusus ... Anda bisa menghapus rekursi itu. Kode di bawah ini tetap setia ke Posting Asli karena tidak dianggap num <= 9perlu dikurangi. Oleh karena itu, singleDigit(8)akan memiliki count = 0, dan singleDigit(39)akan memiliki count = 3, seperti OP dan jawaban yang diterima menunjukkan:

const singleDigit = (num) => {
    let count = 0, ret, x;
    while (num > 9) {
        ret = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            ret *= x;
        }
        num *= ret;
        count++;
        console.log(num);
    }
    console.log("Answer = " + num + ", count = " + count);
    return num;
}

Tidak perlu memproses angka 9 atau kurang (mis. num <= 9). Sayangnya kode OP akan diproses num <= 9walaupun tidak dihitung. Kode di atas tidak akan memproses atau menghitungnum <= 9 sama sekali. Itu hanya melewati itu.

Saya memilih untuk tidak menggunakan .reducekarena melakukan matematika sebenarnya jauh lebih cepat untuk dieksekusi. Dan, bagi saya, lebih mudah dipahami.

Pemikiran lebih lanjut tentang kecepatan

Saya merasa kode yang baik juga cepat. Jika Anda menggunakan jenis pengurangan ini (yang banyak digunakan dalam numerologi), Anda mungkin perlu menggunakannya pada sejumlah besar data. Dalam hal ini, kecepatan akan menjadi yang terpenting.

Menggunakan keduanya .map(Number)dan console.log(pada setiap langkah reduksi) keduanya sangat panjang untuk dieksekusi dan tidak perlu. Cukup menghapus .map(Number)dari OP, mempercepatnya sekitar 4,38x. Menghapus begitu console.logcepat sehingga hampir tidak mungkin untuk menguji dengan benar (saya tidak ingin menunggu untuk itu).

Jadi, mirip dengan jawaban customcommander , tidak menggunakan .map(Number)atau console.logmendorong hasil ke dalam array dan menggunakan .lengthuntuk countjauh lebih cepat. Sayangnya untuk jawaban customcommander , menggunakan fungsi generator benar-benar lambat (jawaban itu sekitar 2.68x lebih lambat daripada OP tanpa .map(Number)dan console.log)

Juga, alih-alih menggunakan .reducesaya hanya menggunakan matematika yang sebenarnya. Perubahan tunggal ini saja mempercepat versi fungsi saya dengan faktor 3,59x.

Akhirnya, rekursi lebih lambat, membutuhkan ruang stack, menggunakan lebih banyak memori, dan memiliki batas berapa kali dapat "berulang". Atau, dalam hal ini, berapa banyak langkah reduksi yang dapat digunakan untuk menyelesaikan reduksi penuh. Meluncurkan rekursi Anda ke loop berulang membuat semuanya berada di tempat yang sama di tumpukan dan tidak memiliki batasan teoritis tentang berapa banyak langkah reduksi yang dapat digunakan untuk menyelesaikannya. Dengan demikian, fungsi-fungsi ini di sini dapat "mengurangi" hampir semua bilangan bulat ukuran, hanya dibatasi oleh waktu eksekusi dan berapa lama array dapat.

Semua ini dalam pikiran ...

const singleDigit2 = (num) => {
    let red, x, arr = [];
    do {
        red = 1;
        while (num > 9) {
            x = num % 10;
            num = (num - x) / 10;
            red *= x;
        }
        num *= red;
        arr.push(num);
    } while (num > 9);
    return arr;
}

let ans = singleDigit2(39);
console.log("singleDigit2(39) = [" + ans + "],  count = " + ans.length );
 // Output: singleDigit2(39) = [27,14,4],  count = 3

Fungsi di atas berjalan sangat cepat. Ini sekitar 3.13x lebih cepat dari OP (tanpa .map(Number)dan console.log) dan sekitar 8.4x lebih cepat dari jawaban customcommander . Ingatlah bahwa menghapus console.logOP mencegahnya menghasilkan angka pada setiap langkah pengurangan. Oleh karena itu, kebutuhan di sini untuk mendorong hasil ini ke dalam array.

PT

Mengapa tidak melakukan panggilan ke console.countdalam fungsi Anda?

Edit: Cuplikan untuk dicoba di browser Anda:

function singleDigit(num) {
    console.count("singleDigit");

    let counter = 0
    let number = [...num + ''].map(Number).reduce((x, y) => {return x * y})

    if(number <= 9){
        console.log(number)
    }else{
        console.log(number)
        return singleDigit(number), counter += 1
    }
}
singleDigit(39)

Saya memilikinya bekerja di Chrome 79 dan Firefox 72

Anda dapat menggunakan penutupan untuk ini.

Cukup simpan saja counter ke dalam penutupan fungsi.

Berikut ini contohnya:

function singleDigitDecorator() {
	let counter = 0;

	return function singleDigitWork(num, isCalledRecursively) {

		// Reset if called with new params 
		if (!isCalledRecursively) {
			counter = 0;
		}

		counter++; // *

		console.log(`called ${counter} times`);

		let number = [...(num + "")].map(Number).reduce((x, y) => {
			return x * y;
		});

		if (number <= 9) {
			console.log(number);
		} else {
			console.log(number);

			return singleDigitWork(number, true);
		}
	};
}

const singleDigit = singleDigitDecorator();

singleDigit(39);

console.log('`===========`');

singleDigit(44);

Berikut ini adalah versi Python yang menggunakan fungsi wrapper untuk menyederhanakan counter, seperti yang telah disarankan oleh jawaban slebetman - Saya menulis ini hanya karena ide inti sangat jelas dalam implementasi ini:

from functools import reduce

def single_digit(n: int) -> tuple:
    """Take an integer >= 0 and return a tuple of the single-digit product reduction
    and the number of reductions performed."""

    def _single_digit(n, i):
        if n <= 9:
            return n, i
        else:
            digits = (int(d) for d in str(n))
            product = reduce(lambda x, y: x * y, digits)
            return _single_digit(product, i + 1)

    return _single_digit(n, 0)

>>> single_digit(39)
(4, 3)