QOJ.ac

QOJ

ID	Problem	Submitter	Result	Time	Memory	Language	File size	Submit time	Judge time
#216759	#7186. "Memo" Game With a Hint	ucup-team2219	AC ✓	467ms	3868kb	C++14	4.3kb	2023-10-15 22:23:13	2023-10-15 22:23:13

Judging History

你现在查看的是最新测评结果

[2023-10-15 22:23:13]
评测

测评结果：AC
用时：467ms
内存：3868kb

查看

[2023-10-15 22:23:13]
提交

answer

#include <bits/stdc++.h>
#ifdef LOCAL
#include "cp_debug.h"
#else
#define debug(...) 42
#endif
#define rep(i,a,b) for(int i = a; i < b; ++i)
#define all(x) begin(x), end(x)
#define sz(x) (int)x.size()
using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<string, int> Op;

template<typename T> void read(T &x){
    x = 0;char ch = getchar();ll f = 1;
    while(!isdigit(ch)){if(ch == '-')f*=-1;ch=getchar();}
    while(isdigit(ch)){x = x*10+ch-48;ch=getchar();}x*=f;
}
template<typename T, typename... Args> void read(T &first, Args& ... args) {
    read(first);
    read(args...);
}
template<typename T> void write(T x) {
    if(x > 9) write(x/10);
    putchar(x%10 + '0');
}

mt19937 rng(19260817), rng2(3414);
string ground_truth;
int score = 0, last = -1;
bitset<50> revealed;

string query_simulated(int x) {
  // cout << (x+1) << endl
  // string resp;
  // cin >> resp;
  assert(x >= 0 && x < (int)ground_truth.length());
  assert(!revealed[x]);
  revealed.set(x);
  if(last == -1) {
    last = x;
    return string(1, ground_truth[x]) + '.';
  } else {
    if(ground_truth[last] == ground_truth[x]) {
      char op = '+';
      if(revealed.count() == 50) {
        op = '!';
      }
      last = -1;
      return string(1, ground_truth[x]) + op;
    } else {
      revealed.flip(last);
      revealed.flip(x);
      last = -1;
      ++score;
      return string(1, ground_truth[x]) + '-';
    }
  }
}

int play(string s, function<string(int)> query) {
  int miss = 0;

  auto solve_for = [&](char o) {
    map<char, int> mp;
    for(int i = 0; i < (int)s.length(); i++) if(s[i] == o) {
      string resp = query(i);
      assert(resp.length() == 2 && resp[1] == '.');
      s[i] = resp[0];
      if(mp.count(resp[0])) {
        int idx = mp[resp[0]];
        resp = query(idx);
        assert(resp[0] == s[i]);
        assert(resp[1] == '+' || resp[1] == '!');
        if(resp[1] == '!') {
          assert(o == '1');
          return;
        }
        mp.erase(resp[0]);
      } else {
        for(int j = i+1; j < (int)s.length(); j++) if(s[j] == o) {
          resp = query(j);
          if(resp[1] == '!') {
            assert(resp[0] == s[i]);
            assert(o == '1');
            return;
          } else if(resp[1] == '+') {
            assert(resp[0] == s[i]);
            s[j] = s[i];
          } else if(resp[1] == '-') {
            miss++;
            s[j] = resp[0];
            assert(s[i] != s[j]);
            assert(!mp.count(s[i]));
            mp[s[i]] = i;
            if(mp.count(s[j])) {
              resp = query(mp[s[j]]);
              assert(resp[0] == s[j] && resp[1] == '.');
              resp = query(j);
              assert(resp[0] == s[j] && (resp[1] == '+' || resp[1] == '!'));
              if(resp[1] == '!') {
                assert(o == '1');
                assert(mp.empty());
                return;
              }
              mp.erase(s[j]);
            } else {
              mp[s[j]] = j;
            }
          } else {
            assert(false);
          }
          break;
        }
      }
    }
    assert(o == '0');
    assert(mp.empty());
  };

  solve_for('0');
  solve_for('1');
  return miss;
}


void prepare() {
  string s;
  cin >> s;
  int best_score = 1e9;
  string best_encoding;
  ground_truth = s;
  rep(_,0,1000) {
    score = 0;
    revealed.reset();
    string choose = string(12, '0') + string(13, '1');
    shuffle(all(choose), rng2);
    string t;
    for(auto c: s) {
      t.push_back(choose[c-'A']);
    }
    int cscore = play(t, query_simulated);
    if(cscore < best_score) {
      best_score = score;
      best_encoding = t;
    }
  }
  cout << best_encoding << endl;
}

