Functional Programming Paradigms Quiz

1. What is the Functional Programming paradigm?

• A methodology that emphasizes the use of commands and sequences to produce specific outcomes in programming.
• A style of programming that primarily uses loops and mutable state to handle data and control flow.
• A programming paradigm that encourages program development to be done purely with functions, treating functions as first-class citizens, and focusing on immutability and avoiding state changes.
• An approach that relies on objects and classes to structure code for better organization and maintainability.

2. How do functions behave in Functional Programming?

• Functions in Functional Programming are static, meaning they cannot accept inputs or produce outputs.
• Functions in Functional Programming are pure, meaning they always produce the same output for the same input and have no side effects.
• Functions in Functional Programming are mutable, meaning they can change their output based on external states.
• Functions in Functional Programming are always side-effecting, meaning they alter states outside their scope.

3. What are first-class citizens in Functional Programming?

• Objects
• Variables
• Functions
• Classes

4. What is the focus of Functional Programming?

• The focus is on procedural step-by-step execution.
• The focus is on object creation and manipulation.
• The focus is on the use of mutable states and variables.
• The focus is on `What to solve` rather than `How to solve.`

5. How do higher-order functions work in Functional Programming?

• Higher-order functions are only used for error handling in programming.
• Higher-order functions can only return primitive data types like strings and numbers.
• Higher-order functions only work with integers and not with functions.
• Higher-order functions take functions as arguments or return functions as results, enabling complex operations.

6. What is function composition in Functional Programming?

• Function decomposition separates functions into smaller, simpler parts without combining them.
• Function inversion changes the order of function execution rather than combining functions.
• Function composition involves combining two or more functions to create a new function, enabling the construction of complex operations from simpler ones.
• Function extension adds additional behavior to a function without composing it with others.

7. What is immutability in Functional Programming?

• Data is immutable, meaning it cannot be changed once created, instead of modifying existing data, new data structures are created.
• Data is lost after creation, requiring recreation for any changes.
• Data is mutable, meaning it can be adjusted or altered as needed during execution.
• Data can be freely changed at any time, allowing easy modifications in structures.

8. What are examples of higher-order functions?

• `sort()`, `delete()`, `edit()`
• `filter()`, `map()`, `reduce()`
• `combine()`, `modify()`, `transform()`
• `append()`, `merge()`, `copy()`

9. How do functions handle data and behavior in Functional Programming?

• Functions operate on data, and there is a clear distinction between input and output, separating data and behavior.
• Functions operate independently from data, ignoring input and output.
• Functions modify shared state to manage data and behavior together.
• Functions hold data inside them, intertwining it with behavior.

10. What is the difference between Functional Programming and Object-Oriented Programming?

• Functional Programming relies heavily on stateful variables, while Object-Oriented Programming avoids mutable state.
• Functional Programming emphasizes functions and immutability, while Object-Oriented Programming focuses on objects and state.
• Functional Programming uses classes to structure code, while Object-Oriented Programming emphasizes functions over objects.
• Functional Programming treats data as mutable, while Object-Oriented Programming focuses on side effects and state changes.

11. Can functions be passed as arguments in Functional Programming?

• No, functions cannot be passed as arguments in Functional Programming.
• Yes, functions can be passed as arguments to other functions in Functional Programming.
• No, functions can only operate independently and cannot be passed.
• Yes, functions can only be used as return values, not arguments.

12. Can functions be returned by other functions in Functional Programming?

• No, functions cannot be returned by other functions.
• No, functions can only be executed, not returned.
• Yes, functions can only return numbers.
• Yes, functions can be returned by other functions.

13. What is the purpose of treating functions as first-class citizens?

• Makes functions less flexible
• Limits the use of variables
• Forces the use of class structures
• Allows for clean and maintainable code

14. How does Functional Programming handle state changes?

• Functional Programming emphasizes immutability, avoiding state changes by creating new data structures instead of modifying existing ones.
• Functional Programming requires all variables to be mutable, enabling straightforward state updates.
• Functional Programming uses stateful objects to manage data changes and provide flexibility.
• Functional Programming allows state changes directly, modifying existing data structures for efficiency.

15. What are the benefits of using pure functions in Functional Programming?

