Argthtjtr

I am trying to print permutations of 0's and 1's recursively in Python.

I understand there is a permutations function in itertools, but was wondering how one could do it recursively, for e.g.

function name is print_01(k) 

    # ...

    print(permutation)

    # ...

...where k is the length of each permutation to be printed, so if you call it as print_01(2), the output would be something like this:

00

01

10

11

The output is always of length k.

How could I get this done recursively using print?

Without giving away the code, I'll attempt to give the hints needed for you to come up with the code.

The idea is to make the recursive call to add one more digit to an accumulated string, that initially is empty.

The so-called "base case" of the recursion is where the accumulated string has the desired length. This is where you would output it (or store it somewhere)

You'll need a loop to visit the two possible digits.

Let me know if this is enough for you to get going.

Spoiler alert (only look below after having tried):

Here is an idea:
Instead of doing that recursively, use binary development of numbers:

def print_01(k):

    end = 1<<k   #this is the integer with binary developpement 1 followed by k zeros

    for j in range(end): # iterate until end means getting all k - 0-1 combinations

        comb = bin(j)[2:].zfill(k)

        print [int(x) for x in comb]

Do you really need to permute ... ?
If not try below

def print_01(length):

    for i in range(1 << length):

        print(format(i, '0{}b'.format(length)))





def main():

    '''The Main'''

    print_01(2)

    print_01(3)





if __name__ == '__main__':

    main()

Here's a simple recursive version:

#!/usr/bin/python -E

#string of binary 1s and 0s, all possible combinations for a given length

def swap(string, loc, val):

    newstring = string[:loc]+val+string[loc+1:]

    return newstring

def printperms(string,n):

    length = len(string)

    if n > 0:

       string = swap(string, (length - n), "0")

       printperms(string, (n -1))

       string = swap(string, (length - n), "1")

       printperms(string, (n -1))

    else:

       print(string)





mystring = "000"

length = len(mystring)

printperms(mystring, length)

mystring = mystring+" "

print("############################################")

printperms(mystring,length+1)

Let's keep it simple:

def print_01(bits, n=0):

    if n.bit_length() <= bits:

        print('{:0{}b}'.format(n, bits))

        print_01(bits, n + 1)

The int type has a method bit_length() that tells you the minimum number of binary characters needed to represent this number -- we use that for control. The nested formatting allows us to pass the output width as a variable.

USAGE

>>> print_01(3)

000

001

010

011

100

101

110

111

>>>