Question

Need Help correcting last function runHanoi(A,C,B) so this program correctly calculates number of moves made. Solving the Hanoi tower. Please post correct Javascript. This is used in jsfiddle.

HTML:

html>
<schript src="TowerOfHanoi.js"</script>
</script>
<h1>
Tower of Hanoi
</h1>
Enter the number of disks (Disk amount must be < 7): <br>
<br>
<input id = 'uInput' type = 'textbox' size = 10 >
<button id = 'setup' onClick = 'insertDisks()'>
Set up Tower of Hanoi
</button>
<button id=calc onClick = 'runHanoi(stackA, stackC, stackB)'> Calculate number of moves
</button>

<br> <br>
<button id = 'aTob' onClick = 'aTob()'>A to B</button>
<button id = 'aToc' onClick = 'aToc()'>A to C</button>
<button id = 'bToa' onClick = 'bToa()'>B to A</button>
<button id = 'bToc' onClick = 'bToc()'>B to C</button>
<button id = 'cToa' onClick = 'cToa()'>C to A</button>
<button id = 'cTob' onClick = 'cTob()'>C to B</button>
<br><br>

<div id = 'output'>
</div>
<div id = 'output1'>
</div>
</html>

JS:

var num = 0;
var t = document.getElementById('uInput').value;

var Node = function(_content) {
this.content = _content;
this.next = null;
this.last = null;
return this;
}

var Stack = function(_content) {
this.top = null;
this.bottom = null;
this.length = 0;
return this;
}

Stack.prototype.push = function(_content) {

var node = new Node(_content);
node.content = _content;

if (this.bottom == null) {
this.bottom = node;
this.top = this.bottom;
this.length++;
return this;
}

node.last = this.top;
this.top.next = node;
this.top = node;
this.length++;
return this;
}

Stack.prototype.pop = function() {
if (this.bottom == null) {
alert('Stack is empty.');
return false;
}

if (this.bottom == this.top) {
this.bottom = null;
this.top = null;
this.length = 0;
return this.top
}

var popped = this.top;
this.top = this.top.last;
this.top.next = null;
this.length--;
return popped;
}

Stack.prototype.toString = function() {
var string = '';
var n = this.bottom;

while (n != null) {
string += n.content ;
n = n.next;
}
return string;
}

Stack.prototype.reverse = function(str) {
var newString = "";
for (var i = str.length - 1; i >= 0; i--) {
newString += str[i];
}
return newString;
}

function insertDisks(i) {
i = parseInt(document.getElementById('uInput').value);
if (i > 7) {
alert('Input must only be less than 7');
document.getElementById('uInput').value = '';
document.getElementById('uInput').focus();
return false;
}
for (var t = i; t > 0 ; t--) {
stackA.push(t);
stackA.length++;

}
document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();

}

var stackA = new Stack();
var stackB = new Stack();
var stackC = new Stack();

function aTob() {
var n = parseInt(stackA.top.content);
stackA.pop(n);
stackB.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackB.reverse(n);
}

function aToc() {
var n = parseInt(stackA.top.content);
stackA.pop(n);
stackC.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackC.reverse(n);
}

function bToa(){
var n = parseInt(stackB.top.content);
stackB.pop(n);
stackA.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackA.reverse(n);
}

function bToc(){
var n = parseInt(stackB.top.content);
stackB.pop(n);
stackC.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackC.reverse(n);
}

function cToa(){
var n = parseInt(stackC.top.content);
stackC.pop(n);
stackA.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackA.reverse(n);
}

function cTob(){
var n = parseInt(stackC.top.content);
stackC.pop(n);
stackB.push(n);

document.getElementById('output').innerHTML = 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
stackB.reverse(n);
}

function runHanoi(A, C, B) {
var c = stackA.length;
//alert(c);
if (c >= 1) {
runHanoi(c-1, A, B, C);
C.push(A.pop().content);   
num++;
runHanoi(c-1, B, C, A);
document.getElementById('output1').innerHTML += 'Towers: Stack A :' + stackA.toString() + '_Stack B: ' + stackB.toString() +'_Stack C: ' + stackC.toString();
}
}

Answer 1

It is better to replace your code with the below code for error free and better results.

JS code to implement the Towers of Hanoi problem:

import Stack from '../../../data-structures/stack/Stack';

/* Variables used in a program:
* {number} numberOfDiscs
* {Stack} fromPole
* {Stack} withPole
* {Stack} toPole
* {function(disc: number, fromPole: number[], toPole: number[])} moveCallback
*/
function hanoiTowerRecursive({
numberOfDiscs,
fromPole,
withPole,
toPole,
moveCallback,
}) {
if (numberOfDiscs === 1) {
// Base case with just one disc.
moveCallback(fromPole.peek(), fromPole.toArray(), toPole.toArray());
const disc = fromPole.pop();
toPole.push(disc);
} else {
// In case if there are more discs then move them recursively.

// Expose the bottom disc on fromPole stack.
hanoiTowerRecursive({
numberOfDiscs: numberOfDiscs - 1,
fromPole,
withPole: toPole,
toPole: withPole,
moveCallback,
});

// Move the disc that was exposed to its final destination.
hanoiTowerRecursive({
numberOfDiscs: 1,
fromPole,
withPole,
toPole,
moveCallback,
});

// Move temporary tower from auxiliary pole to its final destination.
hanoiTowerRecursive({
numberOfDiscs: numberOfDiscs - 1,
fromPole: withPole,
withPole: fromPole,
toPole,
moveCallback,
});
}
}

/* Variables used in a program:
* {number} numberOfDiscs
* {function(disc: number, fromPole: number[], toPole: number[])} moveCallback
* {Stack} [fromPole]
* {Stack} [withPole]
* {Stack} [toPole]
*/
export default function hanoiTower({
numberOfDiscs,
moveCallback,
fromPole = new Stack(),
withPole = new Stack(),
toPole = new Stack(),
}) {
// Each of three poles of Tower of Hanoi puzzle is represented as a stack
// that might contain elements (discs). Each disc is represented as a number.
// Larger discs have bigger number equivalent.

// Let's create the discs and put them to the fromPole.
for (let discSize = numberOfDiscs; discSize > 0; discSize -= 1) {
fromPole.push(discSize);
}

hanoiTowerRecursive({
numberOfDiscs,
fromPole,
withPole,
toPole,
moveCallback,
});
}