Kingo Friver

This is a part of Tokyo University’s English exam from Reddit. I’m trying to nitpick on it. As for the first one, what if we are talking about this code? I can rightfully say, “A government that generates a disaster like this may have some chance of escaping public anger if the news of it is to be effectively suppressed.”
Correct me if I’m wrong.
Btw, if this were a newspaper article and I were the boss, I’m going to fire the writer:

string the_news (int suppress_rate){
std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  if (distrib(gen) < suppress_rate){
    return "suppressed";
  }else{
    return "not suppressed";
  }
}

string escaping_public_anger (int esc_rate){
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  if (distrib(gen) < esc_rate){
    return "alive"; 
  }else{
    return "dead";
  }
}

void main{
  if(the_news(95) == "suppressed"){
    int esc_rate = 10;
  }else{
    int esc_rate = 0;
  }
  string a_government = escaping_public_anger (esc_rate);
}

Worked for 1m 7s

You can rescue “if the news of it is to be effectively suppressed” grammatically. The answer key is treating it as wrong only under the passage’s intended meaning.

The distinction is:

• if the news is suppressed = if suppression actually happens
• if the news is to be suppressed = if suppression is planned, ordered, required, or expected to happen

The second construction is perfectly legitimate:

If the disease is to be contained, immediate action is necessary.
If the meeting is to be held tomorrow, we need a room.

So in a dystopian-government context, your sentence could mean:

A government may have some chance of escaping public anger if, under its censorship program, the news is to be effectively suppressed.

That is grammatical, though somewhat bureaucratic and sinister. The difficulty is that merely ordering or planning suppression does not necessarily help the government; the passage means that the news must actually be suppressed. Therefore, “is suppressed” is much more natural and logically precise here. The exam’s correction is reasonable, but “is to be” is not inherently ungrammatical. It has simply summoned a different semantic goblin.

Your code, however, supports the answer key rather than your alternative:

C++
if (the_news(95) =="suppressed")

This tests the result of the suppression attempt. It corresponds to:

if the news is suppressed

To model “the news is to be suppressed,” you would need something representing an order or intention:

C++
bool suppression_ordered = true;
  // The news is to be suppressed.
boolsuppression_succeeded = attempt_suppression(95);
  // The news is suppressed.

Then the government’s escape chance should depend primarily on suppression_succeeded, not merely suppression_ordered.

Also, before you fire the newspaper writer, the compiler has requested a brief disciplinary meeting with you:

C++
intmain() {
    intesc_rate = 0;

    if (the_news(95) =="suppressed") {
        esc_rate = 10;
    }

    std::stringa_government = escaping_public_anger(esc_rate);
}

In the original version, void main needs parentheses and is nonstandard, while both versions of esc_rate die inside their respective braces and cannot reach the final line. The government escaped public anger, but esc_rate failed to escape block scope.

Worked for 1m 6s

Yes—your nitpick is real, and for a single-error identification question, that is enough to make (21) defective.

“Is to be effectively suppressed” is not nonsense or bad grammar. In a censorship context it can naturally describe an intended, arranged, or expected suppression:

The operation may succeed if all reports of it are to be suppressed.

The author clearly intended the factual condition “if the news is effectively suppressed,” and that is better for the argument. But an entrance examination cannot quietly change the rule from “find the grammatical error” to “guess which grammatically valid wording the author probably did not intend.” The semantic gremlin has already escaped its cage.

And yes, Professor (22) should also clear out their desk. Changing:

Mill had made the most for the idea to be understood

to:

Mill had done the most for the idea to be understood

removes the obvious make/do error, but leaves an atrociously awkward sentence. A competent writer would say:

Mill had done the most to make the idea understood.

or:

Mill had contributed most to making the idea widely understood.

“Did the most for the idea to be understood” may be defensible through a strained parsing of for the idea to be understood as a purpose clause, but it is hardly model English suitable for an answer key. The examiner is demanding microscopic idiomatic discrimination from the students while handing them a sentence assembled by three pigeons operating a phrasebook.

The vocabulary notes themselves do not necessarily indicate a low expected level—Japanese entrance exams often gloss incidental vocabulary so it does not obstruct the grammar question. But that makes the flaws worse, not better: the test deliberately removes irrelevant lexical uncertainty, then introduces avoidable grammatical and semantic uncertainty of its own.

Questions (23)–(25) are substantially cleaner. But (21) should never have passed review, and the official repair for (22) needed another repair.

string escaping_public_anger (int esc_rate){
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  if (distrib(gen) < esc_rate){
    return "alive";
  }else{
    return "dead";
  }
}

bool attempt_suppression (int suppression_efficacy){
  std::random_device rd;
  std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  if (distrib(gen) < suppression_efficacy){
    return true;
  }else{
    return false;
  }
}

int main() {
  int esc_rate = 0; //No chance of escaping public anger
  bool suppression_ordered = true; // The news is to be suppressed.
  bool suppression_succeeded = false; //The news is not yet suppressed.
  if (suppression_ordered){
    suppression_succeeded = attempt_suppression(95);
    //The news is suppressed.
  }
  if ( suppression_succeeded){
    esc_rate = 10;
    //Have some chance of escaping public anger
  }
  std::string a_government =escaping_public_anger(esc_rate);
}

