Complete Guide to Binary and Hexadecimal Conversion: Encoding and Bit Manipulation

// Convert string to binary
function stringToBinary(str) {
  return str.split('')
    .map(char => char.charCodeAt(0).toString(2).padStart(8, '0'))
    .join(' ');
}

console.log(stringToBinary("Hello"));
// "01001000 01100101 01101100 01101100 01101111"

// Without spaces
function stringToBinaryCompact(str) {
  return str.split('')
    .map(char => char.charCodeAt(0).toString(2).padStart(8, '0'))
    .join('');
}

// Python version
"""
def string_to_binary(s):
    return ' '.join(format(ord(c), '08b') for c in s)

print(string_to_binary("Hello"))
# "01001000 01100101 01101100 01101100 01101111"
"""

// Binary with various formatting options
function formatBinary(binary, options = {}) {
  const {
    groupSize = 8,
    separator = ' ',
    prefix = '',
    showAddress = false
  } = options;

  // Remove existing separators
  const clean = binary.replace(/\s/g, '');

  // Group bits
  const groups = [];
  for (let i = 0; i < clean.length; i += groupSize) {
    groups.push(clean.slice(i, i + groupSize).padEnd(groupSize, '0'));
  }

  // Add prefix if requested
  const formatted = groups.map(g => prefix + g).join(separator);

  // Add address/offset if requested
  if (showAddress) {
    return groups.map((g, i) => {
      const addr = (i * groupSize / 8).toString(16).padStart(4, '0');
      return `${addr}: ${prefix}${g}`;
    }).join('\n');
  }

  return formatted;
}

const binary = "010010000110010101101100011011000110111100100001";

console.log(formatBinary(binary));
// "01001000 01100101 01101100 01101100 01101111 00100001"

console.log(formatBinary(binary, { groupSize: 4, separator: '-', prefix: '0b' }));
// "0b0100-0b1000-0b0110-0b0101..."

console.log(formatBinary(binary, { showAddress: true }));
// "0000: 01001000\n0001: 01100101..."

// UTF-8 encoding to binary
function utf8ToBinary(str) {
  const encoder = new TextEncoder();
  const bytes = encoder.encode(str);

  return Array.from(bytes)
    .map(byte => byte.toString(2).padStart(8, '0'))
    .join(' ');
}

// ASCII character (1 byte)
console.log(utf8ToBinary("A"));
// "01000001"

// Unicode character (multi-byte)
console.log(utf8ToBinary("€"));
// "11100010 10000010 10101100" (3 bytes for Euro symbol)

console.log(utf8ToBinary("👋"));
// "11110000 10011111 10010001 10001011" (4 bytes for emoji)

// Node.js version
"""
const buffer = Buffer.from("Hello", 'utf8');
const binary = Array.from(buffer)
  .map(b => b.toString(2).padStart(8, '0'))
  .join(' ');
"""

// Convert binary to string
function binaryToString(binary) {
  // Remove spaces and split into 8-bit chunks
  const clean = binary.replace(/\s/g, '');
  const bytes = clean.match(/.{1,8}/g) || [];

  return bytes
    .map(byte => String.fromCharCode(parseInt(byte, 2)))
    .join('');
}

const binary = "01001000 01100101 01101100 01101100 01101111";
console.log(binaryToString(binary));
// "Hello"

// Handle different bit groupings
function binaryToStringFlexible(binary, bitsPerChar = 8) {
  const clean = binary.replace(/\s/g, '');
  const regex = new RegExp(`.{1,${bitsPerChar}}`, 'g');
  const chunks = clean.match(regex) || [];

  return chunks
    .map(chunk => String.fromCharCode(parseInt(chunk, 2)))
    .join('');
}

// Python version
"""
def binary_to_string(binary):
    binary = binary.replace(' ', '')
    chars = [binary[i:i+8] for i in range(0, len(binary), 8)]
    return ''.join(chr(int(char, 2)) for char in chars)
"""

