dev.to staff

Posted on Dec 24, 2019

Daily Challenge #143 - Big Arithmetic

#challenge

Doing arithmetic with big numbers is impossible to do with regular integer types. In JavaScript (which represents numbers as 64-bit floats), anything beyond 2^53-1 becomes increasingly less accurate.

Write a two functions (bigAdd and bigSub) to accurately represent these large integers as strings. They will both take two arguments: either a valid representation of an integer as a string, or a regular number. They will return the correct answer as a string. bigAdd will sum, bigSub will subtract.

For example:
bigAdd(1, "123456789012345678901234567890") === "123456789012345678901234567891";
bigSub("123456789012345678901234567890", 1) === "123456789012345678901234567889";

Remember, the values could be negative, and so the calculations should be made accordingly.
bigAdd(-1, "123456789012345678901234567890") === "123456789012345678901234567889";
bigSub("123456789012345678901234567890", -1) === "123456789012345678901234567891";

Tests



bigAdd(1, "123456789012345678901234567890")

bigAdd(-1, "123456789012345678901234567890")

bigSub("123456789012345678901234567890", 1)

bigSub("123456789012345678901234567890", -1)

This challenge comes from wthit56 on CodeWars. Thank you to CodeWars, who has licensed redistribution of this challenge under the 2-Clause BSD License!

Want to propose a challenge idea for a future post? Email yo+challenge@dev.to with your suggestions!

Top comments (4)

Yechiel Kalmenson • Dec 25 '19

Thankfully, Ruby automatically converts ints to Bignums when it detects an overflow, so the Ruby solution is as simple as:

def big_add(a, b)
  (a.to_i + b.to_i).to_s
end

def big_sub(a, b)
  (a.to_i - b.to_i).to_s
end

Vaibhav Yadav • Dec 24 '19

In JavaScript.

const bigAdd = (a, b) => (BigInt(a) + BigInt(b)).toString();
const bigSub = (a, b) => (BigInt(a) - BigInt(b)).toString();

Craig McIlwrath • Dec 24 '19

Haskell

bigAdd :: Integer -> Integer -> Integer
bigAdd = (+) 

bigSub :: Integer -> Integer -> Integer
bigSub = (-)

It isn't feaaible/doesn't make sense to define similar methods that take various combinations of strings and integers. Especially in a language with support for literals of arbitrarily sized integers.

Chandra Shekhar • Dec 25 '19

Java :)

import java.math.BigInteger;

public class BigArithmetic {

public static void main(String[] args) {
    System.out.println(bigAdd(1, "123456789012345678901234567890"));
    System.out.println(bigAdd(-1, "123456789012345678901234567890"));
    System.out.println(bigSub("123456789012345678901234567890", 1));
    System.out.println(bigSub("123456789012345678901234567890", -1));
}

private static String bigSub(Object a, Object b) {
    return new BigInteger(a.toString()).add(new BigInteger(b.toString())).toString();
}

private static String bigAdd(Object a, Object b) {
    return new BigInteger(a.toString()).add(new BigInteger(b.toString())).toString();
}

}

DEV Community

Daily Challenge #143 - Big Arithmetic

Top comments (4)

Read next

tuistash: A Terminal User Interface for Logstash

Mastering Multiple Returns in Ruby: The Power of Data.define

[Paper Implementation] Fast Shape-based Template Matching

Software Project Management for Website Development