Slashfear's Programming challenge!!!

#include "stdio.h"

#define TRUE 1
#define FALSE 0


/* 
 * Defining a structure and data type for representing each tower
 * tower is pointer to elements of tower
 * size represent number of elements in tower
 */
typedef struct {
  int *tower;
  int size;
} tower_t;


/* Display the move */
void display_move(tower_t* tt1, tower_t* tt2, tower_t* t1, tower_t* t2, tower_t* t3) {
  int from = 0;
  int to = 0;

  if(tt1->tower == t1->tower) {
    from = 1;
  } else if(tt1->tower == t2->tower) {
    from = 2;
  } else {
    from = 3;
  }

  if(tt2->tower == t1->tower) {
    to = 1;
  } else if(tt2->tower == t2->tower) {
    to = 2;
  } else {
    to = 3;
  }

  printf("Move from %d to %d\n", from, to);
  
}


/* Display current state of all towers */
void display_towers(tower_t t1, tower_t t2, tower_t t3, int tower_size) {
  int i = 0;
  printf("Towers:\n");
  for(i = (tower_size - 1); i >= 0; i--) {
    printf("%d %d %d\n", t1.tower[i], t2.tower[i], t3.tower[i]);
  }
  printf("\n");
}


/* Moves elemet fro tt1 to tt2 using tt3 as buffer */
void move(tower_t* tt1, tower_t* tt2, tower_t* tt3, tower_t* t1, tower_t* t2, tower_t* t3, int tower_size) {
  int move_to_tt2 = FALSE;
  int move_count = 0;
  int i = 0;

  //determining number of elements that can be moved from tt1
  for(i = (tt1->size - 1); i >= 0; i--) {
    if(((tt2->size == 0) || (tt2->tower[tt2->size - 1] > tt1->tower[i]))
        && ((tt3->size == 0) || (tt3->tower[tt3->size - 1] > tt1->tower[i]))) {
      move_count++;
    } else {
      break;
    }
  }

  //if number of elements is odd, move first element to tt2
  //else move first element to tt3
  if(move_count % 2) {
    move_to_tt2 = TRUE;
  } else {
    move_to_tt2 = FALSE;
  }

  //loop for moving each element till count of moveable element is not 0 in tt1
  while(move_count != 0) {
    if(move_to_tt2) {
      //display the current move
      display_move(tt1, tt2, t1, t2, t3);

      //move element from tt1 to tt2
      tt2->tower[tt2->size++] = tt1->tower[--tt1->size];
      tt1->tower[tt1->size] = 0;

      //toggle flag to move next element to tt3
      move_to_tt2 = FALSE;

      //display current state of all towers after move
      display_towers(*t1, *t2, *t3, tower_size);

      //move pegs from tower tt3 to tt2
      move(tt3, tt2, tt1, t1, t2, t3, tower_size);
    } else {
      //display the current move
      display_move(tt1, tt3, t1, t2, t3);

      //move element from tt1 to tt3
      tt3->tower[tt3->size++] = tt1->tower[--tt1->size];
      tt1->tower[tt1->size] = 0;

      //toggle flag to move next element to tt2
      move_to_tt2 = TRUE;

      //display current state of all towers after move
      display_towers(*t1, *t2, *t3, tower_size);

      //move pegs from tower tt2 to tt3
      move(tt2, tt3, tt1, t1, t2, t3, tower_size);
    }

    //one more element moved, decrementing count
    move_count--;
  }
}


int main() {
  tower_t t1 = {0};
  tower_t t2 = {0};
  tower_t t3 = {0};
  int tower_size = 0;
  int i = 0;

  //taking tower size as input
  scanf("%d", &tower_size);

  //validating tower size
  if(tower_size <= 0) {
    printf("Invalid tower size\n");
    return 0;
  }

  //allocating memory for each tower
  t1.tower = (int*)malloc(sizeof(int) * tower_size);
  t2.tower = (int*)malloc(sizeof(int) * tower_size);
  t3.tower = (int*)malloc(sizeof(int) * tower_size);

  //initializing elements of t1 with the peg it contains
  //initializing elements of t2 and t3 with 0 as they are initially empty
  for(i = 0; i < tower_size; i++) {
    t1.tower[i] = tower_size - i;
    t2.tower[i] = t3.tower[i] = 0;
  }

  //initializing size of t1 with current tower size as it contain all pegs
  //initializing size t2 and t3 with 0 as they are initially empty
  t1.size = tower_size;
  t2.size = t3.size = 0;

  //display the initial state of all towers
  display_towers(t1, t2, t3, tower_size);

  //moving complete tower 1 to tower 2 using tower 3 as buffer
  move(&t1, &t2, &t3, &t1, &t2, &t3, tower_size);

  //free the memory previously allocated for each tower
  free(t1.tower);
  free(t2.tower);
  free(t3.tower);

  return 0;
}

