Iroha is very particular about numbers. There are K digits that she dislikes: D_1, D_2, ..., D_K.
She is shopping, and now paying at the cashier.
Her total is N yen (the currency of Japan), thus she has to hand at least N yen to the cashier (and possibly receive the change).
However, as mentioned before, she is very particular about numbers. When she hands money to the cashier, the decimal notation of the amount must not contain any digits that she dislikes. Under this condition, she will hand the minimum amount of money.
Find the amount of money that she will hand to the cashier.

-----Constraints-----
 -  1 ≦ N < 10000
 -  1 ≦ K < 10
 -  0 ≦ D_1 < D_2 < … < D_K≦9
 - \{D_1,D_2,...,D_K\} ≠ \{1,2,3,4,5,6,7,8,9\}

-----Input-----
The input is given from Standard Input in the following format:
N K
D_1 D_2 … D_K

-----Output-----
Print the amount of money that Iroha will hand to the cashier.

-----Sample Input-----
1000 8
1 3 4 5 6 7 8 9

-----Sample Output-----
2000

She dislikes all digits except 0 and 2.
The smallest integer equal to or greater than N=1000 whose decimal notation contains only 0 and 2, is 2000.

Difficulty: introductory

Starter code:

Solutions:
import itertools

def cal(N, target_num, keta):
    answer = float('inf')
    for p in itertools.product(target_num, repeat=keta):
        temp = 0
        for i, num in enumerate(p):
            temp += num * 10**i
            
        if temp >= N:
            answer = min(answer, temp)

    return answer

def __starting_point():
    N, K = map(int, input().split()) # N円の品物、K個の嫌いな数字
    D = set(list(map(int, input().split()))) # 嫌いな数字のリスト
    base = set(range(10))

    target_num = base - D
    keta = len(str(N))

    answer = min(cal(N, target_num, keta), cal(N, target_num, keta+1))

    print(answer)
__starting_point()

import sys
import numpy as np
read = sys.stdin.readline


def main(n, k, a):
    for i in np.arange(n, 100000):
        ok = True
        j = i
        while j:
            ok &= j % 10 not in a
            j //= 10
        if ok:
            print(i)
            break


def __starting_point():
    n, k = np.fromstring(read(), dtype=np.int32, sep=' ')
    a = np.fromstring(read(), dtype=np.int32, sep=' ')
    main(n, k, a)

__starting_point()

N, K = map(int, input().split())
unlike_list = set(map(str, input().split()))

def judge(num):
    for i in str(num):
        if i in unlike_list:
            return False
    return True

ans = False
while not ans:
    if judge(N):
        ans = True
    else:
        N += 1

print(N)

n, k = list(map(int,input().split()))
d = list(map(int,input().split()))

while n < 10**5:
    x = str(n)
    if all(int(i) not in d for i in x):
        print(n)
        return
    n += 1


n, k = list(map(int, input().split()))
d = list(input().split())
ans = n
find = False
while find == False:
    p = str(ans)
    find = True
    for i in range(len(p)):
        if p[i] in d:
            find = False
            break
    if find == False:
        ans += 1

print(ans)


import sys

N,K=list(map(int,input().split()))
D=list(map(int,input().split()))


while True:
  for x in [int(n) for n in str(N)]:
    if x in D:
      break
  else:
    print(N)
    return
  N+=1


total, k = list(map(int, input().split()))

d = list(map(int, input().split()))

def total_to_digits(total):
    return list(map(int, list(str(total))))

def find_lowest_denomination(total, d):
    res = None
    for i in range(total, 99999):
        digits = list(total_to_digits(i))
        if not (set(digits) & set(d)):
            print(i)
            return


find_lowest_denomination(total, d)


n, k = list(map(int,input().split()))
a = list(map(str,input().split()))


while True:
    
    for j in str(n):
        
        if j in a:
            break
    else:
        break
    n += 1        
    
print(n)

def dfs(A: list):
    if len(A) > len(str(n))+1:
        return
    if len(A) and (x := int("".join(A))) >= n and ans[0] > x:
        ans[0] = x
        return

    for v in d:
        if v == "0" and len(A) == 0:
            next
        A.append(v)
        dfs(A)
        A.pop()


n, k = list(map(int, input().split()))
d = sorted(list(set([str(i) for i in range(10)]) - set(input().split())))
ans = [10**10]
dfs([])
print((ans[0]))


n, k= input().split()
l = list(map(int,input().split()))
checkNum=[i for i in range(11)]

def find(x):
    while x!=checkNum[x]:
        checkNum[x]=checkNum[checkNum[x]]
        x=checkNum[x]
    return x

