Check if number is a tribonacci number - c++

Question

Tribonacci numbers are defined as below. I am trying to write a program that checks if a number is a tribonacci number. I have wrote the function, but how can I acctually check if the number is a trib number with this? Because when I enter 45, it wont return anything.
T0=0
T1=1
T2=2
Tn=Tn-1 + Tn-2 + Tn-3 (for n>2)
int trib(int n)
{
if (n == 0 || n == 1 || n == 2)
{
cout << "YES";
}
if (n >= 2)
{
return trib(n - 1) + trib(n - 2) + trib(n - 3);
}
}
int main()
{
int input;
cin >> input;
cout << trib(input);
}
If input
3
45
then output
YES
NO

Answer 1

Other than memoization + recursion, an old style approach is to use a while loop and stop if the value >=n:
#include <iostream>
bool trib(int n)
{
if (n == 0 || n == 1 || n == 2) {return true;}
int a = 0, b = 1, c = 2, d = a+b+c;
while(d < n)
{
a = b; b = c; c = d; d = a+b+c;
}
if (d == n) {return true;} return false;
}
int main()
{
int input; std::cin >> input;
if (trib(input)) {std::cout << "YES";} else {std::cout << "NO";}
}
Result :
3 --> YES
11 --> YES
45 --> NO
Your implementation of recursion (without memoization) will have exponentially time complexity.
Edit: To the second question: I have to input number betwen 0<= && <= 1000000 So I need to make for loop to count 1000000 tribonacci numbers? This will take year.
Seriously? A good to average computers will loop from 1 -> 10^6 in less than 1 second.
Not mentioning that from 1 -> 10^6 based on your formula there's only... 23 Tribonacci number:
#include <iostream>
bool trib(int n)
{
if (n == 0 || n == 1 || n == 2) {return true;}
int a = 0, b = 1, c = 2, d = a+b+c;
while(d < n)
{
a = b; b = c; c = d; d = a+b+c;
}
if (d == n) {return true;} return false;
}
int main()
{
int counter = 0;
for (int i = 1; i <= 1000000; i++)
{
if (trib(i)) {std::cout << i << '\n'; counter++;}
}
std::cout << "Counter : " << counter;
}
Result:
1
2
3
6
11
20
37
68
125
230
423
778
1431
2632
4841
8904
16377
30122
55403
101902
187427
344732
634061
Counter : 23

Answer 2

