Śledź, ile razy wywołano funkcję rekurencyjną

 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)

Powyższy kod przyjmuje liczbę całkowitą i redukuje ją do jednej cyfry, mnożąc ją przez własne cyfry.

Przykład to 39.

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

Konsola będzie rejestrować:

27 
14 
4

Jak sprawdzić, czy funkcja rekurencyjna została wywołana 3 razy?

Próbowałem dodać licznik, ale nie można go zaktualizować. Byłbym wdzięczny za każdą pomoc

Jest to wariant niemal wyłącznie akademicki, ale w tym celu można użyć zmodyfikowanego kombinatora punktów stałych .

Skróćmy i popraw nieco swoją pierwotną funkcję:

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

// singleDigit(123234234) == 0

W tym wariancie możemy wyróżnić i zakryć rekurencyjne wezwanie:

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

Tej funkcji można teraz używać z kombinatorem punktów stałych; konkretnie zaimplementowałem kombinator Y dostosowany do (ścisłego) JavaScript w następujący sposób:

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

gdzie mamy Ynormal(singleDigitF, 123234234) == 0.

Teraz nadchodzi sztuczka. Ponieważ uwzględniliśmy rekurencję do kombinatora Y, możemy policzyć w niej liczbę rekurencji:

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

Szybkie sprawdzenie w węźle REPL daje:

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

Ten kombinator będzie teraz działać w celu zliczania liczby wywołań w dowolnej funkcji rekurencyjnej zapisanej w stylu singleDigitF.

(Zauważ, że istnieją dwa źródła uzyskania zera jako bardzo częstej odpowiedzi: przepełnienie numeryczne ( 123345456999999999staje się 123345457000000000itp.) Oraz fakt, że prawie na pewno otrzymasz gdzieś zero jako wartość pośrednią, gdy rozmiar danych wejściowych rośnie.)

Do definicji funkcji należy dodać argument licznika:

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

Tradycyjnym rozwiązaniem jest przekazanie licznika jako parametru do funkcji, jak sugeruje inna odpowiedź.

Istnieje jednak inne rozwiązanie w js. Kilka innych odpowiedzi sugerowało po prostu zadeklarowanie liczby poza funkcją rekurencyjną:

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

To oczywiście działa. Jednak powoduje to, że funkcja nie jest ponownie aktywowana (nie można jej wywołać dwukrotnie poprawnie). W niektórych przypadkach możesz zignorować ten problem i po prostu upewnij się, że nie dzwonisz singleDigitdwa razy (javascript jest jednowątkowy, więc nie jest to zbyt trudne), ale jest to błąd, który czeka się, jeśli zaktualizujesz singleDigitpóźniej, aby był asynchroniczny, a także czuje się brzydki.

Rozwiązaniem jest zadeklarowanie counterzmiennej na zewnątrz, ale nie globalnie. Jest to możliwe, ponieważ javascript ma zamknięcia:

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
}

Jest to podobne do globalnego rozwiązania, ale za każdym razem dzwonisz singleDigit(co jest teraz nie rekurencyjna funkcja) będzie utworzyć nową instancję counterzmiennej.

Innym podejściem, ponieważ generujesz wszystkie liczby, jest użycie generatora.

Ostatnim elementem jest liczba nzredukowana do liczby jednocyfrowej. Aby zliczyć liczbę iteracji, po prostu przeczytaj długość tablicy.

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>

Końcowe przemyślenia

Możesz rozważyć możliwość wcześniejszego powrotu do funkcji. Wszelkie numery z zerem w nim będzie powrotu do zera.

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

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

To samo można powiedzieć o dowolnych wykonanych liczbach 1.

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

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

Na koniec nie wyjaśniłeś, czy akceptujesz tylko dodatnie liczby całkowite. Jeśli zaakceptujesz liczby całkowite ujemne, rzutowanie ich na ciągi znaków może być ryzykowne:

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

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

Możliwe rozwiązanie:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Było tu wiele interesujących odpowiedzi. Myślę, że moja wersja oferuje dodatkową interesującą alternatywę.

Robisz kilka rzeczy z wymaganą funkcją. Rekurencyjnie redukujesz go do jednej cyfry. Rejestrujesz wartości pośrednie i chcesz uzyskać liczbę wykonanych połączeń rekurencyjnych. Jednym ze sposobów radzenia sobie z tym wszystkim jest napisanie czystej funkcji, która zwróci strukturę danych zawierającą wynik końcowy, podjęte kroki i liczbę połączeń w jednym:

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

Możesz następnie zapisać kroki, jeśli chcesz, lub zapisać je do dalszego przetwarzania.

