Count different numbers that can be generated such that there digits sum is equal to ‘n’

Given an positive integer n. Count the different numbers that can be generated using digits 1, 2, 3 and 4 such that digits sum is the number ‘n’. Here digit ‘4’ will be treated as ‘1’. For instance,
32 = 3 + 2 = 5
1341 = 1 + 3 + 1 + 1 = 6
441 = 1 + 1 + 1 = 3
Note: Answer the value in mod = 109+7

Input: 2
Output: 5
Explanation
There are only '5' numbers that can 
be made:
11 = 1 + 1 = 2
14 = 1 + 1 = 2
41 = 1 + 1 = 2
44 = 1 + 1 = 2
2  = 2

Input: 3
Output: 13
Explanation
There are only '13' numbers that can 
be made i.e., 111, 114, 141, 144, 411, 
414, 441, 444, 12, 21, 42, 24, 3.

The approach is to use Dynamic programming. The problem is same as coin change and Ways to write n as sum of two or more positive integers problems. The only difference is that, instead of iterating up-to ‘n’, iterate only from 1 to 3 as according to question, only 1, 2, 3 and 4 digits are allowed. But since ‘4’ can be replaced with ‘1’ therefore iterate through 1, 2 and 3 and double the count of ‘1’ for compensation of digit ‘4’.

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ program to count ways to write
// 'n' as sum of digits
#include<iostream>
using namespace std;
  
// Function to count 'num' as sum of
// digits(1, 2, 3, 4)
int countWays(int num)
{
    // Initialize dp[] array
    int dp[num+1];
  
    const int MOD = 1e9 + 7;
    // Base case
    dp[1] = 2;
  
    for(int i = 2; i <= num; ++i)
    {
        // Initialize the current dp[] 
        // array as '0'
        dp[i] = 0;
  
        for(int j = 1; j <= 3; ++j)
        {
            /* if i == j then there is only
               one way to write with element
               itself 'i' */
            if(i - j == 0)
               dp[i] += 1;
  
            /* If j == 1, then there exist
               two ways, one from '1' and
               other from '4' */
            else if (j == 1)
               dp[i] += dp[i-j] * 2;
  
            /* if i - j is positive then
               pick the element from 'i-j'
               element of dp[] array */
            else if(i - j > 0)
               dp[i] += dp[i-j];
  
        // Check for modulas
        if(dp[i] >= MOD)
            dp[i] %= MOD;
        }
  
    }
  
    // return the final answer
    return dp[num];
}
  
