给定一个 k 位整数 n=d \r\nk−1\r\n​\r\n 10 \r\nk−1\r\n +⋯+d \r\n1\r\n​\r\n 10 \r\n1\r\n +d \r\n0\r\n​\r\n (0≤d \r\ni\r\n​\r\n ≤9, i=0,⋯,k−1

这道题目是要我们找到一个k位数n，满足n的第一位是-1，第k位是d，而且n-1是10的倍数。

具体的情况可以通过列举几个数字来进行分析：

当k=2时，可得到的数字为-10、-20、-30、-40、-50、-60、-70、-80、-90。

当k=3时，可得到的数字为-109、-118、-127、-136、-145、-154、-163、-172、-181、-190。

当k=4时，可得到的数字为-1090、-1180、-1270、-1360、-1450、-1540、-1630、-1720、-1810、-1900。

可以发现，当k为偶数时，n-1的最后一位就是0，因此d的取值只能为0或5。

当k为奇数时，n-1的最后两位为90时，n就是10的倍数，此时d的取值可以为任何一个数字。

因此，该题的答案为：

当k为偶数时，d可以取0或5。

当k为奇数时，d可以取0、1、2、3、4、5、6、7、8、9。

相关问题

用C++写一下这道题的代码：给定一个 1×1的方格矩阵，方格为白色： 你需要对该矩阵进行 k 次扩张操作，并输出最终得到的矩阵。 扩张操作的具体规则如下。 首先，给定一个 n×n 的方格矩阵，其中的每个方格要么是白色，要么是黑色，称此矩阵为模板矩阵。 在进行扩张操作时，当前矩阵中的每个方格都将扩张为一个 n×n 的方格矩阵，其中： 每个白色方格扩张得到的方格矩阵与模板矩阵相同。 每个黑色方格扩张得到的方格矩阵只包含黑色方格。 输入格式 第一行包含两个整数 n,k 。 接下来 n 行，每行包含 n 个字符，每个字符要么为 .，要么为 *，其中第 i 行第 j 个字符用来描述模板矩阵第 i 行第 j 列的方格颜色，. 表示白色，* 表示黑色。 保证模板矩阵中至少包含一个白色方格。 输出格式 输出一个 nk×nk 的字符矩阵，用来表示最终得到的矩阵。 . 表示白色方格，* 表示黑色方格。

以下是另一种使用 C++ 实现的代码：

#include <iostream>
#include <vector>

using namespace std;

const int N = 20;

char grid[N][N];
vector<vector<char>> mat(N * N, vector<char>(N * N));

void expand(int r, int c, int len)
{
    for (int i = r * len; i < (r + 1) * len; i++)
    {
        for (int j = c * len; j < (c + 1) * len; j++)
        {
            mat[i][j] = grid[r][c];
        }
    }
}

int main()
{
    int n, k;
    cin >> n >> k;

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            cin >> grid[i][j];
        }
    }

    for (int i = 0; i < n; i++)
    {
        for (int j = 0; j < n; j++)
        {
            if (grid[i][j] == '.') // 白色方格与模板矩阵相同
            {
                expand(i, j, k);
            }
            else // 黑色方格只包含黑色
            {
                for (int r = 0; r < k; r++)
                {
                    for (int c = 0; c < k; c++)
                    {
                        for (int x = r * n; x < (r + 1) * n; x++)
                        {
                            for (int y = c * n; y < (c + 1) * n; y++)
                            {
                                mat[x][y] = '*';
                            }
                        }
                    }
                }
            }
        }
    }

    for (int i = 0; i < k * n; i++)
    {
        for (int j = 0; j < k * n; j++)
        {
            cout << mat[i][j];
        }
        cout << endl;
    }

    return 0;
}

输入示例：

2 2
. *
* .

输出示例：

. . * *
. . * *
* * . .
* * . .

