Yinelenen bir işlevin kaç kez çağrıldığını takip edin

 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)

Yukarıdaki kod bir tamsayı alır ve kendi rakamlarıyla çarparak tek bir basamağa indirir.

Örnek 39'dur.

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

Konsol günlüğe kaydeder:

27 
14 
4

Özyinelemeli işlevin 3 kez çağrıldığını nasıl takip edebilirim?

Bir sayaç eklemeyi denedim ancak güncelleme başarısız oluyor. Herhangi bir yardım için minnettar olurum

Bu neredeyse tamamen akademik bir varyanttır, ancak bu amaçla değiştirilmiş bir sabit nokta birleştiriciyi kullanabilirsiniz .

Orijinal işlevinizi biraz kısaltın ve geliştirelim:

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

// singleDigit(123234234) == 0

Bu varyanttan, özyinelemeli çağrıyı etkisiz hale getirebilir ve köpürebiliriz:

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

Bu işlev artık bir sabit nokta birleştirici ile kullanılabilir; özellikle aşağıdaki gibi (katı) JavaScript için uyarlanmış bir Y birleştirici uyguladı:

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

nerede olduğumuzu Ynormal(singleDigitF, 123234234) == 0.

Şimdi hile geliyor. Y birleştiricisinin özyinelemesini çarpanlarına ayırdığımız için, içindeki özyineleme sayısını sayabiliriz:

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

Düğüm REPL'indeki hızlı bir kontrol şunları sağlar:

> 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 ]

Bu birleştirici şimdi tarzında yazılmış herhangi bir özyinelemeli işlevdeki çağrı sayısını saymak için çalışacaktır singleDigitF.

(Çok sık bir cevap olarak sıfır elde etmek için iki kaynak olduğunu unutmayın: sayısal taşma ( 123345456999999999olma 123345457000000000vb.) Ve girdinin boyutu büyürken bir yerde bir ara değer olarak neredeyse kesinlikle sıfır alacağınız gerçeği.)

İşlev tanımınıza bir sayaç bağımsız değişkeni eklemelisiniz:

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

Geleneksel çözüm, sayıyı başka bir cevap tarafından önerilen işleve parametre olarak iletmektir.

Ancak, js'de başka bir çözüm daha vardır. Birkaç cevap daha, özyinelemeli fonksiyonun dışında sayım bildirilmesini önerdi:

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

Bu tabii ki işe yarıyor. Ancak bu, işlevi yeniden giriş yapmaz hale getirir (iki kez doğru çağrılamaz). Bazı durumlarda bu sorunu görmezden gelebilir ve singleDigitiki kez aramadığınızdan emin olabilirsiniz (javascript tek iş parçacıklıdır, bu yüzden yapmak çok zor değildir), ancak singleDigitdaha sonra eşzamansız olarak güncellenir ve aynı zamanda hissedilir çirkin.

Çözüm, counterdeğişkeni dışarıda ilan etmek ama global olarak bildirmektir . Javascript'in kapanışları olduğu için bu mümkündür:

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
}

Bu, global çözüme benzer, ancak her aradığınızda singleDigit(şimdi özyinelemeli bir işlev değildir ), counterdeğişkenin yeni bir örneğini oluşturur .

Başka bir yaklaşım, tüm sayıları ürettiğiniz için bir jeneratör kullanmaktır.

Son öğe, numaranızın ntek basamaklı bir sayıya indirgenmiş olması ve kaç kez yinelediğinizi saymak için dizinin uzunluğunu okumanız yeterlidir.

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>

Son düşünceler

Fonksiyonunuzda erken dönüş koşulu almayı düşünebilirsiniz . İçinde sıfır ile herhangi sayılar olacak sıfır döndürür.

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

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

Aynısı 1sadece yapılan numaralar için de söylenebilir .

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

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

Son olarak, yalnızca pozitif tam sayıları kabul edip etmediğinizi netleştirmediniz. Negatif tamsayıları kabul ederseniz, bunları dizelere yayınlamak riskli olabilir :

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

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

Olası çözüm:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Burada birçok ilginç cevap var. Bence versiyonum ilginç bir alternatif sunuyor.

Gerekli fonksiyonunuzla birkaç şey yaparsınız. Yinelemeli olarak tek bir basamağa azaltırsınız. Ara değerleri günlüğe kaydedersiniz ve yapılan yinelemeli çağrıların sayısını istiyorsunuz. Tüm bunları ele almanın bir yolu, nihai sonucu, atılan adımları ve çağrı sayısını içeren bir veri yapısını döndürecek saf bir işlev yazmaktır:

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

Ardından, isterseniz adımları kaydedebilir veya daha fazla işlem için saklayabilirsiniz.

İşte bunu yapan bir sürüm:

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))

