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 le... | ["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 le... | ['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 le... | ['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 le... | ["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(... | ['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 le... | ['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 le... | ['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 le... | ['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 le... | ['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().sp... | ['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 le... | ["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 le... | ["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... | ['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 le... | ['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)... | ['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 le... | ['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 le... | ['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... | ['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 le... | ['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("Y... | ['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 le... | ['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)-... | ['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 le... | ['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 numb... | ['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 le... | ['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 ... | ['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 le... | ['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 =... | ['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 le... | ['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 le... | ["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 le... | ['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... | ['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 le... | ['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... | ['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 le... | ['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 su... | ['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 le... | ['\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)\n... | ['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 le... | ['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, di... | ['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 le... | ["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... | ['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 le... | ['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... | ['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 le... | ['# 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 le... | ['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 le... | ['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... | ['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 le... | ['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\... | ['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 le... | ["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)... | ['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 le... | ["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 le... | ['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 le... | ['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 prin... | ['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 le... | ["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 le... | ['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 le... | ['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 le... | ['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... | ['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 le... | ['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... | ['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 le... | ['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 =... | ['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 le... | ['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 le... | ["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 ... | ['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 le... | ["_ = 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 le... | ['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 le... | ['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 le... | ['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 le... | ["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('Y... | ['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 le... | ['#! /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 i... | ['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 le... | ['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 le... | ["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 le... | ['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 ... | ['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 le... | ['_ = 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 le... | ['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 le... | ["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 ... | ['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 le... | ["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 le... | ['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 le... | ['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 le... | ["\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 ... | ['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 le... | ['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 le... | ['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)>= ... | ['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 le... | ['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 le... | ['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 le... | ['# -*- 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... | ['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 le... | ["# 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 sumOfSm... | ['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 le... | ["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 >= ... | ['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 le... | ['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")\ne... | ['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 le... | ['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(... | ['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 le... | ['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]) ... | ['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 le... | ['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 le... | ["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('Ye... | ['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 le... | ["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')\nel... | ['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 le... | ["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() f... | ['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 le... | ['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... | ['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 le... | ["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 m... | ['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 le... | ['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[... | ['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 le... | ['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 le... | ["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 le... | ['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... | ['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 le... | ['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_lis... | ['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 le... | ["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... | ['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 le... | ['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("Y... | ['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 le... | ["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) >... | ['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 le... | ['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 le... | ['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 so... | ['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 le... | ['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 le... | ['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\nf... | ['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 le... | ["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,inpu... | ['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 le... | ['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... | ['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 le... | ['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 '... | ['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 le... | ["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=m... | ['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 le... | ['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 i... | ['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 le... | ["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 le... | ['_,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 le... | ['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... | ['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 le... | ['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().spli... | ['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 le... | ['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\... | ['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 le... | ['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:l... | ['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 le... | ['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 prin... | ['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 le... | ['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.