// Handle different encodings
function binaryToStringUTF8(binary) {
  // Remove spaces
  const clean = binary.replace(/\s/g, '');

  // Convert to byte array
  const bytes = [];
  for (let i = 0; i < clean.length; i += 8) {
    const byte = clean.slice(i, i + 8);
    bytes.push(parseInt(byte, 2));
  }

  // Decode UTF-8
  const decoder = new TextDecoder('utf-8');
  const uint8Array = new Uint8Array(bytes);
  return decoder.decode(uint8Array);
}

// Multi-byte UTF-8 character
const euroBinary = "11100010 10000010 10101100";
console.log(binaryToStringUTF8(euroBinary));
// "€"

// Emoji
const emojiBinary = "11110000 10011111 10010001 10001011";
console.log(binaryToStringUTF8(emojiBinary));
// "👋"

// Node.js Buffer approach
function binaryToStringNode(binary) {
  const bytes = binary.replace(/\s/g, '')
    .match(/.{1,8}/g)
    .map(b => parseInt(b, 2));

  return Buffer.from(bytes).toString('utf8');
}

// Error handling for binary conversion
function safeBinaryToString(binary) {
  try {
    // Validate input
    if (!binary || typeof binary !== 'string') {
      throw new Error('Input must be a non-empty string');
    }

    // Remove spaces and validate characters
    const clean = binary.replace(/\s/g, '');
    if (!/^[01]+$/.test(clean)) {
      throw new Error('Invalid binary string: must contain only 0 and 1');
    }

    // Check if divisible by 8
    if (clean.length % 8 !== 0) {
      throw new Error(`Invalid length: ${clean.length} bits (must be multiple of 8)`);
    }

    // Convert
    const bytes = clean.match(/.{8}/g);
    return bytes.map(b => String.fromCharCode(parseInt(b, 2))).join('');

  } catch (error) {
    return {
      success: false,
      error: error.message,
      input: binary
    };
  }
}

// Test cases
console.log(safeBinaryToString("01001000"));  // "H"
console.log(safeBinaryToString("0100100"));   // Error: length
console.log(safeBinaryToString("0120100"));   // Error: invalid char
console.log(safeBinaryToString(null));        // Error: invalid input

// Convert string to hexadecimal
function stringToHex(str) {
  return str.split('')
    .map(char => char.charCodeAt(0).toString(16).padStart(2, '0'))
    .join('');
}

console.log(stringToHex("Hello"));
// "48656c6c6f"

// With separators
function stringToHexFormatted(str, separator = ' ') {
  return str.split('')
    .map(char => char.charCodeAt(0).toString(16).padStart(2, '0'))
    .join(separator);
}

console.log(stringToHexFormatted("Hello", ' '));
// "48 65 6c 6c 6f"

console.log(stringToHexFormatted("Hello", ':'));
// "48:65:6c:6c:6f"

// Python version
"""
def string_to_hex(s):
    return s.encode('utf-8').hex()

print(string_to_hex("Hello"))
# "48656c6c6f"

# With separator
print(':'.join(format(ord(c), '02x') for c in "Hello"))
# "48:65:6c:6c:6f"
"""

// Hexadecimal with various formats
function formatHex(hex, options = {}) {
  const {
    uppercase = false,
    prefix = '',
    separator = '',
    groupSize = 2,
    bytesPerLine = 16
  } = options;

  // Remove existing separators
  let clean = hex.replace(/[^0-9a-fA-F]/g, '');

  // Apply case
  clean = uppercase ? clean.toUpperCase() : clean.toLowerCase();

  // Group by size
  const groups = [];
  for (let i = 0; i < clean.length; i += groupSize) {
    const group = clean.slice(i, i + groupSize);
    groups.push(prefix + group);
  }

  // Add separators
  if (bytesPerLine && groupSize === 2) {
    const lines = [];
    for (let i = 0; i < groups.length; i += bytesPerLine) {
      const line = groups.slice(i, i + bytesPerLine).join(separator);
      const offset = i.toString(16).padStart(4, '0');
      lines.push(`${offset}: ${line}`);
    }
    return lines.join('\n');
  }

  return groups.join(separator);
}

