Enunciado

Dada la siguiente cadena de memoria de una arquitectura IBM que se
encuentra entre las direcciones 35|16 y 3A|16 inclusive
			CADENA DE NUMEROS = 330100021001022120221303|4

Resolucion

A) Indicar en que base se encuentra el numero

I) Cuento la cantidad de digitos que tiene el numero
		cant = 24 digitos

II) Cuento la cantidad de celdas que hay
		3A - 35 = 6 celdas

III) Busco los bits que ocupan la celda y la cantidad de digitos
		1 celda -------------------- 8 bits
    6 celdas ------------------- X = 48 bits

	  24 digitos ----------------- 48 bit (lo de arriba)
    1  digito  ----------------- n = 2

IV) Aplicamos lo de la base
		2^n = base
		2^(2) = 4

V) Obtenemos el resultado final
	 la base del numero es 4

B) Obtener el empaquetado de longitud maxima

I) Analizamos que es lo que nos pide
		En este caso nos pide que este en la mayor base posible que es B = 16

II) Paso la cadena a base 16 usando regla de la potencia
		16 = 4^2
		x = 2

	  33 01 00 02 10 01 02 21 20 22 13 03|4 ..... |16
		F  1  0  2  4  1  2  9  8  A  7  3 |16
 
III) Analizamos la validez de lo obtenido
		F1      02       41       29      8A      73
		1 byte  2 byte   3 byte   4 byte  5 byte  6 byte
		
		vemos que nos piden un empaquetado máximo, y que a su vez
    tiene que ser válido para el formato, lo que tenemos no es válido
	  ya que recordemos que tiene que ser nn nn nn nk signo siendo
    n un numero del 0 al 9, y k una letra que indique el signo
    (A,B,C,D,E,F)
  
	
	  una opcion "válida" que se nos podria ocurrir es 
    1       02       41       29      8A      73
		1 byte  2 byte   3 byte   4 byte  5 byte  6 byte
    pero esto no es válido, puesto que tenemos medio nibble
    y el formato tiene que terminar en una letra válida, con lo cual
    la unica opcion válida que nos queda es

 IV) Escribimos el resultado
    02       41       29       8A  EMPAQUETADO de 4 bytes
    1 byte   2 byte   3 byte   4 byte
    

C) Almacenar el numero hallado en b como binario de punto flotante IEEE 754 de precision simple

I) Hallo el numero que tengo en el formato empaquetado
		02       41       29       8A  |16 EMPAQUETADO de 4 bytes
    1 byte   2 byte   3 byte   4 byte
    
		nos queda
    +241298 |10

II) Paso el numero a binario que es la base del formato BPF IEEE 754
		
    241298 |10 ... |2
    lo paso a una base pivote |16
		241298 |10 ... |16 
    uso divisiones sucesivas y nos queda
    3AE92|16  

    luego, uso la propiedad de la potencia para pasarlo a |2
		3AE92|16  .... |2
		16 = 2^x con x = 4

    3      A      E      9      2
    0011   1010   1110   1001   0010 |2

III) Veo el signo
    signo = 0

IV) Normalizo el numero
		1,11010111010010010 * 2^17

V) Busco el EEX (Exponente En Exceso) y chqueo que tenga 8 bits
	 Exp = 17|10
   EEX = 127|10 + Exp
   EEX = 127|10 + 17|10
   EEX = 144|10 ... |2 (usando la base 16 como pivote
                        y luego la propiedad de la potencia como hice
                        en el II) )
   EEX = 10010000 tiene 8 bits

V) Escribo la mantisa
		M = 1,11010111010010010 
	  (recordando que el primer digito no se almacena)
    ( y que tiene que tener 23 bits en precision simple)

VI) Almaceno el numero
	Signo (1 bit) EEX (8 bits) Mantisa (23 bits)
	0             10010000     11010111010010010000000 |2
  
  Completo la mantisa con 0 a la derecha para que tenga 23 bits.

VII) Escibo el resultado
    01001000011010111010010010000000|2