Common Lisp：“字符串中没有非空白字符”

Question

对于Euler项目Problem 8，我被告知需要解析一个1000位的数字。 这是一个蛮力的Lisp解决方案，它基本上每隔5个连续的数字进行一次，并将它们从开始到结束相乘，并返回循环结尾的最大数字。

代码：

(defun pep8() 
    (labels ((product-of-5n (n) 
     (eval (append '(*) 
       (loop for x from n to (+ n 5) 
       collect (parse-integer 
       1000digits-str :start x :end (+ x 1))))))) 
    (let ((largestproduct 0)) 
     (do ((currentdigit 0 (1+ currentdigit))) 
      ((> currentdigit (- (length 1000digits-str) 6)) (return largestproduct)) 
     (when (> (product-of-5n currentdigit) largestproduct) 
      (setf largestproduct (product-of-5n currentdigit))))))) 

它编译没有任何警告，但在运行它，我得到：

no non-whitespace characters in string "73167176531330624919225119674426574742355349194934...". 
    [Condition of type SB-INT:SIMPLE-PARSE-ERROR] 

我检查，看看是否本地函数product-of-5n被写它的工作再作为全局函数：

(defun product-of-5n (n) 
    (eval (append '(*) 
     (loop for x from n to (+ n 5) 
      collect (parse-integer 
       1000digits-str :start x :end (+ x 1)))))) 

编译时没有警告和upo运行它似乎运行得很好。例如，

CL_USER>（产品的-5N 1）=> 882

由于第一5个位数为7,3，1,6和7

这似乎是正确的

至于1000digits-str，有人简单地用defvar编译并与Emacs的longlines-show-hard-newlines，我不认为有在字符串中的任何空白字符，因为这是SBCL抱怨，对不对？

Answer 1

我不认为有字符串中的任何空白字符，因为这是SBCL抱怨什么，对吧？

差错消息不抱怨存在的空白，但关于缺乏非空白。但它实际上有点误导：消息应该说的是，在特定的子字符串中没有非空白空间可以被解析。这是因为你跑掉了字符串的末尾，所以解析了零长度的子字符串。

另外，product-of-5n没有被定义为非常正确。只是偶尔(product-of-5n 1)返回前五位的乘积。字符串从0索引，所以(product-of-5n 1)开始于秒字符;并且函数从 + 0到n + 5迭代，其总共是六个字符;所以(product-of-5n 1)返回3×1×6×7×1×7，这恰好与7×3×1×6×7×1相同。

Answer 2

EVAL不是一个好主意。

您的循环上限是错误的。

否则，我试着用数字字符串，它的作品。

这也是欧拉8，不9

这是我的版本：

(defun euler8 (string) 
    (loop for (a b c d e) on (map 'list #'digit-char-p string) 
     while e maximize (* a b c d e))) 

Answer 3

由于我不知道常见的lisp，我稍作修改你的代码适合elisp。至于发现错误，除了已经说过的（(product-of-5n 1)应该返回126），我唯一的评论是在(pep8)，长度-4而不是-6（否则你松了最后2个字符）。对不起，我不知道如何解决您解析错误（我用string-to-number代替），但这里是在情况下，代码你觉得它有用：

(defun product-of-5n (n)  ;take 5 characters from a string "1000digits-str" starting with nth one and output their product 
    (let (ox)     ;define ox as a local variable 
    (eval      ;evaluate 
    (append '(*)    ;concatenate the multiplication sign to the list of 5 numbers (that are added next) 
     (dotimes (x 5 ox)  ;x goes from 0 to 4 (n is added later to make it go n to n+4), the output is stored in ox 
      (setq ox (cons  ;create a list of 5 numbers and store it in ox 
      (string-to-number 
       (substring 1000digits-str (+ x n) (+ (+ x n) 1)) ;get the (n+x)th character 
      )    ;end convert char to number 
      ox)    ;end cons 
      )     ;end setq 
      )     ;end dotimes, returns ox outside of do, ox has the list of 5 numbers in it 
     )      ;end append 
    )       ;end eval 
    )       ;end let 
) 

(defun pep8() ;print the highest 
    (let ((currentdigit 0) (largestproduct 0))     ;initialize local variables 
    (while (< currentdigit (- (length 1000digits-str) 4) ) ;while currentdigit (cd from now on) is less than l(str)-4 
     ;(print (cons "current digit" currentdigit))    ;uncomment to print cd 
     (when (> (product-of-5n currentdigit) largestproduct)  ;when current product is greater than previous largestproduct (lp) 
     (setq largestproduct (product-of-5n currentdigit))  ;save lp 
     (print (cons "next good cd" currentdigit))    ;print cd 
     (print (cons "with corresponding lp" largestproduct))  ;print lp 
    )               ;end when 
    (setq currentdigit (1+ currentdigit))      ;increment cd 
    )               ;end while 
    (print (cons "best ever lp" largestproduct))    ;print best ever lp 
    )               ;end let 
) 

(setq 1000digits-str "73167176531330624919") 
(product-of-5n 1) 
(pep9) 

当上了前20个字符跑返回（ ）

"73167176531330624919" 
126 

("next good cd" . 0) 
("with corresponding lp" . 882) 

("next good cd" . 3) 
("with corresponding lp" . 1764) 

("best ever lp" . 1764) 

Answer 4

我做了这个问题前一段时间， 和有一件事你缺少的问题 的描述。你需要为开始于任何偏移刺读取结果，不仅抵消整除5.因此，解决问题的方法会更喜欢以下内容：

(defun pe-8() 
    (do ((input (remove #\Newline 
"73167176531330624919225119674426574742355349194934 
96983520312774506326239578318016984801869478851843 
85861560789112949495459501737958331952853208805511 
12540698747158523863050715693290963295227443043557 
66896648950445244523161731856403098711121722383113 
62229893423380308135336276614282806444486645238749 
30358907296290491560440772390713810515859307960866 
70172427121883998797908792274921901699720888093776 
65727333001053367881220235421809751254540594752243 
52584907711670556013604839586446706324415722155397 
53697817977846174064955149290862569321978468622482 
83972241375657056057490261407972968652414535100474 
82166370484403199890008895243450658541227588666881 
16427171479924442928230863465674813919123162824586 
17866458359124566529476545682848912883142607690042 
24219022671055626321111109370544217506941658960408 
07198403850962455444362981230987879927244284909188 
84580156166097919133875499200524063689912560717606 
05886116467109405077541002256983155200055935729725 
71636269561882670428252483600823257530420752963450")) 
     (tries 0 (1+ tries)) 
     (result 0)) 
     ((= tries 5) result) 
    (setq result 
      (max result 
       (do ((max 0) 
        (i 0 (+ 5 i))) 
        ((= i (length input)) max) 
       (setq max 
         (do ((j i (1+ j)) 
          (current 1) 
          int-char) 
          ((= j (+ 5 i)) (max current max)) 
         (setq int-char (- (char-code (aref input j)) 48)) 
         (case int-char 
          (0 (return max)) 
          (1) 
          (t (setq current (* current int-char)))))))) 
      input (concatenate 'string (subseq input 1) (subseq input 0 1))))) 

这是一点点丑陋，但它说明了这个想法。

编辑对不起，我混淆了你的两个函数。所以这样做是不正确的。