id stringlengths 7 10 | inefficientCode stringlengths 84 2.05k | offset_start int64 -1 100 | termSize int64 4 120 | encrypted_referenceCode stringlengths 111 1.36k | encrypted_expected_output stringlengths 75 383 |
|---|---|---|---|---|---|
train_0 | def calculator(n: int) -> int:
from sympy import symbols, Pow
def a(n_val):
m = symbols('m')
expr = Pow(7 * m + 3, 7)
result = expr.subs(m, n_val)
return int(result)
return a(n) | 0 | 14 | v1:udF7plU3C1woSXQBef2izGMbci757/uWY4DGZp30Z1LELhWfqPzE1rFrKSLDrLwTLhOP6xFUrNN+5hSkAHtLmEnqsfY/32wa1crJ0T4t7k4T05lG8P0K+lw7VmJlz+W492kFqR68a2W6 | v1:urt+1J/KifzWAAX3O5Ru7VZSXFNOIGtz0Jv5zceOS6tjmvgpL26ODFcDSA1aBh9ajP01zIRjTa9Fv82zBqEuRobjOXo+WsCtUJwdnk1w8Yj8aRQDPNaKsNtF1at0iHe6eC0NmXCmljBdDyQ8riT34UVWzX+mU2T7uSicgsAlLVuHXr9m9tjJESMHtkChgTdc/w6L9f6Exfw= |
train_1 | def calculator(n: int) -> int:
import sympy
def a(n_val):
n_sym = sympy.Integer(n_val)
result = (n_sym ** 3 - 2 * n_sym ** 2 + 5 * n_sym - 2) / 2
return int(result)
return a(n) | 1 | 44 | v1:NxbmuGTN4hNRgb1imhCBpOUK9CM8Z++EYM7bkUSyl+OK/qgosF4cxWB3iqEn9jPhQIhx15n+OccaFtfaUFs9Olj2j5mNdXucNLRf/c8oVcujgT8dst2upV/zjvaFMlM1bR5GTcXQ3Fd9Ud1CftIFy/dzZxdlaSGWAM7nnnTGMJIqOKAIoT3EVko9I5Ln7VbhVcePA/YstezbQw6NJnXe4mLwuSFsBB2187jPIwhKuJsgI2QcCJHnxq+PAhaXZx3oYeG0ndpRvEvDI3luqvEHZSB+VzHVK3tAHNsgkCFKj+vkJkyBF/L9ggVzQnUla... | v1:jwkxrtEIoEtSeAVD1BeGBdSr/P1VdZgm0+qEHfFd6aNcoylfavPjczRmzT5f7GEDP1rxTCAzcPhFDZAp0AByxvHWrYeFN60s6jbve6vvPZoxhF3WawrE5m/nWdBmQWjU7nbdiox8H8t4N0X03/awR1gasRXNosriqlRaKjIvNyt7RIIXlkGx7c7cwgx3uYqRglLfkzo97ymhAv52s3HOfjwNUbc3fKeCdRO1T4cV0LQRDKFRsQ== |
train_2 | from sympy import symbols
def calculator(n: int) -> int:
x = symbols('x')
expr = (x ** 3 - 2 * x ** 2 + 5 * x - 2) / 2
return int(expr.subs(x, n)) | 1 | 44 | v1:F1OwTZkNQgfQc7kMftH/AGWueBuPVNLFuRdVHChIqxe0MAaJ/yP9AhluzYqGJI6hv0wrg1dyXUZ3RvFYuGJOLZODjkmz87JzHuB5gYwhtfbXs2Ns2aBO8VpmJdradFjNLn7kxqR4IInp+n8dOs6VtW3h3EOe7KNMF4FSHTUXhZWoABsGKd8v3hmI4iF8fz8OZ4O1OJF37tYXb4qFdveuS6mLRoeeYrePO+ahySU5Ne/I9+4y0Hki88L+bQ4u4vgyWi3fUARHTLYjA2ThFWLId/Dnz6kfBmXjzaTX8XQUhNWi+z08y5LGZF9dsfQDp... | v1:fwy2nard30ZScWFqhJkvxp/FJmrCpUDKyzeY42hrNZpz8GCaXBQDu/5s1F18v6c7Vi3cfb/VYL3fp2VXjHsD2n8aKFLQDodC5x28Yp/0eeOlc3A3qqVaJUlSvVKNBoCzG5xCEMVWJfEaX5dmNt9aIpZD3o5G4Z7wsQkDxfmTLsdRPH5yBeZ4Z87BBHdIcVn4SDCDdckxZcydWM1S4cJ8VweCfKpWWQMid/NbTIm8lTX/7Omkzg== |
train_3 | def calculator(n: int) -> int:
from sympy import symbols, series, Poly, factorial, exp, log, cos, sin, Add, Mul, Pow
def a(n_val):
x = symbols('x')
numerator = 177147 * (x + 2036 * x ** 2 + 152637 * x ** 3 + 2203488 * x ** 4 + 9738114 * x ** 5 + 15724248 * x ** 6 + 9738114 * x ** 7 + 2203488 * ... | 0 | 15 | v1:tUKJBFMcG2V0NI1IprDwWnr4CIB23g5aDN93rqU86vsyBxJdnr61RSpbfzxLaKSz4k0rJeASPSdcGXXJEJZwJm0tqEAF51aAFENfwo0qkRujGIHnzsc+skvcAK0= | v1:UvkO7R2zcEthd6AwUnwf8MKK8du6/xVX4hllstXK+q8RItbEVKLt8C4up5GIm4w2T6thzJ5Y4yV4BrAJb1wCeU4+lhPKjUJSJvyrCtLu2mG7BNE4lDRKquHp8nGs8x5Z5CbANX6+dngYpTAre8gkHlp45TimFIsx0ixuwENljvI6MI/Z8GpPoILKHHyWDUMrEl/MyesZshD4VTubxLPw0a6r2S1xGJQQdPFa |
train_4 | def calculator(n: int) -> int:
from sympy import Integer
def from_digits(digits, base):
result = Integer(0)
power = Integer(1)
for d in reversed(digits):
result += d * power
power *= base
return result
cube = Integer(n) ** 3
digits = []
temp =... | 1 | 28 | v1:Uztbi+6waxezwXPwwsTU+/HAJCYKpNlZZLT82rM/eYSAGUObUkvv2Og33VH+CQOxBAi3aWe6t2IHZETGYbqGjW8ea6IMpgTb5zYq8pRSj2ZNNOvVPCiAr2Yj0T7a9iSbhFUathE8IDkH5ampoeFP8+6WaAWjOrDcZVSG+SbDjJR4ZfWG3QpvtKPfyLOOTroaYAfiSxJd/ZSju73+PyjMSHOVPAYZaQwe0WcWar6mqhrPcb5Jc/fAm8F+SQ== | v1:on6wBfs+9lW8GlCB1+s+sTspodBiOfqV8WO66DmB3yktIbaChP0spkWOeHaOF0ntrPeOEMTNkUUTghQ3XGXv1qN8+vaeTqu7y7s6yQrO9f0wINM2P+KTETCQqvrj9qPss0UQHpSYqlUSRk/p5QX+ExPYUcce1ONBPBi2PRxd1U2+BOgwGyKJ0ucoUPFLw7yDKjE/T2jaZH/ZAMXjk0htuMi6SPJGZKr8 |
train_5 | def calculator(n: int) -> int:
import sympy as sp
def a(k):
if k == 0:
return 8
if k == 1:
return 55
return 6 * a(k - 1) + 6 * a(k - 2)
return a(n) | 0 | 21 | v1:m/Dxv5+cvf5rX45Ar3BG066QJ5GBN7gtQm1MuvG5u6lIThZgq2112tmMVEFwHnPU19UHOFGL5BUkDAEbQgfR5Q3GXyarUnel3SVDoyjdGJD6qvadS+q4A+CCW+hFhnbGJi9HK9Bd78azwpzh/9B9GEqrFOcl5ttRug+C2M4R2s4zfZV2/O/9xk0mLjZXGPhkMaQhamVAtlregkpHV9cQ7yC1yv48bBTc1J8sZ5gzRwrh46i+M42focnHW167BL+TQQM= | v1:ooI1kgQV+8xIPQ8uSM3BhIG/lhUJoyb9xzQUvyLaasIzJssANvd4c5M/o8C8bpkAiY1QAvHk+/X7uDjzkJMfPFdZM6GoLvkfJ5pFMn6cTevIsKLgcZTnkqF4CZ43Qw2bnuZqkfHtlupwr8XrpD7PilpJSJbyGlkljxIIHAoDEtIkM7pL1GWm6K/Pz/THO8ZJxJtbb65+yxhE8/EV9Ujsk+RFfWgIvVNFxkPgEew3Bp1KYeWHdVA= |
train_6 | def calculator(n: int) -> int:
import sympy as sp
def a(n_val):
if n_val == 0:
return sp.Integer(8)
if n_val == 1:
return sp.Integer(55)
return sp.expand(6 * a(n_val - 1) + 6 * a(n_val - 2))
result = a(n)
return int(result) | 0 | 21 | v1:1td/g2Ud06RUyFJ1BcfcqBpZi8NGDMPZLRgT7eZ3CCaB2rrexYqKe+/VLU6NEUmY+beJGxcA12tAxD9n8xpy7c2wvXYJoSsmfBEr1yo4Zpxm0s8+tC51YF0gGNDzp5ChKvnct2g0kTKZysyItkeAh6Er+u73Xu/2v9tpcaE+LMXEdLnpLT8OZn83kaPKHSt+9SCSTcEI2Ee6l8pRArFqv8s3kGGDuynA/MfsCnCv38n0n8cbFTylCNMbLs/tmrMx9PA= | v1:vcR8v3mS6hA+bUh7JcGaJC05Wd+TDl0U/e2ntyw+C6fnahLPuGSR4Fc8LHUP9PssAQGXTxHET+aBUTLtl/G5hBA5Y4cxyBx1a8hSVnpMor41z48aSR4rI0WSCMFDKSyp8aJpF5r+5w2To7y+TXFYRHxe+RoGF+3Gz4R1Z0WZ6KlMD9Pu6h+q7HgCZJA9czWRzobwgWPxtaaoQWB/V1K0bYwbGKlUU8wH4bC4KSJmTtFFjFuzZhc= |
train_7 | import sympy as sp
def calculator(n: int) -> int:
if n == 0:
return 8
elif n == 1:
return 55
else:
a_prev = calculator(n - 1)
a_prev_prev = calculator(n - 2)
value = a_prev ** 2 / a_prev_prev + 0.5
return sp.floor(value) | 0 | 21 | v1:i3y9krWP6s8YSRUZAd3JqZzV6/LuO4wOjauPew9TtjokABIBxysUpli9/cqjHpRi2HNrwD+Fn+We2ww0NuNsnkyVbYg4fTbrz9tMZ1ITVatlZLqXWypPpCZw+/Fb9I7oVnTcV+lpT/JwS+RF35BuaHGuAMRZcBPfDbPs2ZzxHQNCfAro1m9mKJxtJbvhWJ110oIrV3+G2USGBociZBuwx95NCwOW8cr7952DQdV9qNg+V5FHVhYU6Vt4zhsnErMTrkU= | v1:j7FU0ZWyKWhO79VJt8mkeLjFS2cOXoTDkTxaOOaJghQ9OP/3opYNPlovfzVpxzYWKkPloznI3ryMpWQOEf3HvJ1j88D5UbY0nlNDhrIuni4MK3aNATk9LVT9Pixbcj829sYwRPQf95IUJjf6Y2HoJVqph6rnMEq96oaDP56sXlMRi33SDmiYZCsMuY3nuQQFzUt9sEaFW0Q3v3d+ZsXemoL6t+mcn2tLVR9uaJkzSkb1gxECi0k= |
train_8 | import sympy
def calculator(n: int) -> int:
def list_nth(lst, idx):
if idx < 0:
raise IndexError('negative index')
if idx < len(lst):
return lst[idx]
while len(lst) <= idx:
k = len(lst)
a1 = 2 + 3 * (k - 1)
a2 = 3 + 9 * (k - 1)
... | 0 | 66 | v1:ajy+b0DdBKEBb2Ib4zy8Sir43eGfr85Yy1raXoJz+CVbqD8h9U8p44Gqs4DzEymnQNW5BLSn26SkWvKWwKPsx+kakSjQ2OjZyH1hVbn2mTV0wye85LDrjbyd6AVYwDwpzlg/ZYra0EGHMmv0X0D2c4Fch1/Z73KPU2xds5HBzx+nQgiylsZXQ8kCbUQcp5jMnYc6Ke8/TWRrHKvtqFsr | v1:INiAsKXnMI9aZrnW7tX9E5Xju2E1WVME6l9n7OeuO1IxzALQ2ELLYyYDucSW77e3yRhoMI4yuO9ecNinnvzRjg24v95njLaQu3GoRYDIYuxt8cCyE5FssiT0JEv3O+gJL4tSeAuQOavQ3hs1iUE1RUz2SQ6O8tiJpFUTPlaNOxdAZNTMP1dnTkJujnhk7Pv2El3W3BxzBsN/rTjOV1WgCAye5tbYiV8Evt1gDVwhH/Rt |
train_9 | import sympy
def calculator(n: int) -> int:
def a(n_val):
n_sym = sympy.Integer(n_val)
expr = n_sym * (n_sym - 1) * (n_sym - 2) * (n_sym - 3) / 11
return int(sympy.floor(expr))
return a(n) | 0 | 35 | v1:J27T5VjpS88lw4PxteOz/OLcA2hL8ePR35yi3G55bWRs04rGOJcPArR5M5L6oqyNwEQxWNcXIYlWtwzLbCwBqr4SgI1rDHu/K9i2QsUYNMlmNYVhka1/WsPtOl9EQ9GU1OLgivBsQ7CBizr9drlygMNRUxZ6h92cwxPhkoe4UgbYejZAC5MA80hu9PFr3wBMShz5kT5oTIS3yx/G1GEWvVWCeYClgWg= | v1:2KidG1WdJyuNq81Ca/0tm01YQu83ffLenXCiFn+vtimiWL8oXvIkg9KxQ4m4UOkz560cFP8U+3Mtovgf5cAFIIMSkA0kGnHbTDuI9AnyLwlrRVrz8PzIUGTDfovdbQBIqZWhmzlGUA6oxF79MhUW7RZh22O8iaKP8MdCXnLLDVcYrWfucY3/W5ZCFNuG+xeUqozog+Kd51dP/vxxKw== |
train_10 | import sympy as sp
def calculator(n: int) -> int:
x = sp.symbols('n')
expr = (3 * x) ** 3
return int(expr.subs(x, n)) | 0 | 29 | v1:JLQUNs7uN7Auu9lNOq5hb12xrzl0M6LaBvvXUuaN1yhO4fktdgl5jUj/oTxFJLDXg0rNSGmKivXYq1hHAOw9xPQg8KIjTogx9Y2EoII29oJKTXr6TSVd+yeC4gR4 | v1:4F18+l1IKpYiubAgQCqh3JLVbCLvPh6F5idMlKb9dV6lkxJFcGc5aYyw9iQLJuab+p1NiR4tVo31fp3J7V0dmwdCWyy6lx1QNbFlkDReWGM5yfa4DPM6TDerRaMbDIYYbv+kp5UHy/8QHYxSXOMn/65mpmS0ofSSoCykxtKizaYPgQ96cIIS/8OqHmUpOHfZPgHBJbFHc52QKbYt/XtRdj213w== |
train_11 | def calculator(n: int) -> int:
from sympy import Mod
def a(k):
if k == 0:
return 0
elif k == 1:
return 1
else:
return Mod(a(k - 1) + (k - 1) + 1, 10)
return a(n) | 0 | 100 | v1:q04WQ6Bm8s89yrZWn0XJ2fNOov4S3fm3hsSPtx5/ZnJkgBAIkwNKLqoXEHSXz64pP3LL+w8I1AkOouLp/UHpA1vGxaRRQKh/E1qHmQY1FD6KrguE7VHILC/BNsAtgUjcjkkZ6EPoiB7jw1okChh1mR5Zmg== | v1:ySAI91HUWv6RBTwzR5XUzxMk9LxIaDP7CQuJncGp7gfwTaqXpSdCkj8Ju0Br405k+cJZVJrQcaOLO7ZGnToQk9t8Jvx7mJmHS3ut9bHk1suPw2C+XaGM1w== |
train_12 | def calculator(n: int) -> int:
import sympy
def S(n_val, m_val):
total = sympy.Integer(0)
for k in range(n_val + 1):
total += sympy.binomial(n_val, k) * sympy.fibonacci(m_val * k)
return total
if n == 0:
return 2
numerator = S(2 * n, 2)
denominator = S(n,... | 0 | 26 | v1:0XH1x7nMM+fvyYyvW8I9YOHwalL2rTsCw26f/RRTQcTDshnwP0FB3TwFcLp9Q7RDTUsb0BCWmkASO9WwZSALCL01S7sw/PvoeAxRFno1Djl9NxlCVyJssw6t/jZJDvLujUgvnK/amqxkCqmvhm+VhzZYa/PdFzwiCeMgjKmFruv8koxJl8Te+S3GJslRKGd6HFQPj05w6hGZz58yVTTDlmynVNLM8ghS8YgcUtxUVwQmFvm3J7duW9DQpg6+kPb/vFyaWb/U24emJcz+p+uEMN+bC8bXrqztfFcP3EYYJCKqyyHJqifTKUnZDcTXR... | v1:j5N+DFthxElQrWqv4plhhC4DcR6LPIwj6d7nfOlf8zZKQMS0KdvqMuNHiIGRzxMv9phyrw+zEF1Qer2pcMri9VLg3SQYVLFAFfjtP8833iRTvRuCg7PEB23JQQ9X6cppGN9YmxVIxS3Su+ywiYy2ricD1PkyvuNMNNq/aopLIboKPL9nTwQo6O8i5N4gnLJorrj2TRrz2LOHagJ4sw5Ff/VZWIUqEKkj |
train_13 | def calculator(n: int) -> int:
import sympy as sp
def G(x, n):
return sp.cos(x) ** n + sp.cos(3 * x) ** n
def compute_term(n_val):
x_val = sp.pi / 10
expr = 4 ** n_val * G(x_val, 2 * n_val)
simplified = sp.simplify(expr)
return int(simplified)
return compute_ter... | 0 | 26 | v1:xqduutjU5QdLvsc+oKmRaV8dtUf6Iiu1GRHxB3QQJbkw5mBIkIDIATzHbFBDiSgDe7pl0DHJH5YUrxy0N+tPeJbFcj19SD7aJad6PbjCczr4Kr5G3YGH7DiKyYOAbg/bKcNFvxJm8R99DcWjSVd1+e3LKsuHcy9ujW6+efD+ZmuF1cpBJeTCHjeSjhXoYr28TDKDweH1vcSsyzQ9QICi2vat7/LKQ1Rxiiw5yisVq5EFaWK/gJmcHEY9j1vbVXrXzTb/WsBhCLegly/mnJZ+EYS5PS2Cp8AhTpNKad9YvtMXvX50pSrp1vxhanYh9... | v1:mW+9QitJ9ps7sGQmCR9ZlnNPkxpkT6p3Bqgd/1CZ4C+3bJiJ1Qxar1sEu1pwwoR97+3Dp1gWbeuw/pSeCGAv4CbNGzBwbERmYB1Xb0/bvUUJdpYcOAFDSBOk+Uh1ffCJZIblwig3XkkIV3MNjaHjG+VO8rNSGZQbQwHIRHp79aksXC69gBtdpN4Pu4OuHzWy2Ea9uanGat59unvFxf00b1IR8TuQsh+P |
train_14 | def calculator(n: int) -> int:
from sympy import Integer
if n == 0:
return Integer(1)
else:
return Integer(27) * Integer(n) ** Integer(2) + Integer(2) | 0 | 41 | v1:AXQXZrcnu+J6R1PgC81LfuRKp7vy2EVPo3FuQ6/MWj6L4e6Zd733FcJf5InZ103n3TPDUC2WRYYyt/gIo30Bw3oZwluVhSWZA4glhXbvXfqrzRRVRlzTzMXftmrvkfufObkx2QkdF16om3dzs3ea/kQz | v1:wc/BbfqGdYfP/9cik0jWMRLaGGTOs3s8g70mSlpX0AaQcXZWdHs6XD3wExaAcOs0qxMK2uyHaSD0AKaeSjz3OEBUOSxqpsEe5z7A216s+W9FTHuaMx4QkU6J01L2LMD+qv+un7bXn8+wEOTP5vaEZk5hHqKVmrFwVMpP7GPaAf10vgQ7oH/F9gkvYjRFsuk2WzEyiih9vng5PwHKF+VrPgGwq79wE5LA3euDkzudJaTpsxW3 |
train_15 | def calculator(n: int) -> int:
from sympy import Integer
def a(n_val):
return (6 * Integer(n_val) + 1) ** 8
result = a(n)
return int(result) | 0 | 17 | v1:06lWVWbRdEsrxNZIw0i+RlBs+BJv6Ex7pA/Kr4oE+rIM2c2lqepTPQ7pvH6mjnGiNZMz/vvo5pEnZM1AuAMLByGZxH6kdOm9tEsKuf9RsLvt7K/hk07NKcd9pKFOYhaGBydelbF7IFqt | v1:VQnV0WHSLyItTwD4nbrWznAqtNFUY3etvgHCASi7xGjE+TsAnzRIbUnw8HoLM8gBQSA8R/MxYQq5CXQUvH2ntezXdheoRWwF2Q+ERlawPMlPHxjWXYYo18NDBPCFrBiyJKHtE16hCHZy0IhfCt0mIqng6wzMxzOwhVAJIaGdB3wEd8ETJOdvTyZoLHOXeavqcxS5NY/ZSK7GFwAHb3ytPN/lNPSTIC1yGDCY49QHNhG6pg== |
train_16 | import sympy as sp
def calculator(n: int) -> int:
x = sp.symbols('x')
expr = 1 / 4 * x ** 2 + 3 / 2 * x + 1 / 4
value = expr.subs(x, n)
floored = sp.floor(value)
result = floored - 1
return int(result) | 1 | 57 | v1:WC6zT74HAw/LWnSwy3lNMUVhGuP2c7yNx7FP7Y/uaI/OFz1S4mWiROS1ws5eKsR1Gofw1z+WU+L06a9UxYqG16TcC0AJZAnEc6k6tY7wz/NQGdWJdEorxzgB/ZvbcPyj6XuOs4kdYw== | v1:ueDVJsYwbQFz+0tW3YulUr/XEJf2SyKCX7jEv9zoj0cud7aBoPHMoiYZKfIxPgCg3d40ucXBHB6JrE3jMFE+J92mDbuVHVlRLWFDgy7qBGZWCOwuFbKp1WjQ79sFvvI8FGFyG1fsiRWyR9uvxpm6b70a/9NrpNwXx7VTZWUqWEAeAefzjiHLqe7xtoikqAoX4UJAa1uP7D2A8CzewOXciERsN2wCD62vHN3dF7wq2qQ= |
train_17 | import sympy
def calculator(n: int) -> int:
def harmonic_number(n: int):
H = sympy.Rational(0, 1)
for i in range(1, n + 1):
H += sympy.Rational(1, i)
return H
total_sum = sympy.Rational(0, 1)
for i in range(1, n + 1):
for j in range(1, n + 1):
total_... | 1 | 29 | v1:RVSXB9mJQh+CkabgZ9/u7Uh2LQAVDCb6frMqKKK310ajjSzhOVI/e89iwktJRTLCBJnW9Evuuizn4Q9JA3cwy6aSTt/JcQmhUiJV72pK/nOCFfgGDNRG540amd5NB7rKCgZByNcReqXCYLp2gQ6vAQupuBnX5eYBXsibt/615KCI5Xwf7JdEYHyWfdn69MKIrCWtBA1ecADXzNFoVtOAxm1l3J8hvJF+L7bIIhffSGDtUIdxHXdnpO/tm/naBbjtWk7EQOyr5oqbjYokqmY1ySfnuYxIei1/dmYAOmEZRSlMS3NEMpNKatw9K+icq... | v1:8SR1nA4XzOF9Zx9NBrBK2y6dIRP/dE9l70jvYeUM90d6NIa8HwQqk140rOZfWjwqUPPMSMKlLe7oKp+Zhj7BJj7n6MXN1Ys1E/v2eMja+cKKbaiKuyOq4fiFUovnhnwOh6mxthAbxM3zxQUCcAKAAvI04hOPpGMrZi0KJIeGdWSMFN1y6BP77D0oEKlPcGvuPgf/zZoeMwrvS6ns8jxX++2W0BDaI0R+J8nuv684FIR44fY4Hw== |
train_18 | def calculator(n: int) -> int:
from sympy import binomial
def catalan(k: int) -> int:
if k < 0:
return 0
return binomial(2 * k, k) // (k + 1)
total = 0
for k in range(1, n + 1):
total += catalan(k) * 4 ** (n - k)
return total | 0 | 26 | v1:ZDauq/5a3m8sHpqMq6P+yqQcuzfG/dhJDYJQMANoTJbzpSF7aU/vp00NE7NHGG/bOn847kBPdgL6BpDXYDwMk3ITVnHtYBEdeFwPPS025a81ud6Rq6R6i7fw669PHicBKR3MWgwZXfkGki8wsqwlY8QO2TxLmpZ4k0d4+P+V1gr+xA/UJPg= | v1:KFx3zRuqUYdM/pO7XnOXjmXUn/GSrvSc2LdiafrScvMwUkqT0dRfCeFpjaB7rhUIo/clQ4dDEJ07wZB/BtmcfL4U3xd6S1FWrQycwwPP9HSxMeoWYNUXw7CcB3Zq4UoWJVVMBm2j2kgqWxXHPjtmHsPU4tJ/inM7nud7i7WjnJuzlmFHiXBz9E35CmT7L3wBn4FFXjU7mExz7bBlPgQXBNkxuQPbfgE8goTQS9AjVChKGiaX/EJds+9OIk0= |
train_19 | def calculator(n: int) -> int:
import sympy
total = 0
for k in range(n + 1):
for i in range(n + 1):
total += i * sympy.binomial(k + 1, k - 1)
return int(total) | 0 | 36 | v1:t4mQoiigwxqNPqbmLQvZ4j7VM87WJtn99ePs3aSCsowVlupqdhSKOV2fi05y9UOpEJs2T6opPfG6hBbqAjHu+R2wUYeZ5z0J4in+sMLgWbBC7BgIum2jvKRrXZ17hSIzE9vCpQTE7EtIJDVcPm6sE042k21CdAY3A/eXTYq5x0hButyPJsXMCwBGC8ivPg3nqMGuohkhOT/4bkqwFGYhY2BbcuPDzst1e3aoBTsb6eDNUPzeZpr+YqRHWfQU7QV6claBKB9oaXpAd1JTTnHzvls40/dtg6951T8s+u1Ndr4= | v1:lpfzA72pbKzvYIFpOVLFU9LhKJ+hHtLJ+ZlOC0CAy0kXBzHsEd6xC+fX1Z1IQwyK0hNZcNYmqxol6GjM5BhWGdIHoWG0DIAs/n0JXfdDYMpPLpKjhHgbv6yT5l4RsGmTAlSB1mhbyKYVnXo8JzMz0luDyjHet55ZqEToWvAzALMoW4J+Xsh39MLdBt4D9gx0rvfg7NfRcbShefE9X80JQnzkwM7rUqKoJ2GypfFTs60Qwckx/v31 |
train_20 | from sympy import symbols, Sum
def calculator(n: int) -> int:
i = symbols('i')
expr = (n + 2) * (n - i) ** 3 / 3
sum_expr = Sum(expr, (i, 0, n)).doit()
return int(sum_expr) | 0 | 36 | v1:ys/dmNN1Gg2d15XYKzRO1eakAzdaTE/2xkE86pCfbNSBEhNgUU166kLUcynktgtj5TcnZ3s8AVJxwQnwnTUlNoISL5DLbc/gV8oCGJxpuY0a7CVLtWwAFgZgvy9MfVxMhIb7grS62YgIi8svoyyd6JPiB3thEaicq/87vDNUW3HbqE+JcprQB1Vs0OwABXCHFUYGvIl0sgyn89p5RnMFfM6HUEl+gs8/399dxSzSlplYklv4lzTochGCzKnWtLzMO/bculocuno0NqXqEJMlraSRt0DWlpUGqH7uG64GGh8= | v1:YpU9PiXnjDtvFG8AeixQvphLR6qMfXqoxUXthKSdcCL/v4Pw1bh6Yqedw/MGQaJ9gZbilWkun9FiTcgnp5uzHutPqrKh64RnyGt6RI+bprk7k7ST8ShJ8OKlzSzplY6O3BPJjXDG51BMZi791gep0wCuQO08Cpy4aUc1r9G2HmAXOvTBiCFRJgBarstV9ie3RNvkLEV+afjBZx+aTAXZjo8Fv3dLNZXqHPCKBsAA1cHjODsSohNP |
train_21 | import sympy
def calculator(n: int) -> int:
m = n // 2
total = 0
for k in range(0, m + 1):
total += sympy.binomial(m, k // 2)
return int(total) | 0 | 45 | v1:429EXp4GmTp5zkUj+fQwkkyyY0RjL7GCbhsFwh7bCeF4viF1oHry/WmVAL1UsctnHJ+pGZOGQleGDrsFZM+aiTEYb+Dt9k9jzZeUXwVgCuE+IMhHv0bisa/xi8c= | v1:Zrqa+VL90cEEHIzdLKoPxMPetR7u3Y4q3ezSjDZO58eZImm8IB0n6b7NMwFI2/oCFcZ1xttsZGHrn9HFmPX/csr6xdPO8AjEscaFg+CKXfTsiPO59FDND1zeenHBBn7hMcDZ87fAkuEdWXqIEBz+74/82TUbU2gZIi78ObqZaSN5qTyifrONq7W6 |
train_22 | def calculator(n: int) -> int:
import sympy
n_sym = sympy.symbols('n')
expr = sympy.Pow(2, n_sym / 2) * ((1 + sympy.Pow(-1, n_sym)) / 2 + (1 - sympy.Pow(-1, n_sym)) / (2 * sympy.sqrt(2)))
value = expr.subs(n_sym, n).evalf()
return int(round(value)) | 0 | 45 | v1:3bi3zYZm7F5qmyB5Y4Ehf999Vx67UDbw0w53W8pYeK4TgiD1Iz10mvzGxfUU1+4smitku6J26BMvImQtaMmiqJla45+hLyWmgBWQzQSdnDfMmUNQ+RnqRoVjfmM= | v1:zlwGo2uaK10R3lHxne/r6hBkXYNOFA2x8Ol5IcGEYK2fsGm6ODLhHzKneUAi1n2UEhtDdwf2L/lXKqZLrx/X8E1DGHiouN90WUdDEml+NdrtnCy+ENy4v1M8ggP3DVVIFvS0CBE6zg7BlF/OFK7FJRpar7ngvJZpo0pYFT3O2RL/Ob+AFvTS4By2 |
train_23 | def calculator(n: int) -> int:
import sympy as sp
def a(n: int) -> int:
x = sp.symbols('x')
expr = 1 / (1 - 4 * x) ** sp.Rational(15, 2)
series = sp.series(expr, x, 0, n + 1).removeO()
coeff = sp.Poly(series, x).coeff_monomial(x ** n)
return int(coeff)
return a(n) | 0 | 21 | v1:reJnO7RhyyryVTtdGg3LfOYqGLvIad3i6k1nZN/7LomrZPPVUzJz9EhGxQa6FANNmmU3FmPp8BAGBEWrn0zL7916qbRtudPk6PRBVHECzuLf42ubbuBaXhJ3wECsTVvE/vgNnwsn9v8I9lGn56+C49S/D7kXQDeI1VQd74jx1O5WXR9JN9Q= | v1:DwnSHdx1RPT9WBlKJdL8slUyeO4rTINiHWb3xX7HJhwf1gGMGJK56xmOmNv9JwMb37pB7sdyLXVJG9eD5MFKGI64kLBcRyU17YSE7t6rxbrCD4oHbaZnNtxpOEvAuwKPk5wNzeMa9FMgCr1350J5tbqI9jTsuEhPvGfpfa4+ldES8EH233vzoyJLHYmuMvXldYiLFbRPApkSi6ljTp1I8KcNJSt9nsRXfmGxNQBGQn+CfVpxAw== |
train_24 | import sympy
def calculator(n: int) -> int:
from sympy import Rational
if n == 0:
return 2
a = 2
for k in range(1, n + 1):
numerator = 3 * (3 * k - 1) * (3 * k - 2)
denominator = 2 * (k + 1) * (2 * k + 1)
ratio = Rational(numerator, denominator)
a = a * ratio
... | 0 | 26 | v1:mSYTd33tyeq0hwyQkvn4cZ++N/bBH0fHmU+7yi+vqZickG2ZQUIQ8Jtz34OaCVyC9k20E3YYDYKG5VGirA6jVGNSpuLo85LFKiQ+spE6KKMg8LrUL43vgxkISxU/S72TNGYkb/nKJEcVQNBqC+MtctON52tPIPMN8Q0bwGSgNSsfqpxSrj/RH/GVDopXFhkLS5pXag== | v1:BUl1uxl1Ic69XNwhIXnLh6A9RLSio/w4bMNWQ8E69eq+8+17j3ZTwY0A0xQJ3w9R+2nG59zrCNN9WKzhDAVfgRDUxYzTca/8vZrKe0OetZdt/qlaKaHaq2jklAMhgL+WKRqTDANEFGVuP6eynqNFJTr5WWEK0UEDXDBEOx6jdTLCMviUus/Z9F7g3EuGmuTL5VX/N+As7ykKJCMXTmRT3tFXFZuEO6JFTjsP+ikULJzObDfkkUyS1r7YJFNLLg== |
train_25 | def calculator(n: int) -> int:
from sympy import Rational, N
def compute_term(k: int) -> int:
exponent = Rational(k, 3)
value = 12 ** exponent
numerical_value = N(value)
return int(round(numerical_value))
return compute_term(n) | 0 | 31 | v1:cnetS2VAB1gFbE8X3rBUQvAQnel5D5GChQbkRXKbuIoJDaA88tzhYencquBPPfX7hQQOjgocNAP4e1eUrtISWeD5oe25JT+7IOdaVO3HPQwCkbie055ctOq8sZeW+I2etD39N6yUp9hJkxAsetJb5A/e64UsnA470qCn75eE49Udqr5duJ7uZJqzK2XmiWyTO2BScPbu2r+y6fUjS6FSH2P85nNmcvOGK1jxt10FM79NO/33baqC565mfIK+z6mqbgVFoqJzL+JA22Roblw1R5MPBmC5pNMWzOsk1M62GpIiVTskwOY= | v1:URZV5zwKfN2yUtenK/vTcrm2KXVEw1+LAbyHS4H6yDdXYq2R3ualYAJEYofszQ+xs9k7dUxj7K0+k/zI9EKXpKFfjUxucPaQzkcZoQ10ppjMEiyc7yT5nUr+X42xISPAeZt8dsePuQDmAnBf8r9URcDG6m9hM13pZ2FiYPYuXJPyChn0EVR7grGzcqUf+mREYZJ5TS71TF1Z7Ed272/V8rX3VF3CzMvRiiWzgbigtbE8bFbKE/FiJKA0uA== |
train_26 | def calculator(n: int) -> int:
from sympy import sqrt, N
def a(n):
return int(round(N(sqrt(3) ** n)))
return a(n) | 0 | 39 | v1:3thj+m4z+Fj5w3uZsf3w4OHRG6AxSz24rtIUk/r1++790fHuoR7NpDb3xbCrfBJzbv0QvzTW8bAFtFJr55seEQoa8vIJ6rkI3y91VhR0o7fWlSpdpOWtRGfKRW3fXebHYAK23x0Bga4st0CFXvjXrLbdnb2U0+xz8+2n1y5YqhDTKXm4NV7Qzi7MzBgEzByndjFOqCvUaF7X/Ps8tlaO2aCBOoY1JfXtMPc9mYrhe4uo2v6ioXLwC5WdMv2RJ585DLL/9T0WxRVwswka7lOVn/Cb7UM= | v1:ZWP1S0xMK25Vsz6wsBb8L12Gjf/WCOKFzViUjVrQbBS7sbVP35ENx3AgBefV5mMWfiIbXhnYlb7jfIPAlsyrBIF7Wtboha6ia66gy/XAi+W84VhbvFNk5rTcj+6UgKboFR5vzSaCZjjzbTCiCJAU56AdfUx6zr8rhdhnc7s3hQv3AxH2E0U7ej/ZTxDe6IXCU9dv/inzvBQ/hsxJmW0tgkcS2Bq41iqYbDc/n9R82LDcU0v7wIa27hfOmtNghF1IYs8IrIERaKVwgg== |
train_27 | def calculator(n: int) -> int:
from sympy import symbols, expand
x = symbols('x')
expr = x ** n + (x + 1) ** n
result = expand(expr.subs(x, 2))
return int(result) | 0 | 26 | v1:5CGegkkPUX/BN4eEK4lZg8Eh+wHbYS21a7V09nl9Q4kopzvGDzu2N98zGHOpVCQUEK2wdS6V4qjqAQytegpFsB08bOIfEqLBrcfAbpJCxU0nCKkS2CZg5jr/nZm04NImSOd9Y8MrBwC6plA40hz1nS81fleJ9T7HnGlHQ2AvATCrWoD7t6ZylDgikVyKDaEuNXlStpX4bHhTIa+dEA/tXIo= | v1:tZLJIYeIvOFN0gDoykLaGqRmT/h+zAfqGBGYH1gk6oIOWzJAmKA8bznenbW+v42GKxUE4c9qzMEFBhlI4TStUZAAZrV8jsQ18HEc8jn6CqPb4WQ03roo722Ur6sz+Mgt6V87vzvmHRvj+zcc1KtrpYMf/xNJ2lf+iYFAFZGkYuk2n+AMUJg0XyMkacSWo3wmxyYeV7QhZDkZ3LK+PACiyqKn352ftA== |
train_28 | def calculator(n: int) -> int:
import sympy as sp
def compute_a(n_val):
k = 3
if n_val == 0:
return 2 ** k * sp.factorial(k)
else:
n_sym = sp.symbols('n', integer=True, positive=True)
a_n_minus_1 = compute_a(n_val - 1)
return sp.simplify((... | 0 | 12 | v1:pYKMIc8a1DcXPZWwGo1uRaVaWciwAG+Ms0W4PveiwfGsJOS+Ds0y3+NrAEQhkvP2Y0zMfjGIF0tRUz2omlOXOrbSa6F8gT6D0xj1PUGXw7HcxaaSWEeBMUyIcmcw8DaZk4b2jwP6uKu+VVWVPEuFm4dzySA+zR0Yy4p7bfys | v1:DokQQoGt7SMahykd5IvrlSUQbjTGOdO/iRtyrQcAhaPeb+8G74zpaGU7O5Pj/8+uwNFdxfQwHUrGzCHuWzubvJKkkVnFg++hymQfBtmZI73A2gpAle88ncMn1lJIaMTyXlmsGCqqsfUtG6sLOFLkVZ678u+T11F1TSCOR5hi6i2QFQCObkknqh/NAbyqKob+PQjA |
train_29 | def calculator(n: int) -> int:
import sympy as sp
def compute_a_n(n_val):
term1 = sp.Rational(n_val ** 3, 18)
term2 = sp.Rational(n_val ** 2, 2)
term3 = sp.Rational(4 * n_val, 3)
term4 = 1
term5 = sp.Rational((n_val + 1) % 3 - 1, 9)
result_expr = term1 + term2 + ... | 0 | 50 | v1:5Rcs8fXoF9gCS5M0lAeCPunNDIFtmTQFVyseOeDYi4R8bFJS1BjmUQ7cJuDpq3FgL4eUDGBSbu5nrWAG7RFv8/NK45aOpVnlFOJrEjdxkiPdnlqGLU1nXbVKi/wRPHxxoxFwQyiZxE314O8ATxsPsA== | v1:JJYg8n99Vd8gD2rU990RHzjXG0/uW+F8gnCAD9cwgJvVwoEBL1G08nHS3f+XDMcKLHMtj/uooS5tDcU2msHP75VuImzFKPAGy7o5txnmR/nsPj5xg9F9vyFuZc9BaHN9Eil1KBfS9ULCwdp6AFKeT6M/iHF3SWhcayDabSS1+wM7mW5cwY8TDFPhkBemgR1BuMjC8xz9BaI/ZIp061hT4CwDHVoK5xhm1/KNL0sFmPAFtIfE |
train_30 | def calculator(n: int) -> int:
import sympy as sp
def a(n_val):
total = 0
for j in range(0, n_val + 1):
term = (n_val - j + 1) * sp.floor((j + 3) / 3)
total += term
return int(total)
return a(n) | 0 | 50 | v1:pviBbOMtJ4IE3DMLMxjdL8qlDUqK6TE6i0+q14hDwCP4bsM3hbLlTl3C+yilvIG6LHJM3T3nv5rBYsw0sFXb4r9fbyDOLNMV6lNYk38XVpgBx0+rC9JKZDRYzRphd16LYesVgHQ/x/h5GU+CPRXzsQ== | v1:OWP9N6zUj260WUDUH8P/tJglICoS2mXIfg7iVyG5avz9YSa4ruDD5BvtRPx342/7OM4d11X3bCoXeKmAtveTfwjKwAx31XKy4isFK4FjUsEgXtAcHdzsb1VquKNZKahBxGxISRFdgMMcbM41T7AG2EH9JfUx3377P9IGiYsB0B2ZeKpMuUYC1rETOubsfbOBRYc/B8EtMyIfd7EqxImsPKdVXJoVLdbViLLeqA5YMaHsVgoA |
train_31 | def calculator(n: int) -> int:
import sympy as sp
def a(k: int) -> int:
count = 0
current_n = 1
if k == 0:
return 1
while True:
for m in range(current_n // 2, -1, -1):
coeff = (-1) ** m * 2 ** (current_n - 2 * m - 1) * current_n * sp.binom... | 0 | 56 | v1:wBmCgYQr45bW9gziEW998Z98hwvRO8Djb1BoCe8W52Fj3VByVIcwnHbIw4Wtno0JDTZuUpO0ASkXe9Q/sre2KkCifpBAhQMqF9ApdNh1iQYgvoeA7V2+ZSXcVFDiwqsAhkaH3WxbgfewFI4MuCIUSG8/7eICxcLYnXzaKNvh6RUXUol1i8Im1L3Wy3TZP/QNCFQfhiyRrPR0ls+AVKx8SNJKlG7j5kQqx7rZDHJq6CNBvxVxAa5PO122LFlexxdzVLfLPG6Cm7DVNOQVCTBrRsuzWIuqtnKE8S348k0A2sZBtvKuFafWaWXP52HH8... | v1:njKwqY2mMnHuvTWqQf4b62uvC5/QKLIPVoRe03KUAYP+tyhysCDzTPY+TugYxhPfyiZr3I2nrtioCVApeRMXonZVaeG9B6VFpOJql9dLrnpZc0axUv23dSNEf++C1vl6FqpLU7Dnbdsdga5+6siiWt4zTBLijixdCmxr6v062xFjtjL4VfTTohf+AvM4BEpaO/nOenM841CKqrkgrhcTf7TgSOjUt57mL88WvFy249JPoCIIRjg= |
train_32 | def calculator(n: int) -> int:
from sympy import binomial
def a(k: int) -> int:
if k == 2:
return 1
if k == 3:
return 6
if k == 4:
return 28
if k == 5:
return 120
return 2 * k * (2 * k - 1) * a(k - 1) // ((k - 2) * (k + 2))... | 2 | 26 | v1:N7Tzz2Idy57u4bq1r6/jftW2p7GTjAIBTOtzLqaGM8MDFvp7xdkvGrDyNO2m6amA4k4xDoEg+GEMkAV5P/t+mip30Ugl0HUIA++CBI1/CpVcGOwfTw5cwHS8JXcEx084t0LNey7nVdQ0rPERrkg1c8DXlfWuMtHHapxJuw== | v1:kM+DfipndBLKI3SCyA41mNNvawU0pRFjKrNksffQNBqH/DT/TrBmbVEn/uCyOAZYS3PpQ2jpIz7mReL4gScLiWE+7s2YwTy/SIM+XmMmKVP8H2Fh5AS8gr+ORwBF621f3hhynBOHur9jGGlKcE+cxtl/SrYzXS/+dD0WueYfLfjQBsQmv9ONj2F2YRmBKBc3ab0YY8MmYWXfMBy3t/BrdXeiZSkCtR8ydKDdZ4BWAagMckqlh21tjnR2bFQM5KUJcA== |
train_33 | def calculator(n: int) -> int:
import sympy
total = 0
for k in range(1, n + 1):
total += sympy.binomial(2 * n - k, n - k - 1)
return int(total) | 2 | 26 | v1:Mebiu07C2MeuqzpKKP8oogWaN3kA3q51ThV3PZLY81VwK1lfZLWUdKHl9fqnQrVSGbJlUgMSOBQC5XJXGZv1CvThvlU4gmm+wiMzIK+rU1dlMWZ/NH9wTTDE4MrSN/j7TCjJThg/9Zp8c5wJ/igjJQUMVlo5Puevvi6XWg== | v1:Eo19rASbuTGS7ojSsZClG3SkFW13RrpoE3V40Ju3OCIh/57A8sMiasYQdpeeQOLaMQa+7UcXTue1DO6crIahJi9rqKWqxMzUG87xrwM6PMkSzwuQQR62YYG54bSG/B2wHECwxSBifPiMgzH+5zQH5Izsr5BUrAdHtszyig0y/MzUSoEBM1sBfWxz0pdVvZ7S3ad+684VIKVYUW21qmzxvWeAZjWV5/sseYK0En5x7IexjbO7RPruw8Ui2VRIyhntJw== |
train_34 | import sympy
def calculator(n: int) -> int:
def a(n_val):
if n_val < 2:
return 0
binom_part = sympy.binomial(n_val + 2, 4)
prod = 1
for i in range(1, n_val - 1):
for j in range(1, n_val - 1):
numerator = i + j + 4
denominator ... | 2 | 26 | v1:lmXgyTuJVQ4ab+59M3FPLTXoIsWzv00Wo13HPvLYNw2mviJXQWL8FjIRL5nDehRp2j5AkSxUyQrS5UyudrJ+aDw0ZT2lw+U+DtiVnFNNqefzwgSPZaUPLRTVYz+jLATSGkOJoHXEpZ/iiUcqSHUEuHt21DDqDPaS5QKwfA== | v1:Cj8G/n1yVq3oT0yTVnTm42Mw7rQ9ddKCYWeD5MztENy6lLmNLruDVth7vhAa7ZGLLNeFkoNeSBMmLMNGoJfbXa8NV6vvFcYdaAxdo4yk8gimrfxN8ujbZhtkBQjaROOlcsaOZB45B+X0G5wbWMy14FIAOXxQY93TanaqtF5vaDjzu+qWILFKu+eSWi4E0Md3ZbhvFhaMNU1pNNif5YRFmfFIAmnzFB21YndtCP9DLBmt9LbvHx3pgi8U5gQKy2Sidw== |
train_35 | def calculator(n: int) -> int:
if n == 0:
return 1
elif n == 1:
return 22
elif n == 2:
return 353
else:
return 22 * calculator(n - 1) - 131 * calculator(n - 2) + 110 * calculator(n - 3) | 0 | 17 | v1:JTy8KVEyFsDvkgg9i6r46XY4ZvJakbty5yKcnwkJdOAq5bGmDbmOVUJ/pMTw8ym9z15hnBkcjZuHJ1BTxiSqXSkTllqugzD8JvRyriEffMWttOiaGtectdXONXTyFMrsfFOvy5MvfoWPNt6SFK9381i7JQUy8waXktNq8oOCuoRf19cGukCG | v1:BRS/oNqbcaWwwhply7dBP0GQdi17I9weteCZ30wu/mZM/o7oJANGUJPmcRczAkOJo/Hcv+SZ/7HEdCYC8YXO9C8cYz4WcSXoUWOPg0lmXhdVVj6VrCxPvF0JgT4qDBBK3r1D41iFT4h309n+pukqcoRwRtoF6wLnNCTf/q9EncXBnFA99SswDIRV/0QDTJp5jGDEwocqfjCY5qnWIOtgpq8= |
train_36 | def calculator(n: int) -> int:
import sympy as sp
def d(n_val, m):
return 1 if n_val % m == 0 else 0
n_sym = sp.Integer(n)
term1 = 1176 * d(n, 12) * n_sym
term2 = -3744 * d(n, 120) * n_sym
term3 = 1536 * d(n, 18) * n_sym
term4 = -d(n, 2) * (5 * n_sym ** 3 - 42 * n_sym ** 2 + 40 * n_... | 1 | 48 | v1:xYDu0XcXCyFgx82nitGDiMwmEOElmbpO+JXbXmkMsQfWQkUshhShZs9ryV5/ku0dzEkBkRLlPuQF287a9PAYBS2hrxrJIo/UhvnFuvdOZKeaCNz7Jk/uzW8Yf5pLE91h8w8xJus/eTwcX+Dazy4W2HnKyRRYacbhr/aGYbFZF95W1T5J4XfVz4nE4eYVyelyhjcJLDFbV5zCpZKgTqOY+x8YKDyOu+MXbhYnJjzZpBdl+9wkTqoGZgCxkupEAoCSG9ym+5QCQtf1BItDOttNDCtKiltkRUTY4/c+eO7MCK5qb7fu27gkFfss0YPS4... | v1:LZT55WLc1WVQxo3vPMI/LyyHRDNJgfSFVRtj2LdekQOAkgcl4iH8AClNuZwCNf6N1emVGj4Z+8D7j719Xk4IMjRZIU1eVkrdJNMXzurI7XfOL84LlWvt21kMaz16v4c4ef1kHhJA31BxlWt0T/6abB1f44cNHWd7PUEOkrPuo7R9VOCcQYp0NV2QDZijISWtCEmMHb8sg7D3sjbztlfo2NG1zxCghfpjiMG8g4SzLTdLAl0kPXsrRSow2wiG7rpsfMSLFSqO697DHGo= |
train_37 | import sympy
def calculator(n: int) -> int:
x = sympy.symbols('x')
expr = (1 - 4 * x) ** (21 / 2)
series_expansion = expr.series(x, 0, 31)
poly = series_expansion.removeO()
coeffs = [poly.coeff(x, i) for i in range(31)]
return int(coeffs[n]) | 0 | 30 | v1:HfUTxkD/QMRS0Zg0ZljQdqT/Zk3f+UpCKXVgmG4dRhkYIUnCuYon8Y8rdF6XdB3MXLdVi6SQoI4BSj0mZT4IVl7kuxdfJqctli4nEbfBWairUNZXlnNO+f9MRDbdh8hSTjQjnmWNZWVgm4iP3D/MQrBSaj/Ku/8HK0qc4JAJh+mXdgL0C9NJ2Zd/+v5UC5M96+tAs0Ktm5q6SO/kLaJjC414bH6JGZG08CNK0cPl1zAuxHiRUrilLgqweZA6QWt4NXdHQg== | v1:ptEKGf0+LJNNmGLOk9a8lUT3J/EzO7v5aUzn4x8TJEIAzgvh9XNvPtM5vWkhgIcJH7q2dZlA1DJ5u7g8hzxfNTchgNXeva3dy1Kb/V6NuXacUNIeMFo6vMGVko51kQXf5eoiRPVjDq8rPE9dJFRl+/7kYZYzSIdLmeVyT/5ZzZ1NS0qPx6RKD/lZSUgBAIpPs4+MABJxV6WYIsMf8czYCeTzUAXdxo9Aa7ftcFDmyPzYsyhdp2FPX+Y= |
train_38 | def calculator(n: int) -> int:
import sympy
def a(k: int) -> int:
if k == 0:
return 4
if k == 1:
return 7
if k == 2:
return 12
return 2 * a(k - 1) - a(k - 3)
return a(n) | 0 | 37 | v1:IL8BT57PpouEUd4h5MSsxO2WteZZSup6kgKlzT9EmKjsuTk6v0dXNzRD6+tIp/L6kMvHQj3Y02wtXFj/syYjLysILe08E9pMgYC3M/TmAnw9P51S1Q9qYM3N0DwN9lx6KMmu2VckI20YNtDOm4+Y7VRikFvk0o+5D5zeLGErXFMaLHy4C0gfuLrxtJorJyjE007R2k8gNdLxuAxuYMxrklwi6qP/br24cw0ooK/jUAEbK7yyN4nwmj8sLot9DjOukPvyGGae2S4oebm+hDJiMo6KaA7TM8uZHcryw7oaEDeP8JwmTeQ57Pinvn/8/... | v1:nXgJgLPy5s3/8a4Zj5IkG7FevwMX8s20WoTpRwfFPw3be9SJUvItEjXbMK2oemclZxTPayptSY6TcPIsqn5MtiPHLNfqq1nh9TWkMEDyrzihs+6o+A1rsTG3fAukAnOD/qAxFsTXHDypVY+bSlmNnS4OUm/9uSn0TqV0LGfKv2Pg5TjOh6waPeCm4WNKoKc7kMvd7ID9uboS6qXVqbZF5cPTdMUGn1dLNwnYZX1HHNbVN8eWZafQdtEOAKf0LSF2Kw8u |
train_39 | def calculator(n: int) -> int:
import sympy
if n == 0:
return 1
total = 0
for k in range(1, n + 1):
comb = sympy.binomial(2 * n - 1, 2 * k - 1)
a_nk = calculator(n - k)
total += comb * a_nk
return 2 * total | 0 | 18 | v1:85BpOdAAUWuJ5l/ETPP7/ATjPjBLCUCkk8b0mCR3V+IvBFkNW7T2OTK2Cc/BKSdctz1s/SgWEIhJdeUFBGLTeCTK41XKri2z36wfUKOrXsUSPqLx52Kyhv9Nv5rU5EBJjy1CyeJBH+iJakLDlanCTUQisAV1461NLRmOnVaYHSi+h33yFskWWltnucip7y6gpxNI5uVOc1TkQaKyd6V/i9mPldkF6Y8MpITBX6I/89uOiueay3zciDBLqSpyxw46RVnCxzdRoa1Tf5Q+nalmq1RVbFjYlaBAh6Ql8f5eiaVokI/6XsaEQFpE2oA+v... | v1:hOZA2V73hg2Bg2uX3mPEi4ksWRTGGPtCFUCDpIGlpRbw56h61WYgCpapjOKt77OHZwCjFc66QfnsKm1+EEkFNcZVsFk6ZdJd9TQjWDU+L+hRS15I0I8RM3JIwlFHVw13cmsKeQhzU+AeQwQkfOOD4E2+DjF4TnRtogCTW8TfJHTQJUOSj3KLNYAPW4fO8vbS0zSi6/KBLtB2RLtIpZsVtR3JIb8d54Y+cD1xO2IlAKHp86stKrkeOQ== |
train_40 | def calculator(n: int) -> int:
import sympy
x = sympy.symbols('x')
gf = 1 / ((1 - 7 * x) * (1 - 10 * x))
expansion = sympy.series(gf, x, 0, n + 1).removeO()
return int(expansion.coeff(x, n)) | 0 | 21 | v1:piRMDzJG+EGEcezhpAqn4FlzdL5nd6h0wigP1X5X2D6GltxP45zevXACs9mFU49g6CX4EGhq2GGf1F6D0B/DWNSC1NbWtOjz1LXAK2HytKxT9H1yhDsIxDyXueImjZdfl9qV2msB1LE/LjB7duxDJio1 | v1:J30VqfGtJj4TlPBpyYh0eU0jeolC1xzJc3zCaOn0trN3vBrzgn5pQXOqN0P4UfnEyUi7C1PRclDxfuS8j3KHM/1MbH0UzIqxGwD6CkUnxtfYTnQN1oUaNzIk76o8GSn4B2n8OP+C36B9YX22bXPgkdz5plJpVJXxc+9jaAx0NqaqC2OsxwUpiZv5/Xc0EM+OOOVU3B64zfsZfzGiAPNb3ls70wBvtB/H1ht9JSePAyZGT1PwFrqDnOdAGA== |
train_41 | def calculator(n: int) -> int:
import sympy as sp
def a(n_val):
i = sp.Symbol('i', integer=True, nonnegative=True)
term = (i * (i - 2) ** 2 + i ** 2) / 2
summation = sp.summation(term, (i, 0, n_val))
return int(summation)
return a(n) | 1 | 41 | v1:JUqYLbfu/dD3zWhimTHHVmEXbv2HW8Zxkip804N19BCJXUDgKzcGqK3whhLkSsEH90yGTHZwlfBE0LlX2oLG56Yut3F1im3iVB32Oqjb7N1m1HuxjjFRGDbi4T+6m7caXM5toX+/gZwIx72G8j95NncVSiB4mGUEwss8jkN1UAzwi+cnsboswNICXxDlKi5QEyokKnj7t64emrxca/HYPPM8pq+0v0Fxp01CaWqERK9YZdG9LsBKp2XdPSyiaFFQxMY/ZlccAXhLHdTJ5jIPYHP4BWdjtCiMvrJ4Pnkez3srXKVAraH1h/fT1k3YV... | v1:5FBpD/+cPvaBaQ+/ftkLaSvl+4d+1/Z2JJS5oJf9/NR5iP7bDOY1ldwFHXlRPQu7Fcz1gTyBtNmheb9JWYPU6aiEhrjhN4nutU6JXxNA1/CA4TKdvC8I0BzSSV/fusiSxLFHITT9ieVp58wB6FiwmOi/q7YvTv3u8Q77AkxaBnSVENIU/ej4Qu8CAAzJMCaQfylysa19LT0DpZ52zabzec3pEZ+pPS4LaNCzUmISYZAD+QRpKKYbT7AouBRiY6YEBQ== |
train_42 | def calculator(n: int) -> int:
from sympy import gcd
def a_n(n_val: int) -> int:
m = 1
x = n_val
as_val = 1
while x > 1:
m += 1
p = gcd(x, m)
x = x // p
as_val = as_val * (m // p)
return as_val
return a_n(n) | 1 | 29 | v1:NYTkLwYT4VkjQUvG7xFOCuIHkJOMwljgbuejgauHRon1CilNYFLOJI8oyIEY6qZziWeBqVjQsF/525egKarb0tW760nU3FKikm3MI9BTPI1Macvr7iV6B09Ch0QxfBUAgJ+e6HQh9+pBB3cY5JrQN2aQB/Oy4c0E4MVhuyy9UbG4SwXxOVCpVEdh3WjRWALdFKWLmsSyRoFtWYhjxOZaxP/fax5KvQ== | v1:Lo2i/oRjfWItbPKkYJulqiQhtpNRzh58j7LEMdIGhIcwodAj568SS9+6yBt5oIIgljq3OwX3iG30FZcunzkYEUsHcYTBWq2glmq6FW8M5wFUvk6bf+3ncFWgnmTuqs7FdP0YHZgN5rcv47CFXYwIcwHJCLzYidjepYviiEuQ3/vCEY+EcZzbE2P8U8NZe0wszRIteMjxhkZ8J00Dp809fWIC9r0rOw== |
train_43 | def calculator(n: int) -> int:
from sympy import binomial
def seq():
for n_val in range(0, 24):
yield binomial(23, n_val)
sequence = list(seq())
return int(sequence[n]) | 0 | 24 | v1:L3aqRalxqWFBBgTdZj2S1O+k7H0cgi5wLA6qC1CLxRxrjkAuv5s3JkueLKgEDMacgX/fflGyQey2nYO3RLM9xoUNzNe50INL5u/dsfGpjPkOXzHMTLIilz0j4BmGClUz9nkHcmwAui7A4km7XMv1+F+/F0AJMnEAm7otbqoDW8wxxhbFesEoZ7C4vbEdqn87Gz83kW7h1ETZwTnFxLblC24mvpkqAp0= | v1:xVvMyTWZLsKsKuykwlM31/7ijKRfTct4L3MM7k9qEfY7PN8555/vmIWyFYIAKzWbh5dD+PSBmfHCaI0yscBUP7i7t6etumAf16sX3iZo13IfMKUHxAAF2FsPOYvxTI81FqHGUwOCI8FRHNY3TpeIeOokh3j4i6mvO5hBFIfZDdg0RTWk |
train_44 | def calculator(n: int) -> int:
import sympy
m = sympy.symbols('m')
expr = 6 * m + 4
result = expr.subs(m, n)
return int(result) | 0 | 55 | v1:0LdUiMzznq9H9uXhc1VpigXBxlyKiMO2xQunMfaCdvY6WRz65bdeZd6QLUtAu/89iY9xshTPD9vTaCY9spPjkuC0pdnPsqH9joyARvBOZ/yClrIaXH3fgGs1MSeRqdEL0DgGxdX3kxDu6LZXhUdrS8VuJS9iVDHt61T2Bc0= | v1:8NKUclR29IyFr0Yte4k6xrz560qrbVc2ncjxkxbNRkpuQJFckdTsAY5DOYaEQwVQxb/KBvz6DNEdyyHfiAslCJaHKamRCW0r5SOysfwh/QRyyZTvsmTLwrWxJftcgjTncUq29lqX2r+ML6XWuNYSoTQxlBltGNhB8nVjHpksyjVnh/9ob4yKqebSogE= |
train_45 | def calculator(n: int) -> int:
from sympy import factorial
def a(m: int) -> int:
if m < 0:
if m == -1:
return 0
if m == -2:
return 0
if (m + 2) * (m - 1) == 0:
if m == -2:
return 0
return... | 0 | 28 | v1:WKd3F7tpEBb6QcL3w5tZppQC0oa3G9A2ORJhYV8INDTUSEJN+qgxvywqBrIts/Kb8Dr+5F70rFc/RtpIMElJHF/p+28da0tSMIpwYTn797RI9cNKZGg4W50yMI/vhgEUXFBHWv+u+tKkqZdneZ9t8peu2EID6pVR32UeG5cpqHv+t6Vvlod/JtaxhOyU6BvWD9UXhyWnshTiU+Y1rBcdvwtqarERHYHc5ZqKL9Ey3TeQLzRXD+EtzazZc4CtJkMuBn3fTI775v4J761CNib7C616IHPrQMOQqwh2xLs8YYhKtct8ijxp0dRYWnpfI... | v1:wDOKhLrF2pSXUgk+lq9SjHlha61dFP/Za3ImWrud/t/+niaxFUrs5HkuMSVcjR8FqtfWvyX6dLdWxeQ4ulsw/DLVJeA3JqHcRZitUJd+7y3EG9WDLSvYhHcP2sFAXNlQuARqwosb5qLfTFVrKyXzdIWGUJGwbRaW3FpsThwAZoxJGJRxAEQMkWc4xQepq5Ch+eb83uZaxJ6bVBCQdKewKm+fmbNnrltu5CSmZJnih0MlbFy/GQ== |
train_46 | def calculator(n: int) -> int:
from sympy import Rational
def harmonic_sum(k):
total = Rational(0, 1)
for i in range(1, k + 1):
total += Rational(1, i)
return total
if n < 1:
return 0
result = harmonic_sum(n)
return result.denominator | 1 | 31 | v1:kufljYLO289C8/JAWKSxfU3TUxRJ1Ldz89beqFoQQz4P4dm0ZJFboVmol9gqb13JFSqSbvGTRx7IQhVhEuOo4+JRSAYGDZomPtRPTu2z5E60Jo4SMI7XJ9riGVWBszkNAy4jt+RIYYZkLBd9Fq/lNX+S6/+RvXw/DLTr16CocS3PgUfEAjH+OCXCClN8b4lMhFDBTkD8wxa8hU7gU04v6NYE5nlouE2wMY7A1s2S+l6QBcL+d90iHQpTys29kn2ECkFz3L+JzzeERdAliiSHObFZjJG8Tz+mJPV9kJ5K9Mo2Q8hjXfsSJTXooZPD8... | v1:zfTuh97adQqBr9Xpq2yy2n4wRqXVHlcWgHBc3xRASkQwwvc0yG3CcZ9AVzgdylTfB6n7zvaZZpc8JbgN1I8OmxXeK7+nq83JQpbDCf0+W1a0+8ctkFTMLmHz5q2masc+YgtA1LwhryPf4vY5YW/asr6cTrUSkYjn3FRpm86U8+RbzRVVDShorleiRI0T6/sSwS9k2R6liVbkmttFYA== |
train_47 | def calculator(n: int) -> int:
from sympy import Integer
def compute_term(k: int) -> int:
base = 9 * Integer(k) + 5
result = base ** 12
return int(result)
return compute_term(n) | 0 | 10 | v1:a+8XoJR3m3lysHFTmzv+lxaZySwDQ2TJ+ISZO0Kn5xPCGv1TSsy/VhD1gRKwcZG9CfgION1tyLY/Jm9YodSBqJmPrCPjtWTBXjQVh+TJQ644RCme1O3E/yVSpQO88n5NurM22GBJ7A== | v1:H5w/kJh8QIjZdfSdHUg2z3j6VxPMm2Bbpi0c01LLn4JPhAgHnXDVlt1Ku5QyCxCh9KJpZynrVrLseTD11VyqTfh3TpiCDwH9cjDfa5l464OeR0Wp7dOHwwWlEhg5EGRuFjquiZTwLyrkC13kjrJBEwDVmUXbHDlmKicya/cRmp8pBAkKIbmil7NDQI6Zqkc1MMfFdmSRxh9WwBZovw== |
train_48 | import sympy
def calculator(n: int) -> int:
if n == 0:
return 0
current = 0
fib_index = 0
for _ in range(n):
f = sympy.fibonacci(fib_index)
fib_index += 1
if f < current:
current = current - f
else:
current = current + f
return current | 0 | 47 | v1:ZlJjhQjhjdBnSX3G2LO1wzDGeS4S6vO12JLeah1/XmvciCHPoly6hmweZd9/tJ1/wS/or2HJJx35IjdURCu6aoeUCxGrbvpqvaBTnVhyFzHL0uoRakWQgFy0Ce1tOmn9QYxJ3hnf6hPlxjL5+sExTfOXmRTpyW13iBLHCCaTpI/Bl5DelIgHuZoWWdJO3q6LPf7r00OT5XowWj/M/PnfxMtDsU6eIZ1k++JXylZjpFkBUTLdIa7gBa371NT2rLIhyYSIS9c+KtjP | v1:N1YJ9Tnxd/ozHQvy4js8V8yKHYT21DaabRSSb1WoaLYoMxz/+GMXFs/JEsjZ+8P6IttlBc0HzbpUQUptzxbLuSkw4J4doOKXXw/4mXybnMCDYDuNdu/MpJWcyEaBNiXsP8xm2e79CMptkAfcvwGYAdhFKXXSvfnP1kdw4F1/BxehqZwPoipvlVjITQP1aOzlXwdmdnGA2TpRqV2GvJJuBdPt0XzfUAkCIY6M75Jf2+2OWMsbbNlk |
train_49 | def calculator(n: int) -> int:
total = 0
for k in range(1, n + 1):
total += 5 * n - 4 * k
return total | 0 | 44 | v1:U6sramP8rkua7VQ6H25tzJ5ZRTbDvGESfNJhAD8qLwuASPsLOs7SPVimSP7bW15kKjC5prs7Wgt7yN56JAnIe3zY8J54e9fdEuwYjeulYdOuTPAo1mkP1peY1W48Kg== | v1:rb9axXJzukUWqozhl3ygXV27GQKAzyI3lMIU60VkPMUFpMDG1PDfR0RPj7My9PpX9SJHb5FmmXg7JKXDAisjjYPIyhslYfH0ibod5LbuXcIZpHufrm+M+CktuB8/BMR+BnzVD0pulo9e0rWgrQP6CjXQFg0zsN00xZ/67P3Ow1KRIYP2x34/SalZKaVf5128pZfAQtGlzI76fPnMBykg1qeWhOk= |
train_50 | import sympy as sp
def calculator(n: int) -> int:
x = sp.symbols('x')
expr = (2 * x - 1) ** 2 - (x - 1) ** 2
return int(expr.subs(x, n)) | 0 | 44 | v1:HPiNTDidmLRaZOkxXrc9u75IQU3RNhG8V4ul9NScaUK6BrDJKx3wisygMOwIkjYtmEmIlB8P8qDlSNt1aI8qrTT5OSqMieyPia4i91Z9JWpk3ncvnBchYfWrPJUtkw== | v1:+Cecx7Bs08ainrKJv0Vyi0q74g3qWjYA1nNMbxrI1dmt4OcmU4dqsfiXPdc5XgK49TGO6aa23hnXPiG34CCk5JL/fTyjrSG7Y92xjCNQx0SJ8LO+AXusBSh5ywtGzbeKQ/9z7kHM6mE1wMmk4eAWAYSQvoFtBLikUALBL7LKSMXfxZ0Ott9jAolyxHLUt/K8zcpJ+NCU2xnDtwj3GB9olBiDI+A= |
train_51 | def calculator(n: int) -> int:
from sympy import symbols, Function, Eq, solve
def a(k):
if k == 0:
return 0
else:
return a(k - 1) + 18 * k - 11
return a(n) | 0 | 44 | v1:iuNBsQqaf3mFS2ZJwFP8SAR0IilfVIR6mlFvVPIg4BmGk7jOS0vh9zrLbo0OUWxxI7AaPXWwRBZ+hCLUwOh+vQFZ4ETwwy2uKl7D1SLKpiYwwTn0hRocbdYsMMo7BA== | v1:+2B2Vk/aJwj+aLoE/AksTb5I4CHzAyetWezk9epyUntJB3KJHv4WJ8vml3Lds76fVkyA76jozmo47UKfe52hdTbdPviTY9tmLqsCnQDkSg+W4FBniIS5KULEnVYBkRB1oWJzkbJP2xxAUfh/AE2XLhB6q85z5BswJxY1weVSs2ti9ypMO88jlkVyTStxocGNNAtxabvq9TaIrbEWB3knDADBLbSb/SDGmc2hRRxToaXcoWE= |
train_52 | from sympy import symbols
def calculator(n: int) -> int:
x = symbols('n')
expr = x * (9 * x - 2)
return int(expr.subs(x, n)) | 0 | 44 | v1:GvvNN0zsEksFJdxxv3aGOKYYqNccsezEYxnEiK5Hw4Cvpmrnj4iHYRdwnQ00eLGsJnnrkmOmBFjYimDldxD1aLjP6I5GhCXBOPMEi+7b06z5nVckUBiRe7TXNdKaRQ== | v1:7U9Nw/SRo5BVlRwy2vrWLsdBI2uDHUa50DremJBDM/JnPhJ19I2rrkL6V3DceM5Q7n6QNAxyLC6hsed3gc6BwrDGu/Uncabe1Pd9XWrO5whhcd5cQ10b/1zs75iW4M+EwyBztx3XFRZZy2MSmPce0qBProREJiUOFAjf9YPbFNe83RAqDN+mbIa68cTsyLPXovTKpI+oOu+7gqBa+en9AFhXu+bqbra2d25z1sJGrqxe9PY= |
train_53 | def calculator(n: int) -> int:
import sympy
def a_of_n(n_val: int) -> int:
m = n_val
total = 0
for k in range(1, m + 1):
term = 3 ** (m - 1) * 3 ** (m - k) * sympy.binomial(m, k)
total += term
pass
def compute_a(n_index: int) -> int:
N = n_in... | 0 | 20 | v1:rW7N6sOgmT7FXl3s8LEyJrASyxqEmGdvLJB2VBKG4tzPaLaYlz6eAklxDTlBHMiDE5Kj6y19byXDqeVpy7vPt5auKc3MwUyYfrOmxWroV09xcP+2wkV9xxOxZwf1FbnwCqHWzhPrz1pcI/u6b0xYDjMdvA== | v1:aD+qvMyb5Id8fpVN+vqVB9CPSKLIUwOQ7WEk91dm/1iwoDMG8CRU88utHmDb4ycPHkgpYA9RnHtT5/tKyraxRtcgHv/inM8MInAxEu7XXeBM4oMrHfm+efaU+L7D0ux93Jayb3QDI2/K/l2JFq4ClX8BW1z/uEcGcCxSSPxOii/CA91MLlg+8DHD1TT4ISufGDHuEUWSSya2CVeU77fcdVhgZohkIRcRGk7blpYjwmoprx0u6Ej/+THyBVIIf7I= |
train_54 | import sympy as sp
def calculator(n: int) -> int:
x = sp.symbols('x')
gf = 1 / ((1 - 9 * x) * (1 - 12 * x))
expansion = gf.series(x, 0, n + 1).removeO()
coeff = expansion.coeff(x, n)
return int(coeff) | 0 | 20 | v1:OX+KJZASumQiM2Ipvw8bhEqr6wumnSsjyBuArYpzCU4GjWqIIxtFz5eHuZYnImmQCDneGo8Kz4/vjZJgRDlZP/aXFuVZ4ZoHkdqlHjRtCOtsIjKhNnZcHjzOaStIqft+nChar9YaWSVx8X/jowHrPxdPug== | v1:wsBUKX1Yd0tJ8pUvXRKc694vtfZ34SmSs6lN3Xpg7epZZ7rxYcy4ojTTv+JORBPMnKCjDmtJTlGV6MVvHbr8UhsxC44B5acfrLNqkI01rFyu2fZMNbr3elmuNDI5+BOrlOc0sICWyBKsPr+Q3/TZ+T97zci53uhZBies8kVfft5/2GffjNRNYX+k8iBwM6GifucvR1IOyT1JmFndiw8giu98ln39oWlZ87719NgsWzQSYVMiMw291QaG9o+mevc= |
train_55 | def calculator(n: int) -> int:
import sympy as sp
def generating_function():
x = sp.symbols('x')
numerator = 1 + 6 * x
denominator = (1 - 4 * x) ** sp.Rational(7, 2)
return numerator / denominator
x = sp.symbols('x')
g = generating_function()
series = sp.series(g, x,... | 0 | 23 | v1:ZQxRW8KWp4R9NCPHDs3CU4RoVJvBqQgUwb8G5QVfxSgFRCcYFWsojdGVoOqCua5GBRlIQl9X1CYhlajf20WShPVrd2TKKmnm1AuHZ8kEAUJ5X11Olx8cned8hJIUHXuojpbUejK8hY5VODGx5qrzcjkIoUQEvbJDgG/ybTNfZYgIc5xL/uFgpo1CHJLkT0CrbJqB62C4qwR/vl0G+GtJN556f/GljD3B7Mp1+EmRBSmddW6wl9ZsbrFLo8emNXJjNzhAhNxfmJv6LFenl1NOn4gZz/Skr80WfPZhR2iJXyur0HbKXu8e3NO+/pT/2... | v1:N7vxv+htZigxoGquOFKaFMSMAxu5Bg+mNv+CuIRGD6jflcnISaUBfw5MOt+29lDD+e84R0a7oTydlzm9hlk7X7P9cS8LZZlMHme4fbehww3XFmsfC8Vmkr0flRV/AsuWEU2VCVfTuWdAFSQD3+XCiKy9hZGQfpKj+rzanNPsjvcaO97fw0TTk1EELzMV5rWEzEuUctH4A8UQ8AeT3OrKsOe1SK1jxeDwXhHQre63+jHw6k8fewwfHrA= |
train_56 | import sympy
def calculator(n: int) -> int:
from sympy import log, sqrt, floor
def F(j):
return sympy.fibonacci(j)
def b(n_val, i):
if n_val == 0:
return 1
if i < 2:
return 0
term1 = b(n_val, i - 1)
if F(i) > n_val:
term2 = 0
... | 0 | 54 | v1:FvScLKpybMBldk7hZKVbs9vagix09Nq2AkoKSvkznStwcDdc75sO46eImjeMkxOLtsMR3UYVOvX/GO99KYtX7UT8MXNAIU41YcwFf/+9K9HJqCiiE2fGDjseENIt5TDDyqleoOIVoA9AVI2z/AMqZYWyXp1/HTYig+OtHYO+6HOlNY1+Ymu/4ofGvouPma9XnL9GB7s3lCwjnBYCH/ENxQdlvo4t/YB72FHvTvTNiyVrWaKZKXpdOxezrJT8VguItmjj1nY= | v1:Mzkg1SlpEqwzis/s5yq2S2BbNIOIobkyn/Urr/iaxm5b/vLxJ53CUoj9M+YhwOglGFtb7BEUPz8oIPH2zOEFuYDZ/aA/T45sdGEyEL29BDttlDB1HFpbf4pZTpNqxcehLZUw3X4BBfr/O7IJbEynP4GxPk75qZJRSvEUiYUi32/h5I8f/kesYQZpObIGkDXY9goCnFxekw1vm/8GMUd568xYGn6E6iDIA94Sl7r9IogkPCrts9LS |
train_57 | def calculator(n: int) -> int:
import sympy as sp
def a(k: int) -> int:
if k == 4:
return 1
elif k == 5:
return 15
elif k == 6:
return 153
elif k == 7:
return 1330
else:
numerator = 3 * k * (3 * k - 1) * (3 * k ... | 4 | 22 | v1:0Bjb2+NaQWuQ441I0EXsGqUcBu96bR20J6u/5e1c+EJHW8U9cS2l/KDHtOKCwPxPi8CVkDfOMCTY7lJLngzTo9xGLPwmsh+yJ3lszT3Wd2ecSh45Cz0rscubhZeaSk8UqhS36tmTpNunUPWJcz3E03uRKnsxXDU3fgp+K58= | v1:SK9/TERdIfdc0s7Kr/PU8o2zDg+HVxKMVu83jfS2sC629RET/i4zo+Rhe8Rio50F7nKx9tL1PCGJe8nCldTDebv/xaQqUFrXfpkhameP1IBoY2OecZs9oNW3/O3744hxWCDzUkkYQq7HFiStLA03TRQwqNVcgySjXRyJBdlRQ8wHz22DE7szDF+z+tQRuhQ3RMN5Kv5oNaoyqI0Rz5JSU+SPZkF8mdrFn0/I+La3rLzeEOHdt3PAMdb/DoHUbXw= |
train_58 | def calculator(n: int) -> int:
from sympy import symbols, factorial, exp, series, O
def a_recursive(k: int) -> int:
if k < 2:
return 1 if k >= 0 else 0
else:
return k * a_recursive(k - 1) + (-1) ** k
def a_generating(k: int) -> int:
x = symbols('x')
... | 0 | 23 | v1:AAQ0mctlsDjtRUDWunlMeda8T/4o5LUKZDQmk0ZR7TKejB/B4K5cs6PgrzQlepFsuEpDAcWdDjOyVsKtevrDB5LT/nc54WOGDbji6l52Jx1Sj6BmhSY9mLDNBAIX/guqAbNfeVeKTT9sBu80l0p4NlC85uYc4k7oHujxc/aK+snEvWfA1koTZu5X86yMB0wPivrJmp0v/t1v/+XXgwRD93BzJ0lwo6nObUfEkZMPbd+N8zO9NOS017MxVuvVN7Ku/zS/WQ== | v1:XQMT9EY0h/XCxHVjthtMIz9s33sw9Sg8Fh+fRl6JY8wNEirTqCTPbCfJ689aj72Y/tuCLyzzjpBB/KLa4lIlysV+hrs9WTnCaDCX4JCmhYV6irFYYs549roJp829soi0vdqiWZgU5wwiEJproeAA9VM2BNgN8obux3qW5LixNHnTTJjE9b26ilVnR5//t2Yhrg+/QlQZFrEF1HjnzCFSyKJsRilFMm4JpBKFtZ+QYTZ2j0nVB1lU1pVAsA== |
train_59 | def calculator(n: int) -> int:
from sympy import symbols, series
x = symbols('x')
expr = 1 / (1 - n * x)
s = series(expr, x, 0, n ** 2 + 1).removeO()
coeff = s.coeff(x, n ** 2)
return int(coeff) | 0 | 10 | v1:A70qknxmBHz/ZD2FRWkzSNwao6gqZX3ZNCZlUw72cnHCAQ+tzBCvblK+BzMTQG1SpLsnhHeOjg+b1ee2muQwOsI/gQ815VTpctIhj7NtMON5C8Fw3cWBJxhUmzAIngTJNu7C8NKXEnO46XUdUlHslGJjakUBXT4= | v1:OEJiWMC21rb5UXL+Z4gsNwFiSgrwHrpfVzct1DiXE3IuqtWrxFuuB+q+8h1gKHItKkhOLywXmR35iOy1/ku+i6NXzSGIjXVgI9R4JnNroJEoV7YkMqyttItBhJIXTiUxm+GcGiWnCAMyybmmhN3yoyi9C4qyBG6KBojFKuCLOzNPYw/MvZnVC/TUsTDkdRXfV9HEz3zGODbRhXOBeVddL3Rq9Je7gwAltoj2rJXsytvCRbDk+YhE0uKw |
train_60 | import sympy as sp
def calculator(n: int) -> int:
def a(k):
x = sp.symbols('x')
expr = (3 * x + 2) ** 5
return int(expr.subs(x, k))
return a(n) | 0 | 27 | v1:Rw5JIAFPF2DoxoLEdjAIa2ZoVv+pQyLSRMFuk/YZtG/eFsW/cOg/pPk1JvEHi8EwwXDQuM+FFIRX40NkEvDuMIAptpFVnk1/iDRxXIDcuF913XV3vo/9Zg1tsMyfQakkdXrKWCnvPwly | v1:WeKjwsgkQAFRwqBnvzscpkuioIVCgWg8imvhTgqJ/giyvOAOOUrOhLdeUIKpU+znwEsw99jNQuUz5vhQzwhI5n/fVgd/Bi83A0d2SQzaF0YEJjlDSAw09YULqjzIh1jxKX/zy7sL3fMps1xih5lLoQ4dMHxSYONRX2kZmGwQI6cIp8f53bNYtiAqc15hwhnSi/hL1TK4mKOja7t7p/4C3VkGXyayDbDEiGvocewTW4eyWtRuzhb2+MUKH+w2M6EDIA== |
train_61 | def calculator(n: int) -> int:
from sympy import Integer
def a(n_val):
return (11 * Integer(n_val) + 6) ** 7
result = a(n)
return int(result) | 0 | 17 | v1:sNHIHJiu/OuLDVRzgGJbwsdNf+I/ze/5YZK++YAN+hYPeOlZyEOWXSFIVgI0f4WCk8nXPRFDKp14RT+3+GE4/Ot3rCHw1bdcjGxR1cKXF9PCNrlRml29dEnwHSwV3fF0uZYaUYUtp7A= | v1:TWMdx62ZlZKucsTaPSDbWX87o2dEdUK5n5GJgLD5bNoGHBFsVa36OesqlZdRcCMOr7oT/rXWqYIO4+iiBeIJlF2vV0oKed+tfqZcQLDQ67/L45u0MF8+yhdP6GWulI1nYzakoArvlzSDfEENLLmambYmi3VVTdlidIMX3adbAWb7j3BXxr4EgoSpnrNtB4XUCPXOBMRd9IpjfMUpl6XGXC1pU9Duui9YWhaY0i3gqFagD8SiPq8uI4iJMiP3XsM= |
train_62 | import sympy
def calculator(n: int) -> int:
x = sympy.symbols('x')
expr = (11 * x + 6) ** 7
return int(expr.subs(x, n)) | 0 | 17 | v1:tafPrL+t6fD7iFyrSD+o4P0AUQ+eLoUL/UkIkdziGoub+GkwCq6r/w4Jb4IJu/KMJ7L7SzaFwpTqksvubyqoSivZ7EE1fetMnScw4RYpZUSJ0VVkAph24y+HWanhlMZjbpLwm0bZjzo= | v1:mjaL4El9Z1BKLhoY+bFpHlQIEffbjvp7JB28GNhcEti7YaWTQGr9Pibg97TB9Nzq8IJaC2Ty6ko4dSZ5Ars5dVEfQrdKfM40LCA72xv62uGZtV9cS39vOFTGKEkGVo5JFgEzIOHbtPI9KPABfOCEzdxvmfW5wEDrOnTmNDdlygJhlJ8DavduaiS10lsGtqu7qIttnsmKZfFE/puwF0Ibair47G525p2Ch8ebrh8IpfqLuos4C8kytlSdNFILyoI= |
train_63 | def calculator(n: int) -> int:
import sympy
def a_recursive(k: int) -> int:
if k == 0:
return 15625
elif k == 1:
return 4826809
elif k == 2:
return 85766121
elif k == 3:
return 594823321
elif k == 4:
return 2565... | 0 | 15 | v1:1yronQ6XDEJ2lifK0Vrkah8Zl9rORqTgXs1UxRt6Yeevv5PK2jod4nV0a/sFXn1EHYZ5H9uDDCbGcufxd8zVNfRBhWYobZ/EvjxcnHsTU6wlHsWumW8Jkd3BfjOLeGwUBhTASrZsXfFAe1a31gzEORpQ | v1:5whRpECq2llwArkbtaTAFQw7e2mIqLA5g9ZLtC4DX5sxBGv4vL7FFb2nAR1j3/Rsz2yOcAcyzpNUM/AEkH3BHGO1tq1B/K5EOiHEQJ7onWtiFp2Q3o66QBT9G1hp/wnc3KqzlFGtj0ZbxBweacCUNt4VBBmyliDgjuUrC60D8mWVCOKWaHoGY2Hl/u4i8iwOevnWB3lm |
train_64 | def calculator(n: int) -> int:
if n == 0:
return 1
product = 1
for i in range(n):
product *= calculator(i)
return 3 + product | 0 | 10 | v1:oH/J7uLVAn1GXPX02EO+4OLJimXd94mP7Xu5XFUU+VlnUSMPlGmNPKAeh2sc6MSK2wxAEsjEO3o2Nn2j6j97VycS2RdItPBmSxxeUASxs80uKnSp1nIfh2h1A5/jpqLDvwtpMwINJ0BM29z88ASeVJ9MkD/ylcIum1bKTNpjWq2/rTX4Bz8T0rdLbjw6BaubyZggj2qd7BGhhg7w19ok | v1:2yP/RH1NnBY5/eKrH+3ASLeSahU0JWHHjnS6/kLA5YHXjG13vTJ+BR/+ic3RNw2NS9XMWfZu07hC7JBuf5Yoz7hmYIMcUIGIADMbs4oHh+oUeOBNeUZ/iZNoAgKVYX7lu81t7S0S7Z3l5l76XtIO3WR7wR83V/ZhTnjQKHZ6i2tu5mDrRgmwbnC+O066Ls/jZ5NrDhw9EtnX3rNh5xPRJcY= |
train_65 | def calculator(n: int) -> int:
from sympy import symbols, Function, Eq, solve
def a(k):
if k == 0:
return 0
else:
return a(k - 1) + 2 * k
return a(n) | 0 | 51 | v1:mnZLzQthNObwccqqzBfvAbaYeHvqyavGG+DYRM/9KVY7JCZ3Mea3IEzC3bAhGYwYnyMBA9c4GumNbEsz09TGnz+MuevMQeqBlUApwZadLMZTy2ofIQnfC2ox | v1:ZEmK8CZPAm9FEJWa22FGXavyg9WLXWLiDQIFnxu+bkOr898w+5+U+f7TfoIhbODpenCWjCS2tXzNilUNkm1LZFZzRDziBF5q5/nsrcHIrV5TAXf3go/D9NQSfbgIWxXdzXVlrWb5x7hNRBVj+tp4Mcv3XDjhm3dWJZuVveeAzjoxxiM8D0eyedr5lwqvqCy5XecjLN1VSjjkqIoEJWqkHW7/3g== |
train_66 | def calculator(n: int) -> int:
import sympy as sp
def compute_integral():
x = sp.symbols('x')
integrand = x ** (n - 1) - x ** n
integral_value = sp.integrate(integrand, (x, 0, 1))
return integral_value
if n <= 0:
return 0
else:
integral_result = compute_i... | 0 | 51 | v1:9OnfMQv381m4k3drQHQq2cr4tbLG0UXX6GNixkwOaLt+QgOLpe4o9vXand0QliYt5R9GDmEuAgJxb3euRs+GHruB9gfjOQsxGi7I/LaQSH63KPZqMfc9hFnC | v1:MBaBS5P6fdauO7LKBnpy567vZ62emC70BXfsR7QJGHSGYGdA8EdEewG9y2VXUW/k3oEQk1l7tmtDHxQqH9W4DOyOELTYWtBm7ghZaEtfOiIgOiyl8dXxim9uUoEvbDOKQqXWb9+2OwtvHlHP8l4VmHndMLajSPZm8zfmeLZorgIp4mtdW+96/oSbd2b452GYEdptiUFUSLYmYIH7FYYPkLE1zw== |
train_67 | def calculator(n: int) -> int:
from sympy import symbols, solve, simplify, expand, Eq, sqrt, poly
def a_recursive(k):
if k == 0:
return 0
if k == 1:
return 3
if k == 2:
return 15
if k == 3:
return 120
if k == 4:
... | 0 | 24 | v1:+daull+zJ6NjJ5NBw7riplZtKKAH0LfXZYZAdetsNLfDvKPDLBir3sn7YHmbE90hoVARMJRIX3gAshpqeOs1RrTkEz3qa7If/LAggT/PYgSct+psAP6irbNqNChmsKSlTAs5ToTeQn3gKW88V0w1qiWPgwc/MzMF0Eg+28VehpMeAHkjhegUXpyIyRlW62nT5cEh/i2j6dBUnUO25hqzABU4vND21gotLcCAlumhgIuC5enbQce1zeDEJlN8974SOokpGE3cIuDqY521BMPBAuGGhGKNffUO/pF0V6jqF9RHTnxkRswoWjKpt3/zq... | v1:O7Y5IaySUZOIAagqIzzNCph9bt7JxgEg99x4tryO3ExsngBPDuBsf8VLXyIUoGNFEYihxB+4lf4EqiVkF+MXgH3AR/UYLcQKvRuBQ95woXtIPBnub6gr7yyaFGDoEGnd2G8MbduMonaOcr6dg9c4A8WzlJsGxHfa2xUpJvHpIEiIwvBavGUmKPl9mn5/If9/7Z9uBls7cqEWKaaiGANrViQgt0dsgt+ozXJVJFQFlqWbMr6cHq3/msUybFEI9wU= |
train_68 | def calculator(n: int) -> int:
from sympy import binomial
def a(n_val: int) -> int:
total = 0
for i in range(0, n_val + 1):
total += 9 ** i * binomial(n_val + 1, n_val - 1 - i)
return int(total)
return a(n) | 0 | 22 | v1:rJIQU0QEHmIgVDghqn+j4M5TOIEd6gPcFLXIbez57AYbYfYJqdirQOYtE0iFhsQRdrebbgOc2+AC4JqvCT4cVhxFz0NKkI++HhaHvFXtBgYFB5azJ233ugLKynbH3gREQvj0kosbWlI4hvSqD6NC2c2er8BhudFIl5mCoVnZh0/vBW0HqKOjNr0NSollPkDNYPhXKmcyZq6tKA== | v1:qvwTqlbJKY2i+R2HrDDW1mrQCgNxdxanBlCDOKbwG0vwSfysEW3i3w3E6pqyb84T+TvCCN7mjlsYbwnzTIIsqHZhmt4rsRy4OxEQuvy6IMMOk67xCc9RM277EigHMItH7xHLzpa5f1eb+og231il0up1XB+8NDgIH/iNQOA7 |
train_69 | def calculator(n: int) -> int:
from sympy import symbols, summation, Pow
def a(n_val):
j = symbols('j', integer=True)
expr = Pow(10, n_val - j) * j
return summation(expr, (j, 0, n_val))
result = a(n)
return int(result) | 0 | 22 | v1:L4YcbDyGVLyOWP3ZhycWCTx15K82OM6oHbifTmH0VkXRsgSed/Is5uTFzbhrCqji5ql5bTNBvZ6S/SEQ5Eqd8ONsUw3rv8pJFTY3VLX87aOxIJAtNtKQ1cWlI/6JZJf9z4+9NkQA5nNX08sgJYA7h8L5UrbDEwKEAWF4sh5CL1GdH/lCu7iIHqLjs14jKQ1bIZBm9e9VOwz/5w== | v1:USBhZgRoIeDFK+bV09uo2qkZ6ykDJibAMm5WQF8JOVNFeyIFA1jJ/SqO4ptcdU9hTUqfLJzL4BNu5/lEbJXyl9g+MAeIPs1nBN7UtfedNuQwAUL1UKC562kcCjihvmG/EBIHS2u4Ca59pHvef/E02ljbLzorqSIAVnDYdYKy |
train_70 | def calculator(n: int) -> int:
from sympy import symbols, series, Poly
def compute_term() -> int:
x = symbols('x')
numerator = 31381059609 * x * (1 + 2036 * x + 152637 * x ** 2 + 2203488 * x ** 3 + 9738114 * x ** 4 + 15724248 * x ** 5 + 9738114 * x ** 6 + 2203488 * x ** 7 + 152637 * x ** 8 + 20... | 0 | 11 | v1:8OrBysYryMlPObhl1AUbKpL+au93EwvIbSxodVq7t6CjBg5rP+IdVLrcRHioZv85sqmz0/9cAtwRYlmONyqSztVCB8ejnZcJWt7PWuaMIOWOjPthjwuOtRYzaZqxz4xfFN3pOjT0 | v1:lGIC0jHyGMazxIOeF3TGGtpKtvKHXQSxoT/ycfyuujUABK9O9nFqJLrk0S0hLdxWdghiztQWkVMNN97tvX0aNAY2T4rVxCXQq1Cu2z4vwJ80uAJkXOOv063tv9+nhEqyCKEo4wqEkZOUFzgu7S0FtgNKqyOQU3qNTLJNbQkfgfYFdb7gIzZ20qoFRpuIAT5Otdw3auhzyM1d |
train_71 | def calculator(n: int) -> int:
import sympy
def a_recursive(k: int) -> int:
if k == 0:
return 729
elif k == 1:
return 1771561
elif k == 2:
return 47045881
elif k == 3:
return 387420489
elif k == 4:
return 183826... | 0 | 16 | v1:kphRwNHcxH6kfJlsmAA3Y3zrQ8q0phQ4nP2DxeGFDih2tNakvz5G9qR39kk7cxGccIrMAuWXbxIcmUJukN82OqpqmIo7uTCAlNzYBwWArqAC+hgFNsXpSyjH7+I+I/PV3bskaFAuSzuW | v1:QW9amF6zGhiWl+f0jEnXbuVY14OZaImjhKe3mtZTdbIuaFXFz/oApaK4akr4D6568Bz/RPBeNA3lkdGaBEmg6kT5juNC0phDydSDH11cYmn3ALfx3HpNU9VATuWlbJ+ZuQs/s28zKkU9CHiGlm2ja6M6JPbE4QwCum8roH/yWE0WJaX5aPe9/DFWYTDRxFa7y1fy1sDAs9e8njDQrw== |
train_72 | import sympy
def calculator(n: int) -> int:
if n < 233:
return sympy.ntheory.legendre_symbol(n, 233)
else:
return calculator(n - 233) | 0 | 81 | v1:BLGeoeD2LHT1PdNln3HuqqC2U/lm+FBUyiO1/7HJzaA73pZB58qf3hRWE7LhwNBXgOAWq/WIug3eaC+W08BiVW1RczksiTnIGE/mWRrIQUvVo1YmnKTLmz5X/ta4FLGvA3DJbQ/+dLvmKoqefz4zRqfFYl+fjiuX6EWTQN8D1TOtJNqcHMsWP3XU90uQE1AzmUQ9jorxrzKpLjo2wzj9BeqIn4spfV60Y7KK2wcVhjqJnHCWyzfUQG0sLyNj/muS+0m7OtDgg9pnFUfCE4/6P/b0tyREcY63ozlm4ljbVkSy65TPfpShWLW/wHmEM... | v1:q8W3Xd2n3S3UyW/a/WCC8ohx/Bok9VUFA3X5ANcgFSoCfLrnys3pFUJdzxdiivRKgdFvZ6ypDL60T+ZOdV3zvbkJ17Fqm8TzFpv5igQ6jcW4imZLJf+I0AQCRB/8Ig== |
train_73 | def calculator(n: int) -> int:
from sympy import symbols, series, Poly
def a(n_val: int) -> int:
x = symbols('x')
denominator = 1 - x ** 7 - x ** 8 - x ** 9 - x ** 10 - x ** 11 - x ** 12
series_expr = series(1 / denominator, x, 0, n_val + 1)
poly = Poly(series_expr.removeO(), x)... | 0 | 54 | v1:Tt/GB6eI1ifUavLakjMc7XV64IuGWxQER2oUCPM0XTjQxD+a+ppQB5NzBQEVUP42ZwT85JupjYcCogEZQPUM1w/C2BqCLS+l13Ap0E1UUk3Yn4oViaI6tY85zJPcmjl9UurmzwMDCr3Jf9pYv/0lFjYY+IaE+JSth2iRGCu4ZGPD+wnC/gnTNXxO7zeu5lwhRU2UPPrkTlFDDhinR+j2svIciexW0OksveU8/E/Qq09URtnhjtmMtVp01UlMp2D2/ZHSErN5 | v1:pCuN83K3phzYoHH+IgumGYLDV/DSA/F4qOkhitmAgUsUDPGU//k8EIRnfXZjkK0Kkw30hOHVjAIo4o0LMA/f+/fy5awzF7B0DcGXIAt3mxEm/QIxpj+935EpiZEwWryPcB1xtG7FV6ZsiD+3UMsIF4PUa9sKRKjfGYGXgd8zRMP/bPDbUmjuOPlNbm1A//cH4BFca0YYnFh5RPg= |
train_74 | def calculator(n: int) -> int:
from sympy import divisors, Rational
def a(n_val: int) -> int:
total = Rational(0, 1)
for d in divisors(n_val, generator=False):
total += Rational(1, d ** 8)
return total.denominator
return a(n) | 1 | 20 | v1:kJKitRh3uunwuIsDUhSzM6y6sTohs3qvra+BMGsuh+dI5NZBmAkL1m49DyhWKUAm+M4w2RAPTmLMmHc0LbnxQRiPqhydjxnJ+ZBt1IKZMmorzifOU7KQd0Q3fAN8KHTC5L/k+hlSP8aqvRWcjPNKUQ6/NuPLKh7VtgWWENW7OmQrhZFzcWSY3yCQdIu2RRvj+pqMrwubZifWSBbgYIktgc7mQJz5JODhT+1AoU4ASODELIbOORwgYQKxw+pSq851rzWXgLpP6Wmf+3l45cb+16+/rUTNl9eE | v1:fdMYQ+vkegE0fBRDmSfdFz4SM1bXXkQnP1lgdXhihlku2Nup7MOedpBTsJJ8YFlZNJph+3wX792kj45WiMGLv6BMc3KfvEnyBvLcJaBGRne6phFrH8Y9fNSW2rFeM1/gWo0RRhgk0QCdL5wtbWZE78N+nubXGoyE2A8oI0shm5uAqOGIIz8eMWYOMONc2WST2CDnDVhWJkSNLECL |
train_75 | def calculator(n: int) -> int:
from sympy import Rational, floor, sqrt
def a(n_val: int) -> int:
m = n - 1
delta = 1 + 8 * m
k_expr = Rational(-1, 1) + sqrt(delta)
k_expr = k_expr / 2
k_val = floor(k_expr)
i_val = n - k_val * (k_val + 1) // 2
return i_val... | 1 | 105 | v1:eL7eBU5cuXcqM5eQX9fUBk3Yz66FhdLNEY7SJLm+D/fSgtk9gzjEzZZSN2ibujNCrxBHkRKv0gNVU0IjdZYsPDHVhVPghvi7sS1j6B0qkTth0559uws7YCyOImcF3/lezLfLt3+lnsG8+oSZUr5wBa5pr/HFir4wdXF2qhj6+Ck5esMBa7hJApYMPo0= | v1:kxdQuDewyfFwFJgpR2mm3hjh4Q636wyG9Q4VRP8WkPgQBLStfs6pRpACDvhMYDJQvbPtafC1Sczge8I5K3kDY3M6/9XnbeMNfy3/9svfbnC5Gs2fbPZg1vKtiA== |
train_76 | import sympy
def calculator(n: int) -> int:
sqrt_val = sympy.sqrt(8 * n).evalf()
expr = (1 + sqrt_val) / 2
m = sympy.floor(expr)
return int(n - sympy.binomial(m, 2)) | 1 | 105 | v1:lQY7Ykh4zSanVamrn5Qb63/VGHGkTDU6RWMegu7IsojFln+Bl7kqNGV/osX3Ut1NBwz4nz/ugPeVaGE60+qRYU+cugz8UFRCRoJ2uSXm1965ocyoVdxmG87gflwlX4f9tQwejGbLjWZOLTBchLyB10ZfvNTYs1eEUJUgHNLiE9zb6QqUgc6clRjyCnc= | v1:54/SFINTa8LHHs25MlxH1cVAlqw1cS79a35lqt4OlfoG4S5MXJSKCtCor0f7N1jHJnd/+fXXgTPoK/8Gx5nZo4/S04rGHmehVLRI0cEBS5fLiJxDNe1tHcWgyw== |
train_77 | def calculator(n: int) -> int:
from sympy import symbols
import sympy
def compute_a(n_val):
n_sym = symbols('n')
expr = n_sym ** 2 + 3 * n_sym - 1
result = expr.subs(n_sym, n_val)
return int(result)
return compute_a(n) | 0 | 51 | v1:TLCKnuOcoLqkapyDv3m+5zcVey3e3ciWep9rzeqhhjtjwphH5HgpstI3rtrQmutplskUmwsn5Znz2LUryb1e8z0NItpwhXdVFzt3oxt7DLS8Scb6vDiCoY1TNqGSKcrcro0YNskU2aLDxBFxWjcyoicXNM0CqLwaEjZAD3uRWiO1J/D9jKI44TpDFcaKrnWZ | v1:QddPzGrsCjUi4b0Se5b3PBFouF2+bs21pT3fTHBwBEZAoXNTVpkZAJob4RJbd4xaZUClAlarFY9zcHWCub44xmjau8jp4pqNgtbhJCoOXexBvVE+71CCN6Ts9AeNGmtwRRwxFP+PSt7mdnluXTekLzNsvsT1HSWM9WgGoq1xq6B5c9djxzZkAF4GdEGoUpjmrDgTsfaa3fMlSXDdwsUNXy6fGAw= |
train_78 | import sympy
def calculator(n: int) -> int:
def compute_a(k: int) -> int:
n_sym = sympy.Integer(k)
numerator = n_sym * (n_sym - 1) * (n_sym - 2)
denominator = sympy.Integer(25)
fraction = numerator / denominator
floor_value = sympy.floor(fraction)
return int(floor_v... | 0 | 69 | v1:UNtM1yEC1UcOgbaUOjL3baGgBFleHBWyf5oGFWruqWQIMaB3xmZyBE1DyW1sj+TYdJPJ2Rzo1gDGQrzxM78oOpmYTCT+/copfalMoxabv9hxqybH7zMNUwW0xp5AsdI8p2H5RzUzxYIPZA== | v1:iogdyW1zJDUEHaV+A3gHHA8jBBCafebXEbU8wqnbHuafQKILXLNVng6WiI5kmENA32aKQmM6FySmra3LUFU2TTlikS8ef4GLMpTsh8vUDHjUrljESdBxNKm4G/UsGJ48y/vFxJ6XMQRBEge/zpaVNRQ6nwmvFwDBnK8ypHC1OAm9mL4Fg52e+vj/qxwyrAqHh/d5HohkK8yF6bH4BVxgZ8XR9Hl+S9P3xOiXZT4IPo01PSNXcsR1KXmF1B5TLjW1Nq2dNT66HQUL62PzF54km+xLuDg1mdhlTwprkWJ6vg== |
train_79 | def calculator(n: int) -> int:
import sympy as sp
def a(k: int) -> int:
if k == 1:
return 2
a_prev = a(k - 1)
inner_floor = sp.floor(sp.sqrt(a_prev))
outer_sqrt_arg = a_prev + 1 + inner_floor
outer_floor = sp.floor(sp.sqrt(outer_sqrt_arg))
result = a_... | 1 | 63 | v1:nS8Pb14Cj/m3FmUBkWrtKijSvv1+hcPCCNxjdqnFUFbeKJD0mKLFtyi6jk7kblsmkLW0veTJvUBH+06W8SVXH1G1nCvRKKshcSyh1fG5gWi54p3FbTYUichHv0MZkUu5IG7gWJ+WrnZD8uW9Nn5m872u0zKrG8O/RnmPnZW/SW68kR6PtW/wbDJspHL4AQJVN+iMYSUlj5gITaodKmRq1zr0nA7EPIK+v/WTeopNKVfKkRKPBnEUbaI8EsZXa/jtbrTjNEVxuzCKpJ/b4gHulY94xto5T+ywvu0LSN92h5jxsAeHfLeL | v1:KonQnRgjcQzeXbqpePkyuDN98ENjtVQxz7rHDPIeqUs8JjscvGihP/u7Q6w67HPVhGRf8ItUv6aDJboWgGatwa2vdBpjcQwwpCrthRUu6OfYMDIhFmijKCNTsmbU0xDNZu8JGS74jk6CLmtn2LxSNNrGzeJEHA5DmurdXXrqsJL+IAhxzlCPL1pZEGljJXXko4Y3+3XYCJQJxKnauOiA1Jj09Kt/Fp+sp8wEkhisjT4zjJAEKkCKEGvoYMY3vIxdnXwRzw== |
train_80 | def calculator(n: int) -> int:
from sympy import series, symbols
def compute_term():
x = symbols('x')
f = (1 + x) / (1 - 11 * x)
series_expansion = series(f, x, 0, n + 1)
coeff = series_expansion.coeff(x, n)
return int(coeff)
return compute_term() | 0 | 21 | v1:61zL7+IMQw1t5Vt6hrtcLjX/hjGJ4vjfTg8TF4imtosiGkXVfoH/uhixFFQEgO1DDO6mHT8ePL2cj8eMyDenfcWQpClxdSCr0w78bcB4Jrtw/gjNvn6Rxi2EHDSumHGjckhbpBmfn5XzBluRT6o= | v1:acWLbW3ca++MUjTk3+E3fyq4ceSqVqBIqiQv7M7cyicb8qlH2vqDaJjD0qUy0Npt2gKa9q0ouY8liAHYgrg+0wCsnNLvkwZSrZyxpOZnJRwMjwdlGsGQ/vMa0jchIGzD/yDW4FkhnerFLLM4i7z7J6efBrEHDYxlym1e+4WwU/gOUXKxHS5Zl3f7IS02F7YPr49wTvSFZgeBqI/W1bA+lujls/ORxWfzUAaIhHk3F/nmMks4lTlJRRMtuQ== |
train_81 | import sympy
def calculator(n: int) -> int:
if n == 0:
return 1
k = n + 1
b_prev_prev = sympy.Rational(0)
b_prev = sympy.Rational(1)
for i in range(1, k - 1):
b_current = b_prev / i + b_prev_prev
b_prev_prev, b_prev = (b_prev, b_current)
fact = sympy.factorial(n - 1)
... | 0 | 23 | v1:r0aIr2m+6e/9hFWdtvCGL2VQlnV+c69E+qLhep2ncHTCsqd9EvQtnGtJSuRDYZVDrrSQncFLJmmv67QBz4FtGpxzenALNWumU84CJWRWQ5ol1vEm547n6EUev7uDWLXVgHiVj6e+cDcgIVVzKBnM0/V7kJPUBHdyO3uHVY49fx2oF8jqFwloOXkaI/TqZh+LjcrbNn/48bb6ar1VE2+YtSBn7FquGdsa2YV8Bmlmp2+X4aBKNjcpkhbKmAFtvctXb+YFUDBuwybzkDIx0pvh30QidNt/4YX3RBkmfYaUvBmoF6VJt+K/Sl18rGs/h... | v1:BH7yov5NQoptOgNHjztLzOzUMm3Y3erEzBtY8dIM6zgapkonZ1hapQENZjJdwTflwVUyNNSkQyPQax5kCiejm4gTm7C4IglRRiDP+XjbVIpvP0V6QmUkGAU2YvYU7KzMrMMc6SqcudQbDJPFY4b5as81De7QQX0V3DXai8vMOjzUhnblmKGq1Vh4txXyYu9AuBp2iRO9ZiAYpB2+4EnmtIRbq4JQliBCWZMfzlI= |
train_82 | def calculator(n: int) -> int:
import sympy
def a(m: int) -> int:
if m == 0:
return 1
if m == 1:
return 1
if m == 2:
return 1
if m == 3:
return 3
total = 0
for k in range(0, (m - 1) // 2 + 1):
term = sym... | 0 | 23 | v1:Kdlb11Wkbhw0d83pxnLdwvrsO4eMPu1um0ig5R5heFT+U4wsUHmIzy6ruOp3bPfRSEzkxxva6AeVljlritbPwnNLwl+ULbslF7qwqjSfgHD8HZYrhMV/aDK9UhxI9z0yqilC+fFT4ih7Xn7XAQY1cDB0dHLypVs3XOBM1rEpQgxeiD7aLWWoT808ArsRK1nlUPGlz2nszQqW8RnLmYeHqoxc1Z+YuaG1mLnvjM8XtgLzuHscmaguXxituzLUUnNi7iVq2PxozrUVHlDlcNRQxndhOop8n3KYIhPQJbuF0wH74YZ8rz+FYm97k0laM... | v1:heG+gHI1j8yj3nGYj5SoGQtNxZRcwxEq37tPSFDisk1uuuynAISPodBuUJmRJldk98bGyDkw/8NiiUY5UpFxsgSxoO7LTzEmIrA41uHMlU02wSUc8cQQBsJXmMI2/eiycZ84TjqshFuVEhBSlzJ5ELL7pTqsMcWd+MoeXYvyB2GVvQWQDRO++/QylZBjOYFpb7wbmfNEO4lvS9srhmCgOKUD+OjJhsLBB7bKLTA= |
train_83 | import sympy
def calculator(n: int) -> int:
if n == 0:
return 1
else:
return calculator(n - 1) + calculator(int(sympy.floor(n / 5))) | 0 | 60 | v1:EfixjzAxzRiE4rpKOtDMoVcEANdsqthzEvko9Zz5JOcKSyRD/MTpQomHPI1wpBF6VvgzgmqONeouHvjsV9ntw1mNvoogRVWBhOBkFyorSnAWyc3NxeytmDGU2EKUJGC7cFh5Z1lf9K4C21xn1oLeod7rE6cKvpSPlWK1ju4ewZP5s1Dydobg6TvfyIbrf3m0eHGL/6srqA41g9X0VBV/RSs8/3s6ssXWmBpzN0We6cx6+yvcIV1E+18t2e45Qm2uNLZKZmH30Fx+UXeMqQIrfQwiA3CXRvWC1CBNmds6eaPeHsb1UNI= | v1:s9yXXfLeJN8x6vUeM7Bp26e3vw5BfqVPrySXmgW2mcBzOxZwIbmwAzjnxTlwKNauSVeo+IuEY5lN2r+NtcL+J+Olaw9yDozQ6/2INrb2mcXqDEJ9ft/Zz0NaX4/NKghcjqZWTki2p56OiHOH5m6rPlHWTsbF71EqmuWe0MvLOZ+/uKiDt9AscPTXubLTG53TxxEcJckxBUGFiqYMKOL+fiIeGzMrVgC/nfAP6VI= |
train_84 | def calculator(n: int) -> int:
from sympy import cos, sin, log, exp, I, pi, floor
def a(n):
if n < 1:
return 1 if n == 0 else 0
else:
return a(n - 1) + a(floor(n / 5))
return a(n) | 0 | 60 | v1:R18OtjVje6b+nc4wLgh7xhJZ3qEzvxG4848VFUmUz2LPtpoMiwHk/ugaq7iRy5SZqLidRXh7AgUlUT6CgDnTPfAFWMlqJIdX5+8fcRwk+H/3ZVfc2lslKqB2KaSKfnS0Uq6IZ0UtYN57BsYfS5f6geoo967z59I2Ml/2fBbbhrj82EEb7Qaiep5WgHFjkJFJJAhXxf6D7GwR5i6CVYnGgMnUSWHncrtFDA6VnvCtq8ia04k9QuUn/ZhpYckOV0CazM0NjIK6R10U1Yl4qyoys2X6JGQg4jZFSsGUpYcrZ/QO/TAf3pQ= | v1:SIo2PCJF/7X3h7Zwetk78OcV8CDsf5dB/6jtUYFNTmPFbVMyB9Hg04a5b1WSp6aj8e8LF9eIq5wY5DRMWM7kBcPepYG4v3FD5EYJucneGRp5Eui8b4V4c44wxKlzkDqoVs5hj5cqIRoAP/Z7iEu8FA1pkGQ48L7nB0DDsggl8M1DMdOifON4FAXMXcOF6dxERMb7rlFDITNWZIN65AVXLz9yv3/fBqiVb6KXe/A= |
train_85 | def calculator(n: int) -> int:
from sympy import symbols, expand
def a(n_val):
x = symbols('x')
expr = (6 * x + 3) ** 10
expanded = expand(expr)
result = expanded.subs(x, n_val)
return int(result)
return a(n) | 0 | 14 | v1:Ta6ePpH3h3/NV7JLqnFMKh2ToLt6WjKOEuSv8PI7a2kKyeR3ZvHkRWYvyKcUkD/C3Q+AwWAexv9qOdrxX3C5CtJb0AmyTyJ5hMINTF8P0L1fqrmU4dGNoKrmZjKMl9DOiAq6wJSRTA== | v1:d54vqpRSpZSfcI4p5H5IfQzXBjggWCa1WFzF9gV8jpq9Ap0hd7WOGwcLtNB6vkTuP1kYmCJp1g3wFU+R7VHDRRSBW+5G3kefuiVZrcX61Bikn/FvxdmD2RmAL1G/X3CBKhHI/iL4XXow845q7/IXqEbKcOJKQPlfLGnKebDd1fUsk+L64IfuV6Cc4p+9MuPPcYolBtoxY7iA2PcUVm3TXlOUp6xBauKWZ2ddoGhJ1RO3aQ== |
train_86 | def calculator(n: int) -> int:
import sympy
def a(n_val):
if n_val == 0:
return 1
else:
left = 3 * a(n_val - 1)
pass
term1 = (2 * n_val + 1) ** 3
term2 = (2 * n_val - 1) ** 3
term3 = (n_val + 1) ** 3
term4 = (n_val - 1) ** 3
... | 0 | 41 | v1:PShu/DKIhk1iQmaJCqBZc2zP8vBRPKUGkLGOT2VLOFcMx+CDlvzibxmnzFL/EaCX4mgBqBYIKUcvGSDQpN1sVAQ043Q2fhAUnZX+7MzdRHWqMB7hhk7E26pD4tloEaSO09aaXoSWPMMEydIfSA== | v1:nEnNX7BrY8T1FuIgLc/73/1TOM1DPUZchs08TvxskOX5GvjiuBdyNi9r6pwqge2vGXXf8rGqRRoVOI/fglVysC4wVJWxbbDvCfHcySc/Uh3VwfxXIr1hUw/BFLTg0cFK8b+ZfBqpLOo9CmQnKSCiR6gg2ZcJ7Ef6IrFnjdRAqNR8YWzZ0tMQxb/ARRkGKNYvDdNwEtk9pSTu3RY4/KUdteWI8aqKvhgeJ5zbZ7Aa7WZewZIPEQu3whuaHjg= |
train_87 | def calculator(n: int) -> int:
import sympy as sp
def a(n_val):
x = sp.symbols('x')
expr = (1 + 4 * x + x ** 2) ** 2 / (1 - x) ** 4
series = sp.series(expr, x, 0, n_val + 1).removeO()
coeff = series.coeff(x, n_val)
return int(coeff) if coeff is not None else 0
init =... | 0 | 41 | v1:L2MzIfqIwgsHjRT8RwH5vFRRW2LE+e8qo7PWEZ+NfUswEtXMusXZlVnFOylGuEaO+gPItb4qrzXDiwOBN2YydzqVQo5jfyG6kgU/N5mxGlE+Mk14AjF7fDqP+IL/aV2vXTHScuqaGrhqDscMZQ== | v1:S/2Dd3WBvp+mDq7cAKoReVELBc0xcBVmkBhCFkUEqmm6KVQ3isBlE+FTzrGQbdR4h9AcTYiwzWEdN6bEmcxxwDAoOuYoc5lkEoSDONqjPX0GIF0YVGQYDKKb36e1YEbmi+D54rp32C6k8iRmQ0pM4lRvJTT2HwdnDo1+x43qKPgPVH1J/tEwTzaRV4UVtfcpb+HTyaLJEFDGxjunAfS15hIZEOnhCmQTLtO1dY2wthSKnOEek9TPK26ngwU= |
train_88 | def calculator(n: int) -> int:
import sympy
def tau(k: int) -> int:
return sympy.divisor_count(k)
count = 0
for k in range(1, n + 1):
exponent = tau(k) - 1
power_value = n ** exponent
if power_value % k == 0:
count += 1
return count | 1 | 92 | v1:vbQk2C9cMfrWnnKJB5E4GD2RSAly/qZ0igjjiLp6/EG+u+6u6wvc9t2a5n+OHUnrDn8pzQWNIt7RBkdBUubIbfNvzrXaGeBnvl8MvBnligJQE+cyma6X84170tJ3bQgaNY3b115WgEsatIX7017k6dYBO0j5zdh81X3kd7d4I/MCjzc47JRFoeB/G2T2ZwcVN05PfHHyArQW3WJemmrXKp21lPHZQrxZxQx6E+iEPItmcyHb1teFmcGTr88oVwPNWvGBzKWhLWaHc+baA/14wPzgQvHRNoXJE2W67W9IP2x+5d0tQO30PVZmsEDGC... | v1:V9BkC71CdFhdpMyNVyBxAd+gz/tU2ViX/1OH14fJMj0F2gZz5ghp8Exq3Rpy6IDES9fbdK/6o2/dYOtXDJy0FZ8Lq0SWBARth+K4LkNPEZKKHyNjlnPx9ztfDxVyndGPhdV3NaYINNbktgJ1bTrCpa8M9P4trxAYDwFLpOq/GDUtbYZClWeGkiFNKOzc6/tl17LsejLS2AmOmTg+Rp+00EFOFstzZgCF |
train_89 | def calculator(n: int) -> int:
import sympy as sp
def gcd(a, b):
return sp.gcd(a, b)
def mu(k):
return sp.mobius(k)
result = 0
for k in range(1, n + 1):
if gcd(n, k) == 1:
result += mu(k) * (n // k)
return int(result) | 1 | 92 | v1:qlS80Bkpb5R5mcugsZ3s9egbU91nYfRV0XTmUWwU1XC2BdGMgfcJHAnLOohrvabGSRLgKfJmSJ0XpG4Ry0/hqUKSIYoRNqR16YGhabEJB33EOeB9gXSmlkbt2k/4sgocW+QAac0eSQo0WdXO4k50BfgW2tdROCd2qSSNMohyoBptvbTjzmZ3617jyztB6MeW+948bVGpoMyDCL7N+C5W4eXDhP4kCUndKk9inCpj28lYyZEpNmie/Kx3Glhnjp+ZQL3Pt45atnTyZ/SpbKmnXF61xMW00szkiUg5gAKZjhSOUzU1kG6hWdYp8/uDk... | v1:U2W6Msq57l2ZnHEX1x0ob1QfgKLhAThLtve7daeRDIiC4zg9jVKS6Le25tlXuyoKp7Br4o506OB9W0Mi50KoegUn/h1HFDesZqJxdbOsNuFv+bHY51txMR6rCiGkYbOnT/2I3BoVdPtYWMpUHWMkHINIo0Dk2JuYnmXaFucjmHm4zsq8wkCeowk3VrJmNXsKgDlRROXtklVbKe7OtNX07VreSBp6lSeV |
train_90 | def calculator(n: int) -> int:
import sympy
def bigomega(n):
return sympy.primeomega(n)
def omega(n):
return len(sympy.primefactors(n))
exponent = bigomega(n) - omega(n)
return 0 ** exponent | 1 | 100 | v1:uwfRHA6e59bqZwo8ftK1QHbsrKkqyFNRBC6OmLoSRbc/QcLLZ3PFHOFtlcqpEEttisCb2tVG8lOeJWdRqA7MrVLu+CPbVvH366vgbiNVg0ymft+Ne/t4AkP1znmRcUtS5Ml7hxJRBcBoxs3jBKvtjGJ2+xXySy5HMs6HdgQMeLKar3EAAU/qGy5xowddoj41LE4V+TqFAapF4h5ZJB0oHknglp7R88pwH6J93qujjM8RgOUQ7CtMTi6h0iZY6G+A/lDtR7dw8t5chzDdhYefnRBurE3854axDRqzsZmxVh9ZDJBcJC3MSkNjdg== | v1:wGEeuRcJLy94iWagC9op4k/aYLHZpJDTZcb9pdta3GqVtaobzalq4Isumf0bgUMvA9lk+GaZ3uMwUoEaSrchV6ssvv8K9/xw/kCa85/TpZ/feEOv9b5FRzI= |
train_91 | def calculator(n: int) -> int:
from sympy import divisors, mobius, factorint
total = 0
for d in divisors(n):
w = len(factorint(d))
term = 2 ** w * mobius(n // d)
total += term
return total | 1 | 100 | v1:Np70e1ElikIiE/qIuTm0XzuL/5DC+M4E46xWySt1wEgdgo4H/BicbMlc3/7JHF2+zSiNL0XMOXtYoGYLZyu4ej1YQAARus9Z7/f7q+m3VqoPLxzwuwv/tBbfkQrQyyLBtAbV5F8IlNfUwzXgsWdvvOTCCC0cgESD7P99W4/CjsVLj4BMqxpPk8smLFdsoGbu6xa6cPsNvLATbS13Uq1gN75/5ZKi55/69blvvrqeAK2JvM2ml3Ca7CY/7pq2ivBN9W7a5z0vvwcmlqMn/G0czTkOHFvqe+R9/S8LF6PKpZJh3RvnBFeZOuXUkw== | v1:zn49Pc2EIzvQ4zn9oKv1R9y45/oxBErKgN2iwgRaCLws0bFgc/8v6sCQCSIJEuiGSg4z8HbpOzIZIqMyJqNA8XCBFBF5lz2szOHrWu6Vnn/EWJwwuxe0ISw= |
train_92 | def calculator(n: int) -> int:
import sympy
def is_prime(num):
return sympy.isprime(num)
count = 0
k = 1
while True:
if is_prime(2 * k - 1):
count += 1
if count == n:
return k
k += 1 | 1 | 64 | v1:VmHQ4CRB3YQt3T3mhpEh45fjjL+EXAA+rWFRv7WKv2nuZoGVp5waOtfRPEi0ysJ1QZtkqIfIQ2FIlYOTT94hm9qvbmFx1WFWCWg0EvprpBs58Ujopvbi/3q6OYNYuJOU27In5+Me3xu4nFTCMQ0AxLwP0oKPkKMduhEOuqwH4H5lYcvQMLuhmmVSIsjGMQ3Yt+7qggSWXL8QUrOP2BmHvyfbe9GHTg2kXUYFkd7lyUuUynrMP8qMy1u2BUKPYIZgiRA2/YmMxYmOK9QSZa1OLlQlSV4s4a3GU6hT2RCDgx47mfQCkKaScN0Fuy0Wi... | v1:u2WXWujXeDdlqUlCH1mcXh1+T3JopuaXP66p2BKYqQJCCrfyIkP/x8cZfcQyehCJ6VrEs8grmgm/KcM4jy+F4uxWxTyJAtxjNQb+Jsz/m/RMP28OtQXgses6TU7agaqYKFFANeZph7Cpq/sYeRMGpovw2JMZFBk98ObmNbIBIWVXDm2ZISgupvX6KCoKLoy1fTAuuF0ZFOn3TRSWfv2isSWHo2Q1ojQ= |
train_93 | def calculator(n: int) -> int:
import sympy
def binomial_coeff(k: int, m: int) -> int:
if m < 0 or m > k:
return 0
return int(sympy.factorial(k) / (sympy.factorial(m) * sympy.factorial(k - m)))
return binomial_coeff(63, n) | 0 | 20 | v1:WVuljS+UVI21NX2dm5TCWcNMcblawJCcgHxRDLssuzaVZ3hkgeH9USgmjvlgOstMdKciwtURIPjAn4AXhotBA2+v754cgTC+1GNpI/PPxAhCkB7ztaktrVwpX1W0qwdtSIB08v2XWkmccFss/ccomqzj/Zjw06UeFu1dQbOQZw== | v1:1nMg1MaYpHD4olVOmfYYyHcGt2ZvlvTnWKFTQkoumjDMq32YSiIBg0IxsdS51+Ye/BJzc0BbJ42+wwH8TEDteQguokaDmEft61YL422Raq24H/2SFtG2l/99N1BSJtUOHlMEBqvPrtdF3caywacVL3FswZUsO5SvyuLyjU3/AGJr8ZRVdaVR+jDPGkFBoS3/98TYP15EM1T/IoAxnspRaztZZnkvP5K3oQDsyu/XgP3+vDea6SA4 |
train_94 | import sympy
def calculator(n: int) -> int:
x = sympy.symbols('x')
expr = sympy.Pow(11 * x + 4, 6)
return int(expr.subs(x, n)) | 0 | 15 | v1:CC891td5n+Q1vlTzi+fQ/q4DKaM6sXw57PM+7jox6HgP4ClND7dAbWy/gvZnECtTW1HnEfHFo3u70igIviZIAMrF5PrYwc0RdmtFWS5tMHKxuhAiBqqsUxTlw/IzM+bD | v1:1DPGJqsaa/85y7K7RypqF+Fom20lZyUll7nI0lkmRvRJuwDXwGWFvHJazTS35iiHxIOmqJstIfcSUQk0nt4kZbqpkGBM0is5Cyd3CFU0fJMYiYqSjoODAAUWmyZ97nFwqutL19G+e4nW3f/jyeI8bNnzkEBCpZpdptK+jgEQ/klaUX7kYR08GE/rTejHUHgOSa4YUhUMUaDE2rEkaauu |
train_95 | def calculator(n: int) -> int:
from sympy import cyclotomic_poly, Symbol
x = Symbol('x')
if n == 0:
return -1
poly = cyclotomic_poly(n, x)
result = poly.subs(x, -1)
return int(result) | 0 | 65 | v1:9fHibyma82aNbG3YfrjRhgGnU2/VTaf3ZV3X+NLwB6rB8a7bw+EGcQqblDzajQ5LQbpPLWeSk1Of20Gr0uuk41Lvn2s1grNXyr/p2cnP1309fJS7oeYjBgUshWk5LsdiX/ZXBAeHbER2FhqG6dtZCyKmITgsgP/Ok63k9zGHmrbHkUiWemqgMCDJFn1URoBYuKzAn16DcTSB0oSWlhZL4NjCi9HOq6UCXJ4k26QdUEBqSgH3oDdNhWfaSNVr9Acvnwytm2obqDNaXaVCfDOvN177lPWAOr44TU5bi/D5v/Uzb0lpg9kLchsBS9lj6... | v1:8qp+w+ApzgWQ8+p4JbM7WfX4TZf3mfsnvelFtZgclFlg9JVgIyz3/P0IUOEiHPapd6qSxHUQ1ryxqbPYqB0X9dc5SWASV9htRDIOuB6BJueqfmKlB6cacU+yJWZcF91MZUQ9ycGUrk+OAcSR/jj40Q== |
train_96 | def calculator(n: int) -> int:
from sympy import Symbol, Eq, Piecewise, simplify
def A010011(n_val):
n_sym = Symbol('n', integer=True, nonnegative=True)
formula = Piecewise((1, Eq(n_sym, 0)), (21 * n_sym ** 2 + 2, True))
result = formula.subs(n_sym, n_val)
return int(simplify(re... | 0 | 42 | v1:tpB0FPwQ1aXQLFLwynmPIMypim64nUiA3uRC9zTSQKyELVGVX/CGBfTw4xooAQySM6vVnG1mEmsflZU9HywhdmcF8pjSkkijHuJD+99fiB3oKlWz/WKKkymVquOgH10nEzpxkEx2HNGs9TCIGvcbn25V | v1:ZoU9uOdwG+8gEfC3CgCUqOanKFMttYspqu5Agk0OXDU9hGQo77c5jN76yL0kZSZusPcVGMd+Z/b44+3TonMR2KNLwsCenx+Gd05roLHD7ao0cgrJTqEODa/JkHT59zYlglo12oRx8zx2iSSOf+orhcA+M8xtSge9kMyIFjzN0HFBTObhYmYdpbpxnBZ23l/Lwel8x7ZseiHYT6R2iZmproPDn3q+Mgcg2Cj1tmNfj4F7z+HAEgcA5g== |
train_97 | def calculator(n: int) -> int:
from sympy import symbols, O, Poly, series, expand
def compute_sequence() -> list:
x = symbols('x')
S = 0
for i in range(8):
S += x ** i ** 3
S = series(S, x, 0, 455).removeO()
S_pow_7 = expand(S ** 7)
poly = Poly(S_pow_... | 1 | 17 | v1:/1r03MzeTSnKfcYpmwRVa+udP8Bou6bKEuZYYW7MAAKqRKb/pgx8FF6yvh7LTmau9ma6lI0ZoU+U//t1OX3UzIeIcceCK6mSryMWTz4dwbzAHpWSIBIe9fLkAvA5GzmQj28Bofcsl0iukHHQlKzjPawel50POoVi96qvcurxXv5FopAyDuq1spe1HUjAIY1HKqb/OtNXAUpXJJIORNUDCvb4R8Nxjmdee4mWmThZ5tffN7q+cjBLBauKtlz7aHdVnGrAwr3H8lH5Nt+kXMNvFkxJCf53edBoMW67VXxabzb4jb8h2m1iNJ8KTbQ7F... | v1:uwmukGj2L9uJNOLXqgXmgKFkAHusO23rbQRP6cHMzYNOYKNDStZ0gWykAP+8yX++C/FVZXhyoIowGaJVA6bQBwdUPpztHhX5DQHG4hQq0fvbI0IoUXE7bAOo0evb9G/EzzdqJZ5wgAq3oFXt3GY= |
train_98 | import sympy
def calculator(n: int) -> int:
def a(n_val):
x = sympy.Integer(n_val)
numerator = x * (x - 1) * (x - 2) * (x - 3)
denominator = sympy.Integer(19)
result = numerator / denominator
return int(sympy.floor(result))
return a(n) | 0 | 43 | v1:vbhtKj+rVStaghvSQAox+UBF75AQNCuDJ14oGSLSN9ZbBGarAT8tI2TlIzDbHvchowCw9J+9c+RnsiP6s9Y95a4J8hs7sksejE74a3ykjrNnloKjVxAuLgtLw0GCihP/9/pQpY3RzsCY8sY= | v1:30LPILvYpTPTDfv6cF/dS9oPY0dVhKDqrKbD4mNX26BHLQUn6lvGOAaO6m10X454AIRrx0B359PBiJGbaz/dTntxztryHep1VheMM8gcLoBYhlgu1sJ9L7v8qC4VJm7iWjc+KkZpchcZKs5H309uwYsM02S9cU2NkSwPJY890XsY9qQeakIVJL3q0vxjgs9Nk8nBwcSzm+N+mPe55+bIaFHiVIC9Iyql/amD8fB3jR+vWawYnpLBAg== |
train_99 | def calculator(n: int) -> int:
import sympy
total = 0
for p in range(n + 1):
for q in range(n - p + 1):
r = n - p - q
term = (sympy.factorial(n) / (sympy.factorial(p) * sympy.factorial(q) * sympy.factorial(r))) ** 2
total += term
return int(total) | 0 | 21 | v1:BnrYLd9+wIpeKxOuf6NCdC05wn/CnbWdBi4xf4HyoUFSLYJwPGuUq15lQpVuUWN4HELJMHgjsR9JzQRR3qfF7uYx7FbOzAotjmZtsTj55Uga0LK3YMbVc8pjdFs6bAFlrtgBZ51R3M0J90tpTR/L/FfiNAVDRfhS1mJEZXrkUohzTuaI0YZa+O3cwHGakV2CBMmX4IU2bzCT6JZ/xNy5rCIu | v1:7OWH4p11Muc/+QdJ2ZIi/ZYokJDEMdibLtaMdfbCBJjI8W8JNvDB29sRQFlDtYU3eXhOtQSerqq0/ewkRj1dhIghgZxL/Qf2lgx9/4M2MhcBpXr1DRHbO6qJJFn64flJkjOEoBPQDHdfhHI0Ew3sMuMXNe1jaxY8rHt02mIyil2f+9hfFu9yzmM6CfACSiXjQicDvjx1L75+DQBiZ3UDzSXaUCEkmKyHeYt/tg== |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.