fs_exercise

The exercise problems for F# practice suggested by ChatGPT

Question

I am trying F#. I just read the basic syntax. Then what is it good to do for me?

Answer from ChatGPT

F# is a versatile language that can be employed in a variety of domains, thanks to its functional-first programming paradigm, strong static typing, and .NET framework integration. Here are some areas where F# can be particularly beneficial:

Data Analysis and Science: F# can help you perform complex data transformations, statistical analyses, and visualization tasks. The language's strong typing and functional features make it easier to work with large datasets and implement complex algorithms.

Financial Applications: F# is a popular choice for quantitative finance and risk management applications. Its functional-first approach allows for more concise and expressive code, which is critical when working with financial models, pricing algorithms, and simulations.

Web Development: F# can be used for web development through libraries like Giraffe or Saturn, which are built on top of ASP.NET Core. These libraries allow you to create web applications using functional programming concepts, resulting in more maintainable and robust code.

Domain-Specific Languages (DSLs): F# excels in creating internal and external DSLs, thanks to its concise syntax, pattern matching, and algebraic data types. You can create languages tailored to specific problem domains, making it easier to model and solve problems in those areas.

Concurrency and Parallelism: F#'s built-in support for asynchronous programming and parallelism allows you to create highly performant and scalable applications. The language's focus on immutability and functional programming can help you write more predictable and robust concurrent code.

Interoperability with .NET: Since F# is part of the .NET ecosystem, you can use it alongside other .NET languages such as C# and VB.NET. This means you can leverage existing .NET libraries, components, and tooling, as well as integrate F# code into existing .NET projects.

As you continue learning F#, consider exploring these areas based on your interests and the problems you'd like to solve. The language's flexibility, expressiveness, and robustness make it a powerful tool for a wide range of applications.

Useful Links

TODOs

TorchSharp and DiffSharp for ML
P/Invoke to use native C/C++ codes for fast data processing

Problem 1. Fibonacci Sequence

Subject

Recursion, Tail Recursion

Task

Write a function that takes a positive integer n as input and returns the nth number in the Fibonacci sequence. The Fibonacci sequence is defined as follows:

$$F(0) = 0$$

$$F(1) = 1$$

$$F\left(n\right) = \left(n-1\right) + F\left(n-2\right)\quad \mathsf{for} \quad n > 1$$

Here's a template to get you started:

let rec fibonacci n =
    match n with
    | // Your code here

// Test your implementation
printfn "%d" (fibonacci 10) // Should print 55

To solve this problem, you'll need to use pattern matching to handle the base cases (n = 0 and n = 1) and the recursive case (n > 1). When you've completed your implementation, test it with various input values to ensure it produces the correct Fibonacci numbers.

Rewiew

We should a technique called "tail recurssion", which is a form of recursion where the recursive call is the last operation in the function, to avoid stack overflow.

Problem 2. Squares of Odd Numbers

Subject

Higher-Order Functions, List Processing, Pattern Matching

Task

Write a function that takes a list of integers and returns a new list containing the squares of the odd numbers in the input list.

Here's a template to get you started:

let squaresOfOdds numbers =
    // Your code here

// Test your implementation
let testNumbers = [1; 2; 3; 4; 5; 6; 7; 8; 9]
printfn "%A" (squaresOfOdds testNumbers) // Should print [1; 9; 25; 49; 81]

To solve this problem, consider using the List.filter and List.map functions. The List.filter function filters elements from a list based on a predicate (a function that returns true or false), and the List.map function applies a given function to each element of a list and returns a new list with the transformed elements.

Additionally, you can use pattern matching to identify odd numbers. Once you've completed your implementation, test it with various input lists to ensure it produces the correct output.

Problem 3. Palindrome Checker

Subject

String Manipulation, Pattern Matching

Task

Write a function called isPalindrome that takes a string as an argument and returns true if the input string is a palindrome, and false otherwise. A palindrome is a word, phrase, number, or other sequences of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).

Write a function called isPalindrome that takes a string as an argument and returns true if the input string is a palindrome, and false otherwise. A palindrome is a word, phrase, number, or other sequences of characters that reads the same forward and backward (ignoring spaces, punctuation, and capitalization).

Here's a template to get you started:

let isPalindrome (input: string) =
    // Your code here

// Test your implementation
printfn "%b" (isPalindrome "racecar") // Should print true
printfn "%b" (isPalindrome "hello") // Should print false

To solve this problem, consider using F#'s string manipulation functions to remove spaces, punctuation, and convert the string to lowercase. Then, you can compare the original cleaned string with its reverse. If they are the same, the input string is a palindrome. Once you've completed your implementation, test it with various input strings to ensure it produces the correct output.