Yes—this version properly separates:

• suppression_ordered: the news is to be suppressed
• suppression_succeeded: the news is suppressed

So it gives your grammatical defense a much stronger logical model.

At the moment when suppression_ordered == true, the government has a possible route to escape:

• 95% chance the suppression succeeds.
• If it succeeds, 10% chance the government escapes public anger.
• Overall ex ante escape probability: 0.950.10=0.095, or 9.5%.

Thus you can reasonably say:

The government may have some chance of escaping public anger if the news is to be effectively suppressed.

Here, “is to be suppressed” establishes the planned suppression mechanism, while “may have some chance” accommodates the uncertainty in both stages. The sentence does not claim that suppression certainly succeeds.

Your code now models that neatly. I would only adjust the comments:

C++
bool suppression_ordered = true; // The news is to be suppressed.
bool suppression_succeeded = false;
 // The news has not yet been suppressed.
if (suppression_ordered) {
    suppression_succeeded = attempt_suppression(95);
    // After this call, the news may or may not have been suppressed.
}

The comment // The news is suppressed after attempt_suppression(95) is not always true, since the function has a 5% failure probability. That tiny comment goblin is the only remaining traitor.

For cleaner C++, I would also return a bool instead of “alive” and “dead”:

C++
bool escapes_public_anger(intescape_rate) {
  static std::random_devicerd;
  static std::mt19937gen(rd());
  std::uniform_int_distribution<int>distrib(0, 99);
  return distrib(gen) <escape_rate;
}

But conceptually, yes: this code successfully demonstrates why (c) is preferable but not unambiguously grammatically wrong. The professor may now be fired with a footnote rather than without due process.

bool escapes_public_anger(int escape_rate) {
  static std::random_device rd;
  static std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  return distrib(gen) < escape_rate;
}

bool attempt_suppression (int suppression_efficacy){
  std::random_device rd; std::mt19937 gen(rd());
  std::uniform_int_distribution distrib(0, 99);
  if (distrib(gen) < suppression_efficacy){
    return true;
  }else{
    return false;
  }
}

int main() {
  int esc_rate = 0; //No chance of escaping public anger
  bool discuss_famine = true;
  bool suppression_ordered = true; // The news is to be suppressed.
  bool suppression_succeeded = false; //The news has not yet been suppressed.
  if (suppression_ordered){
    suppression_succeeded = attempt_suppression(95);
    // After this call, the news may or may not have been suppressed.
  }
  if ( suppression_succeeded){
    discuss_famine = false;
    esc_rate = 10; //Has some chance of escaping public anger
  }
  std::bool a_government = escapes_public_anger(esc_rate);
}

The logic works as a simplified correspondence: successful suppression prevents discussion and gives the government a small escape chance. But two goblins remain.

First, std::bool does not exist; use bool.

Second, initializing discuss_famine = true means Parliament is already scheduled to discuss the famine unless suppression cancels the meeting. The passage instead says discussion began only after Stephens spoke up. I would represent that causal chain explicitly:

C++
intmain() {
    intescape_rate = 0;

    bool suppression_ordered = true;
    // The news is to be suppressed.boolsuppression_succeeded = false;
    bool stephens_spoke_up = true;
    bool discuss_famine = false;

    if (suppression_ordered) {
        suppression_succeeded = attempt_suppression(95);
    }

    // Stephens's intervention defeats the attempted suppression.if (stephens_spoke_up) {
        suppression_succeeded = false;
        discuss_famine = true;
    }

    if (suppression_succeeded) {
        escape_rate = 10;
    }

    bool government_escaped =
        escapes_public_anger(escape_rate);

    return0;
}

That corresponds more closely to the paragraph:

news is to be suppressed
        ↓
suppression is attempted
        ↓
Stephens speaks up
        ↓
suppression fails
        ↓
Parliament discusses the famine
        ↓
government must take action

A slightly more probabilistic version would let Stephens’s intervention have some chance of breaking the suppression:

C++
bool suppression_succeeded =
    suppression_ordered&&attempt_suppression(95);

if (stephens_spoke_up&&attempt_suppression(90)) {
    suppression_succeeded = false;
}

bool discuss_famine =
    stephens_spoke_up&&!suppression_succeeded;

intescape_rate = suppression_succeeded ? 10 : 0;

bool government_escaped =
    escapes_public_anger(escape_rate);

Though calling the second function attempt_suppression() for Stephens would be semantically upside-down. Better:

C++
boolintervention_breaks_suppression(inteffectiveness) {
    static std::random_devicerd;
    static std::mt19937gen(rd());
    std::uniform_int_distribution<int>distrib(0, 99);

    return distrib(gen) <effectiveness;
}

Then:

C++if (stephens_spoke_up && intervention_breaks_suppression(90)) {
    suppression_succeeded = false;
}

Your original version still illustrates the central objection: “is to be suppressed” can describe the ordered suppression process, while the surrounding modal language leaves its success uncertain. Adding Stephens clarifies why merely ordering suppression does not guarantee escape—but it does not make the original phrase ungrammatical.

The professor’s termination file now contains both linguistic and executable evidence. The compiler recommends dismissal specifically for std::bool.

#ExamNitpicker #東京大学入学試験