Nearest Beautiful Number (easy version) (Codeforces 1560F1)
Tags: Greedy, bitmasks

It is a simplified version of problem F2. The difference between them is the constraints (F1: $$$k \le 2$$$, F2: $$$k \le 10$$$).You are given an integer $$$n$$$. Find the minimum integer $$$x$$$ such that $$$x \ge n$$$ and the number $$$x$$$ is $$$k$$$-beautiful.A number is called $$$k$$$-beautiful if its decimal representation having no leading zeroes contains no more than $$$k$$$ different digits. E.g. if $$$k = 2$$$, the numbers $$$3434443$$$, $$$55550$$$, $$$777$$$ and $$$21$$$ are $$$k$$$-beautiful whereas the numbers $$$120$$$, $$$445435$$$ and $$$998244353$$$ are not.

Input: The first line contains one integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases. Then $$$t$$$ test cases follow.Each test case consists of one line containing two integers $$$n$$$ and $$$k$$$ ($$$1 \le n \le 10^9$$$, $$$1 \le k \le 2$$$).

Output: For each test case output on a separate line $$$x$$$ — the minimum $$$k$$$-beautiful integer such that $$$x \ge n$$$.


Sample Inputs:
4
1 1
221 2
177890 2
998244353 1

Sample Outputs:
1
221
181111
999999999

Solution (Python):
def get_input():
    al = []
    for c in range(int(input())):
        t = input().split(' ')
        el = [t[0], int(t[1])]
        al.append(el)
    return al

def find_best(n, j, s):
    b = ':'
    m = ':'
    for k in s:
        if k < m:
            m = k
        if n[j] < k and k < b:
            b = k
    if b == ':':
        return False
    else:
        return n[:j] + b + m * (len(n) - j - 1)

def solve(n, k):
    if k == 1:
        for i in range(1, len(n)):
            if n[i] > n[0]:
                return str(int(n[0]) + 1) * len(n)
            elif n[i] < n[0]:
                break
        return n[0] * len(n)
    s = []
    for i in range(len(n)):
        if n[i] not in s:
            if len(s) == k:
                rf = find_best(n, i, s)
                if rf != False:
                    return rf
                for j in range(i - 1, -1, -1):
                    if n[j] == '9':
                        continue
                    elif n[j] in n[:j]:
                        rf = find_best(n, j, s)
                        if rf != False:
                            return rf
                    else:
                        c = str(int(n[j]) + 1)
                        cm = c
                        for k in range(j):
                            if n[k] < cm:
                                cm = n[k]
                        d = True
                        for k in range(0, j):
                            if n[k] != c:
                                d = False
                                break
                        if d:
                            return n[:j] + c + '0' * (len(n) - j - 1)
                        return n[:j] + c + min(cm, c) * (len(n) - j - 1)
            s.append(n[i])
    return n

def main():
    arr_list = get_input()
    for n in arr_list:
        r = solve(n[0], n[1])
        print(r)
main()

Solution (Python):
def get_input():
    al = []
    for c in range(int(input())):
        t = input().split(' ')
        el = [t[0], int(t[1])]
        al.append(el)
    return al

def solve(n, k):
    if k == 1:
        for i in range(1, len(n)):
            if n[i] > n[0]:
                return str(int(n[0]) + 1) * len(n)
            elif n[i] < n[0]:
                break
        return n[0] * len(n)
    s = []
    for i in range(len(n)):
        if n[i] not in s:
            if len(s) == 2:
                if n[i] <= min(s):
                    return n[:i] + min(s) * (len(n) - i)
                elif n[i] <= max(s):
                    return n[:i] + max(s) + min(s) * (len(n) - i - 1)
                for j in range(i - 1, -1, -1):
                    if n[j] == '9':
                        continue
                    elif n[j] in n[:j]:
                        if n[j] < min(s):
                            return n[:j] + min(s) * (len(n) - j)
                        elif n[j] < max(s):
                            return n[:j] + max(s) + min(s) * (len(n) - j - 1)
                    else:
                        c = str(int(n[j]) + 1)
                        cm = n[0] if j != 0 else '9'
                        d = True
                        for k in range(0, j):
                            if n[k] != c:
                                d = False
                                break
                        if d:
                            return n[:j] + c + '0' * (len(n) - j - 1)
                        return n[:j] + c + min(cm, c) * (len(n) - j - 1)
            s.append(n[i])
    return n

def main():
    arr_list = get_input()
    for n in arr_list:
        r = solve(n[0], n[1])
        print(r)
main()

Solution (Python):
def F1(s, k):
    siz = len(s)
    pivot = s[0]
    index = 1
    while index < siz:
        if s[index] != pivot:
            break
        else:
            index += 1
    if index == siz:
        return s
    elif pivot > s[index]:
        res = s[:index]
        return replaceF(res, pivot, index, siz)
    else:
        res = ''
        ch = str(int(pivot) + 1)
        return replaceF(res, ch, 0, siz)

def replaceF(res, f, start, siz):
    for i in range(start, siz):
        res += f
    return res

def F2(s, k):
    siz = len(s)
    f1 = s[0]
    index = 1
    while index < siz:
        if s[index] != f1:
            break
        else:
            index += 1
    if index == siz:
        return s
    f2 = s[index]
    pos = index + 1
    while pos < siz:
        if s[pos] != f1 and s[pos] != f2:
            break
        else:
            pos += 1
    if pos == siz:
        return s
    minF = min(f1, f2)
    maxF = max(f1, f2)
    maxInt = int(maxF)
    minInt = int(minF)
    if s[pos] < minF:
        res = s[:pos]
        return replaceF(res, minF, pos, siz)
    elif s[pos] < maxF:
        res = s[:pos]
        res += maxF
        return replaceF(res, minF, pos + 1, siz)
    elif s[pos - 1] == minF:
        res = s[:pos - 1]
        if minF not in res:
            res += str(minInt + 1)
            if maxInt > minInt + 1:
                minF = str(minInt + 1)
            else:
                minF = str(0)
        else:
            res += maxF
        return replaceF(res, minF, pos, siz)
    else:
        stand = pos - 1
        while stand >= 0:
            if s[stand] == minF:
                break
            else:
                stand -= 1
        option = False
        for i in range(stand, -1, -1):
            if s[i] == maxF:
                option = True
                break
        if option:
            res = s[:stand]
            if minF not in res:
                res += str(minInt + 1)
                if maxInt > minInt + 1:
                    minF = str(minInt + 1)
                else:
                    minF = str(0)
            else:
                res += maxF
            return replaceF(res, minF, stand + 1, siz)
        else:
            res = s[:stand + 1]
            res += str(int(maxF) + 1)
            return replaceF(res, minF, stand + 2, siz)
case = int(input())
for t in range(case):
    (s, tmp) = input().split()
    k = int(tmp)
    if k == 1:
        print(F1(s, k))
    else:
        print(F2(s, k))