problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p00042 | C++ | Memory Limit Exceeded | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int dk[10001][1001];
int main() {
int i, j, takara[1001][2], w, n, c, maxv;
c = 0;
while (0 <= scanf("%d", &w)) {
if (w == 0)
break;
scanf("%d", &n);
++c;
for (i = 1; i <= n; i++) {
scanf("%d,%d", &takara[i][0], &takara[i][1]);
}
memset(dk, 0, sizeof(dk));
for (i = 1; i <= n; i++) {
for (j = 1; j <= w; j++) {
if (j >= takara[i][1]) {
dk[i][j] = (dk[i - 1][j - takara[i][1]] + takara[i][0] > dk[i - 1][j]
? dk[i - 1][j - takara[i][1]] + takara[i][0]
: dk[i - 1][j]);
continue;
}
dk[i][j] = dk[i - 1][j];
}
}
maxv = dk[n][w];
for (i = 0; i <= w; i++) {
if (maxv == dk[n][i])
break;
}
printf("Case %d:\n", c);
printf("%d\n%d\n", maxv, i);
}
return 0;
} | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
short dk[10001][1001];
int main() {
int i, j, takara[1001][2], w, n, c, maxv;
c = 0;
while (0 <= scanf("%d", &w)) {
if (w == 0)
break;
scanf("%d", &n);
++c;
for (i = 1; i <= n; i++) {
scanf("%d,%d", &takara[i][0], &takara[i][1]);
}
memset(dk, 0, sizeof(dk));
for (i = 1; i <= n; i++) {
for (j = 1; j <= w; j++) {
if (j >= takara[i][1]) {
dk[i][j] = (dk[i - 1][j - takara[i][1]] + takara[i][0] > dk[i - 1][j]
? dk[i - 1][j - takara[i][1]] + takara[i][0]
: dk[i - 1][j]);
continue;
}
dk[i][j] = dk[i - 1][j];
}
}
maxv = dk[n][w];
for (i = 0; i <= w; i++) {
if (maxv == dk[n][i])
break;
}
printf("Case %d:\n", c);
printf("%d\n%d\n", maxv, i);
}
return 0;
} | replace | 5 | 6 | 5 | 6 | MLE | |
p00042 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
int main() {
int w, n;
int ct = 1;
while (cin >> w >> n, w) {
int va[n], we[n];
for (int i = 0; i < n; i++)
scanf("%d, %d", &va[i], &we[i]);
int dp[1010][1010];
for (int i = 0; i < 1010; i++)
for (int j = 0; j < 1010; j++)
dp[i][j] = 0;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= w; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (j + we[i] <= w)
dp[i + 1][j + we[i]] = max(dp[i + 1][j + we[i]], dp[i][j] + va[i]);
}
int macs = 0, sumwe = 1010;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= w; j++)
if (dp[i][j] == dp[n][w])
sumwe = min(j, sumwe);
cout << "Case " << ct << ":" << endl << dp[n][w] << endl << sumwe << endl;
ct++;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int MOD = 1000000007;
int main() {
int w, n;
int ct = 1;
while (cin >> w >> n, w) {
int va[n], we[n];
for (int i = 0; i < n; i++)
scanf("%d, %d", &va[i], &we[i]);
int dp[1010][1010];
for (int i = 0; i < 1010; i++)
for (int j = 0; j < 1010; j++)
dp[i][j] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= w; j++) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
if (j + we[i] <= w)
dp[i + 1][j + we[i]] = max(dp[i + 1][j + we[i]], dp[i][j] + va[i]);
}
int macs = 0, sumwe = 1010;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= w; j++)
if (dp[i][j] == dp[n][w])
sumwe = min(j, sumwe);
cout << "Case " << ct << ":" << endl << dp[n][w] << endl << sumwe << endl;
ct++;
}
return 0;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p00042 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ALL(co) co.begin(), co.end()
#define tpl(...) make_tuple(__VA_ARGS__)
typedef long long LL;
typedef pair<int, int> P;
typedef pair<int, P> IP;
typedef pair<P, P> PP;
typedef vector<int> Array;
typedef vector<vector<int>> Array2;
typedef vector<LL> LArray;
typedef vector<P> PArray;
typedef vector<string> SArray;
const int INF = 1 << 29;
const LL LINF = 1LL << 60;
inline int getInt() {
int itiv;
return (cin >> itiv, itiv);
}
template <typename T> void readAll(vector<T> &vec) {
for (int i = 0, size = vec.size(); i < size; i++)
cin >> vec[i];
}
template <typename T, typename U> void readAll(vector<pair<T, U>> &vec) {
for (int i = 0, size = vec.size(); i < size; i++)
cin >> vec[i].first >> vec[i].second;
}
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
inline bool between(int min, int max, int n) { return min <= n && n <= max; }
inline bool inRange(int begin, int end, int n) { return begin <= n && n < end; }
inline bool inRange(int size, int n) { return 0 <= n && n < size; }
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int dr[] = {0, -1, 0, 1}, dc[] = {-1, 0, 1, 0};
int n, w;
const int M_W = 1001;
const int M_N = 1001;
P dp[M_N][M_W];
PArray arr;
P dfs(int idx, int weight) {
if (idx == n)
return P(0, weight);
if (dp[idx][weight] != P())
return dp[idx][weight];
P v1 = P(-1, weight + arr[idx].second);
if (v1.second <= w) {
P ret = dfs(idx + 1, weight + arr[idx].second);
v1.first = ret.first + arr[idx].first;
v1.second = ret.second;
}
P v2 = dfs(idx + 1, weight);
P ans;
if (v1.first == v2.first) {
ans.first = v1.first;
ans.second = min(v1.second, v2.second);
} else
ans = max(v1, v2);
return ans;
}
int main(void) {
ios::sync_with_stdio(false);
int counter = 0;
while (cin >> w && w) {
counter++;
cin >> n;
arr.resize(n);
char c;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> c >> arr[i].second;
}
memset(dp, 0, sizeof(dp));
P ans = dfs(0, 0);
cout << "Case " << counter << ":" << endl;
cout << ans.first << endl;
cout << ans.second << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define ALL(co) co.begin(), co.end()
#define tpl(...) make_tuple(__VA_ARGS__)
typedef long long LL;
typedef pair<int, int> P;
typedef pair<int, P> IP;
typedef pair<P, P> PP;
typedef vector<int> Array;
typedef vector<vector<int>> Array2;
typedef vector<LL> LArray;
typedef vector<P> PArray;
typedef vector<string> SArray;
const int INF = 1 << 29;
const LL LINF = 1LL << 60;
inline int getInt() {
int itiv;
return (cin >> itiv, itiv);
}
template <typename T> void readAll(vector<T> &vec) {
for (int i = 0, size = vec.size(); i < size; i++)
cin >> vec[i];
}
template <typename T, typename U> void readAll(vector<pair<T, U>> &vec) {
for (int i = 0, size = vec.size(); i < size; i++)
cin >> vec[i].first >> vec[i].second;
}
template <typename T> inline string toString(const T &a) {
ostringstream oss;
oss << a;
return oss.str();
};
inline bool between(int min, int max, int n) { return min <= n && n <= max; }
inline bool inRange(int begin, int end, int n) { return begin <= n && n < end; }
inline bool inRange(int size, int n) { return 0 <= n && n < size; }
int dx[] = {-1, 0, 1, 0}, dy[] = {0, -1, 0, 1};
int dr[] = {0, -1, 0, 1}, dc[] = {-1, 0, 1, 0};
int n, w;
const int M_W = 1001;
const int M_N = 1001;
P dp[M_N][M_W];
PArray arr;
P dfs(int idx, int weight) {
if (idx == n)
return P(0, weight);
if (dp[idx][weight] != P())
return dp[idx][weight];
P v1 = P(-1, weight + arr[idx].second);
if (v1.second <= w) {
P ret = dfs(idx + 1, weight + arr[idx].second);
v1.first = ret.first + arr[idx].first;
v1.second = ret.second;
}
P v2 = dfs(idx + 1, weight);
P ans;
if (v1.first == v2.first) {
ans.first = v1.first;
ans.second = min(v1.second, v2.second);
} else
ans = max(v1, v2);
return dp[idx][weight] = ans;
}
int main(void) {
ios::sync_with_stdio(false);
int counter = 0;
while (cin >> w && w) {
counter++;
cin >> n;
arr.resize(n);
char c;
for (int i = 0; i < n; i++) {
cin >> arr[i].first >> c >> arr[i].second;
}
memset(dp, 0, sizeof(dp));
P ans = dfs(0, 0);
cout << "Case " << counter << ":" << endl;
cout << ans.first << endl;
cout << ans.second << endl;
}
return 0;
} | replace | 82 | 83 | 82 | 83 | TLE | |
p00042 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) begin(a), end(a)
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(5)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> P;
typedef complex<double> Point;
typedef long long ll;
const int INF = 114514810;
const int MOD = 100000007;
const double EPS = 1e-10;
const double PI = acos(-1.0);
struct edge {
int from, to, cost;
bool operator<(const edge &e) const { return cost < e.cost; }
bool operator>(const edge &e) const { return cost > e.cost; }
};
///*************************************************************************************///
///*************************************************************************************///
///*************************************************************************************///
int W, N, w[1005], v[1005];
P dp[1005][10005];
P solve(int i, int j) {
if (dp[i][j].first >= 0)
return dp[i][j];
if (i == N)
return P(0, 0);
P res;
if (j < w[i])
res = solve(i + 1, j);
else {
P a = solve(i + 1, j);
P b = solve(i + 1, j - w[i]);
b.first += v[i];
b.second += w[i];
if (a.first != b.first)
res = max(a, b);
else
res = min(a, b);
}
return dp[i][j] = res;
}
int main() {
int cse = 0;
while (cin >> W >> N, W) {
cse++;
MS(dp, -1);
char c;
REP(i, N) cin >> v[i] >> c >> w[i];
cout << "Case " << cse << ":" << endl
<< solve(0, W).first << endl
<< solve(0, W).second << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) begin(a), end(a)
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(5)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<short, short> P;
typedef complex<double> Point;
typedef long long ll;
const int INF = 114514810;
const int MOD = 100000007;
const double EPS = 1e-10;
const double PI = acos(-1.0);
struct edge {
int from, to, cost;
bool operator<(const edge &e) const { return cost < e.cost; }
bool operator>(const edge &e) const { return cost > e.cost; }
};
///*************************************************************************************///
///*************************************************************************************///
///*************************************************************************************///
int W, N, w[1005], v[1005];
P dp[1005][10005];
P solve(int i, int j) {
if (dp[i][j].first >= 0)
return dp[i][j];
if (i == N)
return P(0, 0);
P res;
if (j < w[i])
res = solve(i + 1, j);
else {
P a = solve(i + 1, j);
P b = solve(i + 1, j - w[i]);
b.first += v[i];
b.second += w[i];
if (a.first != b.first)
res = max(a, b);
else
res = min(a, b);
}
return dp[i][j] = res;
}
int main() {
int cse = 0;
while (cin >> W >> N, W) {
cse++;
MS(dp, -1);
char c;
REP(i, N) cin >> v[i] >> c >> w[i];
cout << "Case " << cse << ":" << endl
<< solve(0, W).first << endl
<< solve(0, W).second << endl;
}
} | replace | 9 | 10 | 9 | 10 | MLE | |
p00042 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
#include <string.h>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define max_n 1000
#define max_w 1000
using namespace std;
int N, W;
long long dp[max_n][max_w];
long long dw[max_n][max_w];
int w[max_n], v[max_n];
long long rec(int i, int j) {
int res;
if (dp[i][j] != -1)
return dp[i][j];
if (i == N) {
res = 0;
dw[i][j] = 0;
} else if (j < w[i]) {
res = rec(i + 1, j);
dw[i][j] = dw[i + 1][j];
} else {
long long r1 = rec(i + 1, j);
long long r2 = rec(i + 1, j - w[i]) + v[i];
if (r1 > r2) {
res = r1;
dw[i][j] = dw[i + 1][j];
} else if (r2 > r1) {
res = r2;
dw[i][j] = dw[i + 1][j - w[i]] + w[i];
} else {
if (dw[i + 1][j] > (dw[i + 1][j - w[i]] + w[i])) {
res = r2;
dw[i][j] = dw[i + 1][j - w[i]] + w[i];
} else {
res = r1;
dw[i][j] = dw[i + 1][j];
}
}
}
return dp[i][j] = res;
}
int main() {
int p = 1;
while (cin >> W, W) {
cin >> N;
rep(i, N) { scanf("%d,%d", &v[i], &w[i]); }
memset(dp, -1, sizeof(dp));
memset(dw, -1, sizeof(dw));
cout << "Case " << p << ":" << endl;
cout << rec(0, W) << endl;
cout << dw[0][W] << endl;
p++;
/*cout<<"value="<<rec(0,W)<<"
cost="<<dw[0][W]<<endl;//????????§??????????????????
cout<<"cost="<<dw[0][W]<<endl;*/
}
return 0;
} | #include <cstdio>
#include <iostream>
#include <string.h>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define max_n 1000
#define max_w 1000
using namespace std;
int N, W;
long long dp[max_n + 1][max_w + 1];
long long dw[max_n + 1][max_w + 1];
int w[max_n], v[max_n];
long long rec(int i, int j) {
int res;
if (dp[i][j] != -1)
return dp[i][j];
if (i == N) {
res = 0;
dw[i][j] = 0;
} else if (j < w[i]) {
res = rec(i + 1, j);
dw[i][j] = dw[i + 1][j];
} else {
long long r1 = rec(i + 1, j);
long long r2 = rec(i + 1, j - w[i]) + v[i];
if (r1 > r2) {
res = r1;
dw[i][j] = dw[i + 1][j];
} else if (r2 > r1) {
res = r2;
dw[i][j] = dw[i + 1][j - w[i]] + w[i];
} else {
if (dw[i + 1][j] > (dw[i + 1][j - w[i]] + w[i])) {
res = r2;
dw[i][j] = dw[i + 1][j - w[i]] + w[i];
} else {
res = r1;
dw[i][j] = dw[i + 1][j];
}
}
}
return dp[i][j] = res;
}
int main() {
int p = 1;
while (cin >> W, W) {
cin >> N;
rep(i, N) { scanf("%d,%d", &v[i], &w[i]); }
memset(dp, -1, sizeof(dp));
memset(dw, -1, sizeof(dw));
cout << "Case " << p << ":" << endl;
cout << rec(0, W) << endl;
cout << dw[0][W] << endl;
p++;
/*cout<<"value="<<rec(0,W)<<"
cost="<<dw[0][W]<<endl;//????????§??????????????????
cout<<"cost="<<dw[0][W]<<endl;*/
}
return 0;
} | replace | 10 | 12 | 10 | 12 | 0 | |
p00042 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define all(v) (v).begin(), (v).end()
#define rev(s) (s).rbegin(), (s).rend()
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<double, double> dP;
const int INF = 1000000000;
const double EPS = 1e-10;
int main() {
freopen("test.txt", "r", stdin);
int casenum = 0;
while (1) {
int W, n;
cin >> W >> n;
if (!W)
break;
vector<int> w(n + 1);
vector<int> v(n + 1);
FOR(i, 1, n + 1) { scanf("%d,%d", &v[i], &w[i]); }
vector<vector<int>> table(n + 1, vector<int>(W + 1));
FOR(i, 1, n + 1) {
for (int j = 0; j <= W; j++) {
if (j >= w[i]) {
table[i][j] = max(table[i - 1][j], table[i - 1][j - w[i]] + v[i]);
} else {
table[i][j] = table[i - 1][j];
}
}
}
int idx = 0;
rep(i, W + 1) {
if (table[n][idx] < table[n][i]) {
idx = i;
}
}
cout << "Case " << ++casenum << ':' << endl;
cout << table[n][idx] << endl;
cout << idx << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define all(v) (v).begin(), (v).end()
#define rev(s) (s).rbegin(), (s).rend()
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<double, double> dP;
const int INF = 1000000000;
const double EPS = 1e-10;
int main() {
// freopen("test.txt", "r", stdin);
int casenum = 0;
while (1) {
int W, n;
cin >> W >> n;
if (!W)
break;
vector<int> w(n + 1);
vector<int> v(n + 1);
FOR(i, 1, n + 1) { scanf("%d,%d", &v[i], &w[i]); }
vector<vector<int>> table(n + 1, vector<int>(W + 1));
FOR(i, 1, n + 1) {
for (int j = 0; j <= W; j++) {
if (j >= w[i]) {
table[i][j] = max(table[i - 1][j], table[i - 1][j - w[i]] + v[i]);
} else {
table[i][j] = table[i - 1][j];
}
}
}
int idx = 0;
rep(i, W + 1) {
if (table[n][idx] < table[n][i]) {
idx = i;
}
}
cout << "Case " << ++casenum << ':' << endl;
cout << table[n][idx] << endl;
cout << idx << endl;
}
return 0;
} | replace | 32 | 33 | 32 | 33 | TLE | |
p00042 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#define int long long
using namespace std;
int dp[1001], N, v[100], w[100], W;
signed main() {
for (int l = 1;; l++) {
fill(dp, dp + 1001, 0);
/*fill(v,v+100,0);
fill(w,w+100,0);*/
cin >> W;
if (W == 0)
break;
cin >> N;
for (int i = 0; i < N; i++) {
scanf("%lld,%lld", &v[i], &w[i]);
}
for (int i = 0; i < N; i++) {
for (int j = W; j >= w[i]; j--) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
for (int i = W; i >= 0; i--) {
if (dp[W] != dp[i]) {
cout << "Case " << l << ":" << endl << dp[W] << endl << i + 1 << endl;
break;
}
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#define int long long
using namespace std;
int dp[1001], N, v[1001], w[1001], W;
signed main() {
for (int l = 1;; l++) {
fill(dp, dp + 1001, 0);
/*fill(v,v+100,0);
fill(w,w+100,0);*/
cin >> W;
if (W == 0)
break;
cin >> N;
for (int i = 0; i < N; i++) {
scanf("%lld,%lld", &v[i], &w[i]);
}
for (int i = 0; i < N; i++) {
for (int j = W; j >= w[i]; j--) {
dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
for (int i = W; i >= 0; i--) {
if (dp[W] != dp[i]) {
cout << "Case " << l << ":" << endl << dp[W] << endl << i + 1 << endl;
break;
}
}
}
return 0;
} | replace | 5 | 6 | 5 | 6 | TLE | |
p00042 | C++ | Memory Limit Exceeded | #include <array>
#include <cstdio>
#include <iostream>
using namespace std;
array<pair<int, int>, 1001> pairs;
array<array<pair<int, int>, 10001>, 1001> m;
int main() {
for (int caseNo = 0;; caseNo++) {
int w;
scanf("%d", &w);
if (w == 0)
break;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d,%d", &pairs[i].first, &pairs[i].second);
}
for (int j = 0; j <= w; j++) {
m[0][j].first = 0;
m[0][j].second = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w; j++) {
if (pairs[i].second <= j) {
if (m[i - 1][j].first >
m[i - 1][j - pairs[i].second].first + pairs[i].first) {
m[i][j].first = m[i - 1][j].first;
m[i][j].second = m[i - 1][j].second;
} else {
m[i][j].first =
m[i - 1][j - pairs[i].second].first + pairs[i].first;
m[i][j].second =
m[i - 1][j - pairs[i].second].second + pairs[i].second;
}
} else {
m[i][j].first = m[i - 1][j].first;
m[i][j].second = m[i - 1][j].second;
}
}
}
printf("Case %d:\n%d\n%d\n", caseNo + 1, m[n][w].first, m[n][w].second);
}
} | #include <array>
#include <cstdio>
#include <iostream>
using namespace std;
array<pair<int, int>, 1001> pairs;
array<array<pair<int, int>, 1001>, 1001> m;
int main() {
for (int caseNo = 0;; caseNo++) {
int w;
scanf("%d", &w);
if (w == 0)
break;
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d,%d", &pairs[i].first, &pairs[i].second);
}
for (int j = 0; j <= w; j++) {
m[0][j].first = 0;
m[0][j].second = 0;
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= w; j++) {
if (pairs[i].second <= j) {
if (m[i - 1][j].first >
m[i - 1][j - pairs[i].second].first + pairs[i].first) {
m[i][j].first = m[i - 1][j].first;
m[i][j].second = m[i - 1][j].second;
} else {
m[i][j].first =
m[i - 1][j - pairs[i].second].first + pairs[i].first;
m[i][j].second =
m[i - 1][j - pairs[i].second].second + pairs[i].second;
}
} else {
m[i][j].first = m[i - 1][j].first;
m[i][j].second = m[i - 1][j].second;
}
}
}
printf("Case %d:\n%d\n%d\n", caseNo + 1, m[n][w].first, m[n][w].second);
}
} | replace | 5 | 6 | 5 | 6 | MLE | |
p00042 | C++ | Memory Limit Exceeded | #include <cstring>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
const int MAX_N = 1000, MAX_M = 10000;
int n;
typedef pair<int, int> P;
P ilist[MAX_N];
P memo[MAX_N + 1][MAX_M + 1];
P comp(const P &a, const P &b) {
if (a.first < b.first)
return b;
return a;
}
P dp(int now, int lim) {
if (memo[now][lim].first > -1) {
return memo[now][lim];
}
P res;
if (now == n)
return make_pair(0, 0);
else if (lim < ilist[now].second) {
res = dp(now + 1, lim);
} else {
res = dp(now + 1, lim - ilist[now].second);
res.second += ilist[now].second;
res.first += ilist[now].first;
res = comp(dp(now + 1, lim), res);
}
return memo[now][lim] = res;
}
int main() {
int lim, cnt = 0, w, v;
P item;
char buf;
while (cin >> lim, lim) {
for (int i = 0; i <= MAX_N; ++i) {
for (int j = 0; j <= MAX_M; ++j) {
memo[i][j] = make_pair(-1, -1);
}
}
++cnt;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> v >> buf >> w;
ilist[i] = make_pair(v, w);
}
item = dp(0, lim);
cout << "Case " << cnt << ":" << endl;
cout << item.first << endl << item.second << endl;
}
return 0;
} | #include <cstring>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
const int MAX_N = 1000, MAX_M = 1000;
int n;
typedef pair<int, int> P;
P ilist[MAX_N];
P memo[MAX_N + 1][MAX_M + 1];
P comp(const P &a, const P &b) {
if (a.first < b.first)
return b;
return a;
}
P dp(int now, int lim) {
if (memo[now][lim].first > -1) {
return memo[now][lim];
}
P res;
if (now == n)
return make_pair(0, 0);
else if (lim < ilist[now].second) {
res = dp(now + 1, lim);
} else {
res = dp(now + 1, lim - ilist[now].second);
res.second += ilist[now].second;
res.first += ilist[now].first;
res = comp(dp(now + 1, lim), res);
}
return memo[now][lim] = res;
}
int main() {
int lim, cnt = 0, w, v;
P item;
char buf;
while (cin >> lim, lim) {
for (int i = 0; i <= MAX_N; ++i) {
for (int j = 0; j <= MAX_M; ++j) {
memo[i][j] = make_pair(-1, -1);
}
}
++cnt;
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> v >> buf >> w;
ilist[i] = make_pair(v, w);
}
item = dp(0, lim);
cout << "Case " << cnt << ":" << endl;
cout << item.first << endl << item.second << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | MLE | |
p00042 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define req(i, r, k) for (int i = k; i < r; i++)
#define rep(i, r) req(i, r, 0)
const long long int INF = 100000000000000;
long long int dp[1001][1001];
int main() {
for (int a = 1; 1; a++) {
int w, n;
scanf(" %d", &w);
if (w == 0)
break;
scanf(" %d", &n);
pair<int, int> t[n];
char c;
rep(i, n) { scanf(" %d%c%d", &t[i].first, &c, &t[i].second); }
rep(i, w) {
dp[0][i] = 0;
dp[i][0] = 0;
}
dp[0][0] = 0;
rep(i, n + 1) {
rep(j, w + 1) {
if (j >= t[i].second) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - t[i].second] + t[i].first);
} else {
dp[i + 1][j] = dp[i][j];
}
}
}
long long int maxvalue = 0, thenweight = 0;
rep(i, w + 1) {
// cout << dp[i] << " " << i << " " << thenweight << endl;
if (maxvalue < dp[n][i]) {
maxvalue = dp[n][i];
thenweight = i;
}
}
// printf("Case %d:\n%lld\n%lld\n",a,maxvalue,thenweight);
cout << "Case " << a << ':' << endl;
cout << maxvalue << endl;
cout << thenweight << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define req(i, r, k) for (int i = k; i < r; i++)
#define rep(i, r) req(i, r, 0)
const long long int INF = 100000000000000;
long long int dp[1002][1002];
int main() {
for (int a = 1; 1; a++) {
int w, n;
scanf(" %d", &w);
if (w == 0)
break;
scanf(" %d", &n);
pair<int, int> t[n];
char c;
rep(i, n) { scanf(" %d%c%d", &t[i].first, &c, &t[i].second); }
rep(i, w) {
dp[0][i] = 0;
dp[i][0] = 0;
}
dp[0][0] = 0;
rep(i, n + 1) {
rep(j, w + 1) {
if (j >= t[i].second) {
dp[i + 1][j] = max(dp[i][j], dp[i][j - t[i].second] + t[i].first);
} else {
dp[i + 1][j] = dp[i][j];
}
}
}
long long int maxvalue = 0, thenweight = 0;
rep(i, w + 1) {
// cout << dp[i] << " " << i << " " << thenweight << endl;
if (maxvalue < dp[n][i]) {
maxvalue = dp[n][i];
thenweight = i;
}
}
// printf("Case %d:\n%lld\n%lld\n",a,maxvalue,thenweight);
cout << "Case " << a << ':' << endl;
cout << maxvalue << endl;
cout << thenweight << endl;
}
return 0;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p00042 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int W, n, v[1000], w[1000], dp[10000][10000], t = 1;
while (cin >> W, W) {
cin >> n;
for (int i = 0; i < n; i++)
scanf("%d,%d", &v[i], &w[i]);
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 1000; j++)
dp[i][j] = -1;
for (int i = 0; i < 1000; i++) {
dp[0][i] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j <= W; j++)
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
cout << "Case " << t << ":" << endl;
for (int i = W; i >= 0; i--) {
if (dp[n][i] != dp[n][W]) {
cout << dp[n][W] << endl << i + 1 << endl;
break;
}
}
t++;
}
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int W, n, v[1000], w[1000], dp[1001][1001], t = 1;
while (cin >> W, W) {
cin >> n;
for (int i = 0; i < n; i++)
scanf("%d,%d", &v[i], &w[i]);
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 1000; j++)
dp[i][j] = -1;
for (int i = 0; i < 1000; i++) {
dp[0][i] = 0;
}
for (int i = 0; i < n; i++)
for (int j = 0; j <= W; j++)
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
cout << "Case " << t << ":" << endl;
for (int i = W; i >= 0; i--) {
if (dp[n][i] != dp[n][W]) {
cout << dp[n][W] << endl << i + 1 << endl;
break;
}
}
t++;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | -11 | |
p00042 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string.h>
#include <vector>
#define loop(lp) for (int lp2 = 0; lp2 < lp; lp2++)
#define ascent(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
using namespace std;
int dp[2000][20000];
int main() {
int w_max, count = 0;
while (cin >> w_max, w_max) {
count++;
int n;
cin >> n;
memset(dp, 0, sizeof(dp));
int v, w;
pair<int, int> w_sum;
w_sum = make_pair(0, 0);
ascent(i, 1, n + 1) {
scanf("%d,%d", &v, &w);
ascent(j, 1, w_max + 1) {
if (w <= j) {
if (dp[i - 1][j] < dp[i - 1][j - w] + v) {
dp[i][j] = dp[i - 1][j - w] + v;
if (w_sum.first < dp[i][j] ||
w_sum.first == dp[i][j] && j < w_sum.second) {
w_sum = make_pair(dp[i][j], j);
// cout << "i = " << i << " " << "wsum = " << w_sum.second <<
// endl;
}
} else {
dp[i][j] = dp[i - 1][j];
}
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
/*
ascent(i, 0, n+1) {
ascent(j, 0, w_max+1) {
printf("%3d ", dp[i][j]);
}
puts("");
}
*/
cout << "Case " << count << ":" << endl;
cout << dp[n][w_max] << endl;
cout << w_sum.second << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <string.h>
#include <vector>
#define loop(lp) for (int lp2 = 0; lp2 < lp; lp2++)
#define ascent(i, a, b) for (int i = a; i < b; i++)
#define pb push_back
using namespace std;
int dp[1010][10010];
int main() {
int w_max, count = 0;
while (cin >> w_max, w_max) {
count++;
int n;
cin >> n;
memset(dp, 0, sizeof(dp));
int v, w;
pair<int, int> w_sum;
w_sum = make_pair(0, 0);
ascent(i, 1, n + 1) {
scanf("%d,%d", &v, &w);
ascent(j, 1, w_max + 1) {
if (w <= j) {
if (dp[i - 1][j] < dp[i - 1][j - w] + v) {
dp[i][j] = dp[i - 1][j - w] + v;
if (w_sum.first < dp[i][j] ||
w_sum.first == dp[i][j] && j < w_sum.second) {
w_sum = make_pair(dp[i][j], j);
// cout << "i = " << i << " " << "wsum = " << w_sum.second <<
// endl;
}
} else {
dp[i][j] = dp[i - 1][j];
}
} else {
dp[i][j] = dp[i - 1][j];
}
}
}
/*
ascent(i, 0, n+1) {
ascent(j, 0, w_max+1) {
printf("%3d ", dp[i][j]);
}
puts("");
}
*/
cout << "Case " << count << ":" << endl;
cout << dp[n][w_max] << endl;
cout << w_sum.second << endl;
}
return 0;
} | replace | 16 | 17 | 16 | 17 | MLE | |
p00042 | C++ | Memory Limit Exceeded | #include <cstring>
#include <iostream>
using namespace std;
const int MAX_w = 1000;
const int MAX_v = 10000;
int dp[MAX_w + 1][MAX_v + 1];
int n, wet;
int w[MAX_w], v[MAX_v];
// i番目以降の品物から重さの和がj以下なるように選んだときの、
// 取りうる価値の総和の最大値を返す関数
int rec(int i, int j) {
int res;
if (dp[i][j] != -1) {
return dp[i][j];
}
if (i == n) {
// 品物がもう残っていないときは、価値の和の最大値は0で確定
res = 0;
} else if (j < w[i]) {
// 残りの容量が足りず品物iを入れられないので、入れないパターンだけ処理
// i+1 以降の品物のみを使ったときの最大値をそのままこの場合の最大値にする
res = rec(i + 1, j);
} else {
// 品物iを入れるか入れないか選べるので、両方試して価値の和が大きい方を選ぶ
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return dp[i][j] = res;
}
void solve(int ca) {
// 0番目以降で容量W以下の場合の結果を表示する
int wmin;
memset(dp, -1, sizeof(dp));
cout << "Case"
<< " " << ca << ":" << endl;
int ans = rec(0, wet);
cout << ans << endl;
for (int w = wet - 1; w >= 0; w--) {
if (ans != rec(0, w)) {
wmin = w + 1;
break;
}
}
cout << wmin << endl;
}
int main() {
char x;
int ca = 0;
while (1) {
ca++;
cin >> wet;
if (wet == 0)
break;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i] >> x >> w[i];
}
solve(ca);
}
return 0;
} | #include <cstring>
#include <iostream>
using namespace std;
const int MAX_w = 1000;
const int MAX_v = 1000;
int dp[MAX_w + 1][MAX_v + 1];
int n, wet;
int w[MAX_w], v[MAX_v];
// i番目以降の品物から重さの和がj以下なるように選んだときの、
// 取りうる価値の総和の最大値を返す関数
int rec(int i, int j) {
int res;
if (dp[i][j] != -1) {
return dp[i][j];
}
if (i == n) {
// 品物がもう残っていないときは、価値の和の最大値は0で確定
res = 0;
} else if (j < w[i]) {
// 残りの容量が足りず品物iを入れられないので、入れないパターンだけ処理
// i+1 以降の品物のみを使ったときの最大値をそのままこの場合の最大値にする
res = rec(i + 1, j);
} else {
// 品物iを入れるか入れないか選べるので、両方試して価値の和が大きい方を選ぶ
res = max(rec(i + 1, j), rec(i + 1, j - w[i]) + v[i]);
}
return dp[i][j] = res;
}
void solve(int ca) {
// 0番目以降で容量W以下の場合の結果を表示する
int wmin;
memset(dp, -1, sizeof(dp));
cout << "Case"
<< " " << ca << ":" << endl;
int ans = rec(0, wet);
cout << ans << endl;
for (int w = wet - 1; w >= 0; w--) {
if (ans != rec(0, w)) {
wmin = w + 1;
break;
}
}
cout << wmin << endl;
}
int main() {
char x;
int ca = 0;
while (1) {
ca++;
cin >> wet;
if (wet == 0)
break;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> v[i] >> x >> w[i];
}
solve(ca);
}
return 0;
} | replace | 6 | 7 | 6 | 7 | MLE | |
p00042 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define INF 100000000
#define rep(i, a) for (int i = 0; i < (a); i++)
using namespace std;
typedef long long ll;
int dp[2000][20000]; // dp[i][j] i番目以前の物で、重さがj以下の時の価値
int W[2000], V[2000];
int w, n;
void solve() {
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= w; j++) {
if (j - W[i] < 0) {
dp[i][j] = dp[i + 1][j];
} else {
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - W[i]] + V[i]);
}
}
}
cout << dp[0][w] << endl;
for (int i = w; i >= 1; i--) {
if (dp[0][i] != dp[0][i - 1]) {
cout << i << endl;
break;
}
}
}
int main() {
int count = 1;
while (1) {
memset(dp, 0, sizeof(dp));
cin >> w >> n;
if (w == 0)
break;
char a;
rep(i, n) cin >> V[i] >> a >> W[i];
cout << "Case " << count << ":" << endl;
count++;
solve();
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
#define INF 100000000
#define rep(i, a) for (int i = 0; i < (a); i++)
using namespace std;
typedef long long ll;
int dp[1001][10001]; // dp[i][j] i番目以前の物で、重さがj以下の時の価値
int W[1001], V[1001];
int w, n;
void solve() {
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= w; j++) {
if (j - W[i] < 0) {
dp[i][j] = dp[i + 1][j];
} else {
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - W[i]] + V[i]);
}
}
}
cout << dp[0][w] << endl;
for (int i = w; i >= 1; i--) {
if (dp[0][i] != dp[0][i - 1]) {
cout << i << endl;
break;
}
}
}
int main() {
int count = 1;
while (1) {
memset(dp, 0, sizeof(dp));
cin >> w >> n;
if (w == 0)
break;
char a;
rep(i, n) cin >> V[i] >> a >> W[i];
cout << "Case " << count << ":" << endl;
count++;
solve();
}
return 0;
} | replace | 16 | 18 | 16 | 18 | MLE | |
p00042 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define pb(n) push_back(n)
#define mp(n, m) make_pair(n, m)
#define fi first
#define se second
#define all(r) (r).begin(), (r).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int IMAX = ((1 << 30) - 1) * 2 + 1;
const double EPS = 1e-10;
// int mod=1000000007
int w, n;
vector<vi> v(1010, vi(1010, -1));
vector<pii> p(1010, pii(0, 0));
void init() {
rep(i, 1010) {
rep(j, 1010) { v[i][j] = -1; }
}
}
int calc(int i, int j) {
if (i >= n)
return 0;
if (v[i][j] != -1)
return v[i][j];
int ret;
if (j - p[i].se < 0)
ret = calc(i + 1, j);
else {
ret = max(calc(i + 1, j), p[i].fi + calc(i + 1, j - p[i].se));
}
// rep(i,n){
// rep(j,w+1){
// printf("%3d ",v[i][j]);
// }
// cout<<endl;
// }
// cout<<endl;
return v[i][j] = ret;
}
int main() {
char c;
int Case = 0;
int a, b;
while (cin >> w && w > 0) {
init();
cin >> n;
rep(i, n) { cin >> p[i].fi >> c >> p[i].se; }
a = calc(0, 0);
for (int i = 1; i <= w; i++) {
init();
if (a < calc(0, i)) {
a = calc(0, i);
b = i;
}
}
cout << "Case " << (++Case) << ":" << endl;
cout << a << endl;
cout << b << endl;
}
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define pb(n) push_back(n)
#define mp(n, m) make_pair(n, m)
#define fi first
#define se second
#define all(r) (r).begin(), (r).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repc(i, a, b) for (int i = (a); i < (b); i++)
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int IMAX = ((1 << 30) - 1) * 2 + 1;
const double EPS = 1e-10;
// int mod=1000000007
int w, n;
vector<vi> v(1010, vi(1010, -1));
vector<pii> p(1010, pii(0, 0));
void init() {
rep(i, 1010) {
rep(j, 1010) { v[i][j] = -1; }
}
}
int calc(int i, int j) {
if (i >= n)
return 0;
if (v[i][j] != -1)
return v[i][j];
int ret;
if (j - p[i].se < 0)
ret = calc(i + 1, j);
else {
ret = max(calc(i + 1, j), p[i].fi + calc(i + 1, j - p[i].se));
}
// rep(i,n){
// rep(j,w+1){
// printf("%3d ",v[i][j]);
// }
// cout<<endl;
// }
// cout<<endl;
return v[i][j] = ret;
}
int main() {
char c;
int Case = 0;
int a, b;
while (cin >> w && w > 0) {
init();
cin >> n;
rep(i, n) { cin >> p[i].fi >> c >> p[i].se; }
a = calc(0, 0);
for (int i = 1; i <= w; i++) {
// init();
if (a < calc(0, i)) {
a = calc(0, i);
b = i;
}
}
cout << "Case " << (++Case) << ":" << endl;
cout << a << endl;
cout << b << endl;
}
} | replace | 78 | 79 | 78 | 79 | TLE | |
p00042 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int dp[10000][10000];
int main() {
int W, N, v[1024], w[1024], c = 0, res = 0;
while (scanf("%d", &W) && W) {
c++;
scanf("%d", &N);
for (int i = 0; i < N; ++i)
scanf("%d,%d", v + i, w + i);
res = 0;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < N; ++i) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
for (int j = 0; j < W; ++j)
if (dp[N][j] < dp[N][W])
res++;
printf("Case %d:\n%d\n%d\n", c, dp[N][W], res);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
int dp[1001][1001];
int main() {
int W, N, v[1024], w[1024], c = 0, res = 0;
while (scanf("%d", &W) && W) {
c++;
scanf("%d", &N);
for (int i = 0; i < N; ++i)
scanf("%d,%d", v + i, w + i);
res = 0;
memset(dp, 0, sizeof(dp));
for (int i = 0; i < N; ++i) {
for (int j = 0; j <= W; j++) {
if (j < w[i])
dp[i + 1][j] = dp[i][j];
else
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
}
}
for (int j = 0; j < W; ++j)
if (dp[N][j] < dp[N][W])
res++;
printf("Case %d:\n%d\n%d\n", c, dp[N][W], res);
}
return 0;
} | replace | 6 | 7 | 6 | 7 | MLE | |
p00042 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int w, n;
int count = 0;
while (cin >> w, w) {
vector<pair<int, int>> v;
long long dp[1000][1000];
memset(dp, 0, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++) {
int s, t;
scanf("%d,%d", &s, &t);
v.push_back(make_pair(s, t));
}
for (int i = n - 1; 0 <= i; i--) {
for (int j = 0; j <= w; j++) {
if (j < v[i].second)
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - v[i].second] + v[i].first);
}
}
cout << "Case " << ++count << ":" << endl;
cout << dp[0][w] << endl;
for (int i = w;; i--) {
if (dp[0][i] != dp[0][w]) {
cout << i + 1 << endl;
break;
}
}
}
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int w, n;
int count = 0;
while (cin >> w, w) {
vector<pair<int, int>> v;
long long dp[1010][1010];
memset(dp, 0, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++) {
int s, t;
scanf("%d,%d", &s, &t);
v.push_back(make_pair(s, t));
}
for (int i = n - 1; 0 <= i; i--) {
for (int j = 0; j <= w; j++) {
if (j < v[i].second)
dp[i][j] = dp[i + 1][j];
else
dp[i][j] = max(dp[i + 1][j], dp[i + 1][j - v[i].second] + v[i].first);
}
}
cout << "Case " << ++count << ":" << endl;
cout << dp[0][w] << endl;
for (int i = w;; i--) {
if (dp[0][i] != dp[0][w]) {
cout << i + 1 << endl;
break;
}
}
}
} | replace | 12 | 13 | 12 | 13 | 0 | |
p00042 | C++ | Time Limit Exceeded | #include <algorithm>
#include <stdio.h>
using namespace std;
int W, N, v[1000], w[1000], dp[1001][1001], c, r;
int main() {
while (~scanf("%d", &W)) {
if (!W)
break;
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%d%d", &w[i], &v[i]);
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= W; j++) {
dp[i][j] = dp[i - 1][j];
if (j >= w[i - 1]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
}
}
printf("Case %d:\n", ++c);
printf("%d\n", dp[N][W]);
printf("%d\n", lower_bound(dp[N], dp[N] + W + 1, dp[N][W]) - dp[N]);
}
return 0;
} | #include <algorithm>
#include <stdio.h>
using namespace std;
int W, N, v[1000], w[1000], dp[1001][1001], c, r;
int main() {
while (~scanf("%d", &W)) {
if (!W)
break;
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%d,%d", &v[i], &w[i]);
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= W; j++) {
dp[i][j] = dp[i - 1][j];
if (j >= w[i - 1]) {
dp[i][j] = max(dp[i][j], dp[i - 1][j - w[i - 1]] + v[i - 1]);
}
}
}
printf("Case %d:\n", ++c);
printf("%d\n", dp[N][W]);
printf("%d\n", lower_bound(dp[N], dp[N] + W + 1, dp[N][W]) - dp[N]);
}
return 0;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p00042 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second > b.second;
}
int main() {
int n, W;
int t = 1;
while (cin >> W >> n && W) {
vector<pair<int, int>> cur;
cur.push_back({0, 0});
for (int i = 0; i < n; i++) {
int w, c;
scanf("%d,%d", &c, &w);
for (int j = 0, t = cur.size(); j < t; j++)
cur.push_back(pair<int, int>(cur[j].first + w, cur[j].second + c));
sort(cur.begin(), cur.end(), cmp);
int maxi = -1;
vector<pair<int, int>> nex;
for (int j = 0; j < cur.size(); j++) {
if (maxi >= cur[j].second)
continue;
nex.push_back(cur[j]);
maxi = cur[j].second;
}
cur = nex;
}
int ans = 0, ans2;
for (int i = 0; i < cur.size(); i++) {
if (cur[i].first <= W) {
ans = cur[i].second;
ans2 = cur[i].first;
}
}
cout << "Case " << t++ << ":" << endl;
cout << ans << endl;
cout << ans2 << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
bool cmp(const pair<int, int> &a, const pair<int, int> &b) {
if (a.first != b.first)
return a.first < b.first;
else
return a.second > b.second;
}
int main() {
int n, W;
int t = 1;
while (cin >> W >> n && W) {
vector<pair<int, int>> cur;
cur.push_back({0, 0});
for (int i = 0; i < n; i++) {
int w, c;
scanf("%d,%d", &c, &w);
for (int j = 0, t = cur.size(); j < t; j++)
cur.push_back(pair<int, int>(cur[j].first + w, cur[j].second + c));
sort(cur.begin(), cur.end(), cmp);
int maxi = -1;
vector<pair<int, int>> nex;
for (int j = 0; j < cur.size(); j++) {
if (maxi >= cur[j].second)
continue;
if (cur[j].first <= W)
nex.push_back(cur[j]);
maxi = cur[j].second;
}
cur = nex;
}
int ans = 0, ans2;
for (int i = 0; i < cur.size(); i++) {
if (cur[i].first <= W) {
ans = cur[i].second;
ans2 = cur[i].first;
}
}
cout << "Case " << t++ << ":" << endl;
cout << ans << endl;
cout << ans2 << endl;
}
} | replace | 26 | 27 | 26 | 29 | TLE | |
p00042 | C++ | Runtime Error | // バグ有
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int W, N;
char d;
int counter = 1;
int takara[1000][2];
while (1) {
cin >> W;
if (W == 0) {
break;
}
cin >> N;
for (int i = 0; i < N; i++) {
cin >> takara[i][0] >> d >> takara[i][1];
}
vector<vector<int>> dp(W, vector<int>(N + 1));
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
dp[j][i] = 0;
}
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0) {
continue;
}
if (j < takara[i - 1][1]) {
dp[j][i] = dp[j][i - 1];
} else {
dp[j][i] = max(dp[j][i - 1],
dp[j - takara[i - 1][1]][i - 1] + takara[i - 1][0]);
}
}
}
int MAX[2];
MAX[0] = 0;
MAX[1] = 10000;
for (int i = 0; i <= W; i++) {
if (MAX[0] == dp[i][N]) {
MAX[1] = min(MAX[1], i);
} else if (MAX[0] < dp[i][N]) {
MAX[0] = dp[i][N];
MAX[1] = i;
}
}
cout << "Case " << counter << ':' << endl
<< MAX[0] << endl
<< MAX[1] << endl;
counter++;
}
return 0;
} | // バグ有
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int W, N;
char d;
int counter = 1;
int takara[1000][2];
while (1) {
cin >> W;
if (W == 0) {
break;
}
cin >> N;
for (int i = 0; i < N; i++) {
cin >> takara[i][0] >> d >> takara[i][1];
}
vector<vector<int>> dp(W + 1, vector<int>(N + 1));
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
dp[j][i] = 0;
}
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (i == 0) {
continue;
}
if (j < takara[i - 1][1]) {
dp[j][i] = dp[j][i - 1];
} else {
dp[j][i] = max(dp[j][i - 1],
dp[j - takara[i - 1][1]][i - 1] + takara[i - 1][0]);
}
}
}
int MAX[2];
MAX[0] = 0;
MAX[1] = 10000;
for (int i = 0; i <= W; i++) {
if (MAX[0] == dp[i][N]) {
MAX[1] = min(MAX[1], i);
} else if (MAX[0] < dp[i][N]) {
MAX[0] = dp[i][N];
MAX[1] = i;
}
}
cout << "Case " << counter << ':' << endl
<< MAX[0] << endl
<< MAX[1] << endl;
counter++;
}
return 0;
} | replace | 22 | 23 | 22 | 23 | -11 | |
p00042 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <deque>
using namespace std;
typedef pair<int, int> P;
int W, N, v[1000], w[1000];
int I;
P dp[1000][1000];
bool done[1000][1000];
P solve(int i, int r) {
if (done[i][r])
return dp[i][r];
P result;
if (i == N)
result = P(0, r);
else {
if (r - w[i] >= 0) {
P p = solve(i + 1, r - w[i]);
p.first += v[i];
result = max(p, solve(i + 1, r));
} else {
result = solve(i + 1, r);
}
}
done[i][r] = true;
return dp[i][r] = result;
}
int main() {
while (I++, scanf("%d%d", &W, &N), W) {
for (int i = 0; i < N; i++)
scanf("%d,%d", v + i, w + i);
memset(done, 0, sizeof(done));
P p = solve(0, W);
printf("Case %d:\n%d\n%d\n", I, p.first, W - p.second);
}
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <deque>
using namespace std;
typedef pair<int, int> P;
int W, N, v[1000], w[1000];
int I;
P dp[1001][1001];
bool done[1001][1001];
P solve(int i, int r) {
if (done[i][r])
return dp[i][r];
P result;
if (i == N)
result = P(0, r);
else {
if (r - w[i] >= 0) {
P p = solve(i + 1, r - w[i]);
p.first += v[i];
result = max(p, solve(i + 1, r));
} else {
result = solve(i + 1, r);
}
}
done[i][r] = true;
return dp[i][r] = result;
}
int main() {
while (I++, scanf("%d%d", &W, &N), W) {
for (int i = 0; i < N; i++)
scanf("%d,%d", v + i, w + i);
memset(done, 0, sizeof(done));
P p = solve(0, W);
printf("Case %d:\n%d\n%d\n", I, p.first, W - p.second);
}
} | replace | 10 | 12 | 10 | 12 | 0 | |
p00042 | C++ | Runtime Error | #include <iostream>
#include <stdio.h>
using namespace std;
int dp[1001][1001];
int main() {
int W, N, v[1000], w[1000];
int n = 1;
int lastj = 0;
char jyama;
while (cin >> W && W) {
cin >> N;
for (int i = 0; i < N; i++) {
scanf("%d,%d", &v[i], &w[i]);
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
if (j > 0 && dp[i][j] != dp[i][j - 1])
lastj = j;
}
}
}
cout << "Case " << n << ":" << endl;
cout << dp[N][W] << endl;
cout << lastj << endl;
++n;
}
} | #include <iostream>
#include <stdio.h>
using namespace std;
int dp[1005][1005];
int main() {
int W, N, v[1000], w[1000];
int n = 1;
int lastj = 0;
char jyama;
while (cin >> W && W) {
cin >> N;
for (int i = 0; i < N; i++) {
scanf("%d,%d", &v[i], &w[i]);
}
for (int i = 0; i <= N; i++) {
for (int j = 0; j <= W; j++) {
if (j < w[i]) {
dp[i + 1][j] = dp[i][j];
} else {
dp[i + 1][j] = max(dp[i][j], dp[i][j - w[i]] + v[i]);
if (j > 0 && dp[i][j] != dp[i][j - 1])
lastj = j;
}
}
}
cout << "Case " << n << ":" << endl;
cout << dp[N][W] << endl;
cout << lastj << endl;
++n;
}
} | replace | 3 | 4 | 3 | 4 | 0 | |
p00043 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 100000000
#define pb push_back
#define fi first
#define sec second
#define SS stringstream
using namespace std;
typedef pair<int, int> P;
typedef long long int ll;
string str;
char num[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
int t[10];
int main() {
while (cin >> str) {
vector<int> ans;
for (int i = 0; i < 10; i++)
t[i] = 0;
for (int i = 0; i < str.size(); i++) {
for (int j = 1; j < 10; j++) {
if (str[i] == num[j]) {
t[j]++;
break;
}
}
}
bool flag = false;
for (int i = 1; i < 10; i++) {
if (t[i] > 4) {
cout << "0" << endl;
flag = true;
break;
}
}
if (flag == true)
continue;
for (int i = 1; i < 10; i++) {
if (t[i] == 4)
continue;
t[i]++;
for (int j = 1; j < 10; j++) {
if (t[j] >= 2) {
int temp[10];
for (int k = 0; k < 10; k++)
temp[k] = t[k];
t[j] -= 2;
for (int l = 1; l < 10; l++) {
if (t[l] >= 3) {
t[l] -= 3;
}
if (t[l] == 1 || t[l] == 2) {
if (t[l + 1] < t[l] || t[l + 2] < t[l])
break;
else {
t[l + 1] -= t[l];
t[l + 2] -= t[l];
t[l] = 0;
}
}
}
bool hata = false;
for (int k = 0; k < 10; k++) {
if (t[k] != 0)
break;
if (k == 9) {
ans.pb(i);
hata = true;
}
}
for (int k = 0; k < 10; k++)
t[k] = temp[k];
if (hata == true)
break;
}
}
t[i]--;
}
if (ans.size() == 0)
cout << "0" << endl;
else {
cout << ans[0];
for (int i = 1; i < ans.size(); i++) {
cout << " " << ans[i];
}
cout << endl;
}
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define INF 100000000
#define pb push_back
#define fi first
#define sec second
#define SS stringstream
using namespace std;
typedef pair<int, int> P;
typedef long long int ll;
string str;
char num[10] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
int t[10];
int main() {
while (cin >> str) {
vector<int> ans;
for (int i = 0; i < 10; i++)
t[i] = 0;
for (int i = 0; i < str.size(); i++) {
for (int j = 1; j < 10; j++) {
if (str[i] == num[j]) {
t[j]++;
break;
}
}
}
bool flag = false;
for (int i = 1; i < 10; i++) {
if (t[i] > 4) {
cout << "0" << endl;
flag = true;
break;
}
}
if (flag == true)
continue;
for (int i = 1; i < 10; i++) {
if (t[i] == 4)
continue;
t[i]++;
for (int j = 1; j < 10; j++) {
if (t[j] >= 2) {
int temp[10];
for (int k = 0; k < 10; k++)
temp[k] = t[k];
t[j] -= 2;
for (int l = 1; l < 10; l++) {
if (t[l] >= 3) {
t[l] -= 3;
}
if (t[l] == 1 || t[l] == 2) {
if (l > 7)
break;
if (t[l + 1] < t[l] || t[l + 2] < t[l])
break;
else {
t[l + 1] -= t[l];
t[l + 2] -= t[l];
t[l] = 0;
}
}
}
bool hata = false;
for (int k = 0; k < 10; k++) {
if (t[k] != 0)
break;
if (k == 9) {
ans.pb(i);
hata = true;
}
}
for (int k = 0; k < 10; k++)
t[k] = temp[k];
if (hata == true)
break;
}
}
t[i]--;
}
if (ans.size() == 0)
cout << "0" << endl;
else {
cout << ans[0];
for (int i = 1; i < ans.size(); i++) {
cout << " " << ans[i];
}
cout << endl;
}
}
} | insert | 65 | 65 | 65 | 67 | 0 | |
p00043 | C++ | Time Limit Exceeded | #include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
#define loop(i, a, b) for (int i = (a); i < ull(b); ++i)
#define rep(i, n) loop(i, 0, n)
#define all(a) (a).begin(), (a).end()
bool ok(int i, int j) { return i == j && i < 9; }
int main() {
string s;
vector<vector<int>> a, b;
for (int i = 1; i < 10; i++) {
vector<int> v;
for (int j = 0; j < 2; j++)
v.push_back(i);
b.push_back(v);
v.push_back(i);
a.push_back(v);
}
for (int i = 1; i <= 7; i++) {
vector<int> v;
for (int j = 0; j < 3; j++)
v.push_back(i + j);
a.push_back(v);
}
while (cin >> s) {
int c[10] = {0};
for (int i = 0; i < s.size(); i++)
c[s[i] - '0']++;
string t = "123456789";
vector<int> ret;
rep(q, t.size()) {
c[t[q] - '0']++;
bool p = true;
rep(i, 10) if (4 < c[i]) {
c[t[q] - '0']--;
p = false;
break;
}
if (!p)
continue;
loop(i, 0, a.size()) loop(j, 0, a.size()) {
if (ok(i, j))
continue;
loop(k, 0, a.size()) {
if (ok(j, k) || ok(i, k))
continue;
loop(l, 0, a.size()) {
if (ok(i, l) || ok(j, l) || ok(k, l))
continue;
rep(m, b.size()) {
if (i == m || j == m || k == m || l == m)
continue;
int d[10] = {0};
rep(n, 3) {
d[a[i][n]]++;
d[a[j][n]]++;
d[a[k][n]]++;
d[a[l][n]]++;
}
rep(n, 2) d[b[m][n]]++;
bool possible = true;
rep(n, 10) if (c[n] != d[n]) possible = false;
if (possible)
ret.push_back(q + 1);
}
}
}
}
c[t[q] - '0']--;
}
int n = -1;
rep(i, ret.size()) {
if (n != ret[i]) {
cout << (i == 0 ? "" : " ") << ret[i];
n = ret[i];
}
}
if (n == -1)
cout << 0;
cout << endl;
}
} | #include <iostream>
#include <string>
#include <vector>
using namespace std;
typedef unsigned long long ull;
#define loop(i, a, b) for (int i = (a); i < ull(b); ++i)
#define rep(i, n) loop(i, 0, n)
#define all(a) (a).begin(), (a).end()
bool ok(int i, int j) { return i == j && i < 9; }
int main() {
string s;
vector<vector<int>> a, b;
for (int i = 1; i < 10; i++) {
vector<int> v;
for (int j = 0; j < 2; j++)
v.push_back(i);
b.push_back(v);
v.push_back(i);
a.push_back(v);
}
for (int i = 1; i <= 7; i++) {
vector<int> v;
for (int j = 0; j < 3; j++)
v.push_back(i + j);
a.push_back(v);
}
while (cin >> s) {
int c[10] = {0};
for (int i = 0; i < s.size(); i++)
c[s[i] - '0']++;
string t = "123456789";
vector<int> ret;
rep(q, t.size()) {
c[t[q] - '0']++;
bool p = true;
rep(i, 10) if (4 < c[i]) {
c[t[q] - '0']--;
p = false;
break;
}
if (!p)
continue;
loop(i, 0, a.size()) loop(j, 0, a.size()) {
if (ok(i, j))
continue;
loop(k, 0, a.size()) {
if (ok(j, k) || ok(i, k))
continue;
loop(l, 0, a.size()) {
if (ok(i, l) || ok(j, l) || ok(k, l))
continue;
rep(m, b.size()) {
if (i == m || j == m || k == m || l == m)
continue;
int d[10] = {0};
rep(n, 3) {
d[a[i][n]]++;
d[a[j][n]]++;
d[a[k][n]]++;
d[a[l][n]]++;
}
rep(n, 2) d[b[m][n]]++;
bool possible = true;
rep(n, 10) if (c[n] != d[n]) {
possible = false;
break;
}
if (possible)
ret.push_back(q + 1);
}
}
}
}
c[t[q] - '0']--;
}
int n = -1;
rep(i, ret.size()) {
if (n != ret[i]) {
cout << (i == 0 ? "" : " ") << ret[i];
n = ret[i];
}
}
if (n == -1)
cout << 0;
cout << endl;
}
} | replace | 69 | 70 | 69 | 73 | TLE | |
p00043 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <string>
#define NO 100000
#define NO2 1000000000
using namespace std;
int puz[14];
bool solve(int Spuz[]) {
int Bpuz[14];
int tmp[3];
bool f = true;
for (int i = 0; i < 14; i++) {
Bpuz[i] = Spuz[i];
if (Bpuz[i] != NO && Bpuz[i] != NO2)
f = false;
}
if (f) {
return true;
}
sort(Bpuz, Bpuz + 14);
if (f == false) {
if (Bpuz[0] == Bpuz[1] && Bpuz[1] == Bpuz[2]) {
for (int j = 0; j < 3; j++) {
tmp[j] = Bpuz[j];
}
Bpuz[0] = NO, Bpuz[1] = NO, Bpuz[2] = NO;
f = solve(Bpuz);
for (int j = 0; j < 3; j++) {
Bpuz[j] = tmp[j];
}
}
}
if (f == false) {
if (Bpuz[13] != NO2) {
if (Bpuz[0] == Bpuz[1]) {
for (int j = 0; j < 2; j++) {
tmp[j] = Bpuz[j];
}
Bpuz[0] = NO2, Bpuz[1] = NO2;
f = solve(Bpuz);
for (int j = 0; j < 2; j++) {
Bpuz[j] = tmp[j];
}
}
}
}
if (f == false) {
int ii[3] = {0}, cnt = 1;
ii[0] = 0;
for (int i = 1; i < 14; i++) {
if (Bpuz[ii[cnt - 1]] != Bpuz[i]) {
if (Bpuz[ii[cnt - 1]] + 1 == Bpuz[i]) {
ii[cnt] = i;
cnt++;
if (cnt == 3) {
Bpuz[ii[0]] = NO, Bpuz[ii[1]] = NO, Bpuz[ii[2]] = NO;
f = solve(Bpuz);
break;
}
} else
break;
}
}
}
return f;
}
int main(void) {
string inp;
int cnt, ans[10];
int cou;
bool fl;
while (1) {
cin >> inp;
for (int i = 0; i < 13; i++) {
puz[i] = inp[i] - '0';
}
cnt = 0;
for (int i = 1; i < 10; i++) {
puz[13] = i;
fl = true;
for (int j = 1; j < 10; j++) {
cou = 0;
for (int k = 0; k < 14; k++) {
if (puz[k] == j) {
cou++;
}
}
if (cou >= 5) {
fl = false;
break;
}
}
if (fl) {
if (solve(puz)) {
ans[cnt] = i;
cnt++;
}
}
}
if (cnt != 0) {
for (int i = 0; i < cnt - 1; i++) {
cout << ans[i] << " ";
}
cout << ans[cnt - 1] << endl;
} else
cout << "0" << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#define NO 100000
#define NO2 1000000000
using namespace std;
int puz[14];
bool solve(int Spuz[]) {
int Bpuz[14];
int tmp[3];
bool f = true;
for (int i = 0; i < 14; i++) {
Bpuz[i] = Spuz[i];
if (Bpuz[i] != NO && Bpuz[i] != NO2)
f = false;
}
if (f) {
return true;
}
sort(Bpuz, Bpuz + 14);
if (f == false) {
if (Bpuz[0] == Bpuz[1] && Bpuz[1] == Bpuz[2]) {
for (int j = 0; j < 3; j++) {
tmp[j] = Bpuz[j];
}
Bpuz[0] = NO, Bpuz[1] = NO, Bpuz[2] = NO;
f = solve(Bpuz);
for (int j = 0; j < 3; j++) {
Bpuz[j] = tmp[j];
}
}
}
if (f == false) {
if (Bpuz[13] != NO2) {
if (Bpuz[0] == Bpuz[1]) {
for (int j = 0; j < 2; j++) {
tmp[j] = Bpuz[j];
}
Bpuz[0] = NO2, Bpuz[1] = NO2;
f = solve(Bpuz);
for (int j = 0; j < 2; j++) {
Bpuz[j] = tmp[j];
}
}
}
}
if (f == false) {
int ii[3] = {0}, cnt = 1;
ii[0] = 0;
for (int i = 1; i < 14; i++) {
if (Bpuz[ii[cnt - 1]] != Bpuz[i]) {
if (Bpuz[ii[cnt - 1]] + 1 == Bpuz[i]) {
ii[cnt] = i;
cnt++;
if (cnt == 3) {
Bpuz[ii[0]] = NO, Bpuz[ii[1]] = NO, Bpuz[ii[2]] = NO;
f = solve(Bpuz);
break;
}
} else
break;
}
}
}
return f;
}
int main(void) {
string inp;
int cnt, ans[10];
int cou;
bool fl;
while (cin >> inp) {
for (int i = 0; i < 13; i++) {
puz[i] = inp[i] - '0';
}
cnt = 0;
for (int i = 1; i < 10; i++) {
puz[13] = i;
fl = true;
for (int j = 1; j < 10; j++) {
cou = 0;
for (int k = 0; k < 14; k++) {
if (puz[k] == j) {
cou++;
}
}
if (cou >= 5) {
fl = false;
break;
}
}
if (fl) {
if (solve(puz)) {
ans[cnt] = i;
cnt++;
}
}
}
if (cnt != 0) {
for (int i = 0; i < cnt - 1; i++) {
cout << ans[i] << " ";
}
cout << ans[cnt - 1] << endl;
} else
cout << "0" << endl;
}
return 0;
} | replace | 77 | 79 | 77 | 78 | TLE | |
p00044 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define PRIM 50021
bool prim[50022];
int a_prime[50022];
int main() {
memset(prim, true, sizeof(prim));
int N;
prim[0] = false;
FOR(i, 1, sqrt(PRIM)) {
if (prim[i]) {
for (int j = (i + 1); (i + 1) * j <= PRIM; ++j) {
prim[(i + 1) * j - 1] = false;
}
}
}
while (scanf("%d", &N)) {
repr(i, N - 2) {
if (prim[i]) {
printf("%d ", i + 1);
break;
}
}
FOR(i, N, PRIM) {
if (prim[i]) {
printf("%d\n", i + 1);
break;
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
#define PRIM 50021
bool prim[50022];
int a_prime[50022];
int main() {
memset(prim, true, sizeof(prim));
int N;
prim[0] = false;
FOR(i, 1, sqrt(PRIM)) {
if (prim[i]) {
for (int j = (i + 1); (i + 1) * j <= PRIM; ++j) {
prim[(i + 1) * j - 1] = false;
}
}
}
while (cin >> N) {
repr(i, N - 2) {
if (prim[i]) {
printf("%d ", i + 1);
break;
}
}
FOR(i, N, PRIM) {
if (prim[i]) {
printf("%d\n", i + 1);
break;
}
}
}
return 0;
} | replace | 30 | 31 | 30 | 31 | TLE | |
p00044 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> arr(80000);
for (int i = 0; i < 80000; ++i)
arr[i] = 1;
for (int i = 2; i < sqrt(80000); ++i) {
if (arr[i]) {
for (int j = 0; i * (j + 2) < 80000; j++)
arr[i * (j + 2)] = 0;
}
}
while (1) {
int n;
cin >> n;
for (int i = n - 1; i >= 0; --i) {
if (arr[i] == 1) {
cout << i << " ";
break;
}
}
for (int i = n + 1; i <= 80000; ++i) {
if (arr[i] == 1) {
cout << i << endl;
break;
}
}
}
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> arr(80000);
for (int i = 0; i < 80000; ++i)
arr[i] = 1;
for (int i = 2; i < sqrt(80000); ++i) {
if (arr[i]) {
for (int j = 0; i * (j + 2) < 80000; j++)
arr[i * (j + 2)] = 0;
}
}
int n;
while (cin >> n) {
for (int i = n - 1; i >= 0; --i) {
if (arr[i] == 1) {
cout << i << " ";
break;
}
}
for (int i = n + 1; i <= 80000; ++i) {
if (arr[i] == 1) {
cout << i << endl;
break;
}
}
}
}
| replace | 18 | 21 | 18 | 21 | TLE | |
p00044 | C++ | Time Limit Exceeded | #include <iostream>
#include <string.h>
using namespace std;
int isprime[50101];
int main() {
memset(isprime, 0, sizeof(isprime));
for (int i = 4; i < 50101; i += 2)
isprime[i] = 1;
isprime[1] = 1;
for (int i = 3; i * i < 50101; i += 2)
if (isprime[i] == 0)
for (int j = 2; i * j < 50101; ++j)
isprime[i * j] = 1;
int n;
while (cin >> n, n) {
for (int k = n - 1; k > 0; --k)
if (isprime[k] == 0) {
cout << k << " ";
break;
}
for (int k = n + 1; k < 50101; ++k)
if (isprime[k] == 0) {
cout << k << endl;
break;
}
}
} | #include <iostream>
#include <string.h>
using namespace std;
int isprime[50101];
int main() {
memset(isprime, 0, sizeof(isprime));
for (int i = 4; i < 50101; i += 2)
isprime[i] = 1;
isprime[1] = 1;
for (int i = 3; i * i < 50101; i += 2)
if (isprime[i] == 0)
for (int j = 2; i * j < 50101; ++j)
isprime[i * j] = 1;
int n;
while (cin >> n) {
for (int k = n - 1; k > 0; --k)
if (isprime[k] == 0) {
cout << k << " ";
break;
}
for (int k = n + 1; k < 50101; ++k)
if (isprime[k] == 0) {
cout << k << endl;
break;
}
}
} | replace | 17 | 18 | 17 | 18 | TLE | |
p00044 | C++ | Runtime Error | #include <math.h>
#include <stdio.h>
#define N 50001
void Eratos(void);
int prime[N];
int main(void) {
int n;
int lessmax, bigmin;
Eratos();
while (scanf("%d", &n) != EOF) {
for (int i = n - 1;; i--) {
if (prime[i] == 1) {
lessmax = i;
break;
}
}
for (int i = n + 1;; i++) {
if (prime[i] == 1) {
bigmin = i;
break;
}
}
printf("%d %d\n", lessmax, bigmin);
}
return 0;
}
void Eratos(void) {
for (int i = 0; i < N; i++) {
prime[i] = 1;
}
prime[0] = prime[1] = 0;
for (int i = 2; i <= sqrt(N); i++) {
for (int j = 2; i * j < N; j++) {
prime[i * j] = 0;
}
}
} | #include <math.h>
#include <stdio.h>
#define N 50060
void Eratos(void);
int prime[N];
int main(void) {
int n;
int lessmax, bigmin;
Eratos();
while (scanf("%d", &n) != EOF) {
for (int i = n - 1;; i--) {
if (prime[i] == 1) {
lessmax = i;
break;
}
}
for (int i = n + 1;; i++) {
if (prime[i] == 1) {
bigmin = i;
break;
}
}
printf("%d %d\n", lessmax, bigmin);
}
return 0;
}
void Eratos(void) {
for (int i = 0; i < N; i++) {
prime[i] = 1;
}
prime[0] = prime[1] = 0;
for (int i = 2; i <= sqrt(N); i++) {
for (int j = 2; i * j < N; j++) {
prime[i * j] = 0;
}
}
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00044 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int i, no, input;
int prime[500];
int ptr = 0, c = 0;
int flag = 0;
int last;
while (cin >> input) {
flag = ptr = c = 0;
prime[ptr++] = 2;
prime[ptr++] = 3;
for (no = 5;; no += 2) {
if (flag == 2) {
break;
}
if (input + 1 <= no) {
flag = 1;
c++;
}
if (c == 1) {
if (input == prime[ptr - 1])
last = ptr - 2;
else
last = ptr - 1;
}
for (i = 1; i < ptr; i++) {
if (no % prime[i] == 0)
break;
}
if (ptr == i) {
prime[ptr++] = no;
if (flag == 1) {
flag = 2;
}
}
}
printf("%d %d\n", prime[last], prime[ptr - 1]);
}
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int i, no, input;
int prime[10000];
int ptr = 0, c = 0;
int flag = 0;
int last;
while (cin >> input) {
flag = ptr = c = 0;
prime[ptr++] = 2;
prime[ptr++] = 3;
for (no = 5;; no += 2) {
if (flag == 2) {
break;
}
if (input + 1 <= no) {
flag = 1;
c++;
}
if (c == 1) {
if (input == prime[ptr - 1])
last = ptr - 2;
else
last = ptr - 1;
}
for (i = 1; i < ptr; i++) {
if (no % prime[i] == 0)
break;
}
if (ptr == i) {
prime[ptr++] = no;
if (flag == 1) {
flag = 2;
}
}
}
printf("%d %d\n", prime[last], prime[ptr - 1]);
}
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00044 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int p[50100];
int main() {
int i, j;
for (i = 2; i * i < 50100; i++) {
if (p[i] == 0) {
for (j = i * 2; j < 50100; j += i) {
p[j] = 1;
}
}
}
while (cin >> i, i) {
for (j = i - 1; p[j]; j--) {
}
cout << j << ' ';
for (j = i + 1; p[j]; j++) {
}
cout << j << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int p[50100];
int main() {
int i, j;
for (i = 2; i * i < 50100; i++) {
if (p[i] == 0) {
for (j = i * 2; j < 50100; j += i) {
p[j] = 1;
}
}
}
while (cin >> i) {
for (j = i - 1; p[j]; j--) {
}
cout << j << ' ';
for (j = i + 1; p[j]; j++) {
}
cout << j << endl;
}
return 0;
} | replace | 12 | 13 | 12 | 13 | TLE | |
p00044 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define N (50000)
bool prime[N + 1];
int main() {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (int i = 2; i * i <= N; i++) {
for (int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
int n;
while (~scanf("%d", &n)) {
int l = n - 1;
while (!prime[l])
l--;
int r = n + 1;
while (!prime[r])
r++;
printf("%d %d\n", l, r);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define N (50500)
bool prime[N + 1];
int main() {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (int i = 2; i * i <= N; i++) {
for (int j = i * i; j <= N; j += i) {
prime[j] = false;
}
}
int n;
while (~scanf("%d", &n)) {
int l = n - 1;
while (!prime[l])
l--;
int r = n + 1;
while (!prime[r])
r++;
printf("%d %d\n", l, r);
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00045 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
map<double, double> m;
double a, b, ave, sum;
while (scanf("%lf,%lf", &a, &b)) {
if (!a)
break;
m[a] = b;
}
map<double, double>::iterator it = m.begin();
while (it != m.end()) {
ave += (*it).second, sum += ((*it).first * (*it).second);
it++;
}
ave /= m.size();
ave += 0.5;
cout << sum << endl << (int)ave << endl;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
int main() {
map<double, double> m;
double a, b, ave = 0, sum = 0;
while (scanf("%lf,%lf", &a, &b) != EOF) {
m[a] = b;
}
map<double, double>::iterator it = m.begin();
while (it != m.end()) {
ave += (*it).second, sum += ((*it).first * (*it).second);
it++;
}
ave /= m.size();
ave += 0.5;
cout << sum << endl << (int)ave << endl;
} | replace | 12 | 16 | 12 | 14 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include <bits //stdc++.h>
using namespace std;
int main() {
int a, b;
int ca = 0;
double cb = 0;
int i = 0;
while (scanf("%d,%d", &a, &b)) {
ca += a * b;
cb += b;
i++;
}
double cc = cb / i;
double cd = round(cc);
cout << ca << endl << cd << endl;
return 0;
} | #include <bits //stdc++.h>
using namespace std;
int main() {
int a, b;
int ca = 0;
double cb = 0;
int i = 0;
while (scanf("%d,%d", &a, &b) != EOF) {
ca += a * b;
cb += b;
i++;
}
double cc = cb / i;
double cd = round(cc);
cout << ca << endl << cd << endl;
return 0;
} | replace | 8 | 9 | 8 | 9 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
int main() {
int a, b, c = 0, d = 0, n = 0;
while (scanf("%d,%d", &a, &b))
c += a * b, d += b, n++;
printf("%d\n%d\n", c, (int)floor((double)d / n + 0.5));
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
template <class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }
int main() {
int a, b, c = 0, d = 0, n = 0;
while (~scanf("%d,%d", &a, &b))
c += a * b, d += b, n++;
printf("%d\n%d\n", c, (int)floor((double)d / n + 0.5));
return 0;
} | replace | 17 | 18 | 17 | 18 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int value, num, i = 0, total = 0, ave = 0;
while (scanf("%d %d", &value, &num) != EOF) {
total += value * num;
ave += num;
i++;
}
cout << total << endl << (int)(ave / (double)i + 0.5) << endl;
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int value, num, i = 0, total = 0, ave = 0;
while (scanf("%d, %d", &value, &num) != EOF) {
total += value * num;
ave += num;
i++;
}
cout << total << endl << (int)(ave / (double)i + 0.5) << endl;
return 0;
} | replace | 9 | 10 | 9 | 10 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int price, amount;
int sum = 0, ave = 0, i = 0;
while (scanf("%d,%d", &price, &amount)) {
sum += price * amount;
ave += amount;
i++;
}
printf("%d\n%d\n", sum, (int)(ave / (double)i + 0.5));
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int price, amount;
int sum = 0, ave = 0, i = 0;
while (scanf("%d,%d", &price, &amount) != EOF) {
sum += price * amount;
ave += amount;
i++;
}
printf("%d\n%d\n", sum, (int)(ave / (double)i + 0.5));
return 0;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include <iostream>
#include <string.h>
using namespace std;
int main() {
int m = 0, n = 0, c = 0, i, j;
char a;
while (cin >> i >> a >> j, i) {
m += (i * j);
n += j;
c++;
}
double am = 1.0 * n / c;
if (am * 10 - int(am / 10) > 4)
am = am + 1;
cout << m << endl << int(am) << endl;
} | #include <iostream>
#include <string.h>
using namespace std;
int main() {
int m = 0, n = 0, c = 0, i, j;
char a;
while (cin >> i >> a >> j) {
m += (i * j);
n += j;
c++;
}
double am = 1.0 * n / c;
if (am * 10 - int(am / 10) > 4)
am = am + 1;
cout << m << endl << int(am) << endl;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00045 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
int main() {
double a = 0.0, b = 0.0, sum = 0.0, sumw = 0.0;
double cnt = 0.0;
while (scanf("%lf,%lf", &a, &b) != '\n') {
sum = sum + a * b;
sumw = sumw + b;
cnt = cnt + 1.0;
}
cout << sum << endl;
cout << (int)floor((sumw / cnt) + 0.5) << endl;
} | #include "bits/stdc++.h"
using namespace std;
int main() {
double a = 0.0, b = 0.0, sum = 0.0, sumw = 0.0;
double cnt = 0.0;
while (scanf("%lf,%lf", &a, &b) != EOF) {
sum = sum + a * b;
sumw = sumw + b;
cnt = cnt + 1.0;
}
cout << sum << endl;
cout << (int)floor((sumw / cnt) + 0.5) << endl;
} | replace | 6 | 7 | 6 | 7 | TLE | |
p00046 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
void Solution() {
int n = 0;
double a[n];
while (cin >> a[n]) {
n++;
}
// for (int i = 0; i < n - 1; i++)
// {
// for (int j = i + 1; j < n; j++)
// {
// if (a[i] < a[j])
// {
// double temp = a[i]; //swap
// a[i] = a[j];
// a[j] = temp;
// }
// }
// }
sort(a, a + n); // sorting as ascedning sequence
// cout.setf(ios::fixed); //"setf" is used for “half-adjusting”
// cout.precision(2);
// cout<<a[0] - a[n - 1]<<endl;
cout << a[n - 1] - a[0] << endl;
}
int main() {
Solution();
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
void Solution() {
int n = 0;
double a[100]; // notice the definition.
while (cin >> a[n]) {
n++;
}
// for (int i = 0; i < n - 1; i++)
// {
// for (int j = i + 1; j < n; j++)
// {
// if (a[i] < a[j])
// {
// double temp = a[i]; //swap
// a[i] = a[j];
// a[j] = temp;
// }
// }
// }
sort(a, a + n); // sorting as ascedning sequence
// cout.setf(ios::fixed); //"setf" is used for “half-adjusting”
// cout.precision(2);
// cout<<a[0] - a[n - 1]<<endl;
cout << a[n - 1] - a[0] << endl;
}
int main() {
Solution();
return 0;
} | replace | 9 | 10 | 9 | 10 | -11 | |
p00046 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
double n, h = 0.0, l = 999999.0;
while (scanf("%lf", &n)) {
h = max(h, n);
l = min(l, n);
}
printf("%.1lf\n", h - l);
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
double n, h = 0.0, l = 999999.0;
while (cin >> n) {
h = max(h, n);
l = min(l, n);
}
printf("%.1lf\n", h - l);
} | replace | 8 | 9 | 8 | 9 | TLE | |
p00046 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main(void) {
double a, mx, mn;
cin >> a;
mx = mn = a;
while (1) {
if (cin.eof() == -1) {
break;
}
cin >> a;
mx = max(mx, a);
mn = min(mn, a);
}
cout << mx - mn << endl;
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
double a, mx, mn;
cin >> a;
mx = mn = a;
while (1) {
if (cin.eof()) {
break;
}
cin >> a;
mx = max(mx, a);
mn = min(mn, a);
}
cout << mx - mn << endl;
return 0;
} | replace | 9 | 10 | 9 | 10 | TLE | |
p00046 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<double> v;
vector<double>::iterator pv = v.begin();
double d;
while (cin >> d) {
v.push_back(d);
}
sort(v.begin(), v.end());
double a = *pv;
pv = v.end();
double b = *pv;
cout << b - a << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<double> v;
vector<double>::iterator pv = v.begin();
double d;
while (cin >> d) {
v.push_back(d);
}
sort(v.begin(), v.end());
int z = v.size();
double a = v[z - 1];
double b = v[0];
double c = a - b;
cout << c << endl;
return 0;
} | replace | 13 | 17 | 13 | 18 | -11 | |
p00047 | C++ | Time Limit Exceeded | #include <iostream>
#include <string>
using namespace std;
int main() {
int A = 1;
int B = 0;
int C = 0;
while (true) {
string s;
cin >> s;
if (s[0] == 'A') {
if (s[2] == 'B') {
int tmp;
tmp = B;
B = A;
A = tmp;
} else if (s[2] == 'C') {
int tmp;
tmp = C;
C = A;
A = tmp;
}
}
if (s[0] == 'B') {
if (s[2] == 'A') {
int tmp;
tmp = A;
A = B;
B = tmp;
} else if (s[2] == 'C') {
int tmp;
tmp = C;
C = B;
B = tmp;
}
} else if (s[0] == 'C') {
if (s[2] == 'A') {
int tmp;
tmp = A;
A = C;
C = tmp;
} else if (s[2] == 'B') {
int tmp;
tmp = B;
B = C;
C = tmp;
}
}
}
if (A == 1) {
cout << "A" << endl;
} else if (B == 1) {
cout << "B" << endl;
} else if (C == 1) {
cout << "C" << endl;
}
return 0;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
int A = 1;
int B = 0;
int C = 0;
string s;
while (cin >> s) {
if (s[0] == 'A') {
if (s[2] == 'B') {
int tmp;
tmp = B;
B = A;
A = tmp;
} else if (s[2] == 'C') {
int tmp;
tmp = C;
C = A;
A = tmp;
}
}
if (s[0] == 'B') {
if (s[2] == 'A') {
int tmp;
tmp = A;
A = B;
B = tmp;
} else if (s[2] == 'C') {
int tmp;
tmp = C;
C = B;
B = tmp;
}
} else if (s[0] == 'C') {
if (s[2] == 'A') {
int tmp;
tmp = A;
A = C;
C = tmp;
} else if (s[2] == 'B') {
int tmp;
tmp = B;
B = C;
C = tmp;
}
}
}
if (A == 1) {
cout << "A" << endl;
} else if (B == 1) {
cout << "B" << endl;
} else if (C == 1) {
cout << "C" << endl;
}
return 0;
}
| replace | 8 | 11 | 8 | 10 | TLE | |
p00047 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int cup[3] = {1};
int x, y;
while (scanf(" %d,%d", &x, &y) != EOF) {
swap(cup[x - 'A'], cup[y - 'A']);
}
for (int i = 0; i < 3; i++) {
if (cup[i] > 0) {
printf("%c\n", 'A' + i);
break;
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int cup[3] = {1};
char x, y;
while (scanf(" %c", &x) != EOF) {
scanf(",%c", &y);
swap(cup[x - 'A'], cup[y - 'A']);
}
for (int i = 0; i < 3; i++) {
if (cup[i] > 0) {
printf("%c\n", 'A' + i);
break;
}
}
return 0;
} | replace | 6 | 8 | 6 | 9 | TLE | |
p00047 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main() {
char X, Y, P = 'A';
while (scanf("%c,%c", &X, &Y)) {
if (X == P) {
P = Y;
} else if (Y == P) {
P = X;
}
}
printf("%c\n", P);
return 0;
} | #define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
int main() {
char X, Y, P = 'A';
while (scanf("%c,%c", &X, &Y) != EOF) {
if (X == P) {
P = Y;
} else if (Y == P) {
P = X;
}
}
printf("%c\n", P);
return 0;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00047 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
char f, t;
int data[3] = {1, 0, 0};
while (1) {
int tmp;
if (scanf("%c,%c") == EOF)
break;
tmp = data[t - 'A'];
data[t - 'A'] = data[f - 'A'];
data[f - 'A'] = tmp;
}
if (data[0] == 1)
cout << 'A' << endl;
else if (data[1] == 1)
cout << 'B' << endl;
else
cout << 'C' << endl;
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
char f, t;
int data[3] = {1, 0, 0};
while (1) {
int tmp;
if (scanf("%c,%c", &f, &t) == EOF)
break;
tmp = data[t - 'A'];
data[t - 'A'] = data[f - 'A'];
data[f - 'A'] = tmp;
}
if (data[0] == 1)
cout << 'A' << endl;
else if (data[1] == 1)
cout << 'B' << endl;
else
cout << 'C' << endl;
return 0;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p00047 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int cup[3] = {1, 0, 0}, temp = 0, count = 0;
char cup_str[5] = "ABC,";
char cup1, cup2, cup3;
while (1) {
cin >> cup1 >> cup2 >> cup3;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (cup1 == cup_str[j] && cup3 == cup_str[i]) {
temp = cup[j];
cup[j] = cup[i];
cup[i] = temp;
}
}
}
for (int i = 0; i < 3; i++) {
if (cup[i] == 1)
cout << cup_str[i] << endl;
}
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int cup[3] = {1, 0, 0}, temp = 0, count = 0;
char cup_str[5] = "ABC,";
char cup1, cup2, cup3;
while (1) {
cin >> cup1 >> cup2 >> cup3;
for (int i = 0; i < 4; i++) {
for (int j = 0; j < 4; j++) {
if (cup1 == cup_str[j] && cup3 == cup_str[i]) {
temp = cup[j];
cup[j] = cup[i];
cup[i] = temp;
}
}
}
count++;
if (count == 50)
break;
}
for (int i = 0; i < 3; i++) {
if (cup[i] == 1)
cout << cup_str[i] << endl;
}
return 0;
}
| replace | 22 | 26 | 22 | 30 | TLE | |
p00048 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
const string cls[] = {"",
"light fly",
"fly",
"bantam",
"feather",
"light",
"light welter",
"welter",
"light middle",
"middle",
"light heavy",
"heavy"};
const int a[] = {-100, 48, 51, 54, 57, 60, 64, 69, 75, 81, 91};
int main() {
double w;
while (cin >> w) {
int i = 0;
while (w > a[i])
i++;
cout << cls[i] << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
const string cls[] = {"",
"light fly",
"fly",
"bantam",
"feather",
"light",
"light welter",
"welter",
"light middle",
"middle",
"light heavy",
"heavy"};
const int a[] = {-100, 48, 51, 54, 57, 60, 64, 69, 75, 81, 91, 100000000};
int main() {
double w;
while (cin >> w) {
int i = 0;
while (w > a[i])
i++;
cout << cls[i] << endl;
}
} | replace | 17 | 18 | 17 | 18 | 0 | |
p00048 | C++ | Time Limit Exceeded | #include <cstdio>
int main() {
float n;
int m;
const char *rank[] = {"light fly", "fly", "bantam", "feather",
"light", "light welter", "welter", "light middle",
"middle", "light heavy", "heavy"};
while (scanf("%f\n", &n)) {
if (n <= 48.0)
m = 0;
else if (n <= 51.0)
m = 1;
else if (n <= 54.0)
m = 2;
else if (n <= 57.0)
m = 3;
else if (n <= 60.0)
m = 4;
else if (n <= 64.0)
m = 5;
else if (n <= 69.0)
m = 6;
else if (n <= 75.0)
m = 7;
else if (n <= 81.0)
m = 8;
else if (n <= 91.0)
m = 9;
else
m = 10;
puts(rank[m]);
}
return 0;
} | #include <cstdio>
int main() {
float n;
int m;
const char *rank[] = {"light fly", "fly", "bantam", "feather",
"light", "light welter", "welter", "light middle",
"middle", "light heavy", "heavy"};
while (~scanf("%f\n", &n)) {
if (n <= 48.0)
m = 0;
else if (n <= 51.0)
m = 1;
else if (n <= 54.0)
m = 2;
else if (n <= 57.0)
m = 3;
else if (n <= 60.0)
m = 4;
else if (n <= 64.0)
m = 5;
else if (n <= 69.0)
m = 6;
else if (n <= 75.0)
m = 7;
else if (n <= 81.0)
m = 8;
else if (n <= 91.0)
m = 9;
else
m = 10;
puts(rank[m]);
}
return 0;
} | replace | 8 | 9 | 8 | 9 | TLE | |
p00048 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s[11] = {"light fly", "fly", "bantam", "feather",
"light", "light welter", "welter", "light middle",
"middle", "light heavy", "heavy"};
double g[] = {48.0, 51.0, 54.0, 57.0, 60.0, 64.0, 69.0, 75.0, 81.0, 91.0};
int main() {
double n;
while (cin >> n) {
int m;
for (m = 0; m < 11 && n > g[m]; m++)
;
cout << s[m] << endl;
}
return 0;
}
/*
60.2
70.2
48.0
80.2
*/ | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
string s[11] = {"light fly", "fly", "bantam", "feather",
"light", "light welter", "welter", "light middle",
"middle", "light heavy", "heavy"};
double g[] = {48.0, 51.0, 54.0, 57.0, 60.0, 64.0, 69.0, 75.0, 81.0, 91.0};
int main() {
double n;
while (cin >> n) {
int m;
for (m = 0; m < 10 && n > g[m]; m++)
;
cout << s[m] << endl;
}
return 0;
}
/*
60.2
70.2
48.0
80.2
*/ | replace | 14 | 15 | 14 | 15 | 0 | |
p00049 | C++ | Runtime Error | #include <stdio.h>
#include <string.h>
int main(void) {
int a, b, ab, o;
int temp;
char blood[2];
a = b = ab = o = 0;
while (scanf("%d,%s", &temp, blood) != EOF) {
if (strcmp(blood, "AB") == 0)
ab++;
else if (strcmp(blood, "A") == 0)
a++;
else if (strcmp(blood, "B") == 0)
b++;
else if (strcmp(blood, "O") == 0)
o++;
}
printf("%d\n%d\n%d\n%d\n", a, b, ab, o);
return 0;
} | #include <stdio.h>
#include <string.h>
int main(void) {
int a, b, ab, o;
int temp;
char blood[3];
a = b = ab = o = 0;
while (scanf("%d,%s", &temp, blood) != EOF) {
if (strcmp(blood, "AB") == 0)
ab++;
else if (strcmp(blood, "A") == 0)
a++;
else if (strcmp(blood, "B") == 0)
b++;
else if (strcmp(blood, "O") == 0)
o++;
}
printf("%d\n%d\n%d\n%d\n", a, b, ab, o);
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00049 | C++ | Time Limit Exceeded | #include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
void solve() {
int count[4] = {0};
int num;
string blood;
while (scanf("%d,", &num)) {
cin >> blood;
if (blood == "A") {
++count[0];
} else if (blood == "B") {
++count[1];
} else if (blood == "AB") {
++count[2];
} else {
++count[3];
}
}
cout << count[0] << endl;
cout << count[1] << endl;
cout << count[2] << endl;
cout << count[3] << endl;
}
int main() {
solve();
return (0);
} | #include <iostream>
#include <stdio.h>
#include <string>
using namespace std;
void solve() {
int count[4] = {0};
int num;
string blood;
while (scanf("%d,", &num) != EOF) {
cin >> blood;
if (blood == "A") {
++count[0];
} else if (blood == "B") {
++count[1];
} else if (blood == "AB") {
++count[2];
} else {
++count[3];
}
}
cout << count[0] << endl;
cout << count[1] << endl;
cout << count[2] << endl;
cout << count[3] << endl;
}
int main() {
solve();
return (0);
} | replace | 10 | 11 | 10 | 11 | TLE | |
p00049 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
int num;
string blood;
char row[1000];
map<string, int> type;
type.insert(make_pair("A", 0));
type.insert(make_pair("B", 0));
type.insert(make_pair("O", 0));
type.insert(make_pair("AB", 0));
while (cin >> row) {
if (cin.eof())
break;
sscanf(row, "%d,%s", &num, &blood);
type[blood]++;
}
cout << type["A"] << endl;
cout << type["B"] << endl;
cout << type["AB"] << endl;
cout << type["O"] << endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <map>
#include <string>
using namespace std;
int main() {
int num;
char blood[100];
char row[1000];
map<string, int> type;
type.insert(make_pair("A", 0));
type.insert(make_pair("B", 0));
type.insert(make_pair("O", 0));
type.insert(make_pair("AB", 0));
while (cin >> row) {
if (cin.eof())
break;
sscanf(row, "%d,%s", &num, &blood);
type[blood]++;
}
cout << type["A"] << endl;
cout << type["B"] << endl;
cout << type["AB"] << endl;
cout << type["O"] << endl;
return 0;
} | replace | 9 | 10 | 9 | 10 | -6 | free(): invalid pointer
|
p00049 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
string str;
int blood[4] = {0};
while (scanf("%d,%s", &n, &str) != EOF) {
if (str == "A")
blood[0]++;
else if (str == "B")
blood[1]++;
else if (str == "AB")
blood[2]++;
else if (str == "O")
blood[3]++;
}
cout << blood[0] << endl
<< blood[1] << endl
<< blood[2] << endl
<< blood[3] << endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
string str;
int blood[4] = {0};
while (scanf("%d,", &n) != EOF) {
cin >> str;
if (str == "A")
blood[0]++;
else if (str == "B")
blood[1]++;
else if (str == "AB")
blood[2]++;
else if (str == "O")
blood[3]++;
}
cout << blood[0] << endl
<< blood[1] << endl
<< blood[2] << endl
<< blood[3] << endl;
return 0;
} | replace | 8 | 9 | 8 | 10 | -11 | |
p00049 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a = 0, b = 0, c = 0, o = 0, x, y, z, w;
char s[2];
while (scanf("%d,%s", &n, s) != EOF) {
if (s[1] == 'B')
c++;
else if (s[0] == 'A')
a++;
else if (s[0] == 'B')
b++;
else
o++;
}
cout << a << endl << b << endl << c << endl << o << endl;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <math.h>
using namespace std;
int main() {
int n, a = 0, b = 0, c = 0, o = 0, x, y, z, w;
char s[3];
while (scanf("%d,%s", &n, s) != EOF) {
if (s[1] == 'B')
c++;
else if (s[0] == 'A')
a++;
else if (s[0] == 'B')
b++;
else
o++;
}
cout << a << endl << b << endl << c << endl << o << endl;
} | replace | 8 | 9 | 8 | 9 | 0 | |
p00050 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define rp(a) while (a--)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define MAX 1000000
bool sosu[MAX];
int main() {
string s;
getline(cin, s);
while (1) {
int it;
if ((it = s.find("apple")) != string::npos)
s.replace(it, 5, "peach");
else if ((it = s.find("peach")) != string::npos)
s.replace(it, 5, "apple");
else
break;
}
cout << s << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <time.h>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define rp(a) while (a--)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
#define MAX 1000000
bool sosu[MAX];
int main() {
string s;
getline(cin, s);
if (s.size() < 5) {
cout << s << endl;
return 0;
}
rep(i, s.size() - 4) {
string tmp = s.substr(i, 5);
if (tmp == "apple")
s.replace(i, 5, "peach");
else if (tmp == "peach")
s.replace(i, 5, "apple");
}
cout << s << endl;
} | replace | 27 | 35 | 27 | 38 | TLE | |
p00050 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
char input[2000];
cin.getline(input, 1000);
for (int i = 0; input[i] != '\n'; i++) {
if (!strncmp(&input[i], "apple", 5)) {
strncpy(&input[i], "peach", 5);
} else if (!strncmp(&input[i], "peach", 5)) {
strncpy(&input[i], "apple", 5);
}
}
printf("%s\n", input);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main() {
char input[2000];
cin.getline(input, 1000);
for (int i = 0; input[i] != '\0'; i++) {
if (!strncmp(&input[i], "apple", 5)) {
strncpy(&input[i], "peach", 5);
} else if (!strncmp(&input[i], "peach", 5)) {
strncpy(&input[i], "apple", 5);
}
}
printf("%s\n", input);
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p00051 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
#define all(c) c.begin(), c.end()
int main() {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
sort(all(s));
int n = stoi(s);
reverse(all(s));
int m = stoi(s);
cerr << m << " " << n << endl;
cout << m - n << endl;
}
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
#define all(c) c.begin(), c.end()
int main() {
int n;
cin >> n;
while (n--) {
string s;
cin >> s;
sort(all(s));
int n = stoi(s);
reverse(all(s));
int m = stoi(s);
cout << m - n << endl;
}
} | delete | 15 | 16 | 15 | 15 | 0 | 96553100 135569
96553100 135569
|
p00051 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, max, min, kkk;
cin >> n;
for (int i = 0; i < n; i++) {
string input = "", mmm, mai = "", mii = "";
int a[8] = {};
cin >> input;
for (int j = 0; j < 8; j++) {
mmm = input[j];
a[j] = stoi(mmm);
}
sort(a, end(a));
kkk = 0;
for (int j = 0; j < 8; j++) {
mai += to_string(a[7 - j]);
if (a[j] == 0 && kkk == 0) {
} else {
mii += to_string(a[j]);
kkk++;
}
}
max = stoi(mai);
min = stoi(mii);
cout << max - min << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n, max, min, kkk;
cin >> n;
for (int i = 0; i < n; i++) {
string input = "", mmm, mai = "", mii = "";
int a[8] = {};
cin >> input;
for (int j = 0; j < 8; j++) {
mmm = input[j];
a[j] = stoi(mmm);
}
sort(a, end(a));
kkk = 0;
for (int j = 0; j < 8; j++) {
if (a[7] == 0) {
mai = "0";
mii = "0";
break;
}
mai += to_string(a[7 - j]);
if (a[j] == 0 && kkk == 0) {
} else {
mii += to_string(a[j]);
kkk++;
}
}
max = stoi(mai);
min = stoi(mii);
cout << max - min << endl;
}
return 0;
} | insert | 19 | 19 | 19 | 24 | 0 | |
p00051 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
int ret[8];
cin >> n;
while (n-- > 0) {
string s;
cin >> s;
for (int i = 0; i < 8; i++)
ret[i] = s[i - '0'];
int Min = 0, Max = 0;
sort(ret, ret + 8);
for (int i = 0; i < 8; i++) {
Max += pow(10, i) * ret[i];
}
for (int i = 7; i >= 0; i--) {
Min += pow(10, i) * ret[7 - i];
}
int differential = Max - Min;
cout << differential << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
using namespace std;
int main() {
int n;
int ret[8];
cin >> n;
while (n-- > 0) {
string s;
cin >> s;
for (int i = 0; i < 8; i++)
ret[i] = s[i] - '0';
int Min = 0, Max = 0;
sort(ret, ret + 8);
for (int i = 0; i < 8; i++) {
Max += pow(10, i) * ret[i];
}
for (int i = 7; i >= 0; i--) {
Min += pow(10, i) * ret[7 - i];
}
int differential = Max - Min;
cout << differential << endl;
}
return 0;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p00051 | C++ | Runtime Error | // 0051
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int n, a[8], i, max, min;
cin >> n;
while (n--) {
max = 0;
min = 0;
cin >> str;
for (i = 0; i < 9; i++) {
a[i] = str[i] - '0';
}
sort(a, a + 8, greater<int>());
for (i = 0; i < 8; i++) {
max += a[i] * pow(10, 7 - i);
}
sort(a, a + 8);
for (i = 0; i < 8; i++) {
min += a[i] * pow(10, 7 - i);
}
cout << max - min << endl;
}
return 0;
} | // 0051
#include <bits/stdc++.h>
using namespace std;
int main() {
string str;
int n, a[8], i, max, min;
cin >> n;
while (n--) {
max = 0;
min = 0;
cin >> str;
for (i = 0; i < 8; i++) {
a[i] = str[i] - '0';
}
sort(a, a + 8, greater<int>());
for (i = 0; i < 8; i++) {
max += a[i] * pow(10, 7 - i);
}
sort(a, a + 8);
for (i = 0; i < 8; i++) {
min += a[i] * pow(10, 7 - i);
}
cout << max - min << endl;
}
return 0;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p00052 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int n;
while (1) {
int ct = 0;
cin >> n;
if (!n)
break;
while (n / 5)
ct += n;
cout << ct << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
while (1) {
int ct = 0;
cin >> n;
if (!n)
break;
while (n /= 5)
ct += n;
cout << ct << endl;
}
return 0;
} | replace | 11 | 12 | 11 | 12 | TLE | |
p00052 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
while (cin >> n, n) {
a = 0;
while (n != 1) {
a += n / 5;
n /= 5;
}
cout << a << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a;
while (cin >> n, n) {
a = 0;
while (n > 1) {
a += n / 5;
n /= 5;
}
cout << a << endl;
}
} | replace | 6 | 7 | 6 | 7 | TLE | |
p00052 | C++ | Time Limit Exceeded | #include <iostream>
inline void DPri(int n) { std::cout << n << std::endl; }
int recsion(int n, int a, int c) {
if (n == 1)
return c;
int d = n;
while (!(d % a)) {
if (!(d % a))
d /= a, c++;
}
recsion(n - 1, a, c);
}
int main() {
int n;
while (std::cin >> n) {
if (std::cin.eof())
break;
int c = recsion(n, 10, 0), a = recsion(n, 2, 0) - c,
b = recsion(n, 5, 0) - c, res = 0;
a > b ? res += (b + c) : res += (a + c);
std::cout << res << std::endl;
}
return 0;
} | #include <iostream>
inline void DPri(int n) { std::cout << n << std::endl; }
int recsion(int n, int a, int c) {
if (n == 1)
return c;
int d = n;
while (!(d % a)) {
if (!(d % a))
d /= a, c++;
}
recsion(n - 1, a, c);
}
int main() {
int n;
while (std::cin >> n) {
if (!n)
break;
int c = recsion(n, 10, 0), a = recsion(n, 2, 0) - c,
b = recsion(n, 5, 0) - c, res = 0;
a > b ? res += (b + c) : res += (a + c);
std::cout << res << std::endl;
}
return 0;
} | replace | 16 | 17 | 16 | 17 | TLE | |
p00052 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
int main() {
vector<int> zeronum;
zeronum.push_back(0);
int count = 0;
for (int i = 1; i <= 20000000; i++) {
int tmp = i;
while (tmp % 5 == 0) {
count++;
tmp /= 5;
}
zeronum.push_back(count);
}
int n = 0;
while (cin >> n && n != 0) {
cout << zeronum[n] << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
int main() {
vector<int> zeronum;
zeronum.push_back(0);
int count = 0;
for (int i = 1; i <= 5000000; i++) {
int tmp = i;
while (tmp % 5 == 0) {
count++;
tmp /= 5;
}
zeronum.push_back(count);
}
int n = 0;
while (cin >> n && n != 0) {
cout << zeronum[n] << endl;
}
return 0;
} | replace | 18 | 19 | 18 | 19 | MLE | |
p00052 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int s(int x) {
int ans, y = x;
y %= 5;
x = (x - y) / 5;
ans = s(x) + x;
return ans;
}
int main() {
int n, ans;
while (cin >> n) {
if (n == 0) {
break;
}
ans = s(n);
cout << ans << endl;
}
} | #include <iostream>
using namespace std;
int s(int x) {
int ans, y = x;
y %= 5;
x = (x - y) / 5;
if (x < 5)
ans = x;
if (x >= 5)
ans = s(x) + x;
return ans;
}
int main() {
int n, ans;
while (cin >> n) {
if (n == 0) {
break;
}
ans = s(n);
cout << ans << endl;
}
} | replace | 7 | 8 | 7 | 11 | TLE | |
p00052 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
while (cin >> N, N) {
int res = 0;
while (N > 0) {
res += N / 5;
}
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
while (cin >> N, N) {
int res = 0;
while (N > 0) {
res += N /= 5;
}
cout << res << endl;
}
return 0;
} | replace | 9 | 10 | 9 | 10 | TLE | |
p00053 | C++ | Runtime Error | #include <math.h>
#include <stdio.h>
int isprime(int x) {
int i;
if (x == 2) {
return 1;
}
if (x < 2 || x % 2 == 0) {
return 0;
}
i = 3;
while (i <= sqrt(x)) {
if (x % i == 0) {
return 0;
}
i = i + 2;
}
return 1;
}
int main() {
int n, c = 0, l[10001] = {0}, j = 0;
for (int i = 0; i <= 10000000; i++) {
if (isprime(i)) {
c += i;
l[j] = c;
j++;
}
}
while (1) {
scanf("%d", &n);
if (n == 0) {
break;
}
printf("%d\n", l[n - 1]);
}
return 0;
} | #include <math.h>
#include <stdio.h>
int isprime(int x) {
int i;
if (x == 2) {
return 1;
}
if (x < 2 || x % 2 == 0) {
return 0;
}
i = 3;
while (i <= sqrt(x)) {
if (x % i == 0) {
return 0;
}
i = i + 2;
}
return 1;
}
int main() {
int n, c = 0, l[10001] = {0}, j = 0;
for (int i = 0; i <= 104730; i++) {
if (isprime(i)) {
c += i;
l[j] = c;
j++;
}
}
while (1) {
scanf("%d", &n);
if (n == 0) {
break;
}
printf("%d\n", l[n - 1]);
}
return 0;
} | replace | 21 | 22 | 21 | 22 | -11 | |
p00053 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
bool f[105000];
int n;
long long int sum[105000];
memset(f, false, sizeof(f));
sum[0] = 0;
for (int i = 2; i <= 105000; i++) {
if (f[i])
continue;
for (int j = i * i; j < 105000; j += i)
f[j] = true;
}
int k = 1;
for (int j = 2; j <= 105000; j++) {
if (!f[j]) {
sum[k] = sum[k - 1] + j;
k++;
}
}
while (1) {
cin >> n;
if (n == 0)
break;
cout << sum[n] << endl;
}
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
bool f[105000];
int n;
long long int sum[105000];
memset(f, false, sizeof(f));
sum[0] = 0;
for (int i = 2; i * i <= 105000; i++) {
if (f[i])
continue;
for (int j = i * i; j < 105000; j += i)
f[j] = true;
}
int k = 1;
for (int j = 2; j <= 105000; j++) {
if (!f[j]) {
sum[k] = sum[k - 1] + j;
k++;
}
}
while (1) {
cin >> n;
if (n == 0)
break;
cout << sum[n] << endl;
}
return 0;
} | replace | 10 | 11 | 10 | 11 | -11 | |
p00053 | C++ | Runtime Error |
#include <cmath>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX 105000
using namespace std;
int main() {
/*for(int k = 1; k<MAX;k++)
{
if(PrimeCheck(v[k+1]))
{
//cout << v[k+1] << " ";
v2[d] = v[k+1];
d++;
}
}
//rep(i,d) cout << v2[i] << " ";
//cout << d << endl;*/
int number;
while (cin >> number, number) {
int counter = 0;
vector<bool> v(MAX + 1, 0);
vector<int> v2(10008, 0);
rep(i, MAX) v[i + 1] = true;
long long answer = 0;
int lim = (int)sqrt(number);
int d = 0;
// cout << lim <<" ";
for (int i = 2; i < MAX; i++) {
if (v[i]) {
for (int j = 2; j < MAX / i; j++) {
v[j * i] = false;
// cout << " " << i << "i*j= " << i*j;
}
v2[d] = i;
d++;
}
}
// rep(i,number) cout << v[i+1] << " ";
for (int i = 2; i < MAX + 1; i++) {
if (v[i]) {
answer += i;
counter++;
// cout << " " << i;
if (counter == number)
break;
}
}
cout /*<< " answer is "*/ << answer << endl;
}
return 0;
} |
#include <cmath>
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX 105000
using namespace std;
int main() {
/*for(int k = 1; k<MAX;k++)
{
if(PrimeCheck(v[k+1]))
{
//cout << v[k+1] << " ";
v2[d] = v[k+1];
d++;
}
}
//rep(i,d) cout << v2[i] << " ";
//cout << d << endl;*/
int number;
while (cin >> number, number) {
int counter = 0;
vector<bool> v(MAX + 1, 0);
vector<int> v2(MAX, 0);
rep(i, MAX) v[i + 1] = true;
long long answer = 0;
int lim = (int)sqrt(number);
int d = 0;
// cout << lim <<" ";
for (int i = 2; i < MAX; i++) {
if (v[i]) {
for (int j = 2; j < MAX / i; j++) {
v[j * i] = false;
// cout << " " << i << "i*j= " << i*j;
}
v2[d] = i;
d++;
}
}
// rep(i,number) cout << v[i+1] << " ";
for (int i = 2; i < MAX + 1; i++) {
if (v[i]) {
answer += i;
counter++;
// cout << " " << i;
if (counter == number)
break;
}
}
cout /*<< " answer is "*/ << answer << endl;
}
return 0;
} | replace | 25 | 26 | 25 | 26 | -6 | malloc(): corrupted top size
|
p00053 | C++ | Time Limit Exceeded | #include <cmath>
#include <iostream>
using namespace std;
bool isPrime(int n) {
if (n == 2)
return true;
if (n % 2 == 0)
return false;
for (int i = 3; i < n / 2; i += 2) {
if (n % i == 0)
return false;
}
return true;
}
int main() {
int input;
while (cin >> input, input) {
int count = 0;
int sum = 0;
for (int i = 2;; ++i) {
if (isPrime(i)) {
count++;
sum += i;
if (count == input) {
cout << sum << endl;
break;
}
}
}
}
return 0;
}
| #include <cmath>
#include <iostream>
using namespace std;
bool isPrime(int n) {
if (n == 2)
return true;
if (n % 2 == 0)
return false;
double sqrtNum = sqrt(n);
for (int i = 3; i <= sqrtNum; i += 2) {
if (n % i == 0)
return false;
}
return true;
}
int main() {
int input;
while (cin >> input, input) {
int count = 0;
int sum = 0;
for (int i = 2;; ++i) {
if (isPrime(i)) {
count++;
sum += i;
if (count == input) {
cout << sum << endl;
break;
}
}
}
}
return 0;
}
| replace | 10 | 11 | 10 | 12 | TLE | |
p00053 | C++ | Runtime Error | #include <iostream>
unsigned long long a[10001], b[200000], c, n;
using namespace std;
int main() {
for (int i = 2; i < 200000; i++)
for (int j = i * 2; j < 200000; j += i)
b[j]++;
for (int i = 2; i < 200000; i++)
if (!b[i]) {
a[c + 1] += i + a[c];
c++;
}
while (cin >> n, n)
cout << a[n] << endl;
} | #include <iostream>
unsigned long long a[100000], b[200000], c, n;
using namespace std;
int main() {
for (int i = 2; i < 200000; i++)
for (int j = i * 2; j < 200000; j += i)
b[j]++;
for (int i = 2; i < 200000; i++)
if (!b[i]) {
a[c + 1] += i + a[c];
c++;
}
while (cin >> n, n)
cout << a[n] << endl;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p00053 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <memory.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define all(c) ((c).begin()), ((c).end())
#define debug(c) cerr << "> " << #c << " = " << (c) << endl;
#define iter(c) __typeof((c).begin())
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define tr(i, c) for (iter(c) i = (c).begin(); i != (c).end(); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define mp make_pair
#define fst first
#define snd second
#define pb push_back
const double EPS = 1e-10;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef complex<double> P;
int main() {
int N = 200000;
vi p(N, 1);
p[0] = p[1] = 0;
rep(i, N) if (p[i]) for (int j = i + i; j < N; j += i) p[j] = 0;
vi ps;
rep(i, N) if (p[i]) ps.pb(i);
debug(ps.size()) for (int n; cin >> n, n != 0;) {
int sum = 0;
rep(i, n) sum += ps[i];
cout << sum << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <memory.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define all(c) ((c).begin()), ((c).end())
#define debug(c) cerr << "> " << #c << " = " << (c) << endl;
#define iter(c) __typeof((c).begin())
#define present(c, e) ((c).find((e)) != (c).end())
#define cpresent(c, e) (find(all(c), (e)) != (c).end())
#define tr(i, c) for (iter(c) i = (c).begin(); i != (c).end(); i++)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, a, b) for (int i = (int)(a); i <= (int)(b); i++)
#define mp make_pair
#define fst first
#define snd second
#define pb push_back
const double EPS = 1e-10;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef complex<double> P;
int main() {
int N = 200000;
vi p(N, 1);
p[0] = p[1] = 0;
rep(i, N) if (p[i]) for (int j = i + i; j < N; j += i) p[j] = 0;
vi ps;
rep(i, N) if (p[i]) ps.pb(i);
for (int n; cin >> n, n != 0;) {
int sum = 0;
rep(i, n) sum += ps[i];
cout << sum << endl;
}
return 0;
} | replace | 49 | 50 | 49 | 50 | 0 | > ps.size() = 17984
|
p00053 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int prime[10001], p = 3, psum[10001], n;
prime[1] = 2, prime[2] = 3;
for (int i = 5; p < 10001; i++) {
int f = 0;
for (int j = 1; prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
f = 1;
break;
}
if (!f)
prime[p++] = i;
}
psum[1] = 2;
for (int i = 2; i < 100001; i++)
psum[i] = psum[i - 1] + prime[i];
while (1) {
cin >> n;
if (!n)
break;
cout << psum[n] << endl;
}
return 0;
}
| #include <iostream>
using namespace std;
int main() {
int prime[10001], p = 3, psum[10001], n;
prime[1] = 2, prime[2] = 3;
for (int i = 5; p < 10001; i++) {
int f = 0;
for (int j = 1; prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
f = 1;
break;
}
if (!f)
prime[p++] = i;
}
psum[1] = 2;
for (int i = 2; i < 10001; i++)
psum[i] = psum[i - 1] + prime[i];
while (1) {
cin >> n;
if (!n)
break;
cout << psum[n] << endl;
}
return 0;
}
| replace | 18 | 19 | 18 | 19 | -11 | |
p00053 | C++ | Memory Limit Exceeded | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef vector<vb> vvb;
typedef vector<vpii> vvpii;
const int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
const int MOD = 1000000007;
const double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
bool odd(const int &n) { return n & 1; }
bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
vector<int> eratosthenes(const int &n) {
vector<int> v(n);
v[0] = v[1] = false;
loop(i, 2, v.size()) v[i] = true;
for (int i = 2; i * i < n; i++) {
if (v[i]) {
for (int j = i * 2; j < n; j += i) {
v[j] = false;
}
}
}
return v;
}
void solve() {
vi v = eratosthenes(10000000);
int n;
while (cin >> n, n) {
int s = 0, i = 0;
while (n--) {
while (!v[i])
i++;
s += i++;
}
cout << s << endl;
}
} | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef vector<vb> vvb;
typedef vector<vpii> vvpii;
const int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
const int MOD = 1000000007;
const double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
bool odd(const int &n) { return n & 1; }
bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
vector<int> eratosthenes(const int &n) {
vector<int> v(n);
v[0] = v[1] = false;
loop(i, 2, v.size()) v[i] = true;
for (int i = 2; i * i < n; i++) {
if (v[i]) {
for (int j = i * 2; j < n; j += i) {
v[j] = false;
}
}
}
return v;
}
void solve() {
vi v = eratosthenes(1000000);
int n;
while (cin >> n, n) {
int s = 0, i = 0;
while (n--) {
while (!v[i])
i++;
s += i++;
}
cout << s << endl;
}
} | replace | 53 | 54 | 53 | 54 | MLE | |
p00053 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
const int NUM = 10000;
bool prime[NUM];
for (int i = 2; i < NUM; i++)
prime[i] = true;
for (int i = 2; i * i < NUM; i++)
for (int k = 2; i * k < NUM; k++)
prime[i * k] = false;
int n, c;
while (cin >> n) {
if (!n)
break;
c = 0;
for (int i = 2, k = 0; k < n; i++)
if (prime[i])
c += i, k++;
cout << c << endl;
}
} | #include <iostream>
using namespace std;
int main() {
const int NUM = 1e6;
bool prime[NUM];
for (int i = 2; i < NUM; i++)
prime[i] = true;
for (int i = 2; i * i < NUM; i++)
for (int k = 2; i * k < NUM; k++)
prime[i * k] = false;
int n, c;
while (cin >> n) {
if (!n)
break;
c = 0;
for (int i = 2, k = 0; k < n; i++)
if (prime[i])
c += i, k++;
cout << c << endl;
}
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00054 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int func(int a, int b, int n) {
if (n == 0) {
return 0;
}
int u = 10 * a;
return (u / b + func(u % b, b, n - 1));
}
int main() {
int n, a, b;
while (cin >> a >> b >> n) {
while (a >= b) {
a /= b;
}
cout << func(a, b, n) << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int func(int a, int b, int n) {
if (n == 0) {
return 0;
}
int u = 10 * a;
return (u / b + func(u % b, b, n - 1));
}
int main() {
int n, a, b;
while (cin >> a >> b >> n) {
a %= b;
cout << func(a, b, n) << endl;
}
return 0;
} | replace | 17 | 20 | 17 | 18 | TLE | |
p00055 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
double a;
while (cin >> a) {
double ans = 0;
ans += a;
for (int i = 2; i <= 10; i++) {
if (i % 2 == 0)
a *= 2;
else
a /= 3;
ans += a;
}
printf("%llf\n", ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
double a;
while (cin >> a) {
double ans = 0;
ans += a;
for (int i = 2; i <= 10; i++) {
if (i % 2 == 0)
a *= 2;
else
a /= 3;
ans += a;
}
printf("%lf\n", ans);
}
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p00055 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define all(vec) vec.begin(), vec.end()
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
const ll INF = 1000000010;
const ll LINF = 4000000000000000010LL;
const int MAX = 310;
const double EPS = 1e-9;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
double b;
while (cin >> b, b) {
double a[11];
a[1] = b;
double sum = b;
for (int i = 2; i <= 10; i++) {
if (i % 2) {
a[i] = a[i - 1] / 3;
} else {
a[i] = a[i - 1] * 2;
}
sum += a[i];
}
printf("%.9lf\n", sum);
}
}
| #include <bits/stdc++.h>
using namespace std;
#define all(vec) vec.begin(), vec.end()
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
const ll INF = 1000000010;
const ll LINF = 4000000000000000010LL;
const int MAX = 310;
const double EPS = 1e-9;
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
int main() {
double b;
while (cin >> b) {
double a[11];
a[1] = b;
double sum = b;
for (int i = 2; i <= 10; i++) {
if (i % 2) {
a[i] = a[i - 1] / 3;
} else {
a[i] = a[i - 1] * 2;
}
sum += a[i];
}
printf("%.9lf\n", sum);
}
}
| replace | 14 | 15 | 14 | 15 | TLE | |
p00055 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
int main() {
double a, S = 0.0;
while (scanf("%lf", &a)) {
S += a;
for (int i = 2; i <= 10; i++) {
if (i % 2)
a /= 3.0;
else
a *= 2.0;
S += a;
}
printf("%.8f\n", S);
}
return 0;
} | #include <cstdio>
using namespace std;
int main() {
double a;
while (scanf("%lf", &a) == 1) {
double S = a;
for (int i = 2; i <= 10; i++) {
if (i % 2)
a /= 3.0;
else
a *= 2.0;
S += a;
}
printf("%.8f\n", S);
}
return 0;
} | replace | 4 | 7 | 4 | 7 | TLE | |
p00055 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long double a, b, sum;
while (1) {
cin >> a;
sum = a;
for (int i = 0; i < 9; i++) {
if (i % 2 == 0) {
b = a * 2;
sum = sum + b;
} else {
b = a / 3;
sum = sum + b;
}
a = b;
}
cout << fixed << setprecision(8) << sum << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <ctype.h>
#include <functional>
#include <iomanip>
#include <iostream>
#include <math.h>
#include <queue>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int main() {
long double a, b, sum;
while (cin >> a) {
sum = a;
for (int i = 0; i < 9; i++) {
if (i % 2 == 0) {
b = a * 2;
sum = sum + b;
} else {
b = a / 3;
sum = sum + b;
}
a = b;
}
cout << fixed << setprecision(8) << sum << endl;
}
return 0;
} | replace | 20 | 22 | 20 | 21 | TLE | |
p00055 | C++ | Time Limit Exceeded | #include <iomanip>
#include <iostream>
using namespace std;
int main() {
double d[10];
double a;
while (cin >> a) {
d[0] = a;
d[1] = d[0] * 2;
for (int i = 2; i < 10; i + 2) {
d[i] = d[i - 1] / 3;
d[i + 1] = d[i] * 2;
}
int ca = 0;
for (int i = 0; i < 10; i++) {
ca += d[i];
}
cout << fixed << setprecision(9) << ca << endl;
}
return 0;
} | #include <iomanip>
#include <iostream>
using namespace std;
int main() {
double d[10];
double a;
while (cin >> a) {
d[0] = a;
d[1] = d[0] * 2;
d[2] = d[1] / 3;
d[3] = d[2] * 2;
d[4] = d[3] / 3;
d[5] = d[4] * 2;
d[6] = d[5] / 3;
d[7] = d[6] * 2;
d[8] = d[7] / 3;
d[9] = d[8] * 2;
double ca = 0;
for (int i = 0; i < 10; i++) {
ca += d[i];
}
cout << fixed << setprecision(9) << ca << endl;
}
return 0;
} | replace | 10 | 15 | 10 | 19 | TLE | |
p00055 | C++ | Time Limit Exceeded | #include <iomanip>
#include <iostream>
int main() {
while (true) {
double a;
std::cin >> a;
std::cout << std::fixed << std::setprecision(10) << a * 211 / 27
<< std::endl;
}
return 0;
}
| #include <iomanip>
#include <iostream>
int main() {
while (true) {
double a;
std::cin >> a;
if (std::cin.eof()) {
break;
}
std::cout << std::fixed << std::setprecision(10) << a * 211 / 27
<< std::endl;
}
return 0;
}
| insert | 6 | 6 | 6 | 9 | TLE | |
p00055 | C++ | Time Limit Exceeded | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
double a;
while (1) {
cin >> a;
printf("%.8f\n", 211.0 / 27.0 * a);
}
return 0;
} | #include <iostream>
#include <stdio.h>
using namespace std;
int main() {
double a;
while (1) {
cin >> a;
if (cin.eof())
break;
printf("%.8f\n", 211.0 / 27.0 * a);
}
return 0;
} | insert | 8 | 8 | 8 | 10 | TLE | |
p00056 | C++ | Runtime Error |
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int n, x, m;
x = 0;
m = 0;
vector<int> v;
scanf("%d", &n);
while (n) {
v.push_back(n);
if (n > x) {
x = n;
}
scanf("%d", &n);
m++;
}
vector<int> res;
vector<int> p(x + 1, 1);
p[0] = 0;
p[1] = 0;
for (int t = 2; t <= x; t++) {
if (p[t] == 0)
continue;
// p の倍数を全て消す。
for (int k = t * 2; k <= x; k += t) {
p[k] = 0;
}
res.push_back(t);
}
int a = 0;
int s;
for (int t = 0; t < m; t++) {
a = 0;
s = res.size();
for (int k = 0; k < s; k++) {
if (p[v[t] - res[k]] == 1) {
a++;
}
}
a = a / 2 + a % 2;
printf("%d\n", a);
}
}
|
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <vector>
using namespace std;
int main() {
int n, x, m;
x = 0;
m = 0;
vector<int> v;
scanf("%d", &n);
while (n) {
v.push_back(n);
if (n > x) {
x = n;
}
scanf("%d", &n);
m++;
}
vector<int> res;
vector<int> p(x + 1, 1);
p[0] = 0;
p[1] = 0;
for (int t = 2; t <= x; t++) {
if (p[t] == 0)
continue;
// p の倍数を全て消す。
for (int k = t * 2; k <= x; k += t) {
p[k] = 0;
}
res.push_back(t);
}
int a = 0;
int s;
for (int t = 0; t < m; t++) {
a = 0;
s = res.size();
for (int k = 0; k < s; k++) {
if (v[t] - res[k] >= 1) {
if (p[v[t] - res[k]] == 1) {
a++;
}
}
}
a = a / 2 + a % 2;
printf("%d\n", a);
}
}
| replace | 40 | 42 | 40 | 44 | 0 | |
p00056 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
bool is_prime[100000];
is_prime[0] = is_prime[1] = false;
for (int i = 2; i < 100000; i++) {
is_prime[i] = true;
}
for (int i = 2; i * i < 100000; i++) {
if (is_prime[i]) {
for (int j = i * i; j < 100000; j += i) {
is_prime[j] = false;
}
}
}
while (1) {
int n;
cin >> n;
if (n == 0)
break;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (!is_prime[i])
continue;
for (int j = i; j < n; j++) {
if (is_prime[j])
if (i + j == n)
cnt++;
}
}
cout << cnt << endl;
}
}
| #include <iostream>
using namespace std;
int main() {
bool is_prime[100000];
is_prime[0] = is_prime[1] = false;
for (int i = 2; i < 100000; i++) {
is_prime[i] = true;
}
for (int i = 2; i * i < 100000; i++) {
if (is_prime[i]) {
for (int j = i * i; j < 100000; j += i) {
is_prime[j] = false;
}
}
}
while (1) {
int n;
cin >> n;
if (n == 0)
break;
int cnt = 0;
for (int i = 0; i <= n / 2; i++) {
if (is_prime[i] && is_prime[n - i])
if (i + (n - i) == n)
cnt++;
}
cout << cnt << endl;
}
}
| replace | 27 | 36 | 27 | 31 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
bool p[50000];
p[1] = false;
for (int i = 2; i < 50000; i++) {
p[i] = true;
}
for (int j = 2; j < 50000; j++) {
if (p[j]) {
for (int k = j * 2; k < 50000; k += j) {
p[k] = false;
}
}
}
int n;
while (cin >> n) {
if (n == 0)
break;
int count = 0;
if (p[n - 2])
count++;
for (int l = 3; l <= n / 2; l += 2) {
if (p[l]) {
for (int m = l; m <= n; m++) {
if (p[m] == true && l + m == n)
count++;
}
}
}
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
bool p[50000];
p[1] = false;
for (int i = 2; i < 50000; i++) {
p[i] = true;
}
for (int j = 2; j < 50000; j++) {
if (p[j]) {
for (int k = j * 2; k < 50000; k += j) {
p[k] = false;
}
}
}
int n;
while (cin >> n) {
if (n == 0)
break;
int count = 0;
if (p[n - 2])
count++;
for (int l = 3; l <= n / 2; l += 2) {
if (p[l] && p[n - l])
count++;
}
cout << count << endl;
}
return 0;
} | replace | 23 | 29 | 23 | 25 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <iostream>
#include <numeric>
using namespace std;
#define SIZE 50001
int main() {
bool prime[SIZE];
fill(prime, prime + SIZE, true);
prime[0] = prime[1] = false;
for (int i = 2; i * i < SIZE; i++) {
for (int j = 2; j * i < SIZE; j++) {
if (!prime[i * j])
continue;
prime[i * j] = false;
}
}
int n, count;
while (cin >> n) {
if (n == 0)
break;
count = 0;
for (int i = 2; i < n; i++) {
if (!prime[i])
continue;
for (int j = i; j < n; j++) {
if (!prime[j])
continue;
if (i + j == n)
count++;
if (i + j > n)
break;
}
}
cout << count << endl;
}
return 0;
} | #include <iostream>
#include <numeric>
using namespace std;
#define SIZE 50001
int main() {
bool prime[SIZE];
fill(prime, prime + SIZE, true);
prime[0] = prime[1] = false;
for (int i = 2; i * i < SIZE; i++) {
for (int j = 2; j * i < SIZE; j++) {
if (!prime[i * j])
continue;
prime[i * j] = false;
}
}
int n, count;
while (cin >> n) {
if (n == 0)
break;
count = 0;
for (int i = 0; i <= n / 2; i++) {
if (prime[i] && prime[n - i])
count++;
}
cout << count << endl;
}
return 0;
} | replace | 24 | 35 | 24 | 27 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <cmath>
#include <iostream>
using namespace std;
int x[100000], y[100000], n, sum;
int main() {
for (int i = 2; i < 100000; i++) {
for (int j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
goto E;
}
}
x[i] = 1;
E:;
}
while (true) {
cin >> n;
sum = 0;
for (int i = 2; i < n; i++) {
if (x[i] == 1 && x[n - i] == 1) {
sum++;
}
}
cout << sum << endl;
}
} | #include <cmath>
#include <iostream>
using namespace std;
int x[100000], y[100000], n, sum;
int main() {
for (int i = 2; i < 100000; i++) {
for (int j = 2; j <= sqrt(i); j++) {
if (i % j == 0) {
goto E;
}
}
x[i] = 1;
E:;
}
while (true) {
cin >> n;
sum = 0;
if (!n) {
break;
}
for (int i = 2; i <= n / 2; i++) {
if (x[i] == 1 && x[n - i] == 1) {
sum++;
}
}
cout << sum << endl;
}
} | replace | 17 | 18 | 17 | 21 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(n) cout << "# " << #n << "=" << (n) << endl
#define debug(n) \
cout << __FILE__ << "," << __LINE__ << ": # " << #n << "=" << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, n) repi(i, 0, n)
#define iter(c) __typeof((c).begin())
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); i++)
#define allof(c) (c).begin(), (c).end()
#define mp make_pair
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
int main() {
vi prime(1, 2);
for (int i = 3; prime.back() <= 50000; i += 2) {
bool ok = true;
for (int j = 0; prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
ok = false;
break;
}
if (ok)
prime.push_back(i);
}
for (int n; cin >> n, n;) {
int res = 0;
for (int i = 2; i <= n / 2; i++)
if (binary_search(allof(prime), i) && binary_search(allof(prime), n - i))
res++;
cout << res << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(n) cout << "# " << #n << "=" << (n) << endl
#define debug(n) \
cout << __FILE__ << "," << __LINE__ << ": # " << #n << "=" << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define rep(i, n) repi(i, 0, n)
#define iter(c) __typeof((c).begin())
#define tr(c, i) for (iter(c) i = (c).begin(); i != (c).end(); i++)
#define allof(c) (c).begin(), (c).end()
#define mp make_pair
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
int main() {
vi prime(1, 2);
for (int i = 3; prime.back() <= 50000; i += 2) {
bool ok = true;
for (int j = 0; prime[j] * prime[j] <= i; j++)
if (i % prime[j] == 0) {
ok = false;
break;
}
if (ok)
prime.push_back(i);
}
for (int n; cin >> n, n;) {
int res = 0;
for (int i = 0; prime[i] <= n / 2; i++)
if (binary_search(allof(prime), n - prime[i]))
res++;
cout << res << endl;
}
return 0;
} | replace | 55 | 57 | 55 | 57 | TLE | |
p00056 | C++ | Runtime Error | #include <cmath>
#include <iostream>
#include <string.h>
using namespace std;
bool prime_check(int n) {
if (n == 1) {
return false;
}
if (n % 2 == 0) {
if (n == 2) {
return true;
}
else {
return false;
}
}
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
const int DATA_SETS = 1000;
const int MAX_PRIME = 50000;
int N[DATA_SETS], P[DATA_SETS], C = 0;
bool I[MAX_PRIME + 1];
memset(N, 0, sizeof(N));
memset(P, 0, sizeof(P));
memset(I, 0, sizeof(I));
for (int i = 1; i <= MAX_PRIME; i++) {
if (prime_check(i) == true) {
I[i] = true;
} else {
I[i] = false;
}
}
while (true) {
cin >> N[C];
if (N[C] == 0) {
goto Exit;
}
C++;
}
Exit:;
for (int i = 0; i < C; i++) {
for (int j = 2; j <= N[i] / 2; j++) {
if (I[j] == true && I[N[i] - j] == true) {
P[i]++;
}
}
cout << P[i] << endl;
}
return 0;
} | #include <cmath>
#include <iostream>
#include <string.h>
using namespace std;
bool prime_check(int n) {
if (n == 1) {
return false;
}
if (n % 2 == 0) {
if (n == 2) {
return true;
}
else {
return false;
}
}
for (int i = 3; i <= sqrt(n); i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
int main() {
const int DATA_SETS = 10000;
const int MAX_PRIME = 50000;
int N[DATA_SETS], P[DATA_SETS], C = 0;
bool I[MAX_PRIME + 1];
memset(N, 0, sizeof(N));
memset(P, 0, sizeof(P));
memset(I, 0, sizeof(I));
for (int i = 1; i <= MAX_PRIME; i++) {
if (prime_check(i) == true) {
I[i] = true;
} else {
I[i] = false;
}
}
while (true) {
cin >> N[C];
if (N[C] == 0) {
goto Exit;
}
C++;
}
Exit:;
for (int i = 0; i < C; i++) {
for (int j = 2; j <= N[i] / 2; j++) {
if (I[j] == true && I[N[i] - j] == true) {
P[i]++;
}
}
cout << P[i] << endl;
}
return 0;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p00056 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int to_int(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string to_str(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
int main() {
vector<int> primeList;
bool used[50002];
memset(used, true, sizeof(used));
for (int i = 2; i <= sqrt(50000); i++) {
if (used[i] == false) {
continue;
}
for (int j = i * 2; j <= 50000; j += i) {
used[j] = false;
}
}
for (int i = 2; i < 50000; i++) {
if (used[i] == true) {
primeList.push_back(i);
}
}
int num, ans;
while (cin >> num) {
if (num == 0) {
break;
}
ans = 0;
for (int i = 0; i < primeList.size(); i++) {
if (num % 2 != 0 && i >= 1) {
break;
}
for (int j = i; j < primeList.size(); j++) {
if (primeList[i] + primeList[j] > num) {
break;
}
if (primeList[i] + primeList[j] == num) {
ans++;
}
}
}
cout << ans << endl;
}
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int to_int(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string to_str(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef long long ll;
int main() {
vector<int> primeList;
bool used[50002];
memset(used, true, sizeof(used));
for (int i = 2; i <= sqrt(50000); i++) {
if (used[i] == false) {
continue;
}
for (int j = i * 2; j <= 50000; j += i) {
used[j] = false;
}
}
for (int i = 2; i < 50000; i++) {
if (used[i] == true) {
primeList.push_back(i);
}
}
int num, ans;
while (cin >> num) {
if (num == 0) {
break;
}
ans = 0;
for (int i = 0; i < primeList.size() && primeList[i] <= (num / 2); i++) {
if (used[num - primeList[i]] == true) {
ans++;
}
}
cout << ans << endl;
}
} | replace | 61 | 72 | 61 | 64 | TLE | |
p00056 | C++ | Time Limit Exceeded | #define _CRT_SECURE_NO_WARNINGS 1
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define M_PI 3.141592
#define toRad 2.0 * M_PI / 360.0
#define inin(x) \
int x; \
cin >> x;
#define all(x) x.begin(), x.end()
#define debug(x) cout << #x << " " << x << endl;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define pri_max 60000
typedef pair<int, int> pii;
bool memo[pri_max] = {};
vector<int> pri;
void calc() {
for (int i = 2; i < pri_max; i++) {
if (memo[i] == false) {
pri.push_back(i);
for (int l = i; l < pri_max; l += i) {
memo[l] = true;
}
}
}
}
int main() {
calc();
int n;
while (cin >> n && n) {
int ans = 0;
for (int i = 0; i < pri.size(); i++) {
ans += binary_search(all(pri), n - pri[i]);
}
ans /= 2;
if (n % 2 == 0 && binary_search(all(pri), n / 2))
ans++;
cout << ans << endl;
}
} | #define _CRT_SECURE_NO_WARNINGS 1
#include <algorithm>
#include <climits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define M_PI 3.141592
#define toRad 2.0 * M_PI / 360.0
#define inin(x) \
int x; \
cin >> x;
#define all(x) x.begin(), x.end()
#define debug(x) cout << #x << " " << x << endl;
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define pri_max 60000
typedef pair<int, int> pii;
bool memo[pri_max] = {};
vector<int> pri;
void calc() {
for (int i = 2; i < pri_max; i++) {
if (memo[i] == false) {
pri.push_back(i);
for (int l = i; l < pri_max; l += i) {
memo[l] = true;
}
}
}
}
int main() {
calc();
int n;
while (cin >> n && n) {
int ans = 0;
for (int i = 0; i < pri.size(); i++) {
if (n - pri[i] <= 0)
break;
ans += binary_search(all(pri), n - pri[i]);
}
ans /= 2;
if (n % 2 == 0 && binary_search(all(pri), n / 2))
ans++;
cout << ans << endl;
}
} | insert | 43 | 43 | 43 | 45 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void sieve(int n, vector<char> &v) {
v.resize(n + 1);
fill(v.begin(), v.end(), true);
v[0] = v[1] = false;
for (int i = 2; i * i <= n; i++) {
if (v[i]) {
for (int j = i + i; j <= n; j += i) {
v[j] = false;
}
}
}
}
int main() {
vector<char> is_prime;
vector<int> prime_list;
sieve(50000, is_prime);
for (int i = 0; i < is_prime.size(); i++) {
if (is_prime[i]) {
prime_list.push_back(i);
}
}
int n;
while (cin >> n, n) {
int pr = 0;
for (int i = 0; i < prime_list.size(); i++) {
if (prime_list[i] + prime_list[i] > n)
break;
if (find(prime_list.begin(), prime_list.end(), n - prime_list[i]) !=
prime_list.end()) {
pr++;
}
}
cout << pr << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
void sieve(int n, vector<char> &v) {
v.resize(n + 1);
fill(v.begin(), v.end(), true);
v[0] = v[1] = false;
for (int i = 2; i * i <= n; i++) {
if (v[i]) {
for (int j = i + i; j <= n; j += i) {
v[j] = false;
}
}
}
}
int main() {
vector<char> is_prime;
vector<int> prime_list;
sieve(50000, is_prime);
for (int i = 0; i < is_prime.size(); i++) {
if (is_prime[i]) {
prime_list.push_back(i);
}
}
int n;
while (cin >> n, n) {
int pr = 0;
for (int i = 0; i < prime_list.size(); i++) {
if (prime_list[i] + prime_list[i] > n)
break;
if (binary_search(prime_list.begin(), prime_list.end(),
n - prime_list[i])) {
pr++;
}
}
cout << pr << endl;
}
return 0;
} | replace | 40 | 42 | 40 | 42 | TLE | |
p00056 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
bool a[60000]{};
int main() {
for (int b = 2; b < 60000; b++) {
if (!(a[b])) {
for (int c = b * 2; c <= 150000; c += b)
a[c] = true;
}
}
int e;
while (cin >> e, e) {
int s = 0;
for (int f = 2; f <= e / 2; f++) {
if (!a[f] && !a[e - f])
s++;
}
cout << s << endl;
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
bool a[60000]{};
int main() {
for (int b = 2; b < 60000; b++) {
if (!(a[b])) {
for (int c = b * 2; c < 60000; c += b)
a[c] = true;
}
}
int e;
while (cin >> e, e) {
int s = 0;
for (int f = 2; f <= e / 2; f++) {
if (!a[f] && !a[e - f])
s++;
}
cout << s << endl;
}
} | replace | 11 | 12 | 11 | 12 | -11 | |
p00056 | C++ | Time Limit Exceeded | // Goldbach's Conjecture
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
int ans[50001];
void solve() {
int ret = 0;
for (int i = 0; i < p.size(); i++)
for (int j = i; j < p.size(); j++) {
if (p[i] + p[j] > 50000)
break;
ans[p[i] + p[j]]++;
}
}
int main() {
p.push_back(2);
for (int i = 3; i < 50000; i += 2) {
bool flag = true;
for (int j = 0; j < p.size(); j++)
if (i % p[j] == 0) {
flag = false;
break;
}
if (flag) {
p.push_back(i);
}
}
solve();
int n;
while (true) {
cin >> n;
cout << ans[n] << endl;
}
return 0;
} | // Goldbach's Conjecture
#include <bits/stdc++.h>
using namespace std;
vector<int> p;
int ans[50001];
void solve() {
int ret = 0;
for (int i = 0; i < p.size(); i++)
for (int j = i; j < p.size(); j++) {
if (p[i] + p[j] > 50000)
break;
ans[p[i] + p[j]]++;
}
}
int main() {
p.push_back(2);
for (int i = 3; i < 50000; i += 2) {
bool flag = true;
for (int j = 0; j < p.size(); j++)
if (i % p[j] == 0) {
flag = false;
break;
}
if (flag) {
p.push_back(i);
}
}
solve();
int n;
while (true) {
cin >> n;
if (n == 0)
break;
cout << ans[n] << endl;
}
return 0;
} | insert | 35 | 35 | 35 | 37 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
/** Problem0056 : Goldbach's Conjecture **/
#define MAX 50000
int main() {
bool prime[MAX];
int input, count;
for (int i = 0; i < MAX; i++)
prime[i] = true;
prime[0] = false;
prime[1] = false;
for (int i = 2; i < MAX; i++) {
if (prime[i]) {
for (int j = 2; i * j < MAX; j++) {
prime[i * j] = false;
}
}
}
while (1) {
cin >> input;
if (input == 0)
break;
count = 0;
for (int i = input; i > 1; i--) {
if (!prime[i])
continue;
for (int j = input; j >= i; j--) {
if (!prime[j])
continue;
if (i + j == input)
count++;
}
}
cout << count << endl;
}
return 0;
} | #include <iostream>
using namespace std;
/** Problem0056 : Goldbach's Conjecture **/
#define MAX 50000
int main() {
bool prime[MAX];
int input, count;
for (int i = 0; i < MAX; i++)
prime[i] = true;
prime[0] = false;
prime[1] = false;
for (int i = 2; i < MAX; i++) {
if (prime[i]) {
for (int j = 2; i * j < MAX; j++) {
prime[i * j] = false;
}
}
}
while (1) {
cin >> input;
if (input == 0)
break;
count = 0;
for (int i = 2; i <= input / 2; i++) {
if (prime[i] && prime[input - i])
count++;
}
cout << count << endl;
}
return 0;
} | replace | 29 | 38 | 29 | 32 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int *data;
data = new int[50001];
data[0] = 0;
data[1] = 0;
data[2] = 1;
data[3] = 1;
for (int i = 3; i <= 50000; i++) {
int flag = 0;
for (int j = 3; j * j <= i; j += 2) {
if (i % j == 0) {
flag = 1;
break;
}
}
if (flag == 1) {
data[i] = 0;
} else {
data[i] = 1;
}
}
int n;
while (1) {
cin >> n;
if (n == 0)
break;
if (n <= 3) {
cout << 0 << endl;
continue;
} else if (n % 2 == 1) {
if (data[n - 2] == 1) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
continue;
} else if (n == 4) {
cout << 1 << endl;
} else {
int cnt = 0;
for (int i = 3; i <= n / 2; i += 2) {
if (data[i] == 1 && data[n - i] == 1) {
cout << i << " " << n - i << endl;
cnt++;
}
}
cout << cnt << endl;
}
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int *data;
data = new int[50001];
data[0] = 0;
data[1] = 0;
data[2] = 1;
data[3] = 1;
for (int i = 3; i <= 50000; i++) {
int flag = 0;
for (int j = 3; j * j <= i; j += 2) {
if (i % j == 0) {
flag = 1;
break;
}
}
if (flag == 1) {
data[i] = 0;
} else {
data[i] = 1;
}
}
int n;
while (1) {
cin >> n;
if (n == 0)
break;
if (n <= 3) {
cout << 0 << endl;
continue;
} else if (n % 2 == 1) {
if (data[n - 2] == 1) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
continue;
} else if (n == 4) {
cout << 1 << endl;
} else {
int cnt = 0;
for (int i = 3; i <= n / 2; i += 2) {
if (data[i] == 1 && data[n - i] == 1) {
// cout<<i<<" "<<n-i<<endl;
cnt++;
}
}
cout << cnt << endl;
}
}
return 0;
} | replace | 50 | 51 | 50 | 51 | TLE | |
p00056 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for ((i) = 0; (i) < (int)(n); (i)++)
#define foreach(itr, c) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
inline int in() {
int x;
scanf("%d", &x);
return x;
}
bool isprime[50000];
void sieve(int n) {
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = false;
for (int i = 2; i * i <= n; i++)
if (isprime[i]) {
for (int j = 2 * i; j <= n; j += i)
isprime[j] = false;
}
}
int main() {
int i, j, k;
int n;
int res;
sieve(50000);
while (scanf("%d", &n)) {
if (n == 0)
break;
res = 0;
rep(i, n) if (isprime[i]) {
for (j = i; j < n; j++)
if (isprime[j]) {
if (i + j == n)
res++;
}
}
printf("%d\n", res);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for ((i) = 0; (i) < (int)(n); (i)++)
#define foreach(itr, c) \
for (__typeof((c).begin()) itr = (c).begin(); itr != (c).end(); itr++)
inline int in() {
int x;
scanf("%d", &x);
return x;
}
bool isprime[50000];
void sieve(int n) {
memset(isprime, 1, sizeof(isprime));
isprime[0] = isprime[1] = false;
for (int i = 2; i * i <= n; i++)
if (isprime[i]) {
for (int j = 2 * i; j <= n; j += i)
isprime[j] = false;
}
}
int main() {
int i, j, k;
int n;
int res;
sieve(50000);
while (scanf("%d", &n)) {
if (n == 0)
break;
res = 0;
for (i = 2; 2 * i <= n; i++)
if (isprime[i] && isprime[n - i])
res++;
printf("%d\n", res);
}
return 0;
} | replace | 49 | 56 | 49 | 52 | TLE |
Subsets and Splits