pytemp_tozawa.ini

import numpy as np
import bisect

再起上限の引き上げ
import sys
sys.setrecursionlimit(1 << 20) 

入力 x
x = int(input())

入力 x y
n,x = map(int, input().split(' '))

入力 n / a1 ... an
n = int(input())
a = list(map(int, input().split(' ')))

入力 n / s1 / s2 / ... / sn
n = int(input())
s=[]
for i in range(n):
    s.append(int(input()))

入力 n / x1 y1 / ... / xn yn
n=int(input())
pair = [tuple(map(int, input().split(' '))) for i in range(n)]

入力 H W/ a11 a12 ... a1W / ... / aH1 aH2 ... aHW
H,W=map(int,input().split())
A = [input().split() for _ in range(H)]

入力を桁ごとに配列に格納
s=input()
S=[int(x) for x in list(str(s))]

入力を桁ごとに配列に格納（改良）
A=[0]
a=list(map(int,input().split()))
A.extend(a)

入力 N M/ A1 B1 / ... / AM BM
import numpy as np
N,M=map(int,input().split())
A,B=np.zeros(M+1,dtype=int),np.zeros(M+1,dtype=int)
for i in range(1,N+1):
    A[i],B[i]=map(int,input().split())

入力 to 隣接リスト
import numpy as np
N, M = map(int, input().split())
graph = [[] for _ in range(N+1)]
A,B=np.zeros(M+1),np.zeros(M+1)
for i in range(1,M+1):
    A[i], B[i] = map(int, input().split())
    a,b=int(A[i]),int(B[i])
    graph[a].append(b)
    graph[b].append(a)  # 有向グラフなら消す

入力 to 隣接リスト（重み付き）
import numpy as np
N, M = map(int, input().split())
graph = [[] for _ in range(N+1)]
A,B,C =np.zeros(M+1),np.zeros(M+1),np.zeros(M+1)

for i in range(1,M+1):
    A[i], B[i] ,C[i]= map(int, input().split())
    a,b,c=int(A[i]),int(B[i]),int(C[i])
    graph[a].append([b,c])
    graph[b].append([a,c])  # 有向グラフなら消す

優先度付きキュー
import heapq  # heapqライブラリのimport

a = [1, 6, 8, 0, -1]
heapq.heapify(a)  # リストを優先度付きキューへ
print(a)
# 出力: [-1, 0, 8, 1, 6] (優先度付きキューとなった a)


入力1から入れたいとき
A=[0]
a=list(map(int,input().split()))
for i in range(N):
  A.append(a[i])

辞書にリストをいれ込む
friend = {}
friend.setdefault(A[i],[]).append(B[i])

多次元配列のソート
A,B,C=np.zeros(M+1,dtype=int),np.zeros(M+1,dtype=int),np.zeros(M+1,dtype=int)
all_abc=np.zeros((M+1,3),dtype=int)

for i in range(1,M+1):
    A[i],B[i],C[i]=map(int,input().split())
    all_abc[i]=np.array([A[i],B[i],C[i]])

all_abc=all_abc[np.argsort(all_abc[:,2])]

配列
arr = []
print(arr)
# []

arr = [0] * 10
print(arr)
# [0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
二次元配列
arr = [[]]
print(arr)
# [[]]

arr = [[0] * 4 for i in range(3)]
print(arr)
# [[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]
配列の展開
arr = [1, 2, 3]
print(*arr)
# 1 2 3
*をつけると、配列でもタプルでもdictでも展開される。

キュー
from collections import deque
追加
d = deque(['m', 'n'])

d.append('o')
print(d)
# deque(['m', 'n', 'o'])

d.appendleft('l')
print(d)
# deque(['l', 'm', 'n', 'o'])

削除
d = deque(['a', 'b', 'c', 'b', 'd'])

print(d.pop())
# d

print(d)
# deque(['a', 'b', 'c', 'b'])

print(d.popleft())
# a

print(d)
# deque(['b', 'c', 'b'])

d.remove('b')
print(d)
# deque(['c', 'b'])

リスト内にあるかどうか確認
import itertools

lst = [0,1,2]
print(1 in lst)
# True

print(3 in lst)
# False

lst = set([0,1,2])
print(1 in lst)
# True

lst = {0,1,2}
print(1 in lst)
# True


mod = 1000000007


累積和(数値)
import itertools

arr = [0,1,3,5,7,9]
print(arr)
# [0, 1, 3, 5, 7, 9]

cumsum = list(itertools.accumulate(arr))
print(cumsum)
# [0, 1, 4, 9, 16, 25]
累積和(文字)
import itertools

s = ['ab', 'bc', 'cd']
print(s)
# ['ab', 'bc', 'cd']

scum = list(itertools.accumulate(s))
print(scum)
# ['ab', 'abbc', 'abbccd']
順列(数値)
import itertools

lst = [1, 2, 3]
print(lst)
# [1, 2, 3]

permu = list(itertools.permutations(lst))
print(permu)
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]
順列(文字列)
import itertools

