Rewriting whitespace

calcutta2.c

void error(const char *msg, const char *file, int line)
{
    fprintf(stderr, "%s:%d: %s\n", file, line, msg);
    exit(1);
}

enum keyword_ {
    kw_up,
    kw_down,
    kw_left,
    kw_right,
    kw_pass,
    kw_out
};

typedef enum keyword_ keyword;

struct action_ {
    bool place_bomb;
    keyword non_bomb_action;
    int bomb_delay;
};

typedef struct action_ action;

const action action_up    = {false, kw_up,    -1};
const action action_down  = {false, kw_down,  -1};
const action action_left  = {false, kw_left,  -1};
const action action_right = {false, kw_right, -1};
const action action_pass  = {false, kw_pass,  -1};
const action action_out   = {false, kw_out,   -1};

struct parameters_ {
    int player_id;
    int number_of_players;
    int max_number_of_turns;
};

typedef struct parameters_ parameters;

struct map_ {
    int width;
    int height;
    char *data;
};

typedef struct map_ map;

struct bomb_ {
    int pos_x;
    int pos_y;
    int ticks_left;
};

typedef struct bomb_ bomb;

struct player_ {
    int pos_x;
    int pos_y;
    int bomb_count;
    bomb *bombs;
    action last_action;
};

typedef struct player_ player;

struct state_ {
    parameters parameters;
    map map;
    player *players;
};

typedef struct state_ state;

const int max_bombs_per_players = 5;

bool is_whitespace(char c)
{
    return (c == ' ') || (c == '\t') || (c == '\r') || (c == '\n');
}

bool is_digit(char c)
{
    return (c >= '0') && (c <= '9');
}

char *map_pos(map *m, int row, int col)
{
    return &m->data[m->width * row + col];
}

int read_integer_token(void)
{
    int i;
    int res = scanf("%d", &i);
    if (res != 1) {
        FAIL();
    }
    return i;
}

void read_character_tokens(int n, char *buffer)
{
    int i;
    for (i = 0; i < n; i++) {
        int c;
        do {
            c = getchar();
            if (c == EOF) {
                FAIL();
            }
        } while (is_whitespace((char) c));
        buffer[i] = (char) c;
    }
}

keyword read_keyword_token(void)
{
    char buffer[6];
    int res = scanf("%5s", buffer);
    if (res != 1) {
        FAIL();
    }
    if (strcmp(buffer, "up") == 0) {
        return kw_up;
    } else if (strcmp(buffer, "down") == 0) {
        return kw_down;
    } else if (strcmp(buffer, "left") == 0) {
        return kw_left;
    } else if (strcmp(buffer, "right") == 0) {
        return kw_right;
    } else if (strcmp(buffer, "pass") == 0) {
        return kw_pass;
    } else if (strcmp(buffer, "out") == 0) {
        return kw_out;
    } else {
        ERROR("invalid keyword");
    }
}

action read_action_token(void)
{
    action a;
    int c;
    do {
        c = getchar();
        if (c == EOF) {
            FAIL();
        }
    } while (is_whitespace((char) c));
    a.place_bomb = is_digit((char) c);
    int res = ungetc(c, stdin);
    if (res == EOF) {
        FAIL();
    }
    if (a.place_bomb) {
        a.bomb_delay = read_integer_token();
    } else {
        a.non_bomb_action = read_keyword_token();
    }
    return a;
}

void read_parameters(parameters *p)
{
    p->player_id           = read_integer_token();
    p->number_of_players   = read_integer_token();
    p->max_number_of_turns = read_integer_token();
}

void read_map(map *m)
{
    read_character_tokens(m->width * m->height, m->data);
}

void read_bomb(bomb *b)
{
    b->pos_x = read_integer_token();
    b->pos_y = read_integer_token();
    b->ticks_left = read_integer_token();
}

void read_round(state *state)
{
    int player_count = state->parameters.number_of_players;
    for (int i = 0; i < player_count; i++) {
        state->players[i].bomb_count = 0;
    }
    read_map(&state->map);
    int live_player_count = read_integer_token();
    for (int i = 0; i < live_player_count; i++) {
        int player_id = read_integer_token();
        ASSERT(player_id < player_count);
        player *player = &state->players[player_id];
        player->pos_x = read_integer_token();
        player->pos_y = read_integer_token();
    }
    int bomb_count = read_integer_token();
    for (int i = 0; i < bomb_count; i++) {
        int player_id = read_integer_token();
        ASSERT(player_id < player_count);
        player *player = &state->players[player_id];
        ASSERT(player->bomb_count < max_bombs_per_players);
        bomb *bomb = &player->bombs[player->bomb_count];
        read_bomb(bomb);
        player->bomb_count++;
    }
    for (int i = 0; i < player_count; i++)
    {
        int player_id = read_integer_token();
        ASSERT(player_id < player_count);
        player *player = &state->players[player_id];
        player->last_action = read_action_token();
    }
}

