数据结构Online Judge第三章题目(C语言版)

最新推荐文章于 2023-05-25 23:26:06 发布
最新推荐文章于 2023-05-25 23:26:06 发布
阅读量208 收藏
点赞数
分类专栏： 数据结构学习记录 文章标签： c语言 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_70911939/article/details/129875458
版权

文章为作者记录学习过程，小白一枚，各路大佬多多提建议，感激不尽

题目

前言

本文是作者在学习数据结构时写在课程OJ的代码，在OJ上运行答案正确，编译器版本为GCC5.4，如有不足还望指正。

一、3.17-逆序列

试写一算法，识别依次读入的一个以 @ @ @ 为结束符的字符序列是否为形如 “ “ “序列 1   & 1\ \& 1 & 序列 2 ” 2” 2”模式的字符序列。其中序列 1 1 1 和序列 2 2 2 中都不包含字符 “ & ” “\&” “&”，且序列 2 2 2 是序列 1 1 1 的逆序列。例如， “ a + b & b + a ” “a+b\&b+a” “a+b&b+a” 是属于该模式的字符序列，而 “ 1 + 3 & 3 − 1 ” “1+3\&3-1” “1+3&3−1” 则不是。

输入： 输入字符序列。

输出： 如果序列符合模式则输出 1 1 1，不符合则输出 0 0 0。

输入示例：

a+b&b+a@

输出示例：

1

代码：

/* 试写一算法，识别依次读入的一个以@为结束符的字符序列是否为形如“序列1&序列2”模式的字符
*  序列。其中序列1和序列2中都不包含字符“&”，且序列2是序列1的逆序列。例如，“a+b&b+a”是
*  属于该模式的字符序列，而“1+3&3-1”则不是。*/
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int i = 0;
    char c = '0';
    char *Str;
    Str = (char *)malloc((i + 1) * sizeof(char));

    while ((c = getchar()) != '&') {
        Str[i++] = c;
    }
    i--;
    while ((c = getchar()) != '@' && i != -1) {
        if (Str[i--] == c)
            continue;
        else {
            printf("0\n");
            return 0;
        }
    }
    printf("1\n");
    return 0;
}

二、3.18-括号配对

试写一个判别表达式中开，闭括号是否配对出现的算法。

比如： ( a + b ( c − d ) ) (a+b(c-d)) (a+b(c−d)) 是配对出现的，而 ( d − e ) ) (d-e)) (d−e)) 不是配对出现的。

输入： 表达式，如： a + b ( c − d ) a+b(c-d) a+b(c−d)。

输出： 表达式中的括号配对出现，则输出 1 1 1，否则输出 0 0 0。

输入示例1：

(a+b(c-d))

输出示例1：

1

输入示例2：

(d-e))

输出示例2：

0

代码：

/* 试写一个判别表达式中开,闭括号是否配对出现的算法。比如:'(a+b(c-d))'是配对出现的,
*  而'(d-e))'不是配对出现的。*/
#include <stdio.h>
#include <stdlib.h>
#define ERROR           1
#define OK              0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  10
#define INFEASIBLE      -1
#define OVERFLOW        -2

typedef int Status;
typedef char SElemtype;
typedef struct {
    SElemtype* base;
    SElemtype* top;
    int stacksize;
} SqStack;

// 构造一个空栈 S
extern Status InitStack(SqStack *S);
// 若栈不空，则用 e 返回 S 的栈顶元素，并返回 OK；否则返回 ERROR
extern Status GetTop(SqStack S, SElemtype *e);
// 插入元素 e 为新的栈顶元素
extern Status Push(SqStack *S, SElemtype *e);
// 若栈不空，则删除栈顶元素，用 e 返回其值，并返回 OK；否则返回 ERROR
extern Status Pop(SqStack *S, SElemtype *e);
// 若栈 S 为空栈，则返回 TRUE，否则返回 FAUSE
extern Status StackEmpty(SqStack *S);

