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