void reverseWords(string &s) {
string st = s;
int len = s.size();
int cnt = 0;
bool flag = false;
for(int i=0;i<len;++i){
while(i<len && st[i] == ' ')++i;
if(i >= len)break;
if(flag){s[cnt++] = ' ';}
else{ flag = true;}
while(i<len && st[i] != ' ')s[cnt++] = st[i++];
}
for(int i=cnt;i<len;++i)s.pop_back();
int l = 0,r=cnt-1;
while(l<r){
swap(s[l],s[r]);
++l;--r;
}
for(int i=0;i<cnt;++i){
while(i<cnt && s[i] == ' ')++i;
l = i;
while(i<cnt && s[i] != ' ')++i;
r = i-1;
while(l<r)
{
swap(s[l],s[r]);
++l;--r;
}
}
}
//255122344
//255.122.34.4
//k = depth
void enum_ips (string& input,int k,int start,string result,vector<string> &sv) {
//Weed out the extra result
if (k == 4) {
//Remove the last dot
if (input.length() == (result.length() - 4 ) ) {
result.pop_back();
cout << result << endl;
}
return;
} else {
//FFT : put the dot at every place and upper limit is 3 places
int num = 0;
for (int i=start;i<=start+2;i++) {
//Idea to keep track of numerical value on the STACK FRAME
num = num * 10 + input[i] - '0';
if (num <= 255) {
result += input[i];
enum_ips (input,k+1,i+1,result+".",sv);
}
if (num == 0) {
break;
}
}
}
}
void genParens(int n, int lp, int rp, string res) {
//cout << lp << " " << res << "\n";
if(lp == n && rp == n) {
cout << res << "\n";
}
if(lp < n) {
res += '(';
genParens(n, lp + 1, rp, res);
res.pop_back();
}
if(lp > rp) {
res += ')';
genParens(n, lp, rp + 1, res);
res.pop_back();
}
}
void backtr() {
if (!sigma) {
cout << str << '\n';
return ;
}
vector <int> copyS(S.begin(), S.end());
for (auto node: copyS) {
str += (char)(node + 'A');
S.erase(node);
for (auto it: graph[node]) {
-- inDeg[it];
if (!inDeg[it])
S.insert(it);
}
-- sigma;
backtr();
++ sigma;
for (auto it: graph[node]) {
++ inDeg[it];
if (inDeg[it] == 1)
S.erase(it);
}
S.insert(node);
str.pop_back();
}
}
void gpHelper(int l, int r, string &sol, vector<string> &res){
if(l==0 && r==0){
res.push_back(sol);
return;
}
if(l>0){
sol.push_back('(');
gpHelper(l-1, r, sol, res);
sol.pop_back();
}
if(r>l){
sol.push_back(')');
gpHelper(l, r-1, sol, res);
sol.pop_back();
}
}
void dfs(int left, int right, string &comb, vector<string> &res){
if(left == 0 && right == 0){
res.push_back(comb);
return;
}
if(left > 0){
comb.push_back('(');
dfs(left - 1, right, comb, res);
comb.pop_back();
}
if(right > left){
comb.push_back(')');
dfs(left, right - 1, comb, res);
comb.pop_back();
}
}
void FolderIterator::GetFolders(string path, vector<string>& folders,bool is_subfolder)
{
assert(path.length() != 0);
if (path.length() >= _MAX_FNAME || int(path.find(' ')) != -1)
return;
if (path.rfind('\\') == (path.length() - 1))
path.pop_back();
long long hFile = 0;
_finddata_t file_info;// file information struct.
string temp;
if ((hFile = _findfirst(((temp.assign(path)).append("/*")).c_str(), &file_info)) != -1)
{
do
{
if ((file_info.attrib & _A_SUBDIR))
{
if (strcmp(file_info.name, ".") != 0 && strcmp(file_info.name, "..") != 0)
{
folders.push_back(((temp.assign(path)).append("//")).append(file_info.name));
if (is_subfolder)
{
GetFolders(temp.assign(path).append("//").append(file_info.name), folders, is_subfolder);
}
}
}
} while (_findnext(hFile, &file_info) == 0);
_findclose(hFile);
}
}
void generate(int n,int num,string &str,vector<string> &res){
if(n==0&&num==0){
res.push_back(str);
return;
}
if(n>0){
str+='(';
generate(n-1,num+1,str,res);
str.pop_back();
}
if(num){
str+=')';
generate(n,num-1,str,res);
str.pop_back();
}
}
//从构造好的树中挖掘频繁项集
void FPTree::mineTree(string &prefix, unordered_map<string,int> &frequent)
{
//头指针列表head中存储的实际是单频繁项。根据项值和计数值构造节点，插入到集合
//不同于建树时，此时是按照计数值从低到高顺序排序
vector<node> key_count;
for (auto iter = head.begin(); iter != head.end(); ++iter)
key_count.emplace_back(node(iter->first, iter->second->count));
sort(key_count.begin(), key_count.end(), node::comparer::less());
for (auto iter = key_count.begin(); iter != key_count.end(); ++iter)
{//对于每一个单频繁项
prefix.append(iter->key);
frequent.emplace(prefix + ')',iter->count); //发现一个频繁项
unordered_map<string, int> subdata;
//以当前单频繁项为尾，在树中上溯挖掘条件基，也就是在已出现prefix的情况下挖掘记录
findPrefixPath(iter->key, subdata);
FPTree subtree(eps);
subtree.create(subdata); //根据挖掘到的记录构造的子数据集创建子FP树，以用于挖掘更复杂的频繁项
if (!subtree.empty())
{//如果树不空，即存在更复杂的频繁项
prefix += ' ';//用于分隔记录项
subtree.mineTree(prefix, frequent); //继续递归挖掘
prefix.pop_back(); //删除空格
}
int index = prefix.rfind(' ');
if (index == string::npos) prefix.resize(1); //删除iter->key
else prefix.resize(index + 1);
}
}
void dfs(vector<string>& ret, string tmp, string s, int step, const int b){
if(b==s.size() && step==4){
tmp.pop_back();
ret.push_back(tmp);
return;
}
// 剪枝
if(s.size() - b > (4-step)*3){return;}
if(s.size() - b < 4-step){return;}
// 当前部分取1/2/3个数字
// 如果s[b]是0 则只能单独列出来 否则会有重复解
if(s[b]=='0'){
dfs(ret, tmp+"0.", s, step+1, b+1);
return;
}
int curr = 0;
for(int i=b; i<min(b+3, (int)s.size()); i++){
curr = 10*curr + s[i]-'0';
if(curr>=0 && curr<=255){
dfs(ret, tmp + to_string(curr) + ".", s, step+1, i+1);
}
if(curr==0){
break;
}
}
}
void generateParenthesis(int left, string &parenthesis, const int n, vector<string> &answers) {
if (left == n && parenthesis.length() == n + n) {
answers.push_back(parenthesis);
return;
}
if (left < n) {
parenthesis += '(';
generateParenthesis(left + 1, parenthesis, n, answers);
parenthesis.pop_back();
}
if (left + left > parenthesis.length()) {
parenthesis += ')';
generateParenthesis(left, parenthesis, n, answers);
parenthesis.pop_back();
}
}
void dfs(int level,int start,string temp, vector<string> & result ){
//if level is four, add the result back
if(level == 4 && start==s.size() ){
temp.pop_back();
result.push_back(temp);
}
//termination:
//this is equivalent to the following two sentences
if( start == s.size() || level ==4 ) return;
//if( (s.size()-start) < (4-level) return;
//if( (s.size()-start) > (4-level)*3 ) return;
//
int num=0;
for(int i=start; i<start+3; i++){
//previsit, check conditions
num= num*10+s[i]-'0';
if( num<=255 ){
temp+=s[i];
//zhezhong xiaoti i he start qu nong nong cuo...
dfs(level+1, i+1, temp+'.',result);
//post visit: gonna continue
//basically just do nothing, but cannot continue with starting 0 in this level
//(stop trying to reach other adjacant vertics because illegal)
//IMPORTANT!!!!
if(num == 0) break; //first time two continuous 0 happens
}
}
}
void generateParenthesis(int n, int left, int right, string& s) {
if (left == n && right == n) {
r.push_back(s);
return;
}
if (right < left) {
s.push_back(')');
generateParenthesis(n, left, right + 1, s);
s.pop_back();
}
if (left < n) {
s.push_back('(');
generateParenthesis(n, left + 1, right, s);
s.pop_back();
}
}
vector<string> split_string(string input_string) {
string::iterator new_end = unique(input_string.begin(), input_string.end(), [] (const char &x, const char &y) {
return x == y and x == ' ';
});
input_string.erase(new_end, input_string.end());
while (input_string[input_string.length() - 1] == ' ') {
input_string.pop_back();
}
vector<string> splits;
char delimiter = ' ';
size_t i = 0;
size_t pos = input_string.find(delimiter);
while (pos != string::npos) {
splits.push_back(input_string.substr(i, pos - i));
i = pos + 1;
pos = input_string.find(delimiter, i);
}
splits.push_back(input_string.substr(i, min(pos, input_string.length()) - i + 1));
return splits;
}
void getIP(vector<string> &res, string &sol, string s, int start, int level) {
if (level == 4) {
if (start == s.length()) {
sol.pop_back();
res.push_back(sol);
}
return;
}
if (start == s.length()) return;
// push 1 number
int len = sol.length();
if (isValidNumber(s.substr(start, 1))) {
sol += s.substr(start, 1) + ".";
getIP(res, sol, s, start+1, level+1);
sol.resize(len);
}
// push 2 numbers
if (start+2 <= s.length() && isValidNumber(s.substr(start, 2))) {
sol += s.substr(start, 2) + ".";
getIP(res, sol, s, start+2, level+1);
sol.resize(len);
}
// push 3 numbers
if (start+3 <= s.length() && isValidNumber(s.substr(start, 3))) {
sol += s.substr(start, 3) + ".";
getIP(res, sol, s, start+3, level+1);
sol.resize(len);
}
}
void topSort_all() {
bool flag=false, none=true;
int i, j;
char c;
for(i=0; i<s1.size(); i++) {
c = s1[i];
if(!indegree[c] && !visited[c]) {
for(j=0; j<G[c].size(); j++)
--indegree[ G[c][j] ];
visited[c] = true;
res += c;
topSort_all();
visited[c] = false;
res.pop_back();
for(j=0; j<G[c].size(); j++)
++indegree[ G[c][j] ];
flag = true;
none = false;
}
}
if(!flag && ( res.size() == s1.size() || !none ))
cout << res << endl;
}
void restoreIpAddresses(int index,int ipNum,
string& str,string& work,vector<string>& ret){
int size=str.size();
if(ipNum>4)
return ;
if(index==size){
if(ipNum==4){
ret.push_back(work);
ret[ret.size()-1].pop_back();
}
return ;
}
int ipTmp=0;
for(int i=0;i<3;i++){
if(index+i>=size)
break;
ipTmp=ipTmp*10+str[index+i]-'0';
if((size-1-index-i)<=3*(3-ipNum)){
if((i!=0)&&(str[index]=='0'))
break ;
if((i==2)&&(ipTmp>255))
continue;
for(int j=0;j<=i;j++)
work.push_back(str[index+j]);
work.push_back('.');
restoreIpAddresses(index+i+1,ipNum+1,str,work,ret);
for(int j=0;j<=i+1;j++)
work.pop_back();
}
}
}
void Utils::rtrim(string& s, const char c)
{
while (!s.empty() && s.back() == c)
{
s.pop_back();
}
}
void topologicalSort(char ch)
{
visited[ch] = true;
topoSort.push_back(ch);
for(auto& c : adjList[ch]) {
--indegree[c];
}
char c;
for(auto& pr : adjList) {
c = pr.first;
if(!indegree[c] && !visited[c]) {
topologicalSort(c);
}
}
if(topoSort.length() == n) {
cout << topoSort << '\n';
}
visited[ch] = false;
topoSort.pop_back();
for(auto& c : adjList[ch]) {
++indegree[c];
}
}
void dfs(vector<string> &result, string path, const int n, int leftNum, int rightNum)
{
if (leftNum == n && rightNum == n)
{
result.push_back(path);
return;
}
if (leftNum == rightNum)
{ //只能进'('
path.push_back('(');
dfs(result, path, n, leftNum + 1, rightNum);
}
else
{
if (leftNum == n)
{ //只能进')'
path.push_back(')');
dfs(result, path, n, leftNum, rightNum + 1);
}
else
{ //都可以
path.push_back('(');
dfs(result, path, n, leftNum + 1, rightNum);
path.pop_back();
path.push_back(')');
dfs(result, path, n, leftNum, rightNum + 1);
}
}
}
void Bot::process(string network, string script, string nick, string target) {
if(opts.import)
return;
script = util::trim(script);
if(script.empty())
return;
static map<Context, string> contextMap;
if(script.substr(0, 2) == "::") {
auto context = Context{ network, nick, target };
script = util::trim(script.substr(2));
if(script.back() == '\\') {
script.pop_back();
contextMap[context] += script + " ";
return;
}
script = "${ " + contextMap[context] + script + " }";
contextMap[context] = "";
}
bool simpleCall{false};
string result = "";
try {
auto expr = Parser::parse(script);
if(!expr) {
cerr << "Bot::evaluate: \"" << script << "\" is null expr" << endl;
} else {
if(expr->type == "!") simpleCall = true;
result = expr->evaluate(vm, nick).toString();
}
} catch(ParseException e) {
cerr << e.pretty() << endl;
auto lines = util::split(e.pretty(), "\n");
if(lines.size() != 3) {
result = e.msg + " @" + util::asString(e.idx);
} else {
// TODO: jank
this->send(network, target, ":" + lines[1].substr(3), true);
this->send(network, target, ":" + lines[2].substr(3) + " " + lines[0], true);
return;
}
} catch(StackTrace &e) {
cerr << e.toString() << endl;
if(e.type == ExceptionType::FunctionDoesNotExist && simpleCall) {
cerr << "simple call to nonexistant function error supressed" << endl;
} else {
result = e.toString();
}
} catch(string &s) {
cerr << "string type error: " << s << endl;
result = s;
}
// assume we can run the script
this->send(network, target, result, true);
}
string getMin(string S, int L) {
sort(end(S) - L, end(S));
while (S.size() > L) {
S.pop_back();
sort(end(S) - L, end(S));
}
return S;
}
void genParenthesisHelper( vector<string> &pars, string &sofar, int lpcnt, int n) {
if (sofar.size() == (2 * n)) {
pars.push_back(sofar);
} else {
if (lpcnt < n) {
sofar.push_back('(');
genParenthesisHelper(pars, sofar, lpcnt + 1, n);
sofar.pop_back();
}
if ((sofar.size() - lpcnt) < lpcnt) {
sofar.push_back(')');
genParenthesisHelper(pars, sofar, lpcnt, n);
sofar.pop_back();
}
}
}
string ExtractURIEndPathSegment(string URI)
{
if(URI.empty()) return "";
if(Last<char>(URI) == '/') URI.pop_back();
vector<string> splitted;
split(splitted, URI, is_any_of("/"));
return Last<string>(splitted);
}
void _DFS_print(Node* node, string& s) {
if (node == nullptr) {
cout << s << endl;
return;
}
s.push_back(node->key);
_DFS_print(node->child, s);
s.pop_back();
while (node->next != nullptr) {
node = node->next;
s.push_back(node->key);
_DFS_print(node->child, s);
s.pop_back();
}
}
// l 表示 ( 出现的次数, r 表示 ) 出现的次数
void generate(int n, string& path, vector<string> &result, int l, int r) {
if (l == n) {
string s(path);
result.push_back(s.append(n - r, ')'));
return;
}
path.push_back('(');
generate(n, path, result, l + 1, r);
path.pop_back();
if (l > r) {
path.push_back(')');
generate(n, path, result, l, r + 1);
path.pop_back();
}
}
void generateParenthesisRecur(int n, int left, int right, string &result,
vector<string> &results) {
if (result.size() == n*2) {
results.push_back(result);
} else {
if (left < n) {
result.push_back('(');
generateParenthesisRecur(n, left+1, right, result, results);
result.pop_back();
}
if (left > right) {
result.push_back(')');
generateParenthesisRecur(n, left, right+1, result, results);
result.pop_back();
}
}
}
void helper(int n, int nleft, int nright, string &comb, vector<string> &ans) {
if (n == nleft && n == nright) {
ans.push_back(comb);
return;
}
if (nleft < n) {
comb.push_back('(');
helper(n, nleft+1, nright, comb, ans);
comb.pop_back();
}
if (nright < nleft) {
comb.push_back(')');
helper(n, nleft, nright+1, comb, ans);
comb.pop_back();
}
}
void dfs (int x, int y, int idx, string& curr) {
curr += mat[idx][x][y];
if (curr.length() == 4) {
int vowels = isVowel(curr[0]) + isVowel(curr[1]) + isVowel(curr[2]) + isVowel(curr[3]);
if (vowels == 2) ans[idx].push_back(curr);
curr.pop_back();
return;
}
vis[x][y] = true;
int w, z;
for (int d=0; d<8; d++) {
w = x + dx[d];
z = y + dy[d];
if (w >= 0 && w < 4 && z >= 0 && z < 4 && !vis[w][z]) dfs(w, z, idx, curr);
}
vis[x][y] = false;
curr.pop_back();
}
void dfs(int cx, int cy, string& cur, int delta)
{
if(cx < 0 || cx >= n || cy < 0 || cy >= n) return;
cur.push_back(board[cx][cy]);
if(cx + cy == n - 1){
if(delta == 1){
a[cx].insert(cur);
}else{
b[cx].insert(cur);
}
cur.pop_back();
return;
}
dfs(cx + delta, cy, cur, delta);
dfs(cx, cy + delta, cur, delta);
cur.pop_back();
}
