如何用C语言生成长度为9的小写字母与数字全组合？

Got it, you're looking to generate every possible 9-character string made up of lowercase letters (a-z) and digits (0-9) — just like your example b0a6195c9. Since you mentioned you found some related C code but want a complete, working solution, let's walk through this properly.

First, let's ground ourselves in the scale here: there are 36 valid characters (26 letters + 10 digits), so total combinations come out to 36^9 ≈ 1.06e14. That's an enormous number — you'll never be able to store all of these in memory at once, so we need a memory-efficient approach that generates each combination one by one and processes it (like writing to a file) without hogging system resources.

Complete Working Implementation #

Here's a C program that does exactly this, focusing on minimal memory usage and sequential generation:

#include <stdio.h>
#include <string.h>

// Define our valid character set: lowercase letters + digits
const char CHARSET[] = "abcdefghijklmnopqrstuvwxyz0123456789";
const int CHARSET_SIZE = sizeof(CHARSET) - 1; // Subtract 1 to exclude the null terminator
const int TARGET_LENGTH = 9;

void generate_all_combinations(FILE *output_stream) {
    // We only need one buffer to hold the current combination
    char current_str[TARGET_LENGTH + 1];
    // Initialize the first combination (all 'a's)
    memset(current_str, CHARSET[0], TARGET_LENGTH);
    current_str[TARGET_LENGTH] = '\0'; // Null-terminate the string

    while (1) {
        // Write the current combination to our output (file in this case)
        fprintf(output_stream, "%s\n", current_str);

        // Increment the combination like a base-36 number
        int position = TARGET_LENGTH - 1; // Start from the rightmost character
        while (position >= 0) {
            // Find the index of the current character in our charset
            const char *char_pos = strchr(CHARSET, current_str[position]);
            int char_index = char_pos - CHARSET;

            if (char_index == CHARSET_SIZE - 1) {
                // We've hit the last character (9), carry over to the left
                current_str[position] = CHARSET[0];
                position--;
            } else {
                // Move to the next character in the charset
                current_str[position] = CHARSET[char_index + 1];
                break; // No carry needed, exit the inner loop
            }
        }

        // If we carried over past the leftmost character, we've generated all combinations
        if (position < 0) {
            break;
        }
    }
}

int main() {
    // Open a file to write combinations (console output is impractical here)
    FILE *output_file = fopen("9char_combinations.txt", "w");
    if (!output_file) {
        perror("Failed to open output file");
        return 1;
    }

    printf("Starting generation of all %d-character alphanumeric combinations...\n", TARGET_LENGTH);
    generate_all_combinations(output_file);
    
    fclose(output_file);
    printf("Generation complete! Combinations saved to 9char_combinations.txt\n");

    return 0;
}

Key Notes & Warnings #

• Memory Efficiency: This code only keeps one 10-byte string in memory at a time (9 characters + null terminator), which is critical given the sheer number of combinations. Storing all of them would require ~931 terabytes of disk space — so writing directly to a file is the only feasible approach.
• Base-36 Logic: The code treats each combination like a number in base 36. It starts at aaaaaaaaa and increments each position, carrying over to the left when a position reaches 9 (the last character in our set).
• Practicality Check: Even if your system could write 1 million combinations per second, generating all 1.06e14 combinations would take over 3,300 years. This code is technically correct, but it's not feasible to run to completion unless you're only generating a subset (you can add a counter to stop after N combinations if needed).
• Customization: If you need a different character set, just modify the CHARSET array — the rest of the code will adapt automatically.

内容的提问来源于stack exchange，提问作者Sam Braidley