Submission #692533

---

Source Code Expand

#include<bits/stdc++.h>
//#include<iostream>
//#include<list>
//#include<iomanip>
//#include<vector>
//#include<sstream>
//#include<algorithm>
//#include<stack>
//#include<queue>
//#include<cmath>
//#include<cstring>
//#include<climits>
//#include<map>
//#include<set>
//#include<unordered_set>
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
using namespace std;
#define set_bit(bit,i) ((bit) | (1<<(i)))
#define check_bit(bit,i) (((bit) & (1<<(i))) != 0)
#define clear_bit(bit,i) ((bit) &  (~(1<<(i))))
typedef unsigned long long int ull;
typedef long long int ll;
typedef pair<int,int> PII;
typedef pair<PII,PII> PIII;

typedef pair<ll,ll> PLL;
typedef pair<PLL ,PLL> PLLL;
typedef pair<string,string> PSS;
typedef vector<int> VI;
typedef vector<VI> MATRIX;

ll popcount(ull x)
{
    x = ((x & 0xaaaaaaaaaaaaaaaaUL) >> 1)
        +  (x & 0x5555555555555555UL);
    x = ((x & 0xccccccccccccccccUL) >> 2)
        +  (x & 0x3333333333333333UL);
    x = ((x & 0xf0f0f0f0f0f0f0f0UL) >> 4)
        +  (x & 0x0f0f0f0f0f0f0f0fUL);
    x = ((x & 0xff00ff00ff00ff00UL) >> 8)
        +  (x & 0x00ff00ff00ff00ffUL);
    x = ((x & 0xffff0000ffff0000UL) >> 16)
        +  (x & 0x0000ffff0000ffffUL);
    x = ((x & 0xffffffff00000000UL) >> 32)
        +  (x & 0x00000000ffffffffUL);
    return x;
}

bool isprime(ll n){
    if(n==1) return false;
    if(n==2) return true;
    FOR(i,2,n){
        if(n%i==0){ return false; }
    }
    return true;
}

int par[1000];

int root(int i){
    if(par[i]==i) return i;
    return par[i] = root(par[i]);
}

int unite(int i, int j){
    int x = root(i);
    int y = root(j);
    par[x] = y;
}

// stoi(), to_string()
// cout<<fixed<<setprecision(7)
// sort(t.begin(), t.end(), greater<int>());

// 組合せ
ll c (ll n, ll k, ll m) {
    static ll memo[1000][1000];

    if (memo[n][k]!=0) return memo[n][k];
    else if(n==k)      return memo[n][k]=1;
    else if(k==0)      return memo[n][k]=1;
    else               return memo[n][k]=(c(n-1,k-1,m)+c(n-1,k,m))%m;
}

// 重複組合せ
ll hcomp(ll n, ll k, ll m) {
    return c(k+n-1,k,m);
}

ll mplus(ll x, ll y) {
    return (x+y) % 1000000007L;
}

// x^y % m
ll mpow(ll x, ll y, ll m) {
    x %= m;
    ll result = 1;
    while (y > 0) {
        if (y & 1) result = (result * x) % m;
        x = (x * x) % m;
        y >>= 1;
    }
    return result;
}

// mod inverse 法mにおけるxの逆数
ull minverse(ull x, ull m) {
    return mpow(x, m-2, m);
}

ull s2ull(string s) {
    ull x=0;
    ull n=s.size();
    FOR(i,0,n) {
        x |= (s[n-1-i]=='o'?1:0)<<i;
    }
    return x;
}

ull rshift(ull x, int n) {
    ull o = x & 1;
    x = x>>1;
    x |= o<<(n-1);
    return x;
}

//=============================
int main(void) {
    double m;
    int vv;
    cin>>m;
    m/=1000;
    if(m<0.1){
        vv = 0;
    } else if (m<=5){
        vv = m*10;
    } else if(m<=30){
        vv = m+50;
    } else if(m<=70){
        vv = (m-30)/5 + 80;
    } else if(m>=70){
        vv = 89;
    }
    printf("%02d\n",vv);
    return 0;
}

Submission Info

Judge Result