Programowanie Funkcyjne

0

Napisz funkcję accumulate, która przyjmuje tablicę, funkcję lambda przyjmującą dwa parametry oraz wartość początkową. Funkcja accumulate powinna zwrócić wynik działania funkcji lambda dla wartości początkowej i kolejnych elementów tablicy. Napisz funkcję main gdzie przetestujesz funkcję accumulate.

Przykład:

Wartość początkowa: 0
Tablica: 1, 2, 3, 4, 5
Wynik: (((((0 + 1) + 2) + 3) + 4) + 5)
**troche się pogubiłem ,nie bardzo wiem czy idę w dobrą strone i co powinno znajdować się w ciele lambdy.

#include <iostream>

using namespace std;

auto lambda = [](int wart_pocz ,int wartosc[], size_t n){
int suma = 0;

wart_pocz = 0;


for(int i=0; i<n; i++){
	
}
return 
};

template<class Type>
Type Accumulate(Type* liczba,size_t n)
{
	
}
int main()
{
	int ar[] = { 1,1,1,1,1,1,1,1,1,1 };
	size_t n = 10;
	Accumulate(ar,n);
	cout<<endl;
	cout<<lambda(ar,n);
}
2

Przede wszystkim

funkcję lambda przyjmującą dwa parametry

auto lambda = [](int wart_pocz ,int wartosc[], size_t n){

Co Ci się tu nie zgadza?

Lambda ma przyjąć 2 wartości, nie tablicę. To funkcja accumulate ma działać na tablicy - popatrz jak się używa std::accumulate, i spróbuj to samo zaimplementować.

0

Napisałem już funkcję :
vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int sum = std::accumulate(v.begin(), v.end(), 0);
cout << "sum: " << sum << '\n';

Więc lambda ma posiadać dwa parametry:
auto lambda = [](int a , int b ) {

                 };

** czy teraz jest lepiej?

0

Dobrze, a teraz użyj std::accumulate z lambdą. A potem napisz odpowiedni std::accumulate, ale sam.

0

#include <iostream>
#include <vector>
#include <numeric>
#include <string>
#include <functional>
using namespace std;
vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int main()
{

int sum = std::accumulate(v.begin(), v.end(), 0);

 auto lambda = [](int a, int b){return a + b / v.size(); };
cout <<"Wartosc poczatkowa: "<< accumulate(v.begin(), v.end(), 0, lambda) <<endl;
cout << "sum: " << sum << '\n';
         

}

** Czy teraz jest całość poprawna ?

0

A kompiluje się? Bo nie powinno.

0

tak kompiluje się.

0

Na pewno ten sam kod?

0

Przesyłam kod jeszcze raz.

#include <iostream>
#include <vector>
#include <numeric>
#include <string>
#include <functional>
using namespace std;
vector<int> v{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

int main()
{

int sum = std::accumulate(v.begin(), v.end(), 0);

 auto lambda = [](int a, int b){return a + b / v.size(); };
cout <<"Wartosc poczatkowa: "<< accumulate(v.begin(), v.end(), 0, lambda) <<endl;
cout << "sum: " << sum << '\n';
         

}

0

Ach, bo wektor jest globalny. No tak. No dobra, to zła praktyka, ale niech będzie. W takim razie teraz napisz własne accumulate, które przyjmie taką samą lambdę.

0

Przykład implementacji accumulate.

using namespace std;

template< typename Iter >
using value = typename iterator_traits<Iter>::value_type;

template< typename Iter , typename Lambda >
value<Iter> accumulate_( Iter start , Iter stop , value<Iter> init , Lambda lambda )
{
    value<Iter> result {init};

    for( auto iter {start} ; iter!=stop ; ++iter )
    {
        result = lambda(result,*iter);
    }

    return result;
}
0

Przykład implementacji accumulate:

template<typename... Ts>
auto accumulate(auto... a) {
    return std::accumulate(std::forward<Ts...>(a...));
}

Kompilować w G++ z -std=c++17 -fconcepts. (tak, wiem że to pewnie jest uważane za nielegalne).

1 użytkowników online, w tym zalogowanych: 0, gości: 1