Submission #1967378
Source Code Expand
/*
cat <<EOF >mistaken-paste
*/
#pragma GCC diagnostic ignored "-Wincompatible-pointer-types"
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#define BIG 2000000007
#define VERYBIG 200000000000007LL
#define MOD 1000000007
typedef uint64_t ull;
typedef int64_t sll;
#define N_MAX 5000
#define M_MAX 1000
#ifdef __cplusplus
#include <queue>
#include <stack>
using namespace std; // I'm NOT gonna use C++ without compro. shit
typedef priority_queue<ull, vector<ull>, greater<ull> > upque123;
typedef priority_queue<ull, vector<ull> > upque321;
typedef priority_queue<sll, vector<sll>, greater<sll> > spque123;
typedef priority_queue<sll, vector<sll> > spque321;
#endif
typedef struct {
int32_t a;
int32_t b;
} hw;
typedef struct {
sll a;
sll b;
} hwll;
typedef struct {
hwll a;
hwll b;
} linell;
typedef struct {
ull s;
ull t;
int32_t c;
} struct_a;
typedef struct {
int32_t from;
int32_t to;
sll cost;
} struct_b;
const hw vector8[8] = {
{-1, -1},
{-1, 0},
{-1, +1},
{ 0, -1},
{ 0, +1},
{+1, -1},
{+1, 0},
{+1, +1}
};
ull n, m;
ull h, w;
ull k;
ull vua, vub, vuc, vud, vue, vuf;
sll vsa, vsb, vsc, vsd, vse, vsf;
long double vra, vrb, vrc;
double vda, vdb, vdc;
size_t slen;
size_t tlen;
char ch, dh;
ull a[N_MAX];
// ull a[M_MAX];
// sll a[N_MAX];
// ull a[N_MAX][M_MAX];
// ull wall[N_MAX][N_MAX];
// double wall[N_MAX][N_MAX];
// ull b[N_MAX];
// ull b[M_MAX];
// sll b[N_MAX];
// ull b[N_MAX][N_MAX];
// sll b[N_MAX][N_MAX];
// ull c[N_MAX];
// ull c[M_MAX];
// sll c[N_MAX];
char s[N_MAX + 1];
// char t[N_MAX + 1];
// char s[N_MAX][M_MAX + 1];
// char t[N_MAX][M_MAX + 1];
// ull alphabets[26];
ull dp[N_MAX];
// sll dp[N_MAX];
// bool dp[N_MAX];
// int32_t dp[N_MAX];
// ull dp[N_MAX + 1][M_MAX + 1];
// ull dp[N_MAX * N_MAX];
// double dp[N_MAX];
// double dp[N_MAX][70][40][30];
// ull dq[N_MAX];
// ull dq[N_MAX + 1][N_MAX + 1];
// sll dq[N_MAX];
// bool dq[N_MAX];
// double dq[N_MAX];
// hwll dp[N_MAX + 1][N_MAX + 1];
// struct_a dp[N_MAX + 1][N_MAX + 1];
// ull dr[N_MAX];
// ull ds[N_MAX];
// sll imos[N_MAX + 5];
// hw arr[N_MAX];
// hwll arr[N_MAX];
// hwll arr[N_MAX * M_MAX];
// hw brr[M_MAX];
// hwll brr[N_MAX];
// linell arr[N_MAX][N_MAX];
// ull bitdp[1 << 8];
// ull digitdp[1001][ 3][ 2];
// pos less carry
// ull digitdp[1001][ 2];
// pos carry
// struct_a arr[N_MAX * 2];
// struct_b brr[N_MAX * 2];
void swap_adj (ull *a, ull *b) {
if (*a != *b) {
ull tmp = *b;
*b = *a;
*a = tmp;
}
return;
}
ull divide (ull a, ull b) {
ull x = MOD - 2;
ull ans = 1;
while (x) {
if (x & 1) ans = (ans * b) % MOD;
b = (b * b) % MOD;
x /= 2;
}
return (a * ans) % MOD;
}
int32_t digits (ull x) {
int32_t i = 1;
while (x >= 10) {
x /= 10;
i++;
}
return i;
}
ull umin (ull x, ull y) {
return (x < y) ? x : y;
}
ull umax (ull x, ull y) {
return (x > y) ? x : y;
}
sll smin (sll x, sll y) {
return (x < y) ? x : y;
}
sll smax (sll x, sll y) {
return (x > y) ? x : y;
}
ull gcd (ull x, ull y) {
if (x < y) {
return gcd(y, x);
} else if (y == 0) {
return x;
} else {
return gcd(y, x % y);
}
}
ull bitpow (ull a, ull x, ull modulo) {
ull result = 1;
while (x) {
if (x & 1) {
result *= a;
result %= modulo;
}
x /= 2;
a = (a * a) % modulo;
}
return result;
}
int32_t targetdig (ull x, int32_t index /* 1-indexed */) {
// static...?
int32_t posmax = digits(x);
if (posmax < index) return -1;
while (posmax > index) {
posmax--;
x /= 10;
}
return x % 10;
}
int32_t charcomp (const char left, const char right) {
if (left < right) {
return -1;
} else if (left > right) {
return +1;
} else {
return 0;
}
}
int32_t pcharcomp (const void *left, const void *right) {
char lval = *(char*)left;
char rval = *(char*)right;
return charcomp(lval, rval);
}
int32_t intcomp (const int32_t left, const int32_t right) {
if (left < right) {
return -1;
} else if (left > right) {
return +1;
} else {
return 0;
}
}
int32_t pintcomp (const void *left, const void *right) {
int lval = *(int*)left;
int rval = *(int*)right;
return intcomp(lval, rval);
}
int32_t ullcomp (const ull left, const ull right) {
if (left < right) {
return -1;
} else if (left > right) {
return +1;
} else {
return 0;
}
}
int32_t pullcomp (const void *left, const void *right) {
ull lval = *(ull*)left;
ull rval = *(ull*)right;
return ullcomp(lval, rval);
}
int32_t sllcomp (const sll left, const sll right) {
if (left < right) {
return -1;
} else if (left > right) {
return +1;
} else {
return 0;
}
}
int32_t psllcomp (const void *left, const void *right) {
sll lval = *(sll*)left, rval = *(sll*)right;
return ullcomp(lval, rval);
}
int32_t hwllfraccomp (const hwll left, const hwll right) {
return ullcomp(left.a * right.b, left.b * right.a);
}
int32_t phwAcomp (const hw *left, const hw *right) {
return intcomp(left->a, right->a);
}
int32_t phwBcomp (const hw *left, const hw *right) {
return intcomp(left->b, right->b);
}
int32_t phwABcomp (const hw *left, const hw *right) {
int32_t x = phwAcomp(left, right);
if (x) return x;
return phwBcomp(left, right);
}
int32_t phwllAcomp (const hwll *left, const hwll *right) {
return sllcomp(left->a, right->a);
}
int32_t phwllBcomp (const hwll *left, const hwll *right) {
return sllcomp(left->b, right->b);
}
int32_t phwllABcomp (const hwll *left, const hwll *right) {
int32_t x = phwllAcomp(left, right);
if (x) return x;
return phwllBcomp(left, right);
}
int32_t phwllrAcBcomp (const hwll *left, const hwll *right) {
int32_t x = -phwllAcomp(left, right);
if (x) return x;
return phwllBcomp(left, right);
}
int32_t phwllBAcomp (const hwll *left, const hwll *right) {
int32_t x = phwllBcomp(left, right);
if (x) return x;
return phwllAcomp(left, right);
}
int32_t pstrAcomp (const struct_a *left, const struct_a *right) {
int32_t x;
if (x = ullcomp(left->t, right->t)) return x;
if (x = ullcomp(left->s, right->s)) return x;
if (x = intcomp(left->c, right->c)) return x;
return 0;
}
int32_t bitlet (char c) {
return (1 << (c - 'a'));
}
ull ullabs (ull a, ull b) {
if (a >= b) {
return a - b;
} else {
return b - a;
}
}
sll sllabs (sll a, sll b) {
if (a >= b) {
return a - b;
} else {
return b - a;
}
}
sll nibutanlobo (bool (*func)(sll arg), sll ok, sll ng) {
while (sllabs(ok, ng) > 1) {
sll med = (ok + ng) / 2;
if (func(med)) {
ok = med;
} else {
ng = med;
}
// printf("debug: [%lld %lld)\n", ok, ng);
}
if (!func(ok)) return ok * 2 - ng;
return ok;
}
bool nextroute (int32_t arr[], int32_t n) {
int32_t i = n - 1;
int32_t j, x;
while (i > 0 && arr[i - 1] > arr[i]) i--;
if (i == 0) return false;
x = n;
for (j = i; j < n; j++) {
if (arr[j] < arr[i - 1]) continue;
if (x == n || arr[x] > arr[j]) x = j;
}
arr[i - 1] ^= arr[x];
arr[x] ^= arr[i - 1];
arr[i - 1] ^= arr[x];
qsort(&arr[i], n - i, sizeof(int32_t), pintcomp);
return true;
}
void printUquotient (ull left, ull right) {
const int32_t digits = 20;
printf("%llu.", left / right);
left %= right;
for (int32_t i = 0; i < digits; i++) {
left *= 10;
printf("%1d", left / right);
left %= right;
}
puts("");
return;
}
void printSquotient (sll left, sll right) {
if (left * right < 0) putchar('-');
printUquotient(sllabs(left, 0), sllabs(right, 0));
return;
}
int bitcount (ull n) {
int result = 0;
while (n) {
if (n & 1) result++;
n /= 2;
}
return result;
}
#ifdef __cplusplus
typedef struct {
int32_t to;
sll cost;
} edge;
typedef pair<sll, int32_t> P;
std::vector<edge> g[N_MAX];
void dijk_init (ull n, struct_b arr[]) {
edge x;
for (int32_t i = 0; i < n; i++) {
x.to = arr[i].to;
x.cost = arr[i].cost;
g[arr[i].from].push_back(x);
}
}
void dijkstra (int s, sll distance[]) {
priority_queue<P, std::vector<P>, greater<P> > que; // (最短距離, 頂点番号)
for (int32_t i = 0; i < n; i++) {
distance[i] = BIG;
}
distance[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
sll v = p.second;
if (distance[v] < p.first) continue;
int32_t maxsize = g[v].size();
for (int32_t i = 0; i < maxsize; i++) {
edge e = g[v][i];
if (distance[e.to] > distance[v] + e.cost) {
distance[e.to] = distance[v] + e.cost;
que.push(P(distance[e.to], e.to));
}
}
}
return;
}
#endif
double distance (sll x1, sll y1, sll x2, sll y2) {
double xdist2, ydist2, origindist, dist;
xdist2 = (x1 - x2) * (x1 - x2);
ydist2 = (y1 - y2) * (y1 - y2);
return sqrt(xdist2 + ydist2);
}
ull solve () {
sll i, j, ki, l;
ull result = 0;
// sll result = 0;
ull maybe = 0;
// sll maybe = 0;
// double result = 0;
// ull sum = 0;
sll sum = 0;
ull item;
ull *dpcell;
// qsortの際には"p"ullcompを使う
const char str[] = "FESTIVAL";
i = 0;
ull bitn = 0;
while (k >> bitn) {
if (bitn == 0) {
for (j = 0; j < 7; j++) {
s[i++] = str[j];
}
} else {
sll basech = (bitn - 1) / 9;
for (j = 6; j > basech; j--) {
s[i++] = str[j];
}
for (j = (1 << ((bitn - 1) % 9)); j; j--) {
s[i++] = str[basech];
}
}
if ((k >> bitn) & 1) {
s[i++] = str[7];
}
bitn++;
}
// printf("%llu\n", result);
// printf("%.12lf\n", result);
puts(s);
return 0;
success:
// puts("YES");
puts("Yes");
// printf("%llu\n", result);
// puts("Alice");
return 0;
fail:
// puts("NO");
// puts("No");
// puts("0");
// puts("-1");
puts("-1 -1 -1");
// puts("Brown");
return 1;
}
int32_t main (void) {
int32_t i, j;
int32_t x, y;
// scanf("%lf", &vda);
// scanf("%lld%lld%lld%lld", &vsa, &vsb, &vsc, &vsd);
// scanf("%llu%llu", &vua, &vub);
// scanf("%llu%llu", &h, &w);
// scanf("%llu%llu", &n, &m);
// scanf("%*llu");
scanf("%llu", &k, &n);
// scanf("%llu%llu", &vua, &vub, &vuc, &vud, &vue);
// scanf("%llu%llu%llu", &vsa, &vsb, &vsc);
// scanf("%s", s);
// scanf("%s", t);
// scanf("%lld%lld", &vsa, &vsb);
// for (i = 0; i < n; i++) {
// scanf("%llu", &a[i]);
// // a[i]--;
// }
// for (i = 0; i < k; i++) {
// scanf("%d", &dp[i]);
// dp[i]--;
// }
// for (i = 0; i < n; i++) {
// scanf("%s", s[i]);
// }
// for (i = 0; i < m; i++) {
// scanf("%s", t[i]);
// }
// for (i = 0; i < h; i++) {
// scanf("%s", s[i]);
// }
// for (i = 0; i < w; i++) {
// scanf("%llu", &b[i]);
// }
// for (i = 0; i < n; i++) {
// scanf("%llu%llu", &a[i], &b[i]);
// }
// for (i = 0; i < h; i++) {
// for (j = 0; j < w; j++) {
// scanf("%llu", &a[i][j]);
// }
// }
solve();
// for (i = 0; i < n; i++) {
// // scanf("%llu%llu", &vua, &vub);
// scanf("%s%s", s, t);
// // scanf("%f%f%f", &vda, &vdb, &vdc);
// // scanf("%s", s);
// solve();
// }
// while (scanf("%llu%llu", &n, &k), n + k) {
// for (i = 0; i < n; i++) {
// scanf("%llu", &a[i]);
// }
// solve();
// }
return 0;
}
Submission Info
Submission Time
2018-01-13 19:27:52+0900
Task
G - FESTIVAL
User
sheyasutaka
Language
C (GCC 5.4.1)
Score
1000
Code Size
11531 Byte
Status
AC
Exec Time
1 ms
Memory
128 KB
Compile Error
./Main.c: In function ‘printUquotient’:
./Main.c:400:9: warning: format ‘%llu’ expects argument of type ‘long long unsigned int’, but argument 2 has type ‘ull {aka long unsigned int}’ [-Wformat=]
printf("%llu.", left / right);
^
./Main.c:404:10: warning: format ‘%d’ expects argument of type ‘int’, but argument 2 has type ‘ull {aka long unsigned int}’ [-Wformat=]
printf("%1d", left / right);
^
./Main.c: In function ‘main’:
./Main.c:559:8: warning: format ‘%llu’ expects argument of type ‘long long unsigned int *’, but argument 2 has type ‘ull * {aka long unsigned int *}’ [-Wformat=]
scanf("%llu", &k, &n);
^
./Main.c:559:8: warning: too many arguments for format [-Wformat-extra-args]
./Main.c:559:2: warning: ignoring return value of ‘scanf’, declared with attribute warn_unused_result [-Wunused-result]
scanf("%llu", &k, &n);
^
Judge Result
Set Name
Sample
All
Score / Max Score
0 / 0
1000 / 1000
Status
Set Name
Test Cases
Sample
example0.txt, example1.txt
All
000.txt, 001.txt, 002.txt, 003.txt, 004.txt, 005.txt, 006.txt, 007.txt, 008.txt, 009.txt, 010.txt, 011.txt, 012.txt, 013.txt, 014.txt, 015.txt, 016.txt, 017.txt, 018.txt, 019.txt, 020.txt, 021.txt, 022.txt, 023.txt, 024.txt, 025.txt, 026.txt, 027.txt, 028.txt, 029.txt, 030.txt, 031.txt, 032.txt, 033.txt, 034.txt, 035.txt, 036.txt, 037.txt, 038.txt, 039.txt, 040.txt, 041.txt, 042.txt, 043.txt, 044.txt, 045.txt, 046.txt, 047.txt, 048.txt, 049.txt, 050.txt, 051.txt, 052.txt, 053.txt, example0.txt, example1.txt
Case Name
Status
Exec Time
Memory
000.txt
AC
1 ms
128 KB
001.txt
AC
1 ms
128 KB
002.txt
AC
1 ms
128 KB
003.txt
AC
1 ms
128 KB
004.txt
AC
1 ms
128 KB
005.txt
AC
1 ms
128 KB
006.txt
AC
1 ms
128 KB
007.txt
AC
1 ms
128 KB
008.txt
AC
1 ms
128 KB
009.txt
AC
1 ms
128 KB
010.txt
AC
1 ms
128 KB
011.txt
AC
1 ms
128 KB
012.txt
AC
1 ms
128 KB
013.txt
AC
1 ms
128 KB
014.txt
AC
1 ms
128 KB
015.txt
AC
1 ms
128 KB
016.txt
AC
1 ms
128 KB
017.txt
AC
1 ms
128 KB
018.txt
AC
1 ms
128 KB
019.txt
AC
1 ms
128 KB
020.txt
AC
1 ms
128 KB
021.txt
AC
1 ms
128 KB
022.txt
AC
1 ms
128 KB
023.txt
AC
1 ms
128 KB
024.txt
AC
1 ms
128 KB
025.txt
AC
1 ms
128 KB
026.txt
AC
1 ms
128 KB
027.txt
AC
1 ms
128 KB
028.txt
AC
1 ms
128 KB
029.txt
AC
1 ms
128 KB
030.txt
AC
1 ms
128 KB
031.txt
AC
1 ms
128 KB
032.txt
AC
1 ms
128 KB
033.txt
AC
1 ms
128 KB
034.txt
AC
1 ms
128 KB
035.txt
AC
1 ms
128 KB
036.txt
AC
1 ms
128 KB
037.txt
AC
1 ms
128 KB
038.txt
AC
1 ms
128 KB
039.txt
AC
1 ms
128 KB
040.txt
AC
1 ms
128 KB
041.txt
AC
1 ms
128 KB
042.txt
AC
1 ms
128 KB
043.txt
AC
1 ms
128 KB
044.txt
AC
1 ms
128 KB
045.txt
AC
1 ms
128 KB
046.txt
AC
1 ms
128 KB
047.txt
AC
1 ms
128 KB
048.txt
AC
1 ms
128 KB
049.txt
AC
1 ms
128 KB
050.txt
AC
1 ms
128 KB
051.txt
AC
1 ms
128 KB
052.txt
AC
1 ms
128 KB
053.txt
AC
1 ms
128 KB
example0.txt
AC
1 ms
128 KB
example1.txt
AC
1 ms
128 KB