Biz izlemek stepsama türetmek unutmayın calls. Çağrı sayısını ek bir parametre ile izleyebilsek de, hiçbir şey kazanmıyor gibi görünüyor. Ayrıca map(Number)adımı atlıyoruz - bunlar çarpma ile her durumda sayılara zorlanacaktır.

Bu varsayılan stepsparametrenin API'nizin bir parçası olarak gösterilmesiyle ilgili endişeleriniz varsa , aşağıdaki gibi dahili bir işlev kullanarak parametreyi gizlemek yeterince kolaydır:

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, [])
}

Her iki durumda da, rakam çarpımını bir yardımcı fonksiyona çıkarmak biraz daha temiz olabilir:

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])

Sadece kaç kez azaldığını saymaya çalışıyorsanız ve özellikle özyineleme konusunda umursamıyorsanız ... özyinelemeyi kaldırabilirsiniz. Aşağıdaki kod, Orijinal Posta'ya sadık kalmaya devam etmediği için sadık kalır num <= 9. Bu nedenle, singleDigit(8)sahip olacak count = 0ve singleDigit(39)olacak count = 3sadece OP ve kabul cevap sergilediklerini gibi:

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;
}

9 veya daha az sayıları işlemek gereksizdir (yani. num <= 9). Ne yazık ki OP kodu num <= 9sayılmasa bile işleyecektir . Yukarıdaki kod hiç işlemeyecek veya sayılmayacaktır num <= 9. Sadece geçiyor.

Kullanmamayı tercih ediyorum .reduceçünkü gerçek matematiği yürütmek çok daha hızlıydı. Ve benim için anlaşılması daha kolay.

Hız hakkında daha fazla düşünme

İyi kodun da hızlı olduğunu hissediyorum. Bu tür bir indirgeme kullanıyorsanız (numerolojide çok kullanılır) büyük miktarda veri üzerinde kullanmanız gerekebilir. Bu durumda, hız en önemlisi olacaktır.

Her ikisini de kullanmak .map(Number)ve console.log(her azaltma adımında) yürütmek çok uzun ve gereksizdir. Sadece .map(Number)OP'den silmek yaklaşık 4.38x hızlandırdı. Silme console.logo kadar çok hızlandı ki düzgün test etmek neredeyse imkansızdı (Ben beklemek istemedim).

Yani, benzer customcommander 'ın cevabı, kullanmayan .map(Number)ne console.logve sonuçları bir diziye bastırıyor ve kullanma .lengthiçin countçok daha hızlıdır. Ne yazık ki customcommander'ın cevabı için bir jeneratör fonksiyonu kullanmak gerçekten çok yavaş (bu cevap OP olmadan yaklaşık 2.68x daha yavaş .map(Number)ve console.log)

Ayrıca, kullanmak yerine .reducegerçek matematiği kullandım. Bu tek değişiklik tek başına fonksiyonumun versiyonunu 3.59 kat artırdı.

Son olarak, özyineleme daha yavaştır, yığın alanı kaplar, daha fazla bellek kullanır ve kaç kez "tekrarlayabileceği" sınırına sahiptir. Ya da, bu durumda, tam indirgeme işlemini tamamlamak için kaç azaltma aşaması kullanabilir? Yinelemenizi yinelemeli döngülere yaymak, hepsini yığın üzerinde aynı yerde tutar ve bitirmek için kaç azaltma adımının kullanılabileceği konusunda teorik bir sınırlama yoktur. Böylece, bu işlevler, yalnızca yürütme süresi ve bir dizinin ne kadar uzun olabileceği ile sınırlı olan hemen hemen her boyutta tamsayıyı "azaltabilir".

Tüm bunları akılda tutarak ...

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

Yukarıdaki fonksiyon son derece hızlı çalışır. Bu OP den (olmadan hızlı 3.13x hakkındadır .map(Number)ve console.logdaha hızlı) ve 8.4x hakkında customcommander 'ın cevabı. OP'den silme işleminin console.logher azaltma adımında bir sayı üretmesini engellediğini unutmayın . Bu nedenle, bu sonuçları bir dizi haline getirme ihtiyacı.

PT

Neden console.countfonksiyonunuzda bir çağrı yapmıyorsunuz ?

Düzenleme: Snippet'i tarayıcınızda denemek için:

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)

Chrome 79 ve Firefox 72'de çalışıyorum

Bunun için kapatma kullanabilirsiniz.

Sadece counterfonksiyonun kapanışında saklayın .

İşte örnek:

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);

İşte sayacı basitleştirmek için bir sarmalayıcı işlevi kullanan bir Python sürümü, slebetman'ın cevabının önerdiği gibi - Bunu sadece temel fikir bu uygulamada çok açık olduğu için yazıyorum:

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)