1-4 Exercise 2: Sum of big numbers

Question

You are requested to help in writing a program to perform addition of two large number up to 50-digits. In C there is no builtin datatype for large number, but we can use characters and array to solve the problem.

Input: The input will contain two positive integers are separated by a blank, the two positive integers do not exceed 50-digits.

Output: Sum.

寫一個程式輸入兩個大數(最大50個位數)，計算其總合。C語言不提供大數資料型態，但我們可以用字元和陣列來解決這個問題。

Example input:

999999999999999999999999999999 999999999999999999999999999999

Example output:

1999999999999999999999999999998

 

Answer 1

Hidden content!
#include<stdio.h>
#include <string.h>

int main()
{
* ***  * * *    *  *** * *  a[50],b[50];
* * *  ***  *   * **   ** *  c[51] = {0},i,x;
 *****  ****   *  ******     * *   *** %s",a,b);

*  **      ***  *   *** **** = 0 ; i < strlen(a) ; i++)
 *****  * * ** **  ** * **** *  **** **  * **     ***   * = a[strlen(a) - 1 - i] - '0';
 *** *  * **  ** *   ***** = 0 ; i < strlen(b) ; i++)
* **  *  **** **** ** * *  **** ****  *       **   *  * += b[strlen(b) - 1 - i] - '0';
    ****** ****   * ***** = 48

*** ** * *  ***** *   *** *     = 0 ; i < 50 ; i++)
** *   *   *    **  ** ****  * 
   * * ** * **** ***   *  *** * * * *   *  * *** *  *  ***** * > 9)
       * *  * * * ***** * * **  *   * ******  
 * * * *** *   ***   *****  * *  **** * * * **   ****  * * ** * ****     *  * **  *    ***  
* *  * * ***** * *  ** * * ***       * ****  ** * ***       * ****  **** * * *   = c[i] % 10;
     **   *  * * **  ** *  *  * *  *    *  ***  **  ** **
*      *      **  *****  

***  ****** ***     ***  = 50 ; i >= 0 ; i--)
    {
***** * **  * **   ** ** **  ** ****** **  * **  **  * *  != 0)
     *  **         * *** *** **   * ***** ****  ** * 
 * *** *   *** **   *** **  *      *     * * *****  *  **  ** *   **   **   ** **     * *   = i;
** * **    ** ** ***    *  *  *    * *       * ******* ** **      **** * * * ** *  **
    *   ***** * *** **  * * * * * *  * **** **   **** 
* *  **        *  * *    ** 

 * *   *  **  *  ** *  * *** = x ; i >= 0 ; i--)
*  * ** *** * *** *  *** * ** ****   ******* *** ***   **     **  **  *   ****   *

*****  *******     ****   ***** **** 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 2

Hidden content!
#include<stdio.h>
#include <string.h>

int main()
{
      ***    *  * ***    ** a[50],b[50];
 **  *  * *** *   * **  * * *   c[51] = {0},i,x;
      *****  ** *  ** ** ** *  ** **  *  %s",a,b);

 *   *  ** *** ***   ** * *  = 0 ; i < strlen(a) ; i++)
*  * * ***     ***  *  *  * **** *  * *** ** *** **   ****** = a[strlen(a) - 1 - i] - '0';
 *  *** *  ** * ***** ** **** = 0 ; i < strlen(b) ; i++)
  * *** ***     *    * *  **   **      *  ** **** ***  ** * * += b[strlen(b) - 1 - i] - '0';
* * * ** **** *** *** * * * *  ** = 48

 **** *   * ****      * * **    ** = 0 ; i < 50 ; i++)
*  *  * *  ** *   ***  * **
  * ***  *  *  * * ****** ****** ** * ** * *  *** *  * **   *  > 9)
 * * * *   *******     * * **  * *    *  *  ***  *  **    ****
***  **   *  ******* **   * *  * *  ** ****  * ***   **** **   * * *  *** *  ***** * ***  **
    **** *         ***  * **    **  *   ****  * ** *       ***   **  * * **  **   *   = c[i] % 10;
 *    *  *   *** * *******  **    *  **   *  ***   * *** 
