Research on Number Sequence Generation Methods Based on Modulo Operations in Python

Sequence Generation Problem Analysis

In programming practice, there is often a need to generate numerical sequences that satisfy specific mathematical patterns. The sequence discussed in this paper requires generating all integers between 1 and 100 that yield a remainder of 1 or 2 when divided by 4, specifically the sequence: 1, 2, 5, 6, 9, 10, ..., 97, 98. This sequence exhibits clear periodic characteristics mathematically, with each cycle containing two consecutive numbers.

Direct Filtering Based on Modulo Operations

The most intuitive solution involves conditional filtering using modulo operations. Python's generator expressions combined with string operations can elegantly implement this requirement:

result = ','.join(str(i) for i in range(1, 101) if i % 4 in (1, 2))

The core logic of this code iterates through all integers from 1 to 100, filtering target numbers through the condition i % 4 in (1, 2). Here, range(1, 101) generates the integer sequence from 1 to 100, str(i) converts each number to a string, and finally ','.join() concatenates all qualified number strings with commas.

The advantage of this method lies in its concise and clear code with straightforward logic. The time complexity is O(n), and space complexity is O(1) since the generator expression doesn't build a complete intermediate list in memory.

Pattern Recognition and Periodic Generation

Observing the sequence pattern reveals that it actually consists of two interleaved subsequences: one starting from 1 with a step of 4 (1, 5, 9, ...) and another starting from 2 with a step of 4 (2, 6, 10, ...). Based on this observation, a merge-and-sort approach can be employed:

seq1 = list(range(1, 101, 4))
seq2 = list(range(2, 101, 4))
result = ','.join(map(str, sorted(seq1 + seq2)))

This method first generates two independent subsequences, then merges and sorts them. Although the code is slightly more verbose, it clearly demonstrates the mathematical structure of the sequence, aiding in understanding the essence of the problem.

Advanced Iterator Implementation

For more complex sequence generation requirements, Python's itertools module provides powerful tools. Through custom iterators, more flexible sequence generation can be achieved:

from itertools import cycle, takewhile, accumulate, chain

def generate_sequence(start, deltas, max_value):
    delta_cycle = cycle(deltas)
    number_sequence = accumulate(chain([start], delta_cycle))
    return takewhile(lambda x: x <= max_value, number_sequence)

sequence = generate_sequence(1, [1, 3], 100)
result = ','.join(str(x) for x in sequence)

This implementation uses the cycle function to cyclically provide the increment pattern [1, 3], the accumulate function to generate the number sequence through accumulation, and takewhile to ensure the sequence doesn't exceed the maximum value. Although this method has higher code complexity, it offers strong generality and can easily adapt to different sequence patterns.

Performance Analysis and Comparison

The three methods have distinct performance characteristics: the direct filtering method balances code conciseness and runtime efficiency; the pattern generation method excels in sequence structure clarity; the iterator method offers the strongest generality and extensibility. In practical applications, appropriate methods should be selected based on specific requirements. For simple filtering needs, the direct filtering method is recommended; for handling complex sequence patterns, the iterator method should be considered.

Application Scenarios and Extensions

Such sequence generation techniques find wide applications in multiple domains: generating specific sampling sequences in data analysis; creating test data with particular mathematical characteristics in algorithm testing; demonstrating properties of mathematical sequences in educational contexts. Mastering these techniques not only helps solve specific programming problems but also fosters deep understanding of sequence patterns and mathematical regularities.