2023 级新生周赛第二周题解

#include <stdio.h>

int main() {
    switch (getchar()) {
        case 'a':
            printf("掌握提问艺术，从你我他做起");
            break;
        case 'b':
            printf("严禁发布色情内容，严禁涉政")；
            break;
        case 'm':
            printf("萌新不推荐使用 vs");
            break;
        case 'o':
            printf("oj 平台如果自己原来有一个账号的话用学校注册的账户继续往后写就行了，不需要把写过的题再交一遍。");
            break;
        case 's':
            printf("编写代码务必注意代码规范");
            break;
        case 't':
            printf("多读书多动手，编程能力是练出来的不是想出来的");
            break;
        case 'w':
            printf("本群可以灌水但不要一直灌水");
            break;
    }
    return 0;
}

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

int main() {
    char input[20];
    gets(input);
    if (strcmp(input, "base") == 0)
        printf("严禁发布色情内容，严禁涉政");
    else if (strcmp(input, "attention ms") == 0)
        printf("萌新不推荐使用 vs");
    else if (strcmp(input, "water") == 0)
        printf("本群可以灌水但不要一直灌水");
    else if (strcmp(input, "train") == 0)
        printf("多读书多动手，编程能力是练出来的不是想出来的");
    else if (strcmp(input, "ask question") == 0)
        printf("掌握提问艺术，从你我他做起")
    else if (strcmp(input, "oj") == 0)
        printf("oj 平台如果自己原来有一个账号的话用学校注册的账户继续往后写就行了，不需要把写过的题再交一遍。");
    else
        printf("编写代码务必注意代码规范");
    return 0;
}

#include <stdio.h>
#include <math.h>

int main () {
    double m, n;
    int p;
    scanf("%lf %lf %d", &m, &n, &p);
    double ans = m * pow(2.718281828459045, -0.114514 * n);
    printf("%.*f", p, ans);
//  char exp[10];
//  sprintf(exp, "%%.%df", p);
//  printf(exp, ans);
    return 0;
}

#include <stdio.h>
#include <stdbool.h>

int main() {
    int n;
    int sum = 0;
    char p;
    while (true) {
        scanf("%d", &n);
        int c = scanf("%c", &p);    // 1 2 2 0.0 2 0
        if (c != EOF && p == '.') {
            scanf("%*d");   // 使用 %*d 跳过下一个整数
            continue;
        } else if (n == 0) break;
        sum += n;
    }
    printf("%d", sum);
    return 0;
}

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

int main() {
    int record[1001];
    memset(record, 0, sizeof(record));
    int id;
    int result = 0;
    while (~scanf("%*s %d %*s", &id)) {
        if (++record[id - 100000000] == 1) ++result;
    }
    printf("%d", result);
    return 0;
}

#include <stdio.h>
#include <limits.h>

int main() {
    int input;
    scanf("%d", &input);
    unsigned result = UINT_MAX >> (32 - input);
    // unsigned result = ((unsigned) -1) >> (32 - input);
    for (int i = 0; i != input; ++i) {
        printf("%u\n", result);
    }
    return 0;
}

#include <stdio.h>

int main () {
    int n, k, code;
    scanf("%d %d", &n, &k);
    int end = 1 << n;
    while (k--) {
        scanf("%d", &code);
        int mask = 1 << (code - 1);
        for (int i = 1; i != end; ++i) {
            if ((i & mask) != 0)
                printf("%d ", i);
        }
        printf("\n");
    }
    return 0;
}

#include <stdio.h>

typedef unsigned long long LLU;

int main () {
    int k;
    LLU i;
    while (~scanf("%*d %d %llu", &k, &i)) {
        if (k == 0 && i == 0) break;
        LLU interval = LLU(1) << (k - 1);
        LLU div = i / interval;
        LLU mod = i % interval;
        LLU result = (div * interval << 1) + (mod == 0 ? 0 : interval + mod) - 1;
        printf("%llu\n", result);
    }
    return 0;
}

#include <stdio.h>

typedef unsigned long long LLU;

int main() {
    LLU var, real;
    scanf("%llx %llo", &var, &real);
    printf("%d", (int) (var - real));
    return 0;
}

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

typedef long long LL;
typedef struct Mark Mark;
// 用链表实现一个栈
struct Mark {
    Mark* prev;     // 上一个节点
    char* type; // 节点名称
};

bool readln(char* str);
bool invoke();
void pushItem(char* name, int start, int end);
char* popItem();
int indexOfAny(const char* src, int start, int end, char* items);
char* indexOfInRange(char* src, int length, const char* that);
bool strEquals(char* src, int length, const char* that);
bool isSelfClosing(char* src, int start, int end);

char distId[1010] = {'i', 'd', '=', '"'};  // 目标 ID
char input[1001];   // 单行输入
char content[3001];  // 结果
bool hit = false;   // 判断是否找到了 id 为指定字符串的标签
Mark* linkedList = NULL;