Oto wersja, która to robi:

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

Pamiętaj, że śledzimy, stepsale wyprowadzamy calls. Chociaż możemy śledzić liczbę połączeń za pomocą dodatkowego parametru, wydaje się, że nic nie zyskuje. Pomijamy również map(Number)krok - w każdym przypadku zostaną one wymuszone na liczby przez pomnożenie.

Jeśli masz obawy, że ten domyślny stepsparametr zostanie ujawniony jako część interfejsu API, łatwo go ukryć za pomocą funkcji wewnętrznej:

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

W obu przypadkach wyodrębnienie mnożenia cyfr może być nieco czystsze:

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

Jeśli próbujesz po prostu policzyć, ile razy się zmniejsza, i nie przejmujesz się konkretnie rekurencją ... możesz po prostu usunąć rekurencję. Poniższy kod pozostaje wierny oryginalnemu wpisowi, ponieważ nie jest uważany num <= 9za wymagający zmniejszenia. Dlatego singleDigit(8)będzie miał count = 0i singleDigit(39)będzie miał count = 3, podobnie jak PO i zaakceptowana odpowiedź pokazują:

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

Przetwarzanie liczb 9 lub mniejszych (tj. num <= 9) Nie jest konieczne . Niestety kod OP będzie przetwarzany, num <= 9nawet jeśli go nie liczy. Powyższy kod w ogóle nie będzie przetwarzany ani liczony num <= 9. Po prostu mi to przekazuje.

Zdecydowałem się nie używać, .reduceponieważ wykonanie faktycznej matematyki było znacznie szybsze do wykonania. I dla mnie łatwiejsze do zrozumienia.

Dalsze myślenie o prędkości

Uważam, że dobry kod jest również szybki. Jeśli używasz tego typu redukcji (która jest często używana w numerologii), być może będziesz musiał użyć go na ogromnej ilości danych. W takim przypadku prędkość będzie najważniejsza.

Używanie obu .map(Number)i console.log(na każdym etapie redukcji) jest bardzo długie do wykonania i niepotrzebne. Samo usunięcie .map(Number)z PO przyspieszyło go o około 4,38x. Usunięcie console.logprzyspieszyło tak bardzo, że prawie niemożliwe było prawidłowe przetestowanie (nie chciałem na to czekać).

Tak więc, podobnie jak odpowiedź customcommandera , nieużywanie .map(Number)ani nie console.logwypychanie wyników do tablicy i używanie .lengthdla countjest znacznie szybsze. Niestety dla customcommander „s odpowiedź, stosując funkcję generatora jest naprawdę bardzo powolny (które odpowiedź jest około 2.68x wolniej niż OP bez .map(Number)i console.log)

Zamiast tego .reduceużyłem właśnie faktycznej matematyki. Już ta pojedyncza zmiana przyspieszyła moją wersję funkcji o współczynnik 3,59x.

Wreszcie rekurencja jest wolniejsza, zajmuje miejsce na stosie, zużywa więcej pamięci i ma limit liczby powtórzeń. Lub, w tym przypadku, ile kroków redukcji można użyć, aby zakończyć pełną redukcję. Wdrożenie rekurencji w pętle iteracyjne utrzymuje to wszystko w tym samym miejscu na stosie i nie ma teoretycznego limitu liczby kroków redukcji, których można użyć do ukończenia. W związku z tym funkcje te mogą tutaj „zmniejszyć” liczbę całkowitą o dowolnej wielkości, ograniczoną jedynie czasem wykonania i długością tablicy.

Wszystko to na uwadze ...

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

Powyższa funkcja działa bardzo szybko. Jest to około 3.13x szybszy niż OP (bez .map(Number)i console.log) i około 8.4x szybszy niż customcommander „s odpowiedzi. Należy pamiętać, że usunięcie console.logz PO uniemożliwia wygenerowanie liczby na każdym etapie redukcji. Stąd potrzeba tutaj wypchnięcia tych wyników do tablicy.

PT

Dlaczego nie zadzwonić do console.countswojej funkcji?

Edytuj: Snippet, aby wypróbować w przeglądarce:

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)

Mam go w Chrome 79 i Firefox 72

Możesz użyć do tego zamknięcia.

Wystarczy zapisać counterw zamknięciu funkcji.

Oto przykład:

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

Oto wersja Python, która wykorzystuje funkcję otoki w celu uproszczenia licznika, jak sugeruje odpowiedź slebetman - piszę to tylko dlatego, że podstawowa idea jest bardzo jasna w tej implementacji:

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)