11.5 แบบฝึกหัด

#include <stdio.h>

typedef struct {
    char name[21];
    int score;
} Student;

Student students[1000];

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s %d", students[i].name, &students[i].score);
    }
    int best = 0;
    for (int i = 1; i < n; i++) {
        if (students[i].score > students[best].score) {
            best = i;
        }
    }
    int count = 0;
    for (int i = 0; i < n; i++) {
        if (students[i].score == students[best].score) {
            count++;
        }
    }
    printf("%s %d\n", students[best].name, students[best].score);
    printf("%d\n", count);
    return 0;
}

#include <stdio.h>

typedef struct {
    int x;
    int y;
} Point;

typedef struct {
    Point low;
    Point high;
} Rect;

int where(Rect field, Point ball)
{
    if (ball.x < field.low.x || ball.x > field.high.x || ball.y < field.low.y || ball.y > field.high.y) {
        return 2;
    }
    if (ball.x == field.low.x || ball.x == field.high.x || ball.y == field.low.y || ball.y == field.high.y) {
        return 1;
    }
    return 0;
}

int main()
{
    Rect field;
    scanf("%d %d %d %d", &field.low.x, &field.low.y, &field.high.x, &field.high.y);
    int n;
    scanf("%d", &n);
    int count[3] = {0, 0, 0};
    for (int i = 0; i < n; i++) {
        Point ball;
        scanf("%d %d", &ball.x, &ball.y);
        count[where(field, ball)]++;
    }
    printf("%d %d %d\n", count[0], count[1], count[2]);
    return 0;
}

#include <stdio.h>

typedef struct {
    long long x;
    long long y;
} Point;

typedef struct {
    char name[21];
    Point place;
} Shop;

Shop shops[1000];

long long distance_squared(Point a, Point b)
{
    long long dx = a.x - b.x;
    long long dy = a.y - b.y;
    return dx * dx + dy * dy;
}

int main()
{
    Point home;
    scanf("%lld %lld", &home.x, &home.y);
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        scanf("%s %lld %lld", shops[i].name, &shops[i].place.x, &shops[i].place.y);
    }
    int best = 0;
    long long best_distance = distance_squared(home, shops[0].place);
    for (int i = 1; i < n; i++) {
        long long d = distance_squared(home, shops[i].place);
        if (d < best_distance) {
            best = i;
            best_distance = d;
        }
    }
    printf("%s %lld\n", shops[best].name, best_distance);
    return 0;
}

#include <stdio.h>

typedef struct {
    int hours;
    int minutes;
    int seconds;
} Time;

typedef struct {
    char name[21];
    Time start;
    Time finish;
} Runner;

Runner runners[1000];

int to_seconds(Time t)
{
    return t.hours * 3600 + t.minutes * 60 + t.seconds;
}

Time from_seconds(int total)
{
    Time t;
    t.hours = total / 3600;
    t.minutes = total % 3600 / 60;
    t.seconds = total % 60;
    return t;
}

int used(const Runner *r)
{
    return to_seconds(r->finish) - to_seconds(r->start);
}

int faster(const Runner *a, const Runner *b)
{
    if (used(a) != used(b)) {
        return used(a) < used(b);
    }
    return to_seconds(a->finish) < to_seconds(b->finish);
}

int main()
{
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; i++) {
        Runner *r = &runners[i];
        scanf("%s %d %d %d %d %d %d", r->name,
              &r->start.hours, &r->start.minutes, &r->start.seconds,
              &r->finish.hours, &r->finish.minutes, &r->finish.seconds);
    }
    int best = 0;
    for (int i = 1; i < n; i++) {
        if (faster(&runners[i], &runners[best])) {
            best = i;
        }
    }
    Time t = from_seconds(used(&runners[best]));
    printf("%s %d %d %d\n", runners[best].name, t.hours, t.minutes, t.seconds);
    return 0;
}

#include <stdio.h>
#include <string.h>

typedef struct {
    char code[11];
    int quantity;
    int price;
} Item;

Item items[100];

int find_item(const char code[], int m)
{
    for (int i = 0; i < m; i++) {
        if (strcmp(items[i].code, code) == 0) {
            return i;
        }
    }
    return -1;
}

int main()
{
    int m, q;
    scanf("%d %d", &m, &q);
    for (int i = 0; i < m; i++) {
        scanf("%s %d %d", items[i].code, &items[i].quantity, &items[i].price);
    }
    int rejected = 0;
    for (int k = 0; k < q; k++) {
        char type[4], code[11];
        int amount;
        scanf("%s %s %d", type, code, &amount);
        Item *item = &items[find_item(code, m)];
        if (strcmp(type, "IN") == 0) {
            item->quantity += amount;
        } else if (item->quantity >= amount) {
            item->quantity -= amount;
        } else {
            rejected++;
        }
    }
    long long total = 0;
    for (int i = 0; i < m; i++) {
        printf("%s %d\n", items[i].code, items[i].quantity);
        total += (long long)items[i].quantity * items[i].price;
    }
    printf("%lld\n", total);
    printf("%d\n", rejected);
    return 0;
}

#include <stdio.h>

typedef struct {
    long long x;
    long long y;
} Point;

typedef struct {
    Point low;
    Point high;
} Rect;

