int fibo(int a)
{
if ((a==1) || (a == 2)){
return 1;}
else{
return fibo(a-2) + fibo(a-1); }
}
long long fibo(int n)
{
if (n == 1 || n == 2)
return 1;
else
return fibo(n - 1) + fibo(n - 2);
}
int fibo(int n){
if(n < 2){
return 1;
}else{
return fibo(n-1) + fibo(n-2);
}
}
double fibo(int no){
double value = 0;
if(no==0 || no==1)
return 1;
value = fibo(no-1)+fibo(no-2);
return value;
}
// Actual Fibonacci function, taken from definition above
int fibo(int index)
{
if ((index == 0) || (index == 1))
return 1;
else
return fibo(index-1) + fibo(index-2);
}
int fibo(int n) {
if (n==0)
return 1;
else if (n==1)
return 1;
else return fibo(n-1) + fibo(n-2);
}
long int fibo(long int n)
{
if(n==0) return 1;
if(n==1) return 1;
if(memo[n]) return memo[n];
memo[n] = fibo(n-2) + fibo(n-1);
return memo[n];
}
int fibo(int n)
{
if (n <= 0)
return (0);
if (n <= 2)
return (1);
return (fibo(n - 1) + fibo(n - 2));
}
int fibo(int n){
if (n<3)
return 1;
else
return fibo(n-1) + fibo (n-2);
}
long long int fibo(long long int n)
{
if (n == 0)
return 0;
if (n == 1)
return 1;
return fibo(n-1) + fibo(n-2);
}
uint32_t fibo(uint32_t n) {
counter_fibo++;
if ( n == 1 )
return 1;
if ( n == 2 )
return 1;
return fibo(n-1) + fibo(n-2);
}
int fibo(int n) {
if (n < 1) {
return 0;
} else if (n == 1) {
return 1;
} else {
return fibo(n-1) + fibo(n-2);
}
}
unsigned int fibo(unsigned int n)
{
static long x=0;
x++;
if(n<2)
return n;
else
return fibo(n-1)+fibo(n-2);
}
int main()
{
fibo(1);
fibo(2);
fibo(5);
fibo(15);
return 0;
}
int fibo(int n, int *memo)
{
if(memo[n] != -1)
return memo[n];
else
{
memo[n] = fibo(n-1, memo) + fibo(n-2, memo);
return memo[n];
}
}
/*Recursively computes the nth fibonacci number*/
long fibo ( long n )
{
/*if (n == 0) return 0;
else if (n == 1) return 1;
Or a more elegant way */
if ( n == 0 || n ==1 ) return n; /*base case*/
else { /*recursive step*/
return ( fibo(n-1) + fibo(n-2) );
}
}/*end fibo*/
int fibo(int n) {
int x, y;
if (n < 2) {
return (n);
} else {
x = fibo(n - 1);
y = fibo(n - 2);
return (x + y);
}
}
int fibo(int n)
{
int y;
if(n==1||n==0)
return n;
else
{
y=fibo(n-1)+fibo(n-2);
return y;
}}
int fibo(int nth)
{
if (nth == 1) {
return 1;
} else if (nth == 2) {
return 1;
} else {
return fibo(nth-1) + fibo(nth-2);
}
}
int fibo(int n, int *instrucciones) {
(*instrucciones)++; /* Una comparacion*/
if (n < 2){
(*instrucciones)++;
return n;
}
else{
(*instrucciones)++;
return fibo(n-1, instrucciones) + fibo(n-2, instrucciones);
}
}
int fibo(int k){
//checking the memo
if(memo[k] != 0)
return memo[k];
//f(1) and f(2) conditions
if(k < 3)
return 1;
//adding to memo for further use
memo[k] = (fibo(k-1) + fibo(k-2));
return memo[k];
}
int fibo(int n) {
if (n == 0) {
return 1;
}
else if (n == 1 || n == 2) {
return 2;
}
else {
return 2 * fibo(n - 1) + fibo(n - 2) - fibo(n - 3);
}
}
int fibo(int s) {
/* if(s==0)
return 0;
if(s==1)
return 1;
if(s==2)
return 1;
return fibo(s-1)+fibo(s-2);*/
// return (s>1)?(fibo(s-1)+fibo(s-2)):((s==1)?1:0);
return (s>1)?(fibo(s-1)+fibo(s-2)):s;
}
int main(){
long long int l,r;int t,n,m;
scanf("%d",&t);
while(t--){
scanf("%d %d",&n,&m);
l=fibo(n+1)-1;
r=fibo(m+2)-1;
r=(r-l)%mod;
if(r<0)r=1000000007+r;
printf("%lld\n",r);
}}
long long fibo(int n)
{
static long long arr[100];
if(arr[n]!=0)
return arr[n];
if(n ==1 || n==2)
return arr[n] = 1;
else
return arr[n] = fibo(n-1) + fibo(n-2);
}
int fibo(int n)
{
contador++;
printf("contador = %d f(%d)\n",contador, n);
if ( n == 0 )
return 0;
else if ( n == 1 )
return 1;
else
return ( fibo(n-1) + fibo(n-2) );
}
unsigned int fibo(unsigned int n) /* Very slow routine */
{
/*
Updated 2006: gcc-4.1 can optimize the recursion, making fibo run
in linear time, instead of exponential time.
To prevent the compiler from optimizing the tail recursion,
add a dummy side-effect, in the form of incrementing a static counter "x".
*/
static long x = 0;
x++;
if(n<2) return n;
else return fibo(n-1)+fibo(n-2);
}
int main(int argc, const char * argv[]) {
int counter = 1;
int accumulator = 0;
int val = fibo(counter);
while (val < 4000000) {
if (val % 2 == 0) {
accumulator += val;
}
counter++;
val = fibo(counter);
}
printf("%d\n", accumulator);
return 0;
}
void fibo_single_thread(const typename container::value_type& pair)
{
boost::timer::auto_cpu_timer t;
std::size_t idx = pair.first;
std::size_t value = 0;
fibo fibo(idx, value);
fibo();
std::cout << "fibo(" << idx << ") = " << value << std::endl;
if (pair.second != value)
{
std::cout << "!!!!!!!!!!!!!!11 fibo is wrong" << std::endl;
}
}
int fibo(int number){
int numbers;
if(number==1){
return 1;
}
else if(number==2){
return 1;
}
else{
numbers = fibo(number-1)+fibo(number-2);
return numbers;
}
}
