PARI/GP code:

answer=0;for(n=1,44,if(issquare(fibonacci(n)),answer=answer+fibonacci(n)));return(answer)

Actually, 1 and 144 are the ONLY fibonacci numbers which are perfect squares.

This is the source code in C to find such numbers.

#include    <stdio.h>
#include    <math.h>

int fib(int term)
{
    if(term == 0)
        return 0 ;
    else if(term == 1)
        return 1 ;
    else
        return(fib(term-1)+fib(term-2)) ;
}

int main(void)
{
    int term = 0, number = -1, i ;

    while(number < 1000000000)   {
        number = fib(term) ;
        printf("%20d", number) ;
        for(i = 0; i <= ceil(sqrt((double)1000000000)); i++)
            if(number == i*i)   {
                printf("%6s", "CHECK") ;
                break ;
            }
        printf("\n") ;
        term++ ;
    }
    return 0 ;
}

The four numbers found are 0, 1, 1 and 144, giving the sum 0 + 1 + 1 + 144 = 146 .

My Solution in C++ : My Solution

Here is the VB.NET code:

Module Module1

Sub Main()

    Dim previous As uInt64= 0

    Dim current As uInt64= 1

    Dim sum As uInt64= 0

    While current < 1000000000

        Console.WriteLine(current)

        If perfect_squares(current) = True Then

            sum = sum + current

        End If

        Dim temp As BigInteger

        temp = current

        current = current + previous

        previous = temp

    End While

    Console.WriteLine()

    Console.WriteLine(sum)

    Console.ReadLine()
End Sub

Public Function perfect_squares(ByVal a As UInt64) As Boolean

    Dim b As Double = Math.Sqrt(a)

    Dim c As Double = Math.Ceiling(b)

    Dim d As Int64 = Math.Floor(Math.Sqrt(a))

    If (d = c) Then

        Return True

    Else

        Return False

    End If

End Function

End Module

Java solution -

Please note that I haven't added 0 and 1 to the perfect squares, so after getting the answer, add 2

public static void main(String args[]) throws java.lang.Exception{
    int a = 1, b = 1;
    double n = 0;

    for(;a < 1000000000 && b < 1000000000;){
        a += b;
        b += a;

        if(Math.round(Math.sqrt(a))==Math.sqrt(a)){
            n += a;
        }else if(Math.round(Math.sqrt(b))==Math.sqrt(b)){
            n += b;
        }
    }

    System.out.println(n);
}

Output is 144 but on considering 0 and 1, answer is 146.

But I think it should be given in the question whether to assume 0 as a perfect square or not.

It has been proven by Yann Bugeaud, Maurice Mignotte, and Samir Siksek that the only perfect powers in the Fibonacci sequence are $0, 1, 8, 144$ , thus the only perfect squares in the Fibonacci sequence are $0, 1, 144$ . Since $1$ appears twice (as $F_1$ and $F_2$ ), the sum of all perfect squares in the entire Fibonacci sequence (not only among those less than 1 billion!) is $144+1+1+0 = \boxed{146}$ .

My cute java code for the question :

class q3{ public static void main(String as[]){ int a=0; int b=1; int c=0; long sum=0;

    for(;c<1000000000;){
        c=a+b;
        if(perfect_sq(c)){
            sum=sum+c;
        }
        a=b;
        b=c;
    }
    System.out.print(sum+1);//missed the first "1" so adding 1 to

//final answer
} public static boolean perfect_sq(long no){ double t=Math.sqrt(no); int a=(int)t; if(t-a==0)return true; return false;
} }

Python solution:

import math
count = 0
sumsqrt = 0
a = 0
b = 1

while count < 23:
    print a 
    print b
    if math.sqrt(a) % 1 == 0:
        sumsqrt += a
    if math.sqrt(b) % 1 == 0:
        sumsqrt += b
    a = a + b
    b = a + b
    count += 1

print "Sum : "
print sumsqrt

On a side note, here's a code for generating the first $2n$ terms of the sequence :

count = 0
a = 0
b = 1

while count < n:
    print a 
    print b
    a = a + b
    b = a + b
    count += 1

Here is a C++ programme

#include<iostream.h>
#include<math.h>
int main()
{
long int a,b,f,h,sum;
int i;
a=0;
b=1;
sum=0;
for(i=2;f<1000000000;i++)
{
f=a+b;
b=a;
a=f;
h=floor(sqrt(f));
if(f==(h*h)){sum=sum+f;}
}
cout<<"The sum is: "<<sum;
return 0;
}

Java code:

public class brilliant{
    public static void main(String args[]){
        long previous=-1, current=1, next; //these are the -2th and the -1th term
        long sum=0;
        while(current<1000000000){
            next = previous + current;
            previous = current;
            current = next;
            if(Math.sqrt(current)-((int)(Math.sqrt(current)))==0) sum += current;
        }
        System.out.println(sum);
    }
}

Python

img

So answer is $1+1+144=\boxed{146}$