Towers:
1 0 0
2 0 0
3 0 0
4 0 0

Move from 1 to 3
Towers:
0 0 0
2 0 0
3 0 0
4 0 1

Move from 1 to 2
Towers:
0 0 0
0 0 0
3 0 0
4 2 1

Move from 3 to 2
Towers:
0 0 0
0 0 0
3 1 0
4 2 0

Move from 1 to 3
Towers:
0 0 0
0 0 0
0 1 0
4 2 3

Move from 2 to 1
Towers:
0 0 0
0 0 0
1 0 0
4 2 3

Move from 2 to 3
Towers:
0 0 0
0 0 0
1 0 2
4 0 3

Move from 1 to 3
Towers:
0 0 0
0 0 1
0 0 2
4 0 3

Move from 1 to 2
Towers:
0 0 0
0 0 1
0 0 2
0 4 3

Move from 3 to 2
Towers:
0 0 0
0 0 0
0 1 2
0 4 3

Move from 3 to 1
Towers:
0 0 0
0 0 0
0 1 0
2 4 3

Move from 2 to 1
Towers:
0 0 0
0 0 0
1 0 0
2 4 3

Move from 3 to 2
Towers:
0 0 0
0 0 0
1 3 0
2 4 0

Move from 1 to 3
Towers:
0 0 0
0 0 0
0 3 0
2 4 1

Move from 1 to 2
Towers:
0 0 0
0 2 0
0 3 0
0 4 1

Move from 3 to 2
Towers:
0 1 0
0 2 0
0 3 0
0 4 0

Corpse-Thrust

btw is this solvable using simple procedural programming instead of the approach Pradeep used?

typedef struct {
  int *tower;
  int size;
} tower_t;

MoveDiscs(int n, char a, char c, char b)
{
if(n==2)
{
cout<<a<<"->"<<b<<endl;
cout<<a<<"->"<<c<<endl;
cout<<b<<"->"<<c<<endl;
}
else if(n>2)
{
MoveDiscs(n-1, a, b, c);
cout<<a<<"->"<<c<<endl;
MoveDiscs(n-1, b, c, a);
}
}

void main()
{
int x;
cout<<"enter the number of discs in tower A : ";
cin>>x;
MoveDiscs(x, "A", "C", "B");
}

 
[B]
#include <iostream>
using namespace std;

void towers( int, int, int, int );

int main()
{
   int nDisks;
   cout << "Enter the starting number of disks: ";
   cin >> nDisks;
   towers( nDisks, 1, 3, 2 );
   return 0;
}

void towers( int disks, int start, int end, int temp )
{
   if ( disks == 1 ) {
      cout << start << " --> " << end << '\n';
      return;
   }
   // move disks - 1 disks from start to temp
   towers( disks - 1, start, temp, end );
   // move last disk from start to end
   cout << start << " --> " << end << '\n';
   // move disks - 1 disks from temp to end
   towers( disks - 1, temp, end, start );
}[/B]

slashfear

@pradeep, Good solution dude......... (Can't we make a solution in a simple and smaller way? buddy!!! 😒)

slashfear

@Corpse-Thrust, good try but give us the complete code....

slashfear

@Corpse-Thrust, good try but give us the complete code....

#include<iostream.h>

MoveDiscs(int n, char a, char c, char b)
{
if(n==2)
{
cout<<a<<"->"<<b<<endl;
cout<<a<<"->"<<c<<endl;
cout<<b<<"->"<<c<<endl;
}
else if(n>2)
{
MoveDiscs(n-1, a, b, c);
cout<<a<<"->"<<c<<endl;
MoveDiscs(n-1, b, c, a);
}
}

void main()
{
int x;
cout<<"enter the number of discs in tower A : ";
cin>>x;
if(x>1)
MoveDiscs(x, 'A', 'C', 'B');
else
cout<<"invalid input";
}

Corpse-Thrust

@Pradeep -> quick n00b question, but what's validation of input?

Corpse-Thrust

cin>>x;
if(x>0 && x<1)
MoveDiscs(x, 'A', 'C', 'B');
else
cout<<"invalid input";

pradeep_agrawal

If feel the condition should be "if(x<=1)" because the condition you have specified will never execute the "MoveDiscs(x, 'A', 'C', 'B');" code and will always give "invalid input" as output.

-Pradeep

#include<iostream>

using std::cin;

using std::cout;

using std::endl;

void hanoi(int n,char a,char b,char c)
{
    static int x=0;

    if(n==1)
        cout<<++x<<") "<<a<<" => "<<c<<endl<<endl;

    else
    {
        hanoi(n-1,a,c,b);

        cout<<++x<<") "<<a<<" => "<<c<<endl<<endl;

        hanoi(n-1,b,a,c);
    }
}

int main()
{
    int n;

    char a='1',b='2',c='3';

    cout<<"enter the number of desks:";

    cin>>n;

    hanoi(n,a,b,c);

    return 0;
}