output
stringlengths 52
181k
| instruction
stringlengths 296
182k
|
|---|---|
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[1001];
scanf("%s", ch);
return ch;
}
inline char getCh() {
char ch;
scanf(" %c", &ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const int MOD = 1e9 + 7;
const int MAX_N = 200 + 10;
const int MAX_LG = 21;
const int base = 29;
const int MAX_DIF = 5005;
int res = 0;
vector<pair<int, int>> st;
bool vis[MAX_N][MAX_N];
pair<int, int> mv[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int32_t main() {
int n = in(), m = in(), k = in();
priority_queue<pair<int, pair<int, int>>> pq;
pq.push({0, {0, 0}});
while (pq.empty() == false && k) {
int X = pq.top().second.first;
int Y = pq.top().second.second;
int cost = -pq.top().first;
pq.pop();
if (vis[X][Y]) continue;
vis[X][Y] = true;
res += cost + 1;
k--;
st.push_back({X + 1, Y + 1});
for (int i = 0; i < 4; i++) {
int x2 = X + mv[i].first;
int y2 = Y + mv[i].second;
if (x2 >= 0 && x2 < n && y2 >= 0 && y2 < m && vis[x2][y2] == false) {
pq.push({-cost - 1, {x2, y2}});
}
}
}
cout << res << "\n";
sort(st.begin(), st.end());
for (int i = (int)st.size() - 1; i >= 0; i--) {
int curX = 1, curY = 1;
int x = st[i].first, y = st[i].second;
while (curX <= x && curY <= y) {
printf("(%d,%d) ", curX, curY);
if (curX < x) {
curX++;
} else if (curY < y) {
curY++;
} else {
break;
}
}
printf("\n");
}
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int in() {
int32_t x;
scanf("%d", &x);
return x;
}
inline string getStr() {
char ch[1001];
scanf("%s", ch);
return ch;
}
inline char getCh() {
char ch;
scanf(" %c", &ch);
return ch;
}
template <class P, class Q>
inline P smin(P &a, Q b) {
if (b < a) a = b;
return a;
}
template <class P, class Q>
inline P smax(P &a, Q b) {
if (a < b) a = b;
return a;
}
const int MOD = 1e9 + 7;
const int MAX_N = 200 + 10;
const int MAX_LG = 21;
const int base = 29;
const int MAX_DIF = 5005;
int res = 0;
vector<pair<int, int>> st;
bool vis[MAX_N][MAX_N];
pair<int, int> mv[4] = {{0, 1}, {0, -1}, {1, 0}, {-1, 0}};
int32_t main() {
int n = in(), m = in(), k = in();
priority_queue<pair<int, pair<int, int>>> pq;
pq.push({0, {0, 0}});
while (pq.empty() == false && k) {
int X = pq.top().second.first;
int Y = pq.top().second.second;
int cost = -pq.top().first;
pq.pop();
if (vis[X][Y]) continue;
vis[X][Y] = true;
res += cost + 1;
k--;
st.push_back({X + 1, Y + 1});
for (int i = 0; i < 4; i++) {
int x2 = X + mv[i].first;
int y2 = Y + mv[i].second;
if (x2 >= 0 && x2 < n && y2 >= 0 && y2 < m && vis[x2][y2] == false) {
pq.push({-cost - 1, {x2, y2}});
}
}
}
cout << res << "\n";
sort(st.begin(), st.end());
for (int i = (int)st.size() - 1; i >= 0; i--) {
int curX = 1, curY = 1;
int x = st[i].first, y = st[i].second;
while (curX <= x && curY <= y) {
printf("(%d,%d) ", curX, curY);
if (curX < x) {
curX++;
} else if (curY < y) {
curY++;
} else {
break;
}
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int rr[] = {0, 0, -1, 1};
int cc[] = {1, -1, 0, 0};
int n, m, cnt = 1;
struct point {
int a, b, k;
};
vector<point> order;
pair<int, int> par[55][55];
int grid[55][55];
void bfs(int k) {
grid[0][0] = cnt++;
point p, s;
p.a = 0;
p.b = 0;
p.k = 1;
par[0][0] = make_pair(-1, -1);
queue<point> q;
q.push(p);
order.push_back(p);
int u, v;
while (!q.empty()) {
if (cnt > k) return;
p = q.front();
for (int i = 0; i < 4; i++) {
u = p.a + rr[i];
v = p.b + cc[i];
if (u < 0 || v < 0 || u >= n || v >= m) continue;
if (!grid[u][v]) {
s.a = u;
s.b = v;
s.k = cnt++;
q.push(s);
order.push_back(s);
grid[u][v] = grid[p.a][p.b] + 1;
par[u][v] = make_pair(p.a, p.b);
if (cnt > k) return;
}
}
q.pop();
}
return;
}
void find_path(int x, int y) {
if (par[x][y].first == -1) {
cout << "(" << 1 << "," << 1 << ") ";
return;
}
find_path(par[x][y].first, par[x][y].second);
cout << "(" << x + 1 << "," << y + 1 << ") ";
return;
}
bool comp(point a, point b) { return a.k > b.k; }
int main() {
int t, k, cas = 1, len;
cin >> n >> m >> k;
bfs(k);
len = 0;
sort(order.begin(), order.end(), comp);
t = order.size();
for (int i = 0; i < t; i++) len += (grid[order[i].a][order[i].b]);
cout << len << endl;
for (int i = 0; i < t; i++) {
find_path(order[i].a, order[i].b);
cout << endl;
}
return 0;
}
|
### Prompt
Develop a solution in cpp to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int rr[] = {0, 0, -1, 1};
int cc[] = {1, -1, 0, 0};
int n, m, cnt = 1;
struct point {
int a, b, k;
};
vector<point> order;
pair<int, int> par[55][55];
int grid[55][55];
void bfs(int k) {
grid[0][0] = cnt++;
point p, s;
p.a = 0;
p.b = 0;
p.k = 1;
par[0][0] = make_pair(-1, -1);
queue<point> q;
q.push(p);
order.push_back(p);
int u, v;
while (!q.empty()) {
if (cnt > k) return;
p = q.front();
for (int i = 0; i < 4; i++) {
u = p.a + rr[i];
v = p.b + cc[i];
if (u < 0 || v < 0 || u >= n || v >= m) continue;
if (!grid[u][v]) {
s.a = u;
s.b = v;
s.k = cnt++;
q.push(s);
order.push_back(s);
grid[u][v] = grid[p.a][p.b] + 1;
par[u][v] = make_pair(p.a, p.b);
if (cnt > k) return;
}
}
q.pop();
}
return;
}
void find_path(int x, int y) {
if (par[x][y].first == -1) {
cout << "(" << 1 << "," << 1 << ") ";
return;
}
find_path(par[x][y].first, par[x][y].second);
cout << "(" << x + 1 << "," << y + 1 << ") ";
return;
}
bool comp(point a, point b) { return a.k > b.k; }
int main() {
int t, k, cas = 1, len;
cin >> n >> m >> k;
bfs(k);
len = 0;
sort(order.begin(), order.end(), comp);
t = order.size();
for (int i = 0; i < t; i++) len += (grid[order[i].a][order[i].b]);
cout << len << endl;
for (int i = 0; i < t; i++) {
find_path(order[i].a, order[i].b);
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > start;
for (int i = 1; i <= n; i++) start.push_back(make_pair(i, 1));
for (int i = 2; i <= m; i++) start.push_back(make_pair(n, i));
vector<pair<int, int> > move[2505];
int total = 0;
int row = 1, col = 1, idx = 1;
for (int i = 0; i < k; i++) {
for (int r = 1; r <= row; r++) move[i].push_back(make_pair(r, 1));
for (int c = 2; c <= col; c++) move[i].push_back(make_pair(row, c));
total += row + col - 1;
if (row != 1 && col != m) {
row--;
col++;
} else {
row = start[idx].first;
col = start[idx].second;
idx++;
}
}
cout << total << "\n";
for (int i = k - 1; i >= 0; i--) {
for (int j = 0; j < move[i].size(); j++)
cout << "(" << move[i][j].first << "," << move[i][j].second << ")"
<< " ";
cout << "\n";
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<pair<int, int> > start;
for (int i = 1; i <= n; i++) start.push_back(make_pair(i, 1));
for (int i = 2; i <= m; i++) start.push_back(make_pair(n, i));
vector<pair<int, int> > move[2505];
int total = 0;
int row = 1, col = 1, idx = 1;
for (int i = 0; i < k; i++) {
for (int r = 1; r <= row; r++) move[i].push_back(make_pair(r, 1));
for (int c = 2; c <= col; c++) move[i].push_back(make_pair(row, c));
total += row + col - 1;
if (row != 1 && col != m) {
row--;
col++;
} else {
row = start[idx].first;
col = start[idx].second;
idx++;
}
}
cout << total << "\n";
for (int i = k - 1; i >= 0; i--) {
for (int j = 0; j < move[i].size(); j++)
cout << "(" << move[i][j].first << "," << move[i][j].second << ")"
<< " ";
cout << "\n";
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, tot, len;
int a[60][60];
vector<pair<int, int> > vec;
vector<pair<int, int> > ans[3600];
int main() {
scanf("%d%d%d", &n, &m, &k);
int tmpk = k;
for (int sum = 2; sum <= n + m && tmpk; sum++) {
for (int i = 1; i <= n && tmpk > 0; i++) {
int j = sum - i;
if (j >= 1 && j <= m) {
tmpk--;
a[i][j] = 1;
vec.push_back(pair<int, int>(i, j));
}
}
}
reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
int x = vec[i].first;
int y = vec[i].second;
for (int j = 1; j <= y; j++) ans[i].push_back(pair<int, int>(1, j)), tot++;
for (int j = 2; j <= x; j++) ans[i].push_back(pair<int, int>(j, y)), tot++;
}
printf("%d\n", tot);
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < ans[i].size(); j++)
printf("(%d,%d) ", ans[i][j].first, ans[i][j].second);
printf("\n");
}
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, tot, len;
int a[60][60];
vector<pair<int, int> > vec;
vector<pair<int, int> > ans[3600];
int main() {
scanf("%d%d%d", &n, &m, &k);
int tmpk = k;
for (int sum = 2; sum <= n + m && tmpk; sum++) {
for (int i = 1; i <= n && tmpk > 0; i++) {
int j = sum - i;
if (j >= 1 && j <= m) {
tmpk--;
a[i][j] = 1;
vec.push_back(pair<int, int>(i, j));
}
}
}
reverse(vec.begin(), vec.end());
for (int i = 0; i < vec.size(); i++) {
int x = vec[i].first;
int y = vec[i].second;
for (int j = 1; j <= y; j++) ans[i].push_back(pair<int, int>(1, j)), tot++;
for (int j = 2; j <= x; j++) ans[i].push_back(pair<int, int>(j, y)), tot++;
}
printf("%d\n", tot);
for (int i = 0; i < vec.size(); i++) {
for (int j = 0; j < ans[i].size(); j++)
printf("(%d,%d) ", ans[i][j].first, ans[i][j].second);
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<vector<bool>> V(n, vector<bool>(m));
int result = 0;
vector<pair<int, int>> nodes;
for (int i = 0; i < k; i++) {
pair<int, int> start{0, 0};
deque<pair<int, int>> Q{start};
int length = 1;
while (!Q.empty()) {
set<pair<int, int>> S;
while (!Q.empty()) {
pair<int, int> curr = Q.front();
Q.pop_front();
if (V[curr.first][curr.second] == 0) {
V[curr.first][curr.second] = 1;
result += length;
nodes.push_back(curr);
S.clear();
break;
}
if (curr.second + 1 < m) S.emplace(curr.first, curr.second + 1);
if (curr.first + 1 < n) S.emplace(curr.first + 1, curr.second);
}
length++;
Q.assign(S.begin(), S.end());
}
}
reverse(nodes.begin(), nodes.end());
cout << result << endl;
for (pair<int, int> curr : nodes) {
for (int j = 0; j <= curr.first; j++) printf("(%d, %d) ", j + 1, 1);
for (int j = 1; j <= curr.second; j++)
printf("(%d, %d) ", curr.first + 1, j + 1);
cout << endl;
}
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> m >> k;
vector<vector<bool>> V(n, vector<bool>(m));
int result = 0;
vector<pair<int, int>> nodes;
for (int i = 0; i < k; i++) {
pair<int, int> start{0, 0};
deque<pair<int, int>> Q{start};
int length = 1;
while (!Q.empty()) {
set<pair<int, int>> S;
while (!Q.empty()) {
pair<int, int> curr = Q.front();
Q.pop_front();
if (V[curr.first][curr.second] == 0) {
V[curr.first][curr.second] = 1;
result += length;
nodes.push_back(curr);
S.clear();
break;
}
if (curr.second + 1 < m) S.emplace(curr.first, curr.second + 1);
if (curr.first + 1 < n) S.emplace(curr.first + 1, curr.second);
}
length++;
Q.assign(S.begin(), S.end());
}
}
reverse(nodes.begin(), nodes.end());
cout << result << endl;
for (pair<int, int> curr : nodes) {
for (int j = 0; j <= curr.first; j++) printf("(%d, %d) ", j + 1, 1);
for (int j = 1; j <= curr.second; j++)
printf("(%d, %d) ", curr.first + 1, j + 1);
cout << endl;
}
}
```
|
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
int n, m, k;
int i;
int nowx, nowy, xx, yy, ans;
int x[2510], y[2510];
scanf("%d%d%d", &n, &m, &k);
nowx = nowy = 1;
xx = 1;
yy = 1;
ans = 0;
for (i = 1; i <= k; ++i) {
x[i] = nowx;
y[i] = nowy;
ans += nowx + nowy - 1;
if (nowy == 1 || nowx == n) {
nowx = 1;
nowy = ++yy;
} else {
nowx++;
nowy--;
}
if (nowy > m) {
nowy = m;
nowx = ++xx;
}
}
printf("%d\n", ans);
for (i = k; i >= 1; --i) {
nowx = nowy = 1;
while (nowx != x[i]) {
printf("(%d,%d) ", nowx, nowy);
nowx++;
}
while (nowy != y[i]) {
printf("(%d,%d) ", nowx, nowy);
nowy++;
}
printf("(%d,%d)\n", x[i], y[i]);
}
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
int main(int argc, char *argv[]) {
int n, m, k;
int i;
int nowx, nowy, xx, yy, ans;
int x[2510], y[2510];
scanf("%d%d%d", &n, &m, &k);
nowx = nowy = 1;
xx = 1;
yy = 1;
ans = 0;
for (i = 1; i <= k; ++i) {
x[i] = nowx;
y[i] = nowy;
ans += nowx + nowy - 1;
if (nowy == 1 || nowx == n) {
nowx = 1;
nowy = ++yy;
} else {
nowx++;
nowy--;
}
if (nowy > m) {
nowy = m;
nowx = ++xx;
}
}
printf("%d\n", ans);
for (i = k; i >= 1; --i) {
nowx = nowy = 1;
while (nowx != x[i]) {
printf("(%d,%d) ", nowx, nowy);
nowx++;
}
while (nowy != y[i]) {
printf("(%d,%d) ", nowx, nowy);
nowy++;
}
printf("(%d,%d)\n", x[i], y[i]);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
void print1(vector<int> &v) {
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = v[i] - 1; j >= 0; j--) {
for (int ii = 0; ii < i; ii++) cout << "(" << ii + 1 << ", " << 1 << ") ";
for (int jj = 0; jj <= j; jj++)
cout << "(" << i + 1 << ", " << jj + 1 << ") ";
cout << endl;
}
}
}
void print2(vector<int> &v) {
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = v[i] - 1; j >= 0; j--) {
for (int ii = 0; ii < i; ii++) cout << "(" << 1 << ", " << ii + 1 << ") ";
for (int jj = 0; jj <= j; jj++)
cout << "(" << jj + 1 << ", " << i + 1 << ") ";
cout << endl;
}
}
}
int main() {
int n, m, k, l, t;
cin >> n >> m >> k;
vector<int> v;
if (n <= m) {
if (k <= (1 + n) * n / 2) {
l = (sqrt(1 + 8 * k) - 1) / 2;
t = k - (1 + l) * l / 2;
for (int i = 0; i < l; i++) {
int j = (t-- > 0) ? l - i + 1 : l - i;
v.push_back(j);
}
} else if (k <= (1 + n) * n / 2 + (m - n) * n) {
l = (k - (1 + n) * n / 2) / n;
t = k - (1 + n) * n / 2 - l * n;
for (int i = 0; i < n; i++) {
int j = (t-- > 0) ? n - i + l + 1 : n - i + l;
v.push_back(j);
}
} else {
k -= (1 + n) * n / 2 + (m - n) * n;
l = (2 * n - 1 - sqrt((2 * n - 1) * (2 * n - 1) - 8 * k)) / 2;
t = k - (n - 1 + n - l) * l / 2;
for (int i = 0; i < n; i++) v.push_back(m - i);
int ii;
for (int i = n - 1; i >= 0; i--) {
if (v[i] + l < m) {
v[i] += l;
ii = i;
} else
v[i] = m;
}
while (t-- > 0) v[ii++]++;
}
int sum = 0;
for (int i = 0; i < v.size(); i++) sum += i * v[i] + (1 + v[i]) * v[i] / 2;
cout << sum << endl;
print1(v);
} else {
if (k <= (1 + m) * m / 2) {
l = (sqrt(1 + 8 * k) - 1) / 2;
t = k - (1 + l) * l / 2;
for (int i = 0; i < l; i++) {
int j = (t-- > 0) ? l - i + 1 : l - i;
v.push_back(j);
}
} else if (k <= (1 + m) * m / 2 + (n - m) * m) {
l = (k - (1 + m) * m / 2) / m;
t = k - (1 + m) * m / 2 - l * m;
for (int i = 0; i < m; i++) {
int j = (t-- > 0) ? m - i + l + 1 : m - i + l;
v.push_back(j);
}
} else {
k -= (1 + m) * m / 2 + (n - m) * m;
l = (2 * n - 1 - sqrt((2 * m - 1) * (2 * m - 1) - 8 * k)) / 2;
t = k - (m - 1 + m - l) * l / 2;
for (int i = 0; i < m; i++) v.push_back(n - i);
int ii;
for (int i = m - 1; i >= 0; i--) {
if (v[i] + l < n) {
v[i] += l;
ii = i;
} else
v[i] = n;
}
while (t-- > 0) v[ii++]++;
}
int sum = 0;
for (int i = 0; i < v.size(); i++) sum += i * v[i] + (1 + v[i]) * v[i] / 2;
cout << sum << endl;
print2(v);
}
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void print1(vector<int> &v) {
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = v[i] - 1; j >= 0; j--) {
for (int ii = 0; ii < i; ii++) cout << "(" << ii + 1 << ", " << 1 << ") ";
for (int jj = 0; jj <= j; jj++)
cout << "(" << i + 1 << ", " << jj + 1 << ") ";
cout << endl;
}
}
}
void print2(vector<int> &v) {
for (int i = v.size() - 1; i >= 0; i--) {
for (int j = v[i] - 1; j >= 0; j--) {
for (int ii = 0; ii < i; ii++) cout << "(" << 1 << ", " << ii + 1 << ") ";
for (int jj = 0; jj <= j; jj++)
cout << "(" << jj + 1 << ", " << i + 1 << ") ";
cout << endl;
}
}
}
int main() {
int n, m, k, l, t;
cin >> n >> m >> k;
vector<int> v;
if (n <= m) {
if (k <= (1 + n) * n / 2) {
l = (sqrt(1 + 8 * k) - 1) / 2;
t = k - (1 + l) * l / 2;
for (int i = 0; i < l; i++) {
int j = (t-- > 0) ? l - i + 1 : l - i;
v.push_back(j);
}
} else if (k <= (1 + n) * n / 2 + (m - n) * n) {
l = (k - (1 + n) * n / 2) / n;
t = k - (1 + n) * n / 2 - l * n;
for (int i = 0; i < n; i++) {
int j = (t-- > 0) ? n - i + l + 1 : n - i + l;
v.push_back(j);
}
} else {
k -= (1 + n) * n / 2 + (m - n) * n;
l = (2 * n - 1 - sqrt((2 * n - 1) * (2 * n - 1) - 8 * k)) / 2;
t = k - (n - 1 + n - l) * l / 2;
for (int i = 0; i < n; i++) v.push_back(m - i);
int ii;
for (int i = n - 1; i >= 0; i--) {
if (v[i] + l < m) {
v[i] += l;
ii = i;
} else
v[i] = m;
}
while (t-- > 0) v[ii++]++;
}
int sum = 0;
for (int i = 0; i < v.size(); i++) sum += i * v[i] + (1 + v[i]) * v[i] / 2;
cout << sum << endl;
print1(v);
} else {
if (k <= (1 + m) * m / 2) {
l = (sqrt(1 + 8 * k) - 1) / 2;
t = k - (1 + l) * l / 2;
for (int i = 0; i < l; i++) {
int j = (t-- > 0) ? l - i + 1 : l - i;
v.push_back(j);
}
} else if (k <= (1 + m) * m / 2 + (n - m) * m) {
l = (k - (1 + m) * m / 2) / m;
t = k - (1 + m) * m / 2 - l * m;
for (int i = 0; i < m; i++) {
int j = (t-- > 0) ? m - i + l + 1 : m - i + l;
v.push_back(j);
}
} else {
k -= (1 + m) * m / 2 + (n - m) * m;
l = (2 * n - 1 - sqrt((2 * m - 1) * (2 * m - 1) - 8 * k)) / 2;
t = k - (m - 1 + m - l) * l / 2;
for (int i = 0; i < m; i++) v.push_back(n - i);
int ii;
for (int i = m - 1; i >= 0; i--) {
if (v[i] + l < n) {
v[i] += l;
ii = i;
} else
v[i] = n;
}
while (t-- > 0) v[ii++]++;
}
int sum = 0;
for (int i = 0; i < v.size(); i++) sum += i * v[i] + (1 + v[i]) * v[i] / 2;
cout << sum << endl;
print2(v);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int mod = 1e9 + 7;
int n, m, k, ans, x, y;
vector<pair<int, pair<int, int> > > all;
bool used[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
all.push_back(make_pair(i + j, make_pair(i, j)));
sort(all.begin(), all.end());
for (int i = 0; i < k; i++) {
ans += (all[i].second.first + all[i].second.second - 1);
used[all[i].second.first][all[i].second.second] = 1;
}
cout << ans << endl;
while (k--) {
pair<int, int> last;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (used[i][j]) last = make_pair(i, j);
used[last.first][last.second] = 0;
for (int i = 1; i <= last.first; i++) cout << "(" << i << ",1) ";
for (int j = 2; j <= last.second; j++)
cout << "(" << last.first << "," << j << ") ";
cout << endl;
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100;
const int mod = 1e9 + 7;
int n, m, k, ans, x, y;
vector<pair<int, pair<int, int> > > all;
bool used[N][N];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
all.push_back(make_pair(i + j, make_pair(i, j)));
sort(all.begin(), all.end());
for (int i = 0; i < k; i++) {
ans += (all[i].second.first + all[i].second.second - 1);
used[all[i].second.first][all[i].second.second] = 1;
}
cout << ans << endl;
while (k--) {
pair<int, int> last;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
if (used[i][j]) last = make_pair(i, j);
used[last.first][last.second] = 0;
for (int i = 1; i <= last.first; i++) cout << "(" << i << ",1) ";
for (int j = 2; j <= last.second; j++)
cout << "(" << last.first << "," << j << ") ";
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 1e6 + 5;
const double eps = 1e-9;
using namespace std;
int a[MAXN];
int main() {
int n, m, k;
scanf("%d", &(n)), scanf("%d", &(m)), scanf("%d", &(k));
for (int i = 0; i < m * n; i++) a[i] = i + 1;
sort(a, a + m * n, [&m](int lhs, int rhs) -> bool {
return (((lhs - 1) / m + 1) + ((lhs - 1) % m + 1)) <
(((rhs - 1) / m + 1) + ((rhs - 1) % m + 1));
});
int ans = 0;
for (int i = k - 1; i >= 0; i--)
ans += ((a[i] - 1) / m) + ((a[i] - 1) % m + 1);
printf("%d\n", (ans));
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j < ((a[i] - 1) % m + 1); j++) printf("(1, %d) ", j);
for (int j = 1; j <= ((a[i] - 1) / m + 1); j++)
printf("(%d, %d) ", j, ((a[i] - 1) % m + 1));
printf("\n");
}
return 0;
}
|
### Prompt
Construct a Cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
const double pi = acos(-1);
const int MOD = 1e9 + 7;
const int INF = 1e9 + 7;
const int MAXN = 1e6 + 5;
const double eps = 1e-9;
using namespace std;
int a[MAXN];
int main() {
int n, m, k;
scanf("%d", &(n)), scanf("%d", &(m)), scanf("%d", &(k));
for (int i = 0; i < m * n; i++) a[i] = i + 1;
sort(a, a + m * n, [&m](int lhs, int rhs) -> bool {
return (((lhs - 1) / m + 1) + ((lhs - 1) % m + 1)) <
(((rhs - 1) / m + 1) + ((rhs - 1) % m + 1));
});
int ans = 0;
for (int i = k - 1; i >= 0; i--)
ans += ((a[i] - 1) / m) + ((a[i] - 1) % m + 1);
printf("%d\n", (ans));
for (int i = k - 1; i >= 0; i--) {
for (int j = 1; j < ((a[i] - 1) % m + 1); j++) printf("(1, %d) ", j);
for (int j = 1; j <= ((a[i] - 1) / m + 1); j++)
printf("(%d, %d) ", j, ((a[i] - 1) % m + 1));
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
inline int log(const char *format, ...) { return 0; }
const double EPS = 10e-8;
const int MAX = 1000;
const int INF = 1 << 30;
bool compare(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first + a.second - 1) < (b.first + b.second - 1);
}
int main(int argc, char **argv) {
int n, m, k;
vector<pair<int, int> > points;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) points.push_back(make_pair(i, j));
sort(points.begin(), points.end(), compare);
int cost = 0;
for (int i = k - 1; i >= 0; i--) {
int r = points[i].first;
int c = points[i].second;
cost += (r + 1) + (c + 1) - 1;
}
printf("%d\n", cost);
for (int i = k - 1; i >= 0; i--) {
int r = 0, c = 0;
while (r <= points[i].first) {
printf("(%d,%d)", r + 1, c + 1);
if (r < points[i].first) printf(" ");
r++;
}
r--;
c++;
if (c <= points[i].second) printf(" ");
while (c <= points[i].second) {
printf("(%d,%d)", r + 1, c + 1);
if (c < points[i].second) printf(" ");
c++;
}
printf("\n");
}
return EXIT_SUCCESS;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
inline int log(const char *format, ...) { return 0; }
const double EPS = 10e-8;
const int MAX = 1000;
const int INF = 1 << 30;
bool compare(const pair<int, int> &a, const pair<int, int> &b) {
return (a.first + a.second - 1) < (b.first + b.second - 1);
}
int main(int argc, char **argv) {
int n, m, k;
vector<pair<int, int> > points;
scanf("%d %d %d", &n, &m, &k);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) points.push_back(make_pair(i, j));
sort(points.begin(), points.end(), compare);
int cost = 0;
for (int i = k - 1; i >= 0; i--) {
int r = points[i].first;
int c = points[i].second;
cost += (r + 1) + (c + 1) - 1;
}
printf("%d\n", cost);
for (int i = k - 1; i >= 0; i--) {
int r = 0, c = 0;
while (r <= points[i].first) {
printf("(%d,%d)", r + 1, c + 1);
if (r < points[i].first) printf(" ");
r++;
}
r--;
c++;
if (c <= points[i].second) printf(" ");
while (c <= points[i].second) {
printf("(%d,%d)", r + 1, c + 1);
if (c < points[i].second) printf(" ");
c++;
}
printf("\n");
}
return EXIT_SUCCESS;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
string tostring(int x) {
string ret;
while (x) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
string getpath(int x, int y) {
string ret;
int sx = 1, sy = 1;
cnt++;
ret += "(" + tostring(1) + "," + tostring(1) + ") ";
while (sx < x) {
ret += "(" + tostring(sx + 1) + "," + tostring(sy) + ") ";
sx++;
cnt++;
}
while (sy < y) {
ret += "(" + tostring(sx) + "," + tostring(sy + 1) + ") ";
sy++;
cnt++;
}
return ret;
}
bool valid(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
vector<pair<int, int> > build() {
vector<pair<int, int> > ret;
for (int j = 1; j <= m; j++) {
int i = 1, jj = j;
ret.push_back({i, jj});
while (valid(i + 1, jj - 1)) {
i += 1;
jj -= 1;
ret.push_back({i, jj});
}
}
for (int i = 2; i <= n; i++) {
int j = m, ii = i;
ret.push_back({ii, j});
while (valid(ii + 1, j - 1)) {
ii += 1;
j -= 1;
ret.push_back({ii, j});
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k;
cin >> n >> m >> k;
vector<pair<int, int> > v = build();
vector<string> ans;
for (int i = 0; i < k; i++) {
ans.push_back(getpath(v[i].first, v[i].second));
}
reverse(ans.begin(), ans.end());
cout << cnt << endl;
for (auto s : ans) cout << s << endl;
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, cnt = 0;
string tostring(int x) {
string ret;
while (x) {
ret += (x % 10) + '0';
x /= 10;
}
reverse(ret.begin(), ret.end());
return ret;
}
string getpath(int x, int y) {
string ret;
int sx = 1, sy = 1;
cnt++;
ret += "(" + tostring(1) + "," + tostring(1) + ") ";
while (sx < x) {
ret += "(" + tostring(sx + 1) + "," + tostring(sy) + ") ";
sx++;
cnt++;
}
while (sy < y) {
ret += "(" + tostring(sx) + "," + tostring(sy + 1) + ") ";
sy++;
cnt++;
}
return ret;
}
bool valid(int x, int y) { return x >= 1 && x <= n && y >= 1 && y <= m; }
vector<pair<int, int> > build() {
vector<pair<int, int> > ret;
for (int j = 1; j <= m; j++) {
int i = 1, jj = j;
ret.push_back({i, jj});
while (valid(i + 1, jj - 1)) {
i += 1;
jj -= 1;
ret.push_back({i, jj});
}
}
for (int i = 2; i <= n; i++) {
int j = m, ii = i;
ret.push_back({ii, j});
while (valid(ii + 1, j - 1)) {
ii += 1;
j -= 1;
ret.push_back({ii, j});
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int k;
cin >> n >> m >> k;
vector<pair<int, int> > v = build();
vector<string> ans;
for (int i = 0; i < k; i++) {
ans.push_back(getpath(v[i].first, v[i].second));
}
reverse(ans.begin(), ans.end());
cout << cnt << endl;
for (auto s : ans) cout << s << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(2550);
vector<pair<int, int> > a[MAXN];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int now = 0, sum = 0;
for (int t = 1; t <= m; t++) {
if (now == k) break;
for (int i = 1, j = t; j >= 1 && i <= n; i++, j--) {
if (now == k) break;
for (int r = 1; r <= i; r++) a[now].push_back(pair<int, int>(r, 1));
for (int c = 2; c <= j; c++) a[now].push_back(pair<int, int>(i, c));
sum += a[now].size();
now++;
}
}
for (int t = 2; t <= n; t++) {
if (now == k) break;
for (int i = t, j = m; j >= 1 && i <= n; i++, j--) {
if (now == k) break;
for (int r = 1; r <= i; r++) a[now].push_back(pair<int, int>(r, 1));
for (int c = 2; c <= j; c++) a[now].push_back(pair<int, int>(i, c));
sum += a[now].size();
now++;
}
}
printf("%d\n", sum);
for (int i = now - 1; i >= 0; i--) {
for (int j = 0; j < a[i].size(); j++) {
if (j > 0) printf(" ");
printf("(%d,%d)", a[i][j].first, a[i][j].second);
}
printf("\n");
}
}
|
### Prompt
Please create a solution in CPP to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD(1000000007);
const int INF((1 << 30) - 1);
const int MAXN(2550);
vector<pair<int, int> > a[MAXN];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int now = 0, sum = 0;
for (int t = 1; t <= m; t++) {
if (now == k) break;
for (int i = 1, j = t; j >= 1 && i <= n; i++, j--) {
if (now == k) break;
for (int r = 1; r <= i; r++) a[now].push_back(pair<int, int>(r, 1));
for (int c = 2; c <= j; c++) a[now].push_back(pair<int, int>(i, c));
sum += a[now].size();
now++;
}
}
for (int t = 2; t <= n; t++) {
if (now == k) break;
for (int i = t, j = m; j >= 1 && i <= n; i++, j--) {
if (now == k) break;
for (int r = 1; r <= i; r++) a[now].push_back(pair<int, int>(r, 1));
for (int c = 2; c <= j; c++) a[now].push_back(pair<int, int>(i, c));
sum += a[now].size();
now++;
}
}
printf("%d\n", sum);
for (int i = now - 1; i >= 0; i--) {
for (int j = 0; j < a[i].size(); j++) {
if (j > 0) printf(" ");
printf("(%d,%d)", a[i][j].first, a[i][j].second);
}
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > points;
int totmoves;
bool comp(pair<int, int> x, pair<int, int> y) {
return (x.first + x.second < y.first + y.second);
}
void printPath(int x, int y) {
for (int i = 1; i < x; i++) {
cout << '(' << i << ",1) ";
}
for (int i = 1; i <= y; i++) {
cout << '(' << x << ',' << i << ") ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
points.push_back({i, j});
}
}
sort(points.begin(), points.end(), comp);
for (int i = 0; i < k; i++) {
totmoves += (points[i].first + points[i].second - 1);
}
cout << totmoves << '\n';
for (int i = k - 1; i > -1; i--) {
printPath(points[i].first, points[i].second);
}
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > points;
int totmoves;
bool comp(pair<int, int> x, pair<int, int> y) {
return (x.first + x.second < y.first + y.second);
}
void printPath(int x, int y) {
for (int i = 1; i < x; i++) {
cout << '(' << i << ",1) ";
}
for (int i = 1; i <= y; i++) {
cout << '(' << x << ',' << i << ") ";
}
cout << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, m, k;
cin >> n >> m >> k;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
points.push_back({i, j});
}
}
sort(points.begin(), points.end(), comp);
for (int i = 0; i < k; i++) {
totmoves += (points[i].first + points[i].second - 1);
}
cout << totmoves << '\n';
for (int i = k - 1; i > -1; i--) {
printPath(points[i].first, points[i].second);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double EPS = 1e-7;
const int MAX_RC = 50;
struct Point {
int r, c;
};
bool cmp(Point a, Point b) {
int dista = a.r + a.c;
int distb = b.r + b.c;
if (dista != distb) return dista < distb;
if (a.c != b.c) return a.c < b.c;
return a.r < b.r;
}
bool cmp2(Point a, Point b) {
if (a.c != b.c) return a.c > b.c;
return a.r > b.r;
}
vector<Point> allPoints;
vector<Point> ans;
void printPath(Point x) {
vector<Point> path;
Point curr = (Point){0, 0};
path.push_back(curr);
while (!(curr.r == x.r && curr.c == x.c)) {
if (curr.c != x.c)
curr.c++;
else
curr.r++;
path.push_back(curr);
}
for (int(i) = 0, (_batas) = (((int)(path).size())); (i) < (_batas); (i)++) {
printf("(%d,%d)", path[i].r + 1, path[i].c + 1);
if (i < ((int)(path).size()) - 1) printf(" ");
}
puts("");
}
int main() {
int N, M, K;
scanf("%d %d %d", &N, &M, &K);
allPoints.reserve(N * M);
for (int(i) = 0, (_batas) = (N); (i) < (_batas); (i)++)
for (int(j) = 0, (_batas) = (M); (j) < (_batas); (j)++)
allPoints.push_back((Point){i, j});
sort(allPoints.begin(), allPoints.end(), cmp);
ans.resize(K);
for (int(i) = 0, (_batas) = (K); (i) < (_batas); (i)++) ans[i] = allPoints[i];
sort(ans.begin(), ans.end(), cmp2);
int cost = 0;
for (int(i) = 0, (_batas) = (((int)(ans).size())); (i) < (_batas); (i)++)
cost += ans[i].r + ans[i].c + 1;
printf("%d\n", cost);
for (int(i) = 0, (_batas) = (((int)(ans).size())); (i) < (_batas); (i)++) {
printPath(ans[i]);
}
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double EPS = 1e-7;
const int MAX_RC = 50;
struct Point {
int r, c;
};
bool cmp(Point a, Point b) {
int dista = a.r + a.c;
int distb = b.r + b.c;
if (dista != distb) return dista < distb;
if (a.c != b.c) return a.c < b.c;
return a.r < b.r;
}
bool cmp2(Point a, Point b) {
if (a.c != b.c) return a.c > b.c;
return a.r > b.r;
}
vector<Point> allPoints;
vector<Point> ans;
void printPath(Point x) {
vector<Point> path;
Point curr = (Point){0, 0};
path.push_back(curr);
while (!(curr.r == x.r && curr.c == x.c)) {
if (curr.c != x.c)
curr.c++;
else
curr.r++;
path.push_back(curr);
}
for (int(i) = 0, (_batas) = (((int)(path).size())); (i) < (_batas); (i)++) {
printf("(%d,%d)", path[i].r + 1, path[i].c + 1);
if (i < ((int)(path).size()) - 1) printf(" ");
}
puts("");
}
int main() {
int N, M, K;
scanf("%d %d %d", &N, &M, &K);
allPoints.reserve(N * M);
for (int(i) = 0, (_batas) = (N); (i) < (_batas); (i)++)
for (int(j) = 0, (_batas) = (M); (j) < (_batas); (j)++)
allPoints.push_back((Point){i, j});
sort(allPoints.begin(), allPoints.end(), cmp);
ans.resize(K);
for (int(i) = 0, (_batas) = (K); (i) < (_batas); (i)++) ans[i] = allPoints[i];
sort(ans.begin(), ans.end(), cmp2);
int cost = 0;
for (int(i) = 0, (_batas) = (((int)(ans).size())); (i) < (_batas); (i)++)
cost += ans[i].r + ans[i].c + 1;
printf("%d\n", cost);
for (int(i) = 0, (_batas) = (((int)(ans).size())); (i) < (_batas); (i)++) {
printPath(ans[i]);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int a[60];
vector<int> x, y;
int n, m, k;
int main() {
scanf("%d %d %d", &n, &m, &k);
a[0] = 1;
int i = 0, j = 0;
;
int d = 0;
int ret = 0;
while (k--) {
x.push_back(i);
y.push_back(j);
ret += d + 1;
if (!i || j == m - 1) {
i = ++d;
j = max(0, i + 1 - n);
i = min(i, n - 1);
} else {
--i;
++j;
}
}
printf("%d\n", ret);
for (int t = (int)((x).size()) - 1; t >= 0; --t) {
int a = 0;
int b = 0;
printf("(1,1) ");
while (a < x[t]) printf("(%d,%d) ", ++a + 1, b + 1);
if (b != y[t])
while (b < y[t]) printf("(%d,%d) ", a + 1, ++b + 1);
printf("\n");
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, 1, 0, -1};
int a[60];
vector<int> x, y;
int n, m, k;
int main() {
scanf("%d %d %d", &n, &m, &k);
a[0] = 1;
int i = 0, j = 0;
;
int d = 0;
int ret = 0;
while (k--) {
x.push_back(i);
y.push_back(j);
ret += d + 1;
if (!i || j == m - 1) {
i = ++d;
j = max(0, i + 1 - n);
i = min(i, n - 1);
} else {
--i;
++j;
}
}
printf("%d\n", ret);
for (int t = (int)((x).size()) - 1; t >= 0; --t) {
int a = 0;
int b = 0;
printf("(1,1) ");
while (a < x[t]) printf("(%d,%d) ", ++a + 1, b + 1);
if (b != y[t])
while (b < y[t]) printf("(%d,%d) ", a + 1, ++b + 1);
printf("\n");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> ans;
pair<int, int> cameFrom[55][55];
void printPath(int i, int j) {
vector<pair<int, int>> prt;
prt.push_back({i, j});
while (i != 1 || j != 1) {
int n_i = cameFrom[i][j].first;
int n_j = cameFrom[i][j].second;
i = n_i;
j = n_j;
prt.push_back({i, j});
}
reverse(prt.begin(), prt.end());
for (auto& ii : prt) cout << "(" << ii.first << "," << ii.second << ") ";
cout << "\n";
}
void bfs(int n, int m, int k) {
queue<pair<int, int>> st;
set<pair<int, int>> vis;
st.push({1, 1});
vis.insert({1, 1});
while (ans.size() != k) {
auto cur = st.front();
st.pop();
ans.push_back(cur);
if (vis.count({cur.first, cur.second + 1}) == 0 && cur.second + 1 <= m) {
vis.insert({cur.first, cur.second + 1});
st.push({cur.first, cur.second + 1});
cameFrom[cur.first][cur.second + 1] = cur;
}
if (vis.count({cur.first + 1, cur.second}) == 0 && cur.first + 1 <= n) {
vis.insert({cur.first + 1, cur.second});
st.push({cur.first + 1, cur.second});
cameFrom[cur.first + 1][cur.second] = cur;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
bfs(n, m, k);
reverse(ans.begin(), ans.end());
int ansP = 0;
for (auto& i : ans) ansP += (i.first - 1) + (i.second - 1) + 1;
cout << ansP << "\n";
for (auto& i : ans) printPath(i.first, i.second);
return 0;
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int>> ans;
pair<int, int> cameFrom[55][55];
void printPath(int i, int j) {
vector<pair<int, int>> prt;
prt.push_back({i, j});
while (i != 1 || j != 1) {
int n_i = cameFrom[i][j].first;
int n_j = cameFrom[i][j].second;
i = n_i;
j = n_j;
prt.push_back({i, j});
}
reverse(prt.begin(), prt.end());
for (auto& ii : prt) cout << "(" << ii.first << "," << ii.second << ") ";
cout << "\n";
}
void bfs(int n, int m, int k) {
queue<pair<int, int>> st;
set<pair<int, int>> vis;
st.push({1, 1});
vis.insert({1, 1});
while (ans.size() != k) {
auto cur = st.front();
st.pop();
ans.push_back(cur);
if (vis.count({cur.first, cur.second + 1}) == 0 && cur.second + 1 <= m) {
vis.insert({cur.first, cur.second + 1});
st.push({cur.first, cur.second + 1});
cameFrom[cur.first][cur.second + 1] = cur;
}
if (vis.count({cur.first + 1, cur.second}) == 0 && cur.first + 1 <= n) {
vis.insert({cur.first + 1, cur.second});
st.push({cur.first + 1, cur.second});
cameFrom[cur.first + 1][cur.second] = cur;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n, m, k;
cin >> n >> m >> k;
bfs(n, m, k);
reverse(ans.begin(), ans.end());
int ansP = 0;
for (auto& i : ans) ansP += (i.first - 1) + (i.second - 1) + 1;
cout << ansP << "\n";
for (auto& i : ans) printPath(i.first, i.second);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e2 + 5;
const int M = 9e6 + 5;
int maps[N][N];
void print(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,%d)", i, 1);
for (int j = 2; j <= y; j++) printf("(%d,%d)", x, j);
printf("\n");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int answer = 0;
while (k--) {
int maxx = INF, x = 0, y = 0;
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 1; j <= m; j++) {
if (maps[i][j]) {
flag = true;
continue;
}
if (maxx > i + j - 1) {
maxx = i + j - 1;
x = i, y = j;
}
if (!flag) break;
}
}
answer += maxx;
maps[x][y] = 1;
}
printf("%d\n", answer);
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (maps[i][j]) {
print(i, j);
}
}
}
}
|
### Prompt
Construct a Cpp code solution to the problem outlined:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 1e2 + 5;
const int M = 9e6 + 5;
int maps[N][N];
void print(int x, int y) {
for (int i = 1; i <= x; i++) printf("(%d,%d)", i, 1);
for (int j = 2; j <= y; j++) printf("(%d,%d)", x, j);
printf("\n");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
int answer = 0;
while (k--) {
int maxx = INF, x = 0, y = 0;
for (int i = 1; i <= n; i++) {
bool flag = false;
for (int j = 1; j <= m; j++) {
if (maps[i][j]) {
flag = true;
continue;
}
if (maxx > i + j - 1) {
maxx = i + j - 1;
x = i, y = j;
}
if (!flag) break;
}
}
answer += maxx;
maps[x][y] = 1;
}
printf("%d\n", answer);
for (int i = n; i >= 1; i--) {
for (int j = m; j >= 1; j--) {
if (maps[i][j]) {
print(i, j);
}
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long x;
long long result = 0;
vector<pair<long long, long long> > v;
for (long long l = 2; l <= n + m; l++) {
for (long long j = 1; j <= m; j++) {
if ((l - j) >= 1 && (l - j) <= n && k > 0) {
k--;
v.push_back(make_pair(l - j, j));
result += l - 1;
}
}
}
cout << result << endl;
for (int i = (long long)v.size() - 1; i >= 0; i--) {
for (long long j = 1; j <= v[i].first; j++)
cout << "(" << j << "," << 1 << ")"
<< " ";
for (long long j = 2; j <= v[i].second; j++)
cout << "(" << v[i].first << "," << j << ")"
<< " ";
cout << endl;
}
return 0;
}
|
### Prompt
Create a solution in Cpp for the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, m, k;
cin >> n >> m >> k;
long long x;
long long result = 0;
vector<pair<long long, long long> > v;
for (long long l = 2; l <= n + m; l++) {
for (long long j = 1; j <= m; j++) {
if ((l - j) >= 1 && (l - j) <= n && k > 0) {
k--;
v.push_back(make_pair(l - j, j));
result += l - 1;
}
}
}
cout << result << endl;
for (int i = (long long)v.size() - 1; i >= 0; i--) {
for (long long j = 1; j <= v[i].first; j++)
cout << "(" << j << "," << 1 << ")"
<< " ";
for (long long j = 2; j <= v[i].second; j++)
cout << "(" << v[i].first << "," << j << ")"
<< " ";
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ans = 1;
cin >> n >> m >> k;
vector<vector<pair<int, int>>> A;
A.push_back({make_pair(1, 1)});
queue<vector<pair<int, int>>> q;
q.push(A[0]);
vector<vector<bool>> vis(n + 1, vector<bool>(m + 1, 1));
vis[1][1] = 0;
while (!q.empty() && (int)A.size() < k) {
auto x = q.front(), y = x;
int sz = x.size();
auto pa = x[sz - 1];
if (pa.first < n && vis[pa.first + 1][pa.second] == 1) {
vis[pa.first + 1][pa.second] = 0;
x.push_back(make_pair(pa.first + 1, pa.second));
A.push_back(x);
ans += sz + 1;
q.push(x);
}
if (A.size() == k) break;
if (pa.second < m && vis[pa.first][pa.second + 1] == 1) {
vis[pa.first][pa.second + 1] = 0;
y.push_back(make_pair(pa.first, pa.second + 1));
A.push_back(y);
ans += sz + 1;
q.push(y);
}
q.pop();
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
for (int j = 0; j < A[i].size(); j++) {
cout << "(" << A[i][j].first << "," << A[i][j].second << ") ";
}
cout << "\n";
}
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k, ans = 1;
cin >> n >> m >> k;
vector<vector<pair<int, int>>> A;
A.push_back({make_pair(1, 1)});
queue<vector<pair<int, int>>> q;
q.push(A[0]);
vector<vector<bool>> vis(n + 1, vector<bool>(m + 1, 1));
vis[1][1] = 0;
while (!q.empty() && (int)A.size() < k) {
auto x = q.front(), y = x;
int sz = x.size();
auto pa = x[sz - 1];
if (pa.first < n && vis[pa.first + 1][pa.second] == 1) {
vis[pa.first + 1][pa.second] = 0;
x.push_back(make_pair(pa.first + 1, pa.second));
A.push_back(x);
ans += sz + 1;
q.push(x);
}
if (A.size() == k) break;
if (pa.second < m && vis[pa.first][pa.second + 1] == 1) {
vis[pa.first][pa.second + 1] = 0;
y.push_back(make_pair(pa.first, pa.second + 1));
A.push_back(y);
ans += sz + 1;
q.push(y);
}
q.pop();
}
cout << ans << endl;
for (int i = k - 1; i >= 0; i--) {
for (int j = 0; j < A[i].size(); j++) {
cout << "(" << A[i][j].first << "," << A[i][j].second << ") ";
}
cout << "\n";
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
int a[101];
int minnum(int a, int b, int c) {
int mi = 100000;
if (mi > a) mi = a;
if (mi > b) mi = b;
if (mi > c) mi = c;
return mi;
}
void p(int x, int y) {
int i, j;
for (i = 1; i <= x; i++) printf("(%d,%d)", i, 1);
for (j = 2; j <= y; j++) printf("(%d,%d)", x, j);
printf("\n");
}
int main() {
long long int ans = 0;
int mi, lay, non, lcon, i, y, x, n, m, k;
scanf("%d %d %d", &n, &m, &k);
mi = n < m ? n : m;
memset(a, 0, sizeof(a));
for (lay = 1, non = k; non > 0; lay++) {
lcon = minnum(lay, n + m - lay, mi);
if (non >= lcon) {
a[lay] = lcon;
non -= lcon;
} else {
a[lay] = non;
non = 0;
}
}
for (i = 1; i < lay; i++) ans += a[i] * i;
cout << ans << endl;
for (i = lay - 1; i >= 1; i--) {
if (i > n) {
x = n;
y = i - n + 1;
} else {
x = i;
y = 1;
}
for (; a[i] >= 1; a[i]--, x--, y++) p(x, y);
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int a[101];
int minnum(int a, int b, int c) {
int mi = 100000;
if (mi > a) mi = a;
if (mi > b) mi = b;
if (mi > c) mi = c;
return mi;
}
void p(int x, int y) {
int i, j;
for (i = 1; i <= x; i++) printf("(%d,%d)", i, 1);
for (j = 2; j <= y; j++) printf("(%d,%d)", x, j);
printf("\n");
}
int main() {
long long int ans = 0;
int mi, lay, non, lcon, i, y, x, n, m, k;
scanf("%d %d %d", &n, &m, &k);
mi = n < m ? n : m;
memset(a, 0, sizeof(a));
for (lay = 1, non = k; non > 0; lay++) {
lcon = minnum(lay, n + m - lay, mi);
if (non >= lcon) {
a[lay] = lcon;
non -= lcon;
} else {
a[lay] = non;
non = 0;
}
}
for (i = 1; i < lay; i++) ans += a[i] * i;
cout << ans << endl;
for (i = lay - 1; i >= 1; i--) {
if (i > n) {
x = n;
y = i - n + 1;
} else {
x = i;
y = 1;
}
for (; a[i] >= 1; a[i]--, x--, y++) p(x, y);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct de {
int x, y;
} s[25010];
bool cmp(de a, de b) { return a.x + a.y < b.x + b.y; }
int main() {
int w = 0;
int n, m, k, i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
s[w].x = i;
s[w].y = j;
w++;
}
sort(s, s + w, cmp);
int ans = 0;
for (i = k - 1; i >= 0; i--) {
ans = ans + s[i].x - 1 + s[i].y;
}
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
for (j = 1; j < s[i].y; j++) printf("(1,%d) ", j);
for (j = 1; j <= s[i].x; j++) printf("(%d,%d) ", j, s[i].y);
printf("\n");
}
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct de {
int x, y;
} s[25010];
bool cmp(de a, de b) { return a.x + a.y < b.x + b.y; }
int main() {
int w = 0;
int n, m, k, i, j;
scanf("%d%d%d", &n, &m, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
s[w].x = i;
s[w].y = j;
w++;
}
sort(s, s + w, cmp);
int ans = 0;
for (i = k - 1; i >= 0; i--) {
ans = ans + s[i].x - 1 + s[i].y;
}
printf("%d\n", ans);
for (i = k - 1; i >= 0; i--) {
for (j = 1; j < s[i].y; j++) printf("(1,%d) ", j);
for (j = 1; j <= s[i].x; j++) printf("(%d,%d) ", j, s[i].y);
printf("\n");
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
void step(pair<int, int> a) {
int x = a.first, y = a.second;
printf("(1,1)");
for (int i = 2; i <= x; i++) printf(" (%d,1)", i);
for (int i = 2; i <= y; i++) printf(" (%d,%d)", x, i);
puts("");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long cnt = 0;
for (int i = 1; i <= min(n, m) - 1; i++) {
if (!k) break;
for (int j = 1; j <= i; j++) {
if (!k) break;
ans.push_back(make_pair(i + 1 - j, j));
k--;
cnt += i;
}
}
for (int i = 1; i <= abs(n - m) + 1; i++) {
if (!k) break;
for (int j = 1; j <= min(n, m); j++) {
if (!k) break;
if (n > m)
ans.push_back(make_pair(i + m - j, j));
else
ans.push_back(make_pair(n + 1 - j, i + j - 1));
k--;
cnt += (min(n, m) + i - 1);
}
}
for (int i = 1; i <= min(n, m) - 1; i++) {
if (!k) break;
for (int j = 1; j <= min(n, m) - i; j++) {
if (!k) break;
ans.push_back(make_pair(n + 1 - j, m - min(n, m) + i + j));
k--;
cnt += (max(n, m) + i);
}
}
printf("%d\n", cnt);
while (!ans.empty()) {
step(ans.back());
ans.pop_back();
}
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Inna loves sweets very much. That's why she decided to play a game called "Sweet Matrix".
Inna sees an n × m matrix and k candies. We'll index the matrix rows from 1 to n and the matrix columns from 1 to m. We'll represent the cell in the i-th row and j-th column as (i, j). Two cells (i, j) and (p, q) of the matrix are adjacent if |i - p| + |j - q| = 1. A path is a sequence of the matrix cells where each pair of neighbouring cells in the sequence is adjacent. We'll call the number of cells in the sequence the path's length.
Each cell of the matrix can have at most one candy. Initiallly, all the cells are empty. Inna is trying to place each of the k candies in the matrix one by one. For each candy Inna chooses cell (i, j) that will contains the candy, and also chooses the path that starts in cell (1, 1) and ends in cell (i, j) and doesn't contain any candies. After that Inna moves the candy along the path from cell (1, 1) to cell (i, j), where the candy stays forever. If at some moment Inna can't choose a path for the candy, she loses. If Inna can place all the candies in the matrix in the described manner, then her penalty equals the sum of lengths of all the paths she has used.
Help Inna to minimize the penalty in the game.
Input
The first line of the input contains three integers n, m and k (1 ≤ n, m ≤ 50, 1 ≤ k ≤ n·m).
Output
In the first line print an integer — Inna's minimum penalty in the game.
In the next k lines print the description of the path for each candy. The description of the path of the candy that is placed i-th should follow on the i-th line. The description of a path is a sequence of cells. Each cell must be written in the format (i, j), where i is the number of the row and j is the number of the column. You are allowed to print extra whitespaces in the line. If there are multiple optimal solutions, print any of them.
Please follow the output format strictly! If your program passes the first pretest, then the output format is correct.
Examples
Input
4 4 4
Output
8
(1,1) (2,1) (2,2)
(1,1) (1,2)
(1,1) (2,1)
(1,1)
Note
Note to the sample. Initially the matrix is empty. Then Inna follows her first path, the path penalty equals the number of cells in it — 3. Note that now no path can go through cell (2, 2), as it now contains a candy. The next two candies go to cells (1, 2) and (2, 1). Inna simply leaves the last candy at cell (1, 1), the path contains only this cell. The total penalty is: 3 + 2 + 2 + 1 = 8.
Note that Inna couldn't use cell (1, 1) to place, for instance, the third candy as in this case she couldn't have made the path for the fourth candy.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<int, int> > ans;
void step(pair<int, int> a) {
int x = a.first, y = a.second;
printf("(1,1)");
for (int i = 2; i <= x; i++) printf(" (%d,1)", i);
for (int i = 2; i <= y; i++) printf(" (%d,%d)", x, i);
puts("");
}
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
long long cnt = 0;
for (int i = 1; i <= min(n, m) - 1; i++) {
if (!k) break;
for (int j = 1; j <= i; j++) {
if (!k) break;
ans.push_back(make_pair(i + 1 - j, j));
k--;
cnt += i;
}
}
for (int i = 1; i <= abs(n - m) + 1; i++) {
if (!k) break;
for (int j = 1; j <= min(n, m); j++) {
if (!k) break;
if (n > m)
ans.push_back(make_pair(i + m - j, j));
else
ans.push_back(make_pair(n + 1 - j, i + j - 1));
k--;
cnt += (min(n, m) + i - 1);
}
}
for (int i = 1; i <= min(n, m) - 1; i++) {
if (!k) break;
for (int j = 1; j <= min(n, m) - i; j++) {
if (!k) break;
ans.push_back(make_pair(n + 1 - j, m - min(n, m) + i + j));
k--;
cnt += (max(n, m) + i);
}
}
printf("%d\n", cnt);
while (!ans.empty()) {
step(ans.back());
ans.pop_back();
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
string s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> s[i];
}
int len = s[1].length();
for (int i = 0; i < len; ++i) {
set<char> st;
for (int j = 1; j <= n; ++j) {
if (s[j][i] >= 'a' && s[j][i] <= 'z') {
st.insert(s[j][i]);
}
}
if (st.size() == 0) {
printf("a");
} else if (st.size() == 1) {
printf("%c", *st.begin());
} else {
printf("?");
}
}
printf("\n");
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s[100005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
cin >> s[i];
}
int len = s[1].length();
for (int i = 0; i < len; ++i) {
set<char> st;
for (int j = 1; j <= n; ++j) {
if (s[j][i] >= 'a' && s[j][i] <= 'z') {
st.insert(s[j][i]);
}
}
if (st.size() == 0) {
printf("a");
} else if (st.size() == 1) {
printf("%c", *st.begin());
} else {
printf("?");
}
}
printf("\n");
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, m;
char sol[100005];
string cad;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> sol;
m = strlen(sol);
for (i = 1; i < n; i++) {
cin >> cad;
for (j = 0; j < m; j++) {
if (sol[j] == '!' || cad[j] == '?' || (sol[j] == '?' && cad[j] == '?'))
continue;
if (sol[j] == '?')
sol[j] = cad[j];
else if (sol[j] != cad[j])
sol[j] = '!';
}
}
for (j = 0; j < m; j++) {
if (sol[j] == '!')
cout << '?';
else if (sol[j] == '?')
cout << 'a';
else
cout << sol[j];
}
cout << endl;
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, i, j, m;
char sol[100005];
string cad;
int main() {
ios::sync_with_stdio(false);
cin >> n;
cin >> sol;
m = strlen(sol);
for (i = 1; i < n; i++) {
cin >> cad;
for (j = 0; j < m; j++) {
if (sol[j] == '!' || cad[j] == '?' || (sol[j] == '?' && cad[j] == '?'))
continue;
if (sol[j] == '?')
sol[j] = cad[j];
else if (sol[j] != cad[j])
sol[j] = '!';
}
}
for (j = 0; j < m; j++) {
if (sol[j] == '!')
cout << '?';
else if (sol[j] == '?')
cout << 'a';
else
cout << sol[j];
}
cout << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%I64d", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
string s[100010];
int main() {
int n = nxt();
for (int i = 0; i < n; i++) cin >> s[i];
string ans;
for (int j = 0; j < s[0].length(); j++) {
char b = '*';
for (int i = 0; i < n; i++) {
if (s[i][j] == '?')
continue;
else {
if (b == '*')
b = s[i][j];
else {
if (b != s[i][j]) {
b = '?';
break;
}
}
}
}
if (b == '*')
ans += 'a';
else
ans += b;
}
cout << ans << endl;
return 0;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int dx[] = {0, 0, 1, -1, -1, -1, 1, 1};
int dy[] = {1, -1, 0, 0, -1, 1, 1, -1};
template <class T>
inline T biton(T n, T pos) {
return n | ((T)1 << pos);
}
template <class T>
inline T bitoff(T n, T pos) {
return n & ~((T)1 << pos);
}
template <class T>
inline T ison(T n, T pos) {
return (bool)(n & ((T)1 << pos));
}
template <class T>
inline T gcd(T a, T b) {
while (b) {
a %= b;
swap(a, b);
}
return a;
}
template <typename T>
string NumberToString(T Number) {
ostringstream second;
second << Number;
return second.str();
}
inline int nxt() {
int aaa;
scanf("%d", &aaa);
return aaa;
}
inline long long int lxt() {
long long int aaa;
scanf("%I64d", &aaa);
return aaa;
}
inline double dxt() {
double aaa;
scanf("%lf", &aaa);
return aaa;
}
template <class T>
inline T bigmod(T p, T e, T m) {
T ret = 1;
for (; e > 0; e >>= 1) {
if (e & 1) ret = (ret * p) % m;
p = (p * p) % m;
}
return (T)ret;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
string s[100010];
int main() {
int n = nxt();
for (int i = 0; i < n; i++) cin >> s[i];
string ans;
for (int j = 0; j < s[0].length(); j++) {
char b = '*';
for (int i = 0; i < n; i++) {
if (s[i][j] == '?')
continue;
else {
if (b == '*')
b = s[i][j];
else {
if (b != s[i][j]) {
b = '?';
break;
}
}
}
}
if (b == '*')
ans += 'a';
else
ans += b;
}
cout << ans << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
bool vis[200000];
void resolve() {
char ck[100005];
memset(ck, '#', sizeof(ck));
int n, ln;
cin >> n;
for (int i = 0; i < n; i++) {
char s[100005];
cin >> s;
ln = strlen(s);
for (int i = 0; i < ln; i++) {
if (s[i] != '?') {
if (ck[i] == '#')
ck[i] = s[i];
else if (ck[i] != s[i])
ck[i] = '?';
}
}
}
for (int i = 0; i < ln; i++) {
if (ck[i] == '#')
cout << 'z';
else
cout << ck[i];
}
cout << endl;
}
int main() {
int t;
t = 1;
while (t--) {
resolve();
}
}
|
### Prompt
In cpp, your task is to solve the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
bool vis[200000];
void resolve() {
char ck[100005];
memset(ck, '#', sizeof(ck));
int n, ln;
cin >> n;
for (int i = 0; i < n; i++) {
char s[100005];
cin >> s;
ln = strlen(s);
for (int i = 0; i < ln; i++) {
if (s[i] != '?') {
if (ck[i] == '#')
ck[i] = s[i];
else if (ck[i] != s[i])
ck[i] = '?';
}
}
}
for (int i = 0; i < ln; i++) {
if (ck[i] == '#')
cout << 'z';
else
cout << ck[i];
}
cout << endl;
}
int main() {
int t;
t = 1;
while (t--) {
resolve();
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int main() {
int n;
while (scanf("%d", &n) == 1) {
string s[n + 5];
for (int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
int len = (int)s[0].size();
string str = "";
for (int i = 0; i < len; i++) {
char ch = '?';
for (int j = n - 1; j >= 0; j--) {
if (s[j][i] != '?') {
ch = s[j][i];
break;
}
}
if (ch == '?')
str += 'a';
else {
int f = 0;
for (int j = n - 1; j >= 0; j--) {
if (s[j][i] != '?') {
if (s[j][i] != ch) {
f = 1;
break;
}
}
}
if (f) ch = '?';
str += ch;
}
}
cout << str << endl;
}
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
int main() {
int n;
while (scanf("%d", &n) == 1) {
string s[n + 5];
for (int i = 0; i < n; i++) cin >> s[i];
sort(s, s + n);
int len = (int)s[0].size();
string str = "";
for (int i = 0; i < len; i++) {
char ch = '?';
for (int j = n - 1; j >= 0; j--) {
if (s[j][i] != '?') {
ch = s[j][i];
break;
}
}
if (ch == '?')
str += 'a';
else {
int f = 0;
for (int j = n - 1; j >= 0; j--) {
if (s[j][i] != '?') {
if (s[j][i] != ch) {
f = 1;
break;
}
}
}
if (f) ch = '?';
str += ch;
}
}
cout << str << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int main() {
int n;
cin >> n;
cin >> s1;
n--;
for (int i = 0; i < n; i++) {
cin >> s2;
for (int i = 0; i < s2.size(); i++) {
if (s1[i] != s2[i]) {
if (s1[i] == '?')
s1[i] = s2[i];
else if (s2[i] == '?')
;
else
s1[i] = '#';
}
}
}
for (int i = 0; i < s1.size(); i++) {
if (s1[i] == '?')
cout << 'a';
else if (s1[i] == '#')
cout << '?';
else
cout << s1[i];
}
cout << endl;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string s1, s2;
int main() {
int n;
cin >> n;
cin >> s1;
n--;
for (int i = 0; i < n; i++) {
cin >> s2;
for (int i = 0; i < s2.size(); i++) {
if (s1[i] != s2[i]) {
if (s1[i] == '?')
s1[i] = s2[i];
else if (s2[i] == '?')
;
else
s1[i] = '#';
}
}
}
for (int i = 0; i < s1.size(); i++) {
if (s1[i] == '?')
cout << 'a';
else if (s1[i] == '#')
cout << '?';
else
cout << s1[i];
}
cout << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100 * 1000;
string s[MaxN];
bool q[26];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < (int)s[0].length(); i++) {
for (int j = 0; j < 26; j++) q[j] = false;
for (int j = 0; j < n; j++)
if (s[j][i] != '?') q[s[j][i] - 'a'] = true;
int count = 0;
for (int j = 0; j < 26; j++)
if (q[j]) count++;
if (count == 0)
printf("a");
else {
if (count == 1) {
for (int j = 0; j < 26; j++)
if (q[j]) printf("%c", char(j + 'a'));
} else
printf("?");
}
}
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 100 * 1000;
string s[MaxN];
bool q[26];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
for (int i = 0; i < (int)s[0].length(); i++) {
for (int j = 0; j < 26; j++) q[j] = false;
for (int j = 0; j < n; j++)
if (s[j][i] != '?') q[s[j][i] - 'a'] = true;
int count = 0;
for (int j = 0; j < 26; j++)
if (q[j]) count++;
if (count == 0)
printf("a");
else {
if (count == 1) {
for (int j = 0; j < 26; j++)
if (q[j]) printf("%c", char(j + 'a'));
} else
printf("?");
}
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char arr[N];
int n, k;
string s;
int main() {
while (cin >> n) {
int len = 0;
for (int i = 0; i < n; i++) {
cin >> s;
len = s.length();
if (i == 0) {
for (int j = 0; j < s.length(); j++) arr[j] = s[j];
} else {
for (int j = 0; j < s.length(); j++) {
char c = s[j];
if (arr[j] == '?') {
if (c == '?')
arr[j] = '?';
else
arr[j] = c;
} else if (arr[j] != '#') {
if (c == '?') {
} else {
if (c != arr[j]) arr[j] = '#';
}
} else {
}
}
}
}
for (int i = 0; i < len; i++) {
if (arr[i] == '?')
arr[i] = 'a';
else if (arr[i] == '#')
arr[i] = '?';
}
for (int i = 0; i < len; i++) cout << arr[i];
cout << endl;
}
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
char arr[N];
int n, k;
string s;
int main() {
while (cin >> n) {
int len = 0;
for (int i = 0; i < n; i++) {
cin >> s;
len = s.length();
if (i == 0) {
for (int j = 0; j < s.length(); j++) arr[j] = s[j];
} else {
for (int j = 0; j < s.length(); j++) {
char c = s[j];
if (arr[j] == '?') {
if (c == '?')
arr[j] = '?';
else
arr[j] = c;
} else if (arr[j] != '#') {
if (c == '?') {
} else {
if (c != arr[j]) arr[j] = '#';
}
} else {
}
}
}
}
for (int i = 0; i < len; i++) {
if (arr[i] == '?')
arr[i] = 'a';
else if (arr[i] == '#')
arr[i] = '?';
}
for (int i = 0; i < len; i++) cout << arr[i];
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n;
char a[100111];
char b[100111];
bool fix[100111];
int main() {
if (0 == 1) {
freopen("input.txt", "r", stdin);
}
scanf("%d\n", &n);
gets(a);
int m = strlen(a);
for (int i = 0; i <= m - 1; i++) fix[i] = false;
for (int i = 2; i <= n; i++) {
gets(b);
for (int j = 0; j <= m - 1; j++) {
if (a[j] == b[j]) continue;
if (a[j] == '?') {
if (fix[j]) continue;
a[j] = b[j];
continue;
}
if (b[j] == '?') {
continue;
}
a[j] = '?';
fix[j] = true;
}
}
for (int i = 0; i <= m - 1; i++)
if ((a[i] == '?') && (fix[i] == false)) a[i] = 'x';
printf("%s", a);
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
char a[100111];
char b[100111];
bool fix[100111];
int main() {
if (0 == 1) {
freopen("input.txt", "r", stdin);
}
scanf("%d\n", &n);
gets(a);
int m = strlen(a);
for (int i = 0; i <= m - 1; i++) fix[i] = false;
for (int i = 2; i <= n; i++) {
gets(b);
for (int j = 0; j <= m - 1; j++) {
if (a[j] == b[j]) continue;
if (a[j] == '?') {
if (fix[j]) continue;
a[j] = b[j];
continue;
}
if (b[j] == '?') {
continue;
}
a[j] = '?';
fix[j] = true;
}
}
for (int i = 0; i <= m - 1; i++)
if ((a[i] == '?') && (fix[i] == false)) a[i] = 'x';
printf("%s", a);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r, sa;
string s[100 * 1000 + 10], s1, s2("mamali201"), ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
ans = s[0];
for (int i = 0; i < s[0].size(); i++) {
int ok = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] != '?') {
if (ok == 0) {
s2[0] = s[j][i];
ok++;
} else if (s[j][i] != s2[0])
ok = -1;
}
if (ok == -1) ans[i] = '?';
if (ok == 1) ans[i] = s2[0];
if (ok == 0) ans[i] = 'x';
}
}
cout << ans;
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m, k, r, sa;
string s[100 * 1000 + 10], s1, s2("mamali201"), ans;
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
ans = s[0];
for (int i = 0; i < s[0].size(); i++) {
int ok = 0;
for (int j = 0; j < n; j++) {
if (s[j][i] != '?') {
if (ok == 0) {
s2[0] = s[j][i];
ok++;
} else if (s[j][i] != s2[0])
ok = -1;
}
if (ok == -1) ans[i] = '?';
if (ok == 1) ans[i] = s2[0];
if (ok == 0) ans[i] = 'x';
}
}
cout << ans;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
set<char> ss[100010];
bool searching(char c, set<char> s) {
for (typeof(s.begin()) i = s.begin(); i != s.end(); i++)
if (*i == c) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = 0;
string ch;
for (int i = 0; i < n; i++) {
cin >> ch;
for (int j = 0; j < ch.size(); j++) ss[j].insert(ch[j]);
m = max(m, (int)ch.size());
}
string ans = "";
for (int i = 0; i < m; i++) {
if (ss[i].size() == 1 && binary_search(ss[i].begin(), ss[i].end(), '?')) {
ans += 'a';
} else if (ss[i].size() == 1 ||
(ss[i].size() == 2 &&
binary_search(ss[i].begin(), ss[i].end(), '?'))) {
for (int j = 0; j < 26; j++) {
if (binary_search(ss[i].begin(), ss[i].end(), 'a' + j)) {
ans += 'a' + j;
break;
}
}
} else
ans += '?';
}
cout << ans << endl;
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
set<char> ss[100010];
bool searching(char c, set<char> s) {
for (typeof(s.begin()) i = s.begin(); i != s.end(); i++)
if (*i == c) return true;
return false;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int m = 0;
string ch;
for (int i = 0; i < n; i++) {
cin >> ch;
for (int j = 0; j < ch.size(); j++) ss[j].insert(ch[j]);
m = max(m, (int)ch.size());
}
string ans = "";
for (int i = 0; i < m; i++) {
if (ss[i].size() == 1 && binary_search(ss[i].begin(), ss[i].end(), '?')) {
ans += 'a';
} else if (ss[i].size() == 1 ||
(ss[i].size() == 2 &&
binary_search(ss[i].begin(), ss[i].end(), '?'))) {
for (int j = 0; j < 26; j++) {
if (binary_search(ss[i].begin(), ss[i].end(), 'a' + j)) {
ans += 'a' + j;
break;
}
}
} else
ans += '?';
}
cout << ans << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int n;
cin >> n;
cin >> s;
int l = s.size();
for (int x = 1; x < n; x++) {
cin >> t;
for (int i = 0; i < l; i++) {
if (s[i] == '?')
s[i] = t[i];
else if (t[i] != '?' && s[i] != t[i])
s[i] = '!';
}
}
for (int i = 0; i < l; i++) {
if (s[i] == '?')
s[i] = 'y';
else if (s[i] == '!')
s[i] = '?';
}
cout << s << endl;
}
|
### Prompt
Please create a solution in CPP to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
string s, t;
int n;
cin >> n;
cin >> s;
int l = s.size();
for (int x = 1; x < n; x++) {
cin >> t;
for (int i = 0; i < l; i++) {
if (s[i] == '?')
s[i] = t[i];
else if (t[i] != '?' && s[i] != t[i])
s[i] = '!';
}
}
for (int i = 0; i < l; i++) {
if (s[i] == '?')
s[i] = 'y';
else if (s[i] == '!')
s[i] = '?';
}
cout << s << endl;
}
```
|
#include <bits/stdc++.h>
int main(void) {
int n, i, j, l;
char a[100001], b[100001];
scanf("%d", &n);
scanf("%s", &a);
l = strlen(a);
for (i = 0; i < l; i++) {
b[i] = a[i];
}
for (i = 1; i < n; i++) {
scanf("%s", &a);
for (j = 0; j < l; j++) {
if (b[j] == '?') {
b[j] = a[j];
} else if (a[j] != b[j] && b[j] != '?' && a[j] != '?') {
b[j] = 'A';
} else if (a[j] != b[j] && a[j] == '?') {
b[j] = b[j];
}
}
}
for (i = 0; i < l; i++) {
if (b[i] == '?') {
printf("x");
} else if (b[i] == 'A') {
printf("?");
} else {
printf("%c", b[i]);
}
}
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
int main(void) {
int n, i, j, l;
char a[100001], b[100001];
scanf("%d", &n);
scanf("%s", &a);
l = strlen(a);
for (i = 0; i < l; i++) {
b[i] = a[i];
}
for (i = 1; i < n; i++) {
scanf("%s", &a);
for (j = 0; j < l; j++) {
if (b[j] == '?') {
b[j] = a[j];
} else if (a[j] != b[j] && b[j] != '?' && a[j] != '?') {
b[j] = 'A';
} else if (a[j] != b[j] && a[j] == '?') {
b[j] = b[j];
}
}
}
for (i = 0; i < l; i++) {
if (b[i] == '?') {
printf("x");
} else if (b[i] == 'A') {
printf("?");
} else {
printf("%c", b[i]);
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int INF = 1000000000 + 7;
string s[maxn];
set<char> vis;
int main() {
int n;
while (scanf("%d%d", &n) != EOF) {
for (int i = 0; i < n; i++) cin >> s[i];
int m = s[0].length();
string ans = "";
for (int i = 0; i < m; i++) {
vis.clear();
for (int j = 0; j < n; j++) {
if (s[j][i] == '?') continue;
vis.insert(s[j][i]);
}
if (vis.size() > 1) {
ans.push_back('?');
} else if (vis.size() == 1) {
ans.push_back(*vis.begin());
} else {
ans.push_back('a');
}
}
cout << ans << endl;
}
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int INF = 1000000000 + 7;
string s[maxn];
set<char> vis;
int main() {
int n;
while (scanf("%d%d", &n) != EOF) {
for (int i = 0; i < n; i++) cin >> s[i];
int m = s[0].length();
string ans = "";
for (int i = 0; i < m; i++) {
vis.clear();
for (int j = 0; j < n; j++) {
if (s[j][i] == '?') continue;
vis.insert(s[j][i]);
}
if (vis.size() > 1) {
ans.push_back('?');
} else if (vis.size() == 1) {
ans.push_back(*vis.begin());
} else {
ans.push_back('a');
}
}
cout << ans << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
class CPattern {
public:
void solve(std::istream& in, std::ostream& out) {
long long n;
in >> n;
vector<string> arr;
for (long long i = 0; i < n; i++) {
string s;
in >> s;
arr.emplace_back(s);
}
long long m = arr[0].length();
for (long long j = 0; j < m; j++) {
char c = '?';
bool ok = true;
for (long long i = 0; i < n; i++) {
if (arr[i][j] == '?') continue;
if (c == '?')
c = arr[i][j];
else if (c != arr[i][j])
ok = false;
}
if (c == '?') c = 'a';
if (ok)
out << c;
else
out << '?';
}
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CPattern solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
class CPattern {
public:
void solve(std::istream& in, std::ostream& out) {
long long n;
in >> n;
vector<string> arr;
for (long long i = 0; i < n; i++) {
string s;
in >> s;
arr.emplace_back(s);
}
long long m = arr[0].length();
for (long long j = 0; j < m; j++) {
char c = '?';
bool ok = true;
for (long long i = 0; i < n; i++) {
if (arr[i][j] == '?') continue;
if (c == '?')
c = arr[i][j];
else if (c != arr[i][j])
ok = false;
}
if (c == '?') c = 'a';
if (ok)
out << c;
else
out << '?';
}
}
};
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
CPattern solver;
std::istream& in(std::cin);
std::ostream& out(std::cout);
solver.solve(in, out);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t1, t, i, j;
cin >> t1;
t = t1;
vector<string> data;
string result, temp;
while (t1--) {
cin >> result;
data.push_back(result);
}
result = data[0];
for (i = 0; i < t; i++) {
temp = data[i];
for (j = 0; j < data[0].size(); j++) {
if (temp[j] != '?') {
if (temp[j] == result[j]) continue;
if (result[j] == '?' || result[j] == '-')
result[j] = temp[j];
else {
result[j] = '_';
}
} else {
if (result[j] == '?') result[j] = '-';
continue;
}
}
}
for (i = 0; i < result.size(); i++) {
if (result[i] == '_') result[i] = '?';
if (result[i] == '-') result[i] = 'a';
}
cout << result << endl;
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t1, t, i, j;
cin >> t1;
t = t1;
vector<string> data;
string result, temp;
while (t1--) {
cin >> result;
data.push_back(result);
}
result = data[0];
for (i = 0; i < t; i++) {
temp = data[i];
for (j = 0; j < data[0].size(); j++) {
if (temp[j] != '?') {
if (temp[j] == result[j]) continue;
if (result[j] == '?' || result[j] == '-')
result[j] = temp[j];
else {
result[j] = '_';
}
} else {
if (result[j] == '?') result[j] = '-';
continue;
}
}
}
for (i = 0; i < result.size(); i++) {
if (result[i] == '_') result[i] = '?';
if (result[i] == '-') result[i] = 'a';
}
cout << result << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string ans;
string *a = new string[n];
for (int i = 0; i < n; i++) cin >> a[i];
bool q = 1, d = 1;
for (int i = 0; i < a[0].size(); i++) {
q = 1;
d = 1;
if (a[0][i] != '?') {
for (int j = 1; j < n; j++)
if (a[0][i] != a[j][i] && a[j][i] != '?') {
d = 0;
break;
}
if (d == 1)
ans += a[0][i];
else
ans += '?';
}
d = 1;
if (a[0][i] == '?') {
for (int k = 1; k < n; k++) {
if (a[k][i] != '?') {
q = 0;
for (int m = k + 1; m < n; m++)
if (a[k][i] != a[m][i] && a[m][i] != '?') {
d = 0;
break;
}
}
if (q == 0 && d == 1) {
ans += a[k][i];
break;
}
if (q == 0 && d == 0) {
ans += '?';
break;
}
}
if (q == 1) ans += 'x';
}
}
cout << ans;
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string ans;
string *a = new string[n];
for (int i = 0; i < n; i++) cin >> a[i];
bool q = 1, d = 1;
for (int i = 0; i < a[0].size(); i++) {
q = 1;
d = 1;
if (a[0][i] != '?') {
for (int j = 1; j < n; j++)
if (a[0][i] != a[j][i] && a[j][i] != '?') {
d = 0;
break;
}
if (d == 1)
ans += a[0][i];
else
ans += '?';
}
d = 1;
if (a[0][i] == '?') {
for (int k = 1; k < n; k++) {
if (a[k][i] != '?') {
q = 0;
for (int m = k + 1; m < n; m++)
if (a[k][i] != a[m][i] && a[m][i] != '?') {
d = 0;
break;
}
}
if (q == 0 && d == 1) {
ans += a[k][i];
break;
}
if (q == 0 && d == 0) {
ans += '?';
break;
}
}
if (q == 1) ans += 'x';
}
}
cout << ans;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long double PI = 3.14159265;
long long int powerWithMod(long long int base, long long int exponent,
long long int modulus = LLONG_MAX) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent >>= 1;
base = (base * base) % modulus;
}
return result;
}
long long int modInverse(long long int a, long long int m = MOD) {
return powerWithMod(a, m - 2, m);
}
int n;
string a[123456], ans;
char check(int x) {
char ans = '?';
for (int i = 0; i < n; i++) {
if (a[i][x] == '?') continue;
if (ans == '?')
ans = a[i][x];
else if (a[i][x] != ans)
return '0';
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < a[0].size(); i++) {
char curr = check(i);
if (curr == '?')
ans.push_back('a');
else if (curr == '0')
ans.push_back('?');
else
ans.push_back(curr);
}
cout << ans << "\n";
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long int MOD = 1e9 + 7;
const long double PI = 3.14159265;
long long int powerWithMod(long long int base, long long int exponent,
long long int modulus = LLONG_MAX) {
long long int result = 1;
base %= modulus;
while (exponent > 0) {
if (exponent % 2 == 1) result = (result * base) % modulus;
exponent >>= 1;
base = (base * base) % modulus;
}
return result;
}
long long int modInverse(long long int a, long long int m = MOD) {
return powerWithMod(a, m - 2, m);
}
int n;
string a[123456], ans;
char check(int x) {
char ans = '?';
for (int i = 0; i < n; i++) {
if (a[i][x] == '?') continue;
if (ans == '?')
ans = a[i][x];
else if (a[i][x] != ans)
return '0';
}
return ans;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < a[0].size(); i++) {
char curr = check(i);
if (curr == '?')
ans.push_back('a');
else if (curr == '0')
ans.push_back('?');
else
ans.push_back(curr);
}
cout << ans << "\n";
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> arr;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
arr.push_back(t);
}
string ans = "";
for (int i = 0; i < arr[0].length(); i++) {
string x = "?";
int k = -1;
bool full = false;
bool done = false;
for (int j = 0; j < n; j++) {
if (arr[j][i] != '?' && x == "?") {
x = arr[j][i];
full = true;
k = j;
} else if (arr[j][i] != '?' && x != "?" && arr[j][i] != arr[k][i]) {
ans += "?";
done = true;
break;
}
}
if (!done) {
if (!full)
ans += "a";
else
ans += x;
}
}
cout << ans;
return 0;
}
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> arr;
for (int i = 0; i < n; i++) {
string t;
cin >> t;
arr.push_back(t);
}
string ans = "";
for (int i = 0; i < arr[0].length(); i++) {
string x = "?";
int k = -1;
bool full = false;
bool done = false;
for (int j = 0; j < n; j++) {
if (arr[j][i] != '?' && x == "?") {
x = arr[j][i];
full = true;
k = j;
} else if (arr[j][i] != '?' && x != "?" && arr[j][i] != arr[k][i]) {
ans += "?";
done = true;
break;
}
}
if (!done) {
if (!full)
ans += "a";
else
ans += x;
}
}
cout << ans;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int inf = 1e9;
char s[maxn];
char ans[maxn];
int main() {
int n;
while (cin >> n) {
memset(ans, -1, sizeof(ans));
int len;
for (int i = 0; i < n; ++i) {
scanf("%s", s);
len = strlen(s);
ans[len] = 0;
for (int j = 0; j < len; ++j) {
if (s[j] == '?')
continue;
else if (ans[j] != -1) {
if (ans[j] != s[j]) ans[j] = '?';
} else
ans[j] = s[j];
}
}
for (int j = 0; j < len; ++j)
if (ans[j] == -1) ans[j] = 'a';
printf("%s\n", ans);
}
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 5;
const int inf = 1e9;
char s[maxn];
char ans[maxn];
int main() {
int n;
while (cin >> n) {
memset(ans, -1, sizeof(ans));
int len;
for (int i = 0; i < n; ++i) {
scanf("%s", s);
len = strlen(s);
ans[len] = 0;
for (int j = 0; j < len; ++j) {
if (s[j] == '?')
continue;
else if (ans[j] != -1) {
if (ans[j] != s[j]) ans[j] = '?';
} else
ans[j] = s[j];
}
}
for (int j = 0; j < len; ++j)
if (ans[j] == -1) ans[j] = 'a';
printf("%s\n", ans);
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
string a[N];
int n;
void input() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
}
char ans[N];
int bb[N];
int main() {
input();
int m = a[1].size();
for (int i = 0; i < m; i++) ans[i] = '?';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '?') {
continue;
} else if (ans[j] == '?') {
if (bb[j] == 0) {
ans[j] = a[i][j];
}
} else if (ans[j] != '?') {
if (ans[j] != a[i][j]) {
bb[j] = 1;
ans[j] = '?';
}
}
}
}
for (int j = 0; j < m; j++)
if (ans[j] == '?' && bb[j] == 0) ans[j] = 'x';
printf("%s", ans);
}
|
### Prompt
Create a solution in Cpp for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
string a[N];
int n;
void input() {
ios_base::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i];
}
char ans[N];
int bb[N];
int main() {
input();
int m = a[1].size();
for (int i = 0; i < m; i++) ans[i] = '?';
for (int i = 1; i <= n; i++) {
for (int j = 0; j < m; j++) {
if (a[i][j] == '?') {
continue;
} else if (ans[j] == '?') {
if (bb[j] == 0) {
ans[j] = a[i][j];
}
} else if (ans[j] != '?') {
if (ans[j] != a[i][j]) {
bb[j] = 1;
ans[j] = '?';
}
}
}
}
for (int j = 0; j < m; j++)
if (ans[j] == '?' && bb[j] == 0) ans[j] = 'x';
printf("%s", ans);
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5;
int n;
char ans[maxN + 1];
string s;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
cin.ignore();
for (int i = 0; i < n; i++) {
getline(cin, s);
for (int j = 0; j < s.length(); j++) {
if (ans[j] == 0) ans[j] = '?';
if (s[j] == '?' || ans[j] == 'X') continue;
if (ans[j] == '?' && s[j] != '?')
ans[j] = s[j];
else if (ans[j] != '?' && s[j] != '?' && ans[j] != s[j])
ans[j] = 'X';
}
}
for (int i = 0; i < s.length(); i++) {
if (ans[i] == 'X')
ans[i] = '?';
else if (ans[i] == '?')
ans[i] = 'a';
}
cout << ans;
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxN = 1e5;
int n;
char ans[maxN + 1];
string s;
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
cin.ignore();
for (int i = 0; i < n; i++) {
getline(cin, s);
for (int j = 0; j < s.length(); j++) {
if (ans[j] == 0) ans[j] = '?';
if (s[j] == '?' || ans[j] == 'X') continue;
if (ans[j] == '?' && s[j] != '?')
ans[j] = s[j];
else if (ans[j] != '?' && s[j] != '?' && ans[j] != s[j])
ans[j] = 'X';
}
}
for (int i = 0; i < s.length(); i++) {
if (ans[i] == 'X')
ans[i] = '?';
else if (ans[i] == '?')
ans[i] = 'a';
}
cout << ans;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char z[100001];
int main() {
int n;
string t, f, s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
for (int j = 0; j < t.length(); j++) {
if (t[j] == '?') {
t[j] = ' ';
z[j] = '?';
}
}
if (i == 0) {
f = t;
s = t;
} else {
for (int j = 0; j < t.length(); j++) {
if (t[j] < f[j] && t[j] != ' ' || f[j] == ' ' && t[j] >= 'a')
f[j] = t[j];
if (t[j] > s[j]) s[j] = t[j];
}
}
}
for (int i = 0; i < s.length(); i++) {
if (z[i] == '?') {
if (s[i] != f[i] && f[i] > ' ') s[i] = '?';
if (s[i] == ' ' && f[i] == ' ') s[i] = 'x';
} else {
if (f[i] != s[i]) s[i] = '?';
}
}
cout << s;
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char z[100001];
int main() {
int n;
string t, f, s;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> t;
for (int j = 0; j < t.length(); j++) {
if (t[j] == '?') {
t[j] = ' ';
z[j] = '?';
}
}
if (i == 0) {
f = t;
s = t;
} else {
for (int j = 0; j < t.length(); j++) {
if (t[j] < f[j] && t[j] != ' ' || f[j] == ' ' && t[j] >= 'a')
f[j] = t[j];
if (t[j] > s[j]) s[j] = t[j];
}
}
}
for (int i = 0; i < s.length(); i++) {
if (z[i] == '?') {
if (s[i] != f[i] && f[i] > ' ') s[i] = '?';
if (s[i] == ' ' && f[i] == ' ') s[i] = 'x';
} else {
if (f[i] != s[i]) s[i] = '?';
}
}
cout << s;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int m = a[0].length();
for (int i = 0; i < m; i++) {
set<char> s;
for (int j = 0; j < n; j++) {
if (a[j][i] != '?') {
s.insert(a[j][i]);
}
}
if (s.size() == 1) {
cout << *s.begin();
} else if (s.size() == 0) {
cout << "a";
} else {
cout << "?";
}
}
return 0;
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
int m = a[0].length();
for (int i = 0; i < m; i++) {
set<char> s;
for (int j = 0; j < n; j++) {
if (a[j][i] != '?') {
s.insert(a[j][i]);
}
}
if (s.size() == 1) {
cout << *s.begin();
} else if (s.size() == 0) {
cout << "a";
} else {
cout << "?";
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, a[200000];
string second[100005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) cin >> second[i];
int sz = second[0].size();
for (int i = 0; i < sz; ++i) {
int an = 0;
for (int j = 0; j < n; ++j)
if (second[j][i] != '?') a[an++] = second[j][i] - 'a';
sort(a, a + an);
if (an == 0) {
cout << 'a';
continue;
}
if (a[0] == a[an - 1])
cout << char(a[0] + 'a');
else
cout << '?';
}
return 0;
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, a[200000];
string second[100005];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) cin >> second[i];
int sz = second[0].size();
for (int i = 0; i < sz; ++i) {
int an = 0;
for (int j = 0; j < n; ++j)
if (second[j][i] != '?') a[an++] = second[j][i] - 'a';
sort(a, a + an);
if (an == 0) {
cout << 'a';
continue;
}
if (a[0] == a[an - 1])
cout << char(a[0] + 'a');
else
cout << '?';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string x[n];
char k[1000000], t;
for (int i = 0; i < n; i++) cin >> x[i];
int h = 0, H = 1;
for (int i = 0; i < x[0].size(); i++) {
H = 1;
int C = 0, c = 0;
bool o = 0;
t = '1';
for (int j = 0; j < n; j++) {
if (x[j][i] == '?')
c++;
else if (x[j][i] == t) {
o = 1;
H++;
t = x[j][i];
C++;
} else {
t = x[j][i];
C++;
}
}
if (C == H) {
k[h] = t;
} else if (C > 1 && (C != H)) {
k[h] = '?';
} else {
k[h] = 'a';
}
h++;
}
for (int i = 0; i < h; i++) cout << k[i];
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
string x[n];
char k[1000000], t;
for (int i = 0; i < n; i++) cin >> x[i];
int h = 0, H = 1;
for (int i = 0; i < x[0].size(); i++) {
H = 1;
int C = 0, c = 0;
bool o = 0;
t = '1';
for (int j = 0; j < n; j++) {
if (x[j][i] == '?')
c++;
else if (x[j][i] == t) {
o = 1;
H++;
t = x[j][i];
C++;
} else {
t = x[j][i];
C++;
}
}
if (C == H) {
k[h] = t;
} else if (C > 1 && (C != H)) {
k[h] = '?';
} else {
k[h] = 'a';
}
h++;
}
for (int i = 0; i < h; i++) cout << k[i];
}
```
|
#include <bits/stdc++.h>
int main() {
static char s[100000 + 1], cc[100000 + 1];
static int bad[100000];
int n, m, i;
scanf("%d", &n);
memset(cc, '#', sizeof cc);
while (n--) {
scanf("%s", s);
m = strlen(s);
for (i = 0; i < m; i++)
if (cc[i] != '#' && s[i] != '?' && s[i] != cc[i])
bad[i] = 1;
else if (cc[i] == '#' && s[i] != '?')
cc[i] = s[i];
}
cc[m] = 0;
for (i = 0; i < m; i++)
if (bad[i])
cc[i] = '?';
else if (cc[i] == '#')
cc[i] = 'a';
printf("%s\n", cc);
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
int main() {
static char s[100000 + 1], cc[100000 + 1];
static int bad[100000];
int n, m, i;
scanf("%d", &n);
memset(cc, '#', sizeof cc);
while (n--) {
scanf("%s", s);
m = strlen(s);
for (i = 0; i < m; i++)
if (cc[i] != '#' && s[i] != '?' && s[i] != cc[i])
bad[i] = 1;
else if (cc[i] == '#' && s[i] != '?')
cc[i] = s[i];
}
cc[m] = 0;
for (i = 0; i < m; i++)
if (bad[i])
cc[i] = '?';
else if (cc[i] == '#')
cc[i] = 'a';
printf("%s\n", cc);
return 0;
}
```
|
#include <bits/stdc++.h>
char c[100001];
void solve(int n) {
int i, j;
std::vector<std::string> a;
std::string s;
gets(c);
char t;
for (i = 0; i < (n); i++) {
gets(c);
s = c;
a.push_back(s);
}
s = "";
for (i = 0; i < (a[0].length()); i++) {
t = '*';
for (j = 0; j < (a.size()); j++) {
if (a[j][i] != '?') {
if (t != a[j][i]) {
if (t != '*')
t = '?';
else
t = a[j][i];
}
}
}
if (t == '*') t = 'a';
s += t;
}
printf("%s", s.c_str());
}
int main() {
#pragma comment(linker, "/STACK:268435456")
int n;
while (scanf("%d", &n) != EOF) {
solve(n);
}
return 0;
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
char c[100001];
void solve(int n) {
int i, j;
std::vector<std::string> a;
std::string s;
gets(c);
char t;
for (i = 0; i < (n); i++) {
gets(c);
s = c;
a.push_back(s);
}
s = "";
for (i = 0; i < (a[0].length()); i++) {
t = '*';
for (j = 0; j < (a.size()); j++) {
if (a[j][i] != '?') {
if (t != a[j][i]) {
if (t != '*')
t = '?';
else
t = a[j][i];
}
}
}
if (t == '*') t = 'a';
s += t;
}
printf("%s", s.c_str());
}
int main() {
#pragma comment(linker, "/STACK:268435456")
int n;
while (scanf("%d", &n) != EOF) {
solve(n);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
void solve(int n, long long s[], long long p[]);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
int n;
cin >> (n);
string str;
vector<string> v;
for (long long i = 0; i < n; i++) {
cin >> (str);
v.push_back(str);
}
string res = "";
for (long long j = 0; j < v[0].size(); j++) {
char ch = ' ';
for (long long i = 0; i < n; i++) {
if (ch == ' ' and v[i][j] != '?') {
ch = v[i][j];
}
if (v[i][j] != '?') {
if (v[i][j] != ch) {
ch = '?';
break;
}
}
}
if (ch == ' ') {
res += 'x';
} else {
res += ch;
}
}
cout << (res);
}
return 0;
}
|
### Prompt
Generate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
void solve(int n, long long s[], long long p[]);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
int n;
cin >> (n);
string str;
vector<string> v;
for (long long i = 0; i < n; i++) {
cin >> (str);
v.push_back(str);
}
string res = "";
for (long long j = 0; j < v[0].size(); j++) {
char ch = ' ';
for (long long i = 0; i < n; i++) {
if (ch == ' ' and v[i][j] != '?') {
ch = v[i][j];
}
if (v[i][j] != '?') {
if (v[i][j] != ch) {
ch = '?';
break;
}
}
}
if (ch == ' ') {
res += 'x';
} else {
res += ch;
}
}
cout << (res);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
char s[500100], b[500100];
int a[500100];
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
l = (int)strlen(s);
for (int j = 0; j < l; j++)
if (s[j] != '?' && s[j] != b[j]) {
a[j]++;
b[j] = s[j];
}
}
for (int i = 0; i < l; i++) {
if (a[i] == 0)
printf("a");
else if (a[i] == 1)
printf("%c", b[i]);
else
printf("?");
}
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, l;
char s[500100], b[500100];
int a[500100];
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%s", s);
l = (int)strlen(s);
for (int j = 0; j < l; j++)
if (s[j] != '?' && s[j] != b[j]) {
a[j]++;
b[j] = s[j];
}
}
for (int i = 0; i < l; i++) {
if (a[i] == 0)
printf("a");
else if (a[i] == 1)
printf("%c", b[i]);
else
printf("?");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
const long double EPS = 1e-12;
const long long INF = 2e18 + 5;
const long double PI = 3.14159265358979323;
vector<long long> v;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(15) << fixed;
long long t = 1;
cin >> t;
string s, ans;
cin >> s;
ans = s;
t--;
for (; t; t--) {
cin >> s;
for (long long i = 0; i < s.size(); i++) {
if (ans[i] == '.') continue;
if (ans[i] != s[i] && ans[i] != '?' && s[i] != '?')
ans[i] = '.';
else if (ans[i] != s[i] && ans[i] == '?')
ans[i] = s[i];
}
}
for (long long i = 0; i < ans.size(); i++) {
if (ans[i] == '.')
ans[i] = '?';
else if (ans[i] == '?')
ans[i] = 'a';
}
cout << ans << '\n';
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e6 + 5;
const long double EPS = 1e-12;
const long long INF = 2e18 + 5;
const long double PI = 3.14159265358979323;
vector<long long> v;
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << setprecision(15) << fixed;
long long t = 1;
cin >> t;
string s, ans;
cin >> s;
ans = s;
t--;
for (; t; t--) {
cin >> s;
for (long long i = 0; i < s.size(); i++) {
if (ans[i] == '.') continue;
if (ans[i] != s[i] && ans[i] != '?' && s[i] != '?')
ans[i] = '.';
else if (ans[i] != s[i] && ans[i] == '?')
ans[i] = s[i];
}
}
for (long long i = 0; i < ans.size(); i++) {
if (ans[i] == '.')
ans[i] = '?';
else if (ans[i] == '?')
ans[i] = 'a';
}
cout << ans << '\n';
return 0;
}
```
|
#include <bits/stdc++.h>
long key[100001] = {0};
char temp[100003], s[100003];
int main() {
long n, m, len, i;
scanf("%ld", &n);
scanf("%s", &s);
len = strlen(s);
m = n;
while (--m) {
scanf("%s", &temp);
for (i = 0; i < len; i++) {
if (s[i] != '?' && temp[i] != '?')
if (s[i] != temp[i]) key[i] = 1;
if (s[i] == '?' && temp[i] != '?') s[i] = temp[i];
}
}
for (i = 0; i < len; i++) {
if (key[i] == 1)
printf("?");
else if (s[i] == '?')
printf("a");
else
printf("%c", s[i]);
}
return 0;
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
long key[100001] = {0};
char temp[100003], s[100003];
int main() {
long n, m, len, i;
scanf("%ld", &n);
scanf("%s", &s);
len = strlen(s);
m = n;
while (--m) {
scanf("%s", &temp);
for (i = 0; i < len; i++) {
if (s[i] != '?' && temp[i] != '?')
if (s[i] != temp[i]) key[i] = 1;
if (s[i] == '?' && temp[i] != '?') s[i] = temp[i];
}
}
for (i = 0; i < len; i++) {
if (key[i] == 1)
printf("?");
else if (s[i] == '?')
printf("a");
else
printf("%c", s[i]);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s[100007];
char res[100007];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
int len = s[0].size();
char w;
int st;
for (int i = 0; i < len; i++) {
w = 0;
st = 0;
for (int o = 0; o < n; o++) {
if (s[o][i] != '?')
if ((w != 0) && (w != s[o][i])) {
st = 2;
break;
} else {
w = s[o][i];
st = 1;
}
}
if (st == 0)
res[i] = 'a';
else if (st == 1)
res[i] = w;
else
res[i] = '?';
}
cout << res;
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
string s[100007];
char res[100007];
int main() {
cin >> n;
for (int i = 0; i < n; i++) cin >> s[i];
int len = s[0].size();
char w;
int st;
for (int i = 0; i < len; i++) {
w = 0;
st = 0;
for (int o = 0; o < n; o++) {
if (s[o][i] != '?')
if ((w != 0) && (w != s[o][i])) {
st = 2;
break;
} else {
w = s[o][i];
st = 1;
}
}
if (st == 0)
res[i] = 'a';
else if (st == 1)
res[i] = w;
else
res[i] = '?';
}
cout << res;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
string p[100010], res;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
m = p[1].length();
for (int k = 0; k <= m - 1; k++) {
char c = '-';
for (int i = 1; i <= n; i++)
if (p[i][k] != '?')
if (c == '-')
c = p[i][k];
else if (c != '?' && c != p[i][k])
c = '?';
if (c == '-') c = 'a';
res += c;
}
cout << res;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, m;
string p[100010], res;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> p[i];
m = p[1].length();
for (int k = 0; k <= m - 1; k++) {
char c = '-';
for (int i = 1; i <= n; i++)
if (p[i][k] != '?')
if (c == '-')
c = p[i][k];
else if (c != '?' && c != p[i][k])
c = '?';
if (c == '-') c = 'a';
res += c;
}
cout << res;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<pair<char, bool>> ans;
unordered_map<int, int> ind;
void f(string s) {
int size = ind.size();
for (int i = 0; i < s.size(); i++) {
int z = 0;
if (ind.count(i))
z = ind[i] - 1;
else
continue;
if (ans[z].first != '?' && s[z] != '?' && ans[z].second &&
ans[z].first != s[z]) {
ans[z] = make_pair('?', false);
ind.erase(z);
} else if (ans[z].first == '?' && ans[z].second && s[z] != '?')
ans[z] = make_pair(s[z], true);
}
}
int main() {
int n;
cin >> n;
string s, t;
cin >> s;
ans.resize(s.size());
fill(ans.begin(), ans.end(), make_pair('?', true));
for (int i = 0; i < s.size(); i++) {
ind[i] = i + 1;
}
f(s);
for (int i = 0; i < n - 1; i++) {
cin >> s;
f(s);
}
for (int i = 0; i < ans.size(); i++) {
if (ans[i].first == '?' && !ans[i].second) {
cout << '?';
} else if (ans[i].first != '?')
cout << ans[i].first;
else
cout << 'a';
}
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<pair<char, bool>> ans;
unordered_map<int, int> ind;
void f(string s) {
int size = ind.size();
for (int i = 0; i < s.size(); i++) {
int z = 0;
if (ind.count(i))
z = ind[i] - 1;
else
continue;
if (ans[z].first != '?' && s[z] != '?' && ans[z].second &&
ans[z].first != s[z]) {
ans[z] = make_pair('?', false);
ind.erase(z);
} else if (ans[z].first == '?' && ans[z].second && s[z] != '?')
ans[z] = make_pair(s[z], true);
}
}
int main() {
int n;
cin >> n;
string s, t;
cin >> s;
ans.resize(s.size());
fill(ans.begin(), ans.end(), make_pair('?', true));
for (int i = 0; i < s.size(); i++) {
ind[i] = i + 1;
}
f(s);
for (int i = 0; i < n - 1; i++) {
cin >> s;
f(s);
}
for (int i = 0; i < ans.size(); i++) {
if (ans[i].first == '?' && !ans[i].second) {
cout << '?';
} else if (ans[i].first != '?')
cout << ans[i].first;
else
cout << 'a';
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
string ans = "";
string str[100010];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
int l = str[0].length();
for (int i = 0; i < l; i++) {
ans += "#";
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < l; j++) {
if (str[i][j] == '?') {
continue;
}
if (ans[j] == '#') {
ans[j] = str[i][j];
} else if (ans[j] != str[i][j]) {
ans[j] = '?';
}
}
}
for (int i = 0; i < l; i++) {
if (ans[i] == '#') {
ans[i] = 'a';
}
}
cout << ans << endl;
return 0;
}
|
### Prompt
Please create a solution in cpp to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string ans = "";
string str[100010];
int n;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
int l = str[0].length();
for (int i = 0; i < l; i++) {
ans += "#";
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < l; j++) {
if (str[i][j] == '?') {
continue;
}
if (ans[j] == '#') {
ans[j] = str[i][j];
} else if (ans[j] != str[i][j]) {
ans[j] = '?';
}
}
}
for (int i = 0; i < l; i++) {
if (ans[i] == '#') {
ans[i] = 'a';
}
}
cout << ans << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n, i, j, h;
string s;
vector<char> v[100002];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
h = s.size();
for (j = 0; j < s.size(); j++) {
if (s[j] == '?') continue;
if (v[j].size() == 0) {
v[j].push_back(s[j]);
continue;
}
if (v[j][0] != s[j]) v[j].push_back(s[j]);
}
}
for (i = 0; i < h; i++) {
if (v[i].size() == 0)
cout << "x";
else if (v[i].size() > 1)
cout << "?";
else
cout << v[i][0];
}
cout << endl;
return 0;
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n, i, j, h;
string s;
vector<char> v[100002];
int main() {
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
h = s.size();
for (j = 0; j < s.size(); j++) {
if (s[j] == '?') continue;
if (v[j].size() == 0) {
v[j].push_back(s[j]);
continue;
}
if (v[j][0] != s[j]) v[j].push_back(s[j]);
}
}
for (i = 0; i < h; i++) {
if (v[i].size() == 0)
cout << "x";
else if (v[i].size() > 1)
cout << "?";
else
cout << v[i][0];
}
cout << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
string str[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
for (int i = 0; i < ((int)(str[0]).size()); i++) {
bool all = true;
char only = 0;
for (int j = 0; j < n; j++) {
if (str[j][i] == '?') continue;
all = false;
if (only == 0)
only = str[j][i];
else if (only != 0 && str[j][i] != only)
only = -1;
}
if (all) {
printf("a");
} else if (only != -1) {
printf("%c", only);
} else {
printf("?");
}
}
puts("");
return 0;
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
string str[N];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> str[i];
}
for (int i = 0; i < ((int)(str[0]).size()); i++) {
bool all = true;
char only = 0;
for (int j = 0; j < n; j++) {
if (str[j][i] == '?') continue;
all = false;
if (only == 0)
only = str[j][i];
else if (only != 0 && str[j][i] != only)
only = -1;
}
if (all) {
printf("a");
} else if (only != -1) {
printf("%c", only);
} else {
printf("?");
}
}
puts("");
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char buf[123456];
char result[123456];
int main() {
int n = 0;
scanf("%d", &n);
int mxlen = 0;
for (int i = 0; i < n; i++) {
scanf("%s", buf);
int len = strlen(buf);
if (i == 0) {
for (int j = 0; j < len; j++) result[j] = 'R';
}
for (int j = 0; j < len; j++) {
if (buf[j] != '?') {
if (result[j] == 'R')
result[j] = buf[j];
else if (result[j] != buf[j])
result[j] = '?';
}
}
mxlen = len;
}
for (int i = 0; i < mxlen; i++)
if (result[i] == 'R') result[i] = 'r';
puts(result);
return 0;
}
|
### Prompt
Please provide a Cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char buf[123456];
char result[123456];
int main() {
int n = 0;
scanf("%d", &n);
int mxlen = 0;
for (int i = 0; i < n; i++) {
scanf("%s", buf);
int len = strlen(buf);
if (i == 0) {
for (int j = 0; j < len; j++) result[j] = 'R';
}
for (int j = 0; j < len; j++) {
if (buf[j] != '?') {
if (result[j] == 'R')
result[j] = buf[j];
else if (result[j] != buf[j])
result[j] = '?';
}
}
mxlen = len;
}
for (int i = 0; i < mxlen; i++)
if (result[i] == 'R') result[i] = 'r';
puts(result);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag;
scanf("%d", &n);
string x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int l = x[0].length();
for (int j = 0; j < l; j++) {
char z = x[0][j];
flag = 0;
for (int i = 0; i < n; i++) {
if (z == '?') {
if (x[i][j] != '?') {
z = x[i][j];
}
}
if (z == x[i][j] || x[i][j] == '?')
continue;
else {
flag = 1;
break;
}
}
if (flag == 1)
printf("?");
else if (z != '?')
printf("%c", z);
else
printf("x");
}
return 0;
}
|
### Prompt
Your task is to create a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, flag;
scanf("%d", &n);
string x[n];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int l = x[0].length();
for (int j = 0; j < l; j++) {
char z = x[0][j];
flag = 0;
for (int i = 0; i < n; i++) {
if (z == '?') {
if (x[i][j] != '?') {
z = x[i][j];
}
}
if (z == x[i][j] || x[i][j] == '?')
continue;
else {
flag = 1;
break;
}
}
if (flag == 1)
printf("?");
else if (z != '?')
printf("%c", z);
else
printf("x");
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
vector<string> v;
cin >> t;
while (t--) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < v[0].size(); i++) {
set<char> st;
for (int j = 0; j < v.size(); j++) {
if (v[j][i] != '?') st.insert(v[j][i]);
}
if (st.size() == 1)
cout << *st.begin();
else if (st.size() > 1)
cout << "?";
else
cout << "x";
}
cout << endl;
return 0;
}
|
### Prompt
Create a solution in CPP for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int t;
vector<string> v;
cin >> t;
while (t--) {
string s;
cin >> s;
v.push_back(s);
}
for (int i = 0; i < v[0].size(); i++) {
set<char> st;
for (int j = 0; j < v.size(); j++) {
if (v[j][i] != '?') st.insert(v[j][i]);
}
if (st.size() == 1)
cout << *st.begin();
else if (st.size() > 1)
cout << "?";
else
cout << "x";
}
cout << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
double __begin;
template <typename T1, typename T2, typename T3>
struct triple {
T1 a;
T2 b;
T3 c;
triple(){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
template <typename T1, typename T2, typename T3>
bool operator<(const triple<T1, T2, T3> &t1, const triple<T1, T2, T3> &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else
return t1.b < t2.b;
}
template <typename T1, typename T2, typename T3>
inline std::ostream &operator<<(std::ostream &os, const triple<T1, T2, T3> &t) {
return os << "(" << t.a << ", " << t.b << ", " << t.c << ")";
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
int t = v >> 32;
int p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
inline int sign(int x) { return (x >> 31) | (-x >> 31); }
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::set<T> &v) {
bool first = true;
os << "[";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::map<T1, T2> &v) {
bool first = true;
os << "[";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T, typename T2>
void printarray(T a[], T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++) cout << a[i] << " ";
cout << endl;
}
inline long long binpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(int a, int b) { return a / gcd(a, b) * (long long)b; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
inline long long lcm(long long a, long long b, long long c) {
return lcm(lcm(a, b), c);
}
inline long long lcm(int a, int b, int c) {
return lcm(lcm(a, b), (long long)c);
}
inline long long max(long long a, long long b) { return (a > b) ? a : b; }
inline int max(int a, int b) { return (a > b) ? a : b; }
inline double max(double a, double b) { return (a > b) ? a : b; }
inline long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline double max(double a, double b, double c) { return max(a, max(b, c)); }
inline long long min(long long a, long long b) { return (a < b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
inline double min(double a, double b) { return (a < b) ? a : b; }
inline long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline double min(double a, double b, double c) { return min(a, min(b, c)); }
template <class T>
inline void getar(T a, int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
inline void getar(int *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", a + ii);
}
}
inline void getar(pair<int, int> *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d%d", &a[ii].first, &a[ii].second);
}
}
inline void getar(long long *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", a + ii);
}
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n - 1; ++i) {
string t;
cin >> t;
for (int j = 0; j < t.size(); ++j) {
if (t[j] == '?') {
} else {
if (s[j] == '?') {
s[j] = t[j];
} else if (s[j] == t[j]) {
} else {
s[j] = '*';
}
}
}
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '?')
s[i] = 'x';
else if (s[i] == '*')
s[i] = '?';
}
cout << s << endl;
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:20000000")
using namespace std;
double __begin;
template <typename T1, typename T2, typename T3>
struct triple {
T1 a;
T2 b;
T3 c;
triple(){};
triple(T1 _a, T2 _b, T3 _c) : a(_a), b(_b), c(_c) {}
};
template <typename T1, typename T2, typename T3>
bool operator<(const triple<T1, T2, T3> &t1, const triple<T1, T2, T3> &t2) {
if (t1.a != t2.a)
return t1.a < t2.a;
else
return t1.b < t2.b;
}
template <typename T1, typename T2, typename T3>
inline std::ostream &operator<<(std::ostream &os, const triple<T1, T2, T3> &t) {
return os << "(" << t.a << ", " << t.b << ", " << t.c << ")";
}
inline int bits_count(int v) {
v = v - ((v >> 1) & 0x55555555);
v = (v & 0x33333333) + ((v >> 2) & 0x33333333);
return ((v + (v >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
}
inline int bits_count(long long v) {
int t = v >> 32;
int p = (v & ((1LL << 32) - 1));
return bits_count(t) + bits_count(p);
}
unsigned int reverse_bits(register unsigned int x) {
x = (((x & 0xaaaaaaaa) >> 1) | ((x & 0x55555555) << 1));
x = (((x & 0xcccccccc) >> 2) | ((x & 0x33333333) << 2));
x = (((x & 0xf0f0f0f0) >> 4) | ((x & 0x0f0f0f0f) << 4));
x = (((x & 0xff00ff00) >> 8) | ((x & 0x00ff00ff) << 8));
return ((x >> 16) | (x << 16));
}
inline int sign(int x) { return (x >> 31) | (-x >> 31); }
inline bool ispow2(int x) { return (x != 0 && (x & (x - 1)) == 0); }
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
bool first = true;
os << "[";
for (unsigned int i = 0; i < v.size(); i++) {
if (!first) os << ", ";
os << v[i];
first = false;
}
return os << "]";
}
template <typename T>
inline std::ostream &operator<<(std::ostream &os, const std::set<T> &v) {
bool first = true;
os << "[";
for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T1, typename T2>
inline std::ostream &operator<<(std::ostream &os, const std::map<T1, T2> &v) {
bool first = true;
os << "[";
for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end();
++ii) {
if (!first) os << ", ";
os << *ii;
first = false;
}
return os << "]";
}
template <typename T, typename T2>
void printarray(T a[], T2 sz, T2 beg = 0) {
for (T2 i = beg; i < sz; i++) cout << a[i] << " ";
cout << endl;
}
inline long long binpow(long long x, long long n) {
long long res = 1;
while (n) {
if (n & 1) res *= x;
x *= x;
n >>= 1;
}
return res;
}
inline long long powmod(long long x, long long n, long long _mod) {
long long res = 1;
while (n) {
if (n & 1) res = (res * x) % _mod;
x = (x * x) % _mod;
n >>= 1;
}
return res;
}
inline long long gcd(long long a, long long b) {
long long t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline int gcd(int a, int b) {
int t;
while (b) {
a = a % b;
t = a;
a = b;
b = t;
}
return a;
}
inline long long lcm(int a, int b) { return a / gcd(a, b) * (long long)b; }
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long gcd(long long a, long long b, long long c) {
return gcd(gcd(a, b), c);
}
inline int gcd(int a, int b, int c) { return gcd(gcd(a, b), c); }
inline long long lcm(long long a, long long b, long long c) {
return lcm(lcm(a, b), c);
}
inline long long lcm(int a, int b, int c) {
return lcm(lcm(a, b), (long long)c);
}
inline long long max(long long a, long long b) { return (a > b) ? a : b; }
inline int max(int a, int b) { return (a > b) ? a : b; }
inline double max(double a, double b) { return (a > b) ? a : b; }
inline long long max(long long a, long long b, long long c) {
return max(a, max(b, c));
}
inline int max(int a, int b, int c) { return max(a, max(b, c)); }
inline double max(double a, double b, double c) { return max(a, max(b, c)); }
inline long long min(long long a, long long b) { return (a < b) ? a : b; }
inline int min(int a, int b) { return (a < b) ? a : b; }
inline double min(double a, double b) { return (a < b) ? a : b; }
inline long long min(long long a, long long b, long long c) {
return min(a, min(b, c));
}
inline int min(int a, int b, int c) { return min(a, min(b, c)); }
inline double min(double a, double b, double c) { return min(a, min(b, c)); }
template <class T>
inline void getar(T a, int n, int m) {
for (int i = 0; i < n; i++)
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
}
}
inline void getar(int *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d", a + ii);
}
}
inline void getar(pair<int, int> *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%d%d", &a[ii].first, &a[ii].second);
}
}
inline void getar(long long *a, int n) {
for (int ii = 0; ii < n; ii++) {
scanf("%I64d", a + ii);
}
}
int main() {
int n;
cin >> n;
string s;
cin >> s;
for (int i = 0; i < n - 1; ++i) {
string t;
cin >> t;
for (int j = 0; j < t.size(); ++j) {
if (t[j] == '?') {
} else {
if (s[j] == '?') {
s[j] = t[j];
} else if (s[j] == t[j]) {
} else {
s[j] = '*';
}
}
}
}
for (int i = 0; i < s.size(); ++i) {
if (s[i] == '?')
s[i] = 'x';
else if (s[i] == '*')
s[i] = '?';
}
cout << s << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
unsigned long n, range;
string s;
cin >> n >> s;
n--;
range = s.length();
vector<char> output(range, 'X');
do {
for (int i = 0; i < range; i++)
if (s[i] == '?' or output[i] == s[i])
continue;
else if (output[i] == 'X')
output[i] = s[i];
else
output[i] = '?';
if (n != 0) cin >> s;
} while (n--);
for (auto &p : output) cout << (char)tolower(p);
return 0;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
unsigned long n, range;
string s;
cin >> n >> s;
n--;
range = s.length();
vector<char> output(range, 'X');
do {
for (int i = 0; i < range; i++)
if (s[i] == '?' or output[i] == s[i])
continue;
else if (output[i] == 'X')
output[i] = s[i];
else
output[i] = '?';
if (n != 0) cin >> s;
} while (n--);
for (auto &p : output) cout << (char)tolower(p);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int len = 0;
string a;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
len = str.size();
if (i == 0) a = str;
for (int j = 0; j < len; j++) {
if (a[j] == '?' && str[j] != '?') {
a[j] = str[j];
continue;
}
if (a[j] != '?' && str[j] == '?') continue;
if (a[j] != str[j]) a[j] = 'F';
}
}
for (int j = 0; j < len; j++) {
if (a[j] == '?') a[j] = 'a';
if (a[j] == 'F') a[j] = '?';
}
for (int i = 0; i < len; i++) cout << a[i];
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int len = 0;
string a;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
len = str.size();
if (i == 0) a = str;
for (int j = 0; j < len; j++) {
if (a[j] == '?' && str[j] != '?') {
a[j] = str[j];
continue;
}
if (a[j] != '?' && str[j] == '?') continue;
if (a[j] != str[j]) a[j] = 'F';
}
}
for (int j = 0; j < len; j++) {
if (a[j] == '?') a[j] = 'a';
if (a[j] == 'F') a[j] = '?';
}
for (int i = 0; i < len; i++) cout << a[i];
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string res, s;
cin >> n;
n--;
cin >> res;
for (int i = 0; i < res.size(); i++)
if (res[i] == '?') res[i] = '.';
while (n--) {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?') continue;
if (res[i] == s[i] || res[i] == '.')
res[i] = s[i];
else
res[i] = '?';
}
}
for (int i = 0; i < res.size(); i++) {
if (res[i] == '.')
cout << 'a';
else
cout << res[i];
}
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n;
string res, s;
cin >> n;
n--;
cin >> res;
for (int i = 0; i < res.size(); i++)
if (res[i] == '?') res[i] = '.';
while (n--) {
cin >> s;
for (int i = 0; i < s.size(); i++) {
if (s[i] == '?') continue;
if (res[i] == s[i] || res[i] == '.')
res[i] = s[i];
else
res[i] = '?';
}
}
for (int i = 0; i < res.size(); i++) {
if (res[i] == '.')
cout << 'a';
else
cout << res[i];
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<string> a;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
a.push_back(s);
}
int m = a[0].size();
for (int i = 0; i < m; ++i) {
bool isSimbol = false;
char ch;
for (int j = 0; j < n; ++j) {
if (a[j][i] != '?') ch = a[j][i], isSimbol = true;
if (isSimbol) break;
}
if (isSimbol == false)
cout << "a";
else {
bool isEqual = true;
for (int j = 0; j < n; ++j) {
if (a[j][i] != '?' && a[j][i] != ch) isEqual = false;
if (!isEqual) break;
}
if (isEqual)
cout << ch;
else
cout << '?';
}
}
cout << endl;
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<string> a;
int main() {
ios_base::sync_with_stdio(false);
int n;
cin >> n;
for (int i = 0; i < n; ++i) {
string s;
cin >> s;
a.push_back(s);
}
int m = a[0].size();
for (int i = 0; i < m; ++i) {
bool isSimbol = false;
char ch;
for (int j = 0; j < n; ++j) {
if (a[j][i] != '?') ch = a[j][i], isSimbol = true;
if (isSimbol) break;
}
if (isSimbol == false)
cout << "a";
else {
bool isEqual = true;
for (int j = 0; j < n; ++j) {
if (a[j][i] != '?' && a[j][i] != ch) isEqual = false;
if (!isEqual) break;
}
if (isEqual)
cout << ch;
else
cout << '?';
}
}
cout << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
long long l = s.size();
if (n == 1) {
for (long long i = 0; i < l; i++)
if (s[i] == '?') s[i] = 'x';
}
string a = s;
n--;
while (n--) {
string s;
cin >> s;
for (long long i = 0; i < l; i++) {
if (s[i] != '?') {
if (a[i] != s[i] && a[i] != '?' && a[i] != 'A') {
a[i] = 'X';
}
if (a[i] != s[i] && a[i] == '?') {
a[i] = s[i];
}
if (a[i] != s[i] && a[i] == 'A') {
a[i] = s[i];
}
} else {
if (s[i] == a[i]) a[i] = 'A';
}
}
}
for (long long i = 0; i < l; i++) {
if (a[i] == 'A') a[i] = 'x';
if (a[i] == 'X') a[i] = '?';
}
cout << a;
return 0;
}
|
### Prompt
In CPP, your task is to solve the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s;
cin >> s;
long long l = s.size();
if (n == 1) {
for (long long i = 0; i < l; i++)
if (s[i] == '?') s[i] = 'x';
}
string a = s;
n--;
while (n--) {
string s;
cin >> s;
for (long long i = 0; i < l; i++) {
if (s[i] != '?') {
if (a[i] != s[i] && a[i] != '?' && a[i] != 'A') {
a[i] = 'X';
}
if (a[i] != s[i] && a[i] == '?') {
a[i] = s[i];
}
if (a[i] != s[i] && a[i] == 'A') {
a[i] = s[i];
}
} else {
if (s[i] == a[i]) a[i] = 'A';
}
}
}
for (long long i = 0; i < l; i++) {
if (a[i] == 'A') a[i] = 'x';
if (a[i] == 'X') a[i] = '?';
}
cout << a;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int c[100005], N, full;
int LG;
void read() {
scanf("%d\n", &N);
for (int line = 1; line <= N; ++line) {
scanf("%s", s + 1);
s[0] = '#';
int len = strlen(s) - 1;
LG = len;
for (int i = 1; i <= len; ++i) {
if (s[i] == '?') continue;
if (c[i] == 0) {
c[i] = s[i] - 'a' + 1;
continue;
}
if (c[i] == s[i] - 'a' + 1)
continue;
else {
if (c[i] != -1) {
c[i] = -1;
full++;
}
if (full == len) return;
}
}
}
}
int main() {
read();
for (int i = 1; i <= LG; ++i)
if (c[i] == -1)
printf("?");
else if (c[i] == 0)
printf("x");
else
printf("%c", c[i] + 'a' - 1);
return 0;
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char s[100005];
int c[100005], N, full;
int LG;
void read() {
scanf("%d\n", &N);
for (int line = 1; line <= N; ++line) {
scanf("%s", s + 1);
s[0] = '#';
int len = strlen(s) - 1;
LG = len;
for (int i = 1; i <= len; ++i) {
if (s[i] == '?') continue;
if (c[i] == 0) {
c[i] = s[i] - 'a' + 1;
continue;
}
if (c[i] == s[i] - 'a' + 1)
continue;
else {
if (c[i] != -1) {
c[i] = -1;
full++;
}
if (full == len) return;
}
}
}
}
int main() {
read();
for (int i = 1; i <= LG; ++i)
if (c[i] == -1)
printf("?");
else if (c[i] == 0)
printf("x");
else
printf("%c", c[i] + 'a' - 1);
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:436777216")
using namespace std;
inline long long MAX(long long a, long long b) { return (a > b) ? (a) : (b); }
inline int MIN(int a, int b) { return (a < b) ? (a) : (b); }
int main() {
int const sz = 1e5;
long long i, j, n;
string s[sz + 1];
cin >> n;
for (i = 1; i <= n; i++) cin >> s[i];
for (i = 0; i <= s[1].length() - 1; i++) {
if (s[1][i] != '?') {
bool fl = 0;
for (j = 2; j <= n; j++)
if (s[j][i] != s[1][i] && s[j][i] != '?') {
fl = 1;
cout << "?";
break;
}
if (fl == 0) cout << s[1][i];
}
if (s[1][i] == '?') {
char x = '!';
bool fl = 0, fl2 = 0;
for (j = 2; j <= n; j++) {
if (s[j][i] != '?' && x == '!') {
x = s[j][i];
fl2 = 1;
}
if (s[j][i] != '?' && x != '!' && x != s[j][i]) {
fl = 1;
cout << "?";
break;
}
}
if (fl2 == 0) cout << 'a';
if (fl2 == 1 && fl == 0) cout << x;
}
}
return 0;
}
|
### Prompt
Your task is to create a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:436777216")
using namespace std;
inline long long MAX(long long a, long long b) { return (a > b) ? (a) : (b); }
inline int MIN(int a, int b) { return (a < b) ? (a) : (b); }
int main() {
int const sz = 1e5;
long long i, j, n;
string s[sz + 1];
cin >> n;
for (i = 1; i <= n; i++) cin >> s[i];
for (i = 0; i <= s[1].length() - 1; i++) {
if (s[1][i] != '?') {
bool fl = 0;
for (j = 2; j <= n; j++)
if (s[j][i] != s[1][i] && s[j][i] != '?') {
fl = 1;
cout << "?";
break;
}
if (fl == 0) cout << s[1][i];
}
if (s[1][i] == '?') {
char x = '!';
bool fl = 0, fl2 = 0;
for (j = 2; j <= n; j++) {
if (s[j][i] != '?' && x == '!') {
x = s[j][i];
fl2 = 1;
}
if (s[j][i] != '?' && x != '!' && x != s[j][i]) {
fl = 1;
cout << "?";
break;
}
}
if (fl2 == 0) cout << 'a';
if (fl2 == 1 && fl == 0) cout << x;
}
}
return 0;
}
```
|
#include <bits/stdc++.h>
char a[100000], c[100000];
int main() {
int n, l, k, j, i;
scanf("%d", &n);
scanf("%s", c);
int len = strlen(c);
for (i = 0; i < len; i++) {
if (c[i] == '?') c[i] = ',';
}
for (i = 1; i < n; i++) {
scanf("%s", a);
for (j = 0; j < len; j++) {
if (a[j] != '?' && c[j] == ',')
c[j] = a[j];
else if (a[j] != '?' && c[j] != '?' && a[j] != c[j])
c[j] = '.';
}
}
for (i = 0; i < len; i++) {
if (c[i] == '.')
printf("?");
else if (c[i] == ',')
printf("x");
else
printf("%c", c[i]);
}
printf("\n");
return 0;
}
|
### Prompt
Please formulate a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
char a[100000], c[100000];
int main() {
int n, l, k, j, i;
scanf("%d", &n);
scanf("%s", c);
int len = strlen(c);
for (i = 0; i < len; i++) {
if (c[i] == '?') c[i] = ',';
}
for (i = 1; i < n; i++) {
scanf("%s", a);
for (j = 0; j < len; j++) {
if (a[j] != '?' && c[j] == ',')
c[j] = a[j];
else if (a[j] != '?' && c[j] != '?' && a[j] != c[j])
c[j] = '.';
}
}
for (i = 0; i < len; i++) {
if (c[i] == '.')
printf("?");
else if (c[i] == ',')
printf("x");
else
printf("%c", c[i]);
}
printf("\n");
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s[n], o;
long long i;
for (i = 0; i < n; i++) cin >> s[i];
long long m = s[0].length(), j;
for (j = 0; j < m; j++) {
char last = '0';
for (i = 0; i < n; i++) {
if (s[i][j] == '?') continue;
if (last == '0')
last = s[i][j];
else {
if (s[i][j] != last) break;
}
}
if (last == '0')
o.push_back('a');
else if (i != n)
o.push_back('?');
else
o.push_back(last);
}
cout << o << endl;
}
|
### Prompt
Develop a solution in CPP to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const long long inf = 4e18;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
string s[n], o;
long long i;
for (i = 0; i < n; i++) cin >> s[i];
long long m = s[0].length(), j;
for (j = 0; j < m; j++) {
char last = '0';
for (i = 0; i < n; i++) {
if (s[i][j] == '?') continue;
if (last == '0')
last = s[i][j];
else {
if (s[i][j] != last) break;
}
}
if (last == '0')
o.push_back('a');
else if (i != n)
o.push_back('?');
else
o.push_back(last);
}
cout << o << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long int mod = 1e9 + 7;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T>
void print(vector<T> v) {
for (T i : v) cout << i << " ";
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& v) {
for (vector<T>& vv : v) {
for (T& i : vv) cout << i << " ";
cout << '\n';
}
}
template <typename T>
void read(vector<T>& v) {
for (T& i : v) cin >> i;
}
template <typename T>
void read(T&& t) {
cin >> t;
}
template <typename T, typename... Args>
void read(T&& t, Args&&... args) {
cin >> t;
read(forward<Args>(args)...);
}
template <typename T>
void print(T&& t) {
cout << t << '\n';
}
template <typename T, typename... Args>
void print(T&& t, Args&&... args) {
cout << t << " ";
print(forward<Args>(args)...);
}
bool checkPrime(ll n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
ll binpow(ll a, ll b, ll mod) {
a %= mod;
ll res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
ll to_int(string str) {
ll n = str.size(), num = 0;
for (int i = 0; i < n; i++) {
num = num * 10 + (str[i] - '0');
}
return num;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll sumofDigits(ll n) {
ll sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool isPalindrome(string& str) {
int n = str.size();
for (int i = 0; i < n; i++) {
if (str[i] != str[n - i - 1]) {
return false;
}
}
return true;
}
string toBinary(ll n) {
string str = "";
while (n > 0) {
str += n % 2 + '0';
n /= 2;
}
reverse(str.begin(), str.end());
return str;
}
ll toDecimal(string str) {
ll n = str.size(), ans = 0;
for (ll i = n - 1; i >= 0; i--) {
if (str[i] == '1') {
ans += pow(2, n - i - 1);
}
}
return ans;
}
ll modInverse(ll n, ll mod) { return binpow(n, mod - 2, mod); }
ll C(ll n, ll r, ll p) {
if (r == 0 or n == r) return 1;
ll fac[n + 1];
fac[0] = 1;
for (ll i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= p;
}
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
vector<ll> storePrimes;
void seive() {
vector<ll> is_prime(1e6 + 5, 0);
for (ll i = 2; i * i <= 1000000; i++) {
if (is_prime[i] == 0)
for (ll j = i * i; j <= 1000000; j += i) {
is_prime[j] = 1;
}
}
for (ll i = 1; i <= 1000000; i++) {
if (is_prime[i] == 0) {
storePrimes.push_back(i);
}
}
}
bool isPowerof2(ll n) {
if ((n & (n - 1)) == 0) return true;
return false;
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> rotateArray(vector<ll>& arr, ll d) {
ll n = arr.size();
vector<ll> tmp(n);
for (ll i = 0; i < n; i++) {
tmp[i] = arr[(i + d) % n];
tmp[i] = arr[(n + i - d) % n];
}
return tmp;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int n;
cin >> n;
int len;
map<int, set<char>> mp;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
len = str.size();
for (int j = 0; j < str.size(); j++) {
if (str[j] != '?') {
mp[j].insert(str[j]);
}
}
};
for (int i = 0; i < len; i++) {
if (mp[i].size() == 0) {
cout << "z";
} else if (mp[i].size() == 1) {
cout << *mp[i].begin();
} else {
cout << "?";
}
}
cout << endl;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long int mod = 1e9 + 7;
void __print(int x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(long long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char* x) { cerr << '\"' << x << '\"'; }
void __print(const string& x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V>& x) {
cerr << '{';
__print(x.first);
cerr << ',';
__print(x.second);
cerr << '}';
}
template <typename T>
void __print(const T& x) {
int f = 0;
cerr << '{';
for (auto& i : x) cerr << (f++ ? "," : ""), __print(i);
cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cerr << ", ";
_print(v...);
}
template <typename T>
void print(vector<T> v) {
for (T i : v) cout << i << " ";
cout << '\n';
}
template <typename T>
void print(vector<vector<T>>& v) {
for (vector<T>& vv : v) {
for (T& i : vv) cout << i << " ";
cout << '\n';
}
}
template <typename T>
void read(vector<T>& v) {
for (T& i : v) cin >> i;
}
template <typename T>
void read(T&& t) {
cin >> t;
}
template <typename T, typename... Args>
void read(T&& t, Args&&... args) {
cin >> t;
read(forward<Args>(args)...);
}
template <typename T>
void print(T&& t) {
cout << t << '\n';
}
template <typename T, typename... Args>
void print(T&& t, Args&&... args) {
cout << t << " ";
print(forward<Args>(args)...);
}
bool checkPrime(ll n) {
if (n <= 1) return false;
if (n <= 3) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
for (ll i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
ll binpow(ll a, ll b, ll mod) {
a %= mod;
ll res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return res;
}
ll to_int(string str) {
ll n = str.size(), num = 0;
for (int i = 0; i < n; i++) {
num = num * 10 + (str[i] - '0');
}
return num;
}
ll gcd(ll a, ll b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
ll lcm(ll a, ll b) { return (a / gcd(a, b) * b); }
ll sumofDigits(ll n) {
ll sum = 0;
while (n > 0) {
sum += n % 10;
n /= 10;
}
return sum;
}
bool isPalindrome(string& str) {
int n = str.size();
for (int i = 0; i < n; i++) {
if (str[i] != str[n - i - 1]) {
return false;
}
}
return true;
}
string toBinary(ll n) {
string str = "";
while (n > 0) {
str += n % 2 + '0';
n /= 2;
}
reverse(str.begin(), str.end());
return str;
}
ll toDecimal(string str) {
ll n = str.size(), ans = 0;
for (ll i = n - 1; i >= 0; i--) {
if (str[i] == '1') {
ans += pow(2, n - i - 1);
}
}
return ans;
}
ll modInverse(ll n, ll mod) { return binpow(n, mod - 2, mod); }
ll C(ll n, ll r, ll p) {
if (r == 0 or n == r) return 1;
ll fac[n + 1];
fac[0] = 1;
for (ll i = 1; i <= n; i++) {
fac[i] = fac[i - 1] * i;
fac[i] %= p;
}
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
vector<ll> storePrimes;
void seive() {
vector<ll> is_prime(1e6 + 5, 0);
for (ll i = 2; i * i <= 1000000; i++) {
if (is_prime[i] == 0)
for (ll j = i * i; j <= 1000000; j += i) {
is_prime[j] = 1;
}
}
for (ll i = 1; i <= 1000000; i++) {
if (is_prime[i] == 0) {
storePrimes.push_back(i);
}
}
}
bool isPowerof2(ll n) {
if ((n & (n - 1)) == 0) return true;
return false;
}
ll ceil(ll a, ll b) { return (a + b - 1) / b; }
vector<ll> rotateArray(vector<ll>& arr, ll d) {
ll n = arr.size();
vector<ll> tmp(n);
for (ll i = 0; i < n; i++) {
tmp[i] = arr[(i + d) % n];
tmp[i] = arr[(n + i - d) % n];
}
return tmp;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
;
int n;
cin >> n;
int len;
map<int, set<char>> mp;
for (int i = 0; i < n; i++) {
string str;
cin >> str;
len = str.size();
for (int j = 0; j < str.size(); j++) {
if (str[j] != '?') {
mp[j].insert(str[j]);
}
}
};
for (int i = 0; i < len; i++) {
if (mp[i].size() == 0) {
cout << "z";
} else if (mp[i].size() == 1) {
cout << *mp[i].begin();
} else {
cout << "?";
}
}
cout << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string tmp = "x";
string out = "";
cin >> n;
vector<string> strings(n);
for (int i = 0; i < n; i++) cin >> strings[i];
for (int i = 0, j = 0; i < strings[0].size(); i++, j = 0) {
for (; j < n; j++) {
if (tmp == "x" && strings[j][i] != '?') {
tmp = strings[j][i];
break;
}
}
for (j++; j < n; j++) {
if (strings[j][i] != '?' && tmp[0] != strings[j][i]) tmp = "?";
}
out += tmp;
tmp = "x";
}
cout << out << endl;
}
|
### Prompt
Generate a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
string tmp = "x";
string out = "";
cin >> n;
vector<string> strings(n);
for (int i = 0; i < n; i++) cin >> strings[i];
for (int i = 0, j = 0; i < strings[0].size(); i++, j = 0) {
for (; j < n; j++) {
if (tmp == "x" && strings[j][i] != '?') {
tmp = strings[j][i];
break;
}
}
for (j++; j < n; j++) {
if (strings[j][i] != '?' && tmp[0] != strings[j][i]) tmp = "?";
}
out += tmp;
tmp = "x";
}
cout << out << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char a[100005], res[100005];
int main() {
int n, m;
scanf("%d\n", &n);
for (int i = 0; i <= 100000; i++) res[i] = '.';
for (int i1 = 1; i1 <= n; i1++) {
if (i1 != n)
scanf("%s\n", &a);
else
scanf("%s", &a);
m = strlen(a);
for (int i = 0; i < m; i++) {
if (a[i] == '?') continue;
if (res[i] == '.')
res[i] = a[i];
else if (res[i] != a[i]) {
res[i] = '?';
}
}
}
for (int i = 0; i < m; i++) {
if (res[i] == '.')
printf("x");
else
printf("%c", res[i]);
}
printf("\n");
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char a[100005], res[100005];
int main() {
int n, m;
scanf("%d\n", &n);
for (int i = 0; i <= 100000; i++) res[i] = '.';
for (int i1 = 1; i1 <= n; i1++) {
if (i1 != n)
scanf("%s\n", &a);
else
scanf("%s", &a);
m = strlen(a);
for (int i = 0; i < m; i++) {
if (a[i] == '?') continue;
if (res[i] == '.')
res[i] = a[i];
else if (res[i] != a[i]) {
res[i] = '?';
}
}
}
for (int i = 0; i < m; i++) {
if (res[i] == '.')
printf("x");
else
printf("%c", res[i]);
}
printf("\n");
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
char str[MAXN], ans[MAXN];
bool flag[MAXN];
int main() {
int n;
memset(flag, false, sizeof(flag));
scanf("%d%s", &n, ans);
int l = strlen(ans);
while (--n) {
scanf("%s", str);
for (int i = 0; i < l; ++i)
if (ans[i] == '?' && !flag[i])
ans[i] = str[i];
else if (ans[i] != str[i] && str[i] != '?') {
ans[i] = '?';
flag[i] = true;
}
}
for (int i = 0; i < l; ++i) {
if (ans[i] == '?' && !flag[i]) ans[i] = 'w';
putchar(ans[i]);
}
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100005;
char str[MAXN], ans[MAXN];
bool flag[MAXN];
int main() {
int n;
memset(flag, false, sizeof(flag));
scanf("%d%s", &n, ans);
int l = strlen(ans);
while (--n) {
scanf("%s", str);
for (int i = 0; i < l; ++i)
if (ans[i] == '?' && !flag[i])
ans[i] = str[i];
else if (ans[i] != str[i] && str[i] != '?') {
ans[i] = '?';
flag[i] = true;
}
}
for (int i = 0; i < l; ++i) {
if (ans[i] == '?' && !flag[i]) ans[i] = 'w';
putchar(ans[i]);
}
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, patt[N];
string s;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); ++j)
if (s[j] != '?') {
if (patt[j] == 0)
patt[j] = s[j] - 'a' + 1;
else if (patt[j] != s[j] - 'a' + 1)
patt[j] = 27;
}
}
for (int i = 0; i < s.size(); ++i) {
if (patt[i] == 0)
cout << "a";
else if (patt[i] == 27)
cout << "?";
else
cout << (char)(patt[i] + 'a' - 1);
}
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int n, patt[N];
string s;
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); ++j)
if (s[j] != '?') {
if (patt[j] == 0)
patt[j] = s[j] - 'a' + 1;
else if (patt[j] != s[j] - 'a' + 1)
patt[j] = 27;
}
}
for (int i = 0; i < s.size(); ++i) {
if (patt[i] == 0)
cout << "a";
else if (patt[i] == 27)
cout << "?";
else
cout << (char)(patt[i] + 'a' - 1);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char str[100005];
char ans[100005];
int main(void) {
int n;
memset(ans, '*', sizeof(ans));
scanf("%d", &n);
int len;
while (n--) {
scanf("%s", str);
len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] != '?') {
if (ans[i] == '*')
ans[i] = str[i];
else if (ans[i] != str[i])
ans[i] = '?';
}
}
}
for (int i = 0; i < len; i++) printf("%c", (ans[i] == '*' ? 'a' : ans[i]));
puts("");
return 0;
}
|
### Prompt
Your challenge is to write a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char str[100005];
char ans[100005];
int main(void) {
int n;
memset(ans, '*', sizeof(ans));
scanf("%d", &n);
int len;
while (n--) {
scanf("%s", str);
len = strlen(str);
for (int i = 0; i < len; i++) {
if (str[i] != '?') {
if (ans[i] == '*')
ans[i] = str[i];
else if (ans[i] != str[i])
ans[i] = '?';
}
}
}
for (int i = 0; i < len; i++) printf("%c", (ans[i] == '*' ? 'a' : ans[i]));
puts("");
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.front() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.top() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os,
std::unordered_map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
string s[100100];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string ans;
for (int i = 0; i < (n); i++) {
cin >> s[i];
}
int x = n;
int y = ((int)(s[0]).size());
for (int j = 0; j < (y); j++) {
bool all_hatena = true;
char now;
for (int i = 0; i < (x); i++) {
if (s[i][j] != '?') {
all_hatena = false;
now = s[i][j];
break;
}
}
if (all_hatena) {
ans += 'a';
continue;
}
bool OK = true;
for (int i = 0; i < (x); i++) {
if (s[i][j] == '?' || s[i][j] == now) {
;
} else {
OK = false;
break;
}
}
if (OK) {
ans += now;
} else {
ans += '?';
}
}
cout << ans << "\n";
return 0;
}
|
### Prompt
Generate a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v) os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.front() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.top() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os,
std::unordered_map<T, K> &make_pair) {
int remain = make_pair.size();
os << "{";
for (auto e : make_pair)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
string s[100100];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int n;
cin >> n;
string ans;
for (int i = 0; i < (n); i++) {
cin >> s[i];
}
int x = n;
int y = ((int)(s[0]).size());
for (int j = 0; j < (y); j++) {
bool all_hatena = true;
char now;
for (int i = 0; i < (x); i++) {
if (s[i][j] != '?') {
all_hatena = false;
now = s[i][j];
break;
}
}
if (all_hatena) {
ans += 'a';
continue;
}
bool OK = true;
for (int i = 0; i < (x); i++) {
if (s[i][j] == '?' || s[i][j] == now) {
;
} else {
OK = false;
break;
}
}
if (OK) {
ans += now;
} else {
ans += '?';
}
}
cout << ans << "\n";
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
char cacat[100005], sir[100005], s[100005];
int indici[100005];
int main() {
cin.sync_with_stdio(false);
int i, n, len, test, j;
char c;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
test = strlen(s);
strcat(sir, s);
indici[i] = test * (i - 1);
}
len = strlen(s);
for (j = 1; j <= len; j++) {
test = 0;
for (i = 1; i <= n; i++) {
if (sir[indici[i]] >= 'a' && sir[indici[i]] <= 'z' && test == 1 &&
sir[indici[i]] != c)
test = 2;
else if ((sir[indici[i]] >= 'a' && sir[indici[i]] <= 'z') && !test) {
test = 1;
c = sir[indici[i]];
}
indici[i]++;
}
if (test == 0)
s[j] = 'a';
else if (test == 1)
s[j] = c;
else if (test == 2)
s[j] = '?';
}
cout << (s + 1) << "\n";
return 0;
}
|
### Prompt
Please provide a cpp coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
char cacat[100005], sir[100005], s[100005];
int indici[100005];
int main() {
cin.sync_with_stdio(false);
int i, n, len, test, j;
char c;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> s;
test = strlen(s);
strcat(sir, s);
indici[i] = test * (i - 1);
}
len = strlen(s);
for (j = 1; j <= len; j++) {
test = 0;
for (i = 1; i <= n; i++) {
if (sir[indici[i]] >= 'a' && sir[indici[i]] <= 'z' && test == 1 &&
sir[indici[i]] != c)
test = 2;
else if ((sir[indici[i]] >= 'a' && sir[indici[i]] <= 'z') && !test) {
test = 1;
c = sir[indici[i]];
}
indici[i]++;
}
if (test == 0)
s[j] = 'a';
else if (test == 1)
s[j] = c;
else if (test == 2)
s[j] = '?';
}
cout << (s + 1) << "\n";
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
string a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int len = a[0].length();
for (int j = 0; j < len; j++) {
char tmp = '?';
for (int i = 0; i < n; i++) {
if (tmp != '?') {
if (a[i][j] != tmp && a[i][j] != '?') {
tmp = ' ';
break;
}
} else {
if (a[i][j] != tmp) tmp = a[i][j];
}
}
if (tmp == '?')
putchar('a');
else if (tmp == ' ')
putchar('?');
else
putchar(tmp);
}
return 0;
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 100005;
string a[N];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
cin >> a[i];
}
int len = a[0].length();
for (int j = 0; j < len; j++) {
char tmp = '?';
for (int i = 0; i < n; i++) {
if (tmp != '?') {
if (a[i][j] != tmp && a[i][j] != '?') {
tmp = ' ';
break;
}
} else {
if (a[i][j] != tmp) tmp = a[i][j];
}
}
if (tmp == '?')
putchar('a');
else if (tmp == ' ')
putchar('?');
else
putchar(tmp);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
set<char> a[100500];
void solve() {
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] != '?') a[j].insert(s[j]);
}
}
for (int i = 0; i < s.size(); i++) {
if (a[i].empty())
cout << 'a';
else {
if (a[i].size() > 1)
cout << '?';
else
cout << *a[i].begin();
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
for (int i = 1; i <= T; i++) solve();
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
set<char> a[100500];
void solve() {
int n;
cin >> n;
string s;
for (int i = 0; i < n; i++) {
cin >> s;
for (int j = 0; j < s.size(); j++) {
if (s[j] != '?') a[j].insert(s[j]);
}
}
for (int i = 0; i < s.size(); i++) {
if (a[i].empty())
cout << 'a';
else {
if (a[i].size() > 1)
cout << '?';
else
cout << *a[i].begin();
}
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int T = 1;
for (int i = 1; i <= T; i++) solve();
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
set<char> v[MAXN];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m = ((int)(s).size());
for (int j = 0; j < ((int)(s).size()); j++)
if (s[j] != '?') v[j].insert(s[j]);
}
string ans;
for (int i = 0; i < m; i++) {
if (!((int)(v[i]).size()))
ans.push_back('a');
else if (((int)(v[i]).size()) == 1)
ans.push_back(*v[i].begin());
else
ans.push_back('?');
}
cout << ans << endl;
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100 * 1000 + 10;
set<char> v[MAXN];
int main() {
ios::sync_with_stdio(false);
int n;
cin >> n;
int m = 0;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
m = ((int)(s).size());
for (int j = 0; j < ((int)(s).size()); j++)
if (s[j] != '?') v[j].insert(s[j]);
}
string ans;
for (int i = 0; i < m; i++) {
if (!((int)(v[i]).size()))
ans.push_back('a');
else if (((int)(v[i]).size()) == 1)
ans.push_back(*v[i].begin());
else
ans.push_back('?');
}
cout << ans << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
string ch;
char c;
int main() {
int n, k;
scanf("%d", &n);
cin >> ch;
int len = ch.length();
for (int i = 1; i < n; i++) {
for (int k = 0; k < len; k++) {
cin >> c;
if (ch[k] == c) continue;
if (ch[k] == '.') continue;
if (ch[k] == '?' && c != '?')
ch[k] = c;
else if (ch[k] != '?' && c == '?')
;
else
ch[k] = '.';
}
}
for (int i = 0; i < len; i++) {
if (ch[i] == '?')
printf("x");
else if (ch[i] == '.')
printf("?");
else
printf("%c", ch[i]);
}
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
string ch;
char c;
int main() {
int n, k;
scanf("%d", &n);
cin >> ch;
int len = ch.length();
for (int i = 1; i < n; i++) {
for (int k = 0; k < len; k++) {
cin >> c;
if (ch[k] == c) continue;
if (ch[k] == '.') continue;
if (ch[k] == '?' && c != '?')
ch[k] = c;
else if (ch[k] != '?' && c == '?')
;
else
ch[k] = '.';
}
}
for (int i = 0; i < len; i++) {
if (ch[i] == '?')
printf("x");
else if (ch[i] == '.')
printf("?");
else
printf("%c", ch[i]);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
vector<string> v;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
string s;
cin >> s;
v.push_back(s);
}
string ans(v[0].size(), '?');
for (int i = 0; i < (int)ans.size(); i++) {
int cnt[26] = {}, h = 0;
for (int j = 0; j < N; j++) {
if (v[j][i] == '?')
h++;
else
cnt[v[j][i] - 'a']++;
}
int z = 0;
char c = 'a';
for (int j = 0; j < 26; j++)
if (cnt[j]) {
z++;
c = j + 'a';
}
if (z < 2) ans[i] = c;
}
cout << ans << endl;
return 0;
}
|
### Prompt
Your challenge is to write a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int N;
vector<string> v;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
string s;
cin >> s;
v.push_back(s);
}
string ans(v[0].size(), '?');
for (int i = 0; i < (int)ans.size(); i++) {
int cnt[26] = {}, h = 0;
for (int j = 0; j < N; j++) {
if (v[j][i] == '?')
h++;
else
cnt[v[j][i] - 'a']++;
}
int z = 0;
char c = 'a';
for (int j = 0; j < 26; j++)
if (cnt[j]) {
z++;
c = j + 'a';
}
if (z < 2) ans[i] = c;
}
cout << ans << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tam;
string S[100005];
cin >> n;
for (int i = 0; i < n; i++) cin >> S[i];
tam = S[0].size();
for (int j = 0; j < tam; j++) {
char c;
bool marca = false;
bool letra = false;
bool fin = false;
for (int i = 0; i < n; i++) {
if (S[i][j] == '?')
marca = true;
else {
if (!letra) {
c = S[i][j];
letra = true;
} else {
if (c != S[i][j]) {
cout << "?";
fin = true;
break;
}
}
}
}
if (!fin)
if (letra)
cout << c;
else
cout << "a";
}
cout << endl;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, tam;
string S[100005];
cin >> n;
for (int i = 0; i < n; i++) cin >> S[i];
tam = S[0].size();
for (int j = 0; j < tam; j++) {
char c;
bool marca = false;
bool letra = false;
bool fin = false;
for (int i = 0; i < n; i++) {
if (S[i][j] == '?')
marca = true;
else {
if (!letra) {
c = S[i][j];
letra = true;
} else {
if (c != S[i][j]) {
cout << "?";
fin = true;
break;
}
}
}
}
if (!fin)
if (letra)
cout << c;
else
cout << "a";
}
cout << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
int sz = s[0].size();
string result(sz, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < sz; j++) {
if (s[i][j] != '?') {
if (result[j] == 0)
result[j] = s[i][j];
else if (result[j] != s[i][j])
result[j] = '?';
}
}
for (int i = 0; i < sz; i++)
if (result[i] == 0) result[i] = 'a';
cout << result << '\n';
return 0;
}
|
### Prompt
Your task is to create a cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
vector<string> s(n);
for (int i = 0; i < n; i++) cin >> s[i];
int sz = s[0].size();
string result(sz, 0);
for (int i = 0; i < n; i++)
for (int j = 0; j < sz; j++) {
if (s[i][j] != '?') {
if (result[j] == 0)
result[j] = s[i][j];
else if (result[j] != s[i][j])
result[j] = '?';
}
}
for (int i = 0; i < sz; i++)
if (result[i] == 0) result[i] = 'a';
cout << result << '\n';
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int v[26][N];
int main() {
int n;
cin >> n;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); j++)
if (s[j] != '?') v[s[j] - 'a'][j]++;
}
string ans = "";
int pos = 0;
for (int i = 0; i < s.size(); ++i) {
int may = 0;
for (int j = 0; j < 26; j++) {
if (may < v[j][i]) {
may = v[j][i];
pos = j;
}
}
int a1 = 0;
bool flag = 0;
char x = '*';
for (int j = 0; j < 26; j++) {
if (may == v[j][i] or (v[j][i] != may && v[j][i])) a1++, flag = 1;
if (flag && !v[j][i]) {
if (a1 <= 1) x = j;
flag = 0;
}
}
if (a1 == 1)
ans += char(pos) + 'a';
else {
if (may != 0)
ans += '?';
else
ans += char(x) + 'a';
}
}
cout << ans << '\n';
return 0;
}
|
### Prompt
Construct a Cpp code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 5;
int v[26][N];
int main() {
int n;
cin >> n;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
for (int j = 0; j < s.size(); j++)
if (s[j] != '?') v[s[j] - 'a'][j]++;
}
string ans = "";
int pos = 0;
for (int i = 0; i < s.size(); ++i) {
int may = 0;
for (int j = 0; j < 26; j++) {
if (may < v[j][i]) {
may = v[j][i];
pos = j;
}
}
int a1 = 0;
bool flag = 0;
char x = '*';
for (int j = 0; j < 26; j++) {
if (may == v[j][i] or (v[j][i] != may && v[j][i])) a1++, flag = 1;
if (flag && !v[j][i]) {
if (a1 <= 1) x = j;
flag = 0;
}
}
if (a1 == 1)
ans += char(pos) + 'a';
else {
if (may != 0)
ans += '?';
else
ans += char(x) + 'a';
}
}
cout << ans << '\n';
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int n;
string s[100009];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
string ans;
for (int i = 0; i < s[0].size(); i++) {
int num[26] = {0};
for (int j = 0; j < n; j++) {
if (s[j][i] == '?') continue;
num[s[j][i] - 'a']++;
}
int x = 0, id = -1;
for (int j = 0; j < 26; j++) {
if (num[j] > 0) {
x++;
id = j;
}
}
if (x > 1) {
ans += '?';
} else if (x == 0) {
ans += 'a';
} else {
ans += id + 'a';
}
}
cout << ans << endl;
}
|
### Prompt
Construct a CPP code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int n;
string s[100009];
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> s[i];
}
string ans;
for (int i = 0; i < s[0].size(); i++) {
int num[26] = {0};
for (int j = 0; j < n; j++) {
if (s[j][i] == '?') continue;
num[s[j][i] - 'a']++;
}
int x = 0, id = -1;
for (int j = 0; j < 26; j++) {
if (num[j] > 0) {
x++;
id = j;
}
}
if (x > 1) {
ans += '?';
} else if (x == 0) {
ans += 'a';
} else {
ans += id + 'a';
}
}
cout << ans << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 107, N = 100005;
int n;
bool done[N];
string x, ans;
int main() {
cin >> n;
cin >> x;
ans = x;
for (int i = 2; i <= n; i++) {
cin >> x;
for (int j = 0; j < x.size(); j++) {
if (!done[j]) {
if (ans[j] == '?' && x[j] != ans[j]) {
ans[j] = x[j];
} else {
if (ans[j] != '?' && x[j] != '?' && ans[j] != x[j]) {
ans[j] = '?';
done[j] = true;
}
}
}
}
}
for (int i = 0; i < ans.size(); i++) {
if (ans[i] == '?' && !done[i]) {
ans[i] = 'a';
}
cout << ans[i];
}
cout << "\n";
return 0;
}
|
### Prompt
Please create a solution in Cpp to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 107, N = 100005;
int n;
bool done[N];
string x, ans;
int main() {
cin >> n;
cin >> x;
ans = x;
for (int i = 2; i <= n; i++) {
cin >> x;
for (int j = 0; j < x.size(); j++) {
if (!done[j]) {
if (ans[j] == '?' && x[j] != ans[j]) {
ans[j] = x[j];
} else {
if (ans[j] != '?' && x[j] != '?' && ans[j] != x[j]) {
ans[j] = '?';
done[j] = true;
}
}
}
}
}
for (int i = 0; i < ans.size(); i++) {
if (ans[i] == '?' && !done[i]) {
ans[i] = 'a';
}
cout << ans[i];
}
cout << "\n";
return 0;
}
```
|
#include <bits/stdc++.h>
#pragma comment(linker, "/Stack:256000000")
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
vector<string> s(n);
for (int i = 0; i < n; ++i) cin >> s[i];
int l = s[0].length();
vector<map<char, int> > m(l);
vector<char> ans(l);
for (int i = 0; i < l; ++i) {
char c = 122;
for (int j = 0; j < n; ++j) {
if (s[j][i] != '?') {
++m[i][s[j][i]];
c = s[j][i];
}
}
if (m[i].size() == 0)
ans[i] = 'a';
else if (m[i].size() == 1)
ans[i] = c;
else
ans[i] = '?';
}
for (int i = 0; i < l; ++i) printf("%c", ans[i]);
return 0;
}
|
### Prompt
Develop a solution in cpp to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
#pragma comment(linker, "/Stack:256000000")
using namespace std;
int main() {
int n;
scanf("%d\n", &n);
vector<string> s(n);
for (int i = 0; i < n; ++i) cin >> s[i];
int l = s[0].length();
vector<map<char, int> > m(l);
vector<char> ans(l);
for (int i = 0; i < l; ++i) {
char c = 122;
for (int j = 0; j < n; ++j) {
if (s[j][i] != '?') {
++m[i][s[j][i]];
c = s[j][i];
}
}
if (m[i].size() == 0)
ans[i] = 'a';
else if (m[i].size() == 1)
ans[i] = c;
else
ans[i] = '?';
}
for (int i = 0; i < l; ++i) printf("%c", ans[i]);
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
vector<string> Vect;
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
Vect.push_back(s);
}
string res;
int size = Vect[0].size();
for (int j = 0; j < size; ++j) {
char d = '#';
for (int i = 0; i < n; ++i) {
if (d != '?') {
if (d == '#') {
if (Vect[i][j] != '?') d = Vect[i][j];
} else {
if (d != Vect[i][j] && Vect[i][j] != '?') {
d = '?';
}
}
}
}
if (d == '#') d = 'a';
res += d;
}
cout << res;
return 0;
}
|
### Prompt
Please provide a CPP coded solution to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
vector<string> Vect;
int main() {
ios::sync_with_stdio(0);
long long n;
cin >> n;
string s;
for (int i = 0; i < n; ++i) {
cin >> s;
Vect.push_back(s);
}
string res;
int size = Vect[0].size();
for (int j = 0; j < size; ++j) {
char d = '#';
for (int i = 0; i < n; ++i) {
if (d != '?') {
if (d == '#') {
if (Vect[i][j] != '?') d = Vect[i][j];
} else {
if (d != Vect[i][j] && Vect[i][j] != '?') {
d = '?';
}
}
}
}
if (d == '#') d = 'a';
res += d;
}
cout << res;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
string s[maxn];
char sss[maxn];
int n;
int num[maxn];
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> s[i];
memset(num, 0, sizeof(num));
int len;
len = s[0].size();
int flag1, flag, num;
char ss;
for (int j = 0; j < len; j++) {
flag1 = 0;
flag = 0;
num = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] != '?') {
ss = s[i][j];
flag1 = 1;
break;
}
}
if (flag1) {
for (int i = 0; i < n; i++) {
if (s[i][j] != '?' && s[i][j] != ss) {
flag = 1;
break;
}
}
if (flag)
sss[j] = '?';
else
sss[j] = ss;
} else {
sss[j] = 'x';
}
}
for (int i = 0; i < len; i++) cout << sss[i];
cout << endl;
}
return 0;
}
|
### Prompt
Create a solution in cpp for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000 + 10;
string s[maxn];
char sss[maxn];
int n;
int num[maxn];
int main() {
while (cin >> n) {
for (int i = 0; i < n; i++) cin >> s[i];
memset(num, 0, sizeof(num));
int len;
len = s[0].size();
int flag1, flag, num;
char ss;
for (int j = 0; j < len; j++) {
flag1 = 0;
flag = 0;
num = 0;
for (int i = 0; i < n; i++) {
if (s[i][j] != '?') {
ss = s[i][j];
flag1 = 1;
break;
}
}
if (flag1) {
for (int i = 0; i < n; i++) {
if (s[i][j] != '?' && s[i][j] != ss) {
flag = 1;
break;
}
}
if (flag)
sss[j] = '?';
else
sss[j] = ss;
} else {
sss[j] = 'x';
}
}
for (int i = 0; i < len; i++) cout << sss[i];
cout << endl;
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
int N;
string arr[100000 + 10];
char ans[100000 + 10];
int main() {
int t, kase = 0, a, b, i, j, k, l, mx;
while (scanf("%d", &N) == 1) {
for (i = 0; i < N; i++) {
cin >> arr[i];
}
int len = arr[0].size();
char frst, scnd;
for (i = 0; i < len; i++) {
frst = '*';
for (j = 0; j < N; j++) {
if (arr[j][i] == '?')
continue;
else {
if (frst == '*')
frst = arr[j][i];
else if (arr[j][i] != frst) {
frst = '?';
break;
}
}
}
if (frst == '*')
ans[i] = 'x';
else if (frst == '?')
ans[i] = frst;
else
ans[i] = frst;
}
ans[len] = '\0';
printf("%s\n", ans);
}
return 0;
}
|
### Prompt
Your challenge is to write a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T1>
void deb(T1 e1) {
cout << e1 << endl;
}
template <class T1, class T2>
void deb(T1 e1, T2 e2) {
cout << e1 << " " << e2 << endl;
}
template <class T1, class T2, class T3>
void deb(T1 e1, T2 e2, T3 e3) {
cout << e1 << " " << e2 << " " << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void deb(T1 e1, T2 e2, T3 e3, T4 e4) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << endl;
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void deb(T1 e1, T2 e2, T3 e3, T4 e4, T5 e5, T6 e6) {
cout << e1 << " " << e2 << " " << e3 << " " << e4 << " " << e5 << " " << e6
<< endl;
}
int dx[] = {0, 0, 1, -1};
int dy[] = {-1, 1, 0, 0};
int N;
string arr[100000 + 10];
char ans[100000 + 10];
int main() {
int t, kase = 0, a, b, i, j, k, l, mx;
while (scanf("%d", &N) == 1) {
for (i = 0; i < N; i++) {
cin >> arr[i];
}
int len = arr[0].size();
char frst, scnd;
for (i = 0; i < len; i++) {
frst = '*';
for (j = 0; j < N; j++) {
if (arr[j][i] == '?')
continue;
else {
if (frst == '*')
frst = arr[j][i];
else if (arr[j][i] != frst) {
frst = '?';
break;
}
}
}
if (frst == '*')
ans[i] = 'x';
else if (frst == '?')
ans[i] = frst;
else
ans[i] = frst;
}
ans[len] = '\0';
printf("%s\n", ans);
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = (0); i < (int)(n); ++i) cin >> v[i];
int m = v[0].size();
for (int i = (0); i < (int)(m); ++i) {
set<char> s;
for (int j = (0); j < (int)(n); ++j)
if (v[j][i] != '?') s.insert(v[j][i]);
if (s.empty())
cout << 'a';
else if (s.size() == 1)
cout << *s.begin();
else
cout << '?';
}
cout << endl;
return 0;
}
|
### Prompt
Please formulate a CPP solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<string> v(n);
for (int i = (0); i < (int)(n); ++i) cin >> v[i];
int m = v[0].size();
for (int i = (0); i < (int)(m); ++i) {
set<char> s;
for (int j = (0); j < (int)(n); ++j)
if (v[j][i] != '?') s.insert(v[j][i]);
if (s.empty())
cout << 'a';
else if (s.size() == 1)
cout << *s.begin();
else
cout << '?';
}
cout << endl;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long double EPS = 1e-15;
const long double PI = 3.14159265358979323;
int main() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
string ans = a[0];
for (int j = 0; j < ans.size(); ++j) {
for (int i = 1; i < n; ++i) {
if (a[i][j] != '?' && ans[j] == '?') ans[j] = a[i][j];
if (ans[j] != '?' && a[i][j] != '?' && ans[j] != a[i][j]) {
ans[j] = '?';
break;
}
}
}
for (int i = 0; i < ans.size(); ++i) {
bool c = 0;
for (int j = 0; j < n; ++j) {
if (ans[i] == '?' && a[j][i] == '?')
c = 1;
else {
c = 0;
break;
}
}
if (c) ans[i] = 'a';
}
cout << ans;
return 0;
}
|
### Prompt
Create a solution in CPP for the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 7;
const long double EPS = 1e-15;
const long double PI = 3.14159265358979323;
int main() {
int n;
cin >> n;
vector<string> a(n);
for (int i = 0; i < n; ++i) {
cin >> a[i];
}
string ans = a[0];
for (int j = 0; j < ans.size(); ++j) {
for (int i = 1; i < n; ++i) {
if (a[i][j] != '?' && ans[j] == '?') ans[j] = a[i][j];
if (ans[j] != '?' && a[i][j] != '?' && ans[j] != a[i][j]) {
ans[j] = '?';
break;
}
}
}
for (int i = 0; i < ans.size(); ++i) {
bool c = 0;
for (int j = 0; j < n; ++j) {
if (ans[i] == '?' && a[j][i] == '?')
c = 1;
else {
c = 0;
break;
}
}
if (c) ans[i] = 'a';
}
cout << ans;
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
string a[n + 1];
for (long long i = 0; i < n; i++) cin >> a[i];
long long len = a[0].size();
string res = "";
for (long long i = 0; i < len; i++) {
map<char, long long> mp;
for (long long j = 0; j < n; j++) {
mp[a[j][i]]++;
}
long long ans = 0, ans1 = 0;
char vis[30] = {0}, ch;
for (auto x : mp) {
if (x.first == '?')
ans++;
else {
if (vis[x.first - 'a'] == 0) {
ans1++;
vis[x.first] = 1;
ch = x.first;
}
}
}
if (ans1 == 0) {
res += 'a';
} else if (ans1 == 1) {
res += ch;
} else
res += '?';
}
cout << res << endl;
}
|
### Prompt
Please formulate a Cpp solution to the following problem:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n;
cin >> n;
string a[n + 1];
for (long long i = 0; i < n; i++) cin >> a[i];
long long len = a[0].size();
string res = "";
for (long long i = 0; i < len; i++) {
map<char, long long> mp;
for (long long j = 0; j < n; j++) {
mp[a[j][i]]++;
}
long long ans = 0, ans1 = 0;
char vis[30] = {0}, ch;
for (auto x : mp) {
if (x.first == '?')
ans++;
else {
if (vis[x.first - 'a'] == 0) {
ans1++;
vis[x.first] = 1;
ch = x.first;
}
}
}
if (ans1 == 0) {
res += 'a';
} else if (ans1 == 1) {
res += ch;
} else
res += '?';
}
cout << res << endl;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
string* str = new string[n];
string s = "";
for (int i = 0; i < n; i++) {
cin >> str[i];
}
int i = 0;
for (i = 0;; i++) {
if (str[0][i] == '\0') break;
}
int length = i;
char s1 = '?';
char* test;
bool* check = new bool[length];
test = new char[length];
for (int i = 0; i < length; i++) {
test[i] = ' ';
check[i] = false;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < length; j++) {
if (test[j] == ' ') {
if (str[i][j] != '?') test[j] = str[i][j];
} else if (test[j] != str[i][j] && str[i][j] != '?') {
if (test[j] != '?') {
test[j] = '?';
check[j] = true;
} else if (!check[j])
test[j] = str[i][j];
}
}
}
for (int i = 0; i < length; i++) {
if (test[i] == ' ')
cout << 'x';
else
cout << test[i];
}
return 0;
}
|
### Prompt
Construct a cpp code solution to the problem outlined:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int main() {
int n = 0;
cin >> n;
string* str = new string[n];
string s = "";
for (int i = 0; i < n; i++) {
cin >> str[i];
}
int i = 0;
for (i = 0;; i++) {
if (str[0][i] == '\0') break;
}
int length = i;
char s1 = '?';
char* test;
bool* check = new bool[length];
test = new char[length];
for (int i = 0; i < length; i++) {
test[i] = ' ';
check[i] = false;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < length; j++) {
if (test[j] == ' ') {
if (str[i][j] != '?') test[j] = str[i][j];
} else if (test[j] != str[i][j] && str[i][j] != '?') {
if (test[j] != '?') {
test[j] = '?';
check[j] = true;
} else if (!check[j])
test[j] = str[i][j];
}
}
}
for (int i = 0; i < length; i++) {
if (test[i] == ' ')
cout << 'x';
else
cout << test[i];
}
return 0;
}
```
|
#include <bits/stdc++.h>
using namespace std;
int maximum(int a, int b) {
if (a > b)
return a;
else
return b;
}
bool cmp(const pair<int, int>& firs, const pair<int, int>& sec) {
return firs.first < sec.first;
}
string in[100005];
char mark[100005];
int lag[100005];
int main() {
int n;
int l, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
cin >> in[i];
}
l = in[0].size();
for (i = 0; i < l; i++) {
mark[i] = in[0][i];
}
int j;
for (i = 1; i < n; i++) {
for (j = 0; j < l; j++) {
if (mark[j] == in[i][j]) {
continue;
} else {
if (mark[j] == '?') {
mark[j] = in[i][j];
} else if (mark[j] != '?' && in[i][j] != '?') {
lag[j] = 1;
}
}
}
}
for (i = 0; i < l; i++) {
if (lag[i] == 1)
printf("?");
else {
if (mark[i] == '?')
printf("a");
else
printf("%c", mark[i]);
}
}
return 0;
}
|
### Prompt
Develop a solution in Cpp to the problem described below:
Developers often face with regular expression patterns. A pattern is usually defined as a string consisting of characters and metacharacters that sets the rules for your search. These patterns are most often used to check whether a particular string meets the certain rules.
In this task, a pattern will be a string consisting of small English letters and question marks ('?'). The question mark in the pattern is a metacharacter that denotes an arbitrary small letter of the English alphabet. We will assume that a string matches the pattern if we can transform the string into the pattern by replacing the question marks by the appropriate characters. For example, string aba matches patterns: ???, ??a, a?a, aba.
Programmers that work for the R1 company love puzzling each other (and themselves) with riddles. One of them is as follows: you are given n patterns of the same length, you need to find a pattern that contains as few question marks as possible, and intersects with each of the given patterns. Two patterns intersect if there is a string that matches both the first and the second pattern. Can you solve this riddle?
Input
The first line contains a single integer n (1 ≤ n ≤ 105) — the number of patterns. Next n lines contain the patterns.
It is guaranteed that the patterns can only consist of small English letters and symbols '?'. All patterns are non-empty and have the same length. The total length of all the patterns does not exceed 105 characters.
Output
In a single line print the answer to the problem — the pattern with the minimal number of signs '?', which intersects with each of the given ones. If there are several answers, print any of them.
Examples
Input
2
?ab
??b
Output
xab
Input
2
a
b
Output
?
Input
1
?a?b
Output
cacb
Note
Consider the first example. Pattern xab intersects with each of the given patterns. Pattern ??? also intersects with each of the given patterns, but it contains more question signs, hence it is not an optimal answer. Clearly, xab is the optimal answer, because it doesn't contain any question sign. There are a lot of other optimal answers, for example: aab, bab, cab, dab and so on.
### Response
```cpp
#include <bits/stdc++.h>
using namespace std;
int maximum(int a, int b) {
if (a > b)
return a;
else
return b;
}
bool cmp(const pair<int, int>& firs, const pair<int, int>& sec) {
return firs.first < sec.first;
}
string in[100005];
char mark[100005];
int lag[100005];
int main() {
int n;
int l, i;
scanf("%d", &n);
for (i = 0; i < n; i++) {
cin >> in[i];
}
l = in[0].size();
for (i = 0; i < l; i++) {
mark[i] = in[0][i];
}
int j;
for (i = 1; i < n; i++) {
for (j = 0; j < l; j++) {
if (mark[j] == in[i][j]) {
continue;
} else {
if (mark[j] == '?') {
mark[j] = in[i][j];
} else if (mark[j] != '?' && in[i][j] != '?') {
lag[j] = 1;
}
}
}
}
for (i = 0; i < l; i++) {
if (lag[i] == 1)
printf("?");
else {
if (mark[i] == '?')
printf("a");
else
printf("%c", mark[i]);
}
}
return 0;
}
```
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.