string query_realtime(int x) {
  cout << (x+1) << endl;
  string resp;
  cin >> resp;
  if(resp == "##") {
    exit(0);
  }
  return resp;
}

signed main() {
  string op;
  cin >> op;
  int T; read(T);
  while(T--) {
    if(op == "prepare") {
      prepare();
    } else if(op == "play") {
      string s;
      cin >> s;
      play(s, query_realtime);
    }
  }
  return 0;
}

Source code, Language: C++14

Details

Tip: Click on the bar to expand more detailed information

Test #1:

score: 100

Accepted

time: 6ms

memory: 3564kb

First Run Input

prepare
2
ABCDEFGHIJKLMNOPQRSTUVWXYABCDEFGHIJKLMNOPQRSTUVWXY
AABBCCDDEEFFGGHHIIJJKKLLMMNNOOPPQQRRSSTTUUVVWWXXYY

First Run Output

11010011111101010000011001101001111110101000001100
00001100000000111111001100110011111100110011110011

Second Run Input

play
2
11010011111101010000011001101001111110101000001100
C.
E-
F.
M-
O.
Q-
R.
S-
T.
U-
X.
Y-
C.
C+
E.
E+
F.
F+
M.
M+
O.
O+
Q.
Q+
R.
R+
S.
S+
T.
T+
U.
U+
X.
X+
Y.
Y+
A.
B-
D.
G-
H.
I-
J.
K-
L.
N-
P.
V-
W.
A-
A.
A+
B.
B+
D.
D+
G.
G+
H.
H+
I.
I+
J.
J+
K.
K+
L.
L+
N.
N+
P.
P+
V.
V+
W.
W!
00001100000000...

Second Run Output

result:

ok Correct! The number of the misses is 13 (2 test cases)

Test #2:

score: 100

Accepted

time: 5ms

memory: 3604kb

First Run Input

prepare
1
FNETFOMMJTYCXKCRYLGXKSPAIVQNBURJAPQHUDWSDWVIHGELBO

First Run Output

10001011100111110001110110100011101101011001100000

Second Run Input

play
1
10001011100111110001110110100011101101011001100000
N.
E-
T.
O-
T.
T+
Y.
Y+
L.
G-
P.
V-
N.
N+
B.
U-
P.
P+
U.
U+
W.
W+
V.
V+
G.
G+
E.
E+
L.
L+
B.
B+
O.
O+
F.
F+
M.
M+
J.
C-
X.
K-
C.
C+
R.
X-
X.
X+
K.
K+
S.
A-
I.
Q-
R.
R+
J.
J+
A.
A+
Q.
Q+
H.
D-
S.
S+
D.
D+
I.
I+
H.
H!

Second Run Output

result:

ok Correct! The number of the misses is 11 (1 test case)

Test #3:

score: 100

Accepted

time: 232ms

memory: 3572kb

First Run Input

prepare
50
FDAVHJWICNELMBTQGPMHCYSTUUKWOYBJNRLGEFXXSIVOAQDRKP
NPBEHYAERLSHAKCMGTQFUYXDVUIWDPBSOXCMFRJOJTNKIGLQWV
AEFGFISMPACJJYRBXUCKNOPEHODITLXWSMGVWBDQKLUQHRYVTN
CKFXOIQOLCSHAGDEUJTYBAVKWPMHDBJNRMFXTEYQUGVNPILWRS
JYIRTLMHQGUUAEDJXTSDCKPCXWPBAWHQRMGNLONVOYEKFVBIFS
IHDCXSWTUHOFXLGLGWJPACUVTBOESDMYAK...

First Run Output

10010000101101111100100111101010001111000011010011
00101110100111111110010100001010101101010101010100
00111101000110001101110001011010011100011011000111
01101001101111101010010100011001101010001101001011
11011100101101110101011000100001100011001111100010
001011000011101010010000011011100111011001011...

Second Run Input

