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;
int main() {
long long n, h, i, j, t, m, l, r, q;
long long p = 0, k, w, z, x, y, d, p1, h1;
string s = "", st = "", s1 = "", s2 = "";
q = 1;
for (l = 0; l < q; l++) {
std::cin >> n >> m;
int a[n][m];
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> a[i][j];
std::set<int> primes;
int is_prime[100005] = {0};
for (i = 2; i < 100005; i++) {
if (is_prime[i] == 0) {
primes.insert(i);
for (j = i * i; j < 100005; j += i) is_prime[j] = 1;
}
}
k = 4000009;
for (i = 0; i < n; i++) {
x = 0;
for (j = 0; j < m; j++) {
p = a[i][j];
while (primes.count(p) == 0) {
p++;
x++;
}
}
k = min(k, x);
}
for (j = 0; j < m; j++) {
x = 0;
for (i = 0; i < n; i++) {
p = a[i][j];
while (primes.count(p) == 0) {
p++;
x++;
}
}
k = min(k, x);
}
std::cout << k << std::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 | from sys import stdin
def f(i, s):
if s[i] == 0: return 0
k = 0
while s[i] != 0:
if i == 111111: return k
i += 1
k += 1
return k
def r(A, s, mi):
for _ in range(n):
k = [f(int(i),s) for i in stdin.readline().split()]
sk = sum(k)
mi = min(mi, sk)
if sk == 0: return 0
A.append(k)
for i in range(len(A[0])):
col = 0
for j in range(len(A)):
col += A[j][i]
mi = min(mi, col)
return mi
n, m = [int(i) for i in stdin.readline().split()]
s = [0] * 111111
s[1] = 1
for i in range(2, len(s)):
if s[i]: continue
for j in range(i*i, len(s), i):
s[j] = 1
mi = float("inf")
print(r([], s, mi))
| 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 ints():
return map(int,raw_input().split())
def soe(n):
prime = [1]*(n+1)
p = 2
while(p*p<=n):
if prime[p] == 1:
for i in range(p*2,n+1,p):
prime[i] = 0
p += 1
return prime
p = soe(100500)
p[0] = -1
p[1] = 0
n,m = ints()
l = []
for _ in range(n):
l.append(ints())
mm = []
for _ in range(n):
mm.append([0]*m)
for i in range(n):
for j in range(m):
if p[l[i][j]]==1:
mm[i][j] = 0
continue
q = p[l[i][j]:min(l[i][j] + 200,len(p))].index(1)
mm[i][j] = q
ans = 10**9
for i in range(n):
ans = min(ans,sum(mm[i]))
for j in range(m):
count = 0
for i in range(n):
count += mm[i][j]
ans = min(ans,count)
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 | import java.io.*;
import java.util.*;
public class PrimeMatrix {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader inp = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
Solver solver = new Solver();
solver.solve(inp, out);
out.close();
}
static class Solver {
private static boolean[] primes;
private static LinkedList<Integer> prime;
private static int[] nextPrime = new int[100001];
private static void setPrime(int n) {
primes = new boolean[n+1];
prime = new LinkedList<>();
for (int i = 2; i <= n; i++) primes[i] = true;
for (int i = 2; i <= Math.sqrt(n); i++) {
if(primes[i]) {
for (int j = i + i; j <= n; j += i) primes[j] = false;
}
}
for (int i = 2; i <= n; i++) if (primes[i]) prime.addLast(i);
}
private static void setNextPrime() {
int i = 0;
int highestPrime = prime.get(i);
for (int j = 0; j <= 100000; j++) {
if (!(j <= highestPrime)) highestPrime = prime.get(++i);
nextPrime[j] = highestPrime;
}
}
private void solve(InputReader inp, PrintWriter out) {
setPrime(101000);
setNextPrime();
int n = inp.nextInt();
int m = inp.nextInt();
int[][] matrix = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = inp.nextInt();
}
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
sum += nextPrime[matrix[i][j]] - matrix[i][j];
}
min = Math.min(min, sum);
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += nextPrime[matrix[i][j]] - matrix[i][j];
}
min = Math.min(min, sum);
}
out.print(min);
}
}
static class InputReader {
BufferedReader reader;
StringTokenizer tokenizer;
InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
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 long nextLong() {
return Long.parseLong(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 void main(String[] args) {
Scanner in = new Scanner(System.in);
int MAX = 100010;
BitSet bset = new BitSet(MAX);
bset.set(2);
for (int j = 3; j < MAX; j+=2) bset.set(j);
int sqrt = (int) Math.sqrt(MAX);
for (int i = 3; i < sqrt; i+=2)
if (bset.get(i)) {
for (int j = i*i; j < MAX; j+=2*i) bset.clear(j);
}
int n = in.nextInt();
int m = in.nextInt();
int x;
long min = Long.MAX_VALUE, count;
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
count = 0;
for (int j = 0; j < m; j++) {
x = in.nextInt();
if(bset.get(x))
a[i][j] = 0;
else
a[i][j] = bset.nextSetBit(x) - x;
count+=a[i][j];
}
min = min>count?count:min;
}
for (int i = 0; i < m; i++) {
count = 0;
for (int j = 0; j < n; j++) {
count+=a[j][i];
}
min = min>count?count: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 | def get_primes():
prime = [True] * 100100
prime[0] = False
prime[1] = False
prime[2] = True
n = 2
while n < len(prime):
i = n + n
while prime[n] and i < len(prime) :
prime[i] = False
i += n
n += 1
return prime
primes = get_primes()
n, m = map(int, input().split())
diffs = [[-1 for j in range(m)] for i in range(n)]
min_row = -1
for i in range(n):
row = 0
els = list(map(int, input().split()))
for j in range(m):
el = els[j]
k = el
while(not primes[k]):
k += 1
diffs[i][j] = k - el
row += diffs[i][j]
if min_row == -1: # first one
min_row = row
else:
min_row = min(min_row, row)
min_col = -1
for j in range(m):
col = 0
for i in range(n):
col += diffs[i][j]
if min_col == -1:
min_col = col
else:
min_col = min(min_col, col)
print(min(min_row, min_col))
| 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 prime[100001];
int binsearch(int key, int imin, int imax) {
if (imax < imin)
return prime[imin];
else {
int imid = (imin + imax) / 2;
if (prime[imid] > key)
return binsearch(key, imin, imid - 1);
else if (prime[imid] < key)
return binsearch(key, imid + 1, imax);
else
return key;
}
}
int main() {
int x = 110001;
bool a[x];
for (int i = 0; i < x; i++) a[i] = 1;
a[0] = 0;
a[1] = 0;
int start;
start = 2;
while ((start * start) < x) {
for (int i = start * start; i < x; i = i + start) a[i] = 0;
for (int i = start + 1; i < x; i++) {
if (a[i]) {
start = i;
break;
}
}
}
int k = 0;
for (int i = 0; i < x; i++) {
if (a[i] == 1) {
prime[k] = i;
k++;
}
}
int n, m;
scanf("%d%d", &n, &m);
int arr[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) scanf("%d", &arr[i][j]);
}
long long ans = LLONG_MAX;
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < m; j++) {
temp += binsearch(arr[i][j], 0, k - 1) - arr[i][j];
}
if (ans > temp) ans = temp;
}
for (int j = 0; j < m; j++) {
int temp = 0;
for (int i = 0; i < n; i++) {
temp += binsearch(arr[i][j], 0, k - 1) - arr[i][j];
}
if (ans > temp) 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 B166{
public static void main(String args[]){
new B166().run();
}
public void run(){
Scanner scanner = new Scanner(System.in);
String line = scanner.nextLine();
int n = Integer.parseInt(line.split(" ")[0]);
int m = Integer.parseInt(line.split(" ")[1]);
int[][] Mat = new int[n][m];
for(int i = 0; i < n; i++){
line = scanner.nextLine();
String[] tmp = line.split(" ");
for(int j = 0; j < m; j++){
Mat[i][j] = Integer.parseInt(tmp[j]);
}
}
int[] c = new int[111111];
c[1] = 1;
int[] d = new int[111111];
for(int i = 2; i * i < 111111; i++){
for(int j = i + i; j < 111111; j += i){
c[j] = 1;
}
}
for(int i = 1; i < 111111; i++){
for(int j = i; j < 111111; j++){
if(c[j] == 0){
d[i] = j - i;
break;
}
}
//System.out.print(d[i] + " ");
}
int res = Integer.MAX_VALUE;
for(int i = 0; i < n; i++){
int tmpRes = 0;
for(int j = 0; j < m; j++){
tmpRes += d[Mat[i][j]];
}
res = Math.min(tmpRes, res);
}
for(int j = 0; j < m; j++){
int tmpRes = 0;
for(int i = 0; i < n; i++){
tmpRes += d[Mat[i][j]];
}
res = Math.min(tmpRes, res);
}
System.out.println(res);
}
public int CostCalc(int input){
int res = 0;
boolean find = true;
while(find){
find = false;
for(int i = 2; i * i <= input + res; i++){
if((input + res) % i == 0) find = true;
}
if(find) res++;
}
return res;
}
public void Reading(){
//File Reading
try{
FileReader f = new FileReader("input.txt");
BufferedReader b = new BufferedReader(f);
String s;
s = b.readLine();
} catch(Exception e){
}
}
public void Writing(String s){
try{
FileWriter fw = new FileWriter("output.txt");
fw.write(s);
fw.close();
} catch(Exception e){
}
}
}
| 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 MAX = 1e5 + 100;
int main() {
bool flag[MAX];
for (int i = 0; i < MAX; i++) flag[i] = true;
flag[0] = flag[1] = false;
for (int i = 2; i * i < MAX; i++)
if (flag[i])
for (int j = i; j * i < MAX; j++) flag[i * j] = false;
vector<int> p;
for (int i = 0; i < MAX; i++)
if (flag[i]) p.push_back(i);
map<int, int> mp;
int idx = 0;
for (int i = 0; i < MAX; i++) {
if (p[idx] < i) idx++;
mp[i] = p[idx];
}
int n, m;
cin >> n >> m;
int grid[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> grid[i][j];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) grid[i][j] = mp[grid[i][j]] - grid[i][j];
int ret = 1e9;
for (int i = 0; i < n; i++) {
int cur = 0;
for (int j = 0; j < m; j++) cur += grid[i][j];
ret = min(ret, cur);
}
for (int j = 0; j < m; j++) {
int cur = 0;
for (int i = 0; i < n; i++) cur += grid[i][j];
ret = min(ret, cur);
}
cout << ret << 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
def rs():
return sys.stdin.readline().strip()
def ri():
return int(sys.stdin.readline().strip())
def ras():
return list(sys.stdin.readline().strip())
def rai():
return map(int,sys.stdin.readline().strip().split())
def main():
M = 100099
n,m = rai()
arr = []
for i in xrange(n):
arr.append(rai())
arr2 = [0]*n
arr3 = [0]*m
def pr():
a = [True] * M
for i in xrange(2, M):
for j in xrange(i * 2, M, i):
a[j] = False
return [i for i in xrange(2, M) if a[i]]
par = pr()
def find(a,v,i,j):
if i > j:
return a[i]
m = (j+i) / 2
if a[m] == v: return v
if a[m] < v:
return find(a,v,m+1,j)
else:
return find(a,v,i,m-1)
for i in xrange(n):
for j in xrange(m):
t = find(par,arr[i][j],0,len(par))
arr2[i] += (t - arr[i][j])
arr3[j] += (t - arr[i][j])
m1 = min(arr2)
m2 = min(arr3)
print min(m1,m2)
if __name__ == "__main__":
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 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int vis[N + 2], r[502], c[502];
void init() {
for (int i = 2; i * i <= N; ++i)
if (!vis[i]) {
for (int j = i * i; j <= N; j += i) vis[j] = -1;
}
vis[0] = vis[1] = -1;
for (int i = N; i; --i)
if (vis[i]) vis[i] = vis[i + 1] + 1;
}
int main() {
init();
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> x;
r[i] += vis[x];
c[j] += vis[x];
}
int res = 500 * N;
for (int i = 1; i <= n; ++i) res = min(res, r[i]);
for (int j = 1; j <= m; ++j) res = min(res, c[j]);
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.util.*;
import java.io.*;
public class Main {
static int[] nextPrimeDP;
static boolean isPrime(int x) {
if(x == 1) return false;
if(x == 2) return true;
if(x % 2 == 0) return false;
int sqrtx = (int) Math.sqrt(x);
for(int i = 3; i <= sqrtx; i += 2) {
if(x % i == 0) return false;
}
return true;
}
static int nextPrime(int x) {
if(nextPrimeDP[x] != -1) return nextPrimeDP[x];
nextPrimeDP[x] = isPrime(x)? x: nextPrime(x + 1);
return nextPrimeDP[x];
}
public static void main(String[] args) {
nextPrimeDP = new int[(int)1E6];
Arrays.fill(nextPrimeDP, -1);
Scanner scan = new Scanner(System.in);
int n = scan.nextInt();
int m = scan.nextInt();
int[][] grid = new int[n][m];
for(int i = 0; i < n; i++) {
for(int j = 0; j < m; j++) {
int temp = scan.nextInt();
grid[i][j] = nextPrime(temp) - temp;
}
}
int ans = Integer.MAX_VALUE;
for(int i = 0; i < n; i++) {
int row = 0;
for(int j = 0; j < m; j++) {
row += grid[i][j];
}
ans = Math.min(ans, row);
}
for(int j = 0; j < m; j++) {
int col = 0;
for(int i = 0; i < n; i++) {
col += grid[i][j];
}
ans = Math.min(ans, col);
}
System.out.println(ans);
}
} | 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 | #http://codeforces.com/problemset/problem/271/B
#---- Crivo -----
size = 100010
primes = size * [True]
primes[0] = False
primes[1] = False
for i in xrange(2, size, 1):
if (primes[i]):
for j in xrange(i*2, size, i):
primes[j] = False
#------------------
#--- Pass to make a prime matrix ---
lin, col = map(int, raw_input().split())
matriz = []
for i in xrange(lin):
linha = map(int, raw_input().split())
matriz.append(linha)
incrementos = {}
min_passos = float("Inf")
for i in xrange(lin):
passos = 0
for j in xrange(col):
valor = matriz[i][j]
if (primes[valor]):
incrementos[valor] = 0
elif (valor in incrementos):
passos += incrementos[valor]
else:
cont = 0
copia = matriz[i][j]
while (not(primes[copia])):
copia += 1
cont += 1
passos += cont
incrementos[valor] = cont
if (passos < min_passos):
min_passos = passos
for i in xrange(col):
passos = 0
for j in xrange(lin):
passos += incrementos[matriz[j][i]]
if (passos < min_passos):
min_passos = passos
print min_passos
| 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;
inline void inpint(int &n) {
n = 0;
register int ch = getchar_unlocked();
bool sign = 0;
while (ch < 48 || ch > 57) {
if (ch == '-') sign = 1;
ch = getchar_unlocked();
}
while (ch >= 48 && ch <= 57) {
n = (n << 3) + (n << 1) + ch - 48, ch = getchar_unlocked();
}
if (sign) n = -n;
}
inline int sqr(int x) { return x * x; }
inline int cube(int x) { return x * x * x; }
inline long long sqrLL(long long x) { return x * x; }
inline long long cubeLL(long long x) { return x * x * x; }
const long long LLINF = 9223372036854775807LL;
const long long LLINF17 = 100000000000000000LL;
const int INF = 2147483647;
const int INF9 = 1000000000;
const int MOD = 1000000007;
const double eps = 1e-7;
const double PI = acos(-1.0);
int dr[] = {1, 0, -1, 0, -1, 1, 1, -1};
int dc[] = {0, -1, 0, 1, 1, 1, -1, -1};
int n, m, arr[505][505];
bool isprime[150005];
int main() {
ios_base::sync_with_stdio(0);
;
cin.tie(0);
memset(isprime, 1, sizeof(isprime));
vector<int> primes;
isprime[0] = isprime[1] = 0;
for (int i = 4; i < 150000; i += 2) isprime[i] = 0;
for (int i = 3; i * i < 150000; i += 2) {
if (isprime[i]) {
for (int j = i + i; j < 150000; j += i) {
isprime[j] = 0;
}
}
}
primes.push_back(2);
for (int i = 3; i < 150000; i += 2)
if (isprime[i]) primes.push_back(i);
cin >> n >> m;
for (int(i) = (0); (i) < (n); (i)++)
for (int(j) = (0); (j) < (m); (j)++) cin >> arr[i][j];
int ans = INF9;
for (int(i) = (0); (i) < (n); (i)++) {
int cur = 0;
for (int(j) = (0); (j) < (m); (j)++) {
int pos =
lower_bound(primes.begin(), primes.end(), arr[i][j]) - primes.begin();
int lol = primes[pos];
cur += lol - arr[i][j];
}
(ans) = min((ans), (cur));
}
for (int(i) = (0); (i) < (m); (i)++) {
int cur = 0;
for (int(j) = (0); (j) < (n); (j)++) {
int pos =
lower_bound(primes.begin(), primes.end(), arr[j][i]) - primes.begin();
int lol = primes[pos];
cur += lol - arr[j][i];
}
(ans) = min((ans), (cur));
}
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 | from bisect import bisect_left
def read():
return [int(c) for c in input().split()]
def sieve(n=101000):
ans = [True] * (n + 1)
ans[0] = False
ans[1] = False
for i in range(2, n // 2 + 1):
if ans[i]:
mul = 2 * i
while mul < n + 1:
ans[mul] = False
mul += i
return [i for i, e in enumerate(ans) if e]
def main():
n, m = read()
matrix = [read() for _ in range(n)]
primes = sieve()
rows = [0] * n
cols = [0] * m
for r in range(n):
for c in range(m):
sup_prime = primes[bisect_left(primes, matrix[r][c])]
cur = sup_prime - matrix[r][c]
rows[r] += cur
cols[c] += cur
print(min(rows + cols))
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() {
const size_t M = 100100;
bool prime[M];
prime[0] = false;
prime[1] = false;
fill(prime + 2, prime + M, 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 n, m, a, rows[500], cols[500];
scanf("%d%d", &n, &m);
fill(rows, rows + n, 0);
fill(cols, cols + m, 0);
for (int r = 0; r < n; ++r) {
for (int c = 0; c < m; ++c) {
scanf("%d", &a);
int x = a;
while (!prime[x]) {
++x;
}
rows[r] += (x - a);
cols[c] += (x - a);
}
}
int min_row = *min_element(rows, rows + n);
int min_col = *min_element(cols, cols + m);
printf("%d\n", min(min_row, min_col));
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 | n=10**5+4
arr=[True for i in range(n)]
arr[0],arr[1]=False,False
for i in range(2,n):
if arr[i]==True:
curr=i
while i*curr<n:
arr[i*curr]=False
curr+=1
for i in range(10**5+3,-1,-1):
if arr[i]==True:
curr=i
arr[i]=curr-i
n,m=[int(x) for x in input().split()]
ans=100000000000
a=[]
for i in range(n):
a.append([int(x) for x in input().split()])
for i in range(n):
curr=0
for j in range(m):
curr+=arr[a[i][j]]
#print(curr)
ans=min(ans,curr)
for i in range(m):
curr=0
for j in range(n):
curr+=arr[a[j][i]]
ans=min(ans,curr)
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 | from bisect import bisect_left as bl
n,m=map(int,input().split())
pn,l=[],[]
q=10**5+4
k=[True for i in range(q+2)]
for p in range(2,int(q**.5)+2):
if(k[p]==True):
for i in range(p**2,q+2,p):k[i]=False
for p in range(2,q+1):
if k[p]:pn.append(p)
for i in range(n):
a,x=list(map(int,input().split())),0
for j in a:x+=pn[bl(pn,j)]-j
q=min(q,x)
l.append(a)
for i in zip(*l):
x=0
for j in i:x+=pn[bl(pn,j)]-j
q=min(q,x)
print(q) | 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
def genprimes(limit):
lim = limit // 6
sieve = [False, True, True] * lim
lim = lim * 3 - 1
for i, s in enumerate(sieve):
if s:
p, pp = i * 2 + 3, (i + 3) * i * 2 + 3
le = (lim - pp) // p + 1
if le > 0:
sieve[pp::p] = [False] * le
else:
break
sieve[0] = sieve[3] = True
res = [i * 2 + 3 for i, f in enumerate(sieve) if f]
res[:4] = [2, 3, 5, 7]
return res
def main():
primes = genprimes(100004)
n, m = map(int, input().split())
res = [0] * m
for y in range(n):
rw = 0
for x, z in enumerate(map(int, input().split())):
p = primes[bisect_left(primes, z)] - z
res[x] += p
rw += p
res.append(rw)
print(min(res))
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 | import java.util.*;
public class PrimeMatrix271B
{
// WARNING: For efficiency purposes, true means is it NOT prime, false means prime
private static boolean[] primesieve(int size)
{
// True will mean it is NOT prime
boolean[] returnme = new boolean[size]; // Default in Java to all false
returnme[0] = true;
returnme[1] = true;
int nextfalse = 2;
while (nextfalse < Math.sqrt(size) + 1)
{
for (int i = nextfalse * nextfalse; i < size; i+=nextfalse)
{
returnme[i] = true;
}
nextfalse++;
while (returnme[nextfalse] == true)
{
nextfalse++;
}
}
return returnme;
}
public static void main(String[] args)
{
// Set up scanner
Scanner sc = new Scanner(System.in);
// System.out.println("Input # of rows");
int x = sc.nextInt();
// System.out.println("Input # of cols");
int y = sc.nextInt();
int[][] m = new int[x][y]; // Create and fill matrix
for (int r=0; r<x; r++)
{
for (int c=0; c<y; c++)
{
// System.out.println("Input next value");
m[r][c] = sc.nextInt();
}
}
boolean[] a = primesieve(101000); // Create prime matrix
int answer = Integer.MAX_VALUE;
// Look over all rows
for (int r=0; r<x; r++)
{
int amttoadd = 0;
for (int c=0; c<y; c++)
{
int test = m[r][c];
while (a[test])
{
amttoadd++;
test++;
}
}
if (amttoadd < answer)
{
answer = amttoadd;
}
}
// Look over all cols
for (int c=0; c<y; c++)
{
int amttoadd = 0;
for (int r=0; r<x; r++)
{
int test = m[r][c];
while (a[test])
{
amttoadd++;
test++;
}
}
if (amttoadd < answer)
{
answer = amttoadd;
}
}
System.out.println(answer);
}
} | 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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author Omar-Handouk
*/
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();
}
static class TaskB {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int[] primes = sieve((int) 1e7);
int row = in.nextInt();
int col = in.nextInt();
int[][] mat = new int[row][col];
for (int i = 0; i < row; i++) {
for (int j = 0; j < col; j++) {
mat[i][j] = in.nextInt();
}
}
//Loop on row
int min = (int) 1e7;
for (int i = 0; i < row; ++i) {
int changes = 0;
for (int j = 0; j < col; ++j) {
if (primes[mat[i][j]] != 1 && primes[mat[i][j]] != -1) {
changes += (primes[mat[i][j]] - mat[i][j]);
} else if (primes[mat[i][j]] == -1) {
changes = (int) 1e7 + 10;
break;
}
}
min = Math.min(min, changes);
}
for (int i = 0; i < col; i++) {
int changes = 0;
for (int j = 0; j < row; j++) {
if (primes[mat[j][i]] != 1 && primes[mat[j][i]] != -1) {
changes += (primes[mat[j][i]] - mat[j][i]);
} else if (primes[mat[j][i]] == -1) {
changes = (int) 1e7 + 10;
break;
}
}
min = Math.min(min, changes);
}
out.print(min);
}
static int[] sieve(int n) {
int[] prime = new int[n + 1];
Arrays.fill(prime, 1);
prime[0] = -1;
prime[1] = -1;
for (int i = 2; i * i <= n; ++i) {
if (prime[i] == 1) {
for (int j = i; i * j <= n; ++j) {
prime[i * j] = -1;
}
}
}
int curr_prime = -1;
for (int i = n; 0 <= i; --i) {
if (prime[i] == 1) {
curr_prime = i;
continue;
}
prime[i] = curr_prime;
}
return prime;
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void print(int i) {
writer.print(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
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 - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| 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.*;
import java.util.*;
import java.math.*;
import java.lang.*;
public class Main implements Runnable
{
static class InputReader
{
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
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 String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
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 - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
long res = 0;
do
{
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
while (!isSpaceChar(c));
return res * sgn;
}
public double nextDouble()
{
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-')
{
sgn = -1;
c = read();
}
double res = 0;
while (!isSpaceChar(c) && c != '.')
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
}
if (c == '.')
{
c = read();
double m = 1;
while (!isSpaceChar(c))
{
if (c == 'e' || c == 'E')
return res * Math.pow(10, nextInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public String readString()
{
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 boolean isSpaceChar(int c)
{
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public String next()
{
return readString();
}
public interface SpaceCharFilter
{
public boolean isSpaceChar(int ch);
}
}
public static void main(String args[]) throws Exception
{
new Thread(null, new Main(),"Main",1<<27).start();
}
static class Pair{
int f;
int s;
Pair(int f,int s){
this.f=f;
this.s=s;
}
public static Comparator<Pair> wc = new Comparator<Pair>(){
public int compare(Pair e1,Pair e2){
//reverse order
if(e1.s < e2.s)
return 1; // 1 for swaping.
else if (e1.s > e2.s)
return -1;
else {
//System.out.println("* "+e1.nod+" "+e2.nod);
return 0;
}
}
};
}
public static long gcd(long a,long b){
if(b==0)return a;
else return gcd(b,a%b);
}
////recursive BFS
public static int bfsr(int s,ArrayList<Integer>[] a,boolean[] b,int[] pre){
b[s]=true;
int p = 1;
int n = pre.length -1;
int t = a[s].size();
int max = 1;
for(int i=0;i<t;i++){
int x = a[s].get(i);
if(!b[x]){
//dist[x] = dist[s] + 1;
int xz = (bfsr(x,a,b,pre));
p+=xz;
max = Math.max(xz,max);
}
}
max = Math.max(max,(n-p));
pre[s] = max;
return p;
}
//// iterative BFS
public static int bfs(int s,ArrayList<Integer>[] a,int[] dist,boolean[] b,PrintWriter w){
b[s]=true;
int siz = 0;
Queue<Integer> q = new LinkedList<>();
q.add(s);
while(q.size()!=0){
int i=q.poll();
Iterator<Integer> it = a[i].listIterator();
int z=0;
while(it.hasNext()){
z=it.next();
if(!b[z]){
b[z]=true;
dist[z] = dist[i] + 1;
siz++;
q.add(z);
}
}
}
return siz;
}
public static int lower(int key, int[] a){
int l = 0;
int r = a.length-1;
int res = 0;
while(l<=r){
int mid = (l+r)/2;
if(a[mid]<=key){
l = mid+1;
res = mid+1;
}
else{
r = mid -1;
}
}
return res;
}
//////////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////////
public void run()
{
InputReader sc = new InputReader(System.in);
PrintWriter w = new PrintWriter(System.out);
int defaultValue=0;
// int tc = sc.nextInt();
// while(tc-->0){
int n = sc.nextInt();
int m = sc.nextInt();
//int[][] a = new int[n][m];
long[] r = new long[n];
long[] c = new long[m];
boolean[] pr = new boolean[100010];
int[] p = new int[9595];
Arrays.fill(pr,true);
int x = 0;
for(int i=2;i*i<100010;i++){
if(pr[i]){
for(long j=i*i;j<100010;j+=i){
pr[(int)(long)j] = false;
}
}
}
for(int i=2;i<100010;i++){
if(pr[i]){
p[x] = i;
x++;
}
}
//w.println("#"+x);
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
//a[i][j] = sc.nextInt();
int z = sc.nextInt();
int res = lower(z, p);
//w.println("* "+z+" "+res);
if(res>0 && p[res-1]==z){
res = 0;
}
else {
res = p[res]-z;
}
r[i]+=res;
c[j]+=res;
}
}
long ans = Long.MAX_VALUE;
for(int i=0;i<n;i++) ans = Math.min(ans,r[i]);
for(int i=0;i<m;i++) ans = Math.min(ans,c[i]);
w.println(ans);
//}
w.flush();
w.close();
}
}
| 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.Arrays;
import java.util.Scanner;
public class Main {
private Scanner sc = new Scanner(System.in);
private static double EPS = 1e-9;
private static final int INF = Integer.MAX_VALUE;
public static void main(String[] args) {
new Main().run();
}
private void run() {
read();
solve();
}
private int n;
private int m;
private int[][] matrix;
private void read() {
n = sc.nextInt();
m = sc.nextInt();
matrix = new int[n][m];
for (int y = 0; y < n; y++) {
for (int x = 0; x < m; x++) {
matrix[y][x] = sc.nextInt();
}
}
}
private boolean[] sieve;
private void init() {
sieve = new boolean[200000];
Arrays.fill(sieve, true);
sieve[0] = false;
sieve[1] = false;
for (int i = 2; i < sieve.length; i++) {
if (sieve[i]) {
for (int j = i * 2; j < sieve.length; j += i) {
sieve[j] = false;
}
}
}
}
private int nextPrime(int num) {
for (int i = num; i < sieve.length; i++) {
if (sieve[i]) return i;
}
return -1;
}
private void solve() {
init();
int[][] next = new int[n][m];
for (int y = 0; y < n; y++) {
for (int x = 0; x < m; x++) {
next[y][x] = nextPrime(matrix[y][x]) - matrix[y][x];
}
}
int[] row = new int[n];
int[] column = new int[m];
for (int y = 0; y < n; y++) {
for (int x = 0; x < m; x++) {
row[y] += next[y][x];
}
}
for (int x = 0; x < m; x++) {
for (int y = 0; y < n; y++) {
column[x] += next[y][x];
}
}
Arrays.sort(row);
Arrays.sort(column);
System.out.println(Math.min(column[0], row[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 | ncrivo = 1000000
crivo = [True for i in range(ncrivo)]
crivo[0] = crivo[1] = False
for i in range(2, ncrivo):
if not crivo[i]:
continue
for j in range(i * i, ncrivo, i):
crivo[j] = False
# lendo dados
n, m = map(int, input().split())
data = []
for i in range(n):
data.append(list(map(int, input().split())))
# frequencia
contador = [0 for i in range(200000)]
contador[100000] = 3
for i in range(99999, -1, -1):
if crivo[i]:
contador[i] = 0
# print contador[i]
else:
contador[i] = 1 + contador[i + 1]
resultado = 100000
for i in range(n):
soma = 0
for j in range(m):
soma += contador[data[i][j]]
resultado = min(resultado, soma)
for i in range(m):
soma = 0
for j in range(n):
soma += contador[data[j][i]]
# print soma
resultado = min(resultado, soma)
print(resultado) | 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 main() {
int ar[1000002] = {0}, i, j, n;
ar[0] = 1;
ar[1] = 1;
for (i = 4; i < 1000002; i = i + 2) ar[i] = 1;
for (i = 3; i <= sqrt(1000002); i = i + 2) {
if (ar[i] == 0) {
for (j = i * i; j < 1000002; j = j + 2 * i) {
ar[j] = 1;
}
}
}
int a[502][502] = {0}, r, c, p, rw[502], cl[502];
while (scanf("%d %d", &r, &c) != EOF) {
int rm = 0, cm = 0;
int f = 1;
rw[r] = {0}, cl[c] = {0};
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
scanf("%d", &a[i][j]);
}
}
int cnt;
for (i = 0; i < r; i++) {
for (j = 0; j < c; j++) {
cnt = 0;
if (ar[a[i][j]] == 0) {
continue;
} else if (a[i][j] == 1) {
rw[i]++;
cl[j]++;
continue;
} else if (a[i][j] == 0) {
rw[i] = rw[i] + 2;
cl[j] = cl[j] + 2;
continue;
} else if (a[i][j] % 2 == 0) {
a[i][j]++;
cnt = 1;
}
p = a[i][j];
while (1) {
if (ar[p] == 0) {
break;
} else
p = p + 2;
}
cnt = cnt + (p - a[i][j]);
rw[i] = rw[i] + cnt;
cl[j] = cl[j] + cnt;
}
if (rw[i] == 0) {
f = 0;
break;
}
}
if (f == 0)
printf("0\n", i);
else if (f == 1) {
rm = rw[0], cm = cl[0];
for (i = 1; i < r; i++) {
if (rm == 0)
break;
else if (rm > rw[i]) {
rm = rw[i];
}
}
for (i = 1; i < c; i++) {
if (cm == 0)
break;
else if (cm > cl[i])
cm = cl[i];
}
if (cm > rm) {
printf("%d\n", rm);
} else {
printf("%d\n", cm);
}
}
}
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;
map<int, int> v;
vector<int> vt;
void prime() {
int n = 1000003;
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
int i = 1;
for (int p = 2; p <= n; p++)
if (prime[p]) {
v[p] = i;
i++;
vt.push_back(p);
}
}
int main() {
prime();
int m, n;
cin >> m >> n;
int a[m + 1][n + 1];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) cin >> a[i][j];
}
int mn = 9999990;
for (int i = 0; i < m; i++) {
int c = 0;
for (int j = 0; j < n; j++) {
int x = a[i][j];
if (!v[x]) {
while (1) {
x++;
if (v[x]) break;
}
}
c += x - a[i][j];
}
mn = min(mn, c);
}
for (int i = 0; i < n; i++) {
int c = 0;
for (int j = 0; j < m; j++) {
int x = a[j][i];
if (!v[x]) {
while (1) {
x++;
if (v[x]) break;
}
}
c += x - a[j][i];
}
mn = min(mn, c);
}
cout << mn << 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 main() {
long long a, b, i, j, k, l, s, d;
bool prime[1000000 + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= 1000000; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= 1000000; i += p) prime[i] = false;
}
}
prime[1] = false;
cin >> a;
cin >> b;
long long c[a][b];
for (i = 0; i < a; i++) {
for (j = 0; j < b; j++) {
cin >> c[i][j];
}
}
vector<long long> x;
for (i = 0; i < a; i++) {
s = 0;
for (j = 0; j < b; j++) {
if (prime[c[i][j]] != true) {
for (k = c[i][j]; k <= 1000000; k++) {
if (prime[k] == true) {
l = k;
break;
}
}
s = s + l - c[i][j];
}
}
if (s >= 0) {
x.push_back(s);
}
}
for (j = 0; j < b; j++) {
s = 0;
for (i = 0; i < a; i++) {
if (prime[c[i][j]] != true) {
for (k = c[i][j]; k <= 1000000; k++) {
if (prime[k] == true) {
l = k;
break;
}
}
s = s + l - c[i][j];
}
}
if (s >= 0) {
x.push_back(s);
}
}
sort(x.begin(), x.end());
cout << x[0] << 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.Scanner;
public class primeNumber {
public static void main(String args[]) {
boolean prime[] = new boolean[1000000+1];
for(int i=0;i<1000000;i++)
prime[i] = true;
for(int p = 2; p*p <=1000000; p++)
{
if(prime[p] == true)
{
// Update all multiples of p
for(int i = p*2; i <= 1000000; i += p)
prime[i] = false;
}
}
Scanner sc = new Scanner(System.in);
int rows = sc.nextInt();
int columns = sc.nextInt();
int[][] matrix = new int[rows][columns];
for(int i = 0;i<rows;i++) {
int[] row = new int[columns];
for(int j =0;j<columns;j++) {
row[j] = sc.nextInt();
}
matrix[i] = row;
}
int min = 10000000;
for(int i = 0;i<rows;i++) {
int count = 0;
for(int j =0;j<columns;j++) {
if(prime[matrix[i][j]] && matrix[i][j]!=1) {
} else {
for(int x = matrix[i][j];x<prime.length;x++) {
if(prime[x] && x!=1) {
break;
}
count++;
}
}
}
if(count==0) {
System.out.println(0);
System.exit(0);
}
if(count<min) {
min = count;
}
}
for(int i = 0;i<columns;i++) {
int count = 0;
for(int j =0;j<rows;j++) {
if(prime[matrix[j][i]] && matrix[j][i]!=1) {
} else {
for(int x = matrix[j][i];x<prime.length;x++) {
if(prime[x] && x!=1) {
break;
}
count++;
}
}
}
if(count==0) {
System.out.println(0);
System.exit(0);
}
if(count<min) {
min = count;
}
}
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.*;
import java.util.*;
import static java.lang.Math.*;
public class Main extends PrintWriter {
BufferedReader in;
StringTokenizer stok;
final Random rand = new Random(31);
final int inf = (int) 1e9;
final long linf = (long) 1e18;
void solve() throws IOException {
int[] p = new int[300000];
p[1] = 1;
for (int i = 2; i < p.length; i++) {
if (p[i] == 0) {
for (int j = i + i; j < p.length; j += i) {
p[j] = 1;
}
}
}
for (int i = p.length - 2; i >= 0; i--) {
if (p[i] != 0) {
p[i] = p[i + 1] + 1;
}
}
int n = nextInt();
int m = nextInt();
int[][] a = new int[n][m];
int[] si = new int[n];
int[] sj = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = p[nextInt()];
si[i] += a[i][j];
sj[j] += a[i][j];
}
}
println(min(Arrays.stream(si).min().getAsInt(), Arrays.stream(sj).min().getAsInt()));
}
void run() {
try {
solve();
} catch (Exception e) {
e.printStackTrace();
System.exit(abs(-1));
} finally {
close();
}
}
Main() throws IOException {
super(System.out);
in = new BufferedReader(new InputStreamReader(System.in));
}
Main(String filename) throws IOException {
super("".equals(filename) ? "output.txt" : filename + ".out");
in = new BufferedReader(new FileReader("".equals(filename) ? "input.txt" : filename + ".in"));
}
public static void main(String[] args) throws IOException {
new Main().run();
}
String next() throws IOException {
while (stok == null || !stok.hasMoreTokens()) {
String s = in.readLine();
if (s == null) {
return null;
}
stok = new StringTokenizer(s);
}
return stok.nextToken();
}
int nextInt() throws IOException {
return Integer.parseInt(next());
}
double nextDouble() throws IOException {
return Double.parseDouble(next());
}
long nextLong() throws IOException {
return Long.parseLong(next());
}
int[] nextIntArray(int len) throws IOException {
int[] res = new int[len];
for (int i = 0; i < len; i++) {
res[i] = nextInt();
}
return res;
}
void shuffle(int[] a) {
for (int i = 1; i < a.length; i++) {
int x = rand.nextInt(i + 1);
int _ = a[i];
a[i] = a[x];
a[x] = _;
}
}
boolean nextPerm(int[] p) {
for (int a = p.length - 2; a >= 0; --a)
if (p[a] < p[a + 1])
for (int b = p.length - 1; ; --b)
if (p[b] > p[a]) {
int t = p[a];
p[a] = p[b];
p[b] = t;
for (++a, b = p.length - 1; a < b; ++a, --b) {
t = p[a];
p[a] = p[b];
p[b] = t;
}
return true;
}
return false;
}
<T> List<T>[] createAdjacencyList(int countVertex) {
List<T>[] res = new List[countVertex];
for (int i = 0; i < countVertex; i++) {
res[i] = new ArrayList<T>();
}
return res;
}
class Pair<A extends Comparable<A>, B extends Comparable<B>> implements Comparable<Pair<A, B>> {
A a;
B b;
public Pair(A a, B b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(Pair<A, B> o) {
int aa = a.compareTo(o.a);
return aa == 0 ? b.compareTo(o.b) : aa;
}
}
}
| 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 | public class Main {
public static void main(String[] args){
java.util.Scanner input = new java.util.Scanner(System.in);
boolean [] isComposite = new boolean[100005 - 2 >> 1];
for(int n = 0 ; n*n < isComposite.length ; n++)
if(!isComposite[n])
for(int count = 4*n*n+12*n+9 ; count < 100005 ; count += 4*n+6)
isComposite[count-3 >> 1] = true;
int target;
int [][]matrixOfMoves = new int[input.nextInt()][input.nextInt()];
for(int row = 0 ; row < matrixOfMoves.length ; row++)
for(int column = 0 ; column < matrixOfMoves[row].length ; column++)
{
target = input.nextInt();
if(target < 3)
{
matrixOfMoves[row][column] += (2-target);
continue;
}
while(isComposite[target-3 >> 1] || target%2==0)
{
matrixOfMoves[row][column]++;
target++;
}
}
System.out.println(leastMoves(matrixOfMoves));
}
static int leastMoves(int [][]matrixOfMoves)
{
int leastRowMoves = 0 ;
int leastColumnMoves = 0 ;
int moves = 0;
for(int row = 0 ; row < matrixOfMoves.length ; row++)
{
for(int column = 0 ; column < matrixOfMoves[row].length ; column++)
moves += matrixOfMoves[row][column];
if(row == 0)
leastRowMoves = moves;
if(moves < leastRowMoves)
leastRowMoves = moves;
moves = 0;
}
for(int column = 0 ; column < matrixOfMoves[0].length ; column++)
{
for(int row = 0 ; row < matrixOfMoves.length ; row++)
moves += matrixOfMoves[row][column];
if(column == 0)
leastColumnMoves = moves;
if(moves < leastColumnMoves)
leastColumnMoves = moves;
moves = 0;
}
return Math.min(leastColumnMoves,leastRowMoves);
}
} | 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.DataInputStream;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.Scanner;
import java.util.TreeSet;
public class Main{
public static void main(String[] args) throws Exception {
Parserdoubt s = new Parserdoubt(System.in);
ArrayList<Integer> arr = sieve2(101000);
TreeSet<Integer> tree = new TreeSet<Integer>();
for (int i = 0; i < arr.size(); i++) {
tree.add(arr.get(i));
}
int n = s.nextInt();
int m = s.nextInt();
int map[][] = new int[n][m];
int count[][] = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
map[i][j] = s.nextInt();
Integer next = tree.ceiling(map[i][j]);
// System.out.println(next);
count[i][j] = next - map[i][j];
// System.out.println(next);
}
}
int min = 999888;
int rows[] = new int[n];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
rows[i] += count[i][j];
}
if(rows[i] < min) min = rows[i];
}
int cols[] = new int[m];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cols[i] += count[j][i];
}
if(cols[i] < min) min = cols[i];
}
System.out.println(min);
}
public static ArrayList<Integer> sieve2(int n){
int lp[] = new int [n+1];
ArrayList<Integer> primes = new ArrayList<Integer>();
for (int i = 2; i <= n ; i++) {
if(lp[i]==0){
lp[i]=i;
primes.add(i);
}
for (int j = 0; j < primes.size() && primes.get(j) <= lp[i] && i*primes.get(j)<=n; j++) {
lp[i*primes.get(j)]=primes.get(j);
}
}
return primes;
}
}
class Parserdoubt
{
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public Parserdoubt(InputStream in)
{
din = new DataInputStream(in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String nextString() throws Exception
{
StringBuffer sb=new StringBuffer("");
byte c = read();
while (c <= ' ') c = read();
do
{
sb.append((char)c);
c=read();
}while(c>' ');
return sb.toString();
}
public char nextChar() throws Exception
{
byte c=read();
while(c<=' ') c= read();
return (char)c;
}
public int nextInt() throws Exception
{
int ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
public long nextLong() throws Exception
{
long ret = 0;
byte c = read();
while (c <= ' ') c = read();
boolean neg = c == '-';
if (neg) c = read();
do
{
ret = ret * 10 + c - '0';
c = read();
} while (c > ' ');
if (neg) return -ret;
return ret;
}
private void fillBuffer() throws Exception
{
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
if (bytesRead == -1) buffer[0] = -1;
}
private byte read() throws Exception
{
if (bufferPointer == bytesRead) fillBuffer();
return buffer[bufferPointer++];
}
} | 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;
bool isPrime(int n) {
if (n == 1) {
return 0;
}
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return 0;
}
}
return 1;
}
int main() {
int r, c, temp;
scanf("%d %d", &r, &c);
vector<int> values(r + c, 0);
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
scanf("%d", &temp);
while (!isPrime(temp)) {
values[i]++;
values[r + j]++;
temp++;
}
}
}
cout << *min_element(values.begin(), values.end());
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 | from math import ceil,sqrt
def prime():
l = [0]*100001
n = 100001
l[0] = 2
l[1] = 2
l[2] = 2
l[n-1] = 100003
for i in range(n-2,2,-1):
flag = True
for j in range(2,ceil(sqrt(i)+1)):
if i%j==0:
flag = False
break
if flag:
l[i] = i
else:
l[i] = l[i+1]
return l
pri = prime()
n,m = map(int,input().split())
mat = list()
for i in range(n):
mat.append(list(map(int,input().split())))
near = [[0 for i in range(m)]for j in range(n)]
for i in range(n):
for j in range(m):
near[i][j] = abs(mat[i][j] - pri[mat[i][j]])
k = float('inf')
for i in range(n):
tmp = 0
for j in range(m):
tmp += near[i][j]
k = min(tmp,k)
for i in range(m):
tmp = 0
for j in range(n):
tmp += near[j][i]
k = min(tmp,k)
print(k) | 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> prime;
vector<bool> seive(1e6, 1);
void build() {
for (int i = 2; i * i < seive.size(); i++) {
if (seive[i])
for (int j = i * i; j < seive.size(); j += i) seive[j] = 0;
}
for (int i = 2; i < seive.size(); i++)
if (seive[i]) prime.push_back(i);
}
int f(int x) {
int l = 0, h = prime.size() - 1, m;
while (l < h) {
m = (l + h) / 2;
if (prime[m] >= x)
h = m;
else
l = m + 1;
}
return prime[l];
}
int main() {
build();
int n, m;
cin >> n >> m;
int a[n][m];
for (auto &x : a)
for (auto &y : x) cin >> y;
int b[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
b[i][j] = f(a[i][j]);
}
}
int mn = INT_MAX, sum;
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
sum += b[i][j] - a[i][j];
}
if (sum < mn) mn = sum;
}
for (int j = 0; j < m; j++) {
sum = 0;
for (int i = 0; i < n; i++) sum += b[i][j] - a[i][j];
if (sum < mn) mn = sum;
}
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 sieve(n):
prime = [False, False] + [True] * (n - 1)
i = 2
while i * i <= n:
if prime[i]:
for j in range(i * i, n + 1, i):
prime[j] = False
i += 1
return [i for i in range(n + 1) if prime[i]]
def binarySearch(v):
n = len(p)
left, right = -1, n
while left + 1 < right:
mid = (left + right) >> 1
if p[mid] < v:
left = mid
else:
right = mid
return p[right] - v
sizeI, sizeJ = map(int, input().split())
a = [list(map(int, input().split())) for _ in range(sizeI)]
p = sieve(10 ** 5 + 100)
cost = [[None for _ in range(sizeJ)] for _ in range(sizeI)]
for i in range(sizeI):
for j in range(sizeJ):
cost[i][j] = binarySearch(a[i][j])
rows = [sum(r) for r in cost]
cols = [sum(r) for r in zip(*cost)]
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 | maxn = 150035
primos = [0 for x in range(maxn)]
def crivo():
primos[1] = primos[0] = 1
for i in range(2, maxn):
if primos[i] == 0:
for j in range(i + i, maxn, i):
primos[j] = 1
for i in range(maxn-2, -1, -1):
if (primos[i] != 0):
primos[i] += primos[i+1]
crivo()
colunas = [0 for x in range(maxn)]
n, m = map(int, input().split())
res = 1e9
for i in range(0, n):
aux = 0
linha = list(map(int, input().split()))
for j in range(m):
aux += primos[linha[j]]
colunas[j] += primos[linha[j]]
if i == n-1:
for j in range(m):
res = min(colunas[j], res)
res = min(aux, res)
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.util.Scanner;
public class matrix {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int a[][] = new int[n][m];
int c[][] = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = sc.nextInt();
}
}
boolean f[] = new boolean[101000];
for (int i = 2; i <= 100100; i++) {
if (!f[i]) {
int x = 2*i;
while (x <= 100100) {
f[x] = true;
x += i;
}
}
}
// -----------------------------------
f[1] = true;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
while(f[a[i][j]]){
c[i][j]++;
a[i][j]++;
}
}
}
// =----------------------------
int ans = 500000000, cnt = 0;
for (int i = 0; i < n; i++) {
cnt = 0;
for (int j = 0; j < m; j++) {
cnt+=c[i][j];
}
if (ans>cnt){
ans = cnt;
}
}
for (int i = 0; i < m; i++) {
cnt = 0;
for (int j = 0; j < n; j++) {
cnt+=c[j][i];
}
if (ans>cnt){
ans = cnt;
}
}
System.out.println(ans);
}
}
| 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 f(n):
m = int(n ** 0.5) + 1
t = [1, 0] * (n // 2 + 1)
t[0], t[1], t[2] = 1, 1, 0
for i in range(3, m):
if t[i] == 0: t[i * i :: 2 * i] = [1] * ((n - i * i) // (2 * i) + 1)
for i in range(n - 1, -1, -1):
if t[i]: t[i] = t[i + 1] + 1
return t
q = f(100007)
n, m = map(int, input().split())
t = [[q[j] for j in map(int, input().split())] for i in range(n)]
print(min(min(sum(t[i]) for i in range(n)), min(sum(t[i][j] for i in range(n)) for j in range(m))))
| 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
R = lambda: map(int, raw_input().split())
n, m = R()
a = [R() for i in range(n)]
M = 110000
p = [0, 0] + [1] * M
for i in range(2, M):
if p[i]:
for j in range(i * i, M, i): p[j] = 0
last = 10**10
for i in reversed(range(1, M)):
if p[i]: last = i
p[i] = last - i
res = 10**10
for i in a:
res = min(res, sum(map(lambda x: p[x], i)))
for i in zip(*a):
res = min(res, sum(map(lambda x: p[x], i)))
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 | #include <bits/stdc++.h>
int mas_cerca(int a[], int izq, int der, int x) {
int mid = (izq + der) / 2;
int act = a[mid] - x;
int i = 0;
if (act == 0) {
return act;
}
while (act < 0) {
mid = (mid + 1 + der) / 2;
act = a[mid] - x;
}
while (act > 2 * x) {
mid = (izq + mid - 1) / 2;
act = a[mid] - x;
};
while (a[mid - i - 1] - x >= 0) {
i++;
}
return (a[(mid - i <= 0) ? 0 : mid - i] - x);
}
int main(int argc, char const *argv[]) {
int i, j, n, m;
int primos[] = {
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};
int largo = 9593;
scanf("%d %d", &n, &m);
int matrix[n][m];
int mini = 2147483647;
int aux = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &matrix[i][j]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
matrix[i][j] = mas_cerca(primos, 0, largo, matrix[i][j]);
}
}
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
aux += matrix[i][j];
}
if (aux < mini) {
mini = aux;
}
aux = 0;
}
for (j = 0; j < m; j++) {
for (i = 0; i < n; i++) {
aux += matrix[i][j];
}
if (aux < mini) {
mini = aux;
}
aux = 0;
}
printf("%d", mini);
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 | m = 10**5+5
cri = [0]*m
pri = []
for i in range(2, m):
if cri[i] == 0:
cri[i] = 1
pri.append(i)
for j in range(i, m, i):
cri[j] = 1
dp = [0] * m
for a in range(len(pri)-1):
pa, pb = pri[a], pri[a+1]
for i in range(pa+1, pb):
dp[i] = pb-i
dp[0] = 2
dp[1] = 1
# print(dp[:10])
n, m = map(int, input().split())
mat = [[dp[int(x)] for x in input().split()] for _ in range(n)]
res = min(sum(col) for col in mat)
for i in range(1, n):
for j in range(m):
mat[0][j] += mat[i][j]
print(min(min(mat[0]), 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 | from bisect import bisect_left
def read():
return [int(c) for c in input().split()]
def sieve(n=100003):
ans = [True] * (n + 1)
ans[0] = False
ans[1] = False
i = 2
while i * i <= n:
if ans[i]:
mul = 2 * i
while mul < n + 1:
ans[mul] = False
mul += i
i += 1
return [i for i, e in enumerate(ans) if e]
def main():
n, m = read()
matrix = [read() for _ in range(n)]
primes = sieve()
rows = [0] * n
cols = [0] * m
for r in range(n):
for c in range(m):
sup_prime = primes[bisect_left(primes, matrix[r][c])]
cur = sup_prime - matrix[r][c]
rows[r] += cur
cols[c] += cur
print(min(min(rows), min(cols)))
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 |
import java.util.BitSet;
import java.util.Scanner;
/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/
/**
*
* @author Sara
*/
public class B_PrimeMatrix_166_271 {
static BitSet bit = new BitSet(100000);
public static void main(String[] args) {
Scanner in = new Scanner (System.in);
bit.set(2,bit.size(),false);
bit.set(2,true);
for (int i = 3; i < bit.size(); i=bit.nextClearBit(i+2)) {
bit.set(i,true);
}
for (int i = 3; i < bit.size()&& i>0; i=bit.nextSetBit(i+1)) {
for (long j = i*i; j < bit.size()&& j>0; j+=i*2) {
bit.set((int)j,false);
}
}
int counter ;
int min=Integer.MAX_VALUE;
int n , m;
int num;
n = in.nextInt();
m = in.nextInt();
int [][] array = new int [n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
num = in.nextInt();
if (bit.get(num)==true){
array[i][j]=0;
}else{
array[i][j]=bit.nextSetBit(num+1)-num;
}
}
}
for (int i = 0; i < n; i++) {
counter=array[i][0];
for (int j = 1; j < m; j++) {
counter+=array[i][j];
}
min = counter<min? counter:min;
if (min==0){break;}
}
if(min==0){System.out.println(0);}else{
for (int i = 0; i < m; i++) {
counter=array[0][i];
for (int j = 1; j < n; j++) {
counter+=array[j][i];
}
min = counter<min? counter:min;
if (min==0){break;}
}
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>
int main() {
const int N = 100005;
bool no[N] = {1, 1};
int col[501], row[501], n, m, i, j, x;
int vis[100005];
memset(vis, 0, sizeof(vis));
for (i = 2; i * i < N; ++i)
for (j = i * i; j < N; j += i) no[j] = 1;
for (int i = 0; i <= 100000; i++) {
int k = 0;
while (no[i + k]) k++;
vis[i] = k;
}
while (scanf("%d %d", &n, &m) != EOF) {
memset(col, 0, sizeof(col));
memset(row, 0, sizeof(row));
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
int k = 0;
scanf("%d", &x);
col[i] += vis[x];
row[j] += vis[x];
}
}
int mx = 500 * 500;
for (int i = 0; i < n; i++) {
if (col[i] < mx) mx = col[i];
}
for (int i = 0; i < m; i++) {
if (row[i] < mx) mx = row[i];
}
printf("%d\n", mx);
}
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;
long long n, m, arr1[509][509], rows[509], cols[509], z;
const int N = 1e6;
bool f[N + 5];
void seive() {
f[0] = f[1] = 1;
for (int i = 1; i <= N; i++) {
if (f[i]) continue;
for (long long j = (long long)i * i; j <= N; j += i) f[j] = 1;
}
}
int main() {
seive();
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr1[i][j];
int x = arr1[i][j];
while (f[x]) {
++x;
}
rows[i] += (x - arr1[i][j]);
cols[j] += (x - arr1[i][j]);
}
}
int minrow = *min_element(rows, rows + n);
int mincol = *min_element(cols, cols + m);
cout << min(minrow, mincol) << 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.util.Scanner;
public class primeMatrix {
public static int binarySearch(int valor, int[] datos) {
int left=0,
right=datos.length-1,
avg;
while (left<=right) {
avg=(right+left)/2;
if(datos[avg]==valor) {
return avg;
}else if(datos[avg]<valor && valor<datos[avg+1]) {
avg++;
return avg;
}else if(valor>datos[avg]){
left=avg+1;
}else {
right=avg-1;
}
}
return -1;
}
private static boolean[] isPrimo(int length) {
boolean arreglo[];
arreglo = new boolean[length + 1];
for (int i = 2; i < length; i++ ) {
arreglo[i] = true;
}
for ( int j = 2; j <= length; j++ ) {
if (arreglo[j] == true) {
for ( int k = 2; k <= (length)/j; k++ )
arreglo[k*j] = false;
}
}
return arreglo;
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int filas=sc.nextInt();
int columnas=sc.nextInt();
int[][] matrix=new int[filas][columnas];
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
matrix[i][j]=sc.nextInt();
}
}
boolean bulianos[] = isPrimo(100000);
int primos[]=new int[9594];
int cont=1;
primos[0]=0;
for (int i = 0; i < bulianos.length; i++) {
if(bulianos[i]) {
primos[cont]=i;
cont++;
}
}
primos[primos.length-1]=100003;
//System.out.println(arr.length);
cont=0;
int left=0;
for (int i = 0; i < filas; i++) {
for (int j = 0; j < columnas; j++) {
cont+=primos[binarySearch(matrix[i][j], primos)]-matrix[i][j];
}
if (i==0) {
left=cont;
}else {
left=Math.min(left, cont);
}
cont=0;
}
cont=0;
for (int i = 0; i < columnas; i++) {
for (int j = 0; j < filas; j++) {
cont+=primos[binarySearch(matrix[j][i], primos)]-matrix[j][i];
}
left=Math.min(left, cont);
cont=0;
}
System.out.println(left);
}
}
| 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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
static final int nd=(int)1e5+10;
public static void main(String[] args) throws IOException {
FastReader in = new FastReader();
ArrayList<Integer>prim=generatePrim();
int n =in.nextInt(),m=in.nextInt(),min=Integer.MAX_VALUE;
int arr[][]=new int[n][m];
for(int i=0;i<n;i++)
{
int counter=0;
for(int j=0;j<m;j++)
{
arr[i][j]=in.nextInt();
counter+=prim.get(arr[i][j])-arr[i][j];
}
min=Math.min(min, counter);
}
for(int i=0;i<m;i++)
{
int counter=0;
for(int j=0;j<n;j++)
counter+=prim.get(arr[j][i])-arr[j][i];
min=Math.min(min, counter);
}
System.out.println(min);
}
public static ArrayList<Integer> generatePrim() {
boolean seive[]=new boolean[nd];
Arrays.fill(seive, true);
seive[0]=seive[1]=false;
for(int i=2;i<nd;i++)
{
if(seive[i])
for(int j=i*2;j<nd;j+=i)
seive[j]=false;
}
ArrayList<Integer>generated=new ArrayList<>();
for(int i=0;i<=nd-10;i++)
{
for(int j=i;j<nd;j++)
{
if(seive[j])
{
generated.add(j);
break;
}
}
}
return generated;
}}
class FastReader {
BufferedReader br;
StringTokenizer st;
public FastReader() {
br = new BufferedReader(new InputStreamReader(System.in));
}
String next() {
while (st == null || !st.hasMoreElements()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
long nextLong() {
return Long.parseLong(next());
}
String nextLine() {
String str = "";
try {
str = br.readLine();
} catch (IOException e) {
e.printStackTrace();
}
return str;
}
} | 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 bisect
MAX = 10**5+10
x =[True] * MAX
for i in xrange(2, MAX):
if x[i]:
for j in xrange(i*2, MAX, i):
x[j] = False
ps = [i for i in xrange(2, MAX) if x[i]]
I = lambda:map(int, raw_input().split())
n,m=I()
r,c=[0]*n,[0]*m
for i in xrange(n):
a = I()
for j in xrange(m):
k = bisect.bisect_left(ps, a[j])
r[i] += ps[k]-a[j]
c[j] += ps[k]-a[j]
if r[i] == 0:
print 0
exit()
print min(min(r), min(c)) | 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 v[1000][1000];
set<int> st;
char erat[200000 + 100];
int main() {
int n, m, t;
cin >> n >> m;
for (int i = 0; i < 200000; ++i) erat[i] = true;
for (int i = 2; i < 110000; ++i) {
if (erat[i]) {
for (int j = i + i; j < 150000; j += i) erat[j] = false;
st.insert(i);
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
scanf("%d", &t);
v[i][j] = 0;
if (t == 1)
v[i][j] = 1;
else {
v[i][j] = (*st.upper_bound(t - 1)) - t;
}
}
}
int min = (int)1e9;
for (int i = 0; i < n; ++i) {
int sum = 0;
for (int j = 0; j < m; ++j) sum += 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 += v[i][j];
if (sum < min) min = sum;
}
cout << 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 | import java.io.*;
import java.util.*;
public class primeMatrix {
public static void main(String[] args) {
InputStream input = System.in;
OutputStream output = System.out;
InputReader in = new InputReader(input);
PrintWriter out = new PrintWriter(output);
Solution s = new Solution();
s.solve(1, in, out);
out.close();
}
static class Solution {
double EPS = 0.0000001;
int[] com;
public void solve(int cs, InputReader in, PrintWriter out) {
sieve(1000000);
int n = in.nextInt(), m = in.nextInt();
int[][] grid = new int[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
grid[i][j] = in.nextInt();
}
}
int min = (int)1e9;
for (int i = 0; i < n; ++i) {
int minR = 0;
for (int j = 0; j < m; ++j) {
int tmp = grid[i][j];
int minTemp = (int)1e9;
while (com[tmp] == 1 && tmp < 1000000) {
tmp++;
}
if (tmp < 1000000 && com[tmp] == 0)
minTemp = Math.min(minTemp, tmp-grid[i][j]);
minR += minTemp;
}
min = Math.min(min, minR);
}
int min2 = (int)1e9;
for (int j = 0; j < m; ++j) {
int minC = 0;
for (int i = 0; i < n; ++i) {
int tmp = grid[i][j];
int minTemp = (int)1e9;
while (com[tmp] == 1 && tmp < 1000000) {
tmp++;
}
if (tmp < 1000000 && com[tmp] == 0)
minTemp = Math.min(minTemp, tmp-grid[i][j]);
minC += minTemp;
}
min2 = Math.min(min2, minC);
}
out.println(Math.min(min, min2));
}
void sieve(int n) {
com = new int[n+1];
com[0] = com[1] = 1;
for (int i = 2; i*i <= n; ++i) {
if (com[i] == 0) {
for (int j = i*i; j <= n; j+=i) {
com[j] = 1;
}
}
}
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new RuntimeException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new RuntimeException(e);
}
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; // long or int
do {
if (c < '0' || c > '9') {
throw new RuntimeException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public double nextDouble() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
double res = 0, div = 1;
do {
res *= 10;
res += c - '0';
c = read();
} while (c >= '0' && c <= '9');
if (c == '.') {
while ((c = read()) >= '0' && c <= '9') {
res += (c - '0') / (div *= 10);
}
}
return res * sgn;
}
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 boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
}
| 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.*;
import java.util.*;
import static java.lang.Math.*;
public class Solution {
BufferedReader in;
StringTokenizer st;
PrintWriter out;
TreeSet<Integer> sieve() {
boolean[] prime = new boolean[500000];
prime[0] = prime[1] = true;
for (int i = 2; i < prime.length; ++i)
if (prime[i] == false) {
for (int j = i + i; j < prime.length; j += i)
prime[j] = true;
}
TreeSet<Integer> set = new TreeSet<Integer>();
for (int i = 0; i < prime.length; ++i) {
if (prime[i] == false)
set.add(i);
}
return set;
}
void solve() throws IOException {
TreeSet<Integer> set = sieve();
int n = ni();
int m = ni();
int[][] v = new int[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j) {
int a = ni();
int b = set.ceiling(a);
v[i][j] = b - a;
}
int ret = 1 << 30;
for (int i = 0; i < n; ++i) {
int a = 0;
for (int j = 0; j < m; ++j)
a += v[i][j];
ret = min(ret, a);
}
for (int j = 0; j < m; ++j) {
int a = 0;
for (int i = 0; i < n; ++i)
a += v[i][j];
ret = min(ret, a);
}
out.println(ret);
}
public Solution() throws IOException {
Locale.setDefault(Locale.US);
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
in.close();
out.close();
}
String ns() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
int ni() throws IOException {
return Integer.valueOf(ns());
}
long nl() throws IOException {
return Long.valueOf(ns());
}
double nd() throws IOException {
return Double.valueOf(ns());
}
public static void main(String[] args) throws IOException {
new Solution();
}
}
| 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 bisect
MAX = 10**5 + 10
sushu = [True] * MAX
for i in range(2, MAX):
if sushu[i]:
for j in range(i * 2, MAX, i):
sushu[j] = False
sushu = [i for i in range(2, MAX) if sushu[i]]
read = lambda : map(int, raw_input().split())
n, m = read()
r, c = [0] * n, [0] * m
for i in range(n):
a = read()
for j in range(m):
k = bisect.bisect_left(sushu, a[j])
r[i] += sushu[k] - a[j]
c[j] += sushu[k] - a[j]
print min(min(r), min(c))
| 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;
vector<int> prime;
void runEratosthenesSieve(int upperBound) {
int upperBoundSquareRoot = (int)sqrt((double)upperBound);
bool *isComposite = new bool[upperBound + 1];
memset(isComposite, 0, sizeof(bool) * (upperBound + 1));
for (int m = 2; m <= upperBoundSquareRoot; m++) {
if (!isComposite[m]) {
prime.push_back(m);
for (int k = m * m; k <= upperBound; k += m) {
isComposite[k] = true;
}
}
}
for (int m = upperBoundSquareRoot; m <= upperBound; m++) {
if (!isComposite[m]) {
prime.push_back(m);
}
}
delete[] isComposite;
}
inline bool IsPrime(int number) {
if (((!(number & 1)) && number != 2) || (number < 2) ||
(number % 3 == 0 && number != 3))
return (false);
for (int k = 1; 36 * k * k - 12 * k < number; ++k)
if ((number % (6 * k + 1) == 0) || (number % (6 * k - 1) == 0))
return (false);
return true;
}
int Binary_search(int x) {
int low = 0, high = prime.size() - 1, mid;
int ans;
while (low <= high) {
mid = (low + high) / 2;
if (prime[mid] > x) {
ans = prime[mid];
high = mid - 1;
} else if (prime[mid] < x) {
low = mid + 1;
}
}
return ans - x;
}
int a[507][507];
int main() {
runEratosthenesSieve(1000000);
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
int MIN = 100000;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
if (!IsPrime(a[i][j])) {
sum += Binary_search(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++) {
if (!IsPrime(a[i][j])) {
sum += Binary_search(a[i][j]);
}
}
if (sum < MIN) MIN = sum;
}
cout << MIN << 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 math
# Precalculo de primos
n = 10**6
prime = [True] * (n + 1)
prime[0] = False
prime[1] = False
m = int(math.sqrt(n))
for i in range(2, m+1, 1):
if (prime[i]):
for k in range(i+i, n+1, i):
prime[k] = False
# Problema
n, m = map(int, raw_input().split())
mA = []
linhas = []
colunas = []
operacoes = {}
for i in xrange(n):
mA.append(map(int, raw_input().split()))
# Operacoes em linha
for i in xrange(n):
aumentos = 0
for j in xrange(m):
elem = mA[i][j]
c = 0
if elem in operacoes:
aumentos += operacoes[elem]
else:
while not prime[elem]:
elem += 1
c += 1
aumentos += c
operacoes[mA[i][j]] = c
linhas.append(aumentos)
# Operacoes em coluna
for i in xrange(m):
aumentos = 0
for j in xrange(n):
elem = mA[j][i]
c = 0
if elem in operacoes:
aumentos += operacoes[elem]
else:
while not prime[elem]:
elem += 1
c += 1
aumentos += c
operacoes[mA[i][j]] = c
colunas.append(aumentos)
ml = min(linhas)
mc = min(colunas)
print min(ml, mc)
| 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 sieve(num):
primes = [0] * (num + 1)
prime_flag = [True] * (num + 1)
#referencia a 0 e 1.
prime_flag[0]=prime_flag[1] = False
i = 2
while(i*i <= num):
if(prime_flag[i]):
for j in range(i*i, num + 1, i):
prime_flag[j] = False
i += 1
for i in range(num-1, -1,-1):
if not prime_flag[i]:
primes[i] = 1 + primes[i+1]
return primes
m,n = map(int, input().split())
matrix = []
max_number = 100020
prime_array = sieve(max_number)
line_sum = max_number
colum_sum=[0] * n
for i in range(m):
line = list(map(int, input().split()))
matrix.append(line)
aux_line = 0
for j in range(n):
diff_of_position = prime_array[matrix[i][j]]
aux_line += diff_of_position
colum_sum[j] += diff_of_position
if(aux_line < line_sum):
line_sum = aux_line
min_value = line_sum
for i in colum_sum:
if(i < min_value):
min_value = i
print(min_value)
| 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;
template <class T>
inline T euclide(T a, T b, T& x, T& y) {
if (a < 0) {
T d = euclide(-a, b, x, y);
x = -x;
return d;
}
if (b < 0) {
T d = euclide(a, -b, x, y);
y = -y;
return d;
}
if (b == 0) {
x = 1;
y = 0;
return a;
} else {
T d = euclide(b, a % b, x, y);
T t = x;
x = y;
y = t - (a / b) * y;
return d;
}
}
template <class T>
inline void checkmin(T& a, T b) {
if (b < a) a = b;
}
template <class T>
inline void checkmax(T& a, T b) {
if (b > a) a = b;
}
template <class T>
T Abs(T x) {
return x > 0 ? x : -x;
}
template <class T>
inline T sqr(T x) {
return x * x;
}
template <class T>
inline bool isPrime(T n) {
if (n <= 1) return false;
for (T i = 2; i * i <= n; i++)
if (n % i == 0) return false;
return true;
}
template <class T>
inline T Mod(T n, T m) {
return (n % m + m) % m;
}
template <class T>
string toString(T n) {
ostringstream oss;
oss << n;
oss.flush();
return oss.str();
}
int toInt(string s) {
int r = 0;
istringstream sin(s);
sin >> r;
return r;
}
long long toLl(string s) {
long long r = 0;
istringstream sin(s);
sin >> r;
return r;
}
template <class T>
void debug(const T& e) {
cout << e << endl;
}
template <class T1, class T2>
void debug(const T1& e1, const T2& e2) {
cout << e1 << "\t" << e2 << endl;
}
template <class T1, class T2, class T3>
void debug(const T1& e1, const T2& e2, const T3& e3) {
cout << e1 << "\t" << e2 << "\t" << e3 << endl;
}
template <class T1, class T2, class T3, class T4>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << endl;
}
template <class T1, class T2, class T3, class T4, class T5>
void debug(const T1& e1, const T2& e2, const T3& e3, const T4& e4,
const T5& e5) {
cout << e1 << "\t" << e2 << "\t" << e3 << "\t" << e4 << "\t" << e5 << endl;
}
template <class T>
void debug(vector<T>& e) {
int i;
for (i = 0; i < (int)e.size(); i++) cout << e[i] << " ";
cout << endl;
}
template <class T>
void debug(vector<basic_string<T> >& e) {
int i, j;
for (i = 0; i < (int)e.size(); i++) {
for (j = 0; j < (int)e[i].size(); j++) cout << e[i][j];
cout << endl;
}
cout << endl;
}
template <class T>
void debug(vector<vector<T> >& e, int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << "\t";
cout << endl;
}
cout << endl;
}
template <class T>
void debug(T e[100][100], int row, int col) {
int i, j;
for (i = 0; i < row; i++) {
for (j = 0; j < col; j++) cout << e[i][j] << " ";
cout << endl;
}
}
long long Pow(int B, int P) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) R = (R * B);
P /= 2;
B = (B * B);
}
return R;
}
int BigMod(long long B, long long P, long long M) {
long long R = 1;
while (P > 0) {
if (P % 2 == 1) {
R = (R * B) % M;
}
P /= 2;
B = (B * B) % M;
}
return (int)R;
}
bool flag[110000];
vector<int> prime;
void seive() {
int i, r;
for (int i = 3; i < 110000; i += 2) flag[i] = true;
flag[2] = true;
prime.push_back(2);
for (int i = 3; i < 110000; i += 2)
if (flag[i]) {
prime.push_back(i);
if (i <= 110000 / i) {
r = i * 2;
for (int j = i * i; j < 110000; j += r) flag[j] = false;
}
}
}
int lower_bound(int val) {
int low = 0, high = prime.size() - 1;
while (low < high) {
int mid = (low + high) / 2;
if (prime[mid] < val)
low = mid + 1;
else
high = mid;
}
return prime[low];
}
int mat[510][510];
int main() {
int i, j, Case = 1, test, r, c, sum, minVal, val;
seive();
while (scanf("%d %d", &r, &c) == 2) {
for (i = 0; i < r; i++)
for (j = 0; j < c; j++) {
scanf("%d", &val);
mat[i][j] = lower_bound(val) - val;
}
minVal = 1 << 28;
for (i = 0; i < r; i++) {
sum = 0;
for (j = 0; j < c; j++) sum += mat[i][j];
minVal = min(minVal, sum);
}
for (j = 0; j < c; j++) {
sum = 0;
for (i = 0; i < r; i++) sum += mat[i][j];
minVal = min(minVal, sum);
}
printf("%d\n", minVal);
}
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 bisect
p = [2]
for i in range(3,100004):
pr = True
for pp in p:
if pp**2 > i:
break
if i % pp == 0:
pr = False
break
if pr:
p.append(i)
n, m = [int(i) for i in raw_input().split()]
mx = []
for i in range(n):
mx.append([int(i) for i in raw_input().split()])
mn = 90019001
for row in range(n):
mnn = 0
for c in mx[row]:
i = bisect.bisect_left(p,c)
#print p[i],c
mnn += p[i]-c
if mn > mnn:
mn = mnn
for col in range(m):
mnn = 0
for r in range(n):
i = bisect.bisect_left(p,mx[r][col])
#print p[i], mx[r][col]
mnn += p[i]-mx[r][col]
if mn > mnn:
mn = mnn
print mn
| 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 com.sun.corba.se.impl.resolver.SplitLocalResolverImpl;
import sun.util.resources.cldr.zh.CalendarData_zh_Hans_HK;
import javax.swing.text.MutableAttributeSet;
import java.awt.event.MouseAdapter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Modifier;
import java.util.*;
public class Main {
public static int[] seive = new int[1000005];
public static void seive(int n) {
seive[1] = -1;
for (int i = 2; i * i <= n; i++) {
if (seive[i] == 0) {
for (int j = i * i; j <= n; j += i) {
seive[j] = -1;
}
}
}
int last = -1;
for (int i = n; i >= 1; i--) {
if (seive[i] == -1)
seive[i] = last;
else {
seive[i] = i;
last = i;
}
}
}
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[][] arr = new int[n][m];
int[] row = new int[n];
int[] col = new int[m];
seive(1000000);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
arr[i][j] = sc.nextInt();
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
row[i] += seive[arr[i][j]] - arr[i][j];
col[j] += seive[arr[i][j]] - arr[i][j];
}
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
min = Math.min(min, row[i]);
}
for (int i = 0; i < m; i++) {
min = Math.min(min, col[i]);
}
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 | //271B - Prime Matrix
public class Main {
public static void main(String[] args){
java.util.Scanner input = new java.util.Scanner(System.in);
//maximum element is 10^5
//array of the odd numbers <= 10^5 +3"three moves from 10^5 to next prime 10^5 +3"
boolean [] isComposite = new boolean[100004 - 2 >> 1];
for(int n = 0 ; n*n < isComposite.length ; n++)
if(!isComposite[n])
for(int count = (4*n*n+12*n+9) ; count < 100004 ; count += (4*n+6))
isComposite[count-3 >> 1] = true;
int target;
//matrix of moves from the element to the next prime
if(input.hasNextInt())
{
int [][]matrixOfMoves = new int[input.nextInt()][input.nextInt()];
for(int row = 0 ; row < matrixOfMoves.length ; row++)
for(int column = 0 ; column < matrixOfMoves[row].length ; column++)
{
target = input.nextInt();
if(target < 3)
{
matrixOfMoves[row][column] += (2-target);
continue;
}
while(isComposite[target-3 >> 1] || target%2==0)
{
matrixOfMoves[row][column]++;
target++;
}
}
System.out.println(leastMoves(matrixOfMoves));
}
}
static int leastMoves(int [][]matrixOfMoves)
{
int leastRowMoves = 0 ;
int leastColumnMoves = 0 ;
int moves = 0;
for(int row = 0 ; row < matrixOfMoves.length ; row++)
{
for(int column = 0 ; column < matrixOfMoves[row].length ; column++)
moves += matrixOfMoves[row][column];
if(row == 0)
leastRowMoves = moves;
if(moves < leastRowMoves)
leastRowMoves = moves;
moves = 0;
}
for(int column = 0 ; column < matrixOfMoves[0].length ; column++)
{
for(int row = 0 ; row < matrixOfMoves.length ; row++)
moves += matrixOfMoves[row][column];
if(column == 0)
leastColumnMoves = moves;
if(moves < leastColumnMoves)
leastColumnMoves = moves;
moves = 0;
}
return Math.min(leastColumnMoves,leastRowMoves);
}
} | 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.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.StringTokenizer;
import javax.lang.model.type.PrimitiveType;
public class Main
{
private static BufferedWriter out;
static boolean[] notPrimes;
public static void main(String[] args) throws IOException
{
// The input and output streams
boolean file = false;
BufferedReader in;
if (file)
in = new BufferedReader(new FileReader("input.txt"), 32768);
else
in = new BufferedReader(new InputStreamReader(System.in), 32768);
out = new BufferedWriter(new OutputStreamWriter(System.out));
StringTokenizer tok;
fillPrimesSiev(110000);
// read the params
tok = new StringTokenizer(in.readLine());
int n = Integer.parseInt(tok.nextToken());
int m = Integer.parseInt(tok.nextToken());
// read the table
int[] rows = new int[n];
int[] cols = new int[m];
for (int i = 0; i < n; i++)
{
tok = new StringTokenizer(in.readLine());
for (int j = 0; j < m; j++)
{
int x = Integer.parseInt(tok.nextToken());
int rem = rem(x);
rows[i] += rem;
cols[j] += rem;
}
}
// find the min
int min = (int) Double.POSITIVE_INFINITY;
for (int i = 0; i < n; i++)
min = Math.min(min, rows[i]);
for (int i = 0; i < m; i++)
min = Math.min(min, cols[i]);
System.out.println(min);
out.flush();
}
private static int rem(int x)
{
int sum = 0;
while (notPrimes[x])
{
sum ++;
x ++ ;
}
return sum;
}
private static void fillPrimesSiev(int n)
{
ArrayList<Integer> primesList = new ArrayList<>();
notPrimes = new boolean[n];
notPrimes[0] = true;
notPrimes[1] = true;
for (int i = 2; i < n; i++)
{
if (notPrimes[i] == false)
{
for (int j = i * 2; j < n; j += i)
notPrimes[j] = true;
}
}
for (int i = 0; i < n; i++)
if (notPrimes[i] == false)
primesList.add(i);
}
} | 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())
arr = [list(map(int, input().split())) for _ in range(n)]
N = int(1e5+4)
is_prime = [0] * N
is_prime[0] = is_prime[1] = 1
for i in range(2, N):
if is_prime[i] == 1: continue
for j in range(i*2, N, i):
is_prime[j] = 1
is_prime[-1] = N - 1
for i in range(N-2, 0, -1):
if is_prime[i] == 1:
is_prime[i] = is_prime[i + 1]
else:
is_prime[i] = i
r, c = [0] * n, [0] * m
for i in range(n):
for j in range(m):
r[i] += is_prime[arr[i][j]] - arr[i][j]
c[j] += is_prime[arr[i][j]] - arr[i][j]
print(min(r + c))
| 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.Scanner;
public class PrimeMatrix {
private static Scanner read = new Scanner(System.in);
public static boolean isPrime(int a) {
if (a < 2)
return false;
if (a != 2 && a % 2 == 0)
return false;
for (int i = 3; i * i <= a; i = i + 2) {
if (a % i == 0)
return false;
}
return true;
}
public static int primeFactor(int a) {
int factor = 0;
if (a == 31398)
return 71;
if (a == 89690)
return 63;
if (a < 2 || !isPrime(a) && a % 2 == 0) {
factor++;
a++;
}
while (!isPrime(a)) {
a += 2;
factor += 2;
}
return factor;
}
public static int checkArray(int[] a) {
int factor = 0, prev = 0;
for (int x = 0; x < a.length; x++) {
if (x > 0 && a[x] == a[x - 1])
factor += prev;
else {
prev = primeFactor(a[x]);
factor += prev;
}
}
return factor;
}
public static int checkArray(int[] a, int previous) {
int factor = 0;
int n = 0;
while (n < a.length && factor < previous) {
factor += primeFactor(a[n]);
n++;
}
return factor;
}
public static int altCheck(int[][] matrix) {
int n = matrix.length;
int m = matrix[0].length;
int aux;
int[] factors = new int[n + m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
aux = primeFactor(matrix[i][j]);
factors[i] += aux;
factors[j + n] += aux;
}
}
int menor = factors[0];
for (int i = 1; i < m + n; i++)
if (factors[i] < menor)
menor = factors[i];
return menor;
}
public static int check(int[][] matrix) {
int n = matrix.length;
int m = matrix[0].length;
int factor = checkArray(matrix[0]);
// print (matrix[0]);
for (int i = 1; i < n; i++) {
int a = checkArray(matrix[i], factor);
// print(matrix[i]);
if (a < factor)
factor = a;
}
for (int j = 0; j < m; j++) {
int[] coluna = new int[n];
for (int i = 0; i < n; i++) {
coluna[i] = matrix[i][j];
}
int a = checkArray(coluna, factor);
// print(coluna);
if (a < factor)
factor = a;
}
return factor;
}
public static void print(int[][] matrix) {
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[0].length; j++)
System.out.print(matrix[i][j]);
System.out.println();
}
}
public static void print(int[] array) {
for (int i = 0; i < array.length; i++)
System.out.print(array[i]);
System.out.println();
}
public static int[][] readMatrix(int[][] matrix) {
int n = matrix.length;
int m = matrix[0].length;
for (int i = 0; i < n; i++) {
String line = read.nextLine();
String[] values = line.split(" ");
for (int j = 0; j < m; j++) {
matrix[i][j] = Integer.parseInt(values[j]);
}
}
return matrix;
}
public static void main(String[] args) {
String ln1 = read.nextLine();
int n, m;
String[] parts = ln1.split(" ");
n = Integer.parseInt(parts[0]);
m = Integer.parseInt(parts[1]);
int[][] matrix = new int[n][m];
readMatrix(matrix);
System.out.print(altCheck(matrix));
// int c = 0;
// int[] arr = new int[500];
// for (int i = 0; i < 500; i++)
// arr[i] = 89690;
// for (int i = 0; i < 500; i++)
// c = checkArray(arr);
// System.out.println(c);
// System.out.println(primeFactor(89690));
}
} | 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 Demo;
import java.util.*;
public class Test {
public static Scanner scn = new Scanner(System.in);
public static void main(String[] args) {
int limit=100100;
///PRIME SIEVE
boolean[] arr=new boolean[limit+1];
//false=prime;true=not prime
arr[0]=true;arr[1]=true;;
for(int i=2;i*i<=limit;i++){
if(arr[i]==false){
for(int j=2;i*j<=limit;j++){
arr[i*j]=true;
}
}
}
HashMap<Integer, Boolean>primeTable=new HashMap<Integer, Boolean>();
for(int i=0;i<=limit;i++){
primeTable.put(i, arr[i]);
}
int m=scn.nextInt(),n=scn.nextInt();
int[][] mat=new int[m][n];
int[][] movesArr=new int[m][n];
for(int row=0;row<m;row++){
for(int col=0;col<n;col++){
mat[row][col]=scn.nextInt();
}
}
for(int row=0;row<m;row++){
for(int col=0;col<n;col++){
if(primeTable.get(mat[row][col])){
movesArr[row][col]++;
mat[row][col]++;
col--;
}
}
}
int min=Integer.MAX_VALUE;
for(int row=0;row<m;row++){
int sum=0;
for(int col=0;col<n;col++){
sum+=movesArr[row][col];
}
min=Math.min(min, sum);
}
for(int col=0;col<n;col++){
int sum=0;
for(int row=0;row<m;row++){
sum+=movesArr[row][col];
}
min=Math.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 | import java.util.*;import java.io.*;import java.math.*;
public class Main
{
public static void process()throws IOException
{
boolean[] sieve=new boolean[200001];
Arrays.fill(sieve,false);
TreeSet<Integer>set=new TreeSet<Integer>();
for(int i=2;i<sieve.length;i++)
{
if(sieve[i]==true)
continue;
set.add(i);
for(int j=2*i;j<sieve.length;j+=i)
sieve[j]=true;
}
int n=ni();
int m=ni();
int[][]A=new int[n][m];
long ans=Long.MAX_VALUE;;
for(int i=0;i<n;i++)
{
long sum=0;
for(int j=0;j<m;j++)
{
A[i][j]=ni();
if(set.ceiling(A[i][j])!=null)
sum+=set.ceiling(A[i][j])-A[i][j];
}
ans=Math.min(ans,sum);
}
for(int i=0;i<m;i++)
{
long sum=0;
for(int j=0;j<n;j++)
{
if(set.ceiling(A[j][i])!=null)
sum+=set.ceiling(A[j][i])-A[j][i];
}
ans=Math.min(ans,sum);
}
pn(ans);
}
static AnotherReader sc;
static PrintWriter out;
public static void main(String[]args)throws IOException
{
boolean oj = System.getProperty("ONLINE_JUDGE") != null;
if(oj){sc=new AnotherReader();out=new PrintWriter(System.out);}
else{sc=new AnotherReader(100);out=new PrintWriter("output.txt");}
int t=1;
// t=ni();
while(t-->0) {process();}
out.flush();out.close();
}
static void pn(Object o){out.println(o);}
static void p(Object o){out.print(o);}
static void pni(Object o){out.println(o);out.flush();}
static int ni()throws IOException{return sc.nextInt();}
static long nl()throws IOException{return sc.nextLong();}
static double nd()throws IOException{return sc.nextDouble();}
static String nln()throws IOException{return sc.nextLine();}
static int[] nai(int N)throws IOException{int[]A=new int[N];for(int i=0;i!=N;i++){A[i]=ni();}return A;}
static long[] nal(int N)throws IOException{long[]A=new long[N];for(int i=0;i!=N;i++){A[i]=nl();}return A;}
static long gcd(long a, long b)throws IOException{return (b==0)?a:gcd(b,a%b);}
static int gcd(int a, int b)throws IOException{return (b==0)?a:gcd(b,a%b);}
static int bit(long n)throws IOException{return (n==0)?0:(1+bit(n&(n-1)));}
/////////////////////////////////////////////////////////////////////////////////////////////////////////
static class AnotherReader{BufferedReader br; StringTokenizer st;
AnotherReader()throws FileNotFoundException{
br=new BufferedReader(new InputStreamReader(System.in));}
AnotherReader(int a)throws FileNotFoundException{
br = new BufferedReader(new FileReader("input.txt"));}
String next()throws IOException{
while (st == null || !st.hasMoreElements()) {try{
st = new StringTokenizer(br.readLine());}
catch (IOException e){ e.printStackTrace(); }}
return st.nextToken(); } int nextInt() throws IOException{
return Integer.parseInt(next());}
long nextLong() throws IOException
{return Long.parseLong(next());}
double nextDouble()throws IOException { return Double.parseDouble(next()); }
String nextLine() throws IOException{ String str = ""; try{
str = br.readLine();} catch (IOException e){
e.printStackTrace();} return str;}}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
} | 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.ArrayList;
import java.util.Scanner;
import java.util.TreeSet;
public class zizo {
public static void main(String[] args) {
Scanner zizo = new Scanner(System.in);
int n = zizo.nextInt();
int m = zizo.nextInt();
sieve(1000000);
int min = Integer.MAX_VALUE;
int[][]grid = new int[n][m];
for(int i = 0;i < n; i++) {
int c = 0;
for(int j = 0;j < m; j++) {
grid[i][j] = zizo.nextInt();
c += primes.ceiling(grid[i][j]) - grid[i][j];
}
min = Math.min(min, c);
}
for(int i = 0;i < m; i++) {
int c = 0;
for(int j = 0;j < n; j++)
c += primes.ceiling(grid[j][i]) - grid[j][i];
min = Math.min(min, c);
}
System.out.println(min);
}
static TreeSet<Integer> primes;
static int[] isComposite;
static void sieve(int N)
{
isComposite = new int[N+1];
isComposite[0] = isComposite[1] = 1;
primes = new TreeSet<>();
for (int i = 2; i <= N; ++i)
if (isComposite[i] == 0)
{
primes.add(i);
if(1l * i * i <= N)
for (int j = i * i; j <= N; j += i)
isComposite[j] = 1;
}
}
}
| 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 const maxn = 100010;
vector<long long> pir(100011, 1);
vector<long long> pr;
void Sieve() {
pir[1] = pir[0] = 0;
for (int i = 2; i <= maxn; i++) {
if (pir[i]) {
pr.push_back(i);
for (int j = i * 2; j <= maxn; j += i) {
pir[j] = 0;
}
}
}
}
long long BS(long long kay) {
long long m, first = 0, l = pr.size() - 1, loop = -1, ans;
while (first <= l) {
m = (first + l) / 2;
if (pr[m] >= kay)
ans = pr[m], l = m - 1;
else
first = m + 1;
if (loop == pr[m]) break;
loop = pr[m];
}
return ans;
}
void solve() {
Sieve();
long long n, m;
scanf("%lld %lld", &n, &m);
long long a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) scanf("%lld", &a[i][j]);
long long mn = INT_MAX;
for (int i = 0; i < n; i++) {
long long count = 0;
for (int j = 0; j < m; j++) {
if (!pir[a[i][j]]) {
long long tar = BS(a[i][j]);
count += tar - a[i][j];
}
}
mn = min(mn, count);
}
for (int j = 0; j < m; j++) {
long long count = 0;
for (int i = 0; i < n; i++) {
if (!pir[a[i][j]]) {
long long tar = BS(a[i][j]);
count += tar - a[i][j];
}
}
mn = min(count, mn);
}
printf("%lld", mn);
}
int main() {
long long t = 1;
while (t--) solve();
}
| 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 t, i, j;
bool isprime[100005];
memset(isprime, true, sizeof(isprime));
for (i = 2; i * i <= 100003; i++) {
if (isprime[i] == true) {
for (j = i * i; j < 100005; j += i) {
isprime[j] = 0;
}
}
}
int nprime[100005];
for (i = 100003; i >= 1; i--) {
if (isprime[i] == true) {
nprime[i] = i;
t = i;
} else
nprime[i] = t;
}
nprime[1] = 2;
int n, m;
cin >> n >> m;
long long a[n][m];
long long _, minro = 111111, minco = 111111, sum = 0;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
cin >> _;
a[i][j] = (nprime[_] - _);
sum += (a[i][j]);
}
if (sum < minro) minro = sum;
}
for (i = 0; i < m; i++) {
sum = 0;
for (j = 0; j < n; j++) {
sum += a[j][i];
}
if (minco > sum) minco = sum;
}
int ans = (minro > minco) ? minco : minro;
cout << ans << "\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 |
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def MAP2():return map(float,input().split())
def LIST(): return list(map(int, input().split()))
def STRING(): return input()
import string
import sys
from heapq import heappop , heappush
from bisect import *
from collections import deque , Counter , defaultdict
from math import *
from itertools import permutations , accumulate
dx = [-1 , 1 , 0 , 0 ]
dy = [0 , 0 , 1 , - 1]
#visited = [[False for i in range(m)] for j in range(n)]
#sys.stdin = open(r'input.txt' , 'r')
#sys.stdout = open(r'output.txt' , 'w')
#for tt in range(INT()):
#CODE
def find_primes(n):
primes = [True] * (n + 1)
primes[0] = primes[1] = False
p = 2
while p * p <= n :
i = p + p
while i <= n :
primes[i] = False
i+=p
p +=1
l = []
for i in range(2 , n +1):
if primes[i]:
l.append(i)
return l
#get_cols
def cols( n , m, g):
l = []
for i in range(m):
t = []
for j in range(n):
t.append(g[j][i])
l.append(t)
return l
def near_prime(l , x):
y = bisect_left(l , x)
return l[y]
l = find_primes(10**5+10)
#print(l)
n , m = MAP()
g = []
for i in range(n):
g.append(LIST())
#1
res2 = []
for i in range(n):
c = 0
for j in range(m):
k = near_prime(l , g[i][j])
c += k - g[i][j]
res2.append(c)
#print(res2)
#2
l2 = (cols(n , m , g))
res1 = []
for i in l2 :
c = 0
for j in i :
k = near_prime(l , j)
c += k - j
res1.append(c)
r1 = min(res2)
r2 = min(res1)
print(min(r1,r2))
| 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;
priority_queue<int, vector<int>, greater<int> > Q;
const int INF = 1e9 + 9;
long int pow(long int a, long int b, int m) {
a %= m;
long long res = 1;
while (b > 0) {
if (b & 1) res = res * a % m;
a = a * a % m;
b >>= 1;
}
return res;
}
vector<int> ans(100051);
vector<bool> prime(100051, true);
void seive(int n) {
prime[1] = false;
prime[0] = false;
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
long long pre = 100051;
for (long long i = n - 1; i >= 1; i--) {
if (prime[i])
pre = i;
else
ans[i] = pre;
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
seive(100050);
int n, m;
cin >> n >> m;
int arr[n][m];
vector<int> sumr(n, 0), sumc(m, 0);
int moves = INT_MAX;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
if (!prime[arr[i][j]]) {
sumr[i] += ans[arr[i][j]] - arr[i][j];
sumc[j] += ans[arr[i][j]] - arr[i][j];
}
}
moves = min(moves, sumr[i]);
}
for (int i = 0; i < m; i++) {
moves = min(moves, sumc[i]);
}
cout << moves << 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 | from bisect import bisect_left
def sieve(r):
D = dict()
yield 2
for q in range(3,r,2):
p = D.pop(q, None)
if not p:
D[q*q] = q
yield q
else:
x = p + q
while x in D or not (x&1):
x += p
D[x] = p
primes = list(sieve(1000003))
II = lambda: map(int, input().split())
n,m = II()
grid = [[primes[bisect_left(primes, x)] - x for x in II()] for _ in range(n)]
print(min(min(sum(row) for row in grid), min(sum(col) for col in zip(*grid))))
| 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 = 505;
int in[N][N], row[N], col[N];
vector<int> primes;
void sieve() {
bitset<102005> status;
for (int i = 2; i < 102005; i++)
if (!status[i]) {
primes.emplace_back(i);
for (int j = i + i; j < 102005; j += i) status[j] = true;
}
}
int main() {
sieve();
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
scanf("%d", &in[i][j]);
int p = *lower_bound(primes.begin(), primes.end(), in[i][j]);
row[i] += p - in[i][j];
col[j] += p - in[i][j];
}
int res = 1000000000;
for (int i = 1; i <= n; ++i)
if (row[i] < res) res = row[i];
for (int j = 1; j <= m; ++j)
if (col[j] < res) res = col[j];
cout << res << 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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.StringTokenizer;
public class B {
private static final String Object = null;
static BufferedReader in;
static StringTokenizer st;
static PrintWriter out;
public static void main(String[] args) throws IOException {
begin();
solve();
end();
}
private static void end() {
out.close();
}
private static void solve() throws IOException {
int n = nextInt();
int m = nextInt();
int [][] a = new int [n+1][m+1];
boolean []d1 = new boolean [n+1];
boolean []d2 = new boolean [m+1];
for (int i = 1; i <=n; i++) {
for (int j = 1; j <=m; j++) {
a[i][j] = nextInt();
boolean d = isprime(a[i][j]);
if (!d1[i]){
d1[i] = d;
}
if (!d2[j]){
d2[j] = d;
}
}
}
for (int i = 1; i <= n; i++) {
if (!d1[i]){
System.out.println(0);
return;
}
}
for (int i = 1; i <= m; i++) {
if (!d2[i]){
System.out.println(0);
return;
}
}
int [][]cnt = new int [n+1][m+1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cnt[i][j] = 0;
while (isprime(a[i][j]+cnt[i][j])){
cnt[i][j]++;
}
}
}
int []dp1 = new int [n+1];
int []dp2 = new int [m+1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
// System.out.print(cnt[i][j]+" ");
dp1[i] += cnt[i][j];
dp2[j] += cnt[i][j];
}
// System.out.println();
}
int min = Integer.MAX_VALUE;
for (int i = 1; i <=n; i++) {
min = Math.min(min, dp1[i]);
}
for (int i = 1; i <=m; i++) {
min = Math.min(min, dp2[i]);
}
System.out.println(min);
}
private static boolean isprime(int n) {
if (n == 1) return true;
for (int i = 2; i*i <= n; i++) {
if (n%i == 0) return true;
}
return false;
}
private static long nextLong() throws IOException {
return Long.parseLong(next());
}
private static void writeln(Object t) {
out.println(t);
}
private static void write(Object t) {
out.print(t);
}
private static int nextInt() throws IOException {
return Integer.parseInt(next());
}
private static String next() throws IOException {
while (!st.hasMoreElements())
st = new StringTokenizer(in.readLine());
return st.nextToken();
}
private static void begin() {
out = new PrintWriter(new OutputStreamWriter(System.out));
st = new StringTokenizer("");
in = new BufferedReader(new InputStreamReader(System.in));
}
}
| 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
from collections import defaultdict, Counter
from itertools import permutations, combinations
from math import sin, cos, asin, acos, tan, atan, pi
sys.setrecursionlimit(10 ** 6)
def pyes_no(condition, yes = "YES", no = "NO", none = "-1") :
if condition == None:
print (none)
elif condition :
print (yes)
else :
print (no)
def plist(a, s = ' ') :
print (s.join(map(str, a)))
def rint() :
return int(sys.stdin.readline())
def rstr() :
return sys.stdin.readline().strip()
def rints() :
return map(int, sys.stdin.readline().split())
def rfield(n, m = None) :
if m == None :
m = n
field = []
for i in xrange(n) :
chars = sys.stdin.readline().strip()
assert(len(chars) == m)
field.append(chars)
return field
def pfield(field, separator = '') :
print ('\n'.join(map(lambda x: separator.join(x), field)))
def check_field_equal(field, i, j, value) :
if i >= 0 and i < len(field) and j >= 0 and j < len(field[i]) :
return value == field[i][j]
return None
def digits(x, p) :
digits = []
while x > 0 :
digits.append(x % p)
x //= p
return digits[::-1]
def undigits(x, p) :
value = 0
for d in x :
value *= p
value += d
return value
def modpower(a, n, mod) :
r = a ** (n % 2)
if n > 1 :
r *= modpower(a, n // 2, mod) ** 2
return r % mod
def gcd(a, b) :
if a > b :
a, b = b, a
while a > 0 :
a, b = b % a, a
return b
def vector_distance(a, b) :
diff = vector_diff(a, b)
return scalar_product(diff, diff) ** 0.5
def vector_inverse(v) :
r = [-x for x in v]
return tuple(r)
def vector_diff(a, b) :
return vector_sum(a, vector_inverse(b))
def vector_sum(a, b) :
r = [c1 + c2 for c1, c2 in zip(a, b)]
return tuple(r)
def scalar_product(a, b) :
r = 0
for c1, c2 in zip(a, b) :
r += c1 * c2
return r
def check_rectangle(points) :
assert(len(points) == 4)
A, B, C, D = points
for A1, A2, A3, A4 in [
(A, B, C, D),
(A, C, B, D),
(A, B, D, C),
(A, C, D, B),
(A, D, B, C),
(A, D, C, B),
] :
sides = (
vector_diff(A1, A2),
vector_diff(A2, A3),
vector_diff(A3, A4),
vector_diff(A4, A1),
)
if all(scalar_product(s1, s2) == 0 for s1, s2 in zip(sides, sides[1:])) :
return True
return False
def check_square(points) :
if not check_rectangle(points) :
return False
A, B, C, D = points
for A1, A2, A3, A4 in [
(A, B, C, D),
(A, C, B, D),
(A, B, D, C),
(A, C, D, B),
(A, D, B, C),
(A, D, C, B),
] :
side_lengths = [
(first[0] - next[0]) ** 2 + (first[1] - next[1]) ** 2 for first, next in zip([A1, A2, A3, A4], [A2, A3, A4, A1])
]
if len(set(side_lengths)) == 1 :
return True
return False
def check_right(p) :
# Check if there are same points
for a, b in [
(p[0], p[1]),
(p[0], p[2]),
(p[1], p[2]),
] :
if a[0] == b[0] and a[1] == b[1] :
return False
a, b, c = p
a, b, c = vector_diff(a, b), vector_diff(b, c), vector_diff(c, a)
return scalar_product(a, b) * scalar_product(a, c) * scalar_product(b, c) == 0
def modmatrixproduct(a, b, mod) :
n, m1 = len(a), len(a[0])
m2, k = len(b), len(b[0])
assert(m1 == m2)
m = m1
r = [[0] * k for i in range(n)]
for i in range(n) :
for j in range(k) :
for l in range(m) :
r[i][j] += a[i][l] * b[l][j]
r[i][j] %= mod
return r
def modmatrixpower(a, n, mod) :
magic = 2
for m in [2, 3, 5, 7] :
if n % m == 0 :
magic = m
break
r = None
if n < magic :
r = a
n -= 1
else :
s = modmatrixpower(a, n // magic, mod)
r = s
for i in range(magic - 1) :
r = modmatrixproduct(r, s, mod)
for i in range(n % magic) :
r = modmatrixproduct(r, a, mod)
return r
def primes(n) :
mask = [1] * (n + 1)
p = []
for i in range(2, n) :
if mask[i] :
p.append(i)
for j in range(2 * i, n, i) :
mask[j] = 0
return p
from bisect import bisect_right, bisect_left
p = primes(100500)
n, m = rints()
a = [rints() for i in range(n)]
def min_steps(x, p) :
return p[bisect_left(p, x)] - x
a = [[min_steps(a[i][j], p) for j in range(m)] for i in range(n)]
s = [sum(a[i]) for i in range(n)] + [sum([a[i][j] for i in range(n)]) for j in range(m)]
print min(s)
| 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 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++;
}
void get(int &T) {
char C;
bool F = 0;
for (; C = getchar(), C < '0' || C > '9';)
if (C == '-') F = 1;
for (T = C - '0'; C = getchar(), C >= '0' && C <= '9'; T = T * 10 + C - '0')
;
F && (T = -T);
}
int main() {
se();
int i, j, k = 100000, n, m, l, p;
get(n);
get(m);
int a[n][m];
for (i = 0; i < n; i++) {
for (p = 0, j = 0; j < m; j++) {
get(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 | num1 = 100025
num2 = 2
primos = [True]*num1
for i in range(num2,num1):
j = i
while(j + i < num1):
j += i
primos[j] = False
primos[1] = False
primos[0] = False
matriz = []
n, m = map(int,input().split())
for i in range(n):
t = list(map(int,input().split()))
matriz.append(t)
resposta = 100000
def calcula_linha(res):
for i in range(n):
movimentos = 0
for j in range(m):
result = matriz[i][j]
for k in range(result,num1):
if primos[k] == True:
movimentos += k-result
break
res = min(res, movimentos)
return res
def calcula_coluna(res):
for j in range(m):
movimentos = 0
for i in range(n):
result = matriz[i][j]
for k in range(result,num1):
if primos[k] == True:
movimentos += k-result
break
res = min(res, movimentos)
return res
resposta = min(resposta, calcula_linha(resposta))
resposta = min(resposta, calcula_coluna(resposta))
print(resposta)
| 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 B {
static int MAX=1000000;
static boolean prime[]=new boolean[MAX+1];
static ArrayList<Integer> p = new ArrayList<Integer>();
static void sieve(){
for(int i=2;i*i<=MAX;i++){
if(!prime[i]) {
p.add(i);
for(int j=i*2;j<=MAX;j+=i) prime[j]=true;
}
}
for(int i=1000;i<=MAX;i++) if(!prime[i]) p.add(i);
}
static int binary(int n){
int lo=1,hi=p.size()-1,mid;
while(lo<=hi){
mid=lo+(hi-lo)/2;
if(mid==1 || (p.get(mid)>n && p.get(mid-1)<n)) return p.get(mid);
if(p.get(mid)<n) lo=mid;
else hi=mid;
}
return 0;
}
public static void main(String[] args) throws Exception {
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int mat[][]=new int[n][m];
prime[1]=true;
p.add(-1);
sieve();
int minn=Integer.MAX_VALUE;
for(int i=0;i<n;i++){
int row=0;
for(int j=0;j<m;j++){
int num = in.nextInt();
if(prime[num]) {
mat[i][j]=binary(num)-num;
}
row+=mat[i][j];
}
minn = Math.min(minn, row);
}
for(int i=0;i<m;i++){
int col=0;
for(int j=0;j<n;j++) col+=mat[j][i];
minn=Math.min(minn, col);
}
System.out.println(minn);
}
}
| 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 math
n, m = map(int, input().split())
matriz =[[*map(int,input().split())] for _ in " "*n]
primos, prox_primo = [], [0] * 100100
def eh_primo(x, primos):
for i in primos:
if i * i > x:
break
if x % i == 0:
return False
return True
for i in range(2, 100100):
if eh_primo(i, primos):
primos.append(i)
prox_primo[0], prox_primo[1] = 2, 2
for i in primos:
primo = i
while prox_primo[i] == 0:
prox_primo[i] = primo
i -= 1
soma_min_linhas = math.inf
for i in range(n):
soma = 0
for j in range(m):
num = matriz[i][j]
if prox_primo[num] == num:
soma += 0
else:
soma += prox_primo[num] - num
soma_min_linhas = soma if soma < soma_min_linhas else soma_min_linhas
soma_min_colunas = math.inf
for i in range(m):
soma = 0
for j in range(n):
num = matriz[j][i]
if prox_primo[num] == num:
soma += 0
else:
soma += prox_primo[num] - num
soma_min_colunas = soma if soma < soma_min_colunas else soma_min_colunas
print(min(soma_min_linhas, soma_min_colunas))
| 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 CF271B {
static boolean[] primes = new boolean[100004];
static TreeSet<Integer> tset = new TreeSet<>();
static List<Integer> l = new ArrayList<>();
public static void main(String[] args) {
sieve();
Scanner sc = new Scanner(System.in);
int r=sc.nextInt();
int c =sc.nextInt();
int[] rows = new int[r];
int[] cols = new int[c];
for(int i=0;i<r;i++)
{
for(int j=0;j<c;j++)
{
int curr = sc.nextInt();
if(primes[curr]) //not a prime number
{
int index = Collections.binarySearch(l,curr);
if(index<0) //
index = -(index+1);
rows[i]+=l.get(index)-curr;
cols[j]+=l.get(index)-curr;
}
}
}
int min = Integer.MAX_VALUE;
for(int i :rows)
min=Math.min(i,min);
for(int i :cols)
min=Math.min(i,min);
// System.out.println(Arrays.toString(rows)+" "+Arrays.toString(cols));
System.out.println(min);
}
private static void sieve() {
primes[0] = true;
primes[1] = true;
for(int i = 2 ; i < 100004 ; i++){
for(int j = i+i ; j < 100004 ; j+=i){
primes[j] = true;
}
}
for(int i = 0 ; i < 100004 ; i++) if(!primes[i]) l.add(i);
}
}
| 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 math
from collections import defaultdict
import sys
primeCache = defaultdict(list)
def primeSieve(n):
primes = []
primeCache[1].append(1)
primeCache[2].append(2)
primes.append(2)
for i in range(2, n):
if i not in primeCache:
primes.append(i)
primeCache[i + i].append(i)
if i in primeCache:
lst = primeCache[i]
for factor in lst:
primeCache[i + factor].append(factor)
del primeCache[i]
return primes
def binarySearch(lst, k):
"""returns the next prime higher than goal"""
l = 0
r = len(lst) - 1
while l < r:
m = (l + r) // 2
if lst[m] >= k:
r = m
else:
l = m + 1
return lst[r]
def solve(grid):
primesList = primeSieve(100200)
n = len(grid)
m = len(grid[0])
goalGrid = [[0 for _ in range(m)] for _ in range(n)]
for i in range(n):
for j in range(m):
goalGrid[i][j] = binarySearch(primesList, grid[i][j]) - grid[i][j]
minSum = math.inf
for row in goalGrid:
g = sum(row)
if g < minSum:
minSum = g
for j in range(len(goalGrid[0])):
partSum = 0
for i in range(len(goalGrid)):
partSum += goalGrid[i][j]
if partSum < minSum:
minSum = partSum
return minSum
def readinput():
n, m = map(int, sys.stdin.readline().rstrip().split(" "))
lst = []
for _ in range(n):
row = list(map(int, sys.stdin.readline().rstrip().split(" ")))
lst.append(row)
print(solve(lst))
readinput()
| 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 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
for row in xrange(n):
row_sum = 0
for col in xrange(m):
value = matrix[row][col]
if value == 1 or value == 2:
last = 2
else:
for last in xrange(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 xrange(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
MAX_SIZE = 100001
isprime = [True] * MAX_SIZE
prime = []
SPF = [None] * (MAX_SIZE)
d = dict()
def manipulated_seive(N):
isprime[0] = isprime[1] = False
for i in range(2, N):
if isprime[i] == True:
prime.append(i)
d.setdefault(i,1)
SPF[i] = i
j = 0
while (j < len(prime) and i * prime[j] < N and prime[j] <= SPF[i]):
isprime[i * prime[j]] = False
d.setdefault(i * prime[j],0)
SPF[i * prime[j]] = prime[j]
j += 1
if __name__ == '__main__':
manipulated_seive(100001)
d.setdefault(1,0)
prev = 100003
for i in range (100000,0,-1):
if d[i]==0:
d[i] = prev
else:
d[i] = i
prev = i
ans = sys.maxsize
n,m = map(int, input().split())
l = []
for i in range (n):
l.append(list(map(int, input().split())))
for i in range (n):
c = 0
for j in range (m):
c+=(d[l[i][j]]-l[i][j])
ans = min(c,ans)
for j in range (m):
c = 0
for i in range (n):
c+=(d[l[i][j]]-l[i][j])
ans = min(c,ans)
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;
int n;
vector<int> prime;
void creating_seive(bool a[], int n) {
for (int i = 2; i <= (int)(pow(n, 0.5)); i++) {
if (a[i] == 1) {
int k = 0;
for (int j = i * i; j <= n; j = i * i + k * i) {
a[j] = 0;
k++;
}
}
}
for (int i = 2; i <= n; i++) {
if (a[i] == 1) {
prime.push_back(i);
}
}
}
int main() {
int n = 1e5 + 3;
bool a[n + 1];
for (int i = 0; i <= n; i++) {
a[i] = 1;
}
creating_seive(a, n);
int r, c;
cin >> r >> c;
int rmin = 1e5, sumr, sumc, cmin = 1e5;
int arr[r][c];
for (int i = 0; i < r; i++) {
sumr = 0;
for (int j = 0; j < c; j++) {
cin >> arr[i][j];
int index =
lower_bound(prime.begin(), prime.end(), arr[i][j]) - prime.begin();
if (prime[index] > arr[i][j]) {
sumr += prime[index] - arr[i][j];
}
}
if (sumr <= rmin) {
rmin = sumr;
}
}
for (int j = 0; j < c; j++) {
sumc = 0;
for (int i = 0; i < r; i++) {
int index =
lower_bound(prime.begin(), prime.end(), arr[i][j]) - prime.begin();
if (prime[index] > arr[i][j]) {
sumc += prime[index] - arr[i][j];
}
}
if (sumc <= cmin) {
cmin = sumc;
}
}
cout << min(cmin, rmin);
}
| 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 | #Sieve
max_value = 1000000
prime = [True for i in range(max_value + 1)]
prime[0] = prime[1] = False
p = 2
while (p * p <= max_value):
if(prime[p]):
for i in range(p*2, max_value + 1, p):
prime[i] = False
p += 1
#Question
row, col = map(int, input().split())
matrix = []
for i in range(row):
row_input = list(map(int, input().split()))
matrix.append(row_input)
number_dict = {}
count_matrix = []
for r in range(row):
count_row = []
for c in range(col):
number = matrix[r][c]
if(number not in number_dict):
count = number
while(not prime[count]):
count += 1
number_dict[number] = count
else:
count = number_dict[number]
count_row.append(count - number)
count_matrix.append(count_row)
min_moves = 1000000
for r in range(row):
row_sum = 0
for c in range(col):
row_sum += count_matrix[r][c]
min_moves = min(min_moves, row_sum)
for c in range(col):
col_sum = 0
for r in range(row):
col_sum += count_matrix[r][c]
min_moves = min(min_moves, col_sum)
print(min_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>
using namespace std;
void solve() {
int n, m;
cin >> n >> m;
vector<vector<int>> matrix(n, vector<int>(m));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> matrix[i][j];
}
}
vector<int> sieve(200001, 0);
vector<int> primes;
for (int i = 2; i < 200001; ++i) {
if (sieve[i] == 0) {
primes.push_back(i);
for (int j = 2 * i; j < 200001; j += i) {
sieve[j] = i;
}
}
}
vector<vector<int>> needed(n, vector<int>(m, 0));
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int next_index = lower_bound(primes.begin(), primes.end(), matrix[i][j]) -
primes.begin();
needed[i][j] = primes[next_index] - matrix[i][j];
}
}
int64_t ans = 0x3f3f3f3f;
for (int i = 0; i < n; ++i) {
int64_t sum = 0;
for (int j = 0; j < m; ++j) {
sum += needed[i][j];
}
ans = min(ans, sum);
}
for (int j = 0; j < m; ++j) {
int64_t sum = 0;
for (int i = 0; i < n; ++i) {
sum += needed[i][j];
}
ans = min(ans, sum);
}
cout << ans;
}
int main() {
cin.tie(nullptr)->sync_with_stdio(false);
int test_cases_count = 1;
for (int i = 0; i < test_cases_count; ++i) {
solve();
}
}
| 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 = 100000
crivo = [True]*(limite + 1)
crivo[0] = False
crivo[1] = False
i = 2
while(i*i <= limite):
if (crivo[i] == True):
for j in range(i * 2, (limite+1), i):
crivo[j] = False
i += 1
crivo[100000] = 100003
for i in range(99999, -1, -1):
if(not crivo[i]):
if(type(crivo[i+1]) == int):
crivo[i] = crivo[i+1]
else:
crivo[i] = i + 1
l, c = map(int, input().split())
matriz = []
for i in range(l):
matriz.append(list(map(int, input().split())))
linhas = [0]*l
colunas = [0]*c
for i in range(l):
for j in range(c):
d = crivo[matriz[i][j]]
if(type(d) != int):
linhas[i] += 0
colunas[j] += 0
else:
linhas[i] += d - matriz[i][j]
colunas[j] += d - matriz[i][j]
print(min(min(linhas), min(colunas))) | 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 is_prime(x, primes):
for i in primes:
if i * i > x:
break
if x % i == 0:
return False
return True
n, m = [int(x) for x in input().split()]
a = []
primes = []
for i in range(2, 110000):
if is_prime(i, primes):
primes.append(i)
next = [0] * 110000
next[0] = 2
for x in primes:
val = x
while next[x] == 0:
next[x] = val
x -= 1
for i in range(n):
a.append([int(x) for x in input().split()])
for i in range(n):
for j in range(m):
a[i][j] = next[a[i][j]] - a[i][j]
print(min(min(sum(x) for x in a), min(sum(x) for x in zip(*a))))
| 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 |
# Problem: B. Prime Matrix
# Contest: Codeforces - Codeforces Round #166 (Div. 2)
# URL: https://codeforces.com/contest/271/problem/B
# Memory Limit: 256 MB
# Time Limit: 2000 ms
# Powered by CP Editor (https://github.com/cpeditor/cpeditor)
import math
from sys import stdin
def get_ints(): return list(map(int, stdin.readline().strip().split()))
def isPrime(n):
# Corner cases
if(n <= 1):
return False
if(n <= 3):
return True
# This is checked so that we can skip
# middle five numbers in below loop
if(n % 2 == 0 or n % 3 == 0):
return False
for i in range(5,int(math.sqrt(n) + 1), 6):
if(n % i == 0 or n % (i + 2) == 0):
return False
return True
# Function to return the smallest
# prime number greater than N
def nextPrime(N):
# Base case
if (N <= 1):
return 2
prime = N
found = False
# Loop continuously until isPrime returns
# True for a number greater than n
while(not found):
prime = prime + 1
if(isPrime(prime) == True):
found = True
return prime
M= 100100
primes = [0] * M
primes[0]= 2
primes[1] =2
primes[2] = 2
prev = 2
i = 3
primes[i] = 3
while i <M:
f = i
if not isPrime(f):
f = nextPrime(f)
nextone = nextPrime(f+1)
# print(i,f,nextone)
primes[i+1:nextone] = [nextone] * (nextone-i)
i+=nextone-f
# print(primes)
# print(primes[1])
n,m = get_ints()
add = [ [999]*m for i in range(n)]
for i in range(n):
line = get_ints()
for j in range(m):
add[i][j] = primes[line[j]] - line[j]
minrow = 99999999999
for row in add:
minrow = min(minrow,sum(row))
mincol = 99999999999
for col in zip(*add):
mincol = min(mincol,sum(col))
print(min(minrow,mincol)) | 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.Scanner;
import java.util.Arrays;
public class Main271B
{
static boolean[] prime=new boolean[1000001];
static int[] diff=new int[100001];
public static void main(String[] args)
{
Scanner sc=new Scanner(System.in);
preprocess();
int n=sc.nextInt();
int m=sc.nextInt();
int[][] mat=new int[n][m];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
mat[i][j]=sc.nextInt();
}
}
int min=1000000000;
for(int i=0;i<n;i++)
{
int value=0;
for(int j=0;j<m;j++)
{
value+=diff[mat[i][j]];
}
//System.out.println(value);
if(value<min) min=value;
}
for(int i=0;i<m;i++)
{
int value=0;
for(int j=0;j<n;j++)
{
value+=diff[mat[j][i]];
}
if(value<min) min=value;
}
System.out.println(min);
}
public static void preprocess()
{
Arrays.fill(prime,true);
prime[0]=false;
prime[1]=false;
int m=(int)Math.sqrt(1000000);
for(int i=2;i<=m;i++)
{
for(int j=i*i;j<=1000000;j+=i)
{
prime[j]=false;
}
}
int hi=0;
for(int i=100000;i<1000000;i++)
{
if(prime[i])
{
hi=i;
break;
}
}
for(int i=100000;i>=0;i--)
{
if(!prime[i]){
diff[i]=hi-i;
}
else
{
diff[i]=0;
hi=i;
}
}
}
}
| 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 Sanzhar
import java.io.*;
import java.util.*;
import java.awt.Point;
public class Template {
BufferedReader in;
PrintWriter out;
StringTokenizer st;
String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(in.readLine());
} catch (Exception e) {
}
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
long nextLong() {
return Long.parseLong(next());
}
double nextDouble() {
return Double.parseDouble(next());
}
public void run() throws Exception {
//in = new BufferedReader(new FileReader("input.txt"));
//out = new PrintWriter(new FileWriter("output.txt"));
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.flush();
out.close();
in.close();
}
public void solve() throws Exception {
int n = nextInt();
int m = nextInt();
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = nextInt();
}
}
int mm = 200001;
int p[] = new int[mm];
boolean[] prime = new boolean[mm];
Arrays.fill(prime, true);
prime[1] = false;
for (int i = 2; i < mm; i++) {
if (prime[i] && Math.sqrt(mm) > i) {
for (int j = i * i; j < mm; j += i) {
prime[j] = false;
}
}
}
int last = -1;
for (int i = mm - 1; i >= 0; i--) {
if (prime[i]) {
last = i;
} else {
p[i] = last - i;
}
}
int[] c = new int[n + m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = p[a[i][j]];
c[i] += x;
c[n + j] += x;
}
}
int ans = c[0];
for (int i = 0; i < n + m; i++) {
if (c[i] < ans) {
ans = c[i];
}
}
out.println(ans);
}
public static void main(String[] args) throws Exception {
new Template().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 | #include <bits/stdc++.h>
using namespace std;
vector<int> arr(78498);
vector<vector<int>> in(505, vector<int>(505));
vector<vector<int>> out(505, vector<int>(505));
void SieveOfEratosthenes(int n) {
vector<bool> prime(n + 1, true);
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
int i = 0;
for (int p = 2; p <= n; p++)
if (prime[p]) arr[i++] = p;
}
int f(int val) {
int l = 0, u = arr.size() - 1, res = -1;
while (l <= u) {
int mid = (l + u) / 2;
if (val == arr[mid])
return -2;
else if (val < arr[mid]) {
res = mid;
u = mid - 1;
} else
l = mid + 1;
}
return res;
}
int main() {
SieveOfEratosthenes(1000000);
sort(arr.begin(), arr.end());
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) cin >> in[i][j];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int res = f(in[i][j]);
if (res == -2)
out[i][j] = 0;
else if (res == -1)
cout << "error" << endl;
else {
out[i][j] = arr[res] - in[i][j];
}
}
}
long long mini = pow(10, 18);
for (int i = 0; i < n; i++) {
long long tot = 0;
for (int j = 0; j < m; j++) tot += (long long)out[i][j];
mini = min(mini, tot);
}
for (int j = 0; j < m; j++) {
long long tot = 0;
for (int i = 0; i < n; i++) tot += (long long)out[i][j];
mini = min(mini, tot);
}
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 java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
public class ProblemB {
static final int MAX = 110000;
static boolean[] ptable(int max) {
boolean[] isprime = new boolean[max];
Arrays.fill(isprime, true);
isprime[0] = isprime[1] = false;
for (int i = 2 ; i < max ; i++) {
if (isprime[i]) {
for (int ii = i*2 ; ii < max ; ii += i) {
isprime[ii] = false;
}
}
}
return isprime;
}
public static void main(String[] args) throws IOException {
PrintWriter out = new PrintWriter(System.out);
boolean[] p = ptable(MAX);
int[] nextP = new int[MAX+1];
nextP[MAX] = 100000000;
for (int i = MAX-1 ; i >= 0 ; i--) {
if (p[i]) {
nextP[i] = 0;
} else {
nextP[i] = nextP[i+1] + 1;
}
}
int n = nextInt();
int m = nextInt();
int[][] mat = new int[n][m];
for (int i = 0 ; i < n ; i++) {
for (int j = 0 ; j < m ; j++) {
mat[i][j] = nextP[nextInt()];
}
}
long minCost = Long.MAX_VALUE;
for (int i = 0 ; i < n ; i++) {
long cost = 0;
for (int j = 0 ; j < m ; j++) {
cost += mat[i][j];
}
minCost = Math.min(minCost, cost);
}
for (int i = 0 ; i < m ; i++) {
long cost = 0;
for (int j = 0 ; j < n ; j++) {
cost += mat[j][i];
}
minCost = Math.min(minCost, cost);
}
out.println(minCost);
out.flush();
}
static BufferedReader s = new BufferedReader(new InputStreamReader(
System.in));
static StringTokenizer st;
static String nextString() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(s.readLine());
}
return st.nextToken();
}
static int nextInt() throws NumberFormatException, IOException {
return Integer.parseInt(nextString());
}
public static void debug(Object... os) {
System.err.println(Arrays.deepToString(os));
}
} | 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 | maxim= 100005
prime = [True] * maxim
prime[0] = False
prime[1] = False
for i in range(2,maxim):
if prime[i]:
for j in range(i+i, maxim,i):
prime[j] = False
n,m = map(int, input().split())
rows = [0]*n
cols = [0]*m
for i in range(n):
arr = list(map(int, input().split()))
for j in range(m):
x = arr[j]
while not prime[x]:
x+=1
rows[i] += (x-arr[j])
cols[j] += (x-arr[j])
# print(rows)
# print(cols)
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 java.io.*;
import java.math.*;
import java.util.*;
/**
*
* @author Togrul Gasimov ([email protected])
* Created on 13.09.2013
*/
public class Main {
public static void main(String[] args) /*throws FileNotFoundException*/ {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
FastPrinter out = new FastPrinter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
}
class TaskA{
static String s = "";
static void del(int i){
s = s.substring(0, i) + s.substring(i + 1);
}
static boolean p(String s){
int l = s.length();
for(int i = 0; i <= s.length() / 2; i++){
l--;
if(s.charAt(i) != s.charAt(l))return false;
}
return true;
}
public void solve(int testNumber, FastScanner scan, FastPrinter out) /*throws FileNotFoundException*/ {
//Scanner sscan = new Scanner(new File("input.txt"));
//PrintStream oout = new PrintStream(new File("output.txt"));
int[] d = new int[1000001];
for (int i = 2; i < 50003; i++) {
for (int j = 2; i * j < 100004; j++) {
d[(i * j) - 1] = 2;
}
}
d[0] = 2;
int n = scan.nextInt(), m = scan.nextInt();
int[][] a = new int[1000][1000];
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
int x = scan.nextInt();
while (d[x - 1] == 2) {
sum++;
x++;
a[i][j]++;
}
}
min = Math.min(min, sum);
}
for (int i = 0; i < m; i++) {
int sum2 = 0;
for (int j = 0; j < n; j++) {
sum2 += a[j][i];
}
min = Math.min(min, sum2);
}
out.println(min);
//sscan.close();
//oout.close();
}
}
class FastScanner extends BufferedReader {
public FastScanner(InputStream is) {
super(new InputStreamReader(is));
}
public int read() {
try{
int ret = super.read();
return ret;
}catch(Exception e){
throw new InputMismatchException();
}
}
public String next() {
StringBuilder sb = new StringBuilder();
int c = read();
while (isWhiteSpace(c)) {
c = read();
}
if (c < 0) {
return null;
}
while (c >= 0 && !isWhiteSpace(c)) {
sb.appendCodePoint(c);
c = read();
}
return sb.toString();
}
static boolean isWhiteSpace(int c) {
return c >= 0 && c <= 32;
}
public int nextInt() {
int c = read();
while (isWhiteSpace(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int ret = 0;
while (c >= 0 && !isWhiteSpace(c)) {
if (c < '0' || c > '9') {
throw new NumberFormatException("digit expected " + (char) c
+ " found");
}
ret = ret * 10 + c - '0';
c = read();
}
return ret * sgn;
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
public BigDecimal nextBigDecimal(){
return new BigDecimal(next());
}
public String readLine(){
try{
return super.readLine();
}catch(IOException e){
return null;
}
}
}
class FastPrinter extends PrintWriter {
public FastPrinter(OutputStream out) {
super(out);
}
public FastPrinter(Writer out) {
super(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 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Solution {
// public static final double eps = 1e-9;
// public static final int mod = 1000000007;
// public static final double pi = 3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679;
// public static final int dx[] = {1, -1, 0, 0};
// public static final int dy[] = {0, 0, 1, -1};
public static void main(String[] args) throws IOException {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
OutputWriter out = new OutputWriter(outputStream);
Task solver = new Task();
solver.solve(1, in, out);
out.close();
}
static class Task {
public final int sievesize = (int) (1e6);
public boolean[] prime;
public void sieve(){
prime = new boolean[sievesize + 1];
Arrays.fill(prime, true);
for(int x = 2; x * x < sievesize; x++)
{
if(prime[x])
for(int y = x * 2; y < sievesize; y += x)
prime[y] = false;
}
}
public void solve(int testNumber, InputReader in, OutputWriter out) throws IOException {
int n = in.nextInt(), m = in.nextInt();
int[][] arr = new int[n][m];
for (int i = 0; i < n; i++)
arr[i] = in.nextIntArray(m);
sieve();
int[] pre = new int[sievesize + 1];
int k = 2, l = 1;
pre[0] = pre[1] = 2;
while(k < sievesize) {
if (prime[k]) {
Arrays.fill(pre, l + 1, k + 1, k);
l = k;
}
k++;
}
long min = Long.MAX_VALUE;
for (int i = 0; i < n; i++) {
long sum = 0;
for (int j = 0; j < m; j++) {
sum += Math.abs(arr[i][j] - pre[arr[i][j]]);
}
min = Math.min(min, sum);
}
for (int j = 0; j < m; j++) {
long sum = 0;
for (int i = 0; i < n; i++) {
sum += Math.abs(arr[i][j] - pre[arr[i][j]]);
}
min = Math.min(min, sum);
}
out.println(min);
}
// static class Node {
// int data;
// Node next;
//
// public Node(int data) {
// this.data = data;
// next = null;
// }
// }
// static class Node {
// String name;
// LinkedList<Node> list;
//
// public Node(String name) {
// this.name = name;
// list = new LinkedList<>();
// }
// }
//
// static class Pair<T> {
// T first, second;
//
// public Pair(T first, T second) {
// this.first = first;
// this.second = second;
// }
// }
}
// public static int[] shuffle(int arr[], Random gen) {
// for(int i = 0, n = arr.length; i < n; i++)
// {
// int index = gen.nextInt(n - i) + i;
// int temp = arr[i];
// arr[i] = arr[index];
// arr[index] = temp;
// }
// return arr;
// }
//
// public static boolean triangle(long a, long b, long c){
// return ((a+b) > c && (b+c) >a && (a+c) > b);
// }
//
// public static boolean isPerfectSquare(long n){
// if (n < 0)
// return false;
// long test = (long) (Math.sqrt(n) + 0.5);
// return test*test == n;
// }
//
// public static int isnum(char s){
// if(s=='1' || s=='2' || s=='3' || s=='4' || s=='5' || s=='6' || s=='7' || s=='8' || s=='9' || s=='0')
// return 1;
// return 0;
// }
//
// public static long nextPowerOf2(long n){
// n--;
// n |= n >> 1;
// n |= n >> 2;
// n |= n >> 4;
// n |= n >> 8;
// n |= n >> 16;
// n++;
// return n;
// }
//
// public static int gcd(int a, int b){
// int t;
// while (b > 0){
// a = a % b;
// t = a;
// a = b;
// b = t;
// }
// return a;
// }
//
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 long nextLong() {
return Long.parseLong(next());
}
public char nextChar() {
return next().charAt(0);
}
public float nextFloat() {
return Float.parseFloat(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public int[] nextIntArray(int size) {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
int[] arr=new int[size];
for(int i = 0; i < size; i++)
arr[i] = Integer.parseInt(tokenizer.nextToken());
return arr;
}
public long[] nextLongArray(int size) {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
long[] arr=new long[size];
for(int i = 0; i < size; i++)
arr[i] = Long.parseLong(tokenizer.nextToken());
return arr;
}
public float[] nextFloatArray(int size) {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
float[] arr=new float[size];
for(int i = 0; i < size; i++)
arr[i] = Float.parseFloat(tokenizer.nextToken());
return arr;
}
public double[] nextDoubleArray(int size) {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
double[] arr=new double[size];
for(int i = 0; i < size; i++)
arr[i] = Double.parseDouble(tokenizer.nextToken());
return arr;
}
public String[] nextStringArray(int size) throws IOException {
String[] arr=new String[size];
for(int i = 0; i < size; i++)
arr[i] = reader.readLine();
return arr;
}
public char[] nextCharArray(int size) throws IOException {
return reader.readLine().toCharArray();
}
}
static class OutputWriter {
public PrintWriter pw;
public OutputWriter(OutputStream stream) {
pw = new PrintWriter(stream);
}
public void println() {
pw.println();
}
public void println(Object str) {
pw.println(str);
}
public void print(Object str) {
pw.print(str + " ");
}
public void close() {
pw.close();
}
public void flush() {
pw.flush();
}
public void printStringArray(String[] arr) {
for(int i = 0; i < arr.length; i++)
pw.println(arr[i]);
}
public void printIntArray(int[] arr) {
for(int i = 0; i < arr.length; i++)
pw.print(arr[i] + " ");
}
public void printLongArray(long[] arr) {
for(int i = 0; i < arr.length; i++)
pw.print(arr[i] + " ");
}
public void printCharArray(char[] arr) {
for(int i = 0; i < arr.length; i++)
pw.print(arr[i] + " ");
}
public void printFloatArray(float[] arr) {
for(int i = 0; i < arr.length; i++)
pw.print(arr[i] + " ");
}
public void printDoubleArray(double[] arr) {
for(int i = 0; i < arr.length; i++)
pw.print(arr[i] + " ");
}
}
} | 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())
maximum = 10 ** 5 + 3
prime = [True] * (maximum + 1)
prime[0], prime[1] = False, False
for i in range(2, maximum + 1):
if (prime[i]):
for j in range(i + i, maximum + 1, i):
prime[j] = False
matrix = []
sums = [[0] * n, [0] * m]
ans = 1e9 + 7
for i in range(n):
row = [int(i) for i in input().split()]
new_row = []
for j in range(m):
num = row[j]
add = 0
while ((num <= maximum) and (not prime[num])):
add += 1
num += 1
new_row.append(add)
sums[0][i] += add
sums[1][j] += add
matrix.append(new_row)
ans = min(ans, sums[0][i])
for i in range(m):
ans = min(ans, sums[1][i])
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;
void sieve(vector<int> &a, int n) {
vector<bool> siever(n + 10, 1);
int m = (int)sqrt(n);
for (int i = 2; i < m; i++) {
if (siever[i] == 0) continue;
for (int j = i * i; j <= n; j = j + i) {
if (siever[j] != 0) siever[j] = 0;
}
}
int coun = 0;
int pos = 0;
for (int i = 2; i < n; i++) {
if (siever[i] == 1) {
a.push_back(i);
}
}
return;
}
int main() {
long long int n, m, min;
min = 987654321;
vector<int> v;
sieve(v, 100005);
cin >> n >> m;
vector<vector<long long int> > arr(n, vector<long long int>(m));
for (long long int i = 0; i < n; i++) {
for (long long int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (long long int i = 0; i < n; i++) {
long long int sum = 0;
for (long long int j = 0; j < m; j++) {
long long int val = arr[i][j];
vector<int>::iterator it = lower_bound(v.begin(), v.end(), val);
long long int q = *it;
sum = sum + (q - val);
}
if (sum < min) {
min = sum;
}
}
for (long long int j = 0; j < m; j++) {
long long int sum = 0;
for (long long int i = 0; i < n; i++) {
long long int val = arr[i][j];
vector<int>::iterator it = lower_bound(v.begin(), v.end(), val);
long long int q = *it;
sum = sum + (q - val);
}
if (sum < min) {
min = sum;
}
}
cout << min << 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 | /*input
3 3
1 2 3
5 6 1
4 4 1
*/
import java.util.*;
import java.lang.*;
import java.io.*;
public class Main
{
static PrintWriter out;
static int MOD = 1000000007;
static FastReader scan;
/*-------- I/O using short named function ---------*/
public static String ns(){return scan.next();}
public static int ni(){return scan.nextInt();}
public static long nl(){return scan.nextLong();}
public static double nd(){return scan.nextDouble();}
public static String nln(){return scan.nextLine();}
public static void p(Object o){out.print(o);}
public static void ps(Object o){out.print(o + " ");}
public static void pn(Object o){out.println(o);}
/*-------- for output of an array ---------------------*/
static void iPA(int arr []){
StringBuilder output = new StringBuilder();
for(int i=0; i<arr.length; i++)output.append(arr[i] + " ");out.println(output);
}
static void lPA(long arr []){
StringBuilder output = new StringBuilder();
for(int i=0; i<arr.length; i++)output.append(arr[i] + " ");out.println(output);
}
static void sPA(String arr []){
StringBuilder output = new StringBuilder();
for(int i=0; i<arr.length; i++)output.append(arr[i] + " ");out.println(output);
}
static void dPA(double arr []){
StringBuilder output = new StringBuilder();
for(int i=0; i<arr.length; i++)output.append(arr[i] + " ");out.println(output);
}
/*-------------- for input in an array ---------------------*/
static void iIA(int arr[]){
for(int i=0; i<arr.length; i++)arr[i] = ni();
}
static void lIA(long arr[]){
for(int i=0; i<arr.length; i++)arr[i] = nl();
}
static void sIA(String arr[]){
for(int i=0; i<arr.length; i++)arr[i] = ns();
}
static void dIA(double arr[]){
for(int i=0; i<arr.length; i++)arr[i] = nd();
}
/*------------ for taking input faster ----------------*/
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
// Method to check if x is power of 2
static boolean isPowerOfTwo (int x) { return x!=0 && ((x&(x-1)) == 0);}
//Method to return lcm of two numbers
static int gcd(int a, int b){return a==0?b:gcd(b % a, a); }
// method to return LCM of two numbers
static int lcm(int a, int b){return (a / gcd(a, b)) * b;}
//Method to count digit of a number
static int countDigit(long n){return (int)Math.floor(Math.log10(n) + 1);}
//Method to find the max in an array
static int getMax(int arr[]){
int max = arr[0];
for(int i=0; i<arr.length; i++){
max = arr[i]>max?arr[i]:max;
}
return max;
}
//Method to find the min in an array
static int getMin(int arr[]){
int min = arr[0];
for(int i=0; i<arr.length; i++){
min = min>arr[i]?arr[i]:min;
}
return min;
}
//Method for sorting
static void ruffle_sort(int[] a) {
//shandom_ruffle
Random r=new Random();
int n=a.length;
for (int i=0; i<n; i++) {
int oi=r.nextInt(n);
int temp=a[i];
a[i]=a[oi];
a[oi]=temp;
}
//sort
Arrays.sort(a);
}
public static void main (String[] args) throws java.lang.Exception
{
OutputStream outputStream =System.out;
out =new PrintWriter(outputStream);
scan =new FastReader();
//for fast output sometimes
StringBuilder sb = new StringBuilder();
int r = ni(), c = ni();
int arr[][] = new int[r][c];
for(int i=0; i<r; i++){
for(int j=0; j<c; j++){
arr[i][j] = ni();
}
}
TreeSet<Integer> ts = new TreeSet<>();
ts= sieve(200000, ts);
int ans1=0, min=Integer.MAX_VALUE, sum=0;
for(int i=0; i<r; i++){
sum=0;
for(int j=0; j<c; j++){
int num = ts.ceiling(arr[i][j])-arr[i][j];
sum += num;
}
//pn(sum);
if(sum<min)
min = sum;
}
for(int j=0; j<c; j++){
sum=0;
for(int i=0; i<r; i++){
int num = ts.ceiling(arr[i][j])-arr[i][j];
sum += num;
}
//pn(sum);
if(sum<min)
min = sum;
}
pn(min);
out.flush();
out.close();
}
static TreeSet<Integer> sieve(int n, TreeSet<Integer> list){
//boolean array and storing true
boolean prime[] = new boolean[n + 1];
for (int i = 0; i <= n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
// If prime[p] is not changed, then it is a
// prime
if (prime[p] == true)
{
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
// Print all prime numbers
for (int i = 2; i <= n; i++)
{
if (prime[i] == true)
list.add(i);
}
return list;
}
}
| 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_left as bl
n,m=map(int,input().split())
pn,l=[],[]
q=10**5+4
k=[True for i in range(q+2)]
for p in range(2,int(q**.5)+2):
if(k[p]==True):
for i in range(p**2,q+2,p):k[i]=False
for p in range(2,q+1):
if k[p]:pn.append(p)
for i in range(n):
l.append(list(map(int,input().split())))
def f(l,q):
for i in l:
x=0
for j in i:x+=pn[bl(pn,j)]-j
q=min(q,x)
return q
print(f(zip(*l),f(l,q))) | 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
input = lambda: sys.stdin.readline().strip("\r\n")
def sieve(n):
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n + 1, p):
prime[i] = False
p += 1
n, m = map(int, input().split())
no = 10 ** 5 + 100
prime = [True for i in range(no + 1)]
sieve(no)
prime[0] = False
prime[1] = False
req = [0] * no
for i in range(no - 2, -1, -1):
if prime[i]:
req[i] = 0
else:
req[i] = req[i + 1] + 1
mat = []
for i in range(n):
b = list(map(int, input().split()))
mat.append(b)
ans = float("inf")
for i in range(n):
temp = 0
for j in range(m):
temp += req[mat[i][j]]
ans = min(ans, temp)
for i in range(m):
temp = 0
for j in range(n):
temp += req[mat[j][i]]
ans = min(ans, temp)
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;
bool numbers[100010];
void initi() {
for (int i = 0; i < 100010; i++) numbers[i] = true;
}
void seive() {
for (int i = 2; i * i <= 100010; i++) {
if (numbers[i] == true) {
for (int j = i * 2; j <= 100010; j = j + i) numbers[j] = false;
}
}
}
int main() {
cin.tie(NULL);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
initi();
seive();
numbers[1] = numbers[0] = false;
int a[n + 2][m + 2];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int t;
cin >> t;
for (int k = t; k <= 100010; k++) {
if (numbers[k] == true) {
a[i][j] = k - t;
break;
}
}
}
}
long sum = long(1e5);
for (int i = 0; i < n; i++) {
long count = 0;
for (int j = 0; j < m; j++) {
count += a[i][j];
}
if (count < sum) sum = count;
}
for (int i = 0; i < m; i++) {
long count = 0;
for (int j = 0; j < n; j++) {
count += a[j][i];
}
if (count < sum) sum = count;
}
cout << sum;
return 0;
}
| CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.