**  *   **   * *** ***  **  

** **** ****** * *** * *  **  = 50 ; i >= 0 ; i--)
    {
  *  ** ** ***  ***  ** * *  ***** *   ***  * * * * * *    **  != 0)
** * *   *    * **   *  ** *   *    ** *****    *  *
     * ** *  **    *   ********  * ** * **  * * * **** **  **     * * ** * ***    ***    = i;
*** ****   ** * *     ** *      *  ***     * *  *  * * * *** *  ***  ***** *  *****   * *  *  *
  **** **  * * ***   *  * *  *      *** *    
 * ***    * *  * *** * **

  *** **     *** *   ****   *  *  = x ; i >= 0 ; i--)
**** *   *** **     ****    *  *  *** ** *   *** *    *  ** *    * * * * *** *** *

  *    **** ***     ***  ***  0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 3

Hidden content!
#include<stdio.h>
#include<string.h>
int main()
{
  ** * *  ***    **      *    string1[50];
 ** ***   ***   * *  **  ** string2[50];

 *       ***   ****  ** ** ****  **   ** *      string1);
** * *** * ***** *  **   * ***  ****** **   string2);
 ***** *    **  *** *****  arr[51]={0},i;

**  **  **  * ****** * *** *  **  ** i<strlen(string1); i++)
    *** * ** * *  ** *  *
********   ** * **  ** * ****  **  * *** *  ** ***  *   *   += string1[strlen(string1) - 1 - i] - 48;
    }

 ** ***   **     ****** *  *    *  i<strlen(string2); i++)
 ****   * *   **  **  **
*   *    *** ***** ** ****   ****  * *  *   **** * **  * += string2[strlen(string2) - 1 - i] - 48;
  ****** *  **    ** 

*  *       * * *   ** * * ***  * i<50; i++)
* * ** ** *  * ***          **
 ** * ** *  ** *  *   **   ** * **** ** *  * *  **** ***** ** * > 9)
* ** * * **   **    *  *  *     **     ***  * * *** *   *
****      **  ***** **  ** ****  * * * ** **  ***   *   ******* * ***   * **  *** *  *  -= 10;
 **** ***   *  *   ***  **  **   *        * *   *** *  **** * * *  **  * *  **    ** * ** **
   ******** **  ***  ******* *** *  ** **    * * **   * 
*** *     * *****   **** ** * 

 *** *** **   **  *** ** * *  *** i>=0; i--)
* ** *  **   * *** **     
    *** *** *****   * ***   * ***     ** ** * *  * **  **** != 0)
 *** *    *** * ** ** *    *  *     **  * * *  ** *  *   * * **     **
 ****   * *  ** **  *    * * **

  * * *   *  * *   * *** ** *    *      i--)
* **   **** * *      ***  *  * **   * ** * **** * * **  *   * *** ***     *   arr[i]);
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 4

Hidden content!
#include<stdio.h>
#include <string.h>

int main()
{
* * **  * ***    *   * **   * * * a[50],b[50];
 ** * ***      ***  ****  ** c[51] = {0},i,x;
*  **   *       ** ** ***  *  * *  ***  %s",a,b);

***  * * ** **** *  **  *  * * = 0 ; i < strlen(a) ; i++)
* ** *     * ***  ** ** **** ** * *    * *  *********    = a[strlen(a) - 1 - i] - '0';
**** *  ***  * ** *** **** *  *   = 0 ; i < strlen(b) ; i++)
  *  ***   * * *     *  ** * *  ** ***     *******   += b[strlen(b) - 1 - i] - '0';
*    * ** * ****    *    *   = 48

*  * ** ***       ***** * * *** *  = 0 ; i < 50 ; i++)
   *      *    * ** *   *   * *      *
 ***** *   * * *    ** *** * **   ***  *  **  **** * *** *  **   * > 9)
**  *** **    ***  *   ****    *    * ***    * *  **
**  *    *  * ** ***** *** ** **  ****   *   * ** * * ***    *****   *******  *   ** *
* * *  ** *** ****** * ** **   *   *   **    ***   ** ** * *** **     *  * ***     = c[i] % 10;
*    * **  ***    *    **  ****    *****  * **  ** * * 
 *  * ** ****** * ***** *  * ***