play
50
10010000101101111100100111101010001111000011010011
D.
A-
H.
J-
W.
I-
N.
M-
M.
M+
H.
H+
Y.
S-
W.
W+
Y.
Y+
J.
J+
N.
N+
R.
X-
X.
X+
S.
S+
I.
I+
A.
A+
D.
D+
R.
R+
F.
V-
C.
E-
L.
B-
T.
Q-
G.
P-
C.
C+
T.
T+
U.
U+
K.
O-
B.
B+
L.
L+
G.
G+
E.
E+
F.
F+
V.
V+
O.
O+
Q.
Q+
K.
K+
P.
P!
0010111010011111111...

Second Run Output

result:

ok Correct! The number of the misses is 582 (50 test cases)

Test #4:

score: 100

Accepted

time: 352ms

memory: 3868kb

First Run Input

prepare
75
EAHSMUJLVDPNLEKPCNIICFRTMHYWVSTQBBWRXKFDXOJQUAGGOY
CUWYVQJPSRIDKXMKTFXTFDOJVWLBEMNULIAAPYCHNGHEOGSRQB
UJTQMFLPJRGSECWAHXDCIVRQOIEPANHUBYVGFKMKLDTSWYBNOX
EYOUSDBNEQXIPMFUJCYKJVLSVWOXKLCFWARPBTIHGTMNDRGHAQ
PBHANSDUVHNKYRQVMOBLQAXSEXOLYJRGTWCFKGMWPJIFTIEDCU
YREKISUWLRFFQDIWNUASLJXGMVHBXDMBJT...

First Run Output

01000000111100110111011100111010111101110000010001
01010000001110011101111000111001111101010011100001
10001101000011111101100001111011110010100000111001
11100111110100000111000001101010100010111001101101
11010010100101110010111011000011010011011010011100
101010011000101110101001001100010011101100110...

Second Run Input

play
75
01000000111100110111011100111010111101110000010001
E.
H-
S.
M-
U.
J-
L.
L+
E.
E+
C.
C+
M.
M+
H.
H+
S.
S+
Q.
X-
X.
X+
O.
J-
J.
J+
Q.
Q+
U.
U+
G.
G+
O.
O+
A.
V-
D.
P-
N.
K-
P.
P+
N.
N+
I.
I+
F.
R-
T.
Y-
W.
V-
V.
V+
T.
T+
B.
B+
W.
W+
R.
R+
K.
K+
F.
F+
D.
D+
A.
A+
Y.
Y!
0101000000111001110111100...

Second Run Output

result:

ok Correct! The number of the misses is 869 (75 test cases)

Test #5:

score: 100

Accepted

time: 395ms

memory: 3828kb

First Run Input

prepare
85
RSHXLIARGTANBOIMVCQUCBGQWEDTPMYJWYUFPKESKJODLNFVXH
GEFNCRFLXMNOJGIQPLMSBKHDVIUVCHRAAUYWQBPTWYXSJOTEDK
PNCEFQSMQNOUJPKTWEAHFSRKGCIVJXXLRHLYBWGODVBYDUTAIM
EBFQNGFUKBOYENJSUTTPKPVSIRADCMVRHAHMDCLGLXQXIOJYWW
OSYHICRXEQAMWBDUDWANLLNCVBTXMTGEPJYPGFSKIJFHUKRQOV
SESXRAXOUIGPVJUNLMJFYEBVFCOBDQHKGW...

First Run Output

01110000110001011011001100010110011101011010001111
00011101111000110111000101001010001110011111001010
00100111100100111011010101000111011001001000111101
11000000010010110111010110011000101011101101101011
01100111011000000011001110110110101110110000011101
010111110111010000100110011100101001100101111...

Second Run Input

play
85
01110000110001011011001100010110011101011010001111
R.
L-
I.
A-
R.
R+
A.
A+
N.
B-
I.
I+
C.
C+
B.
B+
W.
E-
D.
P-
J.
W-
W.
W+
P.
P+
E.
E+
J.
J+
D.
D+
L.
L+
N.
N+
S.
H-
X.
G-
T.
O-
M.
V-
Q.
U-
G.
G+
Q.
Q+
T.
T+
M.
M+
Y.
Y+
U.
U+
F.
K-
S.
S+
K.
K+
O.
O+
F.
F+
V.
V+
X.
X+
H.
H!
0001110111100011011...

Second Run Output

result:

ok Correct! The number of the misses is 989 (85 test cases)

Test #6:

score: 100

Accepted

time: 414ms

memory: 3572kb

First Run Input

