我们如何获得两次递归调用的最小值，一个是加法，另一个是减法？

Question

We are doing this programming exercise: a Office Space #2 - Closest Three from Twos . The statement is:

You like listening to music at the office.

You frequently have to change the volume in your headphones thanks to your talkative coworkers, and you find yourself using the + and - on your keyboard to do so. The keys increase and decrease the volume by 2 with each keystroke. There's just one problem - you prefer numbers that are divisible by 3.

Sometimes your coworkers are loud, and other times they're at lunch or late to work - Adjust the volume accordingly!

Write a function that takes in current volume and outputs how many times you will have to press the - or + key on your keyboard to make the volume a number that is divisible by three.

The music can't go lower than 0 volume on this plane of existance.

ex: volume = 8 : output = 1 (one stroke of the - key would take you to 6, which is divisible by 3, rather than the two strokes of the + key to get to 12)

We have written the following code:

function musicalOCD(volume) {
  console.log("\n\nvolume: "+volume);
  if(volume%3==0) return 0;
  return Math.min(1+musicalOCD(volume+2),1+musicalOCD(volume-2));
}

However it only passes the base case test, when volume is divisible by 13.

If we pass in other volume, it outputs:

RangeError: Maximum call stack size exceeded
    at Socket.Readable.removeListener (_stream_readable.js:852:47)
    at write (console.js:172:12)
    at Console.log (console.js:200:3)
    at musicalOCD (test.js:5:11)
    at musicalOCD (test.js:7:21)

Being the trace:

volume: 2


volume: 4


volume: 6


volume: 2


volume: 4


volume: 6

So we could write the code to just do recursive calls adding values to volume:

function musicalOCD(volume) {
  console.log("\n\nvolume: "+volume);
  if(volume%3==0) return 0;
  return 1+musicalOCD(volume+2);
}

However in the following tests:

describe("Fixed tests", function() {
  const testing = (volume, exp) => it(`Testing for ${volume}`, () => assert.strictEqual(musicalOCD(volume), exp));
  testing(4, 1);
  testing(12, 0);
  testing(20, 1);
  testing(22, 1);
  testing(68, 1);
});

Testing for 20 and 68 would output 2 instead of 1...

And if we do the reverse:

function musicalOCD(volume) {
  console.log("\n\nvolume: "+volume);
  if(volume%3==0) return 0;
  return 1+musicalOCD(volume-2);
}

Then testing for 22 and 4 would output 2 instead of 1...

How could we combine both recursive calls in a general answer?

We have read:

• https://javascript.info/recursion
• https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Math/min

Answer 1

 const testing = (volume, exp) => { console.assert(musicalOCD(volume) === exp, 'Testing for ${volume} - failure'); }; testing(4, 1); testing(12, 0); testing(20, 1); testing(22, 1); testing(68, 1); console.log('Run tests - done'); function musicalOCD(volume) { return Math.min( // <------- will return min value of two tests _musicalOCD(volume, +2), _musicalOCD(volume, -2) ); } function _musicalOCD(volume, mod) { if (volume < 0) return 0; if (volume >= 100) return 0; //console.log("\\n\\nvolume: " + volume); if (volume % 3 == 0) return 0; return 1 + _musicalOCD(volume + mod, mod); }

Answer 2

You could use an approach where you fork the recursive call by testing decrementing forst and then incrementing.

 function musicalOCD(volume) { if (volume % 3 === 0) return 0; return 1 + (musicalOCD(volume - 2) && musicalOCD(volume + 2)); } [[4, 1], [12, 0], [20, 1], [22, 1], [68, 1]].forEach(([v, r]) => console.log(v, musicalOCD(v), r));

With directions for testing.

 function musicalOCD(volume, dir) { console.log(dir); if (volume % 3 === 0) return 0; return 1 + (musicalOCD(volume - 2, 'down') && musicalOCD(volume + 2, 'up')); } [[4, 1], [12, 0], [20, 1], [22, 1], [68, 1]].forEach(([v, r]) => console.log(v, musicalOCD(v), r));

 .as-console-wrapper { max-height: 100% !important; top: 0; }