bool no_more_tokens(void)
{
    int c;
    do {
        c = getchar();
        if (c == EOF) {
            return true;
        }
    } while (is_whitespace((char) c));
    ungetc(c, stdin);
    return false;
}

void setup(state *state)
{
    read_parameters(&state->parameters);
    state->map.width  = read_integer_token();
    state->map.height = read_integer_token();
    state->map.data   = malloc(sizeof(char) * state->map.width * state->map.height);
    state->players    = malloc(sizeof(player) * state->parameters.number_of_players);
    for (int i = 0; i < state->parameters.number_of_players; i++)
    {
        state->players[i].bombs = malloc(sizeof(bomb) * max_bombs_per_players);
    }
}

void write_action(action a)
{
    if (a.place_bomb) {
        printf("%d\n", a.bomb_delay);
    } else {
        const char *s;
        switch (a.non_bomb_action) {
        case kw_up:
            s = "up";
            break;
        case kw_down:
            s = "down";
            break;
        case kw_left:
            s = "left";
            break;
        case kw_right:
            s = "right";
            break;
        case kw_pass:
            s = "pass";
            break;
        default:
            FAIL();
            break;
        }
        puts(s);
    }
}

void make_move(state *state)
{
    write_action(action_pass);
}

int main(int argc, char **argv)
{
    state state;
    setup(&state);
    while (!no_more_tokens()) {
        read_round(&state);
        make_move(&state);
    }
    return 0;
}

calcutta3.c

