solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int N_MAX = 20;
int t;
int n;
int digits[N_MAX];
int lucky[] = {0, 4, 7};
bool dp[N_MAX][5];
tuple<int, int, int, int, int, int> step[N_MAX][5];
int prevt[N_MAX][5];
long long ans[7];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> t;
while (t--) {
long long val;
cin >> val;
n = 0;
while (val > 0) {
digits[++n] = val % 10;
val /= 10;
}
for (int i = 0; i <= n; i++)
for (int t = 0; t <= 4; t++) dp[i][t] = false;
dp[0][0] = true;
for (int i = 0; i < n; i++)
for (int t = 0; t <= 4; t++)
if (dp[i][t] == true) {
for (int a = 0; a < 3; a++)
for (int b = a; b < 3; b++)
for (int c = b; c < 3; c++)
for (int d = c; d < 3; d++)
for (int e = d; e < 3; e++)
for (int f = e; f < 3; f++) {
int sum = lucky[a] + lucky[b] + lucky[c] + lucky[d] +
lucky[e] + lucky[f] + t;
if (sum % 10 == digits[i + 1]) {
dp[i + 1][sum / 10] = true;
step[i + 1][sum / 10] = make_tuple(a, b, c, d, e, f);
prevt[i + 1][sum / 10] = t;
}
}
}
if (dp[n][0] == true) {
long long p10 = 1;
for (int i = 1; i < n; i++) p10 *= 10;
for (int i = 1; i <= 6; i++) ans[i] = 0;
int pos = n;
int t = 0;
while (pos > 0) {
int a, b, c, d, e, f;
tie(a, b, c, d, e, f) = step[pos][t];
ans[1] += lucky[a] * p10;
ans[2] += lucky[b] * p10;
ans[3] += lucky[c] * p10;
ans[4] += lucky[d] * p10;
ans[5] += lucky[e] * p10;
ans[6] += lucky[f] * p10;
p10 /= 10;
t = prevt[pos][t];
pos--;
}
for (int i = 1; i <= 6; i++) cout << ans[i] << " ";
cout << "\n";
} else
cout << "-1\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:33554432")
using namespace std;
const int a[3] = {0, 4, 7};
int n;
char num[1 << 5];
int len;
int used[20][6];
int path[20][6][6];
int M[1 << 8];
int C[1 << 8];
int go(int pos, int carry) {
if (pos == -1) return carry == 0;
if (used[pos][carry]) return 0;
used[pos][carry] = 1;
for (int i1 = 0; i1 < 3; ++i1)
for (int i2 = i1; i2 < 3; ++i2)
for (int i3 = i2; i3 < 3; ++i3)
for (int i4 = i3; i4 < 3; ++i4)
for (int i5 = i4; i5 < 3; ++i5)
for (int i6 = i5; i6 < 3; ++i6) {
int s = a[i1] + a[i2] + a[i3] + a[i4] + a[i5] + a[i6] + carry;
if (M[s] == num[pos] - '0') {
if (go(pos - 1, C[s])) {
path[pos][carry][0] = i1;
path[pos][carry][1] = i2;
path[pos][carry][2] = i3;
path[pos][carry][3] = i4;
path[pos][carry][4] = i5;
path[pos][carry][5] = i6;
return 1;
}
}
}
return 0;
}
long long nums[6];
int main() {
scanf("%d", &n);
for (int i = 0; i < 1 << 8; ++i) {
C[i] = i / 10;
M[i] = i % 10;
}
for (int i = 0; i < n; ++i) {
scanf("%s", num);
int len = strlen(num);
memset(used, 0, sizeof(used));
if (!go(len - 1, 0))
printf("-1\n");
else {
int pos = len - 1;
int carry = 0;
memset(nums, 0, sizeof(nums));
long long cur = 1;
while (pos >= 0) {
int to = 0;
for (int j = 0; j < 6; ++j) {
nums[j] += cur * a[path[pos][carry][j]];
to += a[path[pos][carry][j]];
}
to += carry;
pos--;
carry = to / 10;
cur *= 10;
}
for (int i = 0; i < 6; ++i) printf("%I64d ", nums[i]);
printf("\n");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long f[100];
long long base[20];
struct NODE {
int a, i4, i7;
NODE(int i, int j) {
i4 = i;
i7 = j;
a = i4 * 4 + i7 * 7;
};
bool operator<(const NODE &x) const { return a < x.a; };
};
vector<NODE> v;
int way[100];
bool dfs(long long remain, int a) {
if (a == 0) {
if ((remain == 0)) return true;
return false;
}
if (remain > f[a]) return false;
for (int i = 0; i < v.size(); ++i) {
if (remain < v[i].a * base[a]) break;
way[a] = i;
if (dfs(remain - v[i].a * base[a], a - 1)) return true;
}
return false;
}
void gao(long long x) {
if (!dfs(x, 18)) {
printf("-1\n");
return;
}
long long ret[10] = {0};
for (int i = 1, now = 0; i <= 18; ++i) {
int k = way[i];
for (int j = 0; j < v[k].i4; ++j) {
ret[now] += base[i] * 4;
now = (now + 1) % 6;
}
for (int j = 0; j < v[k].i7; ++j) {
ret[now] += base[i] * 7;
now = (now + 1) % 6;
}
}
for (int i = 0; i < 6; ++i) cout << ret[i] << ((i == 5) ? '\n' : ' ');
}
int main() {
int n;
for (int i = 0; i <= 6; ++i)
for (int j = 0; j + i <= 6; ++j) v.push_back(NODE(i, j));
sort(v.begin(), v.end());
for (int i = 1; i <= 18; ++i) {
f[i] = f[i - 1] * 10 + 42;
if (i == 1)
base[i] = 1;
else
base[i] = base[i - 1] * 10;
}
int t;
while (cin >> t) {
for (int i = 0; i < t; ++i) {
long long x;
cin >> x;
gao(x);
}
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int T;
bool f[20][5];
long long n, m, a[20], ans[20][5][7], b[7], ten[18];
void dfs(int i, int t, int S) {
int k, p;
if (t > 6) {
p = a[i] - S % 10;
if (p < 0) p += 10;
if (p <= 4 && f[i - 1][p]) {
f[i][(S + p) / 10] = 1;
for (k = 1; k <= 6; k++)
ans[i][(S + p) / 10][k] = ans[i - 1][p][k] + ten[i - 1] * b[k];
}
return;
}
b[t] = 0, dfs(i, t + 1, S);
b[t] = 7, dfs(i, t + 1, S + 7);
b[t] = 4, dfs(i, t + 1, S + 4);
b[t] = 0;
}
void work() {
int i;
scanf("%I64d", &n), m = 0;
while (n) a[++m] = n % 10, n /= 10;
memset(f, 0, sizeof(f));
f[0][0] = 1;
for (i = 1; i <= m; i++) dfs(i, 1, 0);
if (!f[m][0])
printf("-1\n");
else {
for (i = 1; i <= 6; i++)
printf(
"%I64d"
" ",
ans[m][0][i]);
printf("\n");
}
}
int main() {
int i;
cin >> T;
ten[0] = 1;
for (i = 1; i <= 19; i++) ten[i] = ten[i - 1] * 10;
while (T--) work();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
string way[25][50];
bool dp[25][50];
int add, a[] = {0, 4, 7};
string tmp;
vector<pair<string, int> > rec;
void dfs(int pos) {
if (pos == 6) {
rec.push_back(make_pair(tmp, add));
return;
}
for (int i = 0; i < 3; i++) {
add += a[i];
tmp[pos] = (char)('0' + a[i]);
dfs(pos + 1);
add -= a[i];
}
}
int main() {
int cas;
tmp = string(6, '0');
add = 0;
dfs(0);
cin >> cas;
while (cas--) {
string str;
cin >> str;
str = '0' + str;
reverse(str.begin(), str.end());
int n = (int)str.size();
memset(dp, false, sizeof(dp));
dp[0][0] = true;
int mx = 0;
way[0][0] = string(200, '0');
for (int i = 0; i < n; i++) {
for (int j = 0; j <= mx; j++) {
if (!dp[i][j]) continue;
for (int k = 0; k < (int)rec.size(); k++) {
pair<string, int> &tmp = rec[k];
int mod = (j + tmp.second) % 10;
if (mod != (int)(str[i] - '0')) continue;
int newj = (j + tmp.second) / 10;
mx = max(mx, newj);
if (dp[i + 1][newj]) continue;
dp[i + 1][newj] = true;
string newStr = way[i][j];
for (int a = 0; a < 6 && a * n + i < 200; a++) {
newStr[a * n + i] = tmp.first[a];
}
way[i + 1][newj] = newStr;
}
}
}
if (!dp[n][0])
puts("-1");
else {
string s = way[n][0];
for (int i = 0; i < 6; i++) {
string tmp = "";
for (int j = 0; j < n; j++) {
tmp += s[i * n + j];
}
reverse(tmp.begin(), tmp.end());
int j = 0;
while (j < (int)tmp.size() && tmp[j] == '0') j++;
if (j == (int)tmp.size())
putchar('0');
else
cout << tmp.substr(j, (int)tmp.size() - j);
cout << (i == 5 ? '\n' : ' ');
}
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const double PI = acos(-1.0);
const int MAX = 1e5 + 5;
int T;
long long N;
int A[50][6];
int C[6];
int dig[19];
bool vis[19][50];
int dp[19][50][6];
int res[19][6];
void get(int k) {
if (k == 6) {
int sum = 0;
for (int i = 0; i < 6; i++) {
sum += C[i];
}
if (A[sum][0] != -1) return;
for (int i = 0; i < 6; i++) {
A[sum][i] = C[i];
}
return;
}
C[k] = 0;
get(k + 1);
C[k] = 4;
get(k + 1);
C[k] = 7;
get(k + 1);
}
bool getdp(int k, int a) {
if (a >= 50) {
return false;
}
if (k == -1) return (a == 0);
if (vis[k][a]) {
if (dp[k][a][0] == -1) return false;
return true;
}
a += dig[k];
vis[k][a] = true;
for (int i = 0; i <= a; i++) {
if (A[i][0] == -1) continue;
for (int j = 0; j < 6; j++) {
res[k][j] = A[i][j];
}
bool ok = getdp(k - 1, 10 * (a - i));
if (ok) {
return true;
}
}
return false;
}
void solve() {
memset(dp, -1, sizeof(dp));
memset(vis, 0, sizeof(vis));
for (int j = 0; j < 19; j++) {
dig[j] = N % 10;
N /= 10;
}
bool ok = getdp(18, 0);
if (!ok) {
cout << "-1\n";
return;
}
for (int i = 0; i < 6; i++) {
long long v = 0;
for (int j = 18; j >= 0; j--) {
v = v * 10 + res[j][i];
}
cout << v << " ";
}
cout << '\n';
}
int main() {
memset(A, -1, sizeof(A));
get(0);
cin >> T;
for (int i = 0; i < T; i++) {
cin >> N;
solve();
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void chkmin(T &a, T b) {
if (a > b) a = b;
}
template <class T>
inline void chkmax(T &a, T b) {
if (a < b) a = b;
}
map<long long, bool> MP;
int deg[10], a[10][10], b[10][10];
int aa[30], bb[30];
bool find(long long x, int k) {
if (MP.count(x)) return false;
int i, j;
if (x == 0) {
long long ans[10];
memset(ans, 0, sizeof(ans));
for (i = k - 1; i >= 0; i--) {
j = 0;
while (aa[i]) {
ans[j] = ans[j] * 10 + 4;
j++;
aa[i]--;
}
while (bb[i]) {
ans[j] = ans[j] * 10 + 7;
j++;
bb[i]--;
}
while (j < 6) {
ans[j] = ans[j] * 10;
j++;
}
}
for (i = 0; i < 6; i++) {
if (i) printf(" ");
printf("%I64d", ans[i]);
}
puts("");
return true;
}
long long xx;
MP[x] = false;
j = x % 10;
for (i = 0; i < deg[j]; i++) {
aa[k] = a[j][i];
bb[k] = b[j][i];
xx = x - aa[k] * 4 - bb[k] * 7;
if (xx < 0) continue;
if (find(xx / 10, k + 1)) return true;
}
return false;
}
int main() {
int i, j, k, t, T;
long long N;
for (j = 0; j <= 6; j++)
for (k = 0; k + j <= 6; k++) {
i = (j * 4 + k * 7) % 10;
a[i][deg[i]] = j;
b[i][deg[i]] = k;
deg[i]++;
}
for (scanf("%d", &T); T--;) {
scanf("%I64d", &N);
MP.clear();
if (!find(N, 0)) puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int T;
int fours[100];
int sevens[100];
bool ok[100];
int dp[100][10];
int pc[100][10];
int main() {
for (int f = 0; f <= 6; ++f) {
for (int s = 0; s + f <= 6; ++s) {
int val = f * 4 + s * 7;
ok[val] = true;
fours[val] = f;
sevens[val] = s;
}
}
scanf("%d", &T);
for (int i = 0; i < T; ++i) {
long long num;
scanf("%I64d", &num);
for (int i = 0; i < 5; ++i) {
dp[0][i] = -1;
}
dp[0][0] = 0;
int d = 1;
while (num != 0) {
int dig = num % 10;
num /= 10;
for (int i = 0; i < 5; ++i) {
dp[d][i] = -1;
}
for (int oldcarry = 0; oldcarry < 5; ++oldcarry) {
if (dp[d - 1][oldcarry] != -1) {
for (int newcarry = 0; newcarry < 5; ++newcarry) {
int needed = dig + 10 * newcarry - oldcarry;
if (needed >= 0 && ok[needed]) {
dp[d][newcarry] = needed;
pc[d][newcarry] = oldcarry;
}
}
}
}
++d;
}
--d;
if (dp[d][0] != -1) {
long long results[6] = {0, 0, 0, 0, 0, 0};
for (int cc = 0; d > 0; --d) {
int current = dp[d][cc];
for (int i = 0; i < 6; ++i) results[i] *= 10;
for (int i = 0; i < fours[current]; ++i) results[i] += 4;
for (int i = 0; i < sevens[current]; ++i)
results[i + fours[current]] += 7;
cc = pc[d][cc];
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", results[0], results[1],
results[2], results[3], results[4], results[5]);
} else {
printf("-1\n");
}
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
set<long long> failed;
vector<int> prec[10][5];
void go(long long x, vector<long long> &res) {
if (x < 0 || failed.find(x) != failed.end()) return;
if (x == 0) {
res = vector<long long>(6, 0);
return;
}
int last = x % 10;
for (int i = 0; i < 5; i++)
if (!prec[last][i].empty()) {
go((x - last) / 10 - i, res);
if (!res.empty()) {
for (int j = 0; j < 6; j++) res[j] = 10 * res[j] + prec[last][i][j];
return;
}
}
failed.insert(x);
}
int main() {
for (int i = 0; i < 3 * 3 * 3 * 3 * 3 * 3; i++) {
vector<int> v;
int sum = 0;
int t = i;
for (int j = 0; j < 6; j++) {
int x = t % 3;
t /= 3;
if (x == 1)
x = 4;
else if (x == 2)
x = 7;
v.push_back(x);
sum += x;
}
prec[sum % 10][sum / 10] = v;
}
int tst;
scanf("%d", &tst);
while (tst-- > 0) {
failed.clear();
long long x;
scanf("%lld", &x);
vector<long long> res;
go(x, res);
if (res.empty()) {
printf("-1\n");
continue;
}
for (int i = 0; i < 6; i++)
printf(
"%lld"
"%c",
res[i], " \n"[i == 5]);
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct edge {
int u, v;
long long w;
};
long long MOD = 1000000007;
long long _MOD = 1000000009;
double EPS = 1e-10;
bool f(int i, int c, vector<int>& a, vector<vector<bool> >& vis,
vector<unsigned long long>& b) {
if (i == 19) return !c;
if (vis[i][c]) return false;
vis[i][c] = true;
for (int x = 0; x <= 6; x++)
for (int y = x; y <= 6; y++) {
int z = (y - x) * 4 + (6 - y) * 7 + c;
if (z % 10 == a[i] && f(i + 1, z / 10, a, vis, b)) {
for (int k = 0; k < 6; k++) {
b[k] *= 10;
if (x <= k && k < y) b[k] += 4;
if (y <= k) b[k] += 7;
}
return true;
}
}
return false;
}
int main() {
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
vector<int> a(19);
for (int t = 0; t < 19; t++) {
a[t] = n % 10;
n /= 10;
}
vector<vector<bool> > vis(19, vector<bool>(10));
vector<unsigned long long> b(6);
if (f(0, 0, a, vis, b)) {
for (int k = 0; k < 6; k++) cout << b[k] << ' ';
cout << endl;
} else
cout << -1 << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
string second;
int dp[20][12];
long long lucky[] = {0, 4, 7};
string s1, s2, s3, s4, s5, s6;
void printer(string second) {
long long ans = 0;
for (int i = second.size() - 1; i >= 0; i--) {
ans = ans * 10LL + (second[i] - '0');
}
cout << ans << " ";
}
bool done;
int ways(int n, int rem) {
if (done) {
return 1;
}
if (n == second.size() && rem == 0) {
printer(s1), printer(s2);
printer(s3), printer(s4);
printer(s5), printer(s6);
done = true;
return 1;
}
if (n == second.size()) {
return 0;
}
if (dp[n][rem] != -1) {
return dp[n][rem];
}
int ans = 0;
for (int a = 0; a < 3; a++) {
for (int b = 0; b < 3; b++) {
for (int c = 0; c < 3; c++) {
for (int d = 0; d < 3; d++) {
for (int e = 0; e < 3; e++) {
for (int first = 0; first < 3; first++) {
int x = rem + lucky[a] + lucky[b] + lucky[c] + lucky[d] +
lucky[e] + lucky[first];
if ((x % 10) == (second[n] - '0') && !done) {
string alt1 = s1, alt2 = s2, alt3 = s3, alt4 = s4, alt5 = s5,
alt6 = s6;
s1 += lucky[a] + '0';
s2 += lucky[b] + '0';
s3 += lucky[c] + '0';
s4 += lucky[d] + '0';
s5 += lucky[e] + '0';
s6 += lucky[first] + '0';
ans += ways(n + 1, x / 10);
s1 = alt1;
s2 = alt2;
s3 = alt3;
s4 = alt4;
s5 = alt5;
s6 = alt6;
}
}
}
}
}
}
}
return dp[n][rem] = ans;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
cin >> t;
for (int i = 0; i < t; i++) {
cin >> second;
reverse(second.begin(), second.end());
memset(dp, -1, sizeof dp);
done = false;
ways(0, 0);
if (!done) {
cout << "-1";
}
cout << "\n";
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const long long int N = 20, A = 7;
long long int n;
deque<long long int> a;
deque<pair<long long int, long long int> > p[10];
void Quay(long long int l, long long int h, long long int sum,
long long int mask) {
if (l > h) {
p[sum % 10].push_back({sum, mask});
} else {
Quay(l + 1, h, sum, mask * 10);
Quay(l + 1, h, sum + 4, mask * 10 + 4);
Quay(l + 1, h, sum + 7, mask * 10 + 7);
}
}
void Inp() {
cin >> n;
a.clear();
a.push_back(0);
for (int i = 1; i < N; i++) {
a.push_back(n % 10);
n = n / 10;
}
}
long long int dp[N][A], trace[N][A];
void Solve() {
fill_n(&dp[0][0], sizeof(dp) / sizeof(dp[0][0]), -1);
dp[0][0] = 0;
for (int i = 0; i < N - 1; i++) {
for (int j = 0; j < A; j++) {
if (dp[i][j] != -1) {
long long int vt = (a[i + 1] - j + 100) % 10;
for (auto v : p[vt]) {
long long int k = v.first + j;
if ((k % 10) == a[i + 1]) {
dp[i + 1][k / 10] = v.second;
trace[i + 1][k / 10] = j;
}
}
}
}
}
}
deque<long long int> ans[7];
void Add(long long int k) {
for (int i = 1; i <= 6; i++) {
ans[i].push_front(k % 10);
k = k / 10;
}
}
void Out() {
for (int i = 1; i <= 6; i++) {
while (ans[i].size() > 1) {
if (ans[i].back() == 0) {
ans[i].pop_back();
} else {
break;
}
}
for (int j = ans[i].size() - 1; j >= 0; j--) {
putchar(ans[i][j] + '0');
}
putchar(' ');
}
putchar('\n');
}
void Trace() {
if (dp[N - 1][0] == -1) {
putchar('-');
putchar('1');
putchar('\n');
return;
}
for (int i = 1; i <= 6; i++) {
ans[i].clear();
}
long long int k = 0;
for (int i = N - 1; i > 0; i--) {
Add(dp[i][k]);
k = trace[i][k];
}
Out();
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int T;
cin >> T;
Quay(1, 6, 0, 0);
while (T--) {
Inp();
Solve();
Trace();
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct num_6 {
int a[10];
};
vector<num_6> act;
string dest[10];
vector<int> num;
num_6 glo;
int val[] = {0, 4, 7};
set<int> myset;
void rec(int i, int j, int nu) {
if (i == 3) return;
if (j == 6) {
if (myset.count(nu) == 0) {
myset.insert(nu);
num.push_back(nu);
act.push_back(glo);
}
return;
}
rec(i + 1, j, nu);
glo.a[j] = val[i];
rec(i, j + 1, nu + val[i]);
}
string str;
int dp[22][11], len;
int memoize(int dig, int cary) {
if (dig == -1 && !cary) return 1;
if (dig < 0) return 0;
if (dp[dig][cary] != -1) return dp[dig][cary];
int ans = 0;
for (int i = int(0); i <= int(27); i++) {
if (str[dig] - '0' == (cary + num[i]) % 10)
ans |= memoize(dig - 1, (cary + num[i]) / 10);
if (ans) break;
}
return dp[dig][cary] = ans;
}
void print(int dig, int cary) {
if (dig == -1) return;
for (int i = int(0); i <= int(27); i++) {
if (str[dig] - '0' == (cary + num[i]) % 10) {
if (memoize(dig - 1, (cary + num[i]) / 10)) {
for (int j = int(0); j <= int(5); j++) {
dest[j] += ('0' + act[i].a[j]);
}
print(dig - 1, (cary + num[i]) / 10);
break;
}
}
}
}
int main() {
rec(0, 0, 0);
int t;
scanf("%d", &t);
while (t--) {
memset(dp, -1, sizeof(dp));
cin >> str;
len = str.length();
int ans = memoize(len - 1, 0);
if (ans) {
for (int i = int(0); i <= int(6); i++) dest[i] = "";
print(len - 1, 0);
for (int i = int(0); i <= int(5); i++) {
reverse(dest[i].begin(), dest[i].end());
int j = 0;
int len = dest[i].length();
while (j <= len - 2) {
if (dest[i][j] != '0') break;
j++;
}
for (int k = int(j); k <= int(len - 1); k++) {
printf("%c", dest[i][k]);
}
printf(" ");
}
printf("\n");
} else {
printf("-1\n");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int a[100][4];
int all;
unsigned long long M;
int d[100], np;
unsigned long long te[100];
void prework() {
all = 0;
for (int i = 0; i <= 6; i++)
for (int j = 0; j <= 6 - i; j++) {
int k = 6 - i - j;
a[++all][0] = j * 4 + k * 7;
a[all][1] = i;
a[all][2] = i + j;
a[all][3] = i + j + k;
}
te[0] = 1;
for (int i = 1; i <= 18; i++) te[i] = te[i - 1] * 10;
}
bool check(unsigned long long a, unsigned long long b, int p) {
int aa = a / te[p - 1] % 10;
int bb = b / te[p - 1] % 10;
return aa == bb;
}
bool work(unsigned long long mul, unsigned long long now, int p) {
if (mul == now) return true;
for (int i = 1; i <= all; i++) {
if (mul - now < a[i][0] * te[p]) continue;
unsigned long long ne = now + a[i][0] * te[p];
if (!check(mul, ne, p + 1)) continue;
d[p] = i;
np = p;
if (work(mul, ne, p + 1)) return true;
}
return false;
}
int dig[6][20];
void output() {
for (int i = 0; i <= np; i++) {
for (int j = 0; j < a[d[i]][1]; j++) dig[j][i] = 0;
for (int j = a[d[i]][1]; j < a[d[i]][2]; j++) dig[j][i] = 4;
for (int j = a[d[i]][2]; j < a[d[i]][3]; j++) dig[j][i] = 7;
}
for (int i = 0; i < 6; i++) {
unsigned long long now = 0;
for (int j = 0; j <= np; j++) now += te[j] * dig[i][j];
cout << now << " ";
}
cout << endl;
}
int main() {
prework();
int T;
cin >> T;
unsigned long long N;
while (T--) {
memset(dig, 0, sizeof(dig));
cin >> N;
if (work(N, 0, 0))
output();
else
cout << -1 << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
int f[20][4], sw;
int go(long long n, int K) {
int w;
if (n == 0) {
sw = 1;
long long d[6], j = 1;
memset(d, 0, sizeof(d));
for (int i = 0; i < K; i++, j *= 10) {
w = 0;
while (f[i][0]) d[w++] += 4 * j, f[i][0]--;
while (f[i][1]) d[w++] += 7 * j, f[i][1]--;
}
for (int i = 0; i < 6; i++) printf("%I64d ", d[i]);
printf("\n");
return 1;
}
long long k = n % 10;
for (int i = 0; i <= 6; i++) {
for (int j = 0; i + j <= 6; j++) {
long long w = i * 4 + j * 7;
if (w % 10 == k && n >= w) {
f[K][0] = i;
f[K][1] = j;
f[K][2] = 6 - (i + j);
go((n - w) / 10, K + 1);
if (sw) return 1;
}
}
}
return 0;
}
int main() {
int runs;
for (scanf("%d", &runs); runs--;) {
long long n;
sw = 0;
scanf("%I64d", &n);
if (!go(n, 0)) printf("-1\n");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int arr[20];
int mem[20][5];
int cat[20][5];
int mnz[20][5];
int mns[20][5];
int dp(int id, int c) {
if (id == 20) return c == 0;
if (cat[id][c]) return mem[id][c];
for (int i = 0; i <= 6; ++i) {
for (int j = 0; j + i <= 6; ++j) {
int nz = i, ns = j, nf = 6 - nz - ns;
int d = c * 10 + arr[id];
int s = ns * 7 + nf * 4;
if (s > d) continue;
if (d - s > 4) continue;
if (dp(id + 1, d - s)) {
cat[id][c] = 1;
mnz[id][c] = nz;
mns[id][c] = ns;
return mem[id][c] = true;
}
}
}
cat[id][c] = 1;
return mem[id][c] = false;
}
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
long long n;
cin >> n;
for (int i = 19; i >= 0; --i) {
arr[i] = n % 10;
n /= 10;
}
memset(cat, 0, sizeof(cat));
int t = dp(0, 0);
if (t == 0) {
cout << -1 << endl;
} else {
int id = 0, c = 0;
long long arr2[] = {0, 0, 0, 0, 0, 0};
while (id < 20) {
int nz = mnz[id][c];
int ns = mns[id][c];
int nf = 6 - nz - ns;
for (int i = 0; i < nz; ++i) arr2[i] = 10 * arr2[i] + 0;
for (int i = nz; i < nz + nf; ++i) arr2[i] = 10 * arr2[i] + 4;
for (int i = nz + nf; i < nz + nf + ns; ++i) arr2[i] = 10 * arr2[i] + 7;
c = 10 * c + arr[id] - 4 * nf - 7 * ns;
id++;
}
for (int i = 0; i < 6; ++i) cout << arr2[i] << " ";
cout << endl;
}
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:100000000000,100000000000")
using namespace std;
const long long inf = 1e18 + 7;
const long long mod = 1e9 + 7;
const double eps = 1e-12;
const double PI = 2 * acos(0.0);
const double E = 2.71828;
string s;
long long ans[7];
set<pair<int, int> > was;
inline bool rec(int v, int add) {
if (was.count(make_pair(v, add))) return false;
was.insert(make_pair(v, add));
if (v == s.size()) {
return add == 0;
}
for (int zeroes = 0; zeroes < 7; zeroes++) {
for (int fours = 0; fours + zeroes < 7; fours++) {
int sevens = 6 - fours - zeroes;
int val = sevens * 7 + fours * 4 + add;
if (val % 10 == s[v] - '0') {
if (rec(v + 1, val / 10)) {
for (int i = 0; i < zeroes; i++) ans[i] *= 10;
for (int i = zeroes; i < zeroes + fours; i++)
ans[i] = ans[i] * 10 + 4;
for (int i = zeroes + fours; i < 6; i++) ans[i] = ans[i] * 10 + 7;
return true;
}
}
}
}
return false;
}
void Solve() {
cin >> s;
reverse((s).begin(), (s).end());
memset(ans, 0, sizeof ans);
was.clear();
if (rec(0, 0)) {
for (long long(i) = 0; (i) < (long long)(6); (i)++) cout << ans[i] << " ";
cout << endl;
} else
puts("-1");
}
int main(void) {
int T;
scanf("%d", &T);
for (long long(i) = 0; (i) < (long long)(T); (i)++) Solve();
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int vis[100];
int sum[1000];
int bit[100][10], a[10];
int b[100];
int cnt = 0;
int dp[30][20];
int pre[30][20], rem[30][20];
void dfs(int d, int s) {
if (d == 6) {
if (vis[s]) return;
vis[s] = 1;
sum[cnt] = s;
memcpy(bit[cnt], a, sizeof(a));
cnt++;
return;
}
a[d] = 0;
dfs(d + 1, s + 0);
a[d] = 4;
dfs(d + 1, s + 4);
a[d] = 7;
dfs(d + 1, s + 7);
}
long long ans[10];
int main() {
dfs(0, 0);
int T, n;
long long x;
scanf("%d", &T);
while (T--) {
n = 0;
cin >> x;
while (x) {
b[++n] = x % 10;
x /= 10;
}
memset(dp, 0, sizeof(dp));
dp[0][0] = 1;
int nn = 20;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= 10; ++j)
if (dp[i - 1][j]) {
for (int k = 0; k < cnt; ++k) {
x = sum[k] + j;
if (x % 10 != b[i]) continue;
dp[i][x / 10] |= dp[i - 1][j];
pre[i][x / 10] = (i - 1) * nn + j;
rem[i][x / 10] = k;
}
}
if (dp[n][0]) {
memset(ans, 0, sizeof(ans));
int x, y, k;
k = rem[n][0];
for (int i = 0; i < 6; ++i) {
ans[i] = bit[k][i];
}
x = pre[n][0];
while (x) {
y = x % nn, x = x / nn;
k = rem[x][y];
for (int i = 0; i < 6; ++i) {
ans[i] = 10 * ans[i] + bit[k][i];
}
x = pre[x][y];
}
long long haha = 0;
for (int i = 0; i < 6; ++i) {
haha += ans[i];
cout << ans[i] << " ";
}
cout << endl;
} else
puts("-1");
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 20;
int opt[N][N], pre[N][N][3], a[N], len;
long long ans[N];
int main() {
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
len = 0;
for (; n; n /= 10) a[++len] = n % 10;
memset(opt, 0, sizeof opt);
memset(ans, 0, sizeof ans);
opt[0][0] = 1;
for (int i = 0; i < len; ++i)
for (int j = 0; j < 5; ++j)
if (opt[i][j])
for (int x = 0; x <= 6; ++x)
for (int y = 0; x + y <= 6; ++y) {
int sum = j + x * 4 + y * 7, nj = sum / 10;
if (sum % 10 == a[i + 1])
opt[i + 1][nj] = 1, pre[i + 1][nj][0] = j,
pre[i + 1][nj][1] = x, pre[i + 1][nj][2] = y;
}
if (opt[len][0]) {
for (int i = len, j = 0; i > 0; --i) {
int x = pre[i][j][1], y = pre[i][j][2];
for (int k = 0; k < x; ++k) ans[k] = ans[k] * 10 + 4;
for (int k = x; k < x + y; ++k) ans[k] = ans[k] * 10 + 7;
for (int k = x + y; k < 6; ++k) ans[k] = ans[k] * 10;
j = pre[i][j][0];
}
for (int k = 0; k < 6; ++k) printf(k == 5 ? "%I64d\n" : "%I64d ", ans[k]);
} else
puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int dp[50100][10], cnt, p[110][10], val[110];
bool fg[50100];
int T;
long long m;
void pre() {
for (int i = 0; i <= 6; i++) {
for (int j = 0; j <= 6 - i; j++) {
for (int id = 0; id < 6; id++) {
if (id < i) {
p[cnt][id] = 0;
continue;
}
if (id < i + j) {
p[cnt][id] = 4;
val[cnt] += 4;
continue;
}
p[cnt][id] = 7;
val[cnt] += 7;
}
cnt++;
}
}
fg[0] = 1;
for (int dit = 1; dit <= 4; dit++) {
for (int j = 0; j < 50100; j++)
if (fg[j]) {
for (int k = 0; k < cnt; k++) {
int xx = j * 10 + val[k];
if (xx >= 50100 || fg[xx]) continue;
fg[xx] = true;
for (int t = 0; t < 6; t++) dp[xx][t] = dp[j][t] * 10 + p[k][t];
}
}
}
}
long long ans[10];
bool can(long long x) {
if (x <= 50000 && fg[x]) {
for (int i = 0; i < 6; i++) ans[i] = dp[x][i];
return true;
}
if (x < 10000) return false;
int y = x % 10000;
x /= 10000;
for (int i = 0; i <= 4; i++)
if (fg[y + i * 10000]) {
if (can(x - i)) {
for (int j = 0; j < 6; j++)
ans[j] = ans[j] * 10000 + dp[y + i * 10000][j];
return true;
}
}
return false;
}
int main() {
pre();
for (scanf("%d", &T); T--;) {
scanf("%I64d", &m);
if (can(m)) {
for (int i = 0; i < 6; i++) printf("%I64d ", ans[i]);
puts("");
} else
puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int Max(int a, int b) { return (((b - a) >> (32 - 1)) & (a ^ b)) ^ b; }
int Min(int a, int b) { return (((b - a) >> (32 - 1)) & (a ^ b)) ^ a; }
long long GCD(long long a, long long b) { return b != 0 ? GCD(b, a % b) : a; }
long long LCM(long long a, long long b) { return a * (b / GCD(a, b)); }
long long Pow(long long n, long long e) {
if (e == 0) return 1;
if (e == 1)
return n;
else if (e & 1) {
long long t = Pow(n, e / 2);
return n * t * t;
} else {
long long t = Pow(n, e / 2);
return t * t;
}
}
bool used[20][20];
bool dp[20][20];
int nextt[20][20];
int fours[20][20];
int sevens[20][20];
string num;
bool DP(int id, int carry) {
if (id == (int)(num).size()) {
if (carry == 0) return true;
return false;
}
if (used[id][carry]) return dp[id][carry];
used[id][carry] = true;
for (int f = 0, max_ = (7); f < max_; ++f)
for (int s = 0, max_ = (7); s < max_; ++s) {
if (f + s > 6) continue;
int n = 4 * f + 7 * s;
int c = n / 10;
int r = n % 10;
if (carry < c) continue;
int req = (num[id] - '0') - r;
if (carry > c) req += 10 * (carry - c);
if (req < 0 || req > 10) continue;
bool res = DP(id + 1, req);
if (res) {
fours[id][carry] = f;
sevens[id][carry] = s;
nextt[id][carry] = req;
return dp[id][carry] = true;
}
}
return dp[id][carry] = false;
}
int main() {
long long N;
int T;
scanf("%d", &T);
for (int i = 0, max_ = (T); i < max_; ++i) {
cin >> num;
memset(used, false, sizeof(used));
;
memset(dp, false, sizeof(dp));
;
bool r = DP(0, 0);
if (r) {
long long r[6] = {0, 0, 0, 0, 0, 0};
int carry = 0;
long long exp = Pow(10, (int)(num).size() - 1);
for (int i = 0, max_ = ((int)(num).size()); i < max_; ++i) {
for (int j = 0, max_ = (fours[i][carry]); j < max_; ++j)
r[j] += 4 * exp;
for (int j = 0, max_ = (sevens[i][carry]); j < max_; ++j)
r[j + fours[i][carry]] += 7 * exp;
carry = nextt[i][carry];
exp /= 10;
}
printf("%I64d %I64d %I64d %I64d %I64d %I64d\n", r[0], r[1], r[2], r[3],
r[4], r[5]);
} else
printf("-1\n");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
vector<int> b;
int id[33], cnt4[33], cnt7[33];
long long p10[20], mx[20];
int att(long long n, int i) {
if (i == 0) {
for (int j = 0; j < int(b.size()); j++)
if (b[j] == n) {
id[0] = j;
return 1;
}
return 0;
}
for (int j = 0; j < int(b.size()); j++) {
long long nn = n - p10[i] * b[j];
if (nn < 0) continue;
if (nn > mx[i - 1]) continue;
id[i] = j;
if (att(nn, i - 1)) return 1;
}
return 0;
}
void solve(long long n) {
memset(id, 0, sizeof id);
int found = 0;
for (int i = 0; i <= 17; i++)
if (mx[i] >= n)
if (att(n, i)) {
found = 1;
break;
}
if (!found) {
puts("-1");
return;
}
long long ans[6] = {0};
for (int i = 0; i <= 17; i++) {
for (int j = 0; j < cnt4[id[i]]; j++) ans[j] += p10[i] * 4;
for (int j = cnt4[id[i]]; j < cnt4[id[i]] + cnt7[id[i]]; j++)
ans[j] += p10[i] * 7;
}
long long sum = 0;
for (int i = 0; i < 6; i++) cout << ans[i] << (i == 5 ? '\n' : ' ');
}
int main() {
for (int i = 0; i <= 17; i++) p10[i] = i ? p10[i - 1] * 10 : 1;
for (int i = 0; i <= 17; i++) mx[i] = mx[i - 1] + p10[i] * 42;
for (int i = 0; i <= 6; i++)
for (int j = 0; j + i <= 6; j++) {
b.push_back(i * 7 + j * 4);
cnt4[b.size() - 1] = j;
cnt7[b.size() - 1] = i;
}
int test;
long long n;
cin >> test;
while (test--) {
cin >> n;
solve(n);
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int d[20][10], step[20][10];
int main() {
int T;
scanf("%d", &T);
while (T--) {
long long t;
cin >> t;
int len = 0, num[20];
long long ans[6] = {0};
while (t) {
num[++len] = t % 10;
t /= 10;
}
memset(d, 0, sizeof(d));
d[0][0] = 1;
for (int i = 1; i <= len; i++)
for (int j = 0; j <= 5; j++) {
int need = num[i] + j * 10;
for (int k = 0; k <= 6; k++)
for (int l = 0; l + k <= 6; l++)
if (need - 4 * k - 7 * l <= 5 && need - 4 * k - 7 * l >= 0 &&
d[i - 1][need - 4 * k - 7 * l]) {
d[i][j] = 1;
step[i][j] = k * 10 + l;
}
}
if (d[len][0]) {
int c = 0;
for (int i = len; i >= 1; i--) {
int four = step[i][c] / 10, seven = step[i][c] % 10;
for (int j = 0; j < four; j++) ans[j] = ans[j] * 10 + 4;
for (int j = four; j < four + seven; j++) ans[j] = ans[j] * 10 + 7;
for (int j = four + seven; j < 6; j++) ans[j] = ans[j] * 10;
c = 10 * c + num[i] - 4 * four - 7 * seven;
}
for (int i = 0; i < 6; i++) cout << ans[i] << ' ';
printf("\n");
} else
printf("-1\n");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e6 + 10;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
int c[20];
bool vis[20][10];
int A[20][10], B[20][10];
long long P[20];
long long res[7];
int main() {
P[0] = 1;
for (int i = 1; i <= 18; ++i) P[i] = P[i - 1] * 10;
int T;
cin >> T;
while (T--) {
long long n;
cin >> n;
int len = 0;
while (n) c[++len] = n % 10, n /= 10;
memset(vis, false, sizeof(vis));
vis[0][0] = true;
for (int i = 0; i < len; ++i) {
for (int j = 0; j < 20; ++j)
if (j < 10 && vis[i][j]) {
for (int a = 0; a <= 6; ++a) {
for (int b = 0; a + b <= 6; ++b) {
int tmp = a * 4 + b * 7 + j;
if ((tmp % 10) != c[i + 1]) continue;
vis[i + 1][tmp / 10] = true;
A[i + 1][tmp / 10] = a;
B[i + 1][tmp / 10] = b;
}
}
}
}
if (!vis[len][0]) {
puts("-1");
continue;
}
int m = 0;
memset(res, 0, sizeof(res));
for (int i = len; i >= 1; --i) {
int a = A[i][m];
int b = B[i][m];
int tmp = a * 4 + b * 7;
m = m * 10 + c[i] - tmp;
int j = 1;
for (; j <= a; ++j) res[j] += 4 * P[i - 1];
for (; j <= a + b; ++j) res[j] += 7 * P[i - 1];
}
for (int i = 1; i <= 6; ++i) cout << res[i] << ' ';
puts("");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
int d[22];
int dp[22][5];
pair<pair<int, int>, int> pre[22][5];
int cnt[22][2];
int main() {
int t;
long long n;
for (scanf("%d", &t); t--;) {
scanf("%I64d", &n);
int m = 0;
while (n) {
d[m++] = n % 10;
n /= 10;
}
memset(dp, 0, sizeof(dp));
dp[m][0] = 1;
for (int i = m; i--;) {
for (int j = 0; j < 5; j++) {
for (int a = 0; a <= 6; a++) {
for (int b = 0; b <= 6 - a; b++) {
int val = a * 4 + b * 7;
if ((val + j) % 10 != d[i]) continue;
if (dp[i + 1][(val + j) / 10]) {
dp[i][j] = 1;
pre[i][j] = pair<pair<int, int>, int>(pair<int, int>(a, b),
(val + j) / 10);
break;
}
}
if (dp[i][j]) break;
}
}
}
if (!dp[0][0])
puts("-1");
else {
for (int i = 0, up = 0; i < m; i++) {
cnt[i][0] = pre[i][up].first.first;
cnt[i][1] = pre[i][up].first.second;
up = pre[i][up].second;
}
for (int i = 0; i < 6; i++) {
long long val = 0;
for (int i = m; i--;) {
val *= 10;
if (cnt[i][0] > cnt[i][1])
val += 4, cnt[i][0]--;
else if (cnt[i][1])
val += 7, cnt[i][1]--;
}
printf("%I64d ", val);
}
puts("");
}
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class _T>
inline void ina(_T a[], int n) {
for (int i = 0; i < n; i++) In(a[i]);
}
int TEST_CASE = 0;
template <class _T>
inline _T pow(_T a, _T b, _T m) {
a %= m;
_T ans = 1 % m;
while (b) {
if (b & 1) ans *= a, ans %= m;
a *= a;
a %= m;
b >>= 1;
}
return ans;
}
template <class _T>
inline _T pow(_T a, _T b) {
_T ans = 1;
while (b) {
if (b & 1) ans *= a;
a *= a;
b >>= 1;
}
return ans;
}
template <class _T>
inline _T add(_T a, _T b, _T m) {
return a >= m - b ? a - (m - b) : a + b;
}
template <class _T>
inline _T multiply(_T a, _T b, _T m) {
_T ans = 0;
if (b > a) swap(a, b);
while (b) {
if (b & 1) ans = add(ans, a, m);
b >>= 1;
a = add(a, a, m);
}
return ans;
}
template <class _T>
inline _T bigpow(_T a, _T b, _T m) {
a %= m;
_T ans = 1 % m;
while (b) {
if (b & 1) ans = multiply(ans, a, m);
a = multiply(a, a, m);
b >>= 1;
}
return ans;
}
template <class _T>
inline _T modinvers(_T a, _T m) {
return m > 2000000000LL ? bigpow(a, m - 2, m) : pow(a, m - 2, m);
}
template <class _T>
_T _egcd(_T a, _T b, _T &x, _T &y) {
if (!b) {
x = 1, y = 0;
return a;
}
_T _g = _egcd(b, a % b, x, y);
_T xt = x;
x = y, y = xt - (a / b) * y;
return _g;
}
template <class _T>
inline _T fmodinvers(_T a, _T m) {
_T x, y;
_egcd(a, m, x, y);
x %= m;
if (x < 0) x += m;
return x;
}
template <class _T>
inline _T _lcm(_T a, _T b) {
return (a * b) / __gcd(a, b);
}
template <class T>
inline T SQ(T a) {
return a * a;
}
long long SQRT(long long n) {
long long e = sqrt(n * 1.0);
long long l = max(0LL, e - 2), r = min(n, e + 2);
long long ans = 0;
while (l <= r) {
long long m = ((l + r) >> 1);
if (m * m <= n)
ans = m, l = m + 1;
else
r = m - 1;
}
return ans;
}
long long CBRT(long long n) {
long long e = cbrt(n * 1.0);
long long l = max(0LL, e - 2), r = min(n, e + 2);
long long ans = 0;
while (l <= r) {
long long m = ((l + r) >> 1);
if (m * m * m <= n)
ans = m, l = m + 1;
else
r = m - 1;
}
return ans;
}
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
const int SIZE = 1e6;
long long mod = 1e9 + 7;
int mem[5][20], ch4[5][20], ch7[5][20];
char N[22];
int dp(int i, int c) {
if (c < 0 || c > 4) return 0;
if (i == 19) return !c;
int &res = mem[c][i];
if (~res) return res;
res = 0;
for (int f = 0; f <= 6; f++) {
for (int s = 0; s + f <= 6; s++) {
res = res | dp(i + 1, c * 10 + N[i] - '0' - 4 * f - 7 * s);
if (res) {
ch4[c][i] = f, ch7[c][i] = s;
return res = 1;
}
}
}
return res;
}
char NM[6][20];
int main() {
int tc;
long long n;
cin >> tc;
while (tc--) {
cin >> n;
sprintf(N, "%019lld", n);
memset(mem, -1, sizeof(mem));
bool res = dp(0, 0);
if (res) {
for (int i = 0, c = 0; i < 19; i++) {
int j = 0;
for (; j < ch4[c][i]; j++) NM[j][i] = '4';
for (; j < ch4[c][i] + ch7[c][i]; j++) NM[j][i] = '7';
for (; j < 6; j++) NM[j][i] = '0';
c = c * 10 + N[i] - '0' - ch4[c][i] * 4 - ch7[c][i] * 7;
}
for (int j = 0; j < 6; j++) {
sscanf(NM[j], "%lld\n", &n);
cout << n << " ";
}
cout << '\n';
} else
cout << -1 << '\n';
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline int size(const T& c) {
return c.size();
}
using namespace std;
int fastMax(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ y; }
int fastMin(int x, int y) { return (((y - x) >> (32 - 1)) & (x ^ y)) ^ x; }
const int d[3] = {0, 4, 7};
const int maxcs = 20;
struct tracer {
int i, j;
int s1, s2, s3, s4, s5, s6;
} tr[maxcs][10];
struct p6 {
int i1, i2, i3, i4, i5, i6;
} t6[100];
string s;
int t;
int G[100];
bool F[maxcs][10];
long long so[6];
p6 m6(int i1, int i2, int i3, int i4, int i5, int i6) {
p6 u;
u.i1 = i1;
u.i2 = i2;
u.i3 = i3;
u.i4 = i4;
u.i5 = i5;
u.i6 = i6;
return u;
}
tracer maketrace(int i, int j, int k) {
tracer res;
res.i = i;
res.j = j;
res.s1 = d[t6[k].i1];
res.s2 = d[t6[k].i2];
res.s3 = d[t6[k].i3];
res.s4 = d[t6[k].i4];
res.s5 = d[t6[k].i5];
res.s6 = d[t6[k].i6];
return res;
}
void trace(int i, int j) {
if (i == 0 && j == 0) return;
so[0] = so[0] * 10 + tr[i][j].s1;
so[1] = so[1] * 10 + tr[i][j].s2;
so[2] = so[2] * 10 + tr[i][j].s3;
so[3] = so[3] * 10 + tr[i][j].s4;
so[4] = so[4] * 10 + tr[i][j].s5;
so[5] = so[5] * 10 + tr[i][j].s6;
trace(tr[i][j].i, tr[i][j].j);
}
int main() {
cin >> t;
for (int i1 = (0), _b = (2); i1 <= _b; i1++)
for (int i2 = (0), _b = (2); i2 <= _b; i2++)
for (int i3 = (0), _b = (2); i3 <= _b; i3++)
for (int i4 = (0), _b = (2); i4 <= _b; i4++)
for (int i5 = (0), _b = (2); i5 <= _b; i5++)
for (int i6 = (0), _b = (2); i6 <= _b; i6++) {
G[d[i1] + d[i2] + d[i3] + d[i4] + d[i5] + d[i6]] = true;
t6[d[i1] + d[i2] + d[i3] + d[i4] + d[i5] + d[i6]] =
m6(i1, i2, i3, i4, i5, i6);
}
for (int i = (1), _b = (t); i <= _b; i++) {
cin >> s;
int l = 0;
int r = s.length() - 1;
while (l <= r) {
char tg = s[l];
s[l] = s[r];
s[r] = tg;
l++;
r--;
}
s = " " + s;
memset(F, false, sizeof(F));
F[0][0] = true;
for (int i = (0), _b = (s.length() - 2); i <= _b; i++) {
for (int j = (0), _b = (4); j <= _b; j++) {
if (F[i][j] == false) continue;
for (int k = (0), _b = (42); k <= _b; k++) {
if (G[k] && (k + j) % 10 == s[i + 1] - '0') {
F[i + 1][(k + j) / 10] = true;
tr[i + 1][(k + j) / 10] = maketrace(i, j, k);
}
}
}
}
if (F[s.length() - 1][0] == false)
cout << -1 << endl;
else {
memset(so, 0, sizeof(so));
trace(s.length() - 1, 0);
for (int i = (0), _b = (5); i <= _b; i++) cout << so[i] << ' ';
cout << endl;
}
}
fclose(stdin);
fclose(stdout);
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int t;
bool vis[20][10];
vector<int> v;
int l;
long long n;
vector<int> ans[6];
void add(int s, int f) {
for (int i = 0; i < 6; ++i) ans[i].push_back(0);
for (int i = 0; i < s; ++i) ans[i].back() += 7;
for (int i = s; i < s + f; ++i) ans[i].back() += 4;
}
void print() {
for (int i = 0; i < 6; ++i) {
long long x = 0;
for (int j = ans[i].size() - 1; j >= 0; --j) x = (x * 10) + ans[i][j];
printf("%I64d ", x);
}
printf("\n");
}
bool check(int i, int ex) {
if (vis[i][ex]) return false;
vis[i][ex] = true;
if (i == 0) {
for (int s = 0; s <= 6; ++s)
for (int f = 0; s + f <= 6; ++f) {
int num = (s * 7) + (f * 4);
if (num % 10 == v[0] && num / 10 == ex) {
add(s, f);
return true;
}
}
return false;
}
for (int s = 0; s <= 6; ++s)
for (int f = 0; s + f <= 6; ++f) {
for (int prev = 0; prev <= 9; ++prev) {
int num = (s * 7) + (f * 4) + prev;
if (num % 10 == v[i] && num / 10 == ex) {
bool x = check(i - 1, prev);
if (x) {
add(s, f);
return true;
}
}
}
}
return false;
}
int main() {
scanf("%d", &t);
while (t--) {
scanf("%I64d", &n);
memset(vis, 0, sizeof vis);
for (int i = 0; i < 6; ++i) ans[i].clear();
v.clear();
long long x = n;
while (x) {
v.push_back(x % 10);
x /= 10;
}
l = v.size();
x = false;
x = check(l - 1, 0);
if (x) {
print();
continue;
}
if (l >= 2) {
x = check(l - 2, v[l - 1]);
if (x) {
print();
continue;
}
}
puts("-1");
}
return 0;
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
long long T, X;
vector<long long> lucky, l = {0, 4, 7};
vector<long long> ans(6);
bool DP[10000][7];
bool dp(long long x, int i) {
if (i == 6) return (x == 0);
if (!DP[x][i]) return false;
for (long long y : lucky) {
if (y > x) break;
if (dp(x - y, i + 1)) {
ans[i] = y;
return true;
}
}
return DP[x][i] = false;
}
int main() {
for (int i1 = 0; i1 < (int)3; i1++)
for (int i2 = 0; i2 < (int)3; i2++)
for (int i3 = 0; i3 < (int)3; i3++)
lucky.push_back(l[i1] * 100 + l[i2] * 10 + l[i3]);
cin >> T;
while (T--) {
memset(DP, true, sizeof DP);
ans.assign(6, 0ll);
cin >> X;
long long X1 = X % 4000ll, X2 = X - X1;
if (!dp(X1, 0)) {
X1 += 4000ll;
X2 -= 4000ll;
if (X2 < 0 or !dp(X1, 0)) {
cout << -1 << '\n';
continue;
}
}
long long pow = 1000;
X2 = X2 / 4000ll;
while (X2) {
long long d = X2 % 10ll;
X2 /= 10ll;
if (d > 6) {
for (int i = 0; i < (int)4; i++) ans[i + 2] += 7ll * pow;
d -= 7ll;
}
for (int i = 0; i < (int)d; i++) ans[i] += 4ll * pow;
pow *= 10ll;
}
for (int i = 0; i < (int)6; i++) cout << ans[i] << ' ';
cout << '\n';
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
struct elements {
bool canBuild;
int digits[7];
};
struct path {
int a, b;
};
elements s[7 * 6 + 2];
int d[10];
void Try(int i, int sum) {
if (i > 6) {
s[sum].canBuild = true;
for (int j = 1; j <= 6; j++) s[sum].digits[j] = d[j];
return;
}
d[i] = 0;
Try(i + 1, sum);
d[i] = 4;
Try(i + 1, sum + 4);
d[i] = 7;
Try(i + 1, sum + 7);
}
void init() {
for (int i = 0; i <= 7 * 6; i++) s[i].canBuild = false;
Try(1, 0);
}
int main() {
init();
int testCases;
cin >> testCases;
while (testCases--) {
long long n;
cin >> n;
int digits[20], m = 0;
while (n > 0) {
m++;
digits[m] = n % 10;
n = n / 10;
}
bool f[m + 5][5];
path trace[m + 5][5];
memset(f, false, sizeof(f));
f[0][0] = true;
for (int i = 0; i <= m - 1; i++) {
for (int j = 0; j <= 4; j++) {
if (f[i][j]) {
for (int k = 0; k <= 42; k++) {
if ((s[k].canBuild) && ((j + k) % 10 == digits[i + 1])) {
int x = (j + k);
f[i + 1][x / 10] = true;
trace[i + 1][x / 10].a = j;
trace[i + 1][x / 10].b = k;
}
}
}
}
}
if (f[m][0]) {
long long res[10], j = 0;
memset(res, 0, sizeof(res));
while (m > 0) {
int x = trace[m][j].b;
for (int i = 1; i <= 6; i++) res[i] = res[i] * 10 + s[x].digits[i];
j = trace[m][j].a;
m--;
}
for (int i = 1; i <= 6; i++) cout << res[i] << " ";
cout << endl;
} else
cout << -1 << endl;
}
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T Abs(T first) {
return (first < 0 ? -first : first);
}
template <typename T>
T Sqr(T first) {
return (first * first);
}
string plural(string s) {
return (int((s).size()) && s[int((s).size()) - 1] == 'x' ? s + "en"
: s + "s");
}
const int INF = (int)1e9;
const long double EPS = 1e-9;
const long double PI = acos(-1.0);
bool Read(int &first) {
char c, r = 0, n = 0;
first = 0;
for (;;) {
c = getchar();
if ((c < 0) && (!r)) return (0);
if ((c == '-') && (!r))
n = 1;
else if ((c >= '0') && (c <= '9'))
first = first * 10 + c - '0', r = 1;
else if (r)
break;
}
if (n) first = -first;
return (1);
}
int main() {
if (0) freopen("in.txt", "r", stdin);
int T;
int i, j, k, a, b, c;
long long ans[6];
char s[19];
int dig[19];
bool dyn[20][10];
int prevA[20][10], prevB[20][10], prevC[20][10], prevJ[20][10];
Read(T);
while (T--) {
scanf("%s", &s);
memset(dig, 0, sizeof(dig));
j = strlen(s);
for (i = 0; i < j; i++) dig[i] = s[j - i - 1] - '0';
memset(dyn, 0, sizeof(dyn));
dyn[0][0] = 1;
for (i = 0; i < 19; i++)
for (j = 0; j < 10; j++)
if (dyn[i][j])
for (a = 0; a < 7; a++)
for (b = 0; b < 7 - a; b++) {
c = 6 - a - b;
k = j + b * 4 + c * 7;
if (k % 10 != dig[i]) continue;
k /= 10;
if (!dyn[i + 1][k]) {
dyn[i + 1][k] = 1;
prevA[i + 1][k] = a;
prevB[i + 1][k] = b;
prevC[i + 1][k] = c;
prevJ[i + 1][k] = j;
}
}
if (!dyn[19][0])
printf("-1\n");
else {
memset(ans, 0, sizeof(ans));
j = 0;
for (i = 19; i > 0; i--) {
a = prevA[i][j];
b = prevB[i][j];
c = prevC[i][j];
for (k = 0; k < a; k++) ans[k] = ans[k] * 10;
for (k = a; k <= a + b - 1; k++) ans[k] = ans[k] * 10 + 4;
for (k = a + b; k <= 5; k++) ans[k] = ans[k] * 10 + 7;
j = prevJ[i][j];
}
for (i = 0; i < 6; i++) {
cout << ans[i];
if (i == 5)
printf("\n");
else
printf(" ");
}
}
}
return (0);
}
| 11 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 2e9;
const int MAXN = 1e5 + 5;
const long long MOD = 1e9 + 7;
long long x;
long long n1, n2;
bool little_lucky[11111];
long long lucky[] = {0, 4, 7, 40, 44, 47, 70, 74, 77,
400, 404, 407, 440, 444, 447, 470, 474, 477,
700, 704, 707, 740, 744, 747, 770, 774, 777};
vector<long long> dp_lucky[11111][7];
vector<long long> dp_g_lucky[11111][7];
vector<long long> g_lucky;
long long ans[6];
long long t_ans[6];
long long stk;
long long pot10 = 1;
long long tmp;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int T;
cin >> T;
for (int(i) = (0); (i) < (11111); ++(i)) {
bool ok = 1;
int ret = i;
for (int j = 0; j < 7; ++j) {
int yo = ret % 10;
ret /= 10;
if (yo != 0 && yo != 4 && yo != 7) ok = 0;
}
if (ok) {
g_lucky.push_back(i);
dp_g_lucky[i][1].push_back(i);
}
}
for (int(i) = (0); (i) < (27); ++(i))
dp_lucky[lucky[i]][1].push_back(lucky[i]);
for (int(i) = (0); (i) < (11111); ++(i)) {
for (int(j) = (2); (j) < (7); ++(j)) {
for (int(k) = (0); (k) < (27); ++(k)) {
if (lucky[k] > i) break;
if (!dp_lucky[i - lucky[k]][j - 1].empty()) {
int len = int(dp_lucky[i - lucky[k]][j - 1].size());
dp_lucky[i][j].push_back(lucky[k]);
for (int(tt) = (0); (tt) < (len); ++(tt)) {
dp_lucky[i][j].push_back(dp_lucky[i - lucky[k]][j - 1][tt]);
}
break;
}
}
}
}
for (int(i) = (0); (i) < (11111); ++(i))
if (!dp_lucky[i][6].empty()) little_lucky[i] = 1;
for (int(i) = (0); (i) < (11111); ++(i)) {
for (int(j) = (2); (j) < (7); ++(j)) {
for (int(k) = (0); (k) < (g_lucky.size()); ++(k)) {
if (g_lucky[k] > i) break;
if (!dp_g_lucky[i - g_lucky[k]][j - 1].empty()) {
int len = int(dp_g_lucky[i - g_lucky[k]][j - 1].size());
dp_g_lucky[i][j].push_back(g_lucky[k]);
for (int(tt) = (0); (tt) < (len); ++(tt)) {
dp_g_lucky[i][j].push_back(dp_g_lucky[i - g_lucky[k]][j - 1][tt]);
}
break;
}
}
}
}
for (int(u) = (0); (u) < (T); ++(u)) {
cin >> x;
if (x < 11111) {
if (dp_g_lucky[x][6].empty())
cout << "-1" << endl;
else {
for (int(i) = (0); (i) < (6); ++(i)) cout << dp_g_lucky[x][6][i] << " ";
cout << endl;
}
continue;
}
n1 = x % 4000;
if (!little_lucky[n1]) {
n1 += 4000;
}
n2 = x - n1;
for (int(i) = (0); (i) < (6); ++(i)) ans[i] = dp_lucky[n1][6][i];
for (int(i) = (0); (i) < (6); ++(i)) t_ans[i] = 0LL;
stk = n2 / 4000;
pot10 = 1LL;
for (int(j) = (0); (j) < (15); ++(j)) {
tmp = stk % 10;
stk /= 10;
if (tmp <= 6) {
for (int(i) = (0); (i) < (tmp); ++(i)) t_ans[i] += 4 * pot10;
} else {
for (int(i) = (0); (i) < (4); ++(i)) t_ans[i] += 7 * pot10;
for (int(i) = (0); (i) < (tmp - 7); ++(i)) t_ans[i + 4] += 4 * pot10;
}
pot10 *= 10;
}
for (int(i) = (0); (i) < (6); ++(i)) ans[i] += 1000 * t_ans[i];
for (int(i) = (0); (i) < (6); ++(i)) {
cout << ans[i] << " ";
}
cout << endl;
}
return 0;
}
| 11 |
CPP
|
a, b = map(int, input().split())
c, s = a, 0
while a >= b:
s += a // b
a = (a // b) + (a % b)
print(s + c)
| 7 |
PYTHON3
|
x, y=[int(x) for x in input().split()]
b=0
h=0
while x>0:
x-=1
b+=1
if b==y:
b=0
x+=1
h+=1
print(h)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000 * 1000 * 1000 + 7;
const int INF = 1e9 + 100;
const long long LINF = 1e18 + 100;
int32_t main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
int a, b;
cin >> a >> b;
int x = 0, ans = 0;
while (a) {
ans += a;
x += a;
a = x / b;
x %= b;
}
cout << ans << '\n';
return 0;
}
| 7 |
CPP
|
a, b = map(int, input().split())
hrs = a
melt = a
while (melt >= b):
hrs += melt // b
melt = melt % b + melt // b
print(hrs)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b, n = 0, i;
scanf("%d%d", &a, &b);
n = a;
for (i = 0; a / b != 0; i++) {
n += a / b;
a = a / b + a % b;
}
printf("%d\n", n);
return 0;
}
| 7 |
CPP
|
import math
n , m =map(int,input().split())
s = n
l = n
while n>0:
n = math.floor(l/m)
l = l%m + n
s+=n
print(s)
| 7 |
PYTHON3
|
n,m=[int(i) for i in input().split()]
c=n
d=0
while(True):
x=n//m
c+=x
n=x+(n%m)
if(n<m):
break
print(c)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int cnt = a;
while (a >= b) {
cnt += (a / b);
int x = (a % b);
a = a / b + x;
}
cout << cnt;
}
| 7 |
CPP
|
a,b=map(int,input().split())
r=l=0
while a:r+=a;a,l=(a+l)//b,(a+l)%b
print(r)
| 7 |
PYTHON3
|
a, b = [int(i) for i in input().split()]
res = 0
k = 0
while a > 0:
res += a
a, k = (a + k) // b, (a + k) % b
print(res)
| 7 |
PYTHON3
|
import sys
# from collections import deque
# from collections import Counter
# from math import sqrt
from math import log
# from math import ceil
# from bisect import bisect_left, bisect_right
# alpha=['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# mod=10**9+7
# mod=998244353
# def BinarySearch(a,x):
# i=bisect_left(a,x)
# if(i!=len(a) and a[i]==x):
# return i
# else:
# return -1
# def sieve(n):
# prime=[True for i in range(n+1)]
# p=2
# while(p*p<=n):
# if (prime[p]==True):
# for i in range(p*p,n+1,p):
# prime[i]=False
# p+=1
# prime[0]=False
# prime[1]=False
# s=set()
# for i in range(len(prime)):
# if(prime[i]):
# s.add(i)
# return s
def gcd(a, b):
if(a==0):
return b
return gcd(b%a,a)
fast_reader=sys.stdin.readline
fast_writer=sys.stdout.write
def input():
return fast_reader().strip()
def print(*argv):
fast_writer(' '.join((str(i)) for i in argv))
fast_writer('\n')
#____________________________________________________________________________________________________________________________________
a,b=map(int, input().split())
ans=a+(a-1)//(b-1)
print(ans)
| 7 |
PYTHON3
|
a, b = map(int, input().split())
t = 0
u = 0
while True:
u += a
t += a
a = u // b
u -= a*b
if a == 0:
print(t)
break
| 7 |
PYTHON3
|
(a,b)=map(int,input().split())
print((a*b-1)//(b-1))
| 7 |
PYTHON3
|
a, b = [int(x) for x in input().split()]
ans = a + (a - 1)//(b - 1)
print(ans)
| 7 |
PYTHON3
|
n,m= map(int, input().split())
cnt=0
cnt+=n
while(int(n/m)!=0):
cnt+=int(n/m)
#print(cnt)
n=int(n/m)+(n%m)
print(cnt)
| 7 |
PYTHON3
|
n=input().split()
a=int(n[0])
b=int(n[1])
x=0
y=0
while 1<=a<=1000 and 2<=b<=1000:
x=x+1
a=a-1
y=y+1
if y==b:
a=a+1
y=0
print(x)
| 7 |
PYTHON3
|
a,b=map(int,input().split());print(a+(a-1)//(b-1))
| 7 |
PYTHON3
|
a,b=map(int,input().split())
c=a
while(True):
x=a//b
c=c+x
a=x+(a%b)
if(a<b):
break
print(c)
| 7 |
PYTHON3
|
a,b=map(int,input().split())
c,d=0,0
while(a>0):
c=c+a
d=d+a
a=d//b
d=d%b
print(c)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, x, count = 0;
cin >> n >> x;
count += n;
while (n >= x) {
count += n / x;
n = n / x + n % x;
}
cout << count << endl;
return 0;
}
| 7 |
CPP
|
def main():
a,b = input().split()
a,b = int(a),int(b)
i =1
while i <= a:
if i%b == 0:
a += 1
i +=1
print(a)
if __name__ == "__main__" : main()
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int ans;
ans = n;
while (n >= m) {
ans += n / m;
n = n % m + n / m;
}
cout << ans << endl;
return 0;
}
| 7 |
CPP
|
a1,b1=input().split()
a=int(a1)
b=int(b1)
count=0
c=0
while c<a:
count=count+1
if count==b:
a=a+1
count=0
c=c+1
print(a)
| 7 |
PYTHON3
|
import sys
import math
input = sys.stdin.readline
def int_array():
return list(map(int, input().strip().split()))
def str_array():
return input().strip().split()
def lower_letters():
lowercase = []
for i in range(97, 97+26):
lowercase.append(chr(i))
return lowercase
def upper_letters():
uppercase = []
for i in range(65, 65+26):
uppercase.append(chr(i))
return uppercase
######################## TEMPLATE ENDS HERE ########################
a,b = int_array()
ans, res = 0,0
while a!=0:
ans += 1
res += 1
if res == b:
res = 0
a+=1
a -= 1
print(ans)
| 7 |
PYTHON3
|
a,b=map(int,input().split())
s=a
while(a//b):
s+=a//b
a=a//b +a%b
print(s)
| 7 |
PYTHON3
|
x,y=[int(x) for x in input().split()]
acu=x
while x>=y:
x=x-y
acu+=1
x=x+1
print(acu)
| 7 |
PYTHON3
|
import math
a,b=map(int,input().split())
hours=a
if a>=b:
new_candles=a
while new_candles>=b:
if math.floor(new_candles / b)==new_candles/b:
new_candles = math.floor(new_candles / b)
hours+=new_candles
else:
x = new_candles % b
new_candles = math.floor(new_candles / b)
hours += new_candles
new_candles+=x
print(hours)
else:
print(hours)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int k = n;
int f = n;
while (f >= m) {
k += f / m;
f = f % m + f / m;
}
cout << k;
return 0;
}
| 7 |
CPP
|
a,b = map(int,input().split())
res = a
rem = 0
while a > 0:
a += rem
s = a // b
res += s
rem = a % b
a = s
print(res)
| 7 |
PYTHON3
|
info = input().split()
a,b = [int(i) for i in info]
used = a
while a >= b:
new = a//b
a = a//b + a - a//b*b
used += new
print (used)
| 7 |
PYTHON3
|
numbers = [int(i)for i in input().split()]
a = numbers[0]
b = numbers[1]
remain = 0
candles = a
worn = 0
total = 0
while True:
hours = candles
total+=hours
if hours==0:
break
worn = candles+remain
candles = 0
hours = 0
candles = worn//b
remain = worn%b
print(total)
| 7 |
PYTHON3
|
a, b = map(int, input().split())
h = a
while a >= b:
h += a // b
a = a // b + a % b
print(h)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int a, b, sum, x;
int main() {
cin >> a >> b;
while (a) {
sum += a;
x += a % b;
a /= b;
a += x / b;
x %= b;
}
cout << sum;
return 0;
}
| 7 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int ms[100005];
int main() {
int a, b;
cin >> a >> b;
int ans = a;
int tmp;
while (true) {
int new_s = a / b;
ans += new_s;
a = new_s + (a % b);
if (a < b) break;
}
cout << ans << endl;
return 0;
}
| 7 |
CPP
|
from math import *
a, b = map(int, input().split())
print(floor(a * (1 / (1 - 1 / b)) - 1e-5))
| 7 |
PYTHON3
|
a, b = map(int, input().split(' '))
res = 0
q = 0
while (a+q) >= b:
# print(a, q)
res += a #dot
went = a + q #xac nen
a = went // b #nau lai nen
q = went % b #thua nen khong nau duoc
print(res+a)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b, sum = 0, c;
scanf("%d%d", &a, &b);
sum = a;
while (1) {
c = a / b;
a = c + (a % b);
sum += c;
if (a < b) break;
}
printf("%d\n", sum);
return 0;
}
| 7 |
CPP
|
a, b = map(int,input().split())
t = a
r = 0
while (a + r) >= b:
a, r = (a + r) // b, (a + r) % b
t += a
print(t)
| 7 |
PYTHON3
|
candles, reforge = map(int, input().split())
def candl(number, devider):
result = number
while number >= devider:
left_behind = number % devider
number = number // devider
result += number
number += left_behind
return result
print(candl(candles, reforge))
| 7 |
PYTHON3
|
if __name__ == "__main__":
ab = input().split()
a = int(ab[0])
b = int(ab[1])
result = a
debris = a
while debris >= b:
result += int(debris / b)
debris = int(debris / b) + debris % b
print(result)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, count = 0;
cin >> a >> b;
count += a;
while (a / b > 0) {
count += (a / b);
a = (a / b) + (a % b);
}
cout << count;
return 0;
}
| 7 |
CPP
|
ab = input().split()
a = int(ab[0])
b = int(ab[1])
def totCandles(a, b):
tot = a
rem = 0
while(a >= b):
newCandle = int(a / b)
tot = tot + newCandle
rem = rem + (a % b)
a = newCandle
rem = rem + a
# for remains
while rem >= b:
more = int(rem / b)
tot = tot + more
rem = more + (rem % b)
return tot
total = totCandles(a, b)
print(total)
| 7 |
PYTHON3
|
a, b = list(map(int, input().split()))
count = a
while a >= b:
remaining = a // b
count += remaining
remainder = a % b
a = remaining + remainder
print(count)
| 7 |
PYTHON3
|
import math
a,b = [int(x) for x in input().strip().split()]
def recur(can):
if can<1:
return can
else:
return can + recur(can/b)
val = recur(a)
print(str(math.floor(val)))
| 7 |
PYTHON3
|
a,b = [int(x) for x in input().split()]
answer = last = a
while last >= b:
answer += last//b
last = last//b + last%b
print (answer)
| 7 |
PYTHON3
|
a, b = map(int, input().split())
ans = 0
while a >= b:
ans += (a - a % b)
a = a % b + a // b
if a != 0:
ans += a
print(ans)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b, h = 0, r = 0;
scanf("%d %d", &a, &b);
while (a > 0) {
h += a;
r += a % b;
a = a / b;
while (r >= b) {
a++;
r -= b;
}
}
printf("%d\n", h);
}
| 7 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, sum = 0, t = 0;
cin >> a >> b;
while (a) {
if (++t % b != 0) a--;
sum++;
}
cout << sum << endl;
return 0;
}
| 7 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, e, g, s;
cin >> n >> m;
s = n;
while (1) {
e = n % m;
g = n / m;
s += g;
g += e;
n = g;
if (g < m) {
break;
}
}
cout << s;
}
| 7 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
cin >> a >> b;
int s = a;
while (a >= b) {
s = s + (a / b);
a = a / b + (a % b);
}
cout << s << endl;
}
| 7 |
CPP
|
s=input().split()
a=int(s[0])
b=int(s[1])
sisa=0
new=a
ini=0
while new!=0:
ini+=new
a=new
new=(a+sisa)//b
sisa=(a+sisa)%b
print(ini)
| 7 |
PYTHON3
|
inp = list(map(int,input().split()))
a=inp[0]
b=inp[1]
sumi=a
while(a>0):
sumi=sumi+(a//b)
if(a//b!=0):
a=a//b+(a-(a//b)*b)
else:
a=a//b
print (sumi)
| 7 |
PYTHON3
|
line = input()
a = int(line.split()[0])
b = int(line.split()[1])
res = 0
while (a>0):
if (b<=a):
a-=b-1
res+=b
else:
res+=a
a = 0
print(res)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b, hours = 0, rem = 0;
std::cin >> a >> b;
while (a > 0) {
hours += a;
int d = (a + rem) / b;
rem = (a + rem) % b;
a = d;
}
std::cout << hours << "\n";
}
| 7 |
CPP
|
def get_hours():
candles, partial_count = [int(x) for x in input().split()]
return candles + get_sub_hours(candles, partial_count)
def get_sub_hours(candles, partial_count):
additional_candles = int(candles / partial_count)
additional_remainder = candles % partial_count
additional_total = additional_candles + additional_remainder
if additional_total >= partial_count:
return additional_candles + get_sub_hours(additional_total, partial_count)
return additional_candles
if __name__ == '__main__':
print(get_hours())
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int a, b;
int old;
int leftold;
int hours;
int main() {
scanf("%d %d", &a, &b);
hours = a;
old = a / b;
leftold = a;
while (!(old == 0 && leftold < b)) {
leftold %= b;
while (old > 0) {
hours += old;
leftold += old % b;
old /= b;
}
old = leftold / b;
}
printf("%d\n", hours);
return 0;
}
| 7 |
CPP
|
line = input().split(" ")
a = int(line[0])
b = int(line[1])
c = a
cnt = 0
while c > 0:
c -= 1
cnt += 1
if cnt % b == 0:
c += 1
print(cnt)
| 7 |
PYTHON3
|
x, k = map(int, input().split())
print(int(x * k / (k - 1) - 1 / 10 ** 10))
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int numb1, numb2;
scanf("%d%d", &numb1, &numb2);
int temp1, temp2;
int sum = 0;
for (int i = 1; i <= 100; i++) {
temp1 = numb1 / numb2;
temp2 = numb1 % numb2;
sum = sum + numb2 * temp1;
numb1 = temp1 + temp2;
}
printf("%d", sum + temp2);
return 0;
}
| 7 |
CPP
|
a , b = map(int, input().split())
def f(x, y):
if x < y: return x
return y * (x // y) + f(x - y * (x // y) + (x // y), y)
print(f(a, b))
| 7 |
PYTHON3
|
a, b=map(int,input().split())
n=0
while a>0.1:
n+=a
a=a/b
print(int(n))
| 7 |
PYTHON3
|
a,b=map(int, input().split())
c=0
count=0
while a>0:
count+=1
c+=1
a-=1
if(c==b):
a=a+1
c=c-b
print(count)
| 7 |
PYTHON3
|
a, b = map(int, input().split())
c = 0
ans = 0
while a > 0:
ans += a
c += a
a = c // b
c %= b
print(ans)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b, sum, aa;
while (~scanf("%d %d", &a, &b)) {
sum = 0;
aa = a;
while (a >= b) {
sum += a / b;
a = a % b + a / b;
}
printf("%d\n", aa + sum);
}
}
| 7 |
CPP
|
a, b = map(int, input().split())
r = 0
res = 0
while(True):
a = a - 1
res = res + 1
r = r + 1
if(r >= b):
r = r - b
a = a + 1
if a == 0: break
print(res)
| 7 |
PYTHON3
|
#include <bits/stdc++.h>
int main() {
int a, b;
scanf("%d%d", &a, &b);
int ans = a;
while (a / b != 0) {
ans += a / b;
a = a / b + a % b;
}
printf("%d\n", ans);
return 0;
}
| 7 |
CPP
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
scanf("%d%d", &a, &b);
int temp;
temp = a;
while (a >= b) {
temp = temp + (a / b);
a = (a / b) + (a % b);
}
printf("%d\n", temp);
return 0;
}
| 7 |
CPP
|
a,b = [int(i) for i in input().split()]
c = 1
while c <= a:
if c%b == 0:a+=1
c+=1
print(a)
| 7 |
PYTHON3
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.