* *    **    ***   * *  = 50 ; i >= 0 ; i--)
    {
* **   ** *   *******   * ****   * * **  **  *  *** ** != 0)
 ** ** *   **  *   **      * ******* *******  
*     * *  * * * *           * * * **   *  ******  *  **      * ****   ***** *** **  = i;
***   * *** *     *  *     * *  **  ***   * ** ****** * ***   **  ***        * *
* *   *  *******    * * ***** * *   ** *  **  *  
** ***     *** *  * *   **

*     * ******* *    **** **** ** = x ; i >= 0 ; i--)
     * ***  *    ** *****  *** *   *   * **  ** ****   *** ** *** *   ****   ** * ** 

*** *  ** * * *** * *    0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 5

Hidden content!
#include<stdio.h>
#include <string.h>

int main()
{
 *** * * *** *  ** * *   * a[50],b[50];
* **  **** *** ***    **   *** **  c[51] = {0},i,x;
 *    *****  * **   * ****** *  ** **  ***   %s",a,b);

 **    *  * ** *  ** ****     = 0 ; i < strlen(a) ; i++)
   *  ** * **  *  **** *** ***   *  ** * **   ***   **    * *** ** = a[strlen(a) - 1 - i] - '0';
*    *  ***  *  * * ***  * ** = 0 ; i < strlen(b) ; i++)
   ** *   *  **** * *** **  **    **  ****   *   *  ** *** += b[strlen(b) - 1 - i] - '0';
 *  ** *     **   ** * **  *   * = 48

**** *** *  * **  * ***  ** **    = 0 ; i < 50 ; i++)
      *  ********   **  **
  ****   *  ***         ****  **  ** **    * *****   > 9)
 * ** ** *** * * **  **  * ***  *   *     * **  * 
*   *  ** * **   *     ***   * * **  * *   *   **    *      *    *   * **  *****  ***
   ****  * ***  *****  ***   **     * ***  *  ** *   *     ** *  *** * ** *   *  = c[i] % 10;
  ***   * **** **** * *****   ** *   * *    * ***** 
   **  * ***** ***  * ****

     *   **  *     ***** ******    *  = 50 ; i >= 0 ; i--)
    {
    * * *  ** * *   **** *** ****** *  **** *     * * *   ** != 0)
* *        * ***** * *** *  **    * * ** ** *****   
  *  *** *   * * * **** *    * * **  *   * **** *** **    *   * ** **      *  * * *   * = i;
*  **   *** ********   *   **   *  * *** ** * ** * ***** ** ***    *  *   ** 
  ***** ** * **   * ***  *** * ***  ****  ** *** *** ** * * 
** *  **   ** **  ** * ***

 * ****  ** **** *    **  ** ** = x ; i >= 0 ; i--)
***  *    *  *  **  *  * *  *       **  * *** * *  *   ** ***    **    * *  * *

    *  **      * * ***   *** ****  * 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 6