int main()
{
    SqStack S;
    InitStack(&S);
    char c = '0', e;
    while ((c = getchar()) != EOF && c != '\n') {
        switch (c)
        {
        case '(':
            Push(&S, '(');
            break;
        case '[':
            Push(&S, '[');
            break;
        case '{':
            Push(&S, '{');
            break;
        case ')':
            if (StackEmpty(&S)) {
                printf("0\n");
                return 0;
            }
            GetTop(S, &e);
            if (e == '(') {
                Pop(&S, &e);
                break;
            }
            else {
                printf("0\n");
                return 0;
            }
        case ']':
            if (StackEmpty(&S)) {
                printf("0\n");
                return 0;
            }
            GetTop(S, &e);
            if (e == '[') {
                Pop(&S, &e);
                break;
            }
            else {
                printf("0\n");
                return 0;
            }
        case '}':
            if (StackEmpty(&S)) {
                printf("0\n");
                return 0;
            }
            GetTop(S, &e);
            if (e == '{') {
                Pop(&S, &e);
                break;
            }
            else {
                printf("0\n");
                return 0;
            }
        default:
            break;
        }
    }
    if (StackEmpty(&S)) {
        printf("1\n");
    }
    else {
        printf("0\n");
    }
    return 0;
}

Status InitStack(SqStack* S)
{
    S->base = (SElemtype*)malloc(STACK_INIT_SIZE * sizeof(SElemtype));
    if (!S->base) exit(OVERFLOW);
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}// InitStack

Status GetTop(SqStack S, SElemtype *e)
{
    if (S.top == S.base) return ERROR;
    *e = *(S.top - 1);
    return OK;
}// GetTop

