反转整数

Question

我正在尝试编写一个输入数字的函数，并以相反的顺序输出数字。

即：

输入 - ＆gt; 25 输出 - ＆gt; 52

输入 - ＆gt; 125 输出 - ＆gt; 521

我是lisp的新手，如果它在这里有用，那就是c ++中的工作函数

function.cpp

int revs(int rev, int n)
{
  if (n <= 0)
    return rev;

  return revs((rev * 10) + (n % 10), n/10);
}

我在Racket中写了如下：

(define (revs rev n)
  (if (<= n 0)
     rev
     (revs (+ (* rev 10) (modulo n 10)) (/ n 10))))

但是当我使用（revs 0 125）运行它时，我收到此错误：

modulo: contract violation
  expected: integer?
  given: 25/2
  argument position: 1st
  other arguments...:
   10

当然我在这里做错了，但我不确定我错过了什么。

Answer 1

除法运算符/不进行整数除法，而是一般除法，所以当你打电话时，例如(/ 25 2)，你得不到12或{{1}而是理性的13。我认为您需要quotient来代替文档所包含的内容：

25/2

     

返回procedure (quotient n m) → integer? n : integer? m : integer? 。例子：

(truncate (/ n m))

Answer 2

按字典顺序处理操作：

#lang racket
(define (lexicographic-reverse  x)
  (string->number
   (list->string
    (reverse
     (string->list
      (number->string x))))))

适用于任何Racket数字类型的作品[1]。

---

[编辑1]“工作，”我意识到，是依赖于上下文的，并且通过一些测试显示了操作的隐含假设。我天真的词典编纂方法会造成一堆负整数，例如： (lexicographic-reverse -47)会产生错误。

但是，如果我因为词典原因而不是数字原因而反转数字，那么获取错误而不是-74可能会更好，因为它说明了“反转数字”的定义是任意的。 47的反转也可能是-74和74，因为反转不是一个数学概念 - 即使它可能让我想起XOR排列。

如何通过特定的反转功能处理符号是任意的。

#lang racket

;; Reversing a number retains the sign
(define (arbitrary1  x) 
  (define (f n)
    (string->number
     (list->string
      (reverse
       (string->list
        (number->string n))))))
  (if (>= x 0)
      (f x)
      (- (f (abs x)))))

;; Reversing a number reverses the sign
(define (arbitrary2  x)
  (define (f n)
    (string->number
     (list->string
      (reverse
       (string->list
        (number->string n))))))
  (if (>= x 0)
      (- (f x))
      (f (abs x))))

同样的考虑延伸到了Racket的其他数字型符号;关于扭转精确，不精确，复杂的决定同样是任意的 - 例如什么是IEEE +inf.0或+nan.0的反面？

Answer 3

以下是我对此问题的解决方案

(define (reverseInt number)
  (define (loop number reversedNumber)
    (if (= number 0)
        reversedNumber
        (let ((lastDigit (modulo number 10)))
          (loop (/ (- number lastDigit) 10) (+ (* reversedNumber 10) lastDigit)))))
  (loop number 0))

每次我们将反转的数字乘以10并加上数字的最后一位数。

我希望这是有道理的。

Answer 4

R6RS版本（只需稍加努力即可与R7RS配合使用）

#!r6rs
(import (rnrs)
        (srfi :8))

(define (numeric-reverse n)
  (let loop ((acc 0) (n n))
    (if (zero? n)
        acc
        (receive (q r) (div-and-mod n 10)
          (loop (+ (* acc 10) r) q)))))

球拍实施：

#!racket
(require srfi/8)

(define (numeric-reverse n)
  (let loop ((acc 0) (n n))
    (if (zero? n)
        acc
        (receive (q r) (quotient/remainder n 10)
          (loop (+ (* acc 10) r) q)))))

Answer 5

通过递归，您可以执行以下操作：

#lang racket

(define (reverse-num n)
  (let f ([acc 0]
          [n n])
    (cond
      [(zero? n) acc]
      [else (f (+ (* acc 10) (modulo n 10)) (quotient n 10))])))