void error ( const char * msg , const char * file , int line ) { fprintf ( stderr , "%s:%d: %s\n" , file , line , msg ) ; exit ( 1 ) ; } enum keyword_ { kw_up , kw_down , kw_left , kw_right , kw_pass , kw_out } ; typedef enum keyword_ keyword ; struct action_ { bool place_bomb ; keyword non_bomb_action ; int bomb_delay ; } ; typedef struct action_ action ; const action action_up = { false , kw_up , - 1 } ; const action action_down = { false , kw_down , - 1 } ; const action action_left = { false , kw_left , - 1 } ; const action action_right = { false , kw_right , - 1 } ; const action action_pass = { false , kw_pass , - 1 } ; const action action_out = { false , kw_out , - 1 } ; struct parameters_ { int player_id ; int number_of_players ; int max_number_of_turns ; } ; typedef struct parameters_ parameters ; struct map_ { int width ; int height ; char * data ; } ; typedef struct map_ map ; struct bomb_ { int pos_x ; int pos_y ; int ticks_left ; } ; typedef struct bomb_ bomb ; struct player_ { int pos_x ; int pos_y ; int bomb_count ; bomb * bombs ; action last_action ; } ; typedef struct player_ player ; struct state_ { parameters parameters ; map map ; player * players ; } ; typedef struct state_ state ; const int max_bombs_per_players = 5 ; bool is_whitespace ( char c ) { return ( c == ' ' ) || ( c == '\t' ) || ( c == '\r' ) || ( c == '\n' ) ; } bool is_digit ( char c ) { return ( c >= '0' ) && ( c <= '9' ) ; } char * map_pos ( map * m , int row , int col ) { return & m -> data [ m -> width * row + col ] ; } int read_integer_token ( void ) { int i ; int res = scanf ( "%d" , & i ) ; if ( res != 1 ) { FAIL ( ) ; } return i ; } void read_character_tokens ( int n , char * buffer ) { int i ; for ( i = 0 ; i < n ; i ++ ) { int c ; do { c = getchar ( ) ; if ( c == EOF ) { FAIL ( ) ; } } while ( is_whitespace ( ( char ) c ) ) ; buffer [ i ] = ( char ) c ; } } keyword read_keyword_token ( void ) { char buffer [ 6 ] ; int res = scanf ( "%5s" , buffer ) ; if ( res != 1 ) { FAIL ( ) ; } if ( strcmp ( buffer , "up" ) == 0 ) { return kw_up ; } else if ( strcmp ( buffer , "down" ) == 0 ) { return kw_down ; } else if ( strcmp ( buffer , "left" ) == 0 ) { return kw_left ; } else if ( strcmp ( buffer , "right" ) == 0 ) { return kw_right ; } else if ( strcmp ( buffer , "pass" ) == 0 ) { return kw_pass ; } else if ( strcmp ( buffer , "out" ) == 0 ) { return kw_out ; } else { ERROR ( "invalid keyword" ) ; } } action read_action_token ( void ) { action a ; int c ; do { c = getchar ( ) ; if ( c == EOF ) { FAIL ( ) ; } } while ( is_whitespace ( ( char ) c ) ) ; a . place_bomb = is_digit ( ( char ) c ) ; int res = ungetc ( c , stdin ) ; if ( res == EOF ) { FAIL ( ) ; } if ( a . place_bomb ) { a . bomb_delay = read_integer_token ( ) ; } else { a . non_bomb_action = read_keyword_token ( ) ; } return a ; } void read_parameters ( parameters * p ) { p -> player_id = read_integer_token ( ) ; p -> number_of_players = read_integer_token ( ) ; p -> max_number_of_turns = read_integer_token ( ) ; } void read_map ( map * m ) { read_character_tokens ( m -> width * m -> height , m -> data ) ; } void read_bomb ( bomb * b ) { b -> pos_x = read_integer_token ( ) ; b -> pos_y = read_integer_token ( ) ; b -> ticks_left = read_integer_token ( ) ; } void read_round ( state * state ) { int player_count = state -> parameters . number_of_players ; for ( int i = 0 ; i < player_count ; i ++ ) { state -> players [ i ] . bomb_count = 0 ; } read_map ( & state -> map ) ; int live_player_count = read_integer_token ( ) ; for ( int i = 0 ; i < live_player_count ; i ++ ) { int player_id = read_integer_token ( ) ; ASSERT ( player_id < player_count ) ; player * player = & state -> players [ player_id ] ; player -> pos_x = read_integer_token ( ) ; player -> pos_y = read_integer_token ( ) ; } int bomb_count = read_integer_token ( ) ; for ( int i = 0 ; i < bomb_count ; i ++ ) { int player_id = read_integer_token ( ) ; ASSERT ( player_id < player_count ) ; player * player = & state -> players [ player_id ] ; ASSERT ( player -> bomb_count < max_bombs_per_players ) ; bomb * bomb = & player -> bombs [ player -> bomb_count ] ; read_bomb ( bomb ) ; player -> bomb_count ++ ; } for ( int i = 0 ; i < player_count ; i ++ ) { int player_id = read_integer_token ( ) ; ASSERT ( player_id < player_count ) ; player * player = & state -> players [ player_id ] ; player -> last_action = read_action_token ( ) ; } } bool no_more_tokens ( void ) { int c ; do { c = getchar ( ) ; if ( c == EOF ) { return true ; } } while ( is_whitespace ( ( char ) c ) ) ; ungetc ( c , stdin ) ; return false ; } void setup ( state * state ) { read_parameters ( & state -> parameters ) ; state -> map . width = read_integer_token ( ) ; state -> map . height = read_integer_token ( ) ; state -> map . data = malloc ( sizeof ( char ) * state -> map . width * state -> map . height ) ; state -> players = malloc ( sizeof ( player ) * state -> parameters . number_of_players ) ; for ( int i = 0 ; i < state -> parameters . number_of_players ; i ++ ) { state -> players [ i ] . bombs = malloc ( sizeof ( bomb ) * max_bombs_per_players ) ; } } void write_action ( action a ) { if ( a . place_bomb ) { printf ( "%d\n" , a . bomb_delay ) ; } else { const char * s ; switch ( a . non_bomb_action ) { case kw_up : s = "up" ; break ; case kw_down : s = "down" ; break ; case kw_left : s = "left" ; break ; case kw_right : s = "right" ; break ; case kw_pass : s = "pass" ; break ; default : FAIL ( ) ; break ; } puts ( s ) ; } } void make_move ( state * state ) { write_action ( action_pass ) ; } int main ( int argc , char * * argv ) { state state ; setup ( & state ) ; while ( ! no_more_tokens ( ) ) { read_round ( & state ) ; make_move ( & state ) ; } return 0 ; }

calcutta4.c