Problem 4. Group Elements

Subject

List Processing, Recursion

Task

Write a function called groupElements that takes a list of integers and an integer n as arguments, and returns a list of lists, where each inner list contains n elements from the input list. If the input list does not divide evenly by n, the last inner list should contain the remaining elements. Use list processing functions and recursion to implement this function.

Here's a template to get you started:

let rec groupElements lst n =
    // Your code here

// Test your implementation
let testList = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]
printfn "%A" (groupElements testList 3) // Should print [[1; 2; 3]; [4; 5; 6]; [7; 8; 9]; [10]]

To solve this problem, use pattern matching to handle the base case (an empty list) and the recursive case (a non-empty list). In the recursive case, create a new list with the first n elements of the input list, and concatenate this list with the result of calling groupElements on the remaining elements of the input list. Test your implementation with various input lists and group sizes to ensure it produces the correct output.

Problem 5. Person Type and Functions

Subject

Record Types, Function Composition

Task

Define a Person record type with properties FirstName, LastName, and Age. Create the following functions:

createPerson: Takes a first name, last name, and age as arguments, and returns a new Person record.
fullName: Takes a Person record as an argument and returns a string containing the person's full name (i.e., first name and last name separated by a space).
isAdult: Takes a Person record as an argument and returns true if the person's age is 18 or older, and false otherwise.

Here's a template to get you started:

 type Person = {
    FirstName: string
    LastName: string
    Age: int
}

let createPerson firstName lastName age =
    // Your code hear

let fullName person =
    // Your code hear

let isAdult person =
    // Your code hear

// Test your implementation
let person = createPerson "John" "Doe" 25
printfn "Full name: %s" (fullName person)
printfn "Is adult: %b" (isAdult person)

This code defines a Person record type with FirstName, LastName, and Age properties. It also defines the createPerson, fullName, and isAdult functions. Finally, it tests the implementation with a sample person.

Problem 6. File I/O with Simple Text Database

Subject

File I/O, List Processing

Task