给定一个 k 位整数 n=d \nk−1\n​\t\n 10 \nk−1\n +⋯+d \n1\n​\t\n 10 \n1\n +d \n0\n​\t\n (0≤d \ni\n​\t\n ≤9, i=0,⋯,k−1, d \nk−1\n​

### 回答1：
根据题意，给定一个整数 k 和一个 k 位整数 n=d[k-1]d[k-2]...d[1]d[0]，其中每一位数字 d[i] 满足 0≤d[i]≤9，需要计算以下两个值：

1. 数字 n-1,n-2,...,n-k+1 的和。

2. 数字 n-1,n-2,...,n-k+1 的十进制表示中，所有数字 1 的个数。

下面分别介绍两种解法：

解法一：暴力模拟

可以直接模拟数字 n-1,n-2,...,n-k+1，计算它们的和并统计其中数字 1 的个数。具体地，我们可以从 n-1 开始逐个减去 1，每次减完之后将得到的数按位分解，统计其中数字 1 的个数即可。对于每个数字，可以用取模和除法来依次获取它的各个位。

算法的时间复杂度为 O(k(n-1))，其中 n 是输入整数，k 是它的位数。

解法二：找规律

我们可以尝试找到数字 n-1,n-2,...,n-k+1 的和和数字 1 的个数之间的规律。不难发现，这两个问题的答案都只与数字 d[k-1]~d[0] 有关，与其他位上的数字无关。

设 S 表示数字 n-1,n-2,...,n-k+1 的和，C 表示其中数字 1 的个数，则有：

S = (d[k-1]-1)×10^(k-1) + (d[k-2]-1)×10^(k-2) + ... + (d[1]-1)×10 + d[0]×k
C = (d[k-1]≥1) + (d[k-2]≥1) + ... + (d[1]≥1) + (d[0]≥1) + (d[k-1]-1)×(k-1)×10^(k-2) + (d[k-2])×(k-2)×10^(k-3) + ... + (d[1])×1×10^0

可以用上面的公式计算出 S 和 C。

算法的时间复杂度为 O(k)，可以很快计算出结果。

### 回答2：
这个给定的 k 位整数，可以看做是由 k 个数字 d 组成，其中第一个数字是 d0，第二个数字是 d1，以此类推，最后一位数字是 d(k-1)。我们可以把它写成一个数列的形式：

（d0，d1，d2，...，d(k-1)）

其中，我们可以把这个数列按照倒序排序，得到如下的数列：

（d(k-1)，d(k-2)，...，d1，d0）

这个数列就是这个 k 位整数的倒序表示。例如，对于整数 12345，它的倒序表示就是 54321。

这个数列还可以转化成一个数，只需要依次把每一位数字乘上相应的权值，再相加即可。这个权值的计算方法很简单：第 i 位数字的权值是 10^(k-i-1)。例如，在整数 12345 中，第二位数字为 2，它的权值为 10^(5-2-1)=1000。因此，可以把整数 12345 转化成：1×10^4+2×10^3+3×10^2+4×10^1+5×10^0=12345。

对于这个 k 位整数，我们除了可以得到它的倒序表示和它对应的数值表示之外，还可以得到它的各位数字之和。各位数字之和可以通过把这个数列中的所有数字相加得到，即：

d0+d1+d2+...+d(k-1)

这样，我们就得到了给定的 k 位整数的三种表示方法，分别是倒序表示、数值表示和各位数字之和。

### 回答3：
题目描述：

给定一个k位整数n=d[k-1]d[k-2]…d[1]d[0] (0≤dk-1，dk-2，…，d1，d0≤9)，请编写程序求出这个数对10^9+7取模后的值。

解题思路：

这道题实际上就是求一个大数对10^9+7取模的余数，由于数非常大，我们不能直接进行求余，需要用到一些数学上的技巧。

因为我们知道(a+b)%p=(a%p+b%p)%p，所以可以想到，对于一个数n，我们可以将它拆分为若干个简单的数相加，然后对每个简单数取余之后再相加，就可以得到最终的余数，即 (d[0]*10^0 + d[1]*10^1 + … + d[k-1]*10^(k-1))%M = ((d[0] % M)*10^0 + (d[1] % M)*10^1 + … + (d[k-1] % M)*10^(k-1))%M。

由于这个式子中的幂次已经是很大的，所以这么做的话仍然会溢出，不过我们还可以做一些小优化，比如使用快速幂来计算每个10的幂次的值，这样就可以避免溢出问题。

所以我们可以写一个循环遍历每个数位，先使用快速幂计算出对应的10的幂次的值，然后将每个位数上的数对M取余之后再乘上对应的幂次值，最后再累加起来就可以得到结果了。

参考代码：