Overview

Since cards move “one position clockwise simultaneously for everyone” each time, when viewed as a whole, the arrangement of cards is simply rotating around a circular ring.
Therefore, there is no need to simulate the \(K\) operations directly — we can determine which card each child ends up holding using a formula.

Analysis

First, let’s consider what happens after performing the operation just once.

The initial state is:

• Child \(1\) holds card \(1\)
• Child \(2\) holds card \(2\)
• \(\cdots\)
• Child \(N\) holds card \(N\)

When everyone simultaneously passes their card to their clockwise neighbor:

• Child \(1\) receives card \(N\) from child \(N\)
• Child \(2\) receives card \(1\) from child \(1\)
• Child \(3\) receives card \(2\) from child \(2\)
• \(\cdots\)

In other words, after one operation, the card child \(i\) holds is the card that child \(i-1\) originally held
(where for \(i=1\), \(i-1=0\) means child \(N\)).

For example, when \(N=5\):

• Initial state: \([1,2,3,4,5]\)
• After 1 operation: \([5,1,2,3,4]\)
• After 2 operations: \([4,5,1,2,3]\)

Each time, the array appears to “rotate one position to the right.”

Key Insight

After \(K\) operations, the card held by child \(i\) is:

• After each operation, it becomes the card of the previous child
• Repeating this \(K\) times

So child \(i\) holds the card that child \(i-K\) originally held.
Since the arrangement is circular, we just need to consider the index modulo \(N\).

Written in 1-indexed form, the answer is:

\[ ((i-K-1) \bmod N) + 1 \]

Why a Naive Approach Doesn’t Work

If we directly simulate the card movement each time, one operation takes \(O(N)\), and doing this \(K\) times costs \(O(NK)\).

However, given the constraints:

• \(N \le 2 \times 10^5\)
• \(K \le 10^{18}\)

simulating \(K\) operations is far too slow.

How to Solve It

Since rotating \(N\) times in a circle returns to the original state, it is sufficient to consider only

\[ K \bmod N \]

rotations.

Then, for each child \(i\), we can directly compute the answer using the formula

\[ ((i-K-1) \bmod N) + 1 \]

which allows us to solve the entire problem in \(O(N)\).

Algorithm

1. Replace \(K\) with \(K \bmod N\)
2. For each child \(i=1,2,\dots,N\), compute the card number they hold as $\( ((i-K-1) \bmod N) + 1 \)$
3. Output the results in order

Complexity

• Time complexity: \(O(N)\)
• Space complexity: \(O(N)\)

Implementation Notes

• Since the arrangement is circular, performing \(N\) operations returns to the original state. Therefore, we can start by computing K %= N.

• Directly working with 1-indexed numbers can cause off-by-one issues, so using the form

  
  (i - K - 1) % N + 1
  

  gives a clean expression.

• Python’s % operator returns a non-negative remainder even for negative numbers, so even when i-K-1 is negative, it is handled correctly.

  Source Code

import sys

def main():
    N, K = map(int, sys.stdin.readline().split())
    K %= N
    ans = [str((i - K - 1) % N + 1) for i in range(1, N + 1)]
    sys.stdout.write("\n".join(ans))

if __name__ == "__main__":
    main()

---

This editorial was generated by gpt-5.4-high.