Count numbers divisible by K in a range with Fibonacci digit sum for Q queries

Given an array arr[][] containing Q queries and an integer K where each query consists of a range [L, R], the task is to find the count of integers in the given range whose digit sum is a Fibonacci number and divisible by K.

Examples:

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.

Approach: The idea is to use hashing to precompute and store the Fibonacci nodes up to the maximum value in the given range, to make the checking easy and efficient (in O(1) time).



  • After precomputation, mark all the integers from 1 to maxVal which are divisible by K and are fibonacci.
  • Find the prefix sum of the marked array.
  • Answer the given queries by prefix[right] – prefix[left – 1].

Below is the implementation of the above approach:

C/C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count the integers
// in a range [L, R] such that
// their digit sum is Fibonacci
// and divisible by K
  
#include <bits/stdc++.h>
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<vector<int> >& query)
{
    // Precompute the results
    precompute(k);
  
    vector<int> 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<vector<int> > query
        = { { 1, 11 },
            { 5, 15 },
            { 2, 24 } };
    int k = 2, q = query.size();
  
    performQueries(k, q, query);
  
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# 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

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

3
2
5

competitive-programming-img




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.