diff --git a/abc111/a/main.py b/abc111/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc111/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc111/b/main.py b/abc111/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc111/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc111/c/main.py b/abc111/c/main.py new file mode 100644 index 0000000..9282ffb --- /dev/null +++ b/abc111/c/main.py @@ -0,0 +1,64 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + n = I() + V = LI() + c1 = Counter(V[::2]) + c2 = Counter(V[1::2]) + + (r1, d1), (r2, d2) = c1.most_common(1)[0], c2.most_common(1)[0] + if r1 == r2: + w1, w2 = c1.most_common(2), c2.most_common(2) + (r3, d3), (r4, d4) = w1[-1], w2[-1] + if len(w1) >= 2 and len(w2) >= 2: + print(min(n - d3 - d2, n - d1 - d4)) + elif len(w1) == 1 and len(w2) >= 2: + print(n - d1 - d4) + elif len(w1) >= 2 and len(w2) == 1: + print(n - d2 - d3) + else: + print(n - d1) + else: + print(n - d1 - d2) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc111/contest.acc.json b/abc111/contest.acc.json new file mode 100644 index 0000000..713b708 --- /dev/null +++ b/abc111/contest.acc.json @@ -0,0 +1,53 @@ +{ + "contest": { + "id": "abc111", + "title": "AtCoder Beginner Contest 111", + "url": "https://atcoder.jp/contests/abc111" + }, + "tasks": [ + { + "id": "abc111_a", + "label": "A", + "title": "AtCoder Beginner Contest 999", + "url": "https://atcoder.jp/contests/abc111/tasks/abc111_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc111_b", + "label": "B", + "title": "AtCoder Beginner Contest 111", + "url": "https://atcoder.jp/contests/abc111/tasks/abc111_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "arc103_a", + "label": "C", + "title": "/\\/\\/\\/", + "url": "https://atcoder.jp/contests/abc111/tasks/arc103_a", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "arc103_b", + "label": "D", + "title": "Robot Arms", + "url": "https://atcoder.jp/contests/abc111/tasks/arc103_b", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc111/d/main.py b/abc111/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc111/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc118/a/main.py b/abc118/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc118/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc118/b/main.py b/abc118/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc118/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc118/c/main.py b/abc118/c/main.py new file mode 100644 index 0000000..9ad78d6 --- /dev/null +++ b/abc118/c/main.py @@ -0,0 +1,48 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + A = LI() + print(reduce(lambda x, y: math.gcd(x, y), A)) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc118/contest.acc.json b/abc118/contest.acc.json new file mode 100644 index 0000000..6e965ed --- /dev/null +++ b/abc118/contest.acc.json @@ -0,0 +1,53 @@ +{ + "contest": { + "id": "abc118", + "title": "AtCoder Beginner Contest 118", + "url": "https://atcoder.jp/contests/abc118" + }, + "tasks": [ + { + "id": "abc118_a", + "label": "A", + "title": "B +/- A", + "url": "https://atcoder.jp/contests/abc118/tasks/abc118_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc118_b", + "label": "B", + "title": "Foods Loved by Everyone", + "url": "https://atcoder.jp/contests/abc118/tasks/abc118_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc118_c", + "label": "C", + "title": "Monsters Battle Royale", + "url": "https://atcoder.jp/contests/abc118/tasks/abc118_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc118_d", + "label": "D", + "title": "Match Matching", + "url": "https://atcoder.jp/contests/abc118/tasks/abc118_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc118/d/main.py b/abc118/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc118/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc121/a/main.py b/abc121/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc121/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc121/b/main.py b/abc121/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc121/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc121/c/main.py b/abc121/c/main.py new file mode 100644 index 0000000..b8ea419 --- /dev/null +++ b/abc121/c/main.py @@ -0,0 +1,58 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N, M = LI() + AB = sorted(LIR(N)) + count = 0 + now = 0 + ans = 0 + while count < M: + if AB[now][1] == 0: + now += 1 + ans += AB[now][0] + count += 1 + AB[now][1] -= 1 + print(ans) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc121/contest.acc.json b/abc121/contest.acc.json new file mode 100644 index 0000000..ff75372 --- /dev/null +++ b/abc121/contest.acc.json @@ -0,0 +1,53 @@ +{ + "contest": { + "id": "abc121", + "title": "AtCoder Beginner Contest 121", + "url": "https://atcoder.jp/contests/abc121" + }, + "tasks": [ + { + "id": "abc121_a", + "label": "A", + "title": "White Cells", + "url": "https://atcoder.jp/contests/abc121/tasks/abc121_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc121_b", + "label": "B", + "title": "Can you solve this?", + "url": "https://atcoder.jp/contests/abc121/tasks/abc121_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc121_c", + "label": "C", + "title": "Energy Drink Collector", + "url": "https://atcoder.jp/contests/abc121/tasks/abc121_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc121_d", + "label": "D", + "title": "XOR World", + "url": "https://atcoder.jp/contests/abc121/tasks/abc121_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc121/d/main.py b/abc121/d/main.py new file mode 100644 index 0000000..d9b1b77 --- /dev/null +++ b/abc121/d/main.py @@ -0,0 +1,47 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + A, B = LI() + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc124/a/main.py b/abc124/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc124/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc124/b/main.py b/abc124/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc124/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc124/c/main.py b/abc124/c/main.py new file mode 100644 index 0000000..f68a2a4 --- /dev/null +++ b/abc124/c/main.py @@ -0,0 +1,49 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + S = SL() + L1 = [str(i % 2) for i in range(len(S))] + L2 = [str((i+1) % 2) for i in range(len(S))] + print(min(sum(1 for ch, l1 in zip(S, L1) if ch != l1), sum(1 for ch, l2 in zip(S, L2) if ch != l2))) + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc124/contest.acc.json b/abc124/contest.acc.json new file mode 100644 index 0000000..19be7ce --- /dev/null +++ b/abc124/contest.acc.json @@ -0,0 +1,53 @@ +{ + "contest": { + "id": "abc124", + "title": "AtCoder Beginner Contest 124", + "url": "https://atcoder.jp/contests/abc124" + }, + "tasks": [ + { + "id": "abc124_a", + "label": "A", + "title": "Buttons", + "url": "https://atcoder.jp/contests/abc124/tasks/abc124_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc124_b", + "label": "B", + "title": "Great Ocean View", + "url": "https://atcoder.jp/contests/abc124/tasks/abc124_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc124_c", + "label": "C", + "title": "Coloring Colorfully", + "url": "https://atcoder.jp/contests/abc124/tasks/abc124_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc124_d", + "label": "D", + "title": "Handstand", + "url": "https://atcoder.jp/contests/abc124/tasks/abc124_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc124/d/main.py b/abc124/d/main.py new file mode 100644 index 0000000..f09517f --- /dev/null +++ b/abc124/d/main.py @@ -0,0 +1,73 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N, K = LI() + S = SL() + + tmp = [] + cnt = 1 + for i in range(1, N): + if S[i-1] == S[i]: + cnt += 1 + else: + tmp.append((cnt, abs(int(S[i-1]) - 1))) + cnt = 1 + tmp.append((cnt, abs(int(S[-1]) - 1))) + + ans = 0 + left = 0 + now = 0 + k = 0 + for right in range(len(tmp)): + now += tmp[right][0] + k += tmp[right][1] + while k > K: + now -= tmp[left][0] + k -= tmp[left][1] + left += 1 + ans = max(ans, now) + print(ans) + + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc129/c/main.py b/abc129/c/main.py index 4783c85..a63c74f 100644 --- a/abc129/c/main.py +++ b/abc129/c/main.py @@ -17,10 +17,23 @@ def LSR(n): return [LS() for i in range(n)] sys.setrecursionlimit(1000000) dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] -MOD = 1000000007 +MOD = 1_000_000_007 def main(): - N = I() + N, M = LI() + A = set(IR(M)) + + dp = [0]*(N+1) + dp[0] = 1 + dp[1] = 1 if 1 not in A else 0 + + for i in range(2, N+1): + dp[i] = (dp[i-1] + dp[i-2]) % MOD + if i in A: + dp[i] = 0 + print(dp[-1]) + + if __name__ == '__main__': main() \ No newline at end of file diff --git a/abc180/d/main.py b/abc180/d/main.py index e02bf25..f41e088 100644 --- a/abc180/d/main.py +++ b/abc180/d/main.py @@ -37,7 +37,18 @@ def make_list(n, *args, default=0): return [make_list(*args, default=default) fo sys.setrecursionlimit(1000000) def main(): - N = I() + X, Y, A, B = LI() + ans = 0 + C = X * (A - 1) + while C <= B and X * A < Y: + X *= A + C = X * (A - 1) + ans += 1 + ans += (Y - X) // B + X += B * ((Y - X) // B) + if X == Y: ans -= 1 + print(ans) + if __name__ == '__main__': main() \ No newline at end of file diff --git a/abc181/a/main.py b/abc181/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc181/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc181/b/main.py b/abc181/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc181/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc181/c/main.py b/abc181/c/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc181/c/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc181/contest.acc.json b/abc181/contest.acc.json new file mode 100644 index 0000000..b07dd2d --- /dev/null +++ b/abc181/contest.acc.json @@ -0,0 +1,75 @@ +{ + "contest": { + "id": "abc181", + "title": "AtCoder Beginner Contest 181", + "url": "https://atcoder.jp/contests/abc181" + }, + "tasks": [ + { + "id": "abc181_a", + "label": "A", + "title": "Heavy Rotation", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc181_b", + "label": "B", + "title": "Trapezoid Sum", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc181_c", + "label": "C", + "title": "Collinearity", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc181_d", + "label": "D", + "title": "Hachi", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc181_e", + "label": "E", + "title": "Transformable Teacher", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_e", + "directory": { + "path": "e", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc181_f", + "label": "F", + "title": "Silver Woods", + "url": "https://atcoder.jp/contests/abc181/tasks/abc181_f", + "directory": { + "path": "f", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc181/d/main.py b/abc181/d/main.py new file mode 100644 index 0000000..db04b1b --- /dev/null +++ b/abc181/d/main.py @@ -0,0 +1,59 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + S = SL() + C = Counter(S) + + if len(S) <= 2: + print("Yes" if (int("".join(S)) % 8 == 0 or int("".join(S[::-1])) % 8 == 0) else "No") + exit(0) + + for i in range(104, 1000, 8): + c = Counter(str(i)) + if all((C.get(t) or 0) >= c.get(t) for t in c): + print("Yes") + break + else: + print("No") + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc181/e/main.py b/abc181/e/main.py new file mode 100644 index 0000000..185f76c --- /dev/null +++ b/abc181/e/main.py @@ -0,0 +1,63 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N, M = LI() + H = sorted(LI()) + W = LI() + + r1 = [H[i+1]-H[i] for i in range(0, N-1, 2)] + c1 = [0] + list(accumulate(r1)) + r2 = [H[i+1]-H[i] for i in range(1, N-1, 2)] + c2 = [0] + list(accumulate(r2)) + + ans = INF + + for w in W: + i = bisect_left(H, w) + ans = min(ans, abs(H[(i//2)*2] - w) + c1[i//2] + c2[-1] - c2[i//2]) + print(ans) + + + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc181/f/main.py b/abc181/f/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc181/f/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc193/a/main.py b/abc193/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc193/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc193/b/main.py b/abc193/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc193/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc193/c/main.py b/abc193/c/main.py new file mode 100644 index 0000000..cffd605 --- /dev/null +++ b/abc193/c/main.py @@ -0,0 +1,66 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math +import fractions +import sys +import copy + + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + + +def perm(n, r): return math.factorial(n) // math.factorial(r) + + +def comb(n, r): return math.factorial( + n) // (math.factorial(r) * math.factorial(n-r)) + + +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + + +def make_list(n, *args, default=0): return [make_list(*args, default=default) + for _ in range(n)] if args else [default for _ in range(n)] + + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + + +def main(): + N = I() + s = set() + for a in range(2, math.ceil(math.sqrt(N))+1): + for b in range(2, math.ceil(math.log(N, a))+1): + if a**b <= N: + s.add(a**b) + print(N-len(s)) + + +if __name__ == '__main__': + main() diff --git a/abc193/contest.acc.json b/abc193/contest.acc.json new file mode 100644 index 0000000..1b3f1ae --- /dev/null +++ b/abc193/contest.acc.json @@ -0,0 +1,75 @@ +{ + "contest": { + "id": "abc193", + "title": "Caddi Programming Contest 2021(AtCoder Beginner Contest 193)", + "url": "https://atcoder.jp/contests/abc193" + }, + "tasks": [ + { + "id": "abc193_a", + "label": "A", + "title": "Discount", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc193_b", + "label": "B", + "title": "Play Snuke", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc193_c", + "label": "C", + "title": "Unexpressed", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc193_d", + "label": "D", + "title": "Poker", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc193_e", + "label": "E", + "title": "Oversleeping", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_e", + "directory": { + "path": "e", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc193_f", + "label": "F", + "title": "Zebraness", + "url": "https://atcoder.jp/contests/abc193/tasks/abc193_f", + "directory": { + "path": "f", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc193/d/main.py b/abc193/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc193/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc193/e/main.py b/abc193/e/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc193/e/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc193/f/main.py b/abc193/f/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc193/f/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc194/a/main.py b/abc194/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc194/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc194/b/main.py b/abc194/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc194/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc194/c/main.py b/abc194/c/main.py new file mode 100644 index 0000000..3d201eb --- /dev/null +++ b/abc194/c/main.py @@ -0,0 +1,71 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math +import fractions +import sys +import copy + + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + + +def perm(n, r): return math.factorial(n) // math.factorial(r) + + +def comb(n, r): return math.factorial( + n) // (math.factorial(r) * math.factorial(n-r)) + + +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + + +def make_list(n, *args, default=0): return [make_list(*args, default=default) + for _ in range(n)] if args else [default for _ in range(n)] + + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + + +def main(): + N = I() + A = LI() + + cnt = [0] * 401 + for a in A: + cnt[a+200] += 1 + + ans = 0 + for i, c1 in enumerate(cnt): + for j, c2 in enumerate(cnt): + ans += c1*c2*(((i-200) - (j-200))**2) + print(ans//2) + + +if __name__ == '__main__': + main() diff --git a/abc194/contest.acc.json b/abc194/contest.acc.json new file mode 100644 index 0000000..55b5769 --- /dev/null +++ b/abc194/contest.acc.json @@ -0,0 +1,75 @@ +{ + "contest": { + "id": "abc194", + "title": "AtCoder Beginner Contest 194", + "url": "https://atcoder.jp/contests/abc194" + }, + "tasks": [ + { + "id": "abc194_a", + "label": "A", + "title": "I Scream", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc194_b", + "label": "B", + "title": "Job Assignment", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc194_c", + "label": "C", + "title": "Squared Error", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc194_d", + "label": "D", + "title": "Journey", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc194_e", + "label": "E", + "title": "Mex Min", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_e", + "directory": { + "path": "e", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "abc194_f", + "label": "F", + "title": "Digits Paradise in Hexadecimal", + "url": "https://atcoder.jp/contests/abc194/tasks/abc194_f", + "directory": { + "path": "f", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/abc194/d/main.py b/abc194/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc194/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc194/e/main.py b/abc194/e/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc194/e/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/abc194/f/main.py b/abc194/f/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/abc194/f/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/arc017/a/main.py b/arc017/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/arc017/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/arc017/b/main.py b/arc017/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/arc017/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/arc017/c/main.py b/arc017/c/main.py new file mode 100644 index 0000000..6f906ce --- /dev/null +++ b/arc017/c/main.py @@ -0,0 +1,59 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N, X = LI() + W = IR(N) + + first, second = W[:N//2], W[N//2:] + d = defaultdict(int) + + for s in powerset(first): + d[sum(s)] += 1 + + ans = 0 + for s in powerset(second): + ans += d[X - sum(s)] + print(ans) + + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/arc017/contest.acc.json b/arc017/contest.acc.json new file mode 100644 index 0000000..7dbda85 --- /dev/null +++ b/arc017/contest.acc.json @@ -0,0 +1,53 @@ +{ + "contest": { + "id": "arc017", + "title": "AtCoder Regular Contest 017", + "url": "https://atcoder.jp/contests/arc017" + }, + "tasks": [ + { + "id": "arc017_1", + "label": "A", + "title": "素数、コンテスト、素数", + "url": "https://atcoder.jp/contests/arc017/tasks/arc017_1", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "arc017_2", + "label": "B", + "title": "解像度が低い。", + "url": "https://atcoder.jp/contests/arc017/tasks/arc017_2", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "arc017_3", + "label": "C", + "title": "無駄なものが嫌いな人", + "url": "https://atcoder.jp/contests/arc017/tasks/arc017_3", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "arc017_4", + "label": "D", + "title": "ARCたんクッキー", + "url": "https://atcoder.jp/contests/arc017/tasks/arc017_4", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/arc017/d/main.py b/arc017/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/arc017/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/a/main.py b/code-thanks-festival-2017/a/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/a/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/b/main.py b/code-thanks-festival-2017/b/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/b/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/c/main.py b/code-thanks-festival-2017/c/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/c/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/contest.acc.json b/code-thanks-festival-2017/contest.acc.json new file mode 100644 index 0000000..7d3ba51 --- /dev/null +++ b/code-thanks-festival-2017/contest.acc.json @@ -0,0 +1,97 @@ +{ + "contest": { + "id": "code-thanks-festival-2017", + "title": "CODE THANKS FESTIVAL 2017", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017" + }, + "tasks": [ + { + "id": "code_thanks_festival_2017_a", + "label": "A", + "title": "Time Penalty", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_a", + "directory": { + "path": "a", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_b", + "label": "B", + "title": "Concatenated Palindrome", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_b", + "directory": { + "path": "b", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_c", + "label": "C", + "title": "Factory", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_c", + "directory": { + "path": "c", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_d", + "label": "D", + "title": "Bus Tour", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_d", + "directory": { + "path": "d", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_e", + "label": "E", + "title": "Coin Authentication", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_e", + "directory": { + "path": "e", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_f", + "label": "F", + "title": "Limited Xor Subset", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_f", + "directory": { + "path": "f", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_g", + "label": "G", + "title": "Mixture Drug", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_g", + "directory": { + "path": "g", + "testdir": "test", + "submit": "main.py" + } + }, + { + "id": "code_thanks_festival_2017_h", + "label": "H", + "title": "Union Sets", + "url": "https://atcoder.jp/contests/code-thanks-festival-2017/tasks/code_thanks_festival_2017_h", + "directory": { + "path": "h", + "testdir": "test", + "submit": "main.py" + } + } + ] +} \ No newline at end of file diff --git a/code-thanks-festival-2017/d/main.py b/code-thanks-festival-2017/d/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/d/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/e/main.py b/code-thanks-festival-2017/e/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/e/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/f/main.py b/code-thanks-festival-2017/f/main.py new file mode 100644 index 0000000..f0bbc5c --- /dev/null +++ b/code-thanks-festival-2017/f/main.py @@ -0,0 +1,46 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N = I() + +if __name__ == '__main__': + main() \ No newline at end of file diff --git a/code-thanks-festival-2017/g/main.py b/code-thanks-festival-2017/g/main.py new file mode 100644 index 0000000..fc2d4e8 --- /dev/null +++ b/code-thanks-festival-2017/g/main.py @@ -0,0 +1,90 @@ +#!usr/bin/env python3 +from collections import defaultdict, deque, Counter, OrderedDict +from bisect import bisect_left, bisect_right +from functools import reduce, lru_cache +from heapq import heappush, heappop, heapify + +from itertools import * +import math, fractions +import sys, copy + +def L(): return sys.stdin.readline().split() +def I(): return int(sys.stdin.readline().rstrip()) +def SL(): return list(sys.stdin.readline().rstrip()) +def LI(): return [int(x) for x in sys.stdin.readline().split()] +def LI1(): return [int(x) - 1 for x in sys.stdin.readline().split()] +def LS(): return [list(x) for x in sys.stdin.readline().split()] +def R(n): return [sys.stdin.readline().strip() for _ in range(n)] +def LR(n): return [L() for _ in range(n)] +def IR(n): return [I() for _ in range(n)] +def LIR(n): return [LI() for _ in range(n)] +def LIR1(n): return [LI1() for _ in range(n)] +def SLR(n): return [SL() for _ in range(n)] +def LSR(n): return [LS() for _ in range(n)] + +def perm(n, r): return math.factorial(n) // math.factorial(r) +def comb(n, r): return math.factorial(n) // (math.factorial(r) * math.factorial(n-r)) +def powerset(iterable): + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) + +def make_list(n, *args, default=0): return [make_list(*args, default=default) for _ in range(n)] if args else [default for _ in range(n)] + +dire = [[1, 0], [0, 1], [-1, 0], [0, -1]] +dire8 = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]] +alphabets = "abcdefghijklmnopqrstuvwxyz" +ALPHABETS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" +MOD = 1000000007 +INF = float("inf") + +sys.setrecursionlimit(1000000) + +def main(): + N, M = LI() + AB = LIR1(M) + s = [(1<= N//2 and b >= N//2: + ok2[(1 << a-N//2) | (1 << b-N//2)] = False + + else: + a, b = min(a, b), max(a, b) + s[1 << a] ^= 1 << b - N//2 + + + for i in range(1 << N//2): + if not ok1[i]: + for w in range(N//2): + ok1[i | (1 << w)] = False + for i in range(1 << N-N//2): + if not ok2[i]: + for w in range(N-N//2): + ok2[i | (1 << w)] = False + + + for i in range(1<