Verfolgen Sie, wie oft eine rekursive Funktion aufgerufen wurde

 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)

Der obige Code nimmt eine Ganzzahl und reduziert sie auf eine einzelne Ziffer, indem sie mit ihren eigenen Ziffern multipliziert wird.

Beispiel ist 39.

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

Die Konsole protokolliert:

27 
14 
4

Wie verfolge ich, dass die rekursive Funktion dreimal aufgerufen wurde?

Ich habe versucht, einen Zähler hinzuzufügen, der jedoch nicht aktualisiert werden kann. Würde mich über jede Hilfe freuen

Dies ist eine fast rein akademische Variante, aber Sie können zu diesem Zweck einen modifizierten Festpunktkombinator verwenden.

Verkürzen und verbessern Sie Ihre ursprüngliche Funktion ein wenig:

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

// singleDigit(123234234) == 0

Aus dieser Variante können wir den rekursiven Aufruf herausrechnen und curry:

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

Diese Funktion kann jetzt mit einem Festkomma-Kombinator verwendet werden. Insbesondere habe ich einen Y-Kombinator implementiert, der für (striktes) JavaScript wie folgt angepasst ist:

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

wo wir haben Ynormal(singleDigitF, 123234234) == 0.

Jetzt kommt der Trick. Da wir die Rekursion zum Y-Kombinator herausgerechnet haben, können wir die Anzahl der darin enthaltenen Rekursionen zählen:

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

Ein kurzer Check im Node REPL ergibt:

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

Dieser Kombinator zählt jetzt die Anzahl der Anrufe in einem beliebigen rekursiven Funktion, die im Stil von geschrieben wurde singleDigitF.

(Beachten Sie, dass es zwei Ursachen gibt, um als sehr häufige Antwort Null zu erhalten: numerischer Überlauf ( 123345456999999999Werden 123345457000000000usw.) und die Tatsache, dass Sie mit ziemlicher Sicherheit irgendwo Null als Zwischenwert erhalten, wenn die Größe der Eingabe zunimmt.)

Sie sollten Ihrer Funktionsdefinition ein Gegenargument hinzufügen:

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

Die traditionelle Lösung besteht darin, die Zählung als Parameter an die Funktion zu übergeben, wie in einer anderen Antwort vorgeschlagen.

Es gibt jedoch eine andere Lösung in js. Einige andere Antworten schlugen vor, einfach die Anzahl außerhalb der rekursiven Funktion zu deklarieren:

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

Das funktioniert natürlich. Dies macht die Funktion jedoch nicht wiedereintrittsfähig (kann nicht zweimal korrekt aufgerufen werden). In einigen Fällen können Sie dieses Problem ignorieren und einfach sicherstellen, dass Sie nicht singleDigitzweimal aufrufen (Javascript ist Single-Threaded, so dass es nicht zu schwierig ist), aber dies ist ein Fehler, der darauf wartet, wenn Sie singleDigitspäter aktualisieren , um asynchron zu sein, und es fühlt sich auch so an hässlich.

Die Lösung besteht darin, die counterVariable außerhalb, aber nicht global zu deklarieren . Dies ist möglich, weil Javascript Verschlüsse hat:

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
}

Dies ähnelt der globalen Lösung, erstellt jedoch bei jedem Aufruf singleDigit(der jetzt keine rekursive Funktion ist) eine neue Instanz der counterVariablen.

Ein anderer Ansatz, da Sie alle Zahlen erzeugen, ist die Verwendung eines Generators.

Das letzte Element ist Ihre nauf eine einstellige Zahl reduzierte Zahl. Um zu zählen, wie oft Sie iteriert haben, lesen Sie einfach die Länge des Arrays.

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>

Abschließende Gedanken

Möglicherweise möchten Sie eine frühzeitige Rückkehrbedingung in Ihrer Funktion in Betracht ziehen . Jegliche Zahlen mit einer Null in es werden Null zurück.

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

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

Das Gleiche gilt für alle Zahlen, die 1nur aus bestehen.

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

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

Schließlich haben Sie nicht geklärt, ob Sie nur positive ganze Zahlen akzeptieren. Wenn Sie negative Ganzzahlen akzeptieren, kann das Umwandeln in Zeichenfolgen riskant sein:

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

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

Mögliche Lösung:

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

mult(39)
//=> 27

mult(-39)
//=> -27

Hier gab es viele interessante Antworten. Ich denke, meine Version bietet eine weitere interessante Alternative.

Sie machen mehrere Dinge mit Ihrer gewünschten Funktion. Sie reduzieren es rekursiv auf eine einzelne Ziffer. Sie protokollieren die Zwischenwerte und möchten, dass die rekursiven Aufrufe gezählt werden. Eine Möglichkeit, dies alles zu handhaben, besteht darin, eine reine Funktion zu schreiben, die eine Datenstruktur zurückgibt, die das Endergebnis, die durchgeführten Schritte und die Anzahl der Aufrufe in einem enthält:

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

