Bitstream I/O

medium · compression, bit-io, encoding

Bitstream I/O

Implement MSB-first bit-level writing and reading.

Types

type BitWriter struct {
    // implement fields
}

type BitReader struct {
    // implement fields
}

func NewBitWriter() *BitWriter
func (bw *BitWriter) WriteBit(bit uint8)
func (bw *BitWriter) WriteBits(value uint64, n int)
func (bw *BitWriter) Bytes() []byte

func NewBitReader(data []byte) *BitReader
func (br *BitReader) ReadBit() (uint8, bool)
func (br *BitReader) ReadBits(n int) (uint64, bool)

Bit order (MSB-first)

The first bit written goes to the highest bit of the first byte (bit 7).
WriteBits(value, n) writes the n lowest bits of value, from MSB to LSB.
Padding: if the stream ends mid-byte, pad remaining low bits with zeros.

Read behavior

ReadBit returns (bit, ok); ok=false if no more bits.
ReadBits(n) returns (value, ok); ok=false if fewer than n bits remain.

Notes

Bytes() should return a copy of the written bytes.
ReadBits should assemble bits in the same order they were written.

package solution

// BitWriter writes bits MSB-first.
type BitWriter struct {
	buf   []byte
	cur   byte
	nbits uint8 // number of bits currently in cur [0..7]
}

// NewBitWriter creates a new BitWriter.
func NewBitWriter() *BitWriter {
	return &BitWriter{}
}

// WriteBit writes a single bit (0 or 1) MSB-first.
func (bw *BitWriter) WriteBit(bit uint8) {
	// TODO: implement
	_ = bit
}

// WriteBits writes the lowest n bits of value, MSB-first.
func (bw *BitWriter) WriteBits(value uint64, n int) {
	// TODO: implement
	_ = value
	_ = n
}

// Bytes returns the written bytes (padding with zeros if needed).
func (bw *BitWriter) Bytes() []byte {
	// TODO: implement
	return nil
}

// BitReader reads bits MSB-first.
type BitReader struct {
	data  []byte
	idx   int
	nbits uint8 // next bit position within current byte [0..7]
}

// NewBitReader creates a new BitReader.
func NewBitReader(data []byte) *BitReader {
	return &BitReader{data: data}
}

// ReadBit reads a single bit. ok=false if no bits remain.
func (br *BitReader) ReadBit() (uint8, bool) {
	// TODO: implement
	return 0, false
}

// ReadBits reads n bits and returns them in the same order as written.
func (br *BitReader) ReadBits(n int) (uint64, bool) {
	// TODO: implement
	return 0, false
}