prepare
90
HPBUYCSIRIQTEVJLTDYGMNBEKMSFHNCRXVDAUFQAWPLGJWKOXO
DGTONCNKSQVCREJMUPOGFWIQPALERLASDYBFVIWKXHTMXBJUHY
KODTYFIXXRTNWNCUSLOREEBCUJPABHIDVGLGJMYKWMSQHAPQVF
BGTFHKOEJPGLWJIHPWAYVDKIFXSUUQYTENNVCMDRMOASRBXCLQ
YSJXTDDMCLKFFBOWVRCSHNPTGARXJQPBKMYWUEAUNGEIIQVHOL
QTXVHWNRFUOHCPMGWMLFRSCQKGEIPKEADY...

First Run Output

01011000101100111111000010010001001011100111101101
10010001010000010110110110100100111100111101110011
00011111101010011000001010001010110101101111000111
11011000011110111100110110000000011110110000110110
01000001111001110011111000000111110110011000010111
101010000001111001000111101011111000001011101...

Second Run Input

play
90
01011000101100111111000010010001001011100111101101
H.
B-
C.
S-
I.
I+
E.
V-
M.
N-
B.
B+
E.
E+
M.
M+
S.
S+
H.
H+
N.
N+
C.
C+
X.
V-
V.
V+
A.
A+
W.
W+
X.
X+
P.
U-
Y.
R-
Q.
T-
J.
L-
T.
T+
D.
Y-
Y.
Y+
G.
K-
F.
R-
R.
R+
D.
D+
U.
U+
F.
F+
Q.
Q+
P.
P+
L.
L+
G.
G+
J.
J+
K.
K+
O.
O!
1001000101000001011...

Second Run Output

result:

ok Correct! The number of the misses is 1037 (90 test cases)

Test #7:

score: 100

Accepted

time: 438ms

memory: 3828kb

First Run Input

prepare
95
CXKFQPTEDJGCNSIWIDLVHJBTMEUMLQVYOHGPKNRYOFXRSBUWAA
DKGIBMTPLXOCTJEVQYVUMAFHNXEOCRDPNQHSUGSWAJRIFYBWKL
QHTADVKMABFWXHRLNICEGJOCPXWTYNVMBESJURIODUGFLYSKQP
WPTDMLIIEOWCKYSSREBDBFXNQGVNXAPVJHYLUKUCGHQRAFJMOT
PUYIWXOSXDQNITNCYWFEKGHPLKVJABJQTUSVRMLCEDFMGAOBHR
YFMQKSXVBUIYLCBRDWWNVFHTTMRHUDOGLA...

First Run Output

00001100100001111111101010111110010100100001111100
01111001000101100101011000101101000011001111111010
01110000100111101011101101110100011011010110001000
10100011011111110010100011100101001001011010100011
01100110100100101001011010100100010111101001101111
000000101010011100000011101100110110111111001...

Second Run Input

play
95
00001100100001111111101010111110010100100001111100
C.
X-
K.
F-
T.
E-
J.
G-
C.
C+
N.
J-
J.
J+
T.
T+
E.
E+
Y.
O-
G.
G+
K.
K+
N.
N+
Y.
Y+
O.
O+
F.
F+
X.
X+
A.
A+
Q.
P-
D.
S-
I.
W-
I.
I+
D.
D+
L.
V-
H.
B-
M.
U-
M.
M+
L.
L+
Q.
Q+
V.
V+
H.
H+
P.
P+
R.
R+
S.
S+
B.
B+
U.
U+
W.
W!
0111100100010110010...

Second Run Output

result:

ok Correct! The number of the misses is 1098 (95 test cases)

Test #8:

score: 100

Accepted

time: 465ms

memory: 3864kb

First Run Input

prepare
100
NKXFSXFWWAOBPEJOTMVHIPUKCGQSRLCRHYNVDMETALGIJQUDBY
LQEXDPFVMOMABELGPHCWBJTVCTNYXGRYWJUQKFIHOSNSKAIURD
MBTKVSCAPAXWHBEHUSQOGYJIUVTNEIRPFYQXJORNLFDCMKWDGL
EBBOJXCXNECGAQQALWPPMJVTGSHIORNMHRDFSYUYLFIUVDKWKT
GKOAHWLYQXVKCLRRTCYMFBSQUPDIWIJPVGDFMNAUTSJXHBEEON
EQEDVJGKUIXMCYQTANIHSADKWRNFYBGOT...

First Run Output

