对 Q 查询的斐波那契数字总和范围内可被 K 整除的数字进行计数

给定一个包含Q 个查询的数组arr[][]和一个整数K ，其中每个查询由一个范围[L, R] 组成，任务是在给定范围内找到整数的计数，其数字和是斐波那契数并且可整除由K 。
例子：

Input: arr[][] = { {1, 11}, {5, 15}, {2, 24} }, K = 2 
Output: 3 2 5 
Explanation: 
For query 1: 2, 8 and 11 are the numbers in the given range whose digit sum is Fibonacci and divisible by K. 
For query 2: 8 and 11 are the numbers in the given range whose digit sum is Fibonacci and divisible by K. 
For query 3: 2, 8, 11, 17 and 20 are the numbers in the given range whose digit sum is Fibonacci and divisible by K.
Input: arr[][] = { {2, 17}, {3, 24} }, K = 3 
Output: 4 4 
Explanation: 
For query 1: 2, 8, 11 and 17 are the numbers in the given range whose digit sum is Fibonacci and divisible by K. 
For query 2: 8, 11, 17 and 20 are the numbers in the given range whose digit sum is Fibonacci and divisible by K. 
 

方法：这个想法是使用散列来预先计算和存储斐波那契节点，直到给定范围内的最大值，使检查变得容易和高效（在 O(1) 时间内）。

• 预计算后，标记从1到maxVal 的所有整数，这些整数可以被K整除，并且是斐波那契数列。
• 找到标记数组的前缀和。
• 通过prefix[right] – prefix[left – 1]回答给定的查询。

下面是上述方法的实现：

C++

// C++ program to count the integers
// in a range [L, R] such that
// their digit sum is Fibonacci
// and divisible by K
 
#include 
using namespace std;
 
const int maxSize = 1e5 + 5;
bool isFib[maxSize];
int prefix[maxSize];
 
// Function to return the
// digit sum of a number
int digitSum(int num)
{
    int s = 0;
    while (num != 0) {
        s = s + num % 10;
        num = num / 10;
    }
    return s;
}
 
// Function to generate all the Fibonacci
// numbers upto maxSize
void generateFibonacci()
{
    memset(isFib, false, sizeof(isFib));
 
    // Adding the first two Fibonacci
    // numbers in the set
    int prev = 0, curr = 1;
    isFib[prev] = isFib[curr] = true;
 
    // Computing the remaining Fibonacci
    // numbers based on the previous
    // two Fibonacci numbers
    while (curr < maxSize) {
        int temp = curr + prev;
        isFib[temp] = true;
        prev = curr;
        curr = temp;
    }
}
 
// Pre-Computation till maxSize
// and for a given K
void precompute(int k)
{
    generateFibonacci();
 
    for (int i = 1; i < maxSize; i++) {
 
        // Getting the digit sum
        int sum = digitSum(i);
 
        // Check if the digit sum
        // is Fibonacci and divisible by k
        if (isFib[sum] == true
            && sum % k == 0) {
            prefix[i]++;
        }
    }
 
    // Taking Prefix Sum
    for (int i = 1; i < maxSize; i++) {
        prefix[i] = prefix[i]
                    + prefix[i - 1];
    }
}
 
// Function to perform the queries
void performQueries(
    int k, int q,
    vector >& query)
{
    // Precompute the results
    precompute(k);
 
    vector ans;
 
    // Iterating through the queries
    for (int i = 0; i < q; i++) {
 
        int l = query[i][0],
            r = query[i][1];
 
        // Getting count of range
        // in range [L, R]
        int cnt = prefix[r]
                - prefix[l - 1];
        cout << cnt << endl;
    }
}
 
// Driver code
int main()
{
    vector > query
        = { { 1, 11 },
            { 5, 15 },
            { 2, 24 } };
    int k = 2, q = query.size();
 
    performQueries(k, q, query);
 
    return 0;
}

Java

// Java program to count the integers
// in a range [L, R] such that
// their digit sum is Fibonacci
// and divisible by K
import java.util.*;
 