long long min_ll(long long a, long long b)
{
    return a < b ? a : b;
}

long long max_ll(long long a, long long b)
{
    return a > b ? a : b;
}

Rect make_rect(Point a, Point b)
{
    Rect r;
    r.low.x = min_ll(a.x, b.x);
    r.low.y = min_ll(a.y, b.y);
    r.high.x = max_ll(a.x, b.x);
    r.high.y = max_ll(a.y, b.y);
    return r;
}

Rect read_rect()
{
    Point a, b;
    scanf("%lld %lld %lld %lld", &a.x, &a.y, &b.x, &b.y);
    return make_rect(a, b);
}

int main()
{
    int n;
    scanf("%d", &n);
    Rect common = read_rect();
    for (int i = 1; i < n; i++) {
        Rect r = read_rect();
        common.low.x = max_ll(common.low.x, r.low.x);
        common.low.y = max_ll(common.low.y, r.low.y);
        common.high.x = min_ll(common.high.x, r.high.x);
        common.high.y = min_ll(common.high.y, r.high.y);
    }
    long long width = common.high.x - common.low.x;
    long long height = common.high.y - common.low.y;
    if (width > 0 && height > 0) {
        printf("%lld\n", width * height);
    } else {
        printf("0\n");
    }
    return 0;
}

#include <stdio.h>
#include <string.h>

typedef struct {
    char name[16];
    int points;
    int scored;
    int conceded;
} Team;

Team teams[20];
int used[20];

int find_team(const char name[], int t)
{
    for (int i = 0; i < t; i++) {
        if (strcmp(teams[i].name, name) == 0) {
            return i;
        }
    }
    return -1;
}

void record(Team *team, int scored, int conceded)
{
    team->scored += scored;
    team->conceded += conceded;
    if (scored > conceded) {
        team->points += 3;
    } else if (scored == conceded) {
        team->points += 1;
    }
}

int better(const Team *a, const Team *b)
{
    if (a->points != b->points) {
        return a->points > b->points;
    }
    int diff_a = a->scored - a->conceded;
    int diff_b = b->scored - b->conceded;
    if (diff_a != diff_b) {
        return diff_a > diff_b;
    }
    if (a->scored != b->scored) {
        return a->scored > b->scored;
    }
    return strcmp(a->name, b->name) < 0;
}

int main()
{
    int t, m;
    scanf("%d %d", &t, &m);
    for (int i = 0; i < t; i++) {
        scanf("%s", teams[i].name);
    }
    for (int k = 0; k < m; k++) {
        char home[16], away[16];
        int home_goals, away_goals;
        scanf("%s %s %d %d", home, away, &home_goals, &away_goals);
        record(&teams[find_team(home, t)], home_goals, away_goals);
        record(&teams[find_team(away, t)], away_goals, home_goals);
    }
    for (int rank = 0; rank < 3; rank++) {
        int best = -1;
        for (int i = 0; i < t; i++) {
            if (!used[i] && (best == -1 || better(&teams[i], &teams[best]))) {
                best = i;
            }
        }
        used[best] = 1;
        printf("%s %d %d %d\n", teams[best].name, teams[best].points,
               teams[best].scored - teams[best].conceded, teams[best].scored);
    }
    return 0;
}

#include <stdio.h>

typedef struct {
    long long x;
    long long y;
} Point;

typedef struct {
    Point pos;
    int dir;
} Robot;

const char DIRECTIONS[] = "NESW";
const int DX[4] = {0, 1, 0, -1};
const int DY[4] = {1, 0, -1, 0};

Robot robots[1000];

int direction_index(char d)
{
    for (int i = 0; i < 4; i++) {
        if (DIRECTIONS[i] == d) {
            return i;
        }
    }
    return -1;
}

void turn_left(Robot *r)
{
    r->dir = (r->dir + 3) % 4;
}

void turn_right(Robot *r)
{
    r->dir = (r->dir + 1) % 4;
}

void forward(Robot *r, long long steps)
{
    r->pos.x += DX[r->dir] * steps;
    r->pos.y += DY[r->dir] * steps;
}

int main()
{
    int n, q;
    scanf("%d %d", &n, &q);
    for (int i = 0; i < n; i++) {
        char d;
        scanf("%lld %lld %c", &robots[i].pos.x, &robots[i].pos.y, &d);
        robots[i].dir = direction_index(d);
    }
    for (int k = 0; k < q; k++) {
        int id;
        char command;
        scanf("%d %c", &id, &command);
        Robot *r = &robots[id - 1];
        if (command == 'F') {
            long long steps;
            scanf("%lld", &steps);
            forward(r, steps);
        } else if (command == 'L') {
            turn_left(r);
        } else {
            turn_right(r);
        }
    }
    int pairs = 0;
    for (int i = 0; i < n; i++) {
        printf("%lld %lld %c\n", robots[i].pos.x, robots[i].pos.y, DIRECTIONS[robots[i].dir]);
        for (int j = i + 1; j < n; j++) {
            if (robots[i].pos.x == robots[j].pos.x && robots[i].pos.y == robots[j].pos.y) {
                pairs++;
            }
        }
    }
    printf("%d\n", pairs);
    return 0;
}