Hidden content!
#include<stdio.h>
int main()
{
    * **     * * *******  ****   num1[255], num2[255], sum[255];
 *** **** *** * **** ****    *   *    s1[255], s2[255];
   ** ** **  ***     **********  l1, l2;

*  * * * *  ***** ****** **** ***   ** %s", &s1, &s2);

*   ****    * **   *   ****  * (l1 = 0; s1[l1] != '\0'; l1++)
** *  ** ****    ****** ** *   ***  **  ** * *    ****   = s1[l1] - '0';

 **    **     ******** * **   (l2 = 0; s2[l2] != '\0'; l2++)
*** *       ***   *  *      *** * ** ******   * ***   * **  *** ***** = s2[l2] - '0';

 * ** * *   **  **      **  ** carry = 0;
*  * * * **** *  **  *   *   k = 0;
  ***    * *  *  ** * * * *  *  *** i = l1 - 1;
* *  * * ** ** *  **  *   *       j = l2 - 1;
****   *   ** *  ***   **  * **  *  (; i >= 0 && j >= 0; i--, j--, k++)
*** *** *** *  *****  * * 
  ***** *   * ******** *      *   * ** **   *   *   *** *  = (num1[i] + num2[j] + carry) % 10;
 * * *** ** ********* * **        ** *   **  **    **  * = (num1[i] + num2[j] + carry) / 10;
 **** **  * *   *   * *  *  
**** **  ** ** *  **  ***    *  (l1 > l2)
* * ***    *      ** * * ***

* * * * ***    **  *  * ** * * ****    *  *  ** ****   * (i >= 0)
*** *** *  * **    * *    *** *** *     ** **** * **** 
     * ** *  ** *  ***  *  * *    *  **  * ** * ** **** * ***  ***** *    *  * *  *  *** = (num1[i] + carry) % 10;
** *****   * **** * *  ***     * * * * *  *  ****** ** ****   *** ** **** *****  *       = (num1[i--] + carry) / 10;
* *  **  ******     * **** ** *** *    **** ***  * ** * * *
 *  *   * **  * * **** * *** * *   * * *** ***  *   **   * *  
**   ** * ** ***** ** *** *   ** ***   **** *       * **     *  * * * *** ** *  * * ** * *** *   * *

* *    **   ** *     *  ****
   *** ***   *  ******  *  * * * ** if (l1 < l2)
 * ******    * **   *   *
 *  *  * *   ***   ***    *   ** **** * *     *** *   **** * (j >= 0)
*  *   ** * *  ***       *** **  *     *  * *  *    *   
   * * ****   ***** ** * ** **   *    * *   *** **    * * *    ********  *  *      *  * *  = (num2[j] + carry) % 10;
****  **  *   ****  ***   * * ****   *   ** *  ****  * * *  ** **     * ******** * = (num2[j--] + carry) / 10;
*** **   **** ****  ** ** **     * ** * ** **   * *  *  
* *   *  *****       * **  **   *******  ** ** * ** *** * * *   * *  *
   **    ***   * * * *  ***  * **  *  ** *  ******** ***********  **** ***  ** **  ** ***
 ****** *    * ****    *   *
 * *** **** * *   *  * ***  * 
   **    * *  * * ******
* * *   ** *  *     * *  **   *   *** * * **  ** *****  (carry > 0)
** **  ** *  **  *  * *   *   ***  ** *   * ** * *   ***    * * *** ******* *** *   * = carry;
    }

 ***            *   * **   **   * (k--; k >= 0; k--)
  * *   *******      ** * ** ** **   ** *          * ***** * * ** *    ** sum[k]);

  *** *** **** * **  *** * 0;
}

Comments

prog.c: In function 'main':
prog.c:8:13: warning: format '%s' expects argument of type 'char *', but argument 2 has type 'char (*)[255]' [-Wformat=]
     scanf("%s %s", &s1, &s2);
             ^
prog.c:8:16: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'char (*)[255]' [-Wformat=]
     scanf("%s %s", &s1, &s2);
                ^

Answer 7

