About

An alternating binary sequence is a deterministic pattern where each bit is the logical complement of its predecessor: b_i = (s + i) mod 2, where s ∈ {0, 1} is the starting bit. These sequences appear in clock signal testing, UART idle-line detection, Manchester encoding validation, and PRBS baseline comparisons. Getting the phase or length wrong in hardware test vectors can mask timing violations or cause false pass results on boundary-scan tests.

This generator produces sequences up to 100,000 bits with configurable grouping (nibbles, bytes, words) and output formats. It approximates no randomness. The output is fully deterministic. Note: for sequences exceeding your clipboard limit, use the file download option.

Formulas

The alternating binary sequence is defined by a simple recurrence. Given a starting bit s and sequence length n, each bit at position i is computed as:

b_i = (s + i) mod 2, i ∈ {0, 1, …, n − 1}

Where s = 0 produces the sequence 010101… and s = 1 produces 101010….

The Hamming weight (count of 1-bits) for a sequence of length n starting with s is:

H =

{

n2 if n is evenn + 12 if n is odd and s = 1n − 12 if n is odd and s = 0

Where b_i is the bit value at index i, s is the starting bit (0 or 1), n is the total sequence length, and H is the Hamming weight of the output.

Reference Data

Property	Value / Description
Sequence Type	Deterministic alternating binary
Starting Bit Options	0 (0101...) or 1 (1010...)
Min Length	1 bit
Max Length	100,000 bits
Period	2 (repeats every 2 bits)
Duty Cycle	50% (equal 0s and 1s for even lengths)
Hamming Weight (even n)	n2
Autocorrelation at lag 1	−1 (perfect anti-correlation)
Run Length	1 (every run is exactly one bit)
Nibble Grouping	4 bits per group
Byte Grouping	8 bits per group
Word Grouping	16 bits per group
Common Application: Clock Signal	Square wave at f2 of bit rate
Manchester Encoding Baseline	Alternating bits produce constant transitions
UART Idle Pattern	Continuous 1s (not alternating) - use for contrast testing
Hex of 01010101	0x55
Hex of 10101010	0xAA
Decimal of 01010101	85
Decimal of 10101010	170
Bit Error Rate Test (BERT)	Alternating pattern used as reference baseline
I²C SDA Stress Pattern	Alternating bits maximize transition density
CRC of 0x55 (CRC-8)	0x93

Frequently Asked Questions

Starting with 0 produces the byte pattern 0x55 (decimal 85), while starting with 1 produces 0xAA (decimal 170). In BERT (Bit Error Rate Testing), 0xAA is the standard pattern because it begins with a high-to-low transition, matching typical clock edge alignment. Many JTAG boundary-scan tools expect the 0xAA pattern specifically. Using the wrong phase can cause all transitions to align with setup times rather than hold times, masking critical timing violations.

Grouping inserts a separator (space by default) every g bits. Nibble grouping (4 bits) is standard for FPGA constraint files and VHDL/Verilog literals. Byte grouping (8 bits) matches memory dump formats, serial protocol analyzers, and hex editor views. Word grouping (16 bits) aligns with 16-bit register widths common in ARM Cortex-M microcontrollers. The grouping does not change the underlying data, only the visual representation.

At 100,000 bits, the output string occupies roughly 100KB of memory (plus separators). Browsers allocate strings on the heap, and DOM rendering of strings beyond this size causes layout thrashing and can freeze the tab. For sequences exceeding 100,000 bits, use the download feature which writes directly to a Blob without rendering in the DOM. The computational cost is O(n) and negligible; the bottleneck is DOM painting.

No. An alternating binary sequence has zero entropy. Its autocorrelation at lag 1 is −1, meaning every bit is perfectly predictable from its neighbor. It fails all NIST SP 800-22 randomness tests. For PRNG applications, use a Linear Feedback Shift Register (LFSR) with a maximal-length polynomial, or a Mersenne Twister. The alternating sequence is useful precisely because it is deterministic: it stress-tests transition density, not randomness.

The generator provides the raw binary string. To convert to hex, group the bits into nibbles (4-bit groups) and map each to its hex digit: 0101 → 5, 1010 → A. A full byte of 01010101 equals 0x55 and 10101010 equals 0xAA. If the total bit count is not a multiple of 4, pad the last group with trailing zeros before conversion. Most programming languages provide built-in functions: parseInt(binaryString, 2) in JavaScript.

No. For odd-length sequences, the duty cycle deviates slightly. A 7-bit sequence starting with 0 (0101010) contains 3 ones and 4 zeros, giving a duty cycle of 42.86%. The imbalance is always exactly 1 bit. For applications requiring a precise 50% duty cycle (e.g., balanced line coding), use even-length sequences only.