human
I found an interesting problem on https://codeforces.com/problemset/problem/618/E:
Roger is a robot. He has an arm that is a series of n segments connected to each other. The endpoints of the i-th segment are initially located at points (i - 1, 0) and (i, 0). The endpoint at (i - 1, 0) is colored red and the endpoint at (i, 0) is colored blue for all segments. Thus, the blue endpoint of the i-th segment is touching the red endpoint of the (i + 1)-th segment for all valid i.

Roger can move his arm in two different ways:   He can choose some segment and some value. This is denoted as choosing the segment number i and picking some positive l. This change happens as follows: the red endpoint of segment number i and segments from 1 to i - 1 are all fixed in place. Imagine a ray from the red endpoint to the blue endpoint. The blue endpoint and segments i + 1 through n are translated l units in the direction of this ray.

 [Image] [Image] 

In this picture, the red point labeled A and segments before A stay in place, while the blue point labeled B and segments after B gets translated.

 He can choose a segment and rotate it. This is denoted as choosing the segment number i, and an angle a. The red endpoint of the i-th segment will stay fixed in place. The blue endpoint of that segment and segments i + 1 to n will rotate clockwise by an angle of a degrees around the red endpoint.

 [Image] [Image] 

In this picture, the red point labeled A and segments before A stay in place, while the blue point labeled B and segments after B get rotated around point A. 

Roger will move his arm m times. These transformations are a bit complicated, and Roger easily loses track of where the blue endpoint of the last segment is. Help him compute the coordinates of the blue endpoint of the last segment after applying each operation. Note that these operations are cumulative, and Roger's arm may intersect itself arbitrarily during the moves.

-----Input-----

The first line of the input will contain two integers n and m (1 ≤ n, m ≤ 300 000) — the number of segments and the number of operations to perform.

Each of...

I tried it in Python, but could not do it. Can you solve it?

 What is a Python code to compute the coordinates of the blue endpoint of the last segment after applying each operation?
assistant
#Here is Python code to compute the coordinates of the blue endpoint of the last segment after applying each operation.

from cmath import rect
import sys
import math
from functools import reduce

class SegmentTree():
    def __init__(self, L, function = lambda x,y: x+y):
        self.function = function
        N = self.size = len(L)
        M = 1 << N.bit_length()
        self.margin = 2*M - N
        self.L = [None for i in range(self.margin)] + L
        for i in range(M-1, 0, -1):
            x, y = self.L[i<<1], self.L[i<<1|1]
            self.L[i] = None if x is None or y is None else function(x, y)
    def modify(self, pos, value):
        p = pos + self.margin
        self.L[p] = value 
        while p > 1:
            x, y = self.L[p], self.L[p^1]
            if p&1: x, y = y, x
            self.L[p>>1] = None if x is None or y is None else self.function(x, y)
            p>>=1
    def query(self, left, right):
        l, r = left + self.margin, right + self.margin
        stack = []
        void = True
        while l < r:
            if l&1:
                if void:
                    result = self.L[l]
                    void = False
                else:
                    result = self.function(result, self.L[l])
                l+=1
            if r&1:
                r-=1
                stack.append(self.L[r])
            l>>=1
            r>>=1
        init = stack.pop() if void else result
        return reduce(self.function, reversed(stack), init)

def degrect(r, phi):
    return rect(r, math.radians(phi))

def vsum(u, v): #u = (x + y*1j, phi)
    return (u[0] + v[0]*degrect(1, u[1]), (u[1] + v[1])%360)

def solve(f):
    n, m = [int(x) for x in f.readline().split()]
    segments = [[1,0] for i in range(n)]
    arm = SegmentTree([(1,0) for i in range(n)], vsum)
    for line in f:
        q, i, a = [int(x) for x in line.split()]
        if q == 1:
            segments[i-1][0] += a
        else:
            segments[i-1][1] -= a
        arm.modify(i-1, (degrect(segments[i-1][0], segments[i-1][1]), segments[i-1][1]))
        query = arm.query(0,n)[0]
        print(query.real, query.imag)

solve(sys.stdin)