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 | #coding: utf-8
def primes(DIM):
vals=[True] * DIM
vals[0]=False
vals[1]=False
for i in range(2,DIM):
if vals[i]:
j = i * i
while True :
if j >= DIM :
break
vals[j] = False
j += i
return vals
primes = primes(10 ** 5 + 100)
lista = [0,1,0]
for i in range(3,10 ** 5 + 100):
count = 0
if not(primes[i]) :
x = i + 1
count += 1
while x < (10 ** 5 + 100) :
if primes[x] :
break
x += 1
count += 1
lista.append(count)
n , m = map(int,raw_input().split())
matrix = []
moves = []
for i in range(n):
matrix.append(map(int,raw_input().split()))
count = 0
for j in range(m) :
count += lista[matrix[i][j]]
moves.append(count)
if min(moves) == 0 :
print 0
else :
for i in range(m):
count = 0
for j in range(n) :
count += lista[matrix[j][i]]
moves.append(count)
print min(moves)
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long maxn = 2e5 + 10;
long long N, M, vis[maxn], primes[maxn], tot = 0, arr[505][505];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
for (register long long i = 1; i <= N; ++i) {
for (register long long j = 1; j <= M; ++j) {
cin >> arr[i][j];
}
}
for (register long long i = 2; i < maxn; ++i) {
if (vis[i]) continue;
primes[++tot] = i;
for (register long long j = i * i; j < maxn; j += i) {
vis[j] = true;
}
}
long long ans = 1e18;
for (register long long i = 1; i <= N; ++i) {
long long tmp = 0;
for (register long long j = 1; j <= M; ++j) {
auto it = lower_bound(primes + 1, primes + 1 + tot, arr[i][j]);
tmp += *it - arr[i][j];
}
ans = min(ans, tmp);
}
for (register long long j = 1; j <= M; ++j) {
long long tmp = 0;
for (register long long i = 1; i <= N; ++i) {
auto it = lower_bound(primes + 1, primes + 1 + tot, arr[i][j]);
tmp += *it - arr[i][j];
}
ans = min(ans, tmp);
}
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 | LIMIT = 100000+4
l, c = map(int, raw_input().split())
m = [ list(map(int, raw_input().split())) for x in xrange(l)]
def is_prime(num):
if num == 2 or num == 3: return True
if num < 2 or num%2 == 0 or num%3 == 0: return False
r = int(num**0.5)
f = 5
while f <= r:
if (num % f == 0) or (num % (f+2) == 0): return False
f += 6
return True
def generatePrimes(_limit):
prime_list = [0 for x in xrange(_limit)]
last_prime = 100003
for num in xrange(_limit-1, -1, -1):
if is_prime(num):
prime_list[num] = num
last_prime = num
else:
prime_list[num] = last_prime
return prime_list
primes = generatePrimes(LIMIT)
answer = LIMIT
for line in xrange(l):
moves = 0
for column in xrange(c):
moves += primes[m[line][column]] - m[line][column]
answer = moves if (answer > moves) else answer
for column in xrange(c):
moves = 0
for line in xrange(l):
moves += primes[m[line][column]] - m[line][column]
answer = moves if (answer > moves) else answer
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 math
closeprime = [-1]* 100001
primos = []
n= 100001
m = int(math.sqrt(n))
numbers = [1] * ((n)+1)
# generate primes
for i in range(2,m):
num = numbers[i]
if num:
for j in range(i,n,i):
if numbers[j]:
numbers[j] = 0
primos.append(i)
numbers[i]= 1
j=1;
for i in range(primos[-1],len(numbers)-1):
if numbers[i] :
primos.append(i)
j=1
primos.append(100003)
for i in range(n):
menordif = 999999999
j-=1
while(j<len(primos) and (abs(primos[j] - i) < menordif)):
if primos[j] >= i:
menordif = abs(primos[j] - i)
j+=1
closeprime[i] = menordif
ene,eme = map(int,raw_input().split())
tt = 999999
matrix = []
for i in range(ene):
linha = map(int,raw_input().split())
matrix.append(linha)
for i in range(ene):
ttl = 0
linha = matrix[i]
for numb in linha:
ttl += closeprime[numb]
if ttl < tt:
tt = ttl
for i in range(eme):
ttl = 0
for j in range(ene):
val = matrix[j][i]
ttl += closeprime[val]
if ttl < tt:
tt = ttl
print tt
| 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.*;
public class cf271B{
public static void main(String args[])
{
Scanner sc = new Scanner(System.in);
int n= sc.nextInt();
int m= sc.nextInt();
int[][] matrix = new int[n][m];
int count =0;
int[] primes = new int[100010];
int[] new_primes = new int[100010];
int k= 2;
while(k<100010)
{
while(k<100010 && primes[k]!=0 )
k++;
new_primes[count++] = k;
for(int j=k; j<100010; j+=k)
primes[j] = 1;
}
//System.out.println(new_primes[0]+"new");
count--;
int min_row = 1000000000;
for(int i=0; i<n;i++)
{
int sum = 0;
for(int j=0; j<m; j++)
{
matrix[i][j] = sc.nextInt();
int num = bsearch(matrix[i][j],new_primes, 0, count-1);
//System.out.println("num"+num);
sum += (num - matrix[i][j]);
matrix[i][j] = num - matrix[i][j];
}
if(sum < min_row)
min_row = sum;
}
for(int i=0; i<m;i++)
{
int sum = 0;
for(int j=0; j<n; j++)
{
sum += matrix[j][i];
}
if(sum < min_row)
min_row = sum;
}
System.out.println(min_row);
}
public static int bsearch(int val, int[] new_primes, int start, int end)
{
while(start != end && end - start != 1)
{
int mid = (start+end)/2;
if(new_primes[mid] == val)
return val;
if(new_primes[mid] < val)
{
start = mid+1;
}
else
end = mid;
}
if(start == end)
return new_primes[start];
else
if(new_primes[start] >= val)
return new_primes[start];
else
return new_primes[end];
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.lang.invoke.MethodHandles;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.Random;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.TreeSet;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
parseAndGenerate();
try (PrintWriter out = new PrintWriter(System.out)) {
FastScanner scanner = new FastScanner();
int n = scanner.nextInt();
int m = scanner.nextInt();
long[][] arr = new long[n][m];
for (int i = 0; i < n; i++) {
arr[i] = scanner.readArray(m);
}
boolean[] primes = sieve((int) Math.pow(10, 6));
TreeSet<Long> set = new TreeSet<>();
for (int i = 0; i < primes.length; i++) {
if (primes[i]) {
set.add((long) i);
}
}
int ans = Integer.MAX_VALUE;
for (long[] row : arr) {
int count = 0;
for (int i = 0; i < row.length; i++) {
if (!set.contains(row[i])) {
long higher = set.higher(row[i]);
count += (higher - (int) row[i]);
}
}
ans = Math.min(ans, count);
}
for (int col = 0; col < m; col++) {
int count = 0;
for (int row = 0; row < n; row++) {
if (!set.contains(arr[row][col])) {
long higher = set.higher(arr[row][col]);
count += (higher - arr[row][col]);
}
}
ans = Math.min(ans, count);
}
out.println(ans);
}
}
static final Random random = new Random();
static void ruffleSort(long[] a) {
// shuffle, then sort
int n = a.length;
for (int i = 0; i < n; i++) {
int oi = random.nextInt(n);
long temp = a[oi];
a[oi] = a[i];
a[i] = temp;
}
Arrays.sort(a);
}
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());
}
long[] readArray(int n) {
long[] a = new long[n];
for (int i = 0; i < n; i++) {
a[i] = nextLong();
}
return a;
}
Integer[] readArrayInt(int n) {
Integer[] a = new Integer[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
long nextLong() {
return Long.parseLong(next());
}
}
static class Pair {
int first;
int second;
public Pair(int first, int second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Pair pair = (Pair) o;
return first == pair.first && second == pair.second;
}
@Override
public int hashCode() {
return Objects.hash(first, second);
}
}
static class Equation {
// ax+by=c;
int a, b, c;
public Equation(int x1, int y1, int x2, int y2) {
int a = y2 - y1;
int b = x1 - x2;
int c = a * x1 + b * y1;
}
public Equation(int a, int b, int c) {
this.a = a;
this.b = b;
this.c = c;
}
public boolean isPointOnLine(int x, int y) {
return a * x + b * y == c;
}
}
private static void buildGraph(HashMap<Integer, Set<Integer>> map, int first, int second) {
Set<Integer> set = map.getOrDefault(first, new HashSet<>());
set.add(second);
map.put(first, set);
set = map.getOrDefault(second, new HashSet<>());
set.add(first);
}
public static void parseAndGenerate() {
}
private static void print2dArr(PrintWriter out, int[][] arr) {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr[i].length; j++) {
out.print(arr[i][j] + " ");
}
out.println();
}
}
private static boolean[] sieve(int n) {
boolean[] isPrime = new boolean[n + 1];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= n; i++) {
if (isPrime[i] && ((long) i * i) <= n) {
for (int j = i * i; j <= n; j += i) {
isPrime[j] = false;
}
}
}
return isPrime;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
int main() {
int i, j, n, m, sum, min, index, R, P, flag, l, k;
int A[500][500], B[500][500];
scanf("%i%i", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%i", &A[i][j]);
}
}
min = 10000000;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
if (A[i][j] == 1) {
P = 2;
} else {
P = A[i][j];
flag = 0;
while (flag == 0) {
k = 0;
for (l = 2; l <= sqrt(P); l++) {
if (P % l == 0) {
k = 1;
break;
}
}
if (k == 0) {
flag = 1;
} else {
P++;
}
}
}
B[i][j] = P - A[i][j];
if (j < m - 1) {
if (A[i][j] == A[i][j + 1]) {
B[i][j + 1] = B[i][j];
j++;
}
}
}
}
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
sum = sum + B[i][j];
if (sum > min) {
break;
}
}
if (sum < min) {
min = sum;
}
}
for (j = 0; j < m; j++) {
sum = 0;
for (i = 0; i < n; i++) {
sum = sum + B[i][j];
if (sum > min) {
break;
}
}
if (sum < min) {
min = sum;
}
}
printf("%i", min);
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
def STR(): return list(input())
def INT(): return int(input())
def MAP(): return map(int, input().split())
def MAP2():return map(float,input().split())
def LIST(): return list(map(int, input().split()))
def STRING(): return input()
import string
import sys
from heapq import heappop , heappush
from bisect import *
from collections import deque , Counter , defaultdict
from math import *
from itertools import permutations , accumulate
dx = [-1 , 1 , 0 , 0 ]
dy = [0 , 0 , 1 , - 1]
#visited = [[False for i in range(m)] for j in range(n)]
#sys.stdin = open(r'input.txt' , 'r')
#sys.stdout = open(r'output.txt' , 'w')
#for tt in range(INT()):
#CODE
def solve(n):
prime = [True for i in range(n + 1)]
prime[0] = prime[1] = False
p = 2
while p * p <= n:
if prime[p]:
i = p * p
while i <= n:
prime[i] = False
i += p
p += 1
d = []
for i in range(2, n + 1):
if prime[i]:
d.append(i)
return d
def search(arr , l , r , x):
while l <= r :
mid = l + (r - l) // 2
if arr[mid] == x :
return arr[mid]
elif arr[mid] > x :
r = mid - 1
else:
l = mid + 1
return arr[l]
n , m = MAP()
g = []
for i in range(n):
g.append(LIST())
p = solve(10**5+9)
rows = []
for i in range(n):
c = 0
for j in range(m):
x = search(p , 0 , len(p) , g[i][j])
c += x - g[i][j]
rows.append(c)
cols = []
for i in range(m):
c = 0
for j in range(n):
x = search(p , 0 , len(p) , g[j][i])
c += x - g[j][i]
cols.append(c)
r1 = 1000000000
r2 = 1000000000
if len(rows)>0:
r1 = min(rows)
if len(cols) > 0:
r2 = min(cols)
r3 = min(r1,r2)
print(r3)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool t[100004] = {1, 1};
long long a[502], b[502], i, j, n, m, x;
int main() {
for (i = 2; i * i < 100004; i++)
if (!t[i])
for (j = i * i; j < 100004; j += i) t[j] = 1;
cin >> n >> m;
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
long long k = 0;
for (cin >> x; t[x + k]; k++)
;
a[i] += k;
b[j] += k;
}
cout << min(*min_element(a, a + n), *min_element(b, b + m));
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
LIMIT = 100025
is_prime = [True for i in range(LIMIT + 1)]
distance_to_next_prime = [0 for i in range(200000)]
def sieve_of_eratosthenes():
is_prime[0] = is_prime[1] = False
for i in range(2, int(math.sqrt(LIMIT))):
if is_prime[i]:
j = 2
while i * j <= LIMIT:
is_prime[i*j] = False
j += 1
def fill_next_primes():
for i in range(LIMIT - 1, -1, -1):
if is_prime[i]:
distance_to_next_prime[i] = 0
else:
distance_to_next_prime[i] = 1 + distance_to_next_prime[i+1]
sieve_of_eratosthenes()
fill_next_primes()
sizes_input = input().split(' ')
n, m = (int(sizes_input[0]), int(sizes_input[1]))
matrix = []
for i in range(0, n):
matrix.append(input().split(' '))
moves = 100000
for index_row in range(n):
best_row = 0
for index_column in range(m):
num = int(matrix[index_row][index_column])
best_row += distance_to_next_prime[num]
if best_row < moves:
moves = best_row
for index_column in range(m):
best_column = 0
for index_row in range(n):
num = int(matrix[index_row][index_column])
best_column += distance_to_next_prime[num]
if best_column < moves:
moves = best_column
print(moves) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool cmp(char a, char b) { return a > b; }
bool primes[1000001];
vector<long long int> *sieve() {
primes[0] = false;
primes[1] = false;
for (long long int i = 2; i * i < 1000001; i++) {
if (primes[i]) {
for (long long int j = i * i; j < 1000001; j += i) {
primes[j] = false;
}
}
}
vector<long long int> *prime = new vector<long long int>();
prime->push_back(2);
for (long long int i = 3; i < 1000001; i += 2) {
if (primes[i]) {
prime->push_back(i);
}
}
return prime;
}
int main() {
memset(primes, 1, sizeof(primes));
vector<long long int> *prime = sieve();
long long int N, M;
cin >> N >> M;
long long int arr[N][M];
for (long long int i = 0; i < N; i++) {
for (long long int j = 0; j < M; j++) {
cin >> arr[i][j];
}
}
long long int ans[N][M];
for (long long int i = 0; i < N; i++) {
for (long long int j = 0; j < M; j++) {
ans[i][j] = *lower_bound(prime->begin(), prime->end(), arr[i][j]);
ans[i][j] -= arr[i][j];
}
}
long long int mi = INT_MAX;
for (long long int i = 0; i < N; i++) {
long long int sum = 0;
for (int j = 0; j < M; j++) {
sum += ans[i][j];
}
mi = min(mi, sum);
}
for (long long int i = 0; i < M; i++) {
long long int sum = 0;
for (long long int j = 0; j < N; j++) {
sum += ans[j][i];
}
mi = min(mi, sum);
}
cout << mi << "\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 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1000 * 1000 + 10;
const int inf = 1000 * 1000 * 1000;
vector<int> prime;
bool check[maxn];
int mat[500][500], min_dist = inf, n, m, dist[500 * 500 + 10];
int dist_ele(int r, int c) {
int ele = mat[r][c];
if (dist[ele] != 0) return dist[ele];
int alt = ele, s = 0;
int mine = inf;
while (alt < 103000 && !check[alt]) {
alt++;
s++;
}
mine = s;
dist[ele] = mine;
return mine;
}
void check_col(int c) {
int sum = 0;
for (int i = 0; i < n; i++) sum += dist[mat[i][c]];
min_dist = min(min_dist, sum);
}
void check_row(int r) {
int sum = 0;
for (int i = 0; i < m; i++) sum += dist_ele(r, i);
min_dist = min(min_dist, sum);
}
int main() {
int f, g, max_ele = -1;
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
max_ele = max(max_ele, mat[i][j]);
}
prime.push_back(2);
check[2] = 1;
for (int i = 3; i < 103000; i += 2) {
bool t = 0;
for (int j = 0; j < prime.size(); j++) {
if (i % prime[j] == 0) {
t = 1;
break;
}
}
if (!t) {
prime.push_back(i);
check[i] = 1;
}
}
for (int i = 0; i < n; i++) check_row(i);
for (int i = 0; i < m; i++) check_col(i);
cout << min_dist;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | /*
* @Author: steve
* @Date: 2015-06-01 21:08:52
* @Last Modified by: steve
* @Last Modified time: 2015-06-01 21:25:52
*/
import java.io.*;
import java.util.*;
public class PrimeMatrix {
public static void main(String[] args) throws Exception{
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));
String[] cads =entrada.readLine().split(" ");
int n=Integer.parseInt(cads[0]),m=Integer.parseInt(cads[1]);
boolean[] primos=new boolean[1000001];
primos[0]=true;
primos[1]=true;
for(int i=2;i<primos.length;i++)
if(!primos[i])
for(int j=i*2;j<primos.length;j+=i)
primos[j]=true;
int[] col=new int[m],row=new int[n];
for(int i=0;i<n;i++){
cads=entrada.readLine().split(" ");
for(int j=0;j<m;j++){
int aux=Integer.parseInt(cads[j]);
if(primos[aux]){
int pos=Integer.MAX_VALUE;
for(int k=aux;k<primos.length;k++)
if(!primos[k]){
pos=k-aux;
break;
}
col[j]+=pos;
row[i]+=pos;
}
}
}
int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
min=Math.min(min,row[i]);
for(int i=0;i<m;i++)
min=Math.min(min,col[i]);
System.out.println(min);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.math.*;
import java.io.*;
public class Main {
public static StringTokenizer st;
public static BufferedReader scan;
public static PrintWriter out;
public static void main(String[] args) throws IOException{
scan = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
int[] d = new int[200001];
for(int i = 1; i <= 200000; i++){
for(int j = i; j <= 200000; j += i){
d[j]++;
}
}
int n = nextInt(), m = nextInt();
int[][] a = new int[n][m];
int[] x = new int[n], y = new int[m];
for(int i = 0; i < n; i++){
for(int j = 0; j < m; j++){
a[i][j] = nextInt();
while(d[a[i][j]] != 2){
a[i][j]++;
x[i]++;
y[j]++;
}
}
}
int min = x[0];
for(int i = 1; i < n; i++){
if(x[i] < min)min = x[i];
}
for(int j = 0; j < m; j++){
if(y[j] < min) min = y[j];
}
out.println(min);
scan.close();
out.close();
}
public static BigInteger nextBigInteger() throws IOException {
return new BigInteger(next());
}
public static long nextLong() throws IOException {
return Long.parseLong(next());
}
public static double nextDouble() throws IOException {
return Double.parseDouble(next());
}
public static int nextInt() throws IOException {
return Integer.parseInt(next());
}
public static String next() throws IOException {
while(st == null || !st.hasMoreTokens()){
st = new StringTokenizer(scan.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 | #include <bits/stdc++.h>
using namespace std;
vector<long long int> v(1000000 + 1, 0);
void sieve() {
long long int a;
bool prime[1000000 + 1];
memset(prime, true, sizeof(prime));
prime[0] = prime[1] = false;
for (long long int i = 2; i * i <= 1000000; i++) {
if (prime[i]) {
for (long long int j = (i * i); j <= 1000000; j += i) {
prime[j] = false;
}
}
}
for (long long int i = 1000000; i >= 1; i--) {
if (prime[i])
a = i;
else
v[i] = a - i;
}
}
int main() {
long long int a, b, c, d, i, j, k, l, m, n, p, q, r, u, w, e, f, g, h, t,
ct = 0, ct1 = 0, ct2 = 0, ck = 0, ck1 = 0, ck2 = 0, ln, ln1, start, end,
mid;
long long int a1 = 0, a2 = 0, a3 = 0, a4 = 0, b1 = 0, b2 = 0, b3 = 0, b4 = 0,
sum = 0, sum1 = 0, max1, max2, min1, min2;
double x, y, z;
char ch, ch1, ch2;
ios ::sync_with_stdio(false);
cin.tie(0);
;
sieve();
cin >> n >> m;
vector<long long int> v1[n];
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a;
v1[i].push_back(v[a]);
}
}
min1 = 1000000000000000005;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
sum += v1[i][j];
}
min1 = min(min1, sum);
}
for (j = 0; j < m; j++) {
sum = 0;
for (i = 0; i < n; i++) {
sum += v1[i][j];
}
min1 = min(min1, sum);
}
cout << min1 << 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
def isPrime(n):
# Corner cases
if(n <= 1):
return False
if(n <= 3):
return True
if(n % 2 == 0 or n % 3 == 0):
return False
for i in range(5,int(math.sqrt(n) + 1), 6):
if(n % i == 0 or n % (i + 2) == 0):
return False
return True
def nextPrime(N):
if (N <= 1):
return 2
prime = N
found = False
while(not found):
prime = prime + 1
if(isPrime(prime) == True):
found = True
return prime
def nextPrimeList(n):
arr = [False]* (n+1)
for i in range(2, n+1):
if not arr[i]:
j = 2
while j*i <=n:
arr[j*i] = True
j+=1
res = [2]*(n+1)
i = 2
while i <= n:
if not arr[i]: res[i] = i
else:
j = i
while j <=n and arr[j] == True:
j+=1
# print(i, j)
if j >n:
nxt = nextPrime(j-1)
# print(nxt)
res[i] = nxt
else:
# print(i, j)
res[i] = j
# print(res)
i+=1
return res
def solve(matrix, n, m):
maxim = matrix[0][0]
for i in range(n):
for j in range(m):
maxim = max(maxim, matrix[i][j])
nxtPList = nextPrimeList(maxim)
# print(nxtPList)
scores = [[0 for _ in range(m)] for _ in range(n)]
# print(scores)
for i in range(n):
for j in range(m):
scores[i][j] = nxtPList[matrix[i][j]] - matrix[i][j]
res = math.inf
for i in range(n):
rowScore = 0
for j in range(m):
rowScore+= scores[i][j]
res = min(res, rowScore)
for i in range(m):
coloumnScore = 0
for j in range(n):
coloumnScore+= scores[j][i]
# print(coloumnScore)
res =min(res, coloumnScore)
# print(scores)
return res
n, m = map(int, input().split())
matrix = []
for _ in range(n):
row= list(map(int, input().split()))
matrix.append(row)
print(solve(matrix, n, m))
# print(nextPrimeList(4))
| 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 | 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):
entrada = input().split()
matriz.append(list(map(int, entrada)))
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 | primo = 200001*[True]
distprimo = 200001*[0];
grid = []
primo[1] = False
for i in xrange(2, 200001):
j = i*i
while j < 200001:
primo[j] = False
j += i
dist = 1000000
for i in xrange(200000, 0, -1):
if primo[i]: dist = 0
distprimo[i] = dist
dist += 1
n, m = map(int, raw_input().split())
for i in xrange(n):
grid.append(map(int, raw_input().split()))
best = 1000000000
for i in xrange(n):
soma = 0
for j in xrange(m):
soma += distprimo[grid[i][j]]
best = min(best, soma)
for i in xrange(m):
soma = 0
for j in xrange(n):
soma += distprimo[grid[j][i]]
best = min(best, soma)
print best
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | row, column = map(int, input().split())
matrix =[[*map(int,input().split())] for _ in " "*row]
variation = int(1e5+2)
aux = [1,1] + ([0]*variation)
for x in range(2,variation):
aux[x*x::x]= [1] * ((variation-x*x)//x+1)
for y in range(variation,-1,-1):
aux[y]*= aux[y+1] + 1
for i in range(row):
for j in range(column):
matrix[i][j]=aux[matrix[i][j]]
collumsSums = min(sum(value) for value in matrix)
rownSums = min(sum(value) for value in zip(*matrix))
print(min(collumsSums, rownSums))
| 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 boolean a[] = new boolean[100005];
public static void c() {
a[0] = true;
a[1] = true;
for (int i = 2; i < 100005; i++) {
if (a[i] == false) {
for (int j = i * i; j < 100005 && j >= 0; j += i) {
a[j] = true;
}
}
}
}
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
c();
while (in.hasNext()) {
int r = in.nextInt();
int c = in.nextInt();
int ans[][] = new int[r][c];
int min = 1000000;
for (int i = 0; i < r; i++) {
int sum=0;
for (int j = 0; j < c; j++) {
int x = in.nextInt();
while (a[x] == true) {
x++;
ans[i][j] += 1;
}
sum+=ans[i][j];
}
if(sum<min){
min=sum;
}
}
for (int i = 0; i < c; i++) {
int sum2 = 0;
for (int j = 0; j < r; j++) {
sum2 += ans[j][i];
}
if(sum2<min){
min=sum2;
}
}
System.out.println(min);
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int N = 500 + 5, M = 1e5 + 5;
long long sum1[N], sum2[N];
int n, m, a[N][N], par[M];
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> a[i][j];
for (int i = par[1] = 1; i * i < M; i++)
if (!par[i])
for (int j = i * i; j < M; j += i) par[j] = 1;
for (int i = M - 1; i; i--) par[i] = (par[i] ? par[i + 1] : i);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
int x = par[a[i][j]] - a[i][j];
sum1[i] += x, sum2[j] += x;
}
cout << min(*min_element(sum1, sum1 + n), *min_element(sum2, sum2 + m))
<< 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;
bool notPrime[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n = 1000004, m;
notPrime[0] = notPrime[1] = 1;
vector<int> s;
for (size_t i = 2; i * i <= n; i++) {
if (!notPrime[i]) {
for (size_t j = i * 2; j < n; j += i) {
notPrime[j] = 1;
}
}
}
s.reserve(9600);
for (size_t i = 2; i < n; i++) {
if (!notPrime[i]) s.push_back(i);
}
cin >> n >> m;
vector<vector<int> > v(n, vector<int>(m));
for (size_t i = 0; i < n; i++) {
for (size_t j = 0; j < m; j++) {
cin >> v[i][j];
auto it = lower_bound(s.begin(), s.end(), v[i][j]);
v[i][j] = *it - v[i][j];
}
}
int res = 1e9;
for (size_t i = 0; i < n; i++) {
int temp = 0;
for (size_t j = 0; j < m; j++) {
temp += v[i][j];
}
res = min(res, temp);
}
for (size_t i = 0; i < m; i++) {
int temp = 0;
for (size_t j = 0; j < n; j++) {
temp += v[j][i];
}
res = min(res, temp);
}
cout << res << '\n';
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | nearest_prime=[0]*(int(1e5+1))
nearest_prime[0]=2
nearest_prime[1]=1
prime_bool=[0]*(int(1e5+1))
def is_prime(n):
for i in range(2,int(n**0.5)+1):
if n%i==0:
return False
return True
a=[]
for i in range(2,int(1e5)+1):
if is_prime(i):
a.append(i)
prime_bool[i]=1
for i in range(100001,1000001):
if is_prime(i):
a.append(i)
break
np=a[-1]
for i in range(int(1e5),1,-1):
if prime_bool[i]:
nearest_prime[i]=0
np=i
else:
nearest_prime[i]=np-i
#print(nearest_prime[:10])
ans=1e9
n,m=map(int,input().split())
arr=[]
for i in range(n):
arr.append(list(map(int,input().split())))
for i in range(n):
req=0
for j in range(m):
req+=nearest_prime[arr[i][j]]
# print("row",i,req)
ans=min(ans,req)
for i in range(m):
req=0
for j in range(n):
req+=nearest_prime[arr[j][i]]
# print("col",i,req)
ans=min(ans,req)
print(ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
import java.math.*;
public class B271 {
public static BufferedReader read = null;
public static PrintWriter out = null;
public static StringTokenizer token = null;
public static void solve()
{
int up = 100003;
boolean[] p = new boolean[up+1];
for(int i=2; i<=up; i++) p[i] = true;
int ct = 0;
for(int i=2; i<=up; i++)
{
if(p[i])
{
ct++;
for(int j = 2*i; j<=up; j+=i)
{
p[j] = false;
}
}
}
int[] cl = new int[up+1];
cl[up] = up;
for(int i=up-1; i>=0; i--)
{
if(p[i]) cl[i] = i;
else cl[i] = cl[i+1];
}
for(int i= 1; i<=up; i++)
{
cl[i] -=i;
}
int n = nint(), m = nint();
int[][] a = new int[n][m];
for(int i =0; i<n; i++)
{
a[i] = narr(m);
}
int[] rowop = new int[n];
int[] colop = new int[m];
for(int i=0; i<n; i++)
{
for(int j = 0; j<m; j++)
{
rowop[i]+=cl[a[i][j]];
colop[j]+=cl[a[i][j]];
}
}
int min = Integer.MAX_VALUE;
for(int i=0; i<n; i++)
{
min = min <= rowop[i] ? min : rowop[i];
}
for(int j = 0; j<m; j++)
{
min = min <= colop[j] ? min : colop[j];
}
out.println(min);
}
public static void main(String[] args)
{
read = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
solve();
out.flush();
out.close();
}
// i/o functions
public static String next() // returns the next string
{
while(token == null || !token.hasMoreTokens())
{
try {
token = new StringTokenizer(read.readLine());
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
return token.nextToken();
}
public static int nint()
{
return Integer.parseInt(next());
}
public static long nlong()
{
return Long.parseLong(next());
}
public static double ndouble()
{
return Double.parseDouble(next());
}
public static int[] narr(int n)
{
int[] a = new int[n];
for(int i=0; i<n; i++) a[i] = nint();
return a;
}
public static long[] nal(int n)
{
long[] a = new long[n];
for(int i=0; i<n; i++) a[i] = nlong();
return a;
}
}
| 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())
primes = [1 for _ in range(10**6+1)]
primes[0] = False
primes[1] = False
for i in range(2, 10**6):
if primes[i]:
for j in range(i*i, 10**6, i):
primes[j] = False
grid = []
for i in range(n):
grid.append([])
line = list(map(int, input().split()))
for nb in line:
copy = nb
while primes[nb] ^ 1:
nb += 1
grid[i].append(nb-copy)
ans = 10 ** 9
for i in range(n):
ans = min(ans, sum(grid[i]))
for j in range(m):
ans = min(ans, sum(grid[i][j] for i in range(n)))
print(ans) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long prb = 100;
const long long N = 100005;
const long long NN = 105;
const long long HASH1 = 2250119;
const long long HASH2 = 2452343;
const double pi = 3.14159;
const long long MAX = 2e5 + 123;
const long long MOD = 1e9 + 7;
const long long INF = 1000000000000000000;
const long long pw = 31;
void speed() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long n, m, a[505][505], line[505], column[505];
vector<long long> v;
void hajime() {
cin >> n >> m;
for (long long i = 2; i <= 100010; i++) {
bool ok = 1;
for (long long j = 2; j <= sqrt(i); j++) {
if (i % j == 0) ok = 0;
}
if (ok) v.push_back(i);
}
for (long long i = 1; i <= n; i++) {
for (long long j = 1; j <= m; j++) {
cin >> a[i][j];
long long l = 0, r = v.size() - 1;
while (l < r) {
long long md = (l + r) / 2;
if (v[md] >= a[i][j])
r = md;
else
l = md + 1;
}
line[j] += abs(v[r] - a[i][j]);
column[i] += abs(v[r] - a[i][j]);
}
}
long long mn = INF;
for (long long i = 1; i <= n; i++) mn = min(mn, column[i]);
for (long long j = 1; j <= m; j++) mn = min(mn, line[j]);
cout << mn;
}
int main() {
long long miyagi = 1;
speed();
for (long long i = 1; i <= miyagi; i++) {
hajime();
}
}
| 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 | k=[0]*(1000001)
primes=[]
for i in range(2,1000001):
if k[i]==0:
primes.append(i)
for j in range(i,1000001,i):k[j]=1
def bin(x):
lo,hi=0,len(primes)
ans=0
while lo<=hi:
mid = (hi+lo)//2;
if primes[mid]==x:return 0
if primes[mid]<x:lo=mid+1
else:ans=mid;hi=mid-1
return primes[ans]-x
a,b=map(int,input().split())
r=[0]*a
c=[0]*b
for i in range(a):
gh=0
for u,v in enumerate(map(int,input().split())):
t=bin(v)
c[u]+=t
gh+=t
r[i]=gh
print(min(min(r),min(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 | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int mini = 100000, temp_min;
vector<int> v;
v.push_back(2);
int x = 2;
bool tinka = true;
while (1) {
tinka = true;
for (int i = 2; i < sqrt(x) + 1; i++) {
if (x % i == 0) {
tinka = false;
break;
}
}
if (tinka) {
v.push_back(x);
}
x++;
if (x == 100100) break;
}
int A[500][500];
int n, m;
cin >> n >> m;
vector<int>::iterator it;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> A[i][j];
it = lower_bound(v.begin(), v.end(), A[i][j]);
A[i][j] = *it - A[i][j];
}
}
for (int i = 0; i < n; i++) {
temp_min = 0;
for (int j = 0; j < m; j++) temp_min += A[i][j];
mini = min(mini, temp_min);
}
for (int i = 0; i < m; i++) {
temp_min = 0;
for (int j = 0; j < n; j++) temp_min += A[j][i];
mini = min(mini, temp_min);
}
cout << mini;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | sieve=[0]*2+[1]*100003
for i in range(2,1001):
if sieve[i]:
for j in range(i*2,100003,i):
sieve[j]=0
def next_prime(n):
i = 0
while not sieve[n+i]:
i += 1
return i
for x in xrange(0,len(sieve)):
sieve[x] = next_prime(x)
n,m = map(int,raw_input().split())
matrix = [[0 for _ in xrange(m)] for x in xrange(n)]
for x in xrange(n):
arr = map(int,raw_input().split())
for y in xrange(m):
matrix[x][y] = sieve[arr[y]]
print min([sum(x) for x in matrix] + [sum(x) for x in zip(*matrix)]) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.InputMismatchException;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
* @author alex
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
public void solve(int testNumber, InputReader in, PrintWriter out) {
int n = in.readInt();
int m = in.readInt();
int[][] t = IOUtils.readIntMatrix(in, n, m);
Sieve sieve = new Sieve(111111);
int ans = 1 << 30;
for (int i = 0; i < n; ++i) {
int rcost = 0;
for (int j = 0; j < m; ++j) {
rcost += sieve.nextPrime(t[i][j]) - t[i][j];
}
if (ans > rcost) ans = rcost;
}
for (int i = 0; i < m; ++i) {
int ccost = 0;
for (int j = 0; j < n; ++j) {
ccost += sieve.nextPrime(t[j][i]) - t[j][i];
}
if (ans > ccost) ans = ccost;
}
out.println(ans);
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new 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 readInt() {
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 static boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
}
class IOUtils {
public static int[][] readIntMatrix(InputReader in, int r, int c) {
int[][] ret = new int[r][c];
for (int i = 0; i < r; ++i)
for (int j = 0; j < c; ++j)
ret[i][j] = in.readInt();
return ret;
}
}
class Sieve {
int n;
boolean[] b;
int[] p;
int[] sum;
int sz;
public Sieve(int n) {
this.n = n;
b = new boolean[n + 1];
b[0] = true;
b[1] = true;
for (int i = 2; i * i <= n; ++i) {
if (!b[i]) {
for (int j = i + i; j <= n; j += i) {
b[j] = true;
}
}
}
p = new int[n];
sum = new int[n + 1];
sz = 0;
for (int i=2;i<=n;++i) {
sum[i] = sum[i - 1];
if (!b[i]) {
p[sz++] = i;
++sum[i];
}
}
}
public int nextPrime(int x) {
int lo = 0, hi = sz - 1;
while (hi - lo > 5) {
int mid = (lo + hi) >> 1;
if (p[mid] < x) lo = mid + 1;
else hi = mid;
}
while (lo < hi && p[lo] < x) ++lo;
return p[lo];
}
}
| 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> v;
int prime[100015];
void sieve() {
for (long long p = 2; p * p <= 100009; p++) {
if (prime[p] == 0) {
for (long long i = p * p; i <= 100009; i = i + p) {
prime[i] = 1;
}
}
}
}
void num() {
for (int i = 2; i <= 100009; i++) {
if (prime[i] == 0) {
v.push_back(i);
}
}
}
int main() {
sieve();
num();
prime[1] = 1;
long long n, m;
cin >> n >> m;
vector<long long> ansr[n], ansc[m], tem, res;
long long a[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
long long p;
cin >> p;
if (prime[p] == 0 && p != 1)
a[i][j] = -1;
else
a[i][j] = p;
}
}
for (int i = 0; i < n; i++) {
long long sum = 0;
for (int j = 0; j < m; j++) {
if (a[i][j] != -1) {
long long pos;
pos = upper_bound(v.begin(), v.end(), a[i][j]) - v.begin();
ansr[i].push_back(v[pos] - a[i][j]);
}
}
if (ansr[i].size() != 0)
sum = accumulate(ansr[i].begin(), ansr[i].end(), 0);
tem.push_back(sum);
}
sort(tem.begin(), tem.end());
res.push_back(tem[0]);
tem.clear();
for (int j = 0; j < m; j++) {
long long sum = 0;
for (int i = 0; i < n; i++) {
if (a[i][j] != -1) {
long long pos = upper_bound(v.begin(), v.end(), a[i][j]) - v.begin();
ansc[j].push_back(v[pos] - a[i][j]);
}
}
if (ansc[j].size() != 0)
sum = accumulate(ansc[j].begin(), ansc[j].end(), 0);
tem.push_back(sum);
}
sort(tem.begin(), tem.end());
res.push_back(tem[0]);
sort(res.begin(), res.end());
cout << res[0] << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | num_rows, num_columns = map(int, input().split())
limit=int(1e5+2)
diffs=[2,1,0,0]+[1,0]*((limit-2)//2)
for i in range(3,limit):
if not diffs[i]:
diffs[i*i::i]=[1]*((limit-i*i)//i+1)
for i in range(limit,4,-1):
diffs[i]*=diffs[i+1]+1
matrix_diffs = [[diffs[j] for j in map(int,input().split())] for i in range(num_rows)]
min_moves_to_rows = min(sum(i) for i in matrix_diffs)
min_moves_to_cols = min(sum(i) for i in zip(*matrix_diffs))
print(min(min_moves_to_rows, min_moves_to_cols))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
public class CodeForces
{
public static void main(String args[])
{
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int m = input.nextInt();
int[][] array = new int[n][m];
int[] next = new int[100100];
boolean[] primes = sieveOfEratosthenes(1000100);
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++)
{
int count = 0;
for (int j = 0; j < m; j++)
{
array[i][j] = input.nextInt();
if (next[array[i][j]] > 0)
{
count += (next[array[i][j]] - array[i][j]);
} else
{
int z = array[i][j];
int stop = 0;
if (z == 1)
{
count++;
stop = 2;
} else if (z == 2)
{
stop = 2;
} else if (z % 2 == 0)
{
z++;
count++;
while (!primes[z])
{
z += 2;
count += 2;
stop = z;
}
} else
{
while (!primes[z])
{
z++;
count++;
stop = z;
}
}
next[z] = stop;
}
}
if (count < min)
{
min = count;
}
}
for (int i = 0; i < m; i++)
{
int count = 0;
for (int j = 0; j < n; j++)
{
if (next[array[j][i]] > 0)
{
count += (next[array[j][i]] - array[j][i]);
} else
{
int z = array[j][i];
int stop = 0;
if (z == 1)
{
count++;
stop = 2;
} else if (z == 2)
{
stop = 2;
} else if (z % 2 == 0)
{
z++;
count++;
while (!primes[z])
{
z += 2;
count += 2;
stop = z;
}
} else
{
while (!primes[z])
{
z++;
count++;
stop = z;
}
}
next[z] = stop;
}
}
if (count < min)
{
min = count;
}
}
System.out.println(min);
}
public static boolean[] sieveOfEratosthenes(int n)
{
boolean prime[] = new boolean[n + 1];
for (int i = 0; i < n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++)
{
if (prime[p] == true)
{
for (int i = p * 2; i <= n; i += p)
prime[i] = false;
}
}
prime[0] = false;
prime[1] = false;
return prime;
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import bisect
def sieve(n):
p = 2
prime = [True for i in range(n+1)]
while p*p<=n:
if prime[p] ==True:
for i in range(p*p,n+1,p):
prime[i] = False
p+=1
c = []
for p in range(2,n):
if prime[p]:
c.append(p)
return c
def transpose(a,n,m):
c = []
for i in range(max(n,m)):
l = []
for j in range(max(n,m)):
try:
l.append(a[j][i])
except:
pass
c.append(l)
c = c[:m]
return c
def calcost(a,c):
cost = 0
for i in range(len(a)):
p = bisect.bisect_left(c,a[i])
cost+=(c[p]-a[i])
return cost
c = sieve(1000001)
n,m = map(int,input().split())
l = []
for i in range(n):
a = list(map(int,input().split()))
l.append(a)
cost = []
for i in range(len(l)):
cost.append(calcost(l[i],c))
l = transpose(l,n,m)
for i in range(len(l)):
cost.append(calcost(l[i],c))
print(min(cost))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
import java.nio.charset.StandardCharsets;
// import java.math.BigInteger;
public class B {
static Writer wr;
public static void main(String[] args) throws Exception {
// long startTime = System.nanoTime();
// String testString = "";
// InputStream stream = new ByteArrayInputStream(testString.getBytes(StandardCharsets.UTF_8));
// Reader in = new Reader(stream);
Reader in = new Reader();
BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
wr = new Writer();
/* Precomputation */
int max = 200000;
boolean[] is_not_prime = new boolean[max+1];
for(int i=2;i*i<=max;i+=2) {
if(!is_not_prime[i]) {
for(int j=2;j*i<=max;j++) {
is_not_prime[j*i] = true;
}
}
if(i==2) i--;
}
int idx=0;
int[] primes = new int[17984];
for(int i=2;i<=max;i++) {
if(!is_not_prime[i]) {
primes[idx++] = i;
}
}
// wr.writeRedLn(Arrays.toString(Arrays.copyOfRange(primes, 9585, primes.length)));
// wr.writeRedLn(idx);
// long elapsedTime = System.nanoTime() - startTime;
// double seconds = (double)elapsedTime / 1000000000.0;
// wr.writeRedLn(seconds);
/* Input */
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();
}
}
ArrayList<Integer> count = new ArrayList<>();
for(int i=0;i<N;i++) {
int cc=0;
for(int j=0;j<M;j++) {
int check = Arrays.binarySearch(primes, a[i][j]);
if(check<0) {
check = -check-1;
int best = 1000000;
for(int k=check; k<=check+2;k++) {
if((k>=0) && (k<primes.length)) {
best = Math.min(best, Math.abs(a[i][j]-primes[k]));
// wr.writeRedLn(a[i][j] + " " + best +" "+primes[k]);
}
}
cc += best;
// wr.writeRedLn(a[i][j] + " " + best +" "+check);
}
}
// wr.writeGreenLn(cc+"");
count.add(cc);
}
for(int j=0;j<M;j++) {
int cc=0;
for(int i=0;i<N;i++) {
int check = Arrays.binarySearch(primes, a[i][j]);
if(check<0) {
check = -check-1;
int best = 1000000;
for(int k=check; k<=check+2;k++) {
if((k>=0) && (k<primes.length)) {
best = Math.min(best, Math.abs(a[i][j]-primes[k]));
// wr.writeRedLn(a[i][j] + " " + best +" "+primes[k]);
}
}
cc += best;
// wr.writeRedLn(a[i][j] + " " + best +" "+check);
}
}
// wr.writeGreenLn(cc+"");
count.add(cc);
}
Collections.sort(count);
out.write(count.get(0) + "\n");
out.flush();
}
}
class Writer {
public void writeRedLn(Object x) { writeRedLn(x+""); }
public void writeBlueLn(Object x) { writeBlueLn(x+""); }
public void writeGreenLn(Object x) { writeGreenLn(x+""); }
public void writePinkLn(Object x) { writePinkLn(x+""); }
public void writeRedLn(String x) { System.out.println((char)27 + "[31m" + (char)27 + "[40m" + x + (char)27 + "[0m"); }
public void writeBlueLn(String x) { System.out.println((char)27 + "[34m" + (char)27 + "[3m" + x + (char)27 + "[0m"); }
public void writeGreenLn(String x) { System.out.println((char)27 + "[32m" + (char)27 + "[3m" + x + (char)27 + "[0m"); }
public void writePinkLn(String x) { System.out.println((char)27 + "[30m" + (char)27 + "[45m" + x + (char)27 + "[0m"); }
public void writeRed(String x) { System.out.print((char)27 + "[31m" + (char)27 + "[40m" + x + (char)27 + "[0m"); }
public void writeBlue(String x) { System.out.print((char)27 + "[34m" + (char)27 + "[3m" + x + (char)27 + "[0m"); }
public void writeGreen(String x) { System.out.print((char)27 + "[32m" + (char)27 + "[3m" + x + (char)27 + "[0m"); }
public void writePink(String x) { System.out.print((char)27 + "[30m" + (char)27 + "[45m" + x + (char)27 + "[0m"); }
}
class Reader {
final private int BUFFER_SIZE = 1 << 16;private DataInputStream din;private byte[] buffer;private int bufferPointer, bytesRead;
public Reader(){din=new DataInputStream(System.in);buffer=new byte[BUFFER_SIZE];bufferPointer=bytesRead=0;}
public Reader(InputStream stream){din=new DataInputStream(stream);buffer=new byte[BUFFER_SIZE];bufferPointer=bytesRead=0;}
public String readLine()throws IOException{byte[] buf=new byte[1024];int cnt=0,c;
while((c=read())!=-1){if(c=='\n')break;buf[cnt++]=(byte)c;}return new String(buf,0,cnt);}
public char nextChar()throws IOException{byte c=read();while(c<=' ')c=read();return (char)c;}
public int nextInt()throws IOException{int ret=0;byte c=read();while(c<=' ')c=read();boolean neg=(c=='-');
if(neg)c=read();do{ret=ret*10+c-'0';}while((c=read())>='0'&&c<='9');if(neg)return -ret;return ret;}
public long nextLong()throws IOException{long ret=0;byte c=read();while(c<=' ')c=read();boolean neg=(c=='-');
if(neg)c=read();do{ret=ret*10+c-'0';}while((c=read())>='0'&&c<='9');if(neg)return -ret;return ret;}
public double nextDouble()throws IOException{double ret=0,div=1;byte c=read();while(c<=' ')c=read();boolean neg=(c=='-');if(neg)c = read();do {ret=ret*10+c-'0';}while((c=read())>='0'&&c<='9');
if(c=='.')while((c=read())>='0'&&c<='9')ret+=(c-'0')/(div*=10);if(neg)return -ret;return ret;}
private void fillBuffer()throws IOException{bytesRead=din.read(buffer,bufferPointer=0,BUFFER_SIZE);if(bytesRead==-1)buffer[0]=-1;}
private byte read()throws IOException{if(bufferPointer==bytesRead)fillBuffer();return buffer[bufferPointer++];}
public void close()throws IOException{if(din==null) return;din.close();}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Arrays;
import java.util.Scanner;
public class C {
public static int findMaxBinary(int[] lista, int element) {
int izquierda = 0;
int derecha = lista.length-1;
int centro = 0;
boolean isFound = false;
while(!isFound && (izquierda<=derecha)) {
centro = (izquierda + derecha) / 2;
if(lista[centro] == element) {
isFound = true;
}else {
if(element > lista[centro] && element < lista[centro+1]) {
return centro+1;
}else if(lista[centro] > element) {
derecha = centro-1;
}else {
izquierda = centro+1;
}
}
}
if(isFound) {
return centro;
}else {
return -1;
}
}
private static boolean[] calculaPrimos(int size) {
boolean arreglo[];
arreglo = new boolean[size + 1];
for (int i = 2; i < size; i++ ) {
arreglo[i] = true;
}
for ( int j = 2; j <= size; j++ ) {
if (arreglo[j] == true) {
for ( int k = 2; k <= (size)/j; k++ )
arreglo[k*j] = false;
}
}
return arreglo;
}
public static void main(String[] args) {
//Input de consola
Scanner sc = new Scanner(System.in);
String[] s =sc.nextLine().split(" ");
int f = Integer.parseInt(s[0]),
c = Integer.parseInt(s[1]);
int[][] matrix = new int[f][c];
for(int i=0; i<f; i++) {
s= sc.nextLine().split(" ");
for(int j=0; j<c; j++) {
matrix[i][j] = Integer.parseInt(s[j]);
}
}
int index = 1;
int[] primos = new int[9594];
primos[0] = 0;
boolean[] primosBool = calculaPrimos(100000);
for(int i=0; i<100000; i++) {
if(primosBool[i]) {
primos[index] = i;
index++;
}
}
primos[9593] = 100003;
//Programa
int min = 0,
cont = 0;
for(int i=0; i<f; i++) {
for(int j=0; j<c; j++) {
cont += (primos[findMaxBinary(primos, matrix[i][j])]-matrix[i][j]);
}
if(i==0) {
min = cont;
}else {
min = Math.min(min, cont);
}
cont = 0;
}
cont = 0;
for(int i=0; i<c; i++) {
for(int j=0; j<f; j++) {
cont += (primos[findMaxBinary(primos, matrix[j][i])]-matrix[j][i]);
}
min = Math.min(min, cont);
cont = 0;
}
System.out.println(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
public class inter8 {
static int[] p = new int[120001];
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[][] a = new int[n][m];
int[][] op = new int[n][m];
int[] s = new int[n+m];
int min=100000;
p[0]=0;p[1] =0;
for(int i=2;i<120000;i++){
p[i] = prime(i);
}
for(int i=0;i<n;i++){
for(int j=0;j<m;j++){
a[i][j] = in.nextInt();
op[i][j] = cprime(a[i][j]);
s[i] += op[i][j];
}
if(s[i]<min)
min = s[i];
}
for(int j=0;j<m;j++ ){
for(int i=0;i<n;i++){
s[n+j] += op[i][j];
}
if(s[n+j]<min)
min = s[n+j];
}
System.out.println(min);
}
public static int cprime(int x){
int c=0;
while(true){
if(p[x]==1)
return c;
x++;
c++;}
}
public static int prime(int x){
int i;
if(x==1)
return 0;
for(i=2;i<=Math.sqrt(x);i++){
if(x%i==0)
break;
}
if(i >Math.sqrt(x))
return 1;
return 0;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class PrimeMatrix
{
public static void main(String[] args) throws IOException
{
boolean[] primes = new boolean[100010];
ArrayList<Integer> list = new ArrayList<Integer>();
Arrays.fill(primes, true);
primes[0]=false;primes[1]=false;
for (int i = 2; i < primes.length; i++)
if (primes[i]==true){
list.add(i);
if(i*1L*i > primes.length) continue;
for (int j = i*i; j < primes.length; j += i)
primes[j]=false;
}
Reader in = new Reader();
int n, m, temp, min, ind, num, val;
int[][] matrix;
for (int i = 0; i < 1; i++) {
n = in.nextInt();
m = in.nextInt();
matrix = new int[n][m];
for (int j = 0; j < n; j++) {
for (int k = 0; k < m; k++) {
matrix[j][k] = in.nextInt();
}
}
min = Integer.MAX_VALUE;
for (int j = 0; j < n; j++) {
temp = 0;
for (int k = 0; k < m; k++) {
num = matrix[j][k];
if(primes[num]) continue;
ind = Collections.binarySearch(list, num);
ind = (ind*-1)-1;
val = Math.abs(num-list.get(ind));
if(ind+1 < list.size())
val = Math.min(Math.abs(num-list.get(ind+1)), val);
temp += val;
}
min = Math.min(min, temp);
}
for (int j = 0; j < m; j++) {
temp = 0;
for (int k = 0; k < n; k++) {
num = matrix[k][j];
if(primes[num]) continue;
ind = Collections.binarySearch(list, num);
ind = (ind*-1)-1;
val = Math.abs(num-list.get(ind));
if(ind+1 < list.size())
val = Math.min(Math.abs(num-list.get(ind+1)), val);
temp += val;
}
min = Math.min(min, temp);
}
System.out.println(min);
}
}
static class Reader
{
BufferedReader br;
StringTokenizer st;
Reader() { // To read from the standard input
br = new BufferedReader(new InputStreamReader(System.in));
}
Reader(int i) throws IOException { // To read from a file
br = new BufferedReader(new FileReader("Sample Input.txt"));
}
String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
int nextInt() throws IOException { return Integer.parseInt(next()); }
long nextLong() throws IOException { return Long.parseLong(next()); }
double nextDouble() throws IOException { return Double.parseDouble(next()); }
String nextLine() throws IOException { return br.readLine(); }
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int p[100015], prime[100015], no, ans[500][500], a[500][500];
void pre() {
int i, j;
for (i = 2; i <= 100010; i++) {
if (p[i] != 1) {
for (j = 2; i * j <= 100010; j++) {
p[i * j] = 1;
}
}
}
prime[0] = 2;
no = 1;
for (i = 3; i <= 100010; i += 2) {
if (p[i] == 0) {
prime[no++] = i;
}
}
}
int main() {
int n, m, i, j, s = 0, ind, mn = 100000;
cin >> n >> m;
pre();
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> a[i][j];
ind = (lower_bound(prime, prime + no, a[i][j]) - prime);
ans[i][j] = prime[ind] - a[i][j];
}
}
for (i = 0; i < n; i++) {
s = 0;
for (j = 0; j < m; j++) {
s += ans[i][j];
}
if (s < mn) {
mn = s;
}
}
for (i = 0; i < m; i++) {
s = 0;
for (j = 0; j < n; j++) {
s += ans[j][i];
}
if (s < mn) {
mn = s;
}
}
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 | max = 150035
primes = [0 for x in range(max)]
def generatePrimes():
primes[1] = primes[0] = 1
for i in range(2, max):
if primes[i] == 0:
for j in range(i + i, max, i):
primes[j] = 1
for i in range(max-2, -1, -1):
if (primes[i] != 0):
primes[i] += primes[i+1]
generatePrimes()
columns = [0 for x in range(max)]
n, m = map(int, input().split())
res = 10**9
for i in range(0, n):
aux = 0
query = list(map(int, input().split()))
for j in range(m):
aux += primes[query[j]]
columns[j] += primes[query[j]]
if i == n-1:
for j in range(m):
res = min(columns[j], res)
res = min(aux, res)
print(res) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int prime_x(int x) {
for (int i = 2; i * i < x + 2; i++) {
if (x % i == 0) {
return 0;
}
}
return 1;
}
int pr[100009];
int z[100007];
int s[509][509];
int main() {
pr[2] = 1;
for (int i = 3; i < 100007; i++) {
pr[i] = prime_x(i);
}
z[100003] = 0;
for (int i = 100002; i >= 0; i--) {
if (pr[i] == 1)
z[i] = 0;
else {
z[i] = z[i + 1] + 1;
}
}
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x;
cin >> x;
s[i][j] = z[x];
}
}
int row = 100000009;
for (int i = 0; i < n; i++) {
int tem = 0;
for (int j = 0; j < m; j++) {
tem += s[i][j];
}
row = min(row, tem);
}
for (int i = 0; i < m; i++) {
int tem = 0;
for (int j = 0; j < n; j++) {
tem += s[j][i];
}
row = min(row, tem);
}
cout << row;
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 boolean[] primes = new boolean[1000000];
public static void main(String[] args) {
Scanner in = new Scanner(System.in);
getPrimes();
while (in.hasNextInt()) {
int n = in.nextInt();
int m = in.nextInt();
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();
}
}
int[][] dis = new int[n][m];
int min = 2000000;
for (int i = 0; i < n; i++) {
int count = 0;
for (int j = 0; j < m; j++) {
for (int k = arr[i][j]; k < primes.length; k++) {
if (!primes[k]) {
dis[i][j] = k - arr[i][j];
break;
}
}
count += dis[i][j];
}
min = Math.min(min, count);
}
for (int i = 0; i < m; i++) {
int count = 0;
for (int j = 0; j < n; j++) {
count += dis[j][i];
}
min = Math.min(min, count);
}
System.out.println(min);
}
}
private static void getPrimes() {
primes[0] = primes[1] = true;
for (int i = 2; i < primes.length; i++) {
if (!primes[i]) {
for (int j = 2; i * j < primes.length; j++) {
primes[i * j] = 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 sys
import math
m, n = map(int, raw_input().split())
matrix_list = []
for i in range(m):
matrix_list.append(map(int, raw_input().split()))
list_primes = [0]
def is_prime(n):
if n == 2 or n == 3:
return True
elif n < 2 or n % 2 == 0:
return False
elif n < 9:
return True
elif n % 3 == 0:
return False
r = int(math.sqrt(n))
f = 5
while f <= r:
if n % f == 0 or n % (f + 2) == 0:
return False
else:
f += 6
return True
for i in xrange(2, 10**5+100):
if is_prime(i):
list_primes.append(i)
# now have list of primes
def binsearch(num, list_primes):
lo = 0
hi = len(list_primes)
while hi - lo > 1:
mid = (lo + hi) / 2
if list_primes[mid] == num:
return num
elif list_primes[mid] >= num:
hi = mid
else:
lo = mid
return list_primes[hi]
sum_list = []
for i in range(m):
sum_list.append([])
for j in xrange(n):
crap = binsearch(matrix_list[i][j], list_primes) - matrix_list[i][j]
sum_list[i].append(crap)
best = sum(sum_list[0])
for list in sum_list:
best = min(best, sum(list))
for i in xrange(n):
sum_crap = 0
for j in xrange(m):
sum_crap += sum_list[j][i]
best = min(sum_crap, best)
print best
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def _min(x, y):
if x < y:
return x
if y <= x:
return y
n = 100100
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
n = 100100
nextPrime = [0 for _ in range(n+1)]
currentPrime = -1
for i in range(n, -1, -1):
if prime[i]:
nextPrime[i] = i
currentPrime = i
elif currentPrime == -1:
nextPrime[i] = -1
else:
nextPrime[i] = currentPrime
n, m = map(int, input().split())
rows = [0 for i in range(n)]
cols = [0 for i in range(m)]
for r in range(n):
row = [int(x) for x in input().split()]
for c in range(m):
x = row[c]
if not prime[x]:
x = nextPrime[x]
rows[r] += (x - row[c])
cols[c] += (x - row[c])
min_row=min(rows)
min_cols=min(cols)
print(_min(min_row, min_cols))
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
#pragma GCC optimize "trapv"
using namespace std;
std::vector<long long int> v;
const long long int x = 1000007;
void fun() {
bool prime[x + 1];
memset(prime, true, sizeof(prime));
for (long long int p = 2; p * p <= x; p++) {
if (prime[p] == true) {
for (long long int i = p * p; i <= x; i += p) prime[i] = false;
}
}
for (long long int p = 2; p <= x; p++)
if (prime[p]) v.push_back(p);
}
int32_t main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
;
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];
}
}
fun();
long long int ans = INT_MAX;
for (long long int i = 0; i < n; i++) {
long long int s = 0;
for (long long int j = 0; j < m; j++) {
if (binary_search(v.begin(), v.end(), a[i][j]) == 0) {
long long int u = upper_bound(v.begin(), v.end(), a[i][j]) - v.begin();
s += v[u] - a[i][j];
}
}
ans = min(ans, s);
}
for (long long int i = 0; i < m; i++) {
long long int s = 0;
for (long long int j = 0; j < n; j++) {
if (binary_search(v.begin(), v.end(), a[j][i]) == 0) {
long long int u = upper_bound(v.begin(), v.end(), a[j][i]) - v.begin();
s += v[u] - a[j][i];
}
}
ans = min(ans, s);
}
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 | import java.io.*;
import java.util.*;
public class A274 {
/**
* @param args
*/
public static void main(String[] args) {
Scanner in= new Scanner(System.in);
int n=in.nextInt();
int m=in.nextInt();
int [][] g=new int [500+1][500+1];
int [] r=new int [300_000+1];
for (int i=0;i<n;i++){
for (int j=0;j<m;j++){
g[i][j]=in.nextInt();
}
}
for (int i=2 ;i< 100_300;i++){
r[i]=0;
}
for (int i=2 ;i< 100_300;i++){
//System.out.print(i);
if (r[i]==0){
r[i+i]=1;
for (int j=i+i;j < 100_300;j=i+j){
//System.out.printf( " %d",j);
r[j]=1;
}
}
}
/*for (int i=2 ;i< 100;i++){
if (r[i]==0){
System.out.printf(" %d",i);
}
}
*/
int i=100_300;
/*while ( r[i]!=0){
ci);
i--;
}
*/
i++;
while (i>=2){
if (r[i]!=0) r[i]=r[i+1];
else r[i]=i;
i--;
}
r[1]=2;
/*for (int i1=0;i1<100;i1++){
System.out.printf(" %d",r[i1]);
}
*/
int ans = 0;
int max=0;
int max1=100300;
for (int i1=0;i1<n;i1++){
max=0;
for (int j=0;j<m;j++){
max+= r[g[i1][j]]-g[i1][j];
}
max1=Math.min(max,max1);
}
int min=max1;
for (int i1=0;i1<m;i1++){
max=0;
for (int j=0;j<n;j++){
max+= r[g[j][i1]]-g[j][i1];
}
max1=Math.min(max,max1);
}
min=Math.min(min, max1);
System.out.print(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Scanner;
import java.util.stream.IntStream;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
int m = sc.nextInt();
int[][] matrix = new int[n][m];
for (int r = 0; r < n; r++) {
for (int c = 0; c < m; c++) {
matrix[r][c] = sc.nextInt();
}
}
System.out.println(solve(matrix));
sc.close();
}
static int solve(int[][] matrix) {
int n = matrix.length;
int m = matrix[0].length;
int max = Arrays.stream(matrix).mapToInt(row -> Arrays.stream(row).max().getAsInt()).max().getAsInt();
List<Integer> primes = buildPrimes(max);
int[][] moveNums = IntStream.range(0, n)
.mapToObj(r -> IntStream.range(0, m).map(c -> computeMoveNum(primes, matrix[r][c])).toArray())
.toArray(int[][]::new);
int[] rowSums = IntStream.range(0, n).map(r -> Arrays.stream(moveNums[r]).sum()).toArray();
int[] colSums = IntStream.range(0, m).map(c -> IntStream.range(0, n).map(r -> moveNums[r][c]).sum()).toArray();
return Math.min(Arrays.stream(rowSums).min().getAsInt(), Arrays.stream(colSums).min().getAsInt());
}
static List<Integer> buildPrimes(int max) {
List<Integer> primes = new ArrayList<>();
for (int i = 2;; i++) {
if (isPrime(primes, i)) {
primes.add(i);
if (i >= max) {
return primes;
}
}
}
}
static boolean isPrime(List<Integer> primes, int x) {
for (int prime : primes) {
if (x % prime == 0) {
return false;
}
}
return true;
}
static int computeMoveNum(List<Integer> primes, int x) {
int index = Collections.binarySearch(primes, x);
if (index >= 0) {
return 0;
} else {
return primes.get(-1 - index) - x;
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool isPrime[1000011];
void sieve() {
int N = 1000011;
for (int i = 0; i <= N; i++) isPrime[i] = true;
isPrime[0] = 0;
isPrime[1] = 0;
for (int i = 2; i * i <= N; i++) {
if (isPrime[i] == true) {
for (int j = i * i; j <= N; j += i) isPrime[j] = false;
}
}
}
int main() {
sieve();
int n, m, c1 = 0, c2 = 0;
vector<int> v1;
vector<int> v2;
cin >> n >> m;
int arr[n][m], temp;
for (int i = 0; i < n; i++) {
c2 = 0;
for (int j = 0; j < m; j++) {
c1 = 0;
cin >> arr[i][j];
temp = arr[i][j];
if (!isPrime[temp]) {
while (!isPrime[temp]) {
temp++;
c1++;
c2++;
}
}
v1.push_back(c1);
}
v2.push_back(c2);
}
for (int j = 0; j < m; j++) {
c2 = 0;
for (int i = 0; i < n; i++) {
c1 = 0;
temp = arr[i][j];
if (temp) {
while (!isPrime[temp]) {
temp++;
c1++;
c2++;
}
}
v1.push_back(c1);
}
v2.push_back(c2);
}
sort(v2.begin(), v2.end());
cout << v2[0] << endl;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #!/usr/bin/env python
from sys import stdin as cin
def main():
n, m = map(int, next(cin).split())
mind = 100000000
sumline = [0] * m
for i in range(n):
line = [pdist[int(k)] for k in next(cin).split()]
mind = min(mind, sum(line))
sumline = [sumline[j] + line[j] for j in range(m)]
return min(mind, min(sumline))
def calc_pdist():
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)
pdist = [0 for i in range(100009)]
l = 0
for r in primes:
for i in range(l, r):
pdist[i] = r - i
l = r + 1
return pdist
pdist = calc_pdist()
print main()
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def iarr(): return map(int,raw_input().split())
limit = 100010
p = [1] * limit
p[1] = 0
p[0] = 0
for i in xrange(2,limit):
if(p[i]):
for j in xrange(2*i,limit,i):
p[j] = 0
for i in xrange(limit-2,-1,-1):
if(p[i] == 1):
p[i] = 0
else:
p[i] = 1+p[i+1]
[n,m] = iarr()
rmin = 10**9
c = [0] * m
for row in xrange(n):
arr = [p[int(s)] for s in raw_input().split()]
for i in xrange(m):
c[i] += arr[i]
rmin = min(rmin,sum(arr))
print min(c + [rmin])
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys, math
def rs():
return sys.stdin.readline().strip()
def ri():
return int(sys.stdin.readline().strip())
def ras():
return list(sys.stdin.readline().strip())
def rai():
return map(int,sys.stdin.readline().strip().split())
def main():
M = 100099
n,m = rai()
arr = []
for i in xrange(n):
arr.append(rai())
arr2 = [0]*n
arr3 = [0]*m
def pr():
a = [True] * M
for i in xrange(2, M):
for j in xrange(i * 2, M, i):
a[j] = False
return [i for i in xrange(2, M) if a[i]]
par = pr()
map_ = {}
for i in xrange(1,len(par)):
for j in xrange(par[i],par[i-1],-1):
map_[j] = par[i]
for i in xrange(n):
for j in xrange(m):
t = arr[i][j] <= 2 and 2 or map_[arr[i][j]]
arr2[i] += (t - arr[i][j])
arr3[j] += (t - arr[i][j])
m1 = min(arr2)
m2 = min(arr3)
print min(m1,m2)
if __name__ == "__main__":
main() | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
import java.math.*;
import java.lang.reflect.*;
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);
Task solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
interface Task {
public void solve(int testNumber, InputReader in, OutputWriter out);
}
class TaskA implements Task {
public void solve(int testNumber, InputReader in, OutputWriter out) {
out.printLine(in.readInt(), 0, 0);
}
}
class TaskB implements Task {
int[][] matrix;
int[] array;
boolean[] isPrime;
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n=in.readInt(), m=in.readInt(), ret=Integer.MAX_VALUE;
matrix=IOUtils.readIntTable(in, n, m);
isPrime=IntegerUtils.generatePrimalityTable(1000000);
for (int i=0; i<n; i++) {
array=matrix[i];
int c=0;
for (int j=0; j<m; j++) for (int k=0; !isPrime[array[j]+k]; k++) c++;
ret=MiscUtils.min(ret, c);
}
for (int i=0; i<m; i++) {
array=new int[n];
for (int j=0; j<n; j++) array[j]=matrix[j][i];
int c=0;
for (int j=0; j<n; j++) for (int k=0; !isPrime[array[j]+k]; k++) c++;
ret=MiscUtils.min(ret, c);
}
out.printLine(ret);
}
}
class TaskC implements Task {
int[] primes;
public void solve(int testNumber, InputReader in, OutputWriter out) {
primes=IntegerUtils.generatePrimes(10000000);
int n=in.readInt(), k=in.readInt();
if (k<n/2 || n<2 && k>0) {
out.printLine(-1);
return;
}
if (k==0) {
out.printLine(1);
return;
}
k-=(n-2)/2;
if (k==1) n+=2;
else out.print(2*k, 3*k, "");
for (int i=0; i<n-2; i++) out.print(primes[i], "");
}
}
class TaskD implements Task {
public void solve(int testNumber, InputReader in, OutputWriter out) {
int n=in.readInt();
out.printLine(1L*(n/2+1)*((n+1)/2+1)%1000000009);
}
}
class TaskE implements Task {
public void solve(int testNumber, InputReader in, OutputWriter out) {
}
}
class TaskF implements Task {
public void solve(int testNumber, InputReader in, OutputWriter out) {
}
}
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(char[] array) {
writer.print(array);
}
public void print(Object... objects) {
for (int i = 0; i < objects.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(objects[i]);
}
}
public void print(int[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(array[i]);
}
}
public void print(long[] array) {
for (int i = 0; i < array.length; i++) {
if (i != 0)
writer.print(' ');
writer.print(array[i]);
}
}
public void print(Collection<Integer> collection) {
boolean first = true;
for (int value : collection) {
if (first)
first = false;
else
writer.print(' ');
writer.print(value);
}
}
public void printLine(int[] array) {
print(array);
writer.println();
}
public void printLine(long[] array) {
print(array);
writer.println();
}
public void printLine(Collection<Integer> collection) {
print(collection);
writer.println();
}
public void printLine() {
writer.println();
}
public void printLine(Object... objects) {
print(objects);
writer.println();
}
public void print(char i) {
writer.print(i);
}
public void printLine(char i) {
writer.println(i);
}
public void printLine(char[] array) {
writer.println(array);
}
public void printFormat(String format, Object... objects) {
writer.printf(format, objects);
}
public void close() {
writer.close();
}
public void flush() {
writer.flush();
}
public void print(long i) {
writer.print(i);
}
public void printLine(long i) {
writer.println(i);
}
public void print(int i) {
writer.print(i);
}
public void printLine(int i) {
writer.println(i);
}
}
class InputReader {
private boolean finished = false;
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 peek() {
if (numChars == -1)
return -1;
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
return -1;
}
if (numChars <= 0)
return -1;
}
return buf[curChar];
}
public int readInt() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long readLong() {
int c = read();
while (isSpaceChar(c))
c = read();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public String readString() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
if (Character.isValidCodePoint(c))
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
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;
}
private String readLine0() {
StringBuilder buf = new StringBuilder();
int c = read();
while (c != '\n' && c != -1) {
if (c != '\r')
buf.appendCodePoint(c);
c = read();
}
return buf.toString();
}
public String readLine() {
String s = readLine0();
while (s.trim().length() == 0)
s = readLine0();
return s;
}
public String readLine(boolean ignoreEmptyLines) {
if (ignoreEmptyLines)
return readLine();
else
return readLine0();
}
public BigInteger readBigInteger() {
try {
return new BigInteger(readString());
} catch (NumberFormatException e) {
throw new InputMismatchException();
}
}
public char readCharacter() {
int c = read();
while (isSpaceChar(c))
c = read();
return (char) c;
}
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, readInt());
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, readInt());
if (c < '0' || c > '9')
throw new InputMismatchException();
m /= 10;
res += (c - '0') * m;
c = read();
}
}
return res * sgn;
}
public boolean isExhausted() {
int value;
while (isSpaceChar(value = peek()) && value != -1)
read();
return value == -1;
}
public String next() {
return readString();
}
public SpaceCharFilter getFilter() {
return filter;
}
public void setFilter(SpaceCharFilter filter) {
this.filter = filter;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
class IOUtils {
public static Pair<Integer, Integer> readIntPair(InputReader in) {
int first = in.readInt();
int second = in.readInt();
return Pair.makePair(first, second);
}
public static Pair<Long, Long> readLongPair(InputReader in) {
long first = in.readLong();
long second = in.readLong();
return Pair.makePair(first, second);
}
public static int[] readIntArray(InputReader in, int size) {
int[] array = new int[size];
for (int i = 0; i < size; i++)
array[i] = in.readInt();
return array;
}
public static long[] readLongArray(InputReader in, int size) {
long[] array = new long[size];
for (int i = 0; i < size; i++)
array[i] = in.readLong();
return array;
}
public static double[] readDoubleArray(InputReader in, int size) {
double[] array = new double[size];
for (int i = 0; i < size; i++)
array[i] = in.readDouble();
return array;
}
public static String[] readStringArray(InputReader in, int size) {
String[] array = new String[size];
for (int i = 0; i < size; i++)
array[i] = in.readString();
return array;
}
public static char[] readCharArray(InputReader in, int size) {
char[] array = new char[size];
for (int i = 0; i < size; i++)
array[i] = in.readCharacter();
return array;
}
public static Pair<Integer, Integer>[] readIntPairArray(InputReader in,
int size) {
@SuppressWarnings({ "unchecked" })
Pair<Integer, Integer>[] result = new Pair[size];
for (int i = 0; i < size; i++)
result[i] = readIntPair(in);
return result;
}
public static Pair<Long, Long>[] readLongPairArray(InputReader in, int size) {
@SuppressWarnings({ "unchecked" })
Pair<Long, Long>[] result = new Pair[size];
for (int i = 0; i < size; i++)
result[i] = readLongPair(in);
return result;
}
public static void readIntArrays(InputReader in, int[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++)
arrays[j][i] = in.readInt();
}
}
public static void readLongArrays(InputReader in, long[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++)
arrays[j][i] = in.readLong();
}
}
public static void readDoubleArrays(InputReader in, double[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++)
arrays[j][i] = in.readDouble();
}
}
public static char[][] readTable(InputReader in, int rowCount,
int columnCount) {
char[][] table = new char[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readCharArray(in, columnCount);
return table;
}
public static int[][] readIntTable(InputReader in, int rowCount,
int columnCount) {
int[][] table = new int[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readIntArray(in, columnCount);
return table;
}
public static double[][] readDoubleTable(InputReader in, int rowCount,
int columnCount) {
double[][] table = new double[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readDoubleArray(in, columnCount);
return table;
}
public static long[][] readLongTable(InputReader in, int rowCount,
int columnCount) {
long[][] table = new long[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readLongArray(in, columnCount);
return table;
}
public static String[][] readStringTable(InputReader in, int rowCount,
int columnCount) {
String[][] table = new String[rowCount][];
for (int i = 0; i < rowCount; i++)
table[i] = readStringArray(in, columnCount);
return table;
}
public static String readText(InputReader in) {
StringBuilder result = new StringBuilder();
while (true) {
int character = in.read();
if (character == '\r')
continue;
if (character == -1)
break;
result.append((char) character);
}
return result.toString();
}
public static void readStringArrays(InputReader in, String[]... arrays) {
for (int i = 0; i < arrays[0].length; i++) {
for (int j = 0; j < arrays.length; j++)
arrays[j][i] = in.readString();
}
}
public static void printTable(OutputWriter out, char[][] table) {
for (char[] row : table)
out.printLine(new String(row));
}
}
class ArrayUtils {
private static int[] tempInt = new int[0];
private static long[] tempLong = new long[0];
public static Integer[] generateOrder(int size) {
Integer[] order = new Integer[size];
for (int i = 0; i < size; i++)
order[i] = i;
return order;
}
public static void fill(short[][] array, short value) {
for (short[] row : array)
Arrays.fill(row, value);
}
public static void fill(long[][] array, long value) {
for (long[] row : array)
Arrays.fill(row, value);
}
public static void fill(double[][] array, double value) {
for (double[] row : array)
Arrays.fill(row, value);
}
public static void fill(double[][][] array, double value) {
for (double[][] row : array)
fill(row, value);
}
public static void fill(double[][][][] array, double value) {
for (double[][][] row : array)
fill(row, value);
}
public static void fill(double[][][][][] array, double value) {
for (double[][][][] row : array)
fill(row, value);
}
public static void fill(long[][][] array, long value) {
for (long[][] row : array)
fill(row, value);
}
public static void fill(long[][][][] array, long value) {
for (long[][][] row : array)
fill(row, value);
}
public static void fill(long[][][][][] array, long value) {
for (long[][][][] row : array)
fill(row, value);
}
public static void fillColumn(long[][] array, int index, long value) {
for (long[] row : array)
row[index] = value;
}
public static void fillColumn(int[][] array, int index, int value) {
for (int[] row : array)
row[index] = value;
}
public static void fill(int[][] array, int value) {
for (int[] row : array)
Arrays.fill(row, value);
}
public static void fill(boolean[][] array, boolean value) {
for (boolean[] row : array)
Arrays.fill(row, value);
}
public static void fill(boolean[][][] array, boolean value) {
for (boolean[][] row : array)
fill(row, value);
}
public static long sumArray(int[] array) {
long result = 0;
for (int element : array)
result += element;
return result;
}
public static int[] range(int from, int to) {
int[] result = new int[Math.max(from, to) - Math.min(from, to) + 1];
int index = 0;
if (to > from) {
for (int i = from; i <= to; i++)
result[index++] = i;
} else {
for (int i = from; i >= to; i--)
result[index++] = i;
}
return result;
}
public static void fill(int[][][] array, int value) {
for (int[][] subArray : array)
fill(subArray, value);
}
public static void fill(short[][][] array, short value) {
for (short[][] subArray : array)
fill(subArray, value);
}
public static void fill(int[][][][] array, int value) {
for (int[][][] subArray : array)
fill(subArray, value);
}
public static void fill(short[][][][] array, short value) {
for (short[][][] subArray : array)
fill(subArray, value);
}
public static void fill(int[][][][][] array, int value) {
for (int[][][][] subArray : array)
fill(subArray, value);
}
public static void fill(short[][][][][] array, short value) {
for (short[][][][] subArray : array)
fill(subArray, value);
}
public static void fill(int[][][][][][] array, int value) {
for (int[][][][][] subArray : array)
fill(subArray, value);
}
public static void fill(short[][][][][][] array, short value) {
for (short[][][][][] subArray : array)
fill(subArray, value);
}
public static void fill(int[][][][][][][] array, int value) {
for (int[][][][][][] subArray : array)
fill(subArray, value);
}
public static void fill(short[][][][][][][] array, short value) {
for (short[][][][][][] subArray : array)
fill(subArray, value);
}
public static Integer[] order(int size, Comparator<Integer> comparator) {
Integer[] order = generateOrder(size);
Arrays.sort(order, comparator);
return order;
}
public static <T> void fill(T[][] array, T value) {
for (T[] row : array)
Arrays.fill(row, value);
}
public static void fill(char[][] array, char value) {
for (char[] row : array)
Arrays.fill(row, value);
}
public static void fill(byte[][] array, byte value) {
for (byte[] row : array)
Arrays.fill(row, value);
}
public static void fill(byte[][][] array, byte value) {
for (byte[][] row : array)
fill(row, value);
}
public static void fill(byte[][][][] array, byte value) {
for (byte[][][] row : array)
fill(row, value);
}
public static long multiply(int[] first, int[] second) {
long result = 0;
for (int i = 0; i < first.length; i++)
result += (long) first[i] * second[i];
return result;
}
public static int[] createOrder(int size) {
int[] order = new int[size];
for (int i = 0; i < size; i++)
order[i] = i;
return order;
}
public static int[] sort(int[] array, IntComparator comparator) {
return sort(array, 0, array.length, comparator);
}
public static int[] sort(int[] array, int from, int to,
IntComparator comparator) {
Integer[] intArray = new Integer[to - from];
for (int i = from; i < to; i++)
intArray[i - from] = array[i];
Arrays.sort(intArray, comparator);
for (int i=from; i<to; i++) array[i]=intArray[i-from];
return array;
}
private static void ensureCapacityInt(int size) {
if (tempInt.length >= size)
return;
size = Math.max(size, tempInt.length << 1);
tempInt = new int[size];
}
private static void ensureCapacityLong(int size) {
if (tempLong.length >= size)
return;
size = Math.max(size, tempLong.length << 1);
tempLong = new long[size];
}
private static void sortImpl(int[] array, int from, int to, int[] temp,
int fromTemp, int toTemp, IntComparator comparator) {
if (to - from <= 1)
return;
int middle = (to - from) >> 1;
int tempMiddle = fromTemp + middle;
sortImpl(temp, fromTemp, tempMiddle, array, from, from + middle,
comparator);
sortImpl(temp, tempMiddle, toTemp, array, from + middle, to, comparator);
int index = from;
int index1 = fromTemp;
int index2 = tempMiddle;
while (index1 < tempMiddle && index2 < toTemp) {
if (comparator.compare(temp[index1], temp[index2]) <= 0)
array[index++] = temp[index1++];
else
array[index++] = temp[index2++];
}
if (index1 != tempMiddle)
System.arraycopy(temp, index1, array, index, tempMiddle - index1);
if (index2 != toTemp)
System.arraycopy(temp, index2, array, index, toTemp - index2);
}
public static int[] order(final int[] array) {
return sort(createOrder(array.length), new IntComparator() {
public int compare(Integer first, Integer second) {
if (array[first] < array[second])
return -1;
if (array[first] > array[second])
return 1;
return 0;
}
});
}
public static int[] order(final long[] array) {
return sort(createOrder(array.length), new IntComparator() {
public int compare(Integer first, Integer second) {
if (array[first] < array[second])
return -1;
if (array[first] > array[second])
return 1;
return 0;
}
});
}
public static int[] unique(int[] array) {
return unique(array, 0, array.length);
}
public static int[] unique(int[] array, int from, int to) {
if (from == to)
return new int[0];
int count = 1;
for (int i = from + 1; i < to; i++) {
if (array[i] != array[i - 1])
count++;
}
int[] result = new int[count];
result[0] = array[from];
int index = 1;
for (int i = from + 1; i < to; i++) {
if (array[i] != array[i - 1])
result[index++] = array[i];
}
return result;
}
public static char[] unique(char[] array) {
return unique(array, 0, array.length);
}
public static char[] unique(char[] array, int from, int to) {
if (from == to)
return new char[0];
int count = 1;
for (int i = from + 1; i < to; i++) {
if (array[i] != array[i - 1])
count++;
}
char[] result = new char[count];
result[0] = array[from];
int index = 1;
for (int i = from + 1; i < to; i++) {
if (array[i] != array[i - 1])
result[index++] = array[i];
}
return result;
}
public static int maxElement(int[] array) {
return maxElement(array, 0, array.length);
}
public static int maxElement(int[] array, int from, int to) {
int result = Integer.MIN_VALUE;
for (int i = from; i < to; i++)
result = Math.max(result, array[i]);
return result;
}
public static int[] order(final double[] array) {
return sort(createOrder(array.length), new IntComparator() {
public int compare(Integer first, Integer second) {
return Double.compare(array[first], array[second]);
}
});
}
public static int[] reversePermutation(int[] permutation) {
int[] result = new int[permutation.length];
for (int i = 0; i < permutation.length; i++)
result[permutation[i]] = i;
return result;
}
public static void reverse(int[] array) {
for (int i = 0, j = array.length - 1; i < j; i++, j--) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
public static void reverse(char[] array) {
for (int i = 0, j = array.length - 1; i < j; i++, j--) {
char temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
private static long maxElement(long[] array, int from, int to) {
long result = Long.MIN_VALUE;
for (int i = from; i < to; i++)
result = Math.max(result, array[i]);
return result;
}
public static int minPosition(int[] array) {
return minPosition(array, 0, array.length);
}
public static int maxPosition(int[] array) {
return maxPosition(array, 0, array.length);
}
public static int minPosition(int[] array, int from, int to) {
if (from >= to)
return -1;
int min = array[from];
int result = from;
for (int i = from + 1; i < to; i++) {
if (array[i] < min) {
min = array[i];
result = i;
}
}
return result;
}
public static int maxPosition(int[] array, int from, int to) {
if (from >= to)
return -1;
int max = array[from];
int result = from;
for (int i = from + 1; i < to; i++) {
if (array[i] > max) {
max = array[i];
result = i;
}
}
return result;
}
public static int[] multiplyPermutations(int[] first, int[] second) {
int count = first.length;
int[] result = new int[count];
for (int i = 0; i < count; i++) {
result[i] = first[second[i]];
}
return result;
}
public static int[] compress(int[]... arrays) {
int totalLength = 0;
for (int[] array : arrays)
totalLength += array.length;
int[] all = new int[totalLength];
int delta = 0;
for (int[] array : arrays) {
System.arraycopy(array, 0, all, delta, array.length);
delta += array.length;
}
sort(all, IntComparator.DEFAULT);
all = unique(all);
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++)
array[i] = Arrays.binarySearch(all, array[i]);
}
return all;
}
public static int minElement(int[] array) {
return array[minPosition(array)];
}
public static long[] partialSums(int[] array) {
long[] result = new long[array.length + 1];
for (int i = 0; i < array.length; i++)
result[i + 1] = result[i] + array[i];
return result;
}
public static void orderBy(int[] base, int[]... arrays) {
int[] order = ArrayUtils.order(base);
order(order, base);
for (int[] array : arrays)
order(order, array);
}
public static void orderBy(long[] base, long[]... arrays) {
int[] order = ArrayUtils.order(base);
order(order, base);
for (long[] array : arrays)
order(order, array);
}
public static void order(int[] order, int[] array) {
ensureCapacityInt(order.length);
for (int i = 0; i < order.length; i++)
tempInt[i] = array[order[i]];
System.arraycopy(tempInt, 0, array, 0, array.length);
}
public static void order(int[] order, long[] array) {
ensureCapacityLong(order.length);
for (int i = 0; i < order.length; i++)
tempLong[i] = array[order[i]];
System.arraycopy(tempLong, 0, array, 0, array.length);
}
public static long[] asLong(int[] array) {
long[] result = new long[array.length];
for (int i = 0; i < array.length; i++)
result[i] = array[i];
return result;
}
public static int count(int[] array, int value) {
int result = 0;
for (int i : array) {
if (i == value)
result++;
}
return result;
}
public static int count(char[] array, char value) {
int result = 0;
for (char i : array) {
if (i == value)
result++;
}
return result;
}
public static int count(boolean[] array, boolean value) {
int result = 0;
for (boolean i : array) {
if (i == value)
result++;
}
return result;
}
public static int[] merge(int[] first, int[] second) {
int[] result = new int[first.length + second.length];
int firstIndex = 0;
int secondIndex = 0;
int index = 0;
while (firstIndex < first.length && secondIndex < second.length) {
if (first[firstIndex] < second[secondIndex])
result[index++] = first[firstIndex++];
else
result[index++] = second[secondIndex++];
}
System.arraycopy(first, firstIndex, result, index, first.length
- firstIndex);
System.arraycopy(second, secondIndex, result, index, second.length
- secondIndex);
return result;
}
public static boolean nextPermutation(int[] array) {
return nextPermutation(array, IntComparator.DEFAULT);
}
private static boolean nextPermutation(int[] array, IntComparator comparator) {
int size = array.length;
int last = array[size - 1];
for (int i = size - 2; i >= 0; i--) {
int current = array[i];
if (comparator.compare(last, current) > 0) {
for (int j = size - 1; j > i; j--) {
if (comparator.compare(array[j], current) > 0) {
swap(array, i, j);
inPlaceReverse(array, i + 1, size);
return true;
}
}
}
last = current;
}
return false;
}
private static void inPlaceReverse(int[] array, int first, int second) {
for (int i = first, j = second - 1; i < j; i++, j--)
swap(array, i, j);
}
private static void swap(int[] array, int first, int second) {
if (first == second)
return;
int temp = array[first];
array[first] = array[second];
array[second] = temp;
}
public static <V> void reverse(V[] array) {
for (int i = 0, j = array.length - 1; i < j; i++, j--) {
V temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
public static IntComparator compareBy(final int[]... arrays) {
return new IntComparator() {
public int compare(Integer first, Integer second) {
for (int[] array : arrays) {
if (array[first] != array[second])
return Integer.compare(array[first], array[second]);
}
return 0;
}
};
}
public static long minElement(long[] array) {
return array[minPosition(array)];
}
public static long maxElement(long[] array) {
return array[maxPosition(array)];
}
public static int minPosition(long[] array) {
return minPosition(array, 0, array.length);
}
public static int maxPosition(long[] array) {
return maxPosition(array, 0, array.length);
}
public static int minPosition(long[] array, int from, int to) {
if (from >= to)
return -1;
long min = array[from];
int result = from;
for (int i = from + 1; i < to; i++) {
if (array[i] < min) {
min = array[i];
result = i;
}
}
return result;
}
public static int maxPosition(long[] array, int from, int to) {
if (from >= to)
return -1;
long max = array[from];
int result = from;
for (int i = from + 1; i < to; i++) {
if (array[i] > max) {
max = array[i];
result = i;
}
}
return result;
}
public static int[] createArray(int count, int value) {
int[] array = new int[count];
Arrays.fill(array, value);
return array;
}
public static long[] createArray(int count, long value) {
long[] array = new long[count];
Arrays.fill(array, value);
return array;
}
public static double[] createArray(int count, double value) {
double[] array = new double[count];
Arrays.fill(array, value);
return array;
}
public static boolean[] createArray(int count, boolean value) {
boolean[] array = new boolean[count];
Arrays.fill(array, value);
return array;
}
public static char[] createArray(int count, char value) {
char[] array = new char[count];
Arrays.fill(array, value);
return array;
}
public static <T> T[] createArray(int count, T value) {
@SuppressWarnings("unchecked")
T[] array = (T[]) Array.newInstance(value.getClass(), count);
Arrays.fill(array, value);
return array;
}
}
class Graph {
public static final int REMOVED_BIT = 0;
protected int vertexCount;
protected int edgeCount;
private int[] firstOutbound;
private int[] firstInbound;
private Edge[] edges;
private int[] nextInbound;
private int[] nextOutbound;
private int[] from;
private int[] to;
private long[] weight;
private long[] capacity;
private int[] reverseEdge;
private int[] flags;
public Graph(int vertexCount) {
this(vertexCount, vertexCount);
}
public Graph(int vertexCount, int edgeCapacity) {
this.vertexCount = vertexCount;
firstOutbound = new int[vertexCount];
Arrays.fill(firstOutbound, -1);
from = new int[edgeCapacity];
to = new int[edgeCapacity];
nextOutbound = new int[edgeCapacity];
flags = new int[edgeCapacity];
}
public static Graph createGraph(int vertexCount, int[] from, int[] to) {
Graph graph = new Graph(vertexCount, from.length);
for (int i = 0; i < from.length; i++)
graph.addSimpleEdge(from[i], to[i]);
return graph;
}
public static Graph createWeightedGraph(int vertexCount, int[] from,
int[] to, long[] weight) {
Graph graph = new Graph(vertexCount, from.length);
for (int i = 0; i < from.length; i++)
graph.addWeightedEdge(from[i], to[i], weight[i]);
return graph;
}
public static Graph createFlowGraph(int vertexCount, int[] from, int[] to,
long[] capacity) {
Graph graph = new Graph(vertexCount, from.length * 2);
for (int i = 0; i < from.length; i++)
graph.addFlowEdge(from[i], to[i], capacity[i]);
return graph;
}
public static Graph createFlowWeightedGraph(int vertexCount, int[] from,
int[] to, long[] weight, long[] capacity) {
Graph graph = new Graph(vertexCount, from.length * 2);
for (int i = 0; i < from.length; i++)
graph.addFlowWeightedEdge(from[i], to[i], weight[i], capacity[i]);
return graph;
}
public static Graph createTree(int[] parent) {
Graph graph = new Graph(parent.length + 1, parent.length);
for (int i = 0; i < parent.length; i++)
graph.addSimpleEdge(parent[i], i + 1);
return graph;
}
public int addEdge(int fromID, int toID, long weight, long capacity,
int reverseEdge) {
ensureEdgeCapacity(edgeCount + 1);
if (firstOutbound[fromID] != -1)
nextOutbound[edgeCount] = firstOutbound[fromID];
else
nextOutbound[edgeCount] = -1;
firstOutbound[fromID] = edgeCount;
if (firstInbound != null) {
if (firstInbound[toID] != -1)
nextInbound[edgeCount] = firstInbound[toID];
else
nextInbound[edgeCount] = -1;
firstInbound[toID] = edgeCount;
}
this.from[edgeCount] = fromID;
this.to[edgeCount] = toID;
if (capacity != 0) {
if (this.capacity == null)
this.capacity = new long[from.length];
this.capacity[edgeCount] = capacity;
}
if (weight != 0) {
if (this.weight == null)
this.weight = new long[from.length];
this.weight[edgeCount] = weight;
}
if (reverseEdge != -1) {
if (this.reverseEdge == null) {
this.reverseEdge = new int[from.length];
Arrays.fill(this.reverseEdge, 0, edgeCount, -1);
}
this.reverseEdge[edgeCount] = reverseEdge;
}
if (edges != null)
edges[edgeCount] = createEdge(edgeCount);
return edgeCount++;
}
protected final GraphEdge createEdge(int id) {
return new GraphEdge(id);
}
public final int addFlowWeightedEdge(int from, int to, long weight,
long capacity) {
if (capacity == 0) {
return addEdge(from, to, weight, 0, -1);
} else {
int lastEdgeCount = edgeCount;
addEdge(to, from, -weight, 0, lastEdgeCount + entriesPerEdge());
return addEdge(from, to, weight, capacity, lastEdgeCount);
}
}
protected int entriesPerEdge() {
return 1;
}
public final int addFlowEdge(int from, int to, long capacity) {
return addFlowWeightedEdge(from, to, 0, capacity);
}
public final int addWeightedEdge(int from, int to, long weight) {
return addFlowWeightedEdge(from, to, weight, 0);
}
public final int addSimpleEdge(int from, int to) {
return addWeightedEdge(from, to, 0);
}
public final int vertexCount() {
return vertexCount;
}
public final int edgeCount() {
return edgeCount;
}
protected final int edgeCapacity() {
return from.length;
}
public final Edge edge(int id) {
initEdges();
return edges[id];
}
public final int firstOutbound(int vertex) {
int id = firstOutbound[vertex];
while (id != -1 && isRemoved(id))
id = nextOutbound[id];
return id;
}
public final int nextOutbound(int id) {
id = nextOutbound[id];
while (id != -1 && isRemoved(id))
id = nextOutbound[id];
return id;
}
public final int firstInbound(int vertex) {
initInbound();
int id = firstInbound[vertex];
while (id != -1 && isRemoved(id))
id = nextInbound[id];
return id;
}
public final int nextInbound(int id) {
initInbound();
id = nextInbound[id];
while (id != -1 && isRemoved(id))
id = nextInbound[id];
return id;
}
public final int source(int id) {
return from[id];
}
public final int destination(int id) {
return to[id];
}
public final long weight(int id) {
if (weight == null)
return 0;
return weight[id];
}
public final long capacity(int id) {
if (capacity == null)
return 0;
return capacity[id];
}
public final long flow(int id) {
if (reverseEdge == null)
return 0;
return capacity[reverseEdge[id]];
}
public final void pushFlow(int id, long flow) {
if (flow == 0)
return;
if (flow > 0) {
if (capacity(id) < flow)
throw new IllegalArgumentException("Not enough capacity");
} else {
if (flow(id) < -flow)
throw new IllegalArgumentException("Not enough capacity");
}
capacity[id] -= flow;
capacity[reverseEdge[id]] += flow;
}
public int transposed(int id) {
return -1;
}
public final int reverse(int id) {
if (reverseEdge == null)
return -1;
return reverseEdge[id];
}
public final void addVertices(int count) {
ensureVertexCapacity(vertexCount + count);
Arrays.fill(firstOutbound, vertexCount, vertexCount + count, -1);
if (firstInbound != null)
Arrays.fill(firstInbound, vertexCount, vertexCount + count, -1);
vertexCount += count;
}
protected final void initEdges() {
if (edges == null) {
edges = new Edge[from.length];
for (int i = 0; i < edgeCount; i++)
edges[i] = createEdge(i);
}
}
public final void removeVertex(int vertex) {
int id = firstOutbound[vertex];
while (id != -1) {
removeEdge(id);
id = nextOutbound[id];
}
initInbound();
id = firstInbound[vertex];
while (id != -1) {
removeEdge(id);
id = nextInbound[id];
}
}
private void initInbound() {
if (firstInbound == null) {
firstInbound = new int[firstOutbound.length];
Arrays.fill(firstInbound, 0, vertexCount, -1);
nextInbound = new int[from.length];
for (int i = 0; i < edgeCount; i++) {
nextInbound[i] = firstInbound[to[i]];
firstInbound[to[i]] = i;
}
}
}
public final boolean flag(int id, int bit) {
return (flags[id] >> bit & 1) != 0;
}
public final void setFlag(int id, int bit) {
flags[id] |= 1 << bit;
}
public final void removeFlag(int id, int bit) {
flags[id] &= -1 - (1 << bit);
}
public final void removeEdge(int id) {
setFlag(id, REMOVED_BIT);
}
public final void restoreEdge(int id) {
removeFlag(id, REMOVED_BIT);
}
public final boolean isRemoved(int id) {
return flag(id, REMOVED_BIT);
}
public final Iterable<Edge> outbound(final int id) {
initEdges();
return new Iterable<Edge>() {
public Iterator<Edge> iterator() {
return new EdgeIterator(id, firstOutbound, nextOutbound);
}
};
}
public final Iterable<Edge> inbound(final int id) {
initEdges();
initInbound();
return new Iterable<Edge>() {
public Iterator<Edge> iterator() {
return new EdgeIterator(id, firstInbound, nextInbound);
}
};
}
protected void ensureEdgeCapacity(int size) {
if (from.length < size) {
int newSize = Math.max(size, 2 * from.length);
if (edges != null)
edges = resize(edges, newSize);
from = resize(from, newSize);
to = resize(to, newSize);
nextOutbound = resize(nextOutbound, newSize);
if (nextInbound != null)
nextInbound = resize(nextInbound, newSize);
if (weight != null)
weight = resize(weight, newSize);
if (capacity != null)
capacity = resize(capacity, newSize);
if (reverseEdge != null)
reverseEdge = resize(reverseEdge, newSize);
flags = resize(flags, newSize);
}
}
private void ensureVertexCapacity(int size) {
if (firstOutbound.length < size) {
int newSize = Math.max(size, 2 * from.length);
firstOutbound = resize(firstOutbound, newSize);
if (firstInbound != null)
firstInbound = resize(firstInbound, newSize);
}
}
protected final int[] resize(int[] array, int size) {
int[] newArray = new int[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
private long[] resize(long[] array, int size) {
long[] newArray = new long[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
private Edge[] resize(Edge[] array, int size) {
Edge[] newArray = new Edge[size];
System.arraycopy(array, 0, newArray, 0, array.length);
return newArray;
}
public final boolean isSparse() {
return vertexCount == 0 || edgeCount * 20 / vertexCount <= vertexCount;
}
protected class GraphEdge implements Edge {
protected int id;
protected GraphEdge(int id) {
this.id = id;
}
public int getSource() {
return source(id);
}
public int getDestination() {
return destination(id);
}
public long getWeight() {
return weight(id);
}
public long getCapacity() {
return capacity(id);
}
public long getFlow() {
return flow(id);
}
public void pushFlow(long flow) {
Graph.this.pushFlow(id, flow);
}
public boolean getFlag(int bit) {
return flag(id, bit);
}
public void setFlag(int bit) {
Graph.this.setFlag(id, bit);
}
public void removeFlag(int bit) {
Graph.this.removeFlag(id, bit);
}
public int getTransposedID() {
return transposed(id);
}
public Edge getTransposedEdge() {
int reverseID = getTransposedID();
if (reverseID == -1)
return null;
initEdges();
return edge(reverseID);
}
public int getReverseID() {
return reverse(id);
}
public Edge getReverseEdge() {
int reverseID = getReverseID();
if (reverseID == -1)
return null;
initEdges();
return edge(reverseID);
}
public int getID() {
return id;
}
public void remove() {
removeEdge(id);
}
public void restore() {
restoreEdge(id);
}
}
public class EdgeIterator implements Iterator<Edge> {
private int edgeID;
private final int[] next;
private int lastID = -1;
public EdgeIterator(int id, int[] first, int[] next) {
this.next = next;
edgeID = nextEdge(first[id]);
}
private int nextEdge(int id) {
while (id != -1 && isRemoved(id))
id = next[id];
return id;
}
public boolean hasNext() {
return edgeID != -1;
}
public Edge next() {
if (edgeID == -1)
throw new NoSuchElementException();
lastID = edgeID;
edgeID = nextEdge(next[lastID]);
return edges[lastID];
}
public void remove() {
if (lastID == -1)
throw new IllegalStateException();
removeEdge(lastID);
lastID = -1;
}
}
}
class MiscUtils {
public static final int[] DX4 = { 1, 0, -1, 0 };
public static final int[] DY4 = { 0, -1, 0, 1 };
public static final int[] DX8 = { 1, 1, 1, 0, -1, -1, -1, 0 };
public static final int[] DY8 = { -1, 0, 1, 1, 1, 0, -1, -1 };
public static final int[] DX_KNIGHT = { 2, 1, -1, -2, -2, -1, 1, 2 };
public static final int[] DY_KNIGHT = { 1, 2, 2, 1, -1, -2, -2, -1 };
private static final String[] ROMAN_TOKENS = { "M", "CM", "D", "CD", "C",
"XC", "L", "XL", "X", "IX", "V", "IV", "I" };
private static final int[] ROMAN_VALUES = { 1000, 900, 500, 400, 100, 90,
50, 40, 10, 9, 5, 4, 1 };
public static long josephProblem(long n, int k) {
if (n == 1)
return 0;
if (k == 1)
return n - 1;
if (k > n)
return (josephProblem(n - 1, k) + k) % n;
long count = n / k;
long result = josephProblem(n - count, k);
result -= n % k;
if (result < 0)
result += n;
else
result += result / (k - 1);
return result;
}
public static boolean isValidCell(int row, int column, int rowCount,
int columnCount) {
return row >= 0 && row < rowCount && column >= 0
&& column < columnCount;
}
public static List<Integer> getPath(int[] last, int destination) {
List<Integer> path = new ArrayList<Integer>();
while (destination != -1) {
path.add(destination);
destination = last[destination];
}
inPlaceReverse(path);
return path;
}
private static void inPlaceReverse(List<Integer> list) {
for (int i = 0, j = list.size() - 1; i < j; i++, j--)
swap(list, i, j);
}
private static void swap(List<Integer> list, int first, int second) {
if (first == second)
return;
int temp = list.get(first);
list.set(first, list.get(second));
list.set(second, temp);
}
public static List<Integer> getPath(int[][] lastIndex,
int[][] lastPathNumber, int destination, int pathNumber) {
List<Integer> path = new ArrayList<Integer>();
while (destination != -1 || pathNumber != 0) {
path.add(destination);
int nextDestination = lastIndex[destination][pathNumber];
pathNumber = lastPathNumber[destination][pathNumber];
destination = nextDestination;
}
inPlaceReverse(path);
return path;
}
public static long maximalRectangleSum(long[][] array) {
int n = array.length;
int m = array[0].length;
long[][] partialSums = new long[n + 1][m + 1];
for (int i = 0; i < n; i++) {
long rowSum = 0;
for (int j = 0; j < m; j++) {
rowSum += array[i][j];
partialSums[i + 1][j + 1] = partialSums[i][j + 1] + rowSum;
}
}
long result = Long.MIN_VALUE;
for (int i = 0; i < m; i++) {
for (int j = i; j < m; j++) {
long minPartialSum = 0;
for (int k = 1; k <= n; k++) {
long current = partialSums[k][j + 1] - partialSums[k][i];
result = Math.max(result, current - minPartialSum);
minPartialSum = Math.min(minPartialSum, current);
}
}
}
return result;
}
public static int parseIP(String ip) {
String[] components = ip.split("[.]");
int result = 0;
for (int i = 0; i < 4; i++)
result += (1 << (24 - 8 * i)) * Integer.parseInt(components[i]);
return result;
}
public static String buildIP(int mask) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < 4; i++) {
if (i != 0)
result.append('.');
result.append(mask >> (24 - 8 * i) & 255);
}
return result.toString();
}
public static long binarySearch(long from, long to,
Function<Long, Boolean> function) {
while (from < to) {
long argument = from + (to - from) / 2;
if (function.value(argument))
to = argument;
else
from = argument + 1;
}
return from;
}
public static <T> boolean equals(T first, T second) {
return first == null && second == null || first != null
&& first.equals(second);
}
public static boolean isVowel(char ch) {
ch = Character.toUpperCase(ch);
return ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U'
|| ch == 'Y';
}
public static boolean isStrictVowel(char ch) {
ch = Character.toUpperCase(ch);
return ch == 'A' || ch == 'E' || ch == 'I' || ch == 'O' || ch == 'U';
}
public static String convertToRoman(int number) {
StringBuilder result = new StringBuilder();
for (int i = 0; i < ROMAN_TOKENS.length; i++) {
while (number >= ROMAN_VALUES[i]) {
number -= ROMAN_VALUES[i];
result.append(ROMAN_TOKENS[i]);
}
}
return result.toString();
}
public static int convertFromRoman(String number) {
int result = 0;
for (int i = 0; i < ROMAN_TOKENS.length; i++) {
while (number.startsWith(ROMAN_TOKENS[i])) {
number = number.substring(ROMAN_TOKENS[i].length());
result += ROMAN_VALUES[i];
}
}
return result;
}
public static int distance(int x1, int y1, int x2, int y2) {
int dx = x1 - x2;
int dy = y1 - y2;
return dx * dx + dy * dy;
}
public static <T extends Comparable<T>> T min(T first, T second) {
if (first.compareTo(second) <= 0)
return first;
return second;
}
public static <T extends Comparable<T>> T max(T first, T second) {
if (first.compareTo(second) <= 0)
return second;
return first;
}
public static void decreaseByOne(int[]... arrays) {
for (int[] array : arrays) {
for (int i = 0; i < array.length; i++)
array[i]--;
}
}
public static int[] getIntArray(String s) {
String[] tokens = s.split(" ");
int[] result = new int[tokens.length];
for (int i = 0; i < result.length; i++)
result[i] = Integer.parseInt(tokens[i]);
return result;
}
}
class IntegerUtils {
public static long gcd(long a, long b) {
a = Math.abs(a);
b = Math.abs(b);
while (b != 0) {
long temp = a % b;
a = b;
b = temp;
}
return a;
}
public static int gcd(int a, int b) {
a = Math.abs(a);
b = Math.abs(b);
while (b != 0) {
int temp = a % b;
a = b;
b = temp;
}
return a;
}
public static int[] generatePrimes(int upTo) {
int[] isPrime = generateBitPrimalityTable(upTo);
List<Integer> primes = new ArrayList<Integer>();
for (int i = 0; i < upTo; i++) {
if ((isPrime[i >> 5] >>> (i & 31) & 1) == 1)
primes.add(i);
}
int[] array = new int[primes.size()];
for (int i = 0; i < array.length; i++)
array[i] = primes.get(i);
return array;
}
public static boolean[] generatePrimalityTable(int upTo) {
boolean[] isPrime = new boolean[upTo];
if (upTo < 2)
return isPrime;
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for (int i = 2; i * i < upTo; i++) {
if (isPrime[i]) {
for (int j = i * i; j < upTo; j += i)
isPrime[j] = false;
}
}
return isPrime;
}
public static int[] generateBitPrimalityTable(int upTo) {
int[] isPrime = new int[(upTo + 31) >> 5];
if (upTo < 2)
return isPrime;
Arrays.fill(isPrime, -1);
isPrime[0] &= -4;
for (int i = 2; i * i < upTo; i++) {
if ((isPrime[i >> 5] >>> (i & 31) & 1) == 1) {
for (int j = i * i; j < upTo; j += i)
isPrime[j >> 5] &= -1 - (1 << (j & 31));
}
}
return isPrime;
}
public static int[] generateDivisorTable(int upTo) {
int[] divisor = new int[upTo];
for (int i = 1; i < upTo; i++)
divisor[i] = i;
for (int i = 2; i * i < upTo; i++) {
if (divisor[i] == i) {
for (int j = i * i; j < upTo; j += i)
divisor[j] = i;
}
}
return divisor;
}
public static long powerInFactorial(long n, long p) {
long result = 0;
while (n != 0) {
result += n /= p;
}
return result;
}
public static int sumDigits(CharSequence number) {
int result = 0;
for (int i = number.length() - 1; i >= 0; i--)
result += digitValue(number.charAt(i));
return result;
}
public static int digitValue(char digit) {
if (Character.isDigit(digit))
return digit - '0';
if (Character.isUpperCase(digit))
return digit + 10 - 'A';
return digit + 10 - 'a';
}
public static int longCompare(long a, long b) {
if (a < b)
return -1;
if (a > b)
return 1;
return 0;
}
public static long[][] generateBinomialCoefficients(int n) {
long[][] result = new long[n + 1][n + 1];
for (int i = 0; i <= n; i++) {
result[i][0] = 1;
for (int j = 1; j <= i; j++)
result[i][j] = result[i - 1][j - 1] + result[i - 1][j];
}
return result;
}
public static long[][] generateBinomialCoefficients(int n, long module) {
long[][] result = new long[n + 1][n + 1];
if (module == 1)
return result;
for (int i = 0; i <= n; i++) {
result[i][0] = 1;
for (int j = 1; j <= i; j++) {
result[i][j] = result[i - 1][j - 1] + result[i - 1][j];
if (result[i][j] >= module)
result[i][j] -= module;
}
}
return result;
}
public static long[] generateBinomialRow(int n, long module) {
long[] result = generateReverse(n + 1, module);
result[0] = 1;
for (int i = 1; i <= n; i++)
result[i] = result[i - 1] * (n - i + 1) % module * result[i]
% module;
return result;
}
public static int[] representationInBase(long number, int base) {
long basePower = base;
int exponent = 1;
while (number >= basePower) {
basePower *= base;
exponent++;
}
int[] representation = new int[exponent];
for (int i = 0; i < exponent; i++) {
basePower /= base;
representation[i] = (int) (number / basePower);
number %= basePower;
}
return representation;
}
public static int trueDivide(int a, int b) {
return (a - trueMod(a, b)) / b;
}
public static long trueDivide(long a, long b) {
return (a - trueMod(a, b)) / b;
}
public static int trueMod(int a, int b) {
a %= b;
a += b;
a %= b;
return a;
}
public static long trueMod(long a, long b) {
a %= b;
a += b;
a %= b;
return a;
}
public static long factorial(int n) {
long result = 1;
for (int i = 2; i <= n; i++)
result *= i;
return result;
}
public static long factorial(int n, long mod) {
long result = 1;
for (int i = 2; i <= n; i++)
result = result * i % mod;
return result % mod;
}
public static List<Pair<Long, Integer>> factorize(long number) {
List<Pair<Long, Integer>> result = new ArrayList<Pair<Long, Integer>>();
for (long i = 2; i * i <= number; i++) {
if (number % i == 0) {
int power = 0;
do {
power++;
number /= i;
} while (number % i == 0);
result.add(Pair.makePair(i, power));
}
}
if (number != 1)
result.add(Pair.makePair(number, 1));
return result;
}
public static List<Long> getDivisors(long number) {
List<Pair<Long, Integer>> primeDivisors = factorize(number);
return getDivisorsImpl(primeDivisors, 0, 1, new ArrayList<Long>());
}
private static List<Long> getDivisorsImpl(
List<Pair<Long, Integer>> primeDivisors, int index, long current,
List<Long> result) {
if (index == primeDivisors.size()) {
result.add(current);
return result;
}
long p = primeDivisors.get(index).first;
int power = primeDivisors.get(index).second;
for (int i = 0; i <= power; i++) {
getDivisorsImpl(primeDivisors, index + 1, current, result);
current *= p;
}
return result;
}
public static long power(long base, long exponent) {
if (exponent == 0)
return 1;
long result = power(base, exponent >> 1);
result = result * result;
if ((exponent & 1) != 0)
result = result * base;
return result;
}
public static long power(long base, long exponent, long mod) {
if (base >= mod)
base %= mod;
if (exponent == 0)
return 1 % mod;
long result = power(base, exponent >> 1, mod);
result = result * result % mod;
if ((exponent & 1) != 0)
result = result * base % mod;
return result;
}
public static long lcm(long a, long b) {
return a / gcd(a, b) * b;
}
public static long[] generateFibonacci(long upTo) {
int count = 0;
long last = 0;
long current = 1;
while (current <= upTo) {
long next = last + current;
last = current;
current = next;
count++;
}
return generateFibonacci(count, -1);
}
public static long[] generateFibonacci(int count, long module) {
long[] result = new long[count];
if (module == -1) {
if (count != 0)
result[0] = 1;
if (count > 1)
result[1] = 1;
for (int i = 2; i < count; i++)
result[i] = result[i - 1] + result[i - 2];
} else {
if (count != 0)
result[0] = 1 % module;
if (count > 1)
result[1] = 1 % module;
for (int i = 2; i < count; i++)
result[i] = (result[i - 1] + result[i - 2]) % module;
}
return result;
}
public static long[] generateHappy(int digits) {
long[] happy = new long[(1 << (digits + 1)) - 2];
happy[0] = 4;
happy[1] = 7;
int first = 0;
int last = 2;
for (int i = 2; i <= digits; i++) {
for (int j = 0; j < last - first; j++) {
happy[last + 2 * j] = 10 * happy[first + j] + 4;
happy[last + 2 * j + 1] = 10 * happy[first + j] + 7;
}
int next = last + 2 * (last - first);
first = last;
last = next;
}
return happy;
}
public static long[] generateFactorial(int count, long module) {
long[] result = new long[count];
if (module == -1) {
if (count != 0)
result[0] = 1;
for (int i = 1; i < count; i++)
result[i] = result[i - 1] * i;
} else {
if (count != 0)
result[0] = 1 % module;
for (int i = 1; i < count; i++)
result[i] = (result[i - 1] * i) % module;
}
return result;
}
public static long reverse(long number, long module) {
return power(number, module - 2, module);
}
public static boolean isPrime(long number) {
if (number < 2)
return false;
for (long i = 2; i * i <= number; i++) {
if (number % i == 0)
return false;
}
return true;
}
public static long[] generateReverse(int upTo, long module) {
long[] result = new long[upTo];
if (upTo > 1)
result[1] = 1;
for (int i = 2; i < upTo; i++)
result[i] = (module - module / i * result[((int) (module % i))]
% module)
% module;
return result;
}
public static long[] generateReverseFactorials(int upTo, long module) {
long[] result = generateReverse(upTo, module);
if (upTo > 0)
result[0] = 1;
for (int i = 1; i < upTo; i++)
result[i] = result[i] * result[i - 1] % module;
return result;
}
public static long[] generatePowers(long base, int count, long mod) {
long[] result = new long[count];
if (count != 0)
result[0] = 1 % mod;
for (int i = 1; i < count; i++)
result[i] = result[i - 1] * base % mod;
return result;
}
public static long nextPrime(long from) {
if (from <= 2)
return 2;
from += 1 - (from & 1);
while (!isPrime(from))
from += 2;
return from;
}
public static long binomialCoefficient(int n, int m, long mod) {
if (m < 0 || m > n)
return 0;
if (2 * m > n)
m = n - m;
long result = 1;
for (int i = n - m + 1; i <= n; i++)
result = result * i % mod;
return result
* BigInteger.valueOf(factorial(m, mod))
.modInverse(BigInteger.valueOf(mod)).longValue() % mod;
}
public static boolean isSquare(long number) {
long sqrt = Math.round(Math.sqrt(number));
return sqrt * sqrt == number;
}
public static long findCommon(long aRemainder, long aMod, long bRemainder,
long bMod) {
long modGCD = gcd(aMod, bMod);
long gcdRemainder = aRemainder % modGCD;
if (gcdRemainder != bRemainder % modGCD)
return -1;
aMod /= modGCD;
aRemainder /= modGCD;
bMod /= modGCD;
bRemainder /= modGCD;
long aReverse = BigInteger.valueOf(aMod)
.modInverse(BigInteger.valueOf(bMod)).longValue();
long bReverse = BigInteger.valueOf(bMod)
.modInverse(BigInteger.valueOf(aMod)).longValue();
long mod = aMod * bMod;
return (bReverse * aRemainder % mod * bMod + aReverse * bRemainder
% mod * aMod)
% mod * modGCD + gcdRemainder;
}
public static long[] generatePowers(long base, long maxValue) {
if (maxValue <= 0)
return new long[0];
int size = 1;
long current = 1;
while (maxValue / base >= current) {
current *= base;
size++;
}
return generatePowers(base, size, Long.MAX_VALUE);
}
}
interface IntComparator extends Comparator<Integer> {
public static final IntComparator DEFAULT = new IntComparator() {
public int compare(Integer first, Integer second) {
if (first < second)
return -1;
if (first > second)
return 1;
return 0;
}
};
public static final IntComparator REVERSE = new IntComparator() {
public int compare(Integer first, Integer second) {
if (first < second)
return 1;
if (first > second)
return -1;
return 0;
}
};
public int compare(Integer first, Integer second);
}
class BidirectionalGraph extends Graph {
public int[] transposedEdge;
public BidirectionalGraph(int vertexCount) {
this(vertexCount, vertexCount);
}
public BidirectionalGraph(int vertexCount, int edgeCapacity) {
super(vertexCount, 2 * edgeCapacity);
transposedEdge = new int[2 * edgeCapacity];
}
public static BidirectionalGraph createGraph(int vertexCount, int[] from,
int[] to) {
BidirectionalGraph graph = new BidirectionalGraph(vertexCount,
from.length);
for (int i = 0; i < from.length; i++)
graph.addSimpleEdge(from[i], to[i]);
return graph;
}
public static BidirectionalGraph createWeightedGraph(int vertexCount,
int[] from, int[] to, long[] weight) {
BidirectionalGraph graph = new BidirectionalGraph(vertexCount,
from.length);
for (int i = 0; i < from.length; i++)
graph.addWeightedEdge(from[i], to[i], weight[i]);
return graph;
}
public static BidirectionalGraph createFlowGraph(int vertexCount,
int[] from, int[] to, long[] capacity) {
BidirectionalGraph graph = new BidirectionalGraph(vertexCount,
from.length * 2);
for (int i = 0; i < from.length; i++)
graph.addFlowEdge(from[i], to[i], capacity[i]);
return graph;
}
public static BidirectionalGraph createFlowWeightedGraph(int vertexCount,
int[] from, int[] to, long[] weight, long[] capacity) {
BidirectionalGraph graph = new BidirectionalGraph(vertexCount,
from.length * 2);
for (int i = 0; i < from.length; i++)
graph.addFlowWeightedEdge(from[i], to[i], weight[i], capacity[i]);
return graph;
}
@Override
public int addEdge(int fromID, int toID, long weight, long capacity,
int reverseEdge) {
int lastEdgeCount = edgeCount;
super.addEdge(fromID, toID, weight, capacity, reverseEdge);
super.addEdge(toID, fromID, weight, capacity, reverseEdge == -1 ? -1
: reverseEdge + 1);
this.transposedEdge[lastEdgeCount] = lastEdgeCount + 1;
this.transposedEdge[lastEdgeCount + 1] = lastEdgeCount;
return lastEdgeCount;
}
@Override
protected int entriesPerEdge() {
return 2;
}
@Override
public final int transposed(int id) {
return transposedEdge[id];
}
@Override
protected void ensureEdgeCapacity(int size) {
if (size > edgeCapacity()) {
super.ensureEdgeCapacity(size);
transposedEdge = resize(transposedEdge, edgeCapacity());
}
}
}
class Pair<U, V> implements Comparable<Pair<U, V>> {
public final U first;
public final V second;
public static <U, V> Pair<U, V> makePair(U first, V second) {
return new Pair<U, V>(first, second);
}
private Pair(U first, V second) {
this.first = first;
this.second = second;
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (o == null || getClass() != o.getClass())
return false;
Pair pair = (Pair) o;
return !(first != null ? !first.equals(pair.first) : pair.first != null)
&& !(second != null ? !second.equals(pair.second)
: pair.second != null);
}
@Override
public int hashCode() {
int result = first != null ? first.hashCode() : 0;
result = 31 * result + (second != null ? second.hashCode() : 0);
return result;
}
public Pair<V, U> swap() {
return makePair(second, first);
}
@Override
public String toString() {
return "(" + first + "," + second + ")";
}
@SuppressWarnings({ "unchecked" })
public int compareTo(Pair<U, V> o) {
int value = ((Comparable<U>) first).compareTo(o.first);
if (value != 0)
return value;
return ((Comparable<V>) second).compareTo(o.second);
}
}
interface Edge {
public int getSource();
public int getDestination();
public long getWeight();
public long getCapacity();
public long getFlow();
public void pushFlow(long flow);
public boolean getFlag(int bit);
public void setFlag(int bit);
public void removeFlag(int bit);
public int getTransposedID();
public Edge getTransposedEdge();
public int getReverseID();
public Edge getReverseEdge();
public int getID();
public void remove();
public void restore();
}
interface Function<A, V> {
public abstract V value(A argument);
} | 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 javax.naming.PartialResultException;
import java.util.*;
import java.io.*;
public class PrimeMatrix {
InputStream is;
PrintWriter out;
String INPUT = "";
ArrayList<Integer> primes;
void solve() throws IOException {
int n= ni(), m= ni();
int[][] arr= new int[n][m];
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
arr[i][j]= ni();
}
sieve();
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
arr[i][j]= binarySearch(arr[i][j], 0, primes.size()-1)- arr[i][j];
}
int ans= Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
int sum=0;
for(int j=0;j<m;j++)
{
if(sum> ans)
break;
else
sum+= arr[i][j];
}
ans= Math.min(ans, sum);
}
for(int i=0;i<m;i++)
{
int sum=0;
for(int j=0;j<n;j++)
{
if(sum> ans)
break;
else
sum+= arr[j][i];
}
ans= Math.min(ans, sum);
}
out.println(ans);
}
private int binarySearch(int find, int start, int last)
{
while(start<= last)
{
int mid= start+ (last- start)/2;
if(primes.get(mid)== find)
return find;
else if(primes.get(mid)> find)
last= mid-1;
else
start= mid+1;
}
return primes.get(start);
}
private void sieve()
{
boolean[] composite= new boolean[100000];
for(int i=2;i*i<= composite.length;i++)
{
if(composite[i]) continue;
for(int j=i*i;j< composite.length;j+=i)
composite[j]= true;
}
primes= new ArrayList<>();
for(int i=2;i<composite.length;i++)
if(!composite[i]) primes.add(i);
primes.add(100003);
}
void run() throws Exception {
is = INPUT.isEmpty() ? System.in : new ByteArrayInputStream(INPUT.getBytes());
out = new PrintWriter(System.out);
solve();
out.flush();
}
public static void main(String[] args) throws Exception {
new PrimeMatrix().run();
}
private byte[] inbuf = new byte[1024];
public int lenbuf = 0, ptrbuf = 0;
private int readByte() {
if (lenbuf == -1) throw new InputMismatchException();
if (ptrbuf >= lenbuf) {
ptrbuf = 0;
try {
lenbuf = is.read(inbuf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (lenbuf <= 0) return -1;
}
return inbuf[ptrbuf++];
}
private boolean isSpaceChar(int c) {
return !(c >= 33 && c <= 126);
}
private int skip() {
int b;
while ((b = readByte()) != -1 && isSpaceChar(b)) ;
return b;
}
private double nd() {
return Double.parseDouble(ns());
}
private char nc() {
return (char) skip();
}
private String ns() {
int b = skip();
StringBuilder sb = new StringBuilder();
while (!(isSpaceChar(b))) { // when nextLine, (isSpaceChar(b) && b != ' ')
sb.appendCodePoint(b);
b = readByte();
}
return sb.toString();
}
private char[] ns(int n) {
char[] buf = new char[n];
int b = skip(), p = 0;
while (p < n && !(isSpaceChar(b))) {
buf[p++] = (char) b;
b = readByte();
}
return n == p ? buf : Arrays.copyOf(buf, p);
}
private char[][] nm(int n, int m) {
char[][] map = new char[n][];
for (int i = 0; i < n; i++) map[i] = ns(m);
return map;
}
private int[] na(int n) {
int[] a = new int[n];
for (int i = 0; i < n; i++) a[i] = ni();
return a;
}
private int ni() {
int num = 0, b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
private long nl() {
long num = 0;
int b;
boolean minus = false;
while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-')) ;
if (b == '-') {
minus = true;
b = readByte();
}
while (true) {
if (b >= '0' && b <= '9') {
num = num * 10 + (b - '0');
} else {
return minus ? -num : num;
}
b = readByte();
}
}
private void tr(Object... o) {
if (INPUT.length() > 0) System.out.println(Arrays.deepToString(o));
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
bool prime[MAX];
void sieve(int n) {
memset(prime, true, sizeof(prime));
for (int i = 2; i * i <= n; i++)
if (prime[i] == true)
for (int j = i * 2; j <= n; j += i) prime[j] = false;
}
int main() {
sieve(MAX - 1);
int n, m, ans = MAX, c;
cin >> n >> m;
int grid1[n][m], grid2[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
cin >> grid1[i][j];
grid2[i][j] = grid1[i][j];
}
for (int i = 0; i < n; i++) {
c = 0;
for (int j = 0; j < m; j++) {
if (grid1[i][j] == 1)
c++;
else if (!prime[grid1[i][j]])
while (!prime[grid1[i][j]]) grid1[i][j]++, c++;
}
ans = min(ans, c);
}
for (int i = 0; i < m; i++) {
c = 0;
for (int j = 0; j < n; j++) {
if (grid2[j][i] == 1)
c++;
else if (!prime[grid2[j][i]])
while (!prime[grid2[j][i]]) grid2[j][i]++, c++;
}
ans = min(ans, c);
}
return cout << ans, 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
from sys import stdin,stdout
input=stdin.readline
import math,bisect
#from itertools import permutations
#from collections import Counter
prime=[1]*102001
prime[1]=0
prime[0]=0
for i in range(2,102001):
j=i
while(j+i<102001):
j+=i
prime[j]=0
#print(prime)
l=[]
n,m=map(int,input().split())
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
ans=50000000
for i in range(n):
tot=0
for j in range(m):
ele=l[i][j]
for k in range(ele,102001):
if prime[k]==1:
tot+=k-ele
break
ans=min(ans,tot)
for j in range(m):
tot=0
for i in range(n):
ele=l[i][j]
for k in range(ele,102001):
if prime[k]==1:
tot+=k-ele
break
ans=min(ans,tot)
print(ans) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, x, a[511][511], m, pr[111111], sz, row[555], col[555], ans, cur,
p[222222];
void calc() {
for (int i = 2; i <= 200000; i++) {
bool t = true;
for (int j = 2; j <= int(sqrt(i)); j++) {
if (i % j == 0) {
t = false;
break;
}
}
if (t) {
sz++;
pr[sz] = i;
p[i] = 1;
}
}
}
int main() {
calc();
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) {
scanf("%d", &a[i][j]);
if (p[a[i][j]])
cur = 0;
else
cur = (pr[upper_bound(pr + 1, pr + sz + 1, a[i][j]) - pr] - a[i][j]);
col[j] += cur;
row[i] += cur;
}
ans = *min_element(col + 1, col + m + 1);
ans = min(ans, *min_element(row + 1, row + n + 1));
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 | 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):
entrada = input().split()
matriz.append(list(map(int, entrada)))
menor_passo = limite
for i in range(n):
passos = 0
for j in range(m):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
for j in range(m):
passos = 0
for i in range(n):
passos += distancias[matriz[i][j]]
if passos < menor_passo:
menor_passo = passos
print(menor_passo)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import copy, bisect
from math import sqrt
primes = []
top = 10**5+10
pos = [True] * top
for i in range(2, top):
if pos[i]:
for j in range(2*i, top, i):
pos[j] = False
primes = [i for i in range(2, top) if pos[i]]
arr = [];arr2 = []; k = 0; lst = []
n, m = map (int, input ().split ())
ans = 100000000
for i in range (n) :
arr.append (list (map (int, input ().split ())))
for i in arr :
temp = 0
for j in i :
temp += (primes[bisect.bisect_left (primes, j)] - j)
ans = min (ans, temp)
for _ in range (m) :
for i in range (len (arr)) :
lst.append (arr[i][k])
k += 1
arr2.append (copy.copy (lst))
lst.clear()
for i in arr2 :
temp = 0
for j in i :
temp += (primes[bisect.bisect_left (primes, j)] - j)
ans = min (ans, temp)
print (ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #! /usr/bin/env python
#coding=utf-8
MAX_SIZE = 100019
flg = [0 * i for i in range(MAX_SIZE)]
sqrt_i = int(MAX_SIZE ** 0.5)
for i in range(2, sqrt_i):
for j in range(i, MAX_SIZE):
if(i * j >= MAX_SIZE):break
flg[i * j] = 1
primes = [x for x in range(2, MAX_SIZE) if flg[x] == 0]
def minDif(n):
lef = 0
rig = len(primes) - 1
while(lef <= rig):
mid = (lef + rig) / 2
if(primes[mid] < n):
lef = mid + 1
else:
rig = mid - 1
lef = min(lef, rig)
lef = max(lef, 0)
while(primes[lef] < n):lef += 1
return primes[lef] - n
lists = []
n,m = [int(x) for x in raw_input().split()]
for i in range(n):
lists.append([int(x) for x in raw_input().split()])
for i in range(n):
for j in range(m):
lists[i][j] = minDif(lists[i][j])
min_row = MAX_SIZE
min_col = MAX_SIZE
min_row = min([sum(lists[i]) for i in range(n)])
for j in range(m):
min_col = min(min_col, sum([lists[i][j] for i in range(n)]))
print min(min_col, min_row) | 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;
template <typename Arg1>
void ZZ(const char* name, Arg1&& arg1) {
std::cerr << name << " = " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void ZZ(const char* names, Arg1&& arg1, Args&&... args) {
const char* comma = strchr(names + 1, ',');
std::cerr.write(names, comma - names) << " = " << arg1;
ZZ(comma, args...);
}
int n, m;
int a[505][505], prime[100005];
void pre() {
memset(prime, 1, sizeof(prime));
prime[1] = 0;
for (int i = 2; i * i < 100005; i++) {
if (prime[i]) {
for (int j = i * i; j < 100005; j += i) {
prime[j] = 0;
}
}
}
}
int add(int x) {
int c = 0;
while (!prime[x]) {
c++;
x++;
}
return c;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
pre();
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
int ans = 100005, cnt;
for (int i = 1; i <= n; i++) {
cnt = 0;
for (int j = 1; j <= m; j++) {
cnt += add(a[i][j]);
}
ans = min(ans, cnt);
}
for (int i = 1; i <= m; i++) {
cnt = 0;
for (int j = 1; j <= n; j++) {
cnt += add(a[j][i]);
}
ans = min(ans, cnt);
}
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.awt.Point;
import java.io.*;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.util.*;
import javax.security.auth.kerberos.KerberosKey;
import static java.lang.Math.*;
public class Main {
final boolean ONLINE_JUDGE = System.getProperty("ONLINE_JUDGE") != null;
BufferedReader in;
PrintWriter out;
StringTokenizer tok = new StringTokenizer("");
void init() throws FileNotFoundException {
if (ONLINE_JUDGE) {
in = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
} else {
in = new BufferedReader(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
}
}
String readString() throws IOException {
while (!tok.hasMoreTokens()) {
tok = new StringTokenizer(in.readLine());
}
return tok.nextToken();
}
int readInt() throws IOException {
return Integer.parseInt(readString());
}
int gcd(int a, int b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
boolean[] primes=new boolean[150000];
public void fillSieve() {
Arrays.fill(primes,true);
primes[0]=primes[1]=false;
for (int i=2;i<primes.length;i++) {
if(primes[i]) {
for (int j=2;i*j<primes.length;j++) {
primes[i*j]=false;
}
}
}
}
int fib(int n) {
if (n == 1)
return 1;
if (n == 2)
return 2;
else
return fib(n - 1) + fib(n - 2);
}
long readLong() throws IOException {
return Long.parseLong(readString());
}
double readDouble() throws IOException {
return Double.parseDouble(readString());
}
public static void main(String[] args) {
new Main().run();
// Sworn to fight and die
}
public static void mergeSort(int[] a) {
mergeSort(a, 0, a.length - 1);
}
private static void mergeSort(int[] a, int levtIndex, int rightIndex) {
final int MAGIC_VALUE = 50;
if (levtIndex < rightIndex) {
if (rightIndex - levtIndex <= MAGIC_VALUE) {
insertionSort(a, levtIndex, rightIndex);
} else {
int middleIndex = (levtIndex + rightIndex) / 2;
mergeSort(a, levtIndex, middleIndex);
mergeSort(a, middleIndex + 1, rightIndex);
merge(a, levtIndex, middleIndex, rightIndex);
}
}
}
private static void merge(int[] a, int levtIndex, int middleIndex,
int rightIndex) {
int length1 = middleIndex - levtIndex + 1;
int length2 = rightIndex - middleIndex;
int[] levtArray = new int[length1];
int[] rightArray = new int[length2];
System.arraycopy(a, levtIndex, levtArray, 0, length1);
System.arraycopy(a, middleIndex + 1, rightArray, 0, length2);
for (int k = levtIndex, i = 0, j = 0; k <= rightIndex; k++) {
if (i == length1) {
a[k] = rightArray[j++];
} else if (j == length2) {
a[k] = levtArray[i++];
} else {
a[k] = levtArray[i] <= rightArray[j] ? levtArray[i++]
: rightArray[j++];
}
}
}
private static void insertionSort(int[] a, int levtIndex, int rightIndex) {
for (int i = levtIndex + 1; i <= rightIndex; i++) {
int current = a[i];
int j = i - 1;
while (j >= levtIndex && a[j] > current) {
a[j + 1] = a[j];
j--;
}
a[j + 1] = current;
}
}
public void run() {
try {
long t1 = System.currentTimeMillis();
init();
solve();
out.close();
long t2 = System.currentTimeMillis();
System.err.println("Time = " + (t2 - t1));
} catch (Exception e) {
e.printStackTrace(System.err);
System.exit(-1);
}
}
class LOL implements Comparable<LOL> {
int x;
int y;
public LOL(int x, int y) {
this.x = x;
this.y = y;
}
@Override
public int compareTo(LOL o) {
//if (y == o.y)
// return (o.x - x);
return x - o.x; // ---->
// return o.x - x; // <----
// return o.y-y;
}
}
public int unusualSquare(int [][] a, int n) {
int s = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
s += a[i][j]*a[j][i];
return s % 2;
}
public void solve() throws IOException {
int n = readInt();
int m = readInt();
fillSieve();
int [][] a = new int[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
a[i][j] = readInt();
int mini = 100000;
int s = 0;
for (int i = 0; i < n; i++) {
s = 0;
for (int j = 0; j < m; j++) {
if (primes[a[i][j]] == false) {
int k = a[i][j];
while (primes[k] == false && k < 150000) {
k++;
}
if (k!=150000) s += k - (a[i][j]);
}
}
mini = min(mini, s);
}
for (int j = 0; j < m; j++) {
s = 0;
for (int i = 0; i < n; i++) {
if (primes[a[i][j]] == false) {
int k = a[i][j];
while (primes[k] == false && k < 150000) {
k++;
}
if (k!=150000) s += k - (a[i][j]);
}
}
mini = min(mini, s);
}
out.print(mini);
}
} | 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 itertools as it
simple_nums = []
def sieve():
""" Generate an infinite sequence of prime numbers.
"""
yield 2
D = {}
for q in it.count(3, 2): # start at 3 and step by odds
p = D.pop(q, 0)
if p:
x = q + p
while x in D: x += p
D[x] = p # new composite found. Mark that
else:
yield q # q is a new prime since no composite was found
D[q * q] = 2 * q
simple_nums = list(it.islice(sieve(), 0, 10_000))
def resize_simple():
a = it.islice(sieve(), len(simple_nums), len(simple_nums) + 1)
a = list(a)
a = int(*a)
simple_nums.append(a)
def get_nearest_to(num):
if num <= simple_nums[0]:
return simple_nums[0]
while num > simple_nums[len(simple_nums) - 1]:
resize_simple()
high = len(simple_nums) - 1
mid = high // 2
low = 0
while high - low > 1:
mid = (low + high) // 2
if simple_nums[mid] == num:
return simple_nums[mid]
if num > simple_nums[mid]:
low = mid
else:
high = mid
return simple_nums[high]
"""
while low <= high:
mid = (low + high) // 2
if simple_nums[mid] == num:
return simple_nums[mid]
if simple_nums[mid] > num:
high = mid - 1
else:
low = mid + 1
return simple_nums[max(low, mid, high)]
"""
def get_steps(num):
near = get_nearest_to(num)
return near - num
m, n = map(int, input().split())
matrix = [[0 for i in range(n)] for j in range(m)]
simple_steps = [
[0 for i in range(n)],
[0 for i in range(m)]
]
for i in range(m):
buf = list(map(int, input().split()))
for j in range(n):
matrix[i][j] = buf[j]
t = buf[j]
a = get_steps(buf[j])
simple_steps[0][j] += a
simple_steps[1][i] += a
print(min(min(simple_steps[0]), min(simple_steps[1])))
| 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
prime=[2,3,5,7,11];d={}
def GeneratePrimes():
for i in range(12,100100):
for j in prime:
if i%j==0:
break
if j*j>i:
prime.append(i)
break
else:
prime.append(i)
for i in range(1,len(prime)+1):
d[prime[i-1]]=i
def UpperBound(x):
l=0;h=len(prime)
while l<=h:
m=(l+h)//2
if x>prime[m]:
l=m+1
elif x<prime[m]:
h=m-1
else:
return m
return l
GeneratePrimes()
#print(prime)
n,m=map(int,input().split())
f=[]
for i in range(n):
ii=list(map(int,input().split()))
f.append(ii)
mn=10**9
for i in range(n):
now=0
for j in range(m):
now+=prime[UpperBound(f[i][j])]-f[i][j]
mn=min(mn,now)
for i in range(m):
now=0
for j in range(n):
now+=prime[UpperBound(f[j][i])]-f[j][i]
mn=min(mn,now)
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 | from bisect import *
def primes(n):
low = 3
lNum = range(low, n + 1, 2)
iRoot= n ** 0.5
iMid = len(lNum)
i = 0
m = 3
while m < iRoot:
if lNum[i] != 0:
j = (m*m - low) / 2
while (j<iMid):
if (j >= 0):
lNum[j] = 0
j += m
i += 1
m += 2
return [2] + [x for x in lNum if x != 0]
n, m = map(int, raw_input().split())
a = []
for i in range(n):
a.append(map(int, raw_input().split()))
p = primes(2 * (10 ** 5))
min_by_row = 10**5
for i in range(n):
count = 0
for j in range(m):
k = bisect_left(p, a[i][j])
count += p[k] - a[i][j]
min_by_row = min(min_by_row, count)
min_by_col = 10**5
for j in range(m):
count = 0
for i in range(n):
k = bisect_left(p, a[i][j])
count += p[k] - a[i][j]
min_by_col = min(min_by_col, count)
print min(min_by_row, min_by_col) | 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 | #python3
import sys, threading, os.path
import collections, heapq, math,bisect
import string
from platform import python_version
import itertools
sys.setrecursionlimit(10**6)
threading.stack_size(2**27)
def generate_primes(n):
res = []
isPrime = [True]*(n*5)
isPrime[0],isPrime[1] = 0,0
'''
for (ll i = 2; i*i <= n+1; ++i) {
if (isPrime[i]) {
for (ll j = i * 2; j <= n; j += i)
isPrime[j] = 0;
}
}
'''
for i in range(2,n+1):
if i*i >n+1:
break
if isPrime[i]:
for j in range(i*2,n+1,i):
isPrime[j]=0
res.append(2)
for i in range(3,n+1,2):
if isPrime[i]:
res.append(i)
return res;
def main():
if os.path.exists('input.txt'):
input = open('input.txt', 'r')
else:
input = sys.stdin
#--------------------------------INPUT---------------------------------
n,m = list(map(int, input.readline().split()))
mat = []
for i in range(n):
mat.append(list(map(int, input.readline().split())))
allprimes = generate_primes(150000)
#print(allprimes)
tostore = []
for i in range(n):
tostore.append([])
for j in range(m):
x = bisect.bisect(allprimes, mat[i][j])
if allprimes[x-1]==mat[i][j]:
tostore[i].append(0)
else:
tostore[i].append(abs(mat[i][j]-allprimes[x]))
'''
for i in range(n):
for j in range(m):
print(tostore[i][j], end=" ")
print()
'''
rowsum,colsum = [0]*501,[0]*501
for i in range(n):
for j in range(m):
rowsum[i]+=tostore[i][j]
colsum[j]+=tostore[i][j]
#print(rowsum[:n])
#print(colsum[:m])
minone = min(min(rowsum[:n]),min(colsum[:m]))
output = minone
#-------------------------------OUTPUT----------------------------------
if os.path.exists('output.txt'):
open('output.txt', 'w').writelines(str(output))
else:
sys.stdout.write(str(output))
if __name__ == '__main__':
main()
#threading.Thread(target=main).start() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Watermelon {
static long mod = 1000000007;
public static void main(String[] args) throws IOException {
Scanner sc = new Scanner(System.in);
boolean[] prime=sieveOfEratosthenes(1000001);
int index=-1;
for(int i=1000000;i>=0;i--)if(prime[i]){index=i;break;}
int[] suf=new int[1000001];
int temp=index;
for(int i=index;i>=0;i--){
if(prime[i])
temp=i;
suf[i]=temp;
}
int n=sc.nextInt(),m=sc.nextInt();
int[][] mat=new int[n+1][m+1];
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
{
mat[i][j]=sc.nextInt();
mat[i][j]=suf[mat[i][j]]-mat[i][j];
}
int pref;
for(int i=0;i<n;i++){
pref=0;
for(int j=0;j<m;j++){
pref+=mat[i][j];
}
mat[i][m]=pref;
}
for(int i=0;i<m;i++){
pref=0;
for(int j=0;j<n;j++){
pref+=mat[j][i];
}
mat[n][i]=pref;
}
int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
min=Math.min(mat[i][m],min);
for(int i=0;i<m;i++)
min=Math.min(mat[n][i],min);
// for(int i=0;i<=n;i++)
// System.out.println(Arrays.toString(mat[i]));
System.out.print(min);
}
static boolean[] sieveOfEratosthenes(int 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.
boolean prime[] = new boolean[n + 1];
for (int i = 0; i < n; i++)
prime[i] = true;
for (int p = 2; p * p <= n; p++) {
// If prime[p] is not changed, then it is a prime
if (prime[p] == true) {
// Update all multiples of p
for (int i = p * 2; i <= n; i += p)
prime[i] = false;
}
}
prime[0] = false;
prime[1] = false;
return prime;
}
} | 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;
long long fix(long long cur, long long m) { return ((cur % m) + m) % m; }
long long fast_power(long long x, long long y) {
if (y == 0) return 1;
long long temp = fast_power(x, y / 2);
temp = (temp * temp);
if (y % 2 != 0) temp = temp * x;
return temp;
}
bool primes[200010];
vector<int> v;
void sieve() {
primes[0] = primes[1] = true;
for (int i = 2; i * i < 200010; i++) {
if (primes[i] == false) {
for (int j = i * i; j < 200010; j += i) primes[j] = true;
}
}
for (int i = 0; i < 200010; i++) {
if (primes[i] == false) v.push_back(i);
}
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
cout.tie(0);
sieve();
int n, m;
cin >> n >> m;
int arr[501][501];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) cin >> arr[i][j];
int mini = INT_MAX;
int idx, sum;
for (int i = 0; i < n; i++) {
sum = 0;
for (int j = 0; j < m; j++) {
if (primes[arr[i][j]] != false) {
idx = lower_bound(v.begin(), v.end(), arr[i][j]) - v.begin();
sum += (v[idx] - arr[i][j]);
}
}
mini = min(mini, sum);
}
for (int i = 0; i < m; i++) {
sum = 0;
for (int j = 0; j < n; j++) {
if (primes[arr[j][i]] != false) {
idx = lower_bound(v.begin(), v.end(), arr[j][i]) - v.begin();
sum += (v[idx] - arr[j][i]);
}
}
mini = min(mini, sum);
}
cout << mini << 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 | # specify list capacity
MaxN = 100010
prime_list = [0 for x in range(MaxN)]
prime_list[0] = prime_list[1] = 1
# mark all composite number with 1
for i in range(2, MaxN):
if prime_list[i] == 1:
continue
j = i*2
while j < MaxN:
prime_list[j] = 1
j += i
# then replace all '0' and '1' with prime number
i = MaxN-2
while i > 0:
prime_list[i] = prime_list[i+1] if prime_list[i] == 1 else i
i -= 1
n,m=map(int,raw_input().split())
a=[map(int,raw_input().split()) for i in range(n)]
for i in range(n):
for j in range(m):
a[i][j]=prime_list[a[i][j]]-a[i][j]
ans1=min(sum(a[i][j] for j in range(m)) for i in range(n))
ans2=min(sum(a[i][j] for i in range(n)) for j in range(m))
print min(ans1,ans2) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def Bin(li, x):
i = 0
j = len(li)-1
while i < j:
m = int((i+j)/2)
if x > li[m]:
i = m+1
else:
j = m
return j
def intpolsearch(values, x):
idx0 = 0
idxn = (len(values) - 1)
while (idx0 <= idxn and x >= values[idx0] and x <= values[idxn]):
mid = idx0 + int(((float(idxn - idx0)/( values[idxn] - values[idx0]))*(x - values[idx0])))
if ((values[mid] < x and values[mid + 1] > x) or values[mid] == x):
return mid + 1
if values[mid] < x:
idx0 = mid + 1
def G():
n = 105000
a = [i for i in range(n + 1)]
a[0] = 0
lst = []
i = 2
while i <= n:
if a[i] != 0:
lst.append(a[i])
for j in range(i, n + 1, i):
a[j] = 0
i += 1
data = input().split()
n, m = int(data[0]), int(data[1])
matrix = []
sum_j = [0 for i in range(m)]
summ = 999999999999
for i in range(n):
s = input().split()
now = []
for j in range(m):
if int(s[j]) == 1:
el = 1
else:
k = Bin(lst, int(s[j]))
el = lst[k] - int(s[j])
now.append(el)
sum_j[j] += el
matrix.append(now)
ns = sum(now)
if ns < summ:
summ = ns
min_j = min(sum_j)
if min_j < summ:
print(min_j)
else:
print(summ)
if __name__ == "__main__":
G() | 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 | #atal 2020.1, feito baseado nas noocoes vistas, conceito do crivuuuuus facilment eencontrado.
# utilizando py py para ver se funciona.
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 | import bisect
prime=[0]*1000001
i=2
while i*i<1000001:
if prime[i]==0:
for j in range(i*i,1000001,i):
prime[j]=-1
i+=1
lol=[]
for k in range(2,1000001):
if prime[k]==0:
lol.append(k)
x,y=map(int,input().split())
yo=[]
lu=[]
for i in range(x):
yo.append([0]*y)
lu.append(list(map(int,input().split())))
for i in range(x):
for j in range(y):
w=bisect.bisect(lol,lu[i][j])
if lu[i][j]-lol[w-1]!=0:
yo[i][j]=abs(lu[i][j]-lol[w])
else:
yo[i][j]=0
z=1000001
for i in yo:
z=min(z,sum(i))
for i in range(y):
s=0
for j in range(x):
s+=yo[j][i]
z=min(s,z)
print(z)
| 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;
class Soln {
private:
int n;
public:
Soln() {}
~Soln() {}
};
class Seive {
public:
bool *A;
vector<int> v;
Seive(int n) {
A = new bool[n + 1];
for (int i = 0; i <= n; i++) {
A[i] = true;
}
A[0] = false;
A[1] = false;
int stop = (int)sqrt(n);
for (int i = 4; i <= n; i += 2) {
A[i] = false;
}
for (int i = 3; i <= stop; i++) {
if (A[i] == true) {
for (int j = 3 * i; j <= n; j += 2 * i) {
A[j] = false;
}
}
}
for (int i = 0; i <= n; i++) {
if (A[i]) {
v.push_back(i);
}
}
}
~Seive() {
if (!A) {
delete[] A;
}
}
};
int main(int argc, char const *argv[]) {
int n, m, **a;
scanf("%d", &n);
scanf("%d", &m);
a = new int *[n];
for (int i = 0; i < n; i++) {
a[i] = new int[m];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
}
}
Seive sv(2000000);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int diff = 0;
if (!binary_search(sv.v.begin(), sv.v.end(), a[i][j])) {
int pos = upper_bound(sv.v.begin(), sv.v.end(), a[i][j]) - sv.v.begin();
int prime = sv.v[pos];
diff = prime - a[i][j];
}
a[i][j] = diff;
}
}
long long int min = INT_MAX;
for (int i = 0; i < n; i++) {
long long int sum = 0;
for (int j = 0; j < m; j++) {
sum += a[i][j];
}
if (sum < min) {
min = sum;
}
}
for (int j = 0; j < m; j++) {
long long int sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i][j];
}
if (sum < min) {
min = sum;
}
}
printf("%-I64d\n", min);
;
for (int i = 0; i < m; i++) {
if (!a[i]) delete[] a[i];
}
delete[] a;
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 Main {
public static void main(String[] args) {
int[] primes = new int[9593];
int ct = 0;
Scanner input = new Scanner(System.in);
int n = 100005;
// initially assume all integers are prime
boolean[] isPrime = new boolean[n + 1];
for (int i = 2; i <= n; i++) {
isPrime[i] = true;
}
// mark non-primes <= n using Sieve of Eratosthenes
for (int factor = 2; factor * factor <= n; factor++) {
// if factor is prime, then mark multiples of factor as nonprime
// suffices to consider mutiples factor, factor+1, ..., n/factor
if (isPrime[factor]) {
for (int j = factor; factor * j <= n; j++) {
isPrime[factor * j] = false;
}
}
}
int c = 0;
for (int i = 0; i < isPrime.length; i++) {
if (isPrime[i]) {
primes[ct] = i;
ct++;
}
}
///Got all primes
int x = input.nextInt();
int y = input.nextInt();
int minr = Integer.MAX_VALUE;
int[][] arr = new int[x][y];
int sum = 0;
for (int i = 0; i < x; i++) {
for (int j = 0; j < y; j++) {
arr[i][j] = input.nextInt();
if (!isPrime[arr[i][j]]) {
sum += nextPrime(primes, arr[i][j]) - arr[i][j];
}
}
minr = Math.min(sum, minr);
sum = 0;
}
for (int j = 0; j < y; j++) {
for (int i = 0; i < x; i++) {
if (!isPrime[arr[i][j]]) {
sum += nextPrime(primes, arr[i][j]) - arr[i][j];
}
}
minr = Math.min(sum, minr);
sum = 0;
}
System.out.println(minr);
}
public static int nextPrime(int[] primes, int n) {
if (n == 1) {
return 2;
}
int low = 0;
int high = primes.length - 1;
int mid = 0;
while (low <= high) {
mid = (low + high) / 2;
if (primes[mid] < n) {
low = mid + 1;
} else if (primes[mid] > n && primes[mid - 1] < n) {
return primes[mid];
} else {
high = mid - 1;
}
}
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 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 505;
vector<int> pnum;
bool vis[100008 + 100];
int mat[maxn][maxn];
void getprime() {
for (int i = 2; i <= 100008; i++) {
if (!vis[i]) {
pnum.push_back(i);
for (int j = i + i; j <= 100008; j += i) {
vis[j] = true;
}
}
}
}
int gettimes(int n) {
if (n == 1) return 1;
int l = 0, r = pnum.size() - 1;
while (l < r) {
int mid = (l + r) >> 1;
if (pnum[mid] < n)
l = mid + 1;
else
r = mid;
}
int ret = pnum[l] - n;
return ret;
}
int main() {
getprime();
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> mat[i][j];
}
}
int ans = 2100000000;
for (int i = 1; i <= n; i++) {
int sum = 0;
for (int j = 1; j <= m; j++) {
sum += gettimes(mat[i][j]);
}
ans = min(sum, ans);
}
for (int j = 1; j <= m; j++) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += gettimes(mat[i][j]);
}
ans = min(sum, ans);
}
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 | import java.util.*;
import java.lang.*;
import java.io.*;
/* Name of the class has to be "Main" only if the class is public. */
public class Codeforces {
/* static int[] prime=new int[5000000+1];
static int[] countfactors=new int[5000000+1];
static void Seive()
{
for(int j=2;j<prime.length;j=j+2)
{
prime[j]=2;
}
for(int j=3;j<prime.length;j++)
{
if(prime[j]==0)
{
for(int z=j;z<prime.length;z=z+j)
{
if(prime[z]==0)
prime[z]=j;
}
}
}
}
static void Count()
{
countfactors[1]=0;
for(int j=2;j<countfactors.length;j++)
{
countfactors[j]=countfactors[j/prime[j]]+1;
}
}
*/
/*
static int good(int arr[],int start,int end)
{
int ct=0;
for(int p=start;p<end;p++)
{
for(int q=p+1;q<end;q++)
{
for(int r=q+1;r<end;r++)
{
if(Math.min(arr[p],arr[r])<=arr[q] && Math.max(arr[p],arr[r])>=arr[q])
return 0;
}
}
}
return 1;
}
*/
/*
static int binarySearch(long cost[],long val)
{
int lo=0,hi=cost.length-1;
while(hi-lo>1)
{
int mid=lo+(hi-lo)/2;
if(cost[mid]<=val)
lo=mid;
else
hi=mid;
}
if(cost[hi]<=val)
return hi;
else if(cost[lo]<=val)
return lo;
else
return -1;
}
*/
static boolean prime[]=new boolean[1000000+1];
static int left[]=new int[1000000+1];
static int right[]=new int[1000000+1];
static void Seive()
{
prime[1]=true;
for(int j=2;j<prime.length;j++)
{
if(prime[j]==false)
{
for(int z=j*2;z<prime.length;z=z+j)
{
prime[z]=true;
}
}
}
}
static void calculate()
{
left[0]=-1;
for(int j=1;j<left.length;j++)
{
if(prime[j]==true)
left[j]=left[j-1];
else
left[j]=j;
}
if(prime[right.length-1]==true)
right[right.length-1]=-1;
else
right[right.length-1]=right.length-1;
for(int j=right.length-2;j>=0;j--)
{
if(prime[j]==true)
right[j]=right[j+1];
else
right[j]=j;
}
}
public static void main(String[] args) throws java.lang.Exception {
/* your code goes here */
BufferedReader buf = new BufferedReader(new InputStreamReader(System.in));
// int t = Integer.parseInt(buf.readLine());
StringBuilder sb = new StringBuilder();
Seive();
calculate();
// for(int i=0;i<t;i++) {
String st1[] = (buf.readLine()).split(" ");
int n=Integer.parseInt(st1[0]);
int m=Integer.parseInt(st1[1]);
int mat[][]=new int[n][m];
for(int j=0;j<n;j++)
{
String st2[]=(buf.readLine()).split(" ");
for(int z=0;z<m;z++)
mat[j][z]=Integer.parseInt(st2[z]);
}
int moves[][]=new int[n][m];
for(int j=0;j<n;j++)
{
for(int z=0;z<m;z++)
{
moves[j][z]=right[mat[j][z]];
// sb.append(moves[j][z]+" ");
}
// sb.append("\n");
}
long min=Long.MAX_VALUE;
long sum=0;
for(int j=0;j<n;j++)
{
for(int z=0;z<m;z++)
{
sum=sum+(moves[j][z]-mat[j][z]);
}
min=Math.min(sum,min);
sum=0;
}
sum=0;
for(int j=0;j<m;j++){
for(int z=0;z<n;z++)
{
sum=sum+(moves[z][j]-mat[z][j]);
}
min=Math.min(min,sum);
sum=0;
}
sb.append(min+"\n");
// }
System.out.println(sb);
}
} | 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> isP(2e5 + 1, 1), p;
void fun() {
isP[0] = isP[1] = 0;
long long int i, j;
for (i = 2; i < 2e5 + 1; i++) {
if (isP[i]) {
for (j = 2; j * i <= (2e5); j++) isP[i * j] = 0;
p.push_back(i);
}
}
}
long long int ask(vector<long long int> &v) {
long long int i, j, k, n = v.size(), ans = 0;
for (i = 0; i < n; i++) {
long long int ind = lower_bound(p.begin(), p.end(), v[i]) - p.begin();
ans += (p[ind] - v[i]);
}
return ans;
}
void solve() {
fun();
long long int i, j, k, n, m;
cin >> n >> m;
vector<vector<long long int> > v(n, vector<long long int>(m));
for (i = 0; i < n; i++)
for (auto &i : v[i]) cin >> i;
;
long long int ans = LLONG_MAX;
for (i = 0; i < n; i++) {
ans = min(ans, ask(v[i]));
}
for (j = 0; j < m; j++) {
vector<long long int> t;
for (i = 0; i < n; i++) {
t.push_back(v[i][j]);
}
ans = min(ans, ask(t));
}
cout << ans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long 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 | def ints():
return list(map(int,input().split()))
def soe(n):
prime = [1]*(n+1)
p = 2
while(p*p<=n):
if prime[p] == 1:
for i in range(p*2,n+1,p):
prime[i] = 0
p += 1
return prime
p = soe(100500)
p[0] = -1
p[1] = 0
n,m = ints()
l = []
for _ in range(n):
l.append(ints())
mm = []
for _ in range(n):
mm.append([0]*m)
for i in range(n):
for j in range(m):
if p[l[i][j]]==1:
mm[i][j] = 0
continue
q = p[l[i][j]:min(l[i][j] + 200,len(p))].index(1)
mm[i][j] = q
ans = 10**9
for i in range(n):
ans = min(ans,sum(mm[i]))
for j in range(m):
count = 0
for i in range(n):
count += mm[i][j]
ans = min(ans,count)
print (ans)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) {
InputReader sc = new InputReader(System.in);
PrintWriter pw = new PrintWriter(System.out);
//precalculated primes
boolean prime[] = new boolean[1000003];
prime[0] = false;
prime[1] = false;
for(int i=2;i<1000002;i++)
prime[i] = true;
for(int p = 2; p*p <=1000002; p++)
{
if(prime[p] == true)
{
for(int i = p*p; i <= 1000002; i += p)
prime[i] = false;
}
}
ArrayList<Integer> pl = new ArrayList<>();
for(int i=2;i<1000002;i++)
{
if(prime[i])
pl.add(i);
}
Random gen = new Random();
int t = 1;//sc.nextInt();
while(t-- > 0)
{
int n = sc.nextInt();
int m = sc.nextInt();
int [][] ar = new int[n][m];
for(int i=0;i<n;i++)
ar[i] = sc.nextIntArray(m);
int min = Integer.MAX_VALUE;
int c = 0;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
int index = Collections.binarySearch(pl,ar[i][j]);
if(index>=0)
c+=0;
else
{
int next = -index-1;
c+=pl.get(next)-ar[i][j];
}
}
min = Math.min(min,c);
c = 0;
}
if(min!=0)
{
for(int i=0;i<m;i++)
{
for(int j=0;j<n;j++)
{
int index = Collections.binarySearch(pl,ar[j][i]);
if(index>=0)
c+=0;
else
{
int next = -index-1;
c+=pl.get(next)-ar[j][i];
}
}
min = Math.min(min,c);
c = 0;
}
}
pw.println(min);
}
pw.close();
}
static class InputReader {
private final InputStream stream;
private final byte[] buf = new byte[8192];
private int curChar, snumChars;
public InputReader(InputStream st) {
this.stream = st;
}
public int read() {
if (snumChars == -1)
throw new InputMismatchException();
if (curChar >= snumChars) {
curChar = 0;
try {
snumChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (snumChars <= 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 {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
long res = 0;
do {
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public int[] nextIntArray(int n) {
int a[] = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
public static int[] shuffle(int[] a, Random gen)
{ for(int i = 0, n = a.length;i < n;i++)
{ int ind = gen.nextInt(n-i)+i;
int d = a[i];
a[i] = a[ind];
a[ind] = d;
}
return a;
}
public String readString() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isSpaceChar(c));
return res.toString();
}
public String nextLine() {
int c = read();
while (isSpaceChar(c))
c = read();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = read();
} while (!isEndOfLine(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
private boolean isEndOfLine(int c) {
return c == '\n' || c == '\r' || c == -1;
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
limit = 100025
list_primes = [True for i in range(limit + 1)]
next_primes = [0 for i in range(200000)]
def SieveOfEratosthenes():
list_primes[0] = list_primes[1] = False
for i in range(2, int(math.sqrt(limit))):
if list_primes[i]:
j = 2
while i * j <= limit:
list_primes[i*j] = False
j += 1
def get_next_primes():
for i in range(limit - 1, -1, -1):
if list_primes[i]:
next_primes[i] = 0
else:
next_primes[i] = 1 + next_primes[i+1]
SieveOfEratosthenes()
get_next_primes()
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 += next_primes[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 += next_primes[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 | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5;
int vis[N + 2], r[502], c[502];
void init() {
for (int i = 2; i * i <= N; ++i)
if (!vis[i]) {
for (int j = i * i; j <= N; j += i) vis[j] = -1;
}
vis[0] = vis[1] = -1;
for (int i = N; i; --i)
if (vis[i]) vis[i] = vis[i + 1] + 1;
}
int main() {
ios::sync_with_stdio(false);
init();
int n, m, x;
cin >> n >> m;
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= m; ++j) {
cin >> x;
r[i] += vis[x];
c[j] += vis[x];
}
int res = 500 * N;
for (int i = 1; i <= n; ++i) res = min(res, r[i]);
for (int j = 1; j <= m; ++j) res = min(res, c[j]);
cout << res << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Arrays;
import java.util.Scanner;
public class B {
static int[] p;
public static void main(String[] args) {
buildPrime();
Scanner s = new Scanner(System.in);
int n = s.nextInt();
int m = s.nextInt();
int[][] ma = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int next = s.nextInt();
int idx = Arrays.binarySearch(p, next);
if (idx < 0) {
ma[i][j] = p[-idx - 1] - next;
}
}
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int tmp = 0;
for (int j = 0; j < m; j++) {
tmp += ma[i][j];
}
min = Math.min(min, tmp);
}
for (int j = 0; j < m; j++) {
int tmp = 0;
for (int i = 0; i < n; i++) {
tmp += ma[i][j];
}
min = Math.min(min, tmp);
}
System.out.println(min);
}
static void buildPrime() {
final int MX = 200000;
boolean[] prime = new boolean[MX];
int cnt = 0;
Arrays.fill(prime, true);
prime[0] = prime[1] = false;
for (int i = 2; i < MX; i++) {
if (prime[i]) {
cnt++;
for (int j = i + i; j < MX; j += i) {
prime[j] = false;
}
}
}
p = new int[cnt];
cnt = 0;
for (int i = 2; i < MX; i++) {
if (prime[i]) {
p[cnt++] = i;
}
}
Arrays.sort(p);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
import static java.lang.Math.min;
import static java.lang.Math.max;
public class Code implements Runnable {
public static void main(String[] args) throws IOException {
new Thread(new Code()).start();
}
private void solve() throws IOException {
int n = nextInt(), m = nextInt();
int[][] matr = new int[n][m];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
matr[i][j] = nextInt();
}
}
List<Integer> primes = getPrimes(100008);
long[] rows = new long[n];
long min = Long.MAX_VALUE;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < m; ++j) {
rows[i] += getPrime(matr[i][j], primes) - matr[i][j];
}
min = min(min, rows[i]);
}
long[] cols = new long[m];
for (int j = 0; j < m; ++j) {
for (int i = 0; i < n; ++i) {
cols[j] += getPrime(matr[i][j], primes) - matr[i][j];
}
min = min(min, cols[j]);
}
System.out.println(min);
}
private int getPrime(int num, List<Integer> primes) {
int l = 0, r = primes.size() - 1;
while (l < r) {
int mid = l + r >> 1;
if (primes.get(mid) < num)
l = mid + 1;
else
r = mid;
}
return primes.get(r);
}
private List<Integer> getPrimes(int n) {
boolean[] primes = new boolean[n];
Arrays.fill(primes, true);
primes[0] = primes[1] = false;
for (int i = 2; i < n; ++i) {
if (primes[i]) {
for (long j = (long) i * i; j < n; j += i) {
primes[(int) j] = false;
}
}
}
ArrayList<Integer> list = new ArrayList<Integer>();
for (int i = 2; i < n; ++i) {
if (primes[i])
list.add(i);
}
return list;
}
private class IntervalTree {
IntervalTree(int[] arr) {
tree = new int[arr.length << 2];
buildTree(1, 0, arr.length - 1, arr);
}
public int getMax(int l, int r) {
return getMax(1, l, r, 0, (tree.length >> 2) - 1);
}
private int getMax(int u, int l, int r, int tl, int tr) {
if (tl >= l && tr <= r)
return tree[u];
else if (r < tl || l > tr)
return 0;
else {
int mid = tl + tr >> 1, u1 = u << 1, u2 = u1 + 1;
return max(getMax(u1, l, r, tl, mid), getMax(u2, l, r, mid + 1, tr));
}
}
private void buildTree(int v, int l, int r, int[] arr) {
if (l == r)
tree[v] = arr[l];
else {
int mid = l + r >> 1, u1 = v << 1, u2 = u1 + 1;
buildTree(u1, l, mid, arr);
buildTree(u2, mid + 1, r, arr);
tree[v] = max(tree[u1], tree[u2]);
}
}
private int[] tree;
}
private class Pair<E, V> implements Comparable<Pair<E, V>> {
public Pair(E first, V second) {
this.first = first;
this.second = second;
}
@Override
public int compareTo(Pair<E, V> obj) {
if (first.equals(obj.first)) return ((Comparable) second).compareTo(obj.second);
return ((Comparable) first).compareTo(obj.first);
}
@Override
public boolean equals(Object obj) {
Pair other = (Pair) obj;
return first.equals(other.first) && second.equals(other.second);
}
@Override
public String toString() {
return first + " " + second;
}
public E first;
public V second;
}
@Override
public void run() {
try {
if (in.equals(""))
reader = new BufferedReader(new InputStreamReader(System.in));
else
reader = new BufferedReader(new FileReader(in));
if (out.equals(""))
writer = new PrintWriter(System.out, false);
else
writer = new PrintWriter(new FileWriter(out), false);
solve();
} catch (IOException e) {
e.printStackTrace();
} finally {
//writer.println((Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory()) / 1024 + " KB");
try {
reader.close();
writer.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
private long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
private double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
private float nextFloat() throws IOException {
return Float.parseFloat(nextToken());
}
private String nextToken() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(reader.readLine());
return st.nextToken();
}
private String in = "", out = "";
private BufferedReader reader;
private PrintWriter writer;
private StringTokenizer st;
}
| 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 MainClass {
public static final boolean std = true;
public static final String input = "input.txt";
public static final String output = "output.txt";
public static final int maxn = 100010;
public final Scanner in;
public final PrintWriter out;
public MainClass(Scanner IN, PrintWriter OUT) {
in = IN;
out = OUT;
}
public static void main(String[] args) throws Exception {
Locale.setDefault(Locale.US);
Scanner in;
PrintWriter out;
if (std) {
in = new Scanner(System.in);
out = new PrintWriter(System.out);
} else {
in = new Scanner(new File(input));
out = new PrintWriter(new File(output));
}
MainClass solution = new MainClass(in, out);
solution.run();
in.close();
out.close();
}
int n, m;
int[][] matrix;
boolean[] prime;
public void run() {
countPrime();
n = in.nextInt();
m = in.nextInt();
matrix = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = in.nextInt();
matrix[i][j] = getPrime(matrix[i][j]) - matrix[i][j];
}
}
int ans = 1000000000;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int j = 0; j < m; j++)
sum += matrix[i][j];
ans = Math.min(ans, sum);
}
for (int j = 0; j < m; j++) {
int sum = 0;
for (int i = 0; i < n; i++)
sum += matrix[i][j];
ans = Math.min(ans, sum);
}
out.print(ans);
}
public int getPrime(int value) {
while (!prime[value])
value++;
return value;
}
public void countPrime() {
prime = new boolean[maxn];
for (int i = 0; i < maxn; i++)
prime[i] = true;
prime[0] = prime[1] = false;
for (int i = 2; i * i < maxn; i++)
if (prime[i])
for (int j = i * i; j < maxn; j += i)
prime[j] = false;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class TaskB_2 {
public static boolean isPrime(int n) {
if (n==1) return false;
int x = (int)Math.sqrt(n);
for(int i = 2; i <= x ; i++) {
if(n%i == 0) {
return false;
}
}
return true;
}
static public ArrayList<Integer> list = new ArrayList<Integer>();
static public Object [] arr;
static public void fillList(){
for (int i=1;i<(int)10e5 + 1;i++){
if (isPrime(i))
list.add(i);
}
}
static public int binPlaceSearch(int l, int r, int key){
int c = (l+r)/2;
int last=-1;
while (l<=r){
int z=(Integer)(arr[c]);
if (z==key){
return -10;
}else if(z<key){
l=c+1;
last = c;
}else{
r=c-1;
last = c;
}
c=(l+r)/2;
}
if ((Integer)(arr[last])>key)
return last;
return last+1;
}
public static void main(String[] args) {
Scanner read = new Scanner(System.in);
int n = read.nextInt();
int m = read.nextInt();
fillList();
arr = list.toArray();
Arrays.sort(arr);
//System.out.println(arr.length);
int [][] a = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j]=read.nextInt();
}
}
int min=Integer.MAX_VALUE;
int k=0;
for (int i=0;i<n;i++){
for (int j = 0; j < m; j++) {
int z =binPlaceSearch(0,arr.length-1,a[i][j]);
if (z!=-10)
k +=(Integer)(arr[z])-a[i][j];
}
min = Math.min(min, k);
k=0;
}
k=0;
for (int j = 0; j < m; j++)
{
for (int i=0;i<n;i++) {
int z =binPlaceSearch(0,arr.length-1,a[i][j]);
if (z!=-10) {
k +=(Integer)(arr[z])-a[i][j];
}
}
min = Math.min(min, k);
k=0;
}
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 math,bisect
from collections import Counter,defaultdict
I =lambda:int(input())
M =lambda:map(int,input().split())
LI=lambda:list(map(int,input().split()))
n,m=M()
a=[]
for i in range(n):
b=LI()
a+=[b]
prime=[1]*((10**6)+1)
i=2
while i*i<=10**6:
if prime[i]:
for j in range(i+i,(10**6)+1,i):
prime[j]=0
i+=1
ans=[]
for i in range(2,(10**6)+1):
if prime[i]:ans+=[i]
mi=10000000
for i in range(n):
c=0
for j in range(m):
d=bisect.bisect_left(ans,a[i][j])
c+=abs(ans[d]-a[i][j])
# print(c,"f")
mi=min(mi,c)
for j in range(m):
c=0
for i in range(n):
d=bisect.bisect_left(ans,a[i][j])
c+=abs(ans[d]-a[i][j])
# print(c,"l")
mi=min(mi,c)
print(mi)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main {
private final int MAX = 150000;
private int primes[] = new int[MAX];
private void solve() throws IOException {
int n = nextInt();
int m = nextInt();
int a[][] = new int[n][m];
for (int i = 0; i < n; ++i)
for (int j = 0; j < m; ++j)
a[i][j] = nextInt();
Arrays.fill(primes, 0);
primes[0] = primes[1] = -1;
for (int i = 2; i <= 100003; ++i) {
if (primes[i] == 0)
for (long j = (long) i * (long) i; j <= 100060; j += i)
primes[(int) j] = -1;
}
for (int i = 100003; i > 0; --i) {
if (primes[i] == 0)
continue;
if (primes[i + 1] == 0)
primes[i] = 1;
else
primes[i] = primes[i + 1] + 1;
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; ++i) {
int res = 0;
for (int j = 0; j < m; ++j)
res += primes[a[i][j]];
if (res < min)
min = res;
}
for (int j = 0; j < m; ++j) {
int res = 0;
for (int i = 0; i < n; ++i)
res += primes[a[i][j]];
if (res < min)
min = res;
}
println(min);
}
public static void main(String[] args) {
new Main().run();
}
public void run() {
try {
if (isFileIO) {
pw = new PrintWriter(new File("cake_cutting.out"));
br = new BufferedReader(new FileReader("cake_cutting.txt"));
} else {
pw = new PrintWriter(System.out);
br = new BufferedReader(new InputStreamReader(System.in));
}
solve();
pw.close();
br.close();
} catch (IOException e) {
System.err.println("IO Error");
}
}
private void print(Object o) {
pw.print(o);
}
private void println(Object o) {
pw.println(o);
}
int[] nextIntArray(int n) throws IOException {
int arr[] = new int[n];
for (int i = 0; i < n; ++i)
arr[i] = Integer.parseInt(nextToken());
return arr;
}
int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
double nextDouble() throws IOException {
return Double.parseDouble(nextToken());
}
private String nextToken() throws IOException {
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
tokenizer = new StringTokenizer(br.readLine());
}
return tokenizer.nextToken();
}
private BufferedReader br;
private StringTokenizer tokenizer;
private PrintWriter pw;
private final boolean isFileIO = false;
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def SieveOfEratosthenes():
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
#def SieveOfEratosthenes():
# m = 100001
# n = 100000
# #numbers = [True for i in range(m)]
# numbers = [True] * m #EDIT: faster
# for i in range(2, int(n**0.5 + 1)):
# if numbers[i]:
# for j in range(i*i, m, i):
# numbers[j] = False
# primes = []
# numbers[0] = False
# numbers[1] = False
# return numbers
def CalcDistance(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 = SieveOfEratosthenes()
matrix = []
distanceArray = CalcDistance(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 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 510;
int a[maxn][maxn];
const int MAXI = 1e5 + 10;
int n, m;
set<long long> prime;
bool isPrime(long long x) {
for (long long i = 2; i * i <= x; i++)
if (x % i == 0) return false;
return x > 1;
}
void make_prime() {
for (int k = 2; k <= MAXI; k++) {
if (isPrime(k)) {
prime.insert(k);
}
}
}
void get_input() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> a[i][j];
}
}
}
void solve() {
long long ans = 1000000010;
for (long long i = 0; i < n; i++) {
long long kom = 0;
for (long long j = 0; j < m; j++) {
long long smallestp = *prime.lower_bound(a[i][j]);
kom += smallestp - a[i][j];
}
ans = min(ans, kom);
}
for (long long j = 0; j < m; j++) {
long long kom = 0;
for (long long i = 0; i < n; i++) {
long long smallestp = *prime.lower_bound(a[i][j]);
kom += smallestp - a[i][j];
}
ans = min(ans, kom);
}
cout << ans;
}
int main() {
ios ::sync_with_stdio(0), cin.tie(0), cout.tie(0);
make_prime(), get_input(), 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.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class PrimeMatrix {
static BufferedReader br;
static StringTokenizer st;
static int n, m, pn;
static int[][] a;
static int[] p = new int[222222];
static boolean[] prime;
static final int maxn = 150000;
static String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
static int nextInt() throws IOException {
return Integer.parseInt(next());
}
public static void main(String[] args) throws Exception {
br = new BufferedReader(new InputStreamReader(System.in));
n = nextInt();
m = nextInt();
a = new int[n][m];
prime = new boolean[maxn + 1];
Arrays.fill(prime, true);
for (int i = 2; i <= maxn; ++i) if (prime[i]) {
p[pn++] = i;
for (int j = i + i; j <= maxn; j += i)
prime[j] = false;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int x = nextInt();
int l = -1, r = pn;
while (r - l > 1) {
int mid = (l + r) / 2;
if (p[mid] >= x)
r = mid;
else
l = mid;
}
a[i][j] = p[r] - x;
//System.out.print(a[i][j] + " ");
}
//System.out.println();
}
int res = 1000 * 1000 * 1000;
for (int i = 0; i < n; ++i) {
int sum = 0;
for (int j = 0; j < m; ++j) {
sum += a[i][j];
}
res = Math.min(res, sum);
}
for (int j = 0; j < m; ++j) {
int sum = 0;
for (int i = 0; i < n; ++i) {
sum += a[i][j];
}
res = Math.min(res, sum);
}
System.out.println(res);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
int cad[150000];
int n, m;
int matrix[501][501];
int revolution[501][501];
int i, j;
void criba(int n) {
cad[1] = 1;
for (i = 2; i <= n; i++) {
if (cad[i] >= 0) {
for (j = i + i; j < n; j += i) {
cad[j] = 1;
}
}
}
}
int main() {
int i, j, ars, l, vector, menor = 100000;
scanf("%d%d", &n, &m);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
scanf("%d", &matrix[i][j]);
}
}
criba(150000);
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
ars = 0;
l = matrix[i][j];
while (cad[l] != 0) {
l++;
ars++;
cad[l];
}
revolution[i][j] = ars;
}
}
for (i = 0; i < n; i++) {
vector = 0;
for (j = 0; j < m; j++) {
vector += revolution[i][j];
}
if (vector < menor) {
menor = vector;
}
}
for (j = 0; j < m; j++) {
vector = 0;
for (i = 0; i < n; i++) {
vector += revolution[i][j];
}
if (vector < menor) {
menor = vector;
}
}
printf("%d", menor);
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 {
public static void main(String[] args) {
int MAX = 100100;
TreeSet<Integer> primes = new TreeSet<Integer>();
boolean[] isPrime = new boolean[MAX];
Arrays.fill(isPrime, true);
isPrime[0] = isPrime[1] = false;
for(int i=0; i<MAX; i++)
if(isPrime[i]) {
primes.add(i);
for(int j=i+i; j<MAX; j+=i)
isPrime[j] = false;
}
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
int[] row = new int[n];
int[] col = new int[m];
for(int i=0; i<n; i++)
for(int j=0; j<m; j++) {
int x = in.nextInt();
if(!isPrime[x]) {
int best = Math.abs(x-primes.higher(x));
row[i] += best;
col[j] += best;
}
}
int ans = Integer.MAX_VALUE;
for(int x : row) ans = Math.min(ans,x);
for(int x : col) ans = Math.min(ans,x);
System.out.println(ans);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.IOException;
import java.io.InputStream;
import java.util.InputMismatchException;
public class P271B_PrimeMatrix {
/**
* @param args
*/
public static void main(String[] args) {
int maxPrime = 9593;
Primes primes = new Primes(maxPrime);
int[] primeNumbers = primes.getPrimes();
InputReader inputReader = new InputReader(System.in);
int n = inputReader.nextInt();
int m = inputReader.nextInt();
int[][] numbers = inputReader.next2DIntArray(n, m);
int min = Integer.MAX_VALUE, distance = -1;
int[] sumRow = new int[n];
int[] sumColumn = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
distance = nearestPrimeDistance(primeNumbers, numbers[i][j]);
sumRow[i] += distance;
sumColumn[j] += distance;
}
if (sumRow[i] <= 0) {
System.out.println(0);
return;
}
if (sumRow[i] < min) {
min = sumRow[i];
}
}
for (int j = 0; j < m; j++) {
if (sumColumn[j] < min) {
min = sumColumn[j];
}
}
System.out.println(min);
}
private static int nearestPrimeDistance(int[] primeNumbers, int number) {
int left = 1, right = primeNumbers.length - 1, mid = (left + right) / 2;
do {
if (primeNumbers[mid] == number) {
return 0;
} else if (primeNumbers[mid] > number) {
right = mid - 1;
} else if (primeNumbers[mid] < number) {
left = mid + 1;
}
mid = (left + right) / 2;
} while (left <= right);
return primeNumbers[left] - number;
}
}
class Primes {
int[] primeNumbers;
int nPrimes;
public Primes(int n) {
primeNumbers = new int[n + 1];
primeNumbers[1] = 2;
primeNumbers[2] = 3;
nPrimes = 2;
int p = 3;
while (nPrimes < n) {
p = primeNumbers[++nPrimes] = nextPrime(p);
}
}
private int nextPrime(int p) {
do {
p += 2;
} while (!isPrime(p));
return p;
}
private boolean isPrime(int n) {
int root = (int) Math.sqrt(n + 1);
for (int i = 1; i < primeNumbers.length && primeNumbers[i] <= root; i++) {
if (n % primeNumbers[i] == 0) {
return false;
}
}
return true;
}
public boolean isPrimeNumber(int number) {
if (number > primeNumbers[nPrimes]) {
return isPrime(number);
}
// binary search
int low = 0, high = nPrimes;
while (low <= high) {
int mid = (low + high) / 2;
if (primeNumbers[mid] == number) {
return true;
} else if (primeNumbers[mid] > number) {
high = mid - 1;
} else {
low = mid + 1;
}
}
return false;
}
public int[] getPrimes() {
return primeNumbers;
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1 << 16];
private int curChar;
private int numChars;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c & 15;
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public static boolean isSpaceChar(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public char nextChar() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
return (char) c;
}
public int[] nextIntArray(int count) {
int[] result = new int[count];
for (int i = 0; i < count; i++) {
result[i] = nextInt();
}
return result;
}
public int[][] next2DIntArray(int n, int m) {
int[][] result = new int[n][];
for (int i = 0; i < n; i++) {
result[i] = nextIntArray(m);
}
return result;
}
} | 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/python
import io;
import sys;
import math;
from bisect import *;
# IO Method #
def read_int():
return map(int, raw_input().split());
pass
# Binary Search #
def index(a, x):
'Locate the leftmost value exactly equal to x'
i = bisect_left(a, x)
if i != len(a) and a[i] == x:
return i
raise ValueError
def find_lt(a, x):
'Find rightmost value less than x'
i = bisect_left(a, x)
if i:
return a[i-1]
raise ValueError
def find_le(a, x):
'Find rightmost value less than or equal to x'
i = bisect_right(a, x)
if i:
return a[i-1]
raise ValueError
def find_gt(a, x):
'Find leftmost value greater than x'
i = bisect_right(a, x)
if i != len(a):
return a[i]
raise ValueError
def find_ge(a, x):
'Find leftmost item greater than or equal to x'
i = bisect_left(a, x)
if i != len(a):
return a[i]
raise ValueError
# Self Implemented #
def sieve_prime(limit) :
primes = [];
visited = [True for _ in xrange(limit)];
sqlimit = int(math.ceil(math.sqrt(limit)));
for ii in xrange(2, sqlimit+1) :
if visited[ii] == True :
for jj in xrange(ii*ii, limit, ii) :
visited[jj] = False;
pass
pass
pass
for ii in xrange(2, limit) :
if visited[ii] :
primes.append(ii);
return primes;
pass
if __name__ == '__main__':
primes = sieve_prime(10**5+5);
row, col = read_int();
matrix = [];
for ii in xrange(row) :
matrix.append(read_int());
pass
primematrix = [];
for ii in xrange(row) :
primematrix.append([]);
for jj in xrange(col) :
primematrix[ii].append(find_ge(primes, matrix[ii][jj]));
pass
pass
res = 9123456789123456;
for ii in xrange(row) :
now = 0;
for jj in xrange(col) :
now += primematrix[ii][jj] - matrix[ii][jj];
pass
res = min(res, now);
pass
for ii in xrange(col) :
now = 0;
for jj in xrange(row) :
now += primematrix[jj][ii] - matrix[jj][ii];
pass
res = min(res, now);
print res;
pass | 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 | 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
# lendo dados
n, m = map(int, input().split())
data = []
for i in range(n):
data.append(list(map(int, input().split())))
# frequencia
contador = [0 for i in range(200000)]
contador[100000] = 3
for i in range(99999, -1, -1):
if crivo[i]:
contador[i] = 0
# print contador[i]
else:
contador[i] = 1 + contador[i + 1]
resultado = 100000
for i in range(n):
soma = 0
for j in range(m):
soma += contador[data[i][j]]
resultado = min(resultado, soma)
for i in range(m):
soma = 0
for j in range(n):
soma += contador[data[j][i]]
# print soma
resultado = min(resultado, soma)
print(resultado) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 500005;
int vis[maxn];
int q[maxn];
int Map[509][5009];
int sum = 0;
void Prime() {
for (int i = 2; i * i <= maxn; i++) {
for (int j = 2; j <= maxn; j++)
if (!vis[i] && i * j <= maxn) {
vis[i * j] = 1;
}
}
vis[1] = 1;
vis[0] = 1;
for (int i = 2; i < maxn; i++)
if (!vis[i]) q[sum++] = i;
}
const int INF = 0xfffffff;
int erfen(int key) {
int l = 0;
int r = sum;
while (l <= r) {
int mid = (l + r) >> 1;
if (key > q[mid] && key < q[mid + 1]) return mid + 1;
if (key > q[mid]) {
l = mid + 1;
}
if (key < q[mid]) r = mid - 1;
}
}
int main() {
int n, m;
Prime();
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
scanf("%d", &Map[i][j]);
}
int Min = INF;
for (int i = 0; i < n; i++) {
int ans = 0;
for (int j = 0; j < m; j++) {
int t = Map[i][j];
if (!vis[t]) continue;
if (t < 2)
ans += 1;
else {
int c = erfen(t);
ans += q[c] - t;
}
}
if (ans < Min) Min = ans;
}
for (int j = 0; j < m; j++) {
int ans = 0;
for (int i = 0; i < n; i++) {
int t = Map[i][j];
if (!vis[t]) continue;
if (t < 2)
ans += 1;
else {
int c = erfen(t);
ans += q[c] - t;
}
}
if (ans < Min) Min = ans;
}
cout << Min << endl;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
using namespace std::chrono;
void getSOE(vector<uint64_t> &p, uint64_t N, const uint64_t &maxval) {
vector<bool> v(N + 1, true);
v[0] = v[1] = false;
for (uint64_t i = 2; i * i <= N; ++i) {
if (!v[i]) continue;
for (uint64_t j = i * i; j <= N; j += i) {
v[j] = false;
}
}
for (uint64_t i = 0; i < N + 1; ++i)
if (v[i]) p.emplace_back(i);
if (p.back() >= maxval) return;
uint64_t mval = maxval;
bool vfound = false;
while (!vfound) {
bool found = false;
for (uint64_t j = 2; j * j <= mval; ++j) {
if (mval % j == 0) {
found = true;
break;
}
}
if (!found) {
p.emplace_back(mval);
break;
}
++mval;
}
}
int main() {
const uint64_t N = 100000;
uint64_t n, m;
cin >> n >> m;
vector<vector<uint64_t>> d(n, vector<uint64_t>(m));
vector<vector<uint64_t>> input(n, vector<uint64_t>(m));
uint64_t eij, maxval = 0;
for (uint64_t i = 0; i < n; ++i) {
for (uint64_t j = 0; j < m; ++j) {
cin >> eij;
maxval = max(maxval, eij);
input[i][j] = eij;
}
}
vector<uint64_t> p;
getSOE(p, N, maxval);
for (uint64_t i = 0; i < n; ++i) {
for (uint64_t j = 0; j < m; ++j) {
auto eij = input[i][j];
auto it = lower_bound(p.begin(), p.end(), eij);
assert(it != p.end());
d[i][j] = *it - eij;
assert(d[i][j] >= 0);
}
}
vector<uint64_t> rsum(n), csum(m);
uint64_t i = 0;
for (const auto &ee : d) rsum[i++] = accumulate(ee.begin(), ee.end(), 0);
for (uint64_t i = 0; i < m; ++i) {
uint64_t tsum = 0;
for (uint64_t 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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.ArrayList;
import java.io.Writer;
import java.io.OutputStreamWriter;
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 = 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(upper_bound(primes, num));
matrix[i][j] = nextPrime - num;
}
}
int min = FindMin(matrix);
System.out.println(min);
}
private 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;
}
private 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;
}
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();
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
input_file = sys.stdin;
mat = [[0 for _ in xrange(500)] for _ in xrange(500)];
prim = [0 for _ in xrange(10**5 + 1)];
next_prim = [0 for _ in xrange(10**5 + 1)];
prev_prim = [0 for _ in xrange(10**5 + 1)];
def readline():
return input_file.readline();
def is_prim(n):
if n == 1: return False;
for x in xrange(2, int(math.sqrt(n)) + 1):
if n%x == 0: return False;
return True;
if __name__ == '__main__':
prev = 0;
for x in xrange(10**5 + 1):
if is_prim(x):
prim[x] = 1;
pn = 100003;
for x in reversed(xrange(10**5 + 1)):
if not is_prim(x):
next_prim[x] = pn;
else:
pn = x;
next_prim[1] = 2;
#print prim[1:10];
#print "next_prim:",next_prim[1:10];
#print range(10);
#print prim[:10];
#print next_prim[:10];
#print prev_prim[:10];
n, m = map(int, readline().split());
for r in xrange(n):
mat[r] = map(int, readline().split());
for r in xrange(n):
for c in xrange(m):
num = mat[r][c];
if prim[num] == 1:
mat[r][c] = 0;
else:
mat[r][c] = next_prim[num] - num;
small = 10**5;
for r in xrange(n):
k = 0;
for c in xrange(m):
k += mat[r][c];
if k > small:
continue;
small = min(k, small);
for c in xrange(m):
k = 0;
for r in xrange(n):
k += mat[r][c];
if k > small:
continue;
small = min(k, small);
if small < 0:
for r in xrange(n):
line = "";
for c in xrange(m):
line += str(mat[r][c]) + " ";
print line;
print small;
| 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 | # encoding: utf-8
def makePrimeTable(limit):
isPrime = [True] * (limit)
isPrime[0] = False
isPrime[1] = False
for i in range(2, limit):
if isPrime[i]:
for j in range(i + i, limit, i):
isPrime[j] = False
return isPrime
def makeMinPrimeTable(is_prime):
min_prime = [None] * len(is_prime)
p = 2
for i in range(len(is_prime) - 1, -1, -1):
if is_prime[i]:
p = i
min_prime[i] = p
return min_prime
if __name__ == '__main__':
n, m = [int(x) for x in raw_input().rstrip().split()]
matrix = []
for i in range(n):
matrix.append([int(x) for x in raw_input().rstrip().split()])
limit = 10 ** 6 + 1
prime_table = makePrimeTable(limit)
min_prime = makeMinPrimeTable(prime_table)
toPrime = []
for row in matrix:
toPrime.append([min_prime[x] - x for x in row])
min_row = min([sum(row) for row in toPrime])
min_col = min([sum(row) for row in map(list, zip(*toPrime))])
print min(min_row, min_col) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const unsigned int MOD = 1000000007;
template <class T>
T power(T a, long long int n) {
T res = 1;
while (n > 0) {
if (n % 2) res = res * a;
a = a * a, n = n / 2;
}
return res;
}
vector<long long int> arr;
;
void SieveOfEratosthenes(int n) {
bool prime[n + 1];
memset(prime, true, sizeof(prime));
for (int p = 2; p * p <= n; p++) {
if (prime[p] == true) {
for (int i = p * p; i <= n; i += p) prime[i] = false;
}
}
for (int p = 2; p <= n; p++)
if (prime[p]) arr.push_back(p);
}
int main() {
SieveOfEratosthenes(1000000);
long long int n, m;
cin >> n >> m;
long long int mat[n + 1][m + 1];
long long int ansr = INT_MAX, ansc = INT_MAX;
for (int i = 0; i < n; i++) {
long long int sum = 0;
for (int j = 0; j < m; j++) {
cin >> mat[i][j];
long long int a = mat[i][j];
long long int ind = lower_bound(arr.begin(), arr.end(), a) - arr.begin();
sum += arr[ind] - a;
}
ansr = min(ansr, sum);
}
for (int i = 0; i < m; i++) {
long long int sum = 0;
for (int j = 0; j < n; j++) {
long long int a = mat[j][i];
long long int ind = lower_bound(arr.begin(), arr.end(), a) - arr.begin();
sum += arr[ind] - a;
}
ansc = min(ansc, sum);
}
cout << min(ansc, ansr);
}
| CPP |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.