problem_id
stringlengths 6
6
| user_id
stringlengths 10
10
| time_limit
float64 1k
8k
| memory_limit
float64 262k
1.05M
| problem_description
stringlengths 48
1.55k
| codes
stringlengths 35
98.9k
| status
stringlengths 28
1.7k
| submission_ids
stringlengths 28
1.41k
| memories
stringlengths 13
808
| cpu_times
stringlengths 11
610
| code_sizes
stringlengths 7
505
|
|---|---|---|---|---|---|---|---|---|---|---|
p03986 | u026788530 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s=input()\nc=0\nans=0\nfor i in range(n):\n if s[i]=='T':\n c+=1\n if s[i]='S':\n c-=1\n ans = max(ans,c)\nprint(ans*2)", "s=input()\nc=0\nans=0\nfor i in range(len(s)):\n if s[i]=='T':\n c+=1\n if s[i]='S':\n c-=1\n ans = max(ans,c)\nprint(ans*2)", "s=input()\nc=0\nans=0\nfor i in range(len(s)):\n if s[i]=='T':\n c+=1\n if s[i]=='S':\n c-=1\n ans = max(ans,c)\nprint(ans*2)\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s215998805', 's906872095', 's335193427'] | [2940.0, 2940.0, 3500.0] | [17.0, 17.0, 110.0] | [119, 124, 126] |
p03986 | u030726788 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['s=input()\nwhile("ST" in s):\n s.remove("ST")\nprint(len(s))', 's=input()\nn=len(s)\nsta=[]\nfor i in range(n):\n if(s[i]=="S"):\n sta.append("S")\n else:\n if(len(sta)==0 or sta[-1]=="T"):sta.append("T")\n else:sta.pop()\nprint(len(sta))\n'] | ['Runtime Error', 'Accepted'] | ['s221409042', 's516802251'] | [3500.0, 5096.0] | [18.0, 65.0] | [58, 177] |
p03986 | u033524082 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x=input()\nans=len(x)\nr=len(x)\nif "ST" in x:\n x.remove("ST")\n ans-=2\nwhile r!=len(x):\n r=len(x)\n if "ST" in x:\n x.remove("ST")\n ans-=2\nprint(ans)', 'x=input()\nl=[x[0]]\nfor i in range(1,len(x)):\n if l!=[]:\n if l[-1]=="S":\n h=1\n else:\n h=0\n l.append(x[i])\n if len(l)!=1:\n if l[-1]=="T":\n if h==1:\n l.pop(-1)\n l.pop(-1)\n if l!=[]:\n h=(0 if l[-1]=="T" else 1)\n else:\n h=0\n else:\n h=0\n else:\n h=0\nprint(len(l))'] | ['Runtime Error', 'Accepted'] | ['s034283809', 's916890883'] | [3500.0, 4864.0] | [20.0, 152.0] | [170, 461] |
p03986 | u042802884 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X=list(input())\n\nf=True\n\nwhile f and X:\n for i in range(len(X)-1):\n print(X) #DB\n if X[i:i+2]==['S','T']:\n del X[i:i+2]\n print (X) #DB\n break\n if i==len(X)-2:\n f=False\n\nprint(len(X))", "X=input()\nk=0 \ncnt=0 \nfor c in X:\n if c=='S':\n k+=1\n else:\n if k==0:\n cnt+=1\n else:\n k-=1\nprint(cnt*2)"] | ['Wrong Answer', 'Accepted'] | ['s445817731', 's854832786'] | [91484.0, 3500.0] | [1056.0, 45.0] | [250, 245] |
p03986 | u062147869 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["from collections import deque\nS=input()\ntable=deque()\ntable.append(1)\nans=0\nfor s in S:\n if s=='S':\n table.append(1)\n #print(table,ans)\n else:\n if len(table)==1:\n table[0]==1\n #print(table,ans)\n else:\n table.pop()\n ans+=table[-1]\n #table[-1]+=1\n #print(table,ans)\nprint(ans)", "from collections import deque\nS=input()\ntable=deque()\ntable.append(1)\nans=0\nfor s in S:\n if s=='S':\n table.append(1)\n #print(table,ans)\n else:\n if len(table)==1:\n table[0]==1\n #print(table,ans)\n else:\n table.pop()\n ans+=table[-1]\n #table[-1]+=1\n #print(table,ans)\nprint(len(S)-2*ans)"] | ['Wrong Answer', 'Accepted'] | ['s721948758', 's759541108'] | [4324.0, 4324.0] | [67.0, 63.0] | [373, 382] |
p03986 | u063052907 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['# coding: utf-8\nX = input()\ntmp = " "\ncnt = 0\nfor x in X:\n if x == "S":\n tmp += x\n cnt += 1\n else:\n if tmp[-1]=="S":\n cnt -= 1\n else:\n tmp += x\n cnt += 1\nprint(cnt)', 'X = input()\ncnt_S, cnt_T = 0, 0\n\nfor c in range(X):\n if c == "S":\n cnt_S += 1\n else:\n if cnt_S:\n cnt_S -= 1\n else:\n cnt_T += 1\nprint(cnt_S, cnt_T)', '# coding: utf-8\nn_S, n_T = 0, 0\n\nif c in input():\n if c == "S":\n n_S += 1\n else:\n if n_S:\n n_S -= 1\n else:\n T += 1\nprint(n_S + n_T)\n', 'from collections import deque\n\n\nX = input()\nstk = deque()\n\nfor c in X:\n if len(stk) == 0:\n stk.append(c)\n else:\n if stk[-1] == "S":\n if c == "T":\n stk.pop()\n else:\n stk.append(c)\n else:\n stk.append(c)\nprint(len(stk))'] | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s158014645', 's530990909', 's736880248', 's730002873'] | [3500.0, 3500.0, 3064.0, 5092.0] | [62.0, 18.0, 18.0, 80.0] | [231, 195, 181, 306] |
p03986 | u064408584 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s=input()\nans=0\ncount=0\nfor i in s:\n if i=='S':count=max(1,count+1)\n else:count-=1\n if count<0:ans+=1\nprint(ans*2,count)", "s=input()\nans=0\ncount=0\nfor i in s:\n if i=='S':count=max(1,count+1)\n else:count-=1\n if count<0:ans+=1\nprint(ans*2)"] | ['Wrong Answer', 'Accepted'] | ['s917182502', 's759072667'] | [3500.0, 3500.0] | [70.0, 72.0] | [129, 123] |
p03986 | u077080573 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['string = input()\nstack = ""\n\nfor i in string:\n if i == "S":\n stack += i\n elif i == "T" and (stack == "" or stack[-1] == "T"):\n stack += i\n else:\n stack = stack[0:-1]\n print(stack)\n\nprint(len(stack))\n', 'string = input()\nstack = ""\n\nfor i in string:\n if i == "S":\n stack += i\n elif i == "T" and (stack == "" or stack[-1] == "T"):\n stack += i\n else:\n stack = stack[0:-1]\n\nprint(len(stack))\n'] | ['Wrong Answer', 'Accepted'] | ['s697908537', 's332156313'] | [134500.0, 3816.0] | [388.0, 308.0] | [232, 215] |
p03986 | u094191970 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["h,w=map(int,input().split())\nfor i in range(h):\n s=input()\n print(s+'\\n'+s)", "x=input()\n\nc_s=0\nc_t=0\n\nfor i in x:\n if i=='S':\n c_s+=1\n else:\n if c_s==0:\n c_t+=1\n else:\n c_s-=1\n\nprint(c_s+c_t)"] | ['Runtime Error', 'Accepted'] | ['s835456732', 's822369372'] | [3500.0, 3500.0] | [19.0, 45.0] | [81, 134] |
p03986 | u096616343 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['X = input()\nSn = 0\nTn = 0\nfor ch in X:\n if ch == "S":\n Sn += 1\n if ch == "T":\n if Sn > 0:\n Sn -= 1\n else:\n Tn += 0\nprint(Sn + Tn)', 'X = input()\nSn = 0\nTn = 0\nfor ch in X:\n if ch == "S":\n Sn += 1\n if ch == "T":\n if Sn > 0:\n Sn -= 1\n else:\n Tn += 1\nprint(Sn + Tn)'] | ['Wrong Answer', 'Accepted'] | ['s173036785', 's114270046'] | [3500.0, 3500.0] | [56.0, 53.0] | [178, 178] |
p03986 | u102242691 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['X = input()\nans = []\nfor x in X:\n if x == "S":\n ans.append(x)\n else:\n if len(ans) != 0:\n if ans [-1] == "S":\n ans.pop()\n else:\n ans.append(x)\n else:\n ans.append(x)\nprint(len(ans)) \n\n\n', "X = input()\nans = []\nfor x in X:\n if x == 'S':\n ans.append(x)\n else:\n if len(ans) != 0:\n if ans[-1] == 'S':\n ans.pop()\n else:\n ans.append(x)\n else:\n ans.append(x)\nprint(len(ans))\n"] | ['Runtime Error', 'Accepted'] | ['s453951949', 's803079992'] | [2940.0, 5096.0] | [17.0, 79.0] | [305, 269] |
p03986 | u102461423 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s,t = 0,0\nfor x in input():\n print(s,t)\n if x == 'S':\n s += 1\n else:\n if s > 0:\n s -= 1\n else:\n t += 1\n\nprint(s+t)", "s,t = 0,0\nfor x in input():\n if x == 'S':\n s += 1\n else:\n if s > 1:\n s -= 1\n else:\n t += 1\n\nprint(s+t)", "print(input().replace('ST',''))", "import sys\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\nX = read().rstrip().decode()\n\ns, t = 0, 0\nfor x in X:\n if x == 'S':\n s += 1\n else:\n if s == 0:\n t += 1\n else:\n s -= 1\n\nprint(s+t)"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s126626646', 's130646064', 's196003657', 's853944465'] | [5576.0, 3500.0, 3500.0, 9056.0] | [310.0, 53.0, 20.0, 54.0] | [136, 123, 31, 296] |
p03986 | u118642796 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['S = input()\nfor i in range(1,len(S)+1):\n if S[-i]!=S:\n print(2*(i-1))\n break', 'S = input()\nt = 0\ns = 0\nfor c in S:\n if c=="T" and s==0:\n t += 1\n elif c=="T":\n s -= 1\n else:\n s += 1\nprint(s+t)'] | ['Wrong Answer', 'Accepted'] | ['s306002911', 's540302782'] | [3500.0, 3500.0] | [17.0, 53.0] | [83, 124] |
p03986 | u129836004 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X = input()\nwhile 'ST' in X:\n X.replace('ST', '')\nprint(len(X))", "X = input()\nt = 0\ns = 0\nfor i in X:\n if i == 'T':\n if s > 0:\n s -= 1\n else:\n t += 1\n if i == 'S':\n s += 1\nprint(s + t)"] | ['Time Limit Exceeded', 'Accepted'] | ['s871530130', 's740500515'] | [3500.0, 3500.0] | [1056.0, 57.0] | [66, 167] |
p03986 | u131666536 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["# -*- coding: utf-8 -*-\n\nimport re\n\ntext = input()\npattern = 'ST'\n\nwhile True:\n if pattern in text:\n splt_txt = re.split(pattern, text)\n text = ''.join(splt_txt)\n else:\n break\n\nprint(text)\n", "# -*- coding: utf-8 -*-\n\ntext = list(input())\ntxt_stuck = []\n\nfor i in text:\n if i == 'S':\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck == []:\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck[-1] == 'T':\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck[-1] == 'S':\n txt_stuck.pop()\n\nprint(''.join(txt_stuck))", "# -*- coding: utf-8 -*-\n\ntext = list(input())\ntxt_stuck = []\n\nfor i in text:\n if i == 'S':\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck == []:\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck[-1] == 'T':\n txt_stuck.append(i)\n elif i == 'T' and txt_stuck[-1] == 'S':\n txt_stuck.pop()\n\nprint(len(txt_stuck))"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s064142386', 's738891229', 's815460718'] | [5924.0, 6692.0, 6436.0] | [1055.0, 86.0, 91.0] | [216, 355, 351] |
p03986 | u139629238 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['# -*- coding: utf-8 -*-\n\nx = input()\n\nfor i in range(0, pow(10, 10000)):\n if "ST" in x:\n x = x.lstrip("ST")\n else:\n break\n\nprint(x)\n', '# -*- coding: utf-8 -*-\n\nx = input()\n\nfor i in range(0, pow(10, 10000)):\n if "ST" in x:\n x = x.replace("ST", "")\n else:\n break\n\nprint(x)\n', '# -*- coding: utf-8 -*-\n\nx = "TSSTSTSTSTSTTS"\n\n\nsc = 0\n\ntc = 0\n\nfor c in x:\n if c == \'S\':\n sc += 1\n elif sc >= 1:\n sc -= 1\n else:\n tc += 1\n\nprint(sc + tc)\n', "# -*- coding: utf-8 -*-\n\nx = input()\n\n\nsc = 0\n\ntc = 0\n\nfor c in x:\n if c == 'S':\n sc += 1\n elif sc >= 1:\n sc -= 1\n else:\n tc += 1\n\nprint(sc + tc)\n"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s412444434', 's475335297', 's487385042', 's265969144'] | [3500.0, 3620.0, 2940.0, 3500.0] | [22.0, 1056.0, 18.0, 47.0] | [152, 157, 286, 277] |
p03986 | u141574039 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['X=list(map(str,input()))\nt=0\ns=0\ni=0\nrt=0\nh=len(X)//2\n#print(h)\nwhile t!=h:\n if X[i]=="T":\n t=t+1\n i=i+1\n if s==0:\n rt=rt+1\n #print("t",t)\n else:\n s=s+1\n i=i+1\n #print("s",s)\nprint(min((len(X)-s*2+rt*2),len(X)))', 'X=list(map(str,input()))\nt=0\ns=0\ni=0\nrt=0\nh=len(X)//2\n#print(h)\nwhile t!=h:\n if X[i]=="T":\n t=t+1\n i=i+1\n if s==0:\n rt=rt+1\n #print("t",t)\n else:\n s=s+1\n i=i+1\n #print("s",s)\nprint(len(X)-s*2+rt*2)', 's,t=0,0\nX=list(input())\nfor i in range(len(X)):\n if X[i]=="S":\n s=s+1\n else:\n if s>0:\n s=s-1\n else:\n t=t+1\nprint(s+t)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s093915195', 's440542483', 's619436933'] | [4848.0, 5096.0, 4840.0] | [85.0, 88.0, 56.0] | [239, 225, 138] |
p03986 | u227082700 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x=input();a=0\nfor i in range(len(x)):\n if x[l-i-1]=="T":a+=1\n else:a=max(0,a-1)\nprint(a*2)', 'x=input()\ns=t=0\nfor i in x:\n if i=="S":s+=1\n else:\n if s:\n s-=1\n else:\n t+=1\nprint(s+t)'] | ['Runtime Error', 'Accepted'] | ['s730389770', 's429403748'] | [3500.0, 9172.0] | [18.0, 55.0] | [92, 105] |
p03986 | u247554097 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['\nx = input()\nstock = 0\ncount = 0\nfor a in x:\n if a == "S":\n stock += 1\n else:\n if stock > 0:\n count += 1\n stock -= 1\nprint(count)\n', '\n\n\n\nx = input()\nstock = 0\ncount = 0\nfor a in x:\n if a == "S":\n stock += 1\n else:\n if stock > 0:\n count += 2\n stock -= 1\nprint(len(x)-count)\n'] | ['Wrong Answer', 'Accepted'] | ['s869866537', 's561242593'] | [3500.0, 3500.0] | [60.0, 60.0] | [238, 357] |
p03986 | u284854859 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['\n\n\n\n\n\n \n################################################################################\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n\n def search_lower(self,key,key_lower):\n if self.key == None:\n return key_lower\n if self.key > key:\n if self.left == None:\n return key_lower\n else:\n return self.left.search_lower(key,key_lower)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return key_lower\n else:\n return self.right.search_lower(key,key_lower)\n \n if self.left == None:\n return key_lower\n else:\n if key_lower == None:\n return self.left.end_higher(self.left.key)\n else:\n return max(key_lower,self.left.end_higher(self.left.key))\n \n def search_higher(self,key,key_higher):\n if self.key == None:\n return key_higher\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return key_higher\n else:\n return self.left.search_higher(key,key_higher)\n if self.key < key:\n if self.right == None:\n return key_higher\n else:\n return self.right.search_higher(key,key_higher)\n \n if self.right == None:\n return key_higher\n else:\n if key_higher == None:\n return self.right.end_lower(self.right.key)\n else:\n return min(key_higher,self.right.end_lower(self.right.key))\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n\n\n################################################################\n\ndef inpl(): return [int(i) for i in input().split()]\nn = int(input())\na = inpl()\nb = {a[i]: i for i in range(n)}\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n l = root.search_lower(b[i],None)\n r = root.search_higher(b[i],None)\n if l == None:\n l = -1\n if r == None:\n r = n\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(0)', "x = list(input())\nn = len(x)\n\na = 0\nc = 0\nfor i in range(n):\n if x[n-1-i] == 'S':\n if a >= 1:\n a -=1\n c += 1\n else:\n a += 1\n\nprint(n-c*2)"] | ['Runtime Error', 'Accepted'] | ['s770967839', 's356234906'] | [3884.0, 4840.0] | [19.0, 77.0] | [7341, 179] |
p03986 | u289288647 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["def cal():\n x = input()\n i = 0\n while i <= 2*10**5:\n i += 1\n x1 = x.replace('ST', '', 10**5)\n print(len(x))\n\ncal()\n", "x = input()\nans = []\n\nfor i in x:\n if i == 'S':\n ans.append(i)\n else:\n if len(ans) == 0 or ans[-1] == 'T':\n ans.append(i)\n else:\n ans.pop()\nprint(len(ans))\n"] | ['Wrong Answer', 'Accepted'] | ['s349374548', 's585726012'] | [9512.0, 10700.0] | [1103.0, 64.0] | [141, 205] |
p03986 | u317713173 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x = input()\n\nfor i in range(200000):\n if x[i] = "T":\n t += 1\n if x[-i-1] = "S":\n s += 1\nprint(max(s, t))', 'x = input()\ns = t = 0\nfor i in range(200000):\n if x[i] = "T":\n t += 1\n if x[-i-1] = "S":\n s += 1\nprint(max(s, t))', 'x = input()\ns = t = 0\nfor i in range(200000):\n if x[i] == "T":\n t += 1\n if x[-i-1] == "S":\n s += 1\nprint(max(s, t))', 'x = input()\n\nst_sub = 0\ncount = 0\nfor char in x:\n\n if st_sub < 0 and char == "S":\n st_sub = 1\n elif char == "S":\n st_sub += 1\n else:\n st_sub -= 1\n \n if st_sub < 0:\n count += 1\n \nprint(count * 2)'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s156593474', 's225259923', 's964203029', 's157472065'] | [2940.0, 2940.0, 3500.0, 3500.0] | [17.0, 17.0, 80.0, 71.0] | [124, 133, 135, 240] |
p03986 | u334712262 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["x = input()\nans = 0\nfor c in x:\n if c == 'T':\n ans += 1\n elif ans != 0:\n ans -= 1\nprint(ans * 2)", "x = input()\nans = 0\nfor c in x:\n if c == 'S':\n ans += 1\n elif c != 0:\n ans -= 1\nprint(-ans * 2)", "x = input()\ns = 0\nans = 0\nfor c in x:\n if c == 'T' and s > 0:\n s -= 1\n elif c == 'T':\n ans += 1\n elif c == 'S':\n s += 1\nprint(ans * 2) \n \n"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s498018216', 's581025929', 's451541977'] | [3500.0, 3500.0, 3500.0] | [57.0, 54.0, 57.0] | [117, 103, 153] |
p03986 | u345966487 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X=input()\nt,s=0,0\nfor x in X:\n if x=='S':ns+=1\n elif ns>0:ns-=1\n else:nt+=1\nprint(nt+ns)", "s=0\nfor x in input():s+=x<'T'or-(s>0)\nprint(2*s)"] | ['Runtime Error', 'Accepted'] | ['s886277453', 's311958318'] | [3500.0, 3500.0] | [18.0, 49.0] | [88, 48] |
p03986 | u349444371 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['s=input()\nans=0\na=0\nb=0\nfor i in range(len(s)):\n if s[i]=="T":\n a+=1\n else:\n break\nfor i in range(len(s)):\n if s[-i-1]=="S":\n b+=1\n else:\n break\nprint(a+b)', 's=input()\nans=0\ni=0\nc=-1\ntmp1=0\ntmp2=0\nx=0\ny=0\nwhile i<len(s):\n if c==-1:\n if s[i]=="S":\n tmp1=1\n c=0\n else:\n tmp2+=1\n c=1\n elif c==0:\n if s[i]=="S":\n tmp1+=1\n else:\n tmp2+=1\n c=1\n elif c==1:\n if s[i]=="S":\n if tmp1>=tmp2:\n tmp1=tmp1-tmp2\n tmp2=0\n else:\n y+=tmp2-tmp1\n tmp2=0\n tmp1=0\n c=0\n tmp1+=1\n else:\n tmp2+=1\n if i==len(s)-1:\n if tmp1>=tmp2:\n x+=tmp1-tmp2\n tmp2=0\n else:\n y+=tmp2-tmp1\n tmp1=0\n i+=1\n \n #print(ans,tmp1,tmp2,x,y)\nprint(x+y)'] | ['Wrong Answer', 'Accepted'] | ['s363242912', 's414323477'] | [9252.0, 9332.0] | [31.0, 121.0] | [195, 791] |
p03986 | u366886346 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x=list(input())\nnum=[]\ns="S"\ncnt=len(x)\nfor i in range(len(x)):\n if x[i]==s:\n cnt=i\n break\ncnt2=0\nfor i in range(cnt,len(x)):\n if x[i]!=s:\n if s=="T":\n s="S"\n else:\n s="T"\n num.append(cnt2)\n cnt2=1\n else:\n cnt2+=1\nnum.append(cnt2)\nans=0\nnum3=0\nif len(num)%2==1:\n num3=num[-1]\nfor i in range(len(num)//2):\n if num[-2*(i+1)]>=num[-2*i-1]+num3:\n ans+=(num[-2*i-1]+num3)*2\n num3=0\n else:\n ans+=(num[-2*(i+1)])*2\n num3=num[-2*i-1]+num3-num[-2*(i+1)]\nprint(len(x)-ans)\n', 'x=list(input())\nnum=[]\ns="S"\ncnt=len(x)\nfor i in range(len(x)):\n if x[i]==s:\n cnt=i\n break\ncnt2=0\nfor i in range(cnt,len(x)):\n if x[i]!=s:\n if s=="T":\n s="S"\n else:\n s="T"\n num.append(cnt2)\n cnt2=1\n else:\n cnt2+=1\nnum.append(cnt2)\nans=0\nnum3=0\nif len(num)%2==1:\n num3=num[-1]\nfor i in range(len(num)//2):\n if num[-2*(i+1)]>=num[-2*i-1]+num3:\n ans+=(num[-2*i+1]+num3)*2\n num3=0\n else:\n ans+=(num[-2*(i+1)])*2\n num3=num[-2*i-1]+num3-num[-2*(i+1)]\nprint(len(x)-ans)\n', 'x=list(input())\nnum=[]\ns="S"\ncnt=len(x)\nfor i in range(len(x)):\n if x[i]==s:\n cnt=i\n break\ncnt2=0\nfor i in range(cnt,len(x)):\n if x[i]!=s:\n if s=="T":\n s="S"\n else:\n s="T"\n num.append(cnt2)\n cnt2=1\n else:\n cnt2+=1\nnum.append(cnt2)\nans=0\nnum3=0\nif len(num)%2==1:\n del(num[-1])\nfor i in range(len(num)//2):\n if num[-2*(i+1)]>=num[-2*i-1]+num3:\n ans+=(num[-2*i-1]+num3)*2\n num3=0\n else:\n ans+=(num[-2*(i+1)])*2\n num3=num[-2*i-1]+num3-num[-2*(i+1)]\nprint(len(x)-ans)\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s370242033', 's428758819', 's485414533'] | [11320.0, 11416.0, 11420.0] | [91.0, 99.0, 92.0] | [580, 580, 580] |
p03986 | u371467115 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x=input()\nwhile "ST" in x:\n x.strip("ST")\nprint(len(x))', 'x=str(input())\nwhile "ST" in x:\n x.strip("ST")\nprint(len(x))\n', "S = input()\ns = t = 0\nfor c in S:\n if c == 'S':\n s += 1\n else:\n if s > 0:\n s -= 1\n else:\n t += 1\nprint(s+t)\n＃コピペです\n", 'x = list(input())\nc = 0\nfor i in x:\n if i == "S":\n c += 1\n elif c>0:\n c -= 1\nprint(2*c)\n \n'] | ['Time Limit Exceeded', 'Time Limit Exceeded', 'Runtime Error', 'Accepted'] | ['s080315099', 's165080861', 's464426929', 's279240043'] | [3500.0, 3500.0, 2940.0, 4840.0] | [1056.0, 1056.0, 17.0, 53.0] | [56, 64, 172, 99] |
p03986 | u374802266 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['s=input()\na,b,n=0,0,len(s)\nfor i in range(n):\n if s[i]==T:\n if a==0:\n b+=1\n else:\n a-=1\n else:\n a+=1\nprint(n-2*a)', "s=input()\na,b,n=0,0,len(s)\nfor i in range(n):\n if s[i]=='T':\n if a==0:\n b+=1\n else:\n a-=1\n b-=1\n else:\n a+=1\n b+=1\nprint(b)"] | ['Runtime Error', 'Accepted'] | ['s482391659', 's606991687'] | [3500.0, 3500.0] | [18.0, 65.0] | [162, 190] |
p03986 | u397531548 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['S=list(input())\ni=0\nwhile 0<=i<=len(S)-1:\n if S[i]=="S":\n if S[i+1]=="T":\n S.remove(S[i])\n S.remove(S[i])\n i-=1\n else:\n i+=1\n else:\n i+=1\nprint(len(S))', 'S=list(input())\ni=0\nwhile 0<=i<=len(S)-1:\n if S[i]=="S":\n if S[i+1]=="T":\n S.remove(S[i])\n S.remove(S[i])\n i=0\n else:\n i+=1\n else:\n i+=1\nprint(len(S))\n ', 'S=input()\nt=0\nu=0\nfor v in S:\n if v=="S":\n t+=1\n else:\n if t>=1:\n u+=2\n t-=1\nprint(len(S)-u)'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s051358370', 's302055052', 's903152641'] | [4840.0, 4840.0, 3500.0] | [1056.0, 1056.0, 51.0] | [222, 234, 134] |
p03986 | u405256066 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['from sys import stdin\nX = (stdin.readline().rstrip())\nstack = []\nfor i in X:\n if i == "S":\n stack.append(i)\n elif i == "T" and stack[-1] == "S":\n stack.pop()\n else:\n stack.append(i)\nprint(len(stack))', 'from sys import stdin\nX = (stdin.readline().rstrip())\nX_l = X[:(len(X)/2)]\nX_r = X[(len(X)/2):]\nprint(len(X) - min(X_l.count("S"),X_r.count("T")) * 2)', 'from sys import stdin\nfrom collections import deque\nX = (stdin.readline().rstrip())\nstack = []\nfor i in X:\n if i == "S":\n stack.append(i)\n elif (i == "T" and stack == []):\n stack.append(i)\n elif (i == "T" and stack[-1] == "S"):\n stack.pop()\n else:\n stack.append(i)\nprint(len(stack))'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s599169645', 's904325486', 's721449520'] | [4328.0, 3500.0, 5348.0] | [54.0, 18.0, 71.0] | [229, 150, 322] |
p03986 | u408375121 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["x = input()\nt_num = 0\ns_num = 0\ntotal = 0\nfor i in range(len(x)):\n if x[i] == 'S' and t_num == 0:\n s_num += 1\n elif x[i] == 'T':\n t_num += 1\n elif x[i] == 'S' and t_num > 0:\n total += min(s_num, t_num) * 2\n if s_num >= t_num:\n s_num = 1 + s_num - t_num\n t_num = 0\n else:\n s_num = 1\n t_num = 0\ntotal += min(s_num, t_num) * 2\nans = len(x) - total", "x = input()\nt_num = 0\ns_num = 0\ntotal = 0\nfor i in range(len(x)):\n if x[i] == 'S' and t_num == 0:\n s_num += 1\n elif x[i] == 'T':\n t_num += 1\n elif x[i] == 'S' and t_num > 0:\n total += min(s_num, t_num) * 2\n if s_num >= t_num:\n s_num = 1 + s_num - t_num\n t_num = 0\n else:\n s_num = 1\n t_num = 0\ntotal += min(s_num, t_num) * 2\nans = len(x) - total\nprint(ans)"] | ['Wrong Answer', 'Accepted'] | ['s245569130', 's420757072'] | [3500.0, 3500.0] | [90.0, 95.0] | [382, 393] |
p03986 | u417365712 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["S = input()\na = S.count('S')\nb = S.count('T')\nc = 0\nfor s in S:\n if s == 'T':\n c += 1\n else:\n break\nd = 0\nfor s in S[::-1]:\n if s == 'S':\n d += 1\n else:\n break\nc + d + abs(a-d - (b-c))", "a = b = 0\nfor s in input():\n if s == 'S':\n a += 1\n else:\n if a == 0:\n b += 1\n else:\n a -= 1\nprint(a+b)"] | ['Wrong Answer', 'Accepted'] | ['s450539097', 's243986015'] | [9196.0, 9272.0] | [28.0, 50.0] | [200, 123] |
p03986 | u539517139 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["x=input()\nt=0\nfor i in range(len(x)-1,-1,-1):\n if x[i]=='T':\n t+=1\n else:\n if t>0:\n t-=1\n else:\n s+=1\nprint(s+t)", "x=input()\nt=0;s=0\nfor i in range(len(x)-1,-1,-1):\n if x[i]=='T':\n t+=1\n else:\n if t>0:\n t-=1\n else:\n s+=1\nprint(s+t)"] | ['Runtime Error', 'Accepted'] | ['s888036852', 's825636702'] | [3500.0, 3500.0] | [59.0, 53.0] | [133, 137] |
p03986 | u543954314 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x = []\ns = input()\nfor i in s:\n if i == "S":\n x.append(i)\n elif x != [] and x[-1] == "S":\n x.pop()\nprint(len(x))', 'x = []\ns = input()\nfor i in s:\n if i == "T" and x != [] and x[-1] == "S":\n x.pop()\n else:\n x.append(i)\nprint(len(x))'] | ['Wrong Answer', 'Accepted'] | ['s489761402', 's449800300'] | [4328.0, 5096.0] | [66.0, 62.0] | [120, 124] |
p03986 | u557494880 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["S = input()\nn = len(S)\nans = 0\ns = 0\nt = 0\nfor i in range(N):\n x = S[i]\n if x == 'S':\n s += 1\n if t > 0:\n if s > t:\n s -= t\n else:\n t = t-s\n ans += t\n s = 0\n else:\n t += 1\nans += s\nprint(ans)", "S = input()\nn = len(S)\nans = 0\ns = 0\nt = 0\nfor i in range(n):\n x = S[i]\n if x == 'S':\n s += 1\n else:\n if s > 0:\n s -= 1\n else:\n ans += 1\nans += s\nprint(ans)"] | ['Runtime Error', 'Accepted'] | ['s409276312', 's064209982'] | [3500.0, 3500.0] | [18.0, 60.0] | [311, 208] |
p03986 | u562446079 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['import sys\nimport string\nimport re\ninput = lambda: sys.stdin.readline()\n\nst = []\nX = input()\nfor x in X:\n if not len(st) == 0:\n top = st.pop()\n if top == "S" and x == "T":\n continue\n else:\n st.append(top)\n st.append(x)\n else:\n st.append(x)\nprint(len(st))\n\n\n# st = []\n\n#\n# for x in s:\n# if not len(st) == 0:\n# top = st.pop()\n# # print(top)\n# if top == "S" and x == "T":\n# continue\n# else:\n# st.append(top)\n# st.append(x)\n# else:\n# st.append(x)\n#\n# print(len(st))\n\n\n# return s.replace("ST","")\n#\n# if __name__ == \'__main__\':\n# cnt = 0\n\n\n\n# s= main(s)\n# cnt = s.count("ST")\n# if cnt != 0:\n\n# print(len(s) - 1)\n# else:\n# # print(0)\n# print(len(s) - 1)\n', 'import sys\nimport string\nimport re\ninput = lambda: sys.stdin.readline()\n\n\nst = []\ns = input()\n\nfor x in s:\n if not len(st) == 0:\n top = st.pop()\n # print(top)\n if top == "S" and x == "T":\n continue\n else:\n st.append(top)\n st.append(x)\n else:\n st.append(x)\n\nprint(len(st))\n\n\n# return s.replace("ST","")\n#\n# if __name__ == \'__main__\':\n# cnt = 0\n\n\n\n# s= main(s)\n# cnt = s.count("ST")\n# if cnt != 0:\n\n# print(len(s) - 1)\n# else:\n# # print(0)\n# print(len(s) - 1)\n', 'st = []\nX = input()\nfor x in X:\n if not len(st) == 0:\n top = st.pop()\n if top == "S" and x == "T":\n continue\n else:\n st.append(top)\n st.append(x)\n else:\n st.append(x)\nprint(len(st))'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s557352858', 's688608185', 's518523628'] | [5540.0, 5552.0, 5092.0] | [124.0, 124.0, 116.0] | [943, 663, 248] |
p03986 | u595893956 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['s=input()\nsc=0\ntc=0\nfor i in s:\n if i=="S":\n sc+=1\n elif sc!=0:\n sc-=1\n else tc+=1\nprint(tc+sc)', "s=input()\nsc=0\ntc=0\nfor i in s:\n if i=='S':\n sc+=1\n elif sc!=0:\n sc-=1\n else :tc+=1\nprint(tc+sc)"] | ['Runtime Error', 'Accepted'] | ['s504974516', 's526878856'] | [2940.0, 3500.0] | [17.0, 44.0] | [104, 105] |
p03986 | u597455618 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['def main():\n x = input().replace("TS", "T S").split()\n ans = 0\n s = 0\n for i in x:\n s += i.count("S")\n t = i.count("T")\n if t <= s:\n s -= t\n ans += s\n else:\n ans += 2*(t-s)\n s = 0\n print(ans)\n\nif __name__ == "__main__":\n main()', 'def main():\n x = input()\n s, t = 0, 0\n for i in x:\n if i == "S":\n s += 1\n else:\n if s:\n s -= 1\n else:\n t += 1\n print(s + t)\n\nif __name__ == "__main__":\n main()'] | ['Wrong Answer', 'Accepted'] | ['s026136128', 's752960861'] | [12684.0, 9272.0] | [47.0, 40.0] | [317, 251] |
p03986 | u598229387 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["x=list(input())\nans=0\ncheck=0\nfor i in x:\n\tif i=='T':\n\t\tif check==0:\n\t\t\tans+=1\n\t\tcheck-=1\n\t\tcheck=max(check,0)\n\n\telse:\n\t\tcheck+=1\nprint(ans)\n\t\t", "x=list(input())\nans=0\ncheck=0\nfor i in x:\n\tif i=='T':\n\t\tif check==0:\n\t\t\tans+=1\n\t\tcheck-=1\n\t\tcheck=max(check,0)\n\n\telse:\n\t\tcheck+=1\nprint(ans*2)\n\t\t"] | ['Wrong Answer', 'Accepted'] | ['s656857891', 's026389110'] | [4840.0, 4840.0] | [76.0, 72.0] | [143, 145] |
p03986 | u603234915 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s = list(input())\nl = []\nfor i in range(len(s)):\n if s[i] == 'S':\n l.append('S')\n elif l[-1] == 'T' or not l:\n l.append('T')\n else:\n l.pop()\nprint(len(l))\n\n", "s = list(input())\nl = []\nfor i in range(len(s)):\n if s[i] == 'S':\n l.append('S')\n elif not l:\n l.append('T')\n elif l[-1] == 'T':\n l.append('T')\n else:\n l.pop()\nprint(len(l))\n\n"] | ['Runtime Error', 'Accepted'] | ['s608766512', 's328629676'] | [5668.0, 6436.0] | [61.0, 69.0] | [186, 215] |
p03986 | u617225232 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["# -*- coding: utf-8 -*-\n#\n# A - STring\n#\nimport string\n# input\nx_before = input()\nx_after = ''\ntranslator=str.maketrans('','','ST')\n# calc\nwhile True:\n x_after = x_before.translate(translator)\n if len(x_before) == len(x_after):\n break\n x_before = x_after\n# output\nprint(len(x_after))", "# -*- coding: utf-8 -*-\n#\n# A - STring\n#\n# input\nx = list(input())\nn = 0\n# calc\nfor i in range(len(x)):\n if x[i] == 'S':\n n += 1\n elif n>0:\n n -= 1\n# output\nprint(n*2)"] | ['Wrong Answer', 'Accepted'] | ['s634767156', 's049351071'] | [4140.0, 4840.0] | [28.0, 65.0] | [289, 175] |
p03986 | u619631862 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['n = int(input())\na=[int(i) for i in input().split()]\ns=[]\nsa=n*(n+1)/2\n\ns.append(a)\nfor i in range(1,n):\n s.append([])\n for j in range(len(s[i-1])-1):\n if s[i-1][j]<s[i-1][j+1]:\n s[i].append(s[i-1][j])\n sa+=s[i-1][j]\n else:\n s[i].append(s[i-1][j+1])\n sa+=s[i-1][j+1]\nprint(int(sa))', 's = input()\n\na=[]\nfor i in range(len(s)):\n if s[i]=="S":\n a.append("S")\n if s[i]=="T":\n if len(a)==0 or a[-1]=="T":\n a.append("T")\n if a[-1]=="S":\n a.pop()\nprint (len(a))'] | ['Runtime Error', 'Accepted'] | ['s549822530', 's988929801'] | [3756.0, 5096.0] | [25.0, 108.0] | [317, 198] |
p03986 | u671252250 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['# coding: utf-8\n# Your code here!\n\nX = list(input())\nnum = len(X)\nstack = []\n\nfor i in X:\n if i == "S":\n stack.append(i)\n else:\n if stack[-1] == "T" or stack[0] == "":\n stack.append(i)\n else:\n stack.pop()\nprint(len(stack))\n', '# coding: utf-8\n# Your code here!\n\nX = list(input())\nnum = len(X)\nstack = []\n\nfor i in X:\n if i == "S":\n stack.append(i)\n else:\n if stack == [] or stack[-1] == "T":\n stack.append(i)\n else:\n stack.pop()\nprint(len(stack))\n'] | ['Runtime Error', 'Accepted'] | ['s803491766', 's679631966'] | [5668.0, 6436.0] | [58.0, 58.0] | [272, 269] |
p03986 | u729133443 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["x=input()\nif len(x)==6:print('hoge')\nfor _ in range(len(x)//2):x=x.replace('ST','')\nprint(len(x))", "x=input();c=0\nif len(x)==6:print('hoge')\nfor t in x:c+=t=='S'or(c>0)*-1\nprint(2*c)", "x=input();c=0\nif len(x)==6:print('hoge')\nfor t in x:c+=-(c>0and t=='T')or 1;print(c)\nprint(2*c)", "x=list(input())\nif len(x)==6:print('hoge')\nwhile 1:\n\tfor i in range(len(x)-1):\n\t\tif x[i]=='S'and x[i+1]=='T':\n\t\t\ts=i-1;t=i+2\n\t\t\twhile s>=0and x[s]=='S':s-=1\n\t\t\twhile t<len(x)and x[t]=='T':t+=1\n\t\t\tr=min(i-s,t-i-1)\n\t\t\tdel x[i-r+1:i+r+1];break\n\telse:break\nprint(len(x))", "x=input()\nif len(x)==6:print('hoge')\nfor _ in range(len(x)//2):x=x.strip('ST')\nprint(len(x))", "x=input()\nif len(x)==6:print('hoge')\nfor _ in range(len(x)//2):x=''.join(x.split('ST'))\nprint(len(x))", "x=input();c=0\nif len(x)==6:print('hoge')\nfor t in x:c+=-(c>0and t=='T')or 1\nprint(2*c)", "c=0\nfor x in input():c+=x<'T'or-(c>0)\nprint(2*c)"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s187471453', 's388420535', 's519410193', 's580309870', 's601613029', 's617300732', 's678557570', 's112285445'] | [3500.0, 3500.0, 4708.0, 4840.0, 3500.0, 5224.0, 3500.0, 3500.0] | [1056.0, 53.0, 188.0, 1056.0, 36.0, 1056.0, 63.0, 55.0] | [97, 82, 95, 266, 92, 101, 86, 48] |
p03986 | u747703115 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X = input()\nwhile X!=X_:\n X_ = X\n X = X.replace('ST', '')\nprint(len(X))", "from collections import deque\nX = input()\nque = deque()\nfor x in X:\n if x=='S':\n que.append('S')\n elif x=='T' and (not que or que[-1]=='T'):\n que.append('T')\n elif x=='T' and que[-1]=='S':\n _ = que.pop()\n print(que)\nprint(len(que))", "from collections import deque\nX = input()\nque = deque()\nfor x in X:\n if x=='S':\n que.append('S')\n elif x=='T' and (not que or que[-1]=='T'):\n que.append('T')\n elif x=='T' and que[-1]=='S':\n _ = que.pop()\nprint(len(que))"] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s185198142', 's618007990', 's724702278'] | [9224.0, 105548.0, 10776.0] | [25.0, 1242.0, 66.0] | [77, 264, 249] |
p03986 | u798286927 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s = input()\n\ns = s.lstrip('ST')\n\nprint(len(s))", "s = input()\n\nstack = []\n\nfor i in s:\n if i == 'S':\n stack.append(i)\n if i == 'T':\n if not stack:\n stack.append(i)\n continue\n last = stack.pop()\n if last == 'S':\n continue\n else:\n stack.append(last)\n stack.append(i)\n\nprint(len(stack))\n"] | ['Wrong Answer', 'Accepted'] | ['s001915618', 's662201542'] | [3500.0, 5092.0] | [26.0, 83.0] | [46, 330] |
p03986 | u802772880 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s=input()\nls=len(s)\nc=0\nfor i in range(ls):\n if s[i]=='S':\n c+=1\n elif c>0:\n ans+=2\n c-=1\nprint(ls-ans)", "s=input()\nls=len(s)\nc=0\nans=0\nfor i in range(ls):\n if s[i]=='S':\n c+=1\n elif c>0:\n ans+=2\n c-=1\nprint(ls-ans)"] | ['Runtime Error', 'Accepted'] | ['s909052226', 's918275354'] | [3500.0, 3500.0] | [18.0, 63.0] | [130, 136] |
p03986 | u814986259 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['X = input()\nX = list(X)\nprev = ""\nfor i in range(len(X) - 1):\n if X[i] + X[i + 1] == "ST":\n a = X.pop(i + 1)\n b = X.pop(i)\n X = [b,a].extend(X)\n\nfor i in range(0, len(X)):\n if X[len(X) - (i+1)] == "T":\n print(i * 2)\n break', 'X = input()\nY = []\nfor i in X:\n Y.append(i)\n if len(Y) > 1:\n if Y[-2] + Y[-1] == "ST":\n Y.pop()\n Y.pop()\nprint(len(Y))'] | ['Runtime Error', 'Accepted'] | ['s000942539', 's700237529'] | [6304.0, 5096.0] | [22.0, 124.0] | [263, 153] |
p03986 | u832039789 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s=input()\nfor i in range(len(s)//2,0,-1):\n s.replace('S'*i+'T'*i,'')\nprint(len(s))", "s = input()\nSSS = 0\nlen = 0\nfor c in s:\n if c == 'S':\n SSS += 1\n len += 1\n elif SSS == 0:\n len += 1\n else:\n SSS -= 1\n len -= 1\n # print(len)\nprint(len)\n"] | ['Wrong Answer', 'Accepted'] | ['s691009512', 's588640071'] | [3620.0, 3500.0] | [1056.0, 61.0] | [83, 199] |
p03986 | u846150137 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['a=input()\nb=0\nx=0\nfor i in a:\n if i=="T" and x<0: \n x+=1\n else:\n x-=1\n \n if x>=1 or(x==0 and i=="S"):\n b+=1\nprint(b-min(x,0))', 'a=input()\nx=0\nb=0\nfor i in a:\n if i=="T" and x<=-1:\n x+=1\n elif i=="S":\n x-=1\n \n if x==0:\n b+=1\nprint(b*2)', 'a=input()\nb=0\nx=0\nfor i in a:\n if i=="T":\n x+=1\n else:\n x-=1\n if x>=1 or(x==0 and i=="S"):\n b+=1\nprint(b-min(x,0))', 'a=input()\nfor i in range(10**6):\n a.replace("ST","")\nprint(len(a))', 'a=input()\nx=0\nb=0\nfor i in a:\n if i=="T" and x<-1:\n x+=1\n elif i=="S":\n x-=1\n \n if x==0:\n b+=1\nprint(b*2)', 'a=input()\nx=0\nb=0\nfor i in a:\n if i=="T" and x<=-1:\n x+=1\n elif i=="S":\n x-=1\n elif x==0:\n b+=1\nprint(b*2)'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s013999488', 's383349173', 's612369205', 's643139642', 's863984467', 's575610322'] | [3500.0, 3500.0, 3500.0, 3500.0, 3500.0, 3500.0] | [65.0, 59.0, 62.0, 1056.0, 61.0, 54.0] | [140, 121, 126, 67, 120, 118] |
p03986 | u867826040 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['from collections import deque\n\ns = input()\nq = deque()\n\nfor si in s:\n print(q)\n if si == "S":\n q.append(si)\n elif si == "T" and len(q) == 0:\n q.append(si)\n elif q[-1] == "T":\n q.append(si)\n elif q[-1] == "S":\n q.pop()\nprint(len(q))', 'from collections import deque\n\ns = input()\nq = deque()\n\nfor si in s:\n if si == "S":\n q.append(si)\n elif si == "T" and len(q) == 0:\n q.append(si)\n elif q[-1] == "T":\n q.append(si)\n elif q[-1] == "S":\n q.pop()\nprint(len(q))'] | ['Wrong Answer', 'Accepted'] | ['s796574413', 's144948324'] | [110588.0, 10676.0] | [1236.0, 72.0] | [274, 261] |
p03986 | u871841829 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X = input()\n\ncache = 0\nans = len(X)\n\nfor c in X:\n if c == 'S'\n cache += 1\n else:\n if cache > 0:\n cache -= 1\n ans -= 2\n\nprint(ans)", "X = input()\n\ncache = 0\nans = len(X)\n\nfor c in X:\n if c == 'S':\n cache += 1\n else:\n if cache > 0:\n cache -= 1\n ans -= 2\n\nprint(ans)"] | ['Runtime Error', 'Accepted'] | ['s974952176', 's286204635'] | [8920.0, 9328.0] | [24.0, 56.0] | [171, 172] |
p03986 | u905715926 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s = input()\nsums = 0\nsumt = 0\nans = 0\nfor i in s:\n if i == 'S':\n if sumt > 0:\n sumt-=1\n ans += 2\n else:\n sums += 1\n else:\n if sums > 0:\n sums -= 1\n ans += 2\n else:\n sumt += 1\nprint(len(s)-ans)\n", "def solve(s):\n sums = 0\n sumt = 0\n ans = 0\n for i in s:\n if i == 'S':\n sums += 1\n else:\n if sums > 0:\n sums -= 1\n ans += 2\n return len(s)-ans\n\nif __name__ == '__main__':\n print(solve(input()))\n"] | ['Wrong Answer', 'Accepted'] | ['s171803989', 's299493440'] | [3500.0, 3500.0] | [58.0, 37.0] | [293, 277] |
p03986 | u923270446 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x=input()\ns,a=0,0\nfor i in x:\n if i=="S":\n s+=1\n elif s==0:\n ans+=1\n else:\n s-=1\nprint(ans+s)', 'x=input()\ns,a=0,0\nfor i in x:\n if i=="S":\n s+=1\n elif s==0:\n a+=1\n else:\n s-=1\nprint(a+s)'] | ['Runtime Error', 'Accepted'] | ['s060375222', 's477155717'] | [3500.0, 3500.0] | [43.0, 46.0] | [96, 92] |
p03986 | u940102677 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['x = list(input())\nc = 0\nd = 0\nfor i in x:\n if x == "S":\n c += 1\n elif c>0:\n c -= 1\n else:\n d += 1\nprint(2*d)\n ', 'x = list(input())\nc = 0\nfor i in x:\n if x == "S":\n c += 1\n elif c>0:\n c -= 1\nprint(2*c)\n ', 'x = input()\nc = 0\nfor i in x:\n if x == "S":\n c += 1\n elif c>0:\n c -= 1\nprint(2*c)\n ', 'x = input()\nwhile "ST" in x:\n x.replace("ST","")\nprint(len(x))', 'x = list(input())\nc = 0\nfor i in x:\n if i == "S":\n c += 1\n elif c>0:\n c -= 1\nprint(2*c)\n '] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Time Limit Exceeded', 'Accepted'] | ['s237637190', 's258725711', 's749885177', 's901870076', 's879501877'] | [4840.0, 4840.0, 3500.0, 3500.0, 4840.0] | [53.0, 40.0, 40.0, 1056.0, 49.0] | [123, 98, 92, 63, 98] |
p03986 | u941753895 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["l=[]\nx=list(input())\nif ''.join([str(i) for i in x])=='TSTTSS':\n exit()\nfor i in x:\n if i=='S':\n l.append(i)\n elif len(l)>0:\n a=l.pop()\n if a=='S':\n pass\n else:\n l.append('S')\n l.append('S')\n else:\n l.append(i)\nprint(len(l))", "l=[]\nx=list(input())\nif ''.join([str(i) for i in x])=='TSTTSS':\n exit()\nfor i in x:\n if i=='S':\n l.append(i)\n elif len(l)>0:\n a=l.pop()\n if a=='S':\n pass\n else:\n l.append('T')\n l.append('T')\n else:\n l.append(i)\nprint(len(l))", "l=[]\nx=list(input())\nfor i in x:\n if i=='S':\n l.append(i)\n elif len(l)>0:\n a=l.pop()\n if a=='S':\n pass\n else:\n l.append('T')\n l.append('T')\n else:\n l.append(i)\nprint(len(l))"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s041928154', 's092117612', 's041945832'] | [6436.0, 6436.0, 6436.0] | [89.0, 101.0, 76.0] | [258, 258, 206] |
p03986 | u948524308 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['X=input()\n\nS=0\n\nfor i in range(L):\n if X[-(1+i)]=="S":\n S+=1\n else:\n break\nprint(2*S)\n\n', 'S=input()\nA1=[]\nL=len(S)\nA1.append(S[0])\n\nfor i in range(1,L):\n if len(A1)>=1 and A1[-1]=="S" and S[i]=="T":\n A1.pop(-1)\n else:\n A1.append(S[i])\n\nprint(len(A1))'] | ['Runtime Error', 'Accepted'] | ['s335802274', 's536157805'] | [3500.0, 5092.0] | [18.0, 95.0] | [107, 180] |
p03986 | u966695411 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["s = input()\nfor i in range(10**10000):\n print(s)\n if 'st' in s:\n sp = s.split('st', 1)\n s = sp[0] + sp[1]\n else:\n break\nprint(s)", "s = input()\ncnt = 0\nwhile cnt < 100000:\n print(1)\n n = len(s)\n s = ''.join(s.split('ST'))\n if len(s) != n:\n cnt += (len(s) - n) // 2\n else:\n break\n i = s.find('ST')\n \n stlen = 0\n if i > 0:\n for j in range(min(i, len(s)-2-i)):\n if s[i-j-1] == 'S' and s[i+j+2] == 'T':\n stlen += 1\n else:\n break\n s = s[:i-stlen] + s[i+stlen+2:]\n cnt += 1 + stlen\nprint(len(s))", "s = input()\nfor i in range(10**10000):\n print(s)\n if 'ST' in s:\n sp = s.split('ST', 1)\n s = sp[0] + sp[1]\n else:\n break\nprint(s)", "def main():\n s = input()\n cnts = 0\n cnt = 0\n for i in s:\n if i == 'S':\n cnts += 1\n elif cnts > 0:\n cnts -= 1\n cnt += 1\n print(len(s)-cnt*2)\nif __name__ == '__main__':\n main()"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s068016808', 's396594778', 's544182666', 's669846398'] | [4072.0, 5348.0, 135076.0, 3500.0] | [25.0, 64.0, 852.0, 42.0] | [158, 471, 158, 239] |
p03986 | u977193988 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ['import sys\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\nsys.setrecursionlimit(10 ** 9)\n\n\ndef main():\n X = input()\n answer = len(X)\n cnt_s = 0\n for x in X:\n if x == "S":\n cnt_s += 1\n continue\n if cnt_s > 0:\n cnt_s -= 1\n else:\n answer -= 2\n print(answer)\n\n\nif __name__ == "__main__":\n main()\n', 'import sys\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\nsys.setrecursionlimit(10 ** 9)\n\n\ndef main():\n X = input()\n answer = len(X)\n cnt_s = 0\n for x in X:\n if x == "S":\n cnt_s += 1\n continue\n if cnt_s > 0:\n cnt_s -= 1\n answer -= 2\n \n print(answer)\n\n\nif __name__ == "__main__":\n main()\n'] | ['Wrong Answer', 'Accepted'] | ['s016841744', 's306331327'] | [3500.0, 3500.0] | [32.0, 38.0] | [385, 384] |
p03986 | u993622994 | 1,000 | 262,144 | We have a string X, which has an even number of characters. Half the characters are `S`, and the other half are `T`. Takahashi, who hates the string `ST`, will perform the following operation 10^{10000} times: * Among the occurrences of `ST` in X as (contiguous) substrings, remove the leftmost one. If there is no occurrence, do nothing. Find the eventual length of X. | ["X = input()\n\nfor j in range(len(X//2)):\n X = X.replace('ST', '')\n if 'ST' not in X:\n break\n\nprint(len(X))", "X = input()\n\nfor j in range(X//2):\n X = X.replace('ST', '')\n if 'ST' not in X:\n break\n\nprint(len(X))", "X = input()\ns = cnt = 0\n\nfor i in range(len(X)):\n if X[i] == 'S':\n s += 1\n elif s != 0:\n cnt += 2\n s -= 1\n\nans = len(X) - cnt\nprint(ans)"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s799756285', 's903248441', 's933209072'] | [3500.0, 3500.0, 3500.0] | [18.0, 18.0, 59.0] | [118, 113, 163] |
p03987 | u077337864 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import heapq\n\nn = int(input())\nalist = list(map(int, input().split()))\n\nad = {}\nfor i, a in enumerate(alist):\n ad[a] = i\n\nh = []\nright = [n-1] * n\n\nfor i in range(n):\n while h and -h[0] > alist[i]:\n v = -heapq.heappop(h)\n right[ad[v]] = i - 1\n heapq.heappush(h, -alist[i])\n print(right, h)\n\nh = []\nleft = [0] * n\n\nfor i in reversed(range(n)):\n while h and -h[0] > alist[i]:\n v = -heapq.heappop(h)\n left[ad[v]] = i + 1\n heapq.heappush(h, -alist[i])\n print(left, h)\n\nans = 0\nfor i in range(n):\n ans += alist[i] * (i - left[i] + 1) * (right[i] - i + 1)\n print(ans)\n\nprint(ans)\n', 'import heapq\n\nn = int(input())\nalist = list(map(int, input().split()))\n\nad = {}\nfor i, a in enumerate(alist):\n ad[a] = i\n\nh = []\nright = [n-1] * n\n\nfor i in range(n):\n while h and -h[0] > alist[i]:\n v = -heapq.heappop(h)\n right[ad[v]] = i - 1\n heapq.heappush(h, -alist[i])\n\nh = []\nleft = [0] * n\n\nfor i in reversed(range(n)):\n while h and -h[0] > alist[i]:\n v = -heapq.heappop(h)\n left[ad[v]] = i + 1\n heapq.heappush(h, -alist[i])\n\nans = 0\nfor i in range(n):\n ans += alist[i] * (i - left[i] + 1) * (right[i] - i + 1)\n\nprint(ans)\n'] | ['Runtime Error', 'Accepted'] | ['s694118831', 's422403485'] | [166968.0, 47028.0] | [1500.0, 785.0] | [595, 547] |
p03987 | u098968285 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['\n# \treturn [[0 for i in range(m)] for j in range(n)]\n\n# a = int(input())\n# b, c = map(int, input().split())\n\n\n\npar = [0]*202020\nsize = [0]*202020\n\ndef find(x):\n\tif par[x] == x:\n\t\treturn x\n\telse:\n\t\tpar[x] = find(par[x])\n\t\treturn par[x]\n\ndef unite(x, y):\n\tx = find(x)\n\ty = find(y)\n\tres = size[x] * size[y]\n\tsize[x] += size[y]\n\tpar[y] = x\n\treturn res\n\n# main\nn = int(input())\nfor i in range(202020):\n\tpar[i] = i\n\tsize[i] = 1\n\na = [0] + list(map(int, input().split()))\nb = [0]*(n+1)\nfor i in range(1, n+1):\n\tb[a[i]] = i\n\nans = 0\nfor j in reversed(1, n+1):\n\ti = b[j]\n\tans += a[i]\n\tif i - 1 >= 1 and a[i-1] > a[i]:\n\t\tans += unite(i-1, i) * a[i]\n\tif i + 1 <= n and a[i+1] > a[i]:\n\t\tans += unite(i+1, i) * a[i]\nprint(ans)\n', '\n# \treturn [[0 for i in range(m)] for j in range(n)]\n\n# a = int(input())\n# b, c = map(int, input().split())\n\n\n\npar = [0]*202020\nsize = [0]*202020\n\ndef find(x):\n\tif par[x] == x:\n\t\treturn x\n\telse:\n\t\tpar[x] = find(par[x])\n\t\treturn par[x]\n\ndef unite(x, y):\n\tx = find(x)\n\ty = find(y)\n\tres = size[x] * size[y]\n\tsize[x] += size[y]\n\tpar[y] = x\n\treturn res\n\n# main\nn = int(input())\nfor i in range(202020):\n\tpar[i] = i\n\tsize[i] = 1\n\na = [0] + list(map(int, input().split()))\nb = [0]*(n+1)\nfor i in range(1, n+1):\n\tb[a[i]] = i\n\nans = 0\nfor j in reversed(range(1, n+1)):\n\ti = b[j]\n\tans += a[i]\n\tif i - 1 >= 1 and a[i-1] > a[i]:\n\t\tans += unite(i-1, i) * a[i]\n\tif i + 1 <= n and a[i+1] > a[i]:\n\t\tans += unite(i+1, i) * a[i]\nprint(ans)\n'] | ['Runtime Error', 'Accepted'] | ['s044811849', 's386047784'] | [34344.0, 34344.0] | [187.0, 638.0] | [748, 755] |
p03987 | u284854859 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n\n def search_lower(self,key,key_lower,key_higher):\n if self.key == None:\n return [key_lower,key_higher]\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return [key_lower,key_higher]\n else:\n return self.left.search_lower(key,key_lower,key_higher)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return [key_lower,key_higher]\n else:\n return self.right.search_lower(key,key_lower,key_higher)\n \n if self.left == None and self.right == None:\n return [key_lower,key_higher]\n if self.left == None:\n if key_higher == None:\n key_higher = 10**6\n return [key_lower,min(key_higher,self.right.end_lower(self.right.key))]\n if self.right == None:\n if key_lower == None:\n key_lower = -10**6\n return [max(key_lower,self.left.end_higher(self.left.key)),key_higher]\n \n if key_lower == None:\n key_lower = -10**6\n if key_higher == None:\n key_higher = 10**6 \n return [max(key_lower,self.left.end_higher(self.left.key)),min(key_higher,self.right.end_lower(self.right.key))]\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n\n\n################################################################\n\ndef inpl(): return [int(i) for i in input().split()]\nn = int(input())\na = inpl()\nb = {a[i]: i for i in range(n)}\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n [l,r] = root.search_lower(b[i],-1,n)\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(1)\n', '\n\n\n\n\n\n\n################################################################################\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n def search(self,key):\n if self.key == None:\n return None\n if self.key > key:\n if self.left == None:\n return None\n else:\n return self.left.search(key)\n if self.key < key:\n if self.right == None:\n return None\n else:\n return self.right.search(key)\n return self \n \n def search_lower(self,key,key_lower):\n if self.key == None:\n return key_lower\n if self.key > key:\n if self.left == None:\n return key_lower\n else:\n return self.left.search_lower(key,key_lower)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return key_lower\n else:\n return self.right.search_lower(key,key_lower)\n \n if self.left == None:\n return key_lower\n else:\n if key_lower == None:\n return self.left.end_higher(self.left.key)\n else:\n return max(key_lower,self.left.end_higher(self.left.key))\n \n def search_higher(self,key,key_higher):\n if self.key == None:\n return key_higher\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return key_higher\n else:\n return self.left.search_higher(key,key_higher)\n if self.key < key:\n if self.right == None:\n return key_higher\n else:\n return self.right.search_higher(key,key_higher)\n \n if self.right == None:\n return key_higher\n else:\n if key_higher == None:\n return self.right.end_lower(self.right.key)\n else:\n return min(key_higher,self.right.end_lower(self.right.key))\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n\n def to_s(self):\n return self.key\n def left_s(self):\n if self.left == None:\n return None\n return (self.left).key\n def right_s(self):\n if self.right == None:\n return None\n return (self.right).key\n\n################################################################\nn = int(input())\na = list(map(int,input().split()))\t\n\n\nb = [0]*(n+1)\nfor i in range(n):\n b[a[i]] = i\n\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n l = root.search_lower(b[i],None)\n r = root.search_higher(b[i],None)\n if l == None:\n l = -1\n if r == None:\n r = n\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(0)', '\n\n\n\n\n\n \n################################################################################\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n\n def search_lower(self,key,key_lower):\n if self.key == None:\n return key_lower\n if self.key > key:\n if self.left == None:\n return key_lower\n else:\n return self.left.search_lower(key,key_lower)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return key_lower\n else:\n return self.right.search_lower(key,key_lower)\n \n if self.left == None:\n return key_lower\n else:\n if key_lower == None:\n return self.left.end_higher(self.left.key)\n else:\n return max(key_lower,self.left.end_higher(self.left.key))\n \n def search_higher(self,key,key_higher):\n if self.key == None:\n return key_higher\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return key_higher\n else:\n return self.left.search_higher(key,key_higher)\n if self.key < key:\n if self.right == None:\n return key_higher\n else:\n return self.right.search_higher(key,key_higher)\n \n if self.right == None:\n return key_higher\n else:\n if key_higher == None:\n return self.right.end_lower(self.right.key)\n else:\n return min(key_higher,self.right.end_lower(self.right.key))\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n\n\n################################################################\n\ndef inpl(): return [int(i) for i in input().split()]\nn = int(input())\na = inpl()\nb = {a[i]: i for i in range(n)}\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n l = root.search_lower(b[i],None)\n r = root.search_higher(b[i],None)\n if l == None:\n l = -1\n if r == None:\n r = n\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(0)\n', '\n\n\n\n\n\n \n################################################################################\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n\n def search_lower(self,key,key_lower):\n if self.key == None:\n return key_lower\n if self.key > key:\n if self.left == None:\n return key_lower\n else:\n return self.left.search_lower(key,key_lower)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return key_lower\n else:\n return self.right.search_lower(key,key_lower)\n \n if self.left == None:\n return key_lower\n else:\n if key_lower == None:\n return self.left.end_higher(self.left.key)\n else:\n return max(key_lower,self.left.end_higher(self.left.key))\n \n def search_higher(self,key,key_higher):\n if self.key == None:\n return key_higher\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return key_higher\n else:\n return self.left.search_higher(key,key_higher)\n if self.key < key:\n if self.right == None:\n return key_higher\n else:\n return self.right.search_higher(key,key_higher)\n \n if self.right == None:\n return key_higher\n else:\n if key_higher == None:\n return self.right.end_lower(self.right.key)\n else:\n return min(key_higher,self.right.end_lower(self.right.key))\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n\n\n################################################################\n\ndef inpl(): return [int(i) for i in input().split()]\nn = int(input())\na = inpl()\nb = {a[i]: i for i in range(n)}\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n l = root.search_lower(b[i],None)\n r = root.search_higher(b[i],None)\n if l == None:\n l = -1\n if r == None:\n r = n\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(0)', '\n\n\n\n\n\n \n################################################################################\nclass Avltree:\n def __init__(self,key=None):\n self.key = key\n self.left = None\n self.right = None \n self.balance = "Even"\n def search(self,key):\n if self.key == None:\n return None\n if self.key > key:\n if self.left == None:\n return None\n else:\n return self.left.search(key)\n if self.key < key:\n if self.right == None:\n return None\n else:\n return self.right.search(key)\n return self \n \n def search_lower(self,key,key_lower):\n if self.key == None:\n return key_lower\n if self.key > key:\n if self.left == None:\n return key_lower\n else:\n return self.left.search_lower(key,key_lower)\n if self.key < key:\n key_lower = self.key\n if self.right == None:\n return key_lower\n else:\n return self.right.search_lower(key,key_lower)\n \n if self.left == None:\n return key_lower\n else:\n if key_lower == None:\n return self.left.end_higher(self.left.key)\n else:\n return max(key_lower,self.left.end_higher(self.left.key))\n \n def search_higher(self,key,key_higher):\n if self.key == None:\n return key_higher\n if self.key > key:\n key_higher = self.key\n if self.left == None:\n return key_higher\n else:\n return self.left.search_higher(key,key_higher)\n if self.key < key:\n if self.right == None:\n return key_higher\n else:\n return self.right.search_higher(key,key_higher)\n \n if self.right == None:\n return key_higher\n else:\n if key_higher == None:\n return self.right.end_lower(self.right.key)\n else:\n return min(key_higher,self.right.end_lower(self.right.key))\n \n \n def end_lower(self,end_lower_key):\n if self.left == None:\n return end_lower_key\n else:\n end_lower_key = self.left.key\n return self.left.end_lower(end_lower_key)\n def end_higher(self,end_higher_key):\n if self.right == None:\n return end_higher_key\n else:\n end_higher_key = self.right.key\n return self.right.end_higher(end_higher_key)\n \n \n def DoubleRightRotation(self):\n tl = self.left\n self.left = tl.right.right\n tl.right.right = self \n tlr = tl.right\n tl.right = tlr.left\n tlr.left = tl\n if tlr.balance == "Left":\n tlr.right.balance = "Right"\n tlr.left.balance = "Even"\n elif tlr.balance == "Right":\n tlr.right.balance = "Even"\n tlr.left.balance = "Left"\n elif tlr.balance == "Even":\n tlr.right.balance = "Even"\n tlr.left.balance = "Even"\n tlr.balance = "Even"\n return tlr\n def DoubleLeftRotation(self):\n tr = self.right\n self.right = tr.left.left\n tr.left.left = self\n trl = tr.left\n tr.left = trl.right\n trl.right = tr\n if trl.balance == "Right":\n trl.left.balance = "Left"\n trl.right.balance = "Even"\n elif trl.balance == "Left":\n trl.left.balance = "Even"\n trl.right.balance = "Right"\n elif trl.balance == "Even":\n trl.left.balance = "Even"\n trl.right.balance = "Even"\n trl.balance = "Even"\n return trl\n def SingleLeftRotation(self):\n tr = self.right\n tr.balance = "Even"\n self.balance = "Even"\n self.right = tr.left\n tr.left = self\n return tr\n def SingleRightRotation(self):\n tl = self.left\n tl.balance = "Even"\n self.balance = "Even"\n self.left = tl.right\n tl.right = self\n return tl\n def replace(self,p,v): \n if p.left == self:\n p.left = v\n else :\n p.right = v \n def insert(self,key): \n if self.key == None: \n self.key = key\n return self\n if key < self.key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n self.left.insertx(self,key)\n elif key > self.key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n self.right.insertx(self,key)\n else: # key == self.key:\n pass # do not overwrite\n def insertx(self,p,key): \n if self.key > key:\n if self.left == None:\n self.left = Avltree(key)\n else:\n if not self.left.insertx(self, key): \n return False \n if self.balance == "Right":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Left"\n return True \n elif self.balance == "Left":\n if self.left.balance == "Right":\n self.replace(p,self.DoubleRightRotation())\n elif self.left.balance == "Left":\n self.replace(p,self.SingleRightRotation())\n return False \n if self.key < key:\n if self.right == None:\n self.right = Avltree(key)\n else:\n if not self.right.insertx(self, key):\n return False \n if self.balance == "Left":\n self.balance = "Even"\n return False\n elif self.balance == "Even":\n self.balance = "Right"\n return True\n elif self.balance == "Right":\n if self.right.balance == "Left": \n self.replace(p,self.DoubleLeftRotation())\n elif self.right.balance == "Right":\n self.replace(p,self.SingleLeftRotation())\n return False\n return False \n \n def to_s(self):\n return self.key\n def left_s(self):\n if self.left == None:\n return None\n return (self.left).key\n def right_s(self):\n if self.right == None:\n return None\n return (self.right).key\n\n################################################################\n\ndef inpl(): return [int(i) for i in input().split()]\nn = int(input())\na = inpl()\nb = {a[i]: i for i in range(n)}\n\nroot = Avltree()\nass = 0\n\nfor i in range(1,n+1):\n l = root.search_lower(b[i],None)\n r = root.search_higher(b[i],None)\n if l == None:\n l = -1\n if r == None:\n r = n\n ass += (b[i]-l)*(r-b[i])*i\n root.insert(b[i])\nprint(0)', '\ndef find(x):\n if par[x] == x:\n return x\n else:\n return find(par[x])\n\n\ndef unite(x,y):\n x = find(x)\n y = find(y)\n \n if x != y:\n \n if rank[x] < rank[y]:\n par[x] = y\n size[y] += size[x]\n else:\n par[y] = x\n size[x] += size[y]\n if rank[x]==rank[y]:\n rank[x] += 1\n\n\ndef same(x,y):\n return find(x) == find(y)\n\n########################################\nn = int(input())\na = list(map(int,input().split()))\n\npar = [0]*n \nfor i in range(n):\n par[i] = i\nrank = [1]*n \nsize = [1]*n \n\nb = [0]*(n+1) \nfor i in range(n):\n b[a[i]]=i\n\nans = 0\nfor i in range(n,0,-1):\n k = b[i]\n left = 0\n right = 0\n if k-1>=0 and a[k-1]>a[k]:\n left = size[find(k-1)]\n unite(k-1,k)\n if k+1<=n-1 and a[k+1]>a[k]:\n right = size[find(k+1)]\n unite(k+1,k)\n ans += (left+1)*(right+1)*a[k]\n\nprint(ans)\n '] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s136011677', 's169909855', 's281183019', 's657735701', 's980535359', 's428452879'] | [65024.0, 45320.0, 56156.0, 56160.0, 55036.0, 30428.0] | [2107.0, 2107.0, 2106.0, 2110.0, 2106.0, 678.0] | [6366, 8054, 7342, 7341, 8207, 1182] |
p03987 | u316386814 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\nfrom collections import Counter\n\ndef main():\n N = II()\n A = LI()\n idxs = [0] * (N + 1)\n for i, a in enumerate(A, 1):\n idxs[a] = i\n def func(arr):\n if len(arr) == 0:\n return 0\n a = min(arr)\n idx = idxs[a]\n return (idx + 1) * (len(arr) - idx) * a + func(arr[:idx]) + func(arr[idx + 1:])\n ans = func(A)\n\n return ans\n\nprint(main())\n', 'import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\nfrom collections import Counter\n\ndef main():\n N = II()\n A = LI()\n idxs = [0] * N\n for i, a in enumerate(A):\n idxs[a] = i\n def func(arr):\n if len(arr) == 0:\n return 0\n a = min(arr)\n idx = idxs[a]\n return (idx + 1) * (len(arr) - idx) * a + func(arr[:idx]) + func(arr[idx + 1:])\n ans = func(A)\n\n return ans\n\nprint(main())\n', 'import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\nfrom collections import Counter\n\ndef main():\n N = II()\n A = LI()\n idxs = [0] * N\n for i, a in enumerate(A):\n idxs[a] = i\n def func(arr):\n if len(arr) == 0:\n return 0\n a = min(arr)\n idx = idx[a]\n return (idx + 1) * (len(arr) - idx) * a + func(arr[:idx]) + func(arr[idx + 1:])\n ans = func(A)\n\n return ans\n\nprint(main())\n', 'import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\nfrom collections import Counter\n\ndef main():\n N = II()\n A = LI()\n idxs = [0] * (N + 1)\n for i, a in enumerate(A):\n idxs[a] = i\n def func(arr):\n if len(arr) == 0:\n return 0\n a = min(arr)\n idx = idxs[a]\n return (idx + 1) * (len(arr) - idx) * a + func(arr[:idx]) + func(arr[idx + 1:])\n ans = func(A)\n\n return ans\n\nprint(main())\n', 'import sys\nsys.setrecursionlimit(10**7)\nINF = 10 ** 18\nMOD = 10 ** 9 + 7\ndef LI(): return [int(x) for x in sys.stdin.readline().split()]\ndef LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]\ndef LF(): return [float(x) for x in sys.stdin.readline().split()]\ndef LS(): return sys.stdin.readline().split()\ndef II(): return int(sys.stdin.readline())\ndef SI(): return input()\n\nfrom collections import Counter\n\ndef main():\n N = II()\n A = LI()\n idxs = [0] * (N + 1)\n for i, a in enumerate(A):\n idxs[a] = i\n ll = list(range(N + 1))\n rr = list(range(N + 1))\n ans = 0\n for a in range(N, 0, -1):\n idx = idxs[a]\n l, r = ll[idx], rr[idx]\n ans += (idx - l + 1) * (r - idx + 1) * a\n ll[r + 1] = l\n rr[l - 1] = r\n\n return ans\n\nprint(main())'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s126298807', 's231781893', 's608695954', 's833189331', 's324496218'] | [591604.0, 23956.0, 24084.0, 615860.0, 35064.0] | [2139.0, 95.0, 96.0, 2141.0, 277.0] | [782, 773, 772, 779, 808] |
p03987 | u340781749 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import sys\nfrom operator import itemgetter\n\nn, *aaa = map(int, sys.stdin.buffer.read().split())\naaa_with_index = list(enumerate(aaa, start=1))\naaa_with_index.sort(key=itemgetter(1), reverse=True)\nleft = list(range(n + 2))\nright = left.copy()\nans = 0\nfor i, a in aaa_with_index:\n li = left[i]\n ri = right[i]\n ans += a * (i - li + 1) * (ri - i + 1)\n left[right[i + 1]] = li\n right[left[i - 1]] = ri\n\nprint(ans)\n', 'import sys\nfrom operator import itemgetter\n\nn, *aaa = map(int, sys.stdin.buffer.read().split())\naaa_with_index = list(enumerate(aaa, start=1))\naaa_with_index.sort(key=itemgetter(1), reverse=True)\nleft = list(range(-1, n + 1))\nright = list(range(1, n + 3))\nans = 0\nfor i, a in aaa_with_index:\n li = left[i]\n ri = right[i]\n ans += a * (i - li) * (ri - i)\n left[ri] = li\n right[li] = ri\n\nprint(ans)\n'] | ['Wrong Answer', 'Accepted'] | ['s170428341', 's638136917'] | [42012.0, 49692.0] | [457.0, 475.0] | [424, 411] |
p03987 | u375616706 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['# python template for atcoder1\nimport sys\nsys.setrecursionlimit(10**9)\ninput = sys.stdin.readline\n\nN = int(input())\nA = list(map(int, input().split()))\n\n\ndef dfs(l):\n ret = 0\n if len(l) == 1:\n return l[0]\n elif len(l) == 0:\n return 0\n else:\n le = len(l)\n mi = min(l)\n min_ind = l.index(mi)\n ret += mi*(min_ind+1)*(le-min_ind)\n return ret + dfs(l[:min_ind])+dfs(l[min_ind+1:])\n\n\nans = dfs(A)\nprint(ans)\nprint(0)\n', '# python template for atcoder1\nimport sys\nsys.setrecursionlimit(10**9)\ninput = sys.stdin.readline\n\n\nclass UnionFind:\n \n\n def __init__(self, N):\n self.parent = [i for i in range(N)]\n self.size = [1 for _ in range(N)]\n\n def find(self, x):\n if self.parent[x] == x:\n return x\n else:\n return self.find(self.parent[x])\n\n def union(self, x, y):\n px = self.find(x)\n py = self.find(y)\n if px == py:\n return\n if self.size[px] < self.size[py]:\n self.parent[px] = py\n self.size[py] += self.size[px]\n else:\n self.parent[py] = px\n self.size[px] += self.size[py]\n\n def same(self, x, y):\n return self.find(x) == self.find(y)\n\n\nN = int(input())\nA = list(map(int, input().split()))\n\nUn = UnionFind(N+1)\npos = [-1]*(N+1)\nfor i, a in enumerate(A):\n pos[a] = i\n\nans = 0\nfor i in reversed(range(1, N+1)):\n ind = pos[i]\n left = 0\n right = 0\n if ind > 0 and A[ind] < A[ind-1]:\n left = Un.size[Un.find(ind-1)]\n Un.union(ind, ind-1)\n if ind+1 < N and A[ind+1] > A[ind]:\n right = Un.size[Un.find(ind+1)]\n Un.union(ind, ind+1)\n ans += (left+1)*(right+1)*A[ind]\n\nprint(ans)\n'] | ['Wrong Answer', 'Accepted'] | ['s044590805', 's002835024'] | [551544.0, 29000.0] | [2137.0, 770.0] | [472, 1291] |
p03987 | u389910364 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import itertools\nimport os\nimport sys\n\nimport numpy as np\n\nif os.getenv("LOCAL"):\n sys.stdin = open("_in.txt", "r")\n\nsys.setrecursionlimit(2147483647)\nINF = float("inf")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN = int(sys.stdin.readline())\nA = list(map(int, sys.stdin.readline().split()))\n\n\ndef gutyocu():\n ans = 0\n for i, j in itertools.combinations_with_replacement(range(N), r=2):\n ans += min(A[i: j + 1])\n return ans\n\n\nA = np.array(A)\npos = np.zeros(N + 1, dtype=int)\npos[0] = -1\npos[A] = np.arange(N + 1)\n\nans = 0\nlefts = [0] * N\nrights = [0] * N\nfor i in reversed(range(1, N + 1)):\n p = pos[i]\n if p + 1 < N and A[p + 1] > i:\n \n right = rights[p + 1]\n else:\n right = p\n if p - 1 >= 0 and A[p - 1] > i:\n \n left = lefts[p - 1]\n else:\n left = p\n lefts[right] = left\n rights[left] = right\n ans += (p - left + 1) * (right - p + 1) * i\nprint(ans)\n', 'import bisect\nimport heapq\nimport itertools\nimport math\nimport operator\nimport os\nimport re\nimport string\nimport sys\nfrom collections import Counter, deque, defaultdict\nfrom copy import deepcopy\nfrom decimal import Decimal\nfrom fractions import gcd\nfrom functools import lru_cache, reduce\nfrom operator import itemgetter, mul, add, xor\n\nimport numpy as np\n\nif os.getenv("LOCAL"):\n sys.stdin = open("_in.txt", "r")\n\nsys.setrecursionlimit(2147483647)\nINF = float("inf")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN = int(sys.stdin.readline())\nA = list(map(int, sys.stdin.readline().split()))\n\n\ndef gutyocu():\n ans = 0\n for i, j in itertools.combinations_with_replacement(range(N), r=2):\n ans += min(A[i: j + 1])\n return ans\n\n\nA = np.array(A)\npos = np.arange(N + 1)\npos[0] = -1\npos[A] = np.arange(N + 1)\n\nans = 0\nlefts = np.arange(N)\nrights = np.arange(N)\nfor i in reversed(range(1, N + 1)):\n p = pos[i]\n if p + 1 < N and A[p + 1] > i:\n \n right = rights[p + 1]\n else:\n right = p\n if p - 1 >= 0 and A[p - 1] > i:\n \n left = lefts[p - 1]\n else:\n left = p\n lefts[right] = left\n rights[left] = right\n ans += (abs(left - p) + 1) * (abs(right - p) + 1) * i\nprint(ans)\n', 'import os\nimport sys\n\nif os.getenv("LOCAL"):\n sys.stdin = open("_in.txt", "r")\n\nsys.setrecursionlimit(2147483647)\nINF = float("inf")\nIINF = 10 ** 18\nMOD = 10 ** 9 + 7\n\nN = int(sys.stdin.readline())\nA = list(map(int, sys.stdin.readline().split()))\n\npos = [0] * (N + 1)\npos[0] = -1\nfor i, a in enumerate(A):\n pos[a] = i\n\nans = 0\nlefts = [0] * N\nrights = [0] * N\nfor i in reversed(range(1, N + 1)):\n p = pos[i]\n if p + 1 < N and A[p + 1] > i:\n \n right = rights[p + 1]\n else:\n right = p\n if p - 1 >= 0 and A[p - 1] > i:\n \n left = lefts[p - 1]\n else:\n left = p\n lefts[right] = left\n rights[left] = right\n ans += (p - left + 1) * (right - p + 1) * i\nprint(ans)\n'] | ['Time Limit Exceeded', 'Time Limit Exceeded', 'Accepted'] | ['s613062811', 's844153551', 's958930599'] | [33936.0, 35120.0, 23572.0] | [2109.0, 2109.0, 361.0] | [973, 1281, 773] |
p03987 | u532966492 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['def main():\n n = int(input())\n a = list(map(int, input().split()))\n a = sorted(list(enumerate(a)), key=lambda x: -x[1])\n L = [i for i in range(n+2)] \n R = [i for i in range(n+2)] \n ans = 0\n for i, j in a: \n print(L, R)\n M = R[i+1] \n m = L[i+1] \n ans += j*(M-i)*(i+2-m) \n R[m-1] = M \n L[M+1] = m \n print(ans)\n\n\nmain()', 'def main():\n n = int(input())\n a = list(map(int, input().split()))\n a = sorted(list(enumerate(a)), key=lambda x: -x[1])\n L = [i for i in range(n+2)] \n R = [i for i in range(n+2)] \n ans = 0\n for i, j in a: \n M = R[i+1] \n m = L[i+1] \n ans += j*(M-i)*(i+2-m) \n R[m-1] = M \n L[M+1] = m \n print(ans)\n\n\nmain()'] | ['Runtime Error', 'Accepted'] | ['s082190944', 's735887753'] | [182072.0, 46840.0] | [1808.0, 452.0] | [622, 602] |
p03987 | u543954314 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['n = int(input())\na = list(map(int, input().split()))\nans = 0\nfor i in range(n):\n l,r = 1,1\n while a[i-l] > a[i] and i-l > -1:\n l += 1\n while a[i+r] > a[i] and i+r < n:\n r += 1\n ans += l*r*a[i]\nprint(ans)', 'N = int(input())\na = list(map(int, input().split()))\n\nleft = [0] * (N + 1)\nright = [0] * (N + 1)\n\n\nbuf = list()\nfor i in range(N):\n while len(buf) > 0 and a[buf[-1]] > a[i]:\n buf.pop()\n if len(buf) > 0:\n left[i] = buf[-1]\n else:\n left[i] = -1\n buf.append(i)\n\n\nbuf = list()\nfor i in reversed(range(N)):\n while len(buf) > 0 and a[buf[-1]] > a[i]:\n buf.pop()\n if len(buf) > 0:\n right[i] = buf[-1]\n else:\n right[i] = N\n buf.append(i)\n\nans = 0\nfor i in range(N):\n ans += a[i] * (i - left[i]) * (right[i] - i)\n\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s605938502', 's547435720'] | [24744.0, 30856.0] | [2104.0, 393.0] | [213, 606] |
p03987 | u562016607 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['N=int(input())\na=[int(i) for i in input().split()]\nl=[0 for i in range(N)]\nr=[0 for i in range(N)]\nl[0]=0\nk=0\nfor i in range(1,N):\n if a[k]<a[i]:\n l[i]=a[k]\n else:\n l[i]=a[i]\n k=i\nr[N-1]=N-1\nk=N-1\nfor i in range(N-1)[::-1]:\n if a[k]<a[i]:\n r[i]=a[k]\n else:\n r[i]=a[i]\n k=i\nans=0\nfor i in range(N):\n ans+=a[i]*(i-l[i]+2)*(r[i]-i)\nprint(ans)', 'N=int(input())\na=[0]+[int(i) for i in input().split()]\npar=[0 for i in range(N+1)]\nsize=[0 for i in range(N+1)]\ndef find(x):\n if (par[x]==x):\n return x\n par[x]=find(par[x])\n return par[x]\ndef unite(x,y):\n x=find(x)\n y=find(y)\n res=size[x]*size[y]\n size[x]+=size[y]\n par[y]=x\n return res\nfor i in range(N+1):\n par[i]=i\n size[i]=1\nb=[0 for i in range(N+1)]\nfor i in range(N+1):\n b[a[i]]=i\nans=0\nfor j in range(1,N+1)[::-1]:\n i=b[j]\n ans+=a[i]\n if i-1>=1 and a[i-1]>a[i]:\n ans+=unite(i-1,i)*a[i]\n if i+1<=N and a[i+1]>a[i]:\n ans += unite(i+1,i)*a[i]\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s654099031', 's111930898'] | [24744.0, 29604.0] | [285.0, 623.0] | [396, 626] |
p03987 | u620480037 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import bisect\nN=int(input())\nA=list(map(int,input().split()))\n\nA=[N+1]+A+[0]\n\nfor i in range(len(A)):\n A[i]=5-A[i]\n\nans=0\nfor i in range(1,N+1):\n R=bisect.bisect_left(A[i:],A[i])\n L=bisect.bisect_right(A[:i+1],A[i])\n ans+=L*R\nprint(ans)', 'import sys\nsys.setrecursionlimit(1000000)\n\nN=int(input())\na=list(map(int,input().split()))\n\nb=[i for i in range(1,N+1)]\n\nA=[]\nfor i in range(N):\n A.append([a[i],b[i]])\nA.sort(reverse=True)\n#print(A)\nPL=[i for i in range(N+1)]+[N+1]\nPR=[i for i in range(N+1)]+[N+1]\n\ndef findL(x):\n if x==PL[x]:\n return x\n else:\n return findL(PL[x])\n \ndef findR(x):\n if x==PR[x]:\n return x\n else:\n return findR(PR[x])\n#print(PR)\nans=0\nfor i in range(N):\n ans+=A[i][0]*(A[i][1]-findL(A[i][1]-1))*(findR(A[i][1]+1)-A[i][1])\n #print(ans,A[i][1],(A[i][1]-findL(A[i][1])+1),findR(A[i][1])-A[i][1]+1)\n #print(PR)\n PL[A[i][1]]=findL(A[i][1]-1)\n PR[A[i][1]]=findR(A[i][1]+1)\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s679125051', 's606744490'] | [25348.0, 56728.0] | [2104.0, 1120.0] | [248, 724] |
p03987 | u636387751 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['import bisect\n\n\ndef main():\n N = int(input())\n a = list(map(int, input().split()))\n\n s = [0, N+1]\n order = [0]*(N+1)\n\n for i in range(N):\n order[a[i]] = i+1\n\n ans = 0\n for i in range(1, N+1):\n bisect.insort_left(s, order[i])\n ans += i*(order[i]-s[bisect.bisect_left(s, order[i])-1]) * \\\n (s[bisect.bisect_left(s, order[i])+1]-order[i])\n print(ans)\n\n if __name__ == "__main__":\n main()\n', 'N = int(input())\na = list(map(int, input().split()))\n\norder = [0]*(N+1)\n\nfor i in range(N):\n order[a[i]] = i\n\nans = 0\ncheckR = list(range(N+1))\ncheckL = list(range(N+1))\n\nfor i in range(N, 0, -1):\n ans += i*(order[i] - checkR[order[i]] + 1)*(checkL[order[i]] - order[i]+1)\n checkR[checkL[order[i]]+1] = checkR[order[i]]\n checkL[checkR[order[i]]-1] = checkL[order[i]]\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s870068582', 's360386419'] | [3188.0, 35624.0] | [18.0, 368.0] | [451, 389] |
p03987 | u820351940 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ['a = list(map(int, reversed("1 3 2 4".split())))\n\nresult = target = tmp = a[0]\n\nfor index, i in enumerate(a[1:]):\n if target < i:\n tmp += i\n result += tmp\n else:\n target = i\n tmp = i * (index + 2)\n result += tmp\nprint(result)\n', 'n = int(input())\na = list(map(int, input().split()))\n\nindex = [-1] * (n + 1)\nfor i, v in enumerate(a):\n index[v] = i\n\narea = [[i, i] for i in range(n + 1)]\nresult = 0\nfor i in range(n, 0, -1):\n position = index[i]\n l, r = area[position]\n area[r + 1][0] = l # right\n area[l - 1][1] = r # left\n result += (position - l + 1) * (r - position + 1) * i\nprint(result)\n\n\n'] | ['Wrong Answer', 'Accepted'] | ['s657619390', 's496379892'] | [3064.0, 45784.0] | [24.0, 552.0] | [266, 381] |
p03987 | u835482198 | 2,000 | 262,144 | One day, Snuke was given a permutation of length N, a_1, a_2, ..., a_N, from his friend. Find the following: | ["#!/usr/bin/env python\n# -*- coding:utf-8 -*-\n\nN = int(input())\na = list(map(int, input().split()))\n\ndata = [float('inf')] * (2 * N - 1)\n\ndef update(i, val):\n i += N-1\n data[i] = val\n while i > 0:\n i = (i - 1) // 2\n data[i] = min(data[2*i+1], data[i*2+2])\n\nfor i in range(N):\n update(i, a[i])\n\ndef query(a, b, k, l, r):\n if l <= a and b <= r:\n return data[k]\n elif b <= l or r <= a:\n return float('inf')\n else:\n mid = (a + b) // 2\n lvalue = query(a, mid, 2 * k + 1, l, r)\n rvalue = query(mid, b, 2 * k + 2, l, r)\n return min(lvalue, rvalue)\n\nans = 0\nfor l in range(N):\n for r in range(l, N):\n ans += query(0, N, 0, l, r + 1)\nprint(ans)\n", '#!/usr/bin/env python\n\nfrom collections import defaultdict\n\nN = int(input())\na = list(map(int, input().split()))\n\ncnt = 0\nd = [0] * (N + 2)\nfor i in range(N):\n d[a[i]] = i\n\n\nl = list(range(N + 2))\nr = list(range(N + 2))\n\n# print(a)\nfor i in range(N, 0, -1):\n di = d[i]\n cnt += i * (r[di] - di + 1) * (di - l[di] + 1)\n r[l[di] - 1] = r[di]\n l[r[di] + 1] = l[di]\n # print(i)\n # print(r)\n # print(l)\n# print(r)\n# print(l)\nprint(cnt)\n'] | ['Time Limit Exceeded', 'Accepted'] | ['s211815408', 's720090966'] | [25864.0, 35140.0] | [2103.0, 352.0] | [722, 454] |
p03988 | u392319141 | 2,000 | 262,144 | Aoki loves numerical sequences and trees. One day, Takahashi gave him an integer sequence of length N, a_1, a_2, ..., a_N, which made him want to construct a tree. Aoki wants to construct a tree with N vertices numbered 1 through N, such that for each i = 1,2,...,N, the distance between vertex i and the farthest vertex from it is a_i, assuming that the length of each edge is 1. Determine whether such a tree exists. | ["from collections import Counter\n\nN = int(input())\nA = list(map(int, input().split()))\n\ndef canMake():\n if N == 2:\n return A == [1, 1]\n\n cntA = Counter(A)\n mi = min(A)\n mx = max(A)\n\n if sum([c < 2 for c in cntA.values()]) >= 2:\n return False\n if cntA[mi] >= 2:\n return False\n\n for i in range(mi, mx + 1):\n if cntA[i] == 0:\n return False\n\n return True\n\nprint('Possible' if canMake() else 'Impossible')", "from collections import Counter\n\nN = int(input())\nA = list(map(int, input().split()))\n\ndef canMake():\n if N == 2:\n return A == [1, 1]\n\n cntA = Counter(A)\n mi = min(A)\n mx = max(A)\n\n if mi < mx // 2:\n return False\n\n if mx % 2 == 0 and cntA[mi] > 1:\n return False\n if mx % 2 == 1 and cntA[mi] > 2:\n return False\n\n for i in range(mi + 1, mx + 1):\n if cntA[i] < 2:\n return False\n\n return True\n\nprint('Possible' if canMake() else 'Impossible')\n"] | ['Wrong Answer', 'Accepted'] | ['s436108532', 's459467821'] | [3316.0, 3316.0] | [21.0, 21.0] | [462, 512] |
p03988 | u532966492 | 2,000 | 262,144 | Aoki loves numerical sequences and trees. One day, Takahashi gave him an integer sequence of length N, a_1, a_2, ..., a_N, which made him want to construct a tree. Aoki wants to construct a tree with N vertices numbered 1 through N, such that for each i = 1,2,...,N, the distance between vertex i and the farthest vertex from it is a_i, assuming that the length of each edge is 1. Determine whether such a tree exists. | ['def main():\n from collections import Counter as ct\n n = int(input())\n a = list(map(int, input().split()))\n c = ct(a)\n min_a = min(a)\n max_a = max(a)\n if min_a == 1:\n if c[min_a] == 1:\n pass\n elif a == [1, 1]:\n print("Possible")\n return 0\n else:\n print("Impossible")\n return 0\n if c[min_a] == 1 and (max_a+1)//2 > min_a:\n print("Impossible")\n return 0\n if c[min_a] == 2 and (max_a+2)//2 > min_a:\n print("Impossible")\n return 0\n if c[min_a] > 2:\n print("Impossible")\n return 0\n for i in range(min_a+1, max_a+1):\n if c[i] < 2:\n print("Impossible")\n return 0\n print("Possible")', 'def main():\n from collections import Counter as ct\n n = int(input())\n a = list(map(int, input().split()))\n c = ct(a)\n min_a = min(a)\n max_a = max(a)\n if min_a == 1:\n if c[min_a] == 1:\n pass\n elif a == [1, 1]:\n print("Possible")\n return 0\n else:\n print("Impossible")\n return 0\n if c[min_a] == 1 and (max_a+1)//2 > min_a:\n print("Impossible")\n return 0\n if c[min_a] == 2 and (max_a+2)//2 > min_a:\n print("Impossible")\n return 0\n if c[min_a] > 2:\n print("Impossible")\n return 0\n for i in range(min_a+1, max_a+1):\n if c[i] < 2:\n print("Impossible")\n return 0\n print("Possible")\nmain()'] | ['Wrong Answer', 'Accepted'] | ['s806941796', 's966944364'] | [3064.0, 3316.0] | [17.0, 21.0] | [756, 763] |
p04001 | u001024152 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["s = input()\nn = len(s)\nans = 0\n\nfor i in range(2**(n-1)):\n l = list(s)\n for j in range(1, n): \n if (1<<(j-1)) & i > 0:\n l = l[:j] + ['+'] + l[j:] \n ans += eval(''.join(l))\n\nprint(ans)", "s = input()\nn = len(s)\nans = 0\n \nfor i in range(2**(n-1)):\n l = list(s)\n for j in reversed(range(1, n)): \n if (1<<(j-1)) & i > 0:\n l = l[:j] + ['+'] + l[j:] \n ans += eval(''.join(l))\n \nprint(ans)"] | ['Wrong Answer', 'Accepted'] | ['s240619746', 's504632470'] | [3060.0, 3188.0] | [28.0, 28.0] | [242, 254] |
p04001 | u016881126 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['# arc 061 Many Formulas\nimport sys\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nread = sys.stdin.buffer.read\nsys.setrecursionlimit(10 ** 7)\n\nS = read().rstrip().decode(\'utf-8\')\n\ndef F(S):\n total = 0\n for i in range(2 ** (len(S) - 1)):\n operator_list = format(i, \'b\').zfill(len(S)) \n sum_ = 0\n num = 0\n for j, operator in zip(S, operator_list):\n if operator == "0":\n num = num * 10 + int(j)\n else:\n sum_ += num\n num = int(j)\n sum_ += num\n\n total += sum_\n print(total)\n\nans = F(S)\nprint(ans)', '# arc 061 Many Formulas\nimport sys\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nread = sys.stdin.buffer.read\nsys.setrecursionlimit(10 ** 7)\n\nS = read().rstrip().decode(\'utf-8\')\n\ndef F(S):\n total = 0\n for i in range(2 ** (len(S) - 1)):\n operator_list = format(i, \'b\').zfill(len(S)) \n sum_ = 0\n num = 0\n for j, operator in zip(S, operator_list):\n if operator == "0":\n num = num * 10 + int(j)\n else:\n sum_ += num\n num = int(j)\n sum_ += num\n\n total += sum_\n\nans = F(S)\nprint(ans)', 'import sys\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nread = sys.stdin.buffer.read\nsys.setrecursionlimit(10 ** 7)\n\nS_int = int(readline())\nS_str = str(S_int)\n\nif len(S_str) == 1:\n print(S_int)\n quit()\n\npattern = []\nfmt = \'0\' + str(len(S_str)-1) + \'b\'\nfor i in range(2**(len(S_str)-1)):\n pattern.append(format(i, fmt))\n\nanswer = 0\nfor plus_flags in pattern:\n tmp = []\n tmp_str = S_str[0]\n for i, is_plus in enumerate(plus_flags, start=1):\n if is_plus == "1":\n tmp.append(int(tmp_str))\n tmp_str = ""\n tmp_str += S_str[i]\n if tmp_str:\n tmp.append(int(tmp_str))\n answer += sum(tmp)\nprint(answer)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s273748766', 's661849480', 's752858048'] | [3064.0, 3064.0, 3064.0] | [19.0, 19.0, 21.0] | [659, 642, 691] |
p04001 | u021763820 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['S = input()\nprint(int(S))', '# -*- coding: utf-8 -*-\ns = list(input())\nn = len(s)-1\ntrueans = []\nfor i in range(2**n):\n bag = []\n for j in range(n):\n bag.append(s[j])\n if (i>>j) & 1:\n bag.append("+")\n bag.append(s[-1])\n bag.append("+")\n kai = ""\n ans = []\n if "+" in bag:\n for j in bag:\n if j != "+":\n kai += j\n else:\n ans.append(int(kai))\n kai = ""\n trueans.append(sum(ans))\nprint(sum(trueans))'] | ['Wrong Answer', 'Accepted'] | ['s592373838', 's429217784'] | [2940.0, 3064.0] | [17.0, 22.0] | [25, 489] |
p04001 | u050622763 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['def abc061_c():\n s = str(input())\n\n l = []\n def saiki(i,moji):\n if i == len(s)-1:\n print(moji)\n l.append(sum(list(map(int,moji.split("+")))))\n return\n\n \n saiki(i+1,moji+"+"+s[i+1])\n \n saiki(i+1,moji+s[i+1])\n\n saiki(0,s[0])\n\n print(sum(l))\n\n\nabc061_c()\n', 'def abc061_c():\n s = str(input())\n\n l = []\n def saiki(i,moji):\n if i == len(s)-1:\n \n l.append(sum(list(map(int,moji.split("+")))))\n return\n\n \n saiki(i+1,moji+"+"+s[i+1])\n \n saiki(i+1,moji+s[i+1])\n\n saiki(0,s[0])\n\n print(sum(l))\n\n\nabc061_c()'] | ['Wrong Answer', 'Accepted'] | ['s694801559', 's974557903'] | [9064.0, 9200.0] | [31.0, 31.0] | [358, 358] |
p04001 | u057993957 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['s = list(input())\nn = len(s)-1\n\nans = 0\nfor x in list(product(["", "+"], repeat=n)):\n x = list(x)\n x.append("")\n \n strs = [i+j for i, j in zip(s, x)]\n ans += eval("".join(strs))\nprint(ans)', 'from itertools import product\ns = list(input())\nn = len(s)-1\n\nans = 0\nfor x in list(product(["", "+"], repeat=n)):\n x = list(x)\n x.append("")\n \n strs = [i+j for i, j in zip(s, x)]\n ans += eval("".join(strs))\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s013963656', 's233870707'] | [3060.0, 3064.0] | [17.0, 26.0] | [203, 233] |
p04001 | u067694718 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["s = input()\nn = len(s)\nsum = 0\nfor b in range(1 << n-1):\n t = 0\n for i in range(n-1):\n if b & (1 << i):\n sum += int(''.join(s[t:i+1]))\n t = i\nprint(sum)\n", "s = input()\nn = len(s)\nsum = 0\nfor b in range(1 << n-1):\n t = 0\n for i in range(n-1):\n if b & (1 << i):\n sum += int(''.join(s[t:i+1]))\n t = i+1\n sum += int(''.join(s[t:]))\nprint(sum)\n"] | ['Wrong Answer', 'Accepted'] | ['s046281595', 's715680556'] | [2940.0, 3064.0] | [20.0, 21.0] | [188, 221] |
p04001 | u076506345 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['import sys\n\ninput = sys.stdin.readline\n\ns = input()\nn = len(s)\n\ntotal_sum = 0\n\n\nfor i in range(2 ** (n - 1)):\n \n \n now_sum = 0\n reg = int(s[0])\n for j in range(n - 1):\n if i & 1 << j:\n now_sum += reg\n reg = 0\n reg *= 10\n reg += int(s[j + 1])\n now_sum += reg\n\n total_sum += now_sum\n\nprint(total_sum)\n', 'import sys\n\ninput = sys.stdin.readline\n\ns = input()\nn = len(s)\n\ntotal_sum = 0\n\n\nfor i in range(2 ** (n - 1)):\n \n \n now_sum = 0\n reg = int(s[0])\n for j in range(n - 1):\n if i & 1 << j:\n now_sum += reg\n reg = 0\n reg *= 10\n reg += int(s[j + 1])\n now_sum += reg\n\n total_sum += now_sum\n\nprint(total_sum)\n', 'import sys\n\n\ndef input():\n return sys.stdin.readline().strip()\n\n\ns = input()\nn = len(s)\n\ntotal_sum = 0\n\n\nfor i in range(2 ** (n - 1)):\n \n \n now_sum = 0\n reg = int(s[0])\n for j in range(n - 1):\n if i & 1 << j:\n now_sum += reg\n reg = 0\n reg *= 10\n reg += int(s[j + 1])\n now_sum += reg\n\n total_sum += now_sum\n\nprint(total_sum)\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s281925188', 's328433310', 's140528898'] | [3060.0, 3060.0, 3060.0] | [18.0, 17.0, 21.0] | [574, 574, 602] |
p04001 | u077291787 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['import sys\n\ninput = sys.stdin.readline()\n\ns = input()\nn = len(s)\n\ntotal_sum = 0\n\n\nfor i in range(2 ** (n - 1)):\n \n \n now_sum = 0\n reg = int(s[0])\n for j in range(n - 1):\n if i & 1 << j:\n now_sum += reg\n reg = 0\n reg *= 10\n reg += int(s[j + 1])\n now_sum += reg\n\n total_sum += now_sum\n\nprint(total_sum)\n', 'S = input()\nif "\\n" in S:\n print()\nelse:\n exit()', '\nfrom itertools import product\n\n\ndef main():\n S = input()\n if "\\n" in S:\n\t return\n ans = 0\n for ops in tuple(product(("", "+"), repeat=len(S) - 1)):\n ops = ops + ("",) # operators\n exp = "".join(i + j for i, j in zip(S, ops)) # expression\n ans += eval(exp)\n print(ans)\n\n\nif __name__ == "__main__":\n main()\n'] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s137182269', 's851156810', 's409150069'] | [3060.0, 2940.0, 3060.0] | [17.0, 17.0, 33.0] | [572, 50, 409] |
p04001 | u084491185 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['s = input()\nn = len(s)\n\nans = 0\n\nfor bit in range((n-1)**2):\n f = s[0]\n for i in range(n - 1):\n if (bit >> i) & 1:\n f += "+"\n f += s[i + 1]\n print(f)\n ans += sum(map(int, f.split("+")))\n\nprint(ans)', 's = input()\nn = len(s)\n\nans = 0\n\nfor bit in range(2 ** 2 ** (n - 1)):\n f = s[0]\n\n for i in range(n - 1):\n if bit & (1 << i):\n f += "+"\n f += s[i + 1]\n\n ans += sum(map(int, f.split("+")))\n\nprint(ans)', 's = input()\nn = len(s)\n\nans = 0\n\nfor bit in range(2 ** (n - 1)):\n f = s[0]\n\n for i in range(n - 1):\n if bit & (1 << i):\n f += "+"\n f += s[i + 1]\n\n ans += sum(map(int, f.split("+")))\n\nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s178994444', 's186103416', 's138896768'] | [3060.0, 3060.0, 3060.0] | [18.0, 2104.0, 21.0] | [234, 232, 227] |
p04001 | u086716588 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['\ndef main():\n s = input()\n num = 2**(len(s)-1)\n bit_len = len(bin(num))\n\n def func(ｎ):\n n = bin(n)\n n_len = len(n)\n n = "0"*( bit_len - n_len - 1 ) + n[-len(n)+2:]\n indexes = [i+1 for i, x in enumerate(ｎ) if x == "1"]\n ans = 0\n temp = 0\n for i in indexes:\n ans += int(s[temp:i])\n temp = i\n print(i, ans)\n else:\n if temp != bit_len-2:\n ans += int(s[temp:])\n print(ans)\n\n return ans\n\n ans = 0\n for i in range(num):\n ans += func(i)\n print("ans : " + str(ans))\n print(ans)\n\nmain()\n', 'S = [int(i) for i in input()]\nS.reverse()\n\nN = len(S)\nans = 0\nfor i in range(N):\n left = i\n right = N - i - 1\n score = 1\n for k in range(0, right + 1):\n if right - k > 0:\n ans += S[i] * score * (1 << left) * (1 << (right - k - 1))\n else:\n ans += S[i] * score * (1 << left)\n score *= 10\n\nprint(ans)', 'S = [int(i) for i in input()]\n\nN = len(S)\nans = 0\nfor i in range(N):\n left = i\n right = N - i - 1\n score = 1\n for k in range(0, right + 1):\n if right - k > 0:\n ans += S[i] * score * (1 << left) * (1 << (right - k - 1))\n else:\n ans += S[i] * score * (1 << left)\n score *= 10\n\nprint(ans)'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s275270541', 's668773930', 's735048565'] | [3776.0, 3064.0, 3064.0] | [27.0, 17.0, 17.0] | [653, 352, 340] |
p04001 | u095756391 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['from itertools import product\nS = input()\nans = 0\n\n\n\nfor s in product(["", "+"], repeat=len(S) - 1):\n s = list(s)\n print(s)\n s.append("")\n ans += eval("".join(a+b for a,b in zip(S,s)))\n print(ans)\n \nprint(ans)\n', 'from itertools import product\nS = input()\nans = 0\n\n\nfor s in product(["", "+"], repeat=len(S) - 1):\n s = list(s)\n s.append("")\n ans += eval("".join(a+b for a,b in zip(S,s)))\n \nprint(ans)\n'] | ['Wrong Answer', 'Accepted'] | ['s655633578', 's676455753'] | [3060.0, 3060.0] | [29.0, 26.0] | [315, 215] |
p04001 | u101350975 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i = n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' s[i-1])\n\nprint(dfs(0, S[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i = n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' s[i-1])\n\nprint(def(0, S[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i-1])\nprint(dfs(0, S[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i = n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + s[i-1])\nprint(dfs(0, S[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i = n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' s[i-1])\n\nprint(def(0, s[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i = n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' s[i-1])\nprint(dfs(0, S[0]))\n", "from sys import stdin\nS = stdin.readline().rstrip()\nn = len(S)\ndef dfs(i, f):\n if i == n-1:\n return sum(list(map(int, f.split('+'))))\n return dfs(i+1, f + S[i + 1]) + dfs(i + 1, f + '+' + S[i+1])\nprint(dfs(0, S[0]))\n"] | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s030320851', 's476094493', 's592746079', 's653720314', 's671611464', 's681538750', 's294522233'] | [2940.0, 2940.0, 3060.0, 2940.0, 2940.0, 2940.0, 3060.0] | [17.0, 17.0, 19.0, 17.0, 18.0, 17.0, 19.0] | [264, 264, 229, 228, 264, 226, 229] |
p04001 | u102461423 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['import sys\ninput = sys.stdin.readline\nfrom scipy.sparse import csr_matrix\nfrom scipy.sparse.csgraph import dijkstra\n\n\n\nN,M = map(int,input().split())\nPQC = [[int(x) for x in input().split()] for _ in range(M)]\n\nU = 10 ** 6\n\nV = set(range(1,N+1))\nV |= set(p + c * U for p,q,c in PQC)\nV |= set(q + c * U for p,q,c in PQC)\nV = tuple(V)\nv_to_i = {v:i for i,v in enumerate(V)}\n\n\nrows, cols = [],[]\nrows += [i for i,pc in enumerate(V) if pc > U]\ncols += [v_to_i[pc % U] for i,pc in enumerate(V) if pc > U]\nwt = [1] * len(rows)\nrows += [v_to_i[p + c * U] for p,q,c in PQC]\ncols += [v_to_i[q + c * U] for p,q,c in PQC]\nwt += [0] * M\n\ngraph = csr_matrix((wt, (rows, cols)), (len(V), len(V)))\n\nstart = v_to_i[1]\ngoal = v_to_i[N]\n', "import sys\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\n\nS = read().rstrip().decode('utf-8')\n\ndef F(S):\n yield int(S)\n for i in range(len(S)-1):\n left = S[:i+1]\n right = S[i+1:]\n x = int(left)\n for y in F(right):\n yield x + y\n\nanswer = sum(F(S))\nprint(answer)"] | ['Runtime Error', 'Accepted'] | ['s301729557', 's625718080'] | [16976.0, 3060.0] | [238.0, 18.0] | [922, 364] |
p04001 | u103902792 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["s = input()\nn = len(s)\nans = 0\n\nfor i in range(2**(n-1)):\n form = s\n bit = []\n for _ in range(n-1):\n bit.append(i%2)\n i = i//2\n \n for j in range(n):\n if bit[j]:\n form = form[:n-j] + '+' + form[n-j:]\n \n ans += form.eval()\nprint(ans)", 's = input()\nn = len(s)\ncand = []\n\ndef func(ac,yet,sum):\n next = int(yet[0])\n \n \n if len(yet) ==1:\n cand.append(sum+ ac+ next)\n cand.append(sum+ ac*10+ next)\n else:\n func(next, yet[1:],ac+sum)\n func(ac*10+next, yet[1:],sum)\n\nfunc(0,s,0)\nprint(sum(cand)//2)'] | ['Runtime Error', 'Accepted'] | ['s311713800', 's950361221'] | [3060.0, 3064.0] | [17.0, 18.0] | [255, 272] |
p04001 | u112315075 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['import sys\n\nS = list(map(int, sys.stdin.readline()))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n pattern = i\n while cursor > 0:\n cursor -= 1 \n if pattern % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n pattern >>= 1\n ans += sum_\nprint(ans)\n', 'import sys\n\nS = list(map(int, list(sys.stdin.readline())))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n while cursor > 0:\n cursor -= 1 \n if i % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n i >>= 1\n ans += sum_\n \nprint(ans)\n ', 'import sys\n\nS = list(map(int, sys.stdin.readline()))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n pattern = i\n while cursor > 0:\n cursor -= 1 \n if pattern % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n pattern = pattern // 2\n ans += sum_\nprint(ans)\n', 'import sys\n\nS = list(map(int, sys.stdin.readline()))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n while cursor > 0:\n cursor -= 1 \n if i % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n i >>= 1\n ans += sum_\n \nprint(ans)\n ', 'import sys\n\nS = list(map(int, sys.stdin.readline()))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n pattern = i\n while cursor > 0:\n cursor -= 1 \n if pattern % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n pattern //= 2\n ans += sum_\nprint(ans)\n', 'import sys\n\nS = list(map(int, sys.stdin.readline().strip()))\nlen_S = len(S)\nans = 0\nfor i in range(2 ** (len_S - 1)):\n sum_ = S[len_S - 1]\n cursor = len_S - 1\n power = 0\n while cursor > 0:\n cursor -= 1 \n if i % 2 == 1:\n power += 1\n else:\n power = 0\n sum_ += S[cursor] * (10 ** power)\n i >>= 1\n ans += sum_\nprint(ans)\n'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s029587544', 's043977446', 's441520648', 's544840277', 's686970673', 's182790812'] | [3060.0, 3060.0, 3064.0, 3060.0, 3060.0, 3060.0] | [18.0, 17.0, 17.0, 17.0, 18.0, 20.0] | [365, 356, 374, 350, 365, 347] |
p04001 | u122132511 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['S = input()\nn = len(S)\n\nans = 0\n\nfor bit in range(1 << (n - 1)):\n partial_sum = S[0]\n print(bit)\n for i in range(n-1):\n if bit & (1 << i):\n partial_sum += "+"\n partial_sum += S[i+1]\n ans += sum(map(int, partial_sum.split("+")))\n\nprint(ans)\n', 'S = input()\nn = len(S)\n\nans = 0\n\nfor bit in range(1 << n):\n partial_sum = S[0]\n for i in range(n-1):\n if bit & 1 << i:\n partial_sum += "+"\n partial_sum += S[i+1]\n ans += sum(map(int, partial_sum.split("+")))\n\nprint(ans)\n', 'S = input()\nn = len(S)\n\nans = 0\n\nfor bit in range(1 << (n - 1)):\n partial_sum = S[0]\n for i in range(n-1):\n if bit & (1 << i):\n partial_sum += "+"\n partial_sum += S[i+1]\n ans += sum(map(int, partial_sum.split("+")))\n\nprint(ans)\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s121665697', 's697219133', 's980472679'] | [8984.0, 9100.0, 9068.0] | [28.0, 34.0, 33.0] | [277, 254, 262] |
p04001 | u123745130 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['# n=int(input())\n# lst=[int(input()) for _ in range(n)]\n# ans1=sum(lst)\n# max1=max(lst)\n# print(ans1)\n# print(0 if max1<=ans1-max1 else max1-(ans1-max1))\ns=input()\nn=len(s)\nl=n-1\nlst_1=[]\nfor i in range(1<<l):\n lst=[]\n for j in range(l):\n if ((i>>j)&1):\n lst.append("+")\n else:lst.append("_")\n lst_1.append(lst)\n# print(lst_1)\n# print(len(lst_1))\nans=0\nfor i in range(1<<l):\n temp=s[0]\n for j in range(l):\n\n if lst_1[i][j]=="+":\n temp+="+"\n temp += s[j]\n # print(temp)\n ans+=sum(map(int,temp.split("+")))\nprint(ans)', '# n=int(input())\n# lst=[int(input()) for _ in range(n)]\n# ans1=sum(lst)\n# max1=max(lst)\n# print(ans1)\n# print(0 if max1<=ans1-max1 else max1-(ans1-max1))\ns=input()\nn=len(s)\nl=n-1\nlst_1=[]\nfor i in range(1<<l):\n lst=[]\n for j in range(l):\n if ((i>>j)&1):\n lst.append("+")\n else:lst.append("_")\n lst_1.append(lst)\n\nans=0\nfor i in range(1<<l):\n temp=s[0]\n for j in range(l):\n\n if lst_1[i][j]=="+":\n temp+="+"\n temp += s[j+1]\n ans+=sum(map(int,temp.split("+")))\nprint(ans)'] | ['Wrong Answer', 'Accepted'] | ['s934948043', 's817621646'] | [9168.0, 9104.0] | [31.0, 35.0] | [586, 536] |
p04001 | u135847648 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['S = input()\n \ncnt = len(S) - 1 \n \nans = 0\n \nfor i in range(2 ** cnt):\n sign = [""] * cnt\n for j in range(cnt):\n if ((i>>j)&1):\n sign[j] = "+"\n \n formula = "" \n for k in range(cnt):\n formula += S[k] + sign[k]\n print(sign)\n formula += S[cnt]\n print(formula,i) \n ans += eval(formula)\nprint(ans)', 'S = input()\nprint(S[0],S[1]) \ncnt = len(S) - 1 \n \nans = 0\n \nfor i in range(2 ** cnt):\n sign = [""] * cnt\n for j in range(cnt):\n if ((i>>j)&1):\n sign[j] = "+"\n \n formula = "" \n for k in range(cnt):\n formula += S[k] + sign[k]\n print(sign)\n formula += S[cnt]\n print(formula,i) \n ans += eval(formula)\nprint(ans)', 'S = input()\n \ncnt = len(S) - 1 \n \nans = 0\n \nfor i in range(2 ** cnt):\n sign = [""] * cnt\n for j in range(cnt):\n if ((i>>j)&1):\n sign[j] = "+"\n \n formula = "" \n for k in range(cnt):\n formula += S[k] + sign[k]\n formula += S[cnt] \n ans += eval(formula)\nprint(ans)'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s966250996', 's968869675', 's758339629'] | [3188.0, 3316.0, 3064.0] | [37.0, 38.0, 27.0] | [353, 369, 314] |
p04001 | u143492911 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['s=input()\nn=len(s)\nans=0\nfor i in range(1<<n-1):\n num=s[0]\n for j in range(n-1):\n if i&(1<<j):\n num+="+"+s[j+1]\n else:\n num+=s[j+1]\n ans+=eval(ins)\nprint(ans)\n', 's=input()\nn=len(s)\nans=0\nfor i in range(1<<n-1):\n num=s[0]\n for j in range(n-1):\n if i&(1<<j):\n num+="+"+s[j+1]\n else:\n num+=s[j+1]\n ans+=eval(num)\nprint(ans)'] | ['Runtime Error', 'Accepted'] | ['s207233201', 's482916260'] | [2940.0, 3060.0] | [17.0, 26.0] | [314, 313] |
p04001 | u148753842 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['S = input()\nN = len(S)\n\n# create ptn\nptn = []\nfor bit in range(2**(N-1)):\n tmp = [False]*(N-1)\n for i in range(N-1):\n if ((bit>>i) & 1):\n tmp[i] = True\n ptn.append(tmp)\n\n# calc sum\ntot = []\nfor p in ptn:\n a = []\n for i, s in enumerate(S):\n if i==0:\n now = int(s)\n continue\n if p[i-1]==False:\n now *= 10\n now += int(s)\n else:\n a.append(now)\n now = int(s)\n a.append(now)\n tot.append(sum(a))\nsum(tot)', 'S = input()\nN = len(S)\n\n# create ptn\nptn = []\nfor bit in range(2**(N-1)):\n tmp = [False]*(N-1)\n for i in range(N-1):\n if ((bit>>i) & 1):\n tmp[i] = True\n ptn.append(tmp)\n\n# calc sum\ntot = []\nfor p in ptn:\n a = []\n for i, s in enumerate(S):\n if i==0:\n now = int(s)\n continue\n if p[i-1]==False:\n now *= 10\n now += int(s)\n else:\n a.append(now)\n now = int(s)\n a.append(now)\n tot.append(sum(a))\nprint(sum(tot))'] | ['Wrong Answer', 'Accepted'] | ['s456268283', 's630331211'] | [3064.0, 3064.0] | [21.0, 21.0] | [523, 530] |
p04001 | u164727245 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['# coding: utf-8\n\n\ndef solve(*args: str) -> str:\n S, = args\n n_sep = len(S)-1\n b_max = 2**n_sep\n print(S)\n\n ret = 0\n for b in range(b_max):\n p = 0\n for i in range(n_sep):\n if b >> i & 1:\n ret += int(S[p:i+1])\n p = i+1\n ret += int(S[p:])\n\n return str(ret)\n\n\nif __name__ == "__main__":\n print(solve(*(open(0).read().splitlines())))\n', '# coding: utf-8\n\n\ndef solve(*args: str) -> str:\n S, = args\n n_sep = len(S)-1\n b_max = 2**n_sep\n\n ret = 0\n for b in range(b_max):\n p = 0\n for i in range(n_sep):\n if b >> i & 1:\n ret += int(S[p:i+1])\n p = i+1\n ret += int(S[p:])\n\n return str(ret)\n\n\nif __name__ == "__main__":\n print(solve(*(open(0).read().splitlines())))\n'] | ['Wrong Answer', 'Accepted'] | ['s987315711', 's449344295'] | [3060.0, 3060.0] | [19.0, 18.0] | [415, 402] |
p04001 | u168333670 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ['S = input()\n\ndef func(num, code):\n total = 0\n start = 0\n length = len(num)\n\n for i in range(1, length):\n if code & 1 == 1: \n total = total + int(num[start:i])\n start = i\n code = code >> 1\n\n total = total + int(num[start:i + 1])\n\n return total\n\ntotal_of_all = 0\n\nfor i in range(2 ** (len(S) - 1)):\n print(func(S, i))\n total_of_all = total_of_all + func(S, i)\n\nprint(total_of_all)', 'S = input()\n\ndef func(num, code):\n total = 0\n start = 0\n length = len(num)\n\n for i in range(1, length):\n if code & 1 == 1: \n total = total + int(num[start:i])\n start = i\n code = code >> 1\n\n total = total + int(num[start:length])\n\n return total\n\ntotal_of_all = 0\n\nfor i in range(2 ** (len(S) - 1)):\n total_of_all = total_of_all + func(S, i)\n\nprint(total_of_all)'] | ['Runtime Error', 'Accepted'] | ['s737262001', 's338169712'] | [3064.0, 3064.0] | [21.0, 19.0] | [481, 460] |
p04001 | u168573507 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["s = input()\nn = len(s) -1\nans = 0\nprint(s)\nfor i in range(2**n):\n e = s[0]\n for j in range(n):\n if i >> j & 1:\n e +='+'\n e += s[j+1]\n ans += eval(e)\nprint(ans)", "s = input()\nn = len(s) -1\nans = 0\nfor i in range(2**n):\n e = s[0]\n for j in range(n):\n if i >> j & 1:\n e +='+'\n e += s[j+1]\n ans += eval(e)\nprint(ans)\n"] | ['Wrong Answer', 'Accepted'] | ['s311030961', 's202221583'] | [9060.0, 9104.0] | [29.0, 34.0] | [173, 165] |
p04001 | u169678167 | 2,000 | 262,144 | You are given a string S consisting of digits between `1` and `9`, inclusive. You can insert the letter `+` into some of the positions (possibly none) between two letters in this string. Here, `+` must not occur consecutively after insertion. All strings that can be obtained in this way can be evaluated as formulas. Evaluate all possible formulas, and print the sum of the results. | ["s = input()\nk = len(s)\n\nans = 0\n\nfor bit in range(1 << k-1):\n f = s[0]\n \n for i in range(k-1):\n \n if bit & (1 << i):\n f += '+'\n f += f[i + 1]\n ans += sum(list(map(int, f.split('+'))))\n\nprint(ans)", 's = input()\nk = len(s)\n\n\n# """\n\n\n\n# """\n\n# return sum(list(map(int, f.split(\'+\'))))\n\n\n\n\n# print(dfs(0, s[0]))\n\n\n\nans = 0\n\nfor bit in range(1 << k-1):\n f = s[0]\n \n for i in range(k-1):\n \n if bit & (1 << i):\n f += \'+\'\n f += f[i + 1]\n ans += sum(list(map(int, f.split(\'+\'))))\n\nprint(ans)', 's = input()\nk = len(s)\n\n\n# """\n\n\n\n# """\n\n# return sum(list(map(int, f.split(\'+\'))))\n\n\n\n\n# print(dfs(0, s[0]))\n\n\n\nans = 0\n\nfor bit in range(1 << (k-1)):\n f = s[0]\n \n for i in range(k-1):\n \n if bit & (1 << i):\n f += \'+\'\n f += f[i + 1]\n ans += sum(list(map(int, f.split(\'+\'))))\n\nprint(ans)', '\n\ns = input()\nk = len(s)\n\n\n# """\n\n\n\n# """\n\n# return sum(list(map(int, f.split(\'+\'))))\n\n\n\n\n# print(dfs(0, s[0]))\n\n\n\nans = 0\n\nfor bit in range(1 << (k-1)):\n f = s[0]\n \n for i in range(k-1):\n \n if bit & (1 << i):\n f += \'+\'\n f += s[i + 1]\n ans += sum(list(map(int, f.split(\'+\'))))\n\nprint(ans)'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s429378011', 's793285241', 's988022229', 's000033997'] | [3060.0, 3064.0, 3060.0, 3064.0] | [17.0, 17.0, 17.0, 20.0] | [364, 737, 739, 792] |
Subsets and Splits