Search is not available for this dataset
name
stringlengths 2
112
| description
stringlengths 29
13k
| source
int64 1
7
| difficulty
int64 0
25
| solution
stringlengths 7
983k
| language
stringclasses 4
values |
|---|---|---|---|---|---|
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long MAXN = 500 + 10;
long long a[MAXN][MAXN], c[MAXN][MAXN];
bool isPrime[100 * 1000 + 100];
long long b[100 * 1000];
void findPrimes(long long n) {
for (long long i = 0; i < n; i++) isPrime[i] = true;
isPrime[0] = false;
isPrime[1] = false;
for (long long i = 2; i < n; i++) {
if (isPrime[i]) {
for (long long j = 2 * i; j < n; j += i) {
isPrime[j] = false;
}
}
}
}
int main() {
long long n, m;
long long cnst = 100 * 1000 + 10;
findPrimes(cnst);
long long tmp = 0;
for (long long i = 0; i < cnst; i++) {
if (isPrime[i]) {
b[tmp] = i;
tmp++;
}
}
cin >> n >> m;
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
long long ind = lower_bound(b, b + tmp, a[i][j]) - b;
c[i][j] = (b[ind] - a[i][j]);
}
}
long long minimum = 100 * 1000 * 600;
for (long long i = 0; i < n; i++) {
long long cur = 0;
for (long long j = 0; j < m; j++) cur += c[i][j];
minimum = min(minimum, cur);
}
for (long long j = 0; j < m; j++) {
long long cur = 0;
for (long long i = 0; i < n; i++) {
cur += c[i][j];
}
minimum = min(minimum, cur);
}
cout << minimum << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int M1 = 100030;
const int M2 = 316;
bool pri[M1];
void se() {
int i, j, k;
pri[1] = 1;
for (k = 1, i = 2; i <= M2; i += k, k = 2)
if (!pri[i]) {
for (j = i * i; j < M1; j += i) pri[j] = 1;
}
}
int pr(int n) {
int i, j = 0;
for (i = n;; i++)
if (!pri[i])
return j;
else
j++;
}
int main() {
se();
int i, j, k = 100000, n, m, l, p;
cin >> n >> m;
int a[n][m];
for (i = 0; i < n; i++) {
for (p = 0, j = 0; j < m; j++) {
cin >> l;
a[i][j] = pr(l);
p += a[i][j];
}
k = min(k, p);
}
if (k == 0) {
cout << "0\n";
} else {
for (i = 0; i < m; i++) {
for (l = 0, j = 0; j < n; j++) l += a[j][i];
k = min(k, l);
}
cout << k << "\n";
}
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import bisect
from math import sqrt
maxn = int(1e5 + 50)
isprime = [1 for i in range(maxn+1)]
d = [1E9 for i in range(maxn+1)]
def sieve():
cross_limit = int(sqrt(maxn))
isprime[0] = isprime[1]= 0
for i in range(4, maxn+1, 2):
isprime[i] = 0
for i in range(3, cross_limit+1, 2):
if isprime[i]:
for j in range(i*i, maxn+1, 2*i):
isprime[j] = 0
sieve()
dst = 0
for i in range(maxn, 0, -1):
if isprime[i]: dst = 0
d[i] = min(d[i], dst)
dst += 1
n, m = list(map(int, input().split()))
matrix = [list(map(int, input().split())) for i in range(n)]
rows = (sum(map(lambda x: d[x], matrix[i])) for i in range(n))
column = (sum((d[matrix[i][j]] for i in range(n))) for j in range(m))
print(min(min(rows), min(column)))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int sieve[100005];
vector<int> arr;
int mat[505][505];
long long int bbinary_search(int l, int r, long long int k) {
if (r - l == 1) {
if (arr[l] >= k)
return l;
else
return r;
}
if (r == l) return r;
int mid = (l + r) / 2;
if (arr[mid] > k)
return bbinary_search(l, mid, k);
else if (arr[mid] < k)
return bbinary_search(mid + 1, r, k);
else
return mid;
}
int main() {
for (int i = 2; i < 100005 + 1; ++i) {
if (sieve[i] == 0) {
arr.push_back(i);
for (int j = i + i; j <= 100005; j += i) sieve[j] = i;
}
}
int n, m;
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) cin >> mat[i][j];
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
mat[i][j] = arr[bbinary_search(0, arr.size() - 1, mat[i][j])] - mat[i][j];
}
}
int x = 0, mn = (int)1e9;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
x += mat[i][j];
}
mn = min(x, mn);
x = 0;
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
x += mat[j][i];
}
mn = min(x, mn);
x = 0;
}
cout << mn << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Main1 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//inputs
int n = in.nextInt();
int m = in.nextInt();
int[][]mat = new int[n][m];
int[][]mat1 = new int[n][m];
int [] cnt = new int [n+m];
boolean [] isPrime = new boolean [1000002];
isPrime[0] = isPrime[1] = true;
for(long i=2 ; i*i<=1000001 ; i++){
if(isPrime(i))
for(long j=i ; j*i<=1000001 ; j++)
isPrime[(int)(i*j)]=true;
}
for(int i=0 ; i<n ; i++)
for(int j=0 ; j<m ; j++){
int a = in.nextInt();
mat[i][j] = a;
mat1[i][j] = a;
}
int index=0;
for(int i=0 ; i<n ; i++){
int move=0;
for(int j=0 ; j<m ; j++){
while(isPrime[mat[i][j]] == true){
mat[i][j]++;
move++;
}
}
cnt[index++] = move;
}
for(int j=0 ; j<m ; j++){
int move=0;
for(int i=0 ; i<n ; i++){
while(isPrime[mat1[i][j]] == true){
mat1[i][j]++;
move++;
}
}
cnt[index++]= move ;
}
Arrays.sort(cnt);
System.out.println(cnt[0]);
}
public static boolean isPrime(long n){
for(int i=2 ; i*i<=n ; i++)
if(n % i == 0)
return false;
return true;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | limite = int(10e5)
primos = [True for i in range(limite)]
primos[0] = False
primos[1] = False
for i in range(2,limite):
if primos[i]:
for j in range(i**2, limite, i):
primos[j] = False
distancias = [0 for i in range(limite)]
distancias[0] = 2
distancias[1] = 1
distancias[100000] = 3
for i in range(99999, -1 , -1):
if not primos[i]:
distancias[i] = distancias[i + 1] + 1
entrada = input().split()
n = int(entrada[0])
m = int(entrada[1])
matriz = []
for i in range(n):
entrada = input().split()
matriz.append(list(map(int, entrada)))
menor_passo = limite
for i in range(n):
passos = 0
for j in range(m):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
for j in range(m):
passos = 0
for i in range(n):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
print(menor_passo)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, x = 1e9, y = 1e9, z, a[1000][1000], k, sol, sum, MOD = 10000007,
b[1000005], m;
vector<int> v;
pair<int, int> p[1000000];
map<int, int> ma;
string s1, s2, s;
void getprime() {
b[1] = 1;
for (int i = 2; i <= 1000000; i++) {
if (b[i]) continue;
for (int q = 2 * i; q <= 1000000; q += i) {
b[q] = 1;
}
}
for (int i = 2; i <= 1000000; i++) {
if (b[i] == 0) v.push_back(i);
}
}
int main() {
cin >> n >> m;
getprime();
for (int i = 0; i < n; i++)
for (int q = 0; q < m; q++) cin >> a[i][q];
for (int i = 0; i < n; i++) {
for (int q = 0; q < m; q++) {
if (b[a[i][q]] == 1) {
auto it = lower_bound(v.begin(), v.end(), a[i][q]);
z += *it - a[i][q];
}
}
x = min(x, z);
z = 0;
}
z = 0;
for (int i = 0; i < m; i++) {
for (int q = 0; q < n; q++) {
if (b[a[q][i]] == 1) {
auto it = lower_bound(v.begin(), v.end(), a[q][i]);
z += *it - a[q][i];
}
}
y = min(z, y);
z = 0;
}
cout << min(x, y) << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int a[512][512];
int b[512][512];
int table[512][512];
int sum1[512];
int sum2[512];
int NextPrime[131072];
const int inf = 1 << 30;
int AnswerProblem = inf;
bool IsPrime(int number) {
if (number < 2) {
return false;
}
int sq = sqrt(number), j;
for (j = 2; j <= sq; j++)
if (number % j == 0) return false;
return true;
}
int main() {
cin >> n >> m;
int i, j;
i = 100003;
while (i >= 0) {
if (IsPrime(i))
NextPrime[i] = i;
else
NextPrime[i] = NextPrime[i + 1];
i--;
}
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
cin >> a[i][j];
sum1[i] += NextPrime[a[i][j]] - a[i][j];
sum2[j] += NextPrime[a[i][j]] - a[i][j];
}
for (i = 0; i < n; i++) AnswerProblem = min(AnswerProblem, sum1[i]);
for (j = 0; j < m; j++) AnswerProblem = min(AnswerProblem, sum2[j]);
cout << AnswerProblem << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys, math
MaxN = 100500
np = [0 for i in range (MaxN)]
for i in range (2, MaxN):
j = 2
while j * j <= i:
if i % j == 0:
np[i] = 1
break
j += 1
for j in range (MaxN - 2, 0, -1):
if np[j] == 0:
continue
np[j] = np[j+1] + 1
np[1] = 1
n, m = (int (x) for x in sys.stdin.readline().split())
b = [[0 for j in range(m)] for i in range(n)]
for i in range (n):
b[i] = [np[int(x)] for x in sys.stdin.readline().split()]
resr = min (sum(x) for x in b)
resc = min (sum(x) for x in zip(*b))
print min (resr, resc) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int prime[200000];
int table[505][505];
memset(prime, 0, sizeof prime);
prime[1] = prime[0] = -1;
for (int i = 2; i < 200000; i++)
if (prime[i] == 0)
for (int j = 2 * i; j < 200000; j += i) prime[j] = -1;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &table[i][j]);
}
}
int min = 1 << 30;
int temp = 0;
for (int i = 0; i < n; i++) {
temp = 0;
for (int j = 0; j < m; j++) {
int p = table[i][j];
while (prime[p++] != 0) temp++;
}
min = min < temp ? min : temp;
}
for (int i = 0; i < m; i++) {
temp = 0;
for (int j = 0; j < n; j++) {
int p = table[j][i];
while (prime[p++] != 0) temp++;
}
min = min < temp ? min : temp;
}
printf("%d\n", min);
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.io.*;
import java.util.*;
public class Sample {
static int MAX = (int)(1e6+2);
static int MOD=(int)1e9+7;
static int countt = 0;
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner input = new Scanner(System.in);
ArrayList<Integer>list = new ArrayList<>();
boolean seive[] = new boolean[MAX];
for(int i = 2;i*i<MAX;i++) {
if(!seive[i]) {
for(int j = i*i;j<MAX;j+=i) {
seive[j] = true;
}
}
}
for(int i =2;i<MAX;i++) {
if(!seive[i])list.add(i);
}
int n = input.nextInt();
int m = input.nextInt();
int arr[][] = new int[n][m];
for(int i=0;i<n;i++) {
for(int j =0;j<m;j++) {
arr[i][j] = input.nextInt();
int min = getMin(list,arr[i][j]);
arr[i][j] = min-arr[i][j];
}
}
long rowMin = Long.MAX_VALUE;
long colMin = Long.MAX_VALUE;
for(int i = 0;i<n;i++) {
long rowSum =0;
for(int j =0;j<m;j++) {
rowSum+=arr[i][j];
}
rowMin = Math.min(rowMin, rowSum);
}
for(int i = 0;i<m;i++) {
long colSum =0;
for(int j =0;j<n;j++) {
colSum+=arr[j][i];
}
colMin = Math.min(colMin, colSum);
}
System.out.println(Math.min(colMin, rowMin));
}
public static int getMin(ArrayList<Integer>list,int val) {
int min = 0;
int l = 0;
int r = list.size()-1;
while(l<=r) {
int mid = (l+r)/2;
if(list.get(mid)>=val) {
min = list.get(mid);
r = mid-1;
}else l = mid+1;
}
return min;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
limit = 100025
list_primes = [True for i in range(limit + 1)]
next_primes = [0 for i in range(200000)]
def SieveOfEratosthenes():
list_primes[0] = list_primes[1] = False
for i in range(2, int(math.sqrt(limit))):
if list_primes[i]:
j = 2
while i * j <= limit:
list_primes[i*j] = False
j += 1
def get_next_primes():
for i in range(limit - 1, -1, -1):
if list_primes[i]:
next_primes[i] = 0
else:
next_primes[i] = 1 + next_primes[i+1]
SieveOfEratosthenes()
get_next_primes()
sizes = input().split(' ')
n, m = (int(sizes[0]), int(sizes[1]))
matrix = []
for i in range(0, n):
matrix.append(input().split(' '))
moves = 100000
for index_row in range(n):
best_row = 0
for index_column in range(m):
num = int(matrix[index_row][index_column])
best_row += next_primes[num]
if best_row < moves:
moves = best_row
for index_column in range(m):
best_column = 0
for index_row in range(n):
num = int(matrix[index_row][index_column])
best_column += next_primes[num]
if best_column < moves:
moves = best_column
print(moves)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import string
import math
import heapq
from collections import defaultdict
from collections import deque
from collections import Counter
from functools import lru_cache
from fractions import Fraction
def mi(s):
return map(int, s.strip().split())
def lmi(s):
return list(mi(s))
def tmi(s):
return tuple(mi(s))
def mf(f, s):
return map(f, s)
def lmf(f, s):
return list(mf(f, s))
def js(lst):
return " ".join(str(d) for d in lst)
def jsns(lst):
return "".join(str(d) for d in lst)
def line():
return sys.stdin.readline().strip()
def linesp():
return line().split()
def iline():
return int(line())
def mat(n):
matr = []
for _ in range(n):
matr.append(linesp())
return matr
def matns(n):
mat = []
for _ in range(n):
mat.append([c for c in line()])
return mat
def mati(n):
mat = []
for _ in range(n):
mat.append(lmi(line()))
return mat
def pmat(mat):
for row in mat:
print(js(row))
def prime(n):
primes = [True for _ in range(n + 1)]
primes[0] = False
primes[1] = False
for i in range(2, n + 1):
if i * i > n:
break
if primes[i]:
for j in range(i * i, n + 1, i):
primes[j] = False
p=[]
for e, b in enumerate(primes):
if b:
p.append(e)
return p
primes=prime(10**5+1000)
def dist(num):
lo=0
hi=len(primes)-1
cost=0
while lo<=hi:
if lo == hi:
return primes[lo]-num
elif lo == hi - 1:
if primes[lo]>=num:
return primes[lo]-num
else:
return primes[hi]-num
mid=(lo+hi)//2
if primes[mid]>=num:
hi=mid
else:
lo=mid
def costr(mat, row):
cost = 0
for j in range(len(mat[row])):
cost+=dist(mat[row][j])
return cost
def costj(mat, col):
cost=0
for i in range(len(mat)):
cost+=dist(mat[i][col])
return cost
def main():
n,_=mi(line())
mat=mati(n)
mm=float("inf")
for i in range(len(mat)):
mm=min(mm, costr(mat, i))
for j in range(len(mat[0])):
mm=min(mm, costj(mat, j))
print(mm)
main()
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
public class Forsa271B {
private static boolean[] resheto;
public static void main(String[] args) {
resheto = fillResheto(100004);
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[] rows = new int[n];
int[] columns = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int num = in.nextInt();
//System.out.println("("+j+";"+i+") - "+closestNum(num) + " " +num);
rows[i] += closestNum(num) - num;
columns[j] += closestNum(num) - num;
}
}
/*Arrays.stream(rows).forEach(System.out::println);
Arrays.stream(columns).forEach(System.out::println);*/
System.out.println(min(arrayMin(rows),arrayMin(columns)));
/*int[][] matrix = new int[n1][m1];
for (int i = 0; i < n1; i++) {
for (int j = 0; j < m1; j++) {
int num = in.nextInt();
System.out.println("("+i+";"+j+") - "+closestNum(num) + " " +num);
matrix[i][j] = closestNum(num)-num;
}
}
int[] row = new int[m1];
int[] column = new int[n1];
for (int i = 0; i < n1; i++) {
for (int j = 0; j < m1; j++) {
column[i]+=matrix[i][j];
row[j]+=matrix[i][j];
}
}
for (int i = 0; i < m1; i++) {
System.out.println(row[i]);
}
for (int i = 0; i < n1; i++) {
System.out.println(column[i]);
}
OptionalInt min1 = Arrays.stream(row).reduce((a, b) -> a>b?b:a);
OptionalInt min2 = Arrays.stream(column).reduce((a, b) ->a>b?b:a);
System.out.println(min1.getAsInt()>min2.getAsInt()?min2.getAsInt():min1.getAsInt());
}*/
}
private static int arrayMin(int[] array){
return Arrays.stream(array).reduce(Forsa271B::min).getAsInt();
}
private static int min(int a, int b){
return a>b?b:a;
}
private static boolean[] fillResheto(int number) {
boolean[] arr = new boolean[number];
for (int p = 2; p < number; p++) arr[p] = true;
for (int p = 2; p < number; p++)
if (arr[p]) {
for (int j = 2 * p; j < number; j += p)
arr[j] = false;
}
return arr;
}
private static int closestNum(int num){
while (!resheto[num]){
num++;
}
return num;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int INF = ~(1 << 31);
int M[507][507];
int D[507][507];
bool is_prime(int n) {
if (n < 2) return false;
if (n < 4) return true;
if (n % 2 == 0 || n % 3 == 0) return false;
if (n < 25) return true;
for (int i = 5; i * i <= n; i += 6)
if (n % i == 0 || n % (i + 2) == 0) return false;
return true;
}
int f(int n) {
int p = n;
while (!is_prime(p)) p++;
return p - n;
}
int sum_col(int c, int n) {
int s = 0;
for (int i = 0; i < n; i++) s += D[i][c];
return s;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> M[i][j];
D[i][j] = f(M[i][j]);
}
}
int mn = INF;
for (int i = 0; i < n; i++) mn = min(mn, accumulate(D[i], D[i] + m, 0));
for (int i = 0; i < m; i++) mn = min(mn, sum_col(i, n));
cout << mn << '\n';
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # aadiupadhyay
import os.path
from math import gcd, floor, ceil
from collections import *
import sys
mod = 1000000007
INF = float('inf')
def st(): return list(sys.stdin.readline().strip())
def li(): return list(map(int, sys.stdin.readline().split()))
def mp(): return map(int, sys.stdin.readline().split())
def inp(): return int(sys.stdin.readline())
def pr(n): return sys.stdout.write(str(n)+"\n")
def prl(n): return sys.stdout.write(str(n)+" ")
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def BS(val):
i, j = 0, len(prime)-1
ans = -1
while i <= j:
mid = (i+j)//2
if prime[mid] < val:
i = mid+1
else:
ans = mid
j = mid - 1
return ans
maxN = 10**6
x = [0 for i in range(maxN+1)]
i = 2
while i*i <= maxN:
if not x[i]:
for j in range(i*i, maxN+1, i):
x[j] = 1
i += 1
prime = [i for i in range(2, maxN+1) if not x[i]]
n, m = mp()
ans = INF
d = defaultdict(int)
l = [li() for i in range(n)]
for i in range(n):
now = 0
for j in range(m):
cur = BS(l[i][j])
d[(i, j)] = prime[cur]-l[i][j]
now += prime[cur] - l[i][j]
ans = min(ans, now)
for i in range(m):
now = 0
for j in range(n):
now += d[(j, i)]
ans = min(ans, now)
pr(ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
public class uu {
public static void main(String[] args) throws IOException, InterruptedException {
Scanner sc =new Scanner(System.in);
PrintWriter pw =new PrintWriter(System.out);
int r=sc.nextInt(),c=sc.nextInt();
boolean [] prime =new boolean[(int)1e5+101];
Arrays.fill(prime, true);
for(int p = 2; p*p <=(int)1e5+100; p++)
{
if(prime[p] == true)
{
// Update all multiples of p
for(int i = p*2; i <= (int)1e5+100; i += p)
prime[i] = false;
}
}
int [][] mat =new int [r][c];
for (int i =0;i<r;++i)
for (int j =0;j<c;++j)
mat[i][j]=sc.nextInt();
TreeSet<Integer>ts =new TreeSet<Integer>();
for (int i=2;i<=(int)1e5+100;++i)
if (prime[i])
ts.add(i);
int min =(int)1e9;
for (int i =0;i<r;++i) {
int res=0;
for (int j =0;j<c;++j)
res+=(ts.ceiling(mat[i][j])-mat[i][j]);
min=Math.min(min, res);
}
for (int i= 0;i<c;++i) {
int res =0;
for (int j =0;j<r;++j)
res+=(ts.ceiling(mat[j][i])-mat[j][i]);
min =Math.min(min, res);
}
pw.println(min);
pw.flush();
}
static int mod(int x,int y)
{
if(x<0)
x=x+(-x/y+1)*y;
return x%y;
}
static long gcd(long a, long b)
{
if (a == 0)
return b;
return gcd(b % a, a);
}
static class Scanner {
StringTokenizer stringTokenizer;
BufferedReader bfBufferedReader;
public Scanner(InputStream system) {
bfBufferedReader=new BufferedReader(new InputStreamReader( system));
}
public Scanner(String file) throws Exception {
bfBufferedReader = new BufferedReader(new FileReader( file));
}
public String next() throws IOException {
while (stringTokenizer == null || !stringTokenizer.hasMoreTokens())
stringTokenizer = new StringTokenizer( bfBufferedReader.readLine());
return stringTokenizer.nextToken();
}
public String nextLine() throws IOException {
return bfBufferedReader.readLine();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public char nextChar() throws IOException {
return next().charAt(0);
}
public Long nextLong() throws IOException {
return Long.parseLong(next());
}
public boolean ready() throws IOException {
return bfBufferedReader.ready();
}
public void waitForInput() throws InterruptedException {
Thread.sleep(3000);
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | n,m=map(int,input().split())
limit=int(1e5+2)
l=[1,1]+[0]*limit
for i in range(2,limit):
if not l[i]:
l[i*i::i]=[1]*((limit-i*i)//i+1)
for i in range(limit,-1,-1):
l[i]*=l[i+1]+1
s=[[l[j] for j in map(int,input().split())] for _ in ' '*n]
print(min(min(sum(i) for i in s),min(sum(i) for i in zip(*s)))) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.BufferedOutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
import java.util.List;
public class Main {
public static void main(String[] args) {
if (args.length > 0 && args[0].toLowerCase().equals("local")) {
try {
System.setIn(new FileInputStream("input.txt"));
System.setOut(new PrintStream(new File("output.txt")));
} catch (IOException exc) {
}
}
Task task = new Task();
task.solve();
}
public static class Task {
static final long MOD = (long) 1e9 + 7;
static final PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
public void solve() {
try {
Scan sc = new Scan();
int n = (int) sc.scanLong();
int m = (int) sc.scanLong();
int mx = 1000000;
int[] sieve = new int[mx];
sieve[0] = 1;
sieve[1] = 1;
List<Integer> primes = new ArrayList<>();
for (int i = 2; i < mx; ++i) {
if (sieve[i] == 0) {
primes.add(i);
for (long j = i * (long) i; j < mx; j += i) {
sieve[(int) j] = 1;
}
}
}
int[][] grid = new int[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
grid[i][j] = (int) sc.scanLong();
}
}
int[][] need = new int[n][m];
Integer[] primes_ = primes.toArray(new Integer[primes.size()]);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int got = Arrays.binarySearch(primes_, grid[i][j]);
if (got >= 0)
continue;
got += 1;
got *= -1;
need[i][j] = primes_[got] - grid[i][j];
}
}
long ans = Long.MAX_VALUE;
for (int i = 0; i < n; ++i) {
long rowSum = 0;
for (int j = 0; j < m; ++j) {
rowSum += need[i][j];
}
if (rowSum < ans) {
ans = rowSum;
}
}
for (int i = 0; i < m; ++i) {
long colSum = 0;
for (int j = 0; j < n; ++j) {
colSum += need[j][i];
}
if (colSum < ans) {
ans = colSum;
}
}
out.println(ans);
} finally {
out.close();
}
}
private void debug(Object... x) {
StringBuilder sb = new StringBuilder();
for (Object o : x)
sb.append(String.valueOf(o)).append(" ");
out.println(sb);
}
}
public static class Scan {
private byte[] buf = new byte[1024];
private int index;
private InputStream in;
private int total;
public Scan() {
in = System.in;
}
public int scan() {
if (total < 0)
throw new InputMismatchException();
if (index >= total) {
index = 0;
try {
total = in.read(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
if (total <= 0)
return -1;
}
return buf[index++];
}
public long scanLong() {
long integer = 0;
int n = scan();
while (isWhiteSpace(n))
n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
integer *= 10;
integer += n - '0';
n = scan();
} else
throw new InputMismatchException();
}
return neg * integer;
}
public double scanDouble() {
double doub = 0;
int n = scan();
while (isWhiteSpace(n))
n = scan();
int neg = 1;
if (n == '-') {
neg = -1;
n = scan();
}
while (!isWhiteSpace(n) && n != '.') {
if (n >= '0' && n <= '9') {
doub *= 10;
doub += n - '0';
n = scan();
} else
throw new InputMismatchException();
}
if (n == '.') {
n = scan();
double temp = 1;
while (!isWhiteSpace(n)) {
if (n >= '0' && n <= '9') {
temp /= 10;
doub += (n - '0') * temp;
n = scan();
} else
throw new InputMismatchException();
}
}
return doub * neg;
}
public String scanString() {
StringBuilder sb = new StringBuilder();
int n = scan();
while (isWhiteSpace(n))
n = scan();
while (!isWhiteSpace(n)) {
sb.append((char) n);
n = scan();
}
return sb.toString();
}
public char scanChar() {
int n = scan();
while (isWhiteSpace(n))
n = scan();
return (char) n;
}
private boolean isWhiteSpace(int n) {
if (n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1)
return true;
return false;
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int p[100005];
vector<int> v;
void sieve() {
v.push_back(2);
for (int i = 3; i < 100005; i += 2)
if (!p[i]) {
v.push_back(i);
for (int j = 2 * i; j < 100005; j += i) p[j] = 1;
}
p[1] = p[2] = 2;
int k = 1;
for (int i = 3; i < 100005; i++) {
if (p[i] || i % 2 == 0)
p[i] = v[k];
else {
p[i] = v[k];
k++;
}
}
}
int a[100005], b[100005];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sieve();
int n, m, x, k;
cin >> n >> m;
int mn = 100005;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
if (p[x] != x) {
a[i] += (p[x] - x);
b[j] += (p[x] - x);
}
}
mn = min(mn, a[i]);
}
for (int i = 0; i < m; i++) {
mn = min(mn, b[i]);
}
cout << mn << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 1e5 + 100 + 19, N = 500 + 19;
int pp[Maxn], A[N][N], sum[N][N];
int n, m, x, Ans = (1 << 30) - 1;
int main() {
scanf("%d%d", &n, &m);
for (int i = 2; i < Maxn; i++)
if (!pp[i])
for (long long j = 1LL * i * i; j < Maxn; j += i) pp[j] = 1;
pp[1] = 1;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &x);
int y = x;
while (pp[y]) y++;
y -= x;
A[i][j] = y;
}
for (int i = 1; i <= n; i++) {
int tmp = 0;
for (int j = 1; j <= m; j++) tmp += A[i][j];
if (tmp < Ans) Ans = tmp;
}
for (int i = 1; i <= m; i++) {
int tmp = 0;
for (int j = 1; j <= n; j++) tmp += A[j][i];
if (tmp < Ans) Ans = tmp;
}
printf("%d\n", Ans);
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class PrimeMatrix {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
boolean prime[] = new boolean[100004];
for (int i = 2; i < 50003; i++) {
for (int j = 2; i * j < 100004; j++) {
prime[(i * j) - 1] = true;
}
}
prime[0] = true;
prime[1] = false;
int n = in.nextInt(), m = in.nextInt(), sum = 0, sum2 = 0, min = 99999, x;
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
x = in.nextInt();
while (prime[x - 1]) {
sum++;
x++;
a[i][j]++;
}
}
min = Math.min(min, sum);
}
for (int i = 0; i < m; i++) {
sum2 = 0;
for (int j = 0; j < n; j++) {
sum2 += a[j][i];
}
min = Math.min(min, sum2);
}
System.out.println(min);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, a[505][505], cost[505][505], idx, ans = 1e9, sum, k;
bool u[1000000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
u[1] = 1;
for (int i = 2; i <= 100000; i++) {
if (!u[i]) {
for (int j = i * 2; j <= 200000; j += i) u[j] = 1;
}
}
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
k = 0;
while (1) {
if (!u[a[i][j] + k]) break;
k++;
}
cost[i][j] = k;
}
for (int i = 1; i <= n; i++) {
sum = 0;
for (int j = 1; j <= m; j++) sum += cost[i][j];
ans = min(ans, sum);
}
for (int j = 1; j <= m; j++) {
sum = 0;
for (int i = 1; i <= n; i++) sum += cost[i][j];
ans = min(ans, sum);
}
cout << ans;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.OutputStreamWriter;
import java.io.BufferedWriter;
import java.util.Locale;
import java.io.OutputStream;
import java.util.RandomAccess;
import java.io.PrintWriter;
import java.util.AbstractList;
import java.io.Writer;
import java.util.List;
import java.io.IOException;
import java.util.Arrays;
import java.math.BigDecimal;
import java.util.InputMismatchException;
import java.math.BigInteger;
import java.util.Collections;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Jacob Jiang
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
private int[] prime = NumberUtils.generatePrimeTable((int) 1e5 + 50);
private int calc(int x) {
return prime[ArrayUtils.lowerBound(prime, x)] - x;
}
public void solve(int testNumber, InputReader in, OutputWriter out) {
int height = in.nextInt();
int width = in.nextInt();
int[][] a = in.next2DIntArray(height, width);
long[] row = new long[height];
long[] col = new long[width];
for (int i = 0; i < height; i++) {
for (int j = 0; j < width; j++) {
a[i][j] = calc(a[i][j]);
row[i] += a[i][j];
col[j] += a[i][j];
}
}
out.println(Math.min(ArrayUtils.min(row), ArrayUtils.min(col)));
}
}
class NumberUtils {
public static int[] generatePrimeTable(int num) {
return generateBothPrime(num).second;
}
public static Pair<boolean[], int[]> generateBothPrime(int num) {
boolean[] isPrime = generateIsPrime(num);
IntArrayBuilder builder = new IntArrayBuilder();
for (int i = 0; i < isPrime.length; i++) {
if (isPrime[i])
builder.append(i);
}
return Pair.makePair(isPrime, builder.toIntArray());
}
public static boolean[] generateIsPrime(int num) {
if (num < 0) throw new IllegalArgumentException();
if (num == 1) return new boolean[]{false, false};
boolean[] isPrime = new boolean[num + 1];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i <= num; i++) {
if (isPrime[i]) {
for (int j = i * i; j <= num; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
}
class ArrayUtils {
public static long min(long[] array) {
if (array.length == 0) {
throw new IllegalArgumentException();
}
long result = array[0];
for (int i = 1; i < array.length; i++) {
result = Math.min(result, array[i]);
}
return result;
}
// min i thar array[i] >= val
public static int lowerBound(int[] array, int val) {
int n = array.length;
if (array[n - 1] < val)
return n;
int left = 0, right = n - 1;
while (left < right) {
int mid = (left + right) / 2;
if (array[mid] >= val)
right = mid;
else
left = mid + 1;
}
return left;
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1 << 16];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c & 15;
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public static boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public int[] nextIntArray(int count) {
int[] result = new int[count];
for (int i = 0; i < count; i++) {
result[i] = nextInt();
}
return result;
}
public int[][] next2DIntArray(int n, int m) {
int[][] result = new int[n][];
for (int i = 0; i < n; i++) {
result[i] = nextIntArray(m);
}
return result;
}
}
class OutputWriter {
private PrintWriter writer;
public OutputWriter(OutputStream stream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(stream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void println(long x) {
writer.println(x);
}
public void close() {
writer.close();
}
}
class IntArrayBuilder {
int[] data;
int length;
int capacity;
public IntArrayBuilder() {
this(16);
}
public IntArrayBuilder(int initialCapacity) {
this.capacity = initialCapacity;
length = 0;
data = new int[initialCapacity];
}
private void ensureCapacity(int neededCapacity) {
while (neededCapacity > capacity) {
capacity = (capacity << 1) + 1;
}
if (data.length < capacity) {
data = Arrays.copyOf(data, capacity);
}
}
public IntArrayBuilder append(int item) {
ensureCapacity(length + 1);
data[length++] = item;
return this;
}
public int[] toIntArray() {
return Arrays.copyOf(data, length);
}
}
class Pair<A,B> implements Comparable<Pair<A, B>> {
public final A first;
public final B second;
public Pair(A first, B second) {
this.first = first;
this.second = second;
}
public static <A, B> Pair<A, B> makePair(A first, B second) {
return new Pair<A, B>(first, second);
}
public int compareTo(Pair<A, B> anotherPair) {
//noinspection unchecked
int result = ((Comparable<A>)first).compareTo(anotherPair.first);
if (result != 0) {
return result;
}
//noinspection unchecked
return ((Comparable<B>)second).compareTo(anotherPair.second);
}
public String toString() {
return "(" + first + ", " + second + ")";
}
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Pair pair = (Pair) o;
if (first != null ? !first.equals(pair.first) : pair.first != null) return false;
if (second != null ? !second.equals(pair.second) : pair.second != null) return false;
return true;
}
public int hashCode() {
int result = first != null ? first.hashCode() : 0;
result = 31 * result + (second != null ? second.hashCode() : 0);
return result;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import static java.lang.Math.*;
public class Start {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
void init() throws FileNotFoundException {
if (ONLINE_JUDGE) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
}
String readString() throws IOException {
while (!tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException {
return Integer.parseInt(readString());
}
long readLong() throws IOException {
return Long.parseLong(readString());
}
double readDouble() throws IOException {
return Double.parseDouble(readString());
}
public static void main(String[] args) {
new Start().run();
// Sworn to fight and die
}
public static void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
final int MAGIC_VALUE = 50;
if (levtIndex < rightIndex) {
if (rightIndex - levtIndex <= MAGIC_VALUE) {
insertionSort(a, levtIndex, rightIndex);
} else {
int middleIndex = (levtIndex + rightIndex) / 2;
mergeSort(a, levtIndex, middleIndex);
mergeSort(a, middleIndex + 1, rightIndex);
merge(a, levtIndex, middleIndex, rightIndex);
}
}
}
private static void merge(int[] a, int levtIndex, int middleIndex,
int rightIndex) {
int length1 = middleIndex - levtIndex + 1;
int length2 = rightIndex - middleIndex;
int[] levtArray = new int[length1];
int[] rightArray = new int[length2];
System.arraycopy(a, levtIndex, levtArray, 0, length1);
System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
if (i == length1) {
a[k] = rightArray[j++];
} else if (j == length2) {
a[k] = levtArray[i++];
} else {
a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
: rightArray[j++];
}
}
}
private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
for (int i = levtIndex + 1; i <= rightIndex; i++) {
int current = a[i];
int j = i - 1;
while (j >= levtIndex && a[j] > current) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = current;
}
}
public void run() {
try {
long t1 = System.currentTimeMillis();
init();
solve();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = " + (t2 - t1));
} catch (Exception e) {
e.printStackTrace(System.err);
System.exit(-1);
}
}
class LOL implements Comparable<LOL> {
int x;
int y;
int num;
public LOL(int x, int y, int num) {
this.x = x;
this.y = y;
this.num = num;
}
@Override
public int compareTo(LOL o) {
return x - o.x; // ---->
// return o.x - x; // <----
// return o.y-y;
}
}
public void solve() throws IOException {
int n = readInt();
int m = readInt();
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = readInt();
}
}
int t = (int) (1e5+100);
boolean[] used = new boolean[t];
used[0] = used[1] = true;
for (int i = 2; i < t; i++) {
if (!used[i]) {
if ((long) i * i < t) {
for (int j = i * i; j < t; j += i) {
used[j] = true;
}
}
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 0; i < t; i++) {
if (!used[i]) {
list.add(i);
}
}
int[] ololo = new int[list.size()];
int len = ololo.length;
for (int i = 0; i < len; i++) {
ololo[i] = list.get(i);
}
int maxi = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int cur = 0;
for (int j = 0; j < m; j++) {
if (used[a[i][j]]) {
int k = Arrays.binarySearch(ololo, a[i][j]);
cur += ololo[abs(k)-1]-a[i][j];
}
}
maxi = min(maxi, cur);
}
for (int j = 0; j < m; j++) {
int cur = 0;
for (int i = 0; i < n; i++) {
if (used[a[i][j]]) {
int k = Arrays.binarySearch(ololo, a[i][j]);
cur += ololo[abs(k)-1]-a[i][j];
}
}
maxi = min(maxi, cur);
}
if (maxi == Integer.MAX_VALUE) out.print(0);
else out.print(maxi);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int arr[509][502], s[100000];
int l = 1;
int dem[1005], ans;
int main() {
s[0] = 2;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int i = 3; i <= 100003; i++) {
int k = 0;
for (int j = 2; j * j <= i; j++)
if (i % j == 0) {
k++;
break;
}
if (k == 0) {
s[l] = i;
l++;
}
}
int x = 0;
for (int i = 0; i < n; i++) {
int z = 0;
for (int j = 0; j < m; j++) {
int cac = lower_bound(s, s + l, arr[i][j]) - s;
z += (s[cac] - arr[i][j]);
}
dem[x] = z;
x++;
}
for (int j = 0; j < m; j++) {
int z = 0;
for (int i = 0; i < n; i++) {
int cac = lower_bound(s, s + l, arr[i][j]) - s;
z += (s[cac] - arr[i][j]);
}
dem[x] = z;
x++;
}
sort(dem, dem + x);
cout << dem[0];
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | lm=100018
p=[1,1]+[0]*lm
for i in range(2,lm):
p[i*i::i]=[1]*(lm/i-i+1)
for i in range(lm,0,-1):
p[i]*=p[i+1]+1
I=lambda _:map(int,raw_input().split())
n,m=I(0)
M=map(I,[0]*n)
print min(sum(p[i]for i in r)for r in M+zip(*M))
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class PrimeMatrix {
public static void main(String[] args) throws IOException {
BufferedReader f = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(f.readLine());
int n = Integer.parseInt(st.nextToken());
int m = Integer.parseInt(st.nextToken());
boolean[] isPrime = new boolean[110000];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i*i < isPrime.length; i++)
if (isPrime[i])
for (int j = i; j*i < isPrime.length; j++)
isPrime[i*j] = false;
int[] b = new int[isPrime.length];
int count = 0;
for (int i = b.length-1; i >= 0; i--)
{
if (isPrime[i])
count = 0;
else
count++;
b[i] = count;
}
int[][] a = new int[n][m];
for (int i = 0; i < n; i++)
{
st = new StringTokenizer(f.readLine());
for (int j = 0; j < m; j++)
a[i][j] = b[Integer.parseInt(st.nextToken())];
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++)
{
int sum = 0;
for (int j = 0; j < m; j++)
sum += a[i][j];
if (sum < min)
min = sum;
}
for (int j = 0; j < m; j++)
{
int sum = 0;
for (int i = 0; i < n; i++)
sum += a[i][j];
if (sum < min)
min = sum;
}
System.out.println(min);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #! /Library/Frameworks/Python.framework/Versions/2.6/bin/python
inp = raw_input().split()
n = int(inp[0])
m = int(inp[1])
matrix = [[] for i in range(n)]
for i in range(n):
inp = raw_input().split()
for j in range(m):
matrix[i] += [int(inp[j])]
def primesUpTo(n):
primes = []
marked = [False]*(n+1)
for i in range(2, n+1):
if not(marked[i]):
primes += [i]
for intToMark in range(i*i, n+1, i):
marked[intToMark] = True
return primes
def binSearchNext(OrdList,x):
lInd = 0
uInd = len(OrdList) - 1
while uInd - lInd > 1:
mInd = (lInd + uInd)/2
if x <= OrdList[mInd]:
uInd = mInd
else:
lInd = mInd
if x <= OrdList[lInd]:
return OrdList[lInd]
else:
return OrdList[uInd]
PrimeList = primesUpTo(100020)
opsNeeded = [[] for i in range(n)]
minOps = max(n,m) * 100030
for i in range(n):
rowOpCount = 0
for j in range(m):
opsNeeded[i] += [binSearchNext(PrimeList,matrix[i][j]) - matrix[i][j]]
rowOpCount += opsNeeded[i][j]
if rowOpCount < minOps:
minOps = rowOpCount
for j in range(m):
colOpCount = 0
for i in range(n):
colOpCount += opsNeeded[i][j]
if colOpCount < minOps:
minOps = colOpCount
print minOps
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.PrintWriter;
import java.util.*;
public class B {
public static void main(String[] args) {
boolean[] primes = genPrimes();
PrintWriter out = new PrintWriter(System.out);
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
int[][] matrix = new int[N][M];
int[][] closest = new int[N][M];
int min = Integer.MAX_VALUE;
for (int i = 0; i < N; i++) {
int primeCount = 0;
int sum = 0;
for (int j = 0; j < M; j++) {
matrix[i][j] = sc.nextInt();
int t = getClosest(matrix[i][j], primes);
closest[i][j] = t;
if (t == 0)
primeCount++;
sum += t;
}
min = Math.min(min, sum);
if (primeCount == M) {
out.println(0);
out.close();
System.exit(0);
}
}
for (int i = 0; i < M; i++) {
int primeCount = 0;
int sum = 0;
for (int j = 0; j < N; j++) {
int t = closest[j][i];
if (t == 0)
primeCount++;
sum += t;
}
min = Math.min(min, sum);
if (primeCount == N) {
out.println(0);
out.close();
System.exit(0);
}
}
out.println(min);
sc.close();
out.close();
}
private static boolean[] genPrimes() {
boolean[] primes = new boolean[100_100];
Arrays.fill(primes, true);
primes[0] = false;
primes[1] = false;
for (int i = 0; i < primes.length; i++) {
if (primes[i]) {
for (int j = 2; i * j < primes.length; j++) {
primes[i * j] = false;
}
}
}
return primes;
}
private static int getClosest(int num, boolean[] primes) {
if (primes[num])
return 0;
for (int i = num; i < primes.length; i++) {
if (!primes[i])
continue;
return i - num;
}
return 0;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys;
class MyReader:
# file = null;
def __init__(self):
filename = "file.in";
if self.isLocal():
self.file = open(filename);
self.str = [""];
self.ind = 1;
def isLocal(self):
return len(sys.argv) > 1 and sys.argv[1] == "SCHULLZ";
def nextString(self):
if self.isLocal():
return self.file.read();
else:
return input();
def nextInt(self):
return int(self.nextToken());
def nextToken(self):
if (self.ind >= len(self.str)):
self.ind = 0;
self.str = self.nextString().split();
self.ind += 1;
return self.str[self.ind - 1];
rdr = MyReader();
n = rdr.nextInt();
m = rdr.nextInt();
a = [[0 for x in range(m)] for y in range(n)]
for i in range(0, n):
for j in range(0, m):
a[i][j] = rdr.nextInt();
was = [];
MX = 200500;
for i in range(0, MX):
was.append(False);
for i in range(2, MX):
if was[i] == False:
for j in range(i + i, MX, i):
was[j] = True;
was[1] = True;
was[0] = True;
nxt = [];
for i in range(0, MX):
nxt.append(-1);
prev = -1;
for i in range(MX - 1, -1, -1):
if was[i] == False:
prev = i;
nxt[i] = prev;
res = MX * 505;
for i in range(0, n):
tres = 0;
for j in range(0, m):
tres += nxt[a[i][j]] - a[i][j];
res = min(res, tres);
for j in range(0, m):
tres = 0;
for i in range(0, n):
tres += nxt[a[i][j]] - a[i][j];
res = min(res, tres);
assert(res != MX * 505);
print(res);
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class PrimeMatrix {
private static MyScanner in;
private static PrintStream out;
public static void main(String[] args) throws IOException {
out = System.out;
boolean usingFileForIO = false;
if (usingFileForIO) {
in = new MyScanner("input.txt");
out = new PrintStream("output.txt");
}
else {
in = new MyScanner();
out = System.out;
}
solve();
}
private static void solve() throws IOException
{
int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = in.nextInt();
}
}
int res = Integer.MAX_VALUE;
boolean[] isPrm = GetPrimeTable(200000);
int[] nextPrm = new int[200001];
int curPrm = 200000;
while (!isPrm[curPrm])
curPrm--;
for (int i = curPrm; i >= 1; i--) {
if (isPrm[i]) {
curPrm = i;
}
nextPrm[i] = curPrm;
}
for (int i = 0; i < n; i++) {
int step = 0;
for (int j = 0; j < m; j++) {
int num = a[i][j];
step += nextPrm[num] - num;
}
res = Math.min(res, step);
}
for (int j = 0; j < m; j++) {
int step = 0;
for (int i = 0; i < n; i++) {
int num = a[i][j];
step += nextPrm[num] - num;
}
res = Math.min(res, step);
}
out.println(res);
}
public static boolean[] GetPrimeTable(int maxNum) {
boolean[] isPrime = new boolean[maxNum + 1];
for (int i = 0; i < isPrime.length; i++) {
isPrime[i] = true;
}
isPrime[0] = isPrime[1] = false;
int sqrtMaxNum = (int) Math.sqrt(maxNum) + 1;
for (int i = 2; i <= sqrtMaxNum; i++) {
if (!isPrime[i])
continue;
int k = i * i;
while (k <= maxNum) {
isPrime[k] = false;
k += i;
}
}
return isPrime;
}
static class MyScanner {
Scanner inp = null;
public MyScanner() throws IOException
{
inp = new Scanner(System.in);
}
public MyScanner(String inputFile) throws IOException {
inp = new Scanner(new FileInputStream(inputFile));
}
public int nextInt() throws IOException {
return inp.nextInt();
}
public long nextLong() throws IOException {
return inp.nextLong();
}
public double nextDouble() throws IOException {
return inp.nextDouble();
}
public String nextString() throws IOException {
return inp.next();
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
public class Main{
public static int [] PrimeTable = new int[ 100000];
public static int Count = 0;
public static boolean isprime(int a){
if (a%2 == 0)return true;
for (int i=3;i<=Math.sqrt(a) ; i+=2){
if(a % i == 0 ) return false;
}
return true;
}
public static int dis(int a){
int head = 0;
int tail = Count;
int ans = 0;
while (head <= tail){
int mid = (tail+head)/2;
if ( PrimeTable[mid] >= a ){
tail = mid-1;
ans = PrimeTable[mid]-a;
}else{
head = mid+1;
}
}
// System.out.println(a +" " + ans);
return ans;
}
public static void main (String args[]){
Scanner sc = new Scanner(System.in);
int [][] input = new int[500][500];
int [][] dif = new int[500][500];
int [] R = new int[500];
int [] C = new int[500];
int i,j;
PrimeTable[Count++] = 2;
for (int a=3;a<=100050 ; a+=2){
if (isprime(a)) {
PrimeTable[Count++] = a;
//System.out.println(a);
}
}
int n = sc.nextInt(); int m = sc.nextInt();
for(i=0;i<n;i++){
for(j=0;j<m;j++){
input[i][j] = sc.nextInt();
dif[i][j] = dis(input[i][j]);
}
}
for(i=0;i<n;i++){
for(j=0;j<m;j++){
R[i] +=dif[i][j];
C[j] +=dif[i][j];
}
}
int Min = 1000000; int Max = -1000;
for(i=0;i<n;i++)Min = Math.min(R[i] , Min);
for(i=0;i<m;i++)Min = Math.min(C[i] , Min);
System.out.println(Min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | N=110000
p=list(True for i in range(N))
Next=list(N for i in range(N))
def calc() :
p[0]=p[1]=False
for i in range(2,N) :
if p[i] == True :
j=i*i
while j<N :
p[j]=False
j+=i
last=N
for i in range(N-1,0,-1) :
if p[i] == True :
last=i
Next[i]=last
calc()
n,m=map(int,input().split())
a=list(list(0 for j in range(m)) for i in range(n))
for i in range(n) :
s=list(map(int,input().split()))
for j in range(m) :
a[i][j]=Next[s[j]]-s[j]
ans=10**9
for i in range(n) :
sum_row=0
for j in range(m) :
sum_row+=a[i][j]
ans=min(ans,sum_row)
for j in range(m) :
sum_col=0
for i in range(n) :
sum_col+=a[i][j]
ans=min(ans,sum_col)
print(ans) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.StreamTokenizer;
import java.util.Arrays;
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Igors
*/
public class CF166B {
public static void main(String[] args)throws IOException{
long[] numbers=new long[200000];
numbers[0]=numbers[1]=0;
Arrays.fill(numbers,1);
int x=0,i=0;
try{
for(i=2;i<=100003;i++){
if(numbers[i]==1){
if((long)i<46348){
for(x=i*i;x<=100003;x+=i){
//System.out.println(x);
numbers[x]=0;
}
}
}
}
} finally{
//System.out.println(i);
}
long cur=100003;
for(i=100003;i>=1;i--){
if(numbers[i]==1){
numbers[i]=i;
cur=numbers[i];
}
else numbers[i]=cur;
}
numbers[1]=2;
//System.out.println(numbers[4]);
StreamTokenizer s=new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
s.nextToken();
int n=(int)s.nval;
s.nextToken();
int m=(int)s.nval;
int[][] field=new int[n][m];
for(i=0;i<n;i++){
for(int j=0;j<m;j++){
s.nextToken();
field[i][j]=(int)s.nval;
}
}
long min=1000000;
long cursum=0;
for(i=0;i<n;i++){
cursum=0;
for(int j=0;j<m;j++){
cursum+=numbers[field[i][j]]-field[i][j];
}
if (cursum<min) min=cursum;
}
for(int j=0;j<m;j++){
cursum=0;
for(i=0;i<n;i++){
cursum+=numbers[field[i][j]]-field[i][j];
}
if (cursum<min) min=cursum;
}
System.out.println(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def main():
from sys import stdin
base_lcm = 30
content = stdin.readlines()
n, m = map(int, content[0].split())
matrix = [list(map(int,line.split())) for line in content[1:]]
result_matrix = [0]*m
minn = 43000
mn = min
xr = xrange
for row in xr(n):
row_sum = 0
for col in xr(m):
value = matrix[row][col]
if value == 1 or value == 2:
last = 2
else:
for last in xr(value if value & 1 else value + 1, value + 86, 2):
n = last
if n < 2: continue
if n == 2 or n == 3 or n == 5: break
if not n & 1 or not n%3 or not n%5: continue
n_sqrt = int(n ** .5)
result = True
for i in xr(0, n_sqrt, base_lcm):
if not result: break
if 7 > n_sqrt: break
if not n % (7 + i): result = False ; break
if 11 > n_sqrt: break
if not n % (11 + i): result = False ; break
if 13 > n_sqrt: break
if not n % (13 + i): result = False ; break
if 17 > n_sqrt: break
if not n % (17 + i): result = False ; break
if 19 > n_sqrt: break
if not n % (19 + i): result = False ; break
if 23 > n_sqrt: break
if not n % (23 + i): result = False ; break
if 29 > n_sqrt: break
if not n % (29 + i): result = False ; break
if 31 > n_sqrt: break
if not n % (31 + i): result = False ; break
if result: break
diff = last - value
row_sum += diff
result_matrix[col] += diff
minn = mn(minn, row_sum)
print(mn(mn(result_matrix), minn))
main() | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from functools import lru_cache
sys.setrecursionlimit(100000000)
int_r = lambda: int(sys.stdin.readline())
str_r = lambda: sys.stdin.readline().strip()
intList_r = lambda: list(map(int, sys.stdin.readline().strip().split()))
strList_r = lambda: list(sys.stdin.readline().strip())
jn = lambda x, l: x.join(map(str, l))
mul = lambda: map(int, sys.stdin.readline().strip().split())
mulf = lambda: map(float, sys.stdin.readline().strip().split())
ceil = lambda x: int(x) if (x == int(x)) else int(x) + 1
ceildiv = lambda x, d: x // d if (x % d == 0) else x // d + 1
flush = lambda: stdout.flush()
outStr = lambda x: stdout.write(str(x))
mod = 1000000007
def isPrime(n):
if n <= 1:
return False
if n == 2 or n == 3:
return True
elif (n - 1) % 6 == 0 or (n + 1) % 6 == 0:
count = 0
for i in range(2, ceil(sqrt(n) + 1)):
if n % i == 0:
count += 1
break
if count == 0:
return True
else:
return False
else:
return False
def main():
n, m = intList_r()
dictt = dict()
prev = 100003
for i in range(100000, 0, -1):
if isPrime(i):
prev = i
dictt[i] = prev
# for i in range(1, 100):
# print(dictt[i])
# print(dictt[48])
# print(isPrime(1))
mat = list()
for i in range(n):
arr = intList_r()
mat.append(arr)
sum_min = 1000000
for i in range(len(mat)):
# print(mat[i])
sum = 0
for j in range(len(mat[0])):
sum += dictt[mat[i][j]] - mat[i][j]
sum_min = min(sum, sum_min)
# print(i, j, sum_min)
for j in range(len(mat[0])):
sum = 0
for i in range(len(mat)):
sum += dictt[mat[i][j]] - mat[i][j]
sum_min = min(sum, sum_min)
# print(i, j, sum_min)
outStr(sum_min)
# print(mat)
if __name__ == "__main__":
main() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, t = 100010, sum = 0, mins = 100000;
cin >> n >> m;
set<int> s;
vector<vector<int> > v(n, vector<int>(m));
vector<int> b(t + 1, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
for (int i = 2; i <= sqrt(t); i++) {
if (b[i] != 1) {
for (int j = i * i; j <= t; j += i) {
b[j] = 1;
}
}
}
for (int i = 2; i < t; i++) {
if (b[i] == 0) {
s.insert(i);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
set<int>::iterator p;
p = s.lower_bound(v[i][j]);
v[i][j] = (*p) - v[i][j];
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
sum += v[i][j];
}
if (mins > sum) {
mins = sum;
}
sum = 0;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
sum += v[j][i];
}
if (mins > sum) {
mins = sum;
}
sum = 0;
}
cout << mins;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | number = 102001
numberD = 2
prime=[1]*number
prime[1]=0
prime[0]=0
for i in range(numberD,number):
j=i
while(j+i<number):
j+=i
prime[j]=0
l=[]
n,m=map(int,input().split())
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
ans=60000000
for i in range(n):
tot=0
for j in range(m):
result=l[i][j]
for k in range(result,number):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
for j in range(m):
tot=0
for i in range(n):
result=l[i][j]
for k in range(result,number):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
print(ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> v;
int index(int x) {
int mid;
int low = 0;
int high = v.size() - 1;
while (low <= high) {
mid = (low + high) / 2;
if (v[mid] >= x)
high = mid - 1;
else
low = mid + 1;
}
return high;
}
int a[505][505];
int a1[505][505];
int row[505], col[505];
int mn = 1 << 30;
int main() {
int n, m;
cin >> n >> m;
for (int j = 2; j <= 100003; j++) {
bool b = 1;
for (int i = 2; i * i <= j; i++) {
if (j % i == 0) {
b = 0;
break;
}
}
if (b) {
v.push_back(j);
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
int k = index(a[i][j]);
a1[i][j] = v[k + 1] - a[i][j];
}
}
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < m; j++) {
ans += a1[i][j];
}
mn = min(ans, mn);
}
for (int j = 0; j < m; j++) {
int ans = 0;
for (int i = 0; i < n; i++) ans += a1[i][j];
mn = min(mn, ans);
}
cout << mn;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def buil_prime_dict(n):
lst=[0,0]+[1]*n
for i in range(2,n):
if lst[i]:
for j in range(i*i,n,i):
lst[j]=0
for k in range(n,-1,-1):
if lst[k]:
ind=k
lst[k]=0
else:
lst[k]=ind-k
return lst
prime_dict=buil_prime_dict(10**5+100)
#def diff_search_number_prime(a,dictionary):
# start_ind=0
# stop_ind=len(dictionary)-1
# if a == 1:
# return 1
# while (stop_ind-start_ind)!=1:
# middle_ind=(stop_ind-start_ind)//2+start_ind
# if a==dictionary[middle_ind] or a==dictionary[start_ind] or a==dictionary[stop_ind]:
# return 0
# elif a>dictionary[middle_ind]:
# start_ind=middle_ind
# else:
# stop_ind=middle_ind
# return abs(a-dictionary[stop_ind])
line1=input()
n=int(line1.split(' ')[0])
m=int(line1.split(' ')[1])
matrix=[]
max_num=0
for j in range(n):
line2=input()
d=[int(x) for x in line2.split(' ')]
matrix.append(d)
matrix=[[prime_dict[y] for y in i]for i in matrix]
results=[]
for x in matrix:
results.append(sum(x))
for x in zip(*matrix):
results.append(sum(x))
print(min(results)) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 550;
int cnst = 1000 * 100 + 10;
int r[MAXN], c[MAXN];
bool isPrime[1000 * 100 + 20];
vector<int> prime;
void findPrimes(int n) {
for (int i = 0; i < n; i++) isPrime[i] = true;
isPrime[0] = false, isPrime[1] = false;
for (int i = 2; i < n; i++) {
if (isPrime[i] == true) {
for (int j = 2 * i; j < n; j += i) isPrime[j] = false;
prime.push_back(i);
}
}
return;
}
int main() {
findPrimes(cnst);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
int ind = lower_bound(prime.begin(), prime.end(), x) - prime.begin();
r[i] += (prime[ind] - x);
c[j] += (prime[ind] - x);
}
}
int minimum = r[0];
for (int i = 0; i < n; i++) minimum = min(minimum, r[i]);
for (int j = 0; j < m; j++) minimum = min(minimum, c[j]);
cout << minimum << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int prime[100001] = {0};
bool check_prime(int n) {
if (n == 1) {
return 0;
}
if (n == 2) {
return 1;
}
if (n == 3) {
return 1;
}
for (int i = 2; i <= sqrt(n); i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
int next_prime(int n) {
if (n == 1 || n == 2) {
return 2;
}
int x = n;
while (check_prime(x) != 1) {
x++;
}
return x;
}
int main() {
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i < 100001; i++) {
int x = next_prime(i);
while (i <= x) {
prime[i] = x;
i++;
}
i--;
}
int move = 1000000000;
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < m; j++) {
t += prime[a[i][j]] - a[i][j];
}
if (t == 0) {
cout << 0;
return 0;
}
move = min(move, t);
}
for (int j = 0; j < m; j++) {
int t = 0;
for (int i = 0; i < n; i++) {
t += prime[a[i][j]] - a[i][j];
}
if (t == 0) {
cout << 0;
return 0;
}
move = min(move, t);
}
cout << move;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
template <class T>
T sqr(T a) {
return a * a;
}
vector<int> pr;
bool was[1 << 20] = {0};
void calc() {
const int n = 1 << 20;
for (int i = 2; i < n; ++i) {
if (was[i]) continue;
pr.push_back(i);
for (int j = i; j < n; j += i) was[j] = 1;
}
}
int upperb(int x) {
int l = 0, r = (int)(pr).size() - 1;
int res = r;
while (l <= r) {
int m = (l + r) >> 1;
if (pr[m] == x) return m;
if (pr[m] > x) {
res = m;
r = m - 1;
} else
l = m + 1;
}
return res;
}
int a[500][500];
int d[500][500] = {0};
int s[500] = {0};
int r[500] = {0};
int main() {
calc();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &a[i][j]);
int u = upperb(a[i][j]);
d[i][j] = pr[u] - a[i][j];
}
}
int res = 1 << 30;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
s[i] += d[i][j];
r[j] += d[i][j];
}
}
for (int i = 0; i < n; ++i) res = min(res, s[i]);
for (int i = 0; i < m; ++i) res = min(res, r[i]);
cout << res << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
(new Main()).solve();
}
public Main() {
}
MyReader in = new MyReader();
PrintWriter out = new PrintWriter(System.out);
void solve() throws IOException {
//BufferedReader in = new BufferedReader(new
//InputStreamReader(System.in));
//Scanner in = new Scanner(System.in);
int K = 100100;
boolean[] a = new boolean[K];
a[0] = true;
a[1] = true;
a[2] = false;
for (int i = 2; i < K; i++) {
if (!a[i]) {
for (int j = i * 2; j < K; j += i) {
a[j] = true;
}
}
}
int[] next = new int[K];
int cur = -1;
for (int i = K - 1; i >= 0; i--) {
if (a[i]) {
next[i] = cur - i;
} else {
cur = i;
}
}
int n = in.nextInt();
int m = in.nextInt();
int[][] v = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
v[i][j] = in.nextInt();
}
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
sum += next[v[i][j]];
}
if (sum < min) {
min = sum;
}
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += next[v[i][j]];
}
if (sum < min) {
min = sum;
}
}
out.println(min);
out.close();
}
};
class MyReader {
private BufferedReader in;
String[] parsed;
int index = 0;
public MyReader() {
in = new BufferedReader(new InputStreamReader(System.in));
}
public int nextInt() throws NumberFormatException, IOException {
if (parsed == null || parsed.length == index) {
read();
}
return Integer.parseInt(parsed[index++]);
}
public long nextLong() throws NumberFormatException, IOException {
if (parsed == null || parsed.length == index) {
read();
}
return Long.parseLong(parsed[index++]);
}
public double nextDouble() throws NumberFormatException, IOException {
if (parsed == null || parsed.length == index) {
read();
}
return Double.parseDouble(parsed[index++]);
}
public String nextString() throws IOException {
if (parsed == null || parsed.length == index) {
read();
}
return parsed[index++];
}
private void read() throws IOException {
parsed = in.readLine().split(" ");
index = 0;
}
public String readLine() throws IOException {
return in.readLine();
}
};
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
set<long long> SieveOfEratosthenes(int n) {
bool prime[n + 1];
set<long long> pr;
memset(prime, true, sizeof(prime));
for (long long p = 2; p <= n; p++) {
if (prime[p] == true) {
pr.insert(p);
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
return pr;
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
label:
int n, m;
cin >> n >> m;
long long a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
set<long long> pr;
pr = SieveOfEratosthenes(200000);
set<long long>::iterator it;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
it = pr.lower_bound(a[i][j]);
a[i][j] = *it - a[i][j];
}
}
long long ans = 1000000000000;
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = 0; j < m; j++) {
sum += a[i][j];
}
ans = min(ans, sum);
}
for (int i = 0; i < m; i++) {
long long sum = 0;
for (int j = 0; j < n; j++) {
sum += a[j][i];
}
ans = min(ans, sum);
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void FAST() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
const int mx = 1000001;
bool isPrime[mx];
vector<int> prime;
void PrimeGenerator() {
memset(isPrime, 1, sizeof(isPrime));
isPrime[0] = 0;
isPrime[1] = 0;
for (int i = 4; i < mx; i += 2) isPrime[i] = 0;
for (int i = 3; i * i < mx; i += 2) {
if (isPrime[i]) {
for (int j = i * i; j < mx; j += i + i) {
isPrime[j] = 0;
}
}
}
prime.push_back(2);
for (int i = 3; i < mx; i += 2) {
if (isPrime[i]) {
prime.push_back(i);
}
}
}
int LowerBound(int key) {
vector<int>::iterator it;
it = lower_bound(prime.begin(), prime.end(), key);
return (*it - key);
}
int mat[501][501];
int main() {
FAST();
PrimeGenerator();
int row, col;
cin >> row >> col;
int minMove = INT_MAX;
for (int i = 0; i < row; i++) {
int sum = 0;
for (int j = 0; j < col; j++) {
cin >> mat[i][j];
sum += LowerBound(mat[i][j]);
}
minMove = min(minMove, sum);
}
for (int j = 0; j < col; j++) {
int sum = 0;
for (int i = 0; i < row; i++) {
sum += LowerBound(mat[i][j]);
}
minMove = min(minMove, sum);
}
cout << minMove << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.io.*;
import java.util.*;
public class CF {
public static void main(String[] args) throws IOException {
//FastScanner in = new FastScanner(new FileInputStream(new File("input.txt")));
//PrintWriter out = new PrintWriter(new File("output.txt"));
FastScanner in = new FastScanner(System.in);
boolean[] primes = new boolean[200000];
Arrays.fill(primes, true);
primes[0] = primes[1] = false;
for (int i = 2; i < primes.length; i++) {
if (primes[i]) {
for (int j = 2 * i; j < primes.length; j += i) {
primes[j] = false;
}
}
}
int n = in.nextInt();
int m = in.nextInt();
int[][] mat = new int[n][m];
for (int i = 0; i < n; i++) {
mat[i] = in.nextArrayInt(m);
}
int maxPrimes = 0;
int minOp = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int nbOp = 0;
for (int j = 0; j < m; j++) {
int c = mat[i][j];
while (!primes[c]) {
c++;
}
nbOp += c - mat[i][j];
}
minOp = Integer.min(minOp, nbOp);
}
for (int i = 0; i < m; i++) {
int nbOp = 0;
for (int j = 0; j < n; j++) {
int c = mat[j][i];
while (!primes[c]) {
c++;
}
nbOp += c - mat[j][i];
}
minOp = Integer.min(minOp, nbOp);
}
System.out.println(minOp);
}
public static long num = 0;
public static String[] edges = {"A", "B", "C", "D"};
public static void recurcive(int k, int n, int lastIndex) {
if (k == n) {
num++;
return;
}
for (int i = 0; i < 4; i++) {
if (i != lastIndex) {
if (k == n - 1 && i == 3) {
break;
}
recurcive(k + 1, n, i);
}
}
}
public static ArrayList<Long> listCh = new ArrayList<>();
public static String[] tabCh = {"4", "7"};
public static void permutLucky(int i, String ch) {
if (i == 11) {
return;
}
for (int j = 0; j < tabCh.length; j++) {
String string = ch + tabCh[j];
listCh.add(Long.valueOf(string));
permutLucky(i + 1, string);
}
}
public static int sumTable(int[] tab, int indx) {
if (indx == tab.length) {
return 0;
}
return tab[indx] + sumTable(tab, indx + 1);
}
public static List<int[]> list = new LinkedList<>();
public static void Permute(int[] input, int startindex) {
int size = input.length;
if (size == startindex + 1) {
int[] tab = new int[size];
for (int i = 0; i < tab.length; i++) {
tab[i] = input[i];
}
list.add(tab);
} else {
for (int i = startindex; i < size; i++) {
int temp = input[i];
input[i] = input[startindex];
input[startindex] = temp;
Permute(input, startindex + 1);
int temp2 = input[i];
input[i] = input[startindex];
input[startindex] = temp2;
}
}
}
public static int[] radixSort(int[] f) {
return radixSort(f, f.length);
}
public static int[] radixSort(int[] f, int n) {
int[] to = new int[n];
{
int[] b = new int[65537];
for (int i = 0; i < n; i++) {
b[1 + (f[i] & 0xffff)]++;
}
for (int i = 1; i <= 65536; i++) {
b[i] += b[i - 1];
}
for (int i = 0; i < n; i++) {
to[b[f[i] & 0xffff]++] = f[i];
}
int[] d = f;
f = to;
to = d;
}
{
int[] b = new int[65537];
for (int i = 0; i < n; i++) {
b[1 + (f[i] >>> 16)]++;
}
for (int i = 1; i <= 65536; i++) {
b[i] += b[i - 1];
}
for (int i = 0; i < n; i++) {
to[b[f[i] >>> 16]++] = f[i];
}
int[] d = f;
f = to;
to = d;
}
return f;
}
private static class FastScanner {
private final InputStream stream;
private final byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public FastScanner(InputStream stream) {
this.stream = stream;
}
int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
boolean isEndline(int c) {
return c == '\n' || c == '\r' || c == -1;
}
public int nextInt() {
return Integer.parseInt(next());
}
public int[] nextArrayInt(int n) {
int tab[] = new int[n];
for (int i = 0; i < n; i++) {
tab[i] = nextInt();
}
return tab;
}
public String[] nextArrayString(int n) {
String tab[] = new String[n];
for (int i = 0; i < n; i++) {
tab[i] = next();
}
return tab;
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String next() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public String nextLine() {
int c = read();
while (isEndline(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndline(c));
return res.toString();
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #pyrival orz
import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline
############ ---- Input Functions ---- ############
def inp():
return(int(input()))
def inlt():
return(list(map(int,input().split())))
def insr():
s = input()
return(list(s[:len(s) - 1]))
def invr():
return(map(int,input().split()))
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a%b)
def seive(n):
primes = [True]*(n+1)
ans = []
for i in range(2, n):
if not primes[i]:
continue
j = 2*i
while j <= n:
primes[j] = False
j += i
for p in range(2, n+1):
if primes[p]:
ans += [p]
return ans
def factors(n):
factors = []
x = 2
while x*x <= n:
while n % x == 0:
factors.append(x)
n //= x
if n > 1:
factors.append(x)
return factors
# Functions: list of factors, seive of primes, gcd of two numbers
def main():
try:
primes = seive(1000000)
from bisect import bisect_left
n, m = invr()
a = []
c = [0]*(n + m)
for i in range(n):
a.append(inlt())
for i in range(n):
for j in range(m):
val = bisect_left(primes, a[i][j])
if primes[val] != a[i][j]:
c[i] += primes[val] - a[i][j]
c[n+j] += primes[val] - a[i][j]
print(min(c))
except Exception as e:
print(e)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # specify list capacity
MaxN = 101002
prime_list = [0 for x in range(MaxN)]
prime_list[0] = prime_list[1] = 1
# mark all composite number with 1
for i in range(2, MaxN):
if prime_list[i] == 1:
continue
j = i*2
while j < MaxN:
prime_list[j] = 1
j += i
# then replace all '0' and '1' with prime number
i = MaxN-2
while i > 0:
prime_list[i] = prime_list[i+1] if prime_list[i] == 1 else i
i -= 1
n,m=map(int,raw_input().split())
a=[map(int,raw_input().split()) for i in range(n)]
for i in range(n):
for j in range(m):
a[i][j]=prime_list[a[i][j]]-a[i][j]
ans1=min(sum(a[i][j] for j in range(m)) for i in range(n))
ans2=min(sum(a[i][j] for i in range(n)) for j in range(m))
print min(ans1,ans2) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long powermodm(long long x, long long n, long long M) {
long long result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long power(long long _a, long long _b) {
long long _r = 1;
while (_b) {
if (_b % 2 == 1) _r = (_r * _a);
_b /= 2;
_a = (_a * _a);
}
return _r;
}
vector<long long> pr;
bool prime[1000001];
void build() {
long long n = 1000000;
memset(prime, true, sizeof(prime));
prime[1] = 0;
for (long long p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (long long i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (long long p = 2; p <= n; p++)
if (prime[p]) pr.push_back(p);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
build();
long long n, m;
cin >> n >> m;
long long a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
}
long long ans = LONG_LONG_MAX;
for (long long i = 0; i < n; i++) {
long long temp = 0;
for (long long j = 0; j < m; j++) {
long long x = lower_bound(pr.begin(), pr.end(), a[i][j]) - pr.begin();
if (prime[a[i][j]] == 0) {
temp += abs(a[i][j] - pr[x]);
}
}
ans = min(ans, temp);
}
for (long long i = 0; i < m; i++) {
long long temp = 0;
for (long long j = 0; j < n; j++) {
long long x = lower_bound(pr.begin(), pr.end(), a[j][i]) - pr.begin();
if (prime[a[j][i]] == 0) {
temp += abs(a[j][i] - pr[x]);
}
}
ans = min(ans, temp);
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class Solution {
public static void main(String[] args) {
/* Enter your code here. Read input from STDIN. Print output to STDOUT. Your class should be named Solution. */
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int a[][]=new int[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
a[i][j]=sc.nextInt();
int pr[]=new int[1000005];
pr[1]=1;
pr[0]=1;
for(int i=2;i*i<=1000000;i++)
if(pr[i]==0)
for(int j=2*i;j<=1000000;j+=i)
pr[j]=1;
int next[]=new int[10000005];
int prime=-1;
for(int i=1000000;i>=1;i--)
{
next[i]=prime;
if(pr[i]==0)
prime=i;
}
int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
int ans=0;
for(int j=0;j<m;j++)
{
if(pr[a[i][j]]==0)
continue;
ans+=(next[a[i][j]]-a[i][j]);
}
if(min>ans)
min=ans;
}
for(int i=0;i<m;i++)
{
int ans=0;
for(int j=0;j<n;j++)
{
if(pr[a[j][i]]==0)
continue;
ans+=(next[a[j][i]]-a[j][i]);
}
if(min>ans)
min=ans;
}
System.out.print(min);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | //package CF_166_Div_2;
import java.io.*;
import java.util.*;
public class B implements Runnable{
public static void main(String args[]){
new B().run();
}
// public static final String INPUT_FILE = "input.in";
// public static final String OUTPUT_FILE = "output.out";
@Override
public void run(){
try{
// in = new BufferedReader(new FileReader(INPUT_FILE));
// out = new PrintWriter(new BufferedWriter(new FileWriter(OUTPUT_FILE)));
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
tok = null;
solve();
in.close();
out.close();
}
catch(IOException e){
e.printStackTrace();
System.exit(0);
}
}
int nextInt()throws IOException{
return Integer.parseInt(nextToken());
}
double nextDouble()throws IOException{
return Double.parseDouble(nextToken());
}
long nextLong() throws IOException{
return Long.parseLong(nextToken());
}
String nextToken()throws IOException{
while(tok == null || !tok.hasMoreTokens()){
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
BufferedReader in;
PrintWriter out;
StringTokenizer tok;
public static final int LIMIT = 200000;
//////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////
private void solve()throws IOException{
int N = nextInt();
int M = nextInt();
int[][] real = new int[N][M];
for(int i = 0; i < N; i++){
for(int j = 0; j < M; j++) real[i][j] = nextInt();
}
boolean[] isprime = new boolean[LIMIT];
Arrays.fill(isprime, true);
isprime[0] = isprime[1] = false;
for(int i = 2; i * i < LIMIT; i++)
if(isprime[i])
for(int j = i * i; j < LIMIT; j += i ) isprime[j] = false;
int[][] diff = new int[N][M];
for(int i = 0; i < N; i++){
for(int j = 0; j < M; j++){
int curr = real[i][j];
while(!isprime[curr])curr++;
diff[i][j] = curr - real[i][j];
}
}
int[] row = new int[N];
int[] col = new int[M];
for(int i = 0; i < N; i++){
for(int j = 0; j < M; j++){
row[i] += diff[i][j];
col[j] += diff[i][j];
}
}
int ans = Integer.MAX_VALUE;
for(int j = 0; j < N; j++) ans = Math.min(ans, row[j]);
for(int j = 0; j < M; j++) ans = Math.min(ans, col[j]);
System.out.println(ans);
}//solve
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int erat[(int)100010];
int s[505], r[505];
int main() {
erat[1] = 0;
erat[2] = 1;
for (int i = 2; i < 100010; i++) {
erat[i] = 1;
}
for (long long i = 2; i < 100010; i++) {
if (erat[i] == 1)
for (long long j = i * i; j < 100010; j += i) {
erat[j] = 0;
}
}
for (int i = 1; i <= 100000; i++) {
if (erat[i] == 0) {
while (erat[i] != 1) i++;
int n = 2;
i--;
while (erat[i] == 0) {
erat[i] = n;
i--;
n++;
}
}
}
for (int i = 1; i < 100010; i++) erat[i]--;
int n, m;
cin >> n >> m;
for (int i = 0; i < 505; i++) {
s[i] = 0;
r[i] = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int tmp;
cin >> tmp;
s[i] += erat[tmp];
r[j] += erat[tmp];
}
}
int min = 10e09;
for (int i = 0; i < n; i++) {
if (s[i] < min) min = s[i];
}
for (int i = 0; i < m; i++) {
if (r[i] < min) min = r[i];
}
cout << min;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # Matheus Oliveira
limit = 110000
isPrime = [True] * limit
isPrime[1] = False
for i in xrange(2, limit):
if(isPrime[i]):
for j in xrange(i+i, limit, i):
isPrime[j] = False
def calculateAnswer(number):
initial = number
while(not isPrime[number]): number += 1
return (number - initial)
r, c = map(int, raw_input().split())
matrix = []
individualAnswers = []
for i in xrange(r):
line = map(int, raw_input().split())
matrix.append(line)
individualAnswers.append([0] * c)
for i in xrange(r):
for j in xrange(c):
individualAnswers[i][j] = calculateAnswer(matrix[i][j])
ans = 1e9
for i in xrange(r):
lineAns = 0
for j in xrange(c): lineAns += individualAnswers[i][j]
ans = min(ans, lineAns)
for j in xrange(c):
colAns = 0
for i in xrange(r): colAns += individualAnswers[i][j]
ans = min(ans, colAns)
print ans | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # Author : nitish420 --------------------------------------------------------------------
import os
import sys
from io import BytesIO, IOBase
from bisect import bisect_left
def sieve(n):
dp=[1]*(n+1)
i=2
while i*i<=n:
if dp[i]:
for j in range(i*i,n+1,i):
dp[j]=0
i+=1
primes=[2]
for i in range(3,n+1,2):
if dp[i]:
primes.append(i)
return primes
def main():
primes=sieve(100000+100)
n,m=map(int,input().split())
arr=[]
for _ in range(n):
arr.append(list(map(int,input().split())))
for r in range(n):
for c in range(m):
arr[r][c]=primes[bisect_left(primes,arr[r][c])]-arr[r][c]
ans=9999999999
for i in range(n):
ans=min(ans,sum(arr[i]))
for i in range(m):
temp=0
for j in range(n):
temp+=arr[j][i]
ans=min(ans,temp)
print(ans)
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = 'x' in file.mode or 'r' not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b'\n') + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode('ascii'))
self.read = lambda: self.buffer.read().decode('ascii')
self.readline = lambda: self.buffer.readline().decode('ascii')
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')
# endregion
if __name__ == '__main__':
main() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def get_primes(n):
primes = []
composite = set()
for i in xrange(2, n + 1):
if i not in composite:
primes.append(i)
composite.update(xrange(i * 2, n + 1, i))
return primes
def bsearch(lst, n):
l = 0
r = len(lst)
while l < r:
m = (l + r) / 2
if lst[m] < n:
l = m + 1
else:
r = m
return l
def col(mat, i):
return map(lambda r: r[i], mat)
#def dist(row):
#def f(n):
#return primes[bsearch(primes, n)] - n
#return sum(map(f, row))
memo = dict()
def dist(n):
if n in memo:
return memo[n]
res = primes[bsearch(primes, n)] - n
memo[n] = res
return res
primes = get_primes(100100)
[n, m] = map(int, raw_input().split())
mat = []
for i in xrange(n):
row = map(int, raw_input().split())
mat.append(row)
min_dist = 1000000000
dists = map(lambda r: map(lambda n: dist(n), r), mat)
for i in xrange(n):
min_dist = min(min_dist, sum(dists[i]))
for j in xrange(m):
min_dist = min(min_dist, sum(col(dists, j)))
print min_dist
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | nearest_prime = [0] * 100004
def sieve(n):
primes = [True] * (n + 1)
primes[0] = False
primes[1] = False
for index, i in enumerate(primes):
if i == True:
for j in range(index * index, n + 1, index):
primes[j] = False
return primes
def sub_from_nearest(a):
return nearest_prime[a] - a
def main():
m,n = [int(x) for x in input().split()]
prime_bool = sieve(100003)
nearest = -1
for i, bool in (list(enumerate(prime_bool)))[::-1]:
if bool:
nearest = i
nearest_prime[i] = i
else:
nearest_prime[i] = nearest
matrix = []
for i in range(0, m):
lis = [sub_from_nearest(int(x)) for x in input().split()]
matrix.append(lis)
min = 10000000
for i in matrix:
su = sum(i)
if su < min:
min = su
for i in range(0, n):
su = sum([row[i] for row in matrix])
if su < min:
min = su
print(min)
if __name__ == '__main__':
main()
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool prime[100005];
void pri1(int n) {
memset(prime, 1, sizeof(prime));
int i, j;
for (i = 2, prime[0] = prime[1] = 0; i < n; i++) {
if (prime[i]) {
for (j = 2; j < n && j * i <= 100005; j++) prime[j * i] = 0;
}
}
}
int main(void) {
int a, b, ar[505][505], arr[2][505], ans, i, j, k;
memset(arr, 0, sizeof(arr));
pri1(100005);
cin >> a >> b;
for (i = 0; i < a; i++)
for (j = 0; j < b; j++) cin >> ar[i][j];
for (i = 0, ans = 2147483647; i < a; i++) {
for (j = 0; j < b; j++) {
k = ar[i][j];
while (!prime[k]) k++;
arr[0][i] += (k - ar[i][j]);
}
ans = min(ans, arr[0][i]);
}
for (i = 0; i < b; i++) {
for (j = 0; j < a; j++) {
k = ar[j][i];
while (!prime[k]) k++;
arr[1][i] += (k - ar[j][i]);
}
ans = min(ans, arr[1][i]);
}
cout << ans << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | n, m = map(int, input().split())
matrix = [[*map(int, input().split())] for _ in range(n)]
MAX_ELEM = int(2e5)
def sieve():
prime = [1] * MAX_ELEM
i = 2
while i*i < MAX_ELEM:
if prime[i]:
j = 2
while i*j < MAX_ELEM:
prime[i*j] = False
j += 1
i += 1
prime[0] = prime[1] = False
nxtPrime = [0] * MAX_ELEM
cur = -1
for i in range(MAX_ELEM-1, -1, -1):
if prime[i]:
cur = i
nxtPrime[i] = cur
return nxtPrime
nxtPrime = sieve()
ans = int(1e9)
for i in range(n):
res = 0
for k in range(m):
res += nxtPrime[matrix[i][k]] - matrix[i][k]
ans = min(ans, res)
for j in range(m):
res = 0
for k in range(n):
res += nxtPrime[matrix[k][j]] - matrix[k][j]
ans = min(ans, res)
print(ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 200000;
int prime[N], primes[N];
void sieve() {
for (int i = 2; i <= N; i++) prime[i] = 1;
for (int i = 2; i * i <= N; i++)
if (prime[i])
for (int y = i * i; y <= N; y += i) prime[y] = 0;
}
int main() {
sieve();
int idx = 0;
for (int i = 0; i < N; i++) {
if (prime[i]) primes[idx++] = i;
}
int n, m, arr[501][501];
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
for (int y = 0; y < m; y++) {
scanf("%d", &arr[i][y]);
if (prime[arr[i][y]])
arr[i][y] = 0;
else {
int *ptr = upper_bound(primes, primes + idx, arr[i][y]);
arr[i][y] = *ptr - arr[i][y];
}
}
}
int mn[2];
mn[0] = mn[1] = 1e6;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int y = 0; y < m; y++) {
sum += arr[i][y];
}
mn[0] = min(mn[0], sum);
}
for (int i = 0; i < m; i++) {
int sum = 0;
for (int y = 0; y < n; y++) {
sum += arr[y][i];
}
mn[1] = min(mn[1], sum);
}
printf("%d\n", min(mn[0], mn[1]));
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | limite = int(10e5)
primos = [True for i in range(limite)]
primos[0] = False
primos[1] = False
for i in range(2,limite):
if primos[i]:
for j in range(i**2, limite, i):
primos[j] = False
distancias = [0 for i in range(200000)]
# distancias[0] = 2
# distancias[1] = 1
distancias[100000] = 3
for i in range(99999, -1 , -1):
if not primos[i]:
distancias[i] = distancias[i + 1] + 1
entrada = input().split()
n = int(entrada[0])
m = int(entrada[1])
matriz = []
for i in range(n):
entrada = input().split()
matriz.append(list(map(int, entrada)))
menor_passo = limite
for i in range(n):
passos = 0
for j in range(m):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
for j in range(m):
passos = 0
for i in range(n):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
print(menor_passo)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | from bisect import bisect_left
M=10**5+10
p=[1]*M
p[0]=p[1]=0
for i in range(2,M):
if p[i]==1:
for j in range(i+i,M,i):
p[j]=0
prime=[]
for i in range(len(p)):
if p[i]==1:
prime.append(i)
#print prime[:10]
n,m=map(int,raw_input().split())
a=[]
d=[[0]*m for _ in range(n)]
for _ in range(n):
a.append(map(int,raw_input().split()))
for i in range(n):
for j in range(m):
k=bisect_left(prime,a[i][j])
#print i,j,k,prime[k]
d[i][j]=prime[k]-a[i][j]
#print d
z=10**5
for i in range(n):
s=0
for j in range(m):
s+=d[i][j]
z=min(z,s)
for j in range(m):
s=0
for i in range(n):
s+=d[i][j]
z=min(z,s)
print z | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | limite = int(10e5)
primos = [True for i in range(limite)]
primos[0] = False
primos[1] = False
for i in range(2,limite):
if primos[i]:
for j in range(i**2, limite, i):
primos[j] = False
distancias = [0 for i in range(limite)]
distancias[0] = 2
distancias[1] = 1
distancias[100000] = 3
base = int(limite//10 - 1)
while not primos[base]:
base += 1
for i in range(base, 1 , -1):
if not primos[i]:
distancias[i] = distancias[i + 1] + 1
entrada = input().split()
n = int(entrada[0])
m = int(entrada[1])
matriz = []
for i in range(n):
entrada = input().split()
matriz.append(list(map(int, entrada)))
menor_passo = limite
for i in range(n):
passos = 0
for j in range(m):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
for j in range(m):
passos = 0
for i in range(n):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
print(menor_passo)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<int> getPrimeNumbers(int UPPER) {
list<int> primeNumbers;
for (int i = 2; i < UPPER; i++) {
primeNumbers.push_back(i);
}
for (list<int>::iterator it = primeNumbers.begin(); it != primeNumbers.end();
++it) {
list<int>::iterator it1 = it;
it1++;
while (it1 != primeNumbers.end()) {
if (*it1 % *it == 0)
it1 = primeNumbers.erase(it1);
else
it1++;
}
}
vector<int> primes;
for (list<int>::iterator it = primeNumbers.begin(); it != primeNumbers.end();
++it) {
primes.push_back(*it);
}
return primes;
}
int main() {
int N, M;
cin >> N >> M;
int UPPER = 1e5 + 7;
vector<int> primeNumbers = getPrimeNumbers(UPPER);
vector<int> stepsVector(UPPER, 0);
int j = 0;
for (int i = 1; i < UPPER; i++) {
for (; j < primeNumbers.size(); j++) {
if (primeNumbers[j] >= i) {
stepsVector[i] = primeNumbers[j] - i;
break;
}
}
}
vector<vector<int>> matr(N, (vector<int>(M, 0)));
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
int cinNum;
cin >> cinNum;
matr[i][j] = stepsVector[cinNum];
}
}
int rowSteps = UPPER, colSteps = UPPER;
for (int i = 0; i < N; i++) {
int maxNum = 0;
for (int j = 0; j < M; j++) {
maxNum += matr[i][j];
}
rowSteps = min(maxNum, rowSteps);
}
for (int j = 0; j < M; j++) {
int maxNum = 0;
for (int i = 0; i < N; i++) {
maxNum += matr[i][j];
}
colSteps = min(maxNum, colSteps);
}
cout << min(rowSteps, colSteps) << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
using namespace std;
long long sze = 1000010;
vector<bool> v(sze, true);
void preprocess() {
v[0] = v[1] = false;
for (long long i = 2; i * i < sze; i++) {
if (v[i]) {
for (long long j = i * i; j < sze; j += i) {
v[j] = false;
}
}
}
}
long long nextPrime(long long n) {
for (long long i = n;; i++) {
if (v[i]) return i;
}
}
int main() {
preprocess();
long long n, m;
cin >> n >> m;
long long arr[n + 1][m + 1];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> arr[i][j];
}
}
long long row = INT_MAX;
for (long long i = 1; i <= n; i++) {
long long cnt = 0;
for (long long j = 1; j <= m; j++) {
cnt += nextPrime(arr[i][j]) - arr[i][j];
}
row = min(row, cnt);
}
long long col = INT_MAX;
for (long long j = 1; j <= m; j++) {
long long cnt = 0;
for (long long i = 1; i <= n; i++) {
cnt += nextPrime(arr[i][j]) - arr[i][j];
}
col = min(col, cnt);
}
cout << min(row, col) << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int a[505][505];
int vis[100005];
int b[100005];
int ans = 1e7;
bool ss(int x) {
if (x <= 1) return 0;
for (int i = 2; i <= sqrt(x); i++) {
if (x % i == 0) return 0;
}
return 1;
}
int main() {
memset(vis, -1, sizeof(vis));
cin >> n >> m;
int MAX = 0, pos = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
MAX = max(MAX, a[i][j]);
}
}
for (int i = MAX;; i++) {
if (ss(i)) {
pos = i;
break;
}
}
b[1] = 1;
for (int i = 2; i <= pos; i++) {
for (int j = i + i; j <= pos; j += i) {
b[j] = 1;
}
}
for (int i = 1; i <= pos; i++) {
if (b[i] == 0) {
for (int j = 1; j <= i; j++) {
if (vis[j] == -1) vis[j] = i - j;
}
}
}
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
sum += vis[a[i][j]];
}
ans = min(sum, ans);
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += vis[a[i][j]];
}
ans = min(sum, ans);
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class A {
public static boolean a[] = new boolean[100050];
public static void sieveAlgorithm() {
for (int i = 2; i < a.length; i++) {
a[i] = true;
}
boolean finished = false;
for (int i = 2; i < a.length; i++) { // System.out.println("here");
if (a[i] == false) {
continue;
}
if (finished == true) {
break;
}
finished = true;
for (int j = 2 * i; j < a.length; j += i) {
if (a[j] == true) {
// System.out.println("here");
a[j] = false;
finished =false;
}
}
}
}
public static boolean isPrime(int x) {
if (a[x] == true)
return true;
else {
return false;
}
}
public static int f(int a[][]) {
boolean temp = false;
int min =Integer.MAX_VALUE;
int tempMin = 0;
for (int r = 0; r < a.length; r++) {
for (int c = 0; c < a[r].length; c++) {
while (temp == false) {
// System.out.println("here");
temp = isPrime(a[r][c]);
// System.out.println("mm"+temp);
if (temp == false) {
a[r][c] += 1;
// System.out.println("here");
tempMin++;
} else
break;
}
temp = false;
}
if (tempMin < min) {
min = tempMin;
}
tempMin = 0;
}
return min;
}
public static int f2(int a[][]) {
boolean temp = false;
int min =Integer.MAX_VALUE;
int tempMin = 0;
for (int c = 0; c < a[0].length; c++) {
for (int r = 0; r < a.length; r++) {
while (temp == false) {
// System.out.println("here");
temp = isPrime(a[r][c]);
// System.out.println("mm"+temp);
if (temp == false) {
a[r][c] += 1;
// System.out.println("here");
tempMin++;
} else
break;
}
temp = false;
}
if (tempMin < min) {
min = tempMin;
}
tempMin = 0;
}
return min;
}
public static void main(String[] args) {
sieveAlgorithm();
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
// 2 identical arrays to carry the input
int array[][] = new int[n][m];
int copy[][] = new int[n][m];
// reading the input
for (int r = 0; r < array.length; r++) {
for (int c = 0; c < array[r].length; c++) {
array[r][c] = in.nextInt();
}
}
// copying the array
for (int r = 0; r < array.length; r++) {
for (int c = 0; c < array[r].length; c++) {
copy[r][c] = array[r][c];
}
}
// checking the min number of operation due looping on all rows
int x = f(array);
// checking the mi num of operation due looping thriugh all coulomns
int y = f2(copy);
// choosing the minimum between them
int result = (x > y) ? y : x;
// finally printing the result
System.out.println(result);
// System.out.println(isPrime(2));
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
m,n = map(int,raw_input().split())
matrix_list = []
for i in range(m):
matrix_list.append(map(int,raw_input().split()))
def primesieve(n):
bool_list = []
list_primes = [0]
for i in xrange(n):
bool_list.append(True)
bool_list[0] = False
bool_list[1] = False
i=2
while i*i < n:
if bool_list[i] == True:
j = i*i
while j < n:
bool_list[j] = False
j+=i
i+=1
for i in xrange(n):
if bool_list[i]:
list_primes.append(i)
return list_primes
def binsearch(num,list_primes):
lo = 0
hi = len(list_primes)
while hi - lo > 1:
mid = (lo + hi) / 2
if list_primes[mid] == num:
return num
elif list_primes[mid] >= num:
hi = mid
else:
lo = mid
return list_primes[hi]
'''
for prime in list_primes:
if prime >= num:
return prime
'''
list_primes = primesieve(10**5+1000)
sum_list = []
for i in range(m):
sum_list.append([])
for j in xrange(n):
crap = binsearch(matrix_list[i][j], list_primes) - matrix_list[i][j]
sum_list[i].append(crap)
best = sum(sum_list[0])
for list in sum_list[1:]:
best = min(best,sum(list))
for i in xrange(n):
sum_crap = 0
for j in xrange(m):
sum_crap += sum_list[j][i]
best = min(sum_crap,best)
print best
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.ArrayList;
import java.util.Scanner;
public class Main{
public static boolean[] prime;
public static int min;
public static int getnext(int n){
while (prime[n]) {
n++;
}
return n;
}
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
prime = new boolean[100010];
min = Integer.MAX_VALUE;
prime[0] = true;
ArrayList<Integer> list = new ArrayList<Integer>();
int temp = 1;
for (int i = 2; i < prime.length; i++) {
if(!prime[i]){
//list.add(i);
int nex = i;
while (temp<prime.length) {
try{
prime[temp] = true;
}catch(Exception e){
break;
}
temp = nex*i;
nex++;
}
temp = 1;
}
}
//Integer[] z = new Integer[list.size()];
//z = list.toArray(new Integer[1]);
Scanner scanner = new Scanner(System.in);
int row = scanner.nextInt();
int colum = scanner.nextInt();
int[][] matrix = new int[row][colum];
for (int i = 0; i < row; i++) {
for (int j = 0; j < colum; j++) {
matrix[i][j] = scanner.nextInt();
}
}
////check rows
for (int i = 0; i < row; i++) {
int minim = 0;
for (int j = 0; j < colum; j++) {
minim = minim + getnext(matrix[i][j]) - matrix[i][j];
}
if(minim<min)
min = minim;
}
///check column
for (int i = 0; i < colum; i++) {
int minim = 0;
for (int j = 0; j < row; j++) {
minim = minim + getnext(matrix[j][i]) - matrix[j][i];
}
if(minim<min)
min = minim;
}
System.out.println(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #!/usr/bin/env python3
# Takes INT for number up to which to calculate primes.
# Returns 2 lists: list of primes and lists of flags corresponding to index of primes.
def find_primes(prime_len):
# Create a FLAG list of TRUE with length of values to search primes in.
flag_list = [True]*(prime_len)
# Make index 0, 1 not flagged as primes
flag_list[0] = flag_list[1] = False
# Initialize PRIME LIST - return
prime_list = []
for i in range(2,int((prime_len)**.5)):
if flag_list[i]:
for n in range(i+i,len(flag_list),i):
flag_list[n] = False
for idx in range(len(flag_list)):
if flag_list[idx]:
prime_list.append(idx)
return prime_list
def find_next_prime(prime_list, n):
sol = [0] * (n+1)
curr_prime_idx = 0
for i in range(n+1):
if i > prime_list[curr_prime_idx]:
curr_prime_idx +=1
sol[i] = prime_list[curr_prime_idx]
return sol
# Get PRIME LIST
prime_list = find_primes(10**5 + 5)
next_prime = find_next_prime(prime_list, 10**5)
max_dif = 0
# Get matrix dimentions[row,col]
dimentions = input()
dimentions = dimentions.split()
for i in range(len(dimentions)):
dimentions[i] = int(dimentions[i])
# get matrix
input_matrix = []
for r in range(dimentions[0]):
row = input()
row = row.split()
for n in range(len(row)):
row[n] = int(row[n])
input_matrix.append(row)
# Evaluate row moves necessary to get all values to the next prime
moves = 10**5
for row in input_matrix:
row_moves = 0
for val in row:
dist_to_next_prime = next_prime[val] - val
row_moves += dist_to_next_prime
moves = min(moves, row_moves)
#print(row_moves)
#print('moves: %d' % moves)
for col in range(dimentions[1]):
col_moves = 0
for row in input_matrix:
val = row[col]
dist_to_next_prime = next_prime[val] - val
col_moves += dist_to_next_prime
moves = min(moves, col_moves)
#print(col_moves)
#print('moves: %d' % moves)
#print(input_matrix)
print(moves)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
int prime[100001], mat[501][501];
void init() {
int i, j;
memset(prime, 0, sizeof(prime));
prime[0] = prime[1] = 1;
for (i = 2; i * i < 100001; i++) {
if (!prime[i]) {
for (j = i * i; j < 100001; j += i) {
prime[j] = 1;
}
}
}
j = 100003;
for (i = 100000; i >= 0; i--) {
if (!prime[i]) {
j = i;
}
prime[i] = j;
}
}
int main() {
int i, j, n, m, x, ans;
init();
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &x);
mat[i][j] = prime[x] - x;
}
}
ans = -1;
for (i = 0; i < n; i++) {
x = 0;
for (j = 0; j < m; j++) {
x += mat[i][j];
}
if (ans == -1 || ans > x) {
ans = x;
}
}
for (j = 0; j < m; j++) {
x = 0;
for (i = 0; i < n; i++) {
x += mat[i][j];
}
if (ans > x) ans = x;
}
printf("%d\n", ans);
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | // Author: Dr Jonathan Cazalas
// Date: October 25, 2016
import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Collections;
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
static class TaskB {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n, m; // n is rows, m is cols of the matrix
int idx; // idx of value in ArrayList
int minMoves = Integer.MAX_VALUE; // min number of moves
int sum; // used for summing cols and rows
int[][] matrix; // stores the input
int[][] moves2nextPrime; // stores the min # of increments till next prime
ArrayList<Integer> primes = new ArrayList<>();
// Scan input
n = in.nextInt();
m = in.nextInt();
matrix = new int[n][m];
moves2nextPrime = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = in.nextInt();
}
}
// Make ArrayList of primes
for (int i = 2; i <= 120000; i++) {
if (isPrime(i)) {
primes.add(i);
}
}
// Loop over matrix to find next prime number (after given number at cell)
// and then SAVE into moves2nextPrime matrix the number of increments
// needed until the next prime.
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
// CALL the binarySearch method
// IF found, it returns the index where found
// ELSE, method returns (-(insertion point) - 1).
// - basically, it returns the expected insertion point
// - which is GREAT, because this represents the NEXT prime
idx = Collections.binarySearch(primes, matrix[i][j]);
// IF idx is 0 or greater, this means the value was found
// Which means this value in the matrix is already prime
// Therefore, no moves needed
if (idx >= 0) {
moves2nextPrime[i][j] = 0;
}
// ELSE, idx is negative. This means it was NOT found.
// But the value returned (once we change it) is exactly
// what we want!
else {
// So this idx value will now give the index of the NEXT
// prime in the ArrayList
idx = -1 * (++idx);
moves2nextPrime[i][j] = primes.get(idx) - matrix[i][j];
}
}
}
// Now just loop over all rows, summing all cells in each row
// and seeing if that total is less than minMoves. If so, update
// minMoves and keep going. Do the same for columns.
// The final answer should be minMoves.
for (int row = 0; row < n; row++) {
sum = 0;
for (int col = 0; col < m; col++) {
sum += moves2nextPrime[row][col];
}
if (sum < minMoves) {
minMoves = sum;
}
}
for (int col = 0; col < m; col++) {
sum = 0;
for (int row = 0; row < n; row++) {
sum += moves2nextPrime[row][col];
}
if (sum < minMoves) {
minMoves = sum;
}
}
out.println(minMoves);
}
// This is a basic isPrime method.
// NOTE: we only check up to the Square Root of the number
// IF n % i is ever true, we return false. The number is not prime.
// Otherwise, if we *never* return false, then the number is prime...return true.
public boolean isPrime(int n) {
int squareRoot = (int) (Math.sqrt(n));
for (int i = 2; i <= squareRoot; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
}
catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m, a;
int step[505][505];
int prime[100005];
void IsPrime() {
int i;
prime[0] = prime[1] = 0;
prime[2] = 1;
for (i = 3; i <= 100005; i++) prime[i] = i % 2 == 0 ? 0 : 1;
int t = (int)sqrt(100005 * 1.0);
for (i = 3; i <= t; i++)
if (prime[i])
for (int j = i * i; j < 100005; j += 2 * i) prime[j] = 0;
}
int f(int n) {
if (prime[n] == 1)
return 0;
else
for (int i = n; i <= 100005; i++)
if (prime[i] == 1) return i - n;
}
int main() {
IsPrime();
while (scanf("%d%d", &n, &m) != EOF) {
memset(step, 0, sizeof(step));
int i, j;
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++) {
scanf("%d", &a);
step[i][j] = f(a);
}
int sum, Min;
sum = 0;
Min = 99999999;
for (i = 1; i <= n; i++) {
sum = 0;
for (j = 1; j <= m; j++) sum += step[i][j];
if (sum < Min) Min = sum;
}
for (j = 1; j <= m; j++) {
sum = 0;
for (i = 1; i <= n; i++) sum += step[i][j];
if (sum < Min) Min = sum;
}
printf("%d\n", Min);
}
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int m, n;
int a, x[510], y[510], d[100010];
bool z[100010];
int main() {
z[1] = 1;
for (int i = 2; i < 100010; i++)
if (z[i] == 0)
for (int j = 2; j * i < 100010; j++) z[j * i] = 1;
for (int i = 100005; i >= 1; i--) {
if (z[i] == 1)
d[i] = d[i + 1] + 1;
else
d[i] = 0;
}
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a;
x[i] += d[a];
y[j] += d[a];
}
sort(x, x + n);
sort(y, y + m);
cout << min(x[0], y[0]);
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
def prime(n):
for i in xrange(3, n):
if (n % i == 0):
return False
return True
primes = [[1, -1] for i in xrange(100500)]
primes[0] = [0, 2]
primes[1] = [0, 1]
for i in xrange(2, 318):
if (prime(i)):
j = 2
while (i*j < 100500):
primes[i*j][0] = 0
j += 1
for i in xrange(2, 100499):
for j in xrange(i+1, 100500):
if (primes[j][0]):
primes[i][1] = j - i
break
n, m = map(int, raw_input().split())
colums_gap = [0 for i in xrange(m)]
gap = 100500
cont = True
for i in xrange(n):
row = map(int, raw_input().split())
gap_row = 0
for j in xrange(m):
if (not primes[row[j]][0]):
colums_gap[j] += primes[row[j]][1]
gap_row += primes[row[j]][1]
if (gap_row < gap):
gap = gap_row
if (gap == 0):
cont = False
break
if(cont):
for i in xrange(m):
if (colums_gap[i] < gap):
gap = colums_gap[i]
if (gap == 0):
break
print(gap) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def rotated(array_2d):
list_of_tuples = zip(*array_2d[::-1])
return list([list(elem) for elem in list_of_tuples])
n=100100
p=[0,0]+[1]*(n)
p[0],p[1]=0,0
n1=int(n**0.5)
for i in range(2,n1):
if p[i]==1:
for j in range(i*i,n,i):
p[j]=0
for k in range(n,-1,-1):
if p[k]:
ind=k
p[k]=0
else:
p[k]=ind-k
lst=[]
x,y=map(int,input().split())
for j in range(x):
l=[]
for i in map(int,input().split()):
l.append(p[i])
lst.append(l)
st=[]
for x in lst:
st.append(sum(x))
for x in rotated(lst):
st.append(sum(x))
print(min(st)) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # resubimit
crivo = [True for i in xrange(1000000)]
crivo[0] = crivo[1] = False
for i in xrange(2, 1000000):
if not crivo[i]:
continue
for j in range(i * i, 1000000, i):
crivo[j] = False
n, m = map(int, raw_input().split())
data = []
for i in xrange(n):
data.append(map(int, raw_input().split()))
count = [0 for i in xrange(200000)]
count[100000] = 3
for i in xrange(99999, -1, -1):
if crivo[i]:
count[i] = 0
else:
count[i] = 1 + count[i+1]
res = 100000
for i in xrange(n):
sum = 0
for j in xrange(m):
sum += count[data[i][j]]
res = min(res, sum)
for i in xrange(m):
sum = 0
for j in xrange(n):
sum += count[data[j][i]]
res = min(res, sum)
print res
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
def findPrime (arr) :
largest = 100003
for index in range(100000,1,-1):
isPrime = True
root = math.floor(math.sqrt(index))
for div in range(2,root+1) :
if index%div == 0 :
isPrime = False
arr[index] = largest
break
if isPrime :
arr[index] = index
largest = index
def solve(row,col,matrix) :
sieve = [0]*100001
findPrime(sieve)
sieve[0] = 2
sieve[1] = 2
storeCol = [0]*(col)
smallestRow = None
for outerIndex in range(row) :
tempRow = 0
for innerIndex in range(col) :
diff = sieve[matrix[outerIndex][innerIndex]]- matrix[outerIndex][innerIndex]
tempRow += diff
storeCol[innerIndex] += diff
if smallestRow == None or tempRow < smallestRow :
smallestRow = tempRow
return min(min(storeCol),smallestRow)
r,c = list(map(int,input().split()))
matrix = []
for _ in range(r) :
matrix.append(list(map(int,input().split())))
print (solve(r,c,matrix))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.io.*;
import java.util.StringTokenizer;
public class PrimeMatrix {
static boolean esPrimo[] = new boolean[100000 + 100];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
criba(100090);
StringTokenizer st = new StringTokenizer(br.readLine());
int n1 = Integer.parseInt(st.nextToken());
int n2 = Integer.parseInt(st.nextToken());
//int mat[][] = new int[n1][n2];
int columns[] = new int[n2];
int menor = Integer.MAX_VALUE;
for (int i = 0; i < n1; i++) {
st = new StringTokenizer(br.readLine());
int mov = 0;
for (int j = 0; j < n2; j++) {
int n = Integer.parseInt(st.nextToken());
if (!esPrimo[n]) {
int aux = primCercano(n);
mov += aux;
columns[j] += aux;
}
}
if (mov < menor) {
menor = mov;
}
}
for (int i = 0; i < columns.length; i++) {
if (columns[i] < menor) {
menor = columns[i];
}
}
System.out.println(menor);
}
static int primCercano(int n) {
int cont = 0;
for (int i = n; i < esPrimo.length; i++) {
if (esPrimo[i]) {
break;
}
cont++;
}
return cont;
}
static void criba(int tam) {
for (int i = 2; i <= tam; ++i) {
esPrimo[i] = true;
}
esPrimo[0] = false;
esPrimo[1] = false;
for (int i = 2; i * i <= tam; ++i) {
if (esPrimo[i]) {
for (int h = 2; i * h <= tam; ++h) {
esPrimo[i * h] = false;
}
}
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 505;
int n, m, a[N][N];
int main() {
ios::sync_with_stdio(false);
cin >> n >> m;
set<int> st;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 2; i <= 2 * 100005; i++) {
int z = i;
for (int j = 2; j * j <= z; j++)
while (z % j == 0) z /= j;
if (z == i) st.insert(i);
}
long long mn = 1e9;
for (int i = 0; i < n; i++) {
long long cost = 0;
for (int j = 0; j < m; j++) cost += *(st.lower_bound(a[i][j])) - a[i][j];
mn = min(cost, mn);
}
for (int j = 0; j < m; j++) {
long long cost = 0;
for (int i = 0; i < n; i++) cost += *(st.lower_bound(a[i][j])) - a[i][j];
mn = min(cost, mn);
}
cout << mn;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int primes[200010];
vector<int> primesList;
int maze[505][505];
int n, m, t;
memset(primes, 0, sizeof(primes));
for (int i = 2; i * i <= 200000; i++) {
if (primes[i] == 1) continue;
for (int j = i * i; j <= 200000; j += i) {
primes[j] = 1;
}
}
for (int i = 2; i <= 200000; i++) {
if (primes[i] == 0) primesList.push_back(i);
}
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> maze[i][j];
}
}
int min_moves = 100000000;
for (int i = 0; i < n; i++) {
int cnt = 0;
for (int j = 0; j < m; j++) {
int pos = (lower_bound(primesList.begin(), primesList.end(), maze[i][j]) -
primesList.begin());
cnt += (primesList[pos] - maze[i][j]);
}
if (cnt < min_moves) min_moves = cnt;
}
for (int i = 0; i < m; i++) {
int cnt = 0;
for (int j = 0; j < n; j++) {
int pos = (lower_bound(primesList.begin(), primesList.end(), maze[j][i]) -
primesList.begin());
cnt += (primesList[pos] - maze[j][i]);
}
if (cnt < min_moves) min_moves = cnt;
}
cout << min_moves << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import time
primes = list()
def generate_primes():
a=[0]*100010
for x in xrange(2,100004):
if a[x]==0:
primes.append(x)
j=2
while j*x<100004:
a[j*x]=1
j+=1
def bin_search(x):
#if x < primes[0]: return -1
left = 0
right = len(primes)-1
while (right>left):
mid = (left+right)/2
if x == primes[mid]: return (mid,1)
if x>primes[mid]:
left=mid+1
else:
right=mid
return (left,0)
#print mid
n,m = map(int,raw_input().split())
mat = list()
for i in xrange(n):
mat.append(map(int,raw_input().split()))
start = time.time()
mas = generate_primes()
cols = list()
rows = list()
for i in xrange(n): cols.append(0)
for j in xrange(m): rows.append(0)
for i in xrange(n):
for j in xrange(m):
ind = bin_search(mat[i][j])
if ind[1]==1:
cols[i]+=0
rows[j]+=0
else:
cols[i]+=primes[ind[0]]-mat[i][j]
rows[j]+=primes[ind[0]]-mat[i][j]
ans = min(min(cols),min(rows))
print ans
finish = time.time()
#print (finish - start)
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import bisect
top = 10**5+10
pos = [True] * top
for i in range(2, top):
if pos[i]:
for j in range(2*i, top, i):
pos[j] = False
primes = [i for i in range(2, top) if pos[i]]
n, m = map(int, input().split())
rows = [0] * n
cols = [0] * m
for i in range(n):
row = list(map(int, input().split()))
for j in range(m):
nearest = bisect.bisect_left(primes, row[j])
rows[i] += primes[nearest] - row[j]
cols[j] += primes[nearest] - row[j]
if rows[i] == 0:
exit(print(0))
print(min(min(rows), min(cols)))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
# LINK FOR PROBLEM: http://codeforces.com/problemset/problem/271/B
## CRIVO
m = 10 ** 5 + 10
eh_primo = [True] * m
eh_primo[0] = False
eh_primo[1] = False
for i in xrange(int(math.sqrt(m))):
if eh_primo[i]:
for j in xrange(i * i, m, i):
eh_primo[j] = False
n, m = map(int, raw_input().split())
rows = []
columns = []
mydict = dict()
# gera matriz
matriz = []
for vez in range(n):
linha = map(int, raw_input().split())
matriz.append(linha)
# conta n_op por linhas
for i in range(n):
linha = matriz[i]
n_op = 0
for j in range(m):
num = linha[j]
temp = linha[j]
count = 0
if num in mydict:
n_op = n_op + mydict[num]
else:
while not eh_primo[num]:
num = num + 1
count = count + 1
n_op = n_op + count
mydict[temp] = count
rows.append(n_op)
# conta n_op por colunas
for i in range(m):
n_op = 0
for j in range(n):
num = matriz[j][i]
temp = matriz[j][i]
count = 0
if num in mydict:
n_op = n_op + mydict[num]
else:
while not eh_primo[num]:
num = num + 1
count = count + 1
n_op = n_op + count
mydict[temp] = count
columns.append(n_op)
min_rows = min(rows)
min_columns = min(columns)
if min_rows < min_columns:
print min_rows
else:
print min_columns
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import java.io.*;
public class taskB {
private static final int mx =1000000;
private static final long l=1000000000;
private static boolean primes[]=new boolean[mx+1];
private static void Eratos()
{
Arrays.fill(primes,true);
primes[0]=primes[1]=false;
for(int i=2;i*i<=mx;++i)
{
if(primes[i])
{
for(int j=i*i;j<=mx;j+=i)
primes[j]=false;
}
}
}
public void solve() {
int n=cin.nextInt();
int m=cin.nextInt();
int a[][]=new int [n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
a[i][j]=cin.nextInt();
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
if(!primes[a[i][j]])
{
int x=a[i][j];
while(!primes[a[i][j]])
{
++a[i][j];
}
a[i][j]-=x;
}
else
a[i][j]=0;
}
}
long res=l;
for(int i=0;i<n;i++)
{
long sum=0;
for(int j=0;j<m;j++)
sum+=a[i][j];
res=Math.min(sum,res);
}
for(int j=0;j<m;j++)
{
long sum=0;
for(int i=0;i<n;i++)
sum+=a[i][j];
res=Math.min(res,sum);
}
out.println(res);
}
public static void main(String[] args) throws IOException {
taskB solved = new taskB();
solved.Eratos();
solved.solve();
solved.out.close();
}
Scanner cin = new Scanner(System.in);
PrintWriter out = new PrintWriter(System.out);
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | /**
* @author Juan Sebastian Beltran Rojas
* @mail [email protected]
* @veredict No enviado
* @problemId CF166B.java
* @problemName CF166B.java
* @judge http://www.spoj.pl | http://uva.onlinejudge.org/ | http://livearchive.onlinejudge.org/
* @category ---
* @level ???
* @date 11/02/2013
**/
import java.io.*;
import java.util.*;
import static java.lang.Integer.*;
import static java.lang.Math.*;
public class CF166B{
public static void main(String args[]) throws Throwable{
BufferedReader in=new BufferedReader(new InputStreamReader(System.in));
boolean primos[]=new boolean[1000000];
primos[0]=primos[1]=true;
int[] p=new int[1000000];
int c=0;
for(int i=0;i<primos.length;i++)
if(!primos[i]){
p[c++]=i;
for(int j=i+i;j<primos.length;j+=i)
primos[j]=true;
}
StringTokenizer st=new StringTokenizer(in.readLine());
int N=parseInt(st.nextToken()),M=parseInt(st.nextToken());
int[][] mat=new int[N][M];
for(int i=0;i<N;i++){
st=new StringTokenizer(in.readLine());
for(int j=0;j<M;j++)mat[i][j]=parseInt(st.nextToken());
}
int min=MAX_VALUE;
for(int i=0;i<N;i++) {
int s=0;
for(int j=0;j<M;j++) {
int bs=Arrays.binarySearch(p,0,c,mat[i][j]);
if(bs<0)s+=(p[-bs-1]-mat[i][j]);
}
min=min(min,s);
}
for(int j=0;j<M;j++) {
int s=0;
for(int i=0;i<N;i++) {
int bs=Arrays.binarySearch(p,0,c,mat[i][j]);
if(bs<0)s+=(p[-bs-1]-mat[i][j]);
}
min=min(min,s);
}
System.out.println(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.InputStreamReader;
import java.io.IOException;
import java.util.Arrays;
import java.io.BufferedReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.StringTokenizer;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author Vaibhav Mittal
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
boolean[] isPrime = new boolean[1000000];
int[] minMoves = new int[1000000];
public TaskB() {
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i < isPrime.length; ++i)
if (isPrime[i])
for (int j = i * i; j < isPrime.length; j += i)
isPrime[j] = false;
for (int i = 0; i < isPrime.length; ++i)
if (isPrime[i])
for (int j = i - 1; j >= 0 && !isPrime[j]; --j)
minMoves[j] = i - j;
}
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.readInt();
int m = in.readInt();
int[] rowCost = new int[n];
int[] colCost = new int[m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int x = in.readInt();
rowCost[i] += minMoves[x];
colCost[j] += minMoves[x];
}
}
int res = Integer.MAX_VALUE;
for (int cost : rowCost) res = Math.min(res, cost);
for (int cost : colCost) res = Math.min(res, cost);
out.println(res);
}
}
class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException();
}
}
return tokenizer.nextToken();
}
public int readInt() {
return Integer.parseInt(next());
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long int inf = 1e18;
const long long int mod = 998244353;
bool sortbysec(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return (a.second < b.second);
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL), cout.tie(NULL);
long long int t, i, j, n, m, curr, p, x, mini = inf;
long long int prime[100070] = {0};
prime[0] = prime[1] = 1;
for (i = 2; i * i < 100070; i++) {
if (prime[i] != 1) {
for (j = i * i; j < 100070; j += i) prime[j] = 1;
}
}
i = 100069;
while (prime[i] != 0) i++;
curr = i;
while (i >= 0) {
if (!prime[i]) curr = i;
prime[i] = curr;
i--;
}
cin >> n >> m;
long long int col[m], row[n];
for (long long int i = 0; i < n; i++) row[i] = 0;
for (long long int i = 0; i < m; i++) col[i] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> p;
x = prime[p] - p;
col[j] += x;
row[i] += x;
}
mini = min(mini, row[i]);
}
for (i = 0; i < m; i++) mini = min(mini, col[i]);
cout << mini << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import static java.lang.Math.*;
import static java.util.Arrays.*;
import java.util.*;
import java.io.*;
public class Main {
int N = 100100;
int INF = 1<<28;
boolean[] p;
int[] dp;
void prime() {
p = new boolean[N];
dp = new int[N];
fill(dp, 10000);
for(int i=2;i<N;i++) if(!p[i]) {
for(int j=i*2;j<N;j+=i) p[j] = true;
dp[i] = 0;
}
for(int i=N-2;i>=0;i--) {
dp[i] = min(dp[i+1]+1, dp[i]);
}
}
void run() {
Scanner sc = new Scanner(System.in);
prime();
int r = sc.nextInt(), c = sc.nextInt();
int[] hor = new int[r];
int[] ver = new int[c];
for(int i=0;i<r;i++) for(int j=0;j<c;j++) {
int val = sc.nextInt();
hor[i] += dp[val];
ver[j] += dp[val];
}
int min = INF;
for(int i=0;i<r;i++) min = min(min, hor[i]);
for(int i=0;i<c;i++) min = min(min, ver[i]);
System.out.println(min);
}
void debug(Object... os) {
System.err.println(Arrays.deepToString(os));
}
public static void main(String[] args) {
new Main().run();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | from bisect import bisect
l=lambda:map(int,raw_input().split())
# p=[2,3]
# [p.append(i) for i in range(5,10**5+10,2) if all([i%x for x in p])]
p=[2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129,2131,2137,2141,2143,2153,2161,2179,2203,2207,2213,2221,2237,2239,2243,2251,2267,2269,2273,2281,2287,2293,2297,2309,2311,2333,2339,2341,2347,2351,2357,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423,2437,2441,2447,2459,2467,2473,2477,2503,2521,2531,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617,2621,2633,2647,2657,2659,2663,2671,2677,2683,2687,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741,2749,2753,2767,2777,2789,2791,2797,2801,2803,2819,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903,2909,2917,2927,2939,2953,2957,2963,2969,2971,2999,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079,3083,3089,3109,3119,3121,3137,3163,3167,3169,3181,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257,3259,3271,3299,3301,3307,3313,3319,3323,3329,3331,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413,3433,3449,3457,3461,3463,3467,3469,3491,3499,3511,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571,3581,3583,3593,3607,3613,3617,3623,3631,3637,3643,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727,3733,3739,3761,3767,3769,3779,3793,3797,3803,3821,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907,3911,3917,3919,3923,3929,3931,3943,3947,3967,3989,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057,4073,4079,4091,4093,4099,4111,4127,4129,4133,4139,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231,4241,4243,4253,4259,4261,4271,4273,4283,4289,4297,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409,4421,4423,4441,4447,4451,4457,4463,4481,4483,4493,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583,4591,4597,4603,4621,4637,4639,4643,4649,4651,4657,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751,4759,4783,4787,4789,4793,4799,4801,4813,4817,4831,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937,4943,4951,4957,4967,4969,4973,4987,4993,4999,5003,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087,5099,5101,5107,5113,5119,5147,5153,5167,5171,5179,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279,5281,5297,5303,5309,5323,5333,5347,5351,5381,5387,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443,5449,5471,5477,5479,5483,5501,5503,5507,5519,5521,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639,5641,5647,5651,5653,5657,5659,5669,5683,5689,5693,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791,5801,5807,5813,5821,5827,5839,5843,5849,5851,5857,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939,5953,5981,5987,6007,6011,6029,6037,6043,6047,6053,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133,6143,6151,6163,6173,6197,6199,6203,6211,6217,6221,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301,6311,6317,6323,6329,6337,6343,6353,6359,6361,6367,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473,6481,6491,6521,6529,6547,6551,6553,6563,6569,6571,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673,6679,6689,6691,6701,6703,6709,6719,6733,6737,6761,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833,6841,6857,6863,6869,6871,6883,6899,6907,6911,6917,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997,7001,7013,7019,7027,7039,7043,7057,7069,7079,7103,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207,7211,7213,7219,7229,7237,7243,7247,7253,7283,7297,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411,7417,7433,7451,7457,7459,7477,7481,7487,7489,7499,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561,7573,7577,7583,7589,7591,7603,7607,7621,7639,7643,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723,7727,7741,7753,7757,7759,7789,7793,7817,7823,7829,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919,7927,7933,7937,7949,7951,7963,7993,8009,8011,8017,8039,8053,8059,8069,8081,8087,8089,8093,8101,8111,8117,8123,8147,8161,8167,8171,8179,8191,8209,8219,8221,8231,8233,8237,8243,8263,8269,8273,8287,8291,8293,8297,8311,8317,8329,8353,8363,8369,8377,8387,8389,8419,8423,8429,8431,8443,8447,8461,8467,8501,8513,8521,8527,8537,8539,8543,8563,8573,8581,8597,8599,8609,8623,8627,8629,8641,8647,8663,8669,8677,8681,8689,8693,8699,8707,8713,8719,8731,8737,8741,8747,8753,8761,8779,8783,8803,8807,8819,8821,8831,8837,8839,8849,8861,8863,8867,8887,8893,8923,8929,8933,8941,8951,8963,8969,8971,8999,9001,9007,9011,9013,9029,9041,9043,9049,9059,9067,9091,9103,9109,9127,9133,9137,9151,9157,9161,9173,9181,9187,9199,9203,9209,9221,9227,9239,9241,9257,9277,9281,9283,9293,9311,9319,9323,9337,9341,9343,9349,9371,9377,9391,9397,9403,9413,9419,9421,9431,9433,9437,9439,9461,9463,9467,9473,9479,9491,9497,9511,9521,9533,9539,9547,9551,9587,9601,9613,9619,9623,9629,9631,9643,9649,9661,9677,9679,9689,9697,9719,9721,9733,9739,9743,9749,9767,9769,9781,9787,9791,9803,9811,9817,9829,9833,9839,9851,9857,9859,9871,9883,9887,9901,9907,9923,9929,9931,9941,9949,9967,9973,10007,10009,10037,10039,10061,10067,10069,10079,10091,10093,10099,10103,10111,10133,10139,10141,10151,10159,10163,10169,10177,10181,10193,10211,10223,10243,10247,10253,10259,10267,10271,10273,10289,10301,10303,10313,10321,10331,10333,10337,10343,10357,10369,10391,10399,10427,10429,10433,10453,10457,10459,10463,10477,10487,10499,10501,10513,10529,10531,10559,10567,10589,10597,10601,10607,10613,10627,10631,10639,10651,10657,10663,10667,10687,10691,10709,10711,10723,10729,10733,10739,10753,10771,10781,10789,10799,10831,10837,10847,10853,10859,10861,10867,10883,10889,10891,10903,10909,10937,10939,10949,10957,10973,10979,10987,10993,11003,11027,11047,11057,11059,11069,11071,11083,11087,11093,11113,11117,11119,11131,11149,11159,11161,11171,11173,11177,11197,11213,11239,11243,11251,11257,11261,11273,11279,11287,11299,11311,11317,11321,11329,11351,11353,11369,11383,11393,11399,11411,11423,11437,11443,11447,11467,11471,11483,11489,11491,11497,11503,11519,11527,11549,11551,11579,11587,11593,11597,11617,11621,11633,11657,11677,11681,11689,11699,11701,11717,11719,11731,11743,11777,11779,11783,11789,11801,11807,11813,11821,11827,11831,11833,11839,11863,11867,11887,11897,11903,11909,11923,11927,11933,11939,11941,11953,11959,11969,11971,11981,11987,12007,12011,12037,12041,12043,12049,12071,12073,12097,12101,12107,12109,12113,12119,12143,12149,12157,12161,12163,12197,12203,12211,12227,12239,12241,12251,12253,12263,12269,12277,12281,12289,12301,12323,12329,12343,12347,12373,12377,12379,12391,12401,12409,12413,12421,12433,12437,12451,12457,12473,12479,12487,12491,12497,12503,12511,12517,12527,12539,12541,12547,12553,12569,12577,12583,12589,12601,12611,12613,12619,12637,12641,12647,12653,12659,12671,12689,12697,12703,12713,12721,12739,12743,12757,12763,12781,12791,12799,12809,12821,12823,12829,12841,12853,12889,12893,12899,12907,12911,12917,12919,12923,12941,12953,12959,12967,12973,12979,12983,13001,13003,13007,13009,13033,13037,13043,13049,13063,13093,13099,13103,13109,13121,13127,13147,13151,13159,13163,13171,13177,13183,13187,13217,13219,13229,13241,13249,13259,13267,13291,13297,13309,13313,13327,13331,13337,13339,13367,13381,13397,13399,13411,13417,13421,13441,13451,13457,13463,13469,13477,13487,13499,13513,13523,13537,13553,13567,13577,13591,13597,13613,13619,13627,13633,13649,13669,13679,13681,13687,13691,13693,13697,13709,13711,13721,13723,13729,13751,13757,13759,13763,13781,13789,13799,13807,13829,13831,13841,13859,13873,13877,13879,13883,13901,13903,13907,13913,13921,13931,13933,13963,13967,13997,13999,14009,14011,14029,14033,14051,14057,14071,14081,14083,14087,14107,14143,14149,14153,14159,14173,14177,14197,14207,14221,14243,14249,14251,14281,14293,14303,14321,14323,14327,14341,14347,14369,14387,14389,14401,14407,14411,14419,14423,14431,14437,14447,14449,14461,14479,14489,14503,14519,14533,14537,14543,14549,14551,14557,14561,14563,14591,14593,14621,14627,14629,14633,14639,14653,14657,14669,14683,14699,14713,14717,14723,14731,14737,14741,14747,14753,14759,14767,14771,14779,14783,14797,14813,14821,14827,14831,14843,14851,14867,14869,14879,14887,14891,14897,14923,14929,14939,14947,14951,14957,14969,14983,15013,15017,15031,15053,15061,15073,15077,15083,15091,15101,15107,15121,15131,15137,15139,15149,15161,15173,15187,15193,15199,15217,15227,15233,15241,15259,15263,15269,15271,15277,15287,15289,15299,15307,15313,15319,15329,15331,15349,15359,15361,15373,15377,15383,15391,15401,15413,15427,15439,15443,15451,15461,15467,15473,15493,15497,15511,15527,15541,15551,15559,15569,15581,15583,15601,15607,15619,15629,15641,15643,15647,15649,15661,15667,15671,15679,15683,15727,15731,15733,15737,15739,15749,15761,15767,15773,15787,15791,15797,15803,15809,15817,15823,15859,15877,15881,15887,15889,15901,15907,15913,15919,15923,15937,15959,15971,15973,15991,16001,16007,16033,16057,16061,16063,16067,16069,16073,16087,16091,16097,16103,16111,16127,16139,16141,16183,16187,16189,16193,16217,16223,16229,16231,16249,16253,16267,16273,16301,16319,16333,16339,16349,16361,16363,16369,16381,16411,16417,16421,16427,16433,16447,16451,16453,16477,16481,16487,16493,16519,16529,16547,16553,16561,16567,16573,16603,16607,16619,16631,16633,16649,16651,16657,16661,16673,16691,16693,16699,16703,16729,16741,16747,16759,16763,16787,16811,16823,16829,16831,16843,16871,16879,16883,16889,16901,16903,16921,16927,16931,16937,16943,16963,16979,16981,16987,16993,17011,17021,17027,17029,17033,17041,17047,17053,17077,17093,17099,17107,17117,17123,17137,17159,17167,17183,17189,17191,17203,17207,17209,17231,17239,17257,17291,17293,17299,17317,17321,17327,17333,17341,17351,17359,17377,17383,17387,17389,17393,17401,17417,17419,17431,17443,17449,17467,17471,17477,17483,17489,17491,17497,17509,17519,17539,17551,17569,17573,17579,17581,17597,17599,17609,17623,17627,17657,17659,17669,17681,17683,17707,17713,17729,17737,17747,17749,17761,17783,17789,17791,17807,17827,17837,17839,17851,17863,17881,17891,17903,17909,17911,17921,17923,17929,17939,17957,17959,17971,17977,17981,17987,17989,18013,18041,18043,18047,18049,18059,18061,18077,18089,18097,18119,18121,18127,18131,18133,18143,18149,18169,18181,18191,18199,18211,18217,18223,18229,18233,18251,18253,18257,18269,18287,18289,18301,18307,18311,18313,18329,18341,18353,18367,18371,18379,18397,18401,18413,18427,18433,18439,18443,18451,18457,18461,18481,18493,18503,18517,18521,18523,18539,18541,18553,18583,18587,18593,18617,18637,18661,18671,18679,18691,18701,18713,18719,18731,18743,18749,18757,18773,18787,18793,18797,18803,18839,18859,18869,18899,18911,18913,18917,18919,18947,18959,18973,18979,19001,19009,19013,19031,19037,19051,19069,19073,19079,19081,19087,19121,19139,19141,19157,19163,19181,19183,19207,19211,19213,19219,19231,19237,19249,19259,19267,19273,19289,19301,19309,19319,19333,19373,19379,19381,19387,19391,19403,19417,19421,19423,19427,19429,19433,19441,19447,19457,19463,19469,19471,19477,19483,19489,19501,19507,19531,19541,19543,19553,19559,19571,19577,19583,19597,19603,19609,19661,19681,19687,19697,19699,19709,19717,19727,19739,19751,19753,19759,19763,19777,19793,19801,19813,19819,19841,19843,19853,19861,19867,19889,19891,19913,19919,19927,19937,19949,19961,19963,19973,19979,19991,19993,19997,20011,20021,20023,20029,20047,20051,20063,20071,20089,20101,20107,20113,20117,20123,20129,20143,20147,20149,20161,20173,20177,20183,20201,20219,20231,20233,20249,20261,20269,20287,20297,20323,20327,20333,20341,20347,20353,20357,20359,20369,20389,20393,20399,20407,20411,20431,20441,20443,20477,20479,20483,20507,20509,20521,20533,20543,20549,20551,20563,20593,20599,20611,20627,20639,20641,20663,20681,20693,20707,20717,20719,20731,20743,20747,20749,20753,20759,20771,20773,20789,20807,20809,20849,20857,20873,20879,20887,20897,20899,20903,20921,20929,20939,20947,20959,20963,20981,20983,21001,21011,21013,21017,21019,21023,21031,21059,21061,21067,21089,21101,21107,21121,21139,21143,21149,21157,21163,21169,21179,21187,21191,21193,21211,21221,21227,21247,21269,21277,21283,21313,21317,21319,21323,21341,21347,21377,21379,21383,21391,21397,21401,21407,21419,21433,21467,21481,21487,21491,21493,21499,21503,21517,21521,21523,21529,21557,21559,21563,21569,21577,21587,21589,21599,21601,21611,21613,21617,21647,21649,21661,21673,21683,21701,21713,21727,21737,21739,21751,21757,21767,21773,21787,21799,21803,21817,21821,21839,21841,21851,21859,21863,21871,21881,21893,21911,21929,21937,21943,21961,21977,21991,21997,22003,22013,22027,22031,22037,22039,22051,22063,22067,22073,22079,22091,22093,22109,22111,22123,22129,22133,22147,22153,22157,22159,22171,22189,22193,22229,22247,22259,22271,22273,22277,22279,22283,22291,22303,22307,22343,22349,22367,22369,22381,22391,22397,22409,22433,22441,22447,22453,22469,22481,22483,22501,22511,22531,22541,22543,22549,22567,22571,22573,22613,22619,22621,22637,22639,22643,22651,22669,22679,22691,22697,22699,22709,22717,22721,22727,22739,22741,22751,22769,22777,22783,22787,22807,22811,22817,22853,22859,22861,22871,22877,22901,22907,22921,22937,22943,22961,22963,22973,22993,23003,23011,23017,23021,23027,23029,23039,23041,23053,23057,23059,23063,23071,23081,23087,23099,23117,23131,23143,23159,23167,23173,23189,23197,23201,23203,23209,23227,23251,23269,23279,23291,23293,23297,23311,23321,23327,23333,23339,23357,23369,23371,23399,23417,23431,23447,23459,23473,23497,23509,23531,23537,23539,23549,23557,23561,23563,23567,23581,23593,23599,23603,23609,23623,23627,23629,23633,23663,23669,23671,23677,23687,23689,23719,23741,23743,23747,23753,23761,23767,23773,23789,23801,23813,23819,23827,23831,23833,23857,23869,23873,23879,23887,23893,23899,23909,23911,23917,23929,23957,23971,23977,23981,23993,24001,24007,24019,24023,24029,24043,24049,24061,24071,24077,24083,24091,24097,24103,24107,24109,24113,24121,24133,24137,24151,24169,24179,24181,24197,24203,24223,24229,24239,24247,24251,24281,24317,24329,24337,24359,24371,24373,24379,24391,24407,24413,24419,24421,24439,24443,24469,24473,24481,24499,24509,24517,24527,24533,24547,24551,24571,24593,24611,24623,24631,24659,24671,24677,24683,24691,24697,24709,24733,24749,24763,24767,24781,24793,24799,24809,24821,24841,24847,24851,24859,24877,24889,24907,24917,24919,24923,24943,24953,24967,24971,24977,24979,24989,25013,25031,25033,25037,25057,25073,25087,25097,25111,25117,25121,25127,25147,25153,25163,25169,25171,25183,25189,25219,25229,25237,25243,25247,25253,25261,25301,25303,25307,25309,25321,25339,25343,25349,25357,25367,25373,25391,25409,25411,25423,25439,25447,25453,25457,25463,25469,25471,25523,25537,25541,25561,25577,25579,25583,25589,25601,25603,25609,25621,25633,25639,25643,25657,25667,25673,25679,25693,25703,25717,25733,25741,25747,25759,25763,25771,25793,25799,25801,25819,25841,25847,25849,25867,25873,25889,25903,25913,25919,25931,25933,25939,25943,25951,25969,25981,25997,25999,26003,26017,26021,26029,26041,26053,26083,26099,26107,26111,26113,26119,26141,26153,26161,26171,26177,26183,26189,26203,26209,26227,26237,26249,26251,26261,26263,26267,26293,26297,26309,26317,26321,26339,26347,26357,26371,26387,26393,26399,26407,26417,26423,26431,26437,26449,26459,26479,26489,26497,26501,26513,26539,26557,26561,26573,26591,26597,26627,26633,26641,26647,26669,26681,26683,26687,26693,26699,26701,26711,26713,26717,26723,26729,26731,26737,26759,26777,26783,26801,26813,26821,26833,26839,26849,26861,26863,26879,26881,26891,26893,26903,26921,26927,26947,26951,26953,26959,26981,26987,26993,27011,27017,27031,27043,27059,27061,27067,27073,27077,27091,27103,27107,27109,27127,27143,27179,27191,27197,27211,27239,27241,27253,27259,27271,27277,27281,27283,27299,27329,27337,27361,27367,27397,27407,27409,27427,27431,27437,27449,27457,27479,27481,27487,27509,27527,27529,27539,27541,27551,27581,27583,27611,27617,27631,27647,27653,27673,27689,27691,27697,27701,27733,27737,27739,27743,27749,27751,27763,27767,27773,27779,27791,27793,27799,27803,27809,27817,27823,27827,27847,27851,27883,27893,27901,27917,27919,27941,27943,27947,27953,27961,27967,27983,27997,28001,28019,28027,28031,28051,28057,28069,28081,28087,28097,28099,28109,28111,28123,28151,28163,28181,28183,28201,28211,28219,28229,28277,28279,28283,28289,28297,28307,28309,28319,28349,28351,28387,28393,28403,28409,28411,28429,28433,28439,28447,28463,28477,28493,28499,28513,28517,28537,28541,28547,28549,28559,28571,28573,28579,28591,28597,28603,28607,28619,28621,28627,28631,28643,28649,28657,28661,28663,28669,28687,28697,28703,28711,28723,28729,28751,28753,28759,28771,28789,28793,28807,28813,28817,28837,28843,28859,28867,28871,28879,28901,28909,28921,28927,28933,28949,28961,28979,29009,29017,29021,29023,29027,29033,29059,29063,29077,29101,29123,29129,29131,29137,29147,29153,29167,29173,29179,29191,29201,29207,29209,29221,29231,29243,29251,29269,29287,29297,29303,29311,29327,29333,29339,29347,29363,29383,29387,29389,29399,29401,29411,29423,29429,29437,29443,29453,29473,29483,29501,29527,29531,29537,29567,29569,29573,29581,29587,29599,29611,29629,29633,29641,29663,29669,29671,29683,29717,29723,29741,29753,29759,29761,29789,29803,29819,29833,29837,29851,29863,29867,29873,29879,29881,29917,29921,29927,29947,29959,29983,29989,30011,30013,30029,30047,30059,30071,30089,30091,30097,30103,30109,30113,30119,30133,30137,30139,30161,30169,30181,30187,30197,30203,30211,30223,30241,30253,30259,30269,30271,30293,30307,30313,30319,30323,30341,30347,30367,30389,30391,30403,30427,30431,30449,30467,30469,30491,30493,30497,30509,30517,30529,30539,30553,30557,30559,30577,30593,30631,30637,30643,30649,30661,30671,30677,30689,30697,30703,30707,30713,30727,30757,30763,30773,30781,30803,30809,30817,30829,30839,30841,30851,30853,30859,30869,30871,30881,30893,30911,30931,30937,30941,30949,30971,30977,30983,31013,31019,31033,31039,31051,31063,31069,31079,31081,31091,31121,31123,31139,31147,31151,31153,31159,31177,31181,31183,31189,31193,31219,31223,31231,31237,31247,31249,31253,31259,31267,31271,31277,31307,31319,31321,31327,31333,31337,31357,31379,31387,31391,31393,31397,31469,31477,31481,31489,31511,31513,31517,31531,31541,31543,31547,31567,31573,31583,31601,31607,31627,31643,31649,31657,31663,31667,31687,31699,31721,31723,31727,31729,31741,31751,31769,31771,31793,31799,31817,31847,31849,31859,31873,31883,31891,31907,31957,31963,31973,31981,31991,32003,32009,32027,32029,32051,32057,32059,32063,32069,32077,32083,32089,32099,32117,32119,32141,32143,32159,32173,32183,32189,32191,32203,32213,32233,32237,32251,32257,32261,32297,32299,32303,32309,32321,32323,32327,32341,32353,32359,32363,32369,32371,32377,32381,32401,32411,32413,32423,32429,32441,32443,32467,32479,32491,32497,32503,32507,32531,32533,32537,32561,32563,32569,32573,32579,32587,32603,32609,32611,32621,32633,32647,32653,32687,32693,32707,32713,32717,32719,32749,32771,32779,32783,32789,32797,32801,32803,32831,32833,32839,32843,32869,32887,32909,32911,32917,32933,32939,32941,32957,32969,32971,32983,32987,32993,32999,33013,33023,33029,33037,33049,33053,33071,33073,33083,33091,33107,33113,33119,33149,33151,33161,33179,33181,33191,33199,33203,33211,33223,33247,33287,33289,33301,33311,33317,33329,33331,33343,33347,33349,33353,33359,33377,33391,33403,33409,33413,33427,33457,33461,33469,33479,33487,33493,33503,33521,33529,33533,33547,33563,33569,33577,33581,33587,33589,33599,33601,33613,33617,33619,33623,33629,33637,33641,33647,33679,33703,33713,33721,33739,33749,33751,33757,33767,33769,33773,33791,33797,33809,33811,33827,33829,33851,33857,33863,33871,33889,33893,33911,33923,33931,33937,33941,33961,33967,33997,34019,34031,34033,34039,34057,34061,34123,34127,34129,34141,34147,34157,34159,34171,34183,34211,34213,34217,34231,34253,34259,34261,34267,34273,34283,34297,34301,34303,34313,34319,34327,34337,34351,34361,34367,34369,34381,34403,34421,34429,34439,34457,34469,34471,34483,34487,34499,34501,34511,34513,34519,34537,34543,34549,34583,34589,34591,34603,34607,34613,34631,34649,34651,34667,34673,34679,34687,34693,34703,34721,34729,34739,34747,34757,34759,34763,34781,34807,34819,34841,34843,34847,34849,34871,34877,34883,34897,34913,34919,34939,34949,34961,34963,34981,35023,35027,35051,35053,35059,35069,35081,35083,35089,35099,35107,35111,35117,35129,35141,35149,35153,35159,35171,35201,35221,35227,35251,35257,35267,35279,35281,35291,35311,35317,35323,35327,35339,35353,35363,35381,35393,35401,35407,35419,35423,35437,35447,35449,35461,35491,35507,35509,35521,35527,35531,35533,35537,35543,35569,35573,35591,35593,35597,35603,35617,35671,35677,35729,35731,35747,35753,35759,35771,35797,35801,35803,35809,35831,35837,35839,35851,35863,35869,35879,35897,35899,35911,35923,35933,35951,35963,35969,35977,35983,35993,35999,36007,36011,36013,36017,36037,36061,36067,36073,36083,36097,36107,36109,36131,36137,36151,36161,36187,36191,36209,36217,36229,36241,36251,36263,36269,36277,36293,36299,36307,36313,36319,36341,36343,36353,36373,36383,36389,36433,36451,36457,36467,36469,36473,36479,36493,36497,36523,36527,36529,36541,36551,36559,36563,36571,36583,36587,36599,36607,36629,36637,36643,36653,36671,36677,36683,36691,36697,36709,36713,36721,36739,36749,36761,36767,36779,36781,36787,36791,36793,36809,36821,36833,36847,36857,36871,36877,36887,36899,36901,36913,36919,36923,36929,36931,36943,36947,36973,36979,36997,37003,37013,37019,37021,37039,37049,37057,37061,37087,37097,37117,37123,37139,37159,37171,37181,37189,37199,37201,37217,37223,37243,37253,37273,37277,37307,37309,37313,37321,37337,37339,37357,37361,37363,37369,37379,37397,37409,37423,37441,37447,37463,37483,37489,37493,37501,37507,37511,37517,37529,37537,37547,37549,37561,37567,37571,37573,37579,37589,37591,37607,37619,37633,37643,37649,37657,37663,37691,37693,37699,37717,37747,37781,37783,37799,37811,37813,37831,37847,37853,37861,37871,37879,37889,37897,37907,37951,37957,37963,37967,37987,37991,37993,37997,38011,38039,38047,38053,38069,38083,38113,38119,38149,38153,38167,38177,38183,38189,38197,38201,38219,38231,38237,38239,38261,38273,38281,38287,38299,38303,38317,38321,38327,38329,38333,38351,38371,38377,38393,38431,38447,38449,38453,38459,38461,38501,38543,38557,38561,38567,38569,38593,38603,38609,38611,38629,38639,38651,38653,38669,38671,38677,38693,38699,38707,38711,38713,38723,38729,38737,38747,38749,38767,38783,38791,38803,38821,38833,38839,38851,38861,38867,38873,38891,38903,38917,38921,38923,38933,38953,38959,38971,38977,38993,39019,39023,39041,39043,39047,39079,39089,39097,39103,39107,39113,39119,39133,39139,39157,39161,39163,39181,39191,39199,39209,39217,39227,39229,39233,39239,39241,39251,39293,39301,39313,39317,39323,39341,39343,39359,39367,39371,39373,39383,39397,39409,39419,39439,39443,39451,39461,39499,39503,39509,39511,39521,39541,39551,39563,39569,39581,39607,39619,39623,39631,39659,39667,39671,39679,39703,39709,39719,39727,39733,39749,39761,39769,39779,39791,39799,39821,39827,39829,39839,39841,39847,39857,39863,39869,39877,39883,39887,39901,39929,39937,39953,39971,39979,39983,39989,40009,40013,40031,40037,40039,40063,40087,40093,40099,40111,40123,40127,40129,40151,40153,40163,40169,40177,40189,40193,40213,40231,40237,40241,40253,40277,40283,40289,40343,40351,40357,40361,40387,40423,40427,40429,40433,40459,40471,40483,40487,40493,40499,40507,40519,40529,40531,40543,40559,40577,40583,40591,40597,40609,40627,40637,40639,40693,40697,40699,40709,40739,40751,40759,40763,40771,40787,40801,40813,40819,40823,40829,40841,40847,40849,40853,40867,40879,40883,40897,40903,40927,40933,40939,40949,40961,40973,40993,41011,41017,41023,41039,41047,41051,41057,41077,41081,41113,41117,41131,41141,41143,41149,41161,41177,41179,41183,41189,41201,41203,41213,41221,41227,41231,41233,41243,41257,41263,41269,41281,41299,41333,41341,41351,41357,41381,41387,41389,41399,41411,41413,41443,41453,41467,41479,41491,41507,41513,41519,41521,41539,41543,41549,41579,41593,41597,41603,41609,41611,41617,41621,41627,41641,41647,41651,41659,41669,41681,41687,41719,41729,41737,41759,41761,41771,41777,41801,41809,41813,41843,41849,41851,41863,41879,41887,41893,41897,41903,41911,41927,41941,41947,41953,41957,41959,41969,41981,41983,41999,42013,42017,42019,42023,42043,42061,42071,42073,42083,42089,42101,42131,42139,42157,42169,42179,42181,42187,42193,42197,42209,42221,42223,42227,42239,42257,42281,42283,42293,42299,42307,42323,42331,42337,42349,42359,42373,42379,42391,42397,42403,42407,42409,42433,42437,42443,42451,42457,42461,42463,42467,42473,42487,42491,42499,42509,42533,42557,42569,42571,42577,42589,42611,42641,42643,42649,42667,42677,42683,42689,42697,42701,42703,42709,42719,42727,42737,42743,42751,42767,42773,42787,42793,42797,42821,42829,42839,42841,42853,42859,42863,42899,42901,42923,42929,42937,42943,42953,42961,42967,42979,42989,43003,43013,43019,43037,43049,43051,43063,43067,43093,43103,43117,43133,43151,43159,43177,43189,43201,43207,43223,43237,43261,43271,43283,43291,43313,43319,43321,43331,43391,43397,43399,43403,43411,43427,43441,43451,43457,43481,43487,43499,43517,43541,43543,43573,43577,43579,43591,43597,43607,43609,43613,43627,43633,43649,43651,43661,43669,43691,43711,43717,43721,43753,43759,43777,43781,43783,43787,43789,43793,43801,43853,43867,43889,43891,43913,43933,43943,43951,43961,43963,43969,43973,43987,43991,43997,44017,44021,44027,44029,44041,44053,44059,44071,44087,44089,44101,44111,44119,44123,44129,44131,44159,44171,44179,44189,44201,44203,44207,44221,44249,44257,44263,44267,44269,44273,44279,44281,44293,44351,44357,44371,44381,44383,44389,44417,44449,44453,44483,44491,44497,44501,44507,44519,44531,44533,44537,44543,44549,44563,44579,44587,44617,44621,44623,44633,44641,44647,44651,44657,44683,44687,44699,44701,44711,44729,44741,44753,44771,44773,44777,44789,44797,44809,44819,44839,44843,44851,44867,44879,44887,44893,44909,44917,44927,44939,44953,44959,44963,44971,44983,44987,45007,45013,45053,45061,45077,45083,45119,45121,45127,45131,45137,45139,45161,45179,45181,45191,45197,45233,45247,45259,45263,45281,45289,45293,45307,45317,45319,45329,45337,45341,45343,45361,45377,45389,45403,45413,45427,45433,45439,45481,45491,45497,45503,45523,45533,45541,45553,45557,45569,45587,45589,45599,45613,45631,45641,45659,45667,45673,45677,45691,45697,45707,45737,45751,45757,45763,45767,45779,45817,45821,45823,45827,45833,45841,45853,45863,45869,45887,45893,45943,45949,45953,45959,45971,45979,45989,46021,46027,46049,46051,46061,46073,46091,46093,46099,46103,46133,46141,46147,46153,46171,46181,46183,46187,46199,46219,46229,46237,46261,46271,46273,46279,46301,46307,46309,46327,46337,46349,46351,46381,46399,46411,46439,46441,46447,46451,46457,46471,46477,46489,46499,46507,46511,46523,46549,46559,46567,46573,46589,46591,46601,46619,46633,46639,46643,46649,46663,46679,46681,46687,46691,46703,46723,46727,46747,46751,46757,46769,46771,46807,46811,46817,46819,46829,46831,46853,46861,46867,46877,46889,46901,46919,46933,46957,46993,46997,47017,47041,47051,47057,47059,47087,47093,47111,47119,47123,47129,47137,47143,47147,47149,47161,47189,47207,47221,47237,47251,47269,47279,47287,47293,47297,47303,47309,47317,47339,47351,47353,47363,47381,47387,47389,47407,47417,47419,47431,47441,47459,47491,47497,47501,47507,47513,47521,47527,47533,47543,47563,47569,47581,47591,47599,47609,47623,47629,47639,47653,47657,47659,47681,47699,47701,47711,47713,47717,47737,47741,47743,47777,47779,47791,47797,47807,47809,47819,47837,47843,47857,47869,47881,47903,47911,47917,47933,47939,47947,47951,47963,47969,47977,47981,48017,48023,48029,48049,48073,48079,48091,48109,48119,48121,48131,48157,48163,48179,48187,48193,48197,48221,48239,48247,48259,48271,48281,48299,48311,48313,48337,48341,48353,48371,48383,48397,48407,48409,48413,48437,48449,48463,48473,48479,48481,48487,48491,48497,48523,48527,48533,48539,48541,48563,48571,48589,48593,48611,48619,48623,48647,48649,48661,48673,48677,48679,48731,48733,48751,48757,48761,48767,48779,48781,48787,48799,48809,48817,48821,48823,48847,48857,48859,48869,48871,48883,48889,48907,48947,48953,48973,48989,48991,49003,49009,49019,49031,49033,49037,49043,49057,49069,49081,49103,49109,49117,49121,49123,49139,49157,49169,49171,49177,49193,49199,49201,49207,49211,49223,49253,49261,49277,49279,49297,49307,49331,49333,49339,49363,49367,49369,49391,49393,49409,49411,49417,49429,49433,49451,49459,49463,49477,49481,49499,49523,49529,49531,49537,49547,49549,49559,49597,49603,49613,49627,49633,49639,49663,49667,49669,49681,49697,49711,49727,49739,49741,49747,49757,49783,49787,49789,49801,49807,49811,49823,49831,49843,49853,49871,49877,49891,49919,49921,49927,49937,49939,49943,49957,49991,49993,49999,50021,50023,50033,50047,50051,50053,50069,50077,50087,50093,50101,50111,50119,50123,50129,50131,50147,50153,50159,50177,50207,50221,50227,50231,50261,50263,50273,50287,50291,50311,50321,50329,50333,50341,50359,50363,50377,50383,50387,50411,50417,50423,50441,50459,50461,50497,50503,50513,50527,50539,50543,50549,50551,50581,50587,50591,50593,50599,50627,50647,50651,50671,50683,50707,50723,50741,50753,50767,50773,50777,50789,50821,50833,50839,50849,50857,50867,50873,50891,50893,50909,50923,50929,50951,50957,50969,50971,50989,50993,51001,51031,51043,51047,51059,51061,51071,51109,51131,51133,51137,51151,51157,51169,51193,51197,51199,51203,51217,51229,51239,51241,51257,51263,51283,51287,51307,51329,51341,51343,51347,51349,51361,51383,51407,51413,51419,51421,51427,51431,51437,51439,51449,51461,51473,51479,51481,51487,51503,51511,51517,51521,51539,51551,51563,51577,51581,51593,51599,51607,51613,51631,51637,51647,51659,51673,51679,51683,51691,51713,51719,51721,51749,51767,51769,51787,51797,51803,51817,51827,51829,51839,51853,51859,51869,51871,51893,51899,51907,51913,51929,51941,51949,51971,51973,51977,51991,52009,52021,52027,52051,52057,52067,52069,52081,52103,52121,52127,52147,52153,52163,52177,52181,52183,52189,52201,52223,52237,52249,52253,52259,52267,52289,52291,52301,52313,52321,52361,52363,52369,52379,52387,52391,52433,52453,52457,52489,52501,52511,52517,52529,52541,52543,52553,52561,52567,52571,52579,52583,52609,52627,52631,52639,52667,52673,52691,52697,52709,52711,52721,52727,52733,52747,52757,52769,52783,52807,52813,52817,52837,52859,52861,52879,52883,52889,52901,52903,52919,52937,52951,52957,52963,52967,52973,52981,52999,53003,53017,53047,53051,53069,53077,53087,53089,53093,53101,53113,53117,53129,53147,53149,53161,53171,53173,53189,53197,53201,53231,53233,53239,53267,53269,53279,53281,53299,53309,53323,53327,53353,53359,53377,53381,53401,53407,53411,53419,53437,53441,53453,53479,53503,53507,53527,53549,53551,53569,53591,53593,53597,53609,53611,53617,53623,53629,53633,53639,53653,53657,53681,53693,53699,53717,53719,53731,53759,53773,53777,53783,53791,53813,53819,53831,53849,53857,53861,53881,53887,53891,53897,53899,53917,53923,53927,53939,53951,53959,53987,53993,54001,54011,54013,54037,54049,54059,54083,54091,54101,54121,54133,54139,54151,54163,54167,54181,54193,54217,54251,54269,54277,54287,54293,54311,54319,54323,54331,54347,54361,54367,54371,54377,54401,54403,54409,54413,54419,54421,54437,54443,54449,54469,54493,54497,54499,54503,54517,54521,54539,54541,54547,54559,54563,54577,54581,54583,54601,54617,54623,54629,54631,54647,54667,54673,54679,54709,54713,54721,54727,54751,54767,54773,54779,54787,54799,54829,54833,54851,54869,54877,54881,54907,54917,54919,54941,54949,54959,54973,54979,54983,55001,55009,55021,55049,55051,55057,55061,55073,55079,55103,55109,55117,55127,55147,55163,55171,55201,55207,55213,55217,55219,55229,55243,55249,55259,55291,55313,55331,55333,55337,55339,55343,55351,55373,55381,55399,55411,55439,55441,55457,55469,55487,55501,55511,55529,55541,55547,55579,55589,55603,55609,55619,55621,55631,55633,55639,55661,55663,55667,55673,55681,55691,55697,55711,55717,55721,55733,55763,55787,55793,55799,55807,55813,55817,55819,55823,55829,55837,55843,55849,55871,55889,55897,55901,55903,55921,55927,55931,55933,55949,55967,55987,55997,56003,56009,56039,56041,56053,56081,56087,56093,56099,56101,56113,56123,56131,56149,56167,56171,56179,56197,56207,56209,56237,56239,56249,56263,56267,56269,56299,56311,56333,56359,56369,56377,56383,56393,56401,56417,56431,56437,56443,56453,56467,56473,56477,56479,56489,56501,56503,56509,56519,56527,56531,56533,56543,56569,56591,56597,56599,56611,56629,56633,56659,56663,56671,56681,56687,56701,56711,56713,56731,56737,56747,56767,56773,56779,56783,56807,56809,56813,56821,56827,56843,56857,56873,56891,56893,56897,56909,56911,56921,56923,56929,56941,56951,56957,56963,56983,56989,56993,56999,57037,57041,57047,57059,57073,57077,57089,57097,57107,57119,57131,57139,57143,57149,57163,57173,57179,57191,57193,57203,57221,57223,57241,57251,57259,57269,57271,57283,57287,57301,57329,57331,57347,57349,57367,57373,57383,57389,57397,57413,57427,57457,57467,57487,57493,57503,57527,57529,57557,57559,57571,57587,57593,57601,57637,57641,57649,57653,57667,57679,57689,57697,57709,57713,57719,57727,57731,57737,57751,57773,57781,57787,57791,57793,57803,57809,57829,57839,57847,57853,57859,57881,57899,57901,57917,57923,57943,57947,57973,57977,57991,58013,58027,58031,58043,58049,58057,58061,58067,58073,58099,58109,58111,58129,58147,58151,58153,58169,58171,58189,58193,58199,58207,58211,58217,58229,58231,58237,58243,58271,58309,58313,58321,58337,58363,58367,58369,58379,58391,58393,58403,58411,58417,58427,58439,58441,58451,58453,58477,58481,58511,58537,58543,58549,58567,58573,58579,58601,58603,58613,58631,58657,58661,58679,58687,58693,58699,58711,58727,58733,58741,58757,58763,58771,58787,58789,58831,58889,58897,58901,58907,58909,58913,58921,58937,58943,58963,58967,58979,58991,58997,59009,59011,59021,59023,59029,59051,59053,59063,59069,59077,59083,59093,59107,59113,59119,59123,59141,59149,59159,59167,59183,59197,59207,59209,59219,59221,59233,59239,59243,59263,59273,59281,59333,59341,59351,59357,59359,59369,59377,59387,59393,59399,59407,59417,59419,59441,59443,59447,59453,59467,59471,59473,59497,59509,59513,59539,59557,59561,59567,59581,59611,59617,59621,59627,59629,59651,59659,59663,59669,59671,59693,59699,59707,59723,59729,59743,59747,59753,59771,59779,59791,59797,59809,59833,59863,59879,59887,59921,59929,59951,59957,59971,59981,59999,60013,60017,60029,60037,60041,60077,60083,60089,60091,60101,60103,60107,60127,60133,60139,60149,60161,60167,60169,60209,60217,60223,60251,60257,60259,60271,60289,60293,60317,60331,60337,60343,60353,60373,60383,60397,60413,60427,60443,60449,60457,60493,60497,60509,60521,60527,60539,60589,60601,60607,60611,60617,60623,60631,60637,60647,60649,60659,60661,60679,60689,60703,60719,60727,60733,60737,60757,60761,60763,60773,60779,60793,60811,60821,60859,60869,60887,60889,60899,60901,60913,60917,60919,60923,60937,60943,60953,60961,61001,61007,61027,61031,61043,61051,61057,61091,61099,61121,61129,61141,61151,61153,61169,61211,61223,61231,61253,61261,61283,61291,61297,61331,61333,61339,61343,61357,61363,61379,61381,61403,61409,61417,61441,61463,61469,61471,61483,61487,61493,61507,61511,61519,61543,61547,61553,61559,61561,61583,61603,61609,61613,61627,61631,61637,61643,61651,61657,61667,61673,61681,61687,61703,61717,61723,61729,61751,61757,61781,61813,61819,61837,61843,61861,61871,61879,61909,61927,61933,61949,61961,61967,61979,61981,61987,61991,62003,62011,62017,62039,62047,62053,62057,62071,62081,62099,62119,62129,62131,62137,62141,62143,62171,62189,62191,62201,62207,62213,62219,62233,62273,62297,62299,62303,62311,62323,62327,62347,62351,62383,62401,62417,62423,62459,62467,62473,62477,62483,62497,62501,62507,62533,62539,62549,62563,62581,62591,62597,62603,62617,62627,62633,62639,62653,62659,62683,62687,62701,62723,62731,62743,62753,62761,62773,62791,62801,62819,62827,62851,62861,62869,62873,62897,62903,62921,62927,62929,62939,62969,62971,62981,62983,62987,62989,63029,63031,63059,63067,63073,63079,63097,63103,63113,63127,63131,63149,63179,63197,63199,63211,63241,63247,63277,63281,63299,63311,63313,63317,63331,63337,63347,63353,63361,63367,63377,63389,63391,63397,63409,63419,63421,63439,63443,63463,63467,63473,63487,63493,63499,63521,63527,63533,63541,63559,63577,63587,63589,63599,63601,63607,63611,63617,63629,63647,63649,63659,63667,63671,63689,63691,63697,63703,63709,63719,63727,63737,63743,63761,63773,63781,63793,63799,63803,63809,63823,63839,63841,63853,63857,63863,63901,63907,63913,63929,63949,63977,63997,64007,64013,64019,64033,64037,64063,64067,64081,64091,64109,64123,64151,64153,64157,64171,64187,64189,64217,64223,64231,64237,64271,64279,64283,64301,64303,64319,64327,64333,64373,64381,64399,64403,64433,64439,64451,64453,64483,64489,64499,64513,64553,64567,64577,64579,64591,64601,64609,64613,64621,64627,64633,64661,64663,64667,64679,64693,64709,64717,64747,64763,64781,64783,64793,64811,64817,64849,64853,64871,64877,64879,64891,64901,64919,64921,64927,64937,64951,64969,64997,65003,65011,65027,65029,65033,65053,65063,65071,65089,65099,65101,65111,65119,65123,65129,65141,65147,65167,65171,65173,65179,65183,65203,65213,65239,65257,65267,65269,65287,65293,65309,65323,65327,65353,65357,65371,65381,65393,65407,65413,65419,65423,65437,65447,65449,65479,65497,65519,65521,65537,65539,65543,65551,65557,65563,65579,65581,65587,65599,65609,65617,65629,65633,65647,65651,65657,65677,65687,65699,65701,65707,65713,65717,65719,65729,65731,65761,65777,65789,65809,65827,65831,65837,65839,65843,65851,65867,65881,65899,65921,65927,65929,65951,65957,65963,65981,65983,65993,66029,66037,66041,66047,66067,66071,66083,66089,66103,66107,66109,66137,66161,66169,66173,66179,66191,66221,66239,66271,66293,66301,66337,66343,66347,66359,66361,66373,66377,66383,66403,66413,66431,66449,66457,66463,66467,66491,66499,66509,66523,66529,66533,66541,66553,66569,66571,66587,66593,66601,66617,66629,66643,66653,66683,66697,66701,66713,66721,66733,66739,66749,66751,66763,66791,66797,66809,66821,66841,66851,66853,66863,66877,66883,66889,66919,66923,66931,66943,66947,66949,66959,66973,66977,67003,67021,67033,67043,67049,67057,67061,67073,67079,67103,67121,67129,67139,67141,67153,67157,67169,67181,67187,67189,67211,67213,67217,67219,67231,67247,67261,67271,67273,67289,67307,67339,67343,67349,67369,67391,67399,67409,67411,67421,67427,67429,67433,67447,67453,67477,67481,67489,67493,67499,67511,67523,67531,67537,67547,67559,67567,67577,67579,67589,67601,67607,67619,67631,67651,67679,67699,67709,67723,67733,67741,67751,67757,67759,67763,67777,67783,67789,67801,67807,67819,67829,67843,67853,67867,67883,67891,67901,67927,67931,67933,67939,67943,67957,67961,67967,67979,67987,67993,68023,68041,68053,68059,68071,68087,68099,68111,68113,68141,68147,68161,68171,68207,68209,68213,68219,68227,68239,68261,68279,68281,68311,68329,68351,68371,68389,68399,68437,68443,68447,68449,68473,68477,68483,68489,68491,68501,68507,68521,68531,68539,68543,68567,68581,68597,68611,68633,68639,68659,68669,68683,68687,68699,68711,68713,68729,68737,68743,68749,68767,68771,68777,68791,68813,68819,68821,68863,68879,68881,68891,68897,68899,68903,68909,68917,68927,68947,68963,68993,69001,69011,69019,69029,69031,69061,69067,69073,69109,69119,69127,69143,69149,69151,69163,69191,69193,69197,69203,69221,69233,69239,69247,69257,69259,69263,69313,69317,69337,69341,69371,69379,69383,69389,69401,69403,69427,69431,69439,69457,69463,69467,69473,69481,69491,69493,69497,69499,69539,69557,69593,69623,69653,69661,69677,69691,69697,69709,69737,69739,69761,69763,69767,69779,69809,69821,69827,69829,69833,69847,69857,69859,69877,69899,69911,69929,69931,69941,69959,69991,69997,70001,70003,70009,70019,70039,70051,70061,70067,70079,70099,70111,70117,70121,70123,70139,70141,70157,70163,70177,70181,70183,70199,70201,70207,70223,70229,70237,70241,70249,70271,70289,70297,70309,70313,70321,70327,70351,70373,70379,70381,70393,70423,70429,70439,70451,70457,70459,70481,70487,70489,70501,70507,70529,70537,70549,70571,70573,70583,70589,70607,70619,70621,70627,70639,70657,70663,70667,70687,70709,70717,70729,70753,70769,70783,70793,70823,70841,70843,70849,70853,70867,70877,70879,70891,70901,70913,70919,70921,70937,70949,70951,70957,70969,70979,70981,70991,70997,70999,71011,71023,71039,71059,71069,71081,71089,71119,71129,71143,71147,71153,71161,71167,71171,71191,71209,71233,71237,71249,71257,71261,71263,71287,71293,71317,71327,71329,71333,71339,71341,71347,71353,71359,71363,71387,71389,71399,71411,71413,71419,71429,71437,71443,71453,71471,71473,71479,71483,71503,71527,71537,71549,71551,71563,71569,71593,71597,71633,71647,71663,71671,71693,71699,71707,71711,71713,71719,71741,71761,71777,71789,71807,71809,71821,71837,71843,71849,71861,71867,71879,71881,71887,71899,71909,71917,71933,71941,71947,71963,71971,71983,71987,71993,71999,72019,72031,72043,72047,72053,72073,72077,72089,72091,72101,72103,72109,72139,72161,72167,72169,72173,72211,72221,72223,72227,72229,72251,72253,72269,72271,72277,72287,72307,72313,72337,72341,72353,72367,72379,72383,72421,72431,72461,72467,72469,72481,72493,72497,72503,72533,72547,72551,72559,72577,72613,72617,72623,72643,72647,72649,72661,72671,72673,72679,72689,72701,72707,72719,72727,72733,72739,72763,72767,72797,72817,72823,72859,72869,72871,72883,72889,72893,72901,72907,72911,72923,72931,72937,72949,72953,72959,72973,72977,72997,73009,73013,73019,73037,73039,73043,73061,73063,73079,73091,73121,73127,73133,73141,73181,73189,73237,73243,73259,73277,73291,73303,73309,73327,73331,73351,73361,73363,73369,73379,73387,73417,73421,73433,73453,73459,73471,73477,73483,73517,73523,73529,73547,73553,73561,73571,73583,73589,73597,73607,73609,73613,73637,73643,73651,73673,73679,73681,73693,73699,73709,73721,73727,73751,73757,73771,73783,73819,73823,73847,73849,73859,73867,73877,73883,73897,73907,73939,73943,73951,73961,73973,73999,74017,74021,74027,74047,74051,74071,74077,74093,74099,74101,74131,74143,74149,74159,74161,74167,74177,74189,74197,74201,74203,74209,74219,74231,74257,74279,74287,74293,74297,74311,74317,74323,74353,74357,74363,74377,74381,74383,74411,74413,74419,74441,74449,74453,74471,74489,74507,74509,74521,74527,74531,74551,74561,74567,74573,74587,74597,74609,74611,74623,74653,74687,74699,74707,74713,74717,74719,74729,74731,74747,74759,74761,74771,74779,74797,74821,74827,74831,74843,74857,74861,74869,74873,74887,74891,74897,74903,74923,74929,74933,74941,74959,75011,75013,75017,75029,75037,75041,75079,75083,75109,75133,75149,75161,75167,75169,75181,75193,75209,75211,75217,75223,75227,75239,75253,75269,75277,75289,75307,75323,75329,75337,75347,75353,75367,75377,75389,75391,75401,75403,75407,75431,75437,75479,75503,75511,75521,75527,75533,75539,75541,75553,75557,75571,75577,75583,75611,75617,75619,75629,75641,75653,75659,75679,75683,75689,75703,75707,75709,75721,75731,75743,75767,75773,75781,75787,75793,75797,75821,75833,75853,75869,75883,75913,75931,75937,75941,75967,75979,75983,75989,75991,75997,76001,76003,76031,76039,76079,76081,76091,76099,76103,76123,76129,76147,76157,76159,76163,76207,76213,76231,76243,76249,76253,76259,76261,76283,76289,76303,76333,76343,76367,76369,76379,76387,76403,76421,76423,76441,76463,76471,76481,76487,76493,76507,76511,76519,76537,76541,76543,76561,76579,76597,76603,76607,76631,76649,76651,76667,76673,76679,76697,76717,76733,76753,76757,76771,76777,76781,76801,76819,76829,76831,76837,76847,76871,76873,76883,76907,76913,76919,76943,76949,76961,76963,76991,77003,77017,77023,77029,77041,77047,77069,77081,77093,77101,77137,77141,77153,77167,77171,77191,77201,77213,77237,77239,77243,77249,77261,77263,77267,77269,77279,77291,77317,77323,77339,77347,77351,77359,77369,77377,77383,77417,77419,77431,77447,77471,77477,77479,77489,77491,77509,77513,77521,77527,77543,77549,77551,77557,77563,77569,77573,77587,77591,77611,77617,77621,77641,77647,77659,77681,77687,77689,77699,77711,77713,77719,77723,77731,77743,77747,77761,77773,77783,77797,77801,77813,77839,77849,77863,77867,77893,77899,77929,77933,77951,77969,77977,77983,77999,78007,78017,78031,78041,78049,78059,78079,78101,78121,78137,78139,78157,78163,78167,78173,78179,78191,78193,78203,78229,78233,78241,78259,78277,78283,78301,78307,78311,78317,78341,78347,78367,78401,78427,78437,78439,78467,78479,78487,78497,78509,78511,78517,78539,78541,78553,78569,78571,78577,78583,78593,78607,78623,78643,78649,78653,78691,78697,78707,78713,78721,78737,78779,78781,78787,78791,78797,78803,78809,78823,78839,78853,78857,78877,78887,78889,78893,78901,78919,78929,78941,78977,78979,78989,79031,79039,79043,79063,79087,79103,79111,79133,79139,79147,79151,79153,79159,79181,79187,79193,79201,79229,79231,79241,79259,79273,79279,79283,79301,79309,79319,79333,79337,79349,79357,79367,79379,79393,79397,79399,79411,79423,79427,79433,79451,79481,79493,79531,79537,79549,79559,79561,79579,79589,79601,79609,79613,79621,79627,79631,79633,79657,79669,79687,79691,79693,79697,79699,79757,79769,79777,79801,79811,79813,79817,79823,79829,79841,79843,79847,79861,79867,79873,79889,79901,79903,79907,79939,79943,79967,79973,79979,79987,79997,79999,80021,80039,80051,80071,80077,80107,80111,80141,80147,80149,80153,80167,80173,80177,80191,80207,80209,80221,80231,80233,80239,80251,80263,80273,80279,80287,80309,80317,80329,80341,80347,80363,80369,80387,80407,80429,80447,80449,80471,80473,80489,80491,80513,80527,80537,80557,80567,80599,80603,80611,80621,80627,80629,80651,80657,80669,80671,80677,80681,80683,80687,80701,80713,80737,80747,80749,80761,80777,80779,80783,80789,80803,80809,80819,80831,80833,80849,80863,80897,80909,80911,80917,80923,80929,80933,80953,80963,80989,81001,81013,81017,81019,81023,81031,81041,81043,81047,81049,81071,81077,81083,81097,81101,81119,81131,81157,81163,81173,81181,81197,81199,81203,81223,81233,81239,81281,81283,81293,81299,81307,81331,81343,81349,81353,81359,81371,81373,81401,81409,81421,81439,81457,81463,81509,81517,81527,81533,81547,81551,81553,81559,81563,81569,81611,81619,81629,81637,81647,81649,81667,81671,81677,81689,81701,81703,81707,81727,81737,81749,81761,81769,81773,81799,81817,81839,81847,81853,81869,81883,81899,81901,81919,81929,81931,81937,81943,81953,81967,81971,81973,82003,82007,82009,82013,82021,82031,82037,82039,82051,82067,82073,82129,82139,82141,82153,82163,82171,82183,82189,82193,82207,82217,82219,82223,82231,82237,82241,82261,82267,82279,82301,82307,82339,82349,82351,82361,82373,82387,82393,82421,82457,82463,82469,82471,82483,82487,82493,82499,82507,82529,82531,82549,82559,82561,82567,82571,82591,82601,82609,82613,82619,82633,82651,82657,82699,82721,82723,82727,82729,82757,82759,82763,82781,82787,82793,82799,82811,82813,82837,82847,82883,82889,82891,82903,82913,82939,82963,82981,82997,83003,83009,83023,83047,83059,83063,83071,83077,83089,83093,83101,83117,83137,83177,83203,83207,83219,83221,83227,83231,83233,83243,83257,83267,83269,83273,83299,83311,83339,83341,83357,83383,83389,83399,83401,83407,83417,83423,83431,83437,83443,83449,83459,83471,83477,83497,83537,83557,83561,83563,83579,83591,83597,83609,83617,83621,83639,83641,83653,83663,83689,83701,83717,83719,83737,83761,83773,83777,83791,83813,83833,83843,83857,83869,83873,83891,83903,83911,83921,83933,83939,83969,83983,83987,84011,84017,84047,84053,84059,84061,84067,84089,84121,84127,84131,84137,84143,84163,84179,84181,84191,84199,84211,84221,84223,84229,84239,84247,84263,84299,84307,84313,84317,84319,84347,84349,84377,84389,84391,84401,84407,84421,84431,84437,84443,84449,84457,84463,84467,84481,84499,84503,84509,84521,84523,84533,84551,84559,84589,84629,84631,84649,84653,84659,84673,84691,84697,84701,84713,84719,84731,84737,84751,84761,84787,84793,84809,84811,84827,84857,84859,84869,84871,84913,84919,84947,84961,84967,84977,84979,84991,85009,85021,85027,85037,85049,85061,85081,85087,85091,85093,85103,85109,85121,85133,85147,85159,85193,85199,85201,85213,85223,85229,85237,85243,85247,85259,85297,85303,85313,85331,85333,85361,85363,85369,85381,85411,85427,85429,85439,85447,85451,85453,85469,85487,85513,85517,85523,85531,85549,85571,85577,85597,85601,85607,85619,85621,85627,85639,85643,85661,85667,85669,85691,85703,85711,85717,85733,85751,85781,85793,85817,85819,85829,85831,85837,85843,85847,85853,85889,85903,85909,85931,85933,85991,85999,86011,86017,86027,86029,86069,86077,86083,86111,86113,86117,86131,86137,86143,86161,86171,86179,86183,86197,86201,86209,86239,86243,86249,86257,86263,86269,86287,86291,86293,86297,86311,86323,86341,86351,86353,86357,86369,86371,86381,86389,86399,86413,86423,86441,86453,86461,86467,86477,86491,86501,86509,86531,86533,86539,86561,86573,86579,86587,86599,86627,86629,86677,86689,86693,86711,86719,86729,86743,86753,86767,86771,86783,86813,86837,86843,86851,86857,86861,86869,86923,86927,86929,86939,86951,86959,86969,86981,86993,87011,87013,87037,87041,87049,87071,87083,87103,87107,87119,87121,87133,87149,87151,87179,87181,87187,87211,87221,87223,87251,87253,87257,87277,87281,87293,87299,87313,87317,87323,87337,87359,87383,87403,87407,87421,87427,87433,87443,87473,87481,87491,87509,87511,87517,87523,87539,87541,87547,87553,87557,87559,87583,87587,87589,87613,87623,87629,87631,87641,87643,87649,87671,87679,87683,87691,87697,87701,87719,87721,87739,87743,87751,87767,87793,87797,87803,87811,87833,87853,87869,87877,87881,87887,87911,87917,87931,87943,87959,87961,87973,87977,87991,88001,88003,88007,88019,88037,88069,88079,88093,88117,88129,88169,88177,88211,88223,88237,88241,88259,88261,88289,88301,88321,88327,88337,88339,88379,88397,88411,88423,88427,88463,88469,88471,88493,88499,88513,88523,88547,88589,88591,88607,88609,88643,88651,88657,88661,88663,88667,88681,88721,88729,88741,88747,88771,88789,88793,88799,88801,88807,88811,88813,88817,88819,88843,88853,88861,88867,88873,88883,88897,88903,88919,88937,88951,88969,88993,88997,89003,89009,89017,89021,89041,89051,89057,89069,89071,89083,89087,89101,89107,89113,89119,89123,89137,89153,89189,89203,89209,89213,89227,89231,89237,89261,89269,89273,89293,89303,89317,89329,89363,89371,89381,89387,89393,89399,89413,89417,89431,89443,89449,89459,89477,89491,89501,89513,89519,89521,89527,89533,89561,89563,89567,89591,89597,89599,89603,89611,89627,89633,89653,89657,89659,89669,89671,89681,89689,89753,89759,89767,89779,89783,89797,89809,89819,89821,89833,89839,89849,89867,89891,89897,89899,89909,89917,89923,89939,89959,89963,89977,89983,89989,90001,90007,90011,90017,90019,90023,90031,90053,90059,90067,90071,90073,90089,90107,90121,90127,90149,90163,90173,90187,90191,90197,90199,90203,90217,90227,90239,90247,90263,90271,90281,90289,90313,90353,90359,90371,90373,90379,90397,90401,90403,90407,90437,90439,90469,90473,90481,90499,90511,90523,90527,90529,90533,90547,90583,90599,90617,90619,90631,90641,90647,90659,90677,90679,90697,90703,90709,90731,90749,90787,90793,90803,90821,90823,90833,90841,90847,90863,90887,90901,90907,90911,90917,90931,90947,90971,90977,90989,90997,91009,91019,91033,91079,91081,91097,91099,91121,91127,91129,91139,91141,91151,91153,91159,91163,91183,91193,91199,91229,91237,91243,91249,91253,91283,91291,91297,91303,91309,91331,91367,91369,91373,91381,91387,91393,91397,91411,91423,91433,91453,91457,91459,91463,91493,91499,91513,91529,91541,91571,91573,91577,91583,91591,91621,91631,91639,91673,91691,91703,91711,91733,91753,91757,91771,91781,91801,91807,91811,91813,91823,91837,91841,91867,91873,91909,91921,91939,91943,91951,91957,91961,91967,91969,91997,92003,92009,92033,92041,92051,92077,92083,92107,92111,92119,92143,92153,92173,92177,92179,92189,92203,92219,92221,92227,92233,92237,92243,92251,92269,92297,92311,92317,92333,92347,92353,92357,92363,92369,92377,92381,92383,92387,92399,92401,92413,92419,92431,92459,92461,92467,92479,92489,92503,92507,92551,92557,92567,92569,92581,92593,92623,92627,92639,92641,92647,92657,92669,92671,92681,92683,92693,92699,92707,92717,92723,92737,92753,92761,92767,92779,92789,92791,92801,92809,92821,92831,92849,92857,92861,92863,92867,92893,92899,92921,92927,92941,92951,92957,92959,92987,92993,93001,93047,93053,93059,93077,93083,93089,93097,93103,93113,93131,93133,93139,93151,93169,93179,93187,93199,93229,93239,93241,93251,93253,93257,93263,93281,93283,93287,93307,93319,93323,93329,93337,93371,93377,93383,93407,93419,93427,93463,93479,93481,93487,93491,93493,93497,93503,93523,93529,93553,93557,93559,93563,93581,93601,93607,93629,93637,93683,93701,93703,93719,93739,93761,93763,93787,93809,93811,93827,93851,93871,93887,93889,93893,93901,93911,93913,93923,93937,93941,93949,93967,93971,93979,93983,93997,94007,94009,94033,94049,94057,94063,94079,94099,94109,94111,94117,94121,94151,94153,94169,94201,94207,94219,94229,94253,94261,94273,94291,94307,94309,94321,94327,94331,94343,94349,94351,94379,94397,94399,94421,94427,94433,94439,94441,94447,94463,94477,94483,94513,94529,94531,94541,94543,94547,94559,94561,94573,94583,94597,94603,94613,94621,94649,94651,94687,94693,94709,94723,94727,94747,94771,94777,94781,94789,94793,94811,94819,94823,94837,94841,94847,94849,94873,94889,94903,94907,94933,94949,94951,94961,94993,94999,95003,95009,95021,95027,95063,95071,95083,95087,95089,95093,95101,95107,95111,95131,95143,95153,95177,95189,95191,95203,95213,95219,95231,95233,95239,95257,95261,95267,95273,95279,95287,95311,95317,95327,95339,95369,95383,95393,95401,95413,95419,95429,95441,95443,95461,95467,95471,95479,95483,95507,95527,95531,95539,95549,95561,95569,95581,95597,95603,95617,95621,95629,95633,95651,95701,95707,95713,95717,95723,95731,95737,95747,95773,95783,95789,95791,95801,95803,95813,95819,95857,95869,95873,95881,95891,95911,95917,95923,95929,95947,95957,95959,95971,95987,95989,96001,96013,96017,96043,96053,96059,96079,96097,96137,96149,96157,96167,96179,96181,96199,96211,96221,96223,96233,96259,96263,96269,96281,96289,96293,96323,96329,96331,96337,96353,96377,96401,96419,96431,96443,96451,96457,96461,96469,96479,96487,96493,96497,96517,96527,96553,96557,96581,96587,96589,96601,96643,96661,96667,96671,96697,96703,96731,96737,96739,96749,96757,96763,96769,96779,96787,96797,96799,96821,96823,96827,96847,96851,96857,96893,96907,96911,96931,96953,96959,96973,96979,96989,96997,97001,97003,97007,97021,97039,97073,97081,97103,97117,97127,97151,97157,97159,97169,97171,97177,97187,97213,97231,97241,97259,97283,97301,97303,97327,97367,97369,97373,97379,97381,97387,97397,97423,97429,97441,97453,97459,97463,97499,97501,97511,97523,97547,97549,97553,97561,97571,97577,97579,97583,97607,97609,97613,97649,97651,97673,97687,97711,97729,97771,97777,97787,97789,97813,97829,97841,97843,97847,97849,97859,97861,97871,97879,97883,97919,97927,97931,97943,97961,97967,97973,97987,98009,98011,98017,98041,98047,98057,98081,98101,98123,98129,98143,98179,98207,98213,98221,98227,98251,98257,98269,98297,98299,98317,98321,98323,98327,98347,98369,98377,98387,98389,98407,98411,98419,98429,98443,98453,98459,98467,98473,98479,98491,98507,98519,98533,98543,98561,98563,98573,98597,98621,98627,98639,98641,98663,98669,98689,98711,98713,98717,98729,98731,98737,98773,98779,98801,98807,98809,98837,98849,98867,98869,98873,98887,98893,98897,98899,98909,98911,98927,98929,98939,98947,98953,98963,98981,98993,98999,99013,99017,99023,99041,99053,99079,99083,99089,99103,99109,99119,99131,99133,99137,99139,99149,99173,99181,99191,99223,99233,99241,99251,99257,99259,99277,99289,99317,99347,99349,99367,99371,99377,99391,99397,99401,99409,99431,99439,99469,99487,99497,99523,99527,99529,99551,99559,99563,99571,99577,99581,99607,99611,99623,99643,99661,99667,99679,99689,99707,99709,99713,99719,99721,99733,99761,99767,99787,99793,99809,99817,99823,99829,99833,99839,99859,99871,99877,99881,99901,99907,99923,99929,99961,99971,99989,99991,100003]
n,m=l()
h=[l() for _ in range(n)]
v=[ e for e in zip(*h)]
def getmov(data):
cnt=0
for x in data:
t=bisect(p,x)
if p[t-1]<>x:
cnt+=p[t]-x
return cnt
ans=10**5
for line in h:
ans=min(ans,getmov(line))
for line in v:
ans=min(ans,getmov(line))
print ans | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 500 + 10;
const int MAXP = 1e5 + 100;
bool prime[MAXP];
void initPrime() {
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (int i = 2; i < MAXP; ++i) {
if (prime[i]) {
for (int j = i + i; j < MAXP; j += i) {
prime[j] = false;
}
}
}
}
int n, m, a, c[MAXN][MAXN];
int main() {
initPrime();
cin >> n >> m;
int ans = 1e9;
for (int i = 0; i < n; ++i) {
int sum = 0;
for (int j = 0; j < m; ++j) {
cin >> a;
while (not prime[a++]) {
++c[i][j];
}
sum += c[i][j];
}
ans = min(ans, sum);
}
for (int j = 0; j < m; ++j) {
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += c[i][j];
}
ans = min(ans, sum);
}
cout << ans << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int prime[100004];
void sieve() {
prime[1] = 1;
for (int i = 4; i < 100004; i += 2) prime[i] = 1;
int root = sqrt(100004);
for (int i = 3; i <= root; i += 2) {
if (prime[i] == 0) {
for (int j = i * i; j < 100004; j += i * 2) {
prime[j] = 1;
}
}
}
}
int main() {
sieve();
int n, m, i, j;
while (scanf("%d%d", &n, &m) == 2) {
int input[n][m], prime_ara[n][m], row[n + m], colomn[m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &input[i][j]);
if (prime[input[i][j]] == 1) {
int tmp = input[i][j];
while (prime[++tmp] == 1)
;
prime_ara[i][j] = tmp;
} else {
prime_ara[i][j] = input[i][j];
}
}
}
int x = 0, sum;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
sum += prime_ara[i][j] - input[i][j];
}
row[x++] = sum;
}
int y = 0;
for (i = 0; i < m; i++) {
sum = 0;
for (j = 0; j < n; j++) {
sum += prime_ara[j][i] - input[j][i];
}
colomn[y++] = sum;
}
for (i = 0; i < y; i++) {
row[x++] = colomn[i];
}
sort(row, row + x);
printf("%d\n", row[0]);
}
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int M = 1e5 + 5;
int n, m, t[550][550], ans = 2e9, vis[M];
vector<int> p;
void pre() {
for (int i = 2; i < M; i++) {
if (!vis[i]) {
p.push_back(i);
for (int j = i + i; j < M; j += i) vis[j] = 1;
}
}
}
int main() {
pre();
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> t[i][j];
}
}
for (int i = 0; i < n; i++) {
int g = 0;
for (int j = 0; j < m; j++) {
g += *lower_bound(p.begin(), p.end(), t[i][j]) - t[i][j];
}
ans = min(ans, g);
}
for (int i = 0; i < m; i++) {
int g = 0;
for (int j = 0; j < n; j++) {
g += *lower_bound(p.begin(), p.end(), t[j][i]) - t[j][i];
}
ans = min(ans, g);
}
cout << ans;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | primes = []
isPrime = [True for i in range(10**5 + 7)]
nextPrime = []
#crivo
isPrime[1] = isPrime[0] = False
for i in range(2, 10**5 + 7):
if isPrime[i] == True:
primes.append(i)
for j in range(i * i, 10**5 + 7, i):
isPrime[j] = False
aux = 0
for i in range(10**5 + 1):
nextPrime.append(primes[aux])
if isPrime[i] == True:
aux += 1
n, m = list(map(int, input().split(' ')))
matriz = [list(map(int, input().split(' '))) for i in range(n)]
answer = float('inf')
#Testar linhas
for i in range(n):
possibleAnswer = 0
for j in range(m):
possibleAnswer += nextPrime[matriz[i][j]] - matriz[i][j]
answer = min(answer, possibleAnswer)
#Testar coluna
for i in range(m):
possibleAnswer = 0
for j in range(n):
possibleAnswer += nextPrime[matriz[j][i]] - matriz[j][i]
answer = min(answer, possibleAnswer)
print(answer)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import copy
from bisect import bisect_left
primes = []
def sieve():
M = int(1e6)
prime = [True for i in range(M + 1)]
p = 2
while p * p <= M:
if prime[p]:
for i in range(p * 2, M + 1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
for p in range(M + 1):
if prime[p]:
primes.append(p)
if __name__ == '__main__':
sieve()
n, m = map(int, input().split())
o = [list(map(int, input().split())) for _ in range(n)]
v = copy.deepcopy(o)
for (j, x) in enumerate(v):
for (i, y) in enumerate(x):
v[j][i] = primes[bisect_left(primes, y)]
sol = 1e10
for (a, b) in zip(o, v):
ctn = 0
for (x, y) in zip(a, b):
ctn += abs(x - y)
if ctn < sol:
sol = ctn
for (a, b) in zip(zip(*o), zip(*v)):
ctn = 0
for (x, y) in zip(a, b):
ctn += abs(x - y)
if ctn < sol:
sol = ctn
print(sol)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import static java.lang.Math.*;
import static java.lang.reflect.Array.*;
import static java.util.Arrays.*;
import java.io.*;
import java.lang.reflect.*;
import java.util.*;
public class B {
final int MOD = (int)1e9 + 7;
final double eps = 1e-12;
final int INF = (int)1e9;
public B () {
int N = sc.nextInt();
int M = sc.nextInt();
Integer [][] A = sc.nextInts(N);
int res = solve(A);
res = min(res, solve(transpose(A)));
exit(res);
}
int solve(Integer [][] A) {
int res = INF, N = A.length, M = A[0].length;
for (int i = 0; i < N; ++i) {
int cnt = 0;
for (int j = 0; j < M; ++j) {
int s = binarySearch(P, A[i][j]);
if (s < 0)
cnt += P[-(s+1)] - A[i][j];
}
res = min(res, cnt);
}
return res;
}
int MAX = (int)2e5;
Integer [] P = primes(MAX);
Integer [] primes(int N) {
boolean [] C = new boolean [N+1];
int Q = (int)Math.floor(Math.sqrt(N));
for (int p = 3; p <= Q; p += 2) {
if (!C[p]) {
int R = N/p;
for (int j = p; j <= R; ++j)
C[j*p] = true;
}
}
List<Integer> P = new ArrayList<Integer>();
if (N >= 2)
P.add(2);
for (int p = 3; p <= N; p += 2)
if (!C[p])
P.add(p);
return P.toArray(new Integer[0]);
}
<T> T [][] transpose(T [][] S) {
int R = S.length, C = S[0].length;
T [][] res = newArray(S, C);
for (int i = 0; i < C; ++i) {
res[i] = newArray(S[0], R);
for (int j = 0; j < R; ++j)
res[i][j] = S[j][i];
}
return res;
}
<T> T [] newArray(T [] A) {
return newArray(A, A.length);
}
@SuppressWarnings("unchecked")
<T> T [] newArray(T [] A, int N) {
return (T[]) newInstance(A.getClass().getComponentType(), N);
}
////////////////////////////////////////////////////////////////////////////////////
static MyScanner sc;
static class MyScanner {
public String next() {
newLine();
return line[index++];
}
public char nextChar() {
return next().charAt(0);
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public String nextLine() {
line = null;
return readLine();
}
public String [] nextStrings() {
line = null;
return readLine().split(" ");
}
public char [] nextChars() {
return next().toCharArray();
}
public Integer [] nextInts() {
String [] L = nextStrings();
Integer [] res = new Integer [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Integer.parseInt(L[i]);
return res;
}
public Long [] nextLongs() {
String [] L = nextStrings();
Long [] res = new Long [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Long.parseLong(L[i]);
return res;
}
public Double [] nextDoubles() {
String [] L = nextStrings();
Double [] res = new Double [L.length];
for (int i = 0; i < L.length; ++i)
res[i] = Double.parseDouble(L[i]);
return res;
}
public Integer [][] nextInts(int N) {
Integer [][] res = new Integer [N][];
for (int i = 0; i < N; ++i)
res[i] = nextInts();
return res;
}
//////////////////////////////////////////////
private boolean eol() {
return index == line.length;
}
private String readLine() {
try {
return r.readLine();
} catch (Exception e) {
throw new Error(e);
}
}
private final BufferedReader r;
MyScanner () {
this(new BufferedReader(new InputStreamReader(System.in)));
}
MyScanner(BufferedReader r) {
try {
this.r = r;
while (!r.ready())
Thread.sleep(1);
start();
} catch (Exception e) {
throw new Error(e);
}
}
private String [] line;
private int index;
private void newLine() {
if (line == null || eol()) {
line = readLine().split(" ");
index = 0;
}
}
}
static void print (Object o, Object... a) {
pw.println(build(o, a));
}
static void exit (Object o, Object... a) {
print(o, a);
exit();
}
static void exit () {
pw.close();
System.out.flush();
System.err.println("------------------");
System.err.println("Time: " + ((millis() - t) / 1000.0));
System.exit(0);
}
void NO() {
throw new Error("NO!");
}
////////////////////////////////////////////////////////////////////////////////////
static String build(Object... a) {
StringBuilder b = new StringBuilder();
for (Object o : a)
append(b, o);
return b.toString().trim();
}
static void append(StringBuilder b, Object o) {
if (o.getClass().isArray()) {
int L = Array.getLength(o);
for (int i = 0; i < L; ++i)
append(b, Array.get(o, i));
} else if (o instanceof Iterable<?>) {
for (Object p : (Iterable<?>)o)
append(b, p);
} else
b.append(" ").append(o);
}
////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
sc = new MyScanner ();
new B();
exit();
}
static void start() {
t = millis();
}
static PrintWriter pw = new PrintWriter(System.out);
static long t;
static long millis() {
return System.currentTimeMillis();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | N_MAX = (10**5 + 7)
N, M = 0, 0
matrix = [[]]
closest_prime = [[]]
prime = [True] * N_MAX
## Sieve of Eratosthenes
def sieve():
global prime
global closest_prime
prime[0] = False
prime[1] = False
closest_prime = [0] * N_MAX
def backtrack(value):
closest_prime[value] = value
for i in range(value - 1, -1, -1):
if prime[i]: return
closest_prime[i] = value
for i in range(2, 10**5 + 7):
if prime[i] == True:
backtrack(i)
for j in range(i * i, 10**5 + 7, i):
prime[j] = False
def entrypoint():
global N, M, matrix
N, M = list(map(int, input().split()))
read_row = lambda : list(map(int, input().split()))
matrix = [read_row() for i in range(N)]
## Computes cost of transforming row or column in prime
def compute_cost(index, type='ROW'):
values = []
if type == 'ROW':
values = matrix[index]
elif type == 'COL':
values = [matrix[j][index] for j in range(N)]
value_cost = lambda x : closest_prime[x] - x
cost = sum([value_cost(value) for value in values])
return cost
def compute_min_moves():
costs = []
costs += [compute_cost(i, type='ROW') for i in range(N)]
costs += [compute_cost(i, type='COL') for i in range(M)]
print(min(costs))
def main():
sieve()
entrypoint()
compute_min_moves()
if __name__ == "__main__":
main() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
void fast() {
ios_base::sync_with_stdio(NULL);
cin.tie(0);
cout.tie(0);
}
void online_judge() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
const int flag_max = 0x3f3f3f3f;
const long long OO = 1e9;
const double EPS = (1e-7);
int dcmp(double x, double y) { return fabs(x - y) <= EPS ? 0 : x < y ? -1 : 1; }
long long gcd(long long a, long long b) { return !b ? a : gcd(b, a % b); }
long long lcm(long long a, long long b) { return (a / gcd(a, b)) * b; }
vector<long long> prime;
bool isprime[10000000];
void SieveOfEratosthenes(int n) {
memset(isprime, true, sizeof(isprime));
isprime[1] = 0;
for (int p = 2; p * p <= n; p++) {
if (isprime[p] == true) {
for (int i = p * p; i <= n; i += p) isprime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (isprime[p]) prime.push_back(p);
}
int main() {
fast();
SieveOfEratosthenes(100009);
long long ans = INT_MAX;
vector<long long>::iterator it;
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
long long dif = 0;
for (int j = 0; j < m; j++) {
if (isprime[arr[i][j]] == true) {
continue;
} else {
it = upper_bound(prime.begin(), prime.end(), arr[i][j]);
dif += (long long)(*it) - arr[i][j];
}
}
ans = min(dif, ans);
}
for (int i = 0; i < m; i++) {
long long dif = 0;
for (int j = 0; j < n; j++) {
if (isprime[arr[j][i]] == true) {
continue;
} else {
it = upper_bound(prime.begin(), prime.end(), arr[j][i]);
dif += (*it) - arr[j][i];
}
}
ans = min(dif, ans);
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | /* package whatever; // don't place package name! */
import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public final class Ideone
{
public static void main (String[] args) throws java.lang.Exception
{
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int m=sc.nextInt();
int M=100011;
boolean prime[]=new boolean[M];
prime[0]=false;
prime[1]=false;
for(int i=2;i<100011;i++)
prime[i]=true;;
for (int i = 2; i * i < M; ++i)
{
if (prime[i])
{
for (int j = i + i; j < M; j += i)
{
prime[j] = false;
}
}
}
int rows[]=new int[n];
int columns[]=new int[m];
for(int i=0;i<m;i++)
columns[i]=0;
for(int i=0;i<n;i++)
{
rows[i]=0;
//columns[i]=0;
for(int j=0;j<m;j++)
{
int x=sc.nextInt();
int y=x;
while(!prime[y])
y++;
rows[i]+=(y-x);
columns[j]+=(y-x);
}
}
int max1=Arrays.stream(rows).min().getAsInt();
int max2=Arrays.stream(columns).min().getAsInt();
System.out.println(Math.min(max1,max2));
}
} | JAVA |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.