緑コーダーがABC257のA~Eまで

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

chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # 文字列一覧

S_L = [] # S_L:文字列を保管するためのリスト（末尾に結合するためリスト形式）

# AからZまでの文字列
for char in chars:    
    for j in range(N):
        S_L.append(char)

# 配列のX文字目を取り出す時は、0-indexのため-1を忘れずに
print(S_L[X-1])

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

chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" # 文字列一覧

S_L = [] # S_L:文字列を保管するためのリスト（末尾に結合するためリスト形式）

# AからZまでの文字列
for char in chars:    
    S_L.append(char*N)

# 文字毎に半端に固まった配列なので、文字列として全部一纏めにしてあげる
S = ''.join(S_L)
    
# 文字列のX文字目を取り出す時も、0-indexのため-1を忘れずに
print(S[X-1])

import string

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

# ABC...XYZをN回繰り返したものを、ソートして配列形式にしてあげる
ans_L = sorted(string.ascii_uppercase * N)

# 0-indexでX番目の文字を取り出してあげる
print(ans_L[X - 1])

# 入力
N, K, Q = map(int, input().split())
A_L = list(map(int, input().split()))
L = list(map(int, input().split()))

# Q回のクエリを処理する部分
for q in L:
    
    # Li番目のコマを０-indexに戻す
    q -= 1
    
    # もしLi番目のコマが一番右のマスにあるなら何もしない
    if A_L[q] == N:
        continue
    
    # もしLi番目のコマが存在するマスの、右隣にコマが存在するなら、何もしない
    if A_L[q] + 1 in A_L:
        continue

    # q番目のコマを１つ右のマスに動かすよ
    A_L[q] += 1

# 全部のコマの存在するマスを出力して終了
print(*A_L)

from collections import defaultdict

N = int(input())
S = input()
W_L = list(map(int, input().split()))

d = defaultdict(int)

# 前処理：大人と子供で辞書に纏める
# Xを0から増やしていった際に、特定の値を超えた時のスコアの変動を値ごとに纏める
# ついでにX=0の時のf(X)：大人の人数をカウントしておく
adult_cnt = 0
for i, w in enumerate(W_L):

    # wが大人の体重の場合
    if S[i] == '1':
        d[w] -= 1
        adult_cnt += 1

    # wが子供の体重の場合
    else:
        d[w] += 1

# スコアが変動する時の値順に並べたいのでリスト化してソート
L = list(d.items())
L.sort()

# scoreの変動と最大値を保持して順に変動を見ていく
score = adult_cnt
ans = adult_cnt

for k, v in L:
    score += v
    ans = max(ans, score)
print(ans)

from collections import deque

# 入力
N = int(input())
L = []

for i in range(N):
    x, y, P = list(map(int, input().split()))
    L.append([x, y, P])


# BFS用のグラフ生成マシーン。高橋君のジャンプ力決めたら辺を張ってくれる凄いロボだよ
def make_graph(exp):
    edge_L = [[] for _ in range(N)]

    for start in range(N - 1):
        sx, sy, sp = L[start]
        for goal in range(start + 1, N):
            gx, gy, gp = L[goal]
            length = abs(sx - gx) + abs(sy - gy)
            if exp * sp >= length:
                edge_L[start].append(goal)
            if exp * gp >= length:
                edge_L[goal].append(start)

    return edge_L


# BFS本体。グラフとスタート地点与えてあげたら、行ける場所の集合を返すよ
def bfs(start, graph):
    can_s = {start}
    que = deque([start])

    while que:
        now = que.popleft()

        for next_idx in graph[now]:
            if next_idx in can_s:
                continue
            que.append(next_idx)
            can_s.add(next_idx)

    return can_s


# めぐる式二分探索、条件判定部分
def is_ok(n):
    # チェックの最初にグラフ生成するよ
    edge_L = make_graph(n)

    # 始点全探索のBFSで、1箇所でも全地点に到達可能ならその時点でTrueなので打ち切っちゃってOK
    for s in range(N):
        if len(bfs(s, edge_L)) == N:
            return True
    return False


