comp10002 Foundations of Algorithms Semester 2, 2023 Assignment 1

// 原本
// typedef int longint_t;
// #define LONG_ZERO 0

typedef struct {
    int digits[INTSIZE+1];  /* +1 for the buddy variable */
} longint_t;
#define LONG_ZERO (longint_t){.digits = {0}}

// --------
// 定义一个名为longint_t的结构体类型。
// 这个结构体中包含一个名为digits的数组，其大小为INTSIZE+1。
// +1是为了额外的"buddy variable"。
typedef struct {
    int digits[INTSIZE+1];  /* +1 for the buddy variable */
} longint_t;

// 使用宏定义来创建一个longint_t类型的值，这个值的digits字段被初始化为全0。
// 这里使用了C99的指定初始化器（designated initializer）来明确初始化digits字段。
#define LONG_ZERO (longint_t){.digits = {0}}

/*
	下面的实现逻辑是，把用户输入的数字长度，存储到数组的 0 号位。
*/
// 从字符串中解析出长整型数值
longint_t parse_num(char *rhs) {
    longint_t result = LONG_ZERO;  // 声明一个 longint_t 类型的 result，并初始化位 LONG_ZERO
    int length = strlen(rhs);

    // 将数字的长度存储在数组的第一个索引
    result.digits[0] = length;

    // 从字符串中解析出数字，并反转存储（使得低位在前，高位在后）
    for (int i = 0; i < length; i++) {
        result.digits[i+1] = rhs[length-1-i] - '0';  // +1 的原因是 0 号位被我们定为数字长度
    }

    return result;
}


//-----------------
int i = 0;
while (i < length) {
    result.digits[i+1] = rhs[length-1-i] - '0';
    i++;
}

// 记得实现逆序实现，这个是实现的大体思路

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

// 创建一个映射数组，用于将字符 '0'-'9' 转换为整数 0-9
int char_to_digit[128] = {0};

void initialize_mapping() {
    for (char c = '0'; c <= '9'; c++) {
        char_to_digit[c] = c - '0';
    }
}

long long parse_num(char *rhs) {
    int length = strlen(rhs);
    long long result = 0;
    long long multiplier = 1;

    for (int i = 0; i < length; i++) {
        result += char_to_digit[rhs[length-1-i]] * multiplier;
        multiplier *= 10; // 移动到下一个数位
    }

    return result;
}

int main() {
    initialize_mapping();
    char numStr[] = "12345";
    long long num = parse_num(numStr);
    
    // 打印解析后的数字
    printf("%lld\n", num);
    return 0;
}

// 这个代码还没完善，最简单的思路是创建中间数组来实现。正确顺序的时候存到数组，然后再循环输出。

void do_print(int varnum, longint_t *var) {
    printf("register %c: ", varnum + CH_A);
    int count = 0;
    int length = var->numbers[0];
    printf("number length is %d\n", length);
    // for (int i = var->digits[0]; i > 0; i--) {
    //     printf("%d love ", var->digits[i]);
    // }
    for (int i = 1; i <= var->numbers[0]; i++) {
    	if (count == 3) {
    		printf(",");
   		count = 0;
    	}
    	printf("%d", var->numbers[i]);
    	count++;
    }

    printf("\n");
}

// 下面的实现比较巧妙，判断数字的长度是奇数还是偶数
// 如果是奇数，我们 remainder = remainder 这样 remainde 次后就需要逗，如果是偶数我们就每三个添加一个逗号即可实现
#include <stdio.h>

// 定义一个结构体来表示长整数类型
typedef struct {
    int numbers[100]; // 假设有一个固定大小的数组来存储数字，根据需要进行调整
    // int digits[100]; // 你注释掉了这一部分，所以我这里就省略了
} longint_t;

void do_print(int varnum, longint_t *var) {
    // 打印出寄存器的名称，这里使用 'A' 作为起始字母
    printf("register %c: ", varnum + 'a');

    int length = var->numbers[0];
    printf("number length is %d\n", length);

    // remainder 用于存储到下一个逗号之前需要多少个数字
    // 比如，如果 length 是 5，那么 remainder 就是 2（即 5%3），因为前两个数字之后就需要一个逗号
    int remainder = length % 3;
    // 如果数字总数可以被3整除（即 remainder 为0），我们从右边开始输出前三个数字，然后输出一个逗号
    remainder = remainder == 0 ? 3 : remainder;

    // 从最后一个数字开始逆向遍历
    for (int i = length; i > 0; i--) {
        // 当 remainder 减少到0时，我们需要在数字之间添加一个逗号
        if (remainder == 0) {
            printf(",");
            remainder = 3;  // 重置 remainder，因为我们知道之后每三个数字就需要一个逗号
        }

        printf("%d", var->numbers[i]); // 打印当前数字
        remainder--; // 减少 remainder，向左移动
    }

    printf("\n"); // 打印换行，使输出更加清晰
}