Sie können die Schritte dann bei Bedarf protokollieren oder zur weiteren Verarbeitung speichern.

Hier ist eine Version, die das macht:

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

Beachten Sie, dass wir das verfolgen, stepsaber das ableiten calls. Während wir die Anzahl der Anrufe mit einem zusätzlichen Parameter verfolgen konnten, scheint dies nichts zu gewinnen. Wir überspringen auch den map(Number)Schritt - diese werden in jedem Fall durch Multiplikation zu Zahlen gezwungen.

Wenn Sie Bedenken haben, dass dieser Standardparameter stepsals Teil Ihrer API verfügbar gemacht wird, können Sie ihn mithilfe einer internen Funktion wie der folgenden leicht ausblenden:

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

In beiden Fällen kann es etwas sauberer sein, die Ziffernmultiplikation in eine Hilfsfunktion zu extrahieren:

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

Wenn Sie nur versuchen zu zählen, wie oft es reduziert wird, und sich nicht speziell um die Rekursion kümmern , können Sie die Rekursion einfach entfernen. Der folgende Code bleibt dem Originalbeitrag treu, da er nicht num <= 9als reduktionsbedürftig gilt. Daher singleDigit(8)wird count = 0und singleDigit(39)wird count = 3, genau wie das OP und die akzeptierte Antwort zeigen:

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

Es ist nicht erforderlich, die Nummern 9 oder weniger (dh num <= 9) zu verarbeiten. Leider wird der OP-Code verarbeitet, num <= 9obwohl er nicht gezählt wird. Der obige Code wird weder verarbeitet noch gezähltnum <= 9 . Es geht einfach durch.

Ich entscheide mich, es nicht zu verwenden, .reduceda die Ausführung der eigentlichen Mathematik viel schneller war. Und für mich leichter zu verstehen.

Weiteres Denken über Geschwindigkeit

Ich fühle mich gut Code ist auch schnell. Wenn Sie diese Art der Reduzierung verwenden (die in der Numerologie häufig verwendet wird), müssen Sie sie möglicherweise für eine große Datenmenge verwenden. In diesem Fall wird die Geschwindigkeit von größter Bedeutung sein.

Die Verwendung von beiden .map(Number)und console.log(bei jedem Reduktionsschritt) ist sehr, sehr langwierig und unnötig. .map(Number)Durch einfaches Löschen aus dem OP wurde die Geschwindigkeit um das 4,38-fache erhöht. Das Löschen console.logbeschleunigte es so sehr, dass es fast unmöglich war, es richtig zu testen (ich wollte nicht darauf warten).

Ähnlich wie bei der Antwort von customcommander ist es viel schneller , .map(Number)nor nicht zu verwenden console.logund die Ergebnisse in ein Array zu verschieben und .lengthfor zu verwenden count. Unglücklicherweise für die Antwort von customcommander ist die Verwendung einer Generatorfunktion sehr, sehr langsam (diese Antwort ist ungefähr 2,68x langsamer als die OP ohne .map(Number)und console.log).

Anstatt zu verwenden, habe .reduceich auch nur die eigentliche Mathematik verwendet. Allein diese einzelne Änderung hat meine Version der Funktion um den Faktor 3,59 beschleunigt.

Schließlich ist die Rekursion langsamer, beansprucht Stapelspeicher, verbraucht mehr Speicher und kann nur begrenzt "wiederkehren". Oder in diesem Fall, wie viele Reduktionsschritte verwendet werden können, um die vollständige Reduktion abzuschließen. Wenn Sie Ihre Rekursion in iterative Schleifen ausrollen, bleibt alles an derselben Stelle auf dem Stapel und es gibt keine theoretische Begrenzung für die Anzahl der Reduktionsschritte, die zum Beenden verwendet werden können. Somit können diese Funktionen hier nahezu jede beliebige Größe "reduzieren", die nur durch die Ausführungszeit und die Länge eines Arrays begrenzt ist.

All dies im Hinterkopf ...

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

Die obige Funktion läuft extrem schnell. Es ist ungefähr 3,13x schneller als das OP (ohne .map(Number)und console.log) und ungefähr 8,4x schneller als die Antwort von customcommander . Beachten Sie, dass das Löschen console.logaus dem OP verhindert, dass bei jedem Schritt der Reduzierung eine Zahl erzeugt wird. Daher besteht hier die Notwendigkeit, diese Ergebnisse in ein Array zu verschieben.

PT

Warum rufen Sie nicht console.countin Ihrer Funktion an?

Bearbeiten: Snippet zum Ausprobieren in Ihrem Browser:

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)

Ich habe es in Chrome 79 und Firefox 72 funktionieren

Sie können hierfür den Verschluss verwenden.

Einfach counterin den Funktionsschluss speichern .

Hier ist ein Beispiel:

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

Hier ist eine Python-Version, die eine Wrapper-Funktion verwendet, um den Zähler zu vereinfachen, wie in der Antwort von slebetman vorgeschlagen wurde. Ich schreibe dies nur, weil die Kernidee in dieser Implementierung sehr klar ist:

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)