Print the lexicographically smallest permutation that satisfies the given formation
If you print out the solutions for the first couple of numbers,
a pattern becomes obvious:

def print_first_imba(max_):
    """
    &gt;&gt;&gt; print_first_imba(2)
    1 2
    &gt;&gt;&gt; print_first_imba(3)
    2 1 3
    &gt;&gt;&gt; print_first_imba(4)
    2 3 1 4
    &gt;&gt;&gt; print_first_imba(5)
    3 2 4 1 5
    &gt;&gt;&gt; print_first_imba(6)
    3 4 2 5 1 6
    &gt;&gt;&gt; print_first_imba(7)
    4 3 5 2 6 1 7
    """


The pattern looks like:


given an input sequence 1, 2, 3, ..., n, and an empty output list
pop the last number from the sequence and prepend to the output
pop the first number from the sequence and prepend to the output
keep popping until there are no elements left in the sequence


That will be substantially faster than searching the permutation space.

The doc tests I wrote above should help a lot in implementing this alternative algorithm. Your current implementation passes these tests btw, if you reorganize your code to fit it into this method:

checksum = max_ + 1
list_ = range(1, max_ + 1)
for perm in permutations(list_):
    if check_condition(perm, checksum):
        print(" ".join(map(str, perm)))
        break


My alternative implementation also passes these tests:

from collections import deque

imba = deque()
highest = max_
lowest = 1
while lowest &lt;= highest:
    imba.appendleft(highest)
    highest -= 1
    if lowest &lt; highest:
        imba.appendleft(lowest)
        lowest += 1
print(" ".join(map(str, imba)))


In case you don't know, you can run doc tests with python -m doctest yourfile.py.

I also recommend to go a bit further and separate printing from the main logic, by renaming this method to get_first_imba and make it return perm instead of printing it.