Create a simple program that reads and writes records (e.g., people's names and ages) from a text file. Implement the following functions:

readRecords: Takes a file name as an argument and returns a list of records read from the file.
writeRecords: Takes a file name and a list of records as arguments and writes the records to the file.
addRecord: Takes a list of records and a new record as arguments, and returns a new list with the new record added.

Problem 7. Reverse a List

Subject

List processing and recursion

Task

Implement a function that reverses a list using recursion. The function should take a list as input and return a new list with the elements in reverse order.

Here's a template to get you started:

let rec reverseList lst =
    match lst with
    | // Your code here

// Test your implementation
let testList = [1; 2; 3; 4; 5]
printfn "%A" (reverseList testList) // Should print [5; 4; 3; 2; 1]

To solve this problem, use pattern matching to handle the base case (an empty list) and the recursive case (a non-empty list). In the recursive case, you will need to append the head of the input list to the result of reversing the tail of the list. Test your implementation with various input lists to ensure it produces the correct output.

Review

This function is List.rev in F# Core library.

Problem 8. Flatten Nested Lists

Subject

List processing and recursion

Task

Implement a function that flattens a nested list structure. The function should take a nested list as input and return a new list containing all the elements from the input list, in the same order but without any nesting.

Here's a template to get you started:

let rec flatten lst =
    match lst with
    | // Your code here

// Test your implementation
let testNestedList = [[1; 2]; [3; 4; 5]; [6]; []; [7; 8; 9]]
printfn "%A" (flatten testNestedList) // Should print [1; 2; 3; 4; 5; 6; 7; 8; 9]

To solve this problem, use pattern matching to handle the base case (an empty list) and the recursive case (a non-empty list). In the recursive case, you will need to concatenate the head of the input list (which is itself a list) with the result of flattening the tail of the input list. Test your implementation with various input lists to ensure it produces the correct output.

Review

This function is List.collect in F# Core library.

Problem 9. CSV Average Calculator (upcoming)

Subject

File I/O, CSV Processing

Task

Create a function that reads a CSV file and calculates the average of numbers in a specified column. Assume that the CSV file has a header row and the data rows contain only numbers. The CSV file could look like this:

A,B,C
1,2,3
4,5,6
7,8,9

Implement a function averageOfColumn that takes a file name and a column name as arguments, reads the CSV file, and calculates the average of the specified column. Use F#'s file I/O functions and string manipulation functions to process the CSV file. When you've completed your implementation, test it with various CSV files and column names to ensure it produces the correct output.

Here's a template to get you started:

let averageOfColumn fileName columnName =
    // Your code here

// Test your implementation
let testFileName = "test.csv"
let testColumnName = "B"
printfn "%.2f" (averageOfColumn testFileName testColumnName) // Should print 5.00

These problem statements and tasks should provide more guidance for completing the remaining problems.

Problem 10. Contact List Manager (upcoming)

Subject

Command-line interface, Data Manipulation

Task

Create a command-line application that allows users to perform various operations on a list of contacts. The application should support the following operations:

Add a new contact
Delete a contact
Search for a contact by name
Update contact details
List all contacts
Save contacts to a file
Load contacts from a file

To implement this project, consider the following suggestions:

Create a Contact type to represent a contact with properties such as Id, FirstName, LastName, Email, and PhoneNumber.
Use a list or other collection to store contacts in memory.
Create functions to handle each operation (e.g., addContact, deleteContact, searchContact, updateContact, listContacts, saveContacts, and loadContacts).
Use pattern matching and/or if-then-else expressions to process user input and call the appropriate functions.
Use F# file I/O functions to save and load contacts from a file (e.g., using System.IO.File methods).

Your command-line application should be interactive and present a menu to the user. The menu should display the available operations and prompt the user for input. Based on the user's input, the application should perform the corresponding operation and display the result. The application should continue running until the user decides to exit.

Here's a rough outline of how your application might look:

type Contact = {
    Id: int
    FirstName: string
    LastName: string
    Email: string
    PhoneNumber: string
}

// Functions for contact management (addContact, deleteContact, searchContact, updateContact, listContacts, saveContacts, and loadContacts)

let rec mainLoop contacts =
    // Display the menu and prompt the user for input
    // Perform the selected operation
    // Update the contacts list if necessary
    // Call mainLoop with the updated contacts list

// Load contacts from a file (if available) and start the main loop
let initialContacts = loadContacts "contacts.txt"
mainLoop initialContacts

Make sure to test your implementation with various operations and scenarios to ensure it works correctly.

Project 1. Simple Command-Line Todo List Application (upcoming)

Subject

Application Structure, File I/O, Command-Line Interface

Task

Create a simple command-line todo list application that allows users to manage their tasks. The application should support the following operations:

Add a new task.
List all tasks.
Mark a task as complete.
Remove a task.
Save tasks to a file.
Load tasks from a file.

To implement this project, consider the following suggestions:

Create a Task type to represent a task with properties such as Id, Description, and IsCompleted.
Use a list or other collection to store tasks in memory.
Create functions to handle each operation (e.g., addTask, listTasks, markTaskComplete, removeTask, saveTasks, and loadTasks).
Use pattern matching and/or if-then-else expressions to process user input and call the appropriate functions.
Use F# file I/O functions to save and load tasks from a file (e.g., using System.IO.File methods).

Name		Name	Last commit message	Last commit date
Latest commit History 23 Commits
.vscode		.vscode
Problem1		Problem1
Problem2		Problem2
Problem3		Problem3
Problem4		Problem4
Problem5		Problem5
Problem6		Problem6
Problem7		Problem7
Problem8		Problem8
Problem9		Problem9
.gitignore		.gitignore
README.md		README.md

InitusNovus/fs_exercise

Folders and files

Latest commit

History

Repository files navigation

fs_exercise

Question

Answer from ChatGPT

Useful Links

TODOs

Problem 1. Fibonacci Sequence

Subject

Task

Rewiew

Problem 2. Squares of Odd Numbers

Subject

Task

Problem 3. Palindrome Checker

Subject

Task

Problem 4. Group Elements

Subject

Task

Problem 5. Person Type and Functions

Subject

Task

Problem 6. File I/O with Simple Text Database

Subject

Task

Problem 7. Reverse a List

Subject

Task

Review

Problem 8. Flatten Nested Lists

Subject

Task

Review

Problem 9. CSV Average Calculator (upcoming)

Subject

Task

Problem 10. Contact List Manager (upcoming)

Subject

Task

Project 1. Simple Command-Line Todo List Application (upcoming)

Subject

Task

Problem 11. Poker Hand Evaluator

Subject

Task

Problem 12. Text Data Analyzer

Subject

Task

Problem 13. Library System Modeling

Subject

Task

Problem 14. Custom Record Sorter

Subject

Task

Problem 15. Prime Number Summation

Subject

Task

Problem 16. Team Combination Generator

Subject

Task

Problem 17. Arithmetic Expression Evaluator

Subject

Task

Problem 18. Sales Data Analyzer

Subject

Task

Problem 19. Social Network Friend Recommendation

Subject

Task

Problem 20. Data Processing Pipeline

Subject

Task

Problem 21. Infinite Prime Number Generator

Subject

Task

Project 2. Basic Weather Forecast App