Codeforces Round

http://codeforces.com/contest/486/problem/A

A. Calculating Function

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

For a positive integer _n_ let’s define a function _f_ :

_f_ ( _n_ ) = - 1 + 2 - 3 + .. + ( - 1) _n_ _n_

Your task is to calculate _f_ ( _n_ ) for a given integer _n_ .

Input

The single line contains the positive integer _n_ ( 1 ≤ _n_ ≤ 10 15 ).

Output

Print _f_ ( _n_ ) in a single line.

Sample test(s)

input

output

input

output

-3

Note

_f_ (4) = - 1 + 2 - 3 + 4 = 2

_f_ (5) = - 1 + 2 - 3 + 4 - 5 = - 3

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<string.h>
#include<string.h>
#include<algorithm>

using namespace std;

long long n;


int main ()
{
    while (scanf("%I64d",&n)!=EOF)
    {
        if (n%2 == 0)
            printf("%I64d\n",n/2);
        else
            printf("%I64d\n",(n/2+1)*-1);
    }
    return 0;
}

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

B. OR in Matrix

time limit per test

1 second

memory limit per test

256 megabytes

input

standard input

output

standard output

Let’s define logical _OR_ as an operation on two logical values (i. e. values
that belong to the set {0, 1} ) that is equal to 1 if either or both of
the logical values is set to 1 , otherwise it is 0 . We can define logical
_OR_ of three or more logical values in the same manner:

where

is equal to 1 if some _a_ _i_ = 1 , otherwise it is equal to 0 .

Nam has a matrix _A_ consisting of _m_ rows and _n_ columns. The rows are
numbered from 1 to _m_ , columns are numbered from 1 to _n_ . Element at
row _i_ ( 1 ≤ _i_ ≤ _m_ ) and column _j_ ( 1 ≤ _j_ ≤ _n_ ) is denoted as
_A_ _ij_ . All elements of _A_ are either 0 or 1. From matrix _A_ , Nam
creates another matrix _B_ of the same size using formula:

( _B_ _ij_ is _OR_ of all elements in row _i_ and column _j_ of matrix
_A_ )

Nam gives you matrix _B_ and challenges you to guess matrix _A_ . Although
Nam is smart, he could probably make a mistake while calculating matrix _B_ ,
since size of _A_ can be large.

Input

The first line contains two integer _m_ and _n_ ( 1 ≤ _m_ , _n_ ≤ 100 ),
number of rows and number of columns of matrices respectively.

The next _m_ lines each contain _n_ integers separated by spaces describing
rows of matrix _B_ (each element of _B_ is either 0 or 1 ).

Output

In the first line, print “ NO “ if Nam has made a mistake when calculating
_B_ , otherwise print “ YES “. If the first line is “ YES “, then also
print _m_ rows consisting of _n_ integers representing matrix _A_ that can
produce given matrix _B_ . If there are several solutions print any one.

Sample test(s)

input

2 2
1 0
0 0

output

NO

input

2 3
1 1 1
1 1 1

output

YES
1 1 1
1 1 1

input

2 3
0 1 0
1 1 1

output

YES
0 0 0
0 1 0









#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>


using namespace std;


int A[100][100];
int B[100][100];

int main(int argc, char* argv[])
{
    long long m, n;
    cin >> m >> n;

    for (size_t i = 0; i < m; ++i)
        for (size_t j = 0; j < n; ++j)
            A[i][j] = 1;

    for (size_t i = 0; i < m; ++i)
        for (size_t j = 0; j < n; ++j)
        {
            cin >> B[i][j];

            if (B[i][j] == 0)
            {
                for (size_t k = 0; k < m; ++k)
                    A[k][j] = 0;

                for (size_t k = 0; k < n; ++k)
                    A[i][k] = 0;
            }
        }

    for (size_t i = 0; i < m; ++i)
        for (size_t j = 0; j < n; ++j)
        {
            int a = 0;

            for (size_t k = 0; k < m; ++k)
                a |= A[k][j];

            for (size_t k = 0; k < n; ++k)
                a |= A[i][k];

            if (a != B[i][j])
            {
                cout << "NO\n";
                return 0;
            }
        }

    cout << "YES\n";
    for (size_t i = 0; i < m; ++i)
    {
        for (size_t j = 0; j < n; ++j)
            cout << A[i][j] << " ";
        cout << endl;
    }

    return 0;
}