ulvis.paste.net

Paste Search Dynamic
Recent pastes
sumNode
  1. #include <iostream>
  2. using namespace std;
  3.  
  4.  
  5. /*
  6.  
  7.  * You can choose your familiar language and design the api and strcuture
  8.  * Definition for singly-linked list.
  9.  * Input: List(2, 4, 3) + List(5, 6, 4)
  10.  * Output: List(7, 0, 8)
  11.  * Explanation: 342 + 465 = 807.
  12. */
  13.  
  14. struct node{
  15.         int value;
  16.         struct node *next;
  17. } Node;
  18.  
  19.  node* sumNode( node *first, node *second, int carry){
  20.  
  21.          node *result = new node;
  22.         if(first ==null || second == null) return null;
  23.  
  24.  
  25.         printf("\nAdding %d, %d, %d", first->value, second->value , carry);     
  26.         result->value = first->value + second->value + carry;
  27.                 if(result->value > 9) {
  28.                         carry = 1;
  29.                         result->value %=10;
  30.                 }else {
  31.                         carry = 0;
  32.                 }
  33.  
  34.         result->next = sumNode(first->next, second->next, carry);
  35.         return result;
  36.  
  37. }
  38.  
  39.  node* sumList( node *first,  node *second){
  40.  
  41.         //if(first->next == NULL && second->next == NULL) return NULL;
  42.  
  43.         // if(first == NULL) return second;
  44.         // if (second == NULL) return first;
  45.  
  46.         // int len1 = len(first);
  47.         // int len2 = len(second);
  48.  
  49.         // if(len1<len2)
  50.         // {
  51.         //      appendZeros(first, len2-len1);
  52.         // }
  53.         // else if (len2<len1){
  54.         //      appendZeros(first, len1-len2);
  55.         // }
  56.  
  57.         return sumNode(first, second, 0);
  58.  
  59. }
  60.  
  61. // int len(Node node){
  62. //      return 1;
  63. // }
  64.  
  65. // struct node appendZeros(Node first, Node second){
  66.  
  67. // }
  68.  
  69.  
  70. // struct node add(struct node *first, value){
  71. //      struct node a= new node();
  72. //      a.value=value;
  73. //      a->next = NULL;
  74. // }
  75.  
  76. // void sum(int first[], int second[], int ln){
  77. //      //cout<<"in sum";
  78. //      int c[3];
  79. //      int carry = 0;
  80. //      int i=0;
  81. //      while(ln-->0){
  82. //              c[i] = first[i] + second[i] + carry;
  83. //              if (c[i]>9){
  84. //                      c[i]%=10;
  85. //                      carry = 1;
  86. //              }else{
  87. //                      carry =0;
  88. //              }
  89. //              cout<<c[i];
  90. //              i++;
  91. //      }
  92.  
  93. //      if(carry) cout<<"1";
  94. // }
  95.  
  96. void printNode(node *n){
  97.         cout<<"\nprint node\n";
  98.         while(n!=null){
  99.                 cout<<n->value<<",";
  100.                 n=n->next;
  101.  
  102.         }
  103. }
  104.  
  105. void newNode( node **a, int value){
  106.  
  107.         // cout<<"Add new node"<<endl;
  108.         // printf("Value : %d\n", value);
  109.          node *n = new node;
  110.          //cout<<"created new node"<<endl;
  111.         n->value = value;
  112.         n->next = null;
  113.  
  114.         if(*a==null){
  115.                 // cout<<"add in head"<<endl;;
  116.                 *a=n;
  117.         }
  118.         else{
  119.                 // cout<<"add in tail"<<endl;
  120.                 node *p = *a;
  121.                 while(p->next!=null){
  122.                         p=p->next;
  123.                 }
  124.                 p->next = n;
  125.         }
  126.         // cout<<"node added"<<endl;;
  127. }
  128.  
  129. node* dummy(){
  130.         node *a = new node;
  131.         node *b = new node;
  132.         node *c = new node;
  133.  
  134.         a->value = 5;
  135.         b->value = 1;
  136.         c->value = 2;
  137.         a->next = b;
  138.         b->next = c;
  139.         c->next = null;
  140.  
  141.         return a;
  142.  
  143. }
  144.  
  145. int main() {
  146.         // your code goes here
  147.         cout<<"Testing"<<endl;
  148.  
  149.  
  150.           node *first = null;
  151.          node *second = null;
  152.          node *sum = null;
  153.                 //printNode(first);
  154.         newNode(&first, 2);     //printNode(first);
  155.         newNode(&first, 4);     //printNode(first);
  156.         newNode(&first, 3);     //printNode(first);
  157.         newNode(&second, 5);    //printNode(first);
  158.         newNode(&second, 6);    //printNode(first);
  159.         newNode(&second, 4);
  160.         printNode(first);
  161.         printNode(second);
  162.  
  163.     sum = sumList(first, second);
  164.  
  165.         printNode(sum);
  166.  
  167.         node *d = dummy();
  168.         printNode(d);
  169.         // first->next = add(first, 3);
  170.         // first->next->next = add(first->next, 4);
  171.  
  172. //      cout<<"adding list";
  173.         // int first[] = {0, 0, 0};
  174.         // int second[] = {0, 0, 0};
  175.  
  176.         // sum(first, second, 3);
  177.  
  178.         return 0;
  179. }
  180.  
Parsed in 0.018 seconds