s_id stringlengths 10 10 | p_id stringlengths 6 6 | u_id stringlengths 10 10 | date stringlengths 10 10 | language stringclasses 1
value | original_language stringclasses 11
values | filename_ext stringclasses 1
value | status stringclasses 1
value | cpu_time stringlengths 1 5 | memory stringlengths 1 7 | code_size stringlengths 1 6 | code stringlengths 1 539k |
|---|---|---|---|---|---|---|---|---|---|---|---|
s247673300 | p02272 | u825178626 | 1496984458 | Python | Python3 | py | Runtime Error | 0 | 0 | 813 | N = int(input())
A = list(map(int, input().strip().split()))
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A,0,N)
ans = ""
for i in A:
ans += str(i) + " "
print(ans)
print(count) |
s495313691 | p02272 | u825178626 | 1496984555 | Python | Python3 | py | Runtime Error | 0 | 0 | 805 | N = int(input())
A = list(map(int, input().split()))
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A,0,N)
ans = ""
for i in A:
ans += str(i) + " "
print(ans)
print(count) |
s572042711 | p02272 | u825178626 | 1496984582 | Python | Python3 | py | Runtime Error | 0 | 0 | 805 | N = int(input())
A = list(map(int, input().split()))
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A,0,N)
ans = ""
for i in A:
ans += str(i) + " "
print(ans)
print(count) |
s525695213 | p02272 | u825178626 | 1496984589 | Python | Python3 | py | Runtime Error | 0 | 0 | 805 | N = int(input())
A = list(map(int, input().split()))
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A,0,N)
ans = ""
for i in A:
ans += str(i) + " "
print(ans)
print(count) |
s532876619 | p02272 | u825178626 | 1496984783 | Python | Python3 | py | Runtime Error | 0 | 0 | 776 | N = int(input())
A = list(map(int, input().split()))
count=0
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(float("inf"))
R.append(float("inf"))
i, j = 0, 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A,0,N)
print(" ".join(A))
print(count) |
s922416651 | p02272 | u834139744 | 1497252120 | Python | Python3 | py | Runtime Error | 0 | 0 | 1205 | #!/usr/bin/python
def mergesort(mylist, num):
len_list = len(mylist)
center = int(len_list / 2)
former = mylist[:center]
len_former = len(former)
if len_former > 1:
mergesort(former, num)
latter = mylist[center:]
len_latter = len(latter)
if len_latter > 1:
mergesort(latter, num)
temp = mylist[:]
i = 0
j = 0
k = 0
both_flag = True
while both_flag:
while both_flag and former[i] <= latter[j]:
mylist[k] = former[i]
i += 1
k += 1
num[0] += 1
if i == len_former:
both_flag = False
while both_flag and latter[j] < former[i]:
mylist[k] = latter[j]
j += 1
k += 1
num[0] += 1
if j == len_latter:
both_flag = False
while j < len_latter:
mylist[k] = latter[j]
j += 1
k += 1
num[0] += 1
while i < len_former:
mylist[k] = former[i]
i += 1
k += 1
num[0] += 1
N = int(input())
S = list(map(int, input().split(" ")))
num = [0]
mergesort(S, num)
#print(S)
print(" ".join(S))
print(num[0]) |
s716117968 | p02272 | u834139744 | 1497252157 | Python | Python3 | py | Runtime Error | 0 | 0 | 1205 | #!/usr/bin/python
def mergesort(mylist, num):
len_list = len(mylist)
center = int(len_list / 2)
former = mylist[:center]
len_former = len(former)
if len_former > 1:
mergesort(former, num)
latter = mylist[center:]
len_latter = len(latter)
if len_latter > 1:
mergesort(latter, num)
temp = mylist[:]
i = 0
j = 0
k = 0
both_flag = True
while both_flag:
while both_flag and former[i] <= latter[j]:
mylist[k] = former[i]
i += 1
k += 1
num[0] += 1
if i == len_former:
both_flag = False
while both_flag and latter[j] < former[i]:
mylist[k] = latter[j]
j += 1
k += 1
num[0] += 1
if j == len_latter:
both_flag = False
while j < len_latter:
mylist[k] = latter[j]
j += 1
k += 1
num[0] += 1
while i < len_former:
mylist[k] = former[i]
i += 1
k += 1
num[0] += 1
N = int(input())
S = list(map(int, input().split(" ")))
num = [0]
mergesort(S, num)
#print(S)
print(" ".join(S))
print(num[0]) |
s829425009 | p02272 | u193453446 | 1501486238 | Python | Python3 | py | Runtime Error | 2100 | 29468 | 1981 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
?????????????????????Merge Sort??????????????±??????????????\??????????????¢?????´???????????§???
?¬?????????????????£????????????¨?????§????????????
merge(A, left, mid, right)
n1 = mid - left;
n2 = right - mid;
L[0...n1], R[0...n2] ?????????
for i = 0 to n1-1
L[i] = A[left + i]
for i = 0 to n2-1
R[i] = A[mid + i]
L[n1] = INFTY
R[n2] = INFTY
i = 0
j = 0
for k = left to right-1
if L[i] <= R[j]
A[k] = L[i]
i = i + 1
else
A[k] = R[j]
j = j + 1
mergeSort(A, left, right)
if left+1 < right
mid = (left + right)/2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n ????????´??°???????????°??? S ????????????????????????????????£???????????????????????§
???????????´?????????????????°????????????????????????????????????
?????????merge???????????????????????°????????°?????±????????????????????????
"""
MAX = 100000000
def merge(A, left, mid, right, cnt):
# print("l:{} m:{} r:{} cnt:{}".format(left,mid,right,cnt))
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(A[left + i])
for i in range(n2):
R.append(A[mid + i])
L.append(MAX)
R.append(MAX)
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
cnt += 1
return cnt
def mergeSort(A, left, right, cnt):
if left + 1 < right:
mid = int((left + right) / 2)
cnt = mergeSort(A, left, mid, cnt)
cnt = mergeSort(A, mid, right, cnt)
cnt = merge(A, left, mid, right, cnt)
return cnt
def main():
""" ????????? """
n = int(input())
S = list(map(int,input().split()))
cnt = mergeSort(S, 0, n, 0)
print(" ".join(map(str,S)))
print(cnt)
if __name__ == '__main__':
main() |
s862257661 | p02272 | u782850499 | 1504188860 | Python | Python3 | py | Runtime Error | 0 | 0 | 643 | def merge(A,left,mid,right):
global cnt
L = A[left:mid]
R = A[mid:right]
L.append(float("inf"))
R.append(float("inf"))
i = 0
j = 0
for k in range(left, right):
cnt += 1
if L[i] <=R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergeSort(A,left,right):
if left+1 < right:
mid = (left+right) // 2
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n = input()
S = list(map(int,input(),split()))
cnt=0
mergeSort(S,0,n)
print(" ".join(map(str,S)))
print(cnt) |
s343468560 | p02272 | u626266743 | 1510663972 | Python | Python3 | py | Runtime Error | 0 | 0 | 749 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9
count = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid]
R = A[mid:right]
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = r[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
mergeSort(A, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A, 0, n)
print(*A)
print(count) |
s905894462 | p02272 | u626266743 | 1510663994 | Python | Python3 | py | Runtime Error | 0 | 0 | 753 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid]
R = A[mid:right]
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = r[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
mergeSort(A, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A, 0, n)
print(*A)
print(count) |
s116297941 | p02272 | u626266743 | 1510664068 | Python | Python3 | py | Runtime Error | 0 | 0 | 778 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid]
R = A[mid:right]
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = r[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
mergeSort(A, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
mergeSort(A, 0, n)
print(" ".join(list(map(str, A))))
print(count) |
s314388912 | p02272 | u626266743 | 1510664221 | Python | Python3 | py | Runtime Error | 0 | 0 | 779 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
n1 = mid - left
n2 = right - mid
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
for i in range(n1):
L[i] = S[left + i]
for i in range(n2):
R[i] = S[mid + i]
L[n1] = r[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s927851958 | p02272 | u626266743 | 1510664627 | Python | Python3 | py | Runtime Error | 0 | 0 | 712 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
n1 = mid - left
n2 = right - mid
for i in range(n1):
L[i] = S[left + i]
for i in range(n2):
R[i] = S[mid + i]
L[n1] = r[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s951283950 | p02272 | u626266743 | 1510664670 | Python | Python3 | py | Runtime Error | 0 | 0 | 712 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
n1 = mid - left
n2 = right - mid
for i in range(n1):
L[i] = S[left + i]
for i in range(n2):
R[i] = S[mid + i]
L[n1] = R[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s329130552 | p02272 | u626266743 | 1510664781 | Python | Python3 | py | Runtime Error | 0 | 0 | 712 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
n1 = mid - left
n2 = right - mid
for i in range(n1):
L[i] = S[left + i]
for i in range(n2):
R[i] = S[mid + i]
L[n1] = R[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s724146432 | p02272 | u626266743 | 1510664845 | Python | Python3 | py | Runtime Error | 0 | 0 | 779 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
n1 = mid - left
n2 = right - mid
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
for i in range(n1):
L[i] = S[left + i]
for i in range(n2):
R[i] = S[mid + i]
L[n1] = R[n2] = SENTINEL
i = j = 0
for k in range(left, right):
count += 1
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s716382173 | p02272 | u626266743 | 1510665004 | Python | Python3 | py | Runtime Error | 0 | 0 | 615 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
i = j = 0
for k in range(left, right):
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
count += right - left
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s564770502 | p02272 | u626266743 | 1510665084 | Python | Python3 | py | Runtime Error | 0 | 0 | 632 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
i = j = 0
global count
for k in range(left, right):
if(L[i] <= R[i]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
count += right - left
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s129856640 | p02272 | u626266743 | 1510665211 | Python | Python3 | py | Runtime Error | 0 | 0 | 616 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
i = j = 0
for k in range(left, right):
if (L[i] <= R[j]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
count += right - left
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s230650361 | p02272 | u626266743 | 1510665237 | Python | Python3 | py | Runtime Error | 0 | 0 | 633 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
i = j = 0
global count
for k in range(left, right):
if (L[i] <= R[j]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
count += right - left
mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s500756185 | p02272 | u626266743 | 1510665282 | Python | Python3 | py | Runtime Error | 0 | 0 | 620 | n = int(input())
S = list(map(int, input().split()))
SENTINEL = 10 ** 9 + 1
count = 0
def merge(S, left, mid, right):
L = S[left:mid] + [SENTINEL]
R = S[mid:right] + [SENTINEL]
i = j = 0
for k in range(left, right):
if (L[i] <= R[j]):
S[k] = L[i]
i += 1
else:
S[k] = R[j]
j += 1
count += right - left
def mergeSort(S, left, right):
if(left + 1 < right):
mid = (left + right) // 2
mergeSort(S, left, mid)
mergeSort(S, mid, right)
merge(S, left, mid, right)
mergeSort(S, 0, n)
print(*S)
print(count) |
s654066172 | p02272 | u424457654 | 1510674084 | Python | Python3 | py | Runtime Error | 0 | 0 | 591 | count = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [float('inf')]
R = A[mid:right] + [float('inf')]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
mergeSort(A, 0, N)
print(*A)
print(count)
|
s376416338 | p02272 | u424457654 | 1510674173 | Python | Python3 | py | Runtime Error | 0 | 0 | 591 | def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [float('inf')]
R = A[mid:right] + [float('inf')]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s776531452 | p02272 | u424457654 | 1510674234 | Python | Python3 | py | Runtime Error | 0 | 0 | 606 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [float('inf')]
R = A[mid:right] + [float('inf')]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s530808179 | p02272 | u424457654 | 1510674320 | Python | Python3 | py | Runtime Error | 0 | 0 | 592 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [10**9]
R = A[mid:right] + [10**9]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s417540984 | p02272 | u424457654 | 1510674357 | Python | Python3 | py | Runtime Error | 0 | 0 | 600 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [10**9 + 1]
R = A[mid:right] + [10**9 + 1]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s861891532 | p02272 | u424457654 | 1510674533 | Python | Python3 | py | Runtime Error | 0 | 0 | 600 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [10**9 + 1]
R = A[mid:right] + [10**9 + 1]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s122491029 | p02272 | u424457654 | 1510674564 | Python | Python3 | py | Runtime Error | 0 | 0 | 563 | def merge(A, left, mid, right):
global count
L = A[left:mid] + [10**9 + 1]
R = A[mid:right] + [10**9 + 1]
i = 0
j = 0
for k in range(left, right):
if L[i] <= R[i]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count += right - left
def mergeSort(A, left, right):
if left + 1 < right:
mid = (left + right) // 2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
N = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, N)
print(*A)
print(count)
|
s555634863 | p02272 | u565114097 | 1512956659 | Python | Python3 | py | Runtime Error | 0 | 0 | 651 | def merge(left, right):
?? ?? if len(left) == 0:
?? ?? ?? ?? return right
?? ?? elif len(right) == 0:
?? ?? ?? ?? return left
?? ?? elif left[0] < right[0]:
?? ?? ?? ?? return [left[0]] + merge(left[1:],right)
?? ?? else:
?? ?? ?? ?? return [right[0]] + merge(left,right[1:])
def merge_sort(sub):
?? ?? n = len(sub)
?? ?? if n == 1:
?? ?? ?? ?? return sub[0]
?? ?? for i in range(int(n/2)):
?? ?? ?? ?? sub[i] = merge(sub[i], sub[i+1])
?? ?? ?? ?? sub.pop(i+1)
?? ?? return merge_sort(sub)
n = input()
inp = input()
while inp != '':
?? ?? l = inp
l = list(l.split(' '))
sub = []
for i in range(int(n)):
?? ?? sub.append([int(l[i])])
merge_sort(sub) |
s579934260 | p02272 | u150984829 | 1518703769 | Python | Python3 | py | Runtime Error | 0 | 0 | 251 | def m(L,R):
T=[]
for l in L[::-1]:
while R and R[-1]>l:T+=[R.pop()]
T+=[l]
return R+T[::-1]
def d(A):
l=len(A);global c;c+=l
s=l//2;return m(d(A[:s]),d(A[s:]))if l>1 else A
c=-int(input())
print(*d(list(map(int,input().split()))))
print(c-n)
|
s802056055 | p02272 | u150984829 | 1520049924 | Python | Python3 | py | Runtime Error | 0 | 0 | 288 | def m(L,R):
T=[]
for l in L[::-1]:
while R and R[-1]>l:T+=[R.pop()]
T+=[l]
return R+T[::-1]
def d(A):
l=len(A);global c;c+=l
s=l//2;return m(d(A[:s]),d(A[s:]))if l>1 else A
def s():
c=-int(input())
print(*d(list(map(int,input().split()))))
print(c)
if'__main__'==__name__:s()
|
s600461503 | p02272 | u138546245 | 1524010504 | Python | Python3 | py | Runtime Error | 0 | 0 | 1158 | def merge_sort(alist):
"""Sort alist using mergesort.
Returns a tuple of the number of comparisons and sorted list.
>>> merge_sort([8, 5, 9, 2, 6, 3, 7, 1, 10, 4])
(34, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
"""
def _sort(left, right):
count = 0
if left + 1 < right:
mid = (left + right) // 2
count += _sort(left, mid)
count += _sort(mid, right)
count += merge(left, mid, right)
return count
def merge(left, mid, right):
count = 0
ll = alist[left:mid] + [SENTINEL]
rl = alist[mid:right] + [SENTINEL]
i = j = 0
for k in range(left, right):
count += 1
if ll[i] <= rl[j]:
alist[k] = ll[i]
i += 1
else:
alist[k] = rl[j]
j += 1
return count
comp = _sort(0, len(alist))
return (comp, alist)
def run():
_ = int(input()) # flake8: noqa
li = [int(i) for i in input().split()]
(c, s) = merge_sort(li)
print(" ".join([str(i) for i in s]))
print(c)
if __name__ == '__main__':
run()
|
s636499142 | p02272 | u255317651 | 1525348384 | Python | Python3 | py | Runtime Error | 0 | 0 | 899 | # -*- coding: utf-8 -*-
"""
Created on Thu May 3 19:22:34 2018
ALDS-1-5-C
@author: maezawa
"""
cnt = 0
n = int(input())
a = list(map(int, input().split()))
def merge_sort(a, left, right):
#global cnt
#cnt += 1
if left+1 < right:
mid = (left+right)//2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
def merge(a, left, mid, right):
global cnt
n1 = mid - left
n2 = right - mid
l = a[left:n1]
r = a[mid:n2]
l.append(10**10)
r.append(10**10)
i = 0
j = 0
for k in range(left, right):
cnt += 1
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else:
a[k] = r[j]
j += 1
merge_sort(a, 0, len(a))
print(a[0], end='')
for i in range(1,len(a)):
print(' {}'.format(a[i]), end='')
print()
print(cnt)
|
s319887246 | p02272 | u196653484 | 1526800794 | Python | Python3 | py | Runtime Error | 2270 | 27332 | 937 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1+1)]
R=[i for i in range(n2+1)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L[n1] = 1000000
R[n2] = 1000000
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
count+=1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
for i,j in enumerate(A):
if i == n-1:
print(j)
else:
print(j,end=" ")
print(count)
|
s814937486 | p02272 | u196653484 | 1526800846 | Python | Python3 | py | Runtime Error | 2330 | 27328 | 941 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1+1)]
R=[i for i in range(n2+1)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L[n1] = 100000000
R[n2] = 100000000
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
count+=1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
for i,j in enumerate(A):
if i == n-1:
print(j)
else:
print(j,end=" ")
print(count)
|
s489067767 | p02272 | u196653484 | 1526801028 | Python | Python3 | py | Runtime Error | 2270 | 27324 | 941 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1+1)]
R=[i for i in range(n2+1)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L[n1] = 100000000
R[n2] = 100000000
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
count+=1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
for i,j in enumerate(A):
if i == n-1:
print(j)
else:
print(j,end=" ")
print(count)
|
s225623940 | p02272 | u196653484 | 1526801193 | Python | Python3 | py | Runtime Error | 1070 | 16212 | 935 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1+1)]
R=[i for i in range(n2+1)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L[n1] = 100000
R[n2] = 100000
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
count+=1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
for i,j in enumerate(A):
if i == n-1:
print(j)
else:
print(j,end=" ")
print(count)
|
s946876006 | p02272 | u196653484 | 1526801225 | Python | Python3 | py | Runtime Error | 2300 | 27324 | 941 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1+1)]
R=[i for i in range(n2+1)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L[n1] = 100000000
R[n2] = 100000000
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
count+=1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
for i,j in enumerate(A):
if i == n-1:
print(j)
else:
print(j,end=" ")
print(count)
|
s158043747 | p02272 | u196653484 | 1526801603 | Python | Python3 | py | Runtime Error | 2190 | 27328 | 816 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
L=[i for i in range(n1)]
R=[i for i in range(n2)]
for i in range(n1):
L[i] = A[left+i]
for i in range(n2):
R[i] = A[mid+i]
L.append(100000001)
R.append(100000001)
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s870697682 | p02272 | u196653484 | 1526801877 | Python | Python3 | py | Runtime Error | 2010 | 27320 | 782 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
R=[]
L=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+i])
L.append(100000001)
R.append(100000001)
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s220317718 | p02272 | u196653484 | 1526801898 | Python | Python3 | py | Runtime Error | 2000 | 27316 | 780 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
R=[]
L=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+i])
L.append(10000001)
R.append(10000001)
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s786260502 | p02272 | u196653484 | 1526801987 | Python | Python3 | py | Runtime Error | 2030 | 27316 | 776 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
R=[]
L=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+i])
L.append(100000001)
R.append(100000001)
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s583577983 | p02272 | u196653484 | 1526802002 | Python | Python3 | py | Runtime Error | 2140 | 27320 | 776 | count=0
def merge(A, left, mid, right):
global count
n1=mid - left
n2=right - mid
R=[]
L=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+i])
L.append(100000001)
R.append(100000001)
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s171323404 | p02272 | u196653484 | 1526802308 | Python | Python3 | py | Runtime Error | 1460 | 27312 | 630 | count=0
def merge(A, left, mid, right):
global count
L=A[left:mid]+[100000000]
R=A[mid:right]+[10000000]
i=0
j=0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
count+=1
def merge_sort(A, left, right):
if left+1 < right:
mid=(left+right)//2
merge_sort(A, left, mid)
merge_sort(A, mid, right)
merge(A, left, mid, right)
if __name__ == "__main__":
n=int(input())
A=list(map(int,input().split()))
merge_sort(A,0,n)
print(*A)
print(count)
|
s846361336 | p02272 | u361028487 | 1526821728 | Python | Python3 | py | Runtime Error | 0 | 0 | 920 | #include<iostream>
using namespace std;
#define INFTY 2000000000
int count=0;
void merge(int A[],int left,int mid,int right){
int n1=mid-left;
int n2=right-mid;
int *L=new int[n1+1];
int *R=new int[n2+1];
for(int i=0;i<n1;i++){
L[i]=A[left+i];
}
for(int i=0;i<n2;i++){
R[i]=A[mid+i];
}
L[n1]=INFTY;
R[n2]=INFTY;
int i=0;
int j=0;
for(int k=left;k<right;k++){
if(L[i]<=R[j]){
A[k]=L[i];
i++;
}else{
A[k]=R[j];
j++;
}
count++;
}
delete[] L;
delete[] R;
}
void mergeSort(int A[],int left,int right){
if(left+1>=right)
return;
int mid=(left+right)/2;
mergeSort(A,left,mid);
mergeSort(A,mid,right);
merge(A,left,mid,right);
}
int main(){
int n;
cin>>n;
int A[10];
for(int i=0;i<n;i++){
cin>>A[i];
}
mergeSort(A,0,n);
for(int i=0;i<n-1;i++){
cout<<A[i]<<' ';
}
cout<<A[n-1]<<endl;
cout<<count<<endl;
}
|
s262576007 | p02272 | u564105430 | 1527064401 | Python | Python3 | py | Runtime Error | 0 | 0 | 831 | global cnt
cnt=0
def merge(A,left,mid,right):
global cnt
n1=mid-left
n2=right-mid
#L=[0 for i in range(n1+1)]
#R=[0 for i in range(n2+1)]
L=[]
R=[]
for i in range(max(n1,n2)):
if i<n1:
L.append(A[left+i])
if i<n2:
R.append(A[mid+j])
L.append(float("inf"))
R.append(float("inf"))
i=0
j=0
for k in range(left,right):
if L[i]<=R[j]:
A[k]=L[i]
i=i+1
cnt+=1
else:
A[k]=R[j]
j=j+1
cnt+=1
def mergeSort(A,left,right):
if left+1<right:
mid=(int)((left+right)/2)
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n=int(input())
S=list(map(int,input().split()))
mergeSort(S,0,n)
print(*S)
print(cnt)
|
s887875750 | p02272 | u564105430 | 1527064549 | Python | Python3 | py | Runtime Error | 0 | 0 | 813 | global cnt
cnt=0
def merge(A,left,mid,right):
global cnt
n1=mid-left
n2=right-mid
#L=[0 for i in range(n1+1)]
#R=[0 for i in range(n2+1)]
L=[]
R=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+j])
L.append(float("inf"))
R.append(float("inf"))
i=0
j=0
for k in range(left,right):
if L[i]<=R[j]:
A[k]=L[i]
i=i+1
cnt+=1
else:
A[k]=R[j]
j=j+1
cnt+=1
def mergeSort(A,left,right):
if left+1<right:
mid=(int)((left+right)/2)
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n=int(input())
S=list(map(int,input().split()))
mergeSort(S,0,n)
print(*S)
print(cnt)
|
s879937473 | p02272 | u564105430 | 1527064582 | Python | Python3 | py | Runtime Error | 0 | 0 | 806 | global cnt
cnt=0
def merge(A,left,mid,right):
global cnt
n1=mid-left
n2=right-mid
#L=[0 for i in range(n1+1)]
#R=[0 for i in range(n2+1)]
L=[]
R=[]
for i in range(n1):
L.append(A[left+i])
for i in range(n2):
R.append(A[mid+j])
L.append(float("inf"))
R.append(float("inf"))
i=0
j=0
for k in range(left,right):
if L[i]<=R[j]:
A[k]=L[i]
i=i+1
cnt+=1
else:
A[k]=R[j]
j=j+1
cnt+=1
def mergeSort(A,left,right):
if left+1<right:
mid=(int)((left+right)/2)
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n=int(input())
S=list(map(int,input().split()))
mergeSort(S,0,n)
print(*S)
print(cnt)
|
s839685596 | p02272 | u564105430 | 1527066225 | Python | Python3 | py | Runtime Error | 0 | 0 | 737 | def merge(A,left,mid,right):
global cnt
n1=mid-left
n2=right-mid
L=[]
R=[]
for i in range(n1):
L.append(A[left+i])
for j in range(n2):
R.append(A[mid+j])
L.append=float("inf")
R.append=float("inf")
i=0
j=0
for k in range(left,right):
if L[i]<=R[j]:
A[k]=L[i]
i=i+1
cnt[0]+=1
else:
A[k]=R[j]
j=j+1
cnt[0]+=1
def mergeSort(A,left,right):
if left+1<right:
mid=(int)((left+right)/2)
mergeSort(A,left,mid)
mergeSort(A,mid,right)
merge(A,left,mid,right)
n=int(input())
S=list(map(int,input().split()))
cnt=[0]
mergeSort(S,0,n)
print(*S)
print(cnt[0])
|
s662283730 | p02272 | u609614788 | 1527145494 | Python | Python3 | py | Runtime Error | 0 | 0 | 756 | #include <iostream>
#include <sstream>
void merge(int A[],int left,int mid,int right){
int n1,n2;
n1=mid-left;
n2=right-mid;
int L[n1]={0};
int R[n2]={0};
for(int i=0;i<n1;i++){
L[i]=A[left+i];
}
for(int i=0;i<n2;i++){
R[i]=A[mid+i];
}
i=0; j=0;
for(int k=left;k<right;k++){
if(L[i]<=R[j]){
A[k]=L[i];
i++;
}else{
A[k]=R[j];
j++;
}
}
}
void mergeSort(int A[],int left,int right){
int mid;
if(left+1<right){
mid=(int)(left+right)/2;
mergeSort(A,left,mid);
mergeSort(A,mid,right);
merge(A,left,mid,right);
}
}
int main(){
int n;
std::cin>>n;
int A[n];
for(int i=0;i<n;i++){
std::cin>>A[i];
}
int left=0;
int right=n-1;
mergeSort(A,left,right);
}
|
s616719611 | p02272 | u938045879 | 1527312686 | Python | Python3 | py | Runtime Error | 1980 | 27428 | 790 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(a[left + i])
for j in range(n2):
R.append(a[mid + j])
L.append(500001)
R.append(500001)
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
print(" ".join([str(i) for i in a]))
print(counter)
|
s075257350 | p02272 | u938045879 | 1527312783 | Python | Python3 | py | Runtime Error | 1950 | 27420 | 790 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(a[left + i])
for j in range(n2):
R.append(a[mid + j])
L.append(500001)
R.append(500001)
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
print(" ".join([str(i) for i in a]))
print(counter)
|
s348264432 | p02272 | u938045879 | 1527313080 | Python | Python3 | py | Runtime Error | 2080 | 27420 | 790 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(a[left + i])
for j in range(n2):
R.append(a[mid + j])
L.append(500001)
R.append(500001)
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
print(" ".join([str(i) for i in a]))
print(counter)
|
s942222004 | p02272 | u938045879 | 1527323694 | Python | Python3 | py | Runtime Error | 1950 | 27424 | 790 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(a[left + i])
for j in range(n2):
R.append(a[mid + j])
L.append(500001)
R.append(500001)
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
print(" ".join([str(i) for i in a]))
print(counter)
|
s037850159 | p02272 | u938045879 | 1527323890 | Python | Python3 | py | Runtime Error | 1980 | 27316 | 801 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
n1 = mid - left
n2 = right - mid
L = []
R = []
for i in range(n1):
L.append(a[left + i])
for j in range(n2):
R.append(a[mid + j])
L.append(500001)
R.append(500001)
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
#print(" ".join([str(i) for i in a]))
print(*a)
print(counter)
|
s616917463 | p02272 | u938045879 | 1527323985 | Python | Python3 | py | Runtime Error | 1440 | 27312 | 674 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
L = []
R = []
L = a[left:mid] + [500001]
R = a[mid:right] + [500001]
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
#print(" ".join([str(i) for i in a]))
print(*a)
print(counter)
|
s852296383 | p02272 | u938045879 | 1527324080 | Python | Python3 | py | Runtime Error | 1390 | 27316 | 652 | n = int(input())
a = list(map(int, input().split(' ')))
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [500001]
R = a[mid:right] + [500001]
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if(left+1 < right):
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
#print(" ".join([str(i) for i in a]))
print(*a)
print(counter)
|
s885479863 | p02272 | u938045879 | 1527324183 | Python | Python3 | py | Runtime Error | 1430 | 27308 | 610 | n = int(input())
a = list(map(int, input().split()))
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [500001]
R = a[mid:right] + [500001]
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if left+1 < right:
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
mergeSort(a, 0, n)
print(*a)
print(counter)
|
s373433630 | p02272 | u938045879 | 1527324276 | Python | Python3 | py | Runtime Error | 1420 | 27316 | 618 | SEN = 500001
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [SEN]
R = a[mid:right] + [SEN]
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if left+1 < right:
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
n = int(input())
a = list(map(int, input().split()))
mergeSort(a, 0, n)
print(*a)
print(counter)
|
s907531908 | p02272 | u938045879 | 1527324591 | Python | Python3 | py | Runtime Error | 1440 | 27376 | 640 | import math
SEN = 500001
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [SEN]
R = a[mid:right] + [SEN]
i=0
j=0
for k in range(left, right):
counter += 1
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def mergeSort(a, left, right):
if left+1 < right:
mid = math.ceil((left + right) / 2)
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
n = int(input())
a = list(map(int, input().split()))
mergeSort(a, 0, n)
print(*a)
print(counter)
|
s662286283 | p02272 | u938045879 | 1527324814 | Python | Python3 | py | Runtime Error | 0 | 0 | 640 | import math
sentinel = 1e9 + 1
counter = 0
def merge(a, left, mid, right):
global counter
L = a[left:mid] + [SEN]
R = a[mid:right] + [SEN]
i,j = 0,0
for k in range(left, right):
if(L[i] <= R[j]):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
counter += right - left
def mergeSort(a, left, right):
if left+1 < right:
mid = (left + right) // 2
mergeSort(a, left, mid)
mergeSort(a, mid, right)
merge(a, left, mid, right)
n = int(input())
a = list(map(int, input().split()))
mergeSort(a, 0, n)
print(*a)
print(counter)
|
s070454618 | p02272 | u055885332 | 1527568136 | Python | Python3 | py | Runtime Error | 0 | 0 | 630 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L=[]
R=[]
for i in range(n1-1):
L[i] = append(A[left + i])
for i in range(n2-1):
R[i] =append(A[mid + i])
L[n1] = 10e10
R[n2] = 10e10
i = 0
j = 0
for k in range(left , right-1):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, len(A))
print(*A)
print(count)
|
s696643566 | p02272 | u055885332 | 1527568141 | Python | Python3 | py | Runtime Error | 0 | 0 | 630 | def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L=[]
R=[]
for i in range(n1-1):
L[i] = append(A[left + i])
for i in range(n2-1):
R[i] =append(A[mid + i])
L[n1] = 10e10
R[n2] = 10e10
i = 0
j = 0
for k in range(left , right-1):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, len(A))
print(*A)
print(count)
|
s693823611 | p02272 | u165447384 | 1527580666 | Python | Python3 | py | Runtime Error | 0 | 0 | 663 | merge(A, left, mid, right)
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
mergeSort(A, left, right)
if left+1 < right
mid = (left + right)//2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
### Main Function
n = int(input())
S = list(map(int,input().split()))
c = 0
mergeSort(S, 0, n)
print(S)
print(c)
|
s104604661 | p02272 | u165447384 | 1527580759 | Python | Python3 | py | Runtime Error | 0 | 0 | 736 | def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right
mid = (left + right)//2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
### Main Function
n = int(input())
S = list(map(int,input().split()))
c = 0
mergeSort(S, 0, n)
print(S)
print(c)
|
s859852010 | p02272 | u165447384 | 1527580862 | Python | Python3 | py | Runtime Error | 0 | 0 | 777 | def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
c = c+1
A[k] = L[i]
i = i + 1
else:
c = c+1
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
### Main Function
n = int(input())
S = list(map(int,input().split()))
c = 0
mergeSort(S, 0, n)
print(S)
print(c)
|
s600522229 | p02272 | u165447384 | 1527580894 | Python | Python3 | py | Runtime Error | 0 | 0 | 779 | c = 0
def merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
c = c+1
A[k] = L[i]
i = i + 1
else:
c = c+1
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2;
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
### Main Function
n = int(input())
S = list(map(int,input().split()))
mergeSort(S, 0, n)
print(S)
print(c)
|
s578368789 | p02272 | u165447384 | 1527580965 | Python | Python3 | py | Runtime Error | 0 | 0 | 790 | def merge(A, left, mid, right, c):
n1 = mid - left
n2 = right - mid
L = [0]*(n1+1)
R = [0]*(n2+1)
for i in range(n1):
L[i] = A[left + i]
for i in range(n2):
R[i] = A[mid + i]
L[n1] = float("inf")
R[n2] = float("inf")
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
c = c+1
A[k] = L[i]
i = i + 1
else:
c = c+1
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right, c):
if left+1 < right:
mid = (left + right)//2;
mergeSort(A, left, mid, c)
mergeSort(A, mid, right, c)
merge(A, left, mid, right, c)
### Main Function
n = int(input())
S = list(map(int,input().split()))
mergeSort(S, 0, n, c)
print(S)
print(c)
|
s714494695 | p02272 | u564464686 | 1527589243 | Python | Python3 | py | Runtime Error | 0 | 0 | 607 | def merge(left, right,cnt):
merged = []
i,j = 0, 0
while i < len(left) and j < len(right):
cnt.append(1)
if left[i] <= right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
if i < len(left):
merged.extend(left[i:])
if j < len(right):
merged.extend(right[j:])
return merged
n=int(input())
A=[0 for i in range(n)]
A=input().split()
cnt=[]
for i in range(n):
A[i]=int(A[i])
left=0
right=n
A=merge_sort(A,cnt)
for i in range(n):
print(A[i],end="")
print(len(cnt)+1)
|
s192738723 | p02272 | u564464686 | 1527589720 | Python | Python3 | py | Runtime Error | 0 | 0 | 1723 | def merge_sort(A,cnt):
if len(A) <= 1:
return A
mid = len(A) // 2
left = A[:mid]
cnt.append(1)
right = A[mid:]
left = merge_sort(left,cnt)
right = merge_sort(right,cnt)
return merge(left,right,cnt)
def merge(left, right,cnt):
merged = []
i,j = 0, 0
while i < len(left) and j < len(right):
cnt.append(1)
if left[i] <= right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
if i < len(left):
merged.extend(left[i:])
if j < len(right):
merged.extend(right[j:])def merge_sort(A,cnt):
if len(A) <= 1:
return A
mid = len(A) // 2
left = A[:mid]
cnt.append(1)
right = A[mid:]
left = merge_sort(left,cnt)
right = merge_sort(right,cnt)
return merge(left,right,cnt)
def merge(left, right,cnt):
merged = []
i,j = 0, 0
while i < len(left) and j < len(right):
cnt.append(1)
if left[i] <= right[j]:
merged.append(left[i])
i += 1
else:
merged.append(right[j])
j += 1
if i < len(left):
merged.extend(left[i:])
if j < len(right):
merged.extend(right[j:])
return merged
n=int(input())
A=[0 for i in range(n)]
A=input().split()
cnt=[]
for i in range(n):
A[i]=int(A[i])
left=0
right=n
A=merge_sort(A,cnt)
for i in range(n):
print(A[i],"",end="")
print(" ")
c=len(cnt)+1
print(c)
return merged
n=int(input())
A=[0 for i in range(n)]
A=input().split()
cnt=[]
for i in range(n):
A[i]=int(A[i])
left=0
right=n
A=merge_sort(A,cnt)
for i in range(n):
print(A[i],"",end="")
print(" ")
c=len(cnt)+1
print(c)
|
s509041782 | p02272 | u573915636 | 1527607094 | Python | Python3 | py | Runtime Error | 0 | 0 | 568 | def merge(s,left,mid,right):
n1=mid-left
n2=right-mid
l[n1]={}
r[n2]={}
for i in range(n1-1):
l[i]=s[left+1]
for j in range(n2-1):
r[i]=s[mid+1]
l[n1]=10000000
r[n2]=10000000
m=0
n=0
for k in range(left,right-1):
c=c+1
if l[m]<=r[m]:
s[k]=l[m]
m=m+1
else:
s[k]=r[n]
n=n+1
def mergesort(s,left,right):
if left+1<right
mid=(left+right)/2
mergesort(s,left,mid)
mergesort(s,mid,right)
merge(s,left,mid,right)
n=int(input())
s=input().split()
for a in range(n):
s[a]=int(s[a])
c=0
mergesort(s,s[0],s[n])
l=' '.join(s)
print(l)
|
s177735699 | p02272 | u573915636 | 1527607104 | Python | Python3 | py | Runtime Error | 0 | 0 | 568 | def merge(s,left,mid,right):
n1=mid-left
n2=right-mid
l[n1]={}
r[n2]={}
for i in range(n1-1):
l[i]=s[left+1]
for j in range(n2-1):
r[i]=s[mid+1]
l[n1]=10000000
r[n2]=10000000
m=0
n=0
for k in range(left,right-1):
c=c+1
if l[m]<=r[m]:
s[k]=l[m]
m=m+1
else:
s[k]=r[n]
n=n+1
def mergesort(s,left,right):
if left+1<right
mid=(left+right)/2
mergesort(s,left,mid)
mergesort(s,mid,right)
merge(s,left,mid,right)
n=int(input())
s=input().split()
for a in range(n):
s[a]=int(s[a])
c=0
mergesort(s,s[0],s[n])
l=' '.join(s)
print(l)
|
s376648729 | p02272 | u308770067 | 1527626279 | Python | Python3 | py | Runtime Error | 0 | 0 | 1014 | #include<iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int count=0;
void merge(int a[],int left,int mid,int right){
int n1=mid-left,n2=right-mid;
int l[n1+1],r[n2+1];
for(int i=0;i<n1;i++){
l[i]=a[left+i];
}
for(int i=0;i<n2;i++) {
r[i]=a[mid+i];
}
l[n1]=10000000;
r[n2]=10000000;
int i=0,j=0;
for(int k=left;k<right;k++){
count++;
if(l[i]<=r[j]){
a[k]=l[i];
i++;
}
else{
a[k]=r[j];
j++;
}
}
}
void mergesort(int a[],int left,int right){
if(left+1<right){
int mid=(left+right)/2;
mergesort(a,left,mid);
mergesort(a,mid,right);
merge(a,left,mid,right);
}
}
int main(){
int n;
cin>>n;
int data[n];
for(int i=0;i<n;i++){
cin>>data[i];
}
mergesort(data,0,n);
printf("%d",data[0]);
for(int i=1;i<n;i++){
printf(" %d",data[i]);
}
printf("\n%d\n",count);
return 0;
}
|
s367773514 | p02272 | u308770067 | 1527626311 | Python | Python3 | py | Runtime Error | 0 | 0 | 1014 | #include<iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int count=0;
void merge(int a[],int left,int mid,int right){
int n1=mid-left,n2=right-mid;
int l[n1+1],r[n2+1];
for(int i=0;i<n1;i++){
l[i]=a[left+i];
}
for(int i=0;i<n2;i++) {
r[i]=a[mid+i];
}
l[n1]=10000000;
r[n2]=10000000;
int i=0,j=0;
for(int k=left;k<right;k++){
count++;
if(l[i]<=r[j]){
a[k]=l[i];
i++;
}
else{
a[k]=r[j];
j++;
}
}
}
void mergesort(int a[],int left,int right){
if(left+1<right){
int mid=(left+right)/2;
mergesort(a,left,mid);
mergesort(a,mid,right);
merge(a,left,mid,right);
}
}
int main(){
int n;
cin>>n;
int data[n];
for(int i=0;i<n;i++){
cin>>data[i];
}
mergesort(data,0,n);
printf("%d",data[0]);
for(int i=1;i<n;i++){
printf(" %d",data[i]);
}
printf("\n%d\n",count);
return 0;
}
|
s952805380 | p02272 | u810098703 | 1527659224 | Python | Python | py | Runtime Error | 0 | 0 | 928 |
#include<iostream>
#define MAX 10000
using namespace std;
int l[MAX / 2 + 2], r[MAX / 2 + 2];
int cnt_sum;
void merge(int a[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
l[i] = a[left + i];
}
l[n1] = MAX;
for (int i = 0; i < n2; i++) {
r[i] = a[mid + i];
}
r[n2] = MAX;
int p = 0, q = 0;
for (int i = left; i < right; i++) {
cnt_sum++;
if (l[p] < r[q]) {
a[i] = l[p++];
}
else {
a[i] = r[q++];
}
}
}
void mergeSort(int a[], int left, int right) {
if (left + 1 == right) return;
int mid = (left + right) / 2;
mergeSort(a, left, mid);
mergeSort(a, mid, right);
merge(a, left, mid, right);
}
int main(void) {
int n;
int s[50000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
mergeSort(s, 0, n);
for (int i = 0; i < n; i++) {
cout << s[i] << " ";
}
cout << endl;
cout << cnt_sum ;
return 0;
}
|
s381211440 | p02272 | u007270338 | 1528044265 | Python | Python3 | py | Runtime Error | 2010 | 27424 | 851 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i, j = 0, 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
global cnt
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
if (left + right) % 2 == 0:
mid = int((left + right)/2)
else:
mid = int((left + right -1)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s882053466 | p02272 | u007270338 | 1528044400 | Python | Python3 | py | Runtime Error | 1980 | 27428 | 847 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i, j = 0, 0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
if (left + right) % 2 == 0:
mid = int((left + right)/2)
else:
mid = int((left + right -1)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s784487643 | p02272 | u007270338 | 1528044508 | Python | Python3 | py | Runtime Error | 1920 | 27424 | 750 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i, j = 0, 0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s434581044 | p02272 | u007270338 | 1528044598 | Python | Python3 | py | Runtime Error | 1970 | 27424 | 754 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i = 0
j = 0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s938632894 | p02272 | u007270338 | 1528044817 | Python | Python3 | py | Runtime Error | 1940 | 27420 | 748 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s631344283 | p02272 | u007270338 | 1528044894 | Python | Python3 | py | Runtime Error | 1960 | 27428 | 720 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
L = [A[left + i] for i in range(mid-left)]
R = [A[mid + i] for i in range(right-mid)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s435834961 | p02272 | u007270338 | 1528045088 | Python | Python3 | py | Runtime Error | 2140 | 27428 | 784 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [None]*n1
for i in range(n1):
L[i] = A[left + i]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s351105371 | p02272 | u007270338 | 1528045196 | Python | Python3 | py | Runtime Error | 0 | 0 | 758 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
if L[i] > R[j]:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s003910919 | p02272 | u007270338 | 1528045215 | Python | Python3 | py | Runtime Error | 2110 | 27428 | 760 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
elif L[i] > R[j]:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = int((left + right)/2)
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s928578375 | p02272 | u007270338 | 1528045654 | Python | Python3 | py | Runtime Error | 1890 | 27424 | 744 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
n1 = mid - left
n2 = right - mid
L = [A[left + i] for i in range(n1)]
R = [A[mid + i] for i in range(n2)]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s202617653 | p02272 | u007270338 | 1528045800 | Python | Python3 | py | Runtime Error | 1410 | 27408 | 664 | #coding:utf-8
n = int(input())
A = list(map(int, input().split()))
def Merge(A, left, mid, right):
L = A[left:mid]
R = A[mid:right]
L.append(510000)
R.append(510000)
i,j = 0,0
global cnt
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
cnt += 1
def MergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
MergeSort(A, left, mid)
MergeSort(A, mid, right)
Merge(A, left, mid, right)
cnt = 0
MergeSort(A, 0, n)
A = " ".join([str(num) for num in A])
print(A)
print(cnt)
|
s024819340 | p02272 | u318430977 | 1528642970 | Python | Python3 | py | Runtime Error | 0 | 0 | 961 | def merge(a, left, mid, right):
INF = int(1e+11)
n1 = mid - left
n2 = right - mid
l = []
for i in range(n1):
l.append(a[left + i])
r = []
for i in range(n2):
r.append(a[mid + i])
l.append(INF)
r.append(INF)
i = 0
j = 0
ans = 0
for k in range(left, right):
ans += 1
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else:
a[k] = r[j]
j += 1
return ans
def merge_sort(a, left, right):
ans = 0
if left + 1 < right:
mid = (left + right) // 2;
ans += merge_sort(a, left, mid)
ans += merge_sort(a, mid, right)
ans += merge(a, left, mid, right)
return ans
def print_list_split_whitespace(s):
for x in s[-1]:
print(x, " ")
print(s[-1])
n = int(input())
s = [int(x) for x in input().split()]
ans = merge_sort(s, 0, len(s))
print_list_split_whitespace(s)
print(ans)
|
s903939317 | p02272 | u559106458 | 1529300418 | Python | Python3 | py | Runtime Error | 0 | 0 | 819 | #coding: UTF-8
#mergeSort
list=[]
list_l=[]
list_r=[]
cnt=0
def mergesort(x):
if len(x)<=1:
return x
mid = len(x)//2
left=x[:mid]
right=x[mid:]
left=mergesort(left)
right=mergesort(right)
return merge(left,right)
def merge(left,right):
merged=[]
l_i, r_i=0, 0
while l_i < len(left) and r_i<len(right):
global cnt
cnt += 1
if left[l_i] <= right[r_i]:
merged.append(left[l_i])
l_i += 1
else:
merged.append(right[r_i])
r_i += 1
if l_i < len(left):
cnt+=1
merged.extend(left[l_i:])
if r_i < len(right):
cnt+=1
merged.extend(right[r_i:])
return merged
n=int(input())
roop=0
while(roop<n):
list.append(int(input()))
roop+=1
for i in list:
print(i)
list = mergesort(list)
roop=0
while(roop<n):
print (str(list[roop])+" ",end="")
roop+=1
cnt+=1
print()
print(cnt)
|
s550619436 | p02272 | u559106458 | 1529300441 | Python | Python3 | py | Runtime Error | 0 | 0 | 819 | #coding: UTF-8
#mergeSort
list=[]
list_l=[]
list_r=[]
cnt=0
def mergesort(x):
if len(x)<=1:
return x
mid = len(x)//2
left=x[:mid]
right=x[mid:]
left=mergesort(left)
right=mergesort(right)
return merge(left,right)
def merge(left,right):
merged=[]
l_i, r_i=0, 0
while l_i < len(left) and r_i<len(right):
global cnt
cnt += 1
if left[l_i] <= right[r_i]:
merged.append(left[l_i])
l_i += 1
else:
merged.append(right[r_i])
r_i += 1
if l_i < len(left):
cnt+=1
merged.extend(left[l_i:])
if r_i < len(right):
cnt+=1
merged.extend(right[r_i:])
return merged
n=int(input())
roop=0
while(roop<n):
list.append(int(input()))
roop+=1
for i in list:
print(i)
list = mergesort(list)
roop=0
while(roop<n):
print (str(list[roop])+" ",end="")
roop+=1
cnt+=1
print()
print(cnt)
|
s439372369 | p02272 | u559106458 | 1529300512 | Python | Python3 | py | Runtime Error | 0 | 0 | 819 | #coding: UTF-8
#mergeSort
list=[]
list_l=[]
list_r=[]
cnt=0
def mergesort(x):
if len(x)<=1:
return x
mid = len(x)//2
left=x[:mid]
right=x[mid:]
left=mergesort(left)
right=mergesort(right)
return merge(left,right)
def merge(left,right):
merged=[]
l_i, r_i=0, 0
while l_i < len(left) and r_i<len(right):
global cnt
cnt += 1
if left[l_i] <= right[r_i]:
merged.append(left[l_i])
l_i += 1
else:
merged.append(right[r_i])
r_i += 1
if l_i < len(left):
cnt+=1
merged.extend(left[l_i:])
if r_i < len(right):
cnt+=1
merged.extend(right[r_i:])
return merged
n=int(input())
roop=0
while(roop<n):
list.append(int(input()))
roop+=1
for i in list:
print(i)
list = mergesort(list)
roop=0
while(roop<n):
print (str(list[roop])+" ",end="")
roop+=1
cnt+=1
print()
print(cnt)
|
s219649157 | p02272 | u559106458 | 1529300570 | Python | Python3 | py | Runtime Error | 0 | 0 | 794 | #coding: UTF-8
#mergeSort
list=[]
list_l=[]
list_r=[]
cnt=0
def mergesort(x):
if len(x)<=1:
return x
mid = len(x)//2
left=x[:mid]
right=x[mid:]
left=mergesort(left)
right=mergesort(right)
return merge(left,right)
def merge(left,right):
merged=[]
l_i, r_i=0, 0
while l_i < len(left) and r_i<len(right):
global cnt
cnt += 1
if left[l_i] <= right[r_i]:
merged.append(left[l_i])
l_i += 1
else:
merged.append(right[r_i])
r_i += 1
if l_i < len(left):
cnt+=1
merged.extend(left[l_i:])
if r_i < len(right):
cnt+=1
merged.extend(right[r_i:])
return merged
n=int(input())
roop=0
while(roop<n):
list.append(int(input()))
roop+=1
list = mergesort(list)
roop=0
while(roop<n):
print (str(list[roop])+" ",end="")
roop+=1
cnt+=1
print()
print(cnt)
|
s904496854 | p02272 | u559106458 | 1529300655 | Python | Python3 | py | Runtime Error | 0 | 0 | 783 | #coding: UTF-8
#mergeSort
list=[]
cnt=0
def mergesort(x):
if len(x)<=1:
return x
mid = len(x)//2
left=x[:mid]
right=x[mid:]
left=mergesort(left)
right=mergesort(right)
return merge(left,right)
def merge(left,right):
merged=[]
l_i, r_i=0, 0
while l_i < len(left) and r_i<len(right):
global cnt
cnt += 1
if left[l_i] <= right[r_i]:
merged.append(left[l_i])
l_i += 1
else:
merged.append(right[r_i])
r_i += 1
if l_i < len(left):
cnt+=1
merged.extend(left[l_i:])
if r_i < len(right):
cnt+=1
merged.extend(right[r_i:])
return merged
n=int(input())
roop=0
while(roop<n):
list.append(int(input()))
roop+=1
list = mergesort(list)
roop=0
while(roop<n):
print (list[roop],end="")
print(" ",end="")
roop+=1
cnt+=1
print()
print(cnt)
|
s567238846 | p02272 | u436634575 | 1400896348 | Python | Python3 | py | Runtime Error | 0 | 0 | 714 | def merge(a, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L = a[left:left + n1] + SENTINEL
R = a[mid:mid + n2] + SENTINEL
i = j = 0
for k in range(left, right):
if L[i] <= R[j]:
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
count += right - left
def merge_sort(a, left, right):
if left + 1 < right:
mid = (left + right) // 2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
SENTINEL = 1000000001
n = int(input())
a = list(map(int, input().strip().split()))
count = 0
merge_sort(a, 0, len(a))
print(' '.join(map(str, a)))
print(count) |
s617705513 | p02273 | u657361950 | 1530862339 | Python | Python3 | py | Runtime Error | 0 | 0 | 2272 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
static class Point {
double x;
double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public String toString() {
return String.format("%.8f %.8f", x, y);
}
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(reader.readLine());
reader.close();
getKochCurve(n, new Point(0, 0), new Point(100, 0));
}
private static void getKochCurve(int n, Point start, Point end) {
System.out.println(start);
getKochCurve(0, n, start, end);
System.out.println(end);
}
private static void getKochCurve(int i, int n, Point start, Point end) {
if (i < n) {
Point firstPoint = getPoint(start, end, 1.0/3.0);
Point thirdPoint = getPoint(start, end, 2.0/3.0);
Point secondPoint = getSecondPoint(start, end, firstPoint, thirdPoint);
getKochCurve(i + 1, n, start, firstPoint);
System.out.println(firstPoint);
getKochCurve(i + 1, n, firstPoint, secondPoint);
System.out.println(secondPoint);
getKochCurve(i + 1, n, secondPoint, thirdPoint);
System.out.println(thirdPoint);
getKochCurve(i + 1, n, thirdPoint, end);
}
}
private static Point getPoint(Point start, Point end, double d) {
double deltaX = end.x - start.x;
double deltaY = end.y - start.y;
deltaX *= d;
deltaY *= d;
return new Point(start.x + deltaX, start.y + deltaY);
}
private static Point getSecondPoint(Point start, Point end, Point second, Point third) {
double deltaX = third.x - second.x;
double deltaY = third.y - second.y;
double len = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
double x;
double y;
if (deltaY == 0) {
x = start.x + (end.x - start.x) / 2;
y = second.y + Math.sqrt((Math.pow(len, 2) - Math.pow(len / 2.0, 2)));
} else if (start.x < end.x && start.y < end.y) {
x = start.x;
y = third.y;
} else if (start.x < end.x && start.y > end.y) {
x = end.x;
y = second.y;
} else if (start.x > end.x && start.y < end.y) {
x = end.x;
y = second.y;
} else {
x = start.x;
y = third.y;
}
return new Point(x, y);
}
}
|
s513003065 | p02273 | u657361950 | 1530868032 | Python | Python3 | py | Runtime Error | 0 | 0 | 2411 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
public class Main {
static class Point {
double x;
double y;
public Point(double x, double y) {
this.x = x;
this.y = y;
}
public String toString() {
return String.format("%.8f %.8f", x, y);
}
}
public static void main(String[] args) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(reader.readLine());
reader.close();
getKochCurve(n, new Point(0, 0), new Point(100, 0));
}
private static void getKochCurve(int n, Point start, Point end) {
System.out.println(start);
getKochCurve(0, n, start, end);
System.out.println(end);
}
private static void getKochCurve(int i, int n, Point start, Point end) {
if (i < n) {
Point firstPoint = getPoint(start, end, 1.0/3.0);
Point thirdPoint = getPoint(start, end, 2.0/3.0);
Point secondPoint = getSecondPoint(start, end, firstPoint, thirdPoint);
getKochCurve(i + 1, n, start, firstPoint);
System.out.println(firstPoint);
getKochCurve(i + 1, n, firstPoint, secondPoint);
System.out.println(secondPoint);
getKochCurve(i + 1, n, secondPoint, thirdPoint);
System.out.println(thirdPoint);
getKochCurve(i + 1, n, thirdPoint, end);
}
}
private static Point getPoint(Point start, Point end, double d) {
double deltaX = end.x - start.x;
double deltaY = end.y - start.y;
deltaX = deltaX * d;
deltaY = deltaY * d;
return new Point(start.x + deltaX, start.y + deltaY);
}
private static Point getSecondPoint(Point start, Point end, Point second, Point third) {
double deltaX = third.x - second.x;
double deltaY = third.y - second.y;
double len = Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2));
double x;
double y;
if (deltaY == 0) {
x = start.x + (end.x - start.x) / 2;
if (start.x < end.x) {
y = second.y + Math.sqrt((Math.pow(len, 2) - Math.pow(len / 2.0, 2)));
} else {
y = second.y - Math.sqrt((Math.pow(len, 2) - Math.pow(len / 2.0, 2)));
}
} else if (start.x < end.x && start.y < end.y) {
x = start.x;
y = third.y;
} else if (start.x < end.x && start.y > end.y) {
x = end.x;
y = second.y;
} else if (start.x > end.x && start.y < end.y) {
x = end.x;
y = second.y;
} else {
x = start.x;
y = third.y;
}
return new Point(x, y);
}
}
|
s220925973 | p02273 | u881590806 | 1448748617 | Python | Python | py | Runtime Error | 0 | 0 | 671 | import math
n = int(raw_input())
th = math.pi * 60.0 / 180.0
def split(x,y):
s = ((2*x[0]+y[0])/3, (2*x[1]+y[1])/3)
t = ((x[0]+2*y[0])/3, (x[1]+2*y[1])/3)
u = ((t[0]-s[0])*math.cos(th) - (t[1]-s[1])*math.sin(th) + s[0], (t[0]-s[0])*math.sin(th) + (t[1]-s[1])*math.cos(th) + s[1])
return (s,u,t)
s = (0.,0.)
t = (100.,0.)
points = []
points.append(s)
points.append(t)
for i in range(n):
new_points = []
j = 0
while True:
s,u,t = split(points[j],points[j+1])
new_points.extend((points[j],s,u,t,points[j+1]))
j += 1
if j+1 >= len(points): break
points = new_points
for p in new_points:
print p[0],p[1] |
s561418228 | p02273 | u970436839 | 1452683601 | Python | Python | py | Runtime Error | 0 | 0 | 547 | def koch(n, a, b):
if n == 0:
return
s.x = (2*a.x* + b.x)/3
s.y = (2*a.y* + b.y)/3
t.x = (a.x* + 2*b.x)/3
t.y = (a.y* + 2*b.y)/3
u.x = (t.x - s.x)*cos(pi/3) - (t.y - s.y)*sin(pi/3) + s.x
u.y = (t.x - s.x)*sin(pi/3) + (t.y - s.y)*cos(pi/3) + s.y
koch(n-1, a, s)
print "%f %f" %(s.x, s.y)
koch(n-1, s, u)
print "%f %f" %(u.x, u.y)
koch(n-1, u, t)
print "%f %f" %(t.x, t.y)
koch(n-1, t, b)
n = input()
p1.x = 0
p1.y = 0
p2.x = 100
p2.y = 0
print "%f %f" %(p1.x, p2.y)
koch(n, p1, p2)
print "%f %f" %(p1.x, p2.y) |
s158060712 | p02273 | u970436839 | 1452684047 | Python | Python | py | Runtime Error | 0 | 0 | 498 | def koch(n, a, b):
if n == 0:
return
s.x = (2*a[0]* + b[0])/3
s.y = (2*a[1]* + b[1])/3
t.x = (a[0]* + 2*b.x)/3
t.y = (a[1]* + 2*b.y)/3
u.x = (t.x - s.x)*cos(pi/3) - (t.y - s.y)*sin(pi/3) + s.x
u.y = (t.x - s.x)*sin(pi/3) + (t.y - s.y)*cos(pi/3) + s.y
koch(n-1, a, s)
print s.x, s.y
koch(n-1, s, u)
print u.x, u.y
koch(n-1, u, t)
print t.x, t.y
koch(n-1, t, b)
n = input()
p1.x = 0
p1.y = 0
p2.x = 100
p2.y = 0
print p1.x, p2.y
koch(n, p1, p2)
print p1.x, p2.y |
s519753322 | p02273 | u970436839 | 1452684210 | Python | Python | py | Runtime Error | 0 | 0 | 528 | def koch(n, a, b):
if n == 0:
return
s[0] = (2*a[0]* + b[0])/3
s[1] = (2*a[1]* + b[1])/3
t[0] = (a[0]* + 2*b.x)/3
t[1] = (a[1]* + 2*b.y)/3
u[0] = (t[0] - s[0])*cos(pi/3) - (t[1] - s[1])*sin(pi/3) + s[0]
u[1] = (t[0] - s[0])*sin(pi/3) + (t[1] - s[1])*cos(pi/3) + s[1]
koch(n-1, a, s)
print s[0], s[1]
koch(n-1, s, u)
print u[0], u[1]
koch(n-1, u, t)
print t[0], t[1]
koch(n-1, t, b)
n = input()
p1[0] = 0
p1[1] = 0
p2[0] = 100
p2[1] = 0
print p1[0], p2[1]
koch(n, p1, p2)
print p1[0], p2[1] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.