Given that,

Fibonacci(1) = 1

Fibonacci(2) = 1

and Fibonacci(n) = Fibonacci(n - 2) + Fibonacci(n - 1)

So, this is a recursive relation and we have to compute only the last three digits of Fibonacci(46).

We know the property of number theory, if a = b + c then a%m = (b + c)%m .

Lets declare an array of size 50 (just for safety! because some programming language starts from index 0, some from index 1) named $fib[50]$ .

now, $fib[1] := 1, fib[2] := 2$ .

then a loop from 3 to 46 should run: lets the loop counter be i .

$fib[i] := (fib[i-1] + fib[i-2])\%m.$

then $print fib[46]$ .

It is the desired F !

program Q1

implicit none
integer :: F ,s ,N,F1,i
N = 46
do i=1,N
  s = F1(i)
  print*,i,s
enddo

end program Q1

recursive function F1(N) result(F)

implicit none
integer :: F
INTEGER ,intent(in) :: N
if (N <=2) then 
    F = 1
else  
    F = F1(N-2) + F1(N-1)
endif

end function F1

The final answer that i got was 1836311903. sO, THE ANSWER IS $\boxed{903}$ .

I decided to go and learn some Python, did this:

array = [None] * 100

array[0] = 1

array[1] = 1

#

for x in range(2,100):

array[x] = array[x-2] + array[x-1]

#

print(array[45])

package logics;

import java.math.BigInteger; import java.util.ArrayList;

public class MyFibonocci {

static ArrayList<BigInteger>  listSeries= new ArrayList<BigInteger>();

int indexTo;

MyFibonocci(int index){
    this.indexTo = index;
}

public BigInteger getFibonocci(){
    return getFibonocc(this.indexTo);
}

private BigInteger getFibonocc(int n){

    if (listSeries.size() >= n ){
        if ( listSeries.get(n-1) != null ){
            return listSeries.get(n-1);
        }
    }

    if ( n==1 ){
        listSeries.add(new BigInteger("1"));
    }else if (n==2){
        listSeries.add(new BigInteger("1"));
        listSeries.add(new BigInteger("1"));
    }else{
        listSeries.add(getFibonocc(n-1).add(getFibonocc(n-2)));
    }
    return listSeries.get(n-1);
}

public static void main(String[] args) {
    MyFibonocci getFib = new MyFibonocci(46);
    System.out.println(getFib.getFibonocci().toString());
}

}

You could use recursion:

var fib = function (nth) {
if(nth === 0) {
return 0;
}
if(nth === 1){
return 1;
}
return fib(nth-2) + fib(nth-1);
};
console.log(fib(46));

But it will brake you're environment (both console and node builds), after the 40 it's getting slow and eventuly it cant get out of function calls. You shoud use the array aproach:

var fib = [0, 1];
for (var i = 2; i <= 46; i++) {
fib[ i ] = fib[ i - 1 ] + fib[ i - 2 ];
}
console.log(fib);

[ 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377, 610, 987, 1597, 2584, 4181, 6765, 10946, 17711, 28657, 46368, 75025, 121393, 196418, 317811, 514229, 832040, 1346269, 2178309, 3524578, 5702887, 9227465, 14930352, 24157817, 39088169, 63245986, 102334155, 165580141, 267914296, 433494437, 701408733, 1134903170, 1836311903 ] [Finished in 0.1s]

Plus it's fast -), and you can try other high numbers.

Here is the JS Solution by sandy and aman .

Putting the details given by the question directly into code, we get:

def fibonacci(n):
if n == 1:
    return 1
elif n == 2:
    return 1
else:
    return fibonacci(n-2) + fibonacci(n-1)

print fibonacci(46)

This calculates and returns the 46th Fibonacci sequence number in a much simpler manner than the other solutions. From there, we need only look at the last 3 digits (we have eyes for a reason) to see that the answer is 903 .

from math import *

def F(n): return ((1+sqrt(5)) * * n-(1-sqrt(5)) * * n)/(2 * * n * sqrt(5))

def last 3 digits(n): return int(F(n)%1000)

print last 3 digits(46)

A bit about me: i am a high school student, before i study maths, english and now i'm a specialize student in CS but i hardly know about it and there is a big exam coming so I need a lot of practice and advice. I will always appreciate all yours comment about my solution, my english and whatever about me. Thanks I uses free pascal so it may a little bit differences. uses crt; var i,h:integer; a:array[1..2]of ansistring; begin a[1]:=1; a[2]:=1; h:=1; for i:=1 to 46 do begin a[h]:={sum (a[3-h]+a[h]) plus them by string};// or you can use SHL, copy and change ansistring into string.... h:=3-h; end; end.

import java.util.Scanner;

public class Fibonacci {

public static void main(String[] args) {
    Scanner in = new Scanner(System.in);

    System.out.print("Enter in the number to find the fibonacci function for it: ");
    int num = in.nextInt();

    System.out.println("it is: " + fibonacci(num));
}


public static int fibonacci(int num) {

    if (num < 2) {
        return num;
    }else{
        return fibonacci(num - 1) + fibonacci(num - 2);
    }

You can utilize this by running a simple recursive algorithm, by inputing num for 46 as it shows. You get the number: 1836311903 Therefor the number is 903

This algorithm's syntax is in Java by the way.

My solution in C++ :

#include <iostream>

using namespace std;

void PrintFibonnaciTerm()
{
    int T_1 = 1, T_2 = 1, T_n;    // First term, 2nd term and nth term variables

    cout << T_1 << endl << T_2 << endl;    // Printing the first two terms of 
                                           // Fibonnaci sequence
    for (int I = 3; I <= 46; I++)          // iterating until 46th term shows up
    {
        T_n = T_1 + T_2;
        cout << T_n << " " << endl;        // displaying the nth term (here 3 <= n <= 46)
        T_1 = T_2;                         // updating variables T_1 and T_2
        T_2 = T_n;
    }
}

int main()
{
    PrintFibonnaciTerm();
    return 0;
}