class GFG{
  
static int maxSize = (int) (1e5 + 5);
static boolean []isFib  = new boolean[maxSize];
static int []prefix = new int[maxSize];
  
// Function to return the
// digit sum of a number
static int digitSum(int num)
{
    int s = 0;
    while (num != 0) {
        s = s + num % 10;
        num = num / 10;
    }
    return s;
}
  
// Function to generate all the Fibonacci
// numbers upto maxSize
static void generateFibonacci()
{
    Arrays.fill(isFib, false);
  
    // Adding the first two Fibonacci
    // numbers in the set
    int prev = 0, curr = 1;
    isFib[prev] = isFib[curr] = true;
  
    // Computing the remaining Fibonacci
    // numbers based on the previous
    // two Fibonacci numbers
    while (curr < maxSize) {
        int temp = curr + prev;
        if(temp < maxSize)
            isFib[temp] = true;
        prev = curr;
        curr = temp;
    }
}
  
// Pre-Computation till maxSize
// and for a given K
static void precompute(int k)
{
    generateFibonacci();
  
    for (int i = 1; i < maxSize; i++) {
  
        // Getting the digit sum
        int sum = digitSum(i);
  
        // Check if the digit sum
        // is Fibonacci and divisible by k
        if (isFib[sum] == true
            && sum % k == 0) {
            prefix[i]++;
        }
    }
  
    // Taking Prefix Sum
    for (int i = 1; i < maxSize; i++) {
        prefix[i] = prefix[i]
                    + prefix[i - 1];
    }
}
  
// Function to perform the queries
static void performQueries(
    int k, int q,
    int[][] query)
{
    // Precompute the results
    precompute(k);
 
    // Iterating through the queries
    for (int i = 0; i < q; i++) {
  
        int l = query[i][0],
            r = query[i][1];
  
        // Getting count of range
        // in range [L, R]
        int cnt = prefix[r]
                  - prefix[l - 1];
        System.out.print(cnt +"\n");
    }
}
  
// Driver code
public static void main(String[] args)
{
 
    int [][]query
        = { { 1, 11 },
            { 5, 15 },
            { 2, 24 } };
    int k = 2, q = query.length;
  
    performQueries(k, q, query);
}
}
 
// This code is contributed by Princi Singh

Python3

# Python 3 program to count the integers
# in a range [L, R] such that
# their digit sum is Fibonacci
# and divisible by K
maxSize = 100005
isFib = [False]*(maxSize)
prefix = [0]*maxSize
 
# Function to return the
# digit sum of a number
def digitSum(num):
    s = 0
    while (num != 0):
        s = s + num % 10
        num = num // 10
     
    return s
 
# Function to generate all the Fibonacci
# numbers upto maxSize
def generateFibonacci():
 
    global isFib
 
    # Adding the first two Fibonacci
    # numbers in the set
    prev = 0
    curr = 1
    isFib[prev] = True
    isFib[curr] = True
 
    # Computing the remaining Fibonacci
    # numbers based on the previous
    # two Fibonacci numbers
    while (curr < maxSize):
        temp = curr + prev
        if temp < maxSize:
            isFib[temp] = True
        prev = curr
        curr = temp
 
# Pre-Computation till maxSize
# and for a given K
def precompute(k):
 
    generateFibonacci()
    global prefix
     
    for i in range(1, maxSize):
 
        # Getting the digit sum
        sum = digitSum(i)
 
        # Check if the digit sum
        # is Fibonacci and divisible by k
        if (isFib[sum] == True
            and sum % k == 0):
            prefix[i] += 1
 
    # Taking Prefix Sum
    for i in range(1, maxSize):
        prefix[i] = prefix[i]+ prefix[i - 1]
 
# Function to perform the queries
def performQueries(k, q,query):
     
    # Precompute the results
    precompute(k)
 
    # Iterating through the queries
    for i in range(q):
 
        l = query[i][0]
        r = query[i][1]
 
        # Getting count of range
        # in range [L, R]
        cnt = prefix[r]- prefix[l - 1]
        print(cnt)
 
# Driver code
if __name__ == "__main__":
    query = [ [ 1, 11 ],
            [ 5, 15 ],
            [ 2, 24 ] ]
    k = 2
    q = len(query)
 
    performQueries(k, q, query)
 
# This code is contributed by chitranayal

C#

// C# program to count the integers
// in a range [L, R] such that
// their digit sum is Fibonacci
// and divisible by K
using System;
 
