feat: add solutions for lc No.3855 (#5059)

Author: yanglbme

solution/3800-3899/3855.Sum of K-Digit Numbers in a Range/README.md

@@ -84,32 +84,223 @@ edit_url: https://github.com/doocs/leetcode/edit/main/solution/3800-3899/3855.Su
 
 <!-- solution:start -->
 
-### 方法一
+### 方法一：数学 + 快速幂
+
+我们从低位到高位枚举每一位数字 $x$，假设当前为第 $i$ 位（$i$ 从 $0$ 开始），相当于填了一个数字 $x \cdot 10^i$，其余的 $k - 1$ 位数字，每一位都有 $r - l + 1$ 个选择，所以当前位的贡献为 $x \cdot 10^i \cdot (r - l + 1)^{k - 1}$。对于 $x$ 的选择范围是 $[l, r]$，所以 $x$ 的总和为 $\frac{(l + r) \cdot (r - l + 1)}{2}$，因此所有数字的总和为：
+
+$$
+\begin{aligned}
+&\sum_{i = 0}^{k - 1} \frac{(l + r) \cdot (r - l + 1)}{2} \cdot (r - l + 1)^{k - 1} \cdot 10^i \\
+= &\frac{(l + r) \cdot (r - l + 1)}{2} \cdot (r - l + 1)^{k - 1} \cdot \frac{10^k - 1}{9}
+\end{aligned}
+$$
+
+由于 $k$ 的范围是 $[1, 10^9]$，我们需要使用快速幂来计算 $(r - l + 1)^{k - 1}$ 和 $10^k$，另外除法需要使用费马小定理来计算 $9$ 的逆元。
+
+时间复杂度 $O(\log k)$，空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 
 #### Python3
 
 ```python
+class Solution:
+    def sumOfNumbers(self, l: int, r: int, k: int) -> int:
+        mod = 10**9 + 7
+
+        n = r - l + 1
+
+        # ((l + r) * (r - l + 1) // 2) % mod
+        total = (l + r) * n // 2 % mod
 
+        # pow(r - l + 1, k - 1, mod)
+        part1 = pow(n % mod, k - 1, mod)
+
+        # (pow(10, k, mod) - 1)
+        part2 = (pow(10, k, mod) - 1) % mod
+
+        # Fermat inverse of 9
+        inv9 = pow(9, mod - 2, mod)
+
+        ans = total
+        ans = ans * part1 % mod
+        ans = ans * part2 % mod
+        ans = ans * inv9 % mod
+
+        return ans
 ```
 
 #### Java
 
 ```java
-
+class Solution {
+    public int sumOfNumbers(int l, int r, int k) {
+        final int mod = 1_000_000_007;
+
+        long n = r - l + 1L;
+
+        // ((l + r) * (r - l + 1) // 2) % mod
+        long sum = (long) (l + r) * n / 2 % mod;
+
+        // pow(r - l + 1, k - 1, mod)
+        long part1 = qpow(n % mod, k - 1, mod);
+
+        // (pow(10, k, mod) - 1)
+        long part2 = (qpow(10, k, mod) - 1 + mod) % mod;
+
+        // pow(9, mod - 2, mod)  (Fermat inverse of 9)
+        long inv9 = qpow(9, mod - 2, mod);
+
+        long ans = sum;
+        ans = ans * part1 % mod;
+        ans = ans * part2 % mod;
+        ans = ans * inv9 % mod;
+
+        return (int) ans;
+    }
+
+    private int qpow(long a, int n, int mod) {
+        long ans = 1;
+        a %= mod;
+        for (; n > 0; n >>= 1) {
+            if ((n & 1) == 1) {
+                ans = ans * a % mod;
+            }
+            a = a * a % mod;
+        }
+        return (int) ans;
+    }
+}
 ```
 
 #### C++
 
 ```cpp
-
+class Solution {
+public:
+    int sumOfNumbers(int l, int r, int k) {
+        const int mod = 1'000'000'007;
+
+        long long n = 1LL * r - l + 1;
+
+        // ((l + r) * (r - l + 1) / 2) % mod
+        long long sum = 1LL * (l + r) * n / 2 % mod;
+
+        // pow(r - l + 1, k - 1, mod)
+        long long part1 = qpow(n % mod, k - 1, mod);
+
+        // (pow(10, k, mod) - 1)
+        long long part2 = (qpow(10, k, mod) - 1 + mod) % mod;
+
+        // Fermat inverse of 9
+        long long inv9 = qpow(9, mod - 2, mod);
+
+        long long ans = sum;
+        ans = ans * part1 % mod;
+        ans = ans * part2 % mod;
+        ans = ans * inv9 % mod;
+
+        return (int) ans;
+    }
+
+private:
+    long long qpow(long long a, long long n, int mod) {
+        long long ans = 1;
+        a %= mod;
+        while (n > 0) {
+            if (n & 1) {
+                ans = ans * a % mod;
+            }
+            a = a * a % mod;
+            n >>= 1;
+        }
+        return ans;
+    }
+};
 ```
 
 #### Go
 
 ```go
+func sumOfNumbers(l int, r int, k int) int {
+	const mod int64 = 1_000_000_007
+
+	n := int64(r - l + 1)
+
+	// ((l + r) * (r - l + 1) / 2) % mod
+	sum := int64(l+r) * n / 2 % mod
+
+	// pow(r - l + 1, k - 1, mod)
+	part1 := qpow(n%mod, int64(k-1), mod)
+
+	// (pow(10, k, mod) - 1)
+	part2 := (qpow(10, int64(k), mod) - 1 + mod) % mod
+
+	// Fermat inverse of 9
+	inv9 := qpow(9, mod-2, mod)
+
+	ans := sum
+	ans = ans * part1 % mod
+	ans = ans * part2 % mod
+	ans = ans * inv9 % mod
+
+	return int(ans)
+}
+
+func qpow(a int64, n int64, mod int64) int64 {
+	a %= mod
+	var ans int64 = 1
+	for n > 0 {
+		if n&1 == 1 {
+			ans = ans * a % mod
+		}
+		a = a * a % mod
+		n >>= 1
+	}
+	return ans
+}
+```
+
+#### TypeScript
+
+```ts
+function sumOfNumbers(l: number, r: number, k: number): number {
+    const mod = 1_000_000_007n;
+
+    const n = BigInt(r - l + 1);
+
+    // ((l + r) * (r - l + 1) / 2) % mod
+    const sum = ((BigInt(l + r) * n) / 2n) % mod;
+
+    // pow(r - l + 1, k - 1, mod)
+    const part1 = qpow(n % mod, BigInt(k - 1), mod);
+
+    // (pow(10, k, mod) - 1)
+    const part2 = (qpow(10n, BigInt(k), mod) - 1n + mod) % mod;
+
+    // Fermat inverse of 9
+    const inv9 = qpow(9n, mod - 2n, mod);
+
+    let ans = sum;
+    ans = (ans * part1) % mod;
+    ans = (ans * part2) % mod;
+    ans = (ans * inv9) % mod;
+
+    return Number(ans);
+}
 
+function qpow(a: bigint, n: bigint, mod: bigint): bigint {
+    a %= mod;
+    let ans = 1n;
+    while (n > 0n) {
+        if ((n & 1n) === 1n) {
+            ans = (ans * a) % mod;
+        }
+        a = (a * a) % mod;
+        n >>= 1n;
+    }
+    return ans;
+}
 ```
 
 <!-- tabs:end -->