在Scheme中用数字替换字符串的累积递归
问题如下：在Scheme中用数字替换字符串的累积递归,scheme,racket,accumulator,Scheme,Racket,Accumulator,问题如下： (define (abbreviate str) (local [(define str-lst (string->list str)) (define (count-duplicate lst char count) (cond [(empty? lst) count] [(equal? (first lst) char) (count-dup
(define (abbreviate str)
(local [(define str-lst (string->list str))
(define (count-duplicate lst char count)
(cond
[(empty? lst) count]
[(equal? (first lst) char)
(count-duplicate (rest lst)
(first lst)
(add1 count))]
[else (count-duplicate (rest lst)
(first lst)
count)]))
(define (build-string lst)
(cond
[(empty? lst) empty]
[else (cons (first lst)
(cons (string->list (number->string
(count-duplicate (rest lst)
(first lst) 1)))
(build-string (rest lst))))]))]
(build-string str-lst)))
(define (abbreviate str)
(local [(define str-lst (string->list str))
(define (count-duplicate lst char count)
(cond
[(empty? lst) count]
[(equal? (first lst) char)
(count-duplicate (rest lst)
(first lst)
(add1 count))]
[else (count-duplicate (rest lst)
(first lst)
count)]))
(define (build-string lst)
(cond
[(empty? lst) empty]
[else (cons (first lst)
(cons (string->list (number->string
(count-duplicate (rest lst)
(first lst) 1)))
(build-string (rest lst))))]))]
(build-string str-lst)))
有什么帮助吗？首先对帮助程序进行单元测试，并给出一些提示：
- 如果累积递归指的是尾部递归，那么请注意：
不是尾部递归，必须完全重写buildstring
没有达到预期效果-在递归调用中将count duplicate
作为第二个参数传递是错误的（first lst）- 你不是在数连续字符，你只是在数字符数
- 输出列表的构造不正确-为什么总是将一个字符与其频率粘在一起？仅当字符连续复制时才执行此操作
- 预期的输出是字符串，而不是字符列表。在某些情况下，您必须使用
list->string - 此外，在某些时候，您必须将找到的字符数转换为一个字符，例如：
将变成3
。这是在末尾创建字符串所必需的\3
count duplicate(define (count-duplicate lst char count)
(cond [(or (empty? lst) (not (char=? char (first lst))))
count]
[else
(count-duplicate (rest lst) char (add1 count))]))
(count-duplicate (rest '(#\h #\e #\l #\l #\o)) #\h 1)
=> 1
(count-duplicate (rest '(#\h #\h #\h #\l #\o)) #\h 1)
=> 3
现在，您必须确保对于原始字符串中的每个当前字符，计算在列表的其余部分中找到的连续字符数，如果该数字大于
1计数drop(define (abbreviate str)
(let scanning ((list (string->list str))
(last #f)
(numb 1)
(rslt '()))
(if (null? list)
(reverse (if (= 1 numb) rslt (cons numb rslt))) ; after reverse, make a string
(let ((next (car list))
(rest (cdr list)))
(if (equal? last next)
(scanning rest next (+ numb 1) rslt)
(scanning rest next 1
(cons next (if (= 1 numb) rslt (cons numb rslt)))))))))
> (abbreviate "22")
(#\2 2)
> (abbreviate "")
()
> (abbreviate "hellllloo")
(#\h #\e #\l 5 #\o 2)
> (abbreviate "mississippi")
(#\m #\i #\s 2 #\i #\s 2 #\i #\p 2 #\i)
> (abbreviate "Noooooooooooooooooo way!")
(#\N #\o 18 #\space #\w #\a #\y #\!)
;; abbreviate : string -> string
;; consumes a string and produces a new string, with all occurences of
;; sequences of repeating characters reduced to 1 character and the
;; number of times the character repeats
;; Example
;; (abbreviate "oooo) should be "o4"
;; (abbreviate "thiis iss a teesstt") should be "thi2s is2 a te2s2t2"
;; (abbreviate "magic") should be "magic"
;; Definitions:
(define (abbreviate a-string)
(local ((define memory empty)
(define (count-dupes b)
(cond ((empty? b) 0)
((duplicate? b) (+ 1 (count-dupes (rest b))))
(else 0)))
(define (skip-dupes c n)
(cond ((= n 0) c)
((empty? c) c)
(else (skip-dupes (rest c) (sub1 n)))))
(define (duplicate? a)
(equal? (first a) (first memory)))
(define (load lst)
(begin (set! memory (cons (first lst) memory)) (abbreviate-x (rest lst))))
(define (abbreviate-x lst)
(cond ((empty? lst) lst)
((empty? memory) (cons (first lst) (load lst)))
((duplicate? lst) (cons (+ 1 (count-dupes lst))
(abbreviate-x
(skip-dupes lst (count-dupes lst)))))
(else (cons (first lst) (load lst)))))
(define (string-adapt d)
(cond ((empty? d) empty)
((number? (first d)) (append (string->list (number->string (first d)))
(string-adapt (rest d))))
(else (cons (first d) (string-adapt (rest d)))))))
(list->string (string-adapt (abbreviate-x (string->list a-string))))))
;; Test
(check-expect (abbreviate "hellooo wooorldd") "hel2o3 wo3rld2"
亲切问候这是我对这个问题的看法 第一个称为prefix的过程将告诉您字符串开头有多少个连续的相同字母。我使用字符串->列表来处理列表，而不是子字符串：
(define (prefix str)
(let ((chars (string->list str)))
(let loop ((chars chars) (c #\0) (l 0))
(if (empty? chars)
(values l c)
(if (= l 0)
(loop (cdr chars) (car chars) (add1 l))
(if (char=? (car chars) c)
(loop (cdr chars) c (add1 l))
(values l c)))))))
(prefix "")
0
#\0
(prefix "x")
1
#\x
(prefix "hello")
1
#\h
(prefix "hhhello")
3
#\h
(define (rle str)
(let loop ((str str) (res '()))
(if (= (string-length str) 0)
(string-join (reverse res) "")
(let-values (((l c) (prefix str)))
(loop (substring str l)
(cons
(if (= l 1)
(~a c)
(~a c l))
res))))))
(rle "hellooo wooorldd")
"hel2o3 wo3rld2"
如何查找连续字符？比较列表中的第一个值和第二个值？这是我的主要问题。我似乎想不出一种方法来比较连续的字符。谢谢你的提示。@saurs我添加了一些额外的提示，让你开始学习。谢谢你的提示对我帮助很大！只有一个问题，我不允许使用
dropdropcdr