none
Convert C to C# RRS feed

  • Question

  • hi ,, i need to convert this C code to C# code really really fast .

    can anyone help ??!

    here is the code >>
    "
    #include &ltstdio.h>


    #define FALSE 0
    #define TRUE 1
    #define N_POSITIONS 9
    #define MAX_N_MOVES 4
    #define NO_FLAGS 0
    #define ON_SOLUTION_PATH 1
    #define NO_SOLUTION 0
    #define FOUND_SOLUTION 1
    #define HOLE 0
    #define NO_PIECE 255



    typedef unsigned char STATE[ N_POSITIONS ];


    typedef struct node
    {
      STATE state;
      unsigned char piece_moved;
      struct node *sibling;
      struct node *first_child;
      struct node *parent;
      int flags;
    }
    NODE;


    int moves[ N_POSITIONS ][ MAX_N_MOVES ] =
    {
      { 1, 3, -1, -1 },
      { 0, 2, 4, -1 },
      { 1, 5, -1, -1 },
      { 0, 4, 6, -1},
      { 1, 3, 5, 7},
      { 2, 4, 8, -1},
      { 3, 7, -1, -1},
      { 4, 6, 8, -1},
      { 5, 7, -1, -1}
    };

    int solution[ N_POSITIONS ] = { 1, 2, 3, 4, 5, 6, 7, 8, 0 };

    int n_nodes = 0; 



    main()
    {
      NODE *search_tree, *solution;
      NODE *malloc_node();
      int depth;



      search_tree = malloc_node();

      read_initial_state( search_tree->state );
      for( depth = 1; depth state[i] = i;
      node->piece_moved = NO_PIECE;
      node->sibling = NULL;
      node->first_child = NULL;
      node->parent = NULL;
      node->flags = NO_FLAGS;

      n_nodes++;
      return node;
    }


    read_initial_state( state )
         STATE state;
    {
      int i;
      int value;
      int repeats[N_POSITIONS];

      printf( "Please type in the initial position of the squares\n" );
      printf( "Give each row from top to bottom in left to right order\n" );
      for( i = 0; i  8 )
        {
          fprintf( stderr,
          "Illegal value %d in position %d, values must between 0 and 8.\n",
              value, i );
          exit( -1 );
        }
          if ( repeats[value] > 0 )
        {
          fprintf( stderr, "Duplicate value %d in position %d.\n", value, i );
          exit( -1 );
        }
          repeats[value] = 1;
          state[i] = (unsigned char) value; 
        }
      printf( "Input read:\n" );
      print_board( state );
    }


    print_board( state )
         STATE state;
    {
      printf( "%d %d %d\n", state[0], state[1], state[2] );
      printf( "%d %d %d\n", state[3], state[4], state[5] );
      printf( "%d %d %d\n", state[6], state[7], state[8] );
    }


    expand_search_tree_by_one( node )
         NODE *node;
    {

      if ( node == NULL )
        {
          fprintf( stderr, "Consistency check 1 failed\n" );
          exit( -1 );
        }
      if ( node->first_child == NULL )
        generate_moves( node );
      else
        expand_search_tree_by_one( node->first_child );

      if ( on_solution_path( node ) && node->parent != NULL )
        {
          node->parent->flags |= ON_SOLUTION_PATH;
          return;
        }

      if ( node->sibling != NULL )
        expand_search_tree_by_one( node->sibling );
    }


    generate_moves( node )
         NODE *node;
    {
      NODE *make_move();
      NODE *child;
      int i;

      child = make_move( node, 0 );
      node->first_child = child;
      if ( is_solution( child ) )
        {
          node->flags |= ON_SOLUTION_PATH;
          return FOUND_SOLUTION;
        }
      for( i = 1; i sibling = make_move( node, i );
          if ( child->sibling == NULL )
        return NO_SOLUTION;
          if ( is_solution( child->sibling ) )
        {
          node->flags |= ON_SOLUTION_PATH;
          return FOUND_SOLUTION;
        }
          child = child->sibling;
        }
      return NO_SOLUTION;
    }


    NODE *make_move( node, index )
         NODE *node;
         int index;
    {
      int i, hole_position, piece_position;
      NODE *result;


      for( i = 0; i state[i] == HOLE )
        break;
        }
      hole_position = i;
      piece_position = moves[hole_position][index];
      if ( piece_position parent = node;
      for( i = 0; i state[i] = node->state[i];
        }
      result->state[hole_position] = node->state[piece_position];
      result->state[piece_position] = node->state[hole_position];
      result->piece_moved = node->state[piece_position];


      return result;
    }


    is_solution( node )
         NODE *node;
    {
      int i;

      for( i = 0; i state[i] != solution[i] )
        return FALSE;
        }
      node->flags |= ON_SOLUTION_PATH;
      return TRUE;
    }


    on_solution_path( node )
         NODE *node;
    {
      if ( ( node->flags & ON_SOLUTION_PATH ) == 0 )
        return FALSE;
      else
        return TRUE;
    }


    print_out_solution( node )
         NODE *node;
    {
      if ( node == NULL )
        return;
      if ( on_solution_path( node ) )
        {
          if ( node->piece_moved != NO_PIECE )
        {
          printf( "Piece %d moved.\n", node->piece_moved );
          print_board( node );
        }
          else
        {
          printf( "Starting postion:\n" );
          print_board( node );
        }
          print_out_solution( node->first_child );
        }
      else
        print_out_solution( node->sibling );
    }

    "

                                              
    Friday, March 4, 2016 5:58 PM

Answers

All replies