# Count of different numbers divisible by 3 that can be obtained by changing at most one digit

Last Updated : 02 Mar, 2022

Given a string str representing a number having N digits, the task is to calculate the number of ways to make the given number divisible by 3 by changing at most one digit of the number.

Examples:

Input: str[] = “23”
Output: 7
Explanation: Below are the numbers that can be made from the string which are divisible by 3 – 03, 21, 24, 27, 33, 63, 93
1.Change 2 to 0 (0+3)=3 divisible by 3
2.Change 3 to 1 (2+1)=3 divisible by 3
3 change 3 to 4 (2+4)=6 divisible by 3
4 change 2 to 3 sum is 6 divisible by 3
Similarly there are total 7 number of ways to make the given number divisible by 3

Input: str[] = “235”
Output: 9

Approach: The idea is very simple to solve this problem. Calculate the sum of digits of a given number and then for each index, remove that digit and try all possible digits from 0 to 9 and see if the sum is divisible by 3 or not. Follow the steps below to solve the problem:

• Initialize the variable sum as 0 to store the sum of digits of the number.
• Iterate over a range [0, N] using the variable i and perform the following steps:
• Add the value of digit at i-th index in the variable sum.
• Initialize the variable count as 0 to store the answer.
• If the number itself is divisible by 3 then increment count by one.
• Iterate over a range [0, N] using the variable i and perform the following steps:
• Initialize the variable remaining_sum as sum-(number.charAt(i)-48).
• Iterate over a range [0, 9] using the variable j and perform the following steps:
• Add the value of j to the variable remaining_sum and if remaining_sum is divisible by 3 and j is not equal to the digit at i-th index, then add the value of count by 1.
• After performing the above steps, print the value of count as the answer.

Below is the implementation of the above approach..

## C++

 `// C++ program for the above approach ` `#include ` `using` `namespace` `std; ` ` `  `// Function to count the number of ` `// possible numbers divisible by 3 ` `void` `findCount(string number) ` `{ ` ` `  `    ``// Calculate the sum ` `    ``int` `sum = 0; ` `    ``for` `(``int` `i = 0; i < number.length(); ++i) { ` `        ``sum += number[i] - 48; ` `    ``} ` ` `  `    ``// Store the answer ` `    ``int` `count = 0; ` ` `  `    ``// Consider the edge case when ` `    ``// the number itself is divisible by 3 ` `    ``// The count will be added by 1 ` `    ``if` `(sum % 3 == 0) ` `        ``count++; ` ` `  `    ``// Iterate over the range ` `    ``for` `(``int` `i = 0; i < number.length(); ++i) { ` ` `  `        ``// Decreasing the sum ` `        ``int` `remaining_sum = sum - (number[i] - 48); ` ` `  `        ``// Iterate over the range ` `        ``for` `(``int` `j = 0; j <= 9; ++j) { ` ` `  `            ``// Checking if the new sum ` `            ``// is divisible by 3 or not ` `            ``if` `((remaining_sum + j) % 3 == 0 ` `                ``&& j != number[i] - 48) { ` ` `  `                ``// If yes increment ` `                ``// the value of the count ` `                ``++count; ` `            ``} ` `        ``} ` `    ``} ` `    ``cout << count; ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given number ` `    ``string number = ``"235"``; ` ` `  `    ``findCount(number); ` `    ``return` `0; ` `}`

