Rekursion beim Zählen der Vorkommen einer Zahl

Question

Ich habe ein Problem gefunden, das besagt, dass es durch Rekursion gelöst werden soll. Die Frage ist, dass es bei einer bestimmten Anzahl die Anzahl der 8, die es gibt, zählen sollte, aber wenn zwei 8 nebeneinander liegen, sollte es als doppelt gezählt werden. Zum Beispiel:

48 should return 1 
    4881 should return 4 
    8818 should return 5 

Ich habe folgendes Programm in Schema hergestellt:

(define (count n) 
    (if (= n 0) 
     0 
     (begin 
     (if (= (remainder n 100) 88) 
      2 
      (begin 
       (if (= (remainder n 10) 8) 
        1 
        0)) 
      ) 
     (+ (count (quotient n 10)))))) 

Das Problem ist, dass jedes Mal wenn ich es laufen 0 zurück, was bin ich dabei? Ich möchte keine Listen verwenden oder einstellen! um eine Hilfsvariable zu verwenden. Irgendeine Hilfe?

Answer 1

Sie müssen immer wiederholen, wenn Sie eine Übereinstimmung finden, und die Summen scheinen nicht richtig. Auch anstelle if s der Verschachtelung ist es besser cond zu verwenden, wie folgt aus:

(define (count n) 
    (cond ((= n 0) 0) 
     ((= (remainder n 100) 88) 
     (+ 4 (count (quotient n 100)))) 
     ((= (remainder n 10) 8) 
     (+ 1 (count (quotient n 10)))) 
     (else 
     (+ (count (quotient n 10)))))) 

es mit Ihren Beispielen funktioniert:

(count 48) 
=> 1 
(count 4881) 
=> 4 
(count 8818) 
=> 5 

Answer 2

Es wäre besser, Scans von 8s in einem Helfer zu zählen und halten eine aktuelle Anzahl von Treffern und eine Gesamtanzahl für vorherige Scans.

(define (funny-eights n) 
    (define (aux n cur total) 
    (cond ((= (remainder n 10) 8) 
      (aux (quotient n 10) (+ cur 1) total)) 
      ((> cur 1) 
      (aux (quotient n 10) 0 (+ total (* 2 cur)))) 
      ((= cur 1) 
      (aux (quotient n 10) 0 (+ total cur))) 
      ((> n 0) 
      (aux (quotient n 10) 0 total)) 
      (else 
      total))) 
    (aux n 0 0)) 

(funny-eights 488838288) ; ==> 11 or 3*2 + 1 + 2*2