Largest and smallest Fibonacci numbers in an Array
Given an array arr[] of N positive integers, the task is to find the minimum (smallest) and maximum (largest) Fibonacci elements in the given array.
Examples:
Input: arr[] = 1, 2, 3, 4, 5, 6, 7
Output: 1, 5
Explanation :
The array contains 4 fibonacci values 1, 2, 3 and 5.
Hence, the maximum is 5 and the minimum is 1.
Input: arr[] = 13, 3, 15, 6, 8, 11
Output:3, 13
Explanation:
The array contains 3 fibonacci values 13, 3 and 8.
Hence, the maximum is 13 and the minimum is 3.
Approach 1:
This approach is similar to finding the minimum and maximum element in an array. Traverse the array one by one, and check if it is a Fibonacci number or not. If it is, then find the maximum and minimum among such numbers.
Inorder to check if the number is a Fibonacci number or not optimally O(1), generate all Fibonacci numbers up to the maximum element of the array using dynamic programming and store them in a hash table.
Below is the implementation of above approach:
C++
#include <bits/stdc++.h>
using namespace std;
void createHash(set< int >& hash,
int maxElement)
{
int prev = 0, curr = 1;
hash.insert(prev);
hash.insert(curr);
while (curr <= maxElement) {
int temp = curr + prev;
hash.insert(temp);
prev = curr;
curr = temp;
}
}
void fibonacci( int arr[], int n)
{
int max_val
= *max_element(
arr, arr + n);
set< int > hash;
createHash(hash, max_val);
int minimum = INT_MAX;
int maximum = INT_MIN;
for ( int i = 0; i < n; i++) {
if (hash.find(arr[i]) != hash.end()) {
minimum = min(minimum, arr[i]);
maximum = max(maximum, arr[i]);
}
}
cout << minimum << ", "
<< maximum << endl;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof (arr) / sizeof (arr[0]);
fibonacci(arr, n);
return 0;
}
|
Java
import java.util.*;
class GFG{
static void createHash(HashSet<Integer> hash,
int maxElement)
{
int prev = 0 , curr = 1 ;
hash.add(prev);
hash.add(curr);
while (curr <= maxElement) {
int temp = curr + prev;
hash.add(temp);
prev = curr;
curr = temp;
}
}
static void fibonacci( int arr[], int n)
{
int max_val= Arrays.stream(arr).max().getAsInt();
HashSet<Integer> hash = new HashSet<Integer>();
createHash(hash, max_val);
int minimum = Integer.MAX_VALUE;
int maximum = Integer.MIN_VALUE;
for ( int i = 0 ; i < n; i++) {
if (hash.contains(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
System.out.print(minimum+ ", "
+ maximum + "\n" );
}
public static void main(String[] args)
{
int arr[] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
int n = arr.length;
fibonacci(arr, n);
}
}
|
Python3
import sys
def createHash( hash , maxElement):
prev = 0
curr = 1
hash .add(prev)
hash .add(curr)
while (curr < = maxElement):
temp = curr + prev
hash .add(temp)
prev = curr
curr = temp
def fibonacci(arr, n):
max_val = max (arr)
hash = set ()
createHash( hash , max_val)
minimum = sys.maxsize
maximum = - sys.maxsize - 1
for i in range (n):
if (arr[i] in hash ):
minimum = min (minimum, arr[i])
maximum = max (maximum, arr[i])
print (minimum,end = ", " )
print (maximum)
if __name__ = = '__main__' :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
n = len (arr)
fibonacci(arr, n)
|
C#
using System;
using System.Linq;
using System.Collections.Generic;
class GFG{
static void createHash(HashSet< int > hash,
int maxElement)
{
int prev = 0, curr = 1;
hash.Add(prev);
hash.Add(curr);
while (curr <= maxElement) {
int temp = curr + prev;
hash.Add(temp);
prev = curr;
curr = temp;
}
}
static void fibonacci( int []arr, int n)
{
int max_val= arr.Max();
HashSet< int > hash = new HashSet< int >();
createHash(hash, max_val);
int minimum = int .MaxValue;
int maximum = int .MinValue;
for ( int i = 0; i < n; i++) {
if (hash.Contains(arr[i])) {
minimum = Math.Min(minimum, arr[i]);
maximum = Math.Max(maximum, arr[i]);
}
}
Console.Write(minimum+ ", "
+ maximum + "\n" );
}
public static void Main(String[] args)
{
int []arr = { 1, 2, 3, 4, 5, 6, 7 };
int n = arr.Length;
fibonacci(arr, n);
}
}
|
Javascript
<script>
function createHash(hash, maxElement)
{
let prev = 0, curr = 1;
hash.add(prev);
hash.add(curr);
while (curr <= maxElement) {
let temp = curr + prev;
hash.add(temp);
prev = curr;
curr = temp;
}
}
function fibonacci(arr, n)
{
let max_val= Math.max(...arr);
let hash = new Set();
createHash(hash, max_val);
let minimum = Number.MAX_VALUE;
let maximum = Number.MIN_VALUE;
for (let i = 0; i < n; i++) {
if (hash.has(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
document.write(minimum+ ", "
+ maximum + "<br/>" );
}
let arr = [ 1, 2, 3, 4, 5, 6, 7 ];
let n = arr.length;
fibonacci(arr, n);
</script>
|
Time Complexity: O(n + log(m)), where n is the size of the given array and m is the maximum element in the array.
Auxiliary Space: O(n)
Approach 2:
This approach use the below formula to check if the current number is Fibonacci number or not:
A number is Fibonacci if and only if one or both of (5*n2 + 4) or (5*n2 – 4) is a perfect square (Source: Wiki).
Steps:
To find the largest and smallest Fibonacci numbers in an array, we do the following steps:
- First initialize max and min Fibonacci number as INT_MIN and INT_MAX respectively.
- Then we iterate array and for each element check if the element is Fibonacci number or not.
- In each iteration:
- If the element is Fibonacci number then compare it with max and min Fibonacci numbers and as per its value change max or min.
- And at the end print the max and min Fibonacci number.
Below is the implementation of the above approach:
C++
#include <bits/stdc++.h>
using namespace std;
bool isPerfectSquare( int x)
{
int s = sqrt (x);
return (s * s == x);
}
bool isFibonacci( int n)
{
return isPerfectSquare(5 * n * n + 4)
|| isPerfectSquare(5 * n * n - 4);
}
void fibonacci( int arr[], int n)
{
int minimum = INT_MAX;
int maximum = INT_MIN;
for ( int i = 0; i < n; i++) {
if (isFibonacci(arr[i])) {
minimum = min(minimum, arr[i]);
maximum = max(maximum, arr[i]);
}
}
cout << minimum << ", " << maximum << endl;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof (arr) / sizeof (arr[0]);
fibonacci(arr, n);
return 0;
}
|
Java
import java.util.*;
public class FibonacciMinMax {
static boolean isPerfectSquare( int x) {
int s = ( int ) Math.sqrt(x);
return (s * s == x);
}
static boolean isFibonacci( int n) {
return isPerfectSquare( 5 * n * n + 4 ) || isPerfectSquare( 5 * n * n - 4 );
}
static void fibonacci( int [] arr) {
int minimum = Integer.MAX_VALUE;
int maximum = Integer.MIN_VALUE;
for ( int i = 0 ; i < arr.length; i++) {
if (isFibonacci(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
System.out.println(minimum + ", " + maximum);
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
fibonacci(arr);
}
}
|
Python3
import math
def isPerfectSquare(x):
s = int (math.sqrt(x))
return s * s = = x
def isFibonacci(n):
return isPerfectSquare( 5 * n * n + 4 ) or isPerfectSquare( 5 * n * n - 4 )
def fibonacci(arr):
minimum = float ( 'inf' )
maximum = float ( '-inf' )
for num in arr:
if isFibonacci(num):
minimum = min (minimum, num)
maximum = max (maximum, num)
print (f " {minimum}, {maximum}" )
if __name__ = = "__main__" :
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
n = len (arr)
fibonacci(arr)
|
C#
using System;
class Program
{
static bool IsPerfectSquare( int x)
{
int s = ( int )Math.Sqrt(x);
return (s * s == x);
}
static bool IsFibonacci( int n)
{
return IsPerfectSquare(5 * n * n + 4) || IsPerfectSquare(5 * n * n - 4);
}
static void Fibonacci( int [] arr)
{
int minimum = int .MaxValue;
int maximum = int .MinValue;
foreach ( int num in arr)
{
if (IsFibonacci(num))
{
minimum = Math.Min(minimum, num);
maximum = Math.Max(maximum, num);
}
}
Console.WriteLine(minimum + ", " + maximum);
}
static void Main( string [] args)
{
int [] arr = { 1, 2, 3, 4, 5, 6, 7 };
Fibonacci(arr);
}
}
|
Javascript
function isPerfectSquare(x) {
const s = Math.sqrt(x);
return s * s === x;
}
function isFibonacci(n) {
return isPerfectSquare(5 * n * n + 4) || isPerfectSquare(5 * n * n - 4);
}
function fibonacci(arr) {
let minimum = Infinity;
let maximum = -Infinity;
for (let i = 0; i < arr.length; i++) {
if (isFibonacci(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
console.log(`${minimum}, ${maximum}`);
}
function main() {
const arr = [1, 2, 3, 4, 5, 6, 7];
fibonacci(arr);
}
main();
|
Time Complexity: O(N*log(M)), where N is the size of the given array and M is the maximum element in the array.
Auxiliary Space: O(1)
Approach 3:
This approach is one of the optimal approach to find the largest and smallest Fibonacci numbers in an array.
Steps:
To find the largest and smallest Fibonacci numbers in an array, we do the following steps:
- First initialize max and min Fibonacci number as INT_MIN and INT_MAX respectively.
- Then we iterate array and for each element check if the element is Fibonacci number or not.
- To check if the element is Fibonacci number or not we:
- First check if the number is 0 or 1, then return true.
- Then till the number comes do while loop.
- In each iteration:
- First calculate fibonacci of that iteration.
- Then check if it matches with given number or not.
- If matches, return true.
- If the value goes beyond, given number then return false.
- Otherwise continue.
- In each iteration:
- If the element is Fibonacci number then compare it with max and min Fibonacci numbers and as per its value change max or min.
- And at the end print the max and min Fibonacci number.
Below
C++
#include <bits/stdc++.h>
using namespace std;
bool isFibonacci( int N)
{
if (N == 0 || N == 1)
return true ;
int a = 0, b = 1, c;
while ( true ) {
c = a + b;
a = b;
b = c;
if (c == N)
return true ;
else if (c >= N) {
return false ;
}
}
}
void fibonacci( int arr[], int n)
{
int minimum = INT_MAX;
int maximum = INT_MIN;
for ( int i = 0; i < n; i++) {
if (isFibonacci(arr[i])) {
minimum = min(minimum, arr[i]);
maximum = max(maximum, arr[i]);
}
}
cout << minimum << ", " << maximum << endl;
}
int main()
{
int arr[] = { 1, 2, 3, 4, 5, 6, 7 };
int n = sizeof (arr) / sizeof (arr[0]);
fibonacci(arr, n);
return 0;
}
|
Java
import java.util.Arrays;
public class FibonacciMinMax {
public static boolean isFibonacci( int N) {
if (N == 0 || N == 1 ) {
return true ;
}
int a = 0 , b = 1 , c;
while ( true ) {
c = a + b;
a = b;
b = c;
if (c == N) {
return true ;
} else if (c >= N) {
return false ;
}
}
}
public static void fibonacci( int [] arr) {
int minimum = Integer.MAX_VALUE;
int maximum = Integer.MIN_VALUE;
for ( int i = 0 ; i < arr.length; i++) {
if (isFibonacci(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
System.out.println( "Minimum: " + minimum + ", Maximum: " + maximum);
}
public static void main(String[] args) {
int [] arr = { 1 , 2 , 3 , 4 , 5 , 6 , 7 };
fibonacci(arr);
}
}
|
Python3
def is_fibonacci(N):
if N = = 0 or N = = 1 :
return True
a, b = 0 , 1
while True :
c = a + b
a = b
b = c
if c = = N:
return True
elif c > = N:
return False
def find_fibonacci_min_max(arr):
minimum = float ( 'inf' )
maximum = float ( '-inf' )
for num in arr:
if is_fibonacci(num):
minimum = min (minimum, num)
maximum = max (maximum, num)
return minimum, maximum
arr = [ 1 , 2 , 3 , 4 , 5 , 6 , 7 ]
minimum, maximum = find_fibonacci_min_max(arr)
print (f "{minimum}, {maximum}" )
|
C#
using System;
class Program {
static bool IsFibonacci( int N)
{
if (N == 0 || N == 1)
return true ;
int a = 0, b = 1, c;
while ( true ) {
c = a + b;
a = b;
b = c;
if (c == N)
return true ;
else if (c >= N)
return false ;
}
}
static void Fibonacci( int [] arr, int n)
{
int minimum = int .MaxValue;
int maximum = int .MinValue;
for ( int i = 0; i < n; i++) {
if (IsFibonacci(arr[i])) {
minimum = Math.Min(minimum, arr[i]);
maximum = Math.Max(maximum, arr[i]);
}
}
Console.WriteLine(minimum + ", " + maximum);
}
static void Main()
{
int [] arr = { 1, 2, 3, 4, 5, 6, 7 };
int n = arr.Length;
Fibonacci(arr, n);
}
}
|
Javascript
function isFibonacci(N) {
if (N === 0 || N === 1) {
return true ;
}
let a = 0, b = 1, c;
while ( true ) {
c = a + b;
a = b;
b = c;
if (c === N) {
return true ;
} else if (c >= N) {
return false ;
}
}
}
function fibonacci(arr) {
let minimum = Infinity;
let maximum = -Infinity;
for (let i = 0; i < arr.length; i++) {
if (isFibonacci(arr[i])) {
minimum = Math.min(minimum, arr[i]);
maximum = Math.max(maximum, arr[i]);
}
}
console.log(minimum + ', ' + maximum);
}
const arr = [1, 2, 3, 4, 5, 6, 7];
fibonacci(arr);
|
Time Complexity: O(N*log(M)), where N is the size of the given array and M is the maximum element in the array.
Auxiliary Space: O(1)
Last Updated :
18 Dec, 2023
Like Article
Save Article
Share your thoughts in the comments
Please Login to comment...