class GFG{
   
static int maxSize = (int) (1e5 + 5);
static bool []isFib  = new bool[maxSize];
static int []prefix = new int[maxSize];
   
// Function to return the
// digit sum of a number
static int digitSum(int num)
{
    int s = 0;
    while (num != 0) {
        s = s + num % 10;
        num = num / 10;
    }
    return s;
}
   
// Function to generate all the Fibonacci
// numbers upto maxSize
static void generateFibonacci()
{
 
    // Adding the first two Fibonacci
    // numbers in the set
    int prev = 0, curr = 1;
    isFib[prev] = isFib[curr] = true;
   
    // Computing the remaining Fibonacci
    // numbers based on the previous
    // two Fibonacci numbers
    while (curr < maxSize) {
        int temp = curr + prev;
        if(temp < maxSize)
            isFib[temp] = true;
        prev = curr;
        curr = temp;
    }
}
   
// Pre-Computation till maxSize
// and for a given K
static void precompute(int k)
{
    generateFibonacci();
   
    for (int i = 1; i < maxSize; i++) {
   
        // Getting the digit sum
        int sum = digitSum(i);
   
        // Check if the digit sum
        // is Fibonacci and divisible by k
        if (isFib[sum] == true
            && sum % k == 0) {
            prefix[i]++;
        }
    }
   
    // Taking Prefix Sum
    for (int i = 1; i < maxSize; i++) {
        prefix[i] = prefix[i]
                    + prefix[i - 1];
    }
}
   
// Function to perform the queries
static void performQueries(
    int k, int q,
    int[,] query)
{
    // Precompute the results
    precompute(k);
  
    // Iterating through the queries
    for (int i = 0; i < q; i++) {
   
        int l = query[i, 0],
            r = query[i, 1];
   
        // Getting count of range
        // in range [L, R]
        int cnt = prefix[r]
                  - prefix[l - 1];
        Console.Write(cnt +"\n");
    }
}
   
// Driver code
public static void Main(String[] args)
{
  
    int [,]query
        = { { 1, 11 },
            { 5, 15 },
            { 2, 24 } };
    int k = 2, q = query.GetLength(0);
   
    performQueries(k, q, query);
}
}
 
// This code is contributed by PrinciRaj1992

Javascript

 
// Javascript  program to count the integers
// in a range [L, R] such that
// their digit sum is Fibonacci
// and divisible by K
 
let maxSize = (1e5 + 5);
let isFib  = Array.from({length: maxSize}, (_, i) => 0);
let prefix = Array.from({length: maxSize}, (_, i) => 0);
    
// Function to return the
// digit sum of a number
function digitSum(num)
{
    let s = 0;
    while (num != 0) {
        s = s + num % 10;
        num = Math.floor(num / 10);
    }
    return s;
}
    
// Function to generate all the Fibonacci
// numbers upto maxSize
function generateFibonacci()
{
    isFib = Array.from({length: maxSize}, (_, i) => false);
    
    // Adding the first two Fibonacci
    // numbers in the set
    let prev = 0, curr = 1;
    isFib[prev] = isFib[curr] = true;
    
    // Computing the remaining Fibonacci
    // numbers based on the previous
    // two Fibonacci numbers
    while (curr < maxSize) {
        let temp = curr + prev;
        if(temp < maxSize)
            isFib[temp] = true;
        prev = curr;
        curr = temp;
    }
}
    
// Pre-Computation till maxSize
// and for a given K
function precompute(k)
{
    generateFibonacci();
    
    for (let i = 1; i < maxSize; i++) {
    
        // Getting the digit sum
        let sum = digitSum(i);
    
        // Check if the digit sum
        // is Fibonacci and divisible by k
        if (isFib[sum] == true
            && sum % k == 0) {
            prefix[i]++;
        }
    }
    
    // Taking Prefix Sum
    for (let i = 1; i < maxSize; i++) {
        prefix[i] = prefix[i]
                    + prefix[i - 1];
    }
}
    
// Function to perform the queries
function performQueries(
    k, q, query)
{
    // Precompute the results
    precompute(k);
   
    // Iterating through the queries
    for (let i = 0; i < q; i++) {
    
        let l = query[i][0],
            r = query[i][1];
    
        // Getting count of range
        // in range [L, R]
        let cnt = prefix[r]
                  - prefix[l - 1];
        document.write(cnt +"<br/>");
    }
}
 
// Driver code
      let query
        = [[ 1, 11 ],
            [ 5, 15 ],
            [ 2, 24 ]];
    let k = 2, q = query.length;
    
    performQueries(k, q, query);
 
 // This code is contributed by sanjoy_62.                                                                              

输出：

3
2
5