text
stringlengths 37
1.41M
|
|---|
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import defaultdict
class UnionFind():
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):
self.all_group_member=defaultdict(list)
for i in range(self.n):
self.all_group_member[self.find(i)].append(i)
return self.all_group_member
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def main():
h, w = map(int, input().split())
s = [list(input()) for i in range(h)]
uf = UnionFind(h*w)
for i in range(h):
for j in range(w):
if i != h-1:
if s[i][j] != s[i+1][j]:
uf.union((i*w)+j, (i*w)+j+w)
if j != w-1:
if s[i][j] != s[i][j+1]:
uf.union((i*w)+j, (i*w)+j+1)
ans=0
for item in uf.all_group_members().values():
A=0
B=0
for grid in item:
i,j=divmod(grid,w)
if s[i][j]=='.':
A+=1
else:
B+=1
ans+=A*B
print(ans)
if __name__ == '__main__':
main() |
s=input()
yn=0
for i in range(len(s)-1):
if s[i:i+2]=="AC":
yn=1
break
if yn==1:
print("Yes")
else:
print("No")
|
import math
def is_prime(num):
if num == 2:
return True
elif not num & 1:
return False
for i in range(3, math.ceil(math.sqrt(num))+1, 2):
if num % i == 0:
return False
return True
N = int(input())
nums = [int(input()) for _ in range(N)]
ans = len([num for num in nums if is_prime(num)])
print(ans) |
H, W = map( int, input().split() )
h_set = set()
w_set = set()
B = [input() for i in range(H)]
for i in range(H):
for j in range(W):
if B[i][j] == '#':
w_set.add(j)
h_set.add(i)
for i in range(H):
if i in h_set:
t = ""
for j in range(W):
if j in w_set:
t += B[i][j]
print(t) |
# -*- coding: utf-8 -*-
from collections import deque
N = int(input())
q = deque()
for i in range(N):
lst = input().split()
command = lst[0]
if command == 'insert':
q.appendleft(lst[1])
elif command == 'delete':
try:
q.remove(lst[1])
except Exception:
pass
elif command == 'deleteFirst':
q.popleft()
elif command == 'deleteLast':
q.pop()
print(*q) |
def main():
n = list(str(input()))
ans = ''
for i in n:
if i == '1':
ans = ans + '9'
else:
ans = ans + '1'
print(int(ans))
main() |
text = raw_input()
ans = ""
for s in text:
if s.isalpha():
ans += s.upper() if s.islower() else s.lower()
else:
ans += s
print ans |
def selection_sort(a,n):
m=0
for i in range(0,n):
minj=i
for j in range(i,n):
if(a[minj] > a[j]):
minj=j
if(minj!=i):
m+=1
#print("swap(%d<->%d)"%(a[ninj],a[i]))
a[minj],a[i] = a[i],a[minj]
b=list(map(str,a))
print(" ".join(b))
print(m)
a=[]
n=int(input())
s=input()
a=list(map(int,s.split()))
selection_sort(a,n) |
n=int(input())
s=input()
x=s[int(input())-1]
for i in range(n):
if s[i]!=x:
print("*",end="")
else:
print(x,end="") |
def hi():
a = input()
key = ""
for i in range(len(a)):
if a[i]=='0':
key += '0'
elif a[i]=='1':
key += '1'
elif a[i]=='B':
if len(key) == 0:
continue
else:
key = key[0:-1]
print(key)
hi() |
variables = [int(i) for i in input().split()]
for i in range(5) :
if variables[i]==0 :
print(i+1) |
import math
r = float(input())
c = r * r *math.pi
cf = r *2 *math.pi
a = ("{0:.5f} {1:.5f}".format(c,cf))
print(a) |
N = int(input())
a = 2
b = 1
ans = 0
if N == 1:
ans = 1
else:
for i in range(N-1):
b, a = a + b, b
ans = b
print(ans)
|
from time import time
def timer(func):
def f(*args, **kwargs):
before = time()
rv = func(*args, **kwargs)
after = time()
print('temps écoulé', after - before)
return rv
return f
def A(S):
nb = 0
if S == 'RSR':
print(1)
exit
else:
for i in S:
if i == 'R':
nb = nb+1
print(nb)
@timer
def B():
...
@timer
def C():
...
S = input()
A(S)
|
x = ord(input())
if x <= 90:
print('A')
else:
print('a') |
N = int(input())
S = 'Christmas'
for i in range(25-N):
S = S + ' Eve'
print(S) |
#!/usr/bin/env python
import copy
def bubble_sort(card, N):
for i in range(0, N):
for j in range(N-1, i, -1):
if value(card[j]) < value(card[j-1]):
card[j], card[j-1] = card[j-1], card[j]
return " ".join(map(str, card))
def selection_sort(card, N):
for i in range(0, N):
minj = i
for j in range(i, N):
if value(card[j]) < value(card[minj]):
minj = j
card[i], card[minj] = card[minj], card[i]
return " ".join(map(str, card))
# check method
# insertion sort is a stable sort.
def insertion_sort(card, N):
for i in range(1, N):
v = card[i]
j = i - 1
while j >= 0 and value(card[j]) > value(v):
card[j+1] = card[j]
j -= 1
card[j+1] = v
return " ".join(map(str, card))
def value(elem):
return elem[1]
def main():
size = int(input())
line = input().split()
gold_standard = insertion_sort(copy.deepcopy(line), copy.deepcopy(size))
bubble_ans = bubble_sort(copy.deepcopy(line), copy.deepcopy(size))
print(bubble_ans)
if bubble_ans == gold_standard:
print('Stable')
else:
print('Not stable')
selection_ans = selection_sort(copy.deepcopy(line), copy.deepcopy(size))
print(selection_ans)
if selection_ans == gold_standard:
print('Stable')
else:
print('Not stable')
if __name__ == '__main__':
main() |
st = raw_input()
ans = ''
for ch in st:
if ch.islower():
ans += ch.upper()
elif ch.isupper():
ans += ch.lower()
else:
ans += ch
print ans |
import sys
def input(): return sys.stdin.readline().strip()
def main():
N = int(input())
A = (int(input()) for _ in range(N))
print("second") if all(( a%2==0 for a in A)) else print("first")
if __name__ == "__main__":
main() |
x, y = [int(s) for s in input().split()]
temp_list = [{1, 3, 5, 7, 8, 10, 12}, {4, 6, 9, 1}, {2}]
ans = "No"
for temp in temp_list:
if x in temp and y in temp:
ans = "Yes"
print(ans) |
A, B = list(map(int, input().split()))
large = A if A > B else B
small = A if A < B else B
def gcd(large, small):
r = large % small
while r != 0:
large = small
small = r
r = large % small
return small
print(large*small//gcd(large, small))
|
S = input()
if "N" in S:
if "S" not in S:
print("No")
elif "E" in S:
if "W" not in S:
print("No")
else:
print("Yes")
else:
if "W" in S:
print("No")
else:
print("Yes")
else:
if "S" in S:
print("No")
elif "E" in S:
if "W" not in S:
print("No")
else:
print("Yes")
else:
if "W" in S:
print("No")
else:
print("Yes") |
a,b=map(int,input().split())
if a==0 or b==0 or abs(a)==b or (a<0 and b>0):
print('Zero')
elif a>0 or b>0:
print('Positive')
else:
if (abs(a)+abs(b))%2==0:
print('Negative')
else:
print('Positive')
|
string = list(input())
times = int(input())
#a = [int(i) for i in range(0,5)]
#print(a)
for i in range(times):
order = input().split()
#print(order)
if order[0] == "replace":
replace_string = order[3]
#print(string)
count = 0
for j in range(int(order[1]), int(order[2]) + 1):
string[j] = replace_string[count]
count += 1
#print(count)
#print(string)
elif order[0] == "reverse":
#print(string)
reverse_string = string[int(order[1]):int(order[2]) + 1]
reverse_string.reverse()
#for j in range(int(order[1]), int(order[2]) + 1):
# string[j] = reverse_string[j]
string = string[:int(order[1])] + reverse_string + string[int(order[2])+1:]
#print(j)
#print(string)
#string[int(order[1]):int(order[2]) + 1].reverse()
#print(string)
#string[int(order[1]):int(order[2])] = string[int(order[1]):int(order[2])].reverse()
elif order[0] == "print":
#print(string)
print("".join(string[int(order[1]):int(order[2]) + 1]))
#print(string) |
# coding: utf-8
# Your code here!
N=int(input())
count=-1
for i in range(N//2+1):
count+=1
if N%2==0:
print(count-1)
else:
print(count) |
N = input()
cnt = 0
for i in N:
if i == "2":cnt+=1
print(cnt) |
x,a,b =map(int,input().split())
if b <= a: print("delicious")
elif b <= a+x: print("safe")
else: print("dangerous") |
n=input()
if int(n)<=999:
print('ABC')
else:
print('ABD')
|
s = input()
if len(s) == 3:
s = s[::-1]
print(s) |
import re
s = input()
s = s[::-1]
#print(s)
match = re.match('((remaerd)|(maerd)|(resare)|(esare))*',s)
#print(match)
#print(match.group())
if match.group() == s:
print('YES')
else:
print('NO') |
s=input()
t=0
if s[0]=="A":
if(s[2:-1].count("C")==1):
for i in s:
if i!="A" and i!="C":
if i.isupper():
t=0
break
else:
t=1
if t==0:
print("WA")
else:
print("AC")
|
# coding: utf-8
a,b=input().split()
m=int(a)+int(b)
if m<10:
print(int(m))
else:
print("error") |
from numpy import sqrt, round
a, b = input().split(' ')
ans = sqrt(int(a + b))
if ans == round(ans):
print('Yes')
else:
print('No') |
import math
if __name__ == '__main__':
def manh(x, y):
d = 0
for i, j in zip(x, y):
d += abs(int(i)-int(j))
return d
def uqurid(x, y):
d = 0
for i, j in zip(x, y):
d += abs(int(i)-int(j))**2
return math.sqrt(d)
def minco(x, y):
p = 3
d = 0
for i, j in zip(x, y):
d += abs(int(i)-int(j))**p
return d**(1/p)
def ebis(x, y):
d = 0
for i, j in zip(x, y):
d = max(d, abs(int(i)-int(j)))
return d
n = int(input())
x = input().split()
y = input().split()
print(manh(x, y))
print(uqurid(x, y))
print(minco(x, y))
print(ebis(x, y))
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
n = int(input())
r = False
for i in range(1,10):
if n % i == 0:
if n // i < 10:
r = True
break
if r:
print('Yes')
else:
print('No')
|
while True:
s = input().split(" ")
a = int(s[0])
op = s[1]
b = int(s[2])
if op == "?":
break
elif op == "+":
print(a + b)
elif op == "-":
print(a - b)
elif op == "*":
print(a * b)
else:
print(a // b) |
a,b,c = map(int,input())
if a == 7:
print("Yes")
elif b == 7:
print("Yes")
elif c == 7:
print("Yes")
else:
print("No") |
n = int(input())
arr = list(map(str, input().split()))
arr = list(set(arr))
if len(arr) == 3:
print('Three')
elif len(arr) == 4:
print('Four') |
def main():
s=input()[:-2]
while not is_even(s):
s = s[:-2]
print(len(s))
def is_even(s):
half = len(s) // 2
return s[:half] == s[half:]
if __name__ == "__main__":
main() |
def insertion_sort(a,n,g):
global cnt
for i in range(g,n):
temp = a[i]
j = i - g
while j >= 0 and a[j] > temp:
a[j + g] = a[j]
j = j - g
cnt += 1
a[j+g] = temp
def shell_sort(a,n):
h = 1
g = []
while h <= n:
g.append(h)
h = h * 3 + 1
m = len(g)
g = g[::-1]
for i in range(m):
insertion_sort(a,n,g[i])
print(m)
print(' '.join(map(str,g)))
print(cnt)
[print(i) for i in a]
num = int(input())
a = []
cnt = 0
for i in range(num):
a.append(int(input()))
shell_sort(a,num)
print(cnt)
|
#!/usr/bin/env python3
from math import gcd
def lcm(x,y):
return x*y//gcd(x,y)
def solve(a,b,c,d):
def countNonDivisor(n,c,d):
return n - n//c - n//d + n//lcm(c,d)
return countNonDivisor(b,c,d) - countNonDivisor(a-1,c,d)
def main():
a,b,c,d = map(int,input().split())
print(solve(a,b,c,d))
return
if __name__ == '__main__':
main()
|
# coding:UTF-8
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
self.rank = [0] * 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
elif self.rank[x] > self.rank[y]:
self.parents[x] += self.parents[y]
self.parents[y] = x
else:
self.parents[y] += self.parents[x]
self.parents[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
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())
if __name__ == '__main__':
# ------ 入力 ------#
# 1行入力
n, m = list(map(int, input().split())) # スペース区切り連続数字
# 定数行入力
x = m
abList = sorted([list(map(int, input().split())) for _ in range(x)]) # スペース区切り連続数字(行列)
# ------ 処理 ------#
uf = UnionFind(n)
for i in range(m):
uf.union(abList[i][0]-1, abList[i][1]-1)
out = max(uf.size(r) for r in uf.roots())
# ------ 出力 ------#
print("{}".format(out))
|
def gcd(a, b):
if a < b:
a, b = b, a
while a % b:
a, b = b, a % b
return b
x = int(input())
g = gcd(x, 360)
print(360 // g) |
S = input()
f = int(S[:2])
b = int(S[2:])
if (not 0 < f <= 12) and 0 < b <= 12:
print('YYMM')
elif (not 0 < b <= 12) and 0 < f <= 12:
print('MMYY')
elif 0 < f <= 12 and 0 < b <= 12:
print('AMBIGUOUS')
else:
print('NA')
|
#!/usr/bin/env python3
def main():
A1, A2, A3 = map(int, input().split())
A=A1+A2+A3
if A >=22:
ans='bust'
else:
ans='win'
print(ans)
if __name__ == "__main__":
main()
|
class UnionFind:
def __init__(self, n):
self.p = [i for i in range(n)]
self.components = n
def root(self, x):
if self.p[x] == x:
return x
else:
self.p[x] = self.root(self.p[x])
return self.p[x]
def unite(self, x, y):
x, y = self.root(x), self.root(y)
if x != y:
self.p[x] = y
self.components -= 1
def same(self, x,y):
return (self.root(x) == self.root(y))
N, M = map(int,input().split())
UF = UnionFind(N)
for _ in range(M):
X, Y, Z = map(int,input().split())
X, Y = X-1, Y-1
UF.unite(X,Y)
print(UF.components) |
#!/usr/bin/env python3
S = sorted(list(input()))
T = sorted(list(input()))[::-1]
if ''.join(S) < ''.join(T):
print('Yes')
else:
print('No')
|
s=input();u=s.upper();l=s.lower()
print(''.join([(u[i],l[i])[s[i]==u[i]]for i in range(len(s))])) |
from collections import Counter
counter = Counter()
while True:
try:
s = input()
for c in s:
counter[c.lower()] += 1
except:
break
for c in range(ord('a'), ord('z')+1):
print('{} : {}'.format(chr(c), counter[chr(c)])) |
"""
Tの文字にたいして、Sのインデックスをリストで持たせる
Tの頭から順繰りにたし上げていく（Loop数を数えること）
自分よりも大きい要素があれば、それを使うし、
なければ最も小さい要素を使いつつ、Loop数をCountUp
bisect_left()かな？
0123456
contest
01234567
sentence
s=[5] -> 5 (6moji)
e=[4] -> 7*1+4 (12moji)
n=[2] -> 7*2+2 = 16
t=[3,6] -> 7*2+3 = 17
e=[4] -> 7*2+4 = 18
n=[2] -> 7*3+2 = 23
c=[0] -> 7*4+0 = 28
e=[4] -> 7*4+4 = 32 ( 33moji)
"""
from bisect import bisect_right, bisect_left
S = input()
T = input()
def calc(ch):
return ord(ch) - ord('a')
## Tに含まれる文字に対し、Sのインデックスをふる
LST = [[] for _ in range(26)]
for t in T:
nt = calc(t)
if len(LST[nt]) > 0:
continue
for i in range(len(S)):
if t == S[i]:
LST[nt].append(i)
if len(LST[nt]) == 0:
print(-1)
exit(0)
NS = len(S)
## Tの文字に対して順繰りにたしあげる
NofLoop = 0
now = 0
for i in range(len(T)):
t = T[i]
nt = calc(t)
rel_now = now - NofLoop * NS
if rel_now < LST[nt][0] :
#print("R",t,nt,rel_now)
now = NofLoop * NS + LST[nt][0] + 1
elif LST[nt][-1] < rel_now :
#print(t,i)
NofLoop += 1
now = NofLoop * NS + LST[nt][0] + 1
else:
idx = bisect_left(LST[nt], rel_now)
#print(idx)
now = NofLoop * NS + LST[nt][idx] + 1
print(now) |
H, W, A, B = map(int, input().split())
MOD = 10 ** 9 + 7
limit = 2 * 10 ** 5
# modしながらコンビネーションを求める
def mod_cmb(n, r, mod):
x = fact[n] * fact_inverse[r] % mod
x = x * fact_inverse[n - r] % mod
return x
def d_cmb(n, r, mod):
return mod_cmb(n + r - 1, r, mod)
# modしたa^bを求める
def mod_pow(a, p, mod):
if p == 0:
return 1
elif p % 2 == 1:
return a * mod_pow(a, p - 1, mod)
else:
return (mod_pow(a, p // 2, mod) % mod) ** 2 % mod
fact = [1] * (limit + 1)
fact_inverse = [1] * (limit + 1)
for i in range(1, limit + 1):
fact[i] = fact[i - 1] * i % MOD
fact_inverse[limit] = mod_pow(fact[limit], MOD - 2, MOD)
for i in reversed(range(1, limit + 1)):
fact_inverse[i - 1] = fact_inverse[i] * i % MOD
n1 = W
r1 = H - A - 1
n2 = 1
r2 = A - 1
ans = 0
for i in range(W - B):
ans += d_cmb(n1 - i, r1, MOD) * d_cmb(n2 + i, r2, MOD)
ans %= MOD
print(ans) |
s1=str(input())
s1=list(s1)
s2=str(input())
s2=list(s2)
s3=str(input())
s3=list(s3)
print(s1[0]+s2[1]+s3[2])
|
A,B=list(map(int, input().split()))
if A==1:
if B==1:
print('Draw')
else:
print('Alice')
else:
if B==1:
print('Bob')
else:
if A>B:
print('Alice')
elif A<B:
print('Bob')
else:
print('Draw') |
string = input()
index_of_A = string.index("A")
index_of_Z = string.rfind("Z")
print(index_of_Z - index_of_A + 1)
|
H =int(input())
#h= 1
#while 2**(h+1) <= H:
# h += 1
#
#n=2**(h+1) - 1
#print(n)
#
import math
def helper(h):
if h ==1:
return 1
return 1 + 2 * helper(math.floor(h/2))
print(helper(H)) |
def solve(n, a):
for i in range(n):
if a[i] % 2 == 1:
return "first"
return "second"
n = int(input())
a = [int(input()) for i in range(n)]
print(solve(n, a)) |
s = input()
s_r = list(reversed(s))
s = s[:len(s)//2]
s_r = s_r[:len(s_r)//2]
count = 0
for i in range(len(s)):
if s[i] != s_r[i]:
count += 1
print(count)
|
#!/usr/bin/env python3
import sys
try:
from typing import List
except ImportError:
pass
def solve(N: int, a: "List[int]", b: "List[int]", c: "List[int]", d: "List[int]"):
rs = sorted(zip(a, b))
bs = sorted(zip(c, d))
for bx, by in bs:
mi = -1
my = -1
for i, (rx, ry) in enumerate(rs):
if not (rx < bx and ry < by):
continue
if my < ry:
mi = i
my = ry
if mi != -1:
del rs[mi]
print(N - len(rs))
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
a = [int()] * (N) # type: "List[int]"
b = [int()] * (N) # type: "List[int]"
for i in range(N):
a[i] = int(next(tokens))
b[i] = int(next(tokens))
c = [int()] * (N) # type: "List[int]"
d = [int()] * (N) # type: "List[int]"
for i in range(N):
c[i] = int(next(tokens))
d[i] = int(next(tokens))
solve(N, a, b, c, d)
if __name__ == '__main__':
main()
|
# coding: utf-8
N = int(input())
num2 = 2
num1 = 1
num = 1
tmp = 0
i = 2
while i <= N:
num = num1 + num2
tmp = num
num2 = num1
num1 = tmp
i += 1
print(num) |
name = str(input())
for i in range(3):
print(name[i], sep="", end="") |
n = int(input())
minv = 1 << 30
def digit_sum(n):
lst = list(map(int, str(n)))
return sum(lst)
for i in range(1, n//2 + 1):
a = i
b = n - i
minv = min(digit_sum(a) + digit_sum(b), minv)
print(minv)
|
def resolve():
from collections import deque
def checker(n):
n = str(n)
OK3 = False
OK5 = False
OK7 = False
for i in n:
if i == "3":
OK3 = True
elif i== "5":
OK5 = True
elif i == "7":
OK7 = True
if OK3 and OK5 and OK7:
return True
else:
return False
n = int(input())
if n < 357:
print(0)
else:
ans = 0
nxt = [3, 5, 7]
nxt = deque(nxt)
OK = True
while OK:
a = nxt.popleft()
if a > n:
break
nxt.append(a*10+3)
nxt.append(a * 10 + 5)
nxt.append(a * 10 + 7)
if checker(a):
ans += 1
print(ans)
resolve() |
S=input()
n=('N' in S)
s=('S' in S)
w=('W' in S)
e=('E' in S)
if not n^s and not w^e:
print('Yes')
else:
print('No') |
s=raw_input()
p=raw_input()
s=s*2
if p in s:
print('Yes')
else:
print('No') |
n = int(input())
nums = [int(i) for i in input().split()]
mod = 10 ** 9 + 7
def gcd(x, y): #GCD
# greatest_common_divisor
if x < y:
x, y = y, x
if y == 0:
return 0
if x % y == 0:
return y
return gcd(y, x % y)
def lcm(x, y): #LCM
# lowest_common_multiple
return x * y // gcd(x, y)
LCM = 1
for num in nums:
LCM = lcm(num, LCM)
LCM %= mod
# ans = 0
# for num in nums:
# ans += (LCM // num) % mod
# print(ans % mod)
ans = 0
for num in nums:
ans += LCM * pow(num, mod - 2, mod)
ans %= mod
print(ans % mod) |
from collections import Counter
S = input()
C = Counter(S)
if len(C) == 3:
c = min(C.values())
else:
c = 0
for cc in C.values():
if not (cc == c or cc == c + 1):
print("NO")
exit()
print("YES")
|
#coding:utf-8
#1_2_C
def BubbleSort(cards, n):
for i in range(n):
for j in range(n-1, i, -1):
if cards[j][1] < cards[j-1][1]:
cards[j], cards[j-1] = cards[j-1], cards[j]
return cards
def SelectionSort(cards, n):
for i in range(n):
minj = i
for j in range(i, n):
if cards[minj][1] > cards[j][1]:
minj = j
cards[i], cards[minj] = cards[minj], cards[i]
return cards
n = int(input())
cards = input().split()
copy = list(cards)
print(*BubbleSort(cards, n))
print("Stable")
print(*SelectionSort(copy, n))
print("Stable" if cards == copy else "Not stable") |
import sys
import math
S = raw_input()
for x in S:
if "a" <= x <= "z":
sys.stdout.write(x.upper())
elif "A" <= x <= "Z":
sys.stdout.write(x.lower())
else:
sys.stdout.write(x)
print |
num = int(input())
val = 0
while num > 0:
val += num%10
num //= 10
if val == 1:
print(10)
else:
print(val) |
num = int(input())
range_num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for _ in range_num:
if num / _ in range_num:
print("Yes")
break
else:
print("No") |
# A - Good Integer
# 標準入力N
N = input()
my_list = []
j = 0
for i in N:
my_list.append(i)
if my_list[0] == my_list[1] == my_list[2] or my_list[1] == my_list[2] == my_list[3]:
print('Yes')
else:
print('No')
|
import sys
s = input()
for i in range(len(s)):
if i%2 == 0:
if s[i] == 'R' or s[i] == 'U' or s[i] == 'D':
continue
else:
print('No')
sys.exit()
else:
if s[i] == 'L' or s[i] == 'U' or s[i] == 'D':
continue
else:
print('No')
sys.exit()
print('Yes') |
import sys
N = int(input())
if N %2 !=0:
print(0)
sys.exit()
else:
sum = 0
num = N
num_tmp = num //5
while num_tmp > 0:
num_tmp = num // 5
sum += num // 10
num = num_tmp
print(sum) |
def solve_A():
x = int(input())
if x == 3 or x == 5 or x == 7:
return "YES"
else:
return "NO"
print(solve_A()) |
S="*"+input()
N=len(S)-1
F=True
for i in range(1,N+1):
if i%2==1:
F&=S[i] in {"R","U","D"}
else:
F&=S[i] in {"L","U","D"}
if F:
print("Yes")
else:
print("No") |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float("inf")
def solve(N: int, M: int, p: "List[int]", S: "List[str]"):
ac = [0 for _ in range(N)]
for i in set(x[0] for x in zip(p, S) if x[1] == "AC"):
ac[i - 1] = 1
wa = 0
for x in zip(p, S):
ac[x[0] - 1] &= x[1] == "WA"
wa += ac[x[0] - 1]
return f'{len(set(x[0] for x in zip(p,S) if x[1] == "AC"))} {wa}'
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
p = [int()] * (M) # type: "List[int]"
S = [str()] * (M) # type: "List[str]"
for i in range(M):
p[i] = int(next(tokens))
S[i] = next(tokens)
print(f"{solve(N, M, p, S)}")
if __name__ == "__main__":
main()
|
# coding: utf-8
# Here your code !
a,b,c = input().split()
if(a < b < c):
print('Yes')
else:
print('No') |
a,b=int(input()), int(input())
print("EQUAL" if a == b else ("LESS" if a < b else "GREATER")) |
S = input()
pre = ""
for s in S:
if pre == s:
print("Bad")
exit()
pre = s
print("Good")
|
def gcd(m, n):
while n:
m, n = n, m % n
return m
def lcm(m, n):
return m // gcd(m, n) * n
for line in open(0).readlines():
a, b = map(int, line.split())
print(gcd(a, b), lcm(a, b))
|
def i():
return int(input())
def i2():
return map(int,input().split())
def s():
return str(input())
def l():
return list(input())
def intl():
return list(int(k) for k in input().split())
a,b = i2()
if a > 0:
print("Positive")
elif a <= 0 and 0 <= b:
print("Zero")
else:
if (b - a)%2 == 0:
print("Negative")
else:
print("Positive") |
a,b=input().split()
A,B = a*int(b), b*int(a)
if A < B: print(A)
else: print(B) |
str_N = input()
if (str_N[0] == str_N[2]):
print('Yes')
else:
print('No') |
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
N,M = map(int,input().split())
S = input()
T = input()
g = gcd(N,M)
l = lcm(N,M)
for i in range(g):
if S[l//M*i] != T[l//N*i]:
print(-1)
exit()
print(l) |
a = input().split()
if (a[0] == 'H' and a[1] == 'H') or (a[0] == 'D' and a[1] == 'D'):
print('H')
else:
print('D') |
from math import gcd
X = int(input())
def lcm(n, m):
return n * m // gcd(n, m)
print(lcm(X, 360) // X)
|
def bubble_sort(a, n):
for i in range(n-1):
for j in range(n-1, i, -1):
if a[j-1][1] > a[j][1]:
a[j-1], a[j] = a[j], a[j-1]
return a
def selection_sort(a, n):
for i in range(n-1):
min_j = i
for j in range(i+1, n):
if a[min_j][1] > a[j][1]:
min_j = j
if min_j != i:
a[min_j], a[i] = a[i], a[min_j]
return a
if __name__ == "__main__":
n = int(input())
a = input().split()
result1 = bubble_sort(a[:], n)
result2 = selection_sort(a[:], n)
print(*result1)
print("Stable")
print(*result2)
print("Stable" if result1 == result2 else "Not stable")
|
def game(card) :
player = 'a'
while True :
if len(card[player]) == 0 :
break
player = card[player].pop(0)
return player.upper()
card = dict()
card['a'] = list(input())
card['b'] = list(input())
card['c'] = list(input())
print(game(card)) |
N = int(input())
S = input()
assert len(S) == N
count = 0
for i,s in enumerate(S):
if s == 'A' and S[i:i+3] == 'ABC':
count += 1
print(count) |
s = input()
n = int(s)
x = 0
for c in s:
x += int(c)
if n % x ==0:
print('Yes')
else:
print('No') |
# coding=utf-8
def print_list(X):
first_flag = True
for val in X:
if first_flag:
print_line = str(val)
first_flag = False
else:
print_line = print_line + ' ' + str(val)
print(print_line)
def selection_sort(A, N):
counter = 0
for i in range(N):
min_j = i
for j in range(i, N):
if A[j] < A[min_j]:
min_j = j
if i != min_j:
A[i], A[min_j] = A[min_j], A[i]
counter += 1
print_list(A)
print(counter)
N = int(input())
A = list(map(int, input().split()))
selection_sort(A, N) |
a,b,c=input().split()
a=int(a)
b=int(b)
c=int(c)
if b/a>=c:
print(c)
else:
print(int(b/a)) |
from math import sin, cos, radians
a, b, ang = map(int, input().split())
ang = radians(ang)
area = a * b * sin(ang) / 2
c = (a ** 2 + b ** 2 - 2 * a * b * cos(ang)) ** 0.5
circ = a + b + c
height = area * 2 / a
print("%lf\n%lf\n%lf" % (area, circ, height))
|
s = list(input())
ans = []
for t in s:
if t == "0":
ans.append("0")
elif t == "1":
ans.append("1")
elif t == "B" and ans != []:
ans.pop(-1)
print("".join(ans)) |
def mergeSort(A, left, right, n):
if left + 1 < right:
mid = int((right + left ) / 2 )
mergeSort(A, left, mid, n)
mergeSort(A, mid, right, n)
return (merge(A, left, mid, right, n))
def merge(A, left, mid, right, n):
n1 = mid - left
n2 = right - mid
L = A[left:mid] + [10 ** 9 + 1]
R = A[mid:right] + [10 ** 9 + 1]
i , j = 0, 0
for k in range(left, right):
A[n] += 1
if L[i] <= R[j]:
key = L[i]
A[k] = key
i += 1
else:
key = R[j]
A[k] = key
j += 1
return A
n = int(input())
A = list(map(int, input().split()))
A.append(0)
S = mergeSort(A, 0, len(A) - 1, n)
print(" ".join(list(map(str, S[:n]))))
print(S[n])
|
N = int(input())
def make_divisor(n):
divisors = []
for i in range(1, int(n**.5) + 1):
if n%i == 0:
divisors.append(i)
if i != n//i:
divisors.append(n//i)
divisors.sort()
return divisors
cnt = 0
for i in range(1, N+1):
if len(make_divisor(i)) == 8 and i%2 == 1:
cnt += 1
print(cnt)
|
def solve(string):
a = int(string)
return str(a + a**2 + a**3)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
|
b = input()
if "A" in b:
print("T")
elif "T" in b:
print("A")
elif "C" in b:
print("G")
else:
print("C") |
# 条件下の「橋」を、「エッジを1つしか持たないノード」から
#「エッジを3つ以上持つノード」の間にあるエッジと考える
from collections import defaultdict
def remove_checked():
global check_nodes,dd
for n in check_nodes:
if n in dd:
dd.pop(n)
for k in dd:
if n in dd[k]:
dd[k].remove(n)
check_nodes=set()
n,m=map(int,input().split())
dd=defaultdict(list)
check_nodes=set()
for i in range(m):
a,b=map(int,input().split())
dd[a].append(b)
dd[b].append(a)
cnt=0
while True:
for k in dd.keys():
if k in check_nodes:
continue
nodes=dd[k]
if len(nodes) == 1:
nxt=k
while len(nodes) <= 2:
check_nodes.add(nxt)
cnt+=1
nxt=nodes[0]
if nxt in check_nodes:
nxt = nodes[1]
nodes=dd[nxt]
if len(nodes) == 1:
check_nodes.add(nxt)
break
if check_nodes==set():
break
remove_checked()
print(cnt) |
import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
s = list(input())
for i in range(len(s)):
print("x", end="")
main() |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.