The ultimate guide to dynamic programming interviews. Developed by FAANG engineers, it equips you with strategic DP skills, practice with real-world questions, and patterns for efficient solutions.

Some of the toughest questions in technical interviews require dynamic programming solutions. Dynamic programming (DP) is an advanced optimization technique applied to recursive solutions. However, DP is not a one-size-fits-all technique, and it requires practice to develop the ability to identify the underlying DP patterns. With a strategic approach, coding interview prep for DP problems shouldn’t take more than a few weeks.

This course starts with an introduction to DP and thoroughly discusses five DP patterns. You’ll learn to apply each pattern to several related problems, with a visual representation of the working of the pattern, and learn to appreciate the advantages of DP solutions over naive solutions.

After completing this course, you will have the skills you need to unlock even the most challenging questions, grok the coding interview, and level up your career with confidence.

This course is also available in C++, JavaScript, and Python—with more coming soon!

Grokking Dynamic Programming Interview

# Statement
Given a ribbon of length `n` and a set of possible `sizes`,  cut the ribbon in `sizes` such that `n` is achieved with the maximum number of pieces.

You have to return the maximum number of pieces that can make up `n` by using any combination of the available `sizes`. If the `n` can't be made up, return `-1`, and if `n` is `0`, return `0`.

Let's say, we have a ribbon of length $13$ and possible sizes as $[5, 3, 8]$. The ribbon length can be obtained by cutting it into one piece of length $5$ and another of length $8$ (as $5 + 8 = 13$), or, into one piece of length $3$ and two pieces of length $5$ (as $3 + 5 + 5 = 13$). As we wish to maximize the number of pieces, we choose the second option, cutting the ribbon into $3$ pieces.

**Constraints:**


* $1 \leq$ `sizes.length` $\leq 12$

* $1 \leq$ `sizes[i]` $\leq 2^{31} -1$

* $0 \leq$ `n` $\leq 1500$


# Examples

align-center

# Try it yourself
Implement your solution in the following playground:

import java.util.*;

public class RibbonCut{
    public static int countRibbonPieces(int n, int[] sizes)
    {
        // write your code here
        return -1;
    }
}

Help me debug only the function CountRibbonPieces.I don't need the corrected code.I don't want explanations or code reviews. Just provide me the exact and to-the-point error that helps me run the code successfully on the test cases provided.

Please help me understand why this code failed for the last failed test case. Please don't give me the corrected code. Just provide me exact and to-the-point advice on how to correct the code so that it runs successfully on the test cases provided. 

Your current task is to review CountRibbonPieces function And Answer the following questions: Ensure that the Unbounded Knapsack  pattern used? Does the code follow proper language guidelines. At the end, review the code.

Please provide a brief time complexity analysis of the function CountRibbonPieces.While calculating time complexity, include the time complexity of built-in Java functions invoked by the code. The Answer should be to the point and in a few lines.

Please provide a brief Space complexity analysis of the function CountRibbonPieces.While calculating space complexity, include the space complexity of built-in Java functions invoked by the code. The Answer should be to the point and in a few lines.

CustomDS