10111111100111000011111000011001101100100001001010
01101111111001001101010100010001110101011101000001
10011110101110010110001001000001001110001011111101
01100101100011111000100000110011101101011110011010
01001001111110000110101100100010101101000111101101
101011100100110101110000011010101111010010101...

Second Run Input

play
100
10111111100111000011111000011001101100100001001010
K.
A-
O.
J-
O.
O+
T.
M-
K.
K+
C.
G-
Q.
L-
C.
C+
Y.
D-
M.
M+
T.
T+
A.
A+
L.
L+
G.
G+
J.
J+
Q.
Q+
D.
D+
Y.
Y+
N.
X-
F.
S-
X.
X+
F.
F+
W.
W+
B.
P-
E.
V-
H.
I-
P.
P+
U.
S-
S.
S+
R.
R+
H.
H+
N.
N+
V.
V+
E.
E+
I.
I+
U.
U+
B.
B!
011011111110010011...

Second Run Output

result:

ok Correct! The number of the misses is 1155 (100 test cases)

Test #9:

score: 100

Accepted

time: 457ms

memory: 3568kb

First Run Input

prepare
100
BULRJTVXIHFVSKOMPWMCGENUNYAKIQQXSPBADERWHJCYFDOLGT
FIHEGHKMALOKAVTSYYWTMQJCERQNBLFIOPSBDUCXVNRWJXUGPD
IGMAXBJVQJGTTPKQCFEEUWRSONNSHBRKUPWHCDDYLXFYVLOIMA
FKYUXTNHQBVLPWEOPREKVIMHCOJLXNDGBFUGIRSASJYADMWTCQ
RYIDFMJOWUBQNXLWNCRSSGKTXOHPVKTEPAAFMEILQVBUHJDGCY
SOVMPWQBMWNURDEALASGVNHCYUTOGKTKY...

First Run Output

00100110000111101100101011110110110100010001001111
00100111011100100011100101011100100111100111001001
11001010011111100011001101110011010000011101010100
01110110001000100111111010100100001011101110010110
01100001101111011000011011101101000001101110100101
010010110000101101010001000111010110111111011...

Second Run Input

play
100
00100110000111101100101011110110110100010001001111
B.
U-
R.
J-
X.
I-
H.
F-
M.
M+
C.
E-
U.
U+
I.
I+
X.
X+
B.
B+
D.
E-
E.
E+
R.
R+
H.
H+
J.
J+
C.
C+
F.
F+
D.
D+
L.
T-
V.
V+
S.
K-
O.
P-
W.
G-
N.
N+
Y.
A-
K.
K+
Q.
Q+
S.
S+
P.
P+
A.
A+
W.
W+
Y.
Y+
O.
O+
L.
L+
G.
G+
T.
T!
001001110111001000111001...

Second Run Output

result:

ok Correct! The number of the misses is 1145 (100 test cases)

Test #10:

score: 100

Accepted

time: 461ms

memory: 3528kb

First Run Input

prepare
100
SQROXGJWGXFMMKUNTEIRNLEVAYLHDHQPPBCSJIWFUYVCTADBKO
PKYCKEOOYJVXPWFGVDJBEULHWQTCAHLMAMURBFQGTIXSRISNND
UOOAMTVCCXBSEKWXPGWSRBNYNLIHJYJITFADEHKPRFDMQQVUGL
YEFEDNPRNSWMCWBAKSQQRBGLXKOILXTDAGJUVYUMVHHCJIFOTP
AVXANGTWWEBDESYBMQHOVRXCLFKDIGJSTJPQFYRCHIKMNLOPUU
OJNYRXLJHGGWFMDDMOPKYTHTUAKLNICIE...

First Run Output

01011011011001010000110000101011111010110001001111
10110111110111100010111010010011011101000010100000
01111100010011011100100101010100101011111001000011
10100000010010100111011110101100011011001111101100
01101111101101110000101110010101100001010000110011
111110110001110011001101000111010110001011001...

Second Run Input

play
100
01011011011001010000110000101011111010110001001111
S.
R-
G.
G+
M.
M+
U.
T-
E.
I-
R.
R+
E.
E+
V.
A-
Y.
H-
H.
H+
S.
S+
I.
I+
U.
U+
Y.
Y+
V.
V+
T.
T+
A.
A+
Q.
O-
X.
J-
W.
X-
X.
X+
F.
K-
N.
N+
L.
L+
D.
Q-
Q.
Q+
P.
P+
B.
C-
J.
J+
W.
W+
F.
F+
C.
C+
D.
D+
B.
B+
K.
K+
O.
O!
101101111101111000101110...

