Print all subsets in C, C++, Java & Python – Code with Explanation & Examples in Short and Simple

   

C Program

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

void printSubsets(char *str, char *subset, int index, int subIndex) {
    if (index == strlen(str)) {
        subset[subIndex] = '\0';
        printf("%s\n", subset);
        return;
    }
    subset[subIndex] = str[index];
    printSubsets(str, subset, index + 1, subIndex + 1);
    printSubsets(str, subset, index + 1, subIndex);
}

int main() {
    char str[] = "abc";
    char subset[100];
    printSubsets(str, subset, 0, 0);
    return 0;
}

C Output

abc
ab
ac
a
bc
b
c

C++ Program

#include <iostream>
#include <string>
using namespace std;

void printSubsets(string str, string subset, int index) {
    if (index == str.size()) {
        cout << subset << endl;
        return;
    }
    printSubsets(str, subset + str[index], index + 1);
    printSubsets(str, subset, index + 1);
}

int main() {
    string str = "abc";
    printSubsets(str, "", 0);
    return 0;
}

C++ Output

abc
ab
ac
a
bc
b
c

JAVA Program

public class Main {
    static void printSubsets(String str, String subset, int index) {
        if (index == str.length()) {
            System.out.println(subset);
            return;
        }
        printSubsets(str, subset + str.charAt(index), index + 1);
        printSubsets(str, subset, index + 1);
    }

    public static void main(String[] args) {
        String str = "abc";
        printSubsets(str, "", 0);
    }
}

JAVA Output

abc
ab
ac
a
bc
b
c

Python Program

def print_subsets(s, subset, index):
    if index == len(s):
        print(subset)
        return
    print_subsets(s, subset + s[index], index + 1)
    print_subsets(s, subset, index + 1)

s = "abc"
print_subsets(s, "", 0)

Python Output

abc
ab
ac
a
bc
b
c

Explanation

Example

Take the string "abc". The subsets are all possible combinations of characters where the selection order is important, but not order within the subset. We begin at index 0 and have two options: add the current character or omit it. Each option gives rise to a new decision for the next character, creating a path of possibilities with branches. Recursion naturally fits this decision-making process, as it calls itself for each branch until we’ve considered every character.

Real-Life Analogy

Think you're bagging things for a trip. For every thing (such as a shirt, pants, or hat), there are only two choices: pack it or don't pack it. Having decided one thing, you move on to the next until you've decided what to do with all the things on your list. Having decided everything, you write down the last collection you packed. That's precisely how subsets are created — each thing (character) is in or out.

Why It Matters

This recursive method is a fundamental idea in combinatorics and backtracking. Knowing how to create all subsets assists in problems within search algorithms, data analysis, encryption, and AI decision-making. It's also a stepping stone for resolving power set problems, creating permutations, and addressing dynamic programming issues.

Learning Insights

One important point here is that recursion can systematically visit all possibilities without requiring explicit nested loops for every subset length. Rather, one recursive form branches naturally to visit all lengths. This instructs programmers in how to divide problems into repeated binary decisions (yes/no, include/exclude) and is akin to conceptually related binary tree traversal.

Use in Interviews and Projects

Interviewers are fond of subset problems since they expose your grasp of recursion depth, branching, and base cases. They may also include constraints such as subset sum or lexicographic order. Subsets have practical applications in product recommendation engines (identifying sets of user preferences), scheduling (selecting potential time slots), and security (testing all input combinations for security vulnerabilities).

SEO-Friendly Closing

Printing all subsets recursively in C, C++, Java, and Python is a fundamental programming technique for dominating combinatorial logic and backtracking algorithms. By learning how to include or exclude items systematically, programmers are able to tackle all types of problems from power set generation to solving complicated decision-making tasks. The technique is extremely useful for coding interviews, competitive programming problems, and real-world software projects that need to examine every possible input combination effectively.