Codeforces Round

A. Giga Tower

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Giga Tower is the tallest and deepest building in Cyberland. There are 17 777
777 777 floors, numbered from - 8 888 888 888 to 8 888 888 888 . In
particular, there is floor 0 between floor - 1 and floor 1 . Every day,
thousands of tourists come to this place to enjoy the wonderful view.

In Cyberland, it is believed that the number “8” is a lucky number (that’s why
Giga Tower has 8 888 888 888 floors above the ground), and, an integer is
lucky , if and only if its decimal notation contains at least one digit “8”.
For example, 8, - 180, 808 are all lucky while 42, - 10 are not. In
the Giga Tower, if you write code at a floor with lucky floor number, good
luck will always be with you (Well, this round is #278, also lucky, huh?).

Tourist Henry goes to the tower to seek good luck. Now he is at the floor
numbered _a_ . He wants to find the minimum positive integer _b_ , such
that, if he walks _b_ floors higher, he will arrive at a floor with a lucky
number.

Input

The only line of input contains an integer _a_ ( - 10 9 ≤ _a_ ≤ 10 9 ).

Output

Print the minimum _b_ in a line.

Sample test(s)

input

output

input

-1

output

input

output

10







#include <iostream>
#include <algorithm>
#include <iterator>
#include <deque>
#include <vector>
#include <unordered_set>
#include <unordered_map>
#include <set>
#include <valarray>
#include <list>
#include <stack>
#include <array>
#include <iomanip>
#include <map>
#include <string>
#include <queue>
#include <sstream>
#include <iomanip>
#include <fstream>
#include <stdio.h>

using namespace std;

long long  n,m,x;

int check (long long a)
{
    if( a < 0 )
             a = -a;
    while ( a )
    {
        if (a % 10 == 8 )
            return 1 ;
        a /= 10;
    }
    return 0;
}

int main()
{
    while (scanf("%I64d",&n)!=EOF)
    {

        int ans =0 ;
        while (true)
        {
            ans ++;
            n++;
            if (check (n))
            {
                printf("%d\n",ans);
                break;
            }
        }
    }
    return 0;
}

B暴力

http://codeforces.com/contest/488/problem/B

B. Candy Boxes

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

There is an old tradition of keeping 4 boxes of candies in the house in
Cyberland. The numbers of candies are special if their arithmetic mean ,
their median and their range are all equal. By definition, for a set {
_x_ 1 , _x_ 2 , _x_ 3 , _x_ 4 } ( _x_ 1 ≤ _x_ 2 ≤ _x_ 3 ≤ _x_ 4 )
arithmetic mean is

, median is

and range is _x_ 4 - _x_ 1 . The arithmetic mean and median are not
necessary integer. It is well-known that if those three numbers are same,
boxes will create a “debugging field” and codes in the field will have no
bugs.

For example, 1, 1, 3, 3 is the example of 4 numbers meeting the condition
because their mean, median and range are all equal to 2 .

Jeff has 4 special boxes of candies. However, something bad has happened!
Some of the boxes could have been lost and now there are only _n_ ( 0 ≤ _n_
≤ 4 ) boxes remaining. The _i_ -th remaining box contains _a_ _i_ candies.

Now Jeff wants to know: is there a possible way to find the number of candies
of the 4 - _n_ missing boxes, meeting the condition above (the mean, median
and range are equal)?

Input

The first line of input contains an only integer _n_ ( 0 ≤ _n_ ≤ 4 ).

The next _n_ lines contain integers _a_ _i_ , denoting the number of candies
in the _i_ -th box ( 1 ≤ _a_ _i_ ≤ 500 ).

Output

In the first output line, print “ YES “ if a solution exists, or print “ NO
“ if there is no solution.

If a solution exists, you should output 4 - _n_ more lines, each line
containing an integer _b_ , denoting the number of candies in a missing box.

All your numbers _b_ must satisfy inequality 1 ≤ _b_ ≤ 10 6 . It is
guaranteed that if there exists a positive integer solution, you can always
find such _b_ ‘s meeting the condition. If there are multiple answers, you
are allowed to print any of them.

Given numbers _a_ _i_ may follow in any order in the input, not necessary in
non-decreasing.

_a_ _i_ may have stood at any positions in the original set, not necessary on
lowest _n_ first positions .

Sample test(s)

input

2
1
1

output

YES
3
3

input

output

NO

input

output

YES

Note

For the first sample, the numbers of candies in 4 boxes can be 1, 1, 3, 3
. The arithmetic mean, the median and the range of them are all 2 .

For the second sample, it’s impossible to find the missing number of candies.

In the third example no box has been lost and numbers satisfy the condition.

You may output _b_ in any order.

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<math.h>
#include<stdlib.h>
#include<ctype.h>
#include<algorithm>
#include<vector>
#include<string>
#include<queue>
#include<stack>
#include<set>
#include<utility>
#define inf 0x7fffffff

using namespace std;

const int maxn=100+10;

int main()
{
    int n;
    int an[5];
    while (scanf("%d",&n)!=EOF)
    {
        for (int i=1 ;i<=n ;i++) scanf("%d",&an[i]);
        sort(an+1,an+n+1);
        if (n==0)
        {
            printf("YES\n");
            printf("1\n1\n3\n3\n");continue;
        }
        if (n==1)
        {
            int t=2*an[1];
            printf("YES\n");
            printf("%d\n%d\n%d\n",t/2,t/2*3,t/2*3);
            continue;
        }
        if (n==2)
        {
            int flag=0;
            // 1   2
            int t=2*an[1];
            int bn[5];
            bn[1]=an[1],bn[4]=3*bn[1];
            bn[2]=an[2];
            bn[3]=4*bn[1]-bn[2];
            if (bn[2]>=bn[1] && bn[3]>=bn[2] && bn[4]>=bn[3] && bn[4]<=1000000)
            {
                flag=1;
                printf("YES\n");
                printf("%d\n%d\n",bn[3],bn[4]);
                continue;
            }
            // 1   3
            t=2*an[1];
            bn[1]=an[1];
            bn[3]=an[2];
            bn[2]=2*t-bn[3];
            bn[4]=bn[1]+t;
            if (bn[2]>=bn[1] && bn[3]>=bn[2] && bn[4]>=bn[3] && bn[4]<=1000000)
            {
                flag=1;
                printf("YES\n");
                printf("%d\n%d\n",bn[2],bn[4]);
                continue;
            }
            // 1   4
            t=2*an[1];
            bn[1]=an[1];
            bn[4]=bn[1]+t;
            if (an[2]==bn[4])
            {
                bn[2]=bn[1];
                bn[3]=bn[4];
                if (bn[2]>=bn[1] && bn[3]>=bn[2] && bn[4]>=bn[3] && bn[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    printf("%d\n%d\n",bn[2],bn[3]);
                    continue;
                }
            }
            // 2   3
            double cn[5];
            double tt=(double)(an[1]+an[2])/2;
            cn[2]=an[1] ;cn[3]=an[2] ;
            cn[1]=tt/2.0;
            cn[4]=1.5*tt;
            if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
            {
                flag=1;
                printf("YES\n");
                printf("%.0lf\n%.0lf\n",cn[3],cn[4]);
                continue;
            }
            // 2   4
            cn[4]=an[2];
            cn[2]=an[1];
            tt=2.0*cn[4]/3.0;
            cn[1]=tt/2.0;
            cn[3]=2.0*tt-cn[2];
            if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
            {
                flag=1;
                printf("YES\n");
                printf("%.0lf\n%.0lf\n",cn[1],cn[3]);
                continue;
            }
            // 3   4
            cn[3]=an[1];
            cn[4]=an[2];
            tt=2.0*cn[4]/3.0;
            cn[1]=tt/2.0;
            cn[2]=2.0*tt-cn[3];
            if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
            {
                flag=1;
                printf("YES\n");
                printf("%.0lf\n%.0lf\n",cn[1],cn[2]);
                continue;
            }
            if (!flag) printf("NO\n");
        }
        if (n==3)
        {
            // 1   2  3
            double cn[5];
            int flag=0;
            cn[1]=an[1] ;cn[2]=an[2] ;cn[3]=an[3] ;
            double tt=2.0*cn[1];
            cn[4]=1.5*tt;
            if (cn[2]+cn[3]==2.0*tt)
            {
                if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    printf("%.0lf\n",cn[4]);
                    continue;
                }
            }
            // 1   2  4
            cn[1]=an[1] ;cn[2]=an[2] ;cn[4]=an[3];
            tt=2.0*cn[1];
            cn[3]=2.0*tt-cn[2];
            if (2.0*cn[4]==3.0*tt)
            {
                if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    printf("%.0lf\n",cn[3]);
                    continue;
                }
            }
            // 2   3  4
            cn[2]=an[1] ;cn[3]=an[2] ;cn[4]=an[3] ;
            tt=(cn[2]+cn[3])/2.0;
            cn[1]=tt/2.0;
            if (cn[4]*2.0==3.0*tt)
            {
                if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    printf("%.0lf\n",cn[1]);
                    continue;
                }
            }
            // 1   3  4
            cn[1]=an[1] ;cn[3]=an[2] ;cn[4]=an[3] ;
            tt=2.0*cn[1];
            cn[2]=2.0*tt-cn[3];
            if (2.0*cn[4]==3.0*tt)
            {
                if (cn[2]>=cn[1] && cn[3]>=cn[2] && cn[4]>=cn[3] && cn[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    printf("%.0lf\n",cn[2]);
                    continue;
                }
            }
            if (!flag) printf("NO\n");
        }
        if (n==4)
        {
            double tt=2.0*an[1];
            int flag=0;
            if (an[2]+an[3]==2.0*tt && 2.0*an[4]==3.0*tt)
            {
                if (an[2]>=an[1] && an[3]>=an[2] && an[4]>=an[3] && an[4]<=1000000)
                {
                    flag=1;
                    printf("YES\n");
                    continue;
                }
            }
            if (!flag) printf("NO\n");
        }
    }
    return 0;
}