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 |
|---|---|---|---|---|---|---|---|---|---|---|
p03136 | u217303170 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n=int(input())\na=[int(i) for i in input().split()]\nb=sorted(a)\nx=sum(b[-1:])\ny=sum(b[:-1])\nif y<x:\n\tprint('Yes')\nelse:\n\tprint('No')", "n=int(input())\na=[int(i) for i in input().split()]\nb=sorted(a)\nx=sum(b[-1:])\ny=sum(b[:-1])\nif y>x:\n\tprint('Yes')\nelse:\n\tprint('No')"] | ['Wrong Answer', 'Accepted'] | ['s790535887', 's456691630'] | [3060.0, 3060.0] | [17.0, 17.0] | [131, 131] |
p03136 | u221766194 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = list(map(int,input().split()))\nl.sort()\nif sum(l[:n-2]) > l[n-1]:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = list(map(int,input().split()))\nl.sort()\nif sum(l[:n-1]) > l[n-1]:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s456340358', 's033977429'] | [9060.0, 9112.0] | [30.0, 31.0] | [125, 125] |
p03136 | u227082700 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n,ans,l=int(input()),"Yes",list(map(int,input()))\nfor i in l:\n if sum(l)<i*2:ans="No"\nprint(ans)', "n=int(input())\nl=list(map(int,input().split()))\nl.sort()\nif sum(l[:-1])>l[-1]:print('Yes')\nelse:print('No')"] | ['Runtime Error', 'Accepted'] | ['s071759357', 's624138348'] | [2940.0, 3064.0] | [17.0, 18.0] | [97, 107] |
p03136 | u227585789 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nl = list(map(int,input().split()))\nflg = 0\nfor i in range(0, n):\n if l[i] < sum(l)-l[i]:\n pass\n else:\n flg = 1\nif flg == 1:\n print('NO')\nelse:\n print('YES')", "n = int(input())\nl = list(map(int,input().split()))\nflg = 0\nfor i in range(0, n):\n if l[i] < sum(l)-l[i]:\n pass\n else:\n flg = 1\nif flg == 1:\n print('No')\nelse:\n print('Yes')"] | ['Wrong Answer', 'Accepted'] | ['s886190456', 's945597616'] | [9168.0, 9208.0] | [26.0, 27.0] | [199, 199] |
p03136 | u229621546 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int,input().split()))\nL.sort()\nprint("NYoe s"[1 if (sum(L) - L[-1] > L[-1]) else 0])', 'N = int(input())\nL = list(map(int,input().split()))\nL.sort()\nprint("NYoe s"[1 if (sum(L) - L[-1] > L[-1]) else 0::2])'] | ['Wrong Answer', 'Accepted'] | ['s087612522', 's894699653'] | [2940.0, 2940.0] | [17.0, 17.0] | [114, 117] |
p03136 | u229660384 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int, input().split()))\nL.sort()\n\nif sum(L) < L[N-1]*2:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = list(map(int, input().split()))\nL.sort()\n\nif sum(L) > L[N-1]*2:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s605824379', 's486754186'] | [3064.0, 2940.0] | [18.0, 17.0] | [123, 123] |
p03136 | u235376569 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['a=int(input())\nb=input().rstrip().split()\nprint(b)', 'a=int(input())\nb=input().rstrip().split()\nl=[]\nfor i in range(a):\n l.append(int(b[i]))\nl.sort()\nmax = l[a-1]\nSUM=sum(l[:a-1])\n\nif (SUM > max):\n print("Yes")\nelse:\n print("No")\n '] | ['Wrong Answer', 'Accepted'] | ['s895562871', 's137290498'] | [2940.0, 3060.0] | [17.0, 17.0] | [50, 181] |
p03136 | u239316561 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = input().split()\nmax = 0\ntotal = 0\nfor i in range(N-1):\n if max < int(L[i]):\n max = int(L[i])\n else:\n pass\nfor i in range(N-1):\n total += int(L[i])\ntotal = total - max\n\nif max < total:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = input().split()\nmax = 0\ntotal = 0\nfor i in range(N):\n if max < int(L[i]):\n max = int(L[i])\n else:\n pass\nfor i in range(N):\n total += int(L[i])\ntotal = total - max\n\nif max < total:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s206597188', 's548749455'] | [3064.0, 3064.0] | [18.0, 18.0] | [266, 262] |
p03136 | u243572357 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["input()\nlst = map(int, input().split())\nprint('Yes' if max(lst) < sum(lst) - max(lst) else 'No')", "input()\na = sorted(list(map(int, input().split())))\nprint('Yes' if a[-1] < sum(a[:-1]) else 'No')"] | ['Runtime Error', 'Accepted'] | ['s110257755', 's206375764'] | [3060.0, 2940.0] | [20.0, 17.0] | [96, 97] |
p03136 | u243833031 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["input_angle = int(input())\ninput_length = input()\n\n_length = input_length.split(' ')\nlength = [int(l) for l in _length]\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-1):\n sum += int(length[i])\n \nif int(length[-1]) < sum:\n print('Yes')\nelse:", "input_angle = int(input())\ninput_length = input()\n\n_length = input_length.split(' ')\nlength = [int(l) for l in _length]\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-2):\n sum += int(length[i])\n \nif int(length[-1]) < sum:\n print('Yes')\nelse:\n print('No')", "input_angle = int(input())\ninput_length = int(input())\n\nlength = input_length.split(' ')\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-1):\n sum += length[i]\n \nif sum > length[-1]:\n print('Yes')\nelse:\n print('No')", "input_angle = int(input())\ninput_length = input()\n\n_length = input_length.split(' ')\nlength = [int(l) for l in _length]\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-1):\n sum += int(length[i])\n \nif int(length[-1]) < sum:\n print('Yes')\nelse:", "input_angle = int(input())\ninput_length = input()\n\n_length = input_length.split(' ')\nlength = [int(l) for l in _length]\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-2):\n sum += int(length[i])\n \nif int(length[-1]) < sum:\n print('Yes')\nelse:", "input_angle = int(input())\ninput_length = input()\n\n_length = input_length.split(' ')\nlength = [int(l) for l in _length]\nlength.sort()\nsum = 0\n\nfor i in range(input_angle-1):\n sum += int(length[i])\n \nif int(length[-1]) < sum:\n print('Yes')\nelse:\n print('No')"] | ['Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s089195508', 's240781176', 's433632044', 's461166604', 's780443027', 's512627684'] | [2940.0, 3060.0, 3060.0, 2940.0, 2940.0, 3064.0] | [17.0, 17.0, 17.0, 17.0, 17.0, 17.0] | [247, 261, 220, 247, 247, 261] |
p03136 | u244836567 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['a=input()\nb=list(map(int,input().split()))\nb.sort()\nif sum(b)-max(b)-max(b)<=0:\n print("Yes")\nelse:\n print("No")', 'a=input()\nb=list(map(int,input().split()))\nb.sort()\nif sum(b)-max(b)-max(b)<0:\n print("Yes")\nelse:\n print("No")', 'a=input()\nb=list(map(int,input().split()))\nb.sort()\nif sum(b)-max(b)-max(b)>0:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s088632285', 's957981875', 's143605900'] | [8988.0, 9012.0, 9152.0] | [28.0, 28.0, 29.0] | [114, 113, 113] |
p03136 | u246639932 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = [int(input()) for i in range(N)]\nprint("Yes" if max(L) < sum(L)-max(L) else "No")', 'N = int(input())\nL = list(map(int, input().split()))\nprint("Yes" if max(L) < sum(L)-max(L) else "No")'] | ['Runtime Error', 'Accepted'] | ['s222086430', 's595900365'] | [2940.0, 2940.0] | [17.0, 18.0] | [102, 101] |
p03136 | u247211039 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = map(int, input().split())\nx = sorted(L)\nLmax = max(L)\ny = x[0:-1]\nz = 0\nfor i in range(N-1):\n z = z + y[i]\nprint("Yes" if Lmax < z else "No")', 'N = input()\nL = map(int, input().split())\nx = sorted(L)\nLmax = max(L)\ny = x[0:-1]\nysum = sum(y)\nprint("Yes" if Lmax < ysum else "No")\n', 'N = int(input())\nL = map(int, input().split())\nx = sorted(L)\nLmax = max(L)\ny = x[0:-1]\nysum = sum(y)\nprint("Yes" if Lmax < ysum else "No")', 'N = int(input())\nL = list(map(int, input().split()))\nx = sorted(L)\nLmax = max(L)\ny = x[0:-1]\nysum = sum(y)\nprint("Yes" if Lmax < ysum else "No")\n'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s181550664', 's642487988', 's880495755', 's116820234'] | [3060.0, 3064.0, 3060.0, 2940.0] | [18.0, 18.0, 18.0, 17.0] | [165, 134, 138, 145] |
p03136 | u248670337 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = map(int, input().split())\nif max(L) * 2 < Sum(L):\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = map(int, input().split())\nif max(L) * 2 < sum(L):\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = list(map(int, input().split()))\nif max(L) * 2 < sum(L):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s744336633', 's947151725', 's652597644'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [105, 105, 111] |
p03136 | u250102437 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['from sys import stdin\n\n\n############################################\n#from sys import stdin\nimport numpy as np\n\n# read data for n sequences.\nn = int(stdin.readline())\ndata = np.zeros(n)\nd = stdin.readline().split()\nfor i,x in enumerate(d):\n data[i] = int(x)\n\nmax = np.max(data)\nif max>= np.sum(data)-max:\n print("Yes")\nelse:\n print("No")', '# -*- coding: utf-8 -*-\n\n\nfrom sys import stdin\n\n############################################\n#from sys import stdin\nimport numpy as np\n\n# read data for n sequences.\nn = int(stdin.readline())\ndata = np.zeros(n)\nd = stdin.readline().split()\nfor i,x in enumerate(d):\n data[i] = int(x)\n\nmax = np.max(data)\nif max >= (np.sum(data)-max):\n print("No")\nelse:\n print("Yes")'] | ['Wrong Answer', 'Accepted'] | ['s590172949', 's003942122'] | [12508.0, 14428.0] | [154.0, 154.0] | [346, 374] |
p03136 | u251123951 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nnumber_list = []\nfor i in map(int, input().split()):\n number_list += [i]\n\nfor i in range(N-1):\n for j in range(N):\n if i < j:\n if number_list[i] > number_list[j]:\n a = number_list[i]\n number_list[i] = number_list[j]\n number_list[j] = a\n\nsum = 0\nfor i in range(N-1):\n sum+=number_list[i]\n\nif sum > number_list[N]:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nnumber_list = []\nfor i in map(int, input().split()):\n number_list += [i]\n\nfor i in range(N-1):\n for j in range(N):\n if i < j:\n if number_list[i] > number_list[j]:\n a = number_list[i]\n number_list[i] = number_list[j]\n number_list[j] = a\n\nsum = 0\nfor i in range(N-1):\n sum+=number_list[i]\n\nif sum > number_list[N-1]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s622276051', 's653351328'] | [3064.0, 3064.0] | [17.0, 17.0] | [440, 442] |
p03136 | u252828980 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nli = [int(x) for x in input().split()]\nli.sort()\nprint(li)\nif sum(li[:-1]) > li[-1]:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nli = [int(x) for x in input().split()]\nli.sort()\nif sum(li[:-1]) < li[-1]:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nli = [int(x) for x in input().split()]\nli.sort()\n\nif sum(li[:-1]) > li[-1]:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s083418779', 's657603593', 's919964842'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [136, 126, 127] |
p03136 | u253758515 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = input()\nlst = input().split(" ")\nlst2 = []\nfor i in lst:\n int_i = int(i)\n #print(int_i)\n lst2.append(int_i)\n#print(lst2)\nmax = max(lst2)\nsum = sum(lst2)\nif sum - max > max:\n print("YES")\nelse:\n print("NO")\n#input()', 'N = input()\nlst = input().split(" ")\nlist(map(int, lst))\nmax = max(lst)\nsum = sum(lst)\nif sum - max < max:\n print("YES")\nelse:\n print("NO")\n', 'N = input()\nlst = input().split(" ")\nmax = max(lst)\nsum = sum(lst)\nif sum - max < max:\n print("YES")\nelse:\n print("NO")', 'N = input()\nlst = input().split(" ")\nlst2 = []\nfor i in lst:\n int_i = int(i)\n #print(int_i)\n lst2.append(int_i)\n#print(lst2)\nmax = max(lst2)\nsum = sum(lst2)\nif sum - max < max:\n print("YES")\nelse:\n print("NO")\n#input()', 'N = input()\nlst = input().split(" ")\nlst2 = []\nfor i in lst:\n int_i = int(i)\n print(int_i)\n lst2.append(int_i)\nprint(lst2)\nmax = max(lst2)\nsum = sum(lst2)\nif sum - max < max:\n print("YES")\nelse:\n print("NO")\n#input()', 'N = input()\nlst = input().split(" ")\nlst2 = []\nfor i in lst:\n int_i = int(i)\n print(int_i)\n lst2.append(int_i)\nmax = max(lst2)\nsum = sum(lst2)\nif sum - max < max:\n print("YES")\nelse:\n print("NO")\n#input()', 'N = input()\nlst = input().split(" ")\nlst2 = []\nfor i in lst:\n int_i = int(i)\n #print(int_i)\n lst2.append(int_i)\n#print(lst2)\nmax = max(lst2)\n#print(max)\nsum = sum(lst2)\n#print(sum)\nif sum - max > max:\n print("Yes")\nelse:\n print("No")\n#input()'] | ['Wrong Answer', 'Runtime Error', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s160989035', 's246347309', 's497578136', 's824699274', 's892437831', 's896588470', 's410279095'] | [2940.0, 2940.0, 2940.0, 2940.0, 3060.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0, 18.0, 17.0, 17.0, 17.0] | [234, 147, 122, 234, 232, 220, 258] |
p03136 | u256464928 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nL = map(int,input().split())\nprint("Yes" if max(L)<sum(L)-max(L) else "No")', 'n = int(input())\nL = list(map(int,input().split()))\nprint("Yes" if max(L)<sum(L)-max(L) else "No")\n'] | ['Runtime Error', 'Accepted'] | ['s964050394', 's793027322'] | [2940.0, 2940.0] | [17.0, 20.0] | [92, 99] |
p03136 | u256833330 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n=int(input())\nl=map(int,input().split())\nprint('Yes' if max(l)*2< sum(l) else 'No')\n", 'input()\nL=list(map(int,input().split()))\nprint("Yes" if sum(L)>2*max(L) else "No")'] | ['Wrong Answer', 'Accepted'] | ['s499419269', 's108247370'] | [2940.0, 2940.0] | [18.0, 17.0] | [85, 82] |
p03136 | u257162238 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['def read():\n N = int(input().strip())\n L = map(int, input().strip().split())\n return N, L\n\n\ndef solve(N, L):\n L = sorted(L)\n return "Yes" if L[-1] < sum(L[:-1]) else "No"\n\n\nif __name__ == \'__main__\':\n inputs = read()\n print("%f" % solve(*inputs))\n', 'def read():\n N = int(input().strip())\n L = map(int, input().strip().split())\n return N, L\n\n\ndef solve(N, L):\n L = sorted(L)\n return "Yes" if L[-1] < sum(L[:-1]) else "No"\n\n\nif __name__ == \'__main__\':\n inputs = read()\n print("%s" % solve(*inputs))\n'] | ['Runtime Error', 'Accepted'] | ['s311210486', 's603863874'] | [2940.0, 2940.0] | [17.0, 17.0] | [268, 268] |
p03136 | u266569040 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = input()\nEdgeLength=input()\nedgeLength=[int(i) for i in EdgeLength]\nN = int(n)\n\nsorted(edgeLength)\n\nsumL = 0\nsumLength = [sumL += edgeLength[i] for i in range(N-1)]\n\nif edgeLength[N] < sumL:\n print("Yes")\nelse:\n print("No")', 'EdgeLength=input()\nedgeLength=[int(i) for i in EdgeLength]\n\nsorted.edgeLength()\n\nsumL = 0\nsumLength = [sumL += edgeLength[i] for i in range(1,len(edgeLength))]\n\nif edgeLength[0] < sumL:\n print("Yes")\nelse:\n print("No")\n', 'n = input()\nEdgeLength=input().split()\n#print(EdgeLength)\nN = int(n)\nEdgeLength = [int(i) for i in EdgeLength]\n\n#list(map(int, EdgeLength))\n\nEdgeLength.sort()\nprint(EdgeLength)\n\nsumL = sum(EdgeLength) - EdgeLength[N-1]\n\n\n #sumL += edgeLength[i]\n\n\nif EdgeLength[N-1] < sumL:\n print("Yes")\nelse:\n print("No")', 'n = input()\nEdgeLength=input()\nedgeLength=[int(i) for i in EdgeLength]\nN = int(n)\n\nsorted.edgeLength()\n\nsumL = 0\nsumLength = [sumL += edgeLength[i] for i in range(1,N)]\n\nif edgeLength[0] < sumL:\n print("Yes")\nelse:\n print("No")', 'n = input()\nEdgeLength=input().split()\n#print(EdgeLength)\nN = int(n)\nEdgeLength = [int(i) for i in EdgeLength]\n\n#list(map(int, EdgeLength))\n\nEdgeLength.sort()\n#print(EdgeLength)\n\nsumL = sum(EdgeLength) - EdgeLength[N-1]\n#print(sumL)\n\n\nif EdgeLength[N-1] < sumL:\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s567194085', 's725493019', 's826993292', 's867708500', 's134638536'] | [2940.0, 2940.0, 3060.0, 2940.0, 3060.0] | [18.0, 17.0, 17.0, 17.0, 17.0] | [232, 225, 336, 233, 301] |
p03136 | u276577535 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['import numpy as np\n\nN = input()\nL = [int(i) for i in input().split()]\n\nmax_value = np.max(L)\nsum_value = np.sum(L)\nprint("YES" if sum_value > 2 * max_value else "NO")\n', 'import numpy as np\n\nN = input()\nL = [int(i) for i in input().split()]\n\nmax_value = np.max(L)\nsum_value = np.sum(L)\nprint("Yes" if sum_value > 2 * max_value else "No")\n'] | ['Wrong Answer', 'Accepted'] | ['s761836825', 's946744795'] | [13492.0, 13508.0] | [181.0, 183.0] | [167, 167] |
p03136 | u278143034 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['\npolynum = int(input())\nlength = list(map(int,input().split()))\n\n\nmost_l = max(length)\nothersum = sum(length) - most_l\nprint(most_l)\nprint(othersum)\nif othersum > most_l:\n print("Yes")\nelse:\n print("No")', '\npolynum = int(input())\nlength = list(map(int,input().split()))\n\n\nmost_l = max(length)\nothersum = sum(length) - most_l\nif othersum > most_l:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s268624892', 's416000758'] | [9108.0, 9080.0] | [29.0, 29.0] | [276, 246] |
p03136 | u279493135 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\n\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\nsys.setrecursionlimit(10 ** 9)\nINF = float(\'inf\')\nMOD = 10 ** 9 + 7\n\nN = INT()\nL = LIST()\n\ntmp = max(L)\nL.remove(tmp)\nif tmp - sum(L) > 0:\n\tprint("Yes")\nelse:\n\tprint("No")\n\t', 'import sys, re\nfrom collections import deque, defaultdict, Counter\nfrom math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians\nfrom itertools import permutations, combinations, product\nfrom operator import itemgetter, mul\nfrom copy import deepcopy\nfrom string import ascii_lowercase, ascii_uppercase, digits\n\ndef input(): return sys.stdin.readline().strip()\ndef INT(): return int(input())\ndef MAP(): return map(int, input().split())\ndef LIST(): return list(map(int, input().split()))\nsys.setrecursionlimit(10 ** 9)\nINF = float(\'inf\')\nMOD = 10 ** 9 + 7\n\nN = INT()\nL = LIST()\n\ntmp = max(L)\nL.remove(tmp)\nif tmp < sum(L):\n\tprint("Yes")\nelse:\n\tprint("No")\n'] | ['Wrong Answer', 'Accepted'] | ['s918280039', 's734996000'] | [3892.0, 3896.0] | [27.0, 26.0] | [666, 661] |
p03136 | u281320846 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = input()\nl = [int(i) for i in input().split()] \n\nmax_val = max(l)\nsum_val = 0\n\nfor i in l:\n if i == max_val:\n continue\n sum_val +=i\n\nif max_val < sum_val:\n print('yes')\nelse:\n print('No')\n \n", "n = input()\nl = [int(i) for i in input().split()] \n \nmax_val = max(l)\nsum_val = 0\nf = False\n \nfor i in l:\n if i == max_val and not f:\n f = True\n continue\n sum_val +=i\n \nif max_val < sum_val:\n print('yes')\nelse:\n print('No')", 'a = input()\n\nprint(a)', "n = input()\nl = [int(i) for i in input().split()] \n \nif max(l) < sum(l) - max(l):\n print('Yes')\nelse:\n print('No')"] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s058343964', 's497769921', 's990175208', 's407741550'] | [2940.0, 3060.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0, 17.0] | [202, 233, 21, 116] |
p03136 | u282236289 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = input()\nl = list(map(int, input().split()))\n\nlm = 0\nfor i in range(0, n):\n if lm < l[i]:\n lm = l[i]\n\nls = -1 * lm\nfor i in range(0, n):\n ls = ls + l[i]\n\nif lm < ls:\n print("Yes")\nelse:\n print("No")', 'n = input()\nl = list(map(int, input().split()))\n\nlm = 0\nls = 0\nfor i in range(0, n):\n if lm < l[i]:\n lm = l[i]\n ls = ls + l[i]\nls = ls - lm\n\nif lm < ls:\n print("Yes")\nelse:\n print("No")\n', 'n = input()\nl = list(map(int, input().split()))\n\nn = len(l)\n\nlm = 0\nls = 0\nfor i in range(0, n):\n if lm < l[i]:\n lm = l[i]\n ls = ls + l[i]\nls = ls - lm\n\nif lm < ls:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s004146518', 's670716194', 's609511089'] | [3064.0, 3060.0, 3064.0] | [18.0, 17.0, 18.0] | [208, 193, 204] |
p03136 | u284363684 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['# input\nN = int(input())\nL = list(map(int, input().split()))\n\nif max(L) < sum(L) - max(L):\n print("Yes")\nelse;\n print("No")', '# input\nN = int(input())\nL = list(map(int, input().split()))\n\nif max(L) < sum(L) - max(L):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s383091717', 's420929111'] | [2940.0, 2940.0] | [17.0, 17.0] | [129, 129] |
p03136 | u285169240 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = [int(input()) for _ in range(N)]\n\nif max(L) < sum(L)-max(L):\n print("Yes")\nelse:\n print("No")\n', 'N = int(input())\nL = list(map(int, input().split()))\n\nif max(L) < sum(L)-max(L):\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Accepted'] | ['s975437489', 's223106243'] | [2940.0, 3060.0] | [18.0, 17.0] | [121, 120] |
p03136 | u294385082 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = list(map(int,input().split()))\nmaxlen = max(l)\nl.remove(maxlen)\ns = 0\n\nfor i in l:\n s += i\n \nif maxlen > s:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int,input().split())))\ns = 0\n\nfor i in l[:-1]:\n s += i\n \nif l[0] > s:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int,input().split())))\ns = 0\nprint(l)\n\nfor i in l[:-1]:\n s += i\n \n \nprint(s)\nif max(l) < s:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int,input().split())))\ns = 0\nprint(l)\n\nfor i in l[:-1]:\n s += i\n \n \nprint(s)\nif l[-1] < s:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int,input().split())),reverse = True)\ns = 0\n\nfor i in l[1:]:\n s += i\n \nif l[0] > s:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int,input().split())),reverse = True)\ns = 0\n\nfor i in l[1:]:\n s += i\n \nif l[0] < s:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s038995126', 's232096567', 's835021861', 's867008224', 's942441401', 's754900732'] | [3060.0, 3064.0, 3060.0, 3060.0, 2940.0, 3060.0] | [17.0, 19.0, 18.0, 17.0, 18.0, 18.0] | [165, 143, 166, 165, 157, 157] |
p03136 | u296518383 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['10\n1 8 10 5 8 12 34 100 11 3', 'import sys\ninput = sys.stdin.buffer.readline\n\nN = int(input())\nA = list(map(int, input().split()))\n\nif max(A) > sum(A) - max(A):\n print("Yes")\nelse:\n print("No")', 'import sys\ninput = sys.stdin.buffer.readline\n\nN = int(input())\nA = list(map(int, input().split()))\n\nif max(A) < sum(A) - max(A):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s273713684', 's499625848', 's694596376'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [28, 167, 167] |
p03136 | u299241276 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["if int(kaku) != len(s_list):\n print('No')\nelse:\n hen_list = [int(x) for x in s_list]\n\n m = max(hen_list)\n total = sum(hen_list)\n print(m, total)\n\n if m < total - m:\n print('Yes')\n else:\n print('No')\n\n", "kaku = input()\ns_list = input().split(' ')\nif not int(kaku) == len(s_list):\n print('No')\nelse:\n hen_list = [int(x) for x in s_list]\n m = max(hen_list)\n total = sum(hen_list)\n if m < total - m:\n print('Yes')\n else:\n print('No')\n\n"] | ['Runtime Error', 'Accepted'] | ['s815755161', 's622374433'] | [2940.0, 2940.0] | [18.0, 18.0] | [239, 264] |
p03136 | u300968187 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["input()\nl = list(map(int, input().split())).sort(reverse = True)\nprint('Yes' if l[0] < sum(l[1:]) else 'No')", "input()\nl = list(map(int, input().split()))\nl.sort(reverse = True)\nprint('Yes' if l[0] < sum(l[1:]) else 'No')"] | ['Runtime Error', 'Accepted'] | ['s790366157', 's189104682'] | [2940.0, 2940.0] | [18.0, 17.0] | [108, 110] |
p03136 | u302292660 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nL = [list(map(int,input().split()))]\nif max(L)<sum(L)-max(L):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nL = list(map(int,input().split()))\nif max(L)<sum(L)-max(L):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s136268193', 's029688805'] | [2940.0, 2940.0] | [18.0, 17.0] | [113, 111] |
p03136 | u302818391 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int, input().split()))\nM = max(L)\nL.remove(M)\ni = 0\nfor j in L:\n j += i\nif j > M:\n print("Yes")\nelse:\n print("No")\n', 'N = int(input())\nL = list(map(int, input().split()))\nM = max(L)\nL.remove(M)\nfor i in L:\n i += i\nif i > M:\n print("Yes")\nelse:\n print("No")\n', 'N = int(input())\nL = list(map(int, input().split()))\nM = max(L)\nL.remove(M)\ni = 0\nfor j in L:\n j += i\nif i > M:\n print("Yes")\nelse:\n print("No")\n', 'N = int(input())\nL = list(map(int, input().split()))\nM = max(L)\nL.remove(M)\ni = 0\nfor j in L:\n i += j\nif i > M:\n print("Yes")\nelse:\n print("No")\n'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s108792034', 's340667133', 's578984643', 's269287784'] | [3064.0, 2940.0, 2940.0, 2940.0] | [19.0, 17.0, 17.0, 17.0] | [154, 148, 154, 154] |
p03136 | u305452255 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\np = [int(input()) for i in range(n)]\np = sorted(p)\nif p[0] < sum(p[1:]):\n\tprint('Yes')\nelse:\n\tprint('No')", "n = int(input())\np = list(map(int, input().split(' ')))\np = sorted(p, reverse=True)\nif p[0] < sum(p[1:]):\n\tprint('Yes')\nelse:\n\tprint('No')"] | ['Runtime Error', 'Accepted'] | ['s417194657', 's519594368'] | [3056.0, 3060.0] | [18.0, 17.0] | [122, 138] |
p03136 | u305965165 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = sorted([int(i) for i in input().split()])\nif l[-1] < sum(l-l[-1]):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted([int(i) for i in input().split()])\nif l[-1] < sum(l)-l[-1]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s111075648', 's378099121'] | [2940.0, 2940.0] | [17.0, 18.0] | [126, 126] |
p03136 | u306070611 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nli = list(map(int,input().split()))\nMa = max(li)\nli.pop(Ma)\nif Ma >= sum(li):\n print("No")\nelse:\n print("Yes")', 'N = int(input())\nli = list(map(int,input().split()))\nMa = max(li)\nli.remove(Ma)\nif Ma >= sum(li):\n print("No")\nelse:\n print("Yes")'] | ['Runtime Error', 'Accepted'] | ['s451130872', 's190070481'] | [2940.0, 2940.0] | [18.0, 17.0] | [133, 136] |
p03136 | u312748806 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['corners = input()\nsides = list(map(int, input().split))\nsides = sorted(sides)\nfor i in (corners-1):\n nums += sides[i+1]\nif nums > sides[0]:\n print("Yes")\nelse:\n print("No")', 'corners = input()\nsides = list(map(int, input().split))\nsides = sorted(sides)\nfor i in (corners-1):\n nums += sides[i+1]\nif nums > sides[0]:\n print("Yes")\nelse:\n print("No")', 'corners = int(input())\nsides = list(map(int, input().split()))\nre_sides = sorted(sides, reverse=True)\nnums = 0\nfor i in range(corners-1):\n nums += re_sides[i+1]\nif nums > re_sides[0]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s331728959', 's823048801', 's347962388'] | [2940.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [181, 181, 225] |
p03136 | u313340709 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['import sys\n\ndef main():\n """ Code implementation """\n N = int(input())\n L = list(map(int, input().split()))\n longest = 0\n sum = 0\n for l in L:\n sum = sum + l\n if longest < l:\n longest = l\n \n if longest < (sum - longest):\n print("YES")\n else:\n print("NO")\n\nif __name__ == \'__main__\':\n main()\n', 'import sys\n\ndef main():\n """ Code implementation """\n N = int(input())\n L = list(map(int, input().split()))\n longest = 0\n sum = 0\n for l in L:\n sum = sum + l\n if longest < l:\n longest = l\n \n if longest < (sum - longest):\n print("Yes")\n else:\n print("No")\n\nif __name__ == \'__main__\':\n main()\n'] | ['Wrong Answer', 'Accepted'] | ['s279864259', 's907231374'] | [3060.0, 3060.0] | [18.0, 18.0] | [364, 364] |
p03136 | u315685304 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['import numpy as np\n\nn = int(input())\nlen_box = []\nfor _ in input().split():\n len_box.append(int(_))\nlen_box = np.array(len_box)\nlen_max = np.max(len_box)\nlen_sum = np.sum(len_box)\nif (len_sum-len_max) > len_max:\n print("yes")\nelse:\n print("No")', 'import numpy as np\n\nn = int(input())\nlen_box = []\nfor _ in input().split():\n len_box.append(int(_))\nlen_box = np.array(len_box)\nlen_max = np.max(len_box)\nlen_sum = np.sum(len_box)\nif (len_sum-len_max) > len_max:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s222585613', 's104892336'] | [18612.0, 18740.0] | [273.0, 278.0] | [253, 253] |
p03136 | u319410662 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int, input().split()))\nprint("YES" if max(L)*2<sum(L) else "NO")', 'N = int(input())\nL = list(map(int, input().split()))\nprint("Yes" if max(L)*2<sum(L) else "No")'] | ['Wrong Answer', 'Accepted'] | ['s064978251', 's103782237'] | [2940.0, 2940.0] | [17.0, 17.0] | [94, 94] |
p03136 | u325119213 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["def actual(n, L):\n max_l = max(L)\n others_l = sum(L) - max_l\n\n if max_l < others_l:\n return 'Yes'\n\n return 'No'\n\nn = int(input())\nL = map(int, input().split())\nprint(actual(n, L))", "def actual(n, L):\n max_l = max(L)\n others_l = sum(L) - max_l\n\n if max_l < others_l:\n return 'Yes'\n\n return 'No'\n\nn = int(input())\nL = list(map(int, input().split()))\nprint(actual(n, L))"] | ['Wrong Answer', 'Accepted'] | ['s082004130', 's680994966'] | [3060.0, 2940.0] | [17.0, 17.0] | [198, 204] |
p03136 | u328751895 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["_ = input()\nedges = list(int, input().split())\nmax_edge = max(edges)\nprint('Yes' if max_edge < sum(edges) - max_edge else 'No')", "_ = input()\nedges = list(map(int, input().split()))\nmax_edge = max(edges)\nprint('Yes' if max_edge < sum(edges) - max_edge else 'No')"] | ['Runtime Error', 'Accepted'] | ['s085859328', 's961483689'] | [8968.0, 9164.0] | [23.0, 30.0] | [127, 132] |
p03136 | u333139319 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = [int(i) for i in input().split()]\nl = sorted(l)\nm = l.pop(len(l)-1)\nif m <= sum(l):\n print("No")\nelse:\n print("Yes")', 'n = int(input())\nl = [int(i) for i in input().split()]\nl = sorted(l)\nm = l.pop(len(l)-1)\nif m >= sum(l):\n print("No")\nelse:\n print("Yes")'] | ['Wrong Answer', 'Accepted'] | ['s899224594', 's142339253'] | [2940.0, 2940.0] | [20.0, 17.0] | [139, 139] |
p03136 | u333404917 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = input()\nl = sorted(list(map(int, input().split())))\nmax_l = l[-1]\nif sum(max_l[:-1]) > l[-1]:\n print("Yes")\nelse:\n print("No")', 'n = input()\nl = sorted(list(map(int, input().split())))\nmax_l = l[-1]\nif sum(l[:-1]) > l[-1]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s714165348', 's053627482'] | [2940.0, 2940.0] | [18.0, 17.0] | [132, 128] |
p03136 | u337949146 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int,input().split()))\ns = 0\nfor i in L:\n s += i\ns -= max(L)\nif L < s:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = list(map(int,input().split()))\ns = 0\nfor i in L:\n s += i\ns -= max(L)\nif max(L) < s:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s255996303', 's486980246'] | [8884.0, 9140.0] | [27.0, 29.0] | [141, 146] |
p03136 | u338193317 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["import numpy as np\nn = int(input())\na = list(map(int, input().split()))\na.sort(reverse=True)\nb=np.array(a)\nif b[0]<b[1:].sum():\n print('yes')\nelse:\n print('No')", "import numpy as np\nn = int(input())\na = list(map(int, input().split()))\na.sort(reverse=True)\nb=np.array(a)\nif b[0]<b[1:].sum():\n print('Yes')\nelse:\n print('No')"] | ['Wrong Answer', 'Accepted'] | ['s136596810', 's005146096'] | [12488.0, 12488.0] | [149.0, 150.0] | [162, 162] |
p03136 | u339550873 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['#! /usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nN = int(input())\nif sum(sorted([int(x) for x in input().split()]) > 2*sorted([int(x) for x in input().split()][-1]:\n print("Yes")\nelse:\n print("No")\n', '#! /usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nN = int(input())\nif sum(sorted([int(x) for x in input().split()]) > 2*Llist[-1]:\n print("Yes")\nelse:\n print("No")\n', '#! /usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nN = int(input())\nif sum([int(x) for x in input().split()].sort()) > 2*Llist[-1]:\n print("Yes")\nelse:\n print("No")\n', '#! /usr/bin/env python3\n# -*- coding: utf-8 -*-\n\nN = int(input())\nLlist = [int(x) for x in input().split()]\nLlist.sort()\nLlist.reverse()\nif sum(Llist) > 2*Llist[0]:\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s392484238', 's471111319', 's958097165', 's681707350'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 20.0] | [204, 169, 169, 204] |
p03136 | u346395915 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\ns = input().split()\ns = [int(c) for c in s]\nSum = 0\n\nMax = max(s)\n\nfor i in range(n):\n Sum += s[n]\n \nif Max < Sum - Max:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nli = list(map(int,input().split()))\n\nprint("Yes" if max(li) < sum(li) - max(li) else "No")'] | ['Runtime Error', 'Accepted'] | ['s003937813', 's791953922'] | [3060.0, 3064.0] | [17.0, 19.0] | [182, 108] |
p03136 | u347640436 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["N = int(input())\nL = map(int, input().split())\n\nif max(L) < sum(L) - max(L):\n print('Yes')\nelse:\n print('No')\n", "N = int(input())\nL = list(map(int, input().split()))\n\nif max(L) < sum(L) - max(L):\n print('Yes')\nelse:\n print('No')\n"] | ['Runtime Error', 'Accepted'] | ['s255983897', 's328267590'] | [2940.0, 2940.0] | [17.0, 17.0] | [116, 122] |
p03136 | u349365032 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = (int(i) for i in input().split()) \nL = [int(i) for i in input().split()] \nmx = max(L)\nS = sum(L)\n\nif mx < S-mx:\n print("yes")\nelse:\n print("no")', 'N = (int(i) for i in input().split()) \nL = [int(i) for i in input().split()] \nmx = max(L)\nS = sum(L)\n\nif mx < S-mx:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s044666019', 's758492267'] | [2940.0, 3064.0] | [17.0, 17.0] | [155, 155] |
p03136 | u350984260 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['_ = input()\nn = [int(i) for i in input().split()]\nprint("YNeos"[0<sum(n)-max(n)*2::2])', '_ = input()\nn = [int(i) for i in input().split()]\nprint("YNeos"[0>=sum(n)-max(n)*2::2])'] | ['Wrong Answer', 'Accepted'] | ['s652711455', 's236723984'] | [2940.0, 2940.0] | [17.0, 17.0] | [86, 87] |
p03136 | u350997995 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\ns = []\nfor i in range(n):\n s.append(int(input()))\nif max(s)<sum(s)-max(s):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\ns = list(map(int,input().split()))\nif max(s)<sum(s)-max(s):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s365213507', 's276450988'] | [2940.0, 2940.0] | [18.0, 18.0] | [127, 111] |
p03136 | u352642051 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\ntable = [int(x) for x in input().split()]\n\ntable.sort()\nsums = 0\nfor x in range(0, len(table) - 1):\n sums += table[x]\nprint(sums)\nif max(table) < sums:\n print('Yes')\nelse:\n print('No')", "n = int(input())\ntable = [int(x) for x in input().split()]\n\ntable.sort()\nsums = 0\nfor x in range(0, len(table) - 1):\n sums += table[x]\n\nif max(table) > sums:\n print('Yes')\nelse:\n print('No')\n", "n = int(input())\ntable = [int(x) for x in input().split()]\n\ntable.sort()\nsums = 0\nfor x in range(0, len(table) - 1):\n sums += table[x]\nif max(table) < sums:\n print('Yes')\nelse:\n print('No')"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s025863825', 's559836911', 's715781907'] | [3060.0, 2940.0, 3060.0] | [17.0, 17.0, 17.0] | [210, 200, 198] |
p03136 | u357751375 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nl = list(map(int,input().split()))\nl.sort(reverse = True)\nif l[0] > sum(l[1:n]):\n print('Yes')\nelse:\n print('No')", "n = int(input())\nl = list(map(int,input().split()))\nl.sort(reverse = True)\nif l[0] < sum(l[1:]):\n print('Yes')\nelse:\n print('No')"] | ['Wrong Answer', 'Accepted'] | ['s960822414', 's871179803'] | [9144.0, 9148.0] | [36.0, 27.0] | [136, 135] |
p03136 | u358741136 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = list(input())\nmax_N = max(N)\n\nif max_N < sum(N)-max_N :\n print("Yes")\nelse:\n print("No")', 'Q = int(input())\nN = list(map(int, input().split()))\nmax_N = max(N)\n\nif max_N < sum(N)-max_N :\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Accepted'] | ['s333896120', 's874718432'] | [3068.0, 3316.0] | [18.0, 20.0] | [94, 130] |
p03136 | u360515075 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int, input().split()))\n\nprint ("Yes" if max(L) < sum(L) - 2 * max(L) else "No")', 'N = int(input())\nL = list(map(int, input().split()))\n\nprint ("Yes" if max(L) < sum(L) - max(L) else "No")'] | ['Wrong Answer', 'Accepted'] | ['s745998018', 's125792057'] | [2940.0, 2940.0] | [17.0, 20.0] | [109, 105] |
p03136 | u361826811 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["\n\nimport sys\nimport numpy as np\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(10 ** 7)\n\nN = int(readline())\nL = list(map(int, readline().split()))\nS = sum(L)\nans = True\nfor i in L:\n if S >= i+i:\n ans = False\n break\n\nprint('Yes' if ans else 'No')\n", "\n\nimport sys\nimport numpy as np\n\nread = sys.stdin.buffer.read\nreadline = sys.stdin.buffer.readline\nreadlines = sys.stdin.buffer.readlines\nsys.setrecursionlimit(10 ** 7)\n\nN = int(readline())\nL = list(map(int, readline().split()))\nLm=max(L)\nS = sum(L)\nans = True\n\nprint('Yes' if S>2*Lm else 'No')\n\n"] | ['Wrong Answer', 'Accepted'] | ['s598414886', 's116328646'] | [21504.0, 12508.0] | [518.0, 150.0] | [392, 343] |
p03136 | u362563655 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n=int(input())\nl=list(map(int,input().split()))\nif 2* max(s) < sum(l):\n print("Yes")\nelse:\n print("No")', 'n=int(input())\nl=list(map(int,input().split()))\nif 2* max(l) < sum(l):\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Accepted'] | ['s851561091', 's168482452'] | [2940.0, 2940.0] | [17.0, 17.0] | [105, 106] |
p03136 | u368796742 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl - list(map(int,input().split()))\nif max(l)>= sum(l)-2*max(l):\n print("No")\nelse:\n print("Yes")', 'n = int(input())\nl = list(map(int,input().split()))\nif max(l)>= sum(l)-2*max(l):\n print("No")\nelse:\n print("Yes")\n', 'n = int(input())\nl = list(map(int,input().split()))\nif 2*max(l)>= sum(l):\n print("No")\nelse:\n print("Yes")\n'] | ['Runtime Error', 'Wrong Answer', 'Accepted'] | ['s374809773', 's423427753', 's275282275'] | [2940.0, 2940.0, 2940.0] | [20.0, 17.0, 17.0] | [115, 116, 109] |
p03136 | u369752439 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nhens = list(map(int, input().strip().split()))\nans = max(hens) - sum(hens) + max(hens)\nif(ans > 0):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nhens = list(map(int, input().strip().split()))\nans = max(hens) - sum(hens) + max(hens)\nif(ans < 0):\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s993687810', 's147785913'] | [2940.0, 2940.0] | [17.0, 17.0] | [151, 151] |
p03136 | u371467115 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n=int(input())\nl=list(map(int,input().split()))\nans="Yes"\nfor i in l:\n if i>=sum(L)-i:\n ans="No"\nprint(ans)', 'n=input()\nl=list(map(int,input().split()))\nl.sort()\nif l[-1]<sum(l)-l[-1]:\n print("Yes")\nelse:\n print("No")\n '] | ['Runtime Error', 'Accepted'] | ['s293430052', 's130685991'] | [2940.0, 2940.0] | [17.0, 18.0] | [111, 112] |
p03136 | u372923276 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = map(int, input().split())\nmax = max(l)\nnum = 0\nfor i in l:\n num=i[0]\nnum = num-max\nif num > max:\n print("Yes")\nelse:\n print("No")\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))', '# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = list(map(int, input().split()))\nmax = max(l)\n\n# print(i)\n\nnum = 0\nfor i in l:\n num=i+num\nnum = num-max\nprint(num)\nprint(max)\nif num >= max:\n print("Yes")\nelse:\n print("No")\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))', '# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = list(map(int, input().split()))\nmax = max(l)\n\n# print(i)\n\nnum = 0\nfor i in l:\n num=i\n\nnum = num-max\n\nif num >= max:\n print("Yes")\nelse:\n print("No")\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))', '# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = map(int, input().split())\nmax = max(l)\nnum = 0\nfor i in l:\n num=i[0]\nnum = num-max\nif num >= max:\n print("Yes")\nelse:\n print("No")\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))', '# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = map(int, input().split())\nmax = max(l)\nnum = 0\nfor i in l:\n num=i[0]+num\nnum = num-max\nif num > max:\n print("Yes")\nelse:\n print("No")\nprint(max)\nprint(num)\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))', '# -*- coding: utf-8 -*-\n\n\nN = int(input())\n\n#b, c = map(int, input().split())\nl = list(map(int, input().split()))\nmax = max(l)\n\n# print(i)\n\nnum = 0\nfor i in l:\n num=i+num\nnum = num-max\n#print(num)\n#print(max)\nif num > max:\n print("Yes")\nelse:\n print("No")\n\n#s = input()\n\n#print("{} {}".format(a+b+c, s))'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s030477168', 's268513931', 's540538140', 's720079143', 's937743665', 's666915578'] | [3060.0, 3060.0, 3060.0, 3064.0, 3060.0, 3060.0] | [18.0, 17.0, 17.0, 18.0, 19.0, 17.0] | [354, 412, 388, 355, 380, 413] |
p03136 | u374977196 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["# the number of inputs\nN = int(input())\n# each length of edges\nLs= map(int, input().split())\nlargestL = 0\nlargestIndex = 0\n\n# straightforward way\nfor i in range(N):\n if Ls[i] > largestL:\n largestL = Ls[i]\n largestIndex = i\n\nsumOfSmallLs = 0\nfor i in range(N):\n if i != largestIndex:\n sumOfSmallLs += Ls[i]\n\nif sumOfSmallLs < largestL:\n print('Yes')\nelse:\n print('No')", "# the number of inputs\nN = int(input())\n# each length of edges\nLs= map(int(), input().split())\nlargestL = 0\nlargestIndex = 0\n \n# straightforward way\nfor i in range(N):\n if Ls[i] > largestL:\n largestL = Ls[i]\n largestIndex = i\n \nsumOfSmallLs = 0\nfor i in range(N):\n if i != largestIndex:\n sumOfSmallLs += Ls[i]\n \nif sumOfSmallLs < largestL:\n print('Yes')\nelse:\n print('No')", "# the number of inputs\nN = int(input())\n# each length of edges\nLs= list(map(int, input().split()))\n\n# searching largest one\nlargestL = 0\nlargestIndex = 0\n \n# straightforward way\nfor i in range(N):\n if Ls[i] > largestL:\n largestL = Ls[i]\n largestIndex = i\n \nsumOfSmallLs = 0\nfor i in range(N):\n if i != largestIndex:\n sumOfSmallLs += Ls[i]\n \nif sumOfSmallLs < largestL:\n print('Yes')\nelse:\n print('No')", "# the number of inputs\nN = int(input())\n# each length of edges\nLs= list(map(int, input().split()))\n\n# searching largest one\nlargestL = 0\nlargestIndex = 0\n\n# straightforward way\nfor i in range(N):\n if Ls[i] > largestL:\n largestL = Ls[i]\n largestIndex = i\nprint(largestL)\nsumOfSmallLs = 0\nfor i in range(N):\n if i != largestIndex:\n sumOfSmallLs += Ls[i]\n\nif sumOfSmallLs > largestL:\n print('Yes')\nelse:\n print('No')\n", "# the number of inputs\nN = int(input())\n# each length of edges\nLs= list(map(int, input().split()))\n\n# searching largest one\nlargestL = 0\nlargestIndex = 0\n\n# straightforward way\nfor i in range(N):\n if Ls[i] > largestL:\n largestL = Ls[i]\n largestIndex = i\n\nsumOfSmallLs = 0\nfor i in range(N):\n if i != largestIndex:\n sumOfSmallLs += Ls[i]\n\nif sumOfSmallLs > largestL:\n print('Yes')\nelse:\n print('No')\n"] | ['Runtime Error', 'Runtime Error', 'Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s096445757', 's420711206', 's794615278', 's946492652', 's267001615'] | [3064.0, 3060.0, 3064.0, 3060.0, 3060.0] | [18.0, 17.0, 18.0, 18.0, 18.0] | [380, 385, 414, 427, 412] |
p03136 | u377370946 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n=int(input())\nline=list(map(int,input().split()))\nborder=sum(line)/2\n\nflag=True\nfor i in line:\n if i >= border:\n flag=False\n break\n\nif flag:\n print('yes')\nelse:\n print('No')\n ", "n=int(input())\nline=list(map(int,input().split()))\nborder=sum(line)/2\n \nflag=True\nfor i in line:\n if i >= border:\n flag=False\n break\n \nif flag:\n print('Yes')\nelse:\n print('No')"] | ['Wrong Answer', 'Accepted'] | ['s257066973', 's329073952'] | [2940.0, 3060.0] | [17.0, 17.0] | [187, 185] |
p03136 | u379234461 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = input()\n\nl = list(map(int, input().split()))\n\nl.sort(reverse=True)\n\ntotal = l.sum()\n\nif (total - 2 * l[0] > 0 ) :\n print("yes")\nelse:\n print("no")\n ', 'n = input()\n \nl = list(map(int, input().split()))\n \nl.sort(reverse=True)\n \ntotal = sum(l)\n \nif (total - 2 * l[0] > 0 ) :\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s122160879', 's897635833'] | [2940.0, 2940.0] | [18.0, 18.0] | [155, 155] |
p03136 | u384261199 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL_list = list(map(int, input().split()))\n\nmax_ = max(L_list)\nL_list.remove(max_)\n\nif max_ < np.sum(L_list):\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL_list = list(map(int, input().split()))\n\nmax_ = max(L_list)\nL_list.remove(max_)\n\nif max_ < np.sum(L_list):\n print("Yes")\nelse:\n print("No")', 'import numpy as np\nN = int(input())\nL_list = list(map(int, input().split()))\n\nmax_ = max(L_list)\nL_list.remove(max_)\n\nif max_ < np.sum(L_list):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s263362881', 's369861677', 's457496724'] | [2940.0, 2940.0, 12480.0] | [17.0, 17.0, 150.0] | [163, 163, 182] |
p03136 | u385244248 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N,*L = map(int,open(0).read().split())\nL.sort()\nif sum(L[::-2]) < L[-1]:\n print("Yes")\nelse:\n print("No")', 'N,L = map(int,open(0).read().split())\nL.sort()\nif sum(L[::-2]) < L[-1]:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = list(map(int,input().split()))\nL.sort()\nif sum(L[:-1]) > L[-1]:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s011731289', 's470655320', 's687659787'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [111, 110, 123] |
p03136 | u386089355 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nls_l = map(int, input().split())\n\nif (2 * max(ls_l)) < sum(ls_l):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nls_l = list(map(int, input().split()))\n\n\nif (2 * max(ls_l)) < sum(ls_l):\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s018137658', 's151027238'] | [2940.0, 2940.0] | [17.0, 17.0] | [121, 128] |
p03136 | u394723265 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["s1=input()\ns2=input().split()\na=sorted(s2,reverse=True)\n\nmax=a[0]\ncnt=a[1:]\nall=sum(int(i) for i in cnt)\n\nif(max<all){\n print('Yes')\n}else{\n print('No')\n}\n", "s1=input()\ns2=input().split()\na=sorted(s2,reverse=True)\n\nmax=int(a[0])\ncnt=a[1:]\nall=sum(int(i) for i in cnt)\n\nif(max<all):\n print('Yes')\nelse\n print('No')\n\n", "s1=input()\ns2=input().split()\nn2=[int(i) for i in s2]\na=sorted(n2,reverse=True)\n\nmax=a[0]\ncnt=a[1:]\nall=sum(cnt)\n\nif(max<all):\n print('Yes')\nelse:\n print('No')"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s781917672', 's852282132', 's777037942'] | [2940.0, 2940.0, 3064.0] | [17.0, 17.0, 17.0] | [157, 159, 161] |
p03136 | u395620499 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nls = map(int, input().split())\n\ncur_longest = 0\nsum_others = 0\n\nfor l in ls:\n sum_others += l\n if l > cur_longest:\n sum_others -= l\n sum_others += cur_longest\n cur_longest = l\n\nprint(cur_longest, sum_others)\n\nif cur_longest >= sum_others:\n print('No')\nelse:\n print('Yes')\n\n", "n = int(input())\nls = map(int, input().split())\n\ncur_longest = 0\nsum_others = 0\n\nfor l in ls:\n sum_others += l\n if l > cur_longest:\n sum_others -= l\n sum_others += cur_longest\n cur_longest = l\n\nprint(cur_longest, sum_others)\n\nif cur_longest > sum_others:\n print('No')\nelse:\n print('Yes')\n\n", "n = int(input())\nls = map(int, input().split())\n\ncur_longest = 0\nsum_others = 0\n\nfor l in ls:\n sum_others += l\n if l > cur_longest:\n sum_others -= l\n sum_others += cur_longest\n cur_longest = l\n\nif cur_longest >= sum_others:\n print('No')\nelse:\n print('Yes')\n\n"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s028593536', 's278723236', 's718435941'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [323, 322, 291] |
p03136 | u396495667 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nl =[int() for i in input().split()]\nl.sort(reverse=True)\nm = l.pop(0)\nif m < sum(l):\n print('Yes')\nelse:\n print('No')", "n= int(input())\nlist = [int(x) for x in input().split()]\n\nif max(list) < (sum(list) - max(list)):\n print('Yes')\nelse:\n print('No'", "n = int(input())\nl =[int() for i in input().split()]\nprint('Yes' if max(l) < sum(l) - max(l) else 'No')", "n = int(input())\nl =[int(i) for i in input().split()]\nprint('Yes' if max(l) < sum(l) - max(l) else 'No')"] | ['Wrong Answer', 'Runtime Error', 'Wrong Answer', 'Accepted'] | ['s372447317', 's722233850', 's729099631', 's220503133'] | [2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0, 17.0] | [136, 132, 103, 104] |
p03136 | u397953026 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = list(map(int,input().split()))\nl.sort()\nsum = 0\nprint(l[0])\nfor i in range(n-1):\n sum += l[i]\nif (sum <= l[n-1]):\n print("No")\nelse:\n print("Yes")', 'n = int(input())\nl = list(map(int,input().split()))\nl.sort()\nsum = 0\nfor i in range(n-1):\n sum += l[i]\nif (sum <= l[n-1]):\n print("No")\nelse:\n print("Yes")'] | ['Wrong Answer', 'Accepted'] | ['s216428322', 's353676411'] | [3064.0, 2940.0] | [17.0, 17.0] | [176, 164] |
p03136 | u398437835 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nl = list(map(input().split(' '), int))\nif max(l) < sum(l) - max(l):\n print('Yes')\nelse\n print('No')", "n = int(input())\nl = list(map(int, input().split(' ')))\nif max(l) < sum(l) - max(l):\n print('Yes')\nelse\n print('No')\n", "n = int(input())\nl = list(map(int, input().split(' ')))\nif max(l) < sum(l) - max(l):\n print('Yes')\nelse:\n print('No')\n"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s268431930', 's281823634', 's698888976'] | [2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0] | [118, 119, 120] |
p03136 | u398846051 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = list(map(int, input().split()))\nif L[:-1] > L[-1]:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nL = list(map(int, input().split()))\nL.sort()\nif sum(L[:-1]) < L[-1]:\n print("Yes")\nelse:\n print("No")', ' = int(input())\nL = list(map(int, input().split()))\nL.sort()\nif sum(L[:-1]) > L[-1]:\n print("Yes")\nelse:\n print("No")', ' N= int(input())\n L = list(map(int, input().split()))\n L.sort()\n if sum(L[:-1]) > L[-1]:\n print("Yes")\n else:\n print("No")', 'N = int(input())\nL = list(map(int, input().split()))\nL.sort()\nif sum(L[:-1]) > L[-1]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Wrong Answer', 'Runtime Error', 'Runtime Error', 'Accepted'] | ['s048770143', 's259714416', 's262346505', 's984671258', 's133724803'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 19.0, 17.0, 17.0, 17.0] | [106, 120, 119, 148, 120] |
p03136 | u398983698 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['a=int(input())\nb=list(map(int,input().split())\nif sum(b)>2*max(b):\n print("Yes")\nelse:\n print("No")', 'a=int(input())\nb=list(map(int,input().split()))\nif sum(b)>2*max(b):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s380472231', 's221198100'] | [2940.0, 2940.0] | [17.0, 18.0] | [111, 112] |
p03136 | u400221789 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n=int(input())\nl=list(map(int,input().split()))\nL=max(l)\nother=sum(l)-L\nif other>=L:\n print('No')\nelse:\n print('Yes')", "n=int(input())\nl=list(map(int,input().split()))\nL=max(l)\nother=sum(l)-L\nif other<=L:\n print('No')\nelse:\n print('Yes')\n"] | ['Wrong Answer', 'Accepted'] | ['s319375343', 's203595273'] | [2940.0, 2940.0] | [18.0, 18.0] | [119, 120] |
p03136 | u405660020 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n,m=map(int,input().split())\n\nlistA=[]\nfor i in range(n):\n listA.append(list(map(int,input().split())))\n\nfor i in range(n):\n popped_item1=listA[i].pop(0)\n\nlistB=[]\nfor i in listA:\n for j in i:\n listB.append(j)\n\ncnt=0\nfor i in range(m+1):\n if listB.count(i)==n:\n cnt+=1\nprint(cnt)', 'n=int(input())\nlistL = list(map(int, input().split()))\nif max(listL)<(sum(listL)-max(listL)):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s368461708', 's941823927'] | [3064.0, 2940.0] | [18.0, 19.0] | [305, 132] |
p03136 | u406158207 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N=int(input())\nl_list=[int(input())for _ in range(N)]\nmax_l=max(l_list)\nif sum(l_list)-max_l>max_l:\n print("Yes")\nelse:\n print("No")', 'N=int(input())\nl_list = list(int(input()) for _ in range(N))\nmax_l=max(l_list)\nif sum(l_list)-max_l>max_l:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nl_list = list(map(int,input().split()))\nmax_l = max(l_list)\nif sum(l_list)-max_l>max_l:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s438699643', 's563393578', 's529749326'] | [2940.0, 2940.0, 2940.0] | [17.0, 18.0, 17.0] | [134, 141, 139] |
p03136 | u410269178 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n = int(input())\nl = list(map(int, input().split()))\ntot = sum(l)\nflag = True:\nfor l_i in l:\n if 2 * l_i >= tot:\n flag = False\n break\nif flag:\n print('Yes')\nelse:\n print('No')", "n = int(input())\nl = list(map(int, input().split()))\ntot = sum(l)\nflag = True\nfor l_i in l:\n if 2 * l_i >= tot:\n flag = False\n break\nif flag:\n print('Yes')\nelse:\n print('No')"] | ['Runtime Error', 'Accepted'] | ['s314505805', 's173330787'] | [2940.0, 2940.0] | [17.0, 17.0] | [184, 183] |
p03136 | u419967147 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N=input()\na=sort(list(map(int, input().split())))\nsum=0\nfor i in range(len(a)-1):\n sum+=a[i]\n \nif sum>a(len(a)-1):\n Yes\nelse:\n No\n', 'N=int(input())\na=input().split()\nfor i in range(N):\n a[i]=int(a[i])\na.sort()\nsum=0\nm=len(a)-1\nfor i in range(m):\n sum+=a[i]\n \nif sum>a[len(a)-1]:\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Accepted'] | ['s021381827', 's460124317'] | [2940.0, 3060.0] | [19.0, 18.0] | [134, 183] |
p03136 | u422921872 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["N = int(input())\nL = list(map(int,input().split()))\nif max(L) >= (sum(L) - max(L)):\n print('NO')\nelse:\n print('YES')", "N = int(input())\nL = list(map(int,input().split()))\nif max(L) < (sum(L) - max(L)):\n print('YES')\nelse:\n print('NO')", "N = int(input())\nL = list(map(int,input().split()))\nif max(L) >= sum(L) - max(L):\n print('No')\nelse:\n print('Yes')"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s191955933', 's782854731', 's808400376'] | [2940.0, 2940.0, 2940.0] | [18.0, 17.0, 17.0] | [118, 117, 116] |
p03136 | u427984570 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = sprted(list(map(int, input().split())))\nif l[-1] * 2 < sum(l):\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nl = sorted(list(map(int, input().split())))\nif l[-1] * 2 < sum(l):\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Accepted'] | ['s736242290', 's529108338'] | [2940.0, 2940.0] | [18.0, 17.0] | [118, 119] |
p03136 | u432853936 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nl = list(map(int,input().split()))\nsortl = sorted(l)\nans = 0\nfor number in sortl:\n ans += number\nif ans - sortl[n-1] >= sortl[n-1]:\n print("No")\nelse:\n print("Yes")\n', 'n = int(input())\nl = list(map(int,input().split()))\nsortl = sorted(l)\nans = 0\nfor number in sortl:\n ans += number\nif ans - sortl(n-1) >= sortl(n-1):\n print("No")\nelse:\n print("Yes")\n', 'n = int(input())\nl = list(map(int,input().split()))\nsortl = sorted(l)\nans = 0\nfor number in sortl:\n ans += number\nif ans - sortl[n-1] > sortl[n-1]:\n print("Yes")\nelse:\n print("No")\n'] | ['Wrong Answer', 'Runtime Error', 'Accepted'] | ['s431679607', 's936378097', 's137914817'] | [2940.0, 2940.0, 2940.0] | [18.0, 18.0, 18.0] | [206, 206, 205] |
p03136 | u437638594 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nedges = map(int, input().split())\n\nif max(edges) * 2 < sum(edges):\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nedges = list(map(int, input().split()))\n\nif max(edges) * 2 < sum(edges): \n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s721142194', 's363143830'] | [2940.0, 3060.0] | [17.0, 19.0] | [118, 126] |
p03136 | u439312138 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\ni_list = list(map(int,input().split()))\ni_list = sorted(i_list)\n\nline_sum = 0\nfor i in i_list[:-2]:\n line_sum += i\n\nif i_list[-1] < line_sum:\n print("Yes")\nelse:\n print("No")\n\n\n\n', 'N = int(input())\ni_list = list(map(int,input().split()))\ni_list = sorted(i_list)\n\nline_sum = 0\nfor i in i_list:\n line_sum += i\n\nif max(i_list) < line_sum - max(i_list):\n print("Yes")\nelse:\n print("No")\n\n\n\n'] | ['Wrong Answer', 'Accepted'] | ['s990424849', 's782047824'] | [2940.0, 2940.0] | [17.0, 17.0] | [198, 208] |
p03136 | u439392790 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["N=int,input()\nlist=map(int,input().split())\nlist2=list\na=max(list)\nb=sum(list2)\nif a < b-a :\n print('Yes')\nelse :\n print('No')\n", "N=int,input()\nlist=map(int,input().split())\na=max(list)\nb=sum(list)\nif a < b-a :\n print('Yes')\nelse :\n print('No')\n", "N=int(input())\nlistL=list(map(int,input().split()))\na,b=max(listL),sum(listL)\nif a < b-a :\n print('Yes')\nelse :\n print('No')"] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s141753832', 's373149645', 's128304122'] | [3064.0, 2940.0, 2940.0] | [20.0, 17.0, 18.0] | [133, 121, 130] |
p03136 | u440161695 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N=int(input())\nA=list(map(int,input().split()))\nL=sorted(A,reverse=True)\nif L[0]<sum(L[1,]):\n print("Yes")\nelse:\n print("No")', 'N=int(input())\nA=list(map(int,input().split()))\nL=sorted(A,reverse=True)\nif L[0]<sum(L[1,]):\n print("Yes")\nelse:\n print("No")', 'N=int(input())\nA=list(map(int,input().split()))\nL=sorted(A,reverse=True)\nif L[0]<sum(L[1:]):\n print("Yes")\nelse:\n print("No")'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s114444312', 's518527200', 's928904107'] | [2940.0, 3060.0, 3060.0] | [17.0, 18.0, 17.0] | [127, 127, 127] |
p03136 | u442581202 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = map(int,input.split())\nl = [int(x) for x in input.split()]\n\ns = sum(l)\n\nfor x in l:\n if (2*x>=s):\n print("No")\n exit(0)\nprint("Yes")\n ', 'n = map(int,input.split())\nl = [int(x) for x in input().split()]\n\ns = sum(l)\nres = "Yes"\nfor x in l:\n if (2*x>=s):\n res = "No"\nprint(res)\n ', 'n = map(int,input().split())\nl = [int(x) for x in input().split()]\n\ns = sum(l)\nres = "Yes"\nfor x in l:\n if (2*x>=s):\n res = "No"\nprint(res)\n '] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s308739187', 's481087260', 's442173525'] | [2940.0, 2940.0, 2940.0] | [18.0, 18.0, 18.0] | [148, 146, 148] |
p03136 | u446711904 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["n,l=map(int,open(0).read().split())\nsum_n=sum(l)\nfor i in range(n):\n\tif 2*l[i]>=sum_n\n\t\tprint('No')\n\t\timport sys\n\t\tsys.exit()\nprint('Yes')", "n,l=map(int,open(0).read().split())\nsum_n=sum(l)\nfor i in range(n):\n if 2*l[i]>=sum_n\n \tprint('No')\n import sys\n sys.exit()\nprint('Yes')", "n,*l=map(int,open(0).read().split())\nsum_n=sum(l)\nfor i in range(n):\n\tif 2*l[i]>=sum_n:\n\t\tprint('No')\n\t\timport sys\n\t\tsys.exit()\nprint('Yes')"] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s842019815', 's895478561', 's910405645'] | [9000.0, 9024.0, 9180.0] | [26.0, 25.0, 32.0] | [138, 144, 140] |
p03136 | u448655578 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nedges = list(map(int, input().split()))\nsum = 0\nm = max(edges)\nm.pop(m.index(m))\nfor i in range(len(edges)):\n sum += edges[i]\nif m < sum:\n print("Yes")\nelse:\n print("No")', 'N = int(input())\nedges = list(map(int, input().split()))\nsum = 0\nm = max(edges)\nm.pop(edges.index(m))\nfor i in range(len(edges)):\n sum += edges[i]\nif m < sum:\n print("Yes")\nelse:\n print("No")\n', 'N = int(input())\nedges = list(map(int, input().split()))\nsum = 0\nm = max(edges)\nedges.pop(edges.index(m))\nfor i in range(len(edges)):\n sum += edges[i]\nif m < sum:\n print("Yes")\nelse:\n print("No")\n'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s332149125', 's398034596', 's207490746'] | [3060.0, 3060.0, 3060.0] | [17.0, 17.0, 17.0] | [190, 195, 199] |
p03136 | u450288159 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ["l = input()\nn = int(l)\nl = input()\na = list(map(int, input().split(' ')))\n\nif max(a) < sum(a)-max(a):\n print('Yes')\nelse:\n print('No')\n", "l = input()\nn = int(l)\nl = input()\na = list(map(int, l.split(' ')))\n\nif max(a) < sum(a)-max(a):\n print('Yes')\nelse:\n print('No')"] | ['Runtime Error', 'Accepted'] | ['s761356326', 's560311947'] | [2940.0, 3064.0] | [18.0, 17.0] | [137, 130] |
p03136 | u450983668 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['_,l=map(int,open(0).read().split())\nl.sort()\nprint("YNeos"[::sum(l[:-1])<=l[-1]])', '_,l=map(int,open(0).read().split())\nl.sort()\nprint("YNeos"[sum(l[:-1])<=l[-1]::2])', '_,*l=map(int,open(0).read().split())\nl.sort()\nprint("YNeos"[sum(l[:-1])<=l[-1]::2])'] | ['Runtime Error', 'Runtime Error', 'Accepted'] | ['s178234291', 's829122550', 's713733755'] | [9092.0, 9088.0, 9164.0] | [24.0, 23.0, 28.0] | [81, 82, 83] |
p03136 | u455533363 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nd = list(map(int,input().split()))\n\ndmax = max(d)\n\ndsum = sum(d)\n\ntan = dsum - dmax\nprint(dmax)\nprint(tan)\nif tan > dmax:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nd = list(map(int,input().split()))\n\ndmax = max(d)\n\ndsum = sum(d)\n\ntan = sum(d) - max(d)\n\nif tan < dmax:\n print("Yes")\nelse:\n print("No")', 'n = int(input())\nd = list(map(int,input().split()))\n\ndmax = max(d)\n\ndsum = sum(d)\n\ntan = dsum - dmax\n\nif tan > dmax:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s212702064', 's552424519', 's043688436'] | [3060.0, 2940.0, 2940.0] | [17.0, 17.0, 17.0] | [173, 155, 151] |
p03136 | u458315482 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = input().split()\n\nL_i = [int(s) for s in L]\n\nLength = 0\nsum = 0\nnum = 0\n\nfor i in range(N):\n sum += L_i[i]\n \n if L_i[i] > Length:\n Length = L_i[i]\n num = i\n\n\nif Length * 2 < sum:\n print("yes")\nelse:\n print("no")', 'N = int(input())\nL = input().split()\n\nL_i = [int(s) for s in L]\n\nLength = 0\nsum = 0\nnum = 0\n\nfor i in range(N):\n sum += L_i[i]\n \n if L_i[i] > Length:\n Length = L_i[i]\n num = i\n\n\nif Length * 2 > sum:\n print("yes")\nelse:\n print("no")', 'N = int(input())\nL = input().split()\n\nL_i = [int(s) for s in L]\n\nLength = 0\nsum = 0\nnum = 0\n\nfor i in range(N):\n sum += L_i[i]\n\n if L_i[i] > Length:\n Length = L_i[i]\n num = i\n\n\nif Length * 2 < sum:\n print("Yes")\nelse:\n print("No")\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s430353264', 's722460823', 's416963653'] | [3064.0, 3064.0, 3060.0] | [17.0, 17.0, 17.0] | [260, 260, 257] |
p03136 | u459023872 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N=int(input())\ninput_list=map(int,input().split(" "))\n\nmax_input=max(input_list)\nSum_input=sum(input_list)-max_input\nif max_input<Sum_input:\n print("Yes")\nelse:\n print("No")', 'N=int(input())\ninput_list=list(map(int,input().split(" ")))\n\nmax_input=max(input_list)\nSum_input=sum(input_list)-max_input\nif max_input<Sum_input:\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Accepted'] | ['s929577527', 's981149023'] | [9136.0, 9192.0] | [26.0, 28.0] | [179, 185] |
p03136 | u460745860 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['N = int(input())\nL = sorted(list(map(int, input().split())))\n\nmax_length = L[-1]\nsum_length = sum(L[0:len(L)-1])\nprint(sum_length)\n\nprint("Yes") if max_length > sum_length else print("No")', '# ABC117\n\nN = int(input())\nL = sorted(list(map(int, input().split())))\n\nmax_length = L[-1]\nsum_length = sum(L[0:len(L)-1])\n\nprint("Yes") if max_length > sum_length else print("No")\n', 'N = int(input())\nL = sorted(list(map(int, input().split())))\n\nmax_length = L[-1]\nsum_length = sum(L[0:len(L)-1])\n\nprint("Yes") if max_length < sum_length else print("No")\n'] | ['Wrong Answer', 'Wrong Answer', 'Accepted'] | ['s779192729', 's873549724', 's280166088'] | [9168.0, 9164.0, 9072.0] | [31.0, 28.0, 32.0] | [188, 181, 171] |
p03136 | u462956439 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n = int(input())\nnums = list(map(int, input().split()))\nnums.sort()\nmax = nums.pop(-1)\nif(sum(nums) > max):\n print("yes")\nelif(sum(nums) <= max):\n print("no")\n', 'n = int(input())\nnums = list(map(int, input().split()))\nnums.sort()\nmax = nums.pop(-1)\nprint(sum(nums))\n\nif(sum(nums) > max):\n print("yes")\nelse:\n print("no")\n', 'n = int(input())\nnums = list(map(int, input().split()))\nnums.sort()\nmax = nums.pop(-1)\nprint(sum(nums))\n\nif(sum(nums) > max):\n print("yes")\nelif(sum(nums) <= max):\n print("no")\n', 'n = int(input())\nnums = list(map(int, input().split()))\nnums.sort()\nmax = nums.pop(-1)\nprint(sum(nums))\n\nif(sum(nums) > max):\n print("yes")\nelif(sum(nums) <= max)\n print("no")\n', 'n = int(input())\nlines = [int(x) for x in input().split()]\nlines\nlines = sorted(lines)\nif lines[-1] < sum(lines[:-1]):\n print("Yes")\nelse:\n print("No")'] | ['Wrong Answer', 'Wrong Answer', 'Wrong Answer', 'Runtime Error', 'Accepted'] | ['s343547164', 's374871237', 's502607631', 's677888999', 's513189854'] | [2940.0, 2940.0, 2940.0, 2940.0, 2940.0] | [17.0, 17.0, 18.0, 17.0, 17.0] | [165, 165, 183, 182, 157] |
p03136 | u475675023 | 2,000 | 1,048,576 | Determine if an N-sided polygon (not necessarily convex) with sides of length L_1, L_2, ..., L_N can be drawn in a two-dimensional plane. You can use the following theorem: **Theorem** : an N-sided polygon satisfying the condition can be drawn if and only if the longest side is strictly shorter than the sum of the lengths of the other N-1 sides. | ['n=int(input())\nl=list(map(int,input().split()))\nm=l.pop(max(l))\nprint("Yes" if m>sum(l) else "No")', 'n=int(input())\nl=sorted(list(map(int,input().split())))\nm=l.pop(-1)\nprint("Yes" if m<sum(l) else "No")'] | ['Runtime Error', 'Accepted'] | ['s813982458', 's006583025'] | [2940.0, 2940.0] | [17.0, 17.0] | [98, 102] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.