Language: C++

#include<iostream>
#include<string>
#include<vector>
#include<utility>
#include<algorithm>
#include<map>
#include<cstdlib>
#include<cmath>
#include<numeric>
#include<iomanip>
#include<functional>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
using ll =long long;
//const int mod = 1000000007;
//class mint {
//	long long x;
//public:
//	mint(long long x = 0) : x((x% mod + mod) % mod) {}
//	mint operator-() const {
//		return mint(-x);
//	}
//	mint& operator+=(const mint & a) {
//		if ((x += a.x) >= mod) x -= mod;
//		return *this;
//	}
//	mint & operator-=(const mint & a) {
//		if ((x += mod - a.x) >= mod) x -= mod;
//		return *this;
//	}
//	mint & operator*=(const  mint & a) {
//		(x *= a.x) %= mod;
//		return *this;
//	}
//	mint operator+(const mint & a) const {
//		mint res(*this);
//		return res += a;
//	}
//	mint operator-(const mint & a) const {
//		mint res(*this);
//		return res -= a;
//	}
//	mint operator*(const mint & a) const {
//		mint res(*this);
//		return res *= a;
//	}
//	mint pow(ll t) const {
//		if (!t) return 1;
//		mint a = pow(t >> 1);
//		a *= a;
//		if (t & 1) a *= *this;
//		return a;
//	}
//	// for prime mod
//	mint inv() const {
//		return pow(mod - 2);
//	}
//	mint& operator/=(const mint & a) {
//		return (*this) *= a.inv();
//	}
//	mint operator/(const mint & a) const {
//		mint res(*this);
//		return res /= a;
//	}
//
//	friend ostream& operator<<(ostream & os, const mint & m) {
//		os << m.x;
//		return os;
//	}
//};
char num[5]{ 'm','a','r','c','h' };
void recursive_comb(int* indexes, int s, int rest, std::function<void(int*)> f) {
	if (rest == 0) {
		f(indexes);
	}
	else {
		if (s < 0) return;
		recursive_comb(indexes, s - 1, rest, f);
		indexes[rest - 1] = s;
		recursive_comb(indexes, s - 1, rest - 1, f);
	}
}

// nCkの組み合わせに対して処理を実行する
void foreach_comb(int n, int k, std::function<void(int*)> f) {
	int indexes[k];
	recursive_comb(indexes, n - 1, k, f);
}

int main() {
	int N;
	vector<string>s;
	rep(i, N)cin >> s[i];
	map<char, int>a;
	rep(i, N) {
		a[s[i][0]]++;
	}
	ll ans=0;
	foreach_comb(5, 3, [](int* indexes) {
		ans += a[num[indexes[0]]] * a[num[indexes[1]]] * a[num[indexes[2]]];

		});
}


Compiler output:
a.cc: In lambda function:
a.cc:100:17: error: 'ans' is not captured
  100 |                 ans += a[num[indexes[0]]] * a[num[indexes[1]]] * a[num[indexes[2]]];
      |                 ^~~
a.cc:99:29: note: the lambda has no capture-default
   99 |         foreach_comb(5, 3, [](int* indexes) {
      |                             ^
a.cc:98:12: note: 'll ans' declared here
   98 |         ll ans=0;
      |            ^~~
a.cc:100:24: error: 'a' is not captured
  100 |                 ans += a[num[indexes[0]]] * a[num[indexes[1]]] * a[num[indexes[2]]];
      |                        ^
a.cc:99:29: note: the lambda has no capture-default
   99 |         foreach_comb(5, 3, [](int* indexes) {
      |                             ^
a.cc:94:23: note: 'std::map<char, int> a' declared here
   94 |         map<char, int>a;
      |                       ^
a.cc:100:45: error: 'a' is not captured
  100 |                 ans += a[num[indexes[0]]] * a[num[indexes[1]]] * a[num[indexes[2]]];
      |                                             ^
a.cc:99:29: note: the lambda has no capture-default
   99 |         foreach_comb(5, 3, [](int* indexes) {
      |                             ^
a.cc:94:23: note: 'std::map<char, int> a' declared here
   94 |         map<char, int>a;
      |                       ^
a.cc:100:66: error: 'a' is not captured
  100 |                 ans += a[num[indexes[0]]] * a[num[indexes[1]]] * a[num[indexes[2]]];
      |                                                                  ^
a.cc:99:29: note: the lambda has no capture-default
   99 |         foreach_comb(5, 3, [](int* indexes) {
      |                             ^
a.cc:94:23: note: 'std::map<char, int> a' declared here
   94 |         map<char, int>a;
      |                       ^