Hidden content!
***  *     *  * * **
int main()
{
*** **   **  *** ** * ** * num1[255], num2[255], sum[255];
*****      **  ***  ** * ** s1[255], s2[255];
**  * * ***  ***  *  * *   *   l1, l2;

 *  **  * *  * *     *    *** *    * *  * * %s", &s1, &s2);

*    ***   *** * *** *  * (l1 = 0; s1[l1] != '\0'; l1++)
 ****  * * **** *  **  * ** * ***   *   *   *    *** ****** = s1[l1] - '0';

 *** * ** ***  ****** ***   *  (l2 = 0; s2[l2] != '\0'; l2++)
     * ** * * ***   * *** *  *** **   *  ** * * * *  *  = s2[l2] - '0';

    ****** ** *    * * *  ** carry = 0;
*  ** * ** ***    **** *  k = 0;
 *** **  ** *  ***   *** *  i = l1 - 1;
* *** * *    **** * *  **  **  j = l2 - 1;
 * *     *   ** **  *  ***   *   (; i >= 0 && j >= 0; i--, j--, k++)
* *****  * ** **  *  *******
**  **** *** * *   * * *   ***  **  **  **   * *** ****  = (num1[i] + num2[j] + carry) % 10;
 *  * ** ** *    ********   *    **   *    ** ** * ***   ********** = (num1[i] + num2[j] + carry) / 10;
 * *   *     ***  *** ***** * 
*  *    *  * ** ** **   * (l1 > l2)
   ** *** *  *** *** *** **

  * *  ***    *    ***  *  * *** *  * *  ** ** *****   (i >= 0)
*** *  *    ** * *         * ***   * *** * **  **  ** *** 
     ** *   * * * ** *  * ** * **   *** **   *   * * ** ****  **** **  *  = (num1[i] + carry) % 10;
  *   * * ****        ** * *  * * ****   *** * * **  * *  * * ** *   * * **  **   = (num1[i--] + carry) / 10;
   **    * *     *    ** **   **** **   * * *** *** *

 * *  ** ******  *** *  *  * * 
    ** *****    * **  **  * *   if (l1 < l2)
**     * * ** *****       * 
********** *  ** * *    * *** *      **** *   ** ** ****   (j >= 0)
** ***  *  **     * **   *** **** *  *****   * ***  **
  **** **  **      ****  * ***  *  ***** *   * * **** * ** *  **  * * * **  *   * ** * *   * **  = (num2[j] + carry) % 10;
 *  * ** * * * * *** * ** **** * **   * *** **** *  * * *    *  *** * ***  * ****   = (num2[j--] + carry) / 10;
**   *** ****         * * **  ***  * * *** ** ****** ***   * 
 *  *  **  * *  ******  * 
 *  *  **   ****  *********
 *   * **** *  ** *   * **** ***
*    * ** ***** ** **  **  **    *** * * *   * * (carry > 0)
** *  *    ***   * **  ********* * *  ******* * *   **  * * *  **    **  ** ***           ** = carry;
** *  * ****  * ** * **** *

   ** * *** *  ***  * ***** **  (k--; k >= 0; k--)
     *    *  * **  * *   * *   **  **   * *** ***  *  **  * ******   * *******  sum[k]);

** * * ***** *******   **  ** * 0;
}

Comments

prog.c: In function 'main':
prog.c:8:13: warning: format '%s' expects argument of type 'char *', but argument 2 has type 'char (*)[255]' [-Wformat=]
     scanf("%s %s", &s1, &s2);
             ^
prog.c:8:16: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'char (*)[255]' [-Wformat=]
     scanf("%s %s", &s1, &s2);
                ^

Answer 8

Hidden content!
 ** *   *  ******* *