// Driver code
int main()
{
    int n = 3;
    cout << countWays(n);
      
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java program to count ways to 
// write 'n' as sum of digits
import java.io.*;
  
public class GFG
{
  
// Function to count 'num' as 
// sum of digits(1, 2, 3, 4)
static int countWays(int num)
{
      
    // Initialize dp[] array
    int []dp= new int[num + 1];
    int MOD = (int)1E9 + 7;
      
    // Base case
    dp[1] = 2;
  
    for(int i = 2; i <= num; ++i)
    {
        // Initialize the current
        // dp[] array as '0' 
        dp[i] = 0;
  
        for(int j = 1; j <= 3; ++j)
        {
            // if i == j then there is 
            // only one way to write with
            // element itself 'i'
            if(i - j == 0)
            dp[i] += 1;
  
            // If j == 1, then there exist
            // two ways, one from '1' and
            // other from '4' 
            else if (j == 1)
                dp[i] += dp[i - j] * 2;
  
            // if i - j is positive then
            // pick the element from 'i-j'
            // element of dp[] array 
            else if(i - j > 0)
                dp[i] += dp[i - j];
  
        // Check for modulas
        if(dp[i] >= MOD)
            dp[i] %= MOD;
        }
  
    }
  
    // return the final answer
    return dp[num];
}
  
    // Driver code
    static public void main (String[] args)
    {
        int n = 3;
        System.out.println(countWays(n));
      
    }
}
  
// This code is contributed by vt_m

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python3 program to count ways to write 
# 'n' as sum of digits 
  
# Function to count 'num' as sum of 
# digits(1, 2, 3, 4) 
def countWays(num): 
  
    # Initialize dp[] array 
    dp = [0] * (num + 1); 
  
    MOD = 100000000 + 7
      
    # Base case 
    dp[1] = 2
  
    for i in range(2, num + 1):
          
        # Initialize the current dp[] 
        # array as '0' 
        dp[i] = 0
  
        for j in range(1, 4): 
              
            # if i == j then there is only 
            # one way to write with element 
            # itself 'i' 
            if(i - j == 0):
                dp[i] += 1
  
            # If j == 1, then there exist 
            # two ways, one from '1' and 
            # other from '4'
            elif (j == 1):
                dp[i] += dp[i - j] * 2
  
            # if i - j is positive then 
            # pick the element from 'i-j' 
            # element of dp[] array 
            elif(i - j > 0):
                dp[i] += dp[i - j]; 
  
        # Check for modulas 
        if(dp[i] >= MOD): 
            dp[i] %= MOD; 
  
    # return the final answer 
    return dp[num]; 
  
# Driver code 
n = 3
print(countWays(n)); 
  
# This code is contributed by mits

chevron_right


C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# program to count ways to 
// write 'n' as sum of digits
using System;
  
public class GFG
{
  
// Function to count 'num' as 
// sum of digits(1, 2, 3, 4)
static int countWays(int num)
{
      
    // Initialize dp[] array
    int []dp= new int[num + 1];
    int MOD = (int)1E9 + 7;
      
    // Base case
    dp[1] = 2;
  
    for(int i = 2; i <= num; ++i)
    {
        // Initialize the current
        // dp[] array as '0' 
        dp[i] = 0;
  
        for(int j = 1; j <= 3; ++j)
        {
            // if i == j then there is 
            // only one way to write with
            // element itself 'i'
            if(i - j == 0)
            dp[i] += 1;
  
            // If j == 1, then there exist
            // two ways, one from '1' and
            // other from '4' 
            else if (j == 1)
                dp[i] += dp[i - j] * 2;
  
            // if i - j is positive then
            // pick the element from 'i-j'
            // element of dp[] array 
            else if(i - j > 0)
                dp[i] += dp[i - j];
  
        // Check for modulas
        if(dp[i] >= MOD)
            dp[i] %= MOD;
        }
  
    }
  
    // return the final answer
    return dp[num];
}
  
    // Driver code
    static public void Main (String []args)
    {
        int n = 3;
        Console.WriteLine(countWays(n));
      
    }
}
  
// This code is contributed by vt_m

chevron_right


PHP

filter_none

edit
close

play_arrow

link
brightness_4
code

<?php
// PHP program to count ways to write 
// 'n' as sum of digits 
  
// Function to count 'num' as sum of 
// digits(1, 2, 3, 4) 
function countWays($num
    // Initialize dp[] array 
    $dp[$num + 1] = array(); 
  
    $MOD = 100000000 + 7; 
      
    // Base case 
    $dp[1] = 2; 
  
    for($i = 2; $i <= $num; ++$i
    
        // Initialize the current dp[] 
        // array as '0' 
        $dp[$i] = 0; 
  
        for($j = 1; $j <= 3; ++$j
        
            /* if i == j then there is only 
            one way to write with element 
            itself 'i' */
            if($i - $j == 0) 
            $dp[$i] += 1; 
  
            /* If j == 1, then there exist 
            two ways, one from '1' and 
            other from '4' */
            else if ($j == 1) 
            $dp[$i] += $dp[$i - $j] * 2; 
  
            /* if i - j is positive then 
            pick the element from 'i-j' 
            element of dp[] array */
            else if($i - $j > 0) 
            $dp[$i] += $dp[$i - $j]; 
  
        // Check for modulas 
        if($dp[$i] >= $MOD
            $dp[$i] %= $MOD
        
    
  
    // return the final answer 
    return $dp[$num]; 
  
// Driver code 
$n = 3; 
echo countWays($n); 
  
// This code is contributed by jit_t
?>

chevron_right


Output



13

Time complexity: O(n)
Auxiliary space: O(n)

Note: Asked in Directi coding round(2014 and 2017)



My Personal Notes arrow_drop_up

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.



Improved By : vt_m, jit_t, Mithun Kumar