s = 'abc'
permus = list(itertools.permutations(s))
print(permus)
# [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]
組み合わせ(数値)
import itertools

lst = [1, 2, 3, 4]
print(lst)
# [1, 2, 3, 4]

comb = list(itertools.combinations(lst, 2))
print(comb)
# [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]

comb = list(itertools.combinations(lst, 3))
print(comb)
# [(1, 2, 3), (1, 2, 4), (1, 3, 4), (2, 3, 4)]
重複を許す組み合わせ(数値)
import itertools

lst = [1, 2, 3, 4]
print(lst)
# [1, 2, 3, 4]

combr = list(itertools.combinations_with_replacement(lst, 2))
print(combr)
# [(1, 1), (1, 2), (1, 3), (1, 4), (2, 2), (2, 3), (2, 4), (3, 3), (3, 4), (4, 4)]
直積
import itertools

prd = list(itertools.product([0,1], repeat=3))
print(prd)
# [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
入力データを用いて、直積で全パターンを得る。

import itertools

lst = [(0,1), (2,3), (2,4)]
prd = list(itertools.product( *lst ))
print(prd)
# [(0, 2, 2), (0, 2, 4), (0, 3, 2), (0, 3, 4), (1, 2, 2), (1, 2, 4), (1, 3, 2), (1, 3, 4)]

for p in prd:
    p = set(p)
    print(p)
# {0, 2}
# {0, 2, 4}
# {0, 2, 3}
# {0, 3, 4}
# {1, 2}
# {1, 2, 4}
# {1, 2, 3}
# {1, 3, 4}


ビットが立っているものだけ残す
import itertools

lst = [1, 2, 3, 4]
bit = [1, 0, 0, 1]

cps = list(itertools.compress(lst, bit))
print(cps)
# [1, 4]
各値が何個連続しているか
import itertools

bi = [0,0,0,1,1,0,0,0,1,1,0,1]
print(bi)
# [0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1]

gr = itertools.groupby(bi)
for key, group in gr:
    print(f'{key}: {list(group)}')
# 0: [0, 0, 0]
# 1: [1, 1]
# 0: [0, 0, 0]
# 1: [1, 1]
# 0: [0]
# 1: [1]

gr = itertools.groupby(bi)
for key, group in gr:
    print(f'{key}: {len(list(group))}')
# 0: 3
# 1: 2
# 0: 3
# 1: 2
# 0: 1
# 1: 1


参考：

https://docs.python.org/ja/3/library/itertools.html

https://qiita.com/SaitoTsutomu/items/ddb5076ef62745f03b56



nCr：組み合わせの数(math)
import math

n = 7
r = 5
cb = math.comb(n, r)
print(cb) # -> 21


nCr：組み合わせの数(scipy) ※速い
※言語をPythonにする

from scipy.special import comb

n = 7
r = 5
cb = comb(n, r, exact=True)
print(cb) # 21
exact=Trueを指定することで戻り値が"inf"になるのを回避できる 正確な値を求めたい場合にもこの引数が必要。（その分若干遅くなる。）



上記を気にせず使いたい場合は引数を省略。

a = comb(n, r)

素因数分解
def factorization(n):
    arr = []
    temp = n
    for i in range(2, int(-(-n**0.5//1))+1):
        if temp%i==0:
            cnt=0
            while temp%i==0:
                cnt+=1
                temp //= i
            arr.append([i, cnt])

    if temp!=1:
        arr.append([temp, 1])

    if arr==[]:
        arr.append([n, 1])

    return arr

factorization(24) 
## [[2, 3], [3, 1]] 
##  24 = 2^3 * 3^1

タイル問題出力
for l in tile:
        print("".join(l)) 


##UnionFind
from collections import defaultdict
class UnionFind():
    def __init__(self, n):
        self.n = n
        self.parents = [-1] * n

    def find(self, x):
        if self.parents[x] < 0:
            return x
        else:
            self.parents[x] = self.find(self.parents[x])
            return self.parents[x]

    def union(self, x, y):
        x = self.find(x)
        y = self.find(y)

        if x == y:
            return

        if self.parents[x] > self.parents[y]:
            x, y = y, x

        self.parents[x] += self.parents[y]
        self.parents[y] = x

    def size(self, x):
        return -self.parents[self.find(x)]

    def same(self, x, y):
        return self.find(x) == self.find(y)

    def members(self, x):
        root = self.find(x)
        return [i for i in range(self.n) if self.find(i) == root]

    def roots(self):
        return [i for i, x in enumerate(self.parents) if x < 0]

    def group_count(self):
        return len(self.roots())

    def all_group_members(self):
        group_members = defaultdict(list)
        for member in range(self.n):
            group_members[self.find(member)].append(member)
        return group_members

    def __str__(self):
        return '\n'.join(f'{r}: {m}' for r, m in self.all_group_members().items())
##
https://note.nkmk.me/python-union-find/

##平衡2分探索木
https://github.com/tatyam-prime/SortedSet/blob/main/SortedMultiset.py

##配列の全てに対してif文を通す
a = [1, 2, 3, 4, 5]
print(np.all(a < 5))
# False