Summation of `multiples of 5` which sums to a given target

[Deepak Lal]

Write a java function such that given an array of ints, is it possible to choose a group of some of the ints, such that the group sums to the given target with these additional constraints: all multiples of 5 in the array must be included in the group. If the value immediately following a multiple of 5 is 1, it must not be chosen.

groupSum5(0, {2, 5, 10, 4}, 19) => true
groupSum5(0, {2, 5, 10, 4}, 17) => true
groupSum5(0, {2, 5, 10, 4}, 12) => false

I have written the partial code as below but is not working properly.could you check what might be wrong.

public boolean groupSum5(int start, int[] nums, int target) {
   start = 0;
   boolean flag = false;
   for(int i=0;i<nums.length;i++){
       if(nums[i]%5==0){
        start+=nums[i];
       }else{
             if(nums[i] == target){ flag = true; return flag;}
             if(nums[i] != target){
             start+=nums[i];
             }
             if(start == target) { flag = true; return flag;}
             if(nums[i]== 5 && nums[i+1]==1) continue;
        }
  }
return flag;
}

Im unable to proceed further.Code fix provided will be appreciated.>

[fred rosenberger]

What exactly do you mean by "Not working properly"? Please tell us the details. What have you tried that works, what have you tried that doesn't work, etc?

[Joanne Neal]

Two problems that I can see

1. At line 8 and 12 you return true if the target has been matched, yet this doesn't allow for numbers later in the list being multiples of 5. You need to get the sum of all your multiples of 5 before you even begin looking at the other numbers.

2. Line 13 will only skip the value 5, not all multiples of 5.

Fix those and then if you still have problems, see Fred's post

[Deepak Lal]

I have refined my code as below

public boolean groupSum5(int start, int[] nums, int target) {
  start = 0;
  boolean flag = false;
  for(int i=0;i<nums.length;i++){
      if(nums[i]%5==0){
        start+=nums[i];              
      }else if((start != target) && (start%5==0)){
           start+=nums[i];       
      }else if(start == target){
           flag = true; 
           return flag;
      }else if((nums[i]%5==0) && (nums[i+1]==1)){
        continue;                
      }    
  }
  return flag;
}

All the test cases are still failing.could you help me out to fix this piece of code.>

[Joanne Neal]

You still haven't done anything about the first problem I mentioned. You need a separate loop that sums all the values that are multiples of 5. If this sum is greater than the target value you can then immediately return false without checking the other numbers. If not you then use it as a base value when checking the other numbers.

What are you doing on line 7 ? You only increase the value of start if its current value is a multiple of 5.

Lines 10 and 11 can be replaced by

return true;

[Marius Zilenas]

This is recursive solution for the given problem of summing ints with 5's multiples required and 1's excluded if after 5's multiples.

public boolean groupSum5(int start, int[] nums, int target)
{
    if (start >= nums.length)
    {
        return 0 == target;
    }
    
    if (0 == nums[start] % 5)
    {
        return groupSum5(start+1, nums, target - nums[start]);
    }
            
    if (1 == nums[start] && 0 <= start - 1 && 0 == nums[start-1] % 5)
    {
        return groupSum5(start+1, nums, target);
    }

    if (groupSum5(start+1, nums, target - nums[start]))
    {
        return true;
    }
            
    if (groupSum5(start+1, nums, target))
    {
        return true;
    }   
    
    
    return false;  
}

[Campbell Ritchie]

Welcome to the Ranch and thank you for that solution.

[Mike. J. Thompson]

The question says you need to decide if any [i]subset[i] of the applicable numbers sum to the target value.

It is not sufficient to sum the numbers in sequence until the sum is greater than or equal to the target value because this will not check all of the subsets. You need to:

* Find the set of numbers that match the rules.
* Create a list of all non-empty sub-sets of those numbers.
* Sum each subset until you find one that sums to the target value.