Skip to content
Related Articles

Related Articles

Longest sub-sequence of array containing Lucas numbers
  • Difficulty Level : Medium
  • Last Updated : 26 Apr, 2019

Given an array arr[] of N elements, the task is to find the length of the longest sub-sequence in arr[] such that all the elements of the sequence are Lucas Numbers.

Examples:

Input: arr[] = {2, 3, 55, 6, 1, 18}
Output: 4
1, 2, 3 and 18 are the only elements from the Lucas sequence.

Input: arr[] = {22, 33, 2, 123}
Output: 2

Approach:



  • Find the maximum element in the array.
  • Generate Lucas numbers upto to the max and store them in a set.
  • Traverse the array arr[] and check if the current element is present in the set.
  • If it is present in the set, and increment the count.

Below is the implementation of the above approach:

C++




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
  
// Function to return the length of
// the longest required sub-sequence
int LucasSequence(int arr[], int n)
{
    // Find the maximum element from 
    // the array
    int max = *max_element(arr, arr+n);
  
    // Insert all lucas numbers
    // below max to the set
    // a and b are first two elements
    // of the Lucas sequence
    unordered_set<int> s;
    int a = 2, b = 1, c;
    s.insert(a);
    s.insert(b);
    while (b < max) {
        int c = a + b;
        a = b;
        b = c;
        s.insert(b);
    }
  
    int count = 0;
    for (int i = 0; i < n; i++) {
  
        // If current element is a Lucas 
        // number, increment count
        auto it = s.find(arr[i]);
        if (it != s.end()) 
            count++;
    }
  
    // Return the count
    return count;
}
  
// Driver code
int main()
{
    int arr[] = { 7, 11, 22, 4, 2, 1, 8, 9 };
    int n = sizeof(arr) / sizeof(arr[0]);
  
    cout << LucasSequence(arr, n);
  
    return 0;
}

Java




// Java implementation of the approach
import java.util.*;
  
class GFG 
{
  
    // Function to return the length of 
    // the longest required sub-sequence 
    static int LucasSequence(int[] arr, int n)
    {
        // Find the maximum element from 
        // the array 
        int max = Arrays.stream(arr).max().getAsInt();
        int counter = 0;
  
        // Insert all lucas numbers 
        // below max to the set 
        // a and b are first two elements 
        // of the Lucas sequence 
        HashSet<Integer> s = new HashSet<>();
  
        int a = 2, b = 1;
        s.add(a);
        s.add(b);
  
        while (b < max)
        {
            int c = a + b;
            a = b;
            b = c;
            s.add(b);
        }
  
        for (int i = 0; i < n; i++)
        {
  
            // If current element is a Lucas 
            // number, increment count 
            if (s.contains(arr[i])) 
            {
                counter++;
            }
        }
  
        // Return the count 
        return counter;
    }
  
    // Driver code 
    public static void main(String[] args)
    {
        int[] arr = {7, 11, 22, 4, 2, 1, 8, 9};
        int n = arr.length;
  
        System.out.println(LucasSequence(arr, n));
    }
}
  
// This code has been contributed by 29AjayKumar

Python3




# Python 3 implementation of the approach
  
# Function to return the length of
# the longest required sub-sequence
def LucasSequence(arr, n):
      
    # Find the maximum element from 
    # the array
    max = arr[0]
    for i in range(len(arr)):
        if(arr[i] > max):
            max = arr[i]
  
    # Insert all lucas numbers below max 
    # to the set a and b are first two 
    # elements of the Lucas sequence
    s = set()
    a = 2
    b = 1
    s.add(a)
    s.add(b)
    while (b < max):
        c = a + b
        a = b
        b = c
        s.add(b)
  
    count = 0
    for i in range(n):
          
        # If current element is a Lucas 
        # number, increment count
        if(arr[i] in s):
            count += 1
  
    # Return the count
    return count
  
# Driver code
if __name__ == '__main__':
    arr = [7, 11, 22, 4, 2, 1, 8, 9]
    n = len(arr)
  
    print(LucasSequence(arr, n))
  
# This code is contributed by
# Surendra_Gangwar

C#




// C# implementation of the approach 
using System;
using System.Collections.Generic;
using System.Linq;
  
class GFG
{
      
    // Function to return the length of 
    // the longest required sub-sequence 
    static int LucasSequence(int []arr, int n) 
    
        // Find the maximum element from 
        // the array 
        int max = arr.Max(); 
        int counter = 0; 
  
        // Insert all lucas numbers 
        // below max to the set 
        // a and b are first two elements 
        // of the Lucas sequence 
        HashSet<int> s = new HashSet<int>() ;
          
        int a = 2, b = 1 ;
        s.Add(a); 
        s.Add(b); 
          
        while (b < max) 
        
            int c = a + b; 
            a = b; 
            b = c; 
            s.Add(b); 
        
      
        for (int i = 0; i < n; i++) 
        
      
            // If current element is a Lucas 
            // number, increment count 
            if (s.Contains(arr[i]))
                counter++; 
        
      
        // Return the count 
        return counter; 
    
  
    // Driver code 
    static public void Main() 
    
        int []arr = { 7, 11, 22, 4, 2, 1, 8, 9 }; 
        int n = arr.Length ;
      
        Console.WriteLine(LucasSequence(arr, n)) ;
    
}
  
// This code is contributed by Ryuga
Output:
5

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up
Recommended Articles
Page :