• Pure functions are slower and less efficient than impure functions due to additional checks.
• Pure functions make code more predictable and easier to reason about by always producing the same output for the same input and having no side effects.
• Pure functions must always return random outputs, introducing variability.
• Pure functions can change the state of external variables, leading to unpredictable behavior.

16. Can functions be stored in variables in Functional Programming?

• No, functions cannot be stored in variables.
• Functions are only usable directly and cannot be assigned.
• Functions can only be executed, not stored.
• Yes, functions can be stored in variables.

17. How does Functional Programming handle data and behavior separation?

• Data and behavior are tightly coupled, with no clear distinction.
• Functions operate on data, and there is a clear distinction between input and output, separating data and behavior.
• Functions can modify the data directly, intertwining behavior and state.
• Data is hidden within functions, making the separation unclear.

18. What is the role of higher-order functions in Functional Programming?

• Higher-order functions only return numerical values and cannot work with functions.
• Higher-order functions are only used to iterate over data, ignoring other functions.
• Higher-order functions are designed to modify global variables directly within code.
• Higher-order functions take other functions as arguments or return functions as results, enabling complex operations to be constructed from simpler ones.

19. Can functions be combined to create new functions in Functional Programming?

• Yes, functions can be combined to create new functions through function composition.
• Yes, but only in Object-Oriented Programming.
• No, functions cannot be combined in any way.
• No, functions can only exist independently.

20. How does Functional Programming handle mutable state?

• Functional Programming encourages constant mutation of state through in-place changes.
• Functional Programming relies on global variables to manage mutable state effectively.
• Functional Programming promotes objects that encapsulate mutable state changes directly.
• Functional Programming emphasizes immutability, avoiding mutable state by creating new data structures instead of modifying existing ones.

21. What is the difference between first-class and higher-order functions?

• First-class functions can only return values, while higher-order functions cannot.
• First-class functions are only for basic operations, higher-order functions are for advanced ones.
• First-class functions can be passed as arguments, while higher-order functions can take other functions.
• First-class functions are always mutable, while higher-order functions are not.

22. Can functions be passed as arguments to higher-order functions in Functional Programming?

• Yes, only numbers can be passed to higher-order functions.
• Functions can only be passed as return values, not as arguments.
• No, functions cannot be passed as arguments in Functional Programming.
• Yes, functions can be passed as arguments to higher-order functions.

23. Can functions return other functions in Functional Programming?

• No, functions cannot return other functions.
• Yes, functions can return other functions.
• No, functions can only return primitive data types.
• Yes, but only in Object-Oriented Programming.

24. What is an example of a higher-order function in JavaScript?

• log()
• print()
• filter()
• alert()

25. How does Functional Programming handle symbolic computation and application processing?

• Functional Programming uses imperative techniques to manage symbolic computation.
• Functional Programming ignores symbolic computation by focusing solely on numeric processing.
• Functional Programming is designed to handle symbolic computation by treating functions as first-class citizens and emphasizing immutability.
• Functional Programming handles symbolic computation through mutable data structures.

26. Can functions be used to build complex operations from simpler ones in Functional Programming?

• Yes, functions can be used to build complex operations from simpler ones through function composition.
• Functions can only perform single, isolated tasks in Functional Programming.
• Functions can only execute sequentially without combining their outputs.
• No, functions cannot combine in any way to create operations.

27. What is the purpose of using pure functions in Functional Programming?

• Pure functions make code more predictable by providing consistent output.
• Pure functions modify global state to ensure data integrity.
• Pure functions are designed to increase code complexity and ambiguity.
• Pure functions are used solely for error handling in programs.

28. How does Functional Programming handle data immutability?

• Data can be easily modified after creation, allowing for flexible changes.
• Data remains constant throughout a program`s lifecycle, preventing any form of modifications.
• Data is immutable, meaning it cannot be changed once created, instead of modifying existing data, new data structures are created.
• Data is mutable, meaning it frequently changes during program execution.

29. What is an example of function composition in Functional Programming?

• `forEach` loop in JavaScript
• `sort` function in C++
• `map` function in Python
• `fold` function for collections

30. How does Functional Programming handle mutable state changes?

• Functional Programming relies on object-oriented techniques to manage state changes effectively.
• Functional Programming encourages frequent modifications of existing data structures to enhance performance.
• Functional Programming emphasizes immutability, avoiding mutable state changes by creating new data structures instead of modifying existing ones.
• Functional Programming allows mutable states by using global variables for easier access.