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 | # specify list capacity
MaxN = 101002
prime_list = [0]*MaxN
prime_list[0] = prime_list[1] = 1
# mark all composite number with 1
for i in range(2, MaxN):
if prime_list[i] == 1:
continue
j = i*2
while j < MaxN:
prime_list[j] = 1
j += i
# then replace all '0' and '1' with prime number
i = MaxN-2
while i > 0:
prime_list[i] = prime_list[i+1] if prime_list[i] == 1 else i
i -= 1
#print prime_list
n,m=map(int,raw_input().split())
a=[map(int,raw_input().split()) for i in range(n)]
for i in range(n):
for j in range(m):
a[i][j]=prime_list[a[i][j]]-a[i][j]
#print a
ans1=min(sum(a[i][j] for j in range(m)) for i in range(n))
ans2=min(sum(a[i][j] for i in range(n)) for j in range(m))
print min(ans1,ans2)
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def generate_primes(n):
# Create a boolean array "prime[0..n]" and initialize
# all entries it as true. A value in prime[i] will
# finally be false if i is Not a prime, else true.
prime = [True for i in range(n + 1)]
p = 2
while (p * p <= n):
# If prime[p] is not changed, then it is a prime
if (prime[p] == True):
# Update all multiples of p
for i in range(p * 2, n + 1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
# Print all prime numbers
primes = []
for p in range(n + 1):
if prime[p]:
primes.append(p)
return primes
def calculate_distances(primes):
pidx = 0
distances = []
for i in range(100001):
if i > primes[pidx]:
pidx += 1
distances.append(primes[pidx] - i)
return distances
if __name__ == '__main__':
primes = generate_primes(100003)
distances = calculate_distances(primes)
matrix = []
n, _ = map(int, input().split())
for _ in range(n):
matrix.append(list(map(int, input().split())))
dmx = list(map(lambda r: list(map(lambda x: distances[x], r)), matrix))
t_dmx = [[dmx[j][i] for j in range(len(dmx))] for i in range(len(dmx[0]))]
mdr = min(map(sum, dmx))
mdc = min(map(sum, t_dmx))
print(min(mdr, mdc))
| 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 {
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 condition[] = isPrimo(100000);
int primos[]=new int[9594];
int cont=1;
primos[0]=0;
for (int i = 0; i < condition.length; i++) {
if(condition[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.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B {
static StringTokenizer st;
static BufferedReader in;
public static void main(String[] args) throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int n = nextInt();
int m = nextInt();
int[][]a = new int[n+1][m+1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
a[i][j] = nextInt();
}
}
int t = (int) 1e6;
boolean[]prime = new boolean[t+1];
Arrays.fill(prime, true);
prime[1] = false;
for (int i = 2; i*i <= t; i++) {
if (prime[i]) {
for (int j = i*i; j <= t; j += i) {
prime[j] = false;
}
}
}
int[]nextpr = new int[t+1];
int begin = 0;
for (int i = t; i >= 1; i--) {
if (prime[i]) {
begin = i;
break;
}
}
for (int i = begin; i >= 1; i--) {
if (prime[i])
begin = i;
nextpr[i] = begin;
}
long ans = (long) 1e18;
for (int i = 1; i <= n; i++) {
long cnt = 0;
for (int j = 1; j <= m; j++) {
cnt += nextpr[a[i][j]]-a[i][j];
}
ans = Math.min(ans, cnt);
}
for (int i = 1; i <= m; i++) {
long cnt = 0;
for (int j = 1; j <= n; j++) {
cnt += nextpr[a[j][i]]-a[j][i];
}
ans = Math.min(ans, cnt);
}
System.out.println(ans);
pw.close();
}
private static int nextInt() throws IOException{
return Integer.parseInt(next());
}
private static long nextLong() throws IOException{
return Long.parseLong(next());
}
private static double nextDouble() throws IOException{
return Double.parseDouble(next());
}
private static String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
return st.nextToken();
}
}
| 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,math
isprime = [0]*1000010
all_prime = [2]
next_prime = [0]*1000010
def seive():
isprime[1] = isprime[0] = 1
limit = int(math.sqrt(1000010))+2
for i in range(4,1000010,2):
isprime[i] = 1
for i in range(3,1000010,2):
if(not isprime[i]):
all_prime.append(i)
if(i <= limit):
for j in range(i*i,1000010,i*2):
isprime[j] = 1
seive()
prime = 0
for i in range(1000000):
next_prime[i] = all_prime[prime]
if(all_prime[prime] == i):
prime+=1
r,c = map(int,input().split())
input_matrix = []
move = []
for i in range(r):
temp = list(map(int,input().split()))
input_matrix.append(temp)
for i in range(r):
co = 0
for j in range(c):
co+= next_prime[input_matrix[i][j]] - input_matrix[i][j]
move.append(co)
for i in range(c):
co = 0
for j in range(r):
co+= next_prime[input_matrix[j][i]] - input_matrix[j][i]
move.append(co)
print(min(move)) | 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/problemset/problem/271/B
# Memory Limit: 256 MB
# Time Limit: 2000 ms
#
# Powered by CP Editor (https://cpeditor.org)
from sys import stdin, stdout
def INI():
return int(stdin.readline())
def INL():
return [int(_) for _ in stdin.readline().split()]
def INS():
return stdin.readline()
def OPS(ans):
stdout.write(str(ans)+"\n")
def OPL(ans):
[stdout.write(str(_)+" ") for _ in ans]
stdout.write("\n")
def SieveOfEratosthenes(n):
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
for p in range(2, n+1):
if prime[p]:
yield p
from bisect import bisect_left
if __name__=="__main__":
n,m=INL()
X=[]
P=list(SieveOfEratosthenes(1000000))
ans=float("inf")
for _ in range(n):
U=INL()
g=[]
for _ in U:
g.append(P[bisect_left(P,_)]-_)
X.append(g)
ans=min(ans,sum(g))
for _ in range(m):
g=0
for __ in range(n):
g+=X[__][_]
ans=min(ans,g)
print(ans) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
n, m = map(int, input().rstrip().split())
# dp = [[0] * m for _ in range(n)]
row = [0] * n
col = [0] * m
# mat = []
def isPrime(x):
if x in [2, 3, 5, 7, 11, 13, 17, 19]:
return True
if x == 1:
return False
for i in range(2,int( math.sqrt(x)) + 2):
if x % i == 0:
return False
return True
primes = [0] * 100011
for i in range(1, 100011):
if isPrime(i):
primes[i] = 1
for i in range(n):
li = list(map(int, input().rstrip().split()))
# mat += [li]
for j in range(m):
x = li[j]
while primes[x] != 1:
x += 1
row[i] += x - li[j]
col[j] += x - li[j]
minm = min(row + col)
print(minm) | 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 | numMax = 102001
numMin = 2
prime = [1] * numMax
prime[1] = 0
prime[0] = 0
for i in range(numMin, numMax):
j = i
while(j+i < numMax):
j += i
prime[j] = 0
linha, coluna = map(int, raw_input().split())
matrix = []
for i in range(linha):
values = list(map(int, raw_input().split()))
matrix.append(values)
saida = 50000000
for i in range(linha):
total = 0
for j in range(coluna):
result = matrix[i][j]
for k in range(result, numMax):
if prime[k] == 1:
total += k-result
break
saida = min(saida, total)
for j in range(coluna):
total = 0
for i in range(linha):
result = matrix[i][j]
for k in range(result, numMax):
if prime[k] == 1:
total += k-result
break
saida = min(saida, total)
print(saida)
| 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;
string uppercase(string s) {
transform(s.begin(), s.end(), s.begin(), ::toupper);
return s;
}
string lowercase(string s) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
return s;
}
set<pair<int, pair<string, int>>> sp;
vector<vector<int>> v2d(5, vector<int>(5, 7));
vector<int> v;
void Isprime() {
for (int i = 2; i <= 100010; i++) {
int ptr = 1;
for (int j = 2; j * j <= i; ++j) {
if (i % j == 0) {
ptr = 0;
break;
}
}
if (ptr) v.push_back(i);
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
Isprime();
int n, m;
cin >> n >> m;
int A[505][505];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> A[i][j];
}
}
int ans = 0, mn = 1e7;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
int p = lower_bound(v.begin(), v.end(), A[i][j]) - v.begin();
ans += (v[p] - A[i][j]);
}
mn = min(ans, mn);
ans = 0;
}
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
int p = lower_bound(v.begin(), v.end(), A[j][i]) - v.begin();
ans += (v[p] - A[j][i]);
}
mn = min(ans, mn);
ans = 0;
}
cout << mn << "\n";
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class CF_271_B_PRIME_MATRIX {
static final int MAX = (int) (10e6+1);
static boolean notPrime [] = new boolean[MAX];
static ArrayList<Long> list = new ArrayList<>() ;
static void sieve()
{
notPrime[0] = true;
notPrime[1] = true;
for(int i = 2 ; i<MAX ;i++)
{
if(!notPrime[i])
{
if(i*1l*i<=MAX)
{
for(int j = i*i ; j<MAX ;j+=i)
notPrime[j] = true;
// System.out.println(i+" "+MAX);
list.add(i*1l);
}
}
}
}
public static void main(String[] args) throws Exception{
Scanner sc = new Scanner(System.in);
sieve();
for(int i = 3137 ; i<MAX ; i++)
if(!notPrime[i])
list.add(i*1l);
// System.out.println(list);
// System.out.println(list.size());
////
int n = sc.nextInt();
int m = sc.nextInt();
long mat [][] = new long [n][m];
for(int i = 0 ; i<n ; i++)
for(int j = 0 ; j<m ; j++)
mat[i][j] = sc.nextInt();
long res [][] = new long [n][m];
int size = list.size();
for(int i = 0 ; i<n ; i++)
for(int j = 0 ; j<m ; j++)
{
long element = mat[i][j];
int start = 0 ;
int end = size - 1;
int ans = size -1;
if(notPrime[(int)element]) {
while(start<=end)
{
int mid = (start+end)/2;
if(list.get(mid)<element)
start = mid + 1 ;
else {
ans = mid ;
end = mid - 1 ;
}
}
res [i][j] = list.get(ans);
}
else
res [i][j] = mat[i][j];
mat[i][j] = res[i][j] - mat[i][j]<0 ? 0 : res[i][j] - mat[i][j];
}
long ans = (int) 10e6;
for(int i = 0 ; i<n ;i++)
{
long sum = 0 ;
for(int j = 0 ; j<m ; j++)
sum+= mat[i][j];
ans = Math.min(sum, ans);
}
for(int j = 0 ; j<m ; j++)
{
long sum = 0 ;
for(int i = 0 ; i<n ; i++)
sum+= mat[i][j];
ans = Math.min(sum, ans);
}
System.out.println(ans);
}
static class Scanner {
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream s) {
br = new BufferedReader(new InputStreamReader(s));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public String nextLine() throws IOException {
return br.readLine();
}
public double nextDouble() throws IOException {
String x = next();
StringBuilder sb = new StringBuilder("0");
double res = 0, f = 1;
boolean dec = false, neg = false;
int start = 0;
if (x.charAt(0) == '-') {
neg = true;
start++;
}
for (int i = start; i < x.length(); i++)
if (x.charAt(i) == '.') {
res = Long.parseLong(sb.toString());
sb = new StringBuilder("0");
dec = true;
} else {
sb.append(x.charAt(i));
if (dec)
f *= 10;
}
res += Long.parseLong(sb.toString()) / f;
return res * (neg ? -1 : 1);
}
public boolean ready() throws IOException {
return br.ready();
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 20 20:37:49 2020
@author: narayanaaramamurthy
"""
a,b=map(int,input().split())
c=100030
f=[0]*c
f[1]=1
for i in range(2,c):
if f[i]==0:
for j in range(i+i,c,i):
f[j]=1
t=0
for i in range(c-1,0,-1):
if f[i]==0:
t=i
f[i]=t
l=[[int(j) for j in input().split()] for i in range(a)]
for i in range(a):
for j in range(b):
t=l[i][j]
l[i][j]=f[t]-l[i][j]
mx=10**10
for i in range(a):
mx=min(mx,sum(l[i]))
for j in range(b):
t=0
for i in range(a):
t+=l[i][j]
mx=min(mx,t)
print(mx) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import collections
import bisect
prime = [-1] * 200000
i = 2
prime_list = []
while 200000 > i:
if prime[i - 1] == -1:
prime[i - 1] = 0
temp = i * 2
prime_list.append(i)
while temp < 200000:
prime[temp - 1] = 1
temp += i
if i == 2:
i += 1
else:
i += 2
n, m = map(int, sys.stdin.readline().split())
matrix = []
for line in sys.stdin:
matrix.append(map(int, line.split()))
diff = [[0 for i in xrange(m)] for j in xrange(n)]
for i in xrange(n):
for j in xrange(m):
up = prime_list[bisect.bisect_left(prime_list, matrix[i][j])]
diff[i][j] = up - matrix[i][j]
mv = 10000000
for i in xrange(n):
mv = min(mv, sum(diff[i]))
for j in xrange(m):
d = 0
for i in xrange(n):
d += diff[i][j]
mv = min(mv, d)
print mv
| 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<long long> prime;
bool isprime[1000001];
void find_prime() {
memset(isprime, true, sizeof isprime);
for (long long i = 2; i <= sqrt(1000000); i++) {
if (isprime[i] == true) {
for (long long j = i * i; j <= 1000000; j += i) {
isprime[j] = false;
}
}
}
for (long long i = 2; i <= 1000000; i++) {
if (isprime[i]) prime.push_back(i);
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t;
t = 1;
start:
while (t--) {
long long n, m;
cin >> n >> m;
long long arr[n + 1][m + 1];
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) cin >> arr[i][j];
}
long long mn = 1e10;
find_prime();
for (long long i = 1; i <= n; i++) {
long long op = 0;
for (long long j = 1; j <= m; j++) {
long long ind =
lower_bound(prime.begin(), prime.end(), arr[i][j]) - prime.begin();
op += prime[ind] - arr[i][j];
}
mn = min(mn, op);
}
for (long long i = 1; i <= m; i++) {
long long op = 0;
for (long long j = 1; j <= n; j++) {
long long ind =
lower_bound(prime.begin(), prime.end(), arr[j][i]) - prime.begin();
op += prime[ind] - arr[j][i];
}
mn = min(mn, op);
}
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 | 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):
for j in xrange(2, int(math.sqrt(i) + 1)):
if i % j == 0:
p[i] = 0
break
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 | import math
n,m = map(int,input().split())
grid = [list(map(int, input().split())) for _ in range(n)]
def seive():
s = 10**5 + 10
primes = [True] * (s)
primes[0] = False
primes[1] = False
for i in range(2,int(math.sqrt(s))+1):
j = 2
while(j*i<s):
#print(j*i)
primes[i*j] =False
j+=1
return primes
primes = seive()
#calculating nearest prime numbers difference
near = list(range(0,(10**5+10)))
for i in range(10**5+9,0,-1):
if primes[i]:
cur = i
near[i] = 0
j = i
break
for i in range(j-1,-1,-1):
if primes[i]:
cur = i
near[i] = 0
else:
near[i] = abs(cur - near[i])
cols = [0]*m
rows = [0]*n
k = float('INF')
for i in range(n):
temp = 0
for j in range(m):
temp += near[grid[i][j]]
#cols[j]+= near[grid[i][j]]
#rows[i] = temp
k = min(k,temp)
for i in range(m):
temp = 0
for j in range(n):
temp += near[grid[j][i]]
#cols[j]+= near[grid[i][j]]
#rows[i] = temp
k = min(k,temp)
#res = min(rows)
#res = min(res,min(cols))
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;
const int LIMIT = 1000005;
int sieve[LIMIT + 1];
int primes[LIMIT + 1];
int mark_primes() {
int primeCount = 1;
for (int i = 0; i <= LIMIT; ++i) sieve[i] = 0;
for (int i = 2; i <= LIMIT; ++i) {
if (!sieve[i]) {
primes[primeCount] = i;
sieve[i] = primeCount;
primeCount++;
}
for (int j = 1; j <= sieve[i] && i * primes[j] <= LIMIT; j++) {
sieve[i * primes[j]] = j;
}
}
return primeCount;
}
const int MAXN = 505;
int a[MAXN][MAXN];
int main() {
int k = mark_primes();
int n, m;
while (cin >> n >> m) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a[i][j];
}
}
int best_row = INT_MAX;
for (int i = 0; i < n; ++i) {
int count = 0;
for (int j = 0; j < m; ++j) {
int next_prime = *(lower_bound(primes, primes + k, a[i][j]));
count += next_prime - a[i][j];
}
best_row = min(best_row, count);
}
int best_col = INT_MAX;
for (int j = 0; j < m; ++j) {
int count = 0;
for (int i = 0; i < n; ++i) {
int next_prime = *(lower_bound(primes, primes + k, a[i][j]));
count += next_prime - a[i][j];
}
best_col = min(best_col, count);
}
cout << min(best_row, best_col) << 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 | // package codeforces1;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.io.*;
import java.math.*;
import java.text.*;
public class B166 {
static InputReader in = new InputReader(System.in);
static OutputWriter out = new OutputWriter(System.out);
public static void main(String[] args) throws NumberFormatException, IOException {
// TODO Auto-generated method stub
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int t = 1;
boolean isPrime[]=new boolean[200001];
for(int i=0;i<200001;i++) {
isPrime[i]=true;
}
// System.out.println(isPrime[4]);
for (int i=2; i*i<=200000; i++)
{
if (isPrime[i] == true)
{
for (int j=i*i; j<=200000; j += i)
isPrime[j] = false;
}
}
PrintWriter out = new PrintWriter(System.out);
while (t > 0) {
int n = i();
int m=i();
int arr[][] = new int[n][m];
for (int i = 0; i < n; i++) {
for(int j=0;j<m;j++) {
arr[i][j]=i();
}
}
int c=0;
int a1=10000000;
// for(int i=2;i<50;i++) {
// System.out.println(i+" "+isPrime[i]);
// }
isPrime[1]=false;
for(int i=0;i<n;i++) {
c=0;
for(int j=0;j<m;j++) {
int k=arr[i][j];
while(!isPrime[k]) {
// System.out.println(k);
c++;
k++;
}
}
a1=Math.min(c, a1);
}
// System.out.println(a1);
int a2=100000000;
for(int j=0;j<m;j++) {
c=0;
for(int i=0;i<n;i++) {
int k=arr[i][j];
while(!isPrime[k]) {
// System.out.println(k);
c++;
k++;
}
}
a2=Math.min(c, a2);
}
System.out.println(Math.min(a1, a2));
out.println();
t--;
}
out.close();
// long l=l();
// String s=s(); // ONLY BEFORE SPACE IN STRING , ELSE USE BUFFER-READER
}
public static long pow(long a, long b) {
long m = 1000000007;
long result = 1;
while (b > 0) {
if (b % 2 != 0) {
result = (result * a) % m;
b--;
}
a = (a * a) % m;
b /= 2;
}
return result % m;
}
public static long gcd(long a, long b) {
if (a == 0) {
return b;
}
return gcd(b % a, a);
}
public static long lcm(long a, long b) {
return a * (b / gcd(a, b));
}
public static long l() {
String s = in.String();
return Long.parseLong(s);
}
public static void pln(String value) {
System.out.println(value);
}
public static int i() {
return in.Int();
}
public static String s() {
return in.String();
}
}
class pair {
int x, y;
pair(int x, int y) {
this.x = x;
this.y = y;
}
}
class CompareValue {
static void compare(pair arr[], int n) {
Arrays.sort(arr, new Comparator<pair>() {
public int compare(pair p1, pair p2) {
return p1.y - p2.y;
}
});
}
}
class CompareKey {
static void compare(pair arr[], int n) {
Arrays.sort(arr, new Comparator<pair>() {
public int compare(pair p1, pair p2) {
return p2.x - p1.x;
}
});
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private 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 Int() {
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 String String() {
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 String();
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
public double readDouble() {
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, Int());
}
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, Int());
}
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
}
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 print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0) {
writer.print(' ');
}
writer.print(objects[i]);
}
writer.flush();
}
public void printLine(Object... objects) {
print(objects);
writer.println();
writer.flush();
}
public void close() {
writer.close();
}
public void flush() {
writer.flush();
}
}
class IOUtils {
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.Int();
return array;
}
}
/**
* TO SORT VIA TWO KEYS , HERE IT IS ACCORDING TO ASCENDING ORDER OF FIRST AND
* DESC ORDER OF SECOND
* LIST name-list
* ARRAYLIST
* COPY PASTE
*
* Collections.sort(list, (first,second) ->{
if(first.con >second.con)
return -1;
else if(first.con<second.con)
return 1;
else {
if(first.index >second.index)
return 1;
else
return -1;
}
});
*
*/
/**
*
DECIMAL FORMATTER
Double k = in.readDouble();
System.out.println(k);
DecimalFormat df = new DecimalFormat("#.##");
System.out.print(df.format(k));
out.printLine(k);
*
* */
| 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.*;
public class second
{
static long fast_power(long a,long n,long m)
{
if(n==1)
{
return a%m;
}
if(n%2==1)
{
long power = fast_power(a,(n-1)/2,m)%m;
return ((a%m) * ((power*power)%m))%m;
}
long power = fast_power(a,n/2,m)%m;
return (power*power)%m;
}
static int move(int primes[], int k,int last)
{
int first=0;
int mid=last/2;
while(primes[mid]!=k)
{
if(k>primes[mid])first=mid;
else last=mid-1;
mid = (first+last)/2;
if((last-first)<=1)break;
}
if(primes[mid]==k)return primes[mid];
if(primes[last]<k)return primes[last+1];
return primes[last];
}
public static void main(String arr[])
{
Scanner sc= new Scanner(System.in);
int primes[] = new int[100000];
int k[] = new int[1000000];
int i=2;
int num=0;
while(i<=100000)
{
if(k[i]==0)
{
primes[num++] = i;
for(int j=i;j<1000000;j+=i)
{
k[j]+=1;
}
}
i++;
}
while(k[i]!=0)i++;
primes[num++]=i;
int n = sc.nextInt();
int m = sc.nextInt();
int a[][] = new int[n][m];
for(i=0;i<n;i++)
{
for(int j=0;j<m;j++)
a[i][j] = sc.nextInt();
}
int r[] = new int[n];
int c[] = new int[m];
for(i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
int moves= move(primes,a[i][j],num-1)-a[i][j];
r[i]+=moves;
c[j]+=moves;
}
}
int min = r[0];
for( i=0;i<n;i++)
{
if(r[i]<=min)min=r[i];
}
for( i=0;i<m;i++)
{
if(c[i]<=min)min=c[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 | import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Task271B {
public static void main(String... args) throws NumberFormatException,
IOException {
Solution.main(System.in, System.out);
}
static class Solution {
private static boolean isPrime(int n) {
if (n < 2) {
return false;
}
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
return false;
}
}
return true;
}
public static void main(InputStream is, OutputStream os)
throws NumberFormatException, IOException {
PrintWriter pw = new PrintWriter(os);
Scanner s = new Scanner(is);
int n = s.nextInt();
int m = s.nextInt();
ArrayList<Integer> primes = new ArrayList<>();
for (int i = 2; ; i++) {
if (isPrime(i)) {
primes.add(i);
if(i > 100000){
break;
}
}
}
ArrayList<ArrayList<Integer>> matrix = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
matrix.add(new ArrayList<Integer>(m));
for (int j = 0; j < m; j++) {
matrix.get(i).add(s.nextInt());
}
}
ArrayList<ArrayList<Integer>> operations = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
operations.add(new ArrayList<Integer>(m));
for (int j = 0; j < m; j++) {
Integer primeIndex = Collections.binarySearch(primes,
matrix.get(i).get(j));
if(primeIndex >= 0){
operations.get(i).add(0);
} else {
operations.get(i).add(primes.get(Math.abs(primeIndex)-1)-matrix.get(i).get(j));
}
}
}
ArrayList<Integer> columnCosts = new ArrayList<>(n);
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++) {
sum += operations.get(i).get(j);
}
columnCosts.add(sum);
}
ArrayList<Integer> rowCosts = new ArrayList<>(m);
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++) {
sum += operations.get(i).get(j);
}
rowCosts.add(sum);
}
int min = Math.min(Collections.min(columnCosts),
Collections.min(rowCosts));
pw.write("" + min);
pw.flush();
s.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 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.text.*;
public class cf271b {
static BufferedReader br;
static Scanner sc;
static PrintWriter out;
public static void initA() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(System.in);
//out = new PrintWriter("output.txt");
out = new PrintWriter(System.out);
} catch (Exception e) {
}
}
public static void initB() {
try {
br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
} catch (Exception e) {
}
}
public static String getString() {
try {
return br.readLine();
} catch (Exception e) {
}
return "";
}
public static Integer getInt() {
try {
return Integer.parseInt(br.readLine());
} catch (Exception e) {
}
return 0;
}
public static Integer[] getIntArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Integer temp2[] = new Integer[n];
for (int i = 0; i < n; i++) {
temp2[i] = Integer.parseInt(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static Long[] getLongArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Long temp2[] = new Long[n];
for (int i = 0; i < n; i++) {
temp2[i] = Long.parseLong(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static String[] getStringArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
String temp2[] = new String[n];
for (int i = 0; i < n; i++) {
temp2[i] = (temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static int getMax(Integer[] ar) {
int t = ar[0];
for (int i = 0; i < ar.length; i++) {
if (ar[i] > t) {
t = ar[i];
}
}
return t;
}
public static void print(Object a) {
out.println(a);
}
public static int nextInt() {
return sc.nextInt();
}
public static double nextDouble() {
return sc.nextDouble();
}
public static void main(String[] ar) {
initA();
solve();
out.flush();
}
public static void solve() {
int max = 110000;
boolean notprime[] = new boolean[110000];
for (int i = 2; i < max; i++) {
for (int j = 2; j * i < max; j++) {
notprime[i * j] = true;
}
}
ArrayList<Integer> prime = new ArrayList<Integer>(110000);
for (int i = 2; i < max; i++) {
if (!notprime[i]) {
prime.add(i);
}
}
final int last = prime.size();
int dp[] = new int[110000];
Arrays.fill(dp, -1);
Integer x[] = getIntArr();
int n = x[0], m = x[1];
int min[][] = new int[n][m];
for (int i = 0; i < n; i++) {
Integer temp[] = getIntArr();
for (int ii = 0; ii < m; ii++) {
int num = temp[ii];
int orinum = num;
if (dp[num] == -1) {
int s = 0;
while (Collections.binarySearch(prime, num) < 0) {
num++;
s++;
}
min[i][ii] = s;
dp[orinum] = s;
} else {
min[i][ii] = dp[num];
}
/*
int l =0, r= last-1;
while(l!=r){
int mid = (l+r)/2;
int te = prime.get(mid);
if(te >= num){
r=mid;
}else{
l=mid+1;
}
}
min[i][ii] = prime.get(l)-num;
*/
}
}
int out = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int ii = 0; ii < m; ii++) {
sum += min[i][ii];
}
out = Math.min(sum, out);
}
for (int i = 0; i < m; i++) {
int sum = 0;
for (int ii = 0; ii < n; ii++) {
sum += min[ii][i];
}
out = Math.min(sum, out);
}
print(out);
}
static boolean isPrime(int n) {
if (n == 2 || n == 3) {
return true;
}
if (n < 2 || n % 2 == 0) {
return false;
}
for (int i = 3; i <= Math.sqrt(n) + 1; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class Main2 {
public static void main(String args[]){
Scanner input = new Scanner(System.in);
int row = input.nextInt();
int col = input.nextInt();
int[][] matrix = new int[row][col];
for(int i = 0 ; i < row ; i++){
for(int j = 0 ; j < col ; j++){
matrix[i][j] = input.nextInt();
}
}
System.out.println(ressya(row,col,matrix));
}
public static int ressya(int row,int col,int[][] matrix){
int min = 999999999;
int tmp;
int[] nextprime = new int[100000];
nextprime[0] = 1;nextprime[1] = 0;
for(int a = 3 ; a <= 100000 ; a++){
int x = a;
int index = 0;
while(true){
boolean isok = true;
if(x % 2 == 0){
isok = false;
}else{
for(int i = 3 ; i <= Math.sqrt(x) ; i+=2){
if(x % i == 0){
isok = false;
break;
}
}
}
if(isok){
nextprime[a-1] = index;
break;
}
x++;
index++;
}
}
for(int i = 0 ; i < row ; i++){
tmp = 0;
for(int j = 0 ; j < col ; j++){
tmp += nextprime[matrix[i][j]-1];
}
min = Math.min(tmp, min);
}
for(int i = 0 ; i < col ; i++){
tmp = 0;
for(int j = 0 ; j < row ; j++){
tmp += nextprime[matrix[j][i]-1];
}
min = Math.min(tmp, min);
}
return min;
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Random;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
public class Two {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.call(in,out);
out.close();
}
static class TaskA {
public void call(InputReader in, PrintWriter out) {
int n, m , l , r ,mid , sum , max =Integer.MAX_VALUE , temp;
n = in.nextInt();
m = in.nextInt();
int[] array = new int[100001];
int[][] arr = new int[n][m];
for (int i = 0; i <n ; i++) {
for (int j = 0; j <m ; j++) {
arr[i][j] = in.nextInt();
}
}
ArrayList<Integer> arrayList = new ArrayList<>();
for (int i = 2; i <array.length ; i++) {
if(array[i]!=1){
for (int j = i; j <array.length ; j+=i) {
array[j] = 1;
}
arrayList.add(i);
}
}
arrayList.add(100003);
for (int i = 0; i <n ; i++) {
sum = 0;
for (int j = 0; j <m ; j++) {
l = -1;
r = arrayList.size();
while (r>l+1){
mid = (l+r)/2;
if(arrayList.get(mid)<arr[i][j])
l = mid;
else
r= mid;
}
if(arrayList.get(r)!=arr[i][j]){
sum+= arrayList.get(r) - arr[i][j];
}
}
if(sum<max) {
max = sum;
}
}
temp = max;
max = Integer.MAX_VALUE;
for (int i = 0; i <m ; i++) {
sum=0;
for (int j = 0; j <n ; j++) {
l = -1;
r = arrayList.size();
while (r>l+1){
mid = (l+r)/2;
if(arrayList.get(mid)<arr[j][i])
l = mid;
else
r= mid;
}
if (arrayList.get(r) != arr[j][i]) {
sum += arrayList.get(r) - arr[j][i];
}
}
if(sum<max) {
max = sum;
}
}
out.println(Math.min(temp , max));
}
}
static final Random random=new Random();
static void shuffleSort(int[] arr) {
int n=arr.length;
for (int i=0; i<n; i++) {
int a=random.nextInt(n), temp=arr[a];
arr[a]=arr[i];
arr[i]=temp;
}
Arrays.sort(arr);
}
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());
}
}
} | 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<long long int> prime;
bool arr[100009];
void sieve() {
long long int k = sqrt(100009);
for (int i = 3; i <= k; i += 2) {
if (arr[i] == 0) {
for (long long int j = i * i; j < 100009; j += 2 * i) {
arr[j] = 1;
}
}
}
arr[1] = 1;
for (long long int i = 4; i < 100009; i += 2) {
arr[i] = 1;
}
}
int main() {
sieve();
long long int n, m, matrix[501][501], temp, count, primecount, lowest;
while (cin >> n >> m) {
lowest = 999999999;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%lld", &matrix[i][j]);
}
}
for (int i = 0; i < n; i++) {
count = primecount = 0;
for (int j = 0; j < m; j++) {
temp = matrix[i][j];
if (arr[temp] == 0) {
primecount++;
} else {
for (int k = temp + 1;; k++) {
count++;
if (arr[k] == 0) break;
}
}
}
if (primecount == m)
lowest = 0;
else if (lowest > count)
lowest = count;
}
for (int i = 0; i < m; i++) {
count = primecount = 0;
for (int j = 0; j < n; j++) {
temp = matrix[j][i];
if (arr[temp] == 0) {
primecount++;
} else {
for (int k = temp + 1;; k++) {
count++;
if (arr[k] == 0) break;
}
}
}
if (primecount == n)
lowest = 0;
else if (lowest > count)
lowest = count;
}
cout << lowest << 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.*;
public class primeMatrix {
static boolean[] primes = new boolean[1000001];
public static void sieve() {
Arrays.fill(primes, true);
primes[0] = false;
primes[1] = false;
for (int i = 2; i < primes.length; i++) {
if (!primes[i]){continue;}
for (long j = (long) i * i; j < primes.length; j += i) {
primes[(int) j] = false;
}
}
}
public static void main(String[] args) {
sieve();
Scanner in = new Scanner(System.in);
int n = in.nextInt(),m = in.nextInt();
int [][] a = new int[n][m];
int mr = 10000000;int mc = 10000000;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = in.nextInt();
}
}
for (int i = 0; i < n; i++) {
int t = 0;
for (int j = 0; j < m; j++) {
if(!primes[a[i][j]]){
t += nextPrime(a[i][j]);
}
}
mc = Math.min(mc,t);
}
for (int i = 0; i < m; i++) {
int t = 0;
for (int j = 0; j < n; j++) {
if(!primes[a[j][i]]){
t += nextPrime(a[j][i]);
}
}
mr = Math.min(mr,t);
}
System.out.println(Math.min(mr, mc));
}
public static int nextPrime(int x){
int co = 0;
while(!primes[x]){
x++;
co++;
}
return co;
}
}
| 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 | lm=100018;p=[1,1]+[0]*lm
for i in range(2,lm):p[i*i::i]=[1]*(lm/i-i+1)
for i in range(lm,0,-1):p[i]*=p[i+1]+1
I=lambda _:map(int,raw_input().split());n,m=I(0);M=map(I,[0]*n)
print min(sum(p[i]for i in r)for r in M+zip(*M)) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # aadiupadhyay
import os.path
from math import gcd, floor, ceil
from collections import *
import sys
mod = 1000000007
INF = float('inf')
def st(): return list(sys.stdin.readline().strip())
def li(): return list(map(int, sys.stdin.readline().split()))
def mp(): return map(int, sys.stdin.readline().split())
def inp(): return int(sys.stdin.readline())
def pr(n): return sys.stdout.write(str(n)+"\n")
def prl(n): return sys.stdout.write(str(n)+" ")
if os.path.exists('input.txt'):
sys.stdin = open('input.txt', 'r')
sys.stdout = open('output.txt', 'w')
def BS(val):
i, j = 0, len(prime)-1
ans = -1
while i <= j:
mid = (i+j)//2
if prime[mid] < val:
i = mid+1
else:
ans = mid
j = mid - 1
return ans
maxN = 10**6
x = [0 for i in range(maxN+1)]
i = 2
while i*i <= maxN:
if not x[i]:
for j in range(i*i, maxN+1, i):
x[j] = 1
i += 1
prime = [i for i in range(2, maxN+1) if not x[i]]
n, m = mp()
ans = INF
d = defaultdict(int)
l = [li() for i in range(n)]
for i in range(n):
now = 0
for j in range(m):
if l[i][j] not in d:
cur = BS(l[i][j])
d[l[i][j]] = prime[cur]-l[i][j]
now += d[l[i][j]]
ans = min(ans, now)
for i in range(m):
now = 0
for j in range(n):
now += d[l[j][i]]
ans = min(ans, now)
pr(ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | from sys import stdin,stdout
input=stdin.readline
import math,bisect
num = 102001
numD = 2
prime=[1]*num
prime[1]=0
prime[0]=0
for i in range(numD,num):
j=i
while(j+i<num):
j+=i
prime[j]=0
l=[]
n,m=map(int,input().split())
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
ans=60000000
for i in range(n):
tot=0
for j in range(m):
result=l[i][j]
for k in range(result,num):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
for j in range(m):
tot=0
for i in range(n):
result=l[i][j]
for k in range(result,num):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
print(ans)#RESULT
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
vector<int> v;
int isprime[100005];
for (int i = 2; i < 100005; i++) isprime[i] = 1;
isprime[1] = 0;
for (int i = 2; i < 100005; i++) {
if (isprime[i]) {
v.push_back(i);
for (int j = i + i; j < 100005; j += i) isprime[j] = 0;
}
}
int tot = v.size();
int n, m, cnt;
cin >> n >> m;
int rowmax = INT_MAX;
int colmax = INT_MAX;
int mat[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> mat[i][j];
for (int i = 0; i < n; i++) {
cnt = 0;
for (int j = 0; j < m; j++) {
if (*lower_bound(v.begin(), v.end(), mat[i][j]) == 999913 &&
!isprime[mat[i][j]]) {
cnt = rowmax;
break;
} else {
cnt += (isprime[mat[i][j]] == 1)
? 0
: (*upper_bound(v.begin(), v.end(), mat[i][j]) - mat[i][j]);
}
}
rowmax = min(rowmax, cnt);
}
for (int j = 0; j < m; j++) {
cnt = 0;
for (int i = 0; i < n; i++) {
if (*lower_bound(v.begin(), v.end(), mat[i][j]) == 999913 &&
!isprime[mat[i][j]]) {
cnt = colmax;
break;
} else {
cnt += (isprime[mat[i][j]] == 1)
? 0
: (*upper_bound(v.begin(), v.end(), mat[i][j]) - mat[i][j]);
}
}
colmax = min(colmax, cnt);
}
cout << min(rowmax, colmax);
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.*;
public class CF271B {
static boolean[] primes = new boolean[100004];
static TreeSet<Integer> tset = new TreeSet<>();
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])
{
rows[i]+=tset.ceiling(curr)-curr;
cols[j]+=tset.ceiling(curr)-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]) tset.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 | from bisect import bisect_left
MAX_P = 100100
is_prime = [True] * MAX_P
primes = []
is_prime[0] = is_prime[1] = False
for i in xrange(2, MAX_P):
if is_prime[i]:
primes.append(i)
for j in xrange(i + i, MAX_P, i):
is_prime[j] = False
n, m = map(int, raw_input().split())
a = [map(int, raw_input().split()) for i in xrange(n)]
sr = [0] * n
sc = [0] * m
for i in xrange(n):
for j in xrange(m):
v = a[i][j]
p = primes[bisect_left(primes, v)]
sr[i] += p - v
sc[j] += p - v
print min(min(sr), min(sc))
| 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 main() {
int x[501][501], i, j, ans, k, a[100101], b[32000], num[501][501], n, m, l;
long long int ansx[501], ansy[501], minx, miny;
for (i = 2; i <= 100100; i++) a[i] = 1;
k = 0;
for (i = 2; i <= 500; i++) {
if (a[i] == 1) {
for (j = i * i; j <= 100100; j += i) a[j] = 0;
}
}
for (i = 2; i <= 100100; i++) {
if (a[i] == 1) {
b[k] = i;
k++;
}
}
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) num[i][j] = 0;
for (i = 0; i < n; i++) ansx[i] = 0;
for (j = 0; j < m; j++) ansy[j] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &x[i][j]);
for (l = 0; b[l] < x[i][j] && l <= k;) l++;
num[i][j] += b[l] - x[i][j];
ansx[i] += num[i][j];
ansy[j] += num[i][j];
}
}
minx = miny = 12346789;
for (i = 0; i < n; i++) {
if (ansx[i] < minx) minx = ansx[i];
}
for (i = 0; i < m; i++) {
if (ansy[i] < miny) miny = ansy[i];
}
if (minx < miny)
printf("%lld\n", minx);
else
printf("%lld\n", miny);
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,m=map(int,input().split())
s=[[*map(int,input().split())] for _ in " "*n]
limit=int(1e5+2)
l=[1,1]+[0]*limit
for i in range(2,limit):
l[i*i::i]=[1]*((limit-i*i)//i+1)
for i in range(limit,-1,-1):
l[i]*=l[i+1]+1
for i in range(n):
for j in range(m):
s[i][j]=l[s[i][j]]
print(min(min(sum(i) for i in s),min(sum(i) for i in zip(*s)))) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int x = input.nextInt();
int y = input.nextInt();
int l;
int g = 200000;
int[][] z = new int[x][y];
int[] arr = new int[200000];
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
z[i][j] = input.nextInt();
}
}
boolean[] t = new boolean[200001];
Arrays.fill(t, true);
t[0] = false;
t[1] = false;
int m = (int) (Math.sqrt(200001));
for (int i = 2; i <= m; i++) {
if (t[i]) {
for (int j = i * i; j <= 200000; j += i) {
t[j] = false;
}
}
}
for (int i = 0; i < x; i++) {
l = 0;
for (int j = 0; j < y; j++) {
if (t[z[i][j]] == true) {
continue;
} else if(arr[z[i][j]]>0){ l+=arr[z[i][j]];
}else {
int r = z[i][j];
while (t[r] != true) {
l++;
arr[z[i][j]]++;
r++;
}
}
}
if (l < g) {
g = l;
}
}
for (int i = 0; i < y; i++) {
l = 0;
for (int j = 0; j < x; j++) {
l += arr[z[j][i]];
}
if (l < g) {
g = l;
}
}
System.out.println(g);
}
}
| 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 mxn = 1000001;
int prime[mxn];
void sieve() {
for (long long int i = 0; i < mxn; i++) prime[i] = 0;
prime[0] = prime[1] = 1;
for (int i = 2; i * i < mxn; i++) {
if (prime[i] == 0) {
for (long long int j = i * i; j < mxn; j += i) prime[j] = 1;
}
}
}
int next_prime(int n) {
for (int i = n + 1; i < mxn; i++) {
if (prime[i] == 0) return i;
}
}
void solve() {
long long int n, m;
cin >> n >> m;
long long int a[n][m];
for (long long int i = 0; i < n; i++)
for (long long int j = 0; j < m; j++) cin >> a[i][j];
long long int mi = 1000000000;
for (long long int i = 0; i < n; i++) {
long long int cnt = 0;
for (long long int j = 0; j < m; j++) {
if ((prime[a[i][j]]) != 0) cnt += next_prime(a[i][j]) - a[i][j];
}
mi = min(cnt, mi);
}
for (long long int j = 0; j < m; j++) {
long long int cnt = 0;
for (long long int i = 0; i < n; i++) {
if ((prime[a[i][j]]) != 0) cnt += next_prime(a[i][j]) - a[i][j];
}
mi = min(cnt, mi);
}
cout << mi;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
sieve();
int 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 |
# -*- coding: utf-8 -*-
# @Date : 2019-02-08 08:18:25
# @Author : raj lath ([email protected])
# @Link : link
# @Version : 1.0.0
from sys import stdin
max_val=int(10e12)
min_val=int(-10e12)
def read_int() : return int(stdin.readline())
def read_ints() : return [int(x) for x in stdin.readline().split()]
def read_str() : return input()
def read_strs() : return [x for x in stdin.readline().split()]
limit = 110000
primes = [0, 0] + [1] * limit
for i in range(2, limit):
if primes[i]:
for j in range(i * i, limit, i): primes[j] = 0
u = limit
for i in reversed(range(limit)):
if primes[i]: u = i
primes[i] = u - i
n, m = [int(x) for x in input().split()]
matrix=[[int(x) for x in input().split()] for _ in range(n)]
maxs = 10 ** 10
for v in matrix:
maxs = min(maxs,sum([primes[x] for x in v]))
for v in zip(*matrix):
maxs = min(maxs,sum([primes[x] for x in v]))
print(maxs) | 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<bool> prime(2e5, true);
void sieve() {
for (int i = 2; i < prime.size(); i++) {
if (prime[i] == true) {
int k = 2 * i;
while (k < prime.size()) {
prime[k] = false;
k += i;
}
}
}
}
int main() {
sieve();
int n, m;
cin >> n >> m;
vector<int> primes;
for (int i = 2; i < prime.size(); i++) {
if (prime[i] == true) {
primes.push_back(i);
}
}
vector<vector<int>> v(n, vector<int>(m));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> v[i][j];
}
}
int fresult = INT_MAX;
for (int i = 0; i < n; i++) {
int result1 = 0, result2 = 0;
for (int j = 0; j < m; j++) {
result1 += *lower_bound(primes.begin(), primes.end(), v[i][j]) - v[i][j];
}
if (fresult > result1) {
fresult = result1;
}
}
for (int i = 0; i < m; i++) {
int result1 = 0, result2 = 0;
for (int j = 0; j < n; j++) {
result1 += *lower_bound(primes.begin(), primes.end(), v[j][i]) - v[j][i];
}
if (fresult > result1) {
fresult = result1;
}
}
cout << fresult;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;
public class Main1 {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
//inputs
int n = in.nextInt();
int m = in.nextInt();
int[][]mat = new int[n][m];
int[][]mat1 = new int[n][m];
int [] cnt = new int [n+m];
boolean [] isPrime = new boolean [1000001];
isPrime[0] = isPrime[1] = true;
for(long i=2 ; i*i<=1000000 ; i++){
if(isPrime(i))
for(long j=i ; j*i<=1000000 ; j++)
isPrime[(int)(i*j)]=true;
}
for(int i=0 ; i<n ; i++)
for(int j=0 ; j<m ; j++){
int a = in.nextInt();
mat[i][j] = a;
mat1[i][j] = a;
}
int index=0;
for(int i=0 ; i<n ; i++){
int move=0;
for(int j=0 ; j<m ; j++){
while(isPrime[mat[i][j]] == true){
mat[i][j]++;
move++;
}
}
cnt[index++] = move;
}
for(int j=0 ; j<m ; j++){
int move=0;
for(int i=0 ; i<n ; i++){
while(isPrime[mat1[i][j]] == true){
mat1[i][j]++;
move++;
}
}
cnt[index++]= move ;
}
Arrays.sort(cnt);
System.out.println(cnt[0]);
}
public static boolean isPrime(long n){
for(int i=2 ; i*i<=n ; i++)
if(n % i == 0)
return false;
return true;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | limite = int(10e5)
primos = [True for i in range(limite)]
primos[0] = False
primos[1] = False
for i in range(2,limite):
if primos[i]:
for j in range(i**2, limite, i):
primos[j] = False
distancias = [0 for i in range(limite)]
distancias[0] = 2
distancias[1] = 1
base = int(limite//10 - 1)
while not primos[base]:
base += 1
for i in range(base, 1 , -1):
if not primos[i]:
distancias[i] = distancias[i + 1] + 1
entrada = input().split()
n = int(entrada[0])
m = int(entrada[1])
matriz = []
for i in range(n):
matriz.append([int(num) for num in input().split()])
menor_passo = limite
for i in range(n):
passos = sum([distancias[matriz[i][j]] for j in range(m)])
if passos < menor_passo:
menor_passo = passos
for j in range(m):
passos = sum([distancias[matriz[i][j]] for i in range(n)])
if passos < menor_passo:
menor_passo = passos
print(menor_passo)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def sieve(n):
arr = []
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
for p in range(2, n):
if prime[p]:
arr.append(p)
return arr
prime = sieve(10**5+10**4)
n,m = list(map(int,input().split()))
arr = []
cnt = 10**10
for i in range(n):
arr.append(list(map(int,input().split())))
ind = 0
d = {}
for i in range(1,101000):
if i<=prime[ind]:
d[i] = prime[ind]-i
else:
ind+=1
d[i] = prime[ind]-i
cnt = 10**10
for i in range(n):
temp = 0
for j in range(m):
temp+=d[arr[i][j]]
cnt = min(cnt,temp)
for i in range(m):
temp = 0
for j in range(n):
temp+=d[arr[j][i]]
cnt = min(cnt,temp)
print(cnt) | 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 | ######### ## ## ## #### ##### ## # ## # ##
# # # # # # # # # # # # # # # # # # #
# # # # ### # # # # # # # # # # # #
# ##### # # # # ### # # # # # # # # #####
# # # # # # # # # # # # # # # # # #
######### # # # # ##### # ##### # ## # ## # #
"""
PPPPPPP RRRRRRR OOOO VV VV EEEEEEEEEE
PPPPPPPP RRRRRRRR OOOOOO VV VV EE
PPPPPPPPP RRRRRRRRR OOOOOOOO VV VV EE
PPPPPPPP RRRRRRRR OOOOOOOO VV VV EEEEEE
PPPPPPP RRRRRRR OOOOOOOO VV VV EEEEEEE
PP RRRR OOOOOOOO VV VV EEEEEE
PP RR RR OOOOOOOO VV VV EE
PP RR RR OOOOOO VV VV EE
PP RR RR OOOO VVVV EEEEEEEEEE
"""
"""
Perfection is achieved not when there is nothing more to add, but rather when there is nothing more to take away.
"""
import sys
input = sys.stdin.readline
read = lambda: map(int, input().split())
read_float = lambda: map(float, input().split())
# from bisect import bisect_left as lower_bound;
# from bisect import bisect_right as upper_bound;
# from math import ceil, factorial;
def ceil(x):
if x != int(x):
x = int(x) + 1
return x
def factorial(x, m):
val = 1
while x>0:
val = (val * x) % m
x -= 1
return val
def fact(x):
val = 1
while x > 0:
val *= x
x -= 1
return val
# swap_array function
def swaparr(arr, a,b):
temp = arr[a];
arr[a] = arr[b];
arr[b] = temp;
## gcd function
def gcd(a,b):
if b == 0:
return a;
return gcd(b, a % b);
## lcm function
def lcm(a, b):
return (a * b) // math.gcd(a, b)
## nCr function efficient using Binomial Cofficient
def nCr(n, k):
if k > n:
return 0
if(k > n - k):
k = n - k
res = 1
for i in range(k):
res = res * (n - i)
res = res / (i + 1)
return int(res)
## upper bound function code -- such that e in a[:i] e < x;
## prime factorization
def primefs(n):
## if n == 1 ## calculating primes
primes = {}
while(n%2 == 0 and n > 0):
primes[2] = primes.get(2, 0) + 1
n = n//2
for i in range(3, int(n**0.5)+2, 2):
while(n%i == 0 and n > 0):
primes[i] = primes.get(i, 0) + 1
n = n//i
if n > 2:
primes[n] = primes.get(n, 0) + 1
## prime factoriazation of n is stored in dictionary
## primes and can be accesed. O(sqrt n)
return primes
## MODULAR EXPONENTIATION FUNCTION
def power(x, y, p):
res = 1
x = x % p
if (x == 0) :
return 0
while (y > 0) :
if ((y & 1) == 1) :
res = (res * x) % p
y = y >> 1
x = (x * x) % p
return res
## DISJOINT SET UNINON FUNCTIONS
def swap(a,b):
temp = a
a = b
b = temp
return a,b;
# find function with path compression included (recursive)
# def find(x, link):
# if link[x] == x:
# return x
# link[x] = find(link[x], link);
# return link[x];
# find function with path compression (ITERATIVE)
def find(x, link):
p = x;
while( p != link[p]):
p = link[p];
while( x != p):
nex = link[x];
link[x] = p;
x = nex;
return p;
# the union function which makes union(x,y)
# of two nodes x and y
def union(x, y, link, size):
x = find(x, link)
y = find(y, link)
if size[x] < size[y]:
x,y = swap(x,y)
if x != y:
size[x] += size[y]
link[y] = x
## returns an array of boolean if primes or not USING SIEVE OF ERATOSTHANES
def sieve(n):
prime = [True for i in range(n+1)]
prime[0], prime[1] = False, False
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
return prime
# Euler's Toitent Function phi
def phi(n) :
result = n
p = 2
while(p * p<= n) :
if (n % p == 0) :
while (n % p == 0) :
n = n // p
result = result * (1.0 - (1.0 / (float) (p)))
p = p + 1
if (n > 1) :
result = result * (1.0 - (1.0 / (float)(n)))
return (int)(result)
def is_prime(n):
if n == 0:
return False
if n == 1:
return True
for i in range(2, int(n ** (1 / 2)) + 1):
if not n % i:
return False
return True
def next_prime(n, primes):
while primes[n] != True:
n += 1
return n
#### PRIME FACTORIZATION IN O(log n) using Sieve ####
MAXN = int(1e5 + 5)
def spf_sieve():
spf[1] = 1;
for i in range(2, MAXN):
spf[i] = i;
for i in range(4, MAXN, 2):
spf[i] = 2;
for i in range(3, ceil(MAXN ** 0.5), 2):
if spf[i] == i:
for j in range(i*i, MAXN, i):
if spf[j] == j:
spf[j] = i;
## function for storing smallest prime factors (spf) in the array
################## un-comment below 2 lines when using factorization #################
spf = [0 for i in range(MAXN)]
# spf_sieve();
def factoriazation(x):
res = []
for i in range(2, int(x ** 0.5) + 1):
while x % i == 0:
res.append(i)
x //= i
if x != 1:
res.append(x)
return res
## this function is useful for multiple queries only, o/w use
## primefs function above. complexity O(log n)
def factors(n):
res = []
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
res.append(n // i)
return list(set(res))
## taking integer array input
def int_array():
return list(map(int, input().strip().split()));
def float_array():
return list(map(float, input().strip().split()));
## taking string array input
def str_array():
return input().strip().split();
def binary_search(low, high, w, h, n):
while low < high:
mid = low + (high - low) // 2
# print(low, mid, high)
if check(mid, w, h, n):
low = mid + 1
else:
high = mid
return low
## for checking any conditions
def check(l, ps, n, t):
for i in range(n - l + 1):
# print(i, l)
# print(a[i:i + l])
if ps[i + l] - ps[i] <= t:
return True
return False
#defining a couple constants
MOD = int(1e9)+7;
CMOD = 998244353;
INF = float('inf'); NINF = -float('inf');
################### ---------------- TEMPLATE ENDS HERE ---------------- ###################
from itertools import permutations
import math
import bisect as bis
import random
import sys
def solve():
primes = sieve(10 ** 5 + 10**2)
ps = [0]
nextprime = {}
for i in range(10 ** 5 + 10):
nextprime[i] = next_prime(i, primes)
n, m = read()
c, r = [], []
matrix = [list(read()) for _ in range(n)]
r = [0 for i in range(m)]
for i in range(n):
s = 0
for j in range(m):
s += nextprime[matrix[i][j]] - matrix[i][j]
r[j] += nextprime[matrix[i][j]] - matrix[i][j]
c.append(s)
print(min(min(c), min(r)))
if __name__ == '__main__':
for _ in range(1):
solve()
# fin_time = datetime.now()
# print("Execution time (for loop): ", (fin_time-init_time))
| 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> primes;
int sieveCountPrimesInRange(long long n) {
vector<bool> isPrime(n + 1, true);
int cnt = 0;
isPrime[0] = isPrime[1] = 0;
for (long long i = 1; i <= (n / i); i++) {
if (isPrime[i])
for (long long j = i * 2; j <= n; j += i) isPrime[j] = 0;
}
for (int i = 0; i < isPrime.size(); i++) {
isPrime[i] ? cnt++ : cnt;
if (isPrime[i]) primes.push_back(i);
}
return cnt;
}
int P[500][500];
int main() {
int n, m, c = 0;
cin >> n >> m;
vector<int>::iterator it;
vector<int> v;
sieveCountPrimesInRange(100000 + 200);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> P[i][j];
}
}
for (int i = 0; i < n; i++) {
c = 0;
for (int j = 0; j < m; j++) {
it = lower_bound(primes.begin(), primes.end(), P[i][j]);
c += *it - P[i][j];
}
v.push_back(c);
}
for (int i = 0; i < m; i++) {
c = 0;
for (int j = 0; j < n; j++) {
it = lower_bound(primes.begin(), primes.end(), P[j][i]);
c += *it - P[j][i];
}
v.push_back(c);
}
cout << *(min_element(v.begin(), v.end())) << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int MOD = 1e6 + 3;
const int INFI = 1e9 * 2;
const int N = 555;
const int M = 111111;
const int move[8][2] = {0, 1, 0, -1, 1, 0, -1, 0, 1, 1, 1, -1, -1, 1, -1, -1};
bool p[M];
int next(int n) {
int m = n;
while (p[m]) m++;
return m - n;
}
int r[N], c[N];
int main() {
memset(p, 0, sizeof(p));
p[0] = p[1] = 1;
for (int i = 2; i * i < M; i++)
for (int j = i * i; j < M; j += i) p[j] = 1;
int n, m, a, k, ans;
while (scanf("%d%d", &n, &m) != EOF) {
memset(r, 0, sizeof(r));
memset(c, 0, sizeof(c));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &a);
k = next(a);
r[i] += k;
c[j] += k;
}
ans = INFI;
for (int i = 0; i < n; i++)
if (ans > r[i]) ans = r[i];
for (int i = 0; i < m; i++)
if (ans > c[i]) ans = c[i];
printf("%d\n", ans);
}
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long double pi = 3.14159265358979323;
const double EPS = 1e-12;
const int N = 1e6 + 5;
const int mod = 1e9 + 7;
vector<long long> v;
void primearray() {
bool prime[N];
memset(prime, 1, sizeof(prime));
prime[0] = 0;
prime[1] = 1;
for (int i = 2; i < sqrt(N); i++) {
if (prime[i]) {
for (int j = i * i; j < N; j += i) prime[j] = 0;
}
}
for (int i = 2; i < N; i++) {
if (prime[i]) v.push_back(i);
}
}
int main() {
primearray();
long long n, m;
cin >> n >> m;
long long arr[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
long long sum, k, maxi = INT_MAX;
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
k = lower_bound(v.begin(), v.end(), arr[i][j]) - v.begin();
sum += v[k] - arr[i][j];
}
maxi = min(sum, maxi);
}
for (int i = 0; i < m; i++) {
sum = 0;
for (int j = 0; j < n; j++) {
k = lower_bound(v.begin(), v.end(), arr[j][i]) - v.begin();
sum += v[k] - arr[j][i];
}
maxi = min(sum, maxi);
}
cout << maxi;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int main() {
int pr[110000];
int prev = 0;
pr[0] = pr[1] = 2;
for (int i = 2; i < 110000; i++) {
bool prr = true;
for (int j = 2; j * j <= i; j++)
if (i % j == 0) {
prr = false;
break;
}
if (prr) {
for (int j = prev; j <= i; j++) pr[j] = i;
prev = i + 1;
}
}
int arr[500][500];
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
int mi = 100000 * 500;
int sum = 0;
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
sum += pr[arr[i][j]] - arr[i][j];
}
if (sum < mi) mi = sum;
}
for (int i = 0; i < m; i++) {
sum = 0;
for (int j = 0; j < n; j++) {
sum += pr[arr[j][i]] - arr[j][i];
}
if (sum < mi) mi = sum;
}
cout << mi << 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 | ncrivo = int(10e5)
crivo = [True for i in range(ncrivo)]
crivo[0] = False
crivo[1] = False
for i in range(2, ncrivo):
if crivo[i]:
for j in range(i ** 2, ncrivo, i):
crivo[j] = False
# frequencia
contador = [0 for i in range(ncrivo)]
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]
# lendo dados
n, m = map(int, input().split())
data = []
for i in range(n):
data.append(list(map(int, input().split())))
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 | MX = 100500
prime = [True for i in xrange(MX+10)]
ds = [0 for i in xrange (MX+10)]
a = [[0 for i in xrange (510)] for j in xrange (510)]
def sieve():
prime[0] = prime[1] = False
for i in range (3,MX,2):
if (prime[i] == True):
for j in range (3*i,MX,2*i):
prime[j] = False
prime[i+1] = False
cnt = 0
for i in range (MX,-1,-1):
if (prime[i] == True):
cnt = 0
ds[i] = cnt
else :
cnt += 1
ds[i] = cnt
sieve()
while (True):
try:
tm = raw_input()
tm = tm.split()
n = int(tm[0])
m = int(tm[1])
for i in range (0,n):
tm = raw_input()
tm = tm.split()
for j in range (0,m):
a[i][j] = int(tm[j])
ans = 100000000
for i in range (0,n):
t = 0
for j in range (0,m):
t += ds[a[i][j]]
ans = min(ans,t)
for j in range (0,m):
t = 0
for i in range (0,n):
t += ds[a[i][j]]
ans = min(ans,t)
print ans
except EOFError:
break
| 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;
bool arr[1000000 + 100];
void findPrime(int size) {
memset(arr, true, sizeof(arr));
arr[0] = false;
arr[1] = false;
for (int i = 2; i <= size; i++)
if (arr[i])
for (int j = i + i; j <= size; j += i) arr[j] = false;
}
int main() {
int n, m;
while (cin >> n >> m) {
int max = 0;
int a[505][505], b[505][505];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> a[i][j];
if (a[i][j] > max) max = a[i][j];
}
findPrime(max + 100);
int h[505], z[505];
memset(h, 0, sizeof(h));
memset(z, 0, sizeof(z));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
while (!arr[a[i][j]++]) {
h[i]++;
z[j]++;
}
}
int ans = 1 << 30;
for (int i = 0; i < n; i++) {
if (h[i] < ans) ans = h[i];
}
for (int i = 0; i < m; i++) {
if (z[i] < ans) ans = z[i];
}
cout << ans << endl;
}
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class B {
boolean primes[] = new boolean[100091];
public void generate(int n){
primes[0] = true;
primes[1] = true;
for(int i = 2 ; i <= (int)Math.sqrt(n) ; i++){
for(int j=i+1 ; j<=n ; j++){
if( !primes[j] && j%i==0 ) primes[j] = true;
}
}
}
public int findNext(int n){
while( primes[n] ) n++;
return n;
}
public void solve(){
generate(100090);
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int min = Integer.MAX_VALUE;
int ar[][] = new int[n][m];
int ar_col[][] = new int[n][m];
for(int i = 0 ; i < n ; i++){
for(int j = 0; j<m ; j++){
int temp = sc.nextInt();
ar_col[i][j] = ar[i][j] = findNext(temp) - temp;
if(j!=0)
ar[i][j] +=ar[i][j-1];
if(i!=0)
ar_col[i][j] += ar_col[i-1][j];
if(i==n-1 && ar_col[i][j] < min ) min = ar_col[i][j];
}
if( ar[i][m-1] < min ) min = ar[i][m-1];
}
System.out.println(min);
}
public static void main(String args[]){
new B().solve();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def get_input_matrix():
user_input = input().split()
n = int(user_input[0])
m = int(user_input[1])
matrix = []
for i in range(n):
user_input_matrix = input().split()
row = []
for j in range(m):
row.append(int(user_input_matrix[j]))
matrix.append(row)
return (matrix, n, m)
def prime_sieve(n):
primes, sieve = {}, [True] * int(n + 1)
for p in range(2, n + 1):
if sieve[p]:
primes[p] = p
for i in range(p * p, n + 1, p):
sieve[i] = False
return primes
matrix, n, m = get_input_matrix()
primes = prime_sieve(100100)
lesser_row_count = 999999
columns_count = [0] * m
for i in range(n):
row_count = 0
for j in range(m):
while (not primes.get(matrix[i][j])):
matrix[i][j] += 1
row_count += 1
columns_count[j] += 1
if row_count >= lesser_row_count and columns_count[j] >= lesser_row_count:
break
lesser_row_count = min(row_count, lesser_row_count)
print(min(lesser_row_count, *columns_count))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
public class PA {
/*
Tyger! Tyger! burning bright
In the forests of the night,
What immortal hand or eye
Could frame thy fearful symmetry?
In what distant deeps or skies
Burnt the fire of thine eyes?
On what wings dare he aspire?
What the hand, dare sieze the fire?
And what shoulder, & what art,
Could twist the sinews of thy heart?
And when thy heart began to beat,
What dread hand? & what dread feet?
What the hammer? what the chain?
In what furnace was thy brain?
What the anvil? what dread grasp
Dare its deadly terrors clasp?
When the stars threw down their spears,
And water’d heaven with their tears,
Did he smile his work to see?
Did he who made the Lamb make thee?
Tyger! Tyger! burning bright
In the forests of the night,
What immortal hand or eye
Dare frame thy fearful symmetry?
*/
public static boolean isPrime(int x)
{
for(int i = 2 ; i * i <= x ; i++)
{
if(x % i == 0)
return false;
}
return true;
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
PrintWriter out = new PrintWriter(System.out);
// StringTokenizer st1 = new StringTokenizer(br.readLine());
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
TreeSet<Integer> primes = new TreeSet<>();
for(int i = 2 ; i <= 1000000 ; i++)
{
if(isPrime(i))
primes.add(i);
}
int arr[][] = new int [n][m];
for(int i = 0 ; i < n ; i++)
{
for(int j = 0 ; j < m ; j++)
{
arr[i][j] = sc.nextInt();
}
}
int min = Integer.MAX_VALUE;
for(int i = 0 ; i < n ; i++)
{
int sum = 0;
for(int j = 0 ; j < m ; j++)
{
sum += primes.ceiling(arr[i][j])-arr[i][j];
}
min = Math.min(min , sum);
}
for(int i = 0 ; i < m ; i++)
{
int sum = 0;
for(int j = 0 ; j < n ; j++)
{
sum += primes.ceiling(arr[j][i])-arr[j][i];
}
min = Math.min(min , sum);
}
out.println(min);
out.flush();
out.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 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.text.*;
public class cf271b {
static BufferedReader br;
static Scanner sc;
static PrintWriter out;
public static void initA() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(System.in);
//out = new PrintWriter("output.txt");
out = new PrintWriter(System.out);
} catch (Exception e) {
}
}
public static void initB() {
try {
br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
} catch (Exception e) {
}
}
public static String getString() {
try {
return br.readLine();
} catch (Exception e) {
}
return "";
}
public static Integer getInt() {
try {
return Integer.parseInt(br.readLine());
} catch (Exception e) {
}
return 0;
}
public static Integer[] getIntArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Integer temp2[] = new Integer[n];
for (int i = 0; i < n; i++) {
temp2[i] = Integer.parseInt(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static Long[] getLongArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Long temp2[] = new Long[n];
for (int i = 0; i < n; i++) {
temp2[i] = Long.parseLong(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static String[] getStringArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
String temp2[] = new String[n];
for (int i = 0; i < n; i++) {
temp2[i] = (temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static int getMax(Integer[] ar) {
int t = ar[0];
for (int i = 0; i < ar.length; i++) {
if (ar[i] > t) {
t = ar[i];
}
}
return t;
}
public static void print(Object a) {
out.println(a);
}
public static int nextInt() {
return sc.nextInt();
}
public static double nextDouble() {
return sc.nextDouble();
}
public static void main(String[] ar) {
initA();
solve();
out.flush();
}
public static void solve() {
int max = 110000;
boolean notprime[] = new boolean[110000];
for (int i = 2; i < max; i++) {
for (int j = 2; j * i < max; j++) {
notprime[i * j] = true;
}
}
ArrayList<Integer> prime = new ArrayList<Integer>(110000);
for (int i = 2; i < max; i++) {
if (!notprime[i]) {
prime.add(i);
}
}
final int last = prime.size();
int dp[] = new int[110000];
//Arrays.fill(dp, -1);
for (int i = 0; i < 110000; i++) {
int s = 0;
int num = i;
while (!isPrime(num)) {
num++;
s++;
}
dp[i] = s;
}
Integer x[] = getIntArr();
int n = x[0], m = x[1];
int min[][] = new int[n][m];
for (int i = 0; i < n; i++) {
Integer temp[] = getIntArr();
for (int ii = 0; ii < m; ii++) {
int num = temp[ii];
min[i][ii] = dp[num];
/*
int l =0, r= last-1;
while(l!=r){
int mid = (l+r)/2;
int te = prime.get(mid);
if(te >= num){
r=mid;
}else{
l=mid+1;
}
}
min[i][ii] = prime.get(l)-num;
*/
}
}
int out = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int ii = 0; ii < m; ii++) {
sum += min[i][ii];
}
out = Math.min(sum, out);
}
for (int i = 0; i < m; i++) {
int sum = 0;
for (int ii = 0; ii < n; ii++) {
sum += min[ii][i];
}
out = Math.min(sum, out);
}
print(out);
}
static boolean isPrime(int n) {
if (n == 2 || n == 3) {
return true;
}
if (n < 2 || n % 2 == 0) {
return false;
}
for (int i = 3; i <= Math.sqrt(n) + 1; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | # Mateus Brito de Sousa Rangel - 117110914
limit = 300000
primes = [False for x in range(limit)]
columns = [0 for x in range(limit)]
ans = limit
Input = map(int, input().split())
l, c = list(Input)
def crivo():
primes[0] = True
primes[1] = True
for i in range(2, limit):
if not primes[i]:
for j in range(i + i, limit, i):
primes[j] = True
for i in range(limit-2, -1, -1):
if(primes[i]):
primes[i] += primes[i+1]
crivo()
for index in range(0, l):
rowsAux = map(int, input().split())
rows = list(rowsAux)
aux = 0
for value in range(c):
aux += primes[rows[value]]
columns[value] += primes[rows[value]]
if index == l-1:
for value in range(c):
ans = min(columns[value], ans)
ans = min(aux, 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 | import bisect
MAX = 10**5+10
x =[True] * MAX
for i in range(2, MAX):
if x[i]:
for j in range(i*2, MAX, i):
x[j] = False
ps = [i for i in range(2, MAX) if x[i]]
I = lambda:map(int, raw_input().split())
n,m=I()
r,c=[0]*n,[0]*m
for i in range(n):
a = I()
for j in range(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 | #!/usr/bin/python3
n, m = tuple(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(n)]
simple = [0] * (10**5 + 4)
simple[1] = 1
for i in range(2, 10**5 + 4):
if simple[i] == 0:
j = 2
while i * j < 10**5 + 4:
simple[i * j] = 1
j += 1
simple[-1] = len(simple) - 1
for i in range(10**5 + 2, 0, -1):
if simple[i] == 1:
simple[i] = simple[i + 1]
else:
simple[i] = i
row = [0] * n
col = [0] * m
for i in range(n):
for j in range(m):
row[i] += simple[a[i][j]] - a[i][j]
col[j] += simple[a[i][j]] - a[i][j]
print(min(row + 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 |
import java.util.*;
public class cf271b {
static boolean[] p = new boolean[1000001];
public static void sieve() {
Arrays.fill(p, true);
p[0] = false;
p[1] = false;
for (int i = 2; i <= 1000000; i++) {
if (!p[i]) {
continue;
}
for (long j = (long) i * i; j <= 1000000; j += i) {
p[(int) j] = false;
}
}
}
public static void main(String[] args) {
sieve();
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
int minRows = Integer.MAX_VALUE;
int minCols = Integer.MAX_VALUE;
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = input.nextInt();
}
}
for (int i = 0; i < n; i++) {
int temp = 0;
for (int j = 0; j < m; j++) {
temp = temp + calc(a[i][j]);
}
minRows = Math.min(temp, minRows);
}
for (int i = 0; i < m; i++) {
int temp = 0;
for (int j = 0; j < n; j++) {
temp = temp + calc(a[j][i]);
}
minCols = Math.min(temp, minCols);
}
System.out.println(Math.min(minCols, minRows));
}
public static int calc(int i) {
int times = 0;
while (!p[i]) {
times++;
i++;
}
return times;
}
}
| 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.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{
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"));
boolean[] p = new boolean[1000001];
for(int i = 2; i <= 100000; i++){
for(int j = 2; j <= 100000; j++){
if(i * j > 500000)break;
p[i * j] = true;
}
}
p[1] = true;
int n = scan.nextInt(), m = scan.nextInt(), min = Integer.MAX_VALUE;
int[][] a = new int[n][m];
for(int i = 0 ; i < n; i++){
int move = 0;
for(int j = 0; j < m; j++){
int w = scan.nextInt();
while(p[w]){
move++; w++; a[i][j]++;
}
}
if(move < min)min = move;
}
for(int i = 0; i < m; i++){
int move = 0;
for(int j = 0; j < n; j++){
move += a[j][i];
}
if(move < min)min = move;
}
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.*;
import java.math.*;
import java.util.*;
import java.util.stream.*;
public class P271B {
public BitSet genPrimes(int n) {
long [] lPrimes = new long [n / Long.SIZE + 1];
Arrays.fill(lPrimes, 0xAAAAAAAAAAAAAAAAL);
BitSet primes = BitSet.valueOf(lPrimes);
primes.flip(1, 3);
primes.clear(n + 1, primes.size());
int toN = (int)Math.sqrt(n);
for (int i = 3; i <= toN; i = primes.nextSetBit(i + 1)) {
for (int j = i * i; j <= n; j += (i << 1)) {
primes.clear(j);
}
}
return primes;
}
@SuppressWarnings("unchecked")
public void run() throws Exception {
BitSet primes = genPrimes(100_003);
int [] rc = new int [nextInt()];
int [] cc = new int [nextInt()];
for (int r = 0; r < rc.length; r++) {
for (int c = 0; c < cc.length; c++) {
int a = nextInt();
int d = primes.nextSetBit(a) - a;
rc[r] += d;
cc[c] += d;
}
}
println(IntStream.concat(IntStream.of(rc), IntStream.of(cc)).min().getAsInt());
}
public static void main(String... args) throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
pw = new PrintWriter(new BufferedOutputStream(System.out));
new P271B().run();
br.close();
pw.close();
}
static BufferedReader br;
static PrintWriter pw;
StringTokenizer stok;
String nextToken() throws IOException {
while (stok == null || !stok.hasMoreTokens()) {
String s = br.readLine();
if (s == null) { return null; }
stok = new StringTokenizer(s);
}
return stok.nextToken();
}
void print(byte b) { print("" + b); }
void print(int i) { print("" + i); }
void print(long l) { print("" + l); }
void print(double d) { print("" + d); }
void print(char c) { print("" + c); }
void print(Object o) {
if (o instanceof int[]) { print(Arrays.toString((int [])o));
} else if (o instanceof long[]) { print(Arrays.toString((long [])o));
} else if (o instanceof char[]) { print(Arrays.toString((char [])o));
} else if (o instanceof byte[]) { print(Arrays.toString((byte [])o));
} else if (o instanceof short[]) { print(Arrays.toString((short [])o));
} else if (o instanceof boolean[]) { print(Arrays.toString((boolean [])o));
} else if (o instanceof float[]) { print(Arrays.toString((float [])o));
} else if (o instanceof double[]) { print(Arrays.toString((double [])o));
} else if (o instanceof Object[]) { print(Arrays.toString((Object [])o));
} else { print("" + o); }
}
void print(String s) { pw.print(s); }
void println() { println(""); }
void println(byte b) { println("" + b); }
void println(int i) { println("" + i); }
void println(long l) { println("" + l); }
void println(double d) { println("" + d); }
void println(char c) { println("" + c); }
void println(Object o) { print(o); println(); }
void println(String s) { pw.println(s); }
int nextInt() throws IOException { return Integer.parseInt(nextToken()); }
long nextLong() throws IOException { return Long.parseLong(nextToken()); }
double nextDouble() throws IOException { return Double.parseDouble(nextToken()); }
char nextChar() throws IOException { return (char) (br.read()); }
String next() throws IOException { return nextToken(); }
String nextLine() throws IOException { return br.readLine(); }
int [] readInt(int size) throws IOException {
int [] array = new int [size];
for (int i = 0; i < size; i++) { array[i] = nextInt(); }
return array;
}
long [] readLong(int size) throws IOException {
long [] array = new long [size];
for (int i = 0; i < size; i++) { array[i] = nextLong(); }
return array;
}
double [] readDouble(int size) throws IOException {
double [] array = new double [size];
for (int i = 0; i < size; i++) { array[i] = nextDouble(); }
return array;
}
String [] readLines(int size) throws IOException {
String [] array = new String [size];
for (int i = 0; i < size; i++) { array[i] = nextLine(); }
return array;
}
} | 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 | # Generate array of primes using Sieve of Eratosthenes
def arrayOfPrimes():
n = 100000
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
prime[0] = False
prime[1] = False
return prime
# Generates an array with distance for the next prime for each index
def arrayOfPrimeDistance(primes):
n = 100000
distance = 0
distArray = [0 for i in range(n+1)]
distArray[100000] = 3
for i in range(n-1, -1, -1):
if(not primes[i]):
distArray[i] = distArray[i+1] + 1
return distArray
primes = arrayOfPrimes()
matrix = []
distanceArray = arrayOfPrimeDistance(primes)
n, m = list(map(int, input().split()))
for i in range(n):
row = list(map(int, input().split()))
matrix.append(row)
smallerRow = 1000000
smallerCollumn = 1000000
# for rows
for j in range(n):
count = 0
for k in range(m):
number = matrix[j][k]
if not primes[number]:
nextPrime = number + distanceArray[number]
count += nextPrime - number
if(count < smallerRow):
smallerRow = count
# for collumns
for x in range(m):
count = 0
for y in range(n):
number = matrix[y][x]
if not primes[number]:
nextPrime = number + distanceArray[number]
count += nextPrime - number
if(count < smallerCollumn):
smallerCollumn = count
print(smallerRow if smallerRow < smallerCollumn else smallerCollumn) | 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 | enter = input().split(" ")
rows = int(enter[0])
columns = int(enter[1])
matrix = []
minMove = 100000
def is_prime(n: int):
if n <= 3:
return n > 1
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i ** 2 <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
d = {}
for i in range(rows):
matrix.append([])
c = input().split(" ")
totalMoves = 0
for a in range(columns):
move = 0
change = int(c[a])
while (not is_prime(change)):
change += 1
move += 1
matrix[i].append(move)
totalMoves += move
if(a not in d.keys()):
d[a] = 0
d[a] += move
if (totalMoves < minMove):
minMove = totalMoves
minColumns = min(d.values())
if(minColumns < minMove):
minMove = minColumns
print(minMove)
| 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
max_num = 110005
max_range = 505
n, m = map(int, raw_input().split())
d = [0 for i in xrange(max_num)]
is_prime = [True for i in xrange(max_num)]
is_prime[1] = False
for i in xrange(2, 110001):
if is_prime[i]:
for j in xrange(i+i, 110001, i):
is_prime[j] = False
for i in xrange(110000, 0, -1):
if is_prime[i]:
d[i] = 0
else:
d[i] = d[i+1] + 1
matrix = []
for i in xrange(n):
matrix.append(map(int, raw_input().split()))
for i in xrange(n):
for j in xrange(m):
matrix[i][j] = d[matrix[i][j]]
line = [0 for i in xrange(max_range)]
columm = [0 for i in xrange(max_range)]
min_mov = 1000000000
for i in xrange(n):
for j in xrange(m):
line[i] += matrix[i][j]
columm[j] += matrix[i][j]
for i in xrange(n):
min_mov = min(line[i], min_mov)
for j in xrange(m):
min_mov = min(columm[j], min_mov)
print(min_mov) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
prm=[1 for i in range(101001)]
prm[0]=0
prm[1]=0
for i in range(2,int(math.sqrt(101001))+1):
if prm[i]==1:
for j in range(i*i,101001,i):
prm[j]=0
n,m=map(int,input().split())
arr=[]
row=[0]*n
col=[0]*m
for i in range(n):
l=list(map(int,input().split()))
for k in range(m):
x=l[k]
while(prm[l[k]]!=1):
l[k]+=1
row[i]+=(l[k]-x)
col[k]+=(l[k]-x)
r=min(row)
c=min(col)
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 | isPrime = [1] * 100010
def Prime():
global isPrime
isPrime[0] = isPrime[1] = 0
for i in range(100010):
if isPrime[i]:
for j in range(2 * i, 100010, i):
isPrime[j] = 0
Prime()
n, m = map(int, input().split())
l = []
for i in range(n):
l.append([int(x) for x in input().split()])
for j in range(m):
temp = l[-1][j]
while True:
if isPrime[temp]:
l[-1][j] = temp - l[-1][j]
break
temp += 1
#print(l)
s = 1000000000
for i in range(n):
if s > sum(l[i]):
s = sum(l[i])
for j in range(m):
temp = 0
for i in range(n):
temp += l[i][j]
if s > temp:
s = temp
print(s) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
set<int> primes;
int sumr[500];
int sumc[500];
void addpr(int n) {
bool b;
int i, j;
primes.insert(2);
for (i = 3; i <= n; i += 2) {
b = true;
j = 3;
while (b && j * j <= i) {
b = i % j != 0;
j += 2;
}
if (b) primes.insert(i);
}
}
int main() {
int n, m, i, j, k, p;
cin >> n >> m;
for (i = 0; i < n; ++i) sumr[i] = 0;
for (j = 0; j < m; ++j) sumc[j] = 0;
addpr(100100);
for (i = 0; i < n; ++i) {
for (j = 0; j < m; ++j) {
cin >> k;
p = *primes.lower_bound(k) - k;
sumr[i] += p;
sumc[j] += p;
}
}
p = sumr[0];
for (i = 1; i < n; ++i) {
if (sumr[i] < p) p = sumr[i];
}
for (j = 0; j < m; ++j) {
if (sumc[j] < p) p = sumc[j];
}
cout << p << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class PrimeMatrix {
public static void main(String[] args) {
boolean[] isComp = new boolean[200002];
int[] v = new int[200002];
int prev = 0;
for (int i = 2; i < isComp.length; i++) {
if (!isComp[i]) {
for (int j = i + i; j < isComp.length; j += i) {
isComp[j] = true;
}
for (int j = prev; j < i; j++)
v[j] = i - j;
prev = i + 1;
}
}
InputReader r = new InputReader(System.in);
int n = r.nextInt();
int m = r.nextInt();
int[][] arr = new int[n][m];
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
arr[i][j] = r.nextInt();
}
}
int res = 1 << 28;
for (int i = 0; i < n; i++) {
int need = 0;
for (int j = 0; j < m; j++) {
need += v[arr[i][j]];
}
res = Math.min(res, need);
}
for (int j = 0; j < m; j++) {
int need = 0;
for (int i = 0; i < n; i++) {
need += v[arr[i][j]];
}
res = Math.min(res, need);
}
System.out.println(res);
}
static class InputReader {
private BufferedReader reader;
private StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String nextLine() {
try {
return reader.readLine();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return 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());
}
}
}
| 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.*;
public class B {
int INF = Integer.MAX_VALUE / 1000;
static Scanner sc = null;
int MAX = 200001;
public void solve() throws Exception{
int n = sc.nextInt();
int m = sc.nextInt();
int[][] d = new int[n][m];
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
d[i][j] = sc.nextInt();
}
}
boolean[] isp = new boolean[MAX];
int last = 0;
for(int i = 2; i < MAX; i++){
isp[i] = is_prime(i);
if(isp[i]){
last = i;
}
}
int[] cnt = new int[MAX];
int c = 0;
for(int i = last; i >= 0; i--){
if(isp[i]){
c = 0;
}
cnt[i] = c;
c++;
}
int ans = INF;
for(int i = 0; i < n; i++){
int sum = 0;
for(int j = 0; j < m; j++){
sum += cnt[d[i][j]];
}
ans = Math.min(ans, sum);
}
for(int i = 0; i < m; i++){
int sum = 0;
for(int j = 0; j < n; j++){
sum += cnt[d[j][i]];
}
ans = Math.min(ans, sum);
}
System.out.println(ans);
}
boolean is_prime(long n){
for(long i = 2; i*i <= n; i++){
if(n % i == 0) return false;
}
return n != 1;
}
/**
* @param args
*/
public static void main(String[] args) throws Exception{
File file = new File("input.txt");
if(file.exists()){
System.setIn(new BufferedInputStream(new FileInputStream("input.txt")));
}
sc = new Scanner(System.in);
B t = new B();
t.solve();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
int matrix[500][500];
int min = -1;
short primeMap[100500];
bool calcIsPrime(int n) {
if (n < 2) return false;
for (int i = 2; i <= sqrt(n * 1.); i++) {
if (n % i == 0) return false;
}
return true;
}
void genPrimes() {
primeMap[1] = -1;
for (int i = 2; i < 100500; i++) {
int tmp;
tmp = 2;
while (tmp * i < 100500) {
primeMap[tmp * i] = -1;
tmp++;
}
if (primeMap[i] != 0) continue;
if (calcIsPrime(i)) {
primeMap[i] = 1;
} else {
primeMap[i] = -1;
}
}
}
bool isPrime(int n) {
if (n > 100500) {
return calcIsPrime(n);
}
if (primeMap[n] == 1) {
return true;
} else if (primeMap[n] == -1) {
return false;
}
return calcIsPrime(n);
}
int findCloseDiff(int n) {
int diff = 0;
int tmp = n;
while (!isPrime(tmp)) {
tmp++;
diff++;
}
return diff;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> matrix[i][j];
}
genPrimes();
int minNeeded = -1;
for (int i = 0; i < n; i++) {
int needed;
needed = 0;
for (int j = 0; j < m; j++) {
if (!isPrime(matrix[i][j])) {
int val = findCloseDiff(matrix[i][j]);
if (val >= 0) {
needed += val;
} else {
cout << "error : exceed upper bound";
}
}
}
if (minNeeded == -1 || minNeeded > needed) {
minNeeded = needed;
}
if (minNeeded == 0) {
cout << 0;
return 0;
}
}
for (int j = 0; j < m; j++) {
int needed;
needed = 0;
for (int i = 0; i < n; i++) {
if (!isPrime(matrix[i][j])) {
int val = findCloseDiff(matrix[i][j]);
if (val >= 0) {
needed += val;
} else {
cout << "error : exceed upper bound";
}
}
}
if (minNeeded == -1 || minNeeded > needed) {
minNeeded = needed;
}
if (minNeeded == 0) {
cout << 0;
return 0;
}
}
cout << minNeeded;
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, m = map(int, raw_input().split())
g = [[] for i in xrange(n)]
for i in xrange(n):
g[i] = map(int, raw_input().split())
p = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97,101,103,107,109,113,127,131,137,139,149,151,157,163,167,173,179,181,191,193,197,199,211,223,227,229,233,239,241,251,257,263,269,271,277,281,283,293,307,311,313,317,331,337,347,349,353,359,367,373,379,383,389,397,401,409,419,421,431,433,439,443,449,457,461,463,467,479,487,491,499,503,509,521,523,541,547,557,563,569,571,577,587,593,599,601,607,613,617,619,631,641,643,647,653,659,661,673,677,683,691,701,709,719,727,733,739,743,751,757,761,769,773,787,797,809,811,821,823,827,829,839,853,857,859,863,877,881,883,887,907,911,919,929,937,941,947,953,967,971,977,983,991,997,1009,1013,1019,1021,1031,1033,1039,1049,1051,1061,1063,1069,1087,1091,1093,1097,1103,1109,1117,1123,1129,1151,1153,1163,1171,1181,1187,1193,1201,1213,1217,1223,1229,1231,1237,1249,1259,1277,1279,1283,1289,1291,1297,1301,1303,1307,1319,1321,1327,1361,1367,1373,1381,1399,1409,1423,1427,1429,1433,1439,1447,1451,1453,1459,1471,1481,1483,1487,1489,1493,1499,1511,1523,1531,1543,1549,1553,1559,1567,1571,1579,1583,1597,1601,1607,1609,1613,1619,1621,1627,1637,1657,1663,1667,1669,1693,1697,1699,1709,1721,1723,1733,1741,1747,1753,1759,1777,1783,1787,1789,1801,1811,1823,1831,1847,1861,1867,1871,1873,1877,1879,1889,1901,1907,1913,1931,1933,1949,1951,1973,1979,1987,1993,1997,1999,2003,2011,2017,2027,2029,2039,2053,2063,2069,2081,2083,2087,2089,2099,2111,2113,2129,2131,2137,2141,2143,2153,2161,2179,2203,2207,2213,2221,2237,2239,2243,2251,2267,2269,2273,2281,2287,2293,2297,2309,2311,2333,2339,2341,2347,2351,2357,2371,2377,2381,2383,2389,2393,2399,2411,2417,2423,2437,2441,2447,2459,2467,2473,2477,2503,2521,2531,2539,2543,2549,2551,2557,2579,2591,2593,2609,2617,2621,2633,2647,2657,2659,2663,2671,2677,2683,2687,2689,2693,2699,2707,2711,2713,2719,2729,2731,2741,2749,2753,2767,2777,2789,2791,2797,2801,2803,2819,2833,2837,2843,2851,2857,2861,2879,2887,2897,2903,2909,2917,2927,2939,2953,2957,2963,2969,2971,2999,3001,3011,3019,3023,3037,3041,3049,3061,3067,3079,3083,3089,3109,3119,3121,3137,3163,3167,3169,3181,3187,3191,3203,3209,3217,3221,3229,3251,3253,3257,3259,3271,3299,3301,3307,3313,3319,3323,3329,3331,3343,3347,3359,3361,3371,3373,3389,3391,3407,3413,3433,3449,3457,3461,3463,3467,3469,3491,3499,3511,3517,3527,3529,3533,3539,3541,3547,3557,3559,3571,3581,3583,3593,3607,3613,3617,3623,3631,3637,3643,3659,3671,3673,3677,3691,3697,3701,3709,3719,3727,3733,3739,3761,3767,3769,3779,3793,3797,3803,3821,3823,3833,3847,3851,3853,3863,3877,3881,3889,3907,3911,3917,3919,3923,3929,3931,3943,3947,3967,3989,4001,4003,4007,4013,4019,4021,4027,4049,4051,4057,4073,4079,4091,4093,4099,4111,4127,4129,4133,4139,4153,4157,4159,4177,4201,4211,4217,4219,4229,4231,4241,4243,4253,4259,4261,4271,4273,4283,4289,4297,4327,4337,4339,4349,4357,4363,4373,4391,4397,4409,4421,4423,4441,4447,4451,4457,4463,4481,4483,4493,4507,4513,4517,4519,4523,4547,4549,4561,4567,4583,4591,4597,4603,4621,4637,4639,4643,4649,4651,4657,4663,4673,4679,4691,4703,4721,4723,4729,4733,4751,4759,4783,4787,4789,4793,4799,4801,4813,4817,4831,4861,4871,4877,4889,4903,4909,4919,4931,4933,4937,4943,4951,4957,4967,4969,4973,4987,4993,4999,5003,5009,5011,5021,5023,5039,5051,5059,5077,5081,5087,5099,5101,5107,5113,5119,5147,5153,5167,5171,5179,5189,5197,5209,5227,5231,5233,5237,5261,5273,5279,5281,5297,5303,5309,5323,5333,5347,5351,5381,5387,5393,5399,5407,5413,5417,5419,5431,5437,5441,5443,5449,5471,5477,5479,5483,5501,5503,5507,5519,5521,5527,5531,5557,5563,5569,5573,5581,5591,5623,5639,5641,5647,5651,5653,5657,5659,5669,5683,5689,5693,5701,5711,5717,5737,5741,5743,5749,5779,5783,5791,5801,5807,5813,5821,5827,5839,5843,5849,5851,5857,5861,5867,5869,5879,5881,5897,5903,5923,5927,5939,5953,5981,5987,6007,6011,6029,6037,6043,6047,6053,6067,6073,6079,6089,6091,6101,6113,6121,6131,6133,6143,6151,6163,6173,6197,6199,6203,6211,6217,6221,6229,6247,6257,6263,6269,6271,6277,6287,6299,6301,6311,6317,6323,6329,6337,6343,6353,6359,6361,6367,6373,6379,6389,6397,6421,6427,6449,6451,6469,6473,6481,6491,6521,6529,6547,6551,6553,6563,6569,6571,6577,6581,6599,6607,6619,6637,6653,6659,6661,6673,6679,6689,6691,6701,6703,6709,6719,6733,6737,6761,6763,6779,6781,6791,6793,6803,6823,6827,6829,6833,6841,6857,6863,6869,6871,6883,6899,6907,6911,6917,6947,6949,6959,6961,6967,6971,6977,6983,6991,6997,7001,7013,7019,7027,7039,7043,7057,7069,7079,7103,7109,7121,7127,7129,7151,7159,7177,7187,7193,7207,7211,7213,7219,7229,7237,7243,7247,7253,7283,7297,7307,7309,7321,7331,7333,7349,7351,7369,7393,7411,7417,7433,7451,7457,7459,7477,7481,7487,7489,7499,7507,7517,7523,7529,7537,7541,7547,7549,7559,7561,7573,7577,7583,7589,7591,7603,7607,7621,7639,7643,7649,7669,7673,7681,7687,7691,7699,7703,7717,7723,7727,7741,7753,7757,7759,7789,7793,7817,7823,7829,7841,7853,7867,7873,7877,7879,7883,7901,7907,7919,7927,7933,7937,7949,7951,7963,7993,8009,8011,8017,8039,8053,8059,8069,8081,8087,8089,8093,8101,8111,8117,8123,8147,8161,8167,8171,8179,8191,8209,8219,8221,8231,8233,8237,8243,8263,8269,8273,8287,8291,8293,8297,8311,8317,8329,8353,8363,8369,8377,8387,8389,8419,8423,8429,8431,8443,8447,8461,8467,8501,8513,8521,8527,8537,8539,8543,8563,8573,8581,8597,8599,8609,8623,8627,8629,8641,8647,8663,8669,8677,8681,8689,8693,8699,8707,8713,8719,8731,8737,8741,8747,8753,8761,8779,8783,8803,8807,8819,8821,8831,8837,8839,8849,8861,8863,8867,8887,8893,8923,8929,8933,8941,8951,8963,8969,8971,8999,9001,9007,9011,9013,9029,9041,9043,9049,9059,9067,9091,9103,9109,9127,9133,9137,9151,9157,9161,9173,9181,9187,9199,9203,9209,9221,9227,9239,9241,9257,9277,9281,9283,9293,9311,9319,9323,9337,9341,9343,9349,9371,9377,9391,9397,9403,9413,9419,9421,9431,9433,9437,9439,9461,9463,9467,9473,9479,9491,9497,9511,9521,9533,9539,9547,9551,9587,9601,9613,9619,9623,9629,9631,9643,9649,9661,9677,9679,9689,9697,9719,9721,9733,9739,9743,9749,9767,9769,9781,9787,9791,9803,9811,9817,9829,9833,9839,9851,9857,9859,9871,9883,9887,9901,9907,9923,9929,9931,9941,9949,9967,9973,10007,10009,10037,10039,10061,10067,10069,10079,10091,10093,10099,10103,10111,10133,10139,10141,10151,10159,10163,10169,10177,10181,10193,10211,10223,10243,10247,10253,10259,10267,10271,10273,10289,10301,10303,10313,10321,10331,10333,10337,10343,10357,10369,10391,10399,10427,10429,10433,10453,10457,10459,10463,10477,10487,10499,10501,10513,10529,10531,10559,10567,10589,10597,10601,10607,10613,10627,10631,10639,10651,10657,10663,10667,10687,10691,10709,10711,10723,10729,10733,10739,10753,10771,10781,10789,10799,10831,10837,10847,10853,10859,10861,10867,10883,10889,10891,10903,10909,10937,10939,10949,10957,10973,10979,10987,10993,11003,11027,11047,11057,11059,11069,11071,11083,11087,11093,11113,11117,11119,11131,11149,11159,11161,11171,11173,11177,11197,11213,11239,11243,11251,11257,11261,11273,11279,11287,11299,11311,11317,11321,11329,11351,11353,11369,11383,11393,11399,11411,11423,11437,11443,11447,11467,11471,11483,11489,11491,11497,11503,11519,11527,11549,11551,11579,11587,11593,11597,11617,11621,11633,11657,11677,11681,11689,11699,11701,11717,11719,11731,11743,11777,11779,11783,11789,11801,11807,11813,11821,11827,11831,11833,11839,11863,11867,11887,11897,11903,11909,11923,11927,11933,11939,11941,11953,11959,11969,11971,11981,11987,12007,12011,12037,12041,12043,12049,12071,12073,12097,12101,12107,12109,12113,12119,12143,12149,12157,12161,12163,12197,12203,12211,12227,12239,12241,12251,12253,12263,12269,12277,12281,12289,12301,12323,12329,12343,12347,12373,12377,12379,12391,12401,12409,12413,12421,12433,12437,12451,12457,12473,12479,12487,12491,12497,12503,12511,12517,12527,12539,12541,12547,12553,12569,12577,12583,12589,12601,12611,12613,12619,12637,12641,12647,12653,12659,12671,12689,12697,12703,12713,12721,12739,12743,12757,12763,12781,12791,12799,12809,12821,12823,12829,12841,12853,12889,12893,12899,12907,12911,12917,12919,12923,12941,12953,12959,12967,12973,12979,12983,13001,13003,13007,13009,13033,13037,13043,13049,13063,13093,13099,13103,13109,13121,13127,13147,13151,13159,13163,13171,13177,13183,13187,13217,13219,13229,13241,13249,13259,13267,13291,13297,13309,13313,13327,13331,13337,13339,13367,13381,13397,13399,13411,13417,13421,13441,13451,13457,13463,13469,13477,13487,13499,13513,13523,13537,13553,13567,13577,13591,13597,13613,13619,13627,13633,13649,13669,13679,13681,13687,13691,13693,13697,13709,13711,13721,13723,13729,13751,13757,13759,13763,13781,13789,13799,13807,13829,13831,13841,13859,13873,13877,13879,13883,13901,13903,13907,13913,13921,13931,13933,13963,13967,13997,13999,14009,14011,14029,14033,14051,14057,14071,14081,14083,14087,14107,14143,14149,14153,14159,14173,14177,14197,14207,14221,14243,14249,14251,14281,14293,14303,14321,14323,14327,14341,14347,14369,14387,14389,14401,14407,14411,14419,14423,14431,14437,14447,14449,14461,14479,14489,14503,14519,14533,14537,14543,14549,14551,14557,14561,14563,14591,14593,14621,14627,14629,14633,14639,14653,14657,14669,14683,14699,14713,14717,14723,14731,14737,14741,14747,14753,14759,14767,14771,14779,14783,14797,14813,14821,14827,14831,14843,14851,14867,14869,14879,14887,14891,14897,14923,14929,14939,14947,14951,14957,14969,14983,15013,15017,15031,15053,15061,15073,15077,15083,15091,15101,15107,15121,15131,15137,15139,15149,15161,15173,15187,15193,15199,15217,15227,15233,15241,15259,15263,15269,15271,15277,15287,15289,15299,15307,15313,15319,15329,15331,15349,15359,15361,15373,15377,15383,15391,15401,15413,15427,15439,15443,15451,15461,15467,15473,15493,15497,15511,15527,15541,15551,15559,15569,15581,15583,15601,15607,15619,15629,15641,15643,15647,15649,15661,15667,15671,15679,15683,15727,15731,15733,15737,15739,15749,15761,15767,15773,15787,15791,15797,15803,15809,15817,15823,15859,15877,15881,15887,15889,15901,15907,15913,15919,15923,15937,15959,15971,15973,15991,16001,16007,16033,16057,16061,16063,16067,16069,16073,16087,16091,16097,16103,16111,16127,16139,16141,16183,16187,16189,16193,16217,16223,16229,16231,16249,16253,16267,16273,16301,16319,16333,16339,16349,16361,16363,16369,16381,16411,16417,16421,16427,16433,16447,16451,16453,16477,16481,16487,16493,16519,16529,16547,16553,16561,16567,16573,16603,16607,16619,16631,16633,16649,16651,16657,16661,16673,16691,16693,16699,16703,16729,16741,16747,16759,16763,16787,16811,16823,16829,16831,16843,16871,16879,16883,16889,16901,16903,16921,16927,16931,16937,16943,16963,16979,16981,16987,16993,17011,17021,17027,17029,17033,17041,17047,17053,17077,17093,17099,17107,17117,17123,17137,17159,17167,17183,17189,17191,17203,17207,17209,17231,17239,17257,17291,17293,17299,17317,17321,17327,17333,17341,17351,17359,17377,17383,17387,17389,17393,17401,17417,17419,17431,17443,17449,17467,17471,17477,17483,17489,17491,17497,17509,17519,17539,17551,17569,17573,17579,17581,17597,17599,17609,17623,17627,17657,17659,17669,17681,17683,17707,17713,17729,17737,17747,17749,17761,17783,17789,17791,17807,17827,17837,17839,17851,17863,17881,17891,17903,17909,17911,17921,17923,17929,17939,17957,17959,17971,17977,17981,17987,17989,18013,18041,18043,18047,18049,18059,18061,18077,18089,18097,18119,18121,18127,18131,18133,18143,18149,18169,18181,18191,18199,18211,18217,18223,18229,18233,18251,18253,18257,18269,18287,18289,18301,18307,18311,18313,18329,18341,18353,18367,18371,18379,18397,18401,18413,18427,18433,18439,18443,18451,18457,18461,18481,18493,18503,18517,18521,18523,18539,18541,18553,18583,18587,18593,18617,18637,18661,18671,18679,18691,18701,18713,18719,18731,18743,18749,18757,18773,18787,18793,18797,18803,18839,18859,18869,18899,18911,18913,18917,18919,18947,18959,18973,18979,19001,19009,19013,19031,19037,19051,19069,19073,19079,19081,19087,19121,19139,19141,19157,19163,19181,19183,19207,19211,19213,19219,19231,19237,19249,19259,19267,19273,19289,19301,19309,19319,19333,19373,19379,19381,19387,19391,19403,19417,19421,19423,19427,19429,19433,19441,19447,19457,19463,19469,19471,19477,19483,19489,19501,19507,19531,19541,19543,19553,19559,19571,19577,19583,19597,19603,19609,19661,19681,19687,19697,19699,19709,19717,19727,19739,19751,19753,19759,19763,19777,19793,19801,19813,19819,19841,19843,19853,19861,19867,19889,19891,19913,19919,19927,19937,19949,19961,19963,19973,19979,19991,19993,19997,20011,20021,20023,20029,20047,20051,20063,20071,20089,20101,20107,20113,20117,20123,20129,20143,20147,20149,20161,20173,20177,20183,20201,20219,20231,20233,20249,20261,20269,20287,20297,20323,20327,20333,20341,20347,20353,20357,20359,20369,20389,20393,20399,20407,20411,20431,20441,20443,20477,20479,20483,20507,20509,20521,20533,20543,20549,20551,20563,20593,20599,20611,20627,20639,20641,20663,20681,20693,20707,20717,20719,20731,20743,20747,20749,20753,20759,20771,20773,20789,20807,20809,20849,20857,20873,20879,20887,20897,20899,20903,20921,20929,20939,20947,20959,20963,20981,20983,21001,21011,21013,21017,21019,21023,21031,21059,21061,21067,21089,21101,21107,21121,21139,21143,21149,21157,21163,21169,21179,21187,21191,21193,21211,21221,21227,21247,21269,21277,21283,21313,21317,21319,21323,21341,21347,21377,21379,21383,21391,21397,21401,21407,21419,21433,21467,21481,21487,21491,21493,21499,21503,21517,21521,21523,21529,21557,21559,21563,21569,21577,21587,21589,21599,21601,21611,21613,21617,21647,21649,21661,21673,21683,21701,21713,21727,21737,21739,21751,21757,21767,21773,21787,21799,21803,21817,21821,21839,21841,21851,21859,21863,21871,21881,21893,21911,21929,21937,21943,21961,21977,21991,21997,22003,22013,22027,22031,22037,22039,22051,22063,22067,22073,22079,22091,22093,22109,22111,22123,22129,22133,22147,22153,22157,22159,22171,22189,22193,22229,22247,22259,22271,22273,22277,22279,22283,22291,22303,22307,22343,22349,22367,22369,22381,22391,22397,22409,22433,22441,22447,22453,22469,22481,22483,22501,22511,22531,22541,22543,22549,22567,22571,22573,22613,22619,22621,22637,22639,22643,22651,22669,22679,22691,22697,22699,22709,22717,22721,22727,22739,22741,22751,22769,22777,22783,22787,22807,22811,22817,22853,22859,22861,22871,22877,22901,22907,22921,22937,22943,22961,22963,22973,22993,23003,23011,23017,23021,23027,23029,23039,23041,23053,23057,23059,23063,23071,23081,23087,23099,23117,23131,23143,23159,23167,23173,23189,23197,23201,23203,23209,23227,23251,23269,23279,23291,23293,23297,23311,23321,23327,23333,23339,23357,23369,23371,23399,23417,23431,23447,23459,23473,23497,23509,23531,23537,23539,23549,23557,23561,23563,23567,23581,23593,23599,23603,23609,23623,23627,23629,23633,23663,23669,23671,23677,23687,23689,23719,23741,23743,23747,23753,23761,23767,23773,23789,23801,23813,23819,23827,23831,23833,23857,23869,23873,23879,23887,23893,23899,23909,23911,23917,23929,23957,23971,23977,23981,23993,24001,24007,24019,24023,24029,24043,24049,24061,24071,24077,24083,24091,24097,24103,24107,24109,24113,24121,24133,24137,24151,24169,24179,24181,24197,24203,24223,24229,24239,24247,24251,24281,24317,24329,24337,24359,24371,24373,24379,24391,24407,24413,24419,24421,24439,24443,24469,24473,24481,24499,24509,24517,24527,24533,24547,24551,24571,24593,24611,24623,24631,24659,24671,24677,24683,24691,24697,24709,24733,24749,24763,24767,24781,24793,24799,24809,24821,24841,24847,24851,24859,24877,24889,24907,24917,24919,24923,24943,24953,24967,24971,24977,24979,24989,25013,25031,25033,25037,25057,25073,25087,25097,25111,25117,25121,25127,25147,25153,25163,25169,25171,25183,25189,25219,25229,25237,25243,25247,25253,25261,25301,25303,25307,25309,25321,25339,25343,25349,25357,25367,25373,25391,25409,25411,25423,25439,25447,25453,25457,25463,25469,25471,25523,25537,25541,25561,25577,25579,25583,25589,25601,25603,25609,25621,25633,25639,25643,25657,25667,25673,25679,25693,25703,25717,25733,25741,25747,25759,25763,25771,25793,25799,25801,25819,25841,25847,25849,25867,25873,25889,25903,25913,25919,25931,25933,25939,25943,25951,25969,25981,25997,25999,26003,26017,26021,26029,26041,26053,26083,26099,26107,26111,26113,26119,26141,26153,26161,26171,26177,26183,26189,26203,26209,26227,26237,26249,26251,26261,26263,26267,26293,26297,26309,26317,26321,26339,26347,26357,26371,26387,26393,26399,26407,26417,26423,26431,26437,26449,26459,26479,26489,26497,26501,26513,26539,26557,26561,26573,26591,26597,26627,26633,26641,26647,26669,26681,26683,26687,26693,26699,26701,26711,26713,26717,26723,26729,26731,26737,26759,26777,26783,26801,26813,26821,26833,26839,26849,26861,26863,26879,26881,26891,26893,26903,26921,26927,26947,26951,26953,26959,26981,26987,26993,27011,27017,27031,27043,27059,27061,27067,27073,27077,27091,27103,27107,27109,27127,27143,27179,27191,27197,27211,27239,27241,27253,27259,27271,27277,27281,27283,27299,27329,27337,27361,27367,27397,27407,27409,27427,27431,27437,27449,27457,27479,27481,27487,27509,27527,27529,27539,27541,27551,27581,27583,27611,27617,27631,27647,27653,27673,27689,27691,27697,27701,27733,27737,27739,27743,27749,27751,27763,27767,27773,27779,27791,27793,27799,27803,27809,27817,27823,27827,27847,27851,27883,27893,27901,27917,27919,27941,27943,27947,27953,27961,27967,27983,27997,28001,28019,28027,28031,28051,28057,28069,28081,28087,28097,28099,28109,28111,28123,28151,28163,28181,28183,28201,28211,28219,28229,28277,28279,28283,28289,28297,28307,28309,28319,28349,28351,28387,28393,28403,28409,28411,28429,28433,28439,28447,28463,28477,28493,28499,28513,28517,28537,28541,28547,28549,28559,28571,28573,28579,28591,28597,28603,28607,28619,28621,28627,28631,28643,28649,28657,28661,28663,28669,28687,28697,28703,28711,28723,28729,28751,28753,28759,28771,28789,28793,28807,28813,28817,28837,28843,28859,28867,28871,28879,28901,28909,28921,28927,28933,28949,28961,28979,29009,29017,29021,29023,29027,29033,29059,29063,29077,29101,29123,29129,29131,29137,29147,29153,29167,29173,29179,29191,29201,29207,29209,29221,29231,29243,29251,29269,29287,29297,29303,29311,29327,29333,29339,29347,29363,29383,29387,29389,29399,29401,29411,29423,29429,29437,29443,29453,29473,29483,29501,29527,29531,29537,29567,29569,29573,29581,29587,29599,29611,29629,29633,29641,29663,29669,29671,29683,29717,29723,29741,29753,29759,29761,29789,29803,29819,29833,29837,29851,29863,29867,29873,29879,29881,29917,29921,29927,29947,29959,29983,29989,30011,30013,30029,30047,30059,30071,30089,30091,30097,30103,30109,30113,30119,30133,30137,30139,30161,30169,30181,30187,30197,30203,30211,30223,30241,30253,30259,30269,30271,30293,30307,30313,30319,30323,30341,30347,30367,30389,30391,30403,30427,30431,30449,30467,30469,30491,30493,30497,30509,30517,30529,30539,30553,30557,30559,30577,30593,30631,30637,30643,30649,30661,30671,30677,30689,30697,30703,30707,30713,30727,30757,30763,30773,30781,30803,30809,30817,30829,30839,30841,30851,30853,30859,30869,30871,30881,30893,30911,30931,30937,30941,30949,30971,30977,30983,31013,31019,31033,31039,31051,31063,31069,31079,31081,31091,31121,31123,31139,31147,31151,31153,31159,31177,31181,31183,31189,31193,31219,31223,31231,31237,31247,31249,31253,31259,31267,31271,31277,31307,31319,31321,31327,31333,31337,31357,31379,31387,31391,31393,31397,31469,31477,31481,31489,31511,31513,31517,31531,31541,31543,31547,31567,31573,31583,31601,31607,31627,31643,31649,31657,31663,31667,31687,31699,31721,31723,31727,31729,31741,31751,31769,31771,31793,31799,31817,31847,31849,31859,31873,31883,31891,31907,31957,31963,31973,31981,31991,32003,32009,32027,32029,32051,32057,32059,32063,32069,32077,32083,32089,32099,32117,32119,32141,32143,32159,32173,32183,32189,32191,32203,32213,32233,32237,32251,32257,32261,32297,32299,32303,32309,32321,32323,32327,32341,32353,32359,32363,32369,32371,32377,32381,32401,32411,32413,32423,32429,32441,32443,32467,32479,32491,32497,32503,32507,32531,32533,32537,32561,32563,32569,32573,32579,32587,32603,32609,32611,32621,32633,32647,32653,32687,32693,32707,32713,32717,32719,32749,32771,32779,32783,32789,32797,32801,32803,32831,32833,32839,32843,32869,32887,32909,32911,32917,32933,32939,32941,32957,32969,32971,32983,32987,32993,32999,33013,33023,33029,33037,33049,33053,33071,33073,33083,33091,33107,33113,33119,33149,33151,33161,33179,33181,33191,33199,33203,33211,33223,33247,33287,33289,33301,33311,33317,33329,33331,33343,33347,33349,33353,33359,33377,33391,33403,33409,33413,33427,33457,33461,33469,33479,33487,33493,33503,33521,33529,33533,33547,33563,33569,33577,33581,33587,33589,33599,33601,33613,33617,33619,33623,33629,33637,33641,33647,33679,33703,33713,33721,33739,33749,33751,33757,33767,33769,33773,33791,33797,33809,33811,33827,33829,33851,33857,33863,33871,33889,33893,33911,33923,33931,33937,33941,33961,33967,33997,34019,34031,34033,34039,34057,34061,34123,34127,34129,34141,34147,34157,34159,34171,34183,34211,34213,34217,34231,34253,34259,34261,34267,34273,34283,34297,34301,34303,34313,34319,34327,34337,34351,34361,34367,34369,34381,34403,34421,34429,34439,34457,34469,34471,34483,34487,34499,34501,34511,34513,34519,34537,34543,34549,34583,34589,34591,34603,34607,34613,34631,34649,34651,34667,34673,34679,34687,34693,34703,34721,34729,34739,34747,34757,34759,34763,34781,34807,34819,34841,34843,34847,34849,34871,34877,34883,34897,34913,34919,34939,34949,34961,34963,34981,35023,35027,35051,35053,35059,35069,35081,35083,35089,35099,35107,35111,35117,35129,35141,35149,35153,35159,35171,35201,35221,35227,35251,35257,35267,35279,35281,35291,35311,35317,35323,35327,35339,35353,35363,35381,35393,35401,35407,35419,35423,35437,35447,35449,35461,35491,35507,35509,35521,35527,35531,35533,35537,35543,35569,35573,35591,35593,35597,35603,35617,35671,35677,35729,35731,35747,35753,35759,35771,35797,35801,35803,35809,35831,35837,35839,35851,35863,35869,35879,35897,35899,35911,35923,35933,35951,35963,35969,35977,35983,35993,35999,36007,36011,36013,36017,36037,36061,36067,36073,36083,36097,36107,36109,36131,36137,36151,36161,36187,36191,36209,36217,36229,36241,36251,36263,36269,36277,36293,36299,36307,36313,36319,36341,36343,36353,36373,36383,36389,36433,36451,36457,36467,36469,36473,36479,36493,36497,36523,36527,36529,36541,36551,36559,36563,36571,36583,36587,36599,36607,36629,36637,36643,36653,36671,36677,36683,36691,36697,36709,36713,36721,36739,36749,36761,36767,36779,36781,36787,36791,36793,36809,36821,36833,36847,36857,36871,36877,36887,36899,36901,36913,36919,36923,36929,36931,36943,36947,36973,36979,36997,37003,37013,37019,37021,37039,37049,37057,37061,37087,37097,37117,37123,37139,37159,37171,37181,37189,37199,37201,37217,37223,37243,37253,37273,37277,37307,37309,37313,37321,37337,37339,37357,37361,37363,37369,37379,37397,37409,37423,37441,37447,37463,37483,37489,37493,37501,37507,37511,37517,37529,37537,37547,37549,37561,37567,37571,37573,37579,37589,37591,37607,37619,37633,37643,37649,37657,37663,37691,37693,37699,37717,37747,37781,37783,37799,37811,37813,37831,37847,37853,37861,37871,37879,37889,37897,37907,37951,37957,37963,37967,37987,37991,37993,37997,38011,38039,38047,38053,38069,38083,38113,38119,38149,38153,38167,38177,38183,38189,38197,38201,38219,38231,38237,38239,38261,38273,38281,38287,38299,38303,38317,38321,38327,38329,38333,38351,38371,38377,38393,38431,38447,38449,38453,38459,38461,38501,38543,38557,38561,38567,38569,38593,38603,38609,38611,38629,38639,38651,38653,38669,38671,38677,38693,38699,38707,38711,38713,38723,38729,38737,38747,38749,38767,38783,38791,38803,38821,38833,38839,38851,38861,38867,38873,38891,38903,38917,38921,38923,38933,38953,38959,38971,38977,38993,39019,39023,39041,39043,39047,39079,39089,39097,39103,39107,39113,39119,39133,39139,39157,39161,39163,39181,39191,39199,39209,39217,39227,39229,39233,39239,39241,39251,39293,39301,39313,39317,39323,39341,39343,39359,39367,39371,39373,39383,39397,39409,39419,39439,39443,39451,39461,39499,39503,39509,39511,39521,39541,39551,39563,39569,39581,39607,39619,39623,39631,39659,39667,39671,39679,39703,39709,39719,39727,39733,39749,39761,39769,39779,39791,39799,39821,39827,39829,39839,39841,39847,39857,39863,39869,39877,39883,39887,39901,39929,39937,39953,39971,39979,39983,39989,40009,40013,40031,40037,40039,40063,40087,40093,40099,40111,40123,40127,40129,40151,40153,40163,40169,40177,40189,40193,40213,40231,40237,40241,40253,40277,40283,40289,40343,40351,40357,40361,40387,40423,40427,40429,40433,40459,40471,40483,40487,40493,40499,40507,40519,40529,40531,40543,40559,40577,40583,40591,40597,40609,40627,40637,40639,40693,40697,40699,40709,40739,40751,40759,40763,40771,40787,40801,40813,40819,40823,40829,40841,40847,40849,40853,40867,40879,40883,40897,40903,40927,40933,40939,40949,40961,40973,40993,41011,41017,41023,41039,41047,41051,41057,41077,41081,41113,41117,41131,41141,41143,41149,41161,41177,41179,41183,41189,41201,41203,41213,41221,41227,41231,41233,41243,41257,41263,41269,41281,41299,41333,41341,41351,41357,41381,41387,41389,41399,41411,41413,41443,41453,41467,41479,41491,41507,41513,41519,41521,41539,41543,41549,41579,41593,41597,41603,41609,41611,41617,41621,41627,41641,41647,41651,41659,41669,41681,41687,41719,41729,41737,41759,41761,41771,41777,41801,41809,41813,41843,41849,41851,41863,41879,41887,41893,41897,41903,41911,41927,41941,41947,41953,41957,41959,41969,41981,41983,41999,42013,42017,42019,42023,42043,42061,42071,42073,42083,42089,42101,42131,42139,42157,42169,42179,42181,42187,42193,42197,42209,42221,42223,42227,42239,42257,42281,42283,42293,42299,42307,42323,42331,42337,42349,42359,42373,42379,42391,42397,42403,42407,42409,42433,42437,42443,42451,42457,42461,42463,42467,42473,42487,42491,42499,42509,42533,42557,42569,42571,42577,42589,42611,42641,42643,42649,42667,42677,42683,42689,42697,42701,42703,42709,42719,42727,42737,42743,42751,42767,42773,42787,42793,42797,42821,42829,42839,42841,42853,42859,42863,42899,42901,42923,42929,42937,42943,42953,42961,42967,42979,42989,43003,43013,43019,43037,43049,43051,43063,43067,43093,43103,43117,43133,43151,43159,43177,43189,43201,43207,43223,43237,43261,43271,43283,43291,43313,43319,43321,43331,43391,43397,43399,43403,43411,43427,43441,43451,43457,43481,43487,43499,43517,43541,43543,43573,43577,43579,43591,43597,43607,43609,43613,43627,43633,43649,43651,43661,43669,43691,43711,43717,43721,43753,43759,43777,43781,43783,43787,43789,43793,43801,43853,43867,43889,43891,43913,43933,43943,43951,43961,43963,43969,43973,43987,43991,43997,44017,44021,44027,44029,44041,44053,44059,44071,44087,44089,44101,44111,44119,44123,44129,44131,44159,44171,44179,44189,44201,44203,44207,44221,44249,44257,44263,44267,44269,44273,44279,44281,44293,44351,44357,44371,44381,44383,44389,44417,44449,44453,44483,44491,44497,44501,44507,44519,44531,44533,44537,44543,44549,44563,44579,44587,44617,44621,44623,44633,44641,44647,44651,44657,44683,44687,44699,44701,44711,44729,44741,44753,44771,44773,44777,44789,44797,44809,44819,44839,44843,44851,44867,44879,44887,44893,44909,44917,44927,44939,44953,44959,44963,44971,44983,44987,45007,45013,45053,45061,45077,45083,45119,45121,45127,45131,45137,45139,45161,45179,45181,45191,45197,45233,45247,45259,45263,45281,45289,45293,45307,45317,45319,45329,45337,45341,45343,45361,45377,45389,45403,45413,45427,45433,45439,45481,45491,45497,45503,45523,45533,45541,45553,45557,45569,45587,45589,45599,45613,45631,45641,45659,45667,45673,45677,45691,45697,45707,45737,45751,45757,45763,45767,45779,45817,45821,45823,45827,45833,45841,45853,45863,45869,45887,45893,45943,45949,45953,45959,45971,45979,45989,46021,46027,46049,46051,46061,46073,46091,46093,46099,46103,46133,46141,46147,46153,46171,46181,46183,46187,46199,46219,46229,46237,46261,46271,46273,46279,46301,46307,46309,46327,46337,46349,46351,46381,46399,46411,46439,46441,46447,46451,46457,46471,46477,46489,46499,46507,46511,46523,46549,46559,46567,46573,46589,46591,46601,46619,46633,46639,46643,46649,46663,46679,46681,46687,46691,46703,46723,46727,46747,46751,46757,46769,46771,46807,46811,46817,46819,46829,46831,46853,46861,46867,46877,46889,46901,46919,46933,46957,46993,46997,47017,47041,47051,47057,47059,47087,47093,47111,47119,47123,47129,47137,47143,47147,47149,47161,47189,47207,47221,47237,47251,47269,47279,47287,47293,47297,47303,47309,47317,47339,47351,47353,47363,47381,47387,47389,47407,47417,47419,47431,47441,47459,47491,47497,47501,47507,47513,47521,47527,47533,47543,47563,47569,47581,47591,47599,47609,47623,47629,47639,47653,47657,47659,47681,47699,47701,47711,47713,47717,47737,47741,47743,47777,47779,47791,47797,47807,47809,47819,47837,47843,47857,47869,47881,47903,47911,47917,47933,47939,47947,47951,47963,47969,47977,47981,48017,48023,48029,48049,48073,48079,48091,48109,48119,48121,48131,48157,48163,48179,48187,48193,48197,48221,48239,48247,48259,48271,48281,48299,48311,48313,48337,48341,48353,48371,48383,48397,48407,48409,48413,48437,48449,48463,48473,48479,48481,48487,48491,48497,48523,48527,48533,48539,48541,48563,48571,48589,48593,48611,48619,48623,48647,48649,48661,48673,48677,48679,48731,48733,48751,48757,48761,48767,48779,48781,48787,48799,48809,48817,48821,48823,48847,48857,48859,48869,48871,48883,48889,48907,48947,48953,48973,48989,48991,49003,49009,49019,49031,49033,49037,49043,49057,49069,49081,49103,49109,49117,49121,49123,49139,49157,49169,49171,49177,49193,49199,49201,49207,49211,49223,49253,49261,49277,49279,49297,49307,49331,49333,49339,49363,49367,49369,49391,49393,49409,49411,49417,49429,49433,49451,49459,49463,49477,49481,49499,49523,49529,49531,49537,49547,49549,49559,49597,49603,49613,49627,49633,49639,49663,49667,49669,49681,49697,49711,49727,49739,49741,49747,49757,49783,49787,49789,49801,49807,49811,49823,49831,49843,49853,49871,49877,49891,49919,49921,49927,49937,49939,49943,49957,49991,49993,49999,50021,50023,50033,50047,50051,50053,50069,50077,50087,50093,50101,50111,50119,50123,50129,50131,50147,50153,50159,50177,50207,50221,50227,50231,50261,50263,50273,50287,50291,50311,50321,50329,50333,50341,50359,50363,50377,50383,50387,50411,50417,50423,50441,50459,50461,50497,50503,50513,50527,50539,50543,50549,50551,50581,50587,50591,50593,50599,50627,50647,50651,50671,50683,50707,50723,50741,50753,50767,50773,50777,50789,50821,50833,50839,50849,50857,50867,50873,50891,50893,50909,50923,50929,50951,50957,50969,50971,50989,50993,51001,51031,51043,51047,51059,51061,51071,51109,51131,51133,51137,51151,51157,51169,51193,51197,51199,51203,51217,51229,51239,51241,51257,51263,51283,51287,51307,51329,51341,51343,51347,51349,51361,51383,51407,51413,51419,51421,51427,51431,51437,51439,51449,51461,51473,51479,51481,51487,51503,51511,51517,51521,51539,51551,51563,51577,51581,51593,51599,51607,51613,51631,51637,51647,51659,51673,51679,51683,51691,51713,51719,51721,51749,51767,51769,51787,51797,51803,51817,51827,51829,51839,51853,51859,51869,51871,51893,51899,51907,51913,51929,51941,51949,51971,51973,51977,51991,52009,52021,52027,52051,52057,52067,52069,52081,52103,52121,52127,52147,52153,52163,52177,52181,52183,52189,52201,52223,52237,52249,52253,52259,52267,52289,52291,52301,52313,52321,52361,52363,52369,52379,52387,52391,52433,52453,52457,52489,52501,52511,52517,52529,52541,52543,52553,52561,52567,52571,52579,52583,52609,52627,52631,52639,52667,52673,52691,52697,52709,52711,52721,52727,52733,52747,52757,52769,52783,52807,52813,52817,52837,52859,52861,52879,52883,52889,52901,52903,52919,52937,52951,52957,52963,52967,52973,52981,52999,53003,53017,53047,53051,53069,53077,53087,53089,53093,53101,53113,53117,53129,53147,53149,53161,53171,53173,53189,53197,53201,53231,53233,53239,53267,53269,53279,53281,53299,53309,53323,53327,53353,53359,53377,53381,53401,53407,53411,53419,53437,53441,53453,53479,53503,53507,53527,53549,53551,53569,53591,53593,53597,53609,53611,53617,53623,53629,53633,53639,53653,53657,53681,53693,53699,53717,53719,53731,53759,53773,53777,53783,53791,53813,53819,53831,53849,53857,53861,53881,53887,53891,53897,53899,53917,53923,53927,53939,53951,53959,53987,53993,54001,54011,54013,54037,54049,54059,54083,54091,54101,54121,54133,54139,54151,54163,54167,54181,54193,54217,54251,54269,54277,54287,54293,54311,54319,54323,54331,54347,54361,54367,54371,54377,54401,54403,54409,54413,54419,54421,54437,54443,54449,54469,54493,54497,54499,54503,54517,54521,54539,54541,54547,54559,54563,54577,54581,54583,54601,54617,54623,54629,54631,54647,54667,54673,54679,54709,54713,54721,54727,54751,54767,54773,54779,54787,54799,54829,54833,54851,54869,54877,54881,54907,54917,54919,54941,54949,54959,54973,54979,54983,55001,55009,55021,55049,55051,55057,55061,55073,55079,55103,55109,55117,55127,55147,55163,55171,55201,55207,55213,55217,55219,55229,55243,55249,55259,55291,55313,55331,55333,55337,55339,55343,55351,55373,55381,55399,55411,55439,55441,55457,55469,55487,55501,55511,55529,55541,55547,55579,55589,55603,55609,55619,55621,55631,55633,55639,55661,55663,55667,55673,55681,55691,55697,55711,55717,55721,55733,55763,55787,55793,55799,55807,55813,55817,55819,55823,55829,55837,55843,55849,55871,55889,55897,55901,55903,55921,55927,55931,55933,55949,55967,55987,55997,56003,56009,56039,56041,56053,56081,56087,56093,56099,56101,56113,56123,56131,56149,56167,56171,56179,56197,56207,56209,56237,56239,56249,56263,56267,56269,56299,56311,56333,56359,56369,56377,56383,56393,56401,56417,56431,56437,56443,56453,56467,56473,56477,56479,56489,56501,56503,56509,56519,56527,56531,56533,56543,56569,56591,56597,56599,56611,56629,56633,56659,56663,56671,56681,56687,56701,56711,56713,56731,56737,56747,56767,56773,56779,56783,56807,56809,56813,56821,56827,56843,56857,56873,56891,56893,56897,56909,56911,56921,56923,56929,56941,56951,56957,56963,56983,56989,56993,56999,57037,57041,57047,57059,57073,57077,57089,57097,57107,57119,57131,57139,57143,57149,57163,57173,57179,57191,57193,57203,57221,57223,57241,57251,57259,57269,57271,57283,57287,57301,57329,57331,57347,57349,57367,57373,57383,57389,57397,57413,57427,57457,57467,57487,57493,57503,57527,57529,57557,57559,57571,57587,57593,57601,57637,57641,57649,57653,57667,57679,57689,57697,57709,57713,57719,57727,57731,57737,57751,57773,57781,57787,57791,57793,57803,57809,57829,57839,57847,57853,57859,57881,57899,57901,57917,57923,57943,57947,57973,57977,57991,58013,58027,58031,58043,58049,58057,58061,58067,58073,58099,58109,58111,58129,58147,58151,58153,58169,58171,58189,58193,58199,58207,58211,58217,58229,58231,58237,58243,58271,58309,58313,58321,58337,58363,58367,58369,58379,58391,58393,58403,58411,58417,58427,58439,58441,58451,58453,58477,58481,58511,58537,58543,58549,58567,58573,58579,58601,58603,58613,58631,58657,58661,58679,58687,58693,58699,58711,58727,58733,58741,58757,58763,58771,58787,58789,58831,58889,58897,58901,58907,58909,58913,58921,58937,58943,58963,58967,58979,58991,58997,59009,59011,59021,59023,59029,59051,59053,59063,59069,59077,59083,59093,59107,59113,59119,59123,59141,59149,59159,59167,59183,59197,59207,59209,59219,59221,59233,59239,59243,59263,59273,59281,59333,59341,59351,59357,59359,59369,59377,59387,59393,59399,59407,59417,59419,59441,59443,59447,59453,59467,59471,59473,59497,59509,59513,59539,59557,59561,59567,59581,59611,59617,59621,59627,59629,59651,59659,59663,59669,59671,59693,59699,59707,59723,59729,59743,59747,59753,59771,59779,59791,59797,59809,59833,59863,59879,59887,59921,59929,59951,59957,59971,59981,59999,60013,60017,60029,60037,60041,60077,60083,60089,60091,60101,60103,60107,60127,60133,60139,60149,60161,60167,60169,60209,60217,60223,60251,60257,60259,60271,60289,60293,60317,60331,60337,60343,60353,60373,60383,60397,60413,60427,60443,60449,60457,60493,60497,60509,60521,60527,60539,60589,60601,60607,60611,60617,60623,60631,60637,60647,60649,60659,60661,60679,60689,60703,60719,60727,60733,60737,60757,60761,60763,60773,60779,60793,60811,60821,60859,60869,60887,60889,60899,60901,60913,60917,60919,60923,60937,60943,60953,60961,61001,61007,61027,61031,61043,61051,61057,61091,61099,61121,61129,61141,61151,61153,61169,61211,61223,61231,61253,61261,61283,61291,61297,61331,61333,61339,61343,61357,61363,61379,61381,61403,61409,61417,61441,61463,61469,61471,61483,61487,61493,61507,61511,61519,61543,61547,61553,61559,61561,61583,61603,61609,61613,61627,61631,61637,61643,61651,61657,61667,61673,61681,61687,61703,61717,61723,61729,61751,61757,61781,61813,61819,61837,61843,61861,61871,61879,61909,61927,61933,61949,61961,61967,61979,61981,61987,61991,62003,62011,62017,62039,62047,62053,62057,62071,62081,62099,62119,62129,62131,62137,62141,62143,62171,62189,62191,62201,62207,62213,62219,62233,62273,62297,62299,62303,62311,62323,62327,62347,62351,62383,62401,62417,62423,62459,62467,62473,62477,62483,62497,62501,62507,62533,62539,62549,62563,62581,62591,62597,62603,62617,62627,62633,62639,62653,62659,62683,62687,62701,62723,62731,62743,62753,62761,62773,62791,62801,62819,62827,62851,62861,62869,62873,62897,62903,62921,62927,62929,62939,62969,62971,62981,62983,62987,62989,63029,63031,63059,63067,63073,63079,63097,63103,63113,63127,63131,63149,63179,63197,63199,63211,63241,63247,63277,63281,63299,63311,63313,63317,63331,63337,63347,63353,63361,63367,63377,63389,63391,63397,63409,63419,63421,63439,63443,63463,63467,63473,63487,63493,63499,63521,63527,63533,63541,63559,63577,63587,63589,63599,63601,63607,63611,63617,63629,63647,63649,63659,63667,63671,63689,63691,63697,63703,63709,63719,63727,63737,63743,63761,63773,63781,63793,63799,63803,63809,63823,63839,63841,63853,63857,63863,63901,63907,63913,63929,63949,63977,63997,64007,64013,64019,64033,64037,64063,64067,64081,64091,64109,64123,64151,64153,64157,64171,64187,64189,64217,64223,64231,64237,64271,64279,64283,64301,64303,64319,64327,64333,64373,64381,64399,64403,64433,64439,64451,64453,64483,64489,64499,64513,64553,64567,64577,64579,64591,64601,64609,64613,64621,64627,64633,64661,64663,64667,64679,64693,64709,64717,64747,64763,64781,64783,64793,64811,64817,64849,64853,64871,64877,64879,64891,64901,64919,64921,64927,64937,64951,64969,64997,65003,65011,65027,65029,65033,65053,65063,65071,65089,65099,65101,65111,65119,65123,65129,65141,65147,65167,65171,65173,65179,65183,65203,65213,65239,65257,65267,65269,65287,65293,65309,65323,65327,65353,65357,65371,65381,65393,65407,65413,65419,65423,65437,65447,65449,65479,65497,65519,65521,65537,65539,65543,65551,65557,65563,65579,65581,65587,65599,65609,65617,65629,65633,65647,65651,65657,65677,65687,65699,65701,65707,65713,65717,65719,65729,65731,65761,65777,65789,65809,65827,65831,65837,65839,65843,65851,65867,65881,65899,65921,65927,65929,65951,65957,65963,65981,65983,65993,66029,66037,66041,66047,66067,66071,66083,66089,66103,66107,66109,66137,66161,66169,66173,66179,66191,66221,66239,66271,66293,66301,66337,66343,66347,66359,66361,66373,66377,66383,66403,66413,66431,66449,66457,66463,66467,66491,66499,66509,66523,66529,66533,66541,66553,66569,66571,66587,66593,66601,66617,66629,66643,66653,66683,66697,66701,66713,66721,66733,66739,66749,66751,66763,66791,66797,66809,66821,66841,66851,66853,66863,66877,66883,66889,66919,66923,66931,66943,66947,66949,66959,66973,66977,67003,67021,67033,67043,67049,67057,67061,67073,67079,67103,67121,67129,67139,67141,67153,67157,67169,67181,67187,67189,67211,67213,67217,67219,67231,67247,67261,67271,67273,67289,67307,67339,67343,67349,67369,67391,67399,67409,67411,67421,67427,67429,67433,67447,67453,67477,67481,67489,67493,67499,67511,67523,67531,67537,67547,67559,67567,67577,67579,67589,67601,67607,67619,67631,67651,67679,67699,67709,67723,67733,67741,67751,67757,67759,67763,67777,67783,67789,67801,67807,67819,67829,67843,67853,67867,67883,67891,67901,67927,67931,67933,67939,67943,67957,67961,67967,67979,67987,67993,68023,68041,68053,68059,68071,68087,68099,68111,68113,68141,68147,68161,68171,68207,68209,68213,68219,68227,68239,68261,68279,68281,68311,68329,68351,68371,68389,68399,68437,68443,68447,68449,68473,68477,68483,68489,68491,68501,68507,68521,68531,68539,68543,68567,68581,68597,68611,68633,68639,68659,68669,68683,68687,68699,68711,68713,68729,68737,68743,68749,68767,68771,68777,68791,68813,68819,68821,68863,68879,68881,68891,68897,68899,68903,68909,68917,68927,68947,68963,68993,69001,69011,69019,69029,69031,69061,69067,69073,69109,69119,69127,69143,69149,69151,69163,69191,69193,69197,69203,69221,69233,69239,69247,69257,69259,69263,69313,69317,69337,69341,69371,69379,69383,69389,69401,69403,69427,69431,69439,69457,69463,69467,69473,69481,69491,69493,69497,69499,69539,69557,69593,69623,69653,69661,69677,69691,69697,69709,69737,69739,69761,69763,69767,69779,69809,69821,69827,69829,69833,69847,69857,69859,69877,69899,69911,69929,69931,69941,69959,69991,69997,70001,70003,70009,70019,70039,70051,70061,70067,70079,70099,70111,70117,70121,70123,70139,70141,70157,70163,70177,70181,70183,70199,70201,70207,70223,70229,70237,70241,70249,70271,70289,70297,70309,70313,70321,70327,70351,70373,70379,70381,70393,70423,70429,70439,70451,70457,70459,70481,70487,70489,70501,70507,70529,70537,70549,70571,70573,70583,70589,70607,70619,70621,70627,70639,70657,70663,70667,70687,70709,70717,70729,70753,70769,70783,70793,70823,70841,70843,70849,70853,70867,70877,70879,70891,70901,70913,70919,70921,70937,70949,70951,70957,70969,70979,70981,70991,70997,70999,71011,71023,71039,71059,71069,71081,71089,71119,71129,71143,71147,71153,71161,71167,71171,71191,71209,71233,71237,71249,71257,71261,71263,71287,71293,71317,71327,71329,71333,71339,71341,71347,71353,71359,71363,71387,71389,71399,71411,71413,71419,71429,71437,71443,71453,71471,71473,71479,71483,71503,71527,71537,71549,71551,71563,71569,71593,71597,71633,71647,71663,71671,71693,71699,71707,71711,71713,71719,71741,71761,71777,71789,71807,71809,71821,71837,71843,71849,71861,71867,71879,71881,71887,71899,71909,71917,71933,71941,71947,71963,71971,71983,71987,71993,71999,72019,72031,72043,72047,72053,72073,72077,72089,72091,72101,72103,72109,72139,72161,72167,72169,72173,72211,72221,72223,72227,72229,72251,72253,72269,72271,72277,72287,72307,72313,72337,72341,72353,72367,72379,72383,72421,72431,72461,72467,72469,72481,72493,72497,72503,72533,72547,72551,72559,72577,72613,72617,72623,72643,72647,72649,72661,72671,72673,72679,72689,72701,72707,72719,72727,72733,72739,72763,72767,72797,72817,72823,72859,72869,72871,72883,72889,72893,72901,72907,72911,72923,72931,72937,72949,72953,72959,72973,72977,72997,73009,73013,73019,73037,73039,73043,73061,73063,73079,73091,73121,73127,73133,73141,73181,73189,73237,73243,73259,73277,73291,73303,73309,73327,73331,73351,73361,73363,73369,73379,73387,73417,73421,73433,73453,73459,73471,73477,73483,73517,73523,73529,73547,73553,73561,73571,73583,73589,73597,73607,73609,73613,73637,73643,73651,73673,73679,73681,73693,73699,73709,73721,73727,73751,73757,73771,73783,73819,73823,73847,73849,73859,73867,73877,73883,73897,73907,73939,73943,73951,73961,73973,73999,74017,74021,74027,74047,74051,74071,74077,74093,74099,74101,74131,74143,74149,74159,74161,74167,74177,74189,74197,74201,74203,74209,74219,74231,74257,74279,74287,74293,74297,74311,74317,74323,74353,74357,74363,74377,74381,74383,74411,74413,74419,74441,74449,74453,74471,74489,74507,74509,74521,74527,74531,74551,74561,74567,74573,74587,74597,74609,74611,74623,74653,74687,74699,74707,74713,74717,74719,74729,74731,74747,74759,74761,74771,74779,74797,74821,74827,74831,74843,74857,74861,74869,74873,74887,74891,74897,74903,74923,74929,74933,74941,74959,75011,75013,75017,75029,75037,75041,75079,75083,75109,75133,75149,75161,75167,75169,75181,75193,75209,75211,75217,75223,75227,75239,75253,75269,75277,75289,75307,75323,75329,75337,75347,75353,75367,75377,75389,75391,75401,75403,75407,75431,75437,75479,75503,75511,75521,75527,75533,75539,75541,75553,75557,75571,75577,75583,75611,75617,75619,75629,75641,75653,75659,75679,75683,75689,75703,75707,75709,75721,75731,75743,75767,75773,75781,75787,75793,75797,75821,75833,75853,75869,75883,75913,75931,75937,75941,75967,75979,75983,75989,75991,75997,76001,76003,76031,76039,76079,76081,76091,76099,76103,76123,76129,76147,76157,76159,76163,76207,76213,76231,76243,76249,76253,76259,76261,76283,76289,76303,76333,76343,76367,76369,76379,76387,76403,76421,76423,76441,76463,76471,76481,76487,76493,76507,76511,76519,76537,76541,76543,76561,76579,76597,76603,76607,76631,76649,76651,76667,76673,76679,76697,76717,76733,76753,76757,76771,76777,76781,76801,76819,76829,76831,76837,76847,76871,76873,76883,76907,76913,76919,76943,76949,76961,76963,76991,77003,77017,77023,77029,77041,77047,77069,77081,77093,77101,77137,77141,77153,77167,77171,77191,77201,77213,77237,77239,77243,77249,77261,77263,77267,77269,77279,77291,77317,77323,77339,77347,77351,77359,77369,77377,77383,77417,77419,77431,77447,77471,77477,77479,77489,77491,77509,77513,77521,77527,77543,77549,77551,77557,77563,77569,77573,77587,77591,77611,77617,77621,77641,77647,77659,77681,77687,77689,77699,77711,77713,77719,77723,77731,77743,77747,77761,77773,77783,77797,77801,77813,77839,77849,77863,77867,77893,77899,77929,77933,77951,77969,77977,77983,77999,78007,78017,78031,78041,78049,78059,78079,78101,78121,78137,78139,78157,78163,78167,78173,78179,78191,78193,78203,78229,78233,78241,78259,78277,78283,78301,78307,78311,78317,78341,78347,78367,78401,78427,78437,78439,78467,78479,78487,78497,78509,78511,78517,78539,78541,78553,78569,78571,78577,78583,78593,78607,78623,78643,78649,78653,78691,78697,78707,78713,78721,78737,78779,78781,78787,78791,78797,78803,78809,78823,78839,78853,78857,78877,78887,78889,78893,78901,78919,78929,78941,78977,78979,78989,79031,79039,79043,79063,79087,79103,79111,79133,79139,79147,79151,79153,79159,79181,79187,79193,79201,79229,79231,79241,79259,79273,79279,79283,79301,79309,79319,79333,79337,79349,79357,79367,79379,79393,79397,79399,79411,79423,79427,79433,79451,79481,79493,79531,79537,79549,79559,79561,79579,79589,79601,79609,79613,79621,79627,79631,79633,79657,79669,79687,79691,79693,79697,79699,79757,79769,79777,79801,79811,79813,79817,79823,79829,79841,79843,79847,79861,79867,79873,79889,79901,79903,79907,79939,79943,79967,79973,79979,79987,79997,79999,80021,80039,80051,80071,80077,80107,80111,80141,80147,80149,80153,80167,80173,80177,80191,80207,80209,80221,80231,80233,80239,80251,80263,80273,80279,80287,80309,80317,80329,80341,80347,80363,80369,80387,80407,80429,80447,80449,80471,80473,80489,80491,80513,80527,80537,80557,80567,80599,80603,80611,80621,80627,80629,80651,80657,80669,80671,80677,80681,80683,80687,80701,80713,80737,80747,80749,80761,80777,80779,80783,80789,80803,80809,80819,80831,80833,80849,80863,80897,80909,80911,80917,80923,80929,80933,80953,80963,80989,81001,81013,81017,81019,81023,81031,81041,81043,81047,81049,81071,81077,81083,81097,81101,81119,81131,81157,81163,81173,81181,81197,81199,81203,81223,81233,81239,81281,81283,81293,81299,81307,81331,81343,81349,81353,81359,81371,81373,81401,81409,81421,81439,81457,81463,81509,81517,81527,81533,81547,81551,81553,81559,81563,81569,81611,81619,81629,81637,81647,81649,81667,81671,81677,81689,81701,81703,81707,81727,81737,81749,81761,81769,81773,81799,81817,81839,81847,81853,81869,81883,81899,81901,81919,81929,81931,81937,81943,81953,81967,81971,81973,82003,82007,82009,82013,82021,82031,82037,82039,82051,82067,82073,82129,82139,82141,82153,82163,82171,82183,82189,82193,82207,82217,82219,82223,82231,82237,82241,82261,82267,82279,82301,82307,82339,82349,82351,82361,82373,82387,82393,82421,82457,82463,82469,82471,82483,82487,82493,82499,82507,82529,82531,82549,82559,82561,82567,82571,82591,82601,82609,82613,82619,82633,82651,82657,82699,82721,82723,82727,82729,82757,82759,82763,82781,82787,82793,82799,82811,82813,82837,82847,82883,82889,82891,82903,82913,82939,82963,82981,82997,83003,83009,83023,83047,83059,83063,83071,83077,83089,83093,83101,83117,83137,83177,83203,83207,83219,83221,83227,83231,83233,83243,83257,83267,83269,83273,83299,83311,83339,83341,83357,83383,83389,83399,83401,83407,83417,83423,83431,83437,83443,83449,83459,83471,83477,83497,83537,83557,83561,83563,83579,83591,83597,83609,83617,83621,83639,83641,83653,83663,83689,83701,83717,83719,83737,83761,83773,83777,83791,83813,83833,83843,83857,83869,83873,83891,83903,83911,83921,83933,83939,83969,83983,83987,84011,84017,84047,84053,84059,84061,84067,84089,84121,84127,84131,84137,84143,84163,84179,84181,84191,84199,84211,84221,84223,84229,84239,84247,84263,84299,84307,84313,84317,84319,84347,84349,84377,84389,84391,84401,84407,84421,84431,84437,84443,84449,84457,84463,84467,84481,84499,84503,84509,84521,84523,84533,84551,84559,84589,84629,84631,84649,84653,84659,84673,84691,84697,84701,84713,84719,84731,84737,84751,84761,84787,84793,84809,84811,84827,84857,84859,84869,84871,84913,84919,84947,84961,84967,84977,84979,84991,85009,85021,85027,85037,85049,85061,85081,85087,85091,85093,85103,85109,85121,85133,85147,85159,85193,85199,85201,85213,85223,85229,85237,85243,85247,85259,85297,85303,85313,85331,85333,85361,85363,85369,85381,85411,85427,85429,85439,85447,85451,85453,85469,85487,85513,85517,85523,85531,85549,85571,85577,85597,85601,85607,85619,85621,85627,85639,85643,85661,85667,85669,85691,85703,85711,85717,85733,85751,85781,85793,85817,85819,85829,85831,85837,85843,85847,85853,85889,85903,85909,85931,85933,85991,85999,86011,86017,86027,86029,86069,86077,86083,86111,86113,86117,86131,86137,86143,86161,86171,86179,86183,86197,86201,86209,86239,86243,86249,86257,86263,86269,86287,86291,86293,86297,86311,86323,86341,86351,86353,86357,86369,86371,86381,86389,86399,86413,86423,86441,86453,86461,86467,86477,86491,86501,86509,86531,86533,86539,86561,86573,86579,86587,86599,86627,86629,86677,86689,86693,86711,86719,86729,86743,86753,86767,86771,86783,86813,86837,86843,86851,86857,86861,86869,86923,86927,86929,86939,86951,86959,86969,86981,86993,87011,87013,87037,87041,87049,87071,87083,87103,87107,87119,87121,87133,87149,87151,87179,87181,87187,87211,87221,87223,87251,87253,87257,87277,87281,87293,87299,87313,87317,87323,87337,87359,87383,87403,87407,87421,87427,87433,87443,87473,87481,87491,87509,87511,87517,87523,87539,87541,87547,87553,87557,87559,87583,87587,87589,87613,87623,87629,87631,87641,87643,87649,87671,87679,87683,87691,87697,87701,87719,87721,87739,87743,87751,87767,87793,87797,87803,87811,87833,87853,87869,87877,87881,87887,87911,87917,87931,87943,87959,87961,87973,87977,87991,88001,88003,88007,88019,88037,88069,88079,88093,88117,88129,88169,88177,88211,88223,88237,88241,88259,88261,88289,88301,88321,88327,88337,88339,88379,88397,88411,88423,88427,88463,88469,88471,88493,88499,88513,88523,88547,88589,88591,88607,88609,88643,88651,88657,88661,88663,88667,88681,88721,88729,88741,88747,88771,88789,88793,88799,88801,88807,88811,88813,88817,88819,88843,88853,88861,88867,88873,88883,88897,88903,88919,88937,88951,88969,88993,88997,89003,89009,89017,89021,89041,89051,89057,89069,89071,89083,89087,89101,89107,89113,89119,89123,89137,89153,89189,89203,89209,89213,89227,89231,89237,89261,89269,89273,89293,89303,89317,89329,89363,89371,89381,89387,89393,89399,89413,89417,89431,89443,89449,89459,89477,89491,89501,89513,89519,89521,89527,89533,89561,89563,89567,89591,89597,89599,89603,89611,89627,89633,89653,89657,89659,89669,89671,89681,89689,89753,89759,89767,89779,89783,89797,89809,89819,89821,89833,89839,89849,89867,89891,89897,89899,89909,89917,89923,89939,89959,89963,89977,89983,89989,90001,90007,90011,90017,90019,90023,90031,90053,90059,90067,90071,90073,90089,90107,90121,90127,90149,90163,90173,90187,90191,90197,90199,90203,90217,90227,90239,90247,90263,90271,90281,90289,90313,90353,90359,90371,90373,90379,90397,90401,90403,90407,90437,90439,90469,90473,90481,90499,90511,90523,90527,90529,90533,90547,90583,90599,90617,90619,90631,90641,90647,90659,90677,90679,90697,90703,90709,90731,90749,90787,90793,90803,90821,90823,90833,90841,90847,90863,90887,90901,90907,90911,90917,90931,90947,90971,90977,90989,90997,91009,91019,91033,91079,91081,91097,91099,91121,91127,91129,91139,91141,91151,91153,91159,91163,91183,91193,91199,91229,91237,91243,91249,91253,91283,91291,91297,91303,91309,91331,91367,91369,91373,91381,91387,91393,91397,91411,91423,91433,91453,91457,91459,91463,91493,91499,91513,91529,91541,91571,91573,91577,91583,91591,91621,91631,91639,91673,91691,91703,91711,91733,91753,91757,91771,91781,91801,91807,91811,91813,91823,91837,91841,91867,91873,91909,91921,91939,91943,91951,91957,91961,91967,91969,91997,92003,92009,92033,92041,92051,92077,92083,92107,92111,92119,92143,92153,92173,92177,92179,92189,92203,92219,92221,92227,92233,92237,92243,92251,92269,92297,92311,92317,92333,92347,92353,92357,92363,92369,92377,92381,92383,92387,92399,92401,92413,92419,92431,92459,92461,92467,92479,92489,92503,92507,92551,92557,92567,92569,92581,92593,92623,92627,92639,92641,92647,92657,92669,92671,92681,92683,92693,92699,92707,92717,92723,92737,92753,92761,92767,92779,92789,92791,92801,92809,92821,92831,92849,92857,92861,92863,92867,92893,92899,92921,92927,92941,92951,92957,92959,92987,92993,93001,93047,93053,93059,93077,93083,93089,93097,93103,93113,93131,93133,93139,93151,93169,93179,93187,93199,93229,93239,93241,93251,93253,93257,93263,93281,93283,93287,93307,93319,93323,93329,93337,93371,93377,93383,93407,93419,93427,93463,93479,93481,93487,93491,93493,93497,93503,93523,93529,93553,93557,93559,93563,93581,93601,93607,93629,93637,93683,93701,93703,93719,93739,93761,93763,93787,93809,93811,93827,93851,93871,93887,93889,93893,93901,93911,93913,93923,93937,93941,93949,93967,93971,93979,93983,93997,94007,94009,94033,94049,94057,94063,94079,94099,94109,94111,94117,94121,94151,94153,94169,94201,94207,94219,94229,94253,94261,94273,94291,94307,94309,94321,94327,94331,94343,94349,94351,94379,94397,94399,94421,94427,94433,94439,94441,94447,94463,94477,94483,94513,94529,94531,94541,94543,94547,94559,94561,94573,94583,94597,94603,94613,94621,94649,94651,94687,94693,94709,94723,94727,94747,94771,94777,94781,94789,94793,94811,94819,94823,94837,94841,94847,94849,94873,94889,94903,94907,94933,94949,94951,94961,94993,94999,95003,95009,95021,95027,95063,95071,95083,95087,95089,95093,95101,95107,95111,95131,95143,95153,95177,95189,95191,95203,95213,95219,95231,95233,95239,95257,95261,95267,95273,95279,95287,95311,95317,95327,95339,95369,95383,95393,95401,95413,95419,95429,95441,95443,95461,95467,95471,95479,95483,95507,95527,95531,95539,95549,95561,95569,95581,95597,95603,95617,95621,95629,95633,95651,95701,95707,95713,95717,95723,95731,95737,95747,95773,95783,95789,95791,95801,95803,95813,95819,95857,95869,95873,95881,95891,95911,95917,95923,95929,95947,95957,95959,95971,95987,95989,96001,96013,96017,96043,96053,96059,96079,96097,96137,96149,96157,96167,96179,96181,96199,96211,96221,96223,96233,96259,96263,96269,96281,96289,96293,96323,96329,96331,96337,96353,96377,96401,96419,96431,96443,96451,96457,96461,96469,96479,96487,96493,96497,96517,96527,96553,96557,96581,96587,96589,96601,96643,96661,96667,96671,96697,96703,96731,96737,96739,96749,96757,96763,96769,96779,96787,96797,96799,96821,96823,96827,96847,96851,96857,96893,96907,96911,96931,96953,96959,96973,96979,96989,96997,97001,97003,97007,97021,97039,97073,97081,97103,97117,97127,97151,97157,97159,97169,97171,97177,97187,97213,97231,97241,97259,97283,97301,97303,97327,97367,97369,97373,97379,97381,97387,97397,97423,97429,97441,97453,97459,97463,97499,97501,97511,97523,97547,97549,97553,97561,97571,97577,97579,97583,97607,97609,97613,97649,97651,97673,97687,97711,97729,97771,97777,97787,97789,97813,97829,97841,97843,97847,97849,97859,97861,97871,97879,97883,97919,97927,97931,97943,97961,97967,97973,97987,98009,98011,98017,98041,98047,98057,98081,98101,98123,98129,98143,98179,98207,98213,98221,98227,98251,98257,98269,98297,98299,98317,98321,98323,98327,98347,98369,98377,98387,98389,98407,98411,98419,98429,98443,98453,98459,98467,98473,98479,98491,98507,98519,98533,98543,98561,98563,98573,98597,98621,98627,98639,98641,98663,98669,98689,98711,98713,98717,98729,98731,98737,98773,98779,98801,98807,98809,98837,98849,98867,98869,98873,98887,98893,98897,98899,98909,98911,98927,98929,98939,98947,98953,98963,98981,98993,98999,99013,99017,99023,99041,99053,99079,99083,99089,99103,99109,99119,99131,99133,99137,99139,99149,99173,99181,99191,99223,99233,99241,99251,99257,99259,99277,99289,99317,99347,99349,99367,99371,99377,99391,99397,99401,99409,99431,99439,99469,99487,99497,99523,99527,99529,99551,99559,99563,99571,99577,99581,99607,99611,99623,99643,99661,99667,99679,99689,99707,99709,99713,99719,99721,99733,99761,99767,99787,99793,99809,99817,99823,99829,99833,99839,99859,99871,99877,99881,99901,99907,99923,99929,99961,99971,99989,99991,100003]
prime = [False for i in xrange(110000)]
for a in p:
prime[a] = True
ne = range(100100)
t= 999999
for i in xrange(100100-1, 0, -1):
if not prime[i]:
ne[i] = t
else:
t = i
ne[i] = t
#print prime[4]
#print 'ac'
for i in xrange(n):
for j in xrange(m):
#print prime[g[i][j]]
if prime[g[i][j]]:
g[i][j] = 0
else:
g[i][j] = ne[g[i][j]] - g[i][j]
#print g
#print 'wa'
ans = 9999999
for i in xrange(n):
temp = sum(g[i])
if temp < ans:
ans = temp
if ans:
for j in xrange(m):
temp = 0
for i in xrange(n):
temp += g[i][j]
if temp > ans:
break
if temp < ans:
ans = temp
#print ','.join([str(a) for a in p])
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 | m, n = map(int, input().split(' '))
X = list(zip(*[map(int,input().split()) for i in [True] * m]))
from bisect import bisect_left as bsl
MaxPrime = 100004
def vec_primes(n): # See exercise 35.
""" Returns a list of primes < n """
sieve = [True] * (n//2)
for i in range(3,int(n**0.5)+1,2):
if sieve[i//2]:
sieve[i*i//2::i] = [False] * ((n-i*i-1)//(2*i)+1)
return [2] + [2*i+1 for i in range(1,n//2) if sieve[i]]
VecP = vec_primes(MaxPrime) # Vector de números primos < 500
sum2P = [VecP[bsl(VecP, i)]-i for i in range(1, 10**5+1)] # Incremento de un número para ser primo
XT = [[sum2P[j-1] for j in k] for k in X]
minCol = min(map(sum, XT))
minRow = min(map(sum, zip(*XT)))
print(min(minCol, minRow)) | 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<long long> v(1e5 + 1, -1);
bool isprime(int t) {
if (t == 2) return true;
if (!(t % 2)) return false;
for (int x = 3; x * x <= t; x += 2) {
if (!(t % x)) return false;
}
return true;
}
int main() {
int a, mn = INT_MAX, s;
cin >> a >> s;
v[1] = 1;
vector<int> row(a + 1, 0), col(s + 1, 0);
for (int x = 1; x < a + 1; x++) {
for (int z = 1; z < s + 1; z++) {
int t, c = 0, y;
cin >> t;
y = t;
if (v[t] == -1) {
y = t;
while (!isprime(t)) t++, c++;
v[y] = c;
}
row[x] += v[y], col[z] += v[y];
}
}
for (int x = 1; x < a + 1; x++) mn = min(mn, row[x]);
for (int x = 1; x < s + 1; x++) mn = min(mn, col[x]);
cout << mn;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #atal 2020.1, feito baseado nas noocoes vistas, conceito do crivuuuuus facilment eencontrado.
import sys
import math
limit = 100025
minhaListadePrimos = [True for i in range(limit + 1)]
primosSeguintestsss = [0 for i in range(200000)]
def crivandu():
minhaListadePrimos[0] = minhaListadePrimos[1] = False
for i in range(2, int(math.sqrt(limit))):
if minhaListadePrimos[i]:
j = 2
while i * j <= limit:
minhaListadePrimos[i*j] = False
j += 1
def get_primosSeguintestsss():
for i in range(limit - 1, -1, -1):
if minhaListadePrimos[i]:
primosSeguintestsss[i] = 0
else:
primosSeguintestsss[i] = 1 + primosSeguintestsss[i+1]
crivandu()
get_primosSeguintestsss()
dados = input().split(' ')
n, m = (int(dados[0]), int(dados[1]))
matrix = []
for i in range(0, n):
value = input()
matrix.append(value.split(' '))
best = sys.maxsize
for index_row in range(n):
best_row = 0
for index_column in range(m):
num = int(matrix[index_row][index_column])
best_row += primosSeguintestsss[num]
if best_row < best:
best = best_row
for index_column in range(m):
best_column = 0
for index_row in range(n):
num = int(matrix[index_row][index_column])
best_column += primosSeguintestsss[num]
if best_column < best:
best = best_column
print(best)
| 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 sys import stdin, gettrace
import bisect,sys
if not gettrace():
def input():
return next(stdin)[:-1]
# def input():
# return stdin.buffer.readline()
def IP(): # to take tuple as input
return map(int,stdin.readline().split())
def L(): # to take list as input
return list(map(int,stdin.readline().split()))
def sieve():
li=[True]*1000001
li[0],li[1]=False,False
for i in range(2,len(li),1):
if li[i]==True:
for j in range(i*i,len(li),i):
li[j]=False
prime=[]
for i in range(1000001):
if li[i]==True:
prime.append(i)
return prime
def main():
def solve():
n,m=map(int,stdin.readline().split())
l=[]
for i in range(n):
temp=list(map(int,stdin.readline().split()))
l.append(temp)
prime=sieve()
changes=sys.maxsize
for i in range(n):
c=0
for j in range(m):
ind=bisect.bisect_left(prime,l[i][j])
c+=prime[ind]-l[i][j]
changes=min(changes,c)
for j in range(m):
c=0
for i in range(n):
ind=bisect.bisect_left(prime,l[i][j])
c+=prime[ind]-l[i][j]
changes=min(changes,c)
print(changes)
return
solve()
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 gcd(int a, int b) {
if (b == 0) return a;
return gcd(b, a % b);
}
vector<long long int> adj[100001];
long long int vist[10001];
void dfs(long long int node) {
vist[node] = 1;
for (long long int child : adj[node])
if (!vist[child]) dfs(child);
}
vector<long long int> primes;
bool isPrime[1000001];
void sieve() {
isPrime[0] = isPrime[1] = true;
for (int i = 2; i < 1000001; i++) {
if (!isPrime[i]) {
primes.push_back(i);
for (long long int j = 2 * i; j < 1000001; j += i) isPrime[j] = true;
}
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
sieve();
{
long long int c = 0, ans = INT_MAX;
long long int n, m;
cin >> n >> m;
long long int a[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = 0; i < n; i++) {
c = 0;
for (int j = 0; j < m; j++) {
if (isPrime[a[i][j]]) {
auto it = lower_bound(primes.begin(), primes.end(), a[i][j]);
c += (*it) - a[i][j];
}
}
ans = min(ans, c);
if (ans == 0) break;
}
for (int i = 0; i < m; i++) {
c = 0;
for (int j = 0; j < n; j++) {
if (isPrime[a[j][i]]) {
auto it = lower_bound(primes.begin(), primes.end(), a[j][i]);
c += (*it) - a[j][i];
}
}
ans = min(ans, c);
if (ans == 0) break;
}
cout << ans << endl;
}
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 600;
long long n, m, a, b, ans, arr[2][N];
vector<long long> prms;
void build() {
const int LIM = 1e6;
bool num[LIM] = {};
for (long long i = 2; i < LIM; ++i) {
if (num[i]) continue;
prms.push_back(i);
for (long long j = i * i; j < LIM; j += i) num[j] = 1;
}
}
int get(long long x) {
long long i = upper_bound(prms.begin(), prms.end(), x) - prms.begin();
if (i > 0 && prms[i - 1] == x) return 0;
return (prms[i] - x);
}
int main() {
cin.sync_with_stdio(0);
build();
cin >> n >> m;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> a;
b = get(a);
arr[0][i] += b;
arr[1][j] += b;
}
}
ans = arr[0][0];
for (int i = 0; i < n; ++i) ans = min(ans, arr[0][i]);
for (int j = 0; j < m; ++j) ans = min(ans, arr[1][j]);
printf("%lld", ans);
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
struct cmpStruct {
bool operator()(int const& lhs, int const& rhs) const { return lhs > rhs; }
};
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y) {
if (y & 1) res = (res * x) % 1000000009;
y = y / 2, x = (x * x) % 1000000009;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
;
vector<int> lp(1000000, 0);
vector<bool> mark(1000000, true);
lp[1] = 2;
int last = 2;
for (int i = 2; i < 1000000; i++) {
if (mark[i]) {
for (int j = i * 2; j < 1000000; j += i) {
mark[j] = false;
}
lp[i] = i;
last = i;
}
}
int prev = lp[last];
for (int i = last - 1; i >= 2; i--) {
if (lp[i] == 0)
lp[i] = prev;
else
prev = lp[i];
}
int n, m;
cin >> n >> m;
int arr[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
long long int cnt = LLONG_MAX, curr = 0;
for (int i = 0; i < n; i++) {
curr = 0;
for (int j = 0; j < m; j++) {
curr += (lp[arr[i][j]] - arr[i][j]);
}
cnt = min(cnt, curr);
}
for (int i = 0; i < m; i++) {
curr = 0;
for (int j = 0; j < n; j++) {
curr += (lp[arr[j][i]] - arr[j][i]);
}
cnt = min(cnt, curr);
}
cout << cnt << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int inf = 0x7FFFFFFF;
const double eps = 1e-9L;
const double pi = acos(-1.0);
using namespace std;
int prime[100100 + 10], pf[100100 + 10];
int row[520], col[520], con[100100 + 5];
void make() {
int count = 0;
prime[count++] = 2;
for (int i = 3; i < 100100; i += 2) {
if (pf[i] == 0) {
prime[count++] = i;
for (int j = i; j < 100100; j += i) {
pf[j] = 1;
}
}
}
count = 0;
for (int i = 0; i <= 100000 + 3; i++) {
if (prime[count] < i) count++;
con[i] = prime[count] - i;
}
}
int main() {
make();
int n, m;
cin >> n >> m;
int mn = inf;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int a;
cin >> a;
col[i] += con[a];
row[j] += con[a];
}
for (int i = 0; i < n; i++) mn = min(mn, col[i]);
for (int j = 0; j < m; j++) mn = min(mn, row[j]);
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 | import java.util.Scanner;
public class PrimeMatrix {
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
boolean prime[] = new boolean[100004];
for (int i = 2; i < 50003; i++) {
for (int j = 2; i * j < 100004; j++) {
prime[(i * j) - 1] = true;
}
}
prime[0] = true;
prime[1] = false;
int n = in.nextInt(), m = in.nextInt(), sum = 0, sum2 = 0, min = Integer.MAX_VALUE, x;
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
x = in.nextInt();
while (prime[x - 1]) {
sum++;
x++;
a[i][j]++;
}
}
min = Math.min(min, sum);
}
for (int i = 0; i < m; i++) {
sum2 = 0;
for (int j = 0; j < n; j++) {
sum2 += a[j][i];
}
min = Math.min(min, sum2);
}
System.out.println(min);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | 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.util.ArrayList;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*
* @author El-Bishoy
*/
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);
D2B271 solver = new D2B271();
solver.solve(1, in, out);
out.close();
}
static class D2B271 {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n = in.nextInt(), m = in.nextInt();
int MAX = 100003;
int[][] matrix = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = in.nextInt();
}
}
// first calculate each next prime and add the cost instead of the origimal element
// second loop throw all cols and rows and get the min cost
boolean[] isPrime = MathUtils.Mathematics.sieveOfEratosthenes(MAX);
ArrayList<Integer> primes = toArrayLis(isPrime);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int num = matrix[i][j];
if (isPrime[num]) {
matrix[i][j] = 0;
continue;
}
int nextPrime = primes.get(BS.upper_bound(primes, num));
matrix[i][j] = nextPrime - num;
}
}
int min = FindMin(matrix);
out.println(min);
}
private int FindMin(int[][] matrix) {
// go throw all rows
int min = Integer.MAX_VALUE;
for (int i = 0; i < matrix.length; i++) {
int x = 0;
for (int j = 0; j < matrix[0].length; j++) {
x += matrix[i][j];
}
min = Math.min(min, x);
}
for (int i = 0; i < matrix[0].length; i++) {
int x = 0;
for (int j = 0; j < matrix.length; j++) {
x += matrix[j][i];
}
min = Math.min(min, x);
}
return min;
}
private ArrayList<Integer> toArrayLis(boolean[] isPrime) {
ArrayList<Integer> ll = new ArrayList<>();
for (int i = 0; i < isPrime.length; i++) {
if (isPrime[i])
ll.add(i);
}
//add the next prime of 10e5 is 10e5 + 3
ll.add((int) (10e5 + 3));
return ll;
}
}
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);
}
}
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 println(int i) {
writer.println(i);
}
}
static class MathUtils {
public static class Mathematics {
public static boolean[] sieveOfEratosthenes(int n) {
boolean[] prime = new boolean[n + 1];
Arrays.fill(prime, true);
prime[0] = prime[1] = false;
for (int p = 2; p * p <= n; p++) {
// If prime[p] is not changed, then it is a prime
if (prime[p]) {
// Update all multiples of p
for (int i = p * p; i <= n; i += p)
prime[i] = false;
}
}
return prime;
}
}
}
static class BS {
public static int upper_bound(ArrayList<Integer> arr, int val) {
int lo = 0;
int hi = arr.size() - 1;
while (lo < hi) {
int mid = lo + ((hi - lo) / 2);
if (arr.get(mid) == val) {
return mid;
} else if (arr.get(mid) > val) {
hi = mid;
} else lo = mid + 1;
}
if (arr.get(lo) >= val) return lo;
else return -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 | def generate_primes(n):
primes, sieve = {}, [True] * int(n+1)
for p in range(2, n + 1):
if sieve[p]:
primes[p] = p
for i in range(p * p, n + 1, p):
sieve[i] = False
return primes
def distance_prime(n, primes):
if primes.get(n):
return 0
m = n + 1
while not primes.get(m):
m += 1
return m - n
if __name__ == "__main__":
primes_dict = generate_primes(100100)
x, y = [int(x) for x in input().split(' ')]
columns = []
minimumOp = 10000000
for i in range(x):
line = [distance_prime(int(x), primes_dict) for x in input().split(' ')]
sumX = 0
if i == 0:
columns = line
for j in range(len(line)):
sumX += line[j]
if i != 0:
columns[j] += line[j]
if sumX < minimumOp:
minimumOp = sumX
minColumn = min(columns)
if minColumn < minimumOp:
minimumOp = minColumn
print(minimumOp)
| 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 | MOD = 1000000007
ii = lambda: int(input())
si = lambda: input()
dgl = lambda: list(map(int, input()))
f = lambda: map(int, input().split())
il = lambda: list(map(int, input().split()))
ls = lambda: list(input())
from bisect import *
l = [1]*(10**5+100)
for i in range(2,int((10**5+100)**0.5)+1):
for j in range(i*i, 10**5+100, i):
l[j] = 0
lprime = [i for i in range(2, 10**5+100) if l[i] == 1]
n,m=f()
l=[]
for _ in range(n):
l.append(il())
for i in range(n):
for j in range(m):
l[i][j]=lprime[bisect_left(lprime,l[i][j])]-l[i][j]
mn=10**9
for i in range(n):
mn=min(mn,sum(j for j in l[i]))
for i in range(m):
mn=min(mn,sum(l[j][i] for j in range(n)))
print(mn) | 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;
using namespace std::chrono;
static const int N = 200000;
void getSOE(vector<int>& p) {
vector<bool> v(N + 1, true);
v[0] = v[1] = false;
for (int i = 2; i * i <= N; ++i) {
if (!v[i]) continue;
for (int j = i * i; j <= N; j += i) {
v[j] = false;
}
}
int lastprime = INT_MAX;
for (int i = N; i >= 0; --i) {
if (v[i]) {
lastprime = i;
}
if (lastprime != INT_MAX) p[i] = lastprime;
}
return;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> p(N + 1);
getSOE(p);
vector<vector<int>> d(n, vector<int>(m));
int eij;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> eij;
assert(eij < (N + 1));
d[i][j] = p[eij] - eij;
}
}
vector<uint64_t> rsum(n), csum(m);
int i = 0;
for (const auto& ee : d) rsum[i++] = accumulate(ee.begin(), ee.end(), 0);
for (int i = 0; i < m; ++i) {
uint64_t tsum = 0;
for (int j = 0; j < n; ++j) {
tsum += d[j][i];
}
csum[i] = tsum;
}
uint64_t ans = min(*(min_element(rsum.begin(), rsum.end())),
*(min_element(csum.begin(), csum.end())));
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 |
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class B {
static BufferedReader in;
static StringTokenizer st;
static PrintWriter out;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
st = new StringTokenizer(in.readLine());
}
return st.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
public static void main(String[] args) throws IOException {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(
System.out)));
int INF = (int) 1e5 + 100;
boolean[] isPrime = new boolean[INF + 1];
Arrays.fill(isPrime, true);
isPrime[1] = false;
for (int i = 2; i * i < INF; i++) {
if (isPrime[i]) {
for (int j = i * i; j < INF; j += i) {
isPrime[j] = false;
}
}
}
int n = nextInt();
int m = nextInt();
int[] row = new int[n + 1];
int[] col = new int[m + 1];
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
int a = nextInt();
if (!isPrime[a]) {
for (int k = a + 1; k < INF; k++) {
if (isPrime[k]) {
row[i] += k - a;
col[j] += k - a;
break;
}
}
}
}
}
int minRow = Integer.MAX_VALUE;
int minCol = Integer.MAX_VALUE;
for (int i = 1; i <= n; i++) {
minRow = Math.min(minRow, row[i]);
}
for (int i = 1; i <= m; i++) {
minCol = Math.min(minCol, col[i]);
}
out.print(Math.min(minRow, minCol));
out.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 | n,m=map(int,input().split())
limit=int(1e5+2)
l=[1,1]+[0]*limit
for i in range(2,limit):
l[i*i::i]=[1]*((limit-i*i)//i+1)
for i in range(limit,-1,-1):
l[i]*=l[i+1]+1
s=[[l[j] for j in map(int,input().split())] for _ in ' '*n]
print(min(min(sum(i) for i in s),min(sum(i) for i in zip(*s)))) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | row, col = [int(x) for x in raw_input().split()]
matrix = [[int(x) for x in raw_input().split()] for _ in range(row)]
MaxN = 100000+10
u=[1 for i in range(MaxN)]
u[0] = u[1] = 0
for i in range(2,MaxN):
if not u[i]:
continue
j = i
while True:
j += i
if j >= MaxN:
break
u[j] = 0
i=MaxN-2
while i>0:
u[i]=i if u[i] else u[i+1]
i-=1
for i in xrange(row):
for j in xrange(col):
matrix[i][j] = u[matrix[i][j]] - matrix[i][j]
row_ans = min([sum([matrix[i][j] for j in range(col)]) for i in range(row)])
col_ans = min([sum([matrix[i][j] for i in range(row)]) for j in range(col)])
print min(row_ans,col_ans)
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
vector<long long int> a(900005, 1);
vector<long long int> v;
void sieve(long long int nn) {
for (long long int i = 2; i < nn; i++) {
if (a[i]) {
v.push_back(i);
for (long long int j = 2; j * i < nn; j++) a[i * j] = 0;
}
}
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
a[1] = 0;
sieve(200005);
long long int n, m;
cin >> n >> m;
vector<vector<long long int>> ma(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 >> ma[i][j];
}
}
long long int s = 0, mn = INT_MAX;
for (long long int i = 0; i < n; i++) {
s = 0;
for (long long int j = 0; j < m; j++) {
s += (*lower_bound(v.begin(), v.end(), ma[i][j])) - ma[i][j];
}
mn = min(mn, s);
}
for (long long int j = 0; j < m; j++) {
s = 0;
for (long long int i = 0; i < n; i++) {
s += (*lower_bound(v.begin(), v.end(), ma[i][j])) - ma[i][j];
}
mn = min(mn, s);
}
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 | #include <bits/stdc++.h>
using namespace std;
const char nl = '\n';
const char gg = ' ';
const int M = 1e5 + 5;
bool mark[M];
vector<int> prime;
void sieve() {
int i, j, n;
for (i = 3; i * i <= M; i += 2) {
if (!mark[i]) {
for (j = i * i; j < M; j += i + i) mark[j] = true;
}
}
prime.push_back(2);
for (i = 3; i <= 100003; i += 2) {
if (!mark[i]) prime.push_back(i);
}
}
void solve() {
int n, m, i, j, idx, dif, mx = 0, ans = INT_MAX, sm = 0;
cin >> n >> m;
int ar[n][m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> ar[i][j];
mx = max(mx, ar[i][j]);
}
}
idx = upper_bound(prime.begin(), prime.end(), mx) - prime.begin();
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
dif = *lower_bound(prime.begin(), prime.begin() + idx, ar[i][j]);
sm += (dif - ar[i][j]);
}
ans = min(ans, sm);
if (sm == 0) break;
sm = 0;
}
sm = 0;
for (j = 0; j < m; j++) {
for (i = 0; i < n; i++) {
dif = *lower_bound(prime.begin(), prime.begin() + idx, ar[i][j]);
sm += (dif - ar[i][j]);
}
ans = min(ans, sm);
if (sm == 0) break;
sm = 0;
}
cout << ans << nl;
}
int main() {
ios_base::sync_with_stdio(false), cin.tie(0);
;
sieve();
int t = 1;
while (t--) solve();
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 {
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 = 0;
int[] factors = new int[n + m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (j == 0 || matrix[i][j] != matrix[i][j - 1]) {
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 | def crivo(limit):
primes = [True] * limit
primes[0] = False
primes[1] = False
for i in xrange(2, limit):
if (primes[i]):
for j in xrange(i * 2, limit, i):
primes[j] = False
return primes
primes = crivo(10**5 + 100)
n, m = map(int, raw_input().split())
matrix = []
for i in xrange(n):
matrix.append(map(int, raw_input().split()))
attempts = []
dic = {}
for i in xrange(n):
moves = 0
for j in xrange(m):
elem = matrix[i][j]
bckp = matrix[i][j]
count = 0
if (bckp in dic):
count = dic[bckp]
else:
while (not primes[elem]):
elem += 1
count += 1
dic[bckp] = count
moves += count
attempts.append(moves)
for i in xrange(m):
moves = 0
for j in xrange(n):
elem = matrix[j][i]
bckp = matrix[j][i]
count = 0
if (bckp in dic):
count = dic[bckp]
else:
while (not primes[elem]):
elem += 1
count += 1
dic[bckp] = count
moves += count
attempts.append(moves)
print min(attempts)
| 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 | #!/usr/bin/env python
primes = [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]
cache={}
prev = 1
for p in primes:
for j in xrange(prev, p+1):
cache[j] = p
prev=p+1
def find_prime_equal_or_larger(c):
return cache[c]
n,m = map(int, raw_input().split())
matrix = []
sol = []
for row in xrange(n):
matrix.append(map(int, raw_input().split()))
sol.append([0]*m)
for row in xrange(n):
for col in xrange(m):
sol[row][col] = find_prime_equal_or_larger(matrix[row][col]) - matrix[row][col]
answer = sum(sol[0])
for row in xrange(n):
answer = min(sum(sol[row]), answer)
for col in xrange(m):
s=0
for row in xrange(n):
s+=sol[row][col]
answer = min(answer, s)
#print matrix
#print sol
print answer
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
public class B{
static List<Integer> primes = new ArrayList();
static int[] p = new int[110001];
public static void sieve()
{
for(int i=2;i<=110000;i++)
{
if(p[i] == 0) {
for(int j=2;i*j<=110000;j++)
{
p[i*j] = 1;
}
}
}
for(int i=2;i<=110000;i++)if(p[i]==0)primes.add(i);
}
public static int find(int key)
{
int left = -1; //bad
int right = primes.size();//good
while(left+1<right)
{
int mid = (left+right)/2;
int my = primes.get(mid);
if(my>=key)right = mid;
else left = mid;
}
return primes.get(right);
}
public static void main(String[] args)
{
FastScanner fs = new FastScanner();
PrintWriter out = new PrintWriter(System.out);
sieve();
int n = fs.nextInt(); int m = fs.nextInt();
int[][] arr = new int[n][m];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
arr[i][j] = fs.nextInt();
}
}
int rowtotal =Integer.MAX_VALUE ; int coltotal = Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
int cur = 0;
for(int j=0;j<m;j++)
{
int my = arr[i][j];
int best = find(my);
cur+=best-my;
}
// out.println("Row "+i+": "+cur);
rowtotal = Math.min(cur,rowtotal);
}
for(int i=0;i<m;i++)
{
int cur = 0;
for(int j=0;j<n;j++)
{
int my = arr[j][i];
int best = find(my);
cur+=best-my;
}
// out.println("Col "+i+": "+cur);
coltotal = Math.min(cur,coltotal);
}
out.println(Math.min(rowtotal,coltotal));
out.close();
}
static class FastScanner {
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st=new StringTokenizer("");
String next() {
while (!st.hasMoreTokens())
try {
st=new StringTokenizer(br.readLine());
} catch (IOException e) {
e.printStackTrace();
}
return st.nextToken();
}
int nextInt() {
return Integer.parseInt(next());
}
int[] readArray(int n) {
int[] a=new int[n];
for (int i=0; i<n; i++) a[i]=nextInt();
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
public static int[] sort(int[] arr)
{
List<Integer> temp = new ArrayList();
for(int i:arr)temp.add(i);
Collections.sort(temp);
int start = 0;
for(int i:temp)arr[start++]=i;
return arr;
}
} | 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.*;
public class Sample {
static int MAX = (int)(1e6+2);
static int MOD=(int)1e9+7;
static int countt = 0;
public static void main(String[] args) throws Exception{
// TODO Auto-generated method stub
//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner input = new Scanner(System.in);
ArrayList<Integer>list = new ArrayList<>();
boolean seive[] = new boolean[MAX];
for(int i = 2;i*i<MAX;i++) {
if(!seive[i]) {
for(int j = i*i;j<MAX;j+=i) {
seive[j] = true;
}
}
}
for(int i =2;i<MAX;i++) {
if(!seive[i])list.add(i);
}
int n = input.nextInt();
int m = input.nextInt();
int arr[][] = new int[n][m];
for(int i=0;i<n;i++) {
for(int j =0;j<m;j++) {
arr[i][j] = input.nextInt();
int min = getMin(list,arr[i][j]);
arr[i][j] = Math.abs(min-arr[i][j]);
}
}
long rowMin = Long.MAX_VALUE;
long colMin = Long.MAX_VALUE;
for(int i = 0;i<n;i++) {
long rowSum =0;
for(int j =0;j<m;j++) {
rowSum+=arr[i][j];
}
rowMin = Math.min(rowMin, rowSum);
}
for(int i = 0;i<m;i++) {
long colSum =0;
for(int j =0;j<n;j++) {
colSum+=arr[j][i];
}
colMin = Math.min(colMin, colSum);
}
System.out.println(Math.min(colMin, rowMin));
}
public static int getMin(ArrayList<Integer>list,int val) {
int min = 0;
int l = 0;
int r = list.size()-1;
while(l<=r) {
int mid = (l+r)/2;
if(list.get(mid)>=val) {
min = list.get(mid);
r = mid-1;
}else l = mid+1;
}
return min;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.math.BigInteger;
import java.util.*;
/**
*
* @author Saju
*
*/
public class Main {
private static int dx[] = { -1, 0, 1, 0 };
private static int dy[] = { 0, -1, 0, 1 };
private static final long INF = (long) (1e15);
private static final double EPSILON = 1e-10;
private static final int MAX = 10000007;
public static void main(String[] args) {
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
/*
*/
int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = in.nextInt();
}
}
sieve();
long minR = Long.MAX_VALUE;
long minC = Long.MAX_VALUE;
long ans = 0;
for (int i = 0; i < n; i++) {
ans = 0;
for (int j = 0; j < m; j++) {
if (Collections.binarySearch(list,a[i][j])< 0) {
ans +=(long) abs(list.get((-1 * Collections.binarySearch(list, a[i][j])) - 1) - a[i][j]);
}
}
if (ans < minR){
minR = ans;
}
}
for (int i = 0; i < m; i++) {
ans = 0;
for (int j = 0; j < n; j++) {
if (Collections.binarySearch(list, a[j][i])< 0) {
ans +=(long) abs(list.get((-1 * Collections.binarySearch(list, a[j][i])) - 1) - a[j][i]);
}
}
if (ans < minC){
minC = ans;
}
}
System.out.println(min(minR,minC));
out.flush();
out.close();
System.exit(0);
}
static List<Integer> list = new ArrayList<Integer>();
static boolean[] primes = new boolean[MAX];
public static void sieve() {
primes[0] = true;
primes[1] = true;
for (int i = 2; i * i < primes.length; i++) {
if (!primes[i]) {
for (int j = i * i; j < primes.length; j += i) {
primes[j] = true;
}
}
}
for (int i = 2; i < MAX; ++i){
if (!primes[i]) {
list.add(i);
}
}
}
private static class Line{
Point A;
Point B;
Line(Point A, Point B){
this.A = A;
this.B = B;
}
public boolean equals(Object obj) {
if (!(obj instanceof Line)){
return false;
}
Line line = (Line)obj;
if (line.A.equals(this.A) && line.B.equals(this.B)){
return true;
}
if (line.A.equals(this.B) && line.B.equals(this.A)){
return true;
}
return false;
}
}
private static class Point {
long x;
long y;
Point(long x, long y){
this.x = x;
this.y = y;
}
@Override
public boolean equals(Object obj) {
Point ob = (Point) obj;
if(this.x == ob.x && this.y == ob.y){
return true;
}
return false;
}
}
private static int log(int x, int base) {
return (int) (Math.log(x) / Math.log(base));
}
private static long max(long a, long b) {
if (a >= b) {
return a;
}
return b;
}
private static long abs(long a) {
if (a < 0) {
return -a;
}
return a;
}
private static int abs(int a) {
if (a < 0) {
return -a;
}
return a;
}
private static int max(int a, int b) {
if (a >= b) {
return a;
}
return b;
}
private static long min(long a, long b) {
if (a <= b) {
return a;
}
return b;
}
private static long gcd(long a, long b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
private static int gcd(int a, int b) {
if (b == 0) {
return a;
}
return gcd(b, a % b);
}
private static long bigMod(long n, long k, long m) {
long ans = 1;
while (k > 0) {
if ((k & 1) == 1) {
ans = (ans * n) % m;
}
n = (n * n) % m;
k >>= 1;
}
return ans;
}
/*
* Returns an iterator pointing to the first element in the range [first,
* last] which does not compare less than val.
*
*/
private static int lowerBoundNew(long[] arr, long num) {
int start = 0;
int end = arr.length - 1;
int index = 0;
int len = arr.length;
int mid = 0;
while (true) {
if (start > end) {
break;
}
mid = (start + end) / 2;
if (arr[mid] > num) {
end = mid - 1;
} else if (arr[mid] < num) {
start = mid + 1;
} else {
while (mid >= 0 && arr[mid] == num) {
mid--;
}
return mid + 1;
}
}
if (arr[mid] < num) {
return mid + 1;
}
return mid;
}
/*
* upper_bound() is a standard library function in C++ defined in the header
* . It returns an iterator pointing to the first element in the range
* [first, last) that is greater than value, or last if no such element is
* found
*
*/
private static int upperBoundNew(long[] arr, long num) {
int start = 0;
int end = arr.length - 1;
int index = 0;
int len = arr.length;
int mid = 0;
while (true) {
if (start > end) {
break;
}
mid = (start + end) / 2;
if (arr[mid] > num) {
end = mid - 1;
} else if (arr[mid] < num) {
start = mid + 1;
} else {
while (mid < len && arr[mid] == num) {
mid++;
}
if (mid == len - 1 && arr[mid] == num) {
return mid + 1;
} else {
return mid;
}
}
}
if (arr[mid] < num) {
return mid + 1;
}
return mid;
}
private static class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream));
tokenizer = null;
}
public String next() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (IOException e) {
return null;
}
return tokenizer.nextToken();
}
public String nextLine() {
String line = null;
try {
tokenizer = null;
line = reader.readLine();
} catch (IOException e) {
throw new RuntimeException(e);
}
return line;
}
public int nextInt() {
return Integer.parseInt(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public long nextLong() {
return Long.parseLong(next());
}
public boolean hasNext() {
try {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(reader.readLine());
}
} catch (Exception e) {
return false;
}
return true;
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | a,b=map(int,input().split())
c=100030
f=[0]*c
f[1]=1
for i in range(2,c):
if f[i]==0:
for j in range(i+i,c,i):
f[j]=1
t=0
for i in range(c-1,0,-1):
if f[i]==0:
t=i
f[i]=t
l=[[int(j) for j in input().split()] for i in range(a)]
for i in range(a):
for j in range(b):
t=l[i][j]
l[i][j]=f[t]-l[i][j]
mx=10**10
for i in range(a):
mx=min(mx,sum(l[i]))
for j in range(b):
t=0
for i in range(a):
t+=l[i][j]
mx=min(mx,t)
print(mx)
| 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() {
vector<int> prime(100009, 1);
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= 100009; ++i) {
if (prime[i]) {
for (int j = i * 2; j <= 100009; j += i) {
prime[j] = 0;
}
}
}
int l = 0;
for (int i = 100009; i >= 1; --i) {
if (prime[i] == 0) {
prime[i] = l;
}
if (prime[i] == 1) {
l = i;
}
}
int n, m;
cin >> n >> m;
int arr[501][501];
int r[501] = {0}, c[501] = {0};
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
cin >> arr[i][j];
if (prime[arr[i][j]] == 0) {
continue;
}
if (prime[arr[i][j]] != 1) {
r[i] += prime[arr[i][j]] - arr[i][j];
c[j] += prime[arr[i][j]] - arr[i][j];
}
}
}
cout << min(*min_element(r, r + n), *min_element(c, c + m)) << 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 L {
static BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st=new StringTokenizer("");
static public String next() {
while (st == null || !st.hasMoreTokens()) {
try {
st = new StringTokenizer(br.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return st.nextToken();
}
/*static boolean isPalindrome(char[]a){
for(int i=0,j=a.length-1;i<a.length;i++,j--)
if(a[i]!=a[j])return false;
return true;
}*/
//static long gcd(long a,long b){return b==0?a:gcd(b,a%b);}
//static long max(long a,long b){return a>b?a:b;}
static int min(int a,int b){return a>=b?b:a;}
//static int mod=(int)1e9+7;
static boolean isprime[]=new boolean[100015];
static void sieve(){
Arrays.fill(isprime,true);
boolean visited[]=new boolean[100015];
isprime[0]=false;
isprime[1]=false;
for(int i=2;i*i<=100015;i++){
visited[i]=true;
for(int j=i*i;j<100015;j+=i){
if(!visited[j]){
visited[j]=true;
isprime[j]=false;
}
}
}
}
public static void main(String[]args)throws IOException{
PrintWriter op =new PrintWriter(System.out);
int n=Integer.parseInt(next());
int m=Integer.parseInt(next());
int[][] a=new int[n][m];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
a[i][j]=Integer.parseInt(next());
int ans=Integer.MAX_VALUE;
sieve();
for(int i=0;i<n;i++){
int count=0;
for(int j=0;j<m;j++){
int x=a[i][j];
if(!isprime[x]){
while(!isprime[x])x++;
}
count+=x-a[i][j];
}
ans=min(ans,count);
}
for(int i=0;i<m;i++){
int count=0;
for(int j=0;j<n;j++){
int x=a[j][i];
if(!isprime[x]){
while(!isprime[x])x++;
}
count+=x-a[j][i];
}
ans=min(ans,count);
}
op.println(ans);
op.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 | #include <bits/stdc++.h>
using namespace std;
vector<int> P;
int t1;
bool M[1000005];
int A[100005];
int rowsum[600], colsum[600];
int main() {
P.push_back(2);
for (int i = 3; i <= 1000; i += 2)
for (int j = i * i; j <= 1e6; j += i) M[j] = 1;
for (int i = 3; i <= 1e6; i += 2) {
if (!M[i]) P.push_back(i);
}
for (int i = 0; i <= 100000; i++)
A[i] = *(lower_bound(P.begin(), P.end(), i)) - i;
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &t1);
rowsum[i] += A[t1];
colsum[j] += A[t1];
}
int ans = 1e9;
for (int i = 0; i < n; i++) ans = min(ans, rowsum[i]);
for (int i = 0; i < m; i++) ans = min(ans, colsum[i]);
cout << ans << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long fact(long int w) {
long int k, p = 0, l = 0, r = w;
if (w == 1)
return 1;
else {
while (p != 1) {
for (k = 2; k <= pow(w, .5); k++) {
if (w % k == 0) {
l = 1;
k = pow(w, .5);
}
}
if (l == 0)
p = 1;
else {
l = 0;
w++;
}
}
return w - r;
}
}
long long int isprime(long long int n) {
if (n <= 1) return 0;
if (n <= 3) return 1;
if (n % 2 == 0 || n % 3 == 0) return 0;
for (long long int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0) return 0;
return 1;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long int n, m, i, j, g = 0, h = -1;
;
cin >> n >> m;
long int a[n][m], b[n][m], d[n][m], c[n + m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
b[i][j] = a[i][j];
while (isprime(a[i][j]) == 0) {
a[i][j]++;
}
d[i][j] = a[i][j] - b[i][j];
}
}
for (i = 0; i < n; i++) {
g = 0;
for (j = 0; j < m; j++) {
g = g + d[i][j];
}
if (h == -1)
h = g;
else
h = min(h, g);
}
for (i = 0; i < m; i++) {
g = 0;
for (j = 0; j < n; j++) {
g = g + d[j][i];
}
h = min(h, g);
}
cout << h;
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.*;
import java.lang.Math.*;
public class Matrix1
{
public static void main(String args[])throws Exception
{
boolean seive[]=new boolean[1000000];
Arrays.fill(seive,true);
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
PrintWriter pw = new PrintWriter(System.out);
StringTokenizer st=new StringTokenizer(br.readLine());
int n=Integer.parseInt(st.nextToken());
int m=Integer.parseInt(st.nextToken());
int a[][]=new int[n][m];
int i,j,k,l;
seive[1]=seive[0]=false;
for(i=4;i<1000000;i+=2)
{
seive[i]=false;
}
for(i=3;i<1000;i+=2)
{
if(seive[i])
{
for(j=i*i;j<1000000;j+=i)
{
seive[j]=false;
}
}
}
int val;
for(i=0;i<n;i++)
{
st=new StringTokenizer(br.readLine());
for(j=0;j<m;j++)
{
val=Integer.parseInt(st.nextToken());
for(k=val;k<1000000;k++)
{
if(seive[k])
{
break;
}
}
a[i][j]=k-val;
}
}
int row[]=new int[n];
int col[]=new int[m];
for(i=0;i<n;i++)
{
for(j=0;j<m;j++)
{
row[i]+=a[i][j];
}
}
Arrays.sort(row);
for(j=0;j<m;j++)
{
for(i=0;i<n;i++)
{
col[j]+=a[i][j];
}
}
Arrays.sort(col);
System.out.println(Math.min(row[0],col[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 | #include <bits/stdc++.h>
using namespace std;
int main() {
int a[100005];
set<int> b;
for (int i = 2; i <= 100100; i++) {
int flag = 0;
for (int j = 2; j <= sqrt(i); j++) {
if (i % j == 0) flag = 1;
}
if (flag == 0) b.insert(i);
}
set<int>::iterator it, it2;
int r[505], c[505];
memset(r, 0, sizeof(r));
memset(c, 0, sizeof(c));
int n, m;
int x, y;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> x;
it = b.lower_bound(x);
r[i] += abs(x - *it);
c[j] += abs(x - *it);
}
}
int ans = r[0];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
ans = min(min(r[i], c[j]), ans);
}
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int a[100100], i, j, k;
bool b[100100];
void seive() {
a[0] = 2;
a[1] = 2;
a[2] = 2;
for (i = 4; i <= 100100; i += 2) b[i] = 1;
for (i = 3; i * i <= 100100; i += 2) {
if (b[i] == 0)
for (j = i * i; j <= 100100; j += i) b[j] = 1;
}
for (j = 100100; j >= 2; j--)
if (b[j] == 0)
a[j] = j;
else
a[j] = a[j + 1];
}
int main() {
int n, m;
seive();
scanf("%d%d", &n, &m);
int x[n][m];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &x[i][j]);
x[i][j] = a[x[i][j]] - x[i][j];
}
}
int ans = 1000000000;
for (i = 0; i < n; i++) {
k = 0;
for (j = 0; j < m; j++) {
k += x[i][j];
}
ans = min(ans, k);
}
for (i = 0; i < m; i++) {
k = 0;
for (j = 0; j < n; j++) {
k += x[j][i];
}
ans = min(ans, k);
}
printf("%d\n", ans);
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
public class pointonline{
static int n,k;
static StringBuilder ans;
static HashMap<Integer,Integer> map=new HashMap<>();
public static void main(String[] args) throws IOException{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
ans=new StringBuilder();
PrintWriter out=new PrintWriter(System.out);
int t=1;
sieve();
ArrayList<Integer> al=new ArrayList<>();
for(int i=2;i<sf.length;i++){
if(!sf[i]){
al.add(i);
}
}
while(t-->0){
StringTokenizer tok=new StringTokenizer(br.readLine()," ");
n=Integer.parseInt(tok.nextToken());
k=Integer.parseInt(tok.nextToken());
int[][] mat=new int[n][k];;
for(int i=0;i<n;i++){
tok=new StringTokenizer(br.readLine()," ");
for(int j=0;j<k;j++){
Integer x=Integer.parseInt(tok.nextToken());;
int r=Collections.binarySearch(al,x);
if(r<0){
r=-r;
r--;
}
mat[i][j]=al.get(r)-x;
}
}
long amo=Integer.MAX_VALUE;
for(int i=0;i<n;i++){
long mo=0;
for(int j=0;j<k;j++){
mo+=mat[i][j];
}
amo=Math.min(mo, amo);
}for(int i=0;i<k;i++){
long mo=0;
for(int j=0;j<n;j++){
mo+=mat[j][i];
}
amo=Math.min(mo, amo);
}
ans.append(amo);
ans.append("\n");
}
out.println(ans);
out.close();
}
static boolean sf[]=new boolean[1000011];
static void sieve(){
for(int i=2;i*i<=sf.length;i++){
if(!sf[i]){
for(int j=i*i;j<sf.length;j+=i){
sf[j]=true;
}
}
}
}
} | JAVA |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.