leetcode/7.reverse-integer.org

#+title: 7 Reverse Integer

* Subject

Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range \([-2^{31}, 2^{31} - 1]\), then return 0.

Assume the environment does not allow you to store 64-bit integers (signed or unsigned).

** Example 1:

Input: x = 123
Output: 321

** Example 2:

Input: x = -123
Output: -321

** Example 3:

Input: x = 120
Output: 21

** Constraints:

    -231 <= x <= 231 - 1

* Solution
#+name: lang
#+begin_src racket
#lang racket
#+end_src

#+RESULTS: lang

#+begin_src racket
#lang racket/base
(for/list ([i (in-naturals)]
           #:break (> i 10))
  i)
#+end_src

#+RESULTS:
| 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 |

#+name: ten-power-below
#+begin_src racket
(define/contract (ten-power-below x)
  (-> exact-integer? exact-integer?)
  (let ((power-of-ten 1))
    (for/list ([exponent (in-naturals)])
               #:break (> power-of-ten x)
               (set! power-of-ten (* 10 power-of-ten)))
    (/ power-of-ten 10)))
#+end_src

#+RESULTS: ten-power-below


#+begin_src racket :noweb yes
#lang racket
<<ten-power-below>>
(ten-power-below 11)
#+end_src

#+RESULTS:
: 10

#+begin_src racket :noweb yes
#lang racket
<<ten-power-below>>
(ten-power-below 100)
#+end_src

#+RESULTS:
: 100

#+begin_src racket :noweb yes
#lang racket
<<ten-power-below>>
(ten-power-below 1111)
#+end_src

#+RESULTS:
: 1000

#+begin_src racket :noweb yes
<<ten-power-below>>
(for/list ([i (list 1 100 271091029 (- 123001))])
  (ten-power-below i))
#+end_src

#+RESULTS:
| 1 | 100 | 1000000000 | 1 |

#+name: reverse
#+begin_src racket :noweb yes
<<ten-power-below>>
(define/contract (reverse x)
  (-> exact-integer? exact-integer?)
  (cond ((= x 0) 0)
        ((< x 0) (- (reverse (- x))))
        (#t (let* ((remains x)
               (previous remains)
               (number 0)
               (power-of-ten (ten-power-below x))
               (current-number-power-of-ten 1)
               (digit 0))
          (for/list ([i (in-naturals)]
                     #:break (< power-of-ten 1))
            (set! previous remains)
            (set! remains (modulo remains power-of-ten))
            (set! digit (/ (- previous remains) power-of-ten))
            (set! number (+ number (* digit current-number-power-of-ten)))
            (set! power-of-ten (/ power-of-ten 10))
            (set! current-number-power-of-ten (* current-number-power-of-ten 10))
            )
          number))))
#+end_src

#+RESULTS: reverse

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse 123)
#+end_src

#+RESULTS:
: 321

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse 21)
#+end_src

#+RESULTS:
: 12

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse -1)
#+end_src

#+RESULTS:
: -1

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse -124)
#+end_src

#+RESULTS:
: -421

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse 123456789012345678901234567890)
#+end_src

#+RESULTS:
: 98765432109876543210987654321

#+begin_src racket :noweb yes
#lang racket
<<reverse>>
(reverse 10)
#+end_src

#+RESULTS:
: 1

* Reference

https://leetcode.com/problems/reverse-integer/