** * **  
{
*** *  * ****** int * ** *     * 
 *** *   **  *  * *   * 
  ** *  *  * *    int l1, l2;


  *   ****   *      **   *    * * ****  *  *
 **    **   
**   ****  *   * 
*  *  ** ** for (l1 = 0;  **  != * ** **
** ***   ** * ***  * **    ***    * * ** =    * -  **
**   *    ***  
  *  *  **   ** for (l2 = 0;    != *****   
 * **     ***  * **    *   *  **   = *  - * 
 ****   *   ** 
 ** *    *    **   *  = 0;
   **  * * * int k = 0;
   *   **    int i = l1 - 1;
    ** * *   * ** ** j = l2 - 1;
* * **    *  for (; i **   *** 0   **  **     ** j * ***  * 0;  * * * **  
*****  * ***** *    *** **   ** ** {
 * *       *       *  *     * * * =    ** +  * * +  *  ** % 10;
**  *** *  **   *  ** *  *  **   =    + **** +   *  / 10;
*** **   * * * ***  * ** }
 * * ***** *   **** if (l1 *    l2) 
  ** * * * {
 *  *   ***   * * 
 *  **   *  * *  ***  *  *  * **   * (i ***  * ** 0) 
       ** *   ** ** ***   **   **   *  **** * {
 *  *     ** * **** *  ** ***   * * **     *  * *  = *    +  *    % 10;
* * *  * *** *   ** *  *** *     *  ***        *  = *   * +  * * / 10;
 * * * * * **  *** ***    *     * **   }
**  ****   * *     
    ****  **  * }
    *   * **   ** if (l1  * * * l2)
   **  *** *    *** *   *
******* * *   *     ** *    ** (j  *    * 0) 
 ****  ** *  * **     * **  * *  * *** ** *  {
*      *   * ** ** *        *  **      * *   * * *** * = * **   + * *   % 10;
        ** ****** * *    *  * ** *  * * * **   *    * =  **  + * * / 10;
** * * * *   *   *** **     ****  * **     * }
       ** * } 
 *  *  ** **  **     
*  *     **  *  ********
  **  * ** ***** *  * *       * **  if   *    ****  0)
* * *  *** *      *   **  *  ***   *    * = **** 
***  **  *  *  *    *  



 ******** ***     for  *   k *  *** 0; * * 
 * *  *    * * *    * * * ******  *   ***  
*  **     *** 
**     *  *  * *   *** 0;
}

Comments

prog.c: In function 'main':
prog.c:9:10: warning: format '%s' expects argument of type 'char *', but argument 2 has type 'char (*)[50]' [-Wformat=]
  scanf("%s %s", &s1,&s2);
          ^
prog.c:9:13: warning: format '%s' expects argument of type 'char *', but argument 3 has type 'char (*)[50]' [-Wformat=]
  scanf("%s %s", &s1,&s2);
             ^

---

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 9

Hidden content!
#include<stdio.h>
int main()
{
****  *  **  *  *******  *  * num1[200], num2[200], sum[200];
*****   * *  ******  *  *     **   s1[50], s2[50];
 *   * *** ** *** **** ** ** i, j;
** ***** **    *     **  **     carry = 0;
** * **** *       ** * * *  * k = 0;
****       *  ***    ****
   ** **  * ***  *     ** *   ****  *  **  * s1);
 * *  * **   ** * * *     **   * ****  *   s2);
 * ** ******  **   * * *  
******  *    *  *  * * **** * * (i = 0; s1[i] != '\0'; i++)
***    *   * **  ** * ** ** *** *   *** * * *  *     ***  *  *  = s1[i] - '0';
 * *** **  ****  * * ** *
  *** *** *   * * ** *   * (j = 0; s2[j] != '\0'; j++)
* ** * *    ***** **  ******  **  * * * *   *** *  *     = s2[j] - '0';
     *  *  *   ** *  *  ** * *
** *** ****    *   ***      * * m = i - 1;
  * ** * * ***  ** **    **    n = j - 1;
 ****** * ****  **  * * *   
*  *  *  * * ** **  ***     * (; m >= 0 && n >= 0; m--, n--, k++)
***** **   * * ****  **  *
 ***  * * *   *   * *   * *   ** * ***  **    **     = (num1[m] + num2[n] + carry) % 10;
 *  * ** * * ** *     ** * *** * *  *  * **   ***  = (num1[m] + num2[n] + carry) / 10;
***         ***** * * *  ***   ***
  *  *    ** * **  * **  ** * (i > j)
***  ** ** * *   * ***** *
**   *    ****     *** *** ******** * ** *       * *** * * * (m >= 0)
*****     **  *  *   *   ***** *** **  *  *** *    
**     * *     **  * **  ***** *  *  *** *** ************ * *** * ** **  ****  *    = (num1[m] + carry) % 10;
  * ****     *** ***  *   *  **  ***  * * *** * *    ***** * **  *** * ****  *** *  = (num1[m--] + carry) / 10;
** *   ** *  * ** **  ** * * * *****   *****  **   ** *
*******  *****  * *    *** ** ***** ** ** * * **** **  
**  * * ** ***** *       ** ** else if (i < j)
*** *** ******** *     
 ***      * * ******** *  **** * ** *  *      * * **    (j >= 0)
 ** *   *  ***  ***  * * **     *****  **** * *******    * * *
 * ***  **** *    *    * * ********    *    * * *  * * *  **  ****    * * **  ** = (num2[n] + carry) % 10;
