In n circle size removing k th person every time until 1 remains
1. Review


If all the code is at the top level of the module, and reads from standard input, it is hard to test it or measure its performance. It's better to organize the code into functions so that they can be easily tested.
The values in the problem have the names \$N\$ and \$K\$ but in the code they have the names a and b. This makes it hard to check the code against the problem. It would be better to be consistent.
The code initializes the list c by repeatedly calling its append method:

c = []
for i in range(a, 0, -1):
    c.append(i)


Instead, just call list:

c = list(range(a, 0, -1))

The variable d is not used and could be omitted.
Instead of testing len(c) != 0, just test c.
The loop index i is not used; it's conventional to name an unused variable _.
Instead of:

f = c.pop()
c.insert(0, f)


you could save a line and write:

c.insert(0, c.pop())       



2. Revised code

def josephus(n, k):
    """Yield the order in which people are removed from the circle in the
    Josephus problem starting with n people and removing every k'th
    person.

    """
    c = list(range(n, 0, -1))
    while c:
        for _ in range(1, k):
            c.insert(0, c.pop())
        yield c.pop()

def main():
    n, k = map(int, raw_input().split())
    print(' '.join(josephus()))


3. Performance analysis

The while c: loop executes \$N\$ times, each for loop executes \$K-1\$ times, and inserting an item at the start of a list takes time proportional to the length of the list (see the time complexity page on the Python wiki). So the overall runtime is \$Θ(N^2K)\$.

4. Performance improvement

We can avoid one of the factors of \$N\$ in the runtime by using a collections.deque instead of a list and calling the rotate method:

from collections import deque

def josephus(n, k):
    """Yield the order in which people are removed from the circle in the
    Josephus problem starting with n people and removing every k'th
    person.

    """
    c = deque(range(n, 0, -1))
    while c:
        c.rotate(k - 1)
        yield c.pop()


This brings the runtime down to \$Θ(NK)\$ which might be acceptable, but since you didn't give us the link, I can't check whether that's the case.