...
<Saika> I want to get some water from this strange lake. I have a bottle.
<Keeper> OK.
<Saika> Then I want to go forward to look into the parterre.
<Keeper> More details?
<Saika> Err..What will happen if I let some water drip on the flowers?
<Keeper> ...Err...The flowers will all become super-huge monsters and it will be very dangerous.
<Keeper> Ready to fight.
<Saika> WHAT THE HELL???
...
A tabletop role-playing game, or pen-and-paper role-playing game, or table-talk role-playing game is a form of role-playing game (RPG) in which the participants describe their characters' actions through speech. Participants determine the actions of their characters based on their characterization, and the actions will succeed or fail according to a formal system of rules and guidelines. Within the rules, players have the freedom to improvise. Their choices shape the direction and outcome of the game.
The outcomes of some actions are determined by the rules of the game. For example, while looking around the room, a character may or may not notice an important object or secret doorway, depending on the character's powers of perception. This usually involves rolling dice, and comparing the number rolled to their character's statistics to see whether the action was successful. Typically, the higher the character's score in a particular attribute, the higher their probability of success. Combat is resolved in a similar manner, depending on the character's combat skills and physical attributes.
From Wikipedia, by Sargoth. License: CC-by-sa 3.0.
Dice notation (also known as dice algebra, common dice notation, RPG dice notation, and several other titles) is a system to represent different combinations of dice in role-playing games using simple algebra-like notation such as "2d6 + 12".
In most role-playing games, dice rolls required by the system are given in the form of "NdX". N and X are variables, separated by the letter "d", which stands for dice. N is the number of dice to be rolled (usually omitted if 1), and X is the number of faces of each dice. For example, if a game would call for a roll of "d4" or "1d4", this would mean roll a 4-sided dice. While "3d6" would mean roll three six-sided dices. An X-sided dice can get an integer between 1 and X with equal probability.
To this basic notation, an additive modifier can be appended, yielding expressions of the form of "NdX + B". Here, B is a number to be added to the sum of the rolls. We can use a minus sign ("-") to indicate subtraction. So, "1d20 - 10" would indicate a roll of a single 20-sided dice with 10 being subtracted from the result. Further more, we can use multiplication ("*") or division ("/") to do some more compilcated calculations like "(2d6 + 5) * 10 / (12 - 3d6)".
To be specific, here is a standard BNF describes the dice notation:
<notation> ::= <term> "+" <notation>
| <term> "-" <notation>
| <term>
<term> ::= <factor> "*" <term>
| <factor> "/" <term>
| <factor>
<factor> ::= "(" <notation> ")"
| <integer>
| <dice>
<integer> ::= <digit> <integer>
| <digit>
<digit> ::= "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9"
<dice> ::= <integer> "d" <integer>
| "d" <integer>
To have a clearer result of a dice notation in a game, our poor player, Saika, decides to write a program as a dice bot. To standardize the output information, the program needs to generate a format string from user's input string. It should:
- Expand dice notations. The <dice> field like "3d5" should be expanded to "([d5] + [d5] + [d5])". If only one dice is rolled in this field, simply replaced it with "[dX]".
- Trim whitespaces. There should be one and only one space character existed around operators ("+" / "-" / "*" / "/"). No extra whitespaces characters (including "Tab" and "Space") are allowed in the format string.
- End with specific content. Add " = [Result]" to the end of the format string.
However, Saika is fighting against some indescribable monsters now. She has no time to write this program by herself. Please help her to finish it.
Input
There are multiple test cases. The first line of input contains an integer T indicating the number of test cases. For each test case:
There is a line contains a valid dice notation. The length of the notation won't exceed 2000.
Output
For each test case, output the format string.
Sample Input
3
d6+1
((2d6) +5)*((12* 3d6))
2d10 * d100
Sample Output
[d6] + 1 = [Result] ((([d6] + [d6])) + 5) * ((12 * ([d6] + [d6] + [d6]))) = [Result] ([d10] + [d10]) * [d100] = [Result]
大模擬，題目很長全是廢話，就是一個拆分算式。沒有考慮到大數的情況wa了幾次。
#include <bits/stdc++.h>
using namespace std;
struct node {
string x, y;
};
vector <node> v1;
vector <char> v2;
int Stoi(string str) {
int ans = 0, d = 1;
for (int i = str.size() - 1; i >= 0; i--) {
ans += (str[i] - '0') * d;
d *= 10;
}
return ans;
}
int main() {
int t;
cin >> t;
getchar();
while (t--) {
v1.clear();
v2.clear();
string text;
getline(cin, text);
for (int i = 0; i < text.size(); ) {
if (text[i] == ' ') text.erase(i, 1);
else i++;
}
for (unsigned int i = 0; i < text.size(); ) {
if (text[i] == '(' || text[i] == ')' || text[i] == '+' || text[i] == '-' || text[i] == '*' || text[i] == '/')
v2.push_back(text[i]), i++;
else if ((text[i] >= '0' && text[i] <= '9') || text[i] == 'd') {
int f = 0;
string tmp, a, b;
while ((text[i] >= '0' && text[i] <= '9') || text[i] == 'd') tmp += text[i++];
for (unsigned int k = 0; k < tmp.size(); k++) {
if (tmp[k] == 'd') {
f = 1;
continue;
}
if (!f) a += tmp[k];
else b += tmp[k];
}
node tmpnode;
tmpnode.x = a;
tmpnode.y = b;
v1.push_back(tmpnode);
v2.push_back('A');
}
else i++;
}
unsigned int t1 = 0, t2 = 0;
while (t1 != v1.size() || t2 != v2.size()) {
if (v2[t2] == '(' || v2[t2] == ')' || v2[t2] == '+' || v2[t2] == '-' || v2[t2] == '*' || v2[t2] == '/') {
if (v2[t2] != '(' && v2[t2] != ')') cout << " ";
cout << v2[t2];
if (v2[t2] != '(' && v2[t2] != ')') cout << " ";
}
else if (v2[t2] == 'A') {
if ((Stoi(v1[t1].x) == 1 || v1[t1].x.empty()) && Stoi(v1[t1].y)) cout << "[d" << v1[t1].y << "]";
else if (!Stoi(v1[t1].y)) cout << v1[t1].x;
else {
cout << "(";
for (int i = 0; i < Stoi(v1[t1].x); i++) {
cout << "[d" << v1[t1].y << "]";
if (i != Stoi(v1[t1].x) - 1) cout << " + ";
}
cout << ")";
}
t1++;
}
t2++;
}
cout << " = [Result]" << endl;
}
}