Topic: -= {Challenge} =- convert an hexadecimal into a decimal

[ElpanovEvgeniy]

suggesting a new challenge
need to transfer a number from hexadecimal to decimal format.
The difficulty is that the resulting decimal number may be greater than 2147483647

example:

Code: [Select]

(hex2dec "7ffffcf5c20") ;=>>      "8796089834528"
(hex2dec "1234567890abcdef") ;=>> "1311768467294899695"
(hex2dec "fedcba0987654321") ;=>> "18364757930599072545"
(hex2dec "111111111111") ;=>>     "18764998447377"
(hex2dec "ffffffffffff") ;=>>     "281474976710655"

[ElpanovEvgeniy]

Sorry, I found a bug in my code, changed answers in the test examples!

[gile]

Hi,

I have a solution, but it doesn't display good results for very big numbers.

Code: [Select]

(defun hex2dec (hex / r c)
  (setq r 0.)
  (foreach c (vl-string->list (strcase hex))
    (setq r (+
      (* 16. r)
      (-
c
(if (<= c 57)
  48.
  55.
)
      )
    )
    )
  )
  (rtos r 2 0)
)

_$ (hex2dec "7ffffcf5c20")
"8796089834528"
_$ (hex2dec "111111111111")
"18764998447377"
_$ (hex2dec "ffffffffffff")
"281474976710655"

but:

_$ (hex2dec "1234567890abcdef")
"1E+18"
_$ (hex2dec "fedcba0987654321")
"2E+19"

[Lee Mac]

Code: [Select]

(defun hex2dec ( n )
    (defun _ascii2int ( x )
        (- x (if (< x 58) 48.0 55.0))
    )
    (defun _hex2dec ( l )
        (if l (+ (* 16.0 (_hex2dec (cdr l))) (_ascii2int (car l))) 0)
    )
    (defun _dec2str ( n x / d )
        (if (< 0 n)
            (progn
                (setq d (rem (/ n x) 1))
                (strcat (_dec2str (- n (* x d)) (* x 10.0)) (rtos (* 10 d) 2 0))
            )
            ""
        )
    )
    (_dec2str (_hex2dec (reverse (vl-string->list (strcase n)))) 10.0)
)

Code: [Select]

(hex2dec "7ffffcf5c20") ;=>>      "8796089834528"
(hex2dec "1234567890abcdef") ;=>> "1311768467294899800"
(hex2dec "fedcba0987654321") ;=>> "18364757930599073000"
(hex2dec "111111111111") ;=>>     "18764998447377"
(hex2dec "ffffffffffff") ;=>>     "281474976710655"
 

[ElpanovEvgeniy]

Hi gile!
You left quite a bit.

[ElpanovEvgeniy]

Hi Lee Mac!
In your code has a bug.
See if you have
(hex2dec "1234567890abcdef"); =>> "1311768467294899800"
must
(hex2dec "1234567890abcdef"); =>> "1311768467294899695"

[ElpanovEvgeniy]

An example of how to check the code if the number is not great ...

[David Bethel]

I hit the same stumbling block:

Code: [Select]


(defun hex2dec (s / e c l)
;;;SINGLE HEX STRING 0-F to Decimal Conversion
(defun hex2dec1 (s / n)
 (setq n (ascii (strcase s)))
 (- n (if (> n 57) 55 48)))

  (setq e 0
        s (strcase s))
  (while (> (strlen s) 0)
         (setq c (substr s (strlen s) 1)
               s (substr s 1 (1- (strlen s)))
               l (cons (* (hex2dec1 c) (expt 2 e)) l)
               e (+ e 4)))
(apply '+ l))

Anything bigger than (expt 2 30) gives bad results.  -David

[ElpanovEvgeniy]

I hit the same stumbling block:

source of the problem:

Code: [Select]

(1+ 2147483647) = -2147483648

[JohnK]

The number 2147483647 is the largest value you can have for a signed int. In C++ you would have to use an unsigned int which would allow you to have an int with a value of 4294967295.

Code: [Select]

(defun bin? (nu / lst nu)
  (while (not (= nu 0))
         (setq lst (cons (rem nu 2) lst)
               nu (/ nu 2)))
  lst
 )

Command: (bin? 2147483647)
(1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1)

Command: (length (bin? 2147483647))
31

[ElpanovEvgeniy]

The number 2147483647 is the largest value you can have for a signed int. In C++ you would have to use an unsigned int which would allow you to have an int with a value of 4294967295.

but that does not stop to consider list or texts, for the storage of any size integer 

[JohnK]

but that does not stop to consider list or texts, for the storage of any size integer 

That is what I would do too.

[gile]

This is much easier with F# wich has a BigInterger type.

Code: [Select]

let hex2dec (hex : string) =
    let rec foo chrs result =
        match chrs with
        | [] -> result
        | h :: t -> foo t (16I * result + h - (if h <= 57I then 48I else 55I))
    string (foo (hex.ToUpper() |> Seq.toList |> List.map (fun c -> bigint(int c))) 0I)

Code: [Select]

> hex2dec "7ffffcf5c20" ;;
val it : string = "8796089834528"
> hex2dec "1234567890abcdef" ;;
val it : string = "1311768467294899695"
> hex2dec "fedcba0987654321" ;;
val it : string = "18364757930599072545"
> hex2dec "111111111111" ;;
val it : string = "18764998447377"
> hex2dec "ffffffffffff" ;;
val it : string = "281474976710655"

[ElpanovEvgeniy]

This is much easier with F# wich has a BigInterger type.

This is a good way, if you know F # and agree to include it in your project.
My path was through the lisp ... 

[JohnK]

Idea for calculating the list or string length:
(0 . 31) = 2147483647 = 31
(1 . 1) =  2147483648 = 32
(1 . 2) =  2147483649 = 32
...

or something like that.