## Java

 `// Java program for the above approach ` `import` `java.io.*; ` `import` `java.util.*; ` ` `  `class` `GFG { ` ` `  `    ``// Function to count the number of ` `    ``// possible numbers divisible by 3 ` `    ``public` `static` `void` `findCount(String number) ` `    ``{ ` ` `  `        ``// Calculate the sum ` `        ``int` `sum = ``0``; ` `        ``for` `(``int` `i = ``0``; i < number.length(); ++i) { ` `            ``sum += number.charAt(i) - ``48``; ` `        ``} ` ` `  `        ``// Store the answer ` `        ``int` `count = ``0``; ` `        ``if` `(sum % ``3` `== ``0``) ` `            ``count++; ` ` `  `        ``// Iterate over the range ` `        ``for` `(``int` `i = ``0``; i < number.length(); ++i) { ` ` `  `            ``// Decreasing the sum ` `            ``int` `remaining_sum ` `                ``= sum - (number.charAt(i) - ``48``); ` ` `  `            ``// Iterate over the range ` `            ``for` `(``int` `j = ``0``; j <= ``9``; ++j) { ` ` `  `                ``// Checking if the new sum ` `                ``// is divisible by 3 or not ` `                ``if` `((remaining_sum + j) % ``3` `== ``0` `                    ``&& j != number.charAt(i) - ``48``) { ` ` `  `                    ``// If yes increment ` `                    ``// the value of the count ` `                    ``++count; ` `                ``} ` `            ``} ` `        ``} ` `        ``System.out.println(count); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `main(String[] args) ` `    ``{ ` `        ``// Given number ` `        ``String number = ``"235"``; ` ` `  `        ``findCount(number); ` `    ``} ` `}`

## Python3

 `# Python program for the above approach ` ` `  `# Function to count the number of ` `# possible numbers divisible by 3 ` ` `  ` `  `def` `findCount(number): ` ` `  `    ``# Calculate the sum ` `    ``sum` `=` `0` `    ``for` `i ``in` `range``(``len``(number)): ` `        ``sum` `+``=` `int``(number[i]) ``-` `48` ` `  `    ``# Store the answer ` `    ``count ``=` `0` `    ``if``(``sum` `%` `3` `=``=` `0``): ` `      ``count ``+``=` `1` ` `  `    ``# Iterate over the range ` `    ``for` `i ``in` `range``(``len``(number)): ` ` `  `        ``# Decreasing the sum ` `        ``remaining_sum ``=` `sum` `-` `(``int``(number[i]) ``-` `48``) ` ` `  `        ``# Iterate over the range ` `        ``for` `j ``in` `range``(``10``): ` ` `  `            ``# Checking if the new sum ` `            ``# is divisible by 3 or not ` `            ``if` `((remaining_sum ``+` `j) ``%` `3` `=``=` `0` `and` `j !``=` `int``(number[i]) ``-` `48``): ` ` `  `                ``# If yes increment ` `                ``# the value of the count ` `                ``count ``+``=` `1` ` `  `    ``print``(count) ` ` `  `# Driver Code ` ` `  ` `  `# Given number ` `number ``=` `"235"` `findCount(number) `

## C#

 `// C# program for the above approach ` `using` `System; ` `using` `System.Collections.Generic; ` ` `  `class` `GFG { ` ` `  `    ``// Function to count the number of ` `    ``// possible numbers divisible by 3 ` `    ``static` `void` `findCount(``string` `number) ` `    ``{ ` ` `  `        ``// Calculate the sum ` `        ``int` `sum = 0; ` `        ``for` `(``int` `i = 0; i < number.Length; ++i) { ` `            ``sum += (``int``)number[i] - 48; ` `        ``} ` ` `  `        ``// Store the answer ` `        ``int` `count = 0; ` `        ``if` `(sum % 3 == 0) ` `            ``count++; ` ` `  `        ``// Iterate over the range ` `        ``for` `(``int` `i = 0; i < number.Length; ++i) { ` ` `  `            ``// Decreasing the sum ` `            ``int` `remaining_sum = sum - ((``int``)number[i] - 48); ` ` `  `            ``// Iterate over the range ` `            ``for` `(``int` `j = 0; j <= 9; ++j) { ` ` `  `                ``// Checking if the new sum ` `                ``// is divisible by 3 or not ` `                ``if` `((remaining_sum + j) % 3 == 0 ` `                    ``&& j != number[i] - 48) { ` ` `  `                    ``// If yes increment ` `                    ``// the value of the count ` `                    ``++count; ` `                ``} ` `            ``} ` `        ``} ` `        ``Console.Write(count); ` `    ``} ` ` `  `    ``// Driver Code ` `    ``public` `static` `void` `Main() ` `    ``{ ` ` `  `        ``// Given number ` `        ``string` `number = ``"235"``; ` ` `  `        ``findCount(number); ` `    ``} ` `}`

## Javascript

 ``

Output

`9`

Time Complexity: O(N)
Auxiliary Space: O(1)