Долгих Данила AsyncPoly 10624			Хайруллина Алина AsyncPoly 11001
f	1	import unicodedata	f	1	import unicodedata
	2	import asyncio		2	import asyncio
	3			3
	4	class YesFuture:		4	class YesFuture:
	5			5
	6	def __init__(self, value=None):		6	def __init__(self, value=None):
n	7	self._val = value	n	7	self._value = value
	8			8
n	9	def set(self, val):	n	9	def set(self, value):
	10	self._val = val		10	self._value = value
	11			11
	12	def __await__(self):		12	def __await__(self):
	13			13
n	14	async def inner():	n	14	async def _inner():
	15	return self._val		15	return self._value
	16	return inner().__await__()		16	return _inner().__await__()
	17			17
n	18	async def Sum(a, b):	n	18	async def Sum(x, y):
	19	return await a + await b		19	return await x + await y
	20			20
n	21	async def Mul(a, b):	n	21	async def Mul(x, y):
	22	return await a * await b		22	return await x * await y
	23			23
n	24	async def Pow(a, b):	n	24	async def Pow(x, y):
	25	return await a ** await b		25	return await x ** await y
	26			26
n	27	def parse_superscript_number(sup_str):	n	27	def _parse_superscript(exp):
	28	num = 0		28	m = 0
	29	for ch in sup_str:		29	for c in exp:
	30	num = num * 10 + unicodedata.digit(ch)		30	m = m * 10 + unicodedata.digit(c)
	31	return num		31	return m
	32			32
n	33	def parse_poly(poly_str, x_future):	n	33	def parse_poly(str, yesFuture):
	34	cleaned = poly_str.replace(' ', '')		34	text = str.replace(' ', '')
	35	idx = 0		35	pos = 0
	36	terms = []		36	items = []
	37	signs = []		37	polar = []
	38			38
n	39	def parse_number(s, pos):	n	39	def read_num(src, idx):
	40	start = pos		40	beg = idx
	41	while pos < len(s) and s[pos].isdigit():		41	while idx < len(src) and src[idx].isdigit():
				42	idx += 1
				43	if beg == idx:
				44	return (None, idx)
				45	return (int(src[beg:idx]), idx)
				46	while pos < len(text):
				47	flag = 1
				48	if text[pos] == '+':
	42	pos += 1		49	pos += 1
n	43	if start == pos:	n
	44	return (None, pos)
	45	return (int(s[start:pos]), pos)
	46	while idx < len(cleaned):
	47	sign = 1
	48	if cleaned[idx] == '+':
	49	idx += 1
	50	elif cleaned[idx] == '-':		50	elif text[pos] == '-':
	51	sign = -1		51	flag = -1
	52	idx += 1		52	pos += 1
	53	coeff, new_idx = parse_number(cleaned, idx)		53	coef, nxt = read_num(text, pos)
	54	if coeff is None:		54	if coef is None:
	55	coeff = 1		55	coef = 1
	56	idx = new_idx		56	pos = nxt
	57	x_present = False		57	mark_x = False
	58	if idx < len(cleaned) and cleaned[idx] == 'x':		58	if pos < len(text) and text[pos] == 'x':
	59	x_present = True		59	mark_x = True
	60	idx += 1		60	pos += 1
	61	power = 1 if x_present else 0		61	degree = 1 if mark_x else 0
	62	if x_present and idx < len(cleaned):		62	if mark_x and pos < len(text):
	63	start_pow = idx		63	beg = pos
	64	while idx < len(cleaned):		64	while pos < len(text):
				65	char = text[pos]
	65	try:		66	try:
n	66	unicodedata.digit(cleaned[idx])	n	67	unicodedata.digit(char)
	67	idx += 1		68	pos += 1
	68	except (TypeError, ValueError):		69	except (TypeError, ValueError):
	69	break		70	break
n	70	if idx > start_pow:	n	71	if pos > beg:
	71	power = parse_superscript_number(cleaned[start_pow:idx])		72	degree = _parse_superscript(text[beg:pos])
	72			73
n	73	async def const_val(v):	n	74	async def fixed(val):
	74	return v		75	return val
	75	if not x_present:		76	if not mark_x:
	76	term_awaitable = const_val(coeff)		77	term_obj = fixed(coef)
	77	else:		78	else:
	78			79
n	79	async def power_term(xf, p):	n	80	async def raise_pow(x_val, e_val):
	80			81
n	81	async def p_fut():	n	82	async def e_future():
	82	return p		83	return e_val
	83	return await Pow(xf, p_fut())		84	return await Pow(x_val, e_future())
	84	pow_await = power_term(x_future, power)		85	exponent_part = raise_pow(yesFuture, degree)
	85	if coeff == 1:		86	if coef == 1:
	86	term_awaitable = pow_await		87	term_obj = exponent_part
	87	else:		88	else:
	88			89
n	89	async def coeff_mul(c, inner):	n	90	async def scale(v, inner):
	90			91
n	91	async def c_fut():	n	92	async def v_future():
	92	return c		93	return v
	93	return await Mul(c_fut(), inner)		94	return await Mul(v_future(), inner)
	94	term_awaitable = coeff_mul(coeff, pow_await)		95	term_obj = scale(coef, exponent_part)
	95	terms.append(term_awaitable)		96	items.append(term_obj)
	96	signs.append(sign)		97	polar.append(flag)
	97			98
n	98	async def compute():	n	99	async def compute_poly():
	99			100
	100	async def zero_val():		101	async def zero_val():
	101	return 0		102	return 0
n	102	acc = zero_val()	n	103	accum = zero_val()
	103	for sgn, term in zip(signs, terms):		104	for sg, piece in zip(polar, items):
	104	if sgn == 1:		105	if sg == 1:
	105	acc = Sum(acc, term)		106	accum = Sum(accum, piece)
	106	else:		107	else:
	107			108
	108	async def neg_one():		109	async def neg_one():
	109	return -1		110	return -1
t	110	neg_term = Mul(neg_one(), term)	t	111	inv = Mul(neg_one(), piece)
	111	acc = Sum(acc, neg_term)		112	accum = Sum(accum, inv)
	112	return await acc		113	return await accum
	113	return compute()		114	return compute_poly()

Legends
Colors  Added  Changed Deleted	Links (f)irst change (n)ext change (t)op