Sum of all duck numbers lying in range [L,R] for Q queries
Given Q queries in the form of a 2D array arr[][] in which every row consists of two numbers L and R which denotes a range [L, R], the task is to find the sum of all duck numbers lying in the given range [L, R].
A duck number is a number that has at least one 0 present in it.
Examples:
Input: Q = 2, arr[] = {{1, 13}, {99, 121}}
Output: {10, 1275}
Explanation: In first query {1, 13}, only number with 0 in it is 10.
So the sum is 10.
In Second query {99, 121}, the numbers with 0 in them are
100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 120.
So their sum is 1275Input: Q = 5, arr[] = {{1, 10}, {99, 121}, {56, 70}, {1000, 1111}, {108, 250}}
Output: {10, 1275, 130, 117105, 4762}
Approach: To solve the problem follow the below idea:
Use prefix array to store the sum of the numbers from 1 to a particular index having 0 in them.This way each query can be answered in O(1) .
Follow the steps to solve this problem:
- Initialize the pre[] array to store the prefix sum.
- Iterate from 1 to a certain big value (say 105, we can also fix this to be the maximum among the queries):
- If i has 0, then pre[i] = pre[i – 1] + i ;
- Otherwise, pre[i] = pre[i – 1];
- The answer to the query for range L to R is (pre[R] – pre[L – 1]).
Below is the implementation of the above approach:
C++14
// C++ code to implement the approach
#include <bits/stdc++.h>
using namespace std;
int pre[100001];
// Function to check duck numbers
bool CheckZero(int x)
{
string s = to_string(x);
int i = 0, n = s.size();
// To check leading zeros
while (i < n && s[i] == '0')
i++;
// Check remaining digits
while (i < n) {
if (s[i] == '0')
return true;
i++;
}
return false;
}
// Function to precompute sum of
// duck numbers from 1 to i
void precompute()
{
for (int i = 1; i < 100001; i++) {
if (CheckZero(i))
pre[i] = pre[i - 1] + i;
else
pre[i] = pre[i - 1];
}
}
// Function to print sum of duck numbers
// in range [L, R]
void printresult(int L, int R)
{
cout << pre[R] - pre[L - 1] << endl;
}
void printsumduck(int arr[][2], int Q)
{
// To calculate pre array
precompute();
for (int i = 0; i < Q; i++) {
// arr[i][0] is L and arr[i][1] is R
printresult(arr[i][0], arr[i][1]);
}
}
// Driver Code
int main()
{
int Q = 5;
int arr[][2] = { { 1, 10 },
{ 99, 121 },
{ 56, 70 },
{ 1000, 1111 },
{ 108, 250 } };
// Function call
printsumduck(arr, Q);
return 0;
}
Java
// Java code to implement the approach
import java.io.*;
class GFG {
static int[] pre= new int[100001];
// Function to check duck numbers
static boolean CheckZero(int x)
{
String s = String.valueOf(x);
int i = 0, n = s.length();
// To check leading zeros
while (i < n && s.charAt(i)== '0')
i++;
// Check remaining digits
while (i < n) {
if (s.charAt(i) == '0')
return true;
i++;
}
return false;
}
// Function to precompute sum of
// duck numbers from 1 to i
static void precompute()
{
for (int i = 1; i < 100001; i++) {
if (CheckZero(i))
pre[i] = pre[i - 1] + i;
else
pre[i] = pre[i - 1];
}
}
// Function to print sum of duck numbers
// in range [L, R]
static void printresult(int L, int R)
{
System.out.println(pre[R] - pre[L - 1]);
}
static void printsumduck(int [][]arr, int Q)
{
// To calculate pre array
precompute();
for (int i = 0; i < Q; i++) {
// arr[i][0] is L and arr[i][1] is R
printresult(arr[i][0], arr[i][1]);
}
}
// Driver Code
public static void main (String[] args) {
int Q = 5;
int [][] arr = { { 1, 10 },
{ 99, 121 },
{ 56, 70 },
{ 1000, 1111 },
{ 108, 250 } };
// Function call
printsumduck(arr, Q);
}
}
// This code is contributed by hrithikgarg03188.
Python3
# Python code to implement the above approach
pre = [0]*(100001)
def CheckZero(x):
s = str(x)
i = 0
n = len(s)
# To check leading zero
while(i < n and s[i] == '0'):
i += 1
# Check remaining digits
while(i < n):
if(s[i] == '0'):
return True
i += 1
return False
# Function to precompute sum of duck numbers from 1 to i
def precompute():
for i in range(1, 100001):
if(CheckZero(i)):
pre[i] = pre[i-1]+i
else:
pre[i] = pre[i-1]
# Function to print sum of duck numbers in range [L, R]
def printresult(L, R):
print(pre[R] - pre[L-1])
def printsumduck(arr, Q):
# To calculate pre array
precompute()
for i in range(Q):
# arr[i][0] is L and arr[i][1] is R
printresult(arr[i][0], arr[i][1])
Q = 5
arr = [[1, 10],
[99, 121],
[56, 70],
[1000, 1111],
[108, 250]]
# Function call
printsumduck(arr, Q)
# This code is contributed by lokeshmvs21.
C#
// C# code to implement the approach
using System;
class GFG {
static int[] pre= new int[100001];
// Function to check duck numbers
static bool CheckZero(int x)
{
string s = x.ToString();
int i = 0, n = s.Length;
// To check leading zeros
while (i < n && s[i]== '0')
i++;
// Check remaining digits
while (i < n) {
if (s[i] == '0')
return true;
i++;
}
return false;
}
// Function to precompute sum of
// duck numbers from 1 to i
static void precompute()
{
for (int i = 1; i < 100001; i++) {
if (CheckZero(i))
pre[i] = pre[i - 1] + i;
else
pre[i] = pre[i - 1];
}
}
// Function to print sum of duck numbers
// in range [L, R]
static void printresult(int L, int R)
{
Console.WriteLine(pre[R] - pre[L - 1]);
}
static void printsumduck(int [,]arr, int Q)
{
// To calculate pre array
precompute();
for (int i = 0; i < Q; i++) {
// arr[i][0] is L and arr[i][1] is R
printresult(arr[i, 0], arr[i, 1]);
}
}
// Driver Code
public static void Main()
{
int Q = 5;
int [,] arr = { { 1, 10 },
{ 99, 121 },
{ 56, 70 },
{ 1000, 1111 },
{ 108, 250 } };
// Function call
printsumduck(arr, Q);
}
}
// This code is contributed by code_hunt.
Javascript
<script>
// JavaScript code to implement the approach
let pre = new Array(100001).fill(0);
// Function to check duck numbers
const CheckZero = (x) => {
let s = x.toString();
let i = 0, n = s.length;
// To check leading zeros
while (i < n && s[i] == '0')
i++;
// Check remaining digits
while (i < n) {
if (s[i] == '0')
return true;
i++;
}
return false;
}
// Function to precompute sum of
// duck numbers from 1 to i
const precompute = () => {
for (let i = 1; i < 100001; i++) {
if (CheckZero(i))
pre[i] = pre[i - 1] + i;
else
pre[i] = pre[i - 1];
}
}
// Function to print sum of duck numbers
// in range [L, R]
const printresult = (L, R) => {
document.write(`${pre[R] - pre[L - 1]}<br/>`);
}
const printsumduck = (arr, Q) => {
// To calculate pre array
precompute();
for (let i = 0; i < Q; i++) {
// arr[i][0] is L and arr[i][1] is R
printresult(arr[i][0], arr[i][1]);
}
}
// Driver Code
let Q = 5;
let arr = [[1, 10],
[99, 121],
[56, 70],
[1000, 1111],
[108, 250]];
// Function call
printsumduck(arr, Q);
// This code is contributed by rakeshsahni
</script>
Output
10 1275 130 117105 4762
Time Complexity: O(max(Q, N)) where N is the maximum value till which precomputation is being done.
Auxiliary Space: O(N)
Please Login to comment...