# [Blue Bridge Cup brush questions] day-01

Posted by LawsLoop on Fri, 14 Jan 2022 09:26:04 +0100

Basic exercise factorial calculation of test questions

Problem description
Enter a positive integer n and output n! Value of.
Where n= 123*…*n.

Algorithm description
n! It may be very large, and the range of integers that can be represented by the computer is limited, so it is necessary to use high-precision calculation methods. An array A is used to represent a large integer a, A[0] represents one bit of a, A[1] represents ten bits of a, and so on.
Multiply a by an integer k to multiply each element of array a by K. please pay attention to handling the corresponding carry.
First set a to 1, then multiply 2, multiply 3, when multiplied to N, you get n! Value of.

Input format
The input contains a positive integer n, n < = 1000.

Output format
Output n! The exact value of.

sample input
10

sample output
3628800

```#include <stdio.h>
#define MAXNUMBER 100000
int main()
{
int n, i, j, temp;
int a[MAXNUMBER] = {0};
a[0] = 1;

scanf("%d",&n);
for(i = 1; i <= n; ++i)
{
for(j = 0; j < MAXNUMBER ; ++j)
{
a[j] *= i;
}
for(j = 0; j < MAXNUMBER ; ++j)
{
if(a[j] > 9)
{
temp = a[j];
a[j] = a[j] % 10;
temp = temp - a[j];
a[j + 1] += temp / 10;
}
}
}

for(j = MAXNUMBER - 1; j >= 0 ; --j)
{
if(a[j] != 0)
break;
}

for(i = j; i >= 0; --i)
{
printf("%d",a[i]);
}
return 0;
}
```

Basic exercise of test questions high precision addition

Problem description
Input two integers a and b and output the sum of these two integers. Both a and b have no more than 100 digits.

Algorithm description
Since both a and b are large, they cannot be stored directly using the standard data types in the language. For this problem, arrays are generally used.
Define an array a, A[0] is used to store the bits of a, A[1] is used to store the ten bits of a, and so on. You can also use an array B to store B.
When calculating c = a + b, first add A[0] and B[0]. If a carry is generated, store the carry (i.e. the ten digits of the sum) in R and the single digits of the sum in C[0], i.e. C[0] is equal to (A[0]+B[0])%10. Then calculate the addition of A[1] and B[1]. At this time, also add up the value r of the low order, that is, C[1] should be the sum of A[1], B[1] and R. if a carry is generated again, the new carry can still be stored in R and the bits of sum can be stored in C[1]. By analogy, all bits of C can be found.
Finally, output C.

Input format
The input consists of two lines, the first line is a non negative integer a, and the second line is a non negative integer b. Both integers have no more than 100 bits, and the highest bit of the two numbers > is not 0.

Output format
Output a line representing the value of a + b.

```#include <stdio.h>

int main()
{
int i=0, j=0;
char num;
int lena, lenb, max;
int a[100] = {0}, b[100] = {0};
int c[100] = {0}, d[100] = {0};
int temp[100] = {0};

while(1)
{
scanf("%c",&num);
if(num == '\n')
break;
else
c[i++] = num - '0';
}

num = 0;
while(1)
{
scanf("%c",&num);
if(num == '\n')
break;
else
d[j++] = num - '0';
}

lena = i;
lenb = j;
for(i = i - 1; i >= 0; --i)
{
a[lena - i - 1] = c[i];
}
for(j = j - 1; j >= 0; --j)
{
b[lenb - j - 1] = d[j];
}

max = lena > lenb ? lena : lenb;        /*It is processed according to the data with the largest number of bits*/

for(i = 0; i < max; ++i)
{
if(temp[i] != 0)
{
a[i] += temp[i] / 10;
}
a[i] = a[i] + b[i];
if(a[i] > 9)
{
temp[i+1] = a[i] - a[i] % 10;
a[i] = a[i] - temp[i+1];
}
}

if(temp[max] && max < 100)                           /*Also determine whether the highest bit will carry (the highest bit may reach 101)*/
printf("%d",temp[max]/10);

for(i = max - 1; i >=0; --i)
printf("%d",a[i]);
return 0;
}
```

Topics: C Algorithm