text
stringlengths 37
1.41M
|
|---|
import math
r = float(input())
x = math.pi
print("{} {}".format(r*r*x,2*x*r))
|
n = input()
while n != "0":
sum = 0
for i in n:
sum += int(i)
print(sum)
n = input() |
from math import gcd
K = int(input())
ans = 0
for i in range(1,K+1):
for j in range(i,K+1):
L = gcd(i,j)
for k in range(j,K+1):
M = gcd(L,k)
if i == j == k:
ans += M
elif i == j or j == k:
ans += M*3
else:
ans += M*6
print(ans)
|
import sys
def Prime(x):
for i in range(2, x):
if(x%i==0):
return False
return True
if (__name__=='__main__'):
X = int(input())
i = 0
while True:
if Prime(X+i):
print(X+i)
sys.exit()
i += 1 |
n = int(input())
squares = list(map(int, input().split(" ")))
odd = 0
for i in range(0, n, 2):
if squares[i] % 2:
odd += 1
print(odd) |
n = int(input())
char = list("abcdefghijklmnopqrstuvwxyz")
name = ""
while n > 0:
n -= 1
name = char[n % 26] + name
n = n // 26
print(name) |
class SegmentTree():
'''
非再帰
segment tree
'''
def __init__(self, n, func, init=float('inf')):
'''
n->配列の長さ
func:func(a,b)->val, func=minだとRMQになる
木の高さhとすると,
n:h-1までのノード数。h段目のノードにアクセスするために使う。
data:ノード。
parent:k->child k*2+1とk*2+2
'''
self.n = 2**(n-1).bit_length()
self.init = init
self.data = [init]*(2*self.n)
self.func = func
def set(self, k, v):
'''
あたいの初期化
'''
self.data[k+self.n-1] = v
def build(self):
'''
setの後に一斉更新
'''
for k in reversed(range(self.n-1)):
self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])
def update(self, k, a):
'''
list[k]=aに更新する。
更新ぶんをrootまで更新
'''
k += self.n-1
self.data[k] = a
while k > 0:
k = (k-1)//2
self.data[k] = self.func(self.data[k*2+1], self.data[k*2+2])
def query(self, l, r):
'''
[l,r)のfuncを求める
'''
L = l+self.n
R = r+self.n
ret = self.init
while L < R:
if R & 1:
R -= 1
ret = self.func(ret, self.data[R-1])
if L & 1:
ret = self.func(ret, self.data[L-1])
L += 1
L >>= 1
R >>= 1
return ret
N = int(input())
S = input()
Q = int(input())
queries = [list(input().split()) for _ in range(Q)]
def a2n(a):
return ord(a)-ord("a")
def createInp(a):
return 1 << a2n(a)
Seg = SegmentTree(len(S), lambda x, y: x | y, init=0)
for i, s in enumerate(S):
Seg.set(i, createInp(s))
Seg.build()
for q, l, r in queries:
if q == "1":
Seg.update(int(l)-1, createInp(r))
else:
print(bin(Seg.query(int(l)-1, int(r))).count('1'))
|
n=input().split()
x=int(n[0])
A=int(n[1])
if x<A:
print("0")
else:
print("10") |
from collections import Counter
S = Counter(input())
if len(S) == 2:
for i in S.values():
print("No" if i != 2 else "Yes")
break
else:
print("No") |
#!/usr/bin/env python3
x = int(input())
print("10"[x % 100 > (x // 100) * 5])
|
def make_indices_list(n):
"""
Args:
n (int)
>>> make_indices_list(8):
[7, 5, 3, 1, 0, 2, 4, 6]
>>> make_indices_list(7):
[6, 4, 2, 0, 1, 3, 5]
"""
if n % 2 == 0:
return list(range(n-1, 0, -2)) + list(range(0, n, 2))
else:
return list(range(n-1, -1, -2)) + list(range(1, n-1, 2))
n = int(input())
L = list(map(int, input().split()))
indices_list = make_indices_list(n)
for ind in indices_list:
print(L[ind], end=' ')
print('')
|
S = raw_input().split(" ")
Stack = list()
def push(x):
Stack.append(x)
def pop():
return Stack.pop(-1)
a = 0
b = 0
for i in range(len(S)):
if S[i] == "+":
a = pop()
b = pop()
push(b + a)
elif S[i] == "-":
a = pop()
b = pop()
push(b - a)
elif S[i] == "*":
a = pop()
b = pop()
push(b * a)
elif S[i] == "/":
a = pop()
b = pop()
push(b / a)
else:
push(int(S[i]))
print Stack.pop(-1) |
dic = {'AC':0, 'WA':0, 'TLE':0, 'RE':0}
N = int(input())
for i in range(N):
dic[input()] += 1
for i in dic:
print(i, 'x', dic[i]) |
n = int(input())
if n % 2 == 0:
n1 = n / 2
print(n1 / n)
else:
n2 = (n - 1) / 2
print((n2 + 1) / n) |
def is_prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
num = []
prime_numbers = []
n = int(input())
for _ in range(n):
i = int(input())
num.append(i)
for i in num:
if is_prime(i):
prime_numbers.append(i)
print(len(prime_numbers)) |
S = input()
N = len(S)
S1 = S[:(N-1)//2]
S2 = S[(N+1)//2:]
if S==S[::-1] and S1==S1[::-1] and S2==S2[::-1]:
print("Yes")
else:
print("No") |
X = int(input())
amari = X % 100
a = (X-amari)//100
if a*5 >= amari:
ans = 1
else:
ans = 0
print(ans)
|
#-*-coding:utf-8-*-
import sys
def main():
n = int(input())
ans=0
b=0
for a in range(1,n):
#A*B+C=n → A <= n-c//b
#cは1<=c<=nなのでbで可変
b=(n-1)//a
ans+=b
print(ans)
if __name__ == "__main__":
main() |
s=input()
S=list(s)
if len(S)==2:
print(s)
else:
print(S[2]+S[1]+S[0]) |
N=input()
ans=0
for i in range(1,int(N)+1):
if i%15==0:
pass
elif i%5==0:
pass
elif i%3==0:
pass
else:
ans=ans+i
print(ans) |
s = input()
if s[0] == 'S':
print('Cloudy')
if s[0] == 'C':
print('Rainy')
if s[0] == 'R':
print('Sunny')
|
rate = int(input())
if rate >= 0 and rate <= 1199:
print('ABC')
elif rate >= 1200 and rate <= 2799:
print('ARC')
else:
print('AGC')
|
a = int(input())
b = int(input())
h = int(input())
trapezoid = (a + b) * h / 2
print(int(trapezoid))
|
import math
def main():
a, b = map(int, input().split())
if ((a % 2) == 0 and (b % 2) == 0) or ((a % 2) == 1 and (b % 2) == 1):
print(math.floor((a+b)/2))
else:
print('IMPOSSIBLE')
main() |
def bubble_sort(a):
n = len(a)
for j in range(n):
m = n-1-j # n-1 to 0
for i in range(m):
if a[i][1] > a[i+1][1]:
a[i],a[i+1] = a[i+1],a[i]
return a
def selection_sort(a):
MAXINT = 10
n = len(a)
for j in range(n):
minv = MAXINT
minp = -1
for i in range(j,n):
if int(a[i][1]) < minv:
minv = int(a[i][1])
minp = i
a[minp],a[j]=a[j],a[minp]
return a
def stable(a,f):
b = f(a[:])
print ' '.join(b)
p = 1
while p < 10:
c = []
d = []
for i in range(len(a)):
if a[i][1] == str(p):
c.append(a[i])
if b[i][1] == str(p):
d.append(b[i])
for i in range(len(c)):
if c[i] != d[i]:
print "Not stable"
return
p += 1
print "Stable"
n = int(raw_input())
cards = raw_input().split(' ')
stable(cards[:],bubble_sort)
stable(cards[:],selection_sort) |
S=input()
T=input()
ans='Yes'
for x,y in zip(S,T):
if x!=y:
ans='No'
break
print(ans)
|
def collatz_problem(s):
a = []
a.append(s)
counter = 1
while True:
counter += 1
if s % 2 == 0:
s /= 2
a.append(s)
else:
s = s * 3 + 1
a.append(s)
for i in range(len(a)-1):
if a[i] == s:
return counter
def main():
s = int(input())
answer = collatz_problem(s)
print(answer)
if __name__ == "__main__":
main()
|
a,b,c=input().split()
ls=[a,b,c]
ls.sort()
if ls[0]==ls[1]=="5" and ls[2]=="7":
print("YES")
else:
print("NO") |
x, y = list(map(int, input().split()))
a = [1,3,5,7,8,10,12]
b = [4,6,9,11]
c = [2]
if ((x in a) and (y in a)) or ((x in b) and (y in b)) or ((x in c) and (y in c)):
print("Yes")
else:
print("No") |
a,b,c = input().split(' ')
a=int(a)
b=int(b)
c=int(c)
ret="Yes" if a<b<c else "No"
print(ret) |
import math
from decimal import *
# getcontext().prec = 300
a,b,c = map(int,input().split())
if Decimal(a)**Decimal('0.5') + Decimal(b)**Decimal('0.5') < Decimal(c)**Decimal('0.5'):
print("Yes")
else:
print("No")
|
def recKF(p1,p2,n):
if n != 0:
a = 1/2
b = 3**(1/2)/2
s = Point( p1.x + (p2.x-p1.x)/3, p1.y + (p2.y-p1.y)/3 )
t = Point( p1.x + (p2.x-p1.x)*2/3, p1.y + (p2.y-p1.y)*2/3 )
v = Point( t.x-s.x, t.y-s.y )
rot_v = Point( v.x*a - v.y*b, b*v.x + a*v.y )
u = Point( rot_v.x + s.x, rot_v.y + s.y)
recKF(p1,s,n-1)
print(s.x,s.y)
recKF(s,u,n-1)
print(u.x,u.y)
recKF(u,t,n-1)
print(t.x,t.y)
recKF(t,p2,n-1)
from collections import namedtuple
Point = namedtuple("Point", ["x","y"])
p1 = Point(0,0)
p2 = Point(100,0)
n = int(input())
print(p1.x,p1.y)
recKF(p1,p2,n)
print(p2.x,p2.y)
|
import abc
class AdjacentGraph:
"""Implementation adjacency-list Graph.
Beware ids are between 1 and size.
"""
def __init__(self, size):
self.size = size
self._nodes = [[0] * (size+1) for _ in range(size+1)]
def set_adj_node(self, id_, adj_id):
self._nodes[id_][adj_id] = 1
def __iter__(self):
self._id = 0
return self
def __next__(self):
if self._id < self.size:
self._id += 1
return (self._id, self._nodes[self._id][1:])
raise StopIteration()
def dfs(self, handler=None):
visited = []
while len(visited) < self.size:
for id_ in range(1, self.size+1):
if id_ not in visited:
stack = [(id_, 0)]
break
while len(stack) > 0:
i, j = stack.pop()
if j == 0:
if handler:
handler.visit(i)
visited.append(i)
yield i
try:
j = self._nodes[i].index(1, j+1)
stack.append((i, j))
if j not in visited:
stack.append((j, 0))
except ValueError:
if handler:
handler.leave(i)
class EventHandler(abc.ABC):
@abc.abstractmethod
def visit(self, i):
pass
@abc.abstractmethod
def leave(self, i):
pass
class Logger(EventHandler):
def __init__(self, n):
self.log = [(0, 0)] * n
self.step = 0
def visit(self, i):
self.step += 1
self.log[i-1] = (self.step, 0)
def leave(self, i):
self.step += 1
(n, m) = self.log[i-1]
self.log[i-1] = (n, self.step)
def by_node(self):
i = 1
for discover, finish in self.log:
yield (i, discover, finish)
i += 1
def run():
n = int(input())
g = AdjacentGraph(n)
log = Logger(n)
for i in range(n):
id_, c, *links = [int(x) for x in input().split()]
for n in links:
g.set_adj_node(id_, n)
for i in g.dfs(log):
pass
for node in log.by_node():
print(" ".join([str(i) for i in node]))
if __name__ == '__main__':
run()
|
n = int(input())
def memoize(f):
memo = [1, 1] + [0] * max(0, n - 1)
def main(i):
if memo[i]:
return memo[i]
result = memo[i] = f(i)
return result
return main
@memoize
def fibonacci(i):
return fibonacci(i - 1) + fibonacci(i - 2)
print(fibonacci(n)) |
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rnk = [0]*(n+1)
def Find_Root(self, x):
if(self.root[x] < 0):
return x
else:
self.root[x] = self.Find_Root(self.root[x])
return self.root[x]
def Unite(self, x, y):
x = self.Find_Root(x)
y = self.Find_Root(y)
if(x == y):
return
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def isSameGroup(self, x, y):
return self.Find_Root(x) == self.Find_Root(y)
def Count(self, x): # xが属するグループのサイズを返す
return -self.root[self.Find_Root(x)]
def Members(self, x): # xが属するグループに属する要素をリストで返す
return [i for i in range(self.n) if self.Find_Root(i)==self.Find_Root(x)]
def Roots(self): # 全ての根の要素をリストで返す
return [i for i, x in enumerate(self.root) if x < 0]
def Group_Count(self): # グループの数を返す
return len(self.Roots())
n, m = map(int, input().split())
p = list(map(int, input().split()))
xy = [list(map(int, input().split())) for _ in range(m)]
uf = UnionFind(n+1)
for x, y in xy:
uf.Unite(p[x-1], p[y-1])
ans = 0
for i in range(n):
if uf.isSameGroup(i+1, p[i]):
ans += 1
print(ans) |
a,b,c = (int(_) for _ in input().split())
print('Yes') if a+b >= c else print('No') |
key = raw_input().upper()
c = ''
while True:
s = raw_input()
if s == 'END_OF_TEXT':
break
c = c + ' ' + s.upper()
cs = c.split()
total = 0
for w in cs:
if w == key:
total = total + 1
print total |
A, B, C = list(map(int, input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
if C % gcd(A, B) == 0:
print('YES')
else:
print('NO')
|
import math
x1,y1,x2,y2 = map(float,input().split())
x =math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
print(f'{x:.08f}')
|
s = input()
c = 0
for t in s:
if(t == 'o'):c+=1
if(c >= 8-15+len(s)):print('YES')
else:print('NO')
|
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
def solve():
r = input()
if r == 'RRR':
print(3)
elif r == 'RRS' or r == 'SRR':
print(2)
elif r == 'RSR' or r == 'RSS' or r =='SSR' or r =='SRS':
print(1)
elif r == 'SSS':
print(0)
return 0
if __name__ == "__main__":
solve() |
s = input()
s_sort = ''.join(sorted(s))
t = input()
t_sort = ''.join(sorted(t, reverse=True))
if s_sort < t_sort:
print('Yes')
else:
print('No') |
N = int(input())
C1 = input().split()
C2 = C1[:]
def bubbleSort(C, N):
for i in range(N):
for j in range(N-1, i, -1):
if int(C[j][1]) < int(C[j-1][1]):
tmp = C[j]
C[j] = C[j-1]
C[j-1] = tmp
i += 1
return C
def selectionSort(C, N):
for i in range(N):
minj = i
for j in range(i, N):
if int(C[j][1]) < int(C[minj][1]):
minj = j
if minj != i:
tmp = C[minj]
C[minj] = C[i]
C[i] = tmp
i += 1
return C
bubbleSort_result = ' '.join(bubbleSort(C1, N))
selectionSort_result = ' '.join(selectionSort(C2, N))
print(bubbleSort_result)
print('Stable')
print(selectionSort_result)
if bubbleSort_result == selectionSort_result:
print('Stable')
else:
print('Not stable') |
# -*- coding: utf-8 -*-
N = int(raw_input())
A = map(str, raw_input().split())
B = A[:]
for i in range(N):
for j in range(N-1, i, -1):
if int(A[j][1]) < int(A[j-1][1]):
A[j], A[j-1] = A[j-1], A[j]
bubble = " ".join(A)
for i in range(N):
minj = i
for j in range(i, N):
if int(B[j][1]) < int(B[minj][1]):
minj = j
B[i], B[minj] = B[minj], B[i]
select = " ".join(B)
print bubble
print "Stable"
print select
if bubble == select:
print "Stable"
else:
print "Not stable" |
import functools
MOD=10**9+7
def euclid(a, b):
if b == 0:
return a
else:
return euclid(b, a%b)
def multiple(a, b):
return a*b // euclid(a, b)
def lcm(nums):
return functools.reduce(multiple, nums)
n=int(input())
a=list(map(int,input().split()))
x=lcm(a)
sum=0
for i in range(n):
sum+=x//a[i]
print(sum%MOD) |
s = str(input())
num = ['01','02','03','04','05','06','07','08','09','10','11','12']
if s[:2] in num and s[2:] in num:
print("AMBIGUOUS")
elif s[:2] in num:
print("MMYY")
elif s[2:] in num:
print("YYMM")
else:
print("NA") |
str = input()
a = int(str[:3])
b = int(str[-3:])
print("Yes") if a % 111 == 0 or b % 111 == 0 else print("No") |
s = input()
a = s.count('a')
b = s.count('b')
c = s.count('c')
if abs(a - b) >= 2 or abs(b - c) >= 2 or abs(c - a) >= 2:
print('NO')
else:
print('YES')
|
import math
n=int(input())
for i in range(1,n+1):
if math.floor(i*1.08)==n:
print(i)
break
else:
continue
else:
print(":(")
|
def bubbleSort(A, N):
swap = 0
flag = True
while flag:
flag = False
for j in range(N-1,0,-1):
if A[j] < A[j-1]:
A[j],A[j-1] = A[j-1],A[j]
swap += 1
flag = True
return swap
N = int(input())
A = list(map(int,input().split()))
swap=bubbleSort(A,N)
print(" ".join(map(str,A)))
print (swap) |
S = input()
for i in range(len(S)):
for j in range(len(S)):
if S[:j]+S[i:] == "keyence":
print("YES")
exit()
print("NO") |
s = input()
t = input()
ss = sorted(s)
tt = sorted(t, reverse=True)
print('Yes') if ss < tt else print('No') |
N=int(str(input())[-1])
if N==3:
print("bon")
elif N==0 or N==1 or N==6 or N==8:
print("pon")
else:
print("hon") |
import math
a,b=map(int,input().split())
gcd=math.gcd(a,b)
def prime_factorization(n):
i=2
prime=[]
if n%i==0:
n//=i
prime.append(2)
while n%i==0:
n//=i
i+=1
k=int(n**0.5)+1
for j in range(i,k+1,2):
if n%j==0:
n//=j
prime.append(j)
while n%j==0:
n//=j
if n>1:
prime.append(n)
return prime
print(len(prime_factorization(gcd))+1) |
import math
h = int(input())
l = 1
while (h != 1):
h = math.floor(h / 2)
l += 1
ans = 0
for i in range(l):
ans += 2**i
print(ans) |
import sys
import math
X = int(sys.stdin.readline().strip())
# i秒までに進める最大の距離
max_t = int(math.sqrt(2*X)) + 1
# print(max_t)
for i in range(max_t + 1):
if i * (i+1) >= 2 * X:
break
print(i) |
s = input()
count = 0
max = 0
for i in range(len(s)):
if s[i] == 'S':
count =0
else:
count += 1
if count > max:
max = count
print(max) |
def divisor(n):
i = 1
table = []
while i * i <= n:
if n%i == 0:
table.append(i)
table.append(n//i)
i += 1
table = list(set(table))
return table
if __name__ == '__main__':
n = int(input())
#n = a * b のためnの約数を求める
A = divisor(n)
B = []
c_tmp = 11
for i in A:
tmp = n // i
#tmp i の桁数をチェック
c1 = len(str(tmp))
c2 = len(str(i))
c2_tmp = max(c1,c2)
c_tmp = min(c2_tmp,c_tmp)
print(c_tmp)
|
x=int(input())
ans = (x//11)*2
if 0 < x%11 <= 6:
ans += 1
elif x % 11 > 6:
ans += 2
print(ans) |
s = input()
p = input()
p_len = len(p)
if p in s:
print("Yes")
else:
for i in range(p_len):
if (p[:i] == s[-i:]) and (p[i:] == s[:p_len - i]):
print("Yes")
break
else:
print("No") |
num = int(input())
print("{0}".format(num**3))
|
import re
s = input()
t = 'keyence'
#分割区間を固定して、先頭・末尾のマッチング
for i in range(len(t)+1):
if s.startswith(t[:i+1]) and s.endswith(t[i+1:]):
print('YES');exit()
print('NO') |
s = list(map(str,input().split()))
print("YES" if s[0][-1] == s[1][0] and s[1][-1] == s[2][0] else "NO")
|
import math
N = int(input())
ans = math.floor(N / 2)
if N % 2 == 0:
print(ans - 1)
else:
print(ans) |
import os, sys, re, math
(A, B) = [int(n) for n in input().split()]
if A <= 9 and B <= 9:
print(A * B)
else:
print(-1)
|
def main():
n, m = map(int, input().split())
p = [0] + list(map(int, input().split()))
cnt = 0
global parent
parent = list(range(n+1))
for _ in range(m):
x, y = map(int, input().split())
unite(x, y)
for i in range(1, n+1):
if root(i) == root(p[i]):
cnt += 1
print(cnt)
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
root_x = root(x)
if root_x != root(y):
parent[root_x] = y
if __name__ == "__main__":
main() |
s=input()
a=0
for i in range(len(s)):
if s[i]=="o":
a+=1
if a+15-len(s)>=8:
print('YES')
else:
print('NO') |
for i in range(1, 10):
for ii in range(1, 10):
print('{}x{}={}'.format(i, ii, i*ii)) |
nagasa_str = input().split(" ")
A_len = int(nagasa_str[0])
B_len = int(nagasa_str[1])
C_len = int(nagasa_str[2])
if (A_len==B_len and B_len==C_len):
print("Yes")
else:
print("No") |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
def solve():
s = input()
if s[-1] == "s":
print(s+"es")
else:
print(s+"s")
return 0
if __name__ == "__main__":
solve()
|
def f(a,b):
return max(len(str(a)),len(str(b)))
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
def main():
n=int(input())
m=make_divisors(n)
a=10**10
for i in m:
if n//i < i:
break
else:
a=min(a, f(i, n//i))
print(a)
if __name__ == "__main__":
main() |
n = int(input())
lst = [int(input()) for _ in range(n)]
lst2 = sorted(lst)
saidai = max(lst2)
for i in range(n):
if lst[i] != saidai:
print(lst2[-1])
else:
print(lst2[-2]) |
import sys
N = int( input() )
S = input()
count = 0
for i in range(len(S)):
if S[i:i+3] =="ABC":
count+=1
print(count) |
s=list(input())
ans="YES"
while len(s)!=0:
if len(s)<5:
ans="NO"
break
elif s[-1:-6:-1]==["m","a","e","r","d"]:
for i in range(5):
s.pop(-1)
elif s[-1:-8:-1]==["r","e","m","a","e","r","d"]:
for i in range(7):
s.pop(-1)
elif s[-1:-6:-1]==["e","s","a","r","e"]:
for i in range(5):
s.pop(-1)
elif s[-1:-7:-1]==["r","e","s","a","r","e"]:
for i in range(6):
s.pop(-1)
else:
ans="NO"
break
print(ans) |
import sys
from typing import List
COMP_NUM = 0
def merge(elements: List[int], left: int, mid: int, right: int) -> None:
global COMP_NUM
n1 = mid - left
n2 = right - mid
left_array = [0] * (n1 + 1)
right_array = [0] * (n2 + 1)
left_array[0:n1] = elements[left:left + n1]
left_array[n1] = sys.maxsize
right_array[0:n2] = elements[mid:mid + n2]
right_array[n2] = sys.maxsize
i = 0
j = 0
for k in range(left, right):
COMP_NUM += 1
if left_array[i] <= right_array[j]:
elements[k] = left_array[i]
i += 1
else:
elements[k] = right_array[j]
j += 1
def merge_sort(elements: List[int], left: int, right: int) -> None:
if left + 1 < right:
mid = (left + right) // 2
merge_sort(elements, left, mid)
merge_sort(elements, mid, right)
merge(elements, left, mid, right)
if __name__ == "__main__":
n = int(input())
elements = list(map(lambda x: int(x), input().split()))
merge_sort(elements, 0, len(elements))
print(" ".join([str(elem) for elem in elements]))
print(f"{COMP_NUM}")
|
#coding:utf-8
a,op,b=map(str,input().split())
a,b=int(a),int(b)
while op!="?":
if op=="+":
ans=a+b
elif op=="-":
ans=a-b
elif op=="*":
ans=a*b
elif op=="/":
ans=a//b
print(ans)
a,op,b=map(str,input().split())
a,b=int(a),int(b) |
print("Hello World") if input() == "1" else print(int(input()) + int(input()) ) |
S = input()
sform = int(S[:2])
slatt = int(S[2:])
if sform <= 12 and sform >= 1:
if slatt <= 12 and slatt >= 1:
print('AMBIGUOUS')
else:
print('MMYY')
else:
if slatt <= 12 and slatt >= 1:
print('YYMM')
else:
print('NA') |
import itertools
import math
import fractions
import functools
a, b = map(int, input().split())
if (b+a)/2 == (b+a)//2:
print((b+a)//2)
else: print("IMPOSSIBLE") |
N = int(input())
memolist = [-1]*(N+1)
def fib(x):
if memolist[x] == -1:
if x == 0 or x == 1:
memolist[x] = 1
else:
memolist[x] = fib(x - 1) + fib(x - 2)
return memolist[x]
print(fib(N))
|
W, H, x, y, r = [int(x) for x in input().split()]
print('No' if x - r < 0 or y - r < 0 or x + r > W or y + r > H else 'Yes') |
k=int(input())
t=0
import math
for i in range(1,k+1):
for j in range(1,k+1):
s=math.gcd(i,j)
for l in range(1,k+1):
S=math.gcd(s,l)
t+=S
print(t) |
# import matplotlib.pyplot as plt
import math
def squaredDistance(a, b):
return (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
# for X in range(1, 180):
angle = 90
X = int(input())
iter = 0
current = [0, 0]
previous = current
while (iter == 0 or squaredDistance(current, [0, 0]) > 0.00001):
if (iter > 500):
break
dir = [math.cos(math.radians(angle)), math.sin(math.radians(angle))]
current = [current[0] + dir[0], current[1] + dir[1]]
angle = (angle + X) % 360
# plt.plot([previous[0], current[0]], [previous[1], current[1]])
previous = current
iter = iter + 1
# plt.show()
print(iter)
# print("X = {} : {}".format(X, iter))
|
str_num = input()
count = 0
for c in str_num:
if c == "2":
count += 1
print(count) |
a = str(input().split())
b = list(a)
if b[4] == b[5] and b[7] == b[6]:
print("Yes")
else :
print("No") |
import math
from typing import List
buggage_num, truck_num = map(int, input().split())
buggage_list = [int(input()) for i in range(buggage_num)]
def able_to_load_buggage(max_weight: int,
truck_num: int, buggage_list: List[int]) -> bool:
i = 0
truck = [0 for i in range(truck_num + 1)]
for buggage in buggage_list:
if truck[i] + buggage <= max_weight:
truck[i] += buggage
else:
i += 1
truck[i] += buggage
if i > (truck_num - 1):
return False
for t in truck:
if t > max_weight:
return False
else:
return True
# data = [i for i in range(31)]
# for d in data:
# result = able_to_load_buggage(d, truck_num, buggage_list)
# print(f'{d} {result}')
left = 0
right = 100000 * 10000 + 1
i = 0
while left < right:
i += 1
mid = math.floor((left + right) / 2)
result = able_to_load_buggage(mid, truck_num, buggage_list)
# print(f'{i} {left} {mid} {right} {result}')
if result:
right = mid
else:
left = mid + 1
# print(f'{left} {mid} {right}')
print(left)
|
def main():
n = int(input())
f = False
for i in range(n):
a = int(input())
if a%2 == 1:
f = True
if f:
print("first")
else:
print("second")
if __name__ == "__main__":
main()
|
a,b=map(int,input().split())
if a*b<=0:
print("Zero")
elif a>0 or a==b:
print("Positive")
else:
if abs(a-b) % 2 == 0:
print("Negative")
else:
print("Positive") |
a, b, x = map(int, input().split())
from math import degrees, atan2
if x<=a**2*b/2:
tanj = (x*2)/(b*a)
print(90-degrees(atan2(tanj, b)))
else:
x = a**2*b - x
tanj = (x*2)/(a**2)
print(degrees(atan2(tanj, a))) |
s = str(input())
plus = s.count("+")
minus = s.count("-")
print(plus - minus) |
n = int(input())
counter = 0
for i in range(1,n+1):
count = 0
if i % 2 == 1:
for j in range(1,i+1):
if i%j == 0:
count += 1
if j == i:
if count == 8:
counter += 1
print(counter) |
def judg_unit(ss,pp):
sss = ss + ss + ss
result = sss.find(pp)
if result != -1:
return "Yes"
else :
return "No"
s = str(input())
p = str(input())
print(judg_unit(s,p))
|
S = input()
T = input()
if S == T[ :len(S) ]:
if len( S ) + 1 == len( T ):
print("Yes")
else:
print("No")
else:
print("No") |
x = int(input())
if x == 2:
print(2)
else:
while True:
for i in range(2,x):
if x % i == 0:
break
if x - 1 == i:
print(x)
exit()
x += 1 |
t = input()
n = len(t)
res = ''
for i in range(n):
if t[i] == '?':
res += 'D'
else:
res += t[i]
print(res) |
x, y = input().split()
hex = ['A', 'B', 'C', 'D', 'E', 'F']
xi = hex.index(x)
yi = hex.index(y)
if xi < yi:
print('<')
elif xi > yi:
print('>')
else:
print('=')
|
#!/usr/bin/env python3
x,a,b=map(int,input().split())
if a-b >= 0:
print('delicious')
elif a-b >= -x:
print('safe')
else:
print('dangerous') |
from math import gcd
K = int(input())
a = 0
for ai in range(1, K + 1):
for bi in range(1, K + 1):
gcd_ab = gcd(ai, bi)
for ci in range(1, K + 1):
a += gcd(gcd_ab, ci)
print(a) |
def main():
S = input()
if sorted(list(S)) == sorted(list('abc')):
return True
return False
if main():
print('Yes')
else:
print('No')
|
def divide_by_2(num):
cnt = 0
while True:
if num % 2 != 0:
break
num /= 2
cnt += 1
return cnt
def main():
N = int(input())
lst = [-1] * (N + 1)
for num in range(1, N + 1):
cnt = divide_by_2(num)
lst[num] = cnt
print(lst.index(max(lst)))
if __name__ == "__main__":
main() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.