There are several problems.
You need to understand that the values are growing strongly exponential. Already the 24th value will be greater then 1000000.
Then, your function does not work as specified. You also made a very slow implementation. But does not matter in this case.
But then, you made a wrong design. What you need to use is memoization. Sounds complicated, but is not. Simply precalculate the first 25 trib numbers, and the check, if the input is such a number.
Basically very simple. There are one million possible solutions. Here is a straightforward one based on your original approach:
constexpr size_t MaxNumbers = 25u;
int trib(int n)
{
if (n < 3) return n;
return trib(n - 1) + trib(n - 2) + trib(n - 3);
}
int main()
{
int tribNumber[MaxNumbers]{};
for (int i{}; i < MaxNumbers; ++i) {
tribNumber[i] = trib(i);
}
std::cout << "\nEnter number in the range 0...1'000'000: ";
unsigned int numberToCheck{};
if (std::cin >> numberToCheck and numberToCheck <= 1'000'000) {
bool found{};
for (int i{}; i < MaxNumbers; ++i) {
if (tribNumber[i] == numberToCheck) {
found = true;
}
}
if (found)
std::cout << "Yes\n";
else
std::cout << "No\n";
}
else {
std::cerr << "\nError: Wrong Input\n";
}
return 0;
}
By the way. All trib numbers can be easily calculated at runtime. This will make your program ultrafast and very compact. I cannot imagine a better solution.
#include <iostream>
#include <array>
#include <algorithm>
// Begin of all done during compile time -------------------------------------------------------------------
constexpr unsigned int getTribonacciNumber(size_t index) noexcept {
if (index < 3) return index;
unsigned int f0{ 0u }, f1{ 1ull }, f2{ 2ull }, f3{};
index -= 2;
while (index--) { f3 = f2 + f1 + f0; f0 = f1; f1 = f2; f2 = f3; }
return f2;
}
// Some helper to create a constexpr std::array initilized by a generator function
template <typename Generator, size_t ... Indices>
constexpr auto generateArrayHelper(Generator generator, std::index_sequence<Indices...>) {
return std::array<decltype(std::declval<Generator>()(size_t{})), sizeof...(Indices) > { generator(Indices)... };
}
template <size_t Size, typename Generator>
constexpr auto generateArray(Generator generator) {
return generateArrayHelper(generator, std::make_index_sequence<Size>());
}
constexpr size_t MaxIndexForTribonacci = 25u;
// This is the definition of a std::array<unsigned int, 93> with all Tribonacci numbers in it
constexpr auto trib = generateArray<MaxIndexForTribonacci>(getTribonacciNumber);
// End of: All done during compile time -----------------------------------------------------------
// The only code executed during runtime
int main() {
// Show all Tribonacci numbers up to border value
for (const unsigned int t : trib) std::cout << t << '\n';
return 0;
}
See, everything is done during compile time. The resulting array is a compile time array. No calculation at all is done during runtime.
And if you want to addapt this program for your specific requiremens, then youcan use the below:
#include <iostream>
#include <array>
#include <algorithm>
// Begin of all done during compile time -------------------------------------------------------------------
constexpr unsigned int getTribonacciNumber(size_t index) noexcept {
if (index < 3) return index;
unsigned int f0{ 0u }, f1{ 1ull }, f2{ 2ull }, f3{};
index -= 2;
while (index--) { f3 = f2 + f1 + f0; f0 = f1; f1 = f2; f2 = f3; }
return f2;
}
// Some helper to create a constexpr std::array initilized by a generator function
template <typename Generator, size_t ... Indices>
constexpr auto generateArrayHelper(Generator generator, std::index_sequence<Indices...>) {
return std::array<decltype(std::declval<Generator>()(size_t{})), sizeof...(Indices) > { generator(Indices)... };
}
template <size_t Size, typename Generator>
constexpr auto generateArray(Generator generator) {
return generateArrayHelper(generator, std::make_index_sequence<Size>());
}
constexpr size_t MaxIndexForTribonacci = 25u;
// This is the definition of a std::array<unsigned int, 93> with all Tribonacci numbers in it
constexpr auto trib = generateArray<MaxIndexForTribonacci>(getTribonacciNumber);
// End of: All done during compile time -----------------------------------------------------------
// The only code executed during runtime
int main() {
std::cout << "\nEnter number in the range 0...1'000'000: ";
unsigned int numberToCheck{};
if (std::cin >> numberToCheck and numberToCheck <= 1'000'000) {
if (binary_search(trib.begin(), trib.end(), numberToCheck))
std::cout << "Yes\n";
else
std::cout << "No\n";
}
else {
std::cerr << "\nError: Wrong Input\n";
}
return 0;
}
This approach will outperform nearly everything . . .

Answer 3

I think, without using recursion, the program might become a lot faster and easier. we will just see if input matches any of trib0,trib1,trib2.
tribonacci= 0, 0, 1, 1, 2, 4, 7, 13, 24, 44, 81, 149, 274, 504
trib(n)= 0 1 2 0 1 2 0 1 2 0 1 2 0 1
#include <iostream>
using namespace std ;
int main(int argc, char const *argv[])
{
int n;
cin>> n;
int trib0 = 0, trib1 = 0, trib2 = 1;
if (n == trib0 || n == trib1 || n == trib2)
{
cout<<"YES, it is tribonacci\n";
return 0;
}
while(trib0<=n)
{
trib0 = trib0 + trib1 + trib2;
if (n == trib0)
{
cout<<"YES, it is tribonacci\n";
return 0;
}
trib1 = trib0 + trib1 + trib2;
if ( n == trib1)
{
cout<<"YES, it is tribonacci\n";
return 0;
}
trib2 = trib0 + trib1 + trib2;
if (n == trib2)
{
cout<<"YES, it is tribonacci\n";
return 0;
}
}
cout<<"No, it's not\n";
return 0;
}