Well, there the annoying "Not looking for the verification of my code" is gone…
Step 1: White space
Follow the PEP 8 guidelines and put a space around operators and commas (but not limited to):
n, k = map(int, input().split())
arr = list(map(int, input().split())) # read input sequence and store it as list type
for i in range(k): # iterate over 0 to (k-1)
t = i % n # module of i wrt n
arr(t) = arr(t) ^ arr(n - (t) - 1) # xor between two list elements and then set result to the ith list element
for i in arr:
print(i, end=" ") # print the final sequence
Much easier to read.
Step 2: Avoid multiple searches
Python is an interpreted language, and the meaning of a line of code-or even a piece of code-can change until the interpreter returns to run the code the second time. This means that the interpreter can not really compile the code. Unless something is a well-defined short-circuit operation, every operation must be performed.
Consider:
arr(t) = arr(t) ^ arr(n - (t) - 1)
The interpreter must calculate the address of arr(t) twice; once to retrieve the value and a second time to save the new value because of some side effects that occur during the execution of arr(n - (t) - 1) can change the meaning of arr(t), In your case, arr is a list, and n and t are simple integers, but with custom types anything can happen. Therefore, the Python interpreter can never do the following optimization:
arr(t) ^= arr(n - (t) - 1)
It's a tiny acceleration, but considering that the code can be executed $ 10 ^ {12} $ Sometimes it can add up.
Step 3: Avoid calculations
Speaking of labor avoidance: Because we know that the length of the array is fixed, arr(n - 1) is the same as arr(-1), So we can further speed up the line of code as follows:
arr(t) ^= arr(-1 - t)
Instead of two subtractions, we only have one. Yes, Python needs to index from the back of the array, which internally involves a subtraction. BUT This will be an optimized, C-coded subtraction operation ssize_t Values instead of subtractions for variable byte length integers that must be allocated and released by the heap.
Step 4: Print space-separated lists
The following is slow:
for i in arr:
print(i, end=" ")
This is faster:
print(*arr)
And for long lists, this can be the fastest:
print(" ".join(map(str, arr)))
For a detailed discussion, including timing diagrams, see my answer and this answer to another question.
Step 5: The algorithm
Look at the list (A, B, C, D, E),
After applying a single pass of the operation to it (ie k = n), You will get:
(A^E, B^D, C^C, D^(B^D), E^(A^E))
which simplifies:
(A^E, B^D, 0, B, A)
If we apply a second pass (ie k = 2*n), You will get:
((A^E)^A, (B^D)^B, 0^0, B^((B^D)^B), A^((A^E)^A))
which simplifies:
(E, D, 0, B^D, A^E)
A third pass (ie k = 3*n) gives:
(E^(A^E), D^(B^D), 0^0, (B^D)^(D^(B^D)), (A^E)^(E^(A^E)))
or:
(A, B, 0, D, E)
Now k does not have to be an exact multiple of nSo you have to figure out what to do in the general cases, but you should be able to use the above observation to eliminate many unnecessary calculations.
Implementation left to the student.
