Calculadora
MatemáticasCalculadora Hexadecimal
Calculadora hex para programadores: AND/OR/XOR/NOT, desplazamientos y aritmética con ancho de bits 8/16/32/64 o BigInt, salida con signo en complemento a dos, hex/dec/binario.
¿Tienes comentarios? Reporta errores, sugiere funciones o comparte tus ideas — leemos todos¿Cómo Calcular Hexadecimal?
Hexadecimal (base-16) es un sistema numérico que utiliza 16 símbolos: 0-9 y A-F. Se usa comúnmente en programación de computadoras y sistemas digitales. Cada posición representa una potencia de 16.
Conversión de Hexadecimal a Decimal:
- Escribe el número hexadecimal
- Multiplica cada dígito por 16 elevado a la potencia de su posición (de derecha a izquierda, comenzando en 0)
- Suma todos los resultados
0xFF = 15×16¹ + 15×16⁰ = 240 + 15 = 255
Conversión de Decimal a Hexadecimal:
- Divide el número decimal entre 16
- Escribe el resto (convierte 10-15 a A-F)
- Continúa dividiendo el cociente entre 16 hasta que se convierta en 0
255 ÷ 16 = 15 remainder 15 → F
15 ÷ 16 = 0 remainder 15 → F
Result: 0xFF
Tabla de referencia hexadecimal
| Decimal | Hexadecimal | Binary |
|---|---|---|
| 0 | 0x0 | 0000 |
| 1 | 0x1 | 0001 |
| 10 | 0xA | 1010 |
| 15 | 0xF | 1111 |
| 16 | 0x10 | 10000 |
| 255 | 0xFF | 11111111 |
| 256 | 0x100 | 100000000 |
Sobre esta calculadora hexadecimal
Introduce dos números en cualquier combinación de bases — hex, decimal o binario — elige una operación y un ancho de bits, y la calculadora devuelve el resultado a la vez en hex, decimal sin signo, decimal con signo y binario. El núcleo de cálculo usa BigInt, así que en modo Arbitrario (BigInt) valores enormes como 0xFFFFFFFFFFFFFFFF funcionan sin pérdida de precisión (0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000). El selector de ancho de bits (8/16/32/64) hace que las operaciones bitwise (AND, OR, XOR, NOT, desplazamientos) den la vuelta dentro de un registro fijo igual que en C, Rust o Python con máscara: NOT 0xFF en 8 bits da 0x00, y los resultados negativos se muestran como hex en complemento a dos y como decimal con signo. Todo corre en tu navegador — no se sube nada.
Preguntas Frecuentes
Lee los dígitos hex de derecha a izquierda y multiplica cada uno por una potencia creciente de 16. Para 0xFF: F×16¹ + F×16⁰ = 15·16 + 15·1 = 240 + 15 = 255. Para algo más largo como 0x1A2B: 1·16³ + 10·16² + 2·16¹ + 11·16⁰ = 4096 + 2560 + 32 + 11 = 6699. La calculadora hace la conversión en un solo paso — elige 'Hex' como base de entrada y el decimal aparece debajo.
Divide repetidamente entre 16 y anota cada resto. Leyendo los restos de abajo a arriba obtienes el valor en hex, escribiendo 10–15 como A–F. Ejemplo para 255: 255 ÷ 16 = 15 resto 15 (F); 15 ÷ 16 = 0 resto 15 (F). De abajo a arriba: FF. Por tanto 255 = 0xFF. La calculadora convierte en cualquiera de las dos direcciones — elige la base origen en el desplegable y verás el resultado en las tres bases.
Las operaciones bitwise AND, OR, XOR actúan sobre la representación binaria de los operandos, bit a bit. 0xFF AND 0x0F: en binario 11111111 AND 00001111 = 00001111 = 0x0F (deja solo el nibble bajo). 0xA0 OR 0x0B: 10100000 OR 00001011 = 10101011 = 0xAB (combina bits). 0xFF XOR 0x0F: 11111111 XOR 00001111 = 11110000 = 0xF0 (invierte los bits donde el segundo operando tiene 1). Son los bloques básicos de la programación con máscaras de bits y los trucos sobre canales de color.
El desplazamiento a la izquierda en n mueve todos los bits n posiciones a la izquierda y rellena con ceros a la derecha — equivale a multiplicar por 2ⁿ. 0x0F << 4 = 0xF0 (un desplazamiento de un nibble). El desplazamiento a la derecha en n mueve los bits a la derecha y descarta lo que se sale — equivale a dividir entero por 2ⁿ. 0xFF >> 4 = 0x0F. Los desplazamientos sirven para empacar/desempacar canales RGB (red = (color >> 16) & 0xFF), leer formatos binarios y multiplicar o dividir rápido por potencias de dos.
Cada par hex codifica un valor 00–FF (0–255), que es la intensidad de un canal de color. #FF0000 es rojo puro (R=255, G=0, B=0); #00FF00 es verde puro; #FFFFFF es blanco. Tres bytes encajan exactamente en seis dígitos hex, por eso el formato es universal en CSS, herramientas de diseño y APIs gráficas. Usar hex en lugar de decimal mantiene cada canal visualmente distinto (#FF6347 vs rgb(255, 99, 71)) y vuelve trivial el bit-masking de cada canal.
No. 0x10 es dieciséis en hexadecimal — el prefijo '0x' indica al lector (y al compilador) que los dígitos están en base 16. Sin prefijo, 10 es diez en decimal. Los mismos dígitos pueden significar valores diferentes según la base: 10 en binario es 2, 10 en hex es 16, 10 en decimal es 10. El desplegable de base junto a cada número te permite indicarlo de forma explícita, así no hay ambigüedad sobre cómo se interpreta el valor.
Sí. Pon el desplegable de ancho de bits en Arbitrario (BigInt) y la aritmética no tiene límite de ancho: 0xFFFFFFFFFFFFFFFF + 1 = 0x10000000000000000 (17 dígitos hex), y puedes multiplicar o desplazar valores muy por encima de 256 bits sin pérdida de precisión. Si en cambio eliges un ancho fijo (8/16/32/64 bits), el resultado se enmascara a ese tamaño de registro y da la vuelta — justo lo que haría un uint8_t/uint32_t/uint64_t en C o Rust.
En una CPU real no hay un 'bit de signo' aparte — un valor negativo se guarda en complemento a dos dentro de un registro de ancho fijo, así que la respuesta depende del ancho de bits. Elige 8/16/32/64 bits y la herramienta enmascara el resultado a ese ancho: NOT 0xFF en 8 bits = 0x00, NOT 0x00 en 8 bits = 0xFF, y 5 − 10 en 32 bits muestra el hex sin signo 0xFFFFFFFB junto al decimal con signo −5. En modo Arbitrario (BigInt) no hay registro en el que dar la vuelta, por lo que NOT y la resta pueden mostrar un valor con un signo menos explícito en lugar de complemento a dos. El campo Decimal con signo siempre indica cómo se interpreta como entero con signo un resultado de ancho fijo.
Ajusta el ancho al registro o tipo que estés razonando: 8 bits para un byte o uint8_t, 16 bits para un short, 32 bits para un int típico, 64 bits para un long/puntero, o Arbitrario (BigInt) para cálculo exacto con números grandes sin vuelta. El desbordamiento por vuelta significa que un resultado que no cabe en el ancho elegido conserva solo los bits bajos: 0xFF + 1 en 8 bits = 0x00 (dio la vuelta de 255 a 0), y 0xFFFFFFFF + 1 en 32 bits = 0x00000000. Es el comportamiento del que dependen el firmware, los sistemas embebidos y la ingeniería inversa, y coincide con la aritmética entera de C/Rust y con Python usando una máscara & explícita.
Las direcciones de memoria se imprimen en hex (un puntero como 0x7fff5fbff7c0 es más fácil de leer que su forma decimal de 13 dígitos). Las banderas de bits y máscaras de permisos usan constantes hex (modos de archivo Unix como 0644, bits de bandera de registro como 0x80000000). Los hashes criptográficos y los UUID se muestran en hex. Los valores de color en CSS, los identificadores de assets en motores de juego, los opcodes en desensambladores y los códigos de error de Windows (0x80070005 'acceso denegado') son hex. Esta calculadora está pensada para el tipo de cálculos que se hacen al depurar o leer documentación sobre cualquiera de esos casos.
CALCULADORAS MATEMáTICAS32
WUTOOLS