POJ 1894 Alternative Scale of Notation

Alternative Scale of Notation

Time Limit: 1000MS		Memory Limit: 30000K
Total Submissions: 1530		Accepted: 538

Description

One may define a map of strings over an alphabet Σ _B = { C1, C2, . . . C _B } of size B to non-negative integer numbers, using characters as digits C1 = 0, C2 = 1, . . . , C _B = B - 1 and interpreting the string as the representation of some number in a scale of notation with base B. Let us denote this map by U _B , for a string α[ 1...n ] of length n we put 
U_B(α)=Σ_0<=i<=n-1α[n-i]*Bⁱ
For example, U3(1001) = 1*27 + 0*9 + 0*3 + 1*1 = 28. 

However, this correspondence has one major drawback: it is not one-to-one. For example, 
28 = U3(1001) = U3(01001) = U3(001001) = ... , 
infinitely many strings map to the number 28. 

In mathematical logic and computer science this may be unacceptable. To overcome this problem, the alternative interpretation is used. Let us interpret characters as digits, but in a slightly different way: C1 = 1, C2 = 2, . . . , C _B = B . Note that now we do not have 0 digit, but rather we have a rudiment B digit. Now we define the map V _B in a similar way, for each string α[ 1...n ] of length n we put 
V_B(α)=Σ_0<=i<=n-1α[n-i]*Bⁱ
For an empty string ε we put V _B(ε) = 0. 

This map looks very much like U _B , however, the set of digits is now different. So, for example, we have V3(1313) = 1*27 + 3*9 + 1*3 + 3*1 = 60. 

It can be easily proved that the correspondence defined by this map is one-to-one and onto. Such a map is called bijective, and it is well known that every bijective map has an inverse. Your task in this problem is to compute the inverse for the map V _B . That is, for a given integer number x you have to find the string α, such that V _B(α) = x. 

Input

The first line contains B (2 <= B <= 9) and the second line contains an integer number x given in a usual decimal scale of notation, 0 <= x <= 10 ¹⁰⁰.

Output

Output in one line such string α, consisting only of digits from the set { 1, 2, . . . , B }, that V _B(α) = x . 

Sample Input

3
60

Sample Output

1313

Source

Northeastern Europe 2003

/*

第一次在POJ上用JAVA提交程序，一开始用自己写的大数运算工具库做的，结果TLE，后来转用JAVA的BIG INTEGER就过了

看来自己写的那个大数运算工具还是只适合做工程，不适合来做ACM的题啊。下面分别给出C++(TLE)和JAVA(ACCPET)版本

其实思路很简单：

对于U串[Un, Un-1, Un-2, ..., U1]其对应的V串是[Un + 1, Un-1 + 1, Un-2 + 1,..., U1 + 1]即在每一个U串元素的基础上+1

那么U串的X值和V串的X值是什么关系呢？ xV = Bn * (Un + 1) + Bn-1 * (Un-1 + 1) + Bn-2 * (Un-2 + 1) +... + B1 * (U1 + 1)

其中Bn = base ^ (n - 1). 则xV = xU + Bn + Bn-1 + Bn-2 +  ... + B1,所以可以基于以下步骤通过间接求U串来求解V串：

1）将输入x迭代减去bi,当bi > x时退出，此时剩下的x为U的x值，并记录下迭代的步骤len，len即为V串的长度

2）利用10进制转base进制的方法在1）中x的基础上求U串

3）2)中出的U串的长度l很可能小于Len，则在U串前面补齐Len - l个0

4）一次输出U串元素+1即为V串

*/

import java.io.BufferedInputStream;
import java.math.BigInteger;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner cin = new Scanner(System.in);  
        BigInteger base = null, input = null;
        BigInteger zero = BigInteger.valueOf(0);
        String res = "";
        while(cin.hasNextBigInteger())
        {
            base = cin.nextBigInteger();
            input = cin.nextBigInteger();
            if(input.compareTo(zero) == 0) continue;
            //System.out.println("hell0");
            BigInteger cur = BigInteger.valueOf(1);
            int len = 0;
            while(input.compareTo(cur) >= 0)
            {
                len++;
                input = input.subtract(cur);
                cur = cur.multiply(base);
            }
            res = "";
            BigInteger residual = null;
            BigInteger quotient = null;
            while(input.compareTo(zero) != 0)
            {
                quotient = input.divide(base);
                residual = input.mod(base);
                input = quotient;
                res = residual.toString() + res;
            }
            int l = res.length();
            while(l < len)
            {
                res = "0" + res;
                l++;
            }
            for(l = 0; l < res.length(); l++)
                System.out.print((char)(res.charAt(l) + 1));
        }
        
    }
}