Second Run Output

result:

ok Correct! The number of the misses is 1150 (100 test cases)

Test #11:

score: 100

Accepted

time: 466ms

memory: 3624kb

First Run Input

prepare
100
RGFVPILWOVETBGSLKHKNCHJIOXAMPXNQSWJYUDRBMDAEYFQCTU
OLRHQVCXUYKWSEJPDYTFGKNVCASHMIDPNERUBOQJMBTGAXLIFW
KXYEEFLNYOGBNIUVVDTCRJDSHQISRAUWAQCTWLMPBHMJKXGFPO
BUXYMYPJMVFQKCIDQHEUOTITPKHLORXVGLASAGWDCJSBWNEFRN
TXKFEIVQISUBKTHXRDJCNOMPMGHNDCLPAWVBWUAEQSJRFYGOYL
PSRXNYTOKJMUFUTIRVMKBDXLJBCLFVGHA...

First Run Output

11111110010001010101010100111011000010101010011001
10011110000111100010100110111100010001111011000101
00100000111101100100001111110011010010111110001011
11010100001001010011010100010100010100111011111111
10000011011101101101000000101110101101101101010011
001100011111010110111110111000100011101100000...

Second Run Input

play
100
11111110010001010101010100111011000010101010011001
W.
O-
E.
T-
B.
S-
K.
K+
C.
J-
O.
O+
X.
X+
S.
S+
W.
W+
J.
J+
Y.
D-
B.
B+
D.
D+
E.
E+
Y.
Y+
C.
C+
T.
T+
R.
G-
F.
V-
P.
I-
L.
V-
V.
V+
G.
G+
L.
L+
H.
N-
H.
H+
I.
I+
A.
M-
P.
P+
N.
N+
Q.
U-
R.
R+
M.
M+
A.
A+
F.
F+
Q.
Q+
U.
U!
100111100001111000...

Second Run Output

result:

ok Correct! The number of the misses is 1151 (100 test cases)

Test #12:

score: 100

Accepted

time: 467ms

memory: 3628kb

First Run Input

prepare
100
VJXSDLHVPDTYCWKILGXUIJANAHYSMUWBRRQTCENEPFFOKBGMOQ
BVAFIMQXPHKTKJWSLITNXOEVCFYCOQADGSGDWUPLHNBJRUEMYR
RLPSNKYDCLUMVDTHJYIHWQSGRBNXUFOFAAGEQTKCPVJEWBMOIX
IBFYNHNRSYOHXPGGKBFCSUMOJLUPKVAQMTCLDWREWQDTAVXIEJ
KGRTAINBFADUHILYMBEOPECVXQPDOWWTJSKMGQSVRUHLCNFXYJ
ETFGMNTHGOKBXNMELFBWCARUHICYJRWSX...

First Run Output

11001011010001110100111111001011001000100000111101
01011111001110000110111101101100101001000000011110
00100111100001110101010101010101111011111000010001
11000100000110001101001011001011101101011100101111
11000111000011011110011111000000001111010010110110
001100001101100011111001011000101101101111010...

Second Run Input

play
100
11001011010001110100111111001011001000100000111101
X.
S-
L.
P-
T.
Y-
C.
L-
L.
L+
X.
X+
U.
Y-
Y.
Y+
S.
S+
U.
U+
R.
R+
T.
T+
C.
C+
E.
E+
P.
P+
F.
F+
O.
O+
V.
J-
D.
H-
V.
V+
D.
D+
W.
K-
I.
G-
I.
I+
J.
J+
A.
N-
A.
A+
H.
H+
M.
W-
W.
W+
B.
Q-
N.
N+
K.
K+
B.
B+
G.
G+
M.
M+
Q.
Q!
010111110011100001...

Second Run Output

result:

ok Correct! The number of the misses is 1156 (100 test cases)

Test #13:

score: 100

Accepted

time: 460ms

memory: 3860kb

First Run Input

