5完できない芸人の緑コーダーがABC260のA~Eまで

# 入力
S = input()

# リスト化してソート
L = list(S)
L.sort()

# 1文字目と２文字目が一緒じゃないなら、１文字目がユニーク
if L[0] != L[1]:
    print(L[0])

# そうでない場合(1文字目=2文字目)、２文字目と３文字目が一緒じゃないなら、３文字目がユニーク
elif L[1] != L[2]:
    print(L[2])

# そうでもない場合(1文字目=2文字目=3文字目)、ユニークなものは無いので-1
else:
    print(-1)

# 入力
N, X, Y, Z = map(int, input().split())
A_L = list(map(int, input().split()))
B_L = list(map(int, input().split()))

# 合計点と受験者番号を纏めた２次元配列を作成
score_L = []

for num, scores in enumerate(zip(A_L, B_L), 1):
    a, b = scores

    tmp_L = [-a, -b, -(a + b), num]
    score_L.append(tmp_L)

# ソートして、先頭からX(Y,Z)人除いた人だけ残して…
score_L = sorted(score_L, key=lambda x: (x[0], x[-1]))[X:]
score_L = sorted(score_L, key=lambda x: (x[1], x[-1]))[Y:]
score_L = sorted(score_L, key=lambda x: (x[2], x[-1]))[Z:]

# 最終的に残ったものが「不合格者リスト」
failure_s = set()
for scores in score_L:
    failure_s.add(scores[-1])

# 不合格者リストに入っていないのなら、その人は合格！
for num in range(1, N + 1):
    if num not in failure_s:
        print(num)

# 入力
N, X, Y = map(int, input().split())

# 青石、赤石の個数テーブルをそれぞれ作るよ！
# Lvで見たいので、なんとなく直感的に1-indexedにしちゃいました…
# b_L[i] := Lviの青石の個数
# r_L[i] := Lviの赤石の個数
b_L = [0] * (N + 1)
r_L = [0] * (N + 1)

# r_L[N] := Nレベルの赤石が１個ある状態！
r_L[-1] = 1


# LvNからLv２まで、それぞれ小さくする作業
for i in range(N, 1, -1):
    
    # 赤石Lviがそのまま赤石Lv(i-1)になって…
    r_L[i - 1] += r_L[i]
    
    # 赤石LviのX倍が、青石Lviになって…
    b_L[i] += r_L[i] * X
    
    # 青石Lviが、赤石Lv(i-1)になって…
    r_L[i - 1] += b_L[i]
    
    # 青石LviのY倍が、青石Lv(i-1)になる！
    b_L[i - 1] += b_L[i] * Y

# 青石Lv1の数を出力して終了！
print(b_L[1])

# 入力
N, X, Y = map(int, input().split())


# 「Lv○の赤石を△個、操作1で変換するとどうなるの？」関数
def red_conversion(lv, cnt):
    # Lv1なら、何も返さないよ。
    # Lv1の赤石は青石には変換できないので、捨てちゃうイメージで。
    if lv == 1:
        return 0

    # Lv2以上なら、Lv(n-1)の赤石が個数分と、Lvnの青石が個数*X個できるよ！
    return red_conversion(lv - 1, cnt) + blue_conversion(lv, cnt * X)


# 「Lv○の青石を△個、操作２で変換するとどうなるの？」関数
def blue_conversion(lv, cnt):
    
    # Lv1なら、そのまま個数返すよ！
    # Lv1の青石の個数が欲しいからね！
    if lv == 1:
        return cnt

    # Lv2以上なら、Lv(n-1)の赤石が個数分と、Lv(n-1)の青石が、個数*Y個出来るよ！
    return red_conversion(lv - 1, cnt) + blue_conversion(lv - 1, cnt * Y)



# じゃあ、LvNの赤い石を変換するとどうなるの？
print(red_conversion(N, 1))

