Lambda 计算列表中字母的出现次数

到目前为止，我已经尝试过这个，但我得到了1：

(define occur
  (lambda (a s)
    (count (curry string-contains? a) s)))

例如：

（出现“u”（“u”uaub“ubub”）

=>1

应该是5点

想避免使用咖喱，因为我还不知道它是如何工作的： 什么是

（字符串包含？/abc“b”）

什么是

（字符串包含？“b”“abc”）

？

什么是

（字符串包含？“abc”“b”）

---

什么是

（字符串包含？“b”“abc”）

？

字符串包含的语法是：

(string-contains? haystack needle)

这意味着您在调用时使用了错误的参数

(curry string-contains? a)

这用

haystack

标识

a

：要搜索的字符串，而不是要搜索的字符串

curry

返回一个单参数函数，该函数接受

指针

参数，并搜索它是否出现在

a

中。而你想要的是另一种方式

幸运的是，Racket为您提供了解决方案：只需将字母

r

添加到

curry

符号中：改用

curryr

函数，该函数绑定最右边的参数，并保留左边的自由：

(curryr string-contains? a)

这将使

a

与

needle

参数一致（可以在较大的

haystack

中找到），返回一个接受

haystack

参数的函数

然后，将此函数应用于列表的每个元素，并计算它返回true的次数

cons

功能上的

curry

与

curryr

对比说明：

(map (curry cons 'a) '(1 2 3)) -> ((a . 1) (a . 2) (a . 3))
(map (curryr cons 'd) '(1 2 3)) -> ((1 . d) (2 . d) (3 . d))

（curry cons'a）

有效地为我们提供了函数

（lambda（arg）（cons'a arg））

（curryr cons'd）

有效地为我们提供了函数

（lambda（arg）（cons arg'd））

---

部分应用程序和咖喱可以可视化为一种糖，可以理解为对显式且更详细的

lambda

语法的转换。如果您对某些常见情况感到困惑，这可能会不时有所帮助。

字符串的语法包含？是：

(string-contains? haystack needle)

这意味着您在调用时使用了错误的参数

(curry string-contains? a)

这用

haystack

标识

a

：要搜索的字符串，而不是要搜索的字符串

curry

返回一个单参数函数，该函数接受

指针

参数，并搜索它是否出现在

a

中。而你想要的是另一种方式

幸运的是，Racket为您提供了解决方案：只需将字母

r

添加到

curry

符号中：改用

curryr

函数，该函数绑定最右边的参数，并保留左边的自由：

(curryr string-contains? a)

这将使

a

与

needle

参数一致（可以在较大的

haystack

中找到），返回一个接受

haystack

参数的函数

然后，将此函数应用于列表的每个元素，并计算它返回true的次数

cons

功能上的

curry

与

curryr

对比说明：

(map (curry cons 'a) '(1 2 3)) -> ((a . 1) (a . 2) (a . 3))
(map (curryr cons 'd) '(1 2 3)) -> ((1 . d) (2 . d) (3 . d))

（curry cons'a）

有效地为我们提供了函数

（lambda（arg）（cons'a arg））

（curryr cons'd）

有效地为我们提供了函数

（lambda（arg）（cons arg'd））

---

部分应用程序和咖喱可以可视化为一种糖，可以理解为对显式且更详细的

lambda

语法的转换。如果您对当前的一些情况感到困惑，这可能会不时有所帮助。

这会降低字符串联接的reduce

(define (how-many items char)
  (define r (regexp (format "[^~a]" char)))
  (string-length (regexp-replace* r (string-join items) "")))

; call it with (how-many '("u" "uaub" "ubub") #\u)

但是，如果不想一次将所有字符串塞入一起，可以对单个结果求和

(define (how-many items char)
  (define r (regexp (format "[^~a]" char)))
  (for/sum ((text (in-list items)))
    (string-length (regexp-replace* r text ""))))

---

这将删除字符串联接的reduce

(define (how-many items char)
  (define r (regexp (format "[^~a]" char)))
  (string-length (regexp-replace* r (string-join items) "")))

; call it with (how-many '("u" "uaub" "ubub") #\u)

但是，如果不想一次将所有字符串塞入一起，可以对单个结果求和

(define (how-many items char)
  (define r (regexp (format "[^~a]" char)))
  (for/sum ((text (in-list items)))
    (string-length (regexp-replace* r text ""))))

---

以下循环也可用于计算发生次数。它使用

count

函数查找从字符串获取的列表中出现的内容：

(define (occur c l)
  (let loop ((l l)
             (n 0))
    (cond
      [(empty? l) n]
      [else (loop (rest l)
                  (+ n
                     (count (lambda(x) (equal? x c))
                            (string->list (first l)))))])))

请注意，“u”将作为字符发送

测试：

(occur #\u '("u" "uaub" "ubub"))

输出：

5

---

以下循环也可用于计算发生次数。它使用

count

函数查找从字符串获取的列表中出现的内容：

(define (occur c l)
  (let loop ((l l)
             (n 0))
    (cond
      [(empty? l) n]
      [else (loop (rest l)
                  (+ n
                     (count (lambda(x) (equal? x c))
                            (string->list (first l)))))])))

请注意，“u”将作为字符发送

测试：

(occur #\u '("u" "uaub" "ubub"))

输出：

5

---

T和F，因为“abc”不包含在“b”中？T和F，因为“abc”不包含在“b”中？谢谢！我想我现在懂咖喱了。谢谢！我想我现在懂咖喱了。

“[^~a]”

匹配什么？格式首先使用“[^~a]”来生成字母#\u的字符串“[^u]”。带方括号的正则表达式部分表示一组字符，^插入符号表示不在方括号的上下文中，因此最后会出现“任何非“u”字符”。这些非u字符将替换为空字符串。

“[^~A]”“

匹配什么？format首先使用“[^~A]”生成字符串“[^u]”在字母#\u的情况下。带括号的正则表达式部分表示一组字符，^插入符号表示不在括号的上下文中，因此最后会出现“任何不是“u”的字符”。这些非u字符将替换为空字符串。