# めぐる式二分探索本体
ok, ng = 10 ** 10, -1
while ok - ng > 1:
    mid = (ok + ng) // 2
    if is_ok(mid):
        ok = mid
    else:
        ng = mid
print(ok)

# 入力
N = int(input())
L = []
 
for i in range(N):
    x, y, P = list(map(int, input().split()))
    L.append([x, y, P])
 
# ワ―シャルフロイド用の必要ジャンプ力テーブルを作って…
# 4*10^9あればどこへでも行ける…！ので、とりあえず余裕もって10^10で初期化
inf = 10**10
wf_L = [[inf] * N for i in range(N)]
 
# 前準備編
# スタート地点から全点に向かって直接移動するのに必要なジャンプ力を拾っていくよ
for start in range(N - 1):
    sx, sy, sp = L[start]
 
    # ここに飛ぶよ！
    for goal in range(start, N):
        
        # 同じところにとどまるだけならジャンプ力は不要なので0埋め
        if start == goal:
            wf_L[start][goal] = 0
            continue
        gx, gy, gp = L[goal]
        
        # startとgoalの間の距離を測って
        length = abs(sx - gx) + abs(sy - gy)
 
        # startからジャンプする時はこのジャンプ力が必要
        costS = -(-length // sp)
        
        # 逆にgoalからジャンプする時はこのジャンプ力が必要
        costG = -(-length // gp)
        
        # それぞれワ―シャルフロイドテーブルにメモするよ
        wf_L[start][goal] = costS
        wf_L[goal][start] = costG
 
# ワ―シャルフロイド編
# midを使ったときに…
for mid in range(N):
    
    # start→goalと、start→mid→goalで必要な最大ジャンプ力を比較してmid使った方がジャンプ力低くても移動可能ならジャンプ力メモ
    for start in range(N):
        for goal in range(N):
            wf_L[start][goal] = min(wf_L[start][goal], max(wf_L[start][mid], wf_L[mid][goal]))

# 最小値が欲しいので、大きいところから答えを更新していくよ
ans = inf
for costs in wf_L:
    # 「地点iから全頂点に移動するために必要な最大値」の最小値、が、答え！
    ans = min(ans, max(costs))
print(ans)

# 入力
N = int(input())
C_L = list(map(int, input().split()))
 
# 一番小さいコストと、一番小さいコストの中で一番大きい値が欲しいなー。
min_cost = min(C_L)
min_num = 0
for i, n in enumerate(C_L, 1):
    if n == min_cost:
        min_num = i

# 桁数を決めるじゃないですか。桁数が多いほうが強いので。
keta = N // min_cost
 
# とりあえず一番安くて一番大きい数字で埋めて、頼む
ans_L = [min_num] * keta
 
# 使える残りのお金
amari_yosan = N - (min_cost * keta)

 
# 先頭から順に、数字増やせるかチェック
# 先頭を出来る限り大きい数字にしたほうが強いので、先頭を出来る限り大きい数字にする
# 出来る限り大きい数字にしたら、次の桁で、同じ様に出来る限り大きい数字にする
for i in range(keta):
    now_num = ans_L[i] # 今先頭に仮置されてる数字
    now_price = C_L[now_num - 1] # 今先頭に仮置されてる数字を設置するためのコスト
 
    # 9から順に設置可能か検討。
    # 今置いてる数字より小さい数字にする意味はないので、そこまでのループ
    for num in range(9, min_num, -1):
        # 新しい数字を設置するために必要なコスト
        next_price = C_L[num - 1]
        
        # もし使える残りのお金で、数字が交換できるなら交換してその桁は終了
        if amari_yosan + now_price - next_price >= 0:
            amari_yosan += now_price
            amari_yosan -= next_price
            ans_L[i] = num
            break

# 桁結合して出力！
print("".join(map(str, ans_L)))