CareerCup

// TASK: Define a structure / class to hold a very big number (way bigger than bigint) and add a member functions to increment the number by 1 and decrement the number by 1

#include <vector>
#include <stdint.h>
#include <iostream>

class BigNumber {
    
    friend std::ostream & operator<<(std::ostream &out, BigNumber const &number);
    
public:
    
    BigNumber() : positive(true) {
        numbers.push_back(0);
    }
    
public:
    
    void increment() {        
        if (positive) {
            increment_numbers();
        } else {
            decrement_numbers();
        }
        
        if (!positive && numbers.front() == 0 && numbers.size() == 1) {
            positive = true;
        }
    }
    
    void decrement() {
        if (positive && numbers.front() == 0 && numbers.size() == 1) {
            positive = false;
        }
        
        if (positive) {
            decrement_numbers();
        } else {
            increment_numbers();
        }
    }
    
protected:
    
    void increment_numbers() {
        for (uintmax_t &number : numbers) {
            number++;
            if (number != 0) break;
        }
        if (numbers.back() == 0) {
            numbers.push_back(1);
        }
    }
    
    void decrement_numbers() {
        for (uintmax_t &number : numbers) {
            if (number != 0) {
                number--;
                break;
            } else {
                number--;
            }
        }
        if (numbers.back() == 0 && numbers.size() > 1) {
            numbers.pop_back();
        }
    }
    
private:
    bool positive;
    std::vector<uintmax_t> numbers;
};

std::ostream & operator<<(std::ostream &out, BigNumber const &bigNumber) {
    if (!bigNumber.positive) {
        out << '-';
    }
    for (uintmax_t number : bigNumber.numbers) {
        out << std::hex << number << std::dec;
    }
    return out;
}

int main() {
    BigNumber bigNum;
    std::cout << bigNum << std::endl;
    bigNum.increment();
    std::cout << bigNum << std::endl;
    bigNum.decrement();
    bigNum.decrement();
    std::cout << bigNum << std::endl;
}

I think we can use ArrayList.

#define MAX 1000
struct bigN{
unsigned char bigNumber[MAX];
bool / char sign;
}

void incBigN(unsigned char x[])
{
     int i = 1;
     x[MAX-i]++;
     while( ( x[MAX-i] / 10 != 0) || (i != MAX+1) )
     {
         x[MAX-i++] %= 10;
         if(i == MAX+1)
          // overflow, return error or something
          break;
         x[MAX-i]++;
      }
}

void decBigN(unsigned char x[])
{
     int i = 1;
     x[MAX-i]--;
     while( ( x[MAX-i] != 255) || (i != MAX+1) )
     {
         x[MAX-i++] =0;
         if(i == MAX+1)
          break;
         x[MAX-i]--;
      }
}

int main()
{
    bigN b;
    b.sign =0; // initialize sign to 0

   // use b

   return 0;
}

This might work

Each and every digit as an array element

for example the number 1,23,45,67,89,12,34,56,789 can fit in array of size 18

another way is to have each and every digit as linked list node but in reverse direction to provide the increment and decrement operation on head which is the last digit of the number

9->8->7->6->5 and so on

This might work.

class BigNumber {
ArrayList<Integer> number= new ArrayList<Integer>();

BigNumber(String s) {
for(int i=0; i<s.length(); i++) number.add(s.charAt(i) - '0');
}

public void increment() {
int length = number.size();
int i=1;
int temp = number.get(length-i);
temp++;
number.remove(length-i);
number.add(length-i,temp);
while( number.get(length-i) == 10) {
number.remove(length-i);
number.add(0);
i++;
if(number.get(0)==0) {
number.add(0,1);
}
if(i>length) break;
temp = number.get(length-i);
number.remove(length-i);
temp++;
number.add(length-i,temp);

}
}

public void decrement() {
int length = number.size();
int i=1;
int temp = number.get(length-i);
temp--;
number.remove(length-i);
number.add(length-i,temp);
while( number.get(length-i) == -1) {
number.remove(length-i);
number.add(9);
i++;
if(i>length) break;
temp = number.get(length-i);
number.remove(length-i);
temp--;
if(temp!=0) number.add(length-i,temp);
}
}
}

class BigInteger
{
        private ArrayList<Character> digits;
 
        public BigInteger(String s)
        {
                digits = new ArrayList<Character>();
                char[] a  = s.toCharArray();
                for(int i = a.length - 1; i >= 0; i--) digits.add(a[i]);
        }
 
        public void increment()
        {
                int i = 0;
                for(; i < digits.size() && digits.get(i) == '9'; i++) digits.set(i, '0');
                if(i < digits.size()) digits.set(i, (char)(digits.get(i) + 1));
                else digits.add('1');
        }
 
        public void decrement()
        {
                int i = 0;
                for(; i < digits.size() && digits.get(i) == '0'; i++) digits.set(i, '9');
                digits.set(i, (char)(digits.get(i) - 1));
                if(i == digits.size() - 1 && digits.get(i) == '0') digits.remove(i);
        }
 
        @Override
        public String toString()
        {
                StringBuilder sb = new StringBuilder();
                for(int i = digits.size() - 1; i >= 0; i--)
                        sb.append(digits.get(i));
                return sb.toString();
        }        
}

class VeryBigNumber{
	String number;
	
	public VeryBigNumber(String number){
		this.number = number;
	}
	
	void increment(){
		char[] digits = number.toCharArray();
		int carried = 0;
		for(int i = digits.length-1; i>=0; i--){
			int digit = digits[i] - '0';
			int sum = digit + carried;
			if(i==digits.length-1)
				sum++;
			if(sum == 10){
				digits[i] = (char)'0';
				carried = 1;
			}
			else{
				digits[i] = (char)('0' + sum);
				carried = 0;
			}
		}
		number = new String(digits);
		if(carried > 0)
			number = carried + number;

	}

}

the number is consist of a list of number no larger than 100000

class
{
   ArrayList<Integer> num = ArrayList<Integer>();
   public void addOne()
   {
       int f = 1;
       for(int i = 0; i < num.size(); i++)
       {
          int v = num.get(i);
          v += f;
          if(v == 100000)
          {
              num.set(i, 0);
          }
          else
          {
              num.set(i, v);
              f = 0;
              break;
          }
       }
       if(f == 1)
          num.add(1);
   }
}

Think of it as a speedometer we can use a linked list/doubly linked list and keep on adding the node once we reach 10 of the highest digit

class bignumber{
  Public:
        char value[1000000];
        char *increment(char []);
        char *decrement(char[]);
};