void
do_print(int varnum, longint_t *var) {
	printf("register %c: ", varnum+CH_A);
    int count=0;
    for(int i=0;i<=(var->length-1);i++){
        if(i%3==0&&i!=0){
            count+=1;
        }   
     }
     // printf("count %d: ", count);
     // int temp_array[(var->length)+count];
     // 创建一个临时数组，用于存储带有逗号的数字
     int len = (var->length)+count;
     char temp_array[len];
     int pos = 0;  // 使用 pos 变量来跟踪 temp_array 的当前位置
    
    // 遍历 Var 的所有位数，将其复制到 temp_array 中，并在合适的位置插入逗号
     // comma 数字数量
    for (int j = 0, comma = 0; j < var->length; j++, comma++) {
    	// 将数字转化为字符存储
        temp_array[pos++] = (char)((var->digits[j]) + '0');
        // 如果已经添加了三个数字，并且它不是最后一个数字，那么插入一个逗号
        if (comma == 2 && j != var->length - 1) { // 当前的长度，不能是现在数组的长度，因为开头不用添加
            temp_array[pos++] = ',';
            comma = -1;  // Reset comma count
        }
    }

    for (int k = len-1; k >= 0; k--) {
        printf("%c", temp_array[k]);
    }

    printf("\n");

void do_print(int varnum, longint_t *var) {
    // 打印寄存器名
    printf("register %c: ", varnum + 'A');

    int count = 0;
    // 遍历数字的所有位数，以确定要添加的逗号数量
    for (int i = 1; i < var->length; i++) {
        // 每三位数字后加一个逗号
        if (i % 3 == 0) {
            count++;
        }
    }

    // 创建一个临时数组，用于存储带有逗号的数字
    char temp_array[var->length + count];
    int pos = 0;  // 使用pos变量来跟踪temp_array的当前位置
    
    // 遍历var的所有位数，将其复制到temp_array中，并在适当的位置插入逗号
    for (int j = 0, comma = 0; j < var->length; j++, comma++) {
        // 将数字位转化为字符并存储
        temp_array[pos++] = (char)((var->digits[j]) + '0');
        
        // 如果已经添加了三个数字，并且它不是最后一个数字，那么插入一个逗号
        if (comma == 2 && j != var->length - 1) {
            temp_array[pos++] = ',';
            comma = -1;  // 重置comma计数
        }
    }

    // 打印temp_array的内容
    for (int k = 0; k < pos; k++) {
        printf("%c", temp_array[k]);
    }

    printf("\n");  // 打印换行符
}

// 记得声明函数
void check_overflow(longint_t *var);
void do_plus(longint_t *var1, longint_t *var2);


void check_overflow(longint_t *var) {
    if (var->digits[0] > INTSIZE) {
        printf("Overflow error! Exiting...\n");
        exit(EXIT_FAILURE);
    }
}

void do_plus(longint_t *var1, longint_t *var2) {
    int carry = 0;
    int maxLength = (var1->digits[0] > var2->digits[0]) ? var1->digits[0] : var2->digits[0];

    for (int i = 1; i <= maxLength || carry; i++) {
        if (i == INTSIZE+1) {
            var1->digits[0] = i;
            check_overflow(var1);
        }

        var1->digits[i] += carry + (i <= var2->digits[0] ? var2->digits[i] : 0);
        carry = var1->digits[i] / 10;
        var1->digits[i] %= 10;

        if (i > var1->digits[0]) {
            var1->digits[0] = i;
        }
    }
}

// 检查是否溢出，并在需要时退出程序
void check_overflow(longint_t *var) {
    if (var->digits[0] > INTSIZE) {
        printf("Overflow error! Exiting...\n");
        exit(EXIT_FAILURE);
    }
}

// 两个长整型数值相加
void do_plus(longint_t *var1, longint_t *var2) {
    int carry = 0; // 用于存储进位值
    int maxLength = (var1->digits[0] > var2->digits[0]) ? var1->digits[0] : var2->digits[0];

    // 从低位到高位进行加法运算
    for (int i = 1; i <= maxLength || carry; i++) {
        // 检查是否超出预定义的长度
        if (i == INTSIZE+1) {
            var1->digits[0] = i;
            check_overflow(var1);
        }

        // 加上进位和另一个数值（如果存在）
        var1->digits[i] += carry + (i <= var2->digits[0] ? var2->digits[i] : 0);
        carry = var1->digits[i] / 10;  // 计算进位
        var1->digits[i] %= 10;         // 取个位数值

        // 更新数字的实际长度
        if (i > var1->digits[0]) {
            var1->digits[0] = i;
        }
    }
}

void
do_multiply(longint_t *var1, longint_t *var2, longint_t *result) {
    int i, j, carry;
    int temp;

    // 初始化结果
    for (i = 0; i <= INTSIZE; i++) {
        result->numbers[i] = 0;
    }

    for (i = 1; i <= var1->numbers[0]; i++) {
        carry = 0;
        for (j = 1; j <= var2->numbers[0] || carry > 0; j++) {
            temp = result->numbers[i + j - 1] + var1->numbers[i] * var2->numbers[j] + carry;
            result->numbers[i + j - 1] = temp % 10;
            carry = temp / 10;
            result->numbers[0] = i + j - 1;
        }
    }
}

void
do_multiply(longint_t *var1, longint_t *var2, longint_t *result) {
    int i, j, carry;  // 定义两个循环变量 i 和 j，以及进位变量 carry
    int temp;  // 临时存储乘法和加法的结果

    // 初始化结果数组，确保开始时它是空的
    for (i = 0; i <= INTSIZE; i++) {
        result->numbers[i] = 0;
    }

    // 对于 var1 中的每个数字
    for (i = 1; i <= var1->numbers[0]; i++) {
        carry = 0;  // 每次开始新的 i 循环时，都将进位设置为 0
        // 对于 var2 中的每个数字或当还有进位时
        for (j = 1; j <= var2->numbers[0] || carry > 0; j++) {
            // 计算乘法的部分结果，并加上之前的值和进位
            temp = result->numbers[i + j - 1] + var1->numbers[i] * var2->numbers[j] + carry;
            result->numbers[i + j - 1] = temp % 10;  // 保存当前位的数字
            carry = temp / 10;  // 计算进位值
            result->numbers[0] = i + j - 1;  // 更新结果的长度
        }
    }
}



else if (optype == MULT) {
    longint_t result;  // 定义一个新的 longint_t 结构体来存储乘法的结果
    // 调用乘法函数，将结果存储在 result 中
    do_multiply(vars+varnum, &second_value, &result);
    vars[varnum] = result;  // 将结果赋值给相应的变量
}

void
do_print(int varnum, longint_t *var) {
    // 打印变量名，例如 "register a: "
    printf("register %c: ", varnum + CH_A);
    
    // 对于给定变量的每个数字
    for (int i = 1; i <= var->numbers[0]; i++) {
        printf("%d", var->numbers[i]);  // 打印当前数字
        // 检查是否需要在数字之间添加逗号。在每个三位数字后（从右到左计算）添加逗号
        if ((var->numbers[0] - i) % 3 == 0 && i != var->numbers[0]) {
            printf(",");
        }
    }
    printf("\n");  // 在打印完所有数字后添加换行
}

void do_multiply(const longint_t *var1, const longint_t *var2, longint_t *result) {
    int i, j, carry, temp;

    // 初始化结果数组
    // TODO: 用 result 来存储数组，初始化为全部 0
    for (i = 0; i < INTSIZE; i++) {
        result->digits[i] = 0;
    }

    // 对于 var1 中的每个数字
    for (i = 0; i < var1->length; i++) {
        carry = 0;

        // 对于 var2 中的每个数字
        for (j = 0; j < var2->length; j++) {
            temp = result->digits[i + j] + var1->digits[i] * var2->digits[j] + carry;
            result->digits[i + j] = temp % 10;  // 保存当前位的数字
            carry = temp / 10;  // 计算进位值
        }

        // 当 var2 遍历完毕，但仍有进位时
        while (carry > 0) {
            temp = result->digits[i + j] + carry;
            result->digits[i + j] = temp % 10;  // 保存当前位的数字
            carry = temp / 10;  // 计算进位值
            j++;  // 为了正确地放置进位，增加j
        }
    }
    result->length = var1->length + var2->length;  // 最大可能的长度
    while (result->length > 1 && result->digits[result->length - 1] == 0) {
        // 删除前导零
        result->length--;
    }
}

/* Program to perform multi-digit integer arithmetic.

   Skeleton program written by Alistair Moffat, ammoffat@unimelb.edu.au,
   August 2023, with the intention that it be modified by students
   to add functionality, as required by the assignment specification.
   All included code is (c) Copyright University of Melbourne, 2023

   Student Authorship Declaration:

   (1) I certify that except for the code provided in the initial skeleton
   file, the  program contained in this submission is completely my own
   individual work, except where explicitly noted by further comments that
   provide details otherwise.  I understand that work that has been developed
   by another student, or by me in collaboration with other students, or by
   non-students as a result of request, solicitation, or payment, may not be
   submitted for assessment in this subject.  I understand that submitting for
   assessment work developed by or in collaboration with other students or
   non-students constitutes Academic Misconduct, and may be penalized by mark
   deductions, or by other penalties determined via the University of
   Melbourne Academic Honesty Policy, as described at
   https://academicintegrity.unimelb.edu.au.

   (2) I also certify that I have not provided a copy of this work in either
   softcopy or hardcopy or any other form to any other student, and nor will I
   do so until after the marks are released. I understand that providing my
   work to other students, regardless of my intention or any undertakings made
   to me by that other student, is also Academic Misconduct.

   (3) I further understand that providing a copy of the assignment
   specification to any form of code authoring or assignment tutoring service,
   or drawing the attention of others to such services and code that may have
   been made available via such a service, may be regarded as Student General
   Misconduct (interfering with the teaching activities of the University
   and/or inciting others to commit Academic Misconduct).  I understand that
   an allegation of Student General Misconduct may arise regardless of whether
   or not I personally make use of such solutions or sought benefit from such
   actions.

   Signed by: [Enter your full name and student number here before submission]
   Dated:     [Enter the date that you "signed" the declaration]

*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <strings.h>
#include <ctype.h>
#include <assert.h>
#include <unistd.h>

/* All necessary #defines provided as part of the initial skeleton */

#define INTSIZE    500    /* max number of digits per integer value */
#define LINELEN    999    /* maximum length of any input line */
#define NVARS    26    /* number of different variables */

#define CH_A     'a'    /* character 'a', first variable name */

#define ERROR    (-1)    /* error return value from some functions */
#define PROMPT    "> "    /* the prompt string for interactive input */

#define PRINT    '?'    /* the print operator */
#define ASSIGN    '='    /* the assignment operator */
#define PLUS    '+'    /* the addition operator */
#define MULT    '*'    /* the multiplication operator */
#define POWR    '^'    /* the power-of operator */
#define DIVS    '/'    /* the division operator */
#define ALLOPS  "?=+*^/"

#define CH_ZERO  '0'    /* character zero */
#define CH_ONE   '1'    /* character one */
#define CH_NINE  '9'    /* character nine */

#define CH_COM   ','    /* character ',' */
#define PUT_COMMAS 3    /* interval between commas in output values */

#define INT_ZERO 0    /* integer 0 */
#define INT_TEN  10    /* integer 10 */

/* Placeholder typedef for skeleton code
*/
// typedef int longint_t;
typedef struct {
    int numbers[INTSIZE + 1];  /* +1 for the buddy variable */
    // int length;
    // 我们需要得到数字的长度，长度存储在哪？1. 变量
} longint_t;
#define LONG_ZERO { {0} }

// int a = 0;
// longint_t a = LONG_ZERO;

// #define LONG_ZERO 0
#define LONG_ONE  1


/****************************************************************/

/* A "magic" additional function needing explicit declaration */
int fileno(FILE *);

/* Skeleton program function prototypes */

void print_prompt(void);

void print_tadaa(void);

void print_error(char *message);

int read_line(char *line, int maxlen);

void process_line(longint_t vars[], char *line);

int get_second_value(longint_t vars[], char *rhsarg,
                     longint_t *second_value);

int to_varnum(char ident);

void do_print(int varnum, longint_t *var);

void do_assign(longint_t *var1, longint_t *var2);

void do_plus(longint_t *var1, longint_t *var2);

void zero_vars(longint_t vars[]);

longint_t parse_num(char *rhs);

void do_multiply(longint_t *var1, longint_t *var2, longint_t *result);

void do_exponentiation(longint_t *base, int exponent, longint_t *result);
int extract_exponent(longint_t value);
int compare(longint_t a, longint_t b);
void subtract(longint_t* a, longint_t b);
void do_divide(longint_t* dividend, longint_t* divisor, longint_t* result);
void insert_leftmost(longint_t* value, int digit);
void insert_rightmost(longint_t* value, int digit);
void initialize_zero(longint_t *number);

/****************************************************************/

/* Main program controls all the action
*/
int
main(int argc, char *argv[]) {
    char line[LINELEN + 1] = {0};
    longint_t vars[NVARS];

    zero_vars(vars);
    print_prompt();
    while (read_line(line, LINELEN)) {
        if (strlen(line) > 0) {
            /* non empty line, so process it */
            process_line(vars, line);
        }
        print_prompt();
    }

    print_tadaa();
    return 0;
}

/****************************************************************/

/* Prints the prompt indicating ready for input, but only if it
   can be confirmed that the input is coming from a terminal.
   Plus, output might be going to a file, that's why the prompt,
   if required, is written to stderr and not stdout
*/
void
print_prompt(void) {
    if (isatty(fileno(stdin))) {
        fprintf(stderr, "> ");
        fflush(stderr);
    }
}

void
print_tadaa(void) {
    /* all done, so pack up bat and ball and head home,
       getting the exact final lines right is a bit tedious,
       because input might be coming from a file and output
       might be going to a file */
    if (isatty(fileno(stdin)) && isatty(fileno(stdout))) {
        printf("\n");
    }
    printf("ta daa!!!\n");
    if (isatty(fileno(stdin)) && !isatty(fileno(stdout))) {
        fprintf(stderr, "\n");
    }
}

void
print_error(char *message) {
    /* need to write an error message to the right place(s)
    */
    if (isatty(fileno(stdin)) || isatty(fileno(stdout))) {
        fprintf(stderr, "%s\n", message);
        fflush(stderr);
    }
    if (!isatty(fileno(stdout))) {
        printf("%s\n", message);
    }
}

/****************************************************************/

/* Reads a line of input into the array passed as argument,
   returns false if there is no input available.
   All whitespace characters are removed on the way through.
*/
int
read_line(char *line, int maxlen) {
    int i = 0, c;
    while (((c = getchar()) != EOF) && (c != '\n')) {
        if (i < maxlen && !isspace(c)) {
            line[i++] = c;
        }
    }
    line[i] = '\0';
    /* then, if the input is coming from a file or the output
       is going to a file, it is helpful to echo the input line
       and record what the command was */
    if (!isatty(fileno(stdin)) || !isatty(fileno(stdout))) {
        printf("%s%s\n", PROMPT, line);
    }
    return ((i > 0) || (c != EOF));
}

/****************************************************************/

/* Process a command by parsing the input line into parts
*/
void
process_line(longint_t vars[], char *line) {
    int varnum, optype, status;
    longint_t second_value;

    /* determine the LHS variable, it
       must be first character in compacted line
    */
    varnum = to_varnum(line[0]);
    if (varnum == ERROR) {
        print_error("invalid LHS variable");
        return;
    }

    /* more testing for validity
    */
    if (strlen(line) < 2) {
        print_error("no operator supplied");
        return;
    }

    /* determine the operation to be performed, it
       must be second character of compacted line
    */
    optype = line[1];
    if (strchr(ALLOPS, optype) == NULL) {
        print_error("unknown operator");
        return;
    }

    /* determine the RHS argument (if one is required),
       it must start in the third character of compacted line
    */
    if (optype != PRINT) {
        if (strlen(line) < 3) {
            print_error("no RHS supplied");
            return;
        }
        status = get_second_value(vars, line + 2, &second_value);
        if (status == ERROR) {
            print_error("RHS argument is invalid");
            return;
        }
    }

    /* finally, do the actual operation
    */
    if (optype == PRINT) {
        do_print(varnum, vars + varnum);
    } else if (optype == ASSIGN) {
        do_assign(vars + varnum, &second_value);
    } else if (optype == PLUS) {
        do_plus(vars + varnum, &second_value);
        // you will need to add further operators here
    } else if (optype == MULT) {
        longint_t result;
        do_multiply(vars + varnum, &second_value, &result);
        vars[varnum] = result;  // 将结果赋值给相应的变量
    } else if (optype == POWR) {

        longint_t result;
        int exponent = extract_exponent(second_value);
        do_exponentiation(vars + varnum, exponent, &result);

//        do_exponentiation(vars + varnum, second_value.numbers[1], &result); // 假设second_value只有一个数字代表指数
        vars[varnum] = result;
    }
    else if (optype == DIVS) {
        longint_t result;
        do_divide(vars + varnum, &second_value, &result);
        vars[varnum] = result;
    }
    else {
        print_error("operation not available yet");
        return;
    }
    return;
}

/****************************************************************/

/* Convert a character variable identifier to a variable number
*/
int
to_varnum(char ident) {
    int varnum;
    varnum = ident - CH_A;
    if (0 <= varnum && varnum < NVARS) {
        return varnum;
    } else {
        return ERROR;
    }
}

/****************************************************************/

/* Process the input line to extract the RHS argument, which
   should start at the pointer that is passed
*/
int
get_second_value(longint_t vars[], char *rhsarg,
                 longint_t *second_value) {
    char *p;
    int varnum2;
    if (isdigit(*rhsarg)) {
        /* first character is a digit, so RHS is a number
           now check the rest of RHS for validity */
        for (p = rhsarg + 1; *p; p++) {
            if (!isdigit(*p)) {
                /* nope, found an illegal character */
                return ERROR;
            }
        }
        /* nothing wrong, ok to convert */
        *second_value = parse_num(rhsarg);
        return !ERROR;
    } else {
        /* argument is not a number, so should be a variable */
        varnum2 = to_varnum(*rhsarg);
        if (varnum2 == ERROR || strlen(rhsarg) != 1) {
            /* nope, not a variable either */
            return ERROR;
        }
        /* and finally, get that variable's value */
        do_assign(second_value, vars + varnum2);
        return !ERROR;
    }
    return ERROR;
}

/* Set the vars array to all zero values
*/
void
zero_vars(longint_t vars[]) {
    int i;
    longint_t zero = LONG_ZERO;
    for (i = 0; i < NVARS; i++) {
        do_assign(vars + i, &zero);
    }
    return;
}

/*****************************************************************
******************************************************************

Your answer to the assignment should start here, using your new
typedef defined at the top of the program. The next few functions
will require modifications because of the change of structure
used for a long_int, and then you'll need to start adding whole
new functions after you get these first ones working properly.
Try and make the new functions fit the style and naming pattern
of the existing ones, ok?

******************************************************************
*****************************************************************/

/* Create an internal-format number out of a string
*/
// longint_t
// parse_num(char *rhs) {
// 	return atoi(rhs);
// }
int char_to_digit[128] = {0};

void initialize_mapping() {
    for (char c = '0'; c <= '9'; c++) {
        char_to_digit[c] = c - '0';
    }
}

longint_t
parse_num(char *rhs) {
    initialize_mapping();
    longint_t result = LONG_ZERO;  // xxxxxx
    int len = strlen(rhs); // 获取用户输入数字的长度

    // 将数字的长度存储在第一个索引中
    result.numbers[0] = len;
    // 改写成 while 循环「为了独特性」

    for (int i = 0; i < len; i++) {
        // result.numbers[i+1] = rhs[len-1-i] - '0'; // char '9' = int 57
        result.numbers[i + 1] = char_to_digit[rhs[len - 1 - i]];  // char '9' = int 57
        // printf("%d\t", rhs[len-1-i] - '0')
    }

    return result;
}

/****************************************************************/

/* Print out a longint value
*/
// void
// do_print(int varnum, longint_t *var) {
// 	printf("register %c: ", varnum+CH_A);
// 	printf("%d\n", *var);
// }


// void do_print(int varnum, longint_t *var) {
//     printf("register %c: ", varnum + CH_A);
//     int count = 0;
//     int length = var->numbers[0];
//     printf("number length is %d\n", length);
//     // for (int i = var->digits[0]; i > 0; i--) {
//     //     printf("%d love ", var->digits[i]);
//     // }
//     for (int i = 1; i <= var->numbers[0]; i++) {
//     	if (count == 3) {
//     		printf(",");
//    		count = 0;
//     	}
//     	printf("%d", var->numbers[i]);
//     	count++;
//     }

//     printf("\n");
// }
void do_print(int varnum, longint_t *var) {
    printf("register %c: ", varnum + CH_A);

    int length = var->numbers[0];  // 获取长度

    // Count the remaining numbers till the next comma is needed
    // 1234567
    int remainder = length % 3;
    remainder = remainder == 0 ? 3 : remainder;  // 转换成使用 if

    for (int i = length; i > 0; i--) {  // Reverse the iteration order
        // for (int i = 1; i <= length; i++) {  // Reverse the iteration order

        if (remainder == 0) {
            printf(",");
            remainder = 3;  // Reset after printing a comma
        }

        printf("%d", var->numbers[i]);
        remainder--;
    }

    printf("\n");
}

/****************************************************************/

/* Assign a longint value, could do this with just an assignment
   statement, because structs can be assigned, but this is more
   elegant, and only copies over the array elements (digits) that
   are currently in use: var1 = var2

*/
void
do_assign(longint_t *var1, longint_t *var2) {
    *var1 = *var2;
}
// void 
// do_assign(longint_t *var1, longint_t *var2) {
//     var1->numbers[0] = var2->numbers[0];

//     for (int i = 1; i <= var2->numbers[0]; i++) {
//         var1->numbers[i] = var2->numbers[i];
//     }
// }

/****************************************************************/

/* Update the indicated variable var1 by doing an addition
   using var2 to compute var1 = var1 + var2
*/
void check_overflow(longint_t *var) {
    if (var->numbers[0] > INTSIZE) {
        printf("Overflow error! Exiting...\n");
        exit(EXIT_FAILURE);
    }
}

// void
// do_plus(longint_t *var1, longint_t *var2) {
// 	*var1 += *var2;
// }
void do_plus(longint_t *var1, longint_t *var2) {
    int carry = 0;
    int length_var1 = var1->numbers[0];
    int length_var2 = var2->numbers[0];
    int maxLength = (length_var1 > length_var2) ? length_var1 : length_var2;

    for (int i = 1; i <= maxLength || carry; i++) {
        if (i == INTSIZE + 1) {
            var1->numbers[0] = i;
            check_overflow(var1);
        }

        var1->numbers[i] += carry + (i <= var2->numbers[0] ? var2->numbers[i] : 0);
        carry = var1->numbers[i] / 10;
        var1->numbers[i] %= 10;

        if (i > var1->numbers[0]) {
            var1->numbers[0] = i;
        }
    }
}

/*****************************************************************
******************************************************************

Put your new functions below this line. Make sure you add suitable
prototypes at the top of the program.

******************************************************************
*****************************************************************/

void
do_multiply(longint_t *var1, longint_t *var2, longint_t *result) {
    // TODO:结果的数组需要结合两个数组的长度来实现么？
    int i, j, carry;
    int temp;

    // 初始化结果
    for (i = 0; i <= INTSIZE; i++) {
        result->numbers[i] = 0;
    }

    for (i = 1; i <= var1->numbers[0]; i++) {
        carry = 0;
        for (j = 1; j <= var2->numbers[0] || carry > 0; j++) {
            temp = result->numbers[i + j - 1] + var1->numbers[i] * var2->numbers[j] + carry;
            result->numbers[i + j - 1] = temp % 10;
            carry = temp / 10;
            result->numbers[0] = i + j - 1;
        }
    }
}

//TODO:下面的实现，没有测试
//void do_multiply(longint_t *var1, longint_t *var2, longint_t *result) {
//    int i, j, carry;
//    int temp;
//
//    // 初始化结果
//    for (i = 0; i <= INTSIZE; i++) {
//        result->numbers[i] = 0;
//    }
//
//    for (i = 1; i <= var1->numbers[0]; i++) {
//        carry = 0;
//        for (j = 1; j <= var2->numbers[0] || carry > 0; j++) {
//            temp = result->numbers[i + j - 1] + var1->numbers[i] * var2->numbers[j] + carry;
//            result->numbers[i + j - 1] = temp % 10;
//            carry = temp / 10;
//        }
//    }
//
//    // 设置结果的长度。长度应该是两个输入的长度之和或更少。
//    result->numbers[0] = var1->numbers[0] + var2->numbers[0];
//    while (result->numbers[0] > 1 && result->numbers[result->numbers[0]] == 0) {
//        result->numbers[0]--;
//    }
//}

//void
//do_exponentiation(longint_t *base, int exponent, longint_t *result) {
//    longint_t temp_result;
//
//    // Initialize the result as 1 since anything to the power 0 is 1.
//    result->numbers[0] = 1;
//    result->numbers[1] = 1;
//
//    // If the exponent is 0, the result is already set to 1 and we can exit.
//    if (exponent == 0) {
//        return;
//    }
//
//    // For every value from 1 to the exponent
//    for (int i = 1; i <= exponent; i++) {
//        // Multiply the current result by the base
//        do_multiply(result, base, &temp_result);
//        *result = temp_result;  // Copy the result back to our main result
//    }
//}

//
//longint_t powr(const longint_t *base, int exp) {
//    if (exp == 0) {
//        return parse_num("1");
//    }
//    if (exp == 1) {
//        return *base;
//    }
//
//    longint_t temp = powr(base, exp / 2);
//    longint_t result = do_multiply(&temp, &temp);
//    if (exp % 2) {
//        result = do_multiply(&result, base);
//    }
//    return result;
//}
//void do_exponentiation(longint_t *base, int exponent, longint_t *result) {
//    // 定义一个单位数字，代表数字1
//    longint_t one;
//    one.numbers[0] = 1;
//    one.numbers[1] = 1;
//
//    // 将结果初始化为1
//    *result = one;
//
//    // 对于每次的 exponent，进行乘法操作
//    for (int i = 0; i < exponent; i++) {
//        longint_t temp_result;
//        do_multiply(result, base, &temp_result);
//        *result = temp_result;
//    }
//}
//void do_exponentiation(longint_t *base, int exponent, longint_t *result) {
//    // 定义一个单位数字，代表数字1
//    longint_t one;
//    one.numbers[0] = 1; //长度为1
//    one.numbers[1] = 1;
//
//    // 将结果初始化为1
//    *result = one;
//
//    // 如果 exponent 是 0, 直接返回结果 1
//    if (exponent == 0) {
//        return;
//    }
//
//    // 对于每次的 exponent，进行乘法操作
//    for (int i = 1; i <= exponent; i++) {
//        longint_t temp_result;
//        do_multiply(result, base, &temp_result);
//        *result = temp_result;
//    }
//}
void do_exponentiation(longint_t *base, int exponent, longint_t *result) {
    // 定义一个单位数字，代表数字1
    longint_t one;
    one.numbers[0] = 1; //长度为1
    one.numbers[1] = 1;
//    printf("Base: %d, Exponent: %d\n", base->numbers[1], exponent); // 注意，这里我们假设基数是一个一位数

    // 如果 exponent 是 0, 直接返回结果 1
    if (exponent == 0) {
        *result = one;
        return;
    }

    // 初始时，结果是base
    *result = *base;

    // 对于每次的 exponent，进行乘法操作
    for (int i = 2; i <= exponent; i++) {
        longint_t temp_result;
        do_multiply(result, base, &temp_result);
        *result = temp_result;
    }
}

int extract_exponent(longint_t value) {
    int exponent = 0, i;
    for (i = value.numbers[0]; i >= 1; i--) {
        exponent = exponent * 10 + value.numbers[i];
    }
    return exponent;
}

int compare(longint_t a, longint_t b) {
    if(a.numbers[0] > b.numbers[0]) return 1;
    if(a.numbers[0] < b.numbers[0]) return -1;

    for(int i = a.numbers[0]; i >= 1; i--) {
        if(a.numbers[i] > b.numbers[i]) return 1;
        if(a.numbers[i] < b.numbers[i]) return -1;
    }

    return 0; // a == b
}

void subtract(longint_t* a, longint_t b) {
    int carry = 0, i;
    for(i = 1; i <= a->numbers[0]; i++) {
        a->numbers[i] -= b.numbers[i] + carry;
        if(a->numbers[i] < 0) {
            a->numbers[i] += 10;
            carry = 1;
        } else {
            carry = 0;
        }
    }

    // 更新结果的长度
    while(a->numbers[0] > 1 && a->numbers[a->numbers[0]] == 0) {
        a->numbers[0]--;
    }
}

void initialize_zero(longint_t *number) {
    number->numbers[0] = 0; // 设定长度为0
    for (int i = 1; i <= INTSIZE; i++) {
        number->numbers[i] = 0; // 为每个数字位置设定0值
    }
}

void do_divide(longint_t* dividend, longint_t* divisor, longint_t* result) {
    initialize_zero(result);

    if(compare(*dividend, *divisor) < 0) {
        // If dividend < divisor, the result is 0.
        return;
    }

    longint_t current;
    initialize_zero(&current);

    for(int i = dividend->numbers[0]; i >= 1; i--) {
        insert_leftmost(&current, dividend->numbers[i]);
        int quotient_digit = 0;
        while(compare(current, *divisor) >= 0) {
            subtract(&current, *divisor);
            quotient_digit++;
        }
        insert_rightmost(result, quotient_digit);
    }

    // Remove leading zeros from the result.
    while(result->numbers[0] > 1 && result->numbers[1] == 0) {
        for(int j = 1; j < result->numbers[0]; j++) {
            result->numbers[j] = result->numbers[j+1];
        }
        result->numbers[0]--;
    }
}
void insert_leftmost(longint_t* value, int digit) {
    if(value->numbers[0] >= INTSIZE) return;

    for(int i = value->numbers[0]; i >= 1; i--) {
        value->numbers[i+1] = value->numbers[i];
    }
    value->numbers[1] = digit;
    value->numbers[0]++;
}

void insert_rightmost(longint_t* value, int digit) {
    if(value->numbers[0] >= INTSIZE) return;

    value->numbers[0]++;
    value->numbers[value->numbers[0]] = digit;
}