text
stringlengths 37
1.41M
|
|---|
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
n = int(readline())
dic1 = {
4:8,
6:7,
8:6,
10:5,
12:4,
14:3,
16:2,
18:1,
}
for i in range(4,19,2):
if i*100 <= n < (i+2)*100:
print(dic1[i]) |
#入力
lst = input().split()
#整数値化
for i in range(len(lst)):
lst[i] = int(lst[i])
#ソート
lst.sort()
#出力
if lst == [5, 5, 7]:
print('YES')
else:
print('NO') |
abc = input()
num_abc = abc.split()
a = int(num_abc[0])
b = int(num_abc[1])
c = int(num_abc[2])
if a < b < c:
print('Yes')
else:
print('No') |
lst = [int(a) for a in input().split()]
if [5,5,7] == sorted(lst):
print("YES")
else:
print("NO") |
def main():
S = input()
from collections import deque
S = deque(S)
ans = 0
while S:
if S[0] == S[-1]:
S.popleft()
if S:
S.pop()
elif S[0] != "x" and S[-1] != "x":
return print(-1)
elif S[0] == "x":
S.append("x")
ans += 1
else:
S.appendleft("x")
ans += 1
print(ans)
if __name__ == '__main__':
main()
|
S = input()
i = 0
n = len(S)
while i <= n-5:
if S[i:i+5] == "dream":
i += 5
if S[i:i+2] == "er" and S[i:i+5] != "erase":
i += 2
elif S[i:i+5] == "erase":
i += 5
if S[i:i+1] == "r":
i += 1
else:
break
if i != len(S):
print("NO")
else:
print("YES") |
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
A, B, K = map(int, input().split(" "))
a_divisor = divisor(A)
b_divisor = divisor(B)
print(sorted(list(set(a_divisor) & set(b_divisor)), reverse=True)[K-1]) |
#coding:UTF-8
def LoT(List):
List2=sorted(List)
for i in range(3):
print(List2[len(List)-1-i])
if __name__=="__main__":
List=[]
for i in range(10):
List.append(int(input()))
LoT(List) |
A,B,C = map (int, input (). split ())
if A==B!=C or A!=B==C or A==C!=B:
print ('Yes')
else:
print ('No') |
def f(i):
if i == 2:return 1
return pow(2, i-1, i) == 1
print(sum(1 for n in range(int(input())) if f(int(input())))) |
num = int(input())
item_prices = []
for i in range(num):
price = int(input())
item_prices.append(price)
highest_price = max(item_prices)
item_prices[item_prices.index(highest_price)] = highest_price // 2
total_price = sum(item_prices)
print(total_price) |
x = int(input())
answer = 0
answer = (x//500)*1000
x = x%500
answer += (x//5)*5
print(answer) |
n = int(input())
a = list(input().split())
# aの中に黄色Yが含まれていればFourと出力
if "Y" in a:
print("Four")
# aの中に黄色Yが含まれてなけれはThreeと出力
else:
print("Three") |
from math import gcd
K = int(input())
goukei = 0
for a in range(1,K+1):
for b in range(1,K+1):
G = gcd(a,b)
for c in range(1,K+1):
goukei += gcd(G,c)
print(goukei) |
a, b = input().split()
print('>' if a > b else '<' if a < b else '=')
|
a, b = map(int, input().split())
x = a * b
z = x % 2
if z == 0 :
print("Even")
else :
print("Odd") |
S=input()
x=int(S[:2])
y=int(S[2:])
if 0<x<13 and 0<y<13:print("AMBIGUOUS")
elif 0<x<13:print("MMYY")
elif 0<y<13:print("YYMM")
else:print("NA") |
n = int(input())
ans = n
while(1):
if ans%2==0 and ans%n==0:
break
ans += n
print(ans) |
# 最小公倍数(mathは3.5以降)
#参考 https://note.nkmk.me/python-gcd-lcm/
from functools import reduce
import math #(2020-0405 fractions→math)
def lcm_base(x, y):
return (x * y) // math.gcd(x, y) # 「//」はフロートにせずにintにする
def lcm(*numbers): # a,b,cなど
return reduce(lcm_base, numbers, 1)
def lcm_list(numbers): #リスト
return reduce(lcm_base, numbers, 1)
# 初期入力
import sys
input = sys.stdin.readline #文字列では使わない
N = int(input())
a = list(map(int, input().split()))
saisyo_koubaisu =lcm_list(a)
ans =0
for aa in a:
ans += (saisyo_koubaisu-1) %aa
print(ans) |
from math import pi
r=float(raw_input())
print ("%f %f" %(pi*r**2, 2*pi*r)) |
print('Yes') if len(set(input().split(' '))) == 1 else print('No') |
import sys
def gcd(a, b):
return gcd(b, a % b) if a % b else b
def lcm(a, b):
return a * b / gcd(a, b)
for line in sys.stdin:
data = map(int, line.split())
a, b = data
print "%d %d" % (gcd(a, b), lcm(a, b)) |
N = int(input())
flag = True
for i in range(N):
n = int(input())
if n % 2 == 1:
flag = False
if flag:
print('second')
else:
print('first') |
S = input()
L = len(S)
for i in range(L):
print("x",end='') |
args = input().split()
stack = []
def cal_with_operator(b, a, operator):
return eval('{} {} {}'.format(a, operator, b))
for s in args:
if s == '+': stack.append(cal_with_operator(stack.pop(), stack.pop(), '+'))
elif s == '-': stack.append(cal_with_operator(stack.pop(), stack.pop(), '-'))
elif s == '*': stack.append(cal_with_operator(stack.pop(), stack.pop(), '*'))
elif s == '/': stack.append(cal_with_operator(stack.pop(), stack.pop(), '/'))
else : stack.append(s)
print(stack[0])
|
def main():
s = input()
for i in range(len(s) - 1):
if s[i:i + 2] == 'AC':
print('Yes')
exit()
print('No')
if __name__ == '__main__':
main()
|
k = int(input())
x = 7%k
cnt = 0
if k%2 ==0:
print('-1')
else:
while True:
cnt += 1
if x == 0:
print(cnt)
break
elif cnt == k:
print('-1')
break
else:
x = (x*10+7)%k |
from math import pi
n=int(input())
print(2*n*pi) |
koman = int(input())
if koman==7 or koman==5 or koman==3:
print("YES")
else :
print("NO") |
def main():
stop = list(input())
a, b = 0, 0
for i in stop:
if 'A' == i:
a+=1
else:
b+=1
if a > 0 and b > 0:
print('Yes')
else:
print('No')
main() |
p=input().rstrip().split(' ')
if int(p[0])==int(p[1]):
print(1)
elif int(p[1])>int(p[0]):
print(0)
else:
print(int(p[0])-int(p[1])+1)
|
n = int(input())
a = list(map(int, input().split()))
M = max(a)
biggest_prime = [0] * (M+10)
for i in range(2, M+10):
if biggest_prime[i] == 0:
biggest_prime[i] = i
for j in range(i*i, M+1, i):
biggest_prime[j] = i
def fact(n):
arr=[]
while n>1:
now=n
cnt=0
p=biggest_prime[now]
while now % p == 0:
now//=p
cnt+=1
arr.append([p,cnt])
n=now
return arr
from collections import defaultdict
cntd=defaultdict(int)
for i in range(len(a)):
lis = fact(a[i])
for num,cnt in lis:
if num==1:
continue
cntd[num]+=1
flg=False
for c in cntd.values():
if c==n:
print("not coprime")
exit()
if c>1:
flg=True
if flg:
print("setwise coprime")
else:
print("pairwise coprime") |
memo = [1, 1]
def fib(n):
if (n < len(memo)):
return memo[n]
memo.append(fib(n-1) + fib(n-2))
return memo[n]
N = int(input())
print(fib(N))
|
a = [input() for i in range(2)]
sp = "".join(sorted(list(a[0])))
tmp = list(a[1])
tmp.sort()
tmp.reverse()
tp = "".join(tmp)
if sp < tp:
print("Yes")
else:
print("No")
|
x, a, b = input().split()
x = int(x)
a = int(a)
b = int(b)
x_a = (x - a) ** 2
x_b = (x - b) ** 2
if x_a > x_b:
print("B")
else:
print("A") |
s = list(input())
count = 0
maxcount = 0
for i in range(3):
if s[i] == 'R':
count += 1
maxcount = count
else:
count = 0
print(maxcount) |
def merge(A, left, mid, right):
inf = float("inf")
L, R = A[left:mid]+[inf], A[mid:right]+[inf]
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
return right - left
def merge_sort(A, left, right, count=0):
if left+1 < right:
mid = (left + right) // 2
count = merge_sort(A, left, mid, count)
count = merge_sort(A, mid, right, count)
count += merge(A, left, mid, right)
return count
if __name__ == "__main__":
n = int(input())
A = list(map(int, input().split()))
count = merge_sort(A, 0, n)
print(*A)
print(count)
|
inter = list(input())
flag = 0
for i in range(0, len(inter)):
if inter[i] == "7":
flag = 1
if flag == 1:
print("Yes")
else:
print("No") |
n = int(input())
i = 1
for i in range(1, n + 1):
if i % 3 == 0:
print(' {0}'.format(i), end = '')
else:
st = str(i)
for x in range(0, len(st)):
if st[x] == '3':
print(' {0}'.format(i), end = '')
break
print() |
import math
x1, y1, x2, y2 = [float(i) for i in input().split()]
print(math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)) |
def prime_list():
p_lis = [True] * (2 * 10**5 + 1)
p_lis[0], p_lis[1] = False, False
for i in range(2, 2 * 10**5 + 1):
if p_lis[i]:
j = 2
while j * i <= 2 * 10**5:
p_lis[j*i] = False
j += 1
return p_lis
x = int(input())
p_lis = prime_list()
j = 0
while True:
if p_lis[x+j]:
print(x+j)
break
j += 1
|
import math
a,b,x = map(int,input().split())
if x <= a*a*b//2:
theta = (math.pi/2) - math.atan((2*x)/(a*b*b))
else:
theta = math.atan(2*(a*a*b-x)/(a*a*a))
degree = math.degrees(theta)
print(degree) |
#愚直な判定
def JudgeStable(inC, outC, N):
for i in range(N):
for j in range(i+1, N):
for a in range(N):
for b in range(a+1, N):
if inC[i][1] == inC[j][1] and inC[i] == outC[b] and inC[j] == outC[a]:
return False
return True
def PrintJudge(judge):
if judge:
print('Stable')
else:
print('Not stable')
def BubbleSort(C, N):
for i in range(N):
for j in reversed(range(i+1, N)):
if C[j-1][1] > C[j][1]:
C[j-1], C[j] = C[j], C[j-1]
def SelectionSort(C, N):
for i in range(N):
minj = i
for j in range(i+1, N):
if C[minj][1] > C[j][1]:
minj = j
C[minj], C[i] = C[i], C[minj]
def PrintC(C):
print(' '.join([''.join([c[0], str(c[1])]) for c in C]))
N = int(input())
C = [[c[0], int(c[1])] for c in input().split()]
C1 = C.copy()
C2 = C.copy()
BubbleSort(C1, N)
SelectionSort(C2, N)
PrintC(C1)
PrintJudge(JudgeStable(C, C1, N))
PrintC(C2)
PrintJudge(JudgeStable(C, C2, N))
|
from decimal import Decimal
X=int(input())
c =Decimal(100)
C=0
while c<X:
c=Decimal(c)*(Decimal(101))//Decimal(100)
C+=1
print(C) |
import math
X = int(input())
gcd = math.gcd(X, 360)
lcm = X * 360 / gcd
print(int(lcm/X)) |
n = input().count('7')
if n == 0:
ans = 'No'
else:
ans = 'Yes'
print(ans) |
S = input()
l = len(S)
T = ''.join(list(reversed(S)))
a = S[:(l-1)//2]
a1 = ''.join(list(reversed(a)))
b = S[(l+3)//2-1:l]
b1 = ''.join(list(reversed(b)))
if S == T:
if a == a1 and b == b1:
print('Yes')
if a != a1 or b != b1:
print('No')
if S != T:
print('No') |
import math
N = int(input())
def lcm(x, y):
return (x*y) // math.gcd(x, y)
ans = 1
for _ in range(N):
T = int(input())
ans = lcm(ans, T)
print(ans) |
def Reverse(str, A, B):
a = int(A)
b = int(B)
if a == 0:
str = str[0:a] + str[b::-1] + str[b + 1:]
else:
str = str[0:a] + str[b:a - 1:-1] + str[b + 1:]
return str
def Replace(str, a, b, c):
str2 = ''
Str = list(str)
for i in range(int(b) - int(a) + 1):
Str[i + int(a)] = c[i]
for i in range(len(Str)):
str2 += Str[i]
return str2
str = input()
n = int(input())
for i in range(n):
a = input()
A = a.split()
if A[0] == 'print':
print(str[int(A[1]):int(A[2]) + 1])
elif A[0] == 'reverse':
str = Reverse(str, A[1], A[2])
elif A[0] == 'replace':
str = Replace(str, A[1], A[2], A[3])
|
class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
readline = sys.stdin.readline
N, Q = map(int, readline().split())
tree = UnionFind(N)
res = []
ans=0
for _ in range(Q):
u, v = map(int, readline().split())
tree.unite(u-1, v-1)
for u in range(1,N):
if not tree.is_connected(u, 0):
ans+=1
tree.unite(u, 0)
print(ans)
|
n = int(input())
def func(n):
if n==1:
return 1
return n + func(n-1)
print(func(n)) |
X,Y = map(str, input().split())
l = ['A','B','C','D','E','F']
if l.index(X)>l.index(Y):
print('>')
elif l.index(X)<l.index(Y):
print('<')
else:
print('=') |
h = -1
w = -1
while True:
input = map(int, raw_input().split(" "))
h = input[0]
w = input[1]
if (h == 0 and w == 0):
break
i = 1
j = 0
inner_line = "#"
outer_line = ""
while j < w:
outer_line += "#"
if (j != 0 and j != w - 1):
inner_line += "."
j += 1
inner_line += "#"
print outer_line
while i < h - 1:
print inner_line
i += 1
print outer_line
print "" |
s = input()
kouho = ["dream", "dreamer", "erase", "eraser"]
s = s.replace(kouho[3], "").replace(kouho[2], "").replace(kouho[1], "").replace(kouho[0], "")
if s == "":
print("YES")
else:
print("NO") |
counter = 0
while 1:
i = int(input())
if i == 0:
break
counter += 1
print("Case {0}: {1}".format(counter, i)) |
#!/usr/bin/env python3
def right_triangle(edge):
# a < b < c
return (edge[0] ** 2 + edge[1] ** 2 == edge[2] ** 2)
n = int(input())
for i in range(n):
edge = sorted([int(x) for x in input().split()])
if right_triangle(edge):
print("YES")
else:
print("NO") |
import math
def insert_sort(A, n, g):
cnt = 0
for i in range(g, n):
j = i - g
v = A[i]
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
return cnt
def shell_sort(A, n):
cnt = 0
G = []
h = 1
while h <= n:
G.append(h)
h = h*3+1
G.reverse()
print(len(G))
print(*G)
for g in G:
cnt += insert_sort(A, n, g)
return cnt
N = int(input())
A = [int(input()) for _ in range(N)]
cnt = shell_sort(A, N)
print(cnt)
for a in A:
print(a)
|
n = int(input())
s = input()
res = 'Yes' if s[0:n//2] == s[n//2:] else 'No'
print(res) |
n= list(input())
make = 0
for i in range(len(n)):
if n[i] == "x":
make += 1
if make >= 8:
print("NO")
else:
print("YES")
|
n = int(input())
l = [2, 1]
if n == 1:
print(1)
else:
for i in range(n):
l.append(l[i+1]+l[i])
print(l[n]) |
N = input()
a = int(N[-1])
if a == 3:
ans = "bon"
elif a == 0 or a == 1 or a == 6 or a == 8:
ans = "pon"
else:
ans = "hon"
print(ans) |
def input_from_console():
n, k = map(int, input().split())
return n, k
def nCr(n,r):
f = math.factorial
return f(n) / f(r) / f(n-r)
def main():
n, k = input_from_console()
print(n-k+1)
if __name__ == "__main__":
main()
|
import math
r = float(input())
print("{0:5f}".format(r**2*math.pi) , end = " ")
print("{0:5f}".format(2*r*math.pi)) |
def main():
N, A, B = (int(i) for i in input().split())
H = [int(input()) for i in range(N)]
def is_ok(x):
y = 0 # 中心爆破必要回数
for i, h in enumerate(H):
if h - x*B <= 0:
continue
le = 0
ri = 10**9 + 1
while ri - le > 1:
mid = le + ((ri - le) // 2)
if h - B*(max(x - mid, 0)) - A*mid <= 0:
ri = mid
else:
le = mid
y += ri
if y <= x: # 魔物を消し去るのが可能
return True
else:
return False
def binary_search_meguru():
left = -1
right = 10**9 + 1
while right - left > 1:
mid = left + ((right - left) // 2)
if is_ok(mid):
right = mid
else:
left = mid
return right
print(binary_search_meguru())
if __name__ == '__main__':
main()
|
N = int(input())
A = list(map(int, input().split()))
even = [i for i in A if i % 2 == 0]
if all([i % 3 == 0 or i % 5 == 0 for i in even]) == True:
print("APPROVED")
else:
print("DENIED") |
n = int(input())
ans = 0
for i in range(n):
x,n = input().split()
x = float(x)
if n == "BTC":
x *= 380000.0
ans += x
print(ans) |
N = int(input())
A = list(map(int, input().split()))
A_even = [num for num in A if num%2 == 0]
A_odd = [num for num in A if num%2 != 0]
e = len(A_even)
o = len(A_odd)
if(o%2 == 0):
print("YES")
else:
print("NO") |
import sys
count = 0
def insertionSort(A, n, g):
global count
for i in range(n):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j = j - g
count += 1
A[j+g] = v
return A
def shellSort(A, n):
for i in range(m):
insertionSort(A, n, G[i])
return A
n = int(input())
A = []
for i in range(n):
A.append(int(input()))
G = [1]
m = 1
while True:
x = 3 * G[m-1] + 1
if x >= n: break
G.append(x)
m += 1
G = G[::-1]
shellSort(A, n)
print(m)
print(' '.join([str(i) for i in G]))
print(count)
for i in A:
print(i) |
x,y=input().split(' ')
mydec= {'A':1,'B':2,'C':3,'D':4,'E':5,'F':6}
if x < y:
print('<')
elif x > y:
print('>')
else:
print('=') |
class Node:
def __init__(self,v):
self.v = v
self.next = None
class Queue:
def __init__(self):
self.head = None
self.tail = None
self.size = 0
def enqueue(self,v):
self.size += 1
n = Node(v)
if self.tail == None:
self.tail = n
else:
self.tail.next = n
self.tail = n
if self.head == None:
self.head = self.tail
def dequeue(self):
if self.size == 0:
print 'underflow'
exit()
self.size -= 1
v = self.head.v
self.head = self.head.next
if self.head == None:
self.tail = None
return v
#class Queue:
# def __init__(self,l):
# self.values = []
# self.l = l
# for _ in range(l):
# self.values.append(None)
# self.head = 0
# self.tail = 0
# def inc(self,n):
# if n+1 >= self.l:
# return 0
# else:
# return n+1
# def enqueue(self,v):
# if self.inc(self.head) == self.tail:
# print 'overflow'
# exit()
# self.values[self.head] = v
# self.head = self.inc(self.head)
# def dequeue(self):
# if self.head == self.tail:
# print 'underflow'
# exit()
# v = self.values[self.tail]
# self.tail = self.inc(self.tail)
# return v
# def size(self):
# if self.head >= self.tail:
# return self.head-self.tail
# else:
# self.head + (self.l-self.tail)
n,q = map(int,raw_input().split(' '))
queue = Queue()
for _ in range(n):
n,t = raw_input().split(' ')
t = int(t)
queue.enqueue((n,t))
c = 0
while queue.size>0:
n,t = queue.dequeue()
if t <= q:
c += t
print n,c
else:
queue.enqueue((n,t-q))
c += q |
α=input()
if α.isupper():
print('A')
elif α.islower():
print('a') |
# Connect Cities
# Union Findデータ構造（素集合データ構造）
#入力:N,M(int:整数)
def input2():
return map(int,input().split())
#入力:[n1,n2,...nk](int:整数配列)
def input_array():
return list(map(int,input().split()))
class UnionFind():
"""docstring for UnionFind"""
def __init__(self, n):
self.parents = [-1]*n
def find(self,x):
if self.parents[x] < 0: #自分が親である時
return x
else: #自分が子供である時
self.parents[x]=self.find(self.parents[x])
return self.parents[x]
def union(self,x,y):
# 各要素の親要素を返す
x=self.find(x)
y=self.find(y)
if x==y:
return
if self.parents[x] > self.parents[y]:
x,y=y,x
self.parents[y]=x
n,m=input2()
AB=[input_array() for _ in range(m)]
uf = UnionFind(n)
for ab in AB:
a=ab[0]
b=ab[1]
uf.union(a-1,b-1)
ans=0
for i in uf.parents:
if i < 0:
ans+=1
print(ans-1) |
X = int(input())
# A>=0で考えられる
div_list = []
for a in range(1, int(X**0.5)+1):
if X % a == 0:
div_list.append((a, X//a))
#print(div_list)
for x, y in div_list:
for a in range(int(X**0.5)+1):
b = a - x
#print(a, b)
y_hat = a**4 + b*a**3 + b**2*a**2 + b**3*a + b**4
#print(y_hat)
if y_hat == y:
print(a, b)
exit() |
import copy
def BubbleSort(C, n):
flag = 1
while flag:
flag = 0
for i in range(n-1, 0, -1):
if int(C[i][1]) < int(C[i - 1][1]):
C[i], C[i-1] = C[i-1], C[i]
flag = 1
return C
def SelectionSort(C, n):
for i in range(n-1):
minj = i
for j in range(i, n):
if int(C[j][1]) < int(C[minj][1]):
minj = j
if minj != i:
C[i], C[minj] = C[minj], C[i]
return C
n = int(input())
C = list(input().split())
C2 = C.copy()
print(*BubbleSort(C, n), sep=' ')
print("Stable")
print(*SelectionSort(C2, n), sep=' ')
if C ==C2:
print("Stable")
else:
print("Not stable")
|
def isPrime(x):
if x == 2:
return True
elif (x < 2) or (x % 2 == 0):
return False
else:
i = 3
while i <= float(x) ** 0.5:
if x % i == 0:
return False
i += 2
return True
t = 0
for i in range(int(input())):
if isPrime(int(input())):
t += 1
print(t) |
d = input()
s = 0
for i in range(len(d)):
s += int(d[i])
if (s%9) == 0:
print("Yes")
else:
print("No") |
n = int(input())
l = [2, 1]
for i in range(2, n+1):
a = l[i-2] + l[i-1]
l.append(a)
print(l[n]) |
def collatz(n):
c = 1
check = [n]
while(True):
c += 1
if n & 1 == 0:
n = n // 2
if n in check:
break
check.append(n)
else:
n = (n * 3) + 1
if n in check:
break
check.append(n)
return c
n = int(input())
print(collatz(n)) |
cnt=0
def merge_sort(S):
l=len(S)
mid=int(l/2)
Left=S[0:mid]
Right=S[(mid):l]
global cnt
if l>=2:
merge_sort(Left) and merge_sort(Right)
Left.append(float('inf'))
Right.append(float('inf'))
p=0
q=0
for i in range(l):
if Left[p]<Right[q]:
S[i]=Left[p]
p+=1
else:
S[i]=Right[q]
q+=1
if l!=1 :
cnt+=l
return S
n=int(input())
S=list(map(int,input().split()))
merge_sort(S)
print(*S)
print(cnt)
|
#!/usr/bin/env python3
c1 = list(map(int, input().split()))
c2 = list(map(int, input().split()))
c3 = list(map(int, input().split()))
if (c1[1]-c1[0] == c2[1]-c2[0] == c3[1]-c3[0]) and \
(c2[2]-c2[1] == c2[2]-c2[1] == c3[2]-c3[1]) and \
(c2[0]-c1[0] == c2[1]-c1[1] == c2[2]-c1[2]) and \
(c3[0]-c2[0] == c3[1]-c2[1] == c3[2]-c2[2]):
print('Yes')
else:
print('No') |
a, b, c = input().strip().split(' ')
a, b, c = [int(a), int(b), int(c)]
if (a < c and b < c) or (a>c and b > c):
ans = "No"
else:
ans = "Yes"
print(ans)
|
s=input();a="";b=input()
for i in range(len(s)):
a+=s
if b in a:
print("Yes")
else:
print("No")
|
import sys
if sys.platform =='ios':
sys.stdin=open('input.txt')
l = list(map(int,input().split()))
l.sort()
#print(''.join(list(map(str, l))))
if ''.join(list(map(str, l)))=='1479':
print('YES')
else:
print('NO') |
import sys
from math import factorial
input = sys.stdin.readline
def log(*args):
print(*args, file=sys.stderr)
def main():
x, y = map(int, input().rstrip().split())
# 全部 i + 1, j + 2が最初だったとする
# a + 2b = x, 2a + b = y
# =>
# a = x - 2b
# b = y - 2a
# =>
# b = y - 2x + 4b
# 3b = 2x - y
# b = (2x - y) / 3
# a = (2y - x) / 3
if (2 * x - y) % 3 != 0 or (2 * y - x) % 3 != 0:
print(0)
return
a = (2 * x - y) // 3
b = (2 * y - x) // 3
if a < 0 or b < 0:
print(0)
return
# (a + b) C min(a, b)
# => (a + b)! / (min(a, b) ! * (a + b - min(a, b)) !
mod = 10**9 + 7
ans = (factorial_mod(a + b, mod) * pow(factorial_mod(min(a, b), mod), mod - 2, mod)
* pow(factorial_mod(a + b - min(a, b), mod), mod - 2, mod)) % mod
print(ans)
def factorial_mod(a, mod):
ans = 1
for v in range(1, a + 1):
ans *= v
ans %= mod
return ans
if __name__ == '__main__':
main()
|
N=int(input())
res=1
for i in range(1,N+1):
res=res*i
res=res%(10**9+7)
print(res) |
N = int(input())
A = list(map(int, input().split()))
flag = True
for n in A:
if n % 2 == 0 and (n % 3 != 0 and n % 5 != 0):
flag = False
print("APPROVED" if flag else "DENIED")
|
# coding: utf-8
ring = input()
pattern = input()
ring *= 2
if pattern in ring:
print('Yes')
else:
print('No') |
#!/usr/bin/env python3
import sys
import math
import decimal
import itertools
from itertools import product
from functools import reduce
INF = 10**19
def input():
return sys.stdin.readline()[:-1]
def sort_zip(a:list, b:list):
z = zip(a, b)
z = sorted(z)
a, b = zip(*z)
a = list(a)
b = list(b)
return a, b
def main():
W, H, x, y = map(int, input().split())
if x == W / 2 and y == H / 2:
print(W * H / 2, 1)
else:
print(W * H / 2, 0)
if __name__ == '__main__':
main()
|
def BubbleSort(A):
for i in range(len(A)):
for j in range(len(A)-1,i,-1):
if A[j][1] < A[j-1][1]:
# リストの要素の文字列は2次元配列として記憶される
A[j],A[j-1] = A[j-1],A[j]
return A
def SelectionSort(A):
for i in range(len(A)):
mini = i
for j in range(i,len(A)):
if A[j][1] < A[mini][1]:
mini = j
A[i],A[mini] = A[mini],A[i]
return A
N = int(input())
# example for input to array : H4 C9 S4 D2 C3 (from cards)
array = [i for i in input().split()]
array_cp = list(array)
result_bs = BubbleSort(array)
print(*result_bs)
print('Stable') # Bubble sort is stable
result_ss = SelectionSort(array_cp)
print(*result_ss)
if result_ss == result_bs:
print('Stable')
else:
print('Not stable')
|
import sys
input = sys.stdin.readline
from collections import *
def judge(x):
cnt = 0
for hi in h:
cnt += max(0, (hi-B*x+A-B-1)//(A-B))
return cnt<=x
def binary_search():
l, r = 0, 10**10
while l<=r:
m = (l+r)//2
if judge(m):
r = m-1
else:
l = m+1
return l
N, A, B = map(int, input().split())
h = [int(input()) for _ in range(N)]
print(binary_search()) |
#Macで実行する時
import sys
import os
if sys.platform=="darwin":
base = os.path.dirname(os.path.abspath(__file__))
name = os.path.normpath(os.path.join(base, '../atcoder/input.txt'))
#print(name)
sys.stdin = open(name)
from math import factorial
def combinations_count(n,r):
if n < r:
return 0
else:
return factorial(n) // ( factorial(n-r) * factorial(r))
n,m = map(int,input().split())
#print(combinations_count(n,2))
#print(combinations_count(m,2))
#print(factorial(0))
print(combinations_count(n,2) + combinations_count(m,2))
|
n = int(input())
if n == 2:
print(1)
quit()
elif n == 3:
print(2)
quit()
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
ans = 1
for l in factorization(n-1):
ans *= (l[1]+1)
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
return divisors
lst = make_divisors(n)
for i in lst:
if i == 1 or i == n:
continue
m = n
while m % i == 0:
m = m // i
if m % i == 1:
ans += 1
print(ans) |
def main():
parking_hour, fee_par_hour, flat_fee = map(int, input().split())
print(min(parking_hour * fee_par_hour, flat_fee))
if __name__ == '__main__':
main() |
class Dice:
def __init__(self, num_list):
self.faces = num_list
def find_rf(self, top, front):
tf = str(self.faces.index(top)) + str(self.faces.index(front))
if tf in '12431':
return self.faces[0]
elif tf in '03520':
return self.faces[1]
elif tf in '01540':
return self.faces[2]
elif tf in '04510':
return self.faces[3]
elif tf in '02530':
return self.faces[4]
else:
return self.faces[5]
num_list = tuple(map(int, input().split()))
dice = Dice(num_list)
q = int(input())
for i in range(q):
top, front = map(int, input().split())
right_face = dice.find_rf(top, front)
print(right_face) |
(a, b) = map(int, input().split())
print('a', end=' ')
print('<' if a < b else '==' if a==b else '>', end=' ')
print('b') |
a,b=map(int,input().split())
list=[2,3,4,5,6,7,8,9,10,11,12,13,1]
# print(list.index())
a_val=list.index(a)
b_val=list.index(b)
if a_val>b_val:print('Alice')
elif a_val<b_val:print('Bob')
else:print('Draw') |
s = list(input())
moji = []
if len(s)%2 == 0:
for i in range(len(s)//2):
moji.append(s[2*i])
else:
for i in range((len(s)+1)//2):
moji.append(s[2*i])
print("".join(moji))
|
class Dice():
state = [0 for _ in range(6)]
def __init__(self, dice_list):
self.state[0] = dice_list[0]
self.state[1] = dice_list[1]
self.state[2] = dice_list[2]
self.state[3] = dice_list[3]
self.state[4] = dice_list[4]
self.state[5] = dice_list[5]
def north(self):
tmp = self.state[0]
self.state[0] = self.state[1]
self.state[1] = self.state[5]
self.state[5] = self.state[4]
self.state[4] = tmp
def west(self):
tmp = self.state[0]
self.state[0] = self.state[2]
self.state[2] = self.state[5]
self.state[5] = self.state[3]
self.state[3] = tmp
def south(self):
tmp = self.state[0]
self.state[0] = self.state[4]
self.state[4] = self.state[5]
self.state[5] = self.state[1]
self.state[1] = tmp
def east(self):
tmp = self.state[0]
self.state[0] = self.state[3]
self.state[3] = self.state[5]
self.state[5] = self.state[2]
self.state[2] = tmp
if __name__ == '__main__':
L = list(map(int, input().split()))
actions = list(input())
dice = Dice(L)
for action in actions:
if action == 'N':
dice.north()
if action == 'W':
dice.west()
if action == 'S':
dice.south()
if action == 'E':
dice.east()
print(dice.state[0])
|
from math import sqrt
n = int(input())
p = 0
for i in range(n):
x = int(input())
if x == 2:
p += 1
elif x%2 == 1:
j=3
f = 0
while j < (int(sqrt(x))+1):
if x%j == 0:
f = 1
break
else:
j += 2
if f == 0:
p += 1
print(p)
|
a=int(input())
b=int(input())
if a>b:
print("GREATER");
elif a==b:
print("EQUAL");
elif a<b:
print("LESS"); |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.