prepare
100
MOHGEABJDDXQJMYVSPKBWONVTCPLWSQRFEKUNUHTLCXYIAFIGR
LOFDRVYTQJXQHRTKMBHCEVSAUUIFAEXLMOGIKPBYNWNWCJPGSD
EJBMJEYAAUDIPOTXILRCUQSDNKVPRYFCKMLSQGWFTVXOHNBHWG
MHKMCDGVOQRWJBFSKLSGTYUDWOIAIUPCYTQPNEHBNJRAFXXVEL
AVRXEJCFQXWBYTQRSWYHOBUPUNGSDMHILCNLFKJKMDGEOITAPV
IRLQBTAYITACMJROOJHYNHSPBQLNEVWGX...

First Run Output

01101001001110100000111011011010010010111111100100
10001011011001101101100000000111101001110101111100
01011010001001010111010101101101111010000111100100
01100111100001011011011101101100100011111000000110
11101110100000111000000101111100011000101111000111
011110100011101000100111111001100010001011100...

Second Run Input

play
100
01101001001110100000111011011010010010111111100100
M.
G-
A.
B-
D.
D+
M.
M+
V.
S-
P.
K-
B.
B+
V.
V+
P.
P+
S.
S+
R.
F-
K.
K+
U.
U+
A.
A+
F.
F+
G.
G+
R.
R+
O.
H-
E.
J-
X.
Q-
J.
J+
Y.
W-
O.
O+
N.
T-
C.
L-
W.
W+
Q.
Q+
E.
E+
N.
N+
H.
H+
T.
T+
L.
L+
C.
C+
X.
X+
Y.
Y+
I.
I!
100010110110011011011000...

Second Run Output

result:

ok Correct! The number of the misses is 1152 (100 test cases)

Test #14:

score: 100

Accepted

time: 461ms

memory: 3668kb

First Run Input

prepare
100
KVKFHJETMUGYIINCNCXOSBTFLAAQERRDPVHJUXWDPQYWOMLSBG
RKGEAFBUDOEJVNHJBSTOAHIWMWKFCPCYYVITXGXQUDLQSNLRMP
VFSDMWJQNEGIOKCAQFCUJHRBPLWLMUPOASHKYETNTXGDXRVBIY
AUELFVXFMCRTRVDAOJQWJKMQLEUKWSHXGIYHNNBOPBTPGCYSDI
MGTWHRVJKOPGAYSEXKCJIQRYPDXNBTEFBOWACHSLINLUVUDQFM
CAVGCIHTJQXHKTPQOLADBJDMGUWYENMLV...

First Run Output

01010110101011101010100110011110010101000100011101
10010001101011100000011010001011111010101110011110
00010011111000111010111111010010101001010011010100
00100110101011001011011101011111010100011001000101
10011001100011100101100101011000101101101101011001
100010011110011110001101001101100001110100101...

Second Run Input

play
100
01010110101011101010100110011110010101000100011101
K.
K+
H.
T-
U.
Y-
C.
C+
O.
B-
T.
T+
A.
A+
D.
P-
H.
H+
U.
U+
W.
D-
D.
D+
P.
P+
Y.
Y+
W.
W+
O.
O+
B.
B+
V.
F-
J.
E-
M.
G-
I.
I+
N.
N+
X.
S-
F.
F+
L.
Q-
E.
E+
R.
R+
V.
V+
J.
J+
X.
X+
Q.
Q+
M.
M+
L.
L+
S.
S+
G.
G!
100100011010111000000110100010...

Second Run Output

result:

ok Correct! The number of the misses is 1154 (100 test cases)

Test #15:

score: 100

Accepted

time: 460ms

memory: 3792kb

First Run Input

prepare
100
HXKQHJLCSAEPANTBUFWEUTDPXRRDMQGOKMSBFWVCVLONYYIGJI
FHATBVFQWOIECJDGBSLKREDMQYNOTACNMKSJVULXGYIPPURWXH
JVWOTSJAXCAPFURISNLKXYEHWMPIOHGFUQBCRQVMLYEGDBDNTK
TOWIKXQPDRLAHPNUGUNKIRBECJYSQYMEFSDACFLXHVMJGTWBVO
WTBUHJHOXMQNYCGNQBSKUVPFOFGILTXYLARSEDCRVIWAEJMPDK
VHYQVKEJMPWUDBTWSMKIAGTEFGSYDUCCJ...

First Run Output

10001000101101110111010101101000011111101001001001
00110000011011010111100100011110111100101011101000
00111100110010011000110110011111011101000101010010
10101000100100111111001011010010011110000011111100
01010100110011100011100101100111011100110001011001
011101011001000011100100111101111101010100010...

Second Run Input

