diff --git a/others/fibonacci_large.cpp b/others/fibonacci_large.cpp
index 12b926759..bdfb201a5 100644
--- a/others/fibonacci_large.cpp
+++ b/others/fibonacci_large.cpp
@@ -7,52 +7,69 @@
  * number that contains 10450 digits!
  **/
 
-#include "large_number.h"
+#include <ctime>
 #include <iostream>
-#include <chrono>
 
-large_number fib(unsigned long long n)
-{
+#include "large_number.h"
+
+large_number fib(unsigned long long n) {
     large_number f0(1);
     large_number f1(1);
 
-    do
-    {
+    do {
         large_number f2 = f0 + f1;
         f0 = f1;
         f1 = f2;
         n--;
-    } while (n > 2); // since we start from 2
+    } while (n > 2);  // since we start from 2
     return f1;
 }
 
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     unsigned long long N;
     if (argc == 2)
         N = strtoull(argv[1], NULL, 10);
-    else
-    {
+    else {
         std::cout << "Enter N: ";
         std::cin >> N;
     }
 
-    auto start_time = std::chrono::high_resolution_clock::now();
+    clock_t start_time = std::clock();
     large_number result = fib(N);
-    auto end_time = std::chrono::high_resolution_clock::now();
-    std::chrono::duration<double> time_taken = end_time - start_time;
+    clock_t end_time = std::clock();
+    double time_taken = static_cast<double>(end_time - start_time) /
+                        static_cast<double>(CLOCKS_PER_SEC);
 
-    std::cout
-        << std::endl
-        << N << "^th Fibonacci number: " << result << std::endl
-        << "Number of digits: " << result.num_digits() << std::endl
-        << "Time taken: " << time_taken.count() << " s" << std::endl;
+    std::cout << std::endl
+              << N << "^th Fibonacci number: " << result << std::endl
+              << "Number of digits: " << result.num_digits() << std::endl
+              << "Time taken: " << std::scientific << time_taken << " s"
+              << std::endl;
 
     N = 5000;
-    if (fib(N) == large_number("3878968454388325633701916308325905312082127714646245106160597214895550139044037097010822916462210669479293452858882973813483102008954982940361430156911478938364216563944106910214505634133706558656238254656700712525929903854933813928836378347518908762970712033337052923107693008518093849801803847813996748881765554653788291644268912980384613778969021502293082475666346224923071883324803280375039130352903304505842701147635242270210934637699104006714174883298422891491273104054328753298044273676822977244987749874555691907703880637046832794811358973739993110106219308149018570815397854379195305617510761053075688783766033667355445258844886241619210553457493675897849027988234351023599844663934853256411952221859563060475364645470760330902420806382584929156452876291575759142343809142302917491088984155209854432486594079793571316841692868039545309545388698114665082066862897420639323438488465240988742395873801976993820317174208932265468879364002630797780058759129671389634214252579116872755600360311370547754724604639987588046985178408674382863125"))
-        std::cout << "Test for " << N << "^th Fibonacci number passed!" << std::endl;
+    if (fib(N) ==
+        large_number(
+            "387896845438832563370191630832590531208212771464624510616059721489"
+            "555013904403709701082291646221066947929345285888297381348310200895"
+            "498294036143015691147893836421656394410691021450563413370655865623"
+            "825465670071252592990385493381392883637834751890876297071203333705"
+            "292310769300851809384980180384781399674888176555465378829164426891"
+            "298038461377896902150229308247566634622492307188332480328037503913"
+            "035290330450584270114763524227021093463769910400671417488329842289"
+            "149127310405432875329804427367682297724498774987455569190770388063"
+            "704683279481135897373999311010621930814901857081539785437919530561"
+            "751076105307568878376603366735544525884488624161921055345749367589"
+            "784902798823435102359984466393485325641195222185956306047536464547"
+            "076033090242080638258492915645287629157575914234380914230291749108"
+            "898415520985443248659407979357131684169286803954530954538869811466"
+            "508206686289742063932343848846524098874239587380197699382031717420"
+            "893226546887936400263079778005875912967138963421425257911687275560"
+            "0360311370547754724604639987588046985178408674382863125"))
+        std::cout << "Test for " << N << "^th Fibonacci number passed!"
+                  << std::endl;
     else
-        std::cerr << "Test for " << N << "^th Fibonacci number failed!" << std::endl;
+        std::cerr << "Test for " << N << "^th Fibonacci number failed!"
+                  << std::endl;
 
     return 0;
 }
\ No newline at end of file
diff --git a/others/large_factorial.cpp b/others/large_factorial.cpp
index 5ee116b4c..f06f4e7af 100644
--- a/others/large_factorial.cpp
+++ b/others/large_factorial.cpp
@@ -1,102 +1,97 @@
-#include <iostream>
 #include <string.h>
-#include <chrono>
+
+#include <ctime>
+#include <iostream>
+
 #include "large_number.h"
 
-using namespace std;
-
-bool test1()
-{
-    cout << "---- Check 1\t";
+bool test1() {
+    std::cout << "---- Check 1\t";
     unsigned int i, number = 10;
     large_number result;
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
 
     const char *known_reslt = "3628800";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
-        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+    if (strlen(known_reslt) != result.num_digits()) {
+        std::cerr << "Result lengths dont match! " << strlen(known_reslt)
+                  << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
+            std::cerr << i << "^th digit mismatch! " << known_reslt[i]
+                      << " != " << result.digit_char(i) << std::endl;
             return false;
         }
     }
 
-    cout << "Passed!" << endl;
+    std::cout << "Passed!" << std::endl;
     return true;
 }
 
-bool test2()
-{
-    cout << "---- Check 2\t";
+bool test2() {
+    std::cout << "---- Check 2\t";
     unsigned int i, number = 100;
     large_number result;
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
 
-    const char *known_reslt = "93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000";
+    const char *known_reslt =
+        "9332621544394415268169923885626670049071596826438162146859296389521759"
+        "9993229915608941463976156518286253697920827223758251185210916864000000"
+        "000000000000000000";
 
     /* check 1 */
-    if (strlen(known_reslt) != result.num_digits())
-    {
-        cerr << "Result lengths dont match! " << strlen(known_reslt) << " != " << result.num_digits() << endl;
+    if (strlen(known_reslt) != result.num_digits()) {
+        std::cerr << "Result lengths dont match! " << strlen(known_reslt)
+                  << " != " << result.num_digits() << std::endl;
         return false;
     }
 
     const size_t N = result.num_digits();
-    for (i = 0; i < N; i++)
-    {
-        if (known_reslt[i] != result.digit_char(i))
-        {
-            cerr << i << "^th digit mismatch! " << known_reslt[i] << " != " << result.digit_char(i) << endl;
+    for (i = 0; i < N; i++) {
+        if (known_reslt[i] != result.digit_char(i)) {
+            std::cerr << i << "^th digit mismatch! " << known_reslt[i]
+                      << " != " << result.digit_char(i) << std::endl;
             return false;
         }
     }
 
-    cout << "Passed!" << endl;
+    std::cout << "Passed!" << std::endl;
     return true;
 }
 
 /**
  * Main program
  **/
-int main(int argc, char *argv[])
-{
+int main(int argc, char *argv[]) {
     int number, i;
 
     if (argc == 2)
         number = atoi(argv[1]);
-    else
-    {
-        printf("Enter the value of n(n starts from 0 ): ");
-        scanf("%d", &number);
+    else {
+        std::cout << "Enter the value of n(n starts from 0 ): ";
+        std::cin >> number;
     }
 
     large_number result;
 
-    auto start_time = chrono::high_resolution_clock::now();
-    for (i = 2; i <= number; i++)
-        /* Multiply every number from 2 thru N */
+    std::clock_t start_time = std::clock();
+    for (i = 2; i <= number; i++) /* Multiply every number from 2 thru N */
         result *= i;
-    auto end_time = chrono::high_resolution_clock::now();
-    chrono::duration<double> time_taken = end_time - start_time;
+    std::clock_t end_time = std::clock();
+    double time_taken =
+        static_cast<double>(end_time - start_time) / CLOCKS_PER_SEC;
 
-    cout << number << "! = " << result << endl
-         << "Number of digits: " << result.num_digits() << endl
-         << "Time taken: " << time_taken.count() << " s"
-         << endl;
+    std::cout << number << "! = " << result << std::endl
+              << "Number of digits: " << result.num_digits() << std::endl
+              << "Time taken: " << std::scientific << time_taken << " s"
+              << std::endl;
 
     test1();
     test2();
diff --git a/others/large_number.h b/others/large_number.h
index 8c7f688d0..4657e87af 100644
--- a/others/large_number.h
+++ b/others/large_number.h
@@ -5,10 +5,10 @@
 
 #ifndef __LARGE_NUMBER__
 #define __LARGE_NUMBER__
-#include <type_traits>
-#include <iostream>
 #include <cassert>
 #include <cstring>
+#include <iostream>
+#include <type_traits>
 #include <vector>
 
 /**
@@ -17,9 +17,8 @@
  * digit to the number, perform multiplication of
  * large number with long unsigned integers.
  **/
-class large_number
-{
-public:
+class large_number {
+   public:
     large_number() /**< initializer with value = 1 */
     {
         _digits.push_back(1);
@@ -28,85 +27,79 @@ public:
     large_number(unsigned long n) /**< initializer from an integer */
     {
         unsigned long carry = n;
-        do
-        {
+        do {
             add_digit(carry % 10);
             carry /= 10;
         } while (carry != 0);
     }
 
-    large_number(const large_number &a) /**< initializer from another large_number */
+    large_number(
+        const large_number &a) /**< initializer from another large_number */
     {
         _digits = a._digits;
     }
 
-    large_number(const std::vector<unsigned char> &vec) /**< initializer from a vector */
+    large_number(
+        const std::vector<unsigned char> &vec) /**< initializer from a vector */
     {
         _digits = vec;
     }
 
     large_number(const char *number_str) /**< initializer from a string */
     {
-        for (size_t i = strlen(number_str); i > 0; i--)
-        {
+        for (size_t i = strlen(number_str); i > 0; i--) {
             unsigned char a = number_str[i - 1] - '0';
-            if (a >= 0 && a <= 9)
-                _digits.push_back(a);
+            if (a >= 0 && a <= 9) _digits.push_back(a);
         }
     }
 
     /**
      * Function to check implementation
      **/
-    static bool test()
-    {
-        std::cout << "------ Checking `large_number` class implementations\t" << std::endl;
+    static bool test() {
+        std::cout << "------ Checking `large_number` class implementations\t"
+                  << std::endl;
         large_number a(40);
         // 1. test multiplication
         a *= 10;
-        if (a != large_number(400))
-        {
+        if (a != large_number(400)) {
             std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 1/6...";
         // 2. test compound addition with integer
         a += 120;
-        if (a != large_number(520))
-        {
+        if (a != large_number(520)) {
             std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 2/6...";
         // 3. test compound multiplication again
         a *= 10;
-        if (a != large_number(5200))
-        {
+        if (a != large_number(5200)) {
             std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 3/6...";
         // 4. test increment (prefix)
         ++a;
-        if (a != large_number(5201))
-        {
+        if (a != large_number(5201)) {
             std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 4/6...";
         // 5. test increment (postfix)
         a++;
-        if (a != large_number(5202))
-        {
+        if (a != large_number(5202)) {
             std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 5/6...";
         // 6. test addition with another large number
         a = a + large_number("7000000000000000000000000000000");
-        if (a != large_number("7000000000000000000000000005202"))
-        {
-            std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)" << std::endl;
+        if (a != large_number("7000000000000000000000000005202")) {
+            std::cerr << "\tFailed 6/6 (" << a
+                      << "!=7000000000000000000000000005202)" << std::endl;
             return false;
         }
         std::cout << "\tPassed 6/6..." << std::endl;
@@ -116,10 +109,8 @@ public:
     /**
      * add a digit at MSB to the large number
      **/
-    void add_digit(unsigned int value)
-    {
-        if (value > 9)
-        {
+    void add_digit(unsigned int value) {
+        if (value > 9) {
             std::cerr << "digit > 9!!\n";
             exit(EXIT_FAILURE);
         }
@@ -130,31 +121,23 @@ public:
     /**
      * Get number of digits in the number
      **/
-    const size_t num_digits() const
-    {
-        return _digits.size();
-    }
+    const size_t num_digits() const { return _digits.size(); }
 
     /**
      * operator over load to access the
      * i^th digit conveniently and also
      * assign value to it
      **/
-    inline unsigned char &operator[](size_t n)
-    {
-        return this->_digits[n];
-    }
+    inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
 
-    inline const unsigned char &operator[](size_t n) const
-    {
+    inline const unsigned char &operator[](size_t n) const {
         return this->_digits[n];
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend std::ostream &operator<<(std::ostream &out, const large_number &a)
-    {
+    friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
         for (size_t i = a.num_digits(); i > 0; i--)
             out << static_cast<int>(a[i - 1]);
         return out;
@@ -163,30 +146,25 @@ public:
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator==(const large_number &a, const large_number &b)
-    {
+    friend bool operator==(large_number const &a, large_number const &b) {
         size_t N = a.num_digits();
-        if (N != b.num_digits())
-            return false;
+        if (N != b.num_digits()) return false;
         for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i])
-                return false;
+            if (a[i] != b[i]) return false;
         return true;
     }
 
     /**
      * operator overload to compare two numbers
      **/
-    friend bool operator!=(const large_number &a, const large_number &b)
-    {
+    friend bool operator!=(large_number const &a, large_number const &b) {
         return !(a == b);
     }
 
     /**
      * operator overload to increment (prefix)
      **/
-    large_number &operator++()
-    {
+    large_number &operator++() {
         (*this) += 1;
         return *this;
     }
@@ -194,8 +172,7 @@ public:
     /**
      * operator overload to increment (postfix)
      **/
-    large_number operator++(int)
-    {
+    large_number operator++(int) {
         large_number tmp(_digits);
         ++(*this);
         return tmp;
@@ -205,31 +182,28 @@ public:
      * operator overload to add
      **/
     template <class T>
-    large_number &operator+=(T n)
-    {
-        if (typeid(T) == typeid(large_number)) // if adding with another large_number
+    large_number &operator+=(T n) {
+        if (typeid(T) ==
+            typeid(large_number))  // if adding with another large_number
         {
             large_number *b = (large_number *)&n;
             const size_t max_L = std::max(this->num_digits(), b->num_digits());
             unsigned int carry = 0;
             size_t i;
-            for (i = 0; i < max_L || carry != 0; i++)
-            {
-                if (i < b->num_digits())
-                    carry += (*b)[i];
-                if (i < this->num_digits())
-                    carry += (*this)[i];
+            for (i = 0; i < max_L || carry != 0; i++) {
+                if (i < b->num_digits()) carry += (*b)[i];
+                if (i < this->num_digits()) carry += (*this)[i];
                 if (i < this->num_digits())
                     (*this)[i] = carry % 10;
                 else
                     this->add_digit(carry % 10);
                 carry /= 10;
             }
-        }
-        else if (std::is_integral<T>::value)
+        } else if (std::is_integral<T>::value)
             return (*this) += large_number(n);
         else
-            std::cerr << "Must be integer addition unsigned integer types." << std::endl;
+            std::cerr << "Must be integer addition unsigned integer types."
+                      << std::endl;
         return *this;
     }
 
@@ -237,8 +211,7 @@ public:
      * operator overload to perform addition
      **/
     template <class T>
-    friend large_number &operator+(large_number &a, const T &b)
-    {
+    friend large_number &operator+(large_number &a, const T &b) {
         a += b;
         return a;
     }
@@ -246,18 +219,15 @@ public:
     /**
      * assignment operator
      **/
-    void operator=(const large_number &b)
-    {
-        _digits = b._digits;
-    }
+    void operator=(const large_number &b) { _digits = b._digits; }
 
     /**
      * operator overload to increment
      **/
     template <class T>
-    large_number &operator*=(const T n)
-    {
-        static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
+    large_number &operator*=(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Must be integer addition unsigned integer types.");
         this->multiply(n);
         return *this;
     }
@@ -265,46 +235,44 @@ public:
     /**
      * returns i^th digit as an ASCII character
      **/
-    const char digit_char(size_t i) const
-    {
+    const char digit_char(size_t i) const {
         return _digits[num_digits() - i - 1] + '0';
     }
 
-private:
+   private:
     /**
      * multiply large number with another integer and
      * store the result in the same large number
      **/
     template <class T>
-    void multiply(const T n)
-    {
-        static_assert(std::is_integral<T>::value, "Can only have integer types.");
-        // assert(!(std::is_signed<T>::value)); //, "Implemented only for unsigned integer types.");
+    void multiply(const T n) {
+        static_assert(std::is_integral<T>::value,
+                      "Can only have integer types.");
+        // assert(!(std::is_signed<T>::value)); //, "Implemented only for
+        // unsigned integer types.");
 
         size_t i;
         unsigned long long carry = 0, temp;
-        for (i = 0; i < this->num_digits(); i++)
-        {
+        for (i = 0; i < this->num_digits(); i++) {
             temp = (*this)[i] * n;
             temp += carry;
             if (temp < 10)
                 carry = 0;
-            else
-            {
+            else {
                 carry = temp / 10;
                 temp = temp % 10;
             }
             (*this)[i] = temp;
         }
 
-        while (carry != 0)
-        {
+        while (carry != 0) {
             this->add_digit(carry % 10);
             carry /= 10;
         }
     };
 
-    std::vector<unsigned char> _digits; /**< where individual digits are stored */
+    std::vector<unsigned char>
+        _digits; /**< where individual digits are stored */
 };
 
 #endif