import ds_v1.DataStructure.DataStructure;
import java.util.Arrays;
import java.io.IOException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class CustomDS extends DataStructure {
    int[] values = {};


    public CustomDS() {
        //values = {};
    }
    

    public CustomDS(int[] val){
        this.values = val.clone();
        
    }

    public String toString() {
        return Arrays.toString(values);
    }

    @Override
    public CustomDS construct(String new_value, Integer type_of_ds) {
        int[] array={};
        try {
            ObjectMapper mapper = new ObjectMapper();
            array = mapper.readValue(new_value, int[].class);
            
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new CustomDS(array);

    }

    @Override
    public String traverse(Object input, Integer type_of_ds) {
        
        return input.toString();
    }

}

def evaluate_results(self) -> object:
        """
        self.__inputs is the list of inputs that are passed as input to function
        self.__actual_output is a list of outputs that is produced by the learner's code
        return : self.__edu__result object
        """
        # multiple outputs will be added at each index respectively for a single test_case
        expected_outputs = [] 
        # store the 1st expected output that should be displayed to the user 
        expected_outputs.append(self.__inputs[0] + self.__inputs[1])

        if json.dumps(self.__inputs[0] + self.__inputs[1]) == json.dumps(self.__actual_outputs[0]):
            self.__edu_result.store_result(expected_outputs, TestCaseResult.PASS)
        else:
            self.__edu_result.store_result(expected_outputs, TestCaseResult.FAIL)

        return self.__edu_result

import java.util.*;

public class Main{
    public int countRibbonPieces(int n, CustomDS sizes)
    {
        int result = RibbonCut.countRibbonPieces(n, sizes.values);

        return result;
    }
}

testcases:
  - name: "testcase 1"
    inputs:
    - 1 : 11
    - 2 : [1,2,5]
    output: 
    - 1 : 11
  - name: "testcase 2"
    inputs:
    - 1: 4
    - 2: [2]
    output:
    - 1 : 2
  - name: "testcase 3"
    inputs:
    - 1: 3
    - 2: [5]
    output:
    - 1 : -1
  - name: "testcase 4"
    inputs:
    - 1: 0
    - 2: [1,2,5]
    output:
    - 1 : 0
  - name: "testcase 5"
    inputs:
    - 1: 23
    - 2: [2,3,4,6,8]
    output:
    - 1 : 11
  - name: "testcase 6"
    inputs:
    - 1 : 11
    - 2 : [1, 4, 6, 9]
    output: 
    - 1 : 11
  - name: "testcase 7"
    inputs:
    - 1: 27
    - 2: [6, 7, 8]
    output:
    - 1 : 4
  - name: "testcase 8"
    inputs:
    - 1: 41
    - 2: [1, 2, 3, 4, 5]
    output:
    - 1 : 41
  - name: "testcase 9"
    inputs:
    - 1: 52
    - 2: [14, 15, 18, 20]
    output:
    - 1 : 3
  - name: "testcase 9"
    inputs:
    - 1: 1500
    - 2: [2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
    output:
    - 1 : 750

testcases:
  - name: "testcase 1"
    inputs:
    - 1 : 11
    - 2 : [1,2,5]
    output: 
    - 1 : 11
  - name: "testcase 2"
    inputs:
    - 1: 4
    - 2: [2]
    output:
    - 1 : 2
  - name: "testcase 3"
    inputs:
    - 1: 3
    - 2: [5]
    output:
    - 1 : -1
  - name: "testcase 4"
    inputs:
    - 1: 0
    - 2: [1,2,5]
    output:
    - 1 : 0
  - name: "testcase 5"
    inputs:
    - 1: 23
    - 2: [2,3,4,6,8]
    output:
    - 1 : 11

def sum(input_1, input_2):
    return input_1+input_2

def validate_inputs(self) -> None:
        """
        self.__inputs is the list of inputs that are passed as input to function
        store the result using the self.store_result(error_msg, status)
        return : void
        """
        # inputs can be accessed using self.__inputs starting from 0 to len(self.__inputs) - 1
        if self.__inputs[0] > 1000:
            self.store_result ("input 1 should be less than 1000", ValidationFunction.FAIL)
        elif self.__inputs[1] > 1000:
            self.store_result("input 2 should be less than 1000", ValidationFunction.FAIL)
        else:
            self.store_result("", ValidationFunction.PASS)


>**Note:** If you clicked the "Submit" button and the code timed out, this means that your solution needs to be optimized in terms of running time.
>
>**Hint:** Use dynamic programming and see the magic.
# Solution
We will first explore the naive recursive solution to this problem and then see how it can be improved using the Unbounded Knapsack dynamic programming pattern.
## Naive approach
The naive approach is to generate all possible combinations of given ribbon sizes such that in each combination, the sum of ribbon sizes is equal to `n`. This can be achieved by recursively reducing the current ribbon length by available sizes until it reaches `0`. From these combinations, choose the one with the maximum number of ribbon pieces and return that number. If the sum of any combinations is not equal to `n` then return `-1`.



For example, we have a ribbon of length $3$. Given below is the possible ribbon sizes:

* **n:** $3$
* **sizes:** $[1, 2, 3]$

Let's look at all the possible combinations of ribbon sizes whose sum is equal to the `n`, and we will select the maximum count of ribbon sizes out of them, that is $3$:

      
*   $1, 2$ => $(1+2)$ $= 3$  
*   $1, 1, 1$ => $(1+1+1)$ $= 3$ 

Below is the recursion tree for the above example, where at each level `i`, the left subtree indicates the inclusion of the `sizes[i]`, and the right subtree indicates the exclusion of the `sizes[i]`.


Let's solve the Maximum Ribbon Cut problem using Dynamic Programming.

Getting Started

0/1 Knapsack

Unbounded Knapsack

Recursive Numbers

Longest Common Substring

Palindromic Subsequence

Conclusion

Maximum Ribbon Cut

Statement

Examples

Try it yourself

No.	n	sizes	Count of Pieces
1	5	[1, 2, 3]	5
2	13	[5, 3, 8]	3
3	3	[5]	-1