*** **   * ***  *  *   *   *** ******** *  * *** ** * *   *  * **  * *   ** * * * **    = (num2[n--] + carry) / 10;
** * ** * **** * *  ****  * * * ** **   *  * * **
***  * * * * ** *   **** ** else
* * *  *** **     * * *  ** *****
** * ** * * *   *  *    ***  *   *  **   * ** **     ****** (carry > 0)
 * *   * ******* ** *** * * ** *  **** ** ** ****  ** ** ***    **       ******   **     = carry;
*  ** * *  ***  *****  * * 
  *      * *  *** *   **
***** * *** *  *  ** **  **  (k--; k >= 0; k--)
    *****  *   ** * ***  * * **   ** *   ****   ** **     *  ** * *** * *  sum[k]);
    
***  ******** ** **        * 0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output

Answer 10

Hidden content!
#include<stdio.h>
int main() {
  *    *    *   *** * ** *  num1[100], num2[100], sum[100];
 *  * * ** * ***  ** **    s1[50], s2[50];
 **  *   *** *  *   *   ** *  * l1, l2;
    **  *  ***      ***  ** 
 ***  *  *********** *** ** 
* *            * * **  ***  *       **  *  ** ****  s1);
 *  ***  * *  ****** * **  ***** ** *     * *  *  *** s2);
* * ** ******* ****  * 
 * *     **  * *   ****    * (l1 = 0; s1[l1] != '\0'; l1++)
      ***** *   **  *     ** **   **** *****  ****   * *    = s1[l1] - '0';
*****    *  * *  *  * **    *  **
**    *** **    ** * *    (l2 = 0; s2[l2] != '\0'; l2++)
     * ****  *   *   *** *  **  **  * * * * *  ** *   * * ** ** = s2[l2] - '0';
  *  *  **  ** * *  * * * *
**  * **  *    * ** **  * *  ** carry = 0;
 *  *  **** * * * ** * k = 0;
****    ****     * * **  *  ***  i = l1 - 1;
  *     * ***  *  **  *    ** ** j = l2 - 1;
 ****   *  *   ***   **** *  **  (; i >= 0 && j >= 0; i--, j--, k++) {
 *   * **** * **  ***      * ** * * * **** ***  *  ****  * ***    = (num1[i] + num2[j] + carry) % 10;
 ** ** *  **  ***   * *   * *   ** ***** **  ***   ***   *** = (num1[i] + num2[j] + carry) / 10;
***   ***** * ***   * *  * *
*    **     *  * ***  **  (l1 > l2) {
**  *   *   * * **  **** ** **     ** **  * ***   
   **    *    **    * *  ******  ***  ****  ******** *** **   (i >= 0) {
   *   * ***  **    * * * ** * ** ****  **** *** * ** **  **    ** ** *  **** * * ****    = (num1[i] + carry) % 10;
 **  * *   **   ***  *  ***   * * *   *     * ** *   *  **  * *** ***  *   *   = (num1[i--] + carry) / 10;
  * *  **    *  **   * * ** ****     *****   *    
  ** *   ***   *** *  **** *   ***  **  * ** ** *  * *  * 
 *  * ** ** ***  ***** *  *  else if (l1 < l2) {
  ** *** * ** ** *****  *****   * **** *   **   * *     * (j >= 0) {
*** * * ** **    * *  ** *  *  *  * *   ** * * * **   *    **  * *** ******   ****  = (num2[j] + carry) % 10;
** ** ** ** *    ** *    ****  *  *    * *  *    *****   *  * ********** ******* *   * = (num2[j--] + carry) / 10;
*****  *   ****  **   ** * * *   * * *  ** *** **
  * **    * *    *****  else {
****** ** * *   ***   *  * * ***   ** **  *  * * **   * (carry > 0)
  *  ** *   ***  * * ** ***  **   ***** ***** * **      * **** *  *   ** *** * **  *  ** = carry;
*  * *   *   * **** *    *  *
 *  ***  **  **  ** * * * *   *
 ***    * * * * * *  * 
  * *   * ** * ** **  * **** * (k--; k >= 0; k--)
**  ** ** *  ***   **  *    * *  * ****** * *  *   ****** * **   *   *    * *  sum[k]);
  *     **  *    *      * *  ***
 **  *    * *** ** ****        0;
}

Comments

Case 0: Correct output
Case 1: Correct output
Case 2: Correct output