const hex = "48656c6c6f20576f726c6421";

console.log(formatHex(hex, { uppercase: true, separator: ' ' }));
// "48 65 6C 6C 6F 20 57 6F 72 6C 64 21"

console.log(formatHex(hex, { prefix: '0x', separator: ', ' }));
// "0x48, 0x65, 0x6c, 0x6c, 0x6f..."

console.log(formatHex(hex, { bytesPerLine: 8 }));
// "0000: 48656c6c6f20576f\n0008: 726c6421"

// Unicode to hex (UTF-8 encoding)
function unicodeToHex(str) {
  const encoder = new TextEncoder();
  const bytes = encoder.encode(str);
  return Array.from(bytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');
}

console.log(unicodeToHex("Hello"));
// "48656c6c6f"

console.log(unicodeToHex("Hello 👋"));
// "48656c6c6f20f09f918b"

console.log(unicodeToHex("€"));
// "e282ac" (3 bytes in UTF-8)

// Code point to hex
function codePointToHex(str) {
  return Array.from(str)
    .map(char => {
      const code = char.codePointAt(0);
      return 'U+' + code.toString(16).toUpperCase().padStart(4, '0');
    })
    .join(' ');
}

console.log(codePointToHex("Hello 👋"));
// "U+0048 U+0065 U+006C U+006C U+006F U+0020 U+1F44B"

// Convert hex to string
function hexToString(hex) {
  // Remove spaces and 0x prefixes
  const clean = hex.replace(/[\s0x]/g, '');

  // Convert pairs to characters
  const pairs = clean.match(/.{1,2}/g) || [];
  return pairs
    .map(pair => String.fromCharCode(parseInt(pair, 16)))
    .join('');
}

console.log(hexToString("48656c6c6f"));
// "Hello"

console.log(hexToString("48 65 6c 6c 6f"));
// "Hello"

console.log(hexToString("0x48 0x65 0x6c 0x6c 0x6f"));
// "Hello"

// Python version
"""
def hex_to_string(hex_str):
    hex_str = hex_str.replace(' ', '').replace('0x', '')
    return bytes.fromhex(hex_str).decode('utf-8')

print(hex_to_string("48656c6c6f"))
# "Hello"
"""

// Handle various hex input formats
function parseHex(input) {
  // Remove common separators and prefixes
  return input
    .replace(/0x/gi, '')    // Remove 0x prefix
    .replace(/\\x/g, '')   // Remove \x prefix
    .replace(/[:\s-]/g, '')  // Remove separators
    .toLowerCase();
}

// Test various formats
const formats = [
  "48656c6c6f",
  "48 65 6c 6c 6f",
  "48:65:6c:6c:6f",
  "0x48 0x65 0x6c 0x6c 0x6f",
  "\x48\x65\x6c\x6c\x6f",
  "48-65-6c-6c-6f"
];

formats.forEach(format => {
  const clean = parseHex(format);
  const result = hexToString(clean);
  console.log(`"${format}" => "${result}"`);
});
// All output "Hello"

// Validate hex string
function isValidHex(str) {
  const clean = parseHex(str);
  return /^[0-9a-f]*$/i.test(clean) && clean.length % 2 === 0;
}

// Hex to UTF-8 string
function hexToUTF8(hex) {
  const clean = parseHex(hex);
  const bytes = [];

  for (let i = 0; i < clean.length; i += 2) {
    bytes.push(parseInt(clean.slice(i, i + 2), 16));
  }

  const decoder = new TextDecoder('utf-8');
  return decoder.decode(new Uint8Array(bytes));
}

// ASCII text
console.log(hexToUTF8("48656c6c6f"));
// "Hello"

// Unicode characters
console.log(hexToUTF8("e282ac"));
// "€"

console.log(hexToUTF8("f09f918b"));
// "👋"

// Mixed content
console.log(hexToUTF8("48656c6c6f20f09f918b"));
// "Hello 👋"

// Node.js version
function hexToUTF8Node(hex) {
  const clean = parseHex(hex);
  return Buffer.from(clean, 'hex').toString('utf8');
}

// Validate and safely decode hex
function safeHexToString(hex) {
  try {
    // Clean input
    const clean = parseHex(hex);

    // Validate
    if (!clean) {
      throw new Error('Empty hex string');
    }

    if (!/^[0-9a-f]*$/i.test(clean)) {
      throw new Error('Invalid hex characters');
    }

    if (clean.length % 2 !== 0) {
      throw new Error('Hex string must have even length');
    }

    // Convert
    const bytes = [];
    for (let i = 0; i < clean.length; i += 2) {
      bytes.push(parseInt(clean.slice(i, i + 2), 16));
    }

    // Decode
    const decoder = new TextDecoder('utf-8', { fatal: true });
    return decoder.decode(new Uint8Array(bytes));

  } catch (error) {
    return {
      success: false,
      error: error.message,
      input: hex
    };
  }
}

// Test cases
console.log(safeHexToString("48656c6c6f"));     // "Hello"
console.log(safeHexToString("48656c6c6"));      // Error: odd length
console.log(safeHexToString("xyz"));            // Error: invalid chars
console.log(safeHexToString(""));               // Error: empty

// Bitwise operators in JavaScript

// AND (&) - Both bits must be 1
console.log(5 & 3);  // 1
// 0101 & 0011 = 0001

// OR (|) - At least one bit must be 1
console.log(5 | 3);  // 7
// 0101 | 0011 = 0111

// XOR (^) - Bits must be different
console.log(5 ^ 3);  // 6
// 0101 ^ 0011 = 0110

// NOT (~) - Inverts all bits
console.log(~5);  // -6
// ~0101 = 1010 (in two's complement)

// Left shift (<<) - Shift bits left, fill with 0
console.log(5 << 1);  // 10
// 0101 << 1 = 1010

// Right shift (>>) - Shift bits right, preserve sign
console.log(5 >> 1);  // 2
// 0101 >> 1 = 0010

// Unsigned right shift (>>>) - Shift right, fill with 0
console.log(-5 >>> 1);
// Treats as unsigned 32-bit integer

// Common bit manipulation techniques

// Check if bit is set
function isBitSet(num, position) {
  return (num & (1 << position)) !== 0;
}

console.log(isBitSet(5, 0));  // true  (0101, bit 0 is 1)
console.log(isBitSet(5, 1));  // false (0101, bit 1 is 0)

// Set a bit
function setBit(num, position) {
  return num | (1 << position);
}

console.log(setBit(5, 1));  // 7 (0101 -> 0111)

// Clear a bit
function clearBit(num, position) {
  return num & ~(1 << position);
}

console.log(clearBit(5, 0));  // 4 (0101 -> 0100)

// Toggle a bit
function toggleBit(num, position) {
  return num ^ (1 << position);
}

console.log(toggleBit(5, 1));  // 7 (0101 -> 0111)
console.log(toggleBit(5, 0));  // 4 (0101 -> 0100)

// Count set bits (population count)
function countSetBits(num) {
  let count = 0;
  while (num) {
    count += num & 1;
    num >>>= 1;
  }
  return count;
}

console.log(countSetBits(5));  // 2 (0101 has two 1s)

// Check if power of 2
function isPowerOf2(num) {
  return num > 0 && (num & (num - 1)) === 0;
}

console.log(isPowerOf2(8));   // true
console.log(isPowerOf2(10));  // false

// Swap two numbers without temp variable
let a = 5, b = 3;
a = a ^ b;
b = a ^ b;
a = a ^ b;
console.log(a, b);  // 3, 5

// Using bit flags for permissions/features

// Define flags (powers of 2)
const FLAGS = {
  READ:    1 << 0,  // 0001 = 1
  WRITE:   1 << 1,  // 0010 = 2
  EXECUTE: 1 << 2,  // 0100 = 4
  DELETE:  1 << 3   // 1000 = 8
};

class Permissions {
  constructor(flags = 0) {
    this.flags = flags;
  }

  // Grant permission
  grant(flag) {
    this.flags |= flag;
  }

  // Revoke permission
  revoke(flag) {
    this.flags &= ~flag;
  }

  // Check permission
  has(flag) {
    return (this.flags & flag) === flag;
  }

  // Toggle permission
  toggle(flag) {
    this.flags ^= flag;
  }

  // Get all permissions
  toString() {
    const perms = [];
    if (this.has(FLAGS.READ)) perms.push('READ');
    if (this.has(FLAGS.WRITE)) perms.push('WRITE');
    if (this.has(FLAGS.EXECUTE)) perms.push('EXECUTE');
    if (this.has(FLAGS.DELETE)) perms.push('DELETE');
    return perms.join(' | ');
  }
}

// Usage
const perms = new Permissions();
perms.grant(FLAGS.READ | FLAGS.WRITE);  // Grant multiple at once
console.log(perms.has(FLAGS.READ));     // true
console.log(perms.has(FLAGS.EXECUTE));  // false
console.log(perms.toString());          // "READ | WRITE"

perms.grant(FLAGS.EXECUTE);
perms.revoke(FLAGS.WRITE);
console.log(perms.toString());          // "READ | EXECUTE"

// Decimal to binary/hex/octal
const num = 255;

// To binary
console.log(num.toString(2));   // "11111111"

// To hexadecimal
console.log(num.toString(16));  // "ff"

// To octal
console.log(num.toString(8));   // "377"

// With formatting
function formatNumber(num, base, minLength = 0) {
  const converted = num.toString(base);
  const padded = converted.padStart(minLength, '0');

  const prefixes = { 2: '0b', 8: '0o', 16: '0x' };
  return (prefixes[base] || '') + padded;
}

console.log(formatNumber(255, 2, 8));   // "0b11111111"
console.log(formatNumber(255, 16, 2));  // "0xff"
console.log(formatNumber(255, 8, 3));   // "0o377"

// Python version
"""
num = 255
print(bin(num))   # "0b11111111"
print(hex(num))   # "0xff"
print(oct(num))   # "0o377"

# Without prefix
print(format(num, 'b'))   # "11111111"
print(format(num, 'x'))   # "ff"
print(format(num, 'o'))   # "377"
"""

// Binary to decimal/hex
const binary = "11111111";

// Binary to decimal
const decimal = parseInt(binary, 2);
console.log(decimal);  // 255

// Binary to hex
const hex = parseInt(binary, 2).toString(16);
console.log(hex);  // "ff"

// Binary to octal
const octal = parseInt(binary, 2).toString(8);
console.log(octal);  // "377"

// Comprehensive conversion function
function convertFromBinary(binary, toBase) {
  const decimal = parseInt(binary, 2);
  return decimal.toString(toBase);
}

console.log(convertFromBinary("11111111", 10));  // "255"
console.log(convertFromBinary("11111111", 16));  // "ff"
console.log(convertFromBinary("11111111", 8));   // "377"

// With validation
function safeBinaryConvert(binary, toBase = 10) {
  // Validate binary
  if (!/^[01]+$/.test(binary)) {
    throw new Error('Invalid binary string');
  }

  const decimal = parseInt(binary, 2);

  if (isNaN(decimal)) {
    throw new Error('Conversion failed');
  }

  return decimal.toString(toBase);
}

// Hex to decimal/binary
const hex = "ff";

// Hex to decimal
const decimal = parseInt(hex, 16);
console.log(decimal);  // 255

// Hex to binary
const binary = parseInt(hex, 16).toString(2);
console.log(binary);  // "11111111"

// Hex to binary (padded)
const binaryPadded = parseInt(hex, 16).toString(2).padStart(8, '0');
console.log(binaryPadded);  // "11111111"

// Hex to octal
const octal = parseInt(hex, 16).toString(8);
console.log(octal);  // "377"

// Multi-way conversion
function convert(value, fromBase, toBase, padLength = 0) {
  const decimal = parseInt(value, fromBase);
  if (isNaN(decimal)) {
    throw new Error('Invalid number format');
  }

  const result = decimal.toString(toBase);
  return result.padStart(padLength, '0');
}

console.log(convert("ff", 16, 2, 8));   // "11111111"
console.log(convert("255", 10, 16, 2)); // "ff"
console.log(convert("11111111", 2, 10)); // "255"

// Generate conversion table
function generateConversionTable(max = 16) {
  console.log('Dec  Hex  Oct  Binary');
  console.log('---  ---  ---  --------');

  for (let i = 0; i < max; i++) {
    const dec = i.toString().padStart(3);
    const hex = i.toString(16).toUpperCase().padStart(3);
    const oct = i.toString(8).padStart(3);
    const bin = i.toString(2).padStart(8, '0');

    console.log(`${dec}  ${hex}  ${oct}  ${bin}`);
  }
}

generateConversionTable();

// Output:
// Dec  Hex  Oct  Binary
// ---  ---  ---  --------
//   0    0    0  00000000
//   1    1    1  00000001
//   2    2    2  00000010
//   3    3    3  00000011
//   4    4    4  00000100
//   5    5    5  00000101
// ...

// Quick reference
const quickRef = {
  0: { hex: '0', oct: '0', bin: '0000' },
  1: { hex: '1', oct: '1', bin: '0001' },
  2: { hex: '2', oct: '2', bin: '0010' },
  3: { hex: '3', oct: '3', bin: '0011' },
  // ...
  15: { hex: 'F', oct: '17', bin: '1111' }
};

// Network programming applications

// Parse IP address to binary
function ipToBinary(ip) {
  return ip.split('.')
    .map(octet => parseInt(octet).toString(2).padStart(8, '0'))
    .join('.');
}

console.log(ipToBinary("192.168.1.1"));
// "11000000.10101000.00000001.00000001"

// MAC address to binary
function macToBinary(mac) {
  return mac.split(':')
    .map(hex => parseInt(hex, 16).toString(2).padStart(8, '0'))
    .join(':');
}

console.log(macToBinary("ff:ff:ff:ff:ff:ff"));
// "11111111:11111111:11111111:11111111:11111111:11111111"

// Calculate subnet mask
function cidrToSubnetMask(cidr) {
  const mask = -1 << (32 - cidr);
  return [
    (mask >>> 24) & 255,
    (mask >>> 16) & 255,
    (mask >>> 8) & 255,
    mask & 255
  ].join('.');
}

console.log(cidrToSubnetMask(24));  // "255.255.255.0"

// Parse network packet header
function parsePacketHeader(hexDump) {
  const bytes = hexDump.match(/.{2}/g).map(h => parseInt(h, 16));
  return {
    version: (bytes[0] >>> 4) & 0xF,
    ihl: bytes[0] & 0xF,
    totalLength: (bytes[2] << 8) | bytes[3],
    protocol: bytes[9],
    sourceIP: bytes.slice(12, 16).join('.'),
    destIP: bytes.slice(16, 20).join('.')
  };
}

// File format analysis

// Read file magic numbers (file signatures)
const FILE_SIGNATURES = {
  'ffd8ff': 'JPEG',
  '89504e47': 'PNG',
  '47494638': 'GIF',
  '504b0304': 'ZIP',
  '25504446': 'PDF',
  '52494646': 'WAV/AVI (RIFF)'
};

function detectFileType(hexHeader) {
  const clean = hexHeader.toLowerCase().replace(/\s/g, '');

  for (const [sig, type] of Object.entries(FILE_SIGNATURES)) {
    if (clean.startsWith(sig)) {
      return type;
    }
  }

  return 'Unknown';
}

console.log(detectFileType("ffd8ffe0"));  // "JPEG"
console.log(detectFileType("89504e47"));  // "PNG"

// Parse PNG chunk
function parsePNGChunk(hexData) {
  const bytes = hexData.match(/.{2}/g).map(h => parseInt(h, 16));

  const length = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
  const type = String.fromCharCode(...bytes.slice(4, 8));
  const data = bytes.slice(8, 8 + length);
  const crc = bytes.slice(8 + length, 12 + length);

  return { length, type, data, crc };
}

// Read BMP header
function parseBMPHeader(hexData) {
  const bytes = hexData.match(/.{2}/g).map(h => parseInt(h, 16));

  return {
    signature: String.fromCharCode(...bytes.slice(0, 2)),  // "BM"
    fileSize: (bytes[2]) | (bytes[3] << 8) | (bytes[4] << 16) | (bytes[5] << 24),
    dataOffset: (bytes[10]) | (bytes[11] << 8) | (bytes[12] << 16) | (bytes[13] << 24),
    width: (bytes[18]) | (bytes[19] << 8) | (bytes[20] << 16) | (bytes[21] << 24),
    height: (bytes[22]) | (bytes[23] << 8) | (bytes[24] << 16) | (bytes[25] << 24)
  };
}

// Color manipulation with hex

// Parse hex color
function parseHexColor(hex) {
  // Remove # if present
  hex = hex.replace('#', '');

  // Expand shorthand (e.g., "03F" to "0033FF")
  if (hex.length === 3) {
    hex = hex.split('').map(c => c + c).join('');
  }

  const r = parseInt(hex.slice(0, 2), 16);
  const g = parseInt(hex.slice(2, 4), 16);
  const b = parseInt(hex.slice(4, 6), 16);

  return { r, g, b };
}

console.log(parseHexColor("#FF5733"));
// { r: 255, g: 87, b: 51 }

// RGB to hex
function rgbToHex(r, g, b) {
  return '#' + [r, g, b]
    .map(c => c.toString(16).padStart(2, '0'))
    .join('');
}

console.log(rgbToHex(255, 87, 51));  // "#ff5733"

// Lighten/darken color
function adjustBrightness(hex, percent) {
  const { r, g, b } = parseHexColor(hex);

  const adjust = (c) => {
    const adjusted = c + (c * percent / 100);
    return Math.max(0, Math.min(255, Math.round(adjusted)));
  };

  return rgbToHex(adjust(r), adjust(g), adjust(b));
}

console.log(adjustBrightness("#FF5733", 20));   // Lighten by 20%
console.log(adjustBrightness("#FF5733", -20));  // Darken by 20%

// Invert color
function invertColor(hex) {
  const { r, g, b } = parseHexColor(hex);
  return rgbToHex(255 - r, 255 - g, 255 - b);
}

console.log(invertColor("#FF5733"));  // "#00A8CC"

// Debugging with hex dumps

// Create hex dump from buffer
function hexDump(data, options = {}) {
  const {
    bytesPerLine = 16,
    showAscii = true,
    showOffset = true
  } = options;

  const lines = [];
  const bytes = typeof data === 'string'
    ? Array.from(data).map(c => c.charCodeAt(0))
    : Array.from(data);

  for (let i = 0; i < bytes.length; i += bytesPerLine) {
    const chunk = bytes.slice(i, i + bytesPerLine);

    let line = '';

    // Offset
    if (showOffset) {
      line += i.toString(16).padStart(8, '0') + ':  ';
    }

    // Hex bytes
    line += chunk.map(b => b.toString(16).padStart(2, '0')).join(' ');
    line += ' '.repeat((bytesPerLine - chunk.length) * 3);

    // ASCII representation
    if (showAscii) {
      line += '  |';
      line += chunk.map(b =>
        (b >= 32 && b <= 126) ? String.fromCharCode(b) : '.'
      ).join('');
      line += '|';
    }

    lines.push(line);
  }

  return lines.join('\n');
}

console.log(hexDump("Hello World!\nThis is a test."));
// 00000000:  48 65 6c 6c 6f 20 57 6f 72 6c 64 21 0a 54 68 69  |Hello World!.Thi|
// 00000010:  73 20 69 73 20 61 20 74 65 73 74 2e              |s is a test.|

// Compare binary data
function compareBinary(data1, data2) {
  const bytes1 = Array.from(data1).map(c => c.charCodeAt(0));
  const bytes2 = Array.from(data2).map(c => c.charCodeAt(0));

  const differences = [];
  const maxLen = Math.max(bytes1.length, bytes2.length);

  for (let i = 0; i < maxLen; i++) {
    if (bytes1[i] !== bytes2[i]) {
      differences.push({
        offset: i,
        byte1: bytes1[i]?.toString(16),
        byte2: bytes2[i]?.toString(16)
      });
    }
  }

  return differences;
}

// Performance optimization

// ❌ Slow: String concatenation in loop
function stringToBinarySlow(str) {
  let result = '';
  for (let i = 0; i < str.length; i++) {
    result += str.charCodeAt(i).toString(2).padStart(8, '0') + ' ';
  }
  return result.trim();
}

// ✅ Fast: Array join
function stringToBinaryFast(str) {
  return str.split('')
    .map(c => c.charCodeAt(0).toString(2).padStart(8, '0'))
    .join(' ');
}

// ✅ Faster: Pre-allocated array
function stringToBinaryFaster(str) {
  const result = new Array(str.length);
  for (let i = 0; i < str.length; i++) {
    result[i] = str.charCodeAt(i).toString(2).padStart(8, '0');
  }
  return result.join(' ');
}

// Benchmark
const testString = "Hello World".repeat(1000);

console.time('slow');
stringToBinarySlow(testString);
console.timeEnd('slow');

console.time('fast');
stringToBinaryFast(testString);
console.timeEnd('fast');

console.time('faster');
stringToBinaryFaster(testString);
console.timeEnd('faster');

// Use TypedArrays for binary data
function efficientBinaryProcessing(data) {
  const bytes = new Uint8Array(data.length);
  for (let i = 0; i < data.length; i++) {
    bytes[i] = data.charCodeAt(i);
  }
  return bytes;
}

// Use built-in functions for better performance

// Node.js Buffer (fastest)
const text = "Hello World";

// String to hex
const hex = Buffer.from(text, 'utf8').toString('hex');
console.log(hex);  // "48656c6c6f20576f726c64"

// Hex to string
const decoded = Buffer.from(hex, 'hex').toString('utf8');
console.log(decoded);  // "Hello World"

// String to base64
const b64 = Buffer.from(text, 'utf8').toString('base64');
console.log(b64);  // "SGVsbG8gV29ybGQ="

// Browser TextEncoder/TextDecoder
const encoder = new TextEncoder();
const decoder = new TextDecoder();

const encoded = encoder.encode("Hello");
console.log(encoded);  // Uint8Array [72, 101, 108, 108, 111]

const hexString = Array.from(encoded)
  .map(b => b.toString(16).padStart(2, '0'))
  .join('');
console.log(hexString);  // "48656c6c6f"

// JavaScript built-in conversions
const num = 255;
console.log(num.toString(2));   // "11111111" (binary)
console.log(num.toString(16));  // "ff" (hex)
console.log(num.toString(8));   // "377" (octal)

console.log(parseInt("11111111", 2));  // 255
console.log(parseInt("ff", 16));       // 255
console.log(parseInt("377", 8));       // 255