# https://github.com/tatyam-prime/SortedSet/blob/main/SortedSet.py
import math
from bisect import bisect_left, bisect_right
from typing import Generic, Iterable, Iterator, TypeVar, Union, List

T = TypeVar('T')


class SortedSet(Generic[T]):
    BUCKET_RATIO = 50
    REBUILD_RATIO = 170

    def _build(self, a=None) -> None:
        "Evenly divide `a` into buckets."
        if a is None: a = list(self)
        size = self.size = len(a)
        bucket_size = int(math.ceil(math.sqrt(size / self.BUCKET_RATIO)))
        self.a = [a[size * i // bucket_size: size * (i + 1) // bucket_size] for i in range(bucket_size)]

    def __init__(self, a: Iterable[T] = []) -> None:
        "Make a new SortedSet from iterable. / O(N) if sorted and unique / O(N log N)"
        a = list(a)
        if not all(a[i] < a[i + 1] for i in range(len(a) - 1)):
            a = sorted(set(a))
        self._build(a)

    def __iter__(self) -> Iterator[T]:
        for i in self.a:
            for j in i: yield j

    def __reversed__(self) -> Iterator[T]:
        for i in reversed(self.a):
            for j in reversed(i): yield j

    def __len__(self) -> int:
        return self.size

    def __repr__(self) -> str:
        return "SortedSet" + str(self.a)

    def __str__(self) -> str:
        s = str(list(self))
        return "{" + s[1: len(s) - 1] + "}"

    def _find_bucket(self, x: T) -> List[T]:
        "Find the bucket which should contain x. self must not be empty."
        for a in self.a:
            if x <= a[-1]: return a
        return a

    def __contains__(self, x: T) -> bool:
        if self.size == 0: return False
        a = self._find_bucket(x)
        i = bisect_left(a, x)
        return i != len(a) and a[i] == x

    def add(self, x: T) -> bool:
        "Add an element and return True if added. / O(√N)"
        if self.size == 0:
            self.a = [[x]]
            self.size = 1
            return True
        a = self._find_bucket(x)
        i = bisect_left(a, x)
        if i != len(a) and a[i] == x: return False
        a.insert(i, x)
        self.size += 1
        if len(a) > len(self.a) * self.REBUILD_RATIO:
            self._build()
        return True

    def discard(self, x: T) -> bool:
        "Remove an element and return True if removed. / O(√N)"
        if self.size == 0: return False
        a = self._find_bucket(x)
        i = bisect_left(a, x)
        if i == len(a) or a[i] != x: return False
        a.pop(i)
        self.size -= 1
        if len(a) == 0: self._build()
        return True

    def lt(self, x: T) -> Union[T, None]:
        "Find the largest element < x, or None if it doesn't exist."
        for a in reversed(self.a):
            if a[0] < x:
                return a[bisect_left(a, x) - 1]

    def le(self, x: T) -> Union[T, None]:
        "Find the largest element <= x, or None if it doesn't exist."
        for a in reversed(self.a):
            if a[0] <= x:
                return a[bisect_right(a, x) - 1]

    def gt(self, x: T) -> Union[T, None]:
        "Find the smallest element > x, or None if it doesn't exist."
        for a in self.a:
            if a[-1] > x:
                return a[bisect_right(a, x)]

    def ge(self, x: T) -> Union[T, None]:
        "Find the smallest element >= x, or None if it doesn't exist."
        for a in self.a:
            if a[-1] >= x:
                return a[bisect_left(a, x)]

    def __getitem__(self, x: int) -> T:
        "Return the x-th element, or IndexError if it doesn't exist."
        if x < 0: x += self.size
        if x < 0: raise IndexError
        for a in self.a:
            if x < len(a): return a[x]
            x -= len(a)
        raise IndexError

    def index(self, x: T) -> int:
        "Count the number of elements < x."
        ans = 0
        for a in self.a:
            if a[-1] >= x:
                return ans + bisect_left(a, x)
            ans += len(a)
        return ans

    def index_right(self, x: T) -> int:
        "Count the number of elements <= x."
        ans = 0
        for a in self.a:
            if a[-1] > x:
                return ans + bisect_right(a, x)
            ans += len(a)
        return ans


# 入力
N, K = map(int, input().split())
P_L = list(map(int, input().split()))

# 色々情報保管変数の準備！
eat_L = [-1] * N # 何ターン目に食べられた？
cnt_L = [0] * N # cnt_L[i] := iのカードの下に何枚のカードがある？
bot_L = [-1] * N # bot_L[i] := iのカードの下にあるカードの番号は？
ss = SortedSet() # tatyam様のありがたいありがたいSortedSet！！！！！！！！！！
# 場の中で、表に見えてるカードを管理するよ！

# 1ターン目から順に操作していくよ！
for turn in range(1, N + 1):
    # phase1 : カードをドロー！！！0-indexedに直す！！！
    X = P_L[turn - 1]
    X -= 1
    
    # phase2 : 場に見えてるカードの中で、X以上のカードを探すよ！
    bot_card = ss.gt(X)
    
    # そんなのねぇ！なら、カードを場に出す流れ！
    if bot_card is None: 
        cnt_L[X] = 1
    
    # 重ねる場合の処理
    else:
        ss.discard(bot_card)
        cnt_L[X] = cnt_L[bot_card] + 1
        bot_L[X] = bot_card
    ss.add(X)

    # phase3 : 今出したカードの山、枚数がK超えてるなら全部墓場に流すよ！
    if cnt_L[X] >= K:
        ss.discard(X)
        while True:
            eat_L[X] = turn
            next_eat = bot_L[X]
            if next_eat == -1:
                break
            X = next_eat

# 何ターン目に処理されたかを出力して終わり！
for turn in eat_L:
    print(turn)

from collections import defaultdict
from collections import deque

# 入力
N, M = map(int, input().split())
# d[i] := iをしゃくとりに追加/削除した時に、満たされる/外される条件
d = defaultdict(set)

for i in range(N):
    a, b = map(int, input().split())
    d[a].add(i)
    d[b].add(i)

# 変数初期化色々
que = deque()
ans_L = [0] * (M + 10) # imos用の配列！
cnt_L = [0] * N　 # cnt_L[i] := i番目の条件(A,B)のうち、いくつの数字がしゃくとり範囲に入ってる? 0なら区間外、1ならAかBの片方が入ってる、2ならABどっちも入ってる
zero_cnt = N　 # 満たされていない条件の数！


# Rを右に動かした時(=しゃくとりの区間を広げた）の処理！
def func_add(num):
    if len(d[num]) != 0:
        global zero_cnt
        for i in d[num]:
            if cnt_L[i] == 0:
                zero_cnt -= 1
            cnt_L[i] += 1

# Lを右に動かしたとき(=しゃくとりの区間を減らす)の処理！
def func_red(num):
    if len(d[num]) != 0:

        global zero_cnt
        for i in d[num]:
            if cnt_L[i] == 1:
                zero_cnt += 1
            cnt_L[i] -= 1


# Lを1つずつ動かしていくイメージでしゃくとりパート！
for i in range(1, M + 1):
    if len(que) == 0:
        que.append(i)
        func_add(i)

    while True:
        if zero_cnt == 0 or que[-1] == M:
            break
        add_num = que[-1] + 1
        que.append(add_num)
        func_add(add_num)

    if zero_cnt == 0:
        idx = len(que)
        ans_L[idx] += 1
        end_idx = idx + (M - que[-1]) + 1
        ans_L[end_idx] -= 1

    red_num = que.popleft()
    func_red(red_num)

# しゃくとりは終わってimos前処理配列が出来上がってるので、IMOS!!!!!
accum_L = [0]
for score in ans_L:
    accum_L.append(accum_L[-1] + score)

# そのまま答えが出てくる！
print(*accum_L[2:2 + M])