void error(const char*msg,const char*file,int line){fprintf(stderr,"%s:%d: %s\n",file,line,msg);exit(1);}enum keyword_{kw_up,kw_down,kw_left,kw_right,kw_pass,kw_out};typedef enum keyword_ keyword;struct action_{bool place_bomb;keyword non_bomb_action;int bomb_delay;};typedef struct action_ action;const action action_up={false,kw_up,-1};const action action_down={false,kw_down,-1};const action action_left={false,kw_left,-1};const action action_right={false,kw_right,-1};const action action_pass={false,kw_pass,-1};const action action_out={false,kw_out,-1};struct parameters_{int player_id;int number_of_players;int max_number_of_turns;};typedef struct parameters_ parameters;struct map_{int width;int height;char*data;};typedef struct map_ map;struct bomb_{int pos_x;int pos_y;int ticks_left;};typedef struct bomb_ bomb;struct player_{int pos_x;int pos_y;int bomb_count;bomb*bombs;action last_action;};typedef struct player_ player;struct state_{parameters parameters;map map;player*players;};typedef struct state_ state;const int max_bombs_per_players=5;bool is_whitespace(char c){return(c==' ')||(c=='\t')||(c=='\r')||(c=='\n');}bool is_digit(char c){return(c>='0')&&(c<='9');}char*map_pos(map*m,int row,int col){return&m->data[m->width*row+col];}int read_integer_token(void){int i;int res=scanf("%d",&i);if(res!=1){FAIL();}return i;}void read_character_tokens(int n,char*buffer){int i;for(i=0;i<n;i++){int c;do{c=getchar();if(c==EOF){FAIL();}}while(is_whitespace((char)c));buffer[i]=(char)c;}}keyword read_keyword_token(void){char buffer[6];int res=scanf("%5s",buffer);if(res!=1){FAIL();}if(strcmp(buffer,"up")==0){return kw_up;}else if(strcmp(buffer,"down")==0){return kw_down;}else if(strcmp(buffer,"left")==0){return kw_left;}else if(strcmp(buffer,"right")==0){return kw_right;}else if(strcmp(buffer,"pass")==0){return kw_pass;}else if(strcmp(buffer,"out")==0){return kw_out;}else{ERROR("invalid keyword");}}action read_action_token(void){action a;int c;do{c=getchar();if(c==EOF){FAIL();}}while(is_whitespace((char)c));a.place_bomb=is_digit((char)c);int res=ungetc(c,stdin);if(res==EOF){FAIL();}if(a.place_bomb){a.bomb_delay=read_integer_token();}else{a.non_bomb_action=read_keyword_token();}return a;}void read_parameters(parameters*p){p->player_id=read_integer_token();p->number_of_players=read_integer_token();p->max_number_of_turns=read_integer_token();}void read_map(map*m){read_character_tokens(m->width*m->height,m->data);}void read_bomb(bomb*b){b->pos_x=read_integer_token();b->pos_y=read_integer_token();b->ticks_left=read_integer_token();}void read_round(state*state){int player_count=state->parameters.number_of_players;for(int i=0;i<player_count;i++){state->players[i].bomb_count=0;}read_map(&state->map);int live_player_count=read_integer_token();for(int i=0;i<live_player_count;i++){int player_id=read_integer_token();ASSERT(player_id<player_count);player*player=&state->players[player_id];player->pos_x=read_integer_token();player->pos_y=read_integer_token();}int bomb_count=read_integer_token();for(int i=0;i<bomb_count;i++){int player_id=read_integer_token();ASSERT(player_id<player_count);player*player=&state->players[player_id];ASSERT(player->bomb_count<max_bombs_per_players);bomb*bomb=&player->bombs[player->bomb_count];read_bomb(bomb);player->bomb_count++;}for(int i=0;i<player_count;i++){int player_id=read_integer_token();ASSERT(player_id<player_count);player*player=&state->players[player_id];player->last_action=read_action_token();}}bool no_more_tokens(void){int c;do{c=getchar();if(c==EOF){return true;}}while(is_whitespace((char)c));ungetc(c,stdin);return false;}void setup(state*state){read_parameters(&state->parameters);state->map.width=read_integer_token();state->map.height=read_integer_token();state->map.data=malloc(sizeof(char)*state->map.width*state->map.height);state->players=malloc(sizeof(player)*state->parameters.number_of_players);for(int i=0;i<state->parameters.number_of_players;i++){state->players[i].bombs=malloc(sizeof(bomb)*max_bombs_per_players);}}void write_action(action a){if(a.place_bomb){printf("%d\n",a.bomb_delay);}else{const char*s;switch(a.non_bomb_action){case kw_up:s="up";break;case kw_down:s="down";break;case kw_left:s="left";break;case kw_right:s="right";break;case kw_pass:s="pass";break;default:FAIL();break;}puts(s);}}void make_move(state*state){write_action(action_pass);}int main(int argc,char**argv){state state;setup(&state);while(!no_more_tokens()){read_round(&state);make_move(&state);}return 0;}