Brace expansion: Difference between revisions

depythonized
(Add stuff)
(depythonized)
Line 326:
=={{header|C++}}==
 
C++11 version of the Python solution:
 
<lang cpp>#include <iostream>
Line 336:
namespace detail {
 
template <typename String, typename List, typename ForwardIterator>
class tokenizer
List getgroup(ForwardIterator & begin, ForwardIterator end);
 
template <typename String, typename List, typename ForwardIterator>
List getitems(ForwardIterator & begin, ForwardIterator end, bool depth = false)
{
List out{ String() };
ForwardIterator _tbegin, _tend, _end;
for (;;) {
auto c = begin;
public:
for (; c != end && *c != '{' && (!depth || (*c != ',' && *c != '}')); ++c) {
if (*c == '\\' && std::next(c) != end) {
tokenizer(ForwardIterator begin, ForwardIterator end)
++c;
: _tbegin(begin), _tend(begin), _end(end)
{ }
template <typename Lambda>
bool next(Lambda istoken)
{
if (_tbegin == _end) {
return false;
}
_tbegin = _tend;
for (; _tend != _end && !istoken(*_tend); ++_tend) {
if (*_tend == '\\' && std::next(_tend) != _end) {
++_tend;
}
}
forif (auto_tend &== a : out_tbegin) {
_tend++;
a.append(begin, c);
}
ifreturn (c == end || *c_tbegin != '{') {_end;
}
begin = c;
return out;
ForwardIterator begin() const { return _tbegin; }
ForwardIterator end() const { return _tend; }
bool operator==(char c) { return *_tbegin == c; }
};
 
template <typename List>
void append_all(List & lista, const List & listb)
{
if (listb.size() == 1) {
for (auto & a : lista) {
a += listb.back();
}
} else {
ForwardIterator newbegin = std::next(c);
List tmp;
auto x = getgroup<String, List>(newbegin, end);
iffor (!x.empty()auto & a : lista) {
for (auto & b : listb) {
List newout;
for tmp.push_back(auto & a :+ outb) {;
for (auto & b : x) {
newout.push_back(a + b);
}
}
out = std::move(newout);
begin = newbegin;
} else {
for (auto & a : out) {
a += *c;
}
begin = std::next(c);
}
lista = std::move(tmp);
}
}
 
template <typename String, typename List, typename ForwardIteratorTokenizer>
List expand(Tokenizer & token)
List getgroup(ForwardIterator & begin, ForwardIterator end)
{
List out;
std::vector<List> alts{ { String() } };
bool comma = false;
while (begin != end) {
while (token.next([](char c) { return c == '{' || c == ',' || c == '}'; })) {
auto g = getitems<String, List>(begin, end, true);
if (begin == end) {
if (token == '{') {
break;
append_all(alts.back(), expand<String, List>(token));
}
} else if (token == ',') {
out.insert(out.end(), std::make_move_iterator(std::begin(g)),
alts.push_back({ String() });
std::make_move_iterator(std::end(g)));
} else if (token == '}') {
auto c = *begin++;
if (calts.size() == '}'1) {
if for (!commaauto & a : alts.back()) {
for (auto & a : out) {
a = '{' + a + '}';
}
return alts.back();
} else {
for (std::size_t i = 1; i < alts.size(); i++) {
alts.front().insert(alts.front().end(),
std::make_move_iterator(std::begin(alts[i])),
std::make_move_iterator(std::end(alts[i])));
}
return std::move(alts.front());
}
} else {
return out;
for (auto & a : alts.back()) {
a.append(token.begin(), token.end());
}
}
}
List result{ String{ '{' } };
append_all(result, alts.front());
for (std::size_t i = 1; i < alts.size(); i++) {
for (auto & a : result) {
a += ',';
}
append_all(result, alts[i]);
comma = true;
}
return List{ }result;
}
 
Line 414 ⟶ 446:
List expand(ForwardIterator begin, ForwardIterator end)
{
return detail::getitemstokenizer<String,ForwardIterator> List>token(begin, end);
List list{ String() };
while (token.next([](char c) { return c == '{'; })) {
if (token == '{') {
detail::append_all(list, detail::expand<String, List>(token));
} else {
for (auto & a : list) {
a.append(token.begin(), token.end());
}
}
}
return list;
}
 
Line 447 ⟶ 490:
R"({a,b{{1,2}e}f)",
R"({}} some }{,{\\{ edge, edge} \,}{ cases, {here} \\\\\})",
R"({{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{{)",
}) {
std::cout << string << '\n';
Anonymous user