text
stringlengths 37
1.41M
|
|---|
S = int(input())
b=S%100
a=S//100
if 1<=a<=12 and 1<=b<=12:
print('AMBIGUOUS')
elif 1<=a<=12:
print('MMYY')
elif 1<=b<=12:
print('YYMM')
else:
print('NA')
|
string = raw_input()
num_order = int(raw_input())
for i in range(num_order):
command = raw_input().split()
# print command
a, b = map(int, command[1:3])
if command[0] == "print":
print string[a:b+1]
elif command[0] == "reverse":
string = string[:a] + string[a:b+1][::-1] + string[b+1:]
elif command[0] == "replace":
p = command[-1]
string = string[:a] + p + string[b+1:] |
a,b = map(int,input().split())
if a==b:
print('Draw')
elif a==1 and b == 13:
print('Alice')
elif a==13 and b==1:
print('Bob')
elif a > b:
print('Alice')
elif b > a:
print('Bob') |
s=input()
l=list(s)
#print(l)
if(l[-1]=='s'):
l.append('e')
l.append('s')
else:
l.append('s')
#print(l)
str1=""
for i in l:
str1+=i
print(str1)
|
class Union_Find():
def __init__(self, n):
self.n = 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[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M,K=map(int,input().split())
A=[set() for _ in range(N+1)]
U=Union_Find(N+1)
for _ in range(M):
a,b=map(int,input().split())
A[a].add(b)
A[b].add(a)
U.union(a,b)
C=[set() for _ in range(N+1)]
for _ in range(K):
c,d=map(int,input().split())
C[c].add(d)
C[d].add(c)
S=[]
for k in range(1,N+1):
t=U.size(k)
for a in C[k]:
if U.find(a)==U.find(k):
t-=1
t-=len(A[k])
S.append(t-1)
print(" ".join(map(str,S)))
|
d = {}
n = int(input())
for _ in range(n):
a, b = input().split()
if a == 'insert':
d[b] = b
elif a == 'find':
print('yes' if b in d.keys() else 'no')
|
c = input()
v = ["a", "e", "i", "o", "u"]
if(any(i == c for i in v)):
print("vowel")
else:
print("consonant") |
a,b = input().split()
a = int(a)
b = int(b)
if a>b:
print("a > b")
elif a==b:
print("a == b")
else:
print("a < b")
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
def main():
n = int(input().strip())
a_list = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(a_list[n - 1])
if __name__ == '__main__':
main()
|
def main():
n = int(input())
x = int(n/1.08)
if int(x * 1.08) == n:
print(x)
elif int((x + 1) * 1.08) == n:
print(x + 1)
elif int((x - 1) * 1.08) == n:
print(x - 1)
else:
print(":(")
if __name__ == "__main__":
main() |
MOD = 1000000007
def fast_power(base, power):
"""
Returns the result of a^b i.e. a**b
We assume that a >= 1 and b >= 0
Remember two things!
- Divide power by 2 and multiply base to itself (if the power is even)
- Decrement power by 1 to make it even and then follow the first step
"""
result = 1
while power > 0:
# If power is odd
if power % 2 == 1:
result = (result * base) % MOD
# Divide the power by 2
power = power // 2
# Multiply base to itself
base = (base * base) % MOD
return result
n,k = [int(j) for j in input().split()]
d = dict()
ans = k
d[k] = 1
sum_so_far = 1
for i in range(k-1, 0, -1):
d[i] = fast_power(k//(i),n)
for mul in range(i*2, k+1, i):
d[i]-=d[mul]
# d[i] = max(1, d[i])
ans+=(i*d[i])%MOD
# if d[i]>1:
# sum_so_far += d[i]
print(ans%MOD)
|
import math
a, b = input().split()
n =int( a + b )
if int( n ** 0.5 ) ** 2 == n:
print('Yes')
else:
print('No')
|
def some():
n = int(input())
for i in range(9, 0, -1):
for j in range(9, 0, -1):
if i* j == n:
print("Yes")
exit()
print("No")
some() |
n = int(input())
s = []
for i in range(1, n+1):
if i % 3 == 0:
continue
elif i % 5 == 0:
continue
else:
s.append(i)
print(sum(s)) |
#!/usr/bin/env python3
x = int(input())
print((x // 11) * 2 + (2 if x % 11 > 6 else 1 if x % 11 != 0 else 0)) |
N = int(input(""))
if N <= 999:
print("ABC")
elif 1000 <= N <= 1998:
print("ABD")
else:
print("error")
|
import math
A,B,C = map(int,input().split())
if (B/A)>=C:
print(C)
elif (B/A)<C:
print(math.floor(B/A)) |
word = input()
if word[-1] == 's':
word += 'es'
else:
word += 's'
print(word) |
s = input()
for i in range(1,len(s)+1,2):
if s[i-1] == 'L':
print('No')
break
else:
for i in range(2,len(s)+1,2):
if s[i-1] == 'R':
print('No')
break
else:
print('Yes') |
x, y = [int(i) for i in input().split()]
if y % 2 == 0 and y <= x*4 and 2*x <= y:
print('Yes')
else:
print('No') |
N = int(input())
M = 10
ans = 0
if N % 2 == 0:
while N >= M:
ans += N//M
M *= 5
print(ans) |
# coding: utf-8
a=int(input())
b=int(input())
la=len(str(a))
lb=len(str(b))
if la>lb:
print('GREATER')
elif la<lb:
print('LESS')
else:
Flg=True
for i in range(la):
if int(str(a)[i])>int(str(b)[i]):
print('GREATER')
Flg=False
break
elif int(str(a)[i])<int(str(b)[i]):
print('LESS')
Flg=False
break
if Flg:
print('EQUAL') |
S = input()
if int(S[:2]) > 12 or int(S[:2]) == 0:
if int(S[2:]) > 12 or int(S[2:]) == 0: print('NA')
else: print('YYMM')
else:
if int(S[2:]) > 12 or int(S[2:]) == 0: print('MMYY')
else: print('AMBIGUOUS') |
def resolve():
ans = 0
for i in range(2):
a = int(input())
b = int(input())
if a < b:
ans += a
else:
ans += b
print(ans)
resolve() |
while True:
x = raw_input()
if x == "0":
break
else:
num = 0
for i in x:
num+=int(i)
print num
|
# coding= utf-8
rab=input("")
ab=rab.split(" ")
a=int(ab[0])
b=int(ab[1])
if a*b%2==0:
print("Even")
else:
print("Odd") |
def read_int():
return int(input().strip())
def read_ints():
return list(map(int, input().strip().split(' ')))
def solve():
"""
X+i+(i+1)+(i+2)+..
X < n*(n+1)//2
n*(n+1)//2-(n-1)*n//2 > n ?
n//2(2) > n ? false
"""
X = read_int()
if X == 1:
return 1
low, high = 1, 10**9
while high-low > 1:
mid = low+(high-low)//2
if mid*(mid+1)//2 >= X:
high = mid
else:
low = mid
if high*(high+1)//2 == X:
return high
return high
if __name__ == '__main__':
print(solve())
|
round = int(input(""))
for i in range (0,round):
arr = []
temp = input("")
a,b,c = temp.split(" ")
arr.append(int(a))
arr.append(int(b))
arr.append(int(c))
arr.sort()
if(pow(arr[0],2)+pow(arr[1],2)==pow(arr[2],2)):
print("YES")
else:
print("NO")
|
x,a,b = [int(x) for x in input().split()]
if a-b >= 0:
print("delicious")
elif b-a > 0 and b-a <= x:
print("safe")
else:
print("dangerous") |
def swap(m, n, items):
x = items[n]
items[n] = items[m]
items[m] = x
ABC = input().split()
if ABC[0] > ABC[1]:
swap(0, 1, ABC)
if ABC[1] > ABC[2]:
swap(1, 2, ABC)
if ABC[0] > ABC[1]:
swap(0, 1, ABC)
elif ABC[1] > ABC[2]:
swap(1, 2, ABC)
if ABC[0] > ABC[1]:
swap(0, 1, ABC)
print(ABC[0], ABC[1], ABC[2]) |
s = input() * 2
p = input()
if s.find(p) == -1:
print('No')
else:
print('Yes') |
import math
r=float(input())
print(f'{math.pi*r**2} {2*math.pi*r}')
|
# coding: utf-8
str = input()
count = 0
table = list(str)
for i in range(len(str) - 1):
for j in range(i+1, len(str)):
if table[i] == table[j]:
count += 1
if count == 0:
print("yes")
else:
print("no") |
x = input("")
for i in range(3):
alist = list(map(int,x))
result = sum(alist)
x = str(result)
if result % 9 == 0 :
print("Yes")
else:
print("No") |
def merge(A, left, mid, right):
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(1000000001)
R.append(1000000001)
i = 0
j = 0
for k in xrange(left, right):
global cnt
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)
return A
n = int(raw_input())
S = map(int, raw_input().split())
cnt = 0
A = mergeSort(S, 0, n)
for i in xrange(len(A)-1):
print(A[i]),
print A[len(A) - 1]
print cnt |
def bubble_sort(A, N):
sw = 0
flag = True
while flag:
flag = False
for j in reversed(range(1, N)):
if A[j - 1] > A[j]:
A[j - 1], A[j] = A[j], A[j - 1]
sw += 1
flag = True
return sw
def main():
N = int(input().rstrip())
A = list(map(int, input().rstrip().split()))
sw = bubble_sort(A, N)
print(' '.join(map(str, A)))
print(sw)
if __name__ == '__main__':
main() |
h=int(input())
hh=h
ans=1
while(1<h):
h//=2
ans*=2
if h==1:
ans+=ans
if hh==1:
print(1)
else:
print(ans-1)
|
# 種類が同じ寿司であれば、最も美味しさが高い寿司を選ぶべき。
# 従い、
# (1)各種類の最も美味しさが高い寿司グループ
# (2)それ以外の寿司グループ
# をいずれも降順に並べて、(1)から幾つ取るか(最低でも1つは取る)を全探索する
import sys
readline = sys.stdin.readline
N,K = map(int,readline().split())
from collections import defaultdict
sushi = defaultdict(list) # 種類・おいしさ のdictionary
for i in range(N):
t,d = map(int,readline().split())
sushi[t].append(d)
best_sushi = []
other_sushi = []
for value in sushi.values():
value = sorted(value, reverse = True)
best_sushi.append(value[0])
other_sushi += value[1:]
best_sushi = sorted(best_sushi, reverse = True)
other_sushi = sorted(other_sushi, reverse = True)
best_num = 1 # best_sushiから選ぶ個数
other_num = K - 1 # other_sushiから選ぶ個数
if len(other_sushi) < other_num: # 選べない場合
other_num = len(other_sushi)
best_num = K - other_num
# それぞれの寿司から選ぶ個数の開始値が決定
# other_sushiの後ろの要素は切り離して良い
other_sushi = other_sushi[:other_num]
sushi_point = sum(best_sushi[:best_num]) + sum(other_sushi)
kind_point = best_num ** 2
ans = sushi_point + kind_point
# best寿司のインデックスを進めていく
for i in range(best_num, len(best_sushi)):
sushi_point += best_sushi[i]
if len(other_sushi) == 0:
break
rem = other_sushi.pop() # 取り除く寿司
sushi_point -= rem
kind_point = (i + 1) ** 2
if ans < sushi_point + kind_point:
ans = sushi_point + kind_point
print(ans) |
def main():
S = input()
lst = []
for i in range(1, 100):
lst.append('hi' * i)
for it in lst:
if S == it:
print('Yes')
return
print('No')
if __name__ == '__main__':
main() |
s = input()
if 'AAA' in s or 'BBB' in s:
print('No')
else:
print('Yes') |
H, W = map(int, input().split())
scr_list = [input() for _ in range(H)]
print('#' * (W+2))
for i in scr_list:
print('#' + i + '#')
print('#' * (W+2)) |
r = int(input())
if 0 <= r < 1200:
print('ABC')
elif 1200 <= r < 2800:
print('ARC')
elif 2800 <= r <= 4208:
print('AGC')
else:
print('hoge!') |
numbers = []
while True:
x=int(input())
if x==0:
break
numbers.append(x)
for i in range(len(numbers)):
print("Case ",i+1,": ",numbers[i],sep="")
|
def abc106_b():
n = int(input())
have_8_divisors = 0
def count_up_divisor(check_num):
cnt = 0
for i in range(1, check_num + 1):
# 1からcheck_numを順に探索して、nの約数かどうか判断して、約数の時はカウント
if check_num % i == 0:
cnt += 1
return cnt
for i in range(1, n + 1):
# 偶数の時はスキップ
if i % 2 == 0:
continue
result = count_up_divisor(i) == 8
if result:
have_8_divisors += 1
print(have_8_divisors)
if __name__ == '__main__':
abc106_b() |
#!/usr/local/bin/python3
# https://atcoder.jp/contests/abc086/tasks/abc086_b
import math
a, b = input().split()
if math.sqrt(int(a+b)).is_integer():
print("Yes")
else:
print("No")
|
def check(mlist, s):
if len(mlist) == 13:
return 0
else:
lack = []
for i in range(1, 14):
if not i in mlist:
lack.append(i)
#print(lack)
for j in lack:
print("{} {}".format(s, j))
return 0
n = int(input())
Slist = []
Hlist = []
Clist = []
Dlist = []
for i in range(n):
mark, num = input().split()
num = int(num)
if mark == 'S':
Slist.append(num)
elif mark == 'H':
Hlist.append(num)
elif mark == 'C':
Clist.append(num)
else:
Dlist.append(num)
Slist.sort()
Hlist.sort()
Clist.sort()
Dlist.sort()
check(Slist, 'S')
check(Hlist, 'H')
check(Clist, 'C')
check(Dlist, 'D')
|
h = int(input())
ans = 0
t = 1
while h > 0:
h //= 2
ans += t
t *= 2
print(ans)
|
S = list(input())
T = list(input())
def compare(s, t):
if len(s) != len(t): return False
res = True
for i in range(len(s)):
res &= (s[i] == t[i] or s[i] == '?')
return res
n = len(S)
m = len(T)
pos = -1
for i in range(n):
if compare(S[i:i+m], T):
pos = i
if pos == -1:
print('UNRESTORABLE')
else:
S[pos:pos+m] = T
S = ''.join(S)
S = S.replace('?', 'a')
print(S) |
x = input().split()
a = x[0]
b = x[1]
c = int(a) * int(b)
d = c % 2
if d == 0:
print('Even')
else:
print('Odd')
|
s=input()
ans="AC"
if s[0]!='A' or s[-1]=='C' or s[1]<'a':ans="WA"
else:
count=0
for i in range(2,len(s)):
if s[i]<'a':
if s[i]=='C':count+=1
else:count+=2
if count!=1:ans="WA"
print(ans)
|
while True:
H,W = map(int, input().split())
if H==0 and W==0: break
for y in range(0,H):
for x in range(0,W):
if y==0 or y==H-1: print("#",end="")
else:
if x == 0 or x==W-1: print("#",end="")
else: print(".",end="")
print()
print()
|
n = raw_input()
m =n.split(" ")
a = int(m[0])
b = int(m[1])
c = int(m[2])
if a < b < c :print "Yes"
else :print "No" |
N = int(input())
S = input()
ans = 'No'
if len(S) % 2 == 0 and S[0:int(N/2)] == S[int(N/2):N]:
ans = 'Yes'
print(ans) |
num = int(input())
arr = list(map(int, input().split()))
def merge(arr, left, middle, right, count):
L = arr[left:middle]
L.append(float('inf'))
R = arr[middle:right]
R.append(float('inf'))
iterL, iterR = iter(L), iter(R)
l,r = next(iterL), next(iterR)
for index in range(left, right):
count += 1
if l <= r:
arr[index] = l
l = next(iterL)
else:
arr[index] = r
r = next(iterR)
return count
def merge_sort(arr, left, right, count):
if left + 1 < right:
pivot = (left + right) // 2
count = merge_sort(arr, left, pivot, count)
count = merge_sort(arr, pivot, right, count)
count = merge(arr, left, pivot, right, count)
return count
count = merge_sort(arr, 0, num, 0)
print(" ".join(list(map(str, arr))))
print(count)
|
class Dice(object):
"""Dice Class
"""
def __init__(self, numbers):
"""
Args:
numbers:
"""
self.numbers = {1: numbers[0], 2: numbers[1], 3: numbers[2], 4: numbers[3], 5: numbers[4], 6: numbers[5]}
self.vertical = [self.numbers[1], self.numbers[2], self.numbers[6], self.numbers[5]]
self.horizontal = [self.numbers[4], self.numbers[1], self.numbers[3], self.numbers[6]]
def move_dice(self, s):
"""
Args:
s: move direction
Returns:
"""
if s == 'N':
self.move_north()
elif s == 'S':
self.move_south()
elif s == 'W':
self.move_west()
elif s == 'E':
self.move_east()
def move_south(self):
"""move this dice towered north
"""
self.vertical = (self.vertical * 2)[3:7]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
def move_north(self):
"""move this dice towered south
"""
self.vertical = (self.vertical * 2)[1:5]
self.horizontal[1] = self.vertical[0]
self.horizontal[3] = self.vertical[2]
def move_east(self):
"""move this dice towered east
"""
self.horizontal = (self.horizontal * 2)[3:7]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
def move_west(self):
"""move this dice towered west
"""
self.horizontal = (self.horizontal * 2)[1:5]
self.vertical[0] = self.horizontal[1]
self.vertical[2] = self.horizontal[3]
def get_top(self):
return self.vertical[0]
numbers = [int(x) for x in raw_input().split()]
dice1 = Dice(numbers=numbers)
for s in raw_input():
dice1.move_dice(s)
print(dice1.get_top()) |
print("Yes" if eval(input().replace(" ","-"))==0 else "No") |
n = list(input())
denominator_ = sum( list(map(int, n)) )
molecule____ = int( "".join(n) )
if molecule____ % denominator_ == 0:
print("Yes")
else:
print("No")
|
from heapq import heappush, heappop
class Dijkstra:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
self.E[init].append((end, weight))
if undirected: self.E[end].append((init, weight))
def distance(self, s):
INF = float('inf')
E, N = self.E, self.N
self.dist = dist = [INF] * N # the distance of each vertex from s
self.prev = prev = [-1] * N # the previous vertex of each vertex on a shortest path from s
dist[s] = 0
n_visited = 1 # #(visited vertices)
heap = []
heappush(heap, (0, s))
while heap:
d, v = heappop(heap)
if dist[v] < d: continue
for u, c in E[v]:
temp = d + c
if dist[u] > temp:
dist[u] = temp; prev[u] = v
heappush(heap, (temp, u))
n_visited += 1
if n_visited == N: break
return dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1: break
return P[::-1]
N, M = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(M)]
S, T = map(int, input().split())
dijkstra = Dijkstra(3 * N)
for a, b in edges:
a, b = a - 1, b - 1
dijkstra.add_edge(a, N + b, 0)
dijkstra.add_edge(N + a, 2 * N + b, 0)
dijkstra.add_edge(2 * N + a, b, 1)
ans = dijkstra.distance(S - 1)[T - 1]
print(ans if ans != float('inf') else -1) |
# input
S = input()
# check
yy, mm, dd = S.split("/")
if int(yy) >= 2019 and int(mm) >= 5:
print("TBD")
else:
print("Heisei") |
#!/usr/bin/env python3
s = input()
if s == "1":
print("Hello World")
exit()
else:
a = int(input())
b = int(input())
print(a + b) |
# -*- coding: utf-8 -*-
s = str(input())
dic = {'SUN':7, 'MON':6, 'TUE':5, 'WED':4, 'THU':3, 'FRI':2, 'SAT':1}
print(dic[s]) |
H, W=map(int, input().split())
cnt=0
for _ in range(H):
a=list(input())
cnt+=a.count("#")
if cnt==(H+W-1):
print("Possible")
else:
print("Impossible")
|
N = input()
h = list('24579')
p = list('0168')
if N[-1] in h:
o = 'hon'
elif N[-1] in p:
o = 'pon'
else:
o = 'bon'
print(o) |
def prime_factorize(N):
res = [0] * (N+1)
for n in range(2,N+1):
a = 2
while a*a <= n:
if n % a == 0:
ex = 0
while n % a == 0:
ex += 1
n //= a
#res.append((a, ex))
res[a] += ex
a += 1
if n != 1:
res[n] += 1
return res
N = int(input())
prime = prime_factorize(N)
mod = 10 ** 9 + 7
ret = 1
for i in prime:
ret *= (i+1)
ret %= mod
print(ret)
|
n=int(input())
def fibonacci(n):
fib = [2, 1]
for i in range(2, n):
fib.append(fib[i - 2] + fib[i - 1])
return fib[n -1]
print(fibonacci(n+1)) |
def bubble(d):
for i in range(len(d) - 1):
for j in range(len(d) - 1, i, -1):
if int(d[j][1]) < int(d[j - 1][1]):
d[j],d[j - 1] = d[j - 1],d[j]
def selection(d):
for i in range(len(b)):
min_j = i
for j in range(i, len(d)):
if int(d[j][1]) < int(d[min_j][1]):
min_j = j
if min_j != i:
d[i],d[min_j] = d[min_j], d[i]
n = int(input())
a = list(map(str, input().split()))
b = a.copy()
c = a.copy()
bubble(b)
selection(c)
for d in [b, c]:
print(" ".join(d))
if d == b:
print("Stable")
else:
print("Not stable") |
S = input()
es =''
for s in S:
if s == '1' or s == '0':
es+=s
else:
if es != '':
es=es[:-1]
print(es) |
n = int(input())
a = list(map(int,input().split()))
even_list = []
for i in range(n):
if a[i] % 2 == 0:
even_list.append(a[i])
x = 0
for m in range(len(even_list)):
if even_list[m] % 3 == 0 or even_list[m] % 5 == 0:
x += 1
if x == len(even_list):
print('APPROVED')
else:
print('DENIED') |
s = input()
if s.__len__() == 3:
print(s[::-1])
else:
print(s)
|
#!/usr/bin/env python3
import sys
import math
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def generate_primes(n):
if n < 2:
return []
is_prime_array = [True] * (n + 1)
is_prime_array[0], is_prime_array[1] = False, False
for i in range(2, n+1):
if is_prime_array[i]:
k = 2 * i
while k < n + 1:
is_prime_array[k] = False
k += i
return list(filter(lambda i: is_prime_array[i], range(n+1)))
def main():
N = II()
if N <= 1:
print(0)
exit()
max_prime = math.ceil(N**0.5)
primes = generate_primes(max_prime)
es = [0] * len(primes)
for i in range(len(primes)):
while N % primes[i] == 0:
N /= primes[i]
es[i] += 1
ans = 0
if int(N) != 1:
ans += 1
for i in range(len(es)):
k = 1
while es[i] - k >= 0:
es[i] -= k
k += 1
ans += 1
print(ans)
main()
|
n = int(input())
s = [str(i) for i in input().split()]
a = set(s)
if len(a) == 3:
print('Three')
else:
print('Four') |
w=input().lower()
c=[]
s=input()
while(s!='END_OF_TEXT'):
c+=s.lower().split();
s=input()
print(len([x for x in c if x==w]))
|
def readinput():
n,k=map(int,input().split())
return n,k
def main(n,k):
ans=0
for i in range(1,n+1):
p=1/n
point=i
while(point<k):
point*=2
p/=2
#print(p)
ans+=p
return ans
if __name__=='__main__':
n,k=readinput()
ans=main(n,k)
print(ans)
|
def BubbleSort(A):
#tot = 0
flag = 1
N = len(A)
while flag:
flag = 0
for j in xrange(N-1,0,-1):
if A[j][1] < A[j-1][1]:
A[j],A[j-1] = A[j-1],A[j]
flag = 1
#tot += 1
return A #,tot
def SelectionSort(A):
N = len(A)
m = 0
for i in range(N):
minj = i
for j in range(i,N):
if A[j][1] < A[minj][1]:
minj = j
A[i],A[minj] = A[minj],A[i]
if i != minj:
m += 1
return A
N = int(raw_input())
ls = raw_input().split()
tmp = BubbleSort(list(ls))
print ' '.join(map(str,tmp))
print 'Stable'
tmp2 = SelectionSort(list(ls))
print ' '.join(map(str,tmp2))
for k,j in zip(tmp,tmp2):
if k != j:
print 'Not stable'
break
else:
print 'Stable' |
x = int(input())
'''
t = 1, 2, 3, 4, 5, 6,...
d+ = 1, 3, 6,10,15,21,...
x = 11のとき、
t = 5,d+ = 15より、t = 4で一回休みすればいい
-> 行き過ぎたら一回休み
'''
i = 0
d = 0
while True:
i += 1
d += i
if x <= d:
ans = i
break
print(ans) |
X, A, B = list(map(int, input().split()))
if A - B >= 0:
print('delicious')
elif A + X - B >= 0:
print('safe')
else:
print('dangerous') |
import math
x, y = map(int, input().split())
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(x,y):
return (x * y)//gcd(x, y)
def thingo(x,y):
if (x == 0 and y == 0):
return -1
if (x != 0 and y == 0):
return x
test = lcm(x,y)
if (test-x >= x):
return test-x
else:
return -1
print(thingo(x,y))
|
a = list(input())
b = list(input())
c = 0
if len(a) > len(b):
c = 1
elif len(a) < len(b):
c = 2
else:
for i in range(len(a)):
if int(a[i]) > int(b[i]):
c = 1
break
elif int(a[i]) < int(b[i]):
c = 2
break
if c == 0:
print("EQUAL")
elif c == 1:
print("GREATER")
else:
print("LESS") |
def solve():
N = int(input())
xlist = []
for i in range(N):
x, u = input().split()
x = float(x)
if u == "BTC":
xlist.append(x*380000.0)
else:
xlist.append(x)
print(sum(xlist))
if __name__ == "__main__":
solve()
|
def main(heads, foots):
"""
- foots != odd
- 2*heads <= foots <= 4*heads
"""
if foots%2 == 1:
return 'No'
else:
if 2*heads <= foots <= 4*heads:
return 'Yes'
else:
return 'No'
if __name__ == '__main__':
heads, foots = map(int, input().split())
ans = main(heads, foots)
print(ans)
|
def main():
num = list(map(int,input().split()))
if num[0]%3==0 or num[1]%3==0 or (num[0]+num[1])%3==0:
print('Possible')
else:
print('Impossible')
main() |
def dfs(s,n,adj):
adj = 'abcdefghij'
if len(s) == n:
print(s)
else:
for child in adj[:len(set(s))+1]:
dfs(s+child,n,adj)
return -1
def main():
import sys
def input(): return sys.stdin.readline().rstrip()
n = int(input())
adj = 'abcdefghij'
dfs('a',n,adj)
if __name__ == '__main__':
main() |
x = int(input())
def Main(x):
return "ABC" if x < 1200 else "ARC"
print(Main(x))
|
def call(n):
"""
n: int
output numbers that is multiple of 3 or include '3' (1 <= number <= n)
>>> call(30)
3 6 9 12 13 15 18 21 23 24 27 30
"""
line = ''
for i in range(1, n+1):
x = i
if x % 3 == 0:
line += ' ' + str(i)
continue
while x > 0:
if x % 10 == 3:
line += ' ' + str(i)
break
x //= 10
print(line)
if __name__ == '__main__':
i = int(input())
call(i) |
string = input()
if string[-1] == 's':
out = string + "es"
else:
out = string + "s"
print(out) |
d=input()
arr = [int(i) for i in d.split()]
t1 = arr[0]/arr[-1]
if t1<= arr[1]:
print("Yes")
else:
print("No")
|
#!/usr/bin/env python3
import sys
from itertools import chain
YES = "Yes" # type: str
NO = "No" # type: str
def solve(S: str, T: str):
return YES if T[: len(S)] == S else NO
def main():
tokens = chain(*(line.split() for line in sys.stdin))
S = next(tokens) # type: str
T = next(tokens) # type: str
answer = solve(S, T)
print(answer)
if __name__ == "__main__":
main()
|
a = 1
while a<10:
b=1
while b<10:
print(str(a)+'x'+str(b)+'='+str(a*b))
b=b+1
a=a+1 |
S = input()
first_0 = 0
first_1 = 0
for i, s in enumerate(S):
if i % 2 == 0:
if s == "0":
first_1 += 1
else:
first_0 += 1
else:
if s == "0":
first_0 += 1
else:
first_1 += 1
print(min(first_0, first_1)) |
S = list(input())
flag = True
while flag == True:
if len(S) == 0:
break
if len(S) >= 5:
if S[-5:] == list("dream"): del S[-5:]
elif S[-5:] == list("erase"): del S[-5:]
elif len(S)>=6 and S[-6:] == list("eraser"): del S[-6:]
elif len(S)>=7 and S[-7:] == list("dreamer"): del S[-7:]
else:
flag = False
else:
flag = False
if flag:
print("YES")
else:print("NO") |
n=int(input())
suit = ["S","H","C","D"]
card = {i:[] for i in suit}
for i in range(n):
tmp = ([c for c in input().split()])
card[tmp[0]].append(tmp[1])
for i in suit:
for j in range(1,14):
if not (str(j) in card[i]):
print("%s %s" % (i,j)) |
a = list(input())
b = list(input())
a.sort()
b.sort()
b = sorted(b, reverse=True)
a = ''.join(a)
b = ''.join(b)
print('Yes') if a < b else print('No')
|
k = int(input())
if k == 1:
print("ACL")
if k == 2:
print("ACLACL")
if k == 3:
print("ACLACLACL")
if k == 4:
print("ACLACLACLACL")
if k == 5:
print("ACLACLACLACLACL") |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**8)
INF = float("inf")
from collections import Counter
def factorial(n):
prime_count = Counter()
for i in range(2, int(n**0.5) + 2):
while n % i == 0:
n /= i
prime_count[i] += 1
if n > 1:
prime_count[int(n)] += 1
return prime_count
def num_divisors(prime_count):
num = 1
for prime, count in prime_count.items():
num *= (count + 1)
return num
def divisors(n):
ret = set()
for i in range(1, int(n ** 0.5) + 1):
d, m = divmod(n, i)
if m == 0:
ret.add(i)
ret.add(d)
return sorted(ret)
def solve(N: int):
f = factorial(N-1)
ans = num_divisors(f)-1
divs = divisors(N)
for k in divs:
if k == 1:
continue
n = N
while n % k == 0:
n = n//k
if n == 1:
break
if n % k == 1:
ans += 1
print(ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
solve(N)
if __name__ == '__main__':
main()
|
s = str(input())
if 1 <= s.count('AB') or 1 <= s.count('BA'):
print('Yes')
else:
print('No') |
#!/usr/bin/env python
n = int(input())
if n == 0:
print(0)
exit()
ans = ''
while abs(n) > 0:
r = n%2
ans = str(r) + ans
if r == 1:
n -= 1
n //= (-2)
print(ans)
|
x = int(input())
a = int(input())
b = int(input())
if x - a >= 0:
x = x - a
num = x // b
x = x - num * b
print(x) |
# usr/bin/python
# coding: utf-8
################################################################################
#Write a program which prints multiplication tables in the following format:
#
#1x1=1
#1x2=2
#.
#.
#9x8=72
#9x9=81
#
################################################################################
if __name__ == "__main__":
for i in range(1, 10):
for j in range(1, 10):
print("{0}x{1}={2}".format(i,j,i*j))
exit(0) |
n = int(input())
a = list(map(int, input().split()))
pivots = (sorted(a)[n//2-1], sorted(a)[n//2])
# print(pivots)
for el in a:
if el <= pivots[0]:
print(pivots[1])
else:
print(pivots[0]) |
#Z-Algorithm
#文字列が与えられた時、各 i について「S と S[i:] の最長共通接頭辞の長さ」を記録した配列 A を O(len(S)) で構築するアルゴリズム
#s : 文字列
#あとで要復習！
def z_algorithm(s):
N = len(s)
z_alg = [0]*N
z_alg[0] = N
i = 1
j = 0
while i < N:
while i+j < N and s[j] == s[i+j]: # 伸ばせるだけ伸ばす
j += 1
z_alg[i] = j
if j == 0:
i += 1
continue
k = 1
while i+k < N and k+z_alg[k] < j: # 今までで求められている場所ならば計算を省略
z_alg[i+k] = z_alg[k]
k += 1
i += k
j -= k
return z_alg
n = int(input())
S = input()
max_ = 0
for i in range(n):
k = S[i:len(S)]
li = z_algorithm(k)
for j in range(len(li)):
if li[j] < j+1:
max_ = max(max_, li[j])
print(max_) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.