int main() {
    readln(distId + 4);
    int idLength = (int) strlen(distId);
    distId[idLength] = '"';
    distId[idLength + 1] = '\0';
    if (!invoke()) printf("duo lao a cjmm");
    else if (!hit) printf("duo lao a cjjj");
    else {
        bool isNotBlank = false;
        for (int i = 0; content[i] != '\0'; ++i) {
            switch (content[i]) {
                case ' ': case '\t': case '\n':
                    break;
                default:
                    isNotBlank = true;
                    goto skipFor;
            }
        }
        skipFor:
        if (!isNotBlank) printf("QAQ");
        else {
            int start = 0;
            for (; content[start] != '\0'; ++start) {
                if (content[start] != '\n') break;
            }
            printf("%s", content + start);
        }
    }
    return 0;
}

bool invoke() {
    bool skip = false;
    char* contentStartFlag = NULL;
    int contentStartIndex;
    int contentLength = 0;
    while (readln(input)) {
        int length = (int) strlen(input);
        int i = 0;
        if (skip) {
            LL endIndex = (LL) (strstr(input, "-->") - input);
            if (endIndex < 0) continue;
            i = (int) (endIndex + 3);
        }
        while (i != length) {
            LL tmp = (LL) (strchr(input + i, '<') - input);
            if (tmp < 0) break;
            int startIndex = (int) tmp;
            // 判断是否是注释
            if (startIndex + 3 < length && input[startIndex + 1] == '!' && input[startIndex + 2] == '-' && input[startIndex + 3] == '-') {
                LL endIndex = (LL) (strstr(input + i, "-->") - input);
                if (endIndex < 0) { // endIndex < 0 表明注释不在一行内结束
                    skip = true;
                    break;
                }
                i = (int) (endIndex + 3);   // 如果在一行内结束就跳过注释中的内容
                continue;
            }
            int endIndex = (int) (strchr(input + startIndex + 1, '>') - input);
            if (input[startIndex + 1] == '/') { // 如果是结束标记
                char* oldName = popItem();
                if (oldName == NULL) return false;  // 没有开始标记，结构错误
                bool isEquals = strEquals(input + startIndex + 2, endIndex - startIndex - 2, oldName);
                bool isContent = oldName == contentStartFlag;
                free(oldName);
                if (!isEquals) return false;    // 开始标记和结束标记不对应，结构错误
                if (isContent) {
                    contentStartFlag = NULL;
                    int len = startIndex - contentStartIndex;
                    memcpy(content + contentLength, input + contentStartIndex, sizeof(char) * len);
                    contentLength += len;
                }
            } else {    // 如果是开始标记
                int nameEndIndex = indexOfAny(input, startIndex + 1, endIndex + 1, " >");
                bool selfClosing = input[endIndex - 1] == '/' || isSelfClosing(input, startIndex + 1, nameEndIndex);
                if (!selfClosing) pushItem(input, startIndex + 1, nameEndIndex);
                char* idIndex = indexOfInRange(input + startIndex + 1, endIndex - startIndex - 1, distId);
                if (idIndex != NULL) {  // 如果找到了对应的 ID
                    hit = true;
                    if (!selfClosing) {
                        contentStartFlag = linkedList->type;
                        contentStartIndex = endIndex + 1;
                    }
                }
            }
            i = endIndex + 1;
        }
        if (contentStartFlag != NULL) {
            int len = length - contentStartIndex;
            memcpy(content + contentLength, input + contentStartIndex, sizeof(char) * len);
            contentLength += len;
            contentStartIndex = 0;
            content[contentLength++] = '\n';
        }
    }
    content[contentLength] = '\0';
    return !skip && linkedList == NULL;
}

/** 读取一行数据 */
bool readln(char* str) {
    memset(str, 0, sizeof(char) * 1000);
    char *flag = gets(str);
    return flag != NULL;
}

// 在字符串的指定范围内查找 items 中字符最早出现的那一个的下标
int indexOfAny(const char* src, int start, int end, char* items) {
    for (int i = start; i != end; ++i) {
        char value = src[i];
        char* dist = strchr(items, value);
        if (dist != NULL) return i;
    }
    return -1;
}

// 推送一个节点到栈中
void pushItem(char* name, int start, int end) {
    Mark* newItem = malloc(sizeof(Mark));
    newItem->prev = linkedList;
    int length = end - start;
    newItem->type = malloc(sizeof(char) * (length + 1));
    memcpy(newItem->type, name + start, sizeof(char) * length);
    newItem->type[length] = '\0';
    linkedList = newItem;
}

// 弹出栈顶元素
char* popItem() {
    if (linkedList == NULL) return NULL;
    Mark* oldItem = linkedList;
    char* oldType = oldItem->type;
    linkedList = oldItem->prev;
    free(oldItem);
    return oldType;
}

// 在指定范围内比较字符串是否相等
bool strEquals(char* src, int length, const char* that) {
    char tmp = src[length];
    src[length] = '\0';
    bool result = strcmp(src, that) == 0;
    src[length] = tmp;
    return result;
}

// 在指定范围内查找字符串
char* indexOfInRange(char* src, int length, const char* that) {
    char tmp = src[length];
    src[length] = '\0';
    char* result = strstr(src, that);
    src[length] = tmp;
    return result;
}

const char SELF_LIST[][11] = {"br", "hr", "img", "input", "link", "meta", "area"};

// 判断是否是自闭合标签
bool isSelfClosing(char* src, int start, int end) {
    src = src + start;
    int length = end - start;
    for (int i = 0; i != 7; ++i) {
        if (strEquals(src, length, SELF_LIST[i]))
            return true;
    }
    return false;
}