import java.util.*;

public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    }

    public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    }
} import java.util.*; util.* java public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    }

    public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    }
} Main public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    } main {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    } Scanner scanner = new Scanner(System.in); scanner new Scanner(System.in) int M = scanner.nextInt(); M scanner.nextInt() scanner.nextInt scanner int N = scanner.nextInt(); N scanner.nextInt() scanner.nextInt scanner if (M > 0 && N > 0) {
            convert(M, N);
        } M > 0 && N > 0 M > 0 M 0 N > 0 N 0 {
            convert(M, N);
        } convert(M, N) convert M N String[] args args public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    } convert {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    } Map<Integer, String> map = new HashMap<>(); map new HashMap<>() map.put(10, "A") map.put map 10 "A" map.put(11, "B") map.put map 11 "B" map.put(12, "C") map.put map 12 "C" map.put(13, "D") map.put map 13 "D" map.put(14, "E") map.put map 14 "E" map.put(15, "F") map.put map 15 "F" if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        } n == 10 n 10 {
            String a = "" +m;
            System.out.println(a.length());
            return;
        } String a = "" +m; a "" +m "" m System.out.println(a.length()) System.out.println System.out System System.out a.length() a.length a return; Stack list = new Stack(); list new Stack() while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        } m > 0 m 0 {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        } int yushu = m % n; yushu m % n m n if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            } n < 10 n 10 {
                list.push(yushu);
            } list.push(yushu) list.push list yushu {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            } list.push((yushu > 9 ? map.get(yushu) : yushu)) list.push list (yushu > 9 ? map.get(yushu) : yushu) yushu > 9 yushu 9 map.get(yushu) map.get map yushu yushu m = m / n m m / n m n int count = 0; count 0 if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        } !list.isEmpty() list.isEmpty() list.isEmpty list {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        } Enumeration items = list.elements(); items list.elements() list.elements list while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            } items.hasMoreElements() items.hasMoreElements items {
                //System.out.print(list.pop());
                list.pop();
                count++;
            } list.pop() list.pop list count++ count System.out.println(count) System.out.println System.out System System.out count int m m int n n public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    }

    public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    }
} public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    }

    public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    }
} Main
import java.util.*;

public class Main {
    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        int M = scanner.nextInt();
        int N = scanner.nextInt();
        //int a = 11;
        //int b = 2;
        if (M > 0 && N > 0) {
            convert(M, N);
        }
    }

    public static void convert(int m, int n) {
        // 创建一个map对象，用来存储对应的字符
        Map<Integer, String> map = new HashMap<>();
        map.put(10, "A");
        map.put(11, "B");
        map.put(12, "C");
        map.put(13, "D");
        map.put(14, "E");
        map.put(15, "F");

        // 如果是10进制，直接输出结束
        if (n == 10) {
            String a = "" +m;
            System.out.println(a.length());
            return;
        }

        // 创建一个栈
        Stack list = new Stack();

        // 对输入的数值进行计算，直到这个值=1
        // 这里主要使用短除法
        while (m > 0) {
            // 计算余数，7%2=1
            int yushu = m % n;
            // 如果是小于10的进制
            if (n < 10) {
                list.push(yushu);
            } else {
                // 如果大于10的进制，取出余数，并且找到对应的字母
                list.push((yushu > 9 ? map.get(yushu) : yushu));
            }
            m = m / n;
        }

        // 输出
        int count = 0;
        if (!list.isEmpty()) {
            Enumeration items = list.elements();
            while (items.hasMoreElements()) {
                //System.out.print(list.pop());
                list.pop();
                count++;
            }
        }
        System.out.println(count);
    }
}