Status Push(SqStack* S, SElemtype *e)
{
    if (S->top - S->base >= S->stacksize) {
        S->base = (SElemtype*)realloc(S->base,
            (S->stacksize + STACKINCREMENT) * sizeof(SElemtype));
        if (!S->base) exit(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *S->top++ = e;
    return OK;
}// Push

Status Pop(SqStack* S, SElemtype *e)
{
    if (S->top == S->base) return ERROR;
    *e = *--S->top;
    return OK;
}// Pop

Status StackEmpty(SqStack* S)
{
    if (S->top == S->base) return ERROR;
    else return OK;
}// StackEmpty

三、3.20-图像区域颜色置换

假设以二维数组 g ( 1.. m , 1.. n ) g(1..m, 1..n) g(1..m,1..n) 表示一个图像区域， g [ i , j ] g[i, j] g[i,j] 表示该区域中点 ( i , j ) (i, j) (i,j) 所具颜色，其值为从 0 0 0 到 k k k 的整数。

编写算法置换点 ( i , j ) (i, j) (i,j) 所在区域的颜色。约定和 ( i , j ) (i, j) (i,j) 同色的上、下、左、右的邻接点为同色区域的点。

输入： 输入分为两部分，第一部分为第一行输入二维数组的行数、列数、染色起点位置的行坐标与列坐标以及染色开始方向。

中间以空格隔开，其中，行坐标与列坐标均以 ０ ０ ０ 开始，染色方向为上下左右，为枚举结构 ( 0 , 1 , 2 , 3 ) (0,1,2,3) (0,1,2,3)。

第二部分为二维数组形状输入，开始图像着色，用数字 2 2 2 来替换二维数组中 1 1 1 的位置。

输出： 着色完成的图像（即二维数组）

输入示例：

10 17 9 8 3
0 0 1 1 1 0 0 0 0 0 0 0 1 1 1 0 0
0 1 1 1 1 1 1 0 0 0 1 1 1 1 1 1 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 1 1 1 1 1 1 1 1 1 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 1 1 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0

输出示例：

00222000000022200
02222220002222220
22222222222222222
22222222222222222
02222222222222220
00022222222222000
00002222222220000
00000022222000000
00000002220000000
00000000200000000

代码：

题目是这样的，但是OJ上判定方式仅仅是输出，我就用一个动态二维数组草草了事了，毕竟，懒啊。

/* 假设以二维数组g(1..m, 1..n)表示一个图像区域, g[i, j]表示该区域中点(i, j)
*  所具颜色，其值为从0到k的整数。编写算法置换点(i_, j_)所在区域的颜色。约定和
*  (i_, j_)同色的上、下、左、右的邻接点为同色区域的点。*/
#include <stdio.h>
#include <stdlib.h>

typedef int AElemtype;

int main()
{
    AElemtype** p;
    int i = 0, j = 0, c = 0;
    scanf("%d %d", &i, &j);
    while ((c = getchar()) != '\n');
    p = (AElemtype**)malloc((j+1) * sizeof(AElemtype *));
    for (int k = 0; k < j; k++) {
        p[k] = (AElemtype*)malloc((i+1) * sizeof(AElemtype));
    }
    for (int n = 0; n < i; n++)
        for (int m = 0; m < j; m++)
            scanf("%d", &p[m][n]);

    for (int n = 0; n < i; n++) {
        for (int m = 0; m < j; m++) {
            if (p[m][n] == 1)
                printf("2");
            else
                printf("0");
        }
        printf("\n");
    }
    return 0;
}

四、3.21-逆波兰式

假设表达式由单字母变量和双目四则运算符构成。试写一个算法，将一个通常书写形式且书写正确的表达式转换为逆波兰式。

输入： 常规运算表达式，比如 a + b a+b a+b。

输出： 逆波兰式，比如 a b + ab+ ab+。

输入示例1：

A+B*(C-D)-E*F

输出示例1：

ABCD-*+EF*-

输入示例2：

b*c/d

输出示例2：

bc*d/

代码：

/* 假设表达式由单字母变量和双目四则运算符构成。试写一个算法,将一个通常书写形式且
*  书写正确的表达式转换为逆波兰式。*/
#include <stdio.h>
#include <stdlib.h>
#define TRUE            1
#define FALSE           0
#define ERROR           1
#define OK              0
#define STACK_INIT_SIZE 100
#define STACKINCREMENT  10
#define INFEASIBLE      -1
#define OVERFLOW        -2

typedef int Status;
typedef char SElemtype;
typedef struct {
    SElemtype* base;
    SElemtype* top;
    int stacksize;
} SqStack;

// 构造一个空栈 S
extern Status InitStack(SqStack* S);
// 若栈 S 为空栈，则返回 TRUE，否则返回 FAUSE
extern Status StackEmpty(SqStack* S);
// 若栈不空，则用 e 返回 S 的栈顶元素，并返回 OK；否则返回 ERROR
extern Status GetTop(SqStack S, SElemtype* e);
// 插入元素 e 为新的栈顶元素
extern Status Push(SqStack* S, SElemtype* e);
// 若栈不空，则删除栈顶元素，用 e 返回其值，并返回 OK；否则返回 ERROR
extern Status Pop(SqStack* S, SElemtype* e);
// 打印栈，若栈为空则返回 ERROR
extern Status PrintStack(SqStack S);

int main()
{
    SqStack S, tmp;
    InitStack(&S);
    InitStack(&tmp);
    char e = '0', c = '0';
    while ((e = getchar()) != '\n' && e != EOF) {
        if ((e >= 'A' && e <= 'Z') || e >= 'a' && e <= 'z') {
            Push(&S, &e);
        }
        else if (StackEmpty(&tmp))
            Push(&tmp, &e);
        else {
            switch (e)
            {
            case '+':
                GetTop(tmp, &c);
                while ((c == '*' || c == '/' || c == '+') && !StackEmpty(&tmp)) {
                    Pop(&tmp, &c);
                    Push(&S, &c);
                    GetTop(tmp, &c);
                }
                Push(&tmp, &e);
                break;
            case '-':
                GetTop(tmp, &c);
                while ((c == '*' || c == '/' || c == '+') && !StackEmpty(&tmp)) {
                    Pop(&tmp, &c);
                    Push(&S, &c);
                    GetTop(tmp, &c);
                }
                Push(&tmp, &e);
                break;
            case '*':
                GetTop(tmp, &c);
                while (c == '/' && !StackEmpty(&tmp)) {
                    Pop(&tmp, &c);
                    Push(&S, &c);
                    GetTop(tmp, &c);
                }
                Push(&tmp, &e);
                break;
            case '/':
                GetTop(tmp, &c);
                while (c == '*' && !StackEmpty(&tmp)) {
                    Pop(&tmp, &c);
                    Push(&S, &c);
                    GetTop(tmp, &c);
                }
                Push(&tmp, &e);
                break;
            case '(':
                Push(&tmp, &e);
                break;
            case ')':
                GetTop(tmp, &c);
                while (c != '(') {
                    Pop(&tmp, &c);
                    Push(&S, &c);
                    GetTop(tmp, &c);
                }
                Pop(&tmp, &c);
                break;
            default:
                break;
            }
        }
    }
    GetTop(tmp, &c);
    while (!StackEmpty(&tmp)) {
        Pop(&tmp, &c);
        Push(&S, &c);
        GetTop(tmp, &c);
    }

    PrintStack(S);
    return 0;
}

Status InitStack(SqStack* S)
{
    S->base = (SElemtype*)malloc(STACK_INIT_SIZE * sizeof(SElemtype));
    if (!S->base) exit(OVERFLOW);
    S->top = S->base;
    S->stacksize = STACK_INIT_SIZE;
    return OK;
}// InitStack

Status GetTop(SqStack S, SElemtype* e)
{
    if (S.top == S.base) return ERROR;
    *e = *(S.top - 1);
    return OK;
}// GetTop

Status Push(SqStack* S, SElemtype* e)
{
    if (S->top - S->base >= S->stacksize) {
        S->base = (SElemtype*)realloc(S->base,
            (S->stacksize + STACKINCREMENT) * sizeof(SElemtype));
        if (!S->base) exit(OVERFLOW);
        S->top = S->base + S->stacksize;
        S->stacksize += STACKINCREMENT;
    }
    *S->top++ = *e;
    return OK;
}// Push

Status Pop(SqStack* S, SElemtype* e)
{
    if (S->top == S->base) return ERROR;
    *e = *--S->top;
    return OK;
}// Pop

Status StackEmpty(SqStack* S)
{
    if (S->top == S->base) return ERROR;
    else return OK;
}// StackEmpty

Status PrintStack(SqStack S)
{
    if (StackEmpty(&S)) return ERROR;
    while (!StackEmpty(&S))
        printf("%c", *(S.base++));
    printf("\n");
    return OK;
}// PrintStack

五、3.24-递归函数计算

试编写如下定义的递归函数的递归算法，并根据算法画出求 ｇ ( 5 , 2 ) ｇ(5,2) ｇ(5,2) 时栈的变化过程。

g ( m , n ) = 0 ( m = 0 , n > = 0 ) g ( m , n ) = g ( m − 1 , 2 n ) + n ( m > 0 , n > = 0 ) g(m, n) = 0 (m = 0, n>=0) g(m, n) = g(m-1, 2n) + n (m>0, n>=0) g(m,n)=0(m=0,n>=0)g(m,n)=g(m−1,2n)+n(m>0,n>=0)

输入： 输入 ｍ ｍ ｍ 与 n n n 的数值，中间以逗号隔开。

输出： 递归计算后， g ( m , n ) g(m, n) g(m,n) 的值。

输入样例：

5，2

输出样例：

62

代码：

/* 试编写如下定义的递归函数的递归算法，并根据算法画出求ｇ(5, 2)时栈的变化过程。
*  g(m, n)  = 0 (m = 0, n>=0)   g(m, n) = g(m-1, 2n) + n (m>0, n>=0) */
#include <stdio.h>

extern int g(int m, int n);

int main()
{
    int m = 0, n = 0;
    scanf("%d,%d", &m, &n);
    printf("%d\n", g(m, n));
    return 0;
}

int g(int m, int n)
{
    if (m > 0) return (g(m-1, 2*n) + n);
    else return 0;
}

六、3.25-递归函数非递归法计算

试写出求递归函数 Ｆ ( n ) Ｆ(n) Ｆ(n) 的递归算法，并消除递归:
F ( n ) = n + 1 ( n = 0 ) , F ( n ) = n ∗ F ( n / 2 ) ( n > 0 ) F(n ) = n + 1 (n = 0),F(n) = n * F(n / 2) (n > 0) F(n)=n+1(n=0),F(n)=n∗F(n/2)(n>0)

输入： 输入非负整数 ｎ ｎ ｎ。

输出： 计算出的 F ( n ) F(n) F(n) 函数的值。

输入样例：

10

输出样例：

100

代码：

/* 试写出求递归函数Ｆ(n)的递归算法，并消除递归:
*      F(n) = n + 1 (n = 0)
*      F(n) = n * F(n / 2) (n > 0) */
#include <stdio.h>

extern int F(int n);

int main()
{
    int n = 0;
    scanf("%d", &n);
    printf("%d\n", F(n));
    return 0;
}

int F(int n)
{
    if (n > 0) return (n * F(n/2));
    else return (n + 1);
}

七、3.28-队列实现

假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点（注意不设头指针），试编写相应的队列初始化、入队列和出队列的算法。

输入： 输入分为两行，第一行表示队列个数，第二行表示入队列的元素序列，中间以逗号隔开。

输出： 队列出队列的元素序列，中间以逗号隔开。

输入示例：

5
1,2,3,4,5

输出示例：

1,2,3,4,5

代码：

/* 假设以带头结点的循环链表表示队列，并且只设一个指针指向队尾元素结点(注意
*  不设头指针)，试编写相应的队列初始化、入队列和出队列的算法 */
#include <stdio.h>
#include <stdlib.h>
#define OK 0
#define ERROR 1
#define OVERFLOW -2
#define MAXQSIZE 100

typedef int QElemtype;
typedef int Status;

typedef struct {
    QElemtype *base;
    int rear;
} SqQueue;

// 插入队列并初始化
extern Status InitQueue(SqQueue *Q);
// 插入元素 e 为 Q 新的队尾元素
extern Status EnQueue(SqQueue *Q, QElemtype e);
// 若队列不空，则删除 Q 的队头元素，用 e 返回其值，并返回 OK，否则返回 ERROR
extern Status DeQueue(SqQueue *Q, QElemtype *e);

int main()
{
    int len = 0;
    QElemtype e = 0;
    scanf("%d", &len); getchar();
    SqQueue Q;
    InitQueue(&Q);

    for (int i = 0; i < len; i++) {
        scanf("%d", &e); getchar();
        EnQueue(&Q, e);
    }

    DeQueue(&Q, &e);
    int s[MAXQSIZE];
    for (int i = 0; i < len; i++) {
        DeQueue(&Q, &e);
        s[len - i] = e;
    }
    for (int i = 0; i < len; i++) {
        printf("%d", s[i + 1]);
        if (i < len - 1) printf(",");
        else printf("\n");
    }
    return 0;
}

Status InitQueue(SqQueue *Q)
{
    Q->base = (QElemtype *)malloc(MAXQSIZE * sizeof(QElemtype));
    if (!Q->base) exit(OVERFLOW);
    Q->rear = 0;
    return OK;
}// InitQueue

Status EnQueue(SqQueue *Q, QElemtype e)
{
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXQSIZE;
    return OK;
}

Status DeQueue(SqQueue *Q, QElemtype *e)
{
    *e = Q->base[Q->rear];
    Q->rear = (Q->rear - 1) % MAXQSIZE;
    return OK;
}

八、3.31-回文字符串

假设称正读和反读都相同的字符序列为回文，例如， a b b a abba abba 和 a b c b a abcba abcba 是回文，而 a b c d e abcde abcde 和 a b a b a b ababab ababab 则不是回文。

试写一个算法判别读入的一个以 @ @ @ 为结束符的字符序列是否为回文。

输入： 输入字符串，以@结尾。

输出： 是回文则输出 1 1 1，否则输出 0 0 0。

输入样例1：

abba@

输出样例1：

1

输入样例2：

abcde@

输出样例2：

0

代码：

/* 假设称正读和反读都相同的字符序列为"回文",例如,'abba'和'abcba'是回文，
*  而'abcde'和'ababab'则不是回文。
*  试写一个算法判别读入的一个以'@'为结束符的字符序列是否为回文。*/
#include <stdio.h>
#include <stdlib.h>
#define OK 0
#define ERROR 1
#define OVERFLOW -2
#define MAXQSIZE 100

typedef char QElemtype;
typedef int Status;

typedef struct {
    QElemtype* base;
    int front;
    int rear;
} SqQueue;

// 插入队列并初始化
extern Status InitQueue(SqQueue* Q);
// 返回 Q 的元素个数，即队列的长度
extern Status QueueLength(SqQueue Q);
// 插入元素 e 为 Q 新的队尾元素
extern Status EnQueue(SqQueue* Q, QElemtype e);
// 若队列不空，则删除 Q 的队头元素，用 e 返回其值，并返回 OK，否则返回 ERROR
extern Status DeQueue(SqQueue* Q, QElemtype* e);
// 若队列不空，则删除 Q 的队尾元素，用 e 返回其值，并返回 OK，否则返回 ERROR
extern Status UnEnQueue(SqQueue* Q, QElemtype* e);

int main()
{
    SqQueue Q;
    InitQueue(&Q);
    char c = '0';
    while ((c = getchar()) != '@') {
        EnQueue(&Q, c);
    }
    char tmp1, tmp2;
    do {
        DeQueue(&Q, &tmp1);
        UnEnQueue(&Q, &tmp2);
    } while (tmp1 == tmp2 && QueueLength(Q) > 1);
    if (QueueLength(Q) <= 1) {
        printf("1\n");
        return 0;
    }
    else {
        printf("0\n");
        return 0;
    }
}

Status InitQueue(SqQueue* Q)
{
    Q->base = (QElemtype*)malloc(MAXQSIZE * sizeof(QElemtype));
    if (!Q->base) exit(OVERFLOW);
    Q->front = Q->rear = 0;
    return OK;
}// InitQueue

Status QueueLength(SqQueue Q)
{
    return (Q.rear - Q.front + MAXQSIZE) % MAXQSIZE;
}// QueueLength

Status EnQueue(SqQueue* Q, QElemtype e)
{
    if ((Q->rear + 1) % MAXQSIZE == Q->front) return ERROR;
    Q->base[Q->rear] = e;
    Q->rear = (Q->rear + 1) % MAXQSIZE;
    return OK;
}// EnQueue

Status DeQueue(SqQueue* Q, QElemtype* e)
{
    if (Q->front == Q->rear) return ERROR;
    *e = Q->base[Q->front];
    Q->front = (Q->front + 1) % MAXQSIZE;
    return OK;
}// DeQueue

Status UnEnQueue(SqQueue* Q, QElemtype* e)
{
    if (Q->front == Q->rear) return ERROR;
    *e = Q->base[Q->rear - 1];
    Q->rear = (Q->rear - 1) % MAXQSIZE;
    return OK;
}// UnEnQueue

总结

本章学习栈与队列，在调试时不能直观看到数据，必须依靠自己大脑推理，但是题目本身比较简单，花费时间不多。

Jun from a nut shell
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
UVa Online Judge 所有题目PDF题面（合并版）
02-07
自己整理的UVa所有题目的PDF题面，可根据目录中的Volume快速跳转（与UVa官网一致）。 题目共4965题，PDF共8380页，可能会出现打开较慢的问题。 关于某个题目所在位置的判断方法： 题号除了后两位的其他数字构成...
数据结构Online Judge第一章题目(C语言版)
weixin_70911939的博客
03-31 373
数据结构Online Judge第一章题目(C语言版)
New Online Judge题解1000
weixin_52529894的博客
01-16 2620
目录 前言 一、题目描述 二、输入格式 三、输出格式 四、解决方法 前言 从今天开始，我会更新我在New Online Judge网站上做过的题目的解决方法以及代码，希望大家能够支持一下，当然也可以加个关注，我们一起讨论。 一、题目描述 给定两个整数a，b(0<=a, b<=1000)，计算a+b的值 二、输入格式 有多组测试数据，每组一行，每行有两个整数a，b。 三、输出格式 输出a+b的值 四、解决方法以及完整代码 这个题目是一个非常简单的题目..
【c语言oj练习】Online Judge Practice 5
MING.MING的博客
02-25 653
Online Judge Practice 5c语言oj练习一、指向函数的指针二、使用函数指针求最大最小值三、使用函数指针作为函数的参数四、使用函数指针求通用积分五、指针数组六、使用结构体进行选举投票七、使用结构体对学生成绩进行排名八、结构体数组的使用九、建立静态链表十、建立动态链表十一、共用体union的使用十二、枚举enum的使用十三、typedef定义结构体十四、计算天数十五、定义输入输出函...
C++ : Online Judge 输入输出练习
麻城明歌的博客
03-30 1540
C++ : Online Judge 输入输出练习 目录： 1-7、A+B(1-7) 8-10、字符串排序(1-3) 相关文章：OJ编程题教训 相关题目：牛客网OJ在线编程常见输入输出练习场 注意如何理解 while ( cin>>n ) ： “读入不定多行” cin 是标准输入流对象，即istream类的对象，其从标准输入缓冲区中读出数据； 而每次从键盘键入时，只有按下回车，...
算法竞赛：Online Judge介绍
依稀_yixy的博客
04-26 7731
算法竞赛，Online Judge系统的介绍
Online Judge（在线判题系统）+源代码
12-05
Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++、Pascal）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验程序源代码的正确性。欢迎下载，内含源...
青岛大学开源 Online Judge
11-03
青岛大学开源 Online Judge | QQ群 496710125 。。。。。
基于Online Judge的C语言程序设计实验课教学改革研究.pdf
12-05
基于Online Judge的C语言程序设计实验课教学改革研究.pdf
jnoj:Jiangnan Online Judge
05-25
Jiangnan Online Judge江南在线评测系统（Jiangnan Online Judge），是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++、Java）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验...
leetcode题库-OnlineJugg:各大OnlineJudge练习
06-29
leetcode题库 Online Judge习题笔记 本项目收录了我在各个Online Judge上做的习题以及相关的笔记。目前绝大多数的题目来自于HackerRank和LeetCode。 关于刷题 这里我想多说两句我对刷题的看法。我于本科二年级暑假开始大规模的做题目。相比于从大学一年级甚至初高中就开始训练CS能力的同学来说，这一时间点已经算非常晚了。说来惭愧，之前的很长一段时间里我只注意看书而没有注意做练习。 看书是一件很轻松的事情，看几页之后就可以胸有成竹的与人坐而论道——反正没有人会深究我的基本功。而刷题只有前几道是有滋有味的，后面的题目不是因为重复而感到无聊就是因为困难而感到挫败。 后来我越来越发现逃避做练习就是麻醉自己。有人说刷题不是提高计算机能力的最好方法，过度刷题甚至会误入歧途。我深表同意，但是这是给胖子说要注意饮食的话，而我现在是个营养不良急需暴饮暴食的人。 本项目名中的Jugg指代Judge，Jugg实际上是我最喜欢的DOTA英雄剑圣的原名。剑圣Jugg的游戏配音里有这样一句话：“勤练带来力量。” 最后我想送上我国著名统计学老前辈陈希孺对刷题的一番看法，正是这一段话
在线online judge
02-04
在线测评地址，共享资源。地址正确。！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
online judge（在线判题系统）源代码
07-27
Online Judge系统（简称OJ）是一个在线的判题系统。用户可以在线提交程序多种程序（如C、C++、Pascal）源代码，系统对源代码进行编译和执行，并通过预先设计的测试数据来检验程序源代码的正确性。
online judge
09-19
本资源为自己开发的online judege的源码
计算机概论A—Coursera—北京大学Online judge习题以及答案
02-06
最新一期的Coursera 程序设计与算法课程项目（答案）合集 PKU这个的课程的核心就在于他的编程实践，全部是是现实实例的应用，绝对经典。 这里是项目的答案，是我自己在学习的过程中做的。请大家谨慎参考。这些答案都通过了课程的验证并且拿到了满分，所以虽然不敢说是最优解，但在正确性上还是有保证的。不包含答案的部分也在我的分享资源里面。 因为是原创，所以我想下载给5分是值得的，但是依然希望大家谨慎下载，毕竟只有自己亲自编程才会有收获，看别人的永远是别人的。
链表试题之链表分割
qq_56663697的博客
09-01 210
题目简介 现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序，返回重新排列后的链表的头指针。 链表分割 思路分析 代码实现 struct ListNode* partition(pHead,x) { // write code here struct ListNode* greatertail, *greaterhead, *lesstail, *lesshead; greaterhead = greatertai
顺序栈的基础功能实现（C++）
m0_71439858的博客
11-02 114
顺序栈的基础功能实现（C++）
数据结构--顺序栈
weixin_46203845的博客
12-02 81
#include <stdio.h> #include <stdlib.h> //预定义常量和类型 #define OK 1 #define ERROR 0 #define OVERFLOW -2 #define STACK_INIT_SIZE 100 //存储空间分配量 #define STACKINCREMENT 10 //存储空间分配增量 typedef Status; typedef int SElemType; typedef struct{ SElemType
数据结构第3~4章练习答案（PTA）
最新发布
Yhan涵涵
05-25 1584
在这里描述函数接口。例如：//初始化栈//入栈//出栈接口参数:Q是循环队列，N是队列数组空间容量，x是入队元素，e用于接收出队元素的值。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值