Datasets:

PoolC

/

4-fold-clone-detection-600k-5fold

like 0

Follow

PoolC 13

import sys readline = sys.stdin.readline D = int(readline()) C = list(map(int,readline().split())) S = [None] * D for i in range(D): s = list(map(int,readline().split())) S[i] = s def calc_score(arr): point = 0 last_submit = [-1] * 26 for i in range(len(arr)): point += S[i][arr[i]] last_submit[arr[i]] = i for j in range(len(last_submit)): point -= (i - last_submit[j]) * C[j] print(point) return point T = [None] * D for i in range(D): T[i] = int(readline()) - 1 ans = calc_score(T)

D = int(input()) C = list(map(int, input().split())) s = list() for i in range(D): s1 = list(map(int, input().split())) s.append(s1) t = list() for i in range(D): N = int(input()) t.append(N-1) done = [0] * 26 ans = 0 for d in range(1, D+1): td = t[d-1] done[td] = d ans += s[d-1][td] for i in range(26): ans -= C[i]*(d-done[i]) print(ans)

import math x = int(input()) initial = 100 count = 0 while initial < x: initial += initial//100 count += 1 print(count)

N = list(input()) if '7' in N: print("Yes") else: print("No")

a,b,k=map(int,input().split()) if a<=k: k-=a a=0 if b<=k: print(0,0) else: b-=k print(a,b) elif k<a: a-=k print(a,b)

''' Created on 2020/09/10 @author: harurun ''' def main(): import sys pin=sys.stdin.readline pout=sys.stdout.write perr=sys.stderr.write N,M=map(int,pin().split()) if N==3: ans=[1,0,0] for _ in [0]*M: s,c=map(int,pin().split()) if s==1 and c==0: print(-1) return if s!=1 and ans[s-1]!=0 and ans[s-1]!=c: print(-1) return ans[s-1]=c a="" for i in ans: a+=str(i) print(a) return elif N==2: ans=[1,0] for _ in [0]*M: s,c=map(int,pin().split()) if s==1 and c==0: print(-1) return if s!=1 and ans[s-1]!=0 and ans[s-1]!=c: print(-1) return ans[s-1]=c a="" for i in ans: a+=str(i) print(a) return else: if M==0: print(0) return s,c=map(int,pin().split()) ans=c for j in range(M-1): s,c=map(int,pin().split()) if c!=ans: print(-1) return print(ans) return main()

N = int(input()) A = list(map(int,input().split())) A.insert(0,0) C = {i:0 for i in range(1,N+1)} for i in range(1,N+1): C[A[i]] += 1 tot = 0 for i in range(1,N+1): tot += (C[i]*(C[i]-1))//2 for i in range(1,N+1): c = C[A[i]]-1 ans = tot-(C[A[i]]*(C[A[i]]-1))//2+(c*(c-1))//2 print(ans)

from collections import defaultdict def main(): n = int(input()) a = list(map(int, input().split(" "))) d = defaultdict(lambda:0) d2 = {} for i in a: d[i] += 1 for i,j in d.items(): x = j*(j-1)//2 d2[i] = x ans = 0 ans = sum(d2.values()) for i in range(n): print(ans-d[a[i]]+1) if __name__ == "__main__": main()

has, need = [int(x) for x in input().split()] print(["No", "Yes"][has * 500 >= need])

def func(K, X): YEN = 500 ans = 'Yes' if YEN * K >= X else 'No' return ans if __name__ == "__main__": K, X = map(int, input().split()) print(func(K, X))

X = input() ans = "1" if int(X) < 100: ans = "0" elif not int(X[:-2])*5 >= int(X[-2:]): ans = "0" print(ans)

X=int(input()) a=100 cnt=0 while a<X: a=a+a//100 cnt+=1 print(cnt)

s = [] while True: hoge = input() if hoge == '-': break num = int(input()) for i in range(num): h = int(input()) hoge = hoge.replace(hoge,hoge[h:] + hoge[:h]) s += [hoge] for i in s: print(i)

#!usr/bin/env python3 from collections import defaultdict, deque from heapq import heappush, heappop from itertools import permutations import sys import math import bisect def LI(): return [int(x) for x in sys.stdin.readline().split()] def I(): return int(sys.stdin.readline()) def LS(): return [list(x) for x in sys.stdin.readline().split()] def S(): res = list(sys.stdin.readline()) if res[-1] == "\n": return res[:-1] return res def IR(n): return [I() for i in range(n)] def LIR(n): return [LI() for i in range(n)] def SR(n): return [S() for i in range(n)] def LSR(n): return [LS() for i in range(n)] sys.setrecursionlimit(1000000) mod = 1000000007 def solve(): n = I() a = LI() count = 0 for i in range(1,n+1): if i % 2 != 0 and a[i-1] % 2 != 0: count += 1 print(count) return if __name__ == "__main__": solve()

N = int(input()) List = [list(map(str, input().split())) for i in range(0,N)] X = str(input()) yoroshiosu = 0 samu = 0 for i in range (0, N): if X == List[i][0]: yoroshiosu =1 elif yoroshiosu == 0: continue else: samu+=int(List[i][1]) print(samu)

from itertools import accumulate n = int(input()) song= [] time = [] for i in range(n): s, t = input().split() song.append(s) time.append(int(t)) time_acc = list(accumulate(time)) x = input() print(time_acc[n - 1] - time_acc[song.index(x)])

import sys sys.stdin.readline() # ????????? data = sys.stdin.readline().strip().split(' ') data.reverse() print(' '.join(data))

n = input() list = raw_input().split(" ") list.reverse() print " ".join(list)

def main(): import sys sys.setrecursionlimit(10**9) input = sys.stdin.readline import math from collections import defaultdict mod = 1000000007 N = int(input()) zero_pair = 0 zero_a = 0 zero_b = 0 pair_plus = defaultdict(int) pair_minus = defaultdict(int) for a, b in [tuple(map(int, input().split())) for _ in range(N)]: if a == 0 and b == 0: zero_pair += 1 continue if a == 0: zero_a += 1 continue if b == 0: zero_b += 1 continue abs_a = abs(a) abs_b = abs(b) g = math.gcd(abs_a, abs_b) abs_a = abs_a//g abs_b = abs_b//g if a * b > 0: pair_plus[(abs_a, abs_b)] += 1 else: pair_minus[(abs_a, abs_b)] += 1 ans = 1 ans *= (pow(2, zero_a, mod) + pow(2, zero_b, mod) - 1) % mod ans %= mod count_all = 0 for item in pair_plus.items(): a, b = item[0] cnt = item[1] if (b,a) in pair_minus: ans *= (pow(2, cnt, mod) + pow(2, pair_minus[(b,a)]) - 1) % mod ans %= mod del pair_minus[(b, a)] else: count_all += cnt for val in pair_minus.values(): count_all += val ans = (ans * pow(2, count_all, mod)) % mod ans += zero_pair print((ans - 1) % mod) main()