play
100
10001000101101110111010101101000011111101001001001
X.
K-
Q.
J-
L.
C-
A.
A+
U.
U+
D.
X-
X.
X+
D.
D+
Q.
Q+
G.
O-
K.
K+
C.
C+
L.
L+
O.
O+
Y.
Y+
G.
G+
J.
J+
H.
H+
S.
E-
P.
N-
T.
B-
F.
W-
E.
E+
T.
T+
P.
P+
R.
R+
M.
M+
S.
S+
B.
B+
F.
F+
W.
W+
V.
V+
N.
N+
I.
I!
001100000110110101111001000111101111...

Second Run Output

result:

ok Correct! The number of the misses is 1163 (100 test cases)

Test #16:

score: 100

Accepted

time: 465ms

memory: 3632kb

First Run Input

prepare
100
SCMKNXOIGSNYXFERVPAEUQHDULFWTCLIRKMJPOHBBYGJTDVQWA
XGAPSFERTQDFUWOJHLRPYNXIOVSBQTJDGCVKKAMCIUBMLNYEHW
OTQJRXSJVDUSNDIPTGYBIRAMWBEFXFCLEKHGMKQAYHOLNPUCVW
GTPJIHXDRBSYWEECOUYLWNLCXPMJFUAAMOGTVDHQRNFVKQKIBS
URSEIOWGQPCNVFDRMNIUJASLAEBBKFYHJYGVMOXDKWTQXPTCHL
ONFBMGMEDKCRRWCKPABJPDIHIYUGWQXSU...

First Run Output

01101000001100101111011101000110001110100101011101
11001110100110110000101110110110110000011110001100
00101110100110110010110100101011100010101001110110
00100010111101110111001111001100000010011011010011
01101000110110110110111010001001100100111001110010
111101011000010000110101010111010000111010101...

Second Run Input

play
100
01101000001100101111011101000110001110100101011101
S.
K-
X.
O-
I.
G-
S.
S+
X.
X+
F.
R-
U.
U+
F.
F+
W.
T-
I.
I+
R.
R+
K.
K+
O.
O+
B.
B+
G.
G+
T.
T+
W.
W+
C.
M-
N.
N+
Y.
E-
V.
P-
A.
E-
E.
E+
Q.
H-
D.
L-
C.
C+
L.
L+
M.
M+
J.
P-
P.
P+
H.
H+
Y.
Y+
J.
J+
D.
D+
V.
V+
Q.
Q+
A.
A!
110011101001101100...

Second Run Output

result:

ok Correct! The number of the misses is 1166 (100 test cases)

Test #17:

score: 100

Accepted

time: 458ms

memory: 3632kb

First Run Input

prepare
100
NNODHVLKIUVAYTXEBRPAPWXGHYJBOMRSSGKFUIQMFWQLTCJEDC
HANGPOYBUGIFVTKOXXWBFRQAJLMYLMPUWCJEREKCVNDSIQSHDT
ORBBPYTLJSQVISIAGHLGUREEOKAXFKYUJQXDMHNCTNCMDWFWPV
GIAKBSRKPITXAVCLFEWDQFVNJJHXOGRMMYDEHUONTBWPUSCQLY
PXIMBIELUQGORGWAKHNJQJBYFTNTKAPDDVVCHOSYLURFMCESXW
GWUXITHXWIKOVQLSENPLYKDNCQPCJFBRM...

First Run Output

11101000000011111110101011011011100100001000110101
10101010001011000010011011011010111010011100110101
11110000001110100100111111000101010001110110010101
01100010110011101101111100100011101110010001001100
01011001100110000101011111010000000011111111100110
110100011010110001001101010001111101000011110...

Second Run Input

play
100
11101000000011111110101011011011100100001000110101
D.
V-
L.
K-
I.
U-
V.
V+
A.
A+
W.
G-
J.
M-
G.
G+
K.
K+
U.
U+
I.
I+
Q.
M-
M.
M+
W.
W+
Q.
Q+
L.
L+
J.
J+
D.
D+
N.
N+
O.
H-
Y.
T-
X.
E-
B.
R-
P.
P+
X.
X+
H.
H+
Y.
Y+
B.
B+
O.
O+
R.
R+
S.
S+
F.
F+
T.
T+
C.
E-
E.
E+
C.
C!
101010100010110000100110...

Second Run Output

result:

ok Correct! The number of the misses is 1129 (100 test cases)