// Implement these three methods the way, you consider to be the right one

// Instructions:

// Fulfill your implementation

// Share your test

​

using System;

using System.Collections.Generic;

public class Program

{

    public static void Main()

    {

        // Problem 1: Implement the following method Map without using library methods

        // (ie no Linq).

        //

        // Map applies a function to each element of a list and returns the

        // resulting list.

        //

        // Map([1,2,3], x => x + 1) = [2,3,4]

        // Map([1,2,3], x => x.ToString()) = ["1","2","3"]

        // Map([], ...) == []

​

        // Problem 2: Implement the following method Fold

        //

        // Fold applies a function to each element of a list and propagates a state

        // through calls to this function, starting with the initial state.

        //

        // Fold([1,2,3], 0, (sum,x) => sum + x) == 6

        // Fold([1,2,3], "", (str,x) => str + x.ToString()) == "123"

        // Fold([], init, ...) == init

​

        // Problem 3: implement Map in terms of Fold. Rather than implementing Map

        // directly like the first exercise, implement Map by finding a way to call

        // Fold so that it achieves the desired result.

​

         // Problem 1: Map

        List<int> numbers = new List<int> { 1, 2, 3 };

        List<int> incrementedNumbers = Map(numbers, x => x + 1);

        Console.WriteLine(string.Join(",", incrementedNumbers));  // Output: 2,3,4

​

        List<string> stringNumbers = Map(numbers, x => x.ToString());

        Console.WriteLine(string.Join(",", stringNumbers));  // Output: "1","2","3"

​

        List<int> emptyList = new List<int>();

        List<int> emptyResult = Map(emptyList, x => x * 2);

        Console.WriteLine(emptyResult.Count);  // Output: 0

​

        // Problem 2: Fold

        int sum = Fold(numbers, 0, (acc, item) => acc + item);

        Console.WriteLine(sum);  // Output: 6

​

        string concatenated = Fold(numbers, "", (acc, item) => acc + item.ToString());

        Console.WriteLine(concatenated);  // Output: "123"

​

        int initial = 0;

        int result = Fold(emptyList, initial, (acc, item) => acc * item);

        Console.WriteLine(result);  // Output: 0

​

        // Problem 3: Map in terms of Fold

        List<int> mappedNumbers = Map2(numbers, x => x + 1);

        Console.WriteLine(string.Join(",", mappedNumbers));  // Output: 2,3,4

​

        List<string> mappedStringNumbers = Map2(numbers, x => x.ToString());

        Console.WriteLine(string.Join(",", mappedStringNumbers));  // Output: "1","2","3"

​

        List<int> mappedEmptyList = Map2(emptyList, x => x * 2);

        Console.WriteLine(mappedEmptyList.Count);  // Output: 0

    }

    public static List<B> Map<A, B>(List<A> list, Func<A, B> f)

    {

        List<B> result = new List<B>();

​

        foreach (A item in list)

        {

            B transformedItem = f(item);

            result.Add(transformedItem);

        }

​

        return result;

    }

​

    public static B Fold<A, B>(List<A> list, B initial, Func<B, A, B> folder)

    {

        B state = initial;

​

        foreach (A item in list)

        {

            state = folder(state, item);

        }

​

        return state;

    }

​

    public static List<B> Map2<A, B>(List<A> list, Func<A, B> f)

    {

        return Fold(list, new List<B>(), (acc, item) =>

        {

            acc.Add(f(item));

            return acc;

        });

    }

}