2301107049(Manikarthik).ppt.pptx functional programming and lis

Functional Programming
and LIS (Longest
Increasing Subsequence)
Programming
BY
M.MANI KARTHIK
2301107049
CSE’ A

Introduction
This presentation explores the fundamentals of
functional programming and the
implementation of the longest increasing
subsequence (LIS) problem. It covers key
concepts, various programming approaches,
performance optimization techniques, and
practical examples.

Introduction to Functional Programming
Definition: A programming paradigm based on the concept of
mathematical functions.
Key Features include pure functions, immutability, and higher-order
functions.

Key Concepts of Functional Programming
Pure Functions: Functions that return the same output for the same
input and have no side effects.
Immutability: Data cannot be changed after it is created; instead,
new data is returned.
First-Class Functions: Functions can be passed as arguments,
returned from other functions, and assigned to variables.

Benefits of Functional Programming
Predictability: Pure functions make the behavior of code more
predictable.
Concurrency: Easier to write concurrent programs since functions do
not modify state.
Code Reusability: Higher-order functions promote code reuse.
Testability: Easier to test due to the predictability of functions.

Languages Supporting Functional Programming
Haskell: Pure functional programming language.
Lisp: Known for its functional programming capabilities.
Scala: Combines object-oriented and functional programming.
Python: Supports functional programming features like higher-order
functions and lambda expressions.
JavaScript: Highly functional with first-class functions and closures.

Overview of Longest Increasing Subsequence
(LIS)
Problem Definition: The LIS problem is to find the length of the
longest subsequence that is strictly increasing.
Example: For the sequence [3, 10, 2, 1, 20], the LIS is [3, 10, 20] with
length 3.

LIS Problem Description
Given a sequence of integers, find the length of the longest
subsequence where each element is greater than the previous one.

Brute Force Approach for LIS
Description: Check every subsequence and find the longest
increasing one.
Time Complexity: Exponential O(2^n), as every subsequence needs
to be checked.

Dynamic Programming Approach for LIS
Description: Use a table to store the length of the LIS ending at each
element, and build the solution step by step.
Time Complexity: O(n^2).

Dynamic Programming Algorithm for LIS
Create an array LIS[] where LIS[i] holds the length of the longest
increasing subsequence ending at index i.
For each element, compare with all previous elements to update the
LIS.

Time Complexity of LIS Algorithms
Brute Force: O(2^n)
Dynamic Programming: O(n^2)
Optimized Dynamic Programming (using binary search): O(n log n)

Functional Approach for LIS
In functional programming, we can apply a more declarative style to
the LIS problem using functions like map, reduce, filter, and
recursion.

Recursion in Functional Programming
Recursive Definition of LIS: The LIS of a sequence can be defined as
the maximum of two possibilities:
The element itself.
The LIS formed by including the current element and recursively
solving for smaller subsequences.

Lambda Functions and Higher-Order Functions
Lambda Functions: Anonymous functions that can be passed as
arguments.
Higher-Order Functions: Functions that take other functions as
arguments or return them as results. These can help in defining
operations like finding the LIS.

Using Functional Programming to Solve LIS
Example in Python (Functional Style):
def lis(arr):
if not arr:
return []
return max([subseq for subseq in [lis(arr[1:]), [arr[0]] + lis(arr[1:]) if
arr[0] < arr[i] for i in range(1, len(arr))]], key=len)

Example 1: LIS with Recursion
Step-by-step explanation of how recursion is applied in solving LIS
using a functional approach.

Example 2: LIS Using Map, Filter, and Reduce
Use higher-order functions like map, reduce, and filter to solve LIS.

Comparison of Approaches for LIS
Brute Force: Simplest but inefficient.
Dynamic Programming: Efficient for most cases but requires extra
space.
Functional Approach: Elegant but may be less optimized in terms of
performance.

Performance Optimization for LIS
Use binary search (via bisect) to optimize the LIS algorithm to O(n log
n).
Example in Python using bisect:
import bisect
def lis(arr):
subseq = []
for num in arr:
pos = bisect.bisect_left(subseq, num)
if pos == len(subseq):
subseq.append(num)
else:
subseq[pos] = num
return len(subseq)

Real-World Applications of LIS
Stock Prices: Finding the longest increasing subsequence of stock
prices.
Bioinformatics: Finding longest increasing sequences in genetic data.
Data Analysis: Longest increasing subsequences in time-series data.

Benefits of Combining Functional Programming
with LIS
Clean, declarative solutions that are easier to maintain.
Recursion and higher-order functions make the solution concise and
elegant.

Best Practices in Functional Programming
Focus on immutability and pure functions.
Use recursion when applicable but consider the performance trade-
offs.
Leverage higher-order functions for simplicity.

Best Practices in LIS Programming
Choose the right algorithm based on input size (Brute Force, DP, or
Optimized).
Avoid unnecessary recalculations (memoization).
Always test edge cases (empty array, all elements equal, decreasing
sequences).

Debugging Functional Programming Code
Use logging to track the flow of recursive calls.
Test with simple cases to ensure base cases are correct.

Debugging LIS Algorithms
Check intermediate values (e.g., LIS array or subsequence) during
execution.
Test with various sequences (sorted, reversed, random).

Advanced Topics in Functional Programming
Monads: A way to handle side effects in a functional programming
style.
Lazy Evaluation: Techniques to delay computations until the results
are needed.

Case Studies of LIS in Real Applications
Real-world data sets and problems where LIS has been effectively
used to extract patterns and optimize processes.

Conclusion
Functional programming offers clean, maintainable solutions,
particularly suited for problems like LIS.
Understanding both dynamic programming and functional
programming paradigms can help solve complex problems efficiently.

Conclusion
Functional programming offers clean,
maintainable solutions, particularly suited for
problems like LIS. Understanding both dynamic
programming and functional programming
paradigms can help solve complex problems
efficiently.

2301107049(Manikarthik).ppt.pptx functional programming and lis

Recommended

More Related Content

Similar to 2301107049(Manikarthik).ppt.pptx functional programming and lis (20)

Recently uploaded (20)

2301107049(Manikarthik).ppt.pptx functional programming and lis