backup/C-Plus-Plus
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/C-Plus-Plus.git synced 2026-04-05 03:29:46 +08:00
Code Issues Projects Releases Wiki Activity

replace std::chronos with ctime - cpplint does not allow c++-11

Browse Source
This commit is contained in:
Krishna Vedala
2020-05-24 15:56:45 -04:00
parent a77151c254
commit 236b658130
3 changed files with 142 additions and 162 deletions
Download Patch File Download Diff File Expand all files Collapse all files

61
others/fibonacci_large.cpp
View File

@@ -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;
}

91
others/large_factorial.cpp
View File

@@ -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();

152
others/large_number.h
View File

@@ -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