import math import collections n = int(input()) iwashi = [] sub_ans = 0 for i in range(n): a, b = map(int, input().split()) if a == 0 and b == 0: sub_ans += 1 else: if b == 0: iwashi.append('1/0') elif b > 0: c = math.gcd(a, b) iwashi.append('{}/{}'.format(a//c, b//c)) else: c = math.gcd(a, b) iwashi.append('{}/{}'.format(-a//c, -b//c)) # print(iwashi) iwashi = collections.Counter(iwashi) k_list = list(iwashi.keys()) v = list(iwashi.values()) # k_list.sort(key=lambda x: -x) mod = 1000000007 ans = 1 for k in k_list: a = iwashi[k] if k == '1/0': anti_k = '0/1' elif k == '0/1': anti_k = '1/0' else: c, d = k.split('/') if int(c) < 0: anti_k = '{}/{}'.format(d, -int(c)) else: anti_k = '{}/{}'.format(-int(d), c) b = iwashi[anti_k] if a*b != 0: ans *= (pow(2, a, mod) + pow(2, b, mod) -1) else: ans *= pow(2, a, mod) iwashi[k] = 0 iwashi[anti_k] = 0 # print(k, anti_k ,a, b, ans) ans %= mod print((ans+sub_ans-1)%mod)

import numpy n, m = [int(i) for i in input().split()] A = [int(i) for i in input().split()] sup_A = 10 ** 5 B = [0] * (1 << 18) for a in A: B[a] += 1 C = numpy.fft.fft(B) D = numpy.fft.ifft(C * C) ans = 0 cnt = 0 for i in range(2 * sup_A, -1, -1): d = int(D[i].real + 0.5) if cnt + d >= m: ans += (m - cnt) * i break cnt += d ans += i * d print(ans)

d = input().split() dicry = {'N':'152304', 'E':'310542', 'W':'215043','S':'402351'} for i in input(): d = [d[int(c)] for c in dicry[i]] print(d[0])

a, b, c, d = map(int, input().split()) print(max(a * c, a * d, b * c, b * d))

a,b,c,d = (int(x) for x in input().split()) ans = max(a*c,a*d,b*c,b*d) print(ans)

import itertools import numpy as np N, M, Q = map(int, input().split()) abcd = [list(map(int, input().split())) for i in range(Q)] score = [] ans = 0 for A in itertools.combinations_with_replacement(range(1, M+1), N): for i in range(Q): a = abcd[i][0] b = abcd[i][1] c = abcd[i][2] d = abcd[i][3] if A[b-1]-A[a-1] == c: score.append(d) if ans <= sum(score): ans = sum(score) score.clear() print(ans)

import itertools n, m, q = map(int, input().split()) pairs = [] for i in range(q): pairs.append(list(map(int, input().split()))) elem = [i for i in range(1, m+1)] # elemからn回くじを引いて，出た値を昇順にソートする．引いたくじはすぐにelemに戻す．この全組み合わせをリストで返す． candidates = list(itertools.combinations_with_replacement(elem, n)) dsummax = 0 for cand in candidates: dsum = 0 for i in range(q): if cand[pairs[i][1]-1]-cand[pairs[i][0]-1] == pairs[i][2]: dsum += pairs[i][3] if dsummax < dsum: dsummax = dsum print(dsummax)

import collections, copy h, w = map(int, input().split()) maze = [] maze.append("#" * (w + 2)) for i in range(h): maze.append("#" + input() + "#") maze.append("#" * (w + 2)) dis = [] for i in range(h + 2): temp = [-1] * (w + 2) dis.append(temp) def search(x, y): dis2 = copy.deepcopy(dis) move = [[-1, 0], [1, 0], [0, 1], [0, -1]] queue = collections.deque([[x, y]]) dis2[x][y] = 0 while queue: test = queue.popleft() for i in move: place = [test[0] + i[0], test[1] + i[1]] if maze[place[0]][place[1]] == ".": if dis2[place[0]][place[1]] == -1: dis2[place[0]][place[1]] = dis2[test[0]][test[1]] + 1 queue.append(place) return max([max([dis2[i][j] for j in range(w + 2)]) for i in range(h + 2)]) ans = 0 for i in range(h): for j in range(w): if maze[i + 1][j + 1] == ".": dist = search(i + 1, j + 1) ans = max(ans, dist) print(ans)

N, R = map(int, input().split()) # min()でまとめて書ける print(R + 100 * (10-min(10, N)))

import sys import itertools input = lambda: sys.stdin.readline().rstrip() def solve(): N = int(input()) d = list(map(int, input().split())) comb = list(itertools.combinations(range(N), 2)) ans = 0 for c in comb: i1, i2 = c ans += d[i1] * d[i2] print(ans) if __name__ == '__main__': solve()

N=int(input()) d=list(map(int,input().split())) a=0 for i in range(len(d)): for j in range(len(d)): if i!=j and i>j: a+=d[i]*d[j] print(a)

count = [0 for i in range(26)] while(1): try: str = raw_input().lower() except EOFError: break for i in range(len(str)): k = 97 for j in range(26): if str[i] == chr(k): count[j] += 1 k += 1 k = 97 for i in range(26): print "%s : %d" % (chr(k), count[i]) k += 1

import sys import math from collections import defaultdict from collections import deque sys.setrecursionlimit(1000000) MOD = 10 ** 9 + 7 input = lambda: sys.stdin.readline().strip() NI = lambda: int(input()) NMI = lambda: map(int, input().split()) NLI = lambda: list(NMI()) SI = lambda: input() def main(): R, C, K = NMI() item = [[0] * (C + 1) for i in range(R + 1)] for i in range(K): r_, c_, v_, = NMI() item[r_ - 1][c_ - 1] = v_ dp = [[[0 for _ in range(C + 2)] for _ in range(R + 2)] for _ in range(4)] for i in range(R + 1): for j in range(C + 1): for k in range(4): a = dp[k][i][j] v = item[i][j] if k == 3: dp[0][i + 1][j] = max(a, dp[0][i + 1][j]) continue dp[0][i + 1][j] = max(a, a + v, dp[0][i + 1][j]) dp[k][i][j + 1] = max(a, dp[k][i][j + 1]) dp[k + 1][i][j + 1] = max(a + v, dp[k + 1][i][j + 1]) print(max(dp[0][R][C], dp[1][R][C], dp[2][R][C], dp[3][R][C])) if __name__ == "__main__": main()

D = int(input()) c_list = list(map(int, input().split())) s_list = [list(map(int, input().split())) for _ in range(D)] last_open = [0] * 26 res = 0 res_list = [] for i in range(D): t = int(input()) res += s_list[i][t-1] bad = 0 last_open[t-1] = i+1 for ci in range(26): bad += c_list[ci]*(i+1 - last_open[ci]) res -= bad print(res) res_list.append(res)

N = 26 D = int(input()) c_list = list(map(int, input().split())) s_table = [] for _ in range(D): s_table.append(list(map(int, input().split()))) data = [] for _ in range(D): data.append(int(input()) - 1) def calc(data): last = [-1] * N satisfaction = 0 for i in range(D): j = data[i] satisfaction += s_table[i][j] last[j] = i for k in range(N): satisfaction -= c_list[k] * (i - last[k]) print(satisfaction) return satisfaction calc(data)

l = int(input()) ans = (l / 3) ** 3 print(ans)

import operator func = {'+':operator.add, '-':operator.sub, '*':operator.mul} stack = [] for symbol in input().split(): if symbol.isdigit(): stack.append(int(symbol)) else: a = stack.pop() b = stack.pop() stack.append(func[symbol](b, a)) print(stack[0])

intl=map(int, raw_input().split()) a=intl[0] b=intl[1] if a==b: print "a == b" elif a>b: print "a > b" else: print "a < b"

[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")

a, b, c, k = map(int, input().split()) ans = 0 ans += min(a, k) k -= min(a, k) k -= min(b, k) ans -= min(c, k) print(ans)

K, N = map(int, input().split()) A = list(map(int, input().split())) max_d = 0 for a in range(1, N): d = A[a] - A[a-1] if d > max_d: max_d = d last_d = K - A[-1] + A[0] if last_d > max_d: max_d = last_d print(K - max_d)

import copy as cp import time import random #INPUT t_start = time.time() D = int(input()) c = [int(i) for i in input().split()] s = [] for i in range(D): new = [int(i) for i in input().split()] s.append(new) #Utilitiy def score(ans): if len(ans) != D: print("wrong length") return 0 else: p = 0 last = [-1]*26 for i in range(D): contest = ans[i]-1 p += s[i][contest] last[contest] = i for j in range(26): p -= c[j]*(i-last[j]) return p def greedy(ahead=0): ans = [] p = 0 last = [-1]*26 for i in range(D): decay = 0 for j in range(26): decay -= c[j]*(i-last[j]) max_j = -1 max_plus_mod = decay max_plus = decay for j in range(26): plus = s[i][j] + c[j]*(i-last[j]) modify = c[j]*(ahead*(i-last[j])+ahead*(ahead+1)//2) if (plus+modify) > max_plus_mod: max_plus = plus max_plus_mod = plus+modify max_j = j ans.append(max_j+1) last[max_j]=i p += max_plus + decay return ans, p def schedule(ans): dates = [[] for i in range(26)] for i in range(D): dates[ans[i]-1].append(i) return dates def swap(ans): ans_temp = cp.copy(ans) t1 = random.randint(0,D-1) t2 = random.randint(0,D-1) temp = ans_temp[t1] ans_temp[t1] = ans_temp[t2] ans_temp[t2] = temp return ans_temp def change(ans): ans_temp = cp.copy(ans) t = random.randint(0,D-1) A = random.randint(1,26) ans_temp[t] = A return ans_temp #MAIN max_points = -10000000 for k in range(20): ans_temp, points = greedy(ahead = k) #print(k, points, ans_temp) if points > max_points: max_points = points ans = cp.copy(ans_temp) dates = schedule(ans) count = 0 while True: if count % 100 == 0: t_now = time.time() if t_now-t_start > 1.8: break r = random.randint(0,1) if r == 0: ans_temp = swap(ans) points_temp = score(ans_temp) else: ans_temp = change(ans) points_temp = score(ans_temp) if points_temp > points: points = points_temp ans = cp.copy(ans_temp) for i in range(D): print(ans[i])

import sys from pprint import pprint R,C,K=map(int,input().split()) grid=[[0]*C for _ in range(R+1)] for _ in range(K): r,c,v=map(int,input().split()) grid[r][c-1]=v for i in range(1,R+1): cell=[0]*4 for j in range(C): cell[0]=max(cell[0],grid[i-1][j]) for k in range(2,-1,-1): cell[k+1]=max(cell[k+1],cell[k]+grid[i][j]) grid[i][j]=max(cell) print(grid[-1][-1])

s = "#." while True: H,W= map(int, input().split()) if H==0 and W==0: break elif W%2==0 : w1=s*(W//2) w2="."+s*(W//2-1)+"#" elif W%2==1: w1=s*((W-1)//2)+"#" w2="."+s*((W-1)//2) for i in range(H): if i%2==0: print(w1) elif i%2==1: print(w2) print("")

import sys for i in sys.stdin.readlines()[:-1]: h,w = map(int,i.strip().split()) for i in range(h): for j in range(w): if (i+j) % 2 == 0: print('#',end='') else: print('.',end='') print() print()

n = int(input()) fib = [1]*(n+1) for i in range(2,n+1): fib[i] = fib[i-1]+fib[i-2] print(fib[n])

F = {} def fib(n): global F if n < 0: print("error") exit() if n < 2: F[n] = 1 return F[n] # F[n] = fib(n-1) + fib(n-2) F[n] = F[n-1] + F[n-2] return F[n] n = int(input()) #print(fib(n)) #n = int(input()) #print(fib(n)) #fib(44) for i in range(n+1): result = fib(i) print(result) # print(F[i])

#import sys #input = sys.stdin.readline #input = sys.stdin.buffer.readline #sys.setrecursionlimit(10**9) #from functools import lru_cache def RD(): return sys.stdin.read() def II(): return int(input()) def MI(): return map(int,input().split()) def MF(): return map(float,input().split()) def LI(): return list(map(int,input().split())) def LF(): return list(map(float,input().split())) def TI(): return tuple(map(int,input().split())) # rstrip().decode() #import numpy as np from collections import defaultdict def main(): mod=10**9+7 n=II() s=input() s=len(s) pp=[1] for i in range(n+10): pp.append(pp[-1]*25%mod) nn=n+s comb=[1] for i in range(1,n+10): comb.append(comb[-1]*(nn-i+1)*pow(i,mod-2,mod)%mod) #print(comb) ans=0 for i in range(n+1): ans+=(pp[i]*comb[i])%mod ans%=mod print(ans) if __name__ == "__main__": main()

A = sum([list(map(int,input().split()))for _ in range(3)],[]) N = int(input()) b = [int(input()) for _ in range(N)] f=0 for i in range(9): if A[i]in b:f|=1<<i ans=[v for v in [7,56,73,84,146,273,292,448]if f&v==v] print('Yes' if ans else 'No')

n = int(input()) s = input() t = "" for i in range(n // 2): t += s[i] if s == (t + t): print('Yes') else: print('No')

# coding: utf-8 # Your code here! import sys n=int(input()) s=list(input()) if n%2==1: print("No") sys.exit() else: for i in range(n//2): if s[i]==s[n//2+i]: continue print("No") sys.exit() print("Yes")

import sys sys.setrecursionlimit(10 ** 7) read = sys.stdin.buffer.read inp = sys.stdin.buffer.readline from itertools import accumulate def resolve(): N, K = map(int, inp().split()) A = list(map(int, inp().split())) for _ in range(K): imos_table = [0]*(N+1) for i, a in enumerate(A): # 配列の個数を超えないように注意 imos_table[max(i - a, 0)] += 1 imos_table[min(i + a + 1, N)] -= 1 A = list(accumulate(imos_table))[:-1] if all([True if a == N else False for a in A]): print(*A) return else: print(*A) if __name__ == "__main__": resolve()

def ii():return int(input()) def iim():return map(int,input().split()) def iil():return list(map(int,input().split())) def ism():return map(str,input().split()) def isl():return list(map(str,input().split())) from math import gcd mod = int(1e9+7) n = ii() cnd = {} azero = 0 bzero = 0 allzero = 0 for _ in range(n): a,b = iim() if a*b == 0: if a == 0 and b != 0: azero += 1 elif a != 0 and b == 0: bzero += 1 else: allzero += 1 else: g = gcd(a,b) a //= g b //= g if a<0: a *= -1 b *= -1 before = cnd.get((a,b),False) if b > 0: check = cnd.get((b,-a),False) else: check = cnd.get((-b,a),False) if before: cnd[(a,b)] = [before[0]+1,before[1]] elif check: if b > 0: cnd[(b,-a)] = [check[0],check[1]+1] else: cnd[(-b,a)] = [check[0],check[1]+1] else: cnd[(a,b)] = [1,0] cnd[0] = [azero,bzero] noreg = 0 ans = 1 #print(cnd) for item in cnd.values(): if item[0] == 0 or item[1] == 0: noreg += max(item[0],item[1]) else: ans *= (2**item[0]+2**item[1]-1) ans %= mod print((ans*((2**noreg)%mod)-1+allzero)%mod)

while True: a,op,b = input().split() a = int(a) b = int(b) if op =='?': break elif op =='+': print('%d'%(a+b)) elif op =='-': print('%d'%(a-b)) elif op =='*': print('%d'%(a*b)) elif op =='/': print('%d'%(a/b))

n=int(input()) s=input() ans=0 alist=[0]*10 for i in range(n): alist[int(s[i])]=i for i in range(10): flag1=False for a in range(n-2): if s[a]==str(i): flag1=True break if flag1: for j in range(10): flag2=False for b in range(a+1,n-1): if s[b]==str(j): flag2=True break if flag2: for k in range(10): if b<alist[k]: ans+=1 print(ans)

# coding: utf-8 import sys sr = lambda: sys.stdin.readline().rstrip() ir = lambda: int(sr()) lr = lambda: list(map(int, sr().split())) MOD = 10 ** 9 + 7 # gcdがNから順に数える、resetを用意、約数をそれぞれ引く def make_divisors(n): # 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) divisors.sort() return divisors N, K = lr() answer = 0 reset = [0] * (K+1) for x in range(K, 0, -1): #gcdがx nums = K // x add = pow(nums, N, MOD) add -= reset[x] answer += add * x answer %= MOD divs = make_divisors(x) for d in divs: reset[d] += add print(answer%MOD)

n = int(input()) fib = [1,1] if n>=2: for i in range(2,n+1): fib.append(fib[i-1]+fib[i-2]) print(fib[n])

# coding=utf-8 n = int(input()) dic = set() for i in range(n): cmd = input().split() if cmd[0] == 'insert': dic.add(cmd[1]) else: if cmd[1] in dic: print('yes') else: print('no')

while True: h, w = map(int, input().split(" ")) if h == 0 and w == 0: break print("#"*w) print(("#"+ "."*(w-2) +"#" + "\n")*(h-2) + "#" * w) if h >2 and w>=2 else 0 print("#"*w) if h == 2 else 0 print("")

""" 高橋君はとりあえず、青木君から最も遠い木の端を目指すのがベスト。 また、目指すべき木の端までの距離に関しては、高橋くんよりも自分の方が近くなくてはならない。 また、高橋君が捕まるときは、必ず木の端の一歩手前のノードになる。 つまり、青木君が移動しなくてはいけない最大距離は、高橋君が目指す木の端までの距離-1、ということになる。 とりま、高橋くん、青木君の初期位置から各ノードまでの距離を調べて、上記の条件にマッチする端を見つける。 """ from collections import deque N,u,v = map(int,input().split()) edges = [[] for _ in range(N+1)] for _ in range(N-1): a,b = map(int,input().split()) edges[a].append(b) edges[b].append(a) takahashi = [None]*(N+1) que = deque([(0,u,0)]) while que: step,cur,par = que.popleft() takahashi[cur] = step for nx in edges[cur]: if nx == par: continue que.append((step+1,nx,cur)) aoki = [None]*(N+1) que = deque([(0,v,0)]) while que: step,cur,par = que.popleft() aoki[cur] = step for nx in edges[cur]: if nx == par: continue que.append((step+1,nx,cur)) ans = 0 for i in range(1,N+1): if takahashi[i] < aoki[i]: ans = max(ans,aoki[i]-1) print(ans)

import os import sys import numpy as np def solve(inp): r, c, k = inp[:3] items = np.zeros((r + 1, c + 1), dtype=np.int64) rrr = inp[3::3] ccc = inp[4::3] vvv = inp[5::3] for r_, c_, v in zip(rrr, ccc, vvv): items[r_, c_] = v dp = np.zeros((r + 1, c + 1, 4), dtype=np.int64) for i in range(1, r + 1): for j in range(1, c + 1): v = items[i, j] dp[i, j] = np.maximum(dp[i, j - 1], dp[i - 1, j, 3]) if v > 0: dp[i, j, 1:] = np.maximum(dp[i, j, 1:], dp[i, j, :-1] + v) return dp[-1, -1, -1] if sys.argv[-1] == 'ONLINE_JUDGE': from numba.pycc import CC cc = CC('my_module') cc.export('solve', '(i8[:],)')(solve) cc.compile() exit() if os.name == 'posix': # noinspection PyUnresolvedReferences from my_module import solve else: from numba import njit solve = njit('(i8[:],)', cache=True)(solve) print('compiled', file=sys.stderr) inp = np.fromstring(sys.stdin.read(), dtype=np.int64, sep=' ') ans = solve(inp) print(ans)

#coding:utf-8 l = map(int, raw_input(). split()) i = min(l) l.remove(min(l)) n = min(l) l.remove(min(l)) m = min(l) print("{0} {1} {2}". format(i, n, m))

s = map(int, raw_input().split()) s.sort() print ' '.join(map(str, s))

import sys input = sys.stdin.readline N,u,v=map(int,input().split()) E=[tuple(map(int,input().split())) for i in range(N-1)] EDGE=[[] for i in range(N+1)] for x,y in E: EDGE[x].append(y) EDGE[y].append(x) from collections import deque T=[-1]*(N+1) Q=deque() Q.append(u) T[u]=0 while Q: x=Q.pop() for to in EDGE[x]: if T[to]==-1: T[to]=T[x]+1 Q.append(to) A=[-1]*(N+1) Q=deque() Q.append(v) A[v]=0 while Q: x=Q.pop() for to in EDGE[x]: if A[to]==-1: A[to]=A[x]+1 Q.append(to) OK=[0]*(N+1) for i in range(N+1): if T[i]<A[i]: OK[i]=1 ANS=0 for i in range(N+1): if OK[i]==1: ANS=max(ANS,A[i]) print(max(0,ANS-1))

S=raw_input() T=raw_input() ans=0 for s,t in zip(S,T): if s!=t: ans+=1 print ans

n,k=map(int,input().split()) def find_power(n,mod): # 0!からn!までのびっくりを出してくれる関数(ただし、modで割った値に対してである） powlist=[0]*(n+1) powlist[0]=1 powlist[1]=1 for i in range(2,n+1): powlist[i]=powlist[i-1]*i%(mod) return powlist def find_inv_power(n): #0!からn!までの逆元を素数10**9+7で割ったあまりリストを作る関数 powlist=find_power(n,10**9+7) check=powlist[-1] first=1 uselist=[0]*(n+1) secondlist=[0]*30 secondlist[0]=check secondlist[1]=check**2 for i in range(28): secondlist[i+2]=(secondlist[i+1]**2)%(10**9+7) a=format(10**9+5,"b") for j in range(30): if a[29-j]=="1": first=(first*secondlist[j])%(10**9+7) uselist[n]=first for i in range(n,0,-1): uselist[i-1]=(uselist[i]*i)%(10**9+7) return uselist mod=10**9+7 a=find_power(4*10**5+100,mod) b=find_inv_power(4*10**5+100) def combi(n,r,mod): if n<r: return 0 elif n>=r: return (a[n]*b[r]*b[n-r])%(mod) if n<=k: K=combi(2*n-1,n-1,mod) print(K) else: K=combi(2*n-1,n-1,mod) for i in range(k+1,n): K-=combi(n-1,n-i-1,mod)*combi(n,i,mod) print(K%mod)

l = map (int, raw_input().split()) if l[0]<l[1]: if l[1]<l[2]: print 'Yes' else: print 'No' else: print 'No'

n = int(input()) a=list(map(int,input().split())) kane=1000 kabu =0 for i in range(n-1): if a[i]<=a[i+1]: kabu+=kane//a[i] kane=kane%a[i] else: kane+=kabu*a[i] kabu=0 print(kane+kabu*a[n-1])

N = int(input()) An = list(map(int, input().split())) dp = [0 for x in range(N+10)] dp[0] = 1000 for i in range(1, N): stock = dp[i-1] // An[i-1] # print(dp[i-1], An[i-1], stock) money = dp[i-1] money -= stock * An[i-1] money += stock * An[i] # print(money) dp[i] = max(dp[i-1], money) print(dp[N-1])

# -*- coding: utf-8 -*- import math def g(nx, ny, nz): return nx ** 2 + ny ** 2 + nz ** 2 + nx * ny + ny * nz + nz * nx def solve(n): # min_z = max(1, int(math.sqrt(n) / 3)) max_z = max(1, int(math.sqrt(n - 2) - 1) if n > 2 else 1) # max_x = max(1, int(math.sqrt(n / 3) + 1)) counter = [0 for _ in range(n + 1)] for z in range(1, max_z + 1): for y in range(1, max_z + 1): for x in range(1, max_z + 1): gn = g(x, y, z) if gn <= n: counter[gn] += 1 for i in range(1, n + 1): print(counter[i]) N = int(input()) solve(N)

a, b, k = map(int, input().split()) if (a >= k): aa = a - k bb = b else: aa = 0 bb = max(0, b - (k - a)) print(aa, bb)

mod = 10**9+7 n = int(input()) A = list(map(int,input().split())) from collections import defaultdict zero = defaultdict(int) one = defaultdict(int) for a in A: for i in range(61): if a &(1<<i): one[i] += 1 else: zero[i] += 1 ans = 0 for i in range(61): ans += pow(2,i,mod)*zero[i]*one[i] ans %=mod print(ans%mod)

import sys stdin = sys.stdin def main(): N = int(stdin.readline().rstrip()) A = list(map(int,stdin.readline().split())) mod = 10**9+7 ans = 0 for i in range(61): bits = 0 for x in A: if (x>>i)&1: bits += 1 ans += ((bits*(N-bits))* 2**i) %mod ans %= mod print(ans) if __name__ == "__main__": main()

n,p=map(int,input().split()) s=input() if p==2 or p==5: a=0 for i in range(n): if int(s[i])%p==0: a+=i+1 print(a) else: a=0 g=[0]*(n+1) t=[0]*p t[0]=1 d=1 for i in range(n-1,-1,-1): g[i]=(g[i+1]+int(s[i])*d)%p a+=t[g[i]] t[g[i]]+=1 d*=10 d%=p print(a)

s = input() if 4 < len(s) < 6: print('No') exit() if s[::-1] != s: print('No') exit() s = s[:len(s)//2] if s[::-1] != s: print('No') exit() print('Yes')

n,m = map(int,input().split()) ac = [0]*n wa = [0]*n count_ac = 0 count_wa = 0 for i in range(m): p,s = input().split() p = int(p) if ac[p-1]: continue if s == "WA": wa[p-1] += 1 else: ac[p-1] = True count_ac += 1 count_wa += wa[p-1] print(count_ac,count_wa)

n, m = map(int, input().split()) submissions = [list(input().split()) for _ in range(m)] count_penalty = [0] * (n + 1) count_ac = [0] * (n + 1) for i in range(m): ploblem = int(submissions[i][0]) if submissions[i][1] == "AC": count_ac[ploblem] = 1 elif count_ac[ploblem] != 1 and submissions[i][1] == "WA": count_penalty[ploblem] += 1 for i in range(n + 1): if count_ac[i] != 1: count_penalty[i] = 0 print("{} {}".format(count_ac.count(1), sum(count_penalty)))

from operator import mul from functools import reduce def cmb(n,r): r = min(n-r,r) if r == 0: return 1 over = reduce(mul, range(n, n - r, -1)) under = reduce(mul, range(1,r + 1)) return over // under n,m = map(int,input().split()) cmb_n = cmb(n,2) if n>=2 else 0 cmb_m = cmb(m,2) if m>=2 else 0 print(cmb_n+cmb_m)

import sys def main(): input = sys.stdin.buffer.readline n, m = map(int, input().split()) print(n * (n - 1) // 2 + m * (m - 1) // 2) if __name__ == "__main__": main()

s = list(map(int,input().split())) if len(set(s))==2: print("Yes") else: print("No")

a, b, c = map(int, input().split()) ret = "No" if (a == b and a != c) or (b == c and c != a) or (c == a and a != b): ret = "Yes" print("{}".format(ret))

L = int(input()) n = L/3 print(n*n*n)

L = int(input()) print("{}".format((L / 3)**3))

import math def koch(left, right, n): if n < 1: print(" ".join(map(str, left))); return s, t, u = [0] * 2, [0] * 2, [0] * 2 s[0] = (2 * left[0] + right[0]) / 3.0 s[1] = (2 * left[1] + right[1]) / 3.0 t[0] = (left[0] + 2 * right[0]) / 3.0 t[1] = (left[1] + 2 * right[1]) / 3.0 u[0] = (t[0] - s[0]) * math.cos(math.pi/3) - (t[1] - s[1]) * math.sin(math.pi/3) + s[0] u[1] = (t[0] - s[0]) * math.sin(math.pi/3) + (t[1] - s[1]) * math.cos(math.pi/3) + s[1] koch(left, s, n-1) koch(s, u, n-1) koch(u, t, n-1) koch(t, right, n-1) n = int(input()) left = [0, 0] right = [100, 0] koch(left, right, n) print(right[0], right[1])

import math a, b, C=map(int,input().split()) S=a*b*math.sin(math.pi*C/180)/2 c=math.sqrt(a**2+b**2-2*a*b*math.cos(math.pi*C/180)) L=a+b+c h=2*S/a print('{:.4f}'.format(S)) print('{:.4f}'.format(L)) print('{:.4f}'.format(h))

n, m, x = map(int, input().split()) books = [list(map(int, input().split())) for _ in range(n)] INF = 10 ** 9 + 7 ans = INF for bits in range(2 ** n): cost = 0 score = [0] * m for i, book in enumerate(books): if bits >> i & 1: cost += book[0] score = [s + b for s, b in zip(score, book[1:])] if all(s >= x for s in score): ans = min(ans, cost) if ans == INF: print(-1) else: print(ans)

#from statistics import median #import collections #aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0] from fractions import gcd from itertools import combinations,permutations,accumulate, product # (string,3) 3回 #from collections import deque from collections import deque,defaultdict,Counter import decimal import re #import bisect # # d = m - k[i] - k[j] # if kk[bisect.bisect_right(kk,d) - 1] == d: # # # # pythonで無理なときは、pypyでやると正解するかも！！ # # # my_round_int = lambda x:np.round((x*2 + 1)//2) # 四捨五入g import sys sys.setrecursionlimit(10000000) mod = 10**9 + 7 #mod = 9982443453 def readInts(): return list(map(int,input().split())) def I(): return int(input()) n,m,x = readInts() C = [readInts() for _ in range(n)] INF = float('inf') ans = INF for bit in range(1 << n): all = [0] * m money = 0 for i in range(n): if bit & (1 << i): money += C[i][0] for j in range(m): all[j] += C[i][j+1] flag = True for k in range(m): if all[k] >= x: pass else: flag = False break if flag: ans = min(ans, money) print(ans if ans != INF else '-1')

C=str(input()) a=ord(C) print(chr(a+1))

n = input() ord_s = ord(n) chr_s = chr(ord_s + 1) print(chr_s)

buff=input() print(buff.swapcase())

# coding: utf-8 line = raw_input() print ''.join([((s.lower() if s.isupper() else s.upper()) if s.isalpha() else s) for s in line])

num = (10 ** 9) + 7 n, k = map(int, input().split()) a = list(map(int, input().split())) plus = [] minus = [] zero = 0 ans = 1 for i in a: if i > 0: plus.append(i) elif i < 0: minus.append(-i) else: zero += 1 plus.sort() minus.sort() p_l = len(plus) m_l = len(minus) cnt = 0 def tail_num(p): return p[-1] * p[-2] if k == 1: print(max(a) % num) elif zero > n - k: print(0) elif zero == n - k: for i in plus: ans = (i * ans) % num for j in minus: ans = (ans * j) % num if m_l % 2 == 0: print(ans) else: print(-ans % num) elif len(plus) == 0: if k % 2 == 0: for j in range(k): ans = ans * (minus[-(j + 1)]) % num print(ans % num) else: if 0 in a: print(0) else: for j in range(k): ans = ans * (minus[j]) % num print(-ans % num) else: if k % 2 == 1: ans = ans * plus.pop() % num p_l -= 1 for i in range(k//2): if p_l >= 2 and m_l >= 2: if tail_num(minus) >= tail_num(plus): ans = ans * tail_num(minus) % num minus.pop() minus.pop() m_l -= 2 else: ans = ans * tail_num(plus) % num plus.pop() plus.pop() p_l -= 2 else: if p_l <= 1: ans = ans * tail_num(minus) % num minus.pop() minus.pop() m_l -= 2 else: ans = ans * tail_num(plus) % num plus.pop() plus.pop() p_l -= 2 print(ans)

n = int(input()) s = input() if n % 2 == 1: print('No') exit() flg = True n2 = n // 2 for i in range(n2): if s[i] != s[n2+i]: flg = False break print('Yes') if flg else print('No')

n,k=map(int,input().split()) a=list(map(int,input().split())) dic={} wk=1 start=0 for i in range(1,n+1): wk=a[wk-1] if wk in dic: start=dic[wk] break dic[wk]=i end=len(dic) loopcnt=end-start+1 keys=list(dic.keys()) if k<start: print(keys[k-1]) else: chk=(k-start+1)%loopcnt if chk==0: chk=loopcnt print(keys[(start-1)+chk-1])

def main(): S = '' while True: try: S = S + input() except: break s = S.lower() for i in range(97, 123): c = chr(i) n = s.count(c) print('{} : {}'.format(c, n)) main()

dicpos = {} dicneg = {} N = int(input()) for i in range(N): buf = [0] for s in input(): if s=="(": buf.append(buf[-1] + 1) else: buf.append(buf[-1] - 1) low = min(buf) last = buf[-1] if last>0: if low in dicpos: dicpos[low].append(last) else: dicpos[low] = [last] else: if low-last in dicneg: dicneg[low-last].append(-last) else: dicneg[low-last] = [-last] neg_sorted = sorted(dicneg.items(), key=lambda x:x[0], reverse=True) pos_sorted = sorted(dicpos.items(), key=lambda x:x[0], reverse=True) #print(neg_sorted) #print(pos_sorted) summ = 0 flag = 0 for i in pos_sorted: if flag == 1: break for j in i[1]: if summ + i[0] < 0: flag = 1 print("No") break summ += j summ2 = 0 if flag == 0: for i in neg_sorted: if flag == 1: break for j in i[1]: if summ2 + i[0] < 0: flag = 1 print("No") break summ2 += j if flag == 0: if summ == summ2: print("Yes") else: print("No")

import numpy as np r=int(input()) print(2*np.pi*r)

N, M = map(int, input().split()) A = sorted(list(map(int, input().split()))) def count_bigger_x(x): cnt = 0 piv = N-1 for a in A: while piv >= 0 and a + A[piv] >= x: piv -= 1 cnt += N - piv - 1 return cnt def is_ok(x): cnt = count_bigger_x(x) return cnt >= M def bisect(ng, ok): while (abs(ok - ng) > 1): mid = (ok + ng) // 2 if is_ok(mid): ok = mid else: ng = mid return ok x = bisect(2 * A[-1] + 1, 2 * A[0] - 1) ans = 0 piv = N-1 for a in A: while piv >= 0 and a + A[piv] >= x: piv -= 1 ans += (N - piv - 1) * a ans *= 2 ans -= 1 * x * (count_bigger_x(x) - M) print(ans)

import sys from collections import defaultdict import bisect import itertools readline = sys.stdin.buffer.readline # sys.setrecursionlimit(10**5) def geta(fn=lambda s: s.decode()): return map(fn, readline().split()) def gete(fn=lambda s: s.decode()): return fn(readline().rstrip()) def main(): N, M = geta(int) A = list(geta(int)) A.sort() def c(x): """ @return # of handshake where hapiness >= x """ ret = 0 for a in A: ret += bisect.bisect_left(A, x - a) return N * N - ret left, right = 0, 2 * A[-1] + 1 while left + 1 < right: middle = (left + right) // 2 if c(middle) >= M: left = middle else: right = middle ans = 0 Acum = list(itertools.accumulate(A[::-1]))[::-1] for a in A: idx = bisect.bisect_left(A, right - a) if idx < N: ans += Acum[idx] + a * (N - idx) ans += left * (M - c(right)) print(ans) if __name__ == "__main__": main()

""" Given N, D, A, N means no. of monsters, D means distances of bombs, A attack of the bombs Find the minimum of bombs required to win. Each monster out of N pairs - pair[0] = position, pair[1] = health """ from collections import deque mod = 1e9+7 def add(a, b): c = a + b if c >= mod: c -= mod return c def main(): N, D, A = [int(x) for x in raw_input().split()] D *= 2 monsters = [] for _ in range(N): pos, health = [int(x) for x in raw_input().split()] monsters.append([pos, health]) monsters.sort(key = lambda x : x[0]) remain_attacks_queue = deque([]) remain_attack = 0 ans = 0 for monster in monsters: # monster[0] - pos, monster[1] - health # queue[0] - position, queue[1] - attack points while len(remain_attacks_queue) and monster[0] - D > remain_attacks_queue[0][0]: remain_attack -= remain_attacks_queue.popleft()[1] if remain_attack < monster[1]: remained_health = monster[1] - remain_attack times = remained_health / A if remained_health % A == 0 else remained_health // A + 1 #print(times) attack = times * A remain_attacks_queue.append([monster[0], attack]) ans += times remain_attack += attack print(ans) main()

import sys from collections import deque input = sys.stdin.buffer.readline sys.setrecursionlimit(10 ** 7) N, D, A = map(int, input().split()) XH = list(tuple(map(int, input().split())) for _ in range(N)) XH.sort() ans = 0 memo = deque() cnt = 0 for x, h in XH: while memo and memo[0][0] < x: _, i = memo.popleft() cnt -= i h -= cnt * A h = max(h, 0) bomb = (h + A - 1) // A ans += bomb cnt += bomb memo.append((x + 2 * D, bomb)) print(ans)

x=input() x=str.swapcase(x) print(x)

s = raw_input().swapcase() print s

a,b,h,m = map(int,input().split()) import math C = abs(360 / 60 * m - 360 / 12 * h - 360 / 12 / 60 * m) if C > 180: C = 360 - C #print(C) cosC = math.cos(math.radians(C)) #print(cosC) print(math.sqrt(a ** 2 + b ** 2 - 2 * a * b * cosC))

A,B,C=map(int,input().split()) if (A==B and A!=C) or (B==C and B!=A) or (C==A and C!=B): print('Yes') else: print('No')

(lambda *_: None)( *map(print, map('Case {0[0]}: {0[1]}'.format, enumerate(iter(input, '0'), 1))))

import os, sys, re, math (K, X) = (int(n) for n in input().split()) if 500 * K >= X: print('Yes') else: print('No')

import sys n = int( sys.stdin.readline() ) nums = sys.stdin.readline().rstrip().split( " " ) nums.reverse() print( " ".join( nums ) )

dice = [int(i) for i in input().split()] directions = str(input()) for direction in directions: if direction == "N": dice = [dice[1], dice[5], dice[2], dice[3], dice[0], dice[4]] elif direction == "S": dice = [dice[4], dice[0], dice[2], dice[3], dice[5], dice[1]] elif direction == "E": dice = [dice[3], dice[1], dice[0], dice[5], dice[4], dice[2]] else: dice = [dice[2], dice[1], dice[5], dice[0], dice[4], dice[3]] print(dice[0])

def draft(A, K, N): for _ in range(1, K+1):# 2 * 10**5 tmp = [0]*(N+1) for i in range(N):# 2 * 10**5 L = max(0, i - A[i]) R = min(N, i + A[i]+1) tmp[L] += 1 tmp[R] -= 1 f = True for i in range(N): tmp[i+1] += tmp[i] A[i] = tmp[i] if A[i] != N: f = False if f: break for i in range(N): print(A[i], end=" ") def main(): N, K = map(int, input().split()) A = list(map(int, input().split())) draft(A, K, N) if __name__ == "__main__": main()

from fractions import gcd N = int(input()) A = list(map(int, input().split())) mod = 10**9+7 x = 1 for i in range(N): x = (x*A[i]) // gcd(x, A[i]) ans = 0 for a in A: ans += x//a #ans %= mod print(ans%mod)

a, b = map(int,input().split()) c, d = map(int,input().split()) if d == 1: print("1") else: print("0")

def main(): M1, D1 = map(int, input().split()) M2, D2 = map(int, input().split()) if D2 == 1: print(1) else: print(0) if __name__ == "__main__": main()

a, b, c, d = map(int, input().split()) t_death = a // d + 1 if a % d else a // d a_death = c // b + 1 if c % b else c // b if t_death >= a_death: print('Yes') else: print('No')

A, B, C, D=map(int,input().split()) while C or A >= 0: C -= B A -= D if C <= 0: print("Yes") break if A <= 0: print("No") break

def insertionSort(A, n, g): cnt = 0 for i in xrange(g, n): v = A[i] j = i - g while (j >= 0) and (A[j] > v): A[j+g] = A[j] j = j - g cnt += 1 A[j+g] = v return cnt def shellSort(A, n): # variables cnt, m, t = 0, 1, n # getting m while (t-1)/3 > 0: t, m = (t-1)/3, m+1 print m # creating and printing G G = [1] for i in xrange(1,m): G.append(1+G[i-1]*3) G = list(reversed(G)) print " ".join( map(str, G) ) # sorting for i in xrange(0, m): cnt += insertionSort(A, n, G[i]) return cnt # MAIN n = input() A = [input() for i in xrange(n)] cnt = shellSort(A, n) print cnt for i in xrange(n): print A[i]

N,M = map(int,input().split()) ki = (N*(N-1))//2 gu = (M*(M-1))//2 print (ki+gu)

import bisect, collections, copy, heapq, itertools, math, string import sys def I(): return int(sys.stdin.readline().rstrip()) def MI(): return map(int, sys.stdin.readline().rstrip().split()) def LI(): return list(map(int, sys.stdin.readline().rstrip().split())) def S(): return sys.stdin.readline().rstrip() def LS(): return list(sys.stdin.readline().rstrip().split()) X = I() print((X // 500) * 1000 + ((X - ((X // 500) * 500)) // 5) * 5)

import sys input = lambda : sys.stdin.readline().rstrip() sys.setrecursionlimit(max(1000, 10**9)) write = lambda x: sys.stdout.write(x+"\n") n,m,l = list(map(int, input().split())) from collections import defaultdict ns = defaultdict(set) for i in range(m): a,b,c = map(int, input().split()) a-=1 b-=1 if c<=l: ns[a].add((c,b)) ns[b].add((c,a)) def wf(ns): """全頂点間距離 """ d = [[float("inf")]*n for _ in range(n)] for i in range(n): for t,j in ns[i]: d[i][j] = t d[i][i] = 0 for k in range(n): for i in range(n): for j in range(n): d[i][j] = min(d[i][j], d[i][k]+d[k][j]) return d dist = wf(ns) ns2 = defaultdict(set) for i in range(n): for j in range(i+1,n): if dist[i][j]<=l: ns2[i].add((1,j)) ns2[j].add((1,i)) ddist = wf(ns2) q = int(input()) ans = [None]*q for i in range(q): s,t = map(int, input().split()) s-=1 t-=1 if dist[s][t]==float("inf"): ans[i] = -1 else: ans[i] = ddist[s][t] - 1 write("\n".join(map(str, ans)))

n = int(input()) d = [[0] * 10 for _ in range(10)] for i in range(1, n + 1): d[int(str(i)[0])][i % 10] += 1 ret = 0 for s in range(10): for e in range(10): ret += d[s][e] * d[e][s] print(ret)

import sys import collections import bisect def main(): n = int(input()) a = [str(i + 1)[0] + str(i + 1)[-1] for i in range(n)] b = [str(i + 1)[-1] + str(i + 1)[0] for i in range(n)] ac, bc = collections.Counter(a), collections.Counter(b) print(sum(ac[i] * bc[i] for i in ac.keys())) if __name__ == '__main__': main()

ans = 0 while True: num = list(map(str,input().split())) if(num[1] == "?"): break a = int(num[0]) b = int(num[2]) op = num[1] if(op == "+"): ans=a+b elif(op == "-"): ans=a-b elif(op == "*"): ans=a*b elif(op == "/"): ans=a/b print("%d" %ans)

def resolve(): word=input() print(chr(ord(word)+1)) resolve()

#!/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 nPr(n: int, r: int) -> int: return math.factorial(n) // math.factorial(n - r) def nCr(n: int, r: int) -> int: return math.factorial(n) // (math.factorial(n - r) * math.factorial(r)) def solve(N: int, M: int): return (nCr(N, 2)if N > 1 else 0) + (nCr(M, 2) if M > 1 else 0) 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 print(f'{solve(N, M)}') if __name__ == '__main__': main()

def insert(cnt, data): T[str(data)] = cnt cnt = 0 T = {} n = int(input()) for i in range(n): Order, data_S = input().split() if Order[0] =="i": insert(cnt, data_S) cnt +=1 else: if str(data_S) in T: print("yes") else: print("no")

import sys # import re # import math # import collections # import decimal # import bisect # import itertools # import fractions # import functools # import copy # import heapq # import decimal # import statistics import queue sys.setrecursionlimit(10000001) INF = 10 ** 16 MOD = 10 ** 9 + 7 ni = lambda: int(sys.stdin.readline()) ns = lambda: map(int, sys.stdin.readline().split()) na = lambda: list(map(int, sys.stdin.readline().split())) # ===CODE=== def main(): n = ni() a = na() d = [0, 0, 0] ans = 1 for ai in a: ans *= d.count(ai) ans %= MOD for i in range(3): if d[i] == ai: d[i] += 1 break print(ans) if __name__ == '__main__': main()

N = int(input()) A = list(map(int, input().split())) ans = 1 l = [0] * N for i in range(N): n = A[i] if 0 < n: ans *= l[n-1] - l[n] else: ans *= 3 - l[n] l[n] += 1 ans %= 1000000007 print(ans)

import sys input_methods=['clipboard','file','key'] using_method=0 input_method=input_methods[using_method] tin=lambda : map(int, input().split()) lin=lambda : list(tin()) mod=1000000007 #+++++ def main(): k = int(input()) #b , c = tin() #s = input() l=['_']*50 l[0]=0 for _ in range(k): for i, v in enumerate(l): l[i]+=1 if l[i] == 10 and l[i+1]=='_': l[i+1]=1 l[:i+1]=[0]*(i+1) break elif l[i] == 10: l[i]=l[i+1] elif l[i+1]=='_': #l[:i]=[l[i]-1]*(i) for j in range(1,i+1): l[i-j]=max(0, l[i-j+1]-1) break elif l[i] <= l[i+1]+1: #l[:i]=[l[i]-1]*i for j in range(1,i+1): l[i-j]=max(0, l[i-j+1]-1) break #print(*l) print(''.join([str(c) for c in l[::-1] if c != '_'])) #+++++ isTest=False def pa(v): if isTest: print(v) def input_clipboard(): import clipboard input_text=clipboard.get() input_l=input_text.splitlines() for l in input_l: yield l if __name__ == "__main__": if sys.platform =='ios': if input_method==input_methods[0]: ic=input_clipboard() input = lambda : ic.__next__() elif input_method==input_methods[1]: sys.stdin=open('inputFile.txt') else: pass isTest=True else: pass #input = sys.stdin.readline ret = main() if ret is not None: print(ret)

s,t=input().split();print(t+s)

n = int(input()) z = [] w = [] for i in range(n): x,y = map(int,input().split()) z.append(x+y) w.append(x-y) zmax = max(z)-min(z) wmax = max(w)-min(w) print(max(zmax,wmax))

n = int(input()) x = [0] * n y = [0] * n for i in range(n): x[i], y[i] = map(int, input().split()) z = [0] * n w = [0] * n for i in range(n): z[i] = x[i] + y[i] w[i] = x[i] - y[i] cand1 = max(z) - min(z) cand2 = max(w) - min(w) print(max(cand1, cand2))

#昔はtleの回答、今は通る？ import sys input=sys.stdin.readline n=int(input()) lists=list(map(int,input().split())) aa=[0 for i in range(n)] bb=[0 for i in range(n)] length=61 use=[0 for i in range(61)] for j in range(n): k=format(lists[j],"0%ib"%length) k=k[::-1] aa[j]=k[:30] bb[j]=k[30:] for p in aa: for some in range(30): use[some]+=int(p[some]) for q in bb: for some in range(31): use[some+30]+=int(q[some]) answer=0 for j in range(61): answer+=(2**j)*use[j]*(n-use[j])%(10**9+7) print(answer%(10**9+7))

from collections import defaultdict N = int(input()) A = list(map(int, input().split())) mod = 10 ** 9 + 7 def prime_factorize(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 primes = defaultdict(int) for a in A: for x, p in prime_factorize(a): primes[x] = max(primes[x], p) lcm = 1 for prime, ind in primes.items(): lcm *= prime ** ind ans = 0 for i in range(N): ans += lcm // A[i] if i == N // 2: ans %= mod print(ans % mod)

N,K=map(int,input().split()) a=N%K print(min([a,K-a]))

x = list(map(int, input().split())) n = x[0] k = x[1] y = n % k if y < abs(y - k): print(y) else: print(abs(y - k))

n,x,t=map(int,input().split()) kaisu=n//x if n%x!=0: kaisu+=1 ans=kaisu*t print(ans)

x, y, z = map(int, input().split()) createNum = 0 createTime = 0 loopCnt = x//y createNum = y*loopCnt createTime = z*loopCnt remain = x%y if remain != 0: createTime += z print(createTime)

# 問題: https://atcoder.jp/contests/abc144/tasks/abc144_c import math n = int(input()) a = int(math.sqrt(n)) b = 0 while b == 0: if n % a > 0: a -= 1 continue b = n / a res = a + b - 2 print(int(res))

from math import sqrt n=int(input()) m=int(sqrt(n)//1) for i in range(m,0,-1): if n%i==0: m=i o=n//m break print(m+o-2)

a,b,m = map(int,input().split()) A = list(map(int,input().split())) B = list(map(int,input().split())) ans = [] ans.append(min(A)+min(B)) for i in range(m): M = list(map(int,input().split())) tmp = A[M[0]-1] + B[M[1]-1] -M[2] ans.append(tmp) print(min(ans))

import math N,K=map(int,input().split()) sum=0 for s in range(K,N+1): sum+=(s*(2*N-s+1))/2-(s*(s-1))/2+1 print(int(sum+1)%1000000007)

import bisect def roller_coaster(n, k, hli): hli.sort() lenght = len(hli) ans = lenght - bisect.bisect_left(hli, k) return ans def main(): n, k = map(int, input().split()) hli = list(map(int, input().split())) print(roller_coaster(n, k, hli)) if __name__ == '__main__': main()

# B - Roller Coaster # N K N, K = map(int, input().split()) my_list = list(map(int, input().split(maxsplit=N))) answer = 0 for i in range(0, N): if my_list[i] >= K: answer += 1 print(answer)

from sys import stdin, stdout, setrecursionlimit from collections import deque, defaultdict, Counter from heapq import heappush, heappop import math rl = lambda: stdin.readline() rll = lambda: stdin.readline().split() rli = lambda: map(int, stdin.readline().split()) rlf = lambda: map(float, stdin.readline().split()) INF, NINF = float('inf'), float('-inf') def main(): n = int(rl()) ans = 0 for i, a in enumerate(rli(), 1): if i % 2 == 1 and a % 2 == 1: ans += 1 print(ans) stdout.close() if __name__ == "__main__": main()

from itertools import permutations N=int(input()) ans = ['']*N al = 'abcdefghij' d = {al[i]:i for i in range(N)} def dfs(h=[]): if len(h)==N: print(''.join(h)) return for i in range(max([d[h[-1-i]] for i in range(len(h))])+2): h.append(al[i]) dfs(h) h.pop() return dfs(['a'])

def move(up,bottom,right,left,front,back,direction): if direction == "N": return (front,back,right,left,bottom,up) elif direction == "S": return (back,front,right,left,up,bottom) elif direction == "E": return (left,right,up,bottom,front,back) elif direction == "W": return (right,left,bottom,up,front,back) up,front,right,left,back,bottom = input().split() direction = list(input()) for i in range(len(direction)): up,bottom,right,left,front,back = move(up,bottom,right,left,front,back,direction[i]) print(up)

N = int(input()) A = N // 2 B = N % 2 print(A + B)

while True: x, y = map(int, input().split()) if x == 0 and y == 0: break else: a = [x, y] a.sort() print(a[0], a[1])

# coding: utf-8 import sys i = sys.stdin for line in i: a,b = map(int,line.split()) if a == 0 and b == 0: break if a < b: print(a,b) else: print(b,a)

d, t, s = map(int, input().split()) dist = t * s - d if dist >= 0: print("Yes") elif dist < 0: print("No")

#!/usr/bin/env python3 import sys MOD = 998244353 # type: int class ModOperator: def __init__(self, MOD: int = 10 ** 9 + 7): self.MOD = MOD self.factorials = [1, 1] # x^n % MOD def mod_pow(self, x: int, n: int): bi = str(format(n, "b")) res = 1 a = x for i in range(len(bi)): if n >> i & 1: res = (res * a) % self.MOD a = (a * a) % self.MOD return res # x! % MOD def mod_fact(self, x: int): if x < len(self.factorials): return self.factorials[x] else: res = self.factorials[-1] for i in range(len(self.factorials), x + 1): res = res * i % self.MOD self.factorials.append(res) return res % self.MOD # inverse of a number def mod_inv(self, x: int): return self.mod_pow(x, self.MOD - 2) # conmination nCk def mod_comb(self, n: int, k: int): numerator = self.mod_fact(n) denomintator1 = self.mod_fact(k) denomintator2 = self.mod_fact(n - k) denomintator = denomintator1 * denomintator2 % self.MOD return numerator * self.mod_inv(denomintator) % self.MOD def main(): N, M, K = map(int, input().split()) op = ModOperator(MOD) sum = 0 for i in range(K + 1): sum += M * op.mod_pow(M - 1, N - 1 - i) * op.mod_comb(N - 1, i) print(sum % MOD) if __name__ == '__main__': main()

import sys class Card: def __init__(self, card): self.card = card self.mark = card[0] self.value = int(card[1]) def __str__(self): return self.card def print_cards(arr_print, arr_compare): n = len(arr_print) same = True for i in range(n): if arr_compare != None and arr_print[i].card != arr_compare[i].card: same = False sys.stdout.write(str(arr_print[i])) if i != n - 1: sys.stdout.write(' ') print() return same def swap(arr, i, j): temp = arr[i] arr[i] = arr[j] arr[j] = temp def bubble_sort(arr): n = len(arr) for i in range(0, n): for j in range(n - 1, i, -1): if arr[j].value < arr[j - 1].value: swap(arr, j, j - 1) def selection_sort(arr): n = len(arr) for i in range(n): minj = i for j in range(i, n): if arr[j].value < arr[minj].value: minj = j if minj != i: swap(arr, i, minj) n = int(input()) arr = list(map(str, input().split())) cards1 = [None] * n cards2 = [None] * n for i in range(n): cards1[i] = Card(arr[i]) cards2[i] = Card(arr[i]) bubble_sort(cards1) selection_sort(cards2) print_cards(cards1, None) print('Stable') stable = print_cards(cards2, cards1) if stable == True: print('Stable') else: print('Not stable')

_,k,*p=map(int,open(0).read().split());p.sort();print(sum(p[:k]))

n = int(input()) s = ["" for i in range(n)] t = [0 for i in range(n)] for i in range(n): a, b = input().split() s[i], t[i] = a, int(b) x = input() ans = 0 flag = False for i in range(n): if s[i] == x: flag = True elif flag: ans += t[i] print(ans)

n=int(input()) s=[] t=[] flag=0 ans=0 for i in range(n): ss,tt=map(str,input().split()) s.append(ss) t.append(int(tt)) x=input() for i in range(n): if s[i]==x: flag=1 continue if flag == 1: ans+=t[i] print(ans)

import math n, M= map(int,input().split()) #AB=[] #N = int(input()) #C = input() parents = [-1] * n def find( x): if parents[x] < 0: return x else: parents[x] = find(parents[x]) return parents[x] def union(x, y): x = find(x) y = find(y) if x == y: return if parents[x] > parents[y]: x, y = y, x parents[x] += parents[y] parents[y] = x def size( x): return -parents[find(x)] def same( x, y): return find(x) == find(y) def members( x): root = find(x) return [i for i in range(n) if find(i) == root] def roots(): return [i for i, x in enumerate(parents) if x < 0] def group_count(): return len(roots()) def all_group_members(): return {r: members(r) for r in roots()} def __str__(): return '\n'.join('{}: {}'.format(r, members(r)) for r in roots()) C = [] for i in range(M): A, B = map(int,input().split()) union(A-1,B-1) ''' c = 0 for p in C: if A in p: c = 1 p.add(B) elif B in p: c = 1 p.add(A) if c != 1: C.append(set([A,B])) ''' print(group_count()-1)

import sys input = sys.stdin.buffer.readline R, C, K = map(int, input().split()) G = [[None for j in range(C)] for i in range(R)] for _ in range(K): r, c, v = map(int, input().split()) G[r - 1][c - 1] = v dp = [[0, 0, 0, 0] for _ in range(C)] for i in range(R): for j in range(C): if G[i][j] is not None: dp[j][0], dp[j][1] = max(dp[j]), max(dp[j]) + G[i][j] dp[j][2], dp[j][3] = 0, 0 else: dp[j][0] = max(dp[j]) dp[j][1], dp[j][2], dp[j][3] = 0, 0, 0 for j in range(1, C): if G[i][j] is not None: dp[j][0] = max(dp[j - 1][0], dp[j][0]) dp[j][1] = max(dp[j - 1][1], dp[j - 1][0] + G[i][j], dp[j][1]) if dp[j - 1][1] != 0: dp[j][2] = max(dp[j - 1][2], dp[j - 1][1] + G[i][j], dp[j][2]) if dp[j - 1][2] != 0: dp[j][3] = max(dp[j - 1][3], dp[j - 1][2] + G[i][j], dp[j][3]) else: dp[j][0] = max(dp[j - 1][0], dp[j][0]) dp[j][1] = max(dp[j - 1][1], dp[j][1]) dp[j][2] = max(dp[j - 1][2], dp[j][2]) dp[j][3] = max(dp[j - 1][3], dp[j][3]) print(max(dp[-1]))

from sys import stdin, setrecursionlimit def main(): input = stdin.readline n = int(input()) s_arr = [] t_arr = [] for _ in range(n): s, t = list(map(str, input().split())) t = int(t) s_arr.append(s) t_arr.append(t) x = input()[:-1] print(sum(t_arr[s_arr.index(x) + 1:])) if __name__ == "__main__": setrecursionlimit(10000) main()

n = int(input()) s = [] t = [] for i in range(n): a,b = input().split() s.append(a) t.append(int(b)) x = s.index(input()) ans = 0 for i in range(x+1,n): ans += t[i] print(ans)

N = int(input()) letters = 'zabcdefghijklmnopqrstuvwxy' def solve(N): md = N%26 l = letters[md] if md==0: md=26 if N>26: return solve((N-md)//26) + l else: return l print(solve(N))

l = int(input()) print(l/3 * l/3 * (l - 2*l/3))

a = list(map(int, input().split())) suma = a[0] + a[1] + a[2] if suma >= 22: print('bust') else: print('win')

if 22 > sum(map(int, input().split())): print('win') else: print('bust')

# -*- coding: utf-8 -*- k,x = list(map(int,input().split())) ret = "No" if 500*k>=x: ret = "Yes" print(ret)

#!/usr/bin/env python3 k, x = map(int, input().split()) print(["No", "Yes"][500 * k >= x])

n=int(input()) if(n//2==n/2): m=n//2 else: m=n//2+1 print(m)

a = input().split() sum = 0 for n in a: sum += int(n) print('bust') if sum >= 22 else print('win')

mt = [] for i in range(10): mt.append(int(input())) mt.sort() print( mt[9] ) print( mt[8] ) print( mt[7] )

import sys read = sys.stdin.buffer.read readline = sys.stdin.buffer.readline readlines = sys.stdin.buffer.readlines def main(): S = input() if S[-1] == 's': print(S+'es') else: print(S+'s') if __name__ == '__main__': main()

a,b = map(int,input().split()) for i in range(1,1251): if int(i*0.08)==a and int(i*0.1)==b: print(i); break else: print('-1')

A, B = map(int, input().split()) a = [i for i in range(int((A-1)*100/8 ), int((A+1)*100/8 ))] b = [i for i in range(int((B-1)*100/10), int((B+1)*100/10))] a = [i for i in a if int(i*0.08) == A] b = [i for i in b if int(i*0.10) == B] ans = list(set(a) & set(b)) if ans and min(ans) > 0: print(min(ans)) else: print(-1)

MOD = 10**9 + 7 fac = [1 for k in range(200010)] inv = [1 for k in range(200010)] finv = [1 for k in range(200010)] for k in range(2,200010): fac[k] = (fac[k-1]*k)%MOD inv[k] = (MOD - inv[MOD%k] * (MOD // k))%MOD finv[k] = (finv[k - 1] * inv[k]) % MOD; def nCr(n,r): return (fac[n]*finv[r]*finv[n-r])%MOD N, K = map(int,input().split()) A = sorted(list(map(int,input().split()))) m = 0 for k in range(N-K+1): m += A[k]*nCr(N-k-1,K-1) m %= MOD A = A[::-1] M = 0 for k in range(N-K+1): M += A[k]*nCr(N-k-1,K-1) M %= MOD print(M-m if M>=m else M-m+MOD)

from math import factorial n,k=map(int,input().split()) a=list(map(int,input().split())) mod=10**9+7 ans=0 a.sort() x=(factorial(n-1)*pow(factorial(k-1),mod-2,mod)*pow(factorial(n-k),mod-2,mod))%mod y=1 for i in range(n-k+1): ans-=a[i]*x ans%=mod x=(x*(n-k-i)*pow(n-i-1,mod-2,mod))%mod for i in range(k-1,n): ans+=a[i]*y ans%=mod y=(y*(i+1)*pow(i-k+2,mod-2,mod))%mod print(ans)

s = raw_input().swapcase() print s

s1 = input() s2 = input() if s2 in s1+s1: print("Yes") else: print("No")

a,b=map(int,raw_input().split()) men=a*b syuu=(a+b)*2 print men,syuu

lines = input().split(' ') x = int(lines[0]) y = int(lines[1]) print(x * y, (x + y) * 2)

res = [] n = int(input()) for i in range(n): r = input() res.append(r) ac = res.count("AC") wa = res.count("WA") tle = res.count("TLE") re = res.count("RE") print("AC x "+str(ac)) print("WA x "+str(wa)) print("TLE x "+str(tle)) print("RE x "+str(re))

s = [] n = int(input()) for i in range(n): s.append(input()) print("AC x " + str(s.count("AC"))) print("WA x " + str(s.count("WA"))) print("TLE x " + str(s.count("TLE"))) print("RE x " + str(s.count("RE")))

def gcd(li): a=max(li) b=min(li) while b>0: a,b=b,a%b return a def lcm(li): return li[0]*li[1]/gcd(li) while True: try: li=[int(i) for i in input().split(" ")] print("%i %i"%(gcd(li),lcm(li))) except:break

#2-8 while True: try: def gcd(a,b): if b == 0: return a else: return gcd(b,a%b) a = list(map(int,input().split())) a.sort() a.reverse() ans1 = gcd(a[0],a[1]) ans2 = int(a[0]*a[1]/ans1) print(ans1,ans2) except: break

n = int(input()) cn= 1 an= [1] i = 1 while cn < n / 4: an.append(cn*3+1) cn=cn*3+1 an.sort(reverse=True) def insertionSort(a,n,g): cnt=0 for i in range(g,n): v = a[i] j = i - g while j>= 0 and a[j]>v: a[j + g]= a[j] j = j-g cnt+=1 a[j + g]=v return cnt def shellSort(a,n,an): cnt=0 m = len(an) g = an for i in an: cnt += insertionSort(a,n,i) return cnt x=[] for i in range(n): x.append(int(input())) print(len(an)) print(" ".join([str(i) for i in an])) y= shellSort(x,n,an) print(y) for i in range(n): print(x[i])

def insertionSort(A, n, g, cnt): for i in range(g, n): v = A[i] j = i - g while (j >= 0) and (A[j] > v): A[j+g] = A[j] j = j - g cnt += 1 A[j+g] = v return cnt def shellSort(A, n, m, G): cnt = 0 for i in range(m): cnt = insertionSort(A, n, G[i], cnt) return cnt n = int(input()) A = [] for i in range(n): A.append(int(input())) h = 1 p = 1 G = [] if n < 2: G = [1] p = 2 else: while h < n: G.append(h) h = 3 ** p + h p += 1 G.reverse() cnt = shellSort(A, n, p - 1, G) print(p - 1) print(" ".join(map(str, G))) print(cnt) for i in range(n): print(A[i])

n = int(input()) print(n//2-1 + n % 2)

n, k = map(int, input().split()) W = [int(input()) for _ in range(n)] def can_load(W, k, q, n): i = 0 for _ in range(k): s = 0 while i < n and s + W[i] <= q: s += W[i] i += 1 if i == n: return True else: return False # 積載量をmidと仮定して二分探索 hi = 10 ** 9 # OK lo = 0 # NG while hi - lo > 1: mid = (hi + lo) // 2 if can_load(W, k, mid, n): hi = mid else: lo = mid print(hi)

import sys input = sys.stdin.readline from collections import * def bfs(): q = deque([0]) pre = [-1]*N pre[0] = 0 while q: v = q.popleft() for nv in G[v]: if pre[nv]==-1: pre[nv] = v q.append(nv) return pre N, M = map(int, input().split()) G = [[] for _ in range(N)] for _ in range(M): A, B = map(int, input().split()) G[A-1].append(B-1) G[B-1].append(A-1) pre = bfs() print('Yes') for pre_i in pre[1:]: print(pre_i+1)

from collections import deque N, M = map(int, input().split()) route = [[] for i in range(N)] for i in range(M): a, b = map(int, input().split()) route[a - 1].append(b - 1) route[b - 1].append(a - 1) print('Yes') q = deque() d = [-1] * N d[0] = 0 q.append(0) while q: x = q.popleft() for i in route[x]: if d[i] == -1: d[i] = x + 1 q.append(i) for i in range(1, N): print(d[i])

import sys A,V = map(int, input().split()) B,W = map(int, input().split()) T = int(input()) #これO(1)で解けそう。 # スピードが同じ or 逃げる方のスピードが速いと無理 if V <= W: print("NO") sys.exit() # 鬼の方がスピードが速い場合で場合訳 distance_AB = abs(A-B) speed_AB = abs(V-W) if speed_AB * T >= distance_AB: print("YES") else: print("NO")

A, V = map(int, input().split()) B, W = map(int, input().split()) T = int(input()) a = abs(B-A) if T * (V-W) >= a: print("YES") else:print("NO")

# B - Multiple of 9 n = input() print('Yes' if sum(int(d) for d in n) % 9 == 0 else 'No')

import Queue n,q=map(int,raw_input().strip().split()) name=[] time=[] qu=Queue.Queue() class task: def __init__(self,name,time): self.name=name self.time=time self.total=0 for i in xrange(n): inp=raw_input().strip().split() qu.put(task(inp[0],int(inp[1]))) curtime=0 while not qu.empty(): tmp=qu.get() if tmp.time>q: tmp.time-=q curtime+=q qu.put(tmp) else: curtime+=tmp.time ed='' if qu.qsize()==0 else '\n' print tmp.name,curtime # print curtime

import sys while(True): x, y = map(lambda x: (int, int)[x.isdigit()](x) ,sys.stdin.readline().split(None, 1)) if x == 0 and y == 0: break if x < y: print("%d %d" % (x, y)) else: print("%d %d" % (y, x))

i=0 xArray=[] yArray=[] while True: x,y=(int(num) for num in input().split()) if x==0 and y==0: break else: xArray.append(x) yArray.append(y) i+=1 for count in range(i): if xArray[count] < yArray[count]: print(xArray[count],yArray[count]) else: print(yArray[count],xArray[count])

a,b,c = map(int, input().split()) print(len(list(filter(lambda x: c%x==0,range(a,b+1)))))

from sys import stdin a, b, c = [int(x) for x in stdin.readline().rstrip().split()] print(len([x for x in range(a, b+1) if c % x == 0]))

s = input() n = int(input()) for i in range(n): tmp = input().split() a = int(tmp[1]) b = int(tmp[2]) if tmp[0] == "print": print(s[a:b+1]) elif tmp[0] == "reverse": s = s[:a] + s[a:b+1][::-1] + s[b+1:] elif tmp[0] == "replace": s = s[:a] + tmp[3] + s[b+1:]

S = list(input()) q = int(input()) for i in range(q): cmd, a, b, *c = input().split() a = int(a) b = int(b) if cmd == "replace": S[a:b+1] = c[0] elif cmd == "reverse": S[a:b+1] = reversed(S[a:b+1]) else: print(*S[a:b+1], sep='')

def main(): import collections n, m = map(int, input().split()) hs = list(map(int, input().split())) nmap = [0] * n cnt = 0 for j in range(m): v = input().split() v0 = int(v[0]) - 1 v1 = int(v[1]) - 1 if hs[v0] < hs[v1]: nmap[v0] += 1 elif hs[v0] == hs[v1]: nmap[v0] += 1 nmap[v1] += 1 else: nmap[v1] += 1 for i in nmap: if i == 0: cnt += 1 return cnt if __name__ == '__main__': print(main())

n = int(input()) s = [] for i in range(n): s.append(input()) ls1 = [] ls2 = [] for item in s: stk1 = [] stk2 = [] for ch in item: if ch == '(': stk2.append(ch) else: if len(stk2) > 0: stk2.pop() else: stk1.append(ch) l1 = len(stk1) l2 = len(stk2) if l2 >= l1: ls1.append((l1, l2)) else: ls2.append((l1, l2)) ls1.sort() cnt = 0 for item in ls1: cnt -= item[0] if cnt < 0: print('No') exit() else: cnt += item[1] ls2.sort(key=lambda x: x[1]) ls2.reverse() for item in ls2: cnt -= item[0] if cnt < 0: print('No') exit() else: cnt += item[1] if cnt != 0: print('No') else: print('Yes')

n=int(input()) a=list(map(int,input().split())) ans="APPROVED" for i in range(n): if a[i]%2==0: if a[i]%3==0 or a[i]%5==0: continue else: ans="DENIED" break print(ans)

n=int(input()) a=list(map(int,input().split())) t=1 for i in range(n): if a[i]%2==0 and a[i]%3==0: t=1 elif a[i]%2==0 and a[i]%5==0: t=1 elif a[i]%2==1: t=1 else: t=0 break if t==1: print("APPROVED") else: print("DENIED")