send
Grupo de Telegram
play_arrow
Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

Conversor hexa, decimal y binario

  • 0 Respuestas
  • 1252 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5267
  • Actividad:
    48.33%
  • Reputación 26
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« en: Febrero 24, 2010, 04:06:32 pm »
Script que sirve de conversor entre esos 3 sistemas. Realmente este code es un caos, no tiene la claridad que suelen tener los codes de ruby pero de hecho funciona, y nos sirve para saber como se traduce matematicamente de un sistema a otro, y eso es bastante util.

Código: Ruby
  1.         print "\nConversor de los sistemas numericos Hexadecimal,Binario y Decimal\n"
  2.         print "c0ded by pRotos <protos.nu@gmail.com>\n\n"
  3.         def uso
  4.         print "Uso: numero <entrada> <salida>\n"
  5.         print "Inicio: Sistema numerico de entrada (hex, dec, o bi)\n"
  6.         print "Destino: Sistema numerico de salida (hex, dec o bi)\n"
  7.         print "Ejemplo: 1100101 bi hex\n(devolveria el valor en hexa de ese binario)\n"
  8. end
  9.  
  10. if ARGV[0] == nil
  11.  
  12.         uso()
  13. end
  14.  
  15. g=nil
  16. entrada=ARGV[1]
  17. salida=ARGV[2]
  18. numero=ARGV[0]
  19.  
  20. case entrada
  21.         when 'dec'
  22.         when 'bi'
  23.         when 'hex'
  24.         else
  25.                 g=1
  26.                 if ARGV != nil
  27.                         uso()
  28.                 end
  29.         end
  30.  
  31.  
  32. class Conv
  33.         def initialize(num, type)
  34.                 @num=num
  35.                 @type=type                     
  36.         end
  37.  
  38.         def to_bi
  39.                 if @type == 'bi'
  40.                         return @num, "b"
  41.                         elsif @type == 'hex'
  42.                                 num=@num.hex
  43.                                 res=Array.new
  44.                                 while num > 1
  45.                                         a=num%2
  46.                                         res.push(a)
  47.                                         num=num/2
  48.                                 end
  49.                                 res.push(1)
  50.                                 return res.reverse, "b"
  51.                                 elsif @type == 'dec'
  52.                                         res=Array.new
  53.                                         num=@num.to_i
  54.                                         while num > 1
  55.                                                 a=num%2
  56.                                                 res.push(a)
  57.                                                 num=num/2
  58.                                         end
  59.                                         res.push(1)
  60.                                         return res.reverse, "b"
  61.                                 end                                            
  62.  
  63.         end
  64.  
  65.         def to_dec
  66.                 if @type == 'bi'
  67.                         l=@num.length-1
  68.                         n=@num.split("")
  69.                         c=0
  70.                         b=Array.new
  71.                         while l >= 0
  72.                                 x=(n[c].to_i)*(2**l)
  73.                                 b.push(x)
  74.                                 c+=1
  75.                                 l-=1
  76.                         end
  77.                         z=0
  78.                         d=0
  79.                         until z == b.length
  80.                         d=d+b[z]
  81.                         z+=1
  82.                         end
  83.                 return d
  84.                         elsif @type == 'hex'
  85.                                 return @num.hex
  86.                                 elsif @type == 'dec'
  87.                                         return @num
  88.                 end
  89.  
  90.         end
  91.  
  92.         def to_hex
  93.                 if @type == 'hex'
  94.                         return @num, "h"
  95.                         elsif @type == 'dec'
  96.                                 num=@num.to_i
  97.                                 res=Array.new
  98.                                 n=num
  99.                                 if n < 16
  100.                                                 case n
  101.                                                         when 10
  102.                                                         n='A'
  103.  
  104.                                                         when 11
  105.                                                         n='B'
  106.  
  107.                                                         when 12
  108.                                                         n='C'
  109.  
  110.                                                         when 13
  111.                                                         n='D'
  112.  
  113.                                                         when 14
  114.                                                         n='E'
  115.  
  116.                                                         when 15
  117.                                                         n='F'
  118.                                                 end
  119.                                                 return n, "h"
  120.                                                 else
  121.                                 while num > 15
  122.                                         n=num%16
  123.                                         res.push(n)
  124.                                         num=num/16
  125.                                         if num < 16
  126.                                                 j=1
  127.                                                 case num
  128.                                                         when 10
  129.                                                         n='A'
  130.                                                         res.push(n)
  131.                                                         when 11
  132.                                                         n='B'
  133.                                                         res.push(n)
  134.                                                         when 12
  135.                                                         n='C'
  136.                                                         res.push(n)
  137.                                                         when 13
  138.                                                         n='D'
  139.                                                         res.push(n)
  140.                                                         when 14
  141.                                                         n='E'
  142.                                                         res.push(n)
  143.                                                         when 15
  144.                                                         n='F'
  145.                                                         res.push(n)
  146.                                                 end
  147.  
  148.  
  149.                                                 end
  150.                                         end
  151.                                         if j!=1
  152.                                         return "1", res, "h"
  153.                                         else
  154.                                                 return res.reverse, "h"
  155.                                                 end
  156.                                         end
  157.                                         elsif @type == 'bi'
  158.                                                 l=@num.length-1
  159.                                                 n=@num.split("")
  160.                                                 c=0
  161.                                                 b=Array.new
  162.                                                 while l >= 0
  163.                                                         x=(n[c].to_i)*(2**l)
  164.                                                         b.push(x)
  165.                                                         c+=1
  166.                                                         l-=1
  167.                                                 end
  168.                                                 z=0
  169.                                                 d=0
  170.                                                 until z == b.length
  171.                                                         d=d+b[z]
  172.                                                         z+=1
  173.                                                 end
  174.                                                 num=d
  175.                                 res=Array.new
  176.                                 n=num
  177.                                 if n < 16
  178.                                                 case n
  179.                                                         when 10
  180.                                                         n='A'
  181.  
  182.                                                         when 11
  183.                                                         n='B'
  184.  
  185.                                                         when 12
  186.                                                         n='C'
  187.  
  188.                                                         when 13
  189.                                                         n='D'
  190.  
  191.                                                         when 14
  192.                                                         n='E'
  193.  
  194.                                                         when 15
  195.                                                         n='F'
  196.                                                 end
  197.                                                 return n, "h"
  198.                                                 else
  199.  
  200.                                 while num > 15
  201.                                         n=num%16
  202.                                         res.push(n)
  203.                                         num=num/16
  204.                                         if num < 16
  205.                                                 j=1
  206.                                                 case num
  207.                                                         when 10
  208.                                                         n='A'
  209.                                                         res.push(n)
  210.                                                         when 11
  211.                                                         n='B'
  212.                                                         res.push(n)
  213.                                                         when 12
  214.                                                         n='C'
  215.                                                         res.push(n)
  216.                                                         when 13
  217.                                                         n='D'
  218.                                                         res.push(n)
  219.                                                         when 14
  220.                                                         n='E'
  221.                                                         res.push(n)
  222.                                                         when 15
  223.                                                         n='F'
  224.                                                         res.push(n)
  225.                                                 end
  226.  
  227.                                                 end
  228.                                         end
  229.                                 end
  230.                                         if j!=1
  231.                                         return "1", res, "h"
  232.                                         else
  233.                                                 return res.reverse, "h"
  234.                                                 end
  235.  
  236.                                         end
  237.  
  238.  
  239.  
  240.  
  241.  
  242.                         end
  243.  
  244. end
  245.  
  246. s=Conv.new(numero, entrada)
  247. case salida
  248.         when 'hex'
  249.         print s.to_hex, "\n\n"
  250.         when 'dec'
  251.         print s.to_dec, "\n\n"
  252.         when 'bi'
  253.         print s.to_bi, "\n\n"
  254.         else
  255.                 if ARGV != nil && g==nil
  256.  
  257.                         uso()
  258.                 end
  259. end
  260.  
  261. ###########pRUEBAS##########
  262. #a=Conv.new('04CF', 'hex')
  263. #b=Conv.new('3456', 'dec')
  264. #c=Conv.new('101100110010', 'bi')
  265. #print a.to_bi, "\n"
  266. #print b.to_bi, "\n"
  267. #print c.to_bi, "\n"
  268. #print a.to_dec, "\n"
  269. #print b.to_dec, "\n"
  270. #print c.to_dec, "\n"
  271. #print a.to_hex, "\n"
  272. #print b.to_hex, "\n"
  273. #print c.to_hex, "\n"
  274. ###########################
  275.  
« Última modificación: Julio 31, 2014, 09:45:30 pm por Expermicid »


 

¿Te gustó el post? COMPARTILO!



Convertidor de string a binario y viceversa

Iniciado por B3N

Respuestas: 0
Vistas: 1153
Último mensaje Junio 20, 2015, 10:33:08 pm
por B3N
[Ruby] Traductor de Decimal a Ascii / Ascii a Decimal

Iniciado por ANTRAX

Respuestas: 0
Vistas: 1333
Último mensaje Febrero 24, 2010, 04:16:38 pm
por ANTRAX