📌  相关文章
📜  对Q查询的Fibonacci数字总和范围内的K可整除的数字进行计数

📅  最后修改于: 2021-06-27 00:33:47             🧑  作者: Mango

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

例子:

方法:想法是使用散列来预先计算和存储Fibonacci节点,直到给定范围内的最大值,以使检查变得容易和高效(在O(1)时间内)。

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

下面是上述方法的实现:

C/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


输出:
3
2
5

如果您希望与行业专家一起参加现场课程,请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。