for i in l:
    checkNum[find(i)]=checkNum[find(i+1)]

fin=""
for i in range(len(n)):
    first=int(n[i])
    k=find(first)
    if k==first:
        fin+=str(k)
    else:
        if k!=10:
            fin=str(k)+str(find(0))*(len(n)-i-1)
        else:
            fin=str(find(1))+str(find(0))*len(n)
        break

print(fin)


N,K=list(map(int,input().split()))
D=[int(x) for x in input().split()]
D=set(D)
kouho=N
while(1):
    lenkouho=len(str(kouho))
    flag=1
    for i in range(lenkouho):
        if int(str(kouho)[i]) in D:
            flag=0
    if flag==1:
        print(kouho)
        break
    kouho+=1


#
# abc042 c
#

import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """1000 8
1 3 4 5 6 7 8 9"""
        output = """2000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """9999 1
0"""
        output = """9999"""
        self.assertIO(input, output)


def resolve():
    N, K = list(map(int, input().split()))
    D = list(input().split())

    for i in range(N, 10*N+1):
        for d in D:
            if str(i).count(d) != 0:
                break
        else:
            print(i)
            break


def __starting_point():
    # unittest.main()
    resolve()

__starting_point()

N, K = map(int, input().split())
D = list(map(int, input().split()))
num = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
num = str(list(set(num) ^ set(D)))

ans = str(N)
clear = 0

while clear == 0:
    for i in range(len(ans)):
        if not ans[i] in num:
            break
        if i == len(ans) - 1:
            clear += 1  
    ans = str(int(ans) + 1)

print(int(ans) - 1)

N, K = map(int, input().split())
D = list(input().split())

while True:
    n = str(N)
    for i in range(K):
        f = 0
        if D[i] in n:
            N += 1
            f = 1
            break
    if f == 0:
        break

print(N)

N, K = map(int, input().split())
D = list(map(int, input().split()))


def f(n, x):
    if n==0:
        if x >= N:
            print(x)
            return
        return
    
    for i in range(10):
        if i in D:
            continue
        f(n-1, x*10+i)

f(len(str(N)), 0)
ans = ""
for i in range(1, 10):
    if i not in D:
        ans = str(i)
        break
for i in range(10):
    if i not in D:
        ans += str(i)*len(str(N))
        break
print(ans)

#値段、嫌いな数字の数
N, K = map(int, input().split())
#嫌いな数字
hate_num = list(map(int, input().split()))
#ループ用
i = N

while 1:
    #支払う金額に入っている数字の抜き出し
    ans = list({int(i) for i in list(str(i))})
    #支払う金額に嫌いな数字が入っていないか確認
    for j in ans:
        #嫌いな数字があった時
        if j in hate_num: 
            break
    #嫌いな数字がなかった時
    else:
        print(i)
        break
    i += 1

n, k = input().split()
d = list(map(int, input().split()))

a = []

for i in range(10):
    if i not in d:
        a.append(i)

n = list(map(int, list(n)))

for i in range(len(n)):
    if n[i] in d:
        ind = i

        done = False
        while not done:
            for j in range(n[ind]+1, 10):
                if j in a:
                    n[ind] = j
                    done = True
                    break

            if not done:
                ind -= 1

                if ind < 0:
                    n.insert(0, a[1] if a[0] == 0 else a[0])
                    ind = 0
                    done = True

        for j in range(ind+1, len(n)):
            n[j] = a[0]

        break

print("".join(list(map(str, n))))

n,k = list(map(int,input().split()))
if k == 0:
  print(n)
  return
dislike = list(input().split())
 
ans = n-1
flag = 1
while flag == 1:
  ans+=1
  flag = 0
  for i in str(ans):
    if i in dislike:
      flag = 1
      break
print(ans)


def testa(n,d):
    for i in d:
        if str(i) in str(n): return 0
    return 1

n,k = [int(i) for i in input().split()]
d = [int(i) for i in input().split()]

while not testa(n,d): n+=1
print(n)


N, K = map(int, input().split())
bl = set(input().split())

while True:
  if len(set(str(N)) & bl) != 0:
    N += 1
  else:
    print(N)
    break

N, K = list(map(int,input().split()))
D = set(input().split())

for k in range(N,10**9):
    f = 1
    for e in str(k):
        if e in D:
            f = 0
            break
    if f == 1:
        print(k)
        return


def dfs(i,num_str):
    nonlocal ans_list
    if i==len(str(n)):
        ans_list.append(int(num_str))
        if len(num_list)==1:
            ans_list.append(int(num_list[0]+num_str))
        else:
            if num_list[0]=='0':
                ans_list.append(int(num_list[1]+num_str))
            else:    
                ans_list.append(int(num_list[0]+num_str))
        return
    else:
        for j in num_list:
            dfs(i+1,num_str+j)

n,k = map(int,input().split())
d = list(map(int,input().split()))

ans_list = []
num_list = []
for i in range(10):
    if i not in d:
        num_list.append(str(i))
        
#print(num_list)

dfs(0,'')
sort_list = sorted(ans_list)
#print(sort_list[10:])

for i in sort_list:
    if n<=i:
        print(int(i))
        break

n, k = map(int, input().split())
D = set(input())
for i in range(n, 10**5):
  if set(str(i)) & D == set():
    print(i)
    return

#値段、嫌いな数字の数
N, K = map(int, input().split())
#嫌いな数字
hate_num = list(map(int, input().split()))
#ループ用
i = N

while 1:
    #支払う金額に入っている数字の抜き出し
    ans = list({int(x) for x in list(str(i))})
    #支払う金額に嫌いな数字が入っていないか確認
    for j in ans:
        #嫌いな数字があった時
        if j in hate_num: 
            break
    #嫌いな数字がなかった時
    else:
        print(i)
        break
    i += 1

i3=lambda : map(int,input().split())

N,K=i3()
*D,=i3()

D=set(D)

for i in range(N,10**5):
    ans=1
    for s in str(i):
        if int(s) in D:
            ans=0
            break
    if ans : break
print(i)

import sys


def check(pay, like):
    str_pay = str(pay)
    like = ''.join(like)
    for p in str_pay:
        for lk in like:
            if p == lk:
                return False

    return True

N, K = list(map(int, input().split()))

D = []
D = list(map(int, input().split()))
str_D = []

for s in D:
    str_D.append(str(s))

pay = N

while True:
    if check(pay, str_D):
        print(pay)
        return
    pay += 1


def dfs(A: list):
    if len(A) > nn:
        return
    if len(A) and (x := int("".join(A))) >= n and ans[0] > x:
        ans[0] = x
        return

    for v in d:
        if v == "0" and len(A) == 0:
            next
        A.append(v)
        dfs(A)
        A.pop()


n, k = list(map(int, input().split()))
d = sorted(list(set([str(i) for i in range(10)]) - set(input().split())))
nn = len(str(n))+1
ans = [10**7]
dfs([])
print((ans[0]))


n, k = list(map(int, input().split()))
d = list(input().split())
#n = 1000
flag = True
while flag:
    flag2 = True
    for si in str(n):
        if si in d:
            n += 1
            flag2 = False
            break
    if flag2:
        break
    else:
        flag = True
            
print(n)


def check(n, D):
    N = []
    while n != 0:
        N.append(n % 10)
        n //= 10
    for d in D:
        if d in N:
            return False
    return True

def __starting_point():
    n, k = [int(x) for x in input().split(' ')]
    D = [int(x) for x in input().split(' ')]
    res = n
    while True:
        if check(res, D):
            break
        else:
            res += 1
    print(res)

__starting_point()

def is_dislike(N, ds):
  num = N
  while(True):
    if (num % 10) in ds:
      return True
    else:
      num = int(num / 10)
      if num == 0:
        break
  return False


nk = list(map(int,input().split()))
N = nk[0]
K = nk[1]
ds = list(map(int,input().split()))
while(True):
  if is_dislike(N, ds):
    N = N+1
  else:
    print(N)
    break

#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from math import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
import math
import bisect
import heapq
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
#
# インデックス系
# int min_y = max(0, i - 2), max_y = min(h - 1, i + 2);
# int min_x = max(0, j - 2), max_x = min(w - 1, j + 2);
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
#mod = 998244353
INF = float('inf')
from sys import stdin
readline = stdin.readline
def readInts():
  return list(map(int,readline().split()))
def readTuples():
    return tuple(map(int,readline().split()))
def I():
    return int(readline())

#dic = defaultdict(int)
n,k = readInts()
D = Counter(readInts())
def ok(n):
    while n:
        v = n%10
        if D[v]:
            return False
        n //= 10
    return True
ans = n
for i in range(n, 100000):
    if ok(i):
        ans = i
        break
print(ans)


import sys
import numpy as np
read = sys.stdin.readline


def main(n, k, a):
    for i in range(n, 100000):
        s = np.array(list(map(int, str(i))), dtype=np.int64)
        ok = True
        for j in s:
            ok &= j not in a
        if ok:
            print(i)
            break


def __starting_point():
    n, k = np.fromstring(read(), dtype=np.int64, sep=' ')
    a = np.fromstring(read(), dtype=np.int64, sep=' ')
    main(n, k, a)

__starting_point()

n, k = map(int, input().split())
arr = list(map(int, input().split()))

inf = float('inf')
min_cost = inf
for amount in range(n, 100000):
    for i, e in enumerate(arr):
        if str(e) in str(amount):
            break
        if i == len(arr)-1:
            min_cost = min(min_cost, amount)

print(min_cost)

#
# abc042 c
#

import sys
from io import StringIO
import unittest


class TestClass(unittest.TestCase):
    def assertIO(self, input, output):
        stdout, stdin = sys.stdout, sys.stdin
        sys.stdout, sys.stdin = StringIO(), StringIO(input)
        resolve()
        sys.stdout.seek(0)
        out = sys.stdout.read()[:-1]
        sys.stdout, sys.stdin = stdout, stdin
        self.assertEqual(out, output)

    def test_入力例_1(self):
        input = """1000 8
1 3 4 5 6 7 8 9"""
        output = """2000"""
        self.assertIO(input, output)

    def test_入力例_2(self):
        input = """9999 1
0"""
        output = """9999"""
        self.assertIO(input, output)


def resolve():
    N, K = list(map(int, input().split()))
    D = list(input().split())

    for i in range(100000):
        if i < N:
            continue
        for d in D:
            if str(i).count(d) != 0:
                break
        else:
            print(i)
            break


def __starting_point():
    # unittest.main()
    resolve()

__starting_point()

n,k = input().split()
hate = list(input().split())
exi = True
t = True

while True:
    for c in hate:
        t = True
        if c in list(n):
            t = False
            break
    if t:
        print(n)
        break

    intN = int(n) + 1
    n = str(intN)

import itertools

def main():
	N, K = [int(n) for n in input().split(" ")]
	D = [1] * 10
	for d in input().split(" "):
		D[int(d)] = 0
	L = [str(i) for i, v in enumerate(D) if v == 1]

	digit = len(str(N))
	cand = []
	for n in list(itertools.product(L, repeat=digit)):
		p = int("".join(list(n)))
		if p >= N:
			cand.append(p)
	if len(cand):
		print(min(cand))
	else:
		if L[0] == "0":
			print(str(L[1]) + "0" * digit)
		else:
			print(str(L[0]) * (digit + 1))


main()

import sys
input = sys.stdin.readline

def find_ok( x , Oks ):
    for i in Oks:
        if int(i) > int(x):
            break
    return i

def main():
    n,k = map( int , input().split() )
    Nos = set(map( int , input().split() ))
    while(1):
        x = str(n)
        set_n= set()
        for digit in x:
            set_n.add( int(digit) )
        if len(set_n & Nos) == 0:
            break
        n += 1
    print(n)



main()

n,k=list(map(int,input().split()))
d=set(input().split())

while True:
  if len(set(str(n))&d) != 0:
    n+=1
    
  else:
    print(n)
    break


#!/usr/bin/env python
# coding: utf-8

# In[21]:


import itertools

def main():
	N, K = [int(n) for n in input().split(" ")]
	D = [1] * 10
	for d in input().split(" "):
		D[int(d)] = 0
	L = [str(i) for i, v in enumerate(D) if v == 1]

	digit = len(str(N))
	cand = []
	for n in list(itertools.product(L, repeat=digit)):
		p = int("".join(list(n)))
		if p >= N:
			cand.append(p)
	if len(cand):
		print((min(cand)))
	else:
		if L[0] == "0":
			print((str(L[1]) + "0" * digit))
		else:
			print((str(L[0]) * (digit + 1)))


main()


# In[ ]:






N,K = map(int,input().split())
D = list(map(int,input().split()))
E = []
for i in range(10):
    if i not in D:
        E.append(i)
E = sorted(E)
N = str(N)
ind = len(N)
for i in range(len(N)):
    if int(N[i]) not in E:
        ind = i
        break
if ind==len(N):
    print(N)
else:
    flag = 0
    x = ""
    for i in range(ind,-1,-1):
        n = int(N[i])
        for e in E:
            if e>n:
                x = N[:i]+str(e)+str(E[0])*(len(N)-i-1)
                flag = 1
                break
        if flag==1:break
    if flag==0:
        if E[0]>0:
            a = E[0]
        else:
            a = E[1]
        x = str(a)+str(E[0])*len(N)
    print(x)

n, k = map(int, input().split())
ds = [d for d in input().split()]
while any(c in ds for c in str(n)): n += 1
print(n)

n,k = map(int,input().split())
d = list(input().split())
flg = True
while flg:
    flg = False
    m = list(str(n))
    for i in m:
        if i in d:
            flg = True
            break
    if flg:
        n += 1
print(n)

n,k = map(int,input().split())
a = list(map(int,input().split()))
b = set()
for i in range(10):
  if i in a:
    b.add(str(i))
while n > 0:
  c = set(list(str(n)))
  if c.isdisjoint(b):
    print(n)
    return
  n += 1

# coding:UTF-8
import sys


def resultSur97(x):
    return x % (10 ** 9 + 7)

def __starting_point():
    # ------ 入力 ------#
    nk = list(map(int, input().split()))     # スペース区切り連続数字

    x = nk[1]
    dList = list(map(int, input().split()))     # スペース区切り連続数字

    # ------ 処理 ------#
    f = 0
    n = nk[0]
    while f == 0:
        nList = [int(c) for c in str(n)]  # 数字→単数字リスト変換
        b = 1
        for i in nList:
            for j in dList:
                if i == j:
                    b = 0
                    break
        if b == 1:
            break
        else:
            n += 1

    # ------ 出力 ------#
    print(("{}".format(n)))
    # if flg == 0:
    #     print("YES")
    # else:
    #     print("NO")

__starting_point()

import re
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
import functools
def v(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return list(map(int,input().split()))
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
cnt = 0
ans = 0
inf = float("inf")
al = "abcdefghijklmnopqrstuvwxyz"
AL = al.upper()

n,k = I()
d = l()
use = [i for i in range(11) if i not in d ]
a = True
price = n

while a:
    cnt = 0
    for i in str(price):
        a = len(str(price))
        if int(i) not in d:
            cnt += 1
        else:
            cnt = inf
        if a == cnt:
            print(price)
            return
    price += 1
    
    
    



n,k=map(int,input().split())
d=list(map(str,input().split()))
e=set(d)
for i in range(n,100001):
  v = set(str(i))&e
  if len(v)== 0:
    print(i);return

import itertools
n,k = map(int, input().split())
d = list(map(int, input().split()))
safe = [i for i in range(10) if i not in d]

n_l = list(map(int, list(str(n))))
if len(set(safe)&set(n_l)) == len(set(n_l)):
    print(n)
    return

for v in itertools.product(safe, repeat=len(str(n))):
    if v[0] == 0: continue
    x = int("".join(list(map(str, v))))
    if int(x) >= n:
        print(x)
        return

for v in itertools.product(safe, repeat=len(str(n))+1):
    if v[0] == 0: continue
    x = int("".join(list(map(str, v))))
    if int(x) >= n:
        print(x)
        return

import sys
import numpy as np
read = sys.stdin.readline


def main(n, k, a):
    for i in np.arange(n, 100000):
        ok = True
        for j in str(i):
            ok &= j not in a
        if ok:
            print(i)
            break


def __starting_point():
    n, k = np.fromstring(read(), dtype=np.int32, sep=' ')
    a = set(read().split())
    main(n, k, a)

__starting_point()

n,k=map(int,input().split())
d=set(input().split())
 
while True:
  if len(set(str(n))&d) != 0:
    n+=1
    
  else:
    print(n)
    break

N, K = map(int, input().split())
D = set(input().split())

for i in range(N, 100001):
    for d in str(i):
        if d in D:
            break
    else:
        print(i)
        break

n, k = list(map(int, input().split()))
d = list(map(int, input().split()))

v = n
while True:
    f = True
    for t in list(str(v)):
        if int(t) in d:
            f = False
            continue
    if f:
        print(v)
        return
    v+=1


n,k = [int(x) for x in input().split()]
a = input().split()

def check(p):
  p = list(str(p))
  for i in range(len(p)):
    if p[i] in a:
      return False
  return True

for i in range(n,n * 10000):
  if check(i):
    print(i)
    break

N,K=map(int,input().split())
*D,=input().split()
ok=1
while ok:
    ans=list(str(N))
    ok=0
    for a in ans:
        if a in D:
            ok=1
    N+=1
print(''.join(ans))

n, k = map(int, input().split())
D = list(map(int, input().split()))

for i in range(n, 100000):
  m = str(i)
  count = 0
  for j in range(len(m)):
    if int(m[j]) in D:
      break
    else:
      count += 1
    if count == len(m):
      print(i)
      return
      
print(0)

n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
for v in range(n,10**5):
    for c in str(v):
        if int(c) in l:
            break
    else:
        print(v)
        return


N, K = map(int,input().split())
mat = input().split()
while True:
  FIN = 0
  for i in range(len(str(N))):
    for j in range(K):
      if mat[j] == str(N)[i]:
        FIN += 1
        break
  if FIN == 0:
    break 
  else:
    N += 1
print(N)

n,k = [int(x) for x in input().split()]
ds = {int(x) for x in input().split()}
ns = {0,1,2,3,4,5,6,7,8,9} -ds
#print(ds)
#print(ns-ds)
temp=0
d ={}
a=1
b = {}
m = len(str(n)) +1 
over=False
while(a<=m and not over ):
  c = []
  d = 10**(a-1) 
  for v in ns:
    if a>1:
      for bv in b[a-1]:
        t = v*d + bv
        c += [t]
        if t >= n:
          print(t)
          over=True
          break
      if over:
        break
    else:
      t = v*d
      c += [t]
      if t >= n:
          print(t)
          over=True
          break
      
  b[a] = c
  a+=1
  
#for j in b:    
#    print(j,b[j])



# N, Kの入力受付
N, K = map(int, input().split())
# Dの入力受付
D = set(input().split())
# 0-9とDの差集合作成、リスト化してEに代入
E = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9"} - D
# Nに1ずつ足して条件に合う最初の数字を特定する
result = False
while result == False:
    for i in str(N):
        if not i in E:
            N = N + 1
            result = False
            break
        else:
            result = True
print(N)

n, k = map(int,input().split())
a = list(input().split())

for i in range(n, 100001):
    flg = True
    s = str(i)
    for j in range(len(s)):
        if s[j] in a:
            flg = False
            break
    if flg:
        break
print(i)

# bsdk idhar kya dekhne ko aaya hai, khud kr!!!
# import math
# from itertools import *
# import random
# import calendar
import datetime
# import webbrowser

# f = open("input.txt", 'r')
# g = open("output.txt", 'w')
# n, m = map(int, f.readline().split())

n, k = list(map(int, input().split()))
dislike = list(map(int, input().split()))
while True:
    for i in str(n):
        if int(i) not in dislike:
            continue
        else:
            break
    else:
        break
    n += 1
print(n)


n,k=list(map(int,input().split()))
d = list(map(int,input().split()))
#print(d)
for i in range(n,10**5):
    count=0
    for j in range(k):
        u = str(d[j])
        if(str(i).count(u)==0):
            count+=1
    #print("count:"+str(count))
    if(count==k):
        print(i)
        break


def is_bad_nums(j: int, d: []) -> bool:
    while j:
        if j % 10 in d:
            return True
        j //= 10
    return False


def answer(n: int, k: int, d: []) -> int:
    for i in range(n, 100000):
        if is_bad_nums(i, d):
            continue
        return i


def main():
    n, k = map(int, input().split())
    d = list(map(int, input().split()))
    print(answer(n, k, d))


def __starting_point():
    main()
__starting_point()

N, K = map(int, input().split())
D = list(map(int, input().split()))
s = set(D)

for i in range(N, 10**6+1):
  l = [j for j in str(i)]
  flag = True
  for n in l:
    if int(n) in s:
      flag = False
      break
  if flag:
    ans = i
    break
print(ans)

n, k = map(int, input().split())
d = list(input().split())
while True:
    flag2 = True
    for si in str(n):
        if si in d:
            n += 1
            flag2 = False
            break
    if flag2:
        break            
print(n)

def price(N,K):
    Kn = input().split()
    Flag = False

    for i in range(N,10*N,1):
        value = str(i)
        for j in range(K):
            if(Kn[j] not in value):
                Flag = True
            elif(Kn[j] in value):
                Flag = False
                break

        if(Flag == True):
            print(i)
            break

N,K = (int(x) for x in input().split())
price(N,K)

n, k = list(map(int, input().split()))
dl = list(map(int, input().split()))

i = n
while True:
    money = list(map(int, str(i)))
    for m in money:
        if dl.count(m) != 0:
            break
    else:
        print(i)
        break
    i += 1
    


import sys
sys.setrecursionlimit(10**7)
arr = ["a","b","c"]
savelis = [0]*10
def main():
   N,K = list(map(int,input().split()))
   Flis = list(map(int,input().split()))
   Tlis = [i for i in range(10)]
   Tlis = [i for i in Tlis if i not in Flis]
   str_flis = [str(i) for i in Flis]
   ANS = []
   for i in range(N*10):
      stri = str(i)
      TF = True
      for j in stri:
         if j in str_flis:
            TF = False
            break
      if(TF):ANS.append(i)
   for item in ANS:
      if(item>=N):
         print(item)
         break


def __starting_point():
    main()

__starting_point()

import itertools

N, K = map(int, input().split()) # N円の品物、K個の嫌いな数字
D = set(list(map(int, input().split()))) # 嫌いな数字のリスト
base = set(range(10))

target_num = base - D
keta = len(str(N))

answer = float('inf')
for p in itertools.product(target_num, repeat=keta):
    temp = 0
    for i, num in enumerate(p):
        temp += num * 10**i
        
    if temp >= N:
        answer = min(answer, temp)

for p in itertools.product(target_num, repeat=keta+1):
    temp = 0
    for i, num in enumerate(p):
        temp += num * 10**i
        
    if temp >= N:
        answer = min(answer, temp)

print(answer)

n,k = list(map(int,input().split()))

a = list(input().split())

while  not set(list(str(n)[0:k])).isdisjoint(a):
	n += 1

print(n)


n, k = map(int, input().split())
D = list(input().split())

ans = str(n)
while not all([c not in D for c in ans]) and int(ans) >= n:
    ans = str(int(ans) + 1)
print(ans)

n, k = map(int, input().split())
d = list(map(int, input().split()))
ng = [False] * 10
for i in d:
    ng[i] = True
def ok(n):
    nonlocal ng
    while n > 0:
        if ng[n%10]:
            return False
        n //= 10
    return True
while not ok(n):
    n += 1
print(n)

n, k = list(map(int, input().split()))
d = set(map(int, input().split()))

while True:
    tmp_str = set(str(n))
    for i in tmp_str:
        if int(i) in d:
            n += 1
            break
    else:
        print(n)
        break


n,k=map(int,input().split())
d=list(map(int,input().split()))
x=list(range(1,100001))
y=[0]*100000
for i in range(100000):
    s=str(i)
    S=len(s)
    for j in range(S):
        if int(s[j]) in d:
            y[i-1]=1
            break
for i in range(100000):
    if i>=n-1:
        if y[i]==0:
            print(i+1)
            break

n, k = map(int, input().split())
D = set(map(int, input().split()))
from itertools import count
for ans in count(n,1):
    for c in str(ans):
        if int(c) in D:
            break
    else:
        print(ans)
        break

def iparse():
    return list(map(int, input().split()))

n, k = iparse()
d = iparse()

for i in range(n, 5000000):
    tmp = i
    f = True
    while tmp > 0:
        x = tmp % 10
        if x in d:
            f = False
            break
        tmp //= 10
    if f:
        print(i)
        return



from sys import stdin
input = stdin.readline

N, K = map(int, input().split())
D = set(map(int, input().split()))

while True:
    tmp = set(str(N))
    b = True
    for x in tmp:
        if int(x) in D:
            b = False
            break 
    if b == True:
        break
    else:
        N += 1

print(N)

N,K = input().split()
D =list(map(int,input().split()))
ans = []
a = int(N[0])
x = 0
b = 0
while b in D:
    b += 1
c = 2
while c in D:
    c += 1
y = 0
while a == int(N[x]) and x <= len(N)-1:
    while a in D and a <= 9:
        a += 1
    if  a == 10:
        y = x
        if 0 in D:
            a += b
        if 1 in D:
            if b != 0:
                a += (b-1)*10
            else:
                a += (c-1)*10
    ans.append(str(a))
    if a != int(N[x]):
        for i in range(len(N)-1-x):
            ans.append(str(b))
    elif x <= len(N)-2:
        x += 1
        a = int(N[x])
    else:
        a = int(N[x])-1
while y > 0:
    s = ans[y][0]
    t = ans[y][1]
    r = ans[y]
    ans[y] = t
    ans[y-1] = str(int(ans[y-1]) + 1)
    if int(ans[y-1]) in D:
        u = int(ans[y-1])
        while u in D:
            u += 1
            ans[y-1] = str(u)
    if ans[y-1] != "10":
        y = 0
    else:
        y -= 1
        ans[y] = r
print("".join(ans))

n, k = map(int, input().split())
d = list(input().split())
num = [str(i) for i in range(10)]
for i in range(k):
    num.remove(d[i])
    
import itertools, heapq
ans = []
heapq.heapify(ans)
for i in itertools.product(num, repeat=len(str(n))):
    s = int(''.join(i))
    if s >= n:
        heapq.heappush(ans, s)
        
if len(ans) == 0:
    for i in itertools.product(num, repeat=len(str(n)) + 1):
        s = int(''.join(i))
        if s >= n:
            heapq.heappush(ans, s)
    print(heapq.heappop(ans))
    
else:
    print(heapq.heappop(ans))

n, k = list(map(int, input().split()))
d = list(map(int, input().split()))
s = {'0','1','2','3','4','5','6','7','8','9'} - set(str(d))
ans = n

while (s >= set(str(n))) == False:
  n += 1
  if (s >= set(str(n))) == True:
    ans = n
    break
    
print(ans)


def main():
    N, K = map(int, input().split())
    A_list = list(map(str, input().split()))
    use_list = ["0","1","2","3","4","5","6","7","8","9"]
    list_A = list(set(use_list) - set(A_list))
    #print("list_A", list_A)
    for i in range(100000) :
        ans = N + i
        #print("ans", ans)
        ans_str = str(ans)
        frag = 0
        for val in ans_str :
            #print("val", val)
            if str(val) in list_A :
                pass
                #print("frag", frag)
            else :
                frag = 1
                break

        if frag == 0 :
            break
    print(ans)


def __starting_point():
    main()
__starting_point()

def main():
    N, K = list(map(int, input().split()))
    D = set(map(int, input().split()))
    numset = set(range(0,10))
    d = numset.difference(D)

    for n in range(N, pow(10, 6) + 10):
        check = set(list(str(n)))
        ngflag = False
        for i in check:
            if int(i) in D:
                ngflag = True
                break
        if not ngflag:
            break
    print(n)

def __starting_point():
    main()

__starting_point()

N, K = [int(x) for x in input().split()]
D = input().split()

for payment in range(N, 10*N+1):
    if all(char not in D for char in str(payment)):
        print(payment)
        break

n, k = map(int, input().split())
d = list(input().split())
num = [str(i) for i in range(10)]
for i in range(k):
    num.remove(d[i])
    
import itertools
ans = []
for i in itertools.product(num, repeat=len(str(n))):
    s = int(''.join(i))
    if s >= n:
        ans.append(s)
        
if len(ans) == 0:
    for i in itertools.product(num, repeat=len(str(n)) + 1):
        s = int(''.join(i))
        if s >= n:
            ans.append(s)
    print(min(ans))
    
else:
  print(min(ans))

N, K = map(int, input().split())
S = set(input().split())
while True:
    L = list(str(N))
    for i in L:
        if i in S:
            break
    else:
        break
    N += 1
print(N)

n, k = map(int, input().split())
d = list(map(int, input().split()))

while True:
    for i in str(n):
        if int(i) in d:
            n += 1
            break
    
    else:
        print(n)
        break

N, K, *D = list(map(int, open(0).read().split()))
D = set(str(d) for d in D)
for i in range(N, 100_000):
    if set(str(i)) & D:
        continue
    print(i)
    break


n,t = [int(x) for x in input().split()]
d = [int(x) for x in input().split()]

def check(x) -> bool:
    while x>0:
        a = x%10
        if a in d:
            return False
        x//=10
    return True

while check(n)==False:
    n+=1
print(n)

n,k = map(int,input().split())
d=set(input().split())
while True:
    if len(set(str(n))&d)!=0:
        n+=1
    else:
        break
print(n)

def minN(N:int, usable:list, restrict=True):
    usable.sort()
    keta = False
    if restrict:
        for i in usable:
            if i >= N:
                return str(i)
        # 桁が増える
        return '1'+str(usable[0])
    else:
        return str(usable[0])

def rote(N:list, D:set, d:set):
    ans = []
    flag = True
    lenNstr = len(N)
    for i, n in enumerate(N):
        n = int(n)
        keta = 10**(len(N) - i - 1)
        if flag:
            if n in D:
                ans.append(int(minN(n, d)) * keta)
                flag = False
            else:
                ans.append(keta * n)
        else:
            ans.append(keta * min(d))
    return sum(ans)

def main():
    N, K = list(map(int, input().split()))
    D = set(map(int, input().split()))
    numset = set(range(0,10))
    d = list(numset.difference(D))
    d.sort()
    for _ in range(10):
        Nstr = list(str(N))
        ans = rote(Nstr, D, d)
        N = ans    
    print(ans)

def __starting_point():
    main()

__starting_point()

N,K = list(map(int,input().split()))

D = list(map(int,input().split()))

def ok(x):
    while x:
        if x % 10 in D:
            return False
        x //= 10
    return True

for i in range(N,100000):
    if ok(i):
        print(i)
        return


N,K=map(int,input().split())
D=list(map(int,input().split()))

while True:
  S=str(N)
  flag=True
  for x in S:
    if int(x) in D:
      flag=False
  if flag==True:
    break;
  N+=1
print(N)

n,k=map(int,input().split());a=set(input().split())
while True:
  if not set(str(n))&a: print(n);break
  n+=1

N, K = list(map(int, input().split()))
kirai = list(map(int, input().split()))
while True:
  bara = [int(x) for x in list(str(N))]
  diff = set(kirai) & set(bara)
  if diff == set():
    print(N)
    break
  else:
    N = N + 1