Friday, May 17, 2024
 Popular · Latest · Hot · Upcoming
22
rated 0 times [  28] [ 6]  / answers: 1 / hits: 7150  / 5 Years ago, mon, september 16, 2019, 12:00:00

Hi I'm trying to solve this recursion challenge, could anyone give me a hand to complete it please?



This is the challenge:




Have the function PlusMinus(num) read the num parameter being passed which will be a combination of 1 or more single digits, and determine if it's possible to separate the digits with either a plus or minus sign to get the final expression to equal zero. For example: if num is 35132 then it's possible to separate the digits the following way, 3 - 5 + 1 + 3 - 2, and this expression equals zero. Your program should return a string of the signs you used, so for this example your program should return -++-. If it's not possible to get the digit expression to equal zero, return the string not possible.
If there are multiple ways to get the final expression to equal zero, choose the one that contains more minus characters. For example: if num is 26712 your program should return -+-- and not +-+-.
Sample Test Cases:
Input: 199
Output: not possible
Input: 26712
Output: -+--




This is what I have tried:





const plusMinus = (num) => {
let arr = num.toString().split('').map(num => parseInt(num));

return plusMinusRec(arr, 0);

function plusMinusRec(arr, target){
if(arr.length == 1){
if(arr[0] == target){
return
} else {
return not possible;
}
}

let s1 = plusMinusRec(arr.slice(1), arr[0]);
if(s1 != not possible){
return - + s1;
}
let s2 = plusMinusRec(arr.slice(1), arr[0] * -1);
if(s2 != not possible){
return + + s2;
}
return not possible;
}
}

plusMinus(35132);




More From » algorithm

 Answers
11

I don't think you're keeping track of the sum as you go deeper into the recursive calls. You either have +arr[0] or -arr[0] as your target for each subsequent recursive call, which does not take into account the sum so far.



But you have have the right idea with this backtracking approach. If you pass in the sum so far to each subsequent call, you can check at the end whether the total is 0, and add the plus-minus combination that that path took to your list of possible combinations. Finally, you can return the combination with the most minuses.





function PlusMinus(num) {
let arr = num.split('').map(num => parseInt(num));
let possibilities = [];

const traverse = ([d, ...rest], combination, sum) => {
if (rest.length === 0) {
if (sum + d === 0) possibilities.push(combination + '+');
if (sum - d === 0) possibilities.push(combination + '-');
} else {
traverse(rest, combination + '+', sum + d);
traverse(rest, combination + '-', sum - d);
}
}

const maxMinuses = (combinations) => {
return combinations.reduce((acc, curr) => [...acc].filter(c => c === '-').length > [...curr].filter(c => c === '-').length ? acc : curr);
}

traverse(arr.slice(1), '', arr[0]);
return possibilities.length ? maxMinuses(possibilities) : 'not possible';
}

console.log(PlusMinus('35132'));
console.log(PlusMinus('199'));
console.log(PlusMinus('26712'));




[#6242] Thursday, September 12, 2019, 5 Years  [reply] [flag answer]
Only authorized users can answer the question. Please sign in first, or register a free account.
kieraelsies

Total Points: 718
Total Questions: 103
Total Answers: 104

Location: England
Member since Sun, May 21, 2023
1 Year ago
kieraelsies questions
Tue, Aug 3, 21, 00:00, 3 Years ago
Tue, Feb 23, 21, 00:00, 3 Years ago
Thu, Nov 12, 20, 00:00, 4 Years ago
Wed, Sep 9, 20, 00:00, 4 Years ago
Fri, Sep 13, 19, 00:00, 5 Years ago
;