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 |
|---|---|---|---|---|---|
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(input())
x = [i for i in range(2, n + 2)]
x[n - 1] = 1;
if(n < 3): print(-1)
else:
for v in x:
print(v, end =' ')
| PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(input())
if n == 1 or n == 2:
print(-1)
else:
arr = [x for x in range(2, n+1)]
arr.append(1)
print(*arr) | PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
bool com(pair<int, int> x, pair<int, int> y) {
if (x.first == y.first) return x.second < y.second;
return x.first < y.first;
}
long long int power(long long int x, long long int y) {
long long int prod = 1;
while (y) {
if (y & 1) prod = (prod * x) % 1000000007;
x = (x * x) % 1000000007;
y /= 2;
}
return prod;
}
const int N = 1e5 + 9;
void solve() {
int n;
cin >> n;
if (n == 1 || n == 2) {
cout << -1;
return;
}
for (int i = n; i > 0; i--) cout << i << " ";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) solve();
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n < 3) {
cout << -1;
} else {
for (int i = (int)0; i < (int)n; i++) {
cout << n - i << " ";
}
}
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
int main() {
int i, j, n, a[105];
for (i = 1; i <= 100; i++) a[i] = 1;
a[1] = 3;
a[2] = 2;
scanf("%d", &n);
if (n <= 2)
printf("-1\n");
else
for (i = 1; i <= n; i++) printf("%d ", a[i]);
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n;
cin >> n;
if (n == 1 || n == 2)
cout << -1;
else
for (int i = n; i >= 1; i--) cout << i << " ";
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | __autor__ = 'Esfandiar'
n = int(input())
if n < 3:print(-1);exit()
print(5,4,end=" ")
for i in range(n-2):print(1,end=" ")
| PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(input())
if n <= 2:
print(-1)
else:
ans = [3, 2, 1] + [1] * (n - 3)
print(*ans) | PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(input())
if n == 1 or n == 2:
print(-1)
else:
for I in range(n, 0, -1):
print(I, end = " ")
print()
| PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n=int(input())
if(n<=2):
print(-1)
else:
for i in range(n,1,-1):
print(i,end=" ")
print(1)
| PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(input())
if (n <= 2):
print(-1)
else:
for i in range(n):
print(n-i, end = ' ') | PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | import java.util.*;
import java.io.*;
import java.math.*;
public class Main{
public static void main(String []args)throws IOException{
//BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
Scanner input = new Scanner(System.in);
PrintWriter pw = new PrintWriter(new OutputStreamWriter(System.out));
int n = input.nextInt();
if(n<=2) pw.println("-1");
else{
for(int i = 2 ;i <= n ;i++)
pw.print(i+" ");
pw.print("1");
pw.println();
}
pw.close();
}
} | JAVA |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | import java.util.*;
public class BuggySorting {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
int n = cin.nextInt();
if (n < 3) {
System.out.print(-1);
System.exit(0);
}
for (int i = n; i > 0; i--) {
System.out.print(i + " ");
}
cin.close();
}
}
| JAVA |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n = int(raw_input())
if n < 3:
print -1
else:
for i in range(n, 0, -1):
print i, | PYTHON |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 2)
cout << -1;
else {
while (n) {
cout << n << " ";
n--;
}
}
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
if (n <= 2)
cout << -1 << endl;
else
for (int i = n; i > 0; i--) cout << i << " ";
cout << endl;
return 0;
}
| CPP |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | n=eval(input())
a=""
if n==1 or n==2 :
print (-1)
else:
i=0
j=100
while i<n :
a+= str(j)
a+=" "
i+=1
j-=1
print (str(a))
| PYTHON3 |
246_A. Buggy Sorting | Little boy Valera studies an algorithm of sorting an integer array. After studying the theory, he went on to the practical tasks. As a result, he wrote a program that sorts an array of n integers a1, a2, ..., an in the non-decreasing order. The pseudocode of the program, written by Valera, is given below. The input of the program gets number n and array a.
loop integer variable i from 1 to n - 1
loop integer variable j from i to n - 1
if (aj > aj + 1), then swap the values of elements aj and aj + 1
But Valera could have made a mistake, because he hasn't yet fully learned the sorting algorithm. If Valera made a mistake in his program, you need to give a counter-example that makes his program work improperly (that is, the example that makes the program sort the array not in the non-decreasing order). If such example for the given value of n doesn't exist, print -1.
Input
You've got a single integer n (1 ≤ n ≤ 50) — the size of the sorted array.
Output
Print n space-separated integers a1, a2, ..., an (1 ≤ ai ≤ 100) — the counter-example, for which Valera's algorithm won't work correctly. If the counter-example that meets the described conditions is impossible to give, print -1.
If there are several counter-examples, consisting of n numbers, you are allowed to print any of them.
Examples
Input
1
Output
-1 | 2 | 7 | import java.util.*;
import java.io.*;
import java.lang.*;
import java.math.*;
public class newsort
{
public static void main(String args[]) throws IOException
{
BufferedReader cin=new BufferedReader(new InputStreamReader(System.in));
int n=Integer.parseInt(cin.readLine());
/*String s=cin.readLine();
String[] tok=s.split(" ");
int ar[]=new int[n];
for(int i=0;i<n;i++)
{
ar[i]=Integer.parseInt(tok[i]);
}
int temp=0;
for(int i=0;i<n-1;i++)
{
for(int j=i;j<n-1;j++)
{
if(ar[j]>ar[j+1])
{
temp=ar[j];
ar[j]=ar[j+1];
ar[j+1]=temp;
}
else;
}
}*/
if(n<=2)
System.out.print(-1);
else
{
for(int i=n;i>0;i--)
{
System.out.print(i+ " ");
}
}
System.out.println();
}
} | 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 comp(int a, int b) { return (a < b); }
int main() {
long long int s = 100010;
bool a[s];
memset(a, true, s);
a[1] = false;
for (int i = 2; i * i < s; i++) {
if (a[i]) {
for (int j = i + i; j < s; j += i) a[j] = false;
}
}
long long int m, n;
cin >> m >> n;
long long int row[501] = {0}, col[501] = {0};
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
long long int x;
cin >> x;
long long int k = x;
while (!a[k]) {
k++;
}
row[i] += k - x;
col[j] += k - x;
}
}
int min_row_ele = *(min_element(row, row + m));
int min_col_ele = *(min_element(col, col + n));
cout << min(min_row_ele, min_col_ele);
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 | # coding: utf-8
matrix_params = input()
params = matrix_params.split(" ")
rows = int(params[0])
cols = int(params[1])
initial_matrix = []
count_r = []
count_c = []
curr_row = []
def is_prime(n):
if n <= 3:
return n > 1
if n % 2 == 0 or n % 3 == 0:
return False
i = 5
while i ** 2 <= n:
if n % i == 0 or n % (i + 2) == 0:
return False
i += 6
return True
def count_to_prime(n):
count = 0
while not is_prime(n + count):
count += 1
return count
for i in range(cols):
count_c.append(0)
for i in range(rows):
count_r.append(0)
raw_row = input()
curr_row = raw_row.split(" ")
initial_matrix.append(curr_row)
for i in range(rows):
for j in range(cols):
increase = count_to_prime(int(initial_matrix[i][j]))
count_c[j] += increase
count_r[i] += increase
def get_min(array):
minimum = array[0]
for i in range(1, len(array)):
if array[i] < minimum:
minimum = array[i]
return minimum
min_cols = get_min(count_c)
min_rows = get_min(count_r)
print(min_cols if min_cols < min_rows else min_rows)
| 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, m, a[600][600], r[600], c[600], pr[111118];
int check[111118];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
cin >> a[i][j];
}
}
for (int i = 1; i <= 111111; i++) {
check[i] = 1;
}
check[1] = 0;
for (int i = 2; i <= 111111; i++) {
for (int j = i + i; j <= 111111; j += i) {
check[j] = 0;
}
}
for (int i = 2; i <= 111111; i++) {
if (check[i] == 1) pr[i] = i;
}
for (int i = 111111; i >= 0; i--) {
if (check[i] == 0) pr[i] = pr[i + 1];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
if (check[a[i][j]]) {
a[i][j] = 0;
} else {
a[i][j] = abs(a[i][j] - pr[a[i][j]]);
}
}
}
int ans = 999999;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++) {
r[i] += a[i][j];
}
ans = min(ans, r[i]);
}
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
c[i] += a[j][i];
}
ans = min(ans, c[i]);
}
cout << ans;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.lang.*;
import java.io.*;
import java.util.*;
public class Matrix {
public static void main(String[] args) throws java.lang.Exception {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskA solver = new TaskA();
solver.solve(in, out);
out.close();
}
}
class TaskA {
public final static int maxn = 505;
public final static int maxm = 100005;
int[][] M = new int[maxn][maxn];
boolean[] visit = new boolean[maxm];
int[] inc = new int[maxm];
public void solve(InputReader in, PrintWriter out) {
int n = in.nextInt(), m = in.nextInt();
int[] rs = new int[n];
int[] cs = new int[m];
int i, j, k;
int ans = Integer.MAX_VALUE;
init();
for (i=0; i<n; ++i) {
for (j=0; j<m; ++j) {
k = inc[in.nextInt()];
rs[i] += k;
cs[j] += k;
}
}
for (i=0; i<n; ++i)
ans = Math.min(ans, rs[i]);
for (i=0; i<m; ++i)
ans = Math.min(ans, cs[i]);
out.println(ans);
}
private void init() {
int i, j;
long tmp;
int pre = 0;
Arrays.fill(visit, true);
visit[0] = visit[1] = false;
for (i=2; i<maxm; ++i) {
if (visit[i]) {
tmp = 1L * i * i;
if (tmp < maxm) {
for (j=i+i; j<maxm; j+=i)
visit[j] = false;
}
for (j=pre+1; j<=i; ++j)
inc[j] = i - j;
pre = i;
}
}
}
}
class InputReader {
public BufferedReader reader;
public StringTokenizer tokenizer;
public InputReader(InputStream stream) {
reader = new BufferedReader(new InputStreamReader(stream), 32768);
tokenizer = null;
}
public String next() {
while (tokenizer==null || !tokenizer.hasMoreTokens()) {
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (IOException e) {
throw new RuntimeException(e);
}
}
return tokenizer.nextToken();
}
public int nextInt() {
return Integer.parseInt(next());
}
public long nextLong() {
return Long.parseLong(next());
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class Solution {
void solve() throws IOException {
boolean[] p = new boolean[200010];
Arrays.fill(p, true);
List<Integer> primes = new ArrayList<>(p.length);
for (int i = 2; i < p.length; i++) {
if (p[i]) {
primes.add(i);
for (int j = i; j < p.length; j += i) {
p[j] = false;
}
}
}
int n = in.nextInt(), m = in.nextInt();
int[][] a = new int[n][m];
int[] rowMax = new int[n], colMax = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j] = in.nextInt();
int k = Collections.binarySearch(primes, a[i][j]);
if (k < 0) {
k = -k - 1;
rowMax[i] += primes.get(k) - a[i][j];
colMax[j] += primes.get(k) - a[i][j];
}
}
}
int min = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
min = Math.min(min, rowMax[i]);
}
for (int i = 0; i < m; i++) {
min = Math.min(min, colMax[i]);
}
System.out.println(min);
}
public void run() throws IOException {
in = new MyScanner();
solve();
in.close();
}
private MyScanner in;
public class MyScanner {
private BufferedReader br;
private StringTokenizer st;
public MyScanner() {
this.br = new BufferedReader(new InputStreamReader(System.in));
}
public MyScanner(String fileTitle) throws IOException {
this.br = new BufferedReader(new FileReader(fileTitle + ".in"));
}
public String next() throws IOException {
while (st == null || !st.hasMoreTokens()) {
String s = br.readLine();
if (s == null) {
return "-1";
}
st = new StringTokenizer(s);
}
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public long nextLong() throws IOException {
return Long.parseLong(next());
}
public int[] nextIntArr(int n) throws IOException {
int[] a = new int[n];
for (int i = 0; i < n; i++) {
a[i] = nextInt();
}
return a;
}
public void close() throws IOException {
br.close();
}
}
public static void main(String[] args) throws IOException {
new Solution().run();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
const long double eps = 1e-12;
using namespace std;
vector<long long int> primes;
long long int p[1000001];
void primeSeive() {
long long int n = 1000001;
p[0] = p[1] = 0;
p[2] = 1;
for (long long int i = 3; i <= n; i += 2) {
p[i] = 1;
}
for (long long int i = 3; i <= n; i += 2) {
if (p[i] == 1) {
for (long long int j = i * i; j <= n; j = j + i) {
p[j] = 0;
}
}
}
primes.push_back(2);
for (long long int i = 3; i <= n; i += 2) {
if (p[i] == 1) {
primes.push_back(i);
}
}
}
void solve() {
long long int n, m;
cin >> n >> m;
vector<vector<long long int>> arr(n, vector<long long int>(m));
long long int cnt = INT_MAX;
primeSeive();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> arr[i][j];
}
}
for (int i = 0; i < n; i++) {
long long int temp = 0;
for (int j = 0; j < m; j++) {
temp += primes[lower_bound(primes.begin(), primes.end(), arr[i][j]) -
primes.begin()] -
arr[i][j];
}
cnt = min(cnt, temp);
}
for (int i = 0; i < m; i++) {
long long int temp = 0;
for (int j = 0; j < n; j++) {
temp += primes[lower_bound(primes.begin(), primes.end(), arr[j][i]) -
primes.begin()] -
arr[j][i];
}
cnt = min(cnt, temp);
}
cout << cnt << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cout << fixed << setprecision(12);
int t = 1;
for (int i = 0; i < t; i++) {
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 | max = 150035
primes = [0 for x in range(max)]
def sieveOfEratosthenes():
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]
sieveOfEratosthenes()
columns = [0 for x in range(max)]
n, m = map(int, input().split())
res = 1e9
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 | import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
/**
* Built using CHelper plug-in
* Actual solution is at the top
*/
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);
BPrimeMatrix solver = new BPrimeMatrix();
solver.solve(1, in, out);
out.close();
}
static class BPrimeMatrix {
public void solve(int testNumber, InputReader sc, OutputWriter out) {
int n = sc.nextInt();
int m = sc.nextInt();
boolean val[] = new boolean[100021];
Arrays.fill(val, true);
val[1] = false;
for (int i = 2; i * i <= 100020; i++) {
for (int j = i * i; j <= 100020; j += i) {
val[j] = false;
}
}
int ar[][] = new int[n][m];
int r[] = new int[n];
int c[] = new int[m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
int v = ar[i][j] = sc.nextInt();
while (!val[v])
v++;
int dif = v - ar[i][j];
r[i] += dif;
c[j] += dif;
}
}
int min = Integer.MAX_VALUE;
for (int i : r)
if (i < min)
min = i;
for (int i : c)
if (i < min)
min = i;
out.println(min);
}
}
static class OutputWriter {
private final PrintWriter writer;
public OutputWriter(OutputStream outputStream) {
writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
}
public OutputWriter(Writer writer) {
this.writer = new PrintWriter(writer);
}
public void close() {
writer.close();
}
public void println(int i) {
writer.println(i);
}
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1) {
throw new InputMismatchException();
}
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0) {
return -1;
}
}
return buf[curChar++];
}
public int nextInt() {
int c = read();
while (isSpaceChar(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int res = 0;
do {
if (c < '0' || c > '9') {
throw new InputMismatchException();
}
res *= 10;
res += c - '0';
c = read();
} while (!isSpaceChar(c));
return res * sgn;
}
public boolean isSpaceChar(int c) {
if (filter != null) {
return filter.isSpaceChar(c);
}
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
//package B;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Solution {
BufferedReader br;
StringTokenizer st;
int n, m, pn;
int[][] a;
int[] p = new int[222222];
boolean[] prime;
final int maxn = 150000;
public String next() throws IOException {
while (st == null || !st.hasMoreTokens())
st = new StringTokenizer(br.readLine());
return st.nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(next());
}
public void run() 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);
}
public static void main(String[] args) throws Exception {
new Solution().run();
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
const int LI = 100005;
using namespace std;
int isprime[LI + 10];
int main() {
int n, m;
int t[502][502], sl[502] = {0}, sc[502] = {0}, tbs[502][502], minl, minc;
vector<int> prime;
for (int i = 2; i < LI; i++) {
if (isprime[i] == 0) {
for (long long j = i + i; j < LI; j += i) {
isprime[j] = 1;
}
prime.push_back(i);
}
}
cin >> n >> m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> t[i][j];
if (binary_search(prime.begin(), prime.end(), t[i][j]))
tbs[i][j] = 0;
else if (t[i][j] == 0 || t[i][j] == 1)
tbs[i][j] = 2 - t[i][j];
else
tbs[i][j] =
*(upper_bound(prime.begin(), prime.end(), t[i][j])) - t[i][j];
sl[i] += tbs[i][j];
}
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
sc[i] += tbs[j][i];
}
}
minl = *min_element(sl, sl + n);
minc = *min_element(sc, sc + m);
cout << min(minl, minc);
}
| 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.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
public class Main4
{
public static void main(String a[]) throws IOException
{
BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st;
boolean prime[]=new boolean[1000001];
prime[1]=true;
for(int i=2;i*i<1000001;i++)
{
if(!prime[i])
{
for(int j=i*i;j<1000001;j+=i)
prime[j]=true;
}
}
st=new StringTokenizer(br.readLine());
int r=Integer.parseInt(st.nextToken());
int c=Integer.parseInt(st.nextToken());
int[][] mat=new int[r][c];
int row[]=new int[r];
int col[]=new int[c];
int minr=Integer.MAX_VALUE;
int minc=Integer.MAX_VALUE;
for(int i=0;i<r;i++)
{
st=new StringTokenizer(br.readLine());
for(int j=0;j<c;j++)
{
int count=0;
mat[i][j]=Integer.parseInt(st.nextToken());
while(prime[mat[i][j]])
{
mat[i][j]++;
count++;
}
row[i]+=count;
col[j]+=count;
}
if(minr>row[i] )
minr=row[i];
}
for(int i=0;i<c;i++)
if(col[i]<minc)
minc=col[i];
int min=Math.min(minc,minr);
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.*;
import java.io.*;
public class Main
{
public static void main(String[] args)
{
FastScanner in = new FastScanner(System.in);
int N = in.nextInt();
int M = in.nextInt();
int[][] mat = new int[N+1][M+1];
for (int i = 1; i <=N; i++)
for (int j = 1; j <= M; j++)
{
int p = in.nextInt();
while (! isPrime(p+mat[i][j])) mat[i][j]++;
}
int answer = 500 * 1000;
for (int r = 1; r <= N; r++)
{
int sum = 0;
for (int c = 1; c <= M; c++)
sum += mat[r][c];
if (answer > sum) answer = sum;
}
for (int c = 1; c <= M; c++)
{
int sum = 0;
for (int r = 1; r <= N; r++)
sum += mat[r][c];
if (answer > sum) answer = sum;
}
System.out.println(answer);
}
static boolean isPrime(int n)
{
if (n == 1)
return false;
if (n == 2) return true;
if ((n & 1) == 0) return false;
if (n == 3) return true;
if (n % 3 == 0) return false;
int last = 1 + (int) Math.sqrt(n);
int d = 5;
while (d <= last)
{
if (n % d == 0)
return false;
d += 2;
if (n % d == 0)
return false;
d += 4;
}
return true;
}
}
class FastScanner
{
BufferedReader reader;
StringTokenizer tokenizer;
FastScanner (InputStream inputStream)
{
reader = new BufferedReader(new InputStreamReader(inputStream));
}
String nextToken()
{
while (tokenizer == null || ! tokenizer.hasMoreTokens())
{
try {
tokenizer = new StringTokenizer(reader.readLine());
} catch (Exception e){}
}
return tokenizer.nextToken();
}
int nextInt()
{
return Integer.parseInt(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 | rows,cols = map(int,input().split())
a = []
for i in range(rows):
a.append([])
k = list(map(int,input().split()))
a[i]+=k
primes = [True for i in range(100004)]
for num in range(2,50003):
for i in range(num+num,100004,num):
primes[i]=False
primes[0]=2
primes[1]=2
primes[2]=2
for num in range(3,100004):
if(primes[num]==True):
i = num-1
while(primes[i]==False):
primes[i]=num
i-=1
primes[num]=num
answer = 300012
# rows
for row in range(rows):
cur = 0
for col in range(cols):
cur+=primes[a[row][col]]-a[row][col]
answer = min(answer,cur)
# cols
for col in range(cols):
cur = 0
for row in range(rows):
cur+=primes[a[row][col]]-a[row][col]
answer = min(answer,cur)
print(answer) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | ncrivo = int(10e5)
crivo = [True for i in range(ncrivo)]
crivo[0] = False
crivo[1] = False
for i in range(2, ncrivo):
if crivo[i]:
for j in range(i ** 2, ncrivo, i):
crivo[j] = False
# frequencia
contador = [0 for i in range(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]
# lendo dados
n, m = map(int, input().split())
data = []
for i in range(n):
data.append(list(map(int, input().split())))
resultado = 100000
for i in range(n):
soma = 0
for j in range(m):
soma += contador[data[i][j]]
resultado = min(resultado, soma)
for i in range(m):
soma = 0
for j in range(n):
soma += contador[data[j][i]]
# print soma
resultado = min(resultado, soma)
print(resultado) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | def genSieve():
n = 200000
isPrime = [True for i in range(n)]
isPrime[0] = isPrime[1] = False
for i in range(2,n):
j = i
while i*j < n:
isPrime[i*j] = False
j += 1
return isPrime
isPrime = genSieve()
def distToPrime(n):
dist = 0
while True:
if isPrime[n+dist]:
break
dist += 1
return dist
def toDistMatrix(matrix):
n, m = len(matrix), len(matrix[0])
for i in range(n):
for j in range(m):
matrix[i][j] = distToPrime(matrix[i][j])
def getAns(matrix):
n, m = len(matrix), len(matrix[0])
ans = 1000000
for i in range(n):
temp = 0
for j in range(m):
temp += matrix[i][j]
ans = min(temp, ans)
for j in range(m):
temp = 0
for i in range(n):
temp += matrix[i][j]
ans = min(temp, ans)
return ans
n, m = (int(x) for x in input().split())
matrix = [[int(x) for x in input().split()] for x in range(n)]
toDistMatrix(matrix)
print(getAns(matrix)) | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.math.*;
import java.util.*;
/**
*
* @author Togrul Gasimov ([email protected])
* Created on 13.09.2013
*/
public class Main {
public static void main(String[] args) /*throws FileNotFoundException*/ {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
FastScanner in = new FastScanner(inputStream);
FastPrinter out = new FastPrinter(outputStream);
TaskA solver = new TaskA();
solver.solve(1, in, out);
out.close();
}
}
class TaskA{
static String s = "";
static void del(int i){
s = s.substring(0, i) + s.substring(i + 1);
}
static boolean p(String s){
int l = s.length();
for(int i = 0; i <= s.length() / 2; i++){
l--;
if(s.charAt(i) != s.charAt(l))return false;
}
return true;
}
public void solve(int testNumber, FastScanner scan, FastPrinter out) /*throws FileNotFoundException*/ {
//Scanner sscan = new Scanner(new File("input.txt"));
//PrintStream oout = new PrintStream(new File("output.txt"));
int[] d = new int[1000001];
for (int i = 2; i < 50003; i++) {
for (int j = 2; i * j < 100004; j++) {
d[(i * j) - 1] = 2;
}
}
d[0] = 2;
int n = scan.nextInt(), m = scan.nextInt(), min = Integer.MAX_VALUE;
int[][] a = new int[500][500];
for(int i = 0; i < n; i++){
int move = 0;
for(int j = 0; j < m; j++){
int w = scan.nextInt();
while(d[w - 1] == 2){
a[i][j]++; w++; move++;
}
}
if(move < min)min = move;
}
for(int i = 0; i < m; i++){
int move = 0;
for(int j = 0; j < n; j++){
move += a[j][i];
}
if(move < min)min = move;
}
out.println(min);
//sscan.close();
//oout.close();
}
}
class FastScanner extends BufferedReader {
public FastScanner(InputStream is) {
super(new InputStreamReader(is));
}
public int read() {
try{
int ret = super.read();
return ret;
}catch(Exception e){
throw new InputMismatchException();
}
}
public String next() {
StringBuilder sb = new StringBuilder();
int c = read();
while (isWhiteSpace(c)) {
c = read();
}
if (c < 0) {
return null;
}
while (c >= 0 && !isWhiteSpace(c)) {
sb.appendCodePoint(c);
c = read();
}
return sb.toString();
}
static boolean isWhiteSpace(int c) {
return c >= 0 && c <= 32;
}
public int nextInt() {
int c = read();
while (isWhiteSpace(c)) {
c = read();
}
int sgn = 1;
if (c == '-') {
sgn = -1;
c = read();
}
int ret = 0;
while (c >= 0 && !isWhiteSpace(c)) {
if (c < '0' || c > '9') {
throw new NumberFormatException("digit expected " + (char) c
+ " found");
}
ret = ret * 10 + c - '0';
c = read();
}
return ret * sgn;
}
public long nextLong() {
return Long.parseLong(next());
}
public double nextDouble() {
return Double.parseDouble(next());
}
public BigInteger nextBigInteger() {
return new BigInteger(next());
}
public BigDecimal nextBigDecimal(){
return new BigDecimal(next());
}
public String readLine(){
try{
return super.readLine();
}catch(IOException e){
return null;
}
}
}
class FastPrinter extends PrintWriter {
public FastPrinter(OutputStream out) {
super(out);
}
public FastPrinter(Writer out) {
super(out);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Scanner;
import java.util.Set;
import java.util.Stack;
import java.util.Vector;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class Main {
public static void main(String[] args) throws IOException {
Task task = new Task();
task.getData();
task.solve();
task.printAnswer();
}
}
class Task {
final int maxValueInMatrix = 100000;
int[][] matrix;
//StringBuilder answer = new StringBuilder();
int answer = 0;
public void getData() throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String[] data = br.readLine().split(" ");
matrix = new int[Integer.parseInt(data[0])][Integer.parseInt(data[1])];
for (int row = 0; row < matrix.length; ++row) {
data = br.readLine().split(" ");
for (int column = 0; column < matrix[0].length; ++column) {
matrix[row][column] = Integer.parseInt(data[column]);
}
}
}
public void solve() {
ArrayList<Integer> primes = firstPrimes(1000000);
answer = Integer.MAX_VALUE;
for (int row = 0; row < matrix.length; ++row) {
int answerForCurrentRow = 0;
for (int column = 0; column < matrix[0].length; ++column) {
int index = Collections.binarySearch(primes, matrix[row][column]);
if (index >= 0) {
continue;
}
index = -(index + 1);
answerForCurrentRow += primes.get(index) - matrix[row][column];
}
answer = Math.min(answer, answerForCurrentRow);
}
for (int column = 0; column < matrix[0].length; ++column) {
int answerForCurrentColumn = 0;
for (int row = 0; row < matrix.length; ++row) {
int index = Collections.binarySearch(primes, matrix[row][column]);
if (index >= 0) {
continue;
}
index = -(index + 1);
answerForCurrentColumn += primes.get(index) - matrix[row][column];
}
answer = Math.min(answer, answerForCurrentColumn);
}
}
private ArrayList<Integer> firstPrimes(int bound) {
boolean[] isPrime = new boolean[bound];
Arrays.fill(isPrime, 2, isPrime.length, true);
for (int i = 2; i <= Math.sqrt(bound); ++i) {
if (isPrime[i]) {
for (int j = i * i; j < bound; j += i) {
isPrime[j] = false;
}
}
}
ArrayList<Integer> primes = new ArrayList<Integer>();
for (int i = 0; i < isPrime.length; ++i) {
if (isPrime[i]) {
primes.add(i);
}
}
return primes;
}
public void printAnswer() {
System.out.print(answer);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #!/usr/bin/env python3
# Takes INT for number up to which to calculate primes.
# Returns 2 lists: list of primes and lists of flags corresponding to index of primes.
def find_primes(prime_len):
# Create a FLAG list of TRUE with length of values to search primes in.
flag_list = [True]*(prime_len)
# Make index 0, 1 not flagged as primes
flag_list[0] = flag_list[1] = False
# Initialize PRIME LIST - return
prime_list = []
for i in range(2,int((prime_len)**.5)):
if flag_list[i]:
for n in range(i+i,len(flag_list),i):
flag_list[n] = False
for idx in range(len(flag_list)):
if flag_list[idx]:
prime_list.append(idx)
return prime_list, flag_list
# RECURSION
#condition that kills
#what's the call
#what parameters change
# this function returns next higher value from search_list, closest to input value: val.
def next_val_binary_search(val, search_list, idx_low, idx_hi):
idx_mid = int((idx_hi + idx_low) / 2)
# Kill function if we find the value
if idx_mid == idx_low:
if val < search_list[0]:
next_prime = search_list[0]
return next_prime
next_prime = search_list[idx_hi]
return next_prime
if val > search_list[idx_mid]:
new_idx_low = idx_mid
next_prime = next_val_binary_search(val, search_list, new_idx_low, idx_hi)
return next_prime
else:
new_idx_hi = idx_mid
next_prime = next_val_binary_search(val, search_list, idx_low, new_idx_hi)
return next_prime
###########################################
##################_TESTS_##################
###########################################
#prime_list = find_primes(100)
#next_prime = (next_val_binary_search( 42, prime_list, 0, (len(prime_list)-1) ) )
#print(next_prime)
# if val in prime_list:
# continue
# else:
# next_val_binary_search()
# Get PRIME LIST
prime_list, flag_list = find_primes(10**5 + 5)
max_dif = 0
'''
for i in range (len(prime_list)-1):
dif = prime_list[i+1] - prime_list[i]
max_dif = max(max_dif, dif)
print(max_dif)
'''
# Get matrix dimentions[row,col]
dimentions = input()
dimentions = dimentions.split()
for i in range(len(dimentions)):
dimentions[i] = int(dimentions[i])
# get matrix
input_matrix = []
for r in range(dimentions[0]):
row = input()
row = row.split()
for n in range(len(row)):
row[n] = int(row[n])
input_matrix.append(row)
# Evaluate row moves necessary to get all values to the next prime
moves = 10**5
for row in input_matrix:
row_moves = 0
for val in row:
if not flag_list[val]:
next_prime = next_val_binary_search( val, prime_list, 0, (len(prime_list) -1) )
dist_to_next_prime = next_prime - val
#print("val:",val, "nxt p:", next_prime, "dist:", dist_to_next_prime)
row_moves += dist_to_next_prime
moves = min(moves, row_moves)
#print(row_moves)
#print('moves: %d' % moves)
for col in range(dimentions[1]):
col_moves = 0
for row in input_matrix:
val = row[col]
if not flag_list[val]:
next_prime = next_val_binary_search( val, prime_list, 0, (len(prime_list) -1) )
dist_to_next_prime = next_prime - val
#print("val:",val, "nxt p:", next_prime, "dist:", dist_to_next_prime)
col_moves += dist_to_next_prime
moves = min(moves, col_moves)
#print(col_moves)
#print('moves: %d' % moves)
#print(input_matrix)
print(moves)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.IOException;
import java.io.PrintWriter;
import java.math.BigDecimal;
import java.math.MathContext;
import java.text.DecimalFormat;
import java.util.*;
public class contest {
public static boolean isPrime(int n) {
if(n==2)return true;
if(n==3)return true;
for(int i=2;i<Math.sqrt(n)+1;i++) {
if(n%i==0)return false;
}
return true;
}
public static int closePrime(int[] primes,int key,int l) {
int a = 0;
int b = l-1;
int mid = 0;
while(a<=b) {
mid = (a+b)/2;
if(primes[mid]<key) {
a = mid+1;
}else{
b = mid-1;
}
}
if(primes[mid]==key) {
return 0;
}else {
return primes[a]-key;
}
}
public static void main(String[] args) throws IOException{
Scanner sc = new Scanner(System.in);
PrintWriter pw = new PrintWriter(System.out);
int[] primes = new int[100000];
int k = 0;
for(int i=2;i<100100;i++) {
if(isPrime(i)) {
primes[k++] = i;
}
}
int n = sc.nextInt();
int m = sc.nextInt();
int[][] mat = new int[n][m];
int[][] dif = new int[n][m];
for(int i=0;i<mat.length;i++) {
for(int j=0;j<mat[i].length;j++) {
mat[i][j] = sc.nextInt();
dif[i][j] = closePrime(primes,mat[i][j],k);
}
}
int max = Integer.MAX_VALUE;
for(int i=0;i<dif.length;i++) {
int c1 = 0;
for(int j=0;j<dif[i].length;j++) {
c1 += dif[i][j];
}
max = Math.min(c1, max);
}
for(int i=0;i<m;i++) {
int c1=0;
for(int j=0;j<n;j++) {
c1+=dif[j][i];
}
max = Math.min(c1, max);
}
System.out.println(max);
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
public class main {
public static ArrayList<Integer> sieve(int n){
boolean[] primeBoolArray = new boolean[n+1];
Arrays.fill(primeBoolArray, true);
ArrayList<Integer> myPrimes = new ArrayList<Integer>(n+1);
primeBoolArray[0] = false;
primeBoolArray[1] = false;
for(int currNumber = 2; currNumber < n; currNumber++) {
if(primeBoolArray[currNumber] == true) {
myPrimes.add(currNumber);
for(int i = (2*currNumber); i < n; i += currNumber) {
primeBoolArray[i] = false;
}
}
}
return myPrimes;
}
public static int binarySearch(List<Integer> primeList, int start, int end, int value){
if (end >= start){
int mid = (start + end)/2;
if(primeList.get(mid) == value) {
return value;
}else if(primeList.get(mid) < value) {
return binarySearch(primeList, mid+1, end, value);
} else {
return binarySearch(primeList, start, mid-1, value);
}
}
if(start < primeList.size()) {
return primeList.get(start);
}
return -1;
}
public static void main(String[] args) {
ArrayList<Integer> allPrimes = sieve(200001);
Scanner sc = new Scanner(System.in);
int matrixRows = sc.nextInt();
int matrixCols = sc.nextInt();
int[][] myMatrix = new int[matrixRows][matrixCols];
for(int currRow = 0; currRow < matrixRows; currRow++) {
for(int currCol = 0; currCol < matrixCols; currCol++) {
myMatrix[currRow][currCol] = sc.nextInt();
}
}
int[] rowsValue = new int[matrixRows];
int[] colsValue = new int[matrixCols];
for(int currRow = 0; currRow < matrixRows; currRow++) {
for(int currCol = 0; currCol < matrixCols; currCol++) {
int currNumber = myMatrix[currRow][currCol];
int smallestPrime = binarySearch(allPrimes, 0, allPrimes.size()-1, currNumber);
int primeDiff = smallestPrime - currNumber;
rowsValue[currRow] += primeDiff;
}
}
for(int currCol = 0; currCol < matrixCols; currCol++) {
for(int currRow = 0; currRow < matrixRows; currRow++) {
int currNumber = myMatrix[currRow][currCol];
int smallestPrime = binarySearch(allPrimes, 0, allPrimes.size()-1, currNumber);
int primeDiff = smallestPrime - currNumber;
colsValue[currCol] += primeDiff;
}
}
int minRowValue = Arrays.stream(rowsValue).min().getAsInt();
int minColValue = Arrays.stream(colsValue).min().getAsInt();
if(minRowValue < minColValue) {
System.out.print(minRowValue);
} else {
System.out.print(minColValue);
}
}
} | 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.util.ArrayList;
import java.util.StringTokenizer;
import java.util.*;
public class CF271B {
public static void main(String[] args) {
FastReader input = new FastReader();
PrintWriter pw = new PrintWriter(System.out);
boolean[] prime = new boolean[1000000+1];
Arrays.fill(prime,true);
prime[0] = false;
prime[1] = false;
for(int i = 2;i * i <= 1000000;i++){
if(prime[i]){
for(int j = i * i;j <= 1000000; j+=i){
prime[j] = false;
}
}
}
ArrayList<Integer> primes = new ArrayList<>();
for(int i = 0;i < prime.length;i++){
if(prime[i])
primes.add(i);
}
int n = input.nextInt();
int m = input.nextInt();
int[][] matrix = new int[n+1][m+1];
for(int i = 1;i <= n;i++){
for(int j = 1;j <= m;j++){
matrix[i][j] = input.nextInt();
}
}
int rowMin = Integer.MAX_VALUE;
for(int i = 1;i <= n;i++){
int sum = 0;
for(int j = 1;j <= m;j++){
int val = matrix[i][j];
if(prime[val]){
}
else{
int up = -1;
int low = 0;
int high = primes.size()-1;
int ans1 = -1;
while (low <= high){
int mid = (low + high) / 2;
if(primes.get(mid) >= val){
ans1 = primes.get(mid);
high = mid - 1;
}
else{
low = mid + 1;
}
}
up = ans1 - val;
sum += up;
}
}
rowMin = Math.min(rowMin,sum);
}
// pw.println(rowMin);
int colMin = Integer.MAX_VALUE;
for(int col = 1;col <= m;col++){
int sum = 0;
for(int row = 1;row <= n;row++){
int val = matrix[row][col];
if(prime[val]){
}
else{
int up = -1;
int low = 0;
int high = primes.size()-1;
int ans1 = -1;
while (low <= high){
int mid = (low + high) / 2;
if(primes.get(mid) >= val){
ans1 = primes.get(mid);
high = mid - 1;
}
else{
low = mid + 1;
}
}
up = ans1 - val;
sum += up;
}
}
colMin = Math.min(colMin,sum);
}
// pw.println(rowMin + " " + colMin);
pw.println(Math.min(rowMin,colMin));
// ****If sorting is required, use ArrayList
pw.flush();
pw.close();
}
static void sort(int[] arr){
ArrayList<Integer> list = new ArrayList<Integer>();
for(int i : arr)
list.add(i);
Collections.sort(list);
for(int i = 0;i < list.size();i++){
arr[i] = list.get(i);
}
return;
}
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 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 org.omg.CORBA.MARSHAL;
import java.io.*;
//import java.lang.reflect.Array;
import java.lang.reflect.Array;
import java.util.*;
//import java.util.logging.LoggingMXBean;
public class citylights {
public static int[] arr;
public static ArrayList<Integer> p;
public static int[] val;
public static long[] facto;
public static long mod = 1000000007;
public static long[] fillme;
// public static HashMap<pair, Integer> hs;
public static int ans = 0;
public static int n, k;
// public static int []tt;
//--------------------------------------My Code--------------------------------------------
public static void main(String[] args) throws IOException {
arr = new int[1000001];
p = new ArrayList<>();
val = new int[1000001];
facto = new long[1000007];
//tt=new int[100];
fillme = new long[1000007];
sieve();
InputReader in = new InputReader(System.in);
PrintWriter out = new PrintWriter(System.out);
int n=in.nextInt();
int m=in.nextInt();
int [][]a=new int[n][m];
for (int i=0;i<n;i++) {
for (int j = 0; j < m; j++) {
int k=in.nextInt();
int ind=Collections.binarySearch(p,k);
// out.println(ind);
if(ind<0)
{
a[i][j]=p.get(-ind-1)-k;
}else
{
a[i][j]=0;
}
}
}
/*for (int i=0;i<n;i++)
{
for (int j=0;j<m;j++)
{
out.print(a[i][j]+" ");
}
out.println();
}
*/
int min = Integer.MAX_VALUE;
for(int i = 0;i < n;i++){
int sum = 0;
for(int j = 0;j < m;j++){
sum += a[i][j];
}
min = Math.min(min, sum);
}
for(int i = 0;i < m;i++){
int sum = 0;
for(int j = 0;j < n;j++){
sum += a[j][i];
}
min = Math.min(min, sum);
}
out.println(min);
out.close();
}
//-------------------------------------------Code ends-------------------------------
public static long bsearchg(int[] a, int t) {
long ans = 0;
int low = 0;
int high = a.length - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (a[mid] <= t) {
ans = mid;
low = mid + 1;
} else
high = mid - 1;
}
return ans;
}
private static long fib(long n) {
if (n == 1) return 2l;
if (n == 0) return 1l;
long[][] F = new long[][]{{1, 1}, {1, 0}};
matPow(F, n);
return F[0][0];
//return 0l;
}
private static void matPow(long[][] F, long n) {
if (n == 0 || n == 1)
return;
long M[][] = new long[][]{{1, 1}, {1, 0}};
matPow(F, n / 2);
matrixMult(F, F);
if (n % 2 != 0)
matrixMult(F, M);
}
private static void matrixMult(long A[][], long M[][]) {
long a = ((A[0][0] * M[0][0]) % mod + (A[0][1] * M[1][0]) % mod) % mod;
long b = ((A[0][0] * M[0][1]) % mod + (A[0][1] * M[1][1]) % mod) % mod;
long c = ((A[1][0] * M[0][0]) % mod + (A[1][1] * M[1][0]) % mod) % mod;
long d = ((A[1][0] * M[0][1]) % mod + (A[1][1] * M[1][1]) % mod) % mod;
A[0][0] = a;
A[0][1] = b;
A[1][0] = c;
A[1][1] = d;
}
private static long lcm(long a, long b) {
return (long) ((a * b) / euclgcd(a, b));
}
public static int[] rotate(int[] order, int by) {
int length = order.length;
int[] a = new int[length];
for (int i = 0; i < length; i++) {
a[(i + by) % length] = order[i];
}
return a;
}
public static long modinv(long x, long m) {
return powmod(x, m - 2, m);
}
public static long eulertoitent(long n) {
long res = n;
for (int i = 2; i * i <= n; i++)
if (n % i == 0) {
while (n % i == 0)
n /= i;
res -= res / i;
}
if (n > 1)
res -= res / n;
return res;
}
//calculate factorial till modulas
public static void fact() {
facto[0] = 1;
for (int i = 1; i <= mod; i++) {
facto[i] = (i * facto[i - 1]) % mod;
}
}
public static void sieve() {
arr[0] = 1;
arr[1] = 1;
for (int i = 2; i * i < 1000001; i++) {
if (arr[i] == 0) {
for (int j = i * i; j < 1000001; j += i) {
arr[j] = 1;
}
}
}
for (int i = 2; i < 1000001; i++) {
if (arr[i] == 0)
p.add(i);
}
}
public static boolean isPrime(int n) {
// Corner cases
if (n <= 1) return false;
if (n <= 3) return true;
// This is checked so that we can skip
// middle five numbers in below loop
if (n % 2 == 0 || n % 3 == 0) return false;
for (int i = 5; i * i <= n; i = i + 6)
if (n % i == 0 || n % (i + 2) == 0)
return false;
return true;
}
public static long euclgcd(long a, long b) {
if (b == 0)
return a;
else
return euclgcd(b, a % b);
}
public static long powmod(long x, long n, long m) {
long result = 1L;
while (n > 0) {
if (n % 2 == 1)
result = (result * x) % m;
x = (x * x) % m;
n = n / 2;
}
return result;
}
static class InputReader {
private InputStream stream;
private byte[] buf = new byte[8192];
private int curChar, snumChars;
private InputReader.SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int snext() {
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 = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
int res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} while (!isSpaceChar(c));
return res * sgn;
}
public long nextLong() {
int c = snext();
while (isSpaceChar(c))
c = snext();
int sgn = 1;
if (c == '-') {
sgn = -1;
c = snext();
}
long res = 0;
do {
if (c < '0' || c > '9')
throw new InputMismatchException();
res *= 10;
res += c - '0';
c = snext();
} 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 String readString() {
int c = snext();
while (isSpaceChar(c))
c = snext();
StringBuilder res = new StringBuilder();
do {
res.appendCodePoint(c);
c = snext();
} while (!isSpaceChar(c));
return res.toString();
}
public boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
long long int sieve[1000000], large[1000000];
int main() {
long long int n, m, max = 0, i, j, cou = 0;
cin >> n;
cin >> m;
vector<vector<long long int> > v(n, vector<long long int>(m));
for (i = 0; i < n; i = i + 1) {
for (j = 0; j < m; j = j + 1) {
cin >> v[i][j];
if (max > v[i][j]) max = v[i][j];
}
}
for (i = 1; i < 1000000; i = i + 1) sieve[i] = 0;
i = 2;
large[1] = 1;
long long int last = 1, found = 0;
while (i < 1000000 && found == 0) {
if (sieve[i] == 0) {
for (j = i * i; j < 1000000; j = j + i) sieve[j] = i;
for (j = last; j <= i; j = j + 1) {
large[j] = i;
if (j == max) found = 1;
}
last = i + 1;
}
i++;
}
long long int mi = -1;
for (i = 0; i < n; i = i + 1) {
cou = 0;
for (j = 0; j < m; j = j + 1) {
cou = cou + large[v[i][j]] - v[i][j];
}
if (mi == -1)
mi = cou;
else if (cou < mi)
mi = cou;
}
for (i = 0; i < m; i = i + 1) {
cou = 0;
for (j = 0; j < n; j = j + 1) {
cou = cou + large[v[j][i]] - v[j][i];
}
if (cou < mi) mi = cou;
}
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 N = 1e5 + 100;
bool primes[N];
int rows[505];
int cols[505];
int main() {
memset(primes, true, N);
memset(rows, 0, 505);
memset(cols, 0, 505);
primes[0] = primes[1] = false;
for (int i = 2; i * i < N; i++)
if (primes[i])
for (int j = i * 2; j <= N; j += i) primes[j] = false;
int r, c;
cin >> r >> c;
for (int i = 0; i < r; i++)
for (int j = 0; j < c; j++) {
int x;
scanf("%d", &x);
while (!primes[x++]) {
rows[i]++;
cols[j]++;
}
}
cout << min(*min_element(rows, rows + r), *min_element(cols, cols + c))
<< 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;
void sieve();
int binser(int, int, int);
vector<int> prime;
int main() {
sieve();
int n, m;
cin >> n >> m;
int num[n][m];
int co = 0, re = 1e9;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> num[i][j];
int x = binser(num[i][j], 0, prime.size());
co = co + prime[x] - num[i][j];
}
re = min(re, co);
co = 0;
}
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
int x = binser(num[j][i], 0, prime.size());
co = co + prime[x] - num[j][i];
}
re = min(re, co);
co = 0;
}
cout << re;
return 0;
}
int binser(int n, int low, int high) {
if (n < 2) return 0;
if (high < low) return -1;
int mid = low + (high - low) / 2;
if (prime[mid] <= n && prime[mid + 1] > n) {
if (prime[mid] == n)
return mid;
else
return mid + 1;
} else if (prime[mid] > n)
return binser(n, low, mid - 1);
return binser(n, mid + 1, high);
}
void sieve() {
bool mark[100004];
prime.push_back(2);
int n = 100004;
memset(mark, true, sizeof(mark));
int i;
for (i = 3; i * i < n; i += 2) {
if (mark[i] == true) {
prime.push_back(i);
for (int j = i * i; j < n; j += 2 * i) mark[j] = false;
}
}
for (; i < n; i += 2)
if (mark[i] == true) prime.push_back(i);
}
| 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 primo(p):
ret = [True] * p
ret[0] = False
ret[1] = False
for i in range(2,p):
if ret[i]:
j = i * i
while True :
if j >= p :
break
ret[j] = False
j += i
return ret
v = 10**5+10
primo = primo(v)
aux = [0,1,0]
for i in range(3,v):
cont = 0
if not(primo[i]) :
x = i + 1
cont += 1
while x < (v) :
if primo[x]:
break
x += 1
cont += 1
aux.append(cont)
n , m = map(int,raw_input().split())
arr = []
mov = []
for i in range(n):
arr.append(map(int,raw_input().split()))
cont = 0
for j in range(m) :
cont += aux[arr[i][j]]
mov.append(cont)
if min(mov) == 0 :
print 0
else :
for i in range(m):
cont = 0
for j in range(n) :
cont += aux[arr[j][i]]
mov.append(cont)
print min(mov) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.math.BigInteger;
import java.util.*;
public class practic {
public static void main(String[] args) throws IOException {
boolean[] isnotprime = new boolean[110001];
isnotprime[0] = true;
isnotprime[1] = true;
int count = 2;
int sqrt = (int)Math.sqrt(110001);
for(int i = 2; i <= sqrt ; ++i ){
if(!isnotprime[i]){
for(int j = i*i ; j <= 110000 ; j+= i){
if(!isnotprime[j]) ++count;
isnotprime[j] = true;
}
}
}
//System.out.println(count);
int[] primeArray = new int[110001 - count];
int k = 0;
for(int i = 0; i < isnotprime.length ; ++i){
if(!isnotprime[i]){
primeArray[k++] = i;
}
}
// TODO code application logic here
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringBuilder sb = new StringBuilder();
String[] s = ti(br);
int n = pi(s[0]);
int m = pi(s[1]);
int[][] ar = new int[n][m];
int min = Integer.MAX_VALUE;
for(int i = 0; i < n ; ++i){
String[] st = ti(br);
int max = 0;
for(int j = 0; j < m ; ++j){
ar[i][j] = pi(st[j]);
int index = Arrays.binarySearch(primeArray, ar[i][j]);
if(index < 0){
max += primeArray[Math.abs(index) - 1] - ar[i][j];
}
}
min = Math.min(max, min);
}
for(int i = 0; i < m ; ++i){
int max = 0;
for(int z = 0; z < n ; ++z){
int index = Arrays.binarySearch(primeArray, ar[z][i]);
if(index < 0){
max += primeArray[Math.abs(index) - 1] - ar[z][i];
}
}
min = Math.min(max, min);
}
System.out.println(min);
}
public static int pi(String s) {
return Integer.parseInt(s);
}
public static String[] ti(BufferedReader b) throws IOException {
return b.readLine().split(" ");
}
} | 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]
'''
for prime in list_primes:
if prime >= num:
return prime
'''
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 | #include <bits/stdc++.h>
using namespace std;
int main() {
long long is[110005];
for (long long i = 2; i < 110005; i++) {
if (is[i] == 0) {
for (long long j = i * i; j < 110005; j += i) {
is[j] = 1;
}
}
}
long long x;
map<long long, long long> p;
is[1] = 1;
for (long long i = 110004; i >= 0; i--) {
if (is[i] == 0) {
x = i;
}
p[i] = x - i;
}
long long n, m;
cin >> n >> m;
long long a[n][m];
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) {
cin >> a[i][j];
}
}
long long mi = 1000000007;
for (long long i = 0; i < n; i++) {
long long leo = 0;
for (long long j = 0; j < m; j++) {
long long x = a[i][j];
leo += p[x];
}
mi = min(mi, leo);
}
for (long long i = 0; i < m; i++) {
long long leo = 0;
for (long long j = 0; j < n; j++) {
long long x = a[j][i];
leo += p[x];
}
mi = min(mi, leo);
}
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;
int pr[200000], pi;
int vis[200000];
void civ() {
int i, j;
pr[pi++] = 2;
vis[1] = vis[0] = 1;
for (i = 4; i < 110000; i += 2) vis[i] = 1;
for (i = 3; i < 110000; i += 2) {
if (!vis[i]) {
pr[pi++] = i;
if (i < 1000) {
for (j = i * i; j < 110000; j += 2 * i) {
vis[j] = 1;
}
}
}
}
int cnt;
for (i = pr[pi - 1]; i >= 0; i--) {
cnt++;
if (!vis[i]) cnt = 0;
vis[i] = cnt;
}
}
int a[600][600];
int main() {
civ();
int n, m, i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf("%d", &a[i][j]);
a[i][j] = vis[a[i][j]];
}
int ans = 900000000;
int sum;
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) {
sum += a[i][j];
}
ans = min(ans, sum);
}
for (i = 0; i < m; i++) {
sum = 0;
for (j = 0; j < n; j++) {
sum += a[j][i];
}
ans = min(ans, sum);
}
printf("%d\n", ans);
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
public class Main {
public static void main(String [] args ) {
try{
int [] prime = new int[100000];
prime[0] = 2;
prime[1] = 3;
int num = 5;
int iter = 2;
while(iter<100000) {
int x = new Double(Math.sqrt(num)).intValue();
int it = 0;
boolean isPrime = true;
while(prime[it] <= x) {
if((num%prime[it]) == 0) {
isPrime = false;
break;
}
it++;
}
if(isPrime) {
prime[iter] = num;
iter++;
}
num+=2;
}
String str;
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
BufferedOutputStream bos = new BufferedOutputStream(System.out);
String eol = System.getProperty("line.separator");
byte [] eolb = eol.getBytes();
byte[] spaceb= " ".getBytes();
str = br.readLine();
int blank = str.indexOf( " ");
int n = Integer.parseInt(str.substring(0,blank));
int m = Integer.parseInt(str.substring(blank+1));
int [] [] array = new int[n][m];
for(int i =0 ; i < n ; i++) {
int j=0;
int s=0;
int k =0;
str = br.readLine();
int length = str.length();
while(j<length) {
while(j<length) {
if(str.charAt(j) == ' ') {
break;
}else {
j++;
}
}
array[i][k] = Integer.parseInt(str.substring(s,j)) ;
k++;
j++;
s=j;
}
}
for(int p = 0 ; p < n ; p++) {
for(int q = 0 ; q < m ; q++) {
int index = Arrays.binarySearch(prime, array[p][q]);
int add = 0;
if(index<0) {
index *= -1;
index--;
add = prime[index] - array[p][q];
}
array[p][q] = add ;
}
}
int [] rowSum = new int[n];
int [] colSum = new int[m];
int min = 10000000;
for(int p = 0 ; p < n ; p++) {
rowSum[p] = 0;
for(int q = 0 ; q < m ; q++) {
rowSum[p] += array[p][q];
}
if(rowSum[p] < min ) {
min = rowSum[p];
}
}
for(int p = 0 ; p < m ; p++) {
colSum[p] = 0;
for(int q = 0 ; q < n ; q++) {
colSum[p] += array[q][p];
}
if(colSum[p] < min ) {
min = colSum[p];
}
}
bos.write(new Integer(min).toString().getBytes());
bos.write(eolb);
bos.flush();
} catch(IOException ioe) {
ioe.printStackTrace();
}
}
}
| 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 double PI = atan(1) * 4;
const int mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int tt = 1;
while (tt--) {
int sieve[100010];
for (int i = int(0); i < int((100010) + 1); ++i) sieve[i] = i;
set<int> st;
for (int i = int(2); i < int((100010) + 1); ++i) {
if (sieve[i] == i) {
for (int j = int(i); j < int((100010) + 1); ++j) {
if (sieve[j] == j) sieve[j] = i;
j += i - 1;
}
}
}
for (int i = int(2); i < int((100010) + 1); ++i)
if (sieve[i] == i) st.insert(i);
int n, m;
cin >> n >> m;
int a[n][m];
for (int i = int(0); i < int(n); ++i) {
for (int j = int(0); j < int(m); ++j) {
cin >> a[i][j];
}
}
long long ans = 1e18;
for (int i = int(0); i < int(n); ++i) {
long long sum = 0;
for (int j = int(0); j < int(m); ++j) {
int k = *st.lower_bound(a[i][j]);
sum += k - a[i][j];
}
ans = min(ans, sum);
}
for (int j = int(0); j < int(m); ++j) {
long long sum = 0;
for (int i = int(0); i < int(n); ++i) {
int k = *st.lower_bound(a[i][j]);
sum += k - a[i][j];
}
ans = min(ans, sum);
}
cout << ans;
}
cerr << "Time elapsed : " << 1.0 * clock() / CLOCKS_PER_SEC << " sec \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 bisect
def b_s(dp,ele):
l=0;r=len(dp)-1;ans=0
while l<=r:
mid=(l+r)//2
if dp[mid]==ele:return mid
elif dp[mid]>ele:ans=mid;r=mid-1
else:l=mid+1
return ans
def sieve(n):
dp=[True]*(n+1);i=2;dp[0]=False;dp[1]=False;dp[2]=True
while i*i<=n:
j=i
for ii in range(j*j,n+1,j):
dp[ii]=False
i+=1
dp1=[2]
for jj in range(3,n+1,2):
if dp[jj]==True:
dp1.append(jj)
return dp1
dp=sieve(2*10**5);arr=[]
n,m=map(int,input().split())
for i in range(n):
a=list(map(int,input().split()))
arr.append(a)
#for rows
uni_ans=10**5
for i in range(n):
ans=0
for j in range(m):
ele=arr[i][j]
idx=b_s(dp,ele);ans+=dp[idx]-ele
uni_ans=min(ans,uni_ans)
#for col
for i in range(m):
ans=0
for j in range(n):
ele=arr[j][i]
idx=b_s(dp,ele);ans+=dp[idx]-ele
uni_ans=min(ans,uni_ans)
print(uni_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, m;
vector<int> primes;
long long const N = 1e5 + 20;
bool v[N];
void sieve() {
v[0] = v[1] = 1;
for (int i = 2; i < N; i++) {
if (!v[i]) {
primes.push_back(i);
for (int j = i * 2; j < N; j += i) {
v[j] = 1;
}
}
}
}
int main() {
sieve();
cin >> n >> m;
long long a[n][m], mi = 1e9;
for (int i = 0; i < n; i++) {
long long counter = 0;
for (int j = 0; j < m; j++) {
cin >> a[i][j];
vector<int>::iterator k =
lower_bound(primes.begin(), primes.end(), a[i][j]);
if (k != primes.end()) {
counter += primes[k - primes.begin()] - a[i][j];
}
}
mi = min(mi, counter);
}
for (int i = 0; i < m; i++) {
long long counter = 0;
for (int j = 0; j < n; j++) {
vector<int>::iterator k =
lower_bound(primes.begin(), primes.end(), a[j][i]);
if (k != primes.end()) {
counter += primes[k - primes.begin()] - a[j][i];
}
}
mi = min(mi, counter);
}
cout << mi;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import math
def prime_filter(n,isPrime):
for i in range(2,int(math.sqrt(n))+1):
if isPrime[i]:
for j in range(i*i,n+1,i):
isPrime[j]=False
return isPrime
def minStep(matrix,nextPrime):
cols = [0 for i in range(len(matrix[0]))]
rows = [0 for i in range(len(matrix))]
for r in range(len(matrix)):
for c in range(len(matrix[r])):
cur = matrix[r][c]
add = nextPrime[cur]-cur
# print("{}:{}".format(nextPrime,cur))
rows[r] += add
cols[c] += add
print(min(min(rows),min(cols)))
if __name__=="__main__":
r,c = [int(i) for i in input().split()]
matrix = []
for i in range(r):
matrix.append([int(i) for i in input().split()])
#######################################
# import random
# matrix = []
# for r in range(500):
# temp = []
# for j in range(500):
# n = random.randint(1,10**5)
# temp.append(n)
# matrix.append(temp)
# print(matrix)
######################################
n=10**5+1000
isPrime = [True for i in range(n+1)]
isPrime = prime_filter(n,isPrime)
isPrime[1] = False
isPrime[0] = False
nextPrime = [0 for i in range(len(isPrime))]
index=0
i=len(isPrime)-1
while(i>=0):
if isPrime[i]:
index = i
nextPrime[i] = index
i-=1
# print(nextPrime)
# print(nextPrime)
# print(len(isPrime))
# print(isPrime[10**5])
# print(isPrime)
minStep(matrix,nextPrime) | 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 | num = 100100
primes = [0]*num
primes[1] = 1
for i in range(2,num):
if primes[i] == 0:
for j in range(2*i,num,i):
primes[j] = 1
cur = 0
index = num - 1
while index > 0:
if primes[index] == 0:
primes[index] = index
cur = index
else:
primes[index] = cur
index -= 1
matrix = []
[n, m] = map(int,raw_input().strip().split(' '))
for i in range(n):
matrix.append(map(int,raw_input().strip().split(' ')))
answer = None
for rownumber in range(n):
tmp = 0
for colnumber in range(m):
tmp += primes[matrix[rownumber][colnumber]] - matrix[rownumber][colnumber]
if answer == None or tmp < answer:
answer = tmp
for colnumber in range(m):
tmp = 0
for rownumber in range(n):
tmp += primes[matrix[rownumber][colnumber]] - matrix[rownumber][colnumber]
if tmp < answer:
answer = tmp
print answer
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.*;
import java.io.*;
public class PrimeMatrix
{
public static void main(String[] args)
{
Scanner in = new Scanner(System.in);
int n = in.nextInt();
int m = in.nextInt();
boolean[] isPrime = new boolean[1000000];
for(int x = 2; x < isPrime.length; x++)
{
isPrime[x] = true;
}
for(int y = 2; y < (int)Math.sqrt(isPrime.length); y++)
{
if(isPrime[y])
{
for(int z = (y * y); z < isPrime.length; z += y)
{
isPrime[z] = false;
}
}
}
ArrayList<Integer> primes = new ArrayList<Integer>();
for(int a = 0; a < isPrime.length; a++)
{
if(isPrime[a])
{
primes.add(a);
}
}
int[][] matrix = new int[n][m];
for(int b = 0; b < n; b++)
{
for(int c = 0; c < m; c++)
{
int num = in.nextInt();
int index = Collections.binarySearch(primes, num);
if(index < 0)
{
index = -(index + 1);
}
matrix[b][c] = primes.get(index) - num;
}
}
int min = Integer.MAX_VALUE;
for(int d = 0; d < n; d++)
{
int current = 0;
for(int e = 0; e < m; e++)
{
current += matrix[d][e];
}
min = Math.min(min, current);
}
for(int f = 0; f < m; f++)
{
int current = 0;
for(int g = 0; g < n; g++)
{
current += matrix[g][f];
}
min = Math.min(min, current);
}
System.out.println(min);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
import java.io.*;
public class Contest1 {
static Scanner sc=new Scanner(System.in);
static PrintWriter out=new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
int n=sc.nextInt();
int m=sc.nextInt();
int cost=0;
int a[][]=new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
a[i][j]=sc.nextInt();
}
}
primes(1000000);
int min=Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
cost=0;
for (int j = 0; j < m; j++) {
cost+=set.ceiling(a[i][j])-a[i][j];
}
min=Math.min(cost, min);
}
for (int i = 0; i < m; i++) {
cost=0;
for (int j = 0; j < n; j++) {
cost+=set.ceiling(a[j][i])-a[j][i];
}
min=Math.min(cost, min);
}
System.out.println(min);
}
static TreeSet<Integer> set=new TreeSet<Integer>();
public static void primes(int n) {
boolean[] primes = new boolean[n + 1];
for (int i = 2; i < primes.length; i++) {
primes[i] = true;
}
int num = 2;
while (true) {
for (int i = 2;; i++) {
int multiple = num * i;
if (multiple > n) {
break;
} else {
primes[multiple] = false;
}
}
boolean nextNumFound = false;
for (int i = num + 1; i < n + 1; i++) {
if (primes[i]) {
num = i;
nextNumFound = true;
break;
}
}
if (!nextNumFound) {
break;
}
}
for (int i = 0; i < primes.length; i++) {
if (primes[i]) {
set.add(i);
}
}
}
}
class Scanner{
StringTokenizer st;
BufferedReader br;
public Scanner(InputStream system){
br=new BufferedReader(new InputStreamReader(system));
}
public Scanner (String file) throws IOException{
br=new BufferedReader(new FileReader(file));
}
public String next() throws IOException{
while (st==null || !st.hasMoreTokens())
st=new StringTokenizer(br.readLine());
return st.nextToken();
}
public String nextLine() throws IOException{
return br.readLine();
}
public int nextInt() throws IOException{
return Integer.parseInt(next());
}
public long nextLong() throws IOException{
return Long.parseLong(next());
}
public Double nextDouble() throws IOException{
return Double.parseDouble(next());
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | 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)
'''
list_primes = [0,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,100019,100043,100049,100057,100069]
# 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]
'''
for prime in list_primes:
if prime >= num:
return prime
'''
sum_list = []
for i in range(m):
sum_list.append([])
for j in xrange(n):
crap = binsearch(matrix_list[i][j],list_primes) - matrix_list[i][j]
sum_list[i].append(crap)
best = sum(sum_list[0])
for list in sum_list[1:]:
best = min(best,sum(list))
for i in xrange(n):
sum_crap = 0
for j in xrange(m):
sum_crap += sum_list[j][i]
best = min(sum_crap,best)
print best
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
public class Main {
static boolean[] bol = new boolean[100010];
static int[] primes = new int[9593];
private static void init() {
for(int i=2;i*i<100010;i++) {
if(!bol[i]) {
for(int j=i+i;j<100010;j+=i) {
bol[j] = true;
}
}
}
int point = 0;
for(int i =2;i<100010;i++) {
if(!bol[i]) {
primes[point] = i;
point++;
}
}
}
private static int solve(int n) {
int place = Arrays.binarySearch(primes, n);
if(place >= 0) {
return 0;
}
place = -place - 1;
return primes[place]-n;
}
public static void main(String[] args) {
init();
FastReader f = new FastReader();
int n = f.nextInt();
int m = f.nextInt();
int[][] arr = new int[n][m];
int[] row = new int[n];
int[] col = new int[m];
for(int i=0;i<n;i++) {
for(int j=0;j<m;j++) {
arr[i][j] = f.nextInt();
int loc = solve(arr[i][j]);
row[i] += loc;
col[j] += loc;
}
}
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);
}
//fast input reader
static class FastReader
{
BufferedReader br;
StringTokenizer st;
public FastReader()
{
br = new BufferedReader(new
InputStreamReader(System.in));
}
String next()
{
while (st == null || !st.hasMoreElements())
{
try
{
st = new StringTokenizer(br.readLine());
}
catch (IOException e)
{
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt()
{
return Integer.parseInt(next());
}
long nextLong()
{
return Long.parseLong(next());
}
double nextDouble()
{
return Double.parseDouble(next());
}
String nextLine()
{
String str = "";
try
{
str = br.readLine();
}
catch (IOException e)
{
e.printStackTrace();
}
return str;
}
}
}
| 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;
using vi = vector<int>;
using pi = pair<int, int>;
using ll = long long int;
template <typename T1, typename T2, typename T3>
T1 modpow(T1 _a, T2 p, T3 mod) {
assert(p >= 0);
ll ret = 1, a = _a;
if (a < 0) {
a %= mod;
a += mod;
}
if (a >= mod) {
a %= mod;
}
for (; p > 0; p /= 2) {
if (p & 1) ret = ret * a % mod;
a = a * a % mod;
}
return ret;
}
constexpr int dx[] = {-1, 0, 1, 0, 1, 1, -1, -1};
constexpr int dy[] = {0, -1, 0, 1, 1, -1, 1, -1};
constexpr auto PI = 3.14159265358979323846L;
constexpr auto oo = numeric_limits<int>::max() / 2 - 2;
constexpr auto eps = 1e-6;
constexpr auto mod = 1000000007;
constexpr int mx_n = 502, mx_a = 101005;
int mat[mx_n][mx_n];
int notprime[mx_a], inc[mx_a];
int n, m;
void pre() {
notprime[0] = notprime[1] = 1;
for (int i = 2; i * i < mx_a; ++i)
if (!notprime[i]) {
for (int j = i * i; j < mx_a; j += i) notprime[j] = 1;
}
for (int i = mx_a - 2; i >= 0; --i) {
if (notprime[i]) inc[i] = 1 + inc[i + 1];
}
for (int i = ((0)), _i = ((15) - 1); i <= _i; ++i)
;
}
int costRow(int i) {
int ret = 0;
for (int j = ((0)), _j = ((m)-1); j <= _j; ++j) ret += mat[i][j];
return ret;
}
int costCol(int j) {
int ret = 0;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) ret += mat[i][j];
return ret;
}
int main() {
pre();
cin >> n >> m;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i)
for (int j = ((0)), _j = ((m)-1); j <= _j; ++j) {
cin >> mat[i][j];
mat[i][j] = inc[mat[i][j]];
;
}
int ans = oo;
for (int i = ((0)), _i = ((n)-1); i <= _i; ++i) ans = min(ans, costRow(i));
for (int j = ((0)), _j = ((m)-1); j <= _j; ++j) ans = min(ans, costCol(j));
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 bisect
import math
def chk_prime(x):
for i in xrange(2,int(math.sqrt(x))+1):
if x % i == 0:
return False
return True
v = []
for x in xrange(2,100007):
if chk_prime(x):
v.append(x)
n,m = map(int,raw_input().split())
g = []
for _ in xrange(0,n):
g.append(map(int,raw_input().split()))
for x in xrange(0,n):
for y in xrange(0,m):
i = bisect.bisect_left(v,g[x][y])
g[x][y] = v[i] - g[x][y]
cols = []
for i in xrange(0,m):
cols.append(sum(row[i] for row in g))
print min(min(cols), min(map(sum,g)))
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import bisect
def primer():
n = 100010
li = [True for i in range(n)]
li[0] = False
li[1] = False
prime = []
for i in range(2, n):
if li[i]:
prime.append(i)
for j in range(2,n):
if i*j >= n:
break
li[i*j] = False
return prime
def main():
res = 987654321987
prime = primer()
n, m = map(int, input().split())
li = []
for i in range(n):
x = list(map(int, input().strip().split()))[:m]
li.append(x)
for i in range(n):
x = 0
for j in range(m):
pos = bisect.bisect_left(prime,li[i][j],0,min(len(prime), li[i][j]+10))
x += prime[pos] - li[i][j]
res = min(res,x)
for j in range(m):
x = 0
for i in range(n):
pos = bisect.bisect_left(prime,li[i][j],0,min(len(prime), li[i][j]+10))
x += prime[pos] - li[i][j]
res = min(res,x)
print(res)
if __name__ == '__main__':
main()
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | from math import sqrt, ceil
n, m = list(map(int, raw_input().split(' ')))
def find_primes():
maxi = 10**5 + 10
primes = [True] * (maxi + 1)
primes[0] = False
primes[1] = False
i = 2
while i * i <= maxi:
if primes[i]:
for j in range(i**2, maxi+1, i):
primes[j] = False
i += 1
return primes
def find_closest_prime(primes, n):
i = n+1
right = 1
while i < len(primes):
if primes[i]:
break
right += 1
i += 1
if i >= len(primes):
right = 1000000
return right
matrix = []
for i in range(n):
row = list(map(int, raw_input().split(' ')))
matrix.append(row)
primes = find_primes()
distance = [-1] * (10**5 + 1)
moves = 1000000
# rows
for i in range(n):
sumita = 0
for num in matrix[i]:
if not primes[num]:
if distance[num] == -1:
distance[num] = find_closest_prime(primes, num)
sumita += distance[num]
moves = min(moves, sumita)
if moves == 0:
break
if moves != 0:
for c in range(m):
sumita = 0
for r in range(n):
v = matrix[r][c]
if not primes[v]:
if distance[v] == -1:
distance[v] = find_closest_prime(primes, v)
sumita += distance[v]
moves = min(moves, sumita)
if moves == 0:
break
print(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 | import java.io.IOException;
import java.util.Arrays;
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
*/
public class Main {
public static void main(String[] args) {
InputStream inputStream = System.in;
OutputStream outputStream = System.out;
InputReader in = new InputReader(inputStream);
PrintWriter out = new PrintWriter(outputStream);
TaskB solver = new TaskB();
solver.solve(1, in, out);
out.close();
}
}
class TaskB {
boolean primes[];
int max=1000000;
public void solve(int testNumber, InputReader in, PrintWriter out) {
primes=new boolean[max+1];
int count=0;
for (int i=2;i<=max;i++){
if(primes[i]) continue;
go(i);
primes[i]=false;
count++;
}
primes[2]=false;
int val[]=new int[count];
for (int i=2,j=0;i<=max;i++) if(!primes[i]) val[j++]=i;
int n=in.readInt();
int m=in.readInt();
int matrix[][]=new int[n][m];
for (int i=0;i<n;i++) for (int j=0;j<m;j++){
matrix[i][j]=in.readInt();
int s= Arrays.binarySearch(val,matrix[i][j]);
if(s>=0) matrix[i][j]=0;
else matrix[i][j]=val[-1*s-1]-matrix[i][j];
}
int ans=Integer.MAX_VALUE;
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 i=0;i<m;i++){
int sum=0;
for (int j=0;j<n;j++) sum+=matrix[j][i];
ans=Math.min(ans,sum);
}
out.println(ans);
}
void go(int pos){
if(primes[pos]) return;
primes[pos]=true;
for (int i=2;pos*i<=max;i++) go(pos*i);
}
}
class InputReader {
private InputStream stream;
private byte[] buf = new byte[1024];
private int curChar;
private int numChars;
private SpaceCharFilter filter;
public InputReader(InputStream stream) {
this.stream = stream;
}
public int read() {
if (numChars == -1)
throw new InputMismatchException();
if (curChar >= numChars) {
curChar = 0;
try {
numChars = stream.read(buf);
} catch (IOException e) {
throw new InputMismatchException();
}
if (numChars <= 0)
return -1;
}
return buf[curChar++];
}
public int 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 boolean isSpaceChar(int c) {
if (filter != null)
return filter.isSpaceChar(c);
return isWhitespace(c);
}
public static boolean isWhitespace(int c) {
return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
}
public interface SpaceCharFilter {
public boolean isSpaceChar(int ch);
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import bisect
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]
[n, m] = map(int, raw_input().split())
r = [0] * n
c = [0] * m
for i in xrange(n):
row = map(int, raw_input().split())
for j in xrange(m):
index = bisect.bisect_left(primes, row[j])
increase = primes[index] - row[j]
r[i] += increase
c[j] += increase
print min(min(r), min(c))
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int pc, notPrime[3130], P[10000], A[502][502], B[502][502];
void sieve(int n) {
int i, j;
(notPrime[1 >> 5] |= (1 << (1 & 31)));
for (j = 2 * 2; j <= n; j += 2) (notPrime[j >> 5] |= (1 << (j & 31)));
for (i = 3; i * i <= n; i += 2)
if ((!(notPrime[i >> 5] & (1 << (i & 31)))))
for (j = i * i; j <= n; j += (i << 1))
(notPrime[j >> 5] |= (1 << (j & 31)));
P[pc++] = 2;
for (i = 3; i <= n; i += 2)
if ((!(notPrime[i >> 5] & (1 << (i & 31))))) P[pc++] = i;
}
long long solve(int n, int m) {
int maxA = 0, i, j;
long long sum, minSum = 1000000000000000000ll;
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
if (maxA < A[i][j]) maxA = A[i][j];
sieve(maxA + 75);
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j)
B[i][j] = *lower_bound(P, P + pc, A[i][j]) - A[i][j];
for (i = 0; i < n; ++i) {
sum = 0;
for (j = 0; j < m; ++j) sum += B[i][j];
if (minSum > sum) minSum = sum;
}
for (j = 0; j < m; ++j) {
sum = 0;
for (i = 0; i < n; ++i) sum += B[i][j];
if (minSum > sum) minSum = sum;
}
return minSum;
}
int main() {
int n, m, i, j;
scanf("%d %d", &n, &m);
for (i = 0; i < n; ++i)
for (j = 0; j < m; ++j) scanf("%d", &A[i][j]);
printf("%I64d\n", solve(n, m));
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | n,m=map(int,raw_input().split())
N=int((10**5)+100)
r,c=[0]*n,[0]*m
a=[0]*2+[1]*N
for i in xrange(2,N):
if (a[i]):
for j in xrange(2,1+(N/i)):a[i*j]=0
for i in reversed(xrange(1,N)):
if (a[i]):a[i]=i
else:a[i]=a[i+1]
for i in xrange(n):
s=map(lambda x:a[x]-x,map(int,raw_input().split()))
r[i]=sum(s)
c=map(lambda x,y:x+y,c,s)
print min(min(r),min(c))
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long N = 200005;
vector<long long> vis(N);
vector<vector<long long>> adj(N);
void dfs(long long v) {
vis[v] = 1;
for (auto i : adj[v]) {
if (!vis[i]) {
dfs(i);
}
}
return;
}
bool isPrime(long long n) {
if (n < 2) return false;
for (long long i = 2; i * i <= n; ++i) {
if (n % i == 0) {
return false;
}
}
return true;
}
long long factorial(long long n) {
return (n == 1 || n == 0) ? 1 : n * factorial(n - 1);
}
long long power(long long x, long long y) {
long long res = 1;
x = x;
while (y > 0) {
if (y & 1) res = (res * x) % mod;
y = y >> 1;
x = (x * x) % mod;
}
return res % mod;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long lcm(long long a, long long b) { return (a / gcd(a, b) * b); }
long long max(long long a, long long b) {
long long ans = a > b ? a : b;
return ans;
}
long long min(long long a, long long b) {
long long ans = a < b ? a : b;
return ans;
}
long long root(long long a[], long long i) {
while (a[i] != i) {
a[i] = a[a[i]];
i = a[i];
}
return i;
}
void unionn(long long a[], long long i, long long j) {
long long root_i = root(a, i);
long long root_j = root(a, j);
a[root_i] = root_j;
return;
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) {
long long n, m;
cin >> n >> m;
long long a[n][m];
vector<long long> v;
map<long long, long long> make_pair;
for (long long i = 2; i < 100005; i++)
if (isPrime(i)) {
v.push_back(i);
make_pair[i]++;
}
for (long long i = 0; i < n; i++) {
for (long long j = 0; j < m; j++) cin >> a[i][j];
}
long long minn = INT_MAX;
for (long long i = 0; i < n; i++) {
long long s = 0;
for (long long j = 0; j < m; j++) {
if (!make_pair[a[i][j]]) {
long long k = upper_bound(v.begin(), v.end(), a[i][j]) - v.begin();
s = s + (v[k] - a[i][j]);
}
}
minn = min(minn, s);
}
for (long long i = 0; i < m; i++) {
long long s = 0;
for (long long j = 0; j < n; j++) {
if (!make_pair[a[j][i]]) {
long long k = upper_bound(v.begin(), v.end(), a[j][i]) - v.begin();
s = s + (v[k] - a[j][i]);
}
}
minn = min(minn, s);
}
cout << minn;
}
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int a[600][600];
int b[600][600];
bool IP[1000000];
int F(int x) {
int tmp = x;
while (true) {
if (IP[x] == true) {
return x - tmp;
}
x++;
}
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 2; i <= 1000000; i++) IP[i] = true;
for (int i = 2; i <= 1000000; i++)
if (IP[i] == true)
for (int j = 2; j * i <= 1000000; j++) IP[j * i] = false;
int n, m;
long long minn = 1000000000;
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) cin >> a[i][j];
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++) b[i][j] = F(a[i][j]);
for (int i = 1; i <= n; i++) {
long long ans = 0;
for (int j = 1; j <= m; j++) ans += b[i][j];
if (minn > ans) minn = ans;
}
for (int j = 1; j <= m; j++) {
long long ans = 0;
for (int i = 1; i <= n; i++) ans += b[i][j];
if (minn > ans) minn = ans;
}
cout << minn;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | primes = [True]*(2*(10**5) + 1)
for i in range(2,int((2*(10**5) + 1)**0.5 + 1)):
if primes[i]:
for j in range(2*i,len(primes),i):
primes[j] = False
primes = [i for i in range(2,len(primes)) if primes[i]]
def bin_search(n):
l = 0
r = len(primes)
while l <= r:
mid = (l+r)//2
if primes[mid] == n:
return n
elif primes[mid] < n:
l = mid+1
else:
r = mid-1
return primes[(l+r)//2 + 1]
n,m = map(int, input().split())
arr = []
for i in range(n):
arr.append(list(map(int, input().split())))
min_cost = float('inf')
#check for rows
for i in range(n):
temp = 0
for j in range(m):
temp += abs(arr[i][j] - bin_search(arr[i][j]))
min_cost = min(min_cost, temp)
#check for cols
for j in range(m):
temp = 0
for i in range(n):
temp += abs(arr[i][j] - bin_search(arr[i][j]))
min_cost = min(min_cost, temp)
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 sys
inp = [[int(j) for j in i.split(' ')] for i in sys.stdin.read().strip().splitlines()[1:]]
def check(m):
return min([sum([rest[i] for i in s]) for s in m])
sieve = [None]*100005
sieve[0] = False
sieve[1] = False
for i in xrange(2, 100005):
if sieve[i] == None:
sieve[i] = True
for j in xrange(2*i, 100005, i):
sieve[j] = False
rest = [0] * 100005
cnt = 0
for i in xrange(100004, -1, -1):
if sieve[i]:
cnt = 0
else:
cnt += 1
rest[i] = cnt
res = min(check(inp), check(zip(*inp)))
sys.stdout.write(str(res)) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class C5 {
private static boolean[] calculosPrimos(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 int binarySearch(int valor, int[] datos) {
int index = 0;
int low = 0;
int high = datos.length-1;
while (low <= high) {
index = (high + low)/2;
if(valor==datos[index]) {
return index;
}else if(valor>datos[index] && valor<datos[index+1]) {
index++;
return index;
}else if(valor>datos[index]) {
low = index +1;
}else {
high = index-1;
}
}
return -1;
}
public static void main(String[] args) {
//9593
//10001
Scanner sc = new Scanner(System.in);
int[][] matriz = new int[sc.nextInt()][sc.nextInt()];
for(int i=0;i<matriz.length;i++) {
for(int j=0;j<matriz[0].length;j++) {
matriz[i][j] = sc.nextInt();
}
}
boolean[] primosTotal = calculosPrimos(100000);
int[] primos = new int[9594];
int index = 1;
primos[0] = 0;
for(int i=0;i<primosTotal.length;i++) {
if(primosTotal[i]) {
primos[index] = i;
index++;
}
}
primos[primos.length-1]=100003;
index = 0;
int minimo= 0;
int cont = 0;
for(int i=0;i<matriz.length;i++) {
for(int j=0;j<matriz[0].length;j++) {
cont+=primos[binarySearch(matriz[i][j], primos)]- matriz[i][j];
}
if(i==0) {
minimo = cont;
}else {
minimo = Math.min(minimo, cont);
}
cont= 0;
}
cont = 0;
for(int i=0;i<matriz[0].length;i++) {
for(int j=0;j<matriz.length;j++) {
cont+=primos[binarySearch(matriz[j][i], primos)]- matriz[j][i];
}
minimo = Math.min(minimo, cont);
cont = 0;
}
System.out.println(minimo);
}
}
| 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 M1 = 100030;
const int M2 = 316;
bool pri[M1];
void se() {
int i, j, k;
pri[1] = 1;
for (k = 1, i = 2; i <= M2; i += k, k = 2)
if (!pri[i]) {
for (j = 2 * i; j < M1; j += i) pri[j] = 1;
}
}
int pr(int n) {
int i, j = 0;
for (i = n;; i++)
if (!pri[i])
return j;
else
j++;
}
int main() {
se();
int i, j, k = 100000, n, m, l, p;
cin >> n >> m;
int a[n][m];
for (i = 0; i < n; i++) {
for (p = 0, j = 0; j < m; j++) {
cin >> l;
a[i][j] = pr(l);
p += a[i][j];
}
k = min(k, p);
}
if (k == 0) {
cout << "0\n";
} else {
for (i = 0; i < m; i++) {
for (l = 0, j = 0; j < n; j++) l += a[j][i];
k = min(k, l);
}
cout << k << "\n";
}
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
int abs(int a) {
if (a < 0) return -1 * a;
return a;
}
int big(int a, int b) {
if (a > b) return a;
return b;
}
int small(int a, int b) {
if (a < b) return a;
return b;
}
int compare(const void *a, const void *b) {
int *p1 = (int *)a;
int *p2 = (int *)b;
return *p1 - *p2;
}
int a[100100] = {};
void sieve() {
int sum, min, i, j, k;
a[0] = a[1] = 1;
for (i = 2; i < 320; i++) {
if (a[i] == 0) {
for (j = i * i; j < 100100; j += i) a[j] = 1;
}
}
}
int b[500][500];
int r[500] = {}, c[500] = {};
int main() {
sieve();
int sum, min, n, m, i, j, k, x, y, t;
scanf("%d", &n);
scanf("%d", &m);
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) {
scanf("%d", &x);
k = x;
while (a[k]) k++;
b[i][j] = k - x;
}
for (i = 0; i < n; i++) {
sum = 0;
for (j = 0; j < m; j++) sum += b[i][j];
r[i] = sum;
}
for (i = 0; i < m; i++) {
sum = 0;
for (j = 0; j < n; j++) sum += b[j][i];
c[i] = sum;
}
min = 1000000000;
for (i = 0; i < n; i++) {
if (r[i] < min) min = r[i];
}
for (i = 0; i < m; i++) {
if (c[i] < min) min = c[i];
}
printf("%d", min);
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
template <typename T>
T sgn(T x) {
return x < 0 ? -1 : x != 0;
}
template <typename T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
void reads(string& x) {
char kk[((long long)5e2 + 123)];
scanf("%s", kk);
x = kk;
}
long long n, m, ans;
long long v, r[((long long)5e2 + 123)], c[((long long)5e2 + 123)];
long long lp[(long long)1e6 + 1];
vector<long long> pr;
void sieve() {
for (long long i = 2; i <= 1e6; ++i) {
if (lp[i] == 0) {
lp[i] = i;
pr.push_back(i);
}
for (long long j = 0;
j < (long long)pr.size() && pr[j] <= lp[i] && i * pr[j] <= 1e6; ++j)
lp[i * pr[j]] = pr[j];
}
}
void solve() {
sieve();
scanf("%lld %lld", &n, &m);
for (long long i = 0; i < n; i++)
for (long long j = 0; j < m; j++) {
scanf(" %lld", &v);
v = (*lower_bound(pr.begin(), pr.end(), v) - v);
r[i] += v;
c[j] += v;
}
ans = 1e9;
for (long long i = 0; i < n; i++) ans = min(ans, r[i]);
for (long long i = 0; i < m; i++) ans = min(ans, c[i]);
printf("%lld\n", ans);
}
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long t = 1;
while (t--) solve();
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 |
import java.util.*;
/**
* Created by shereifhawary on 1/9/16.
*/
public class PrimeMatrix {
private static List<Integer> primes;
public static void main(String... args) {
primes = new ArrayList<Integer>();
buildPrimes(primes);
Scanner scanner = new Scanner(System.in);
int n = scanner.nextInt(), m = scanner.nextInt();
int[][] matrix = new int[n][m];
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
matrix[i][j] = scanner.nextInt();
}
}
int countj = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int count = 0;
for (int j = 0; j < m; j++) {
count += primeDiff(matrix[i][j]);
}
countj = Math.min(countj, count);
}
if (countj == 0) {
System.out.println(0);
} else {
int counti = Integer.MAX_VALUE;
for (int j = 0; j < m; j++) {
int count = 0;
for (int i = 0; i < n; i++) {
count += primeDiff(matrix[i][j]);
}
counti = Math.min(counti, count);
}
System.out.println(Math.min(counti, countj));
}
}
private static void buildPrimes(List<Integer> primes) {
for (int i = 2; i < 100100; i++) {
if (isPrime(i)) {
primes.add(i);
}
}
}
private static boolean isPrime(int num) {
if (num == 2 || num == 3) {
return true;
}
if (num % 2 == 0 || num % 3 == 0) {
return false;
}
for (int i = 5; i * i <= num; i += 6) {
if (num % i == 0 || num % (i + 2) == 0) {
return false;
}
}
return true;
}
private static boolean localIsPrime(int num) {
return Collections.binarySearch(primes, num) >= 0;
}
private static int primeDiff(int num) {
int location = Collections.binarySearch(primes, num);
if (location >= 0) {
return 0;
} else {
return primes.get((-1 * (location)) - 1) - num;
}
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | n, m = tuple(map(int, input().split()))
pro = [list(map(int, input().split())) for _ in range(n)]
r = [0] * (10**5+4)
r[1] = 1
for i in range(2, 10**5+4):
if r[i] == 0:
j = 2
while (i * j < 10**5+4):
r[i * j] = 1
j += 1
r[-1] = len(r) - 1
for i in range(10**5+2, 0, -1):
if r[i] == 1:
r[i] = r[i + 1]
else:
r[i] = i
ren = [0] * n
col = [0] * m
for i in range(n):
for j in range(m):
ren[i] += r[pro[i][j]] - pro[i][j]
col[j] += r[pro[i][j]] - pro[i][j]
print( min(ren + col) )
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys,math,bisect
inf = float('inf')
mod = (inf)+7
def lcm(a,b):
return int((a/math.gcd(a,b))*b)
def gcd(a,b):
return int(math.gcd(a,b))
def binarySearch(a,x):
i = bisect.bisect_left(a,x)
if i!=len(a) and a[i]==x:
return i
else:
return -1
def lowerBound(a, x):
i = bisect.bisect_left(a, x)
if i:
return (i-1)
else:
return -1
def upperBound(a,x):
i = bisect.bisect_right(a,x)
if i!= len(a)+1 and a[i-1]==x:
return (i-1)
else:
return -1
def freq(a,x):
z = upperBound(a,x) - lowerBound(a,x)
if z<=0:
return 0
return z
"""
n = int(input())
n,k = map(int,input().split())
arr = list(map(int,input().split()))
"""
def bs(arr,x):
l = 0
r = len(arr)-1
ans = 10**9
while l<=r:
mid=(l+r)//2
if arr[mid]>=x:
ans = min(ans,arr[mid])
r = mid-1
else:
l=mid+1
return ans
def SieveOfEratosthenes(n):
ans = []
prime = [True for i in range(n+1)]
p = 2
while (p * p <= n):
if (prime[p] == True):
for i in range(p * p, n+1, p):
prime[i] = False
p += 1
for p in range(2, n+1):
if prime[p]:
ans.append(p)
return ans
arr=SieveOfEratosthenes((10**5)+100)
for _ in range(1):
n,m=map(int,input().split())
matt=[]
for i in range(n):
matt.append(list(map(int,input().split())))
ans = [[-1 for i in range(m)] for j in range(n)]
for i in range(n):
for j in range(m):
ans[i][j] = bs(arr,matt[i][j]) - matt[i][j]
res = 10**9
for i in range(n):
res = min(sum(ans[i]),res)
for i in range(m):
curr = 0
for j in range(n):
curr+=ans[j][i]
res=min(curr,res)
print(res)
| PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import sys
import math
limit = 100025
primeNumberList = [True for i in range(limit + 1)] #Coloca true em todo mundo
distanceToNextPrimeNumber = [0 for i in range(200000)]
def sieve():
primeNumberList[0] = primeNumberList[1] = False #0 e 1 não sao primos, logo, coloca false
for i in range(2, int(math.sqrt(limit))):
if primeNumberList[i]:
j = 2
while i * j <= limit:
primeNumberList[i*j] = False #Se for multiplo de outro numero, nao é primo, logo, coloca false
j += 1
def getNextPrimeNumber():
for i in range(limit - 1, -1, -1):
if primeNumberList[i]: #Se o numero for primo
distanceToNextPrimeNumber[i] = 0 # A distancia até o proximo numero primo é 0
else: #Se o numero não for primo
distanceToNextPrimeNumber[i] = 1 + distanceToNextPrimeNumber[i+1] # A distancia até o proximo numero primo é 1 + distancia do proximo numero
sieve()
getNextPrimeNumber()
dados = input().split(' ')
n, m = (int(dados[0]), int(dados[1]))
matrix = []
for i in range(0, n):
value = input()
matrix.append(value.split(' '))
rows = [0]*n
columns = [0]*m
for i in range(n):
for j in range(m):
num = int(matrix[i][j])
distance = distanceToNextPrimeNumber[num] #Pega a distancia até o proximo número primo
rows[i] += distance #Soma o total das distancias até um numero primo nessa linha
columns[j] += distance #Soma o total das distancias até um numero primo nessa coluna
rows_min = min(rows) #Pega o menor valor (a menor distancia) do array de linhas
column_min = min(columns) #Pega o menor valor (a menor distancia) do array de colunas
print(min(rows_min, column_min)) #Pega o menor valor entre os dois valores anteriores
| 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 | R = 10 ** 5 + 300
is_prime = [0] * (R + 1)
is_prime[1] = 1
d = 2
while d * d <= R:
if not is_prime[d]:
for i in range(d ** 2, R + 1, d):
is_prime[i] = 1
d += 1
for i in range(R + 1):
if is_prime[i]:
k = i
step = 0
while k <= R and is_prime[k]:
k += 1
step += 1
is_prime[i] = step
n, m = map(int, input().split())
a = []
for i in range(n):
a.append(list(map(int,input().split())))
min_step = 10**5
for j in range(n):
step = 0
i = 0
for i in range(m):
step += is_prime[a[j][i]]
if step > min_step:
break
else:
if step < min_step:
min_step = step
for j in range(m):
step = 0
i = 0
for i in range(n):
step += is_prime[a[i][j]]
if step > min_step:
break
else:
if step < min_step:
min_step = step
print(min_step) | 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.Arrays;
public class primeMatrix {
static boolean []primes=new boolean[1000000];
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String s[]=br.readLine().split(" ");
int n=Integer.parseInt(s[0]);
int m=Integer.parseInt(s[1]);
int [][]arr=new int[n][m];
int ans=Integer.MAX_VALUE;
seive();
for(int i=0;i<n;i++){
String a[]=br.readLine().split(" ");
int count=0;
for(int j=0;j<m;j++){
arr[i][j]=Integer.parseInt(a[j]);
count+=nearestPrime(arr[i][j]);
}
ans=Math.min(ans, count);
}
for(int j=0;j<m;j++){
int count=0;
for(int i=0;i<n;i++){
count+=nearestPrime(arr[i][j]);
}
ans=Math.min(ans, count);
}
System.out.println(ans);
}
public static int nearestPrime(int n){
int itr=0;
while(!primes[n]){
n++;
itr++;
}
return itr;
}
public static void seive(){
Arrays.fill(primes, true);
primes[0]=false;
primes[1]=false;
for(int i=2;i*i<1000000;i++){
if(primes[i]){
for(int j=i*i;j<1000000;j+=i){
primes[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 | from Queue import * # Queue, LifoQueue, PriorityQueue
from bisect import * #bisect, insort
from datetime import *
from collections import * #deque, Counter,OrderedDict,defaultdict
import calendar
import heapq
import math
import copy
import itertools
myread = lambda : map(int,raw_input().split())
def solver():
n,m = myread()
matrix = [myread() for i in range(n)]
mymax = 100000 + 100
prime = []
is_prime = [True] * mymax
is_prime[0] = False
is_prime[1] = False
for i in range(2,mymax):
if is_prime[i]:
prime.append(i)
j = 2 * i
while j < mymax:
is_prime[j] = False
j += i
diff_matrix = [[0] * m for i in range(n)]
for i in range(n):
for j in range(m):
index = bisect_left(prime,matrix[i][j])
diff_matrix[i][j] = prime[index] - matrix[i][j]
#print diff_matrix
ans = sum(diff_matrix[0])
for i in range(n):
ans = min(sum(diff_matrix[i]),ans)
for j in range(m):
sum_gyou = 0
for i in range(n):
sum_gyou += diff_matrix[i][j]
ans = min(sum_gyou,ans)
print ans
if __name__ == "__main__":
solver()
| PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
bool isPrime(int n) {
int i;
if (n == 1 || n == 0) return false;
for (i = 2; i * i <= n; i++) {
if (n % i == 0) return false;
}
return true;
}
int main() {
int i = 0, j = 0, k = 0, l = 0, temp;
int primes[100004];
for (i = 100003; i >= 0; i--) {
if (isPrime(i))
primes[i] = i;
else
primes[i] = primes[i + 1];
}
int n, m;
cin >> n >> m;
int ara[n][m];
int row[n];
int col[m];
for (i = 0; i < n; i++) row[i] = 0;
for (i = 0; i < m; i++) col[i] = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
cin >> temp;
ara[i][j] = primes[temp] - temp;
row[k] = row[k] + ara[i][j];
}
k++;
}
for (i = 0; i < m; i++) {
for (j = 0; j < n; j++) {
col[l] = col[l] + ara[j][i];
}
l++;
}
int ans = row[0];
for (i = 1; i < n; i++) {
if (row[i] < ans) ans = row[i];
}
for (i = 0; i < m; i++) {
if (col[i] < ans) ans = col[i];
}
cout << ans;
return 0;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.*;
import java.util.*;
import java.math.*;
public class Main{
static BufferedReader bf;
static PrintWriter out;
static FastScanner in;
static final int MAXN = (int)1e6 + 100;
static final int INF = Integer.MAX_VALUE;
static boolean used [] = new boolean[MAXN];
static int a[][] = new int[555][555];
static int d[][] = new int[555][555];
static Vector < Integer > v = new Vector<Integer>();
static void precalc(){
int max = (int)1e6;
for (int i=2;(long)i*i<=max;i++){
if ( !used[i] ){
int k = i+i;
while ( k <= max){
used[k] = true;
k += i;
}
}
}
for (int i=2;i<=max;i++){
if ( !used[i])v.add(i);
}
}
static int check(int x){
int r = (int)1e4;
int l = 0;
while ( l <= r){
int mid = (l+r)/2;
int t = v.elementAt(mid);
if ( t >= x ){
r = mid - 1;
}
else
l = mid + 1;
}
return v.elementAt(r+1)-x;
}
static void show(){
for (int i=0;i<v.size();i++){
int t = v.elementAt(i);
if ( t >= (int)1e5){
System.out.println(i);
System.exit(0);
}
//out.print(t+" ");
}
}
public static void main(String[] args) throws Exception {
bf = new BufferedReader(new InputStreamReader(System.in));
out = new PrintWriter(System.out);
in = new FastScanner(bf);
precalc();
//show();
int n = in.nextInt();
int m = in.nextInt();
for (int i=1;i<=n;i++){
for (int j=1;j<=m;j++){
a[i][j] = in.nextInt();
d[i][j] = check(a[i][j]);
}
}
int ans = INF;
for (int i=1;i<=n;i++){
int maxi = 0;
for (int j=1;j<=m;j++){
maxi += d[i][j];
}
ans = Math.min(maxi,ans);
}
for (int i=1;i<=m;i++){
int maxi = 0;
for (int j=1;j<=n;j++){
maxi += d[j][i];
}
ans = Math.min(maxi,ans);
}
out.println(ans);
out.close();
}
}
class FastScanner {
BufferedReader reader;
StringTokenizer strTok;
public FastScanner(BufferedReader reader) {
this.reader = reader;
}
public String nextToken() throws IOException {
while (strTok == null || !strTok.hasMoreTokens()) {
strTok = new StringTokenizer(reader.readLine());
}
return strTok.nextToken();
}
public String next()throws IOException{
return nextToken();
}
public int nextInt() throws IOException {
return Integer.parseInt(nextToken());
}
public long nextLong() throws IOException {
return Long.parseLong(nextToken());
}
public double nextDouble() throws IOException {
return Double.parseDouble(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 | from sys import stdin,stdout
input=stdin.readline
import math,bisect
num = 102001
numD = 2
prime=[1]*num
prime[1]=0
prime[0]=0
for i in range(numD,num):
j=i
while(j+i<num):
j+=i
prime[j]=0
l=[]
n,m=map(int,input().split())
for i in range(n):
t=list(map(int,input().split()))
l.append(t)
ans=60000000
for i in range(n):
tot=0
for j in range(m):
result=l[i][j]
for k in range(result,num):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
for j in range(m):
tot=0
for i in range(n):
result=l[i][j]
for k in range(result,num):
if prime[k]==1:
tot+=k-result
break
ans=min(ans,tot)
print(ans)
| 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 primes(l):
z=[1]*l
z[:2]=[0,0]
for (i,p) in enumerate(z[2:],2):
if p:
z[i*i::i]=[0]*((l-i*i)/i+(l%i!=0))
return z
p=primes(10**5+100)
e=[0]*len(p)
j=len(p)
for i in range(len(p) - 1, 0, -1):
if p[i]:
j = i
e[i] = j - i
r=lambda:map(int, raw_input().split())
n,m=r()
M=[r() for i in [0]*n]
N=[[0]*m for i in range(n)]
for i in range(n):
for j in range(m):
N[i][j]=e[M[i][j]]
print min([sum(i) for i in N]+[sum(N[i][j] for i in range(n)) for j in range(m)]) | PYTHON |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int x = input.nextInt();
int y = input.nextInt();
int[][] a = new int[x][y];
int minc =10000000;
for(int i =0;i<x;i++){
for(int j=0;j<y;j++ ){
a[i][j]=input.nextInt();
}
}
int [][] c =new int[x][y];
for (int i = 0; i <x; i++) {
for (int j = 0; j < y; j++) {
c[i][j]=a[i][j];
}
}
boolean [] b = new boolean[1000000];
b[0]=true;
b[1]= true;
int m = (int)Math.sqrt(1000000);
for (int i=2; i<=m; i++)
if (b[i]==false)
for (int k=i*i; k<1000000; k+=i)
b[k]=true;
int min1 = (int)1e9;
int min2 = (int)1e9;
for(int i =0;i<x;i++){
int min3=0;
for(int j=0;j<y;j++){
if(b[a[i][j]]){
while(b[a[i][j]]==true){
min3++;
a[i][j]++;
}
}
}
if(min3<min1){min1=min3;}
}
for(int i =0;i<y;i++){
int min3=0;
for(int j=0;j<x;j++){
if(b[c[j][i]]){
while(b[c[j][i]]==true){
min3++;
c[j][i]++;
}
}
}
if(min3<min2){min2=min3;}
}
System.out.println((int)Math.min(min1, min2));
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;
public class primematrix {
static TreeSet<Integer> primes;
static int[] isComposite;
static void sieve(int N)
{
isComposite = new int[N+1];
isComposite[0] = isComposite[1] = 1;
primes = new TreeSet<Integer>();
for (int i = 2; i <= N; ++i)
if (isComposite[i] == 0)
{
primes.add(i);
if(1l * i * i <= N)
for (int j = i * i; j <= N; j += i)
isComposite[j] = 1;
}
}
static boolean isPrime(int N)
{
if(N < isComposite.length)
return isComposite[N] == 0;
for(int p: primes)
if(N%p==0)
return false;
return true;
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int r = Integer.parseInt(st.nextToken());int c = Integer.parseInt(st.nextToken());
int [] row = new int [r];
int [] col = new int [c];
sieve(1000001);
for(int i = 0 ; i < r ; i++){
st = new StringTokenizer(br.readLine());
for(int j = 0 ; j < c ; j++){
int n = Integer.parseInt(st.nextToken());
if(!isPrime(n)){
row[i]+=primes.ceiling(n)-n;
col[j]+=primes.ceiling(n)-n;
}
}
}
int min =Integer.MAX_VALUE;
for(int i = 0 ; i < r ; i++){
min = Math.min(min, row[i]);
}
for(int i = 0 ; i < c ; 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 | /*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.text.*;
public class cf271b {
static BufferedReader br;
static Scanner sc;
static PrintWriter out;
public static void initA() {
try {
br = new BufferedReader(new InputStreamReader(System.in));
//br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(System.in);
//out = new PrintWriter("output.txt");
out = new PrintWriter(System.out);
} catch (Exception e) {
}
}
public static void initB() {
try {
br = new BufferedReader(new FileReader("input.txt"));
sc = new Scanner(new FileReader("input.txt"));
out = new PrintWriter("output.txt");
} catch (Exception e) {
}
}
public static String getString() {
try {
return br.readLine();
} catch (Exception e) {
}
return "";
}
public static Integer getInt() {
try {
return Integer.parseInt(br.readLine());
} catch (Exception e) {
}
return 0;
}
public static Integer[] getIntArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Integer temp2[] = new Integer[n];
for (int i = 0; i < n; i++) {
temp2[i] = Integer.parseInt(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static Long[] getLongArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
Long temp2[] = new Long[n];
for (int i = 0; i < n; i++) {
temp2[i] = Long.parseLong(temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static String[] getStringArr() {
try {
StringTokenizer temp = new StringTokenizer(br.readLine());
int n = temp.countTokens();
String temp2[] = new String[n];
for (int i = 0; i < n; i++) {
temp2[i] = (temp.nextToken());
}
return temp2;
} catch (Exception e) {
}
return null;
}
public static int getMax(Integer[] ar) {
int t = ar[0];
for (int i = 0; i < ar.length; i++) {
if (ar[i] > t) {
t = ar[i];
}
}
return t;
}
public static void print(Object a) {
out.println(a);
}
public static int nextInt() {
return sc.nextInt();
}
public static double nextDouble() {
return sc.nextDouble();
}
public static void main(String[] ar) {
initA();
solve();
out.flush();
}
public static void solve() {
int max = 110000;
boolean notprime[] = new boolean[110000];
for (int i = 2; i < max; i++) {
for (int j = 2; j * i < max; j++) {
notprime[i * j] = true;
}
}
ArrayList<Integer> prime = new ArrayList<Integer>(110000);
for (int i = 2; i < max; i++) {
if (!notprime[i]) {
prime.add(i);
}
}
final int last = prime.size();
int dp[] = new int[110000];
Arrays.fill(dp, -1);
/*
for (int i = 0; i < 110000; i++) {
int s = 0;
int num = i;
while (!isPrime(num)) {
num++;
s++;
}
dp[i] = s;
}
*
*/
Integer x[] = getIntArr();
int n = x[0], m = x[1];
int min[][] = new int[n][m];
for (int i = 0; i < n; i++) {
Integer temp[] = getIntArr();
for (int ii = 0; ii < m; ii++) {
int num = temp[ii];
if (dp[num] == -1) {
int l = 0, r = last - 1;
while (l != r) {
int mid = (l + r) / 2;
int te = prime.get(mid);
if (te >= num) {
r = mid;
} else {
l = mid + 1;
}
}
min[i][ii] = prime.get(l) - num;
dp[num]=prime.get(l) - num;
}else{
min[i][ii]=dp[num];
}
}
}
int out = Integer.MAX_VALUE;
for (int i = 0; i < n; i++) {
int sum = 0;
for (int ii = 0; ii < m; ii++) {
sum += min[i][ii];
}
out = Math.min(sum, out);
}
for (int i = 0; i < m; i++) {
int sum = 0;
for (int ii = 0; ii < n; ii++) {
sum += min[ii][i];
}
out = Math.min(sum, out);
}
print(out);
}
static boolean isPrime(int n) {
if (n == 2 || n == 3) {
return true;
}
if (n < 2 || n % 2 == 0) {
return false;
}
for (int i = 3; i <= Math.sqrt(n) + 1; i += 2) {
if (n % i == 0) {
return false;
}
}
return true;
}
}
| JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import javax.swing.*;
import java.io.*;
import java.math.BigInteger;
import java.util.*;
public class Main {
static PrintWriter out=new PrintWriter(System.out);
public static void main(String[] args) throws IOException {
//BufferedReader reader=new BufferedReader(new FileReader("input.txt"));
//PrintWriter pw=new PrintWriter(new BufferedWriter(new FileWriter("output.txt")));
//BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
//Scanner scanner=new Scanner(System.in);
Reader sc = new Reader();
boolean[] sieve=new boolean[1000001];
int l=(int)Math.sqrt(sieve.length+1);
sieve[0]=sieve[1]=true;
for (int i = 2; i <=l ; i++) {
if (!sieve[i]){
for (int j = i+i; j <sieve.length ; j+=i) {
sieve[j]=true;
}
}
}
TreeSet<Integer> treeSet=new TreeSet<>();
for (int i = 2; i <sieve.length ; i++) {
if (!sieve[i])
treeSet.add(i);
}
int n=sc.nextInt(),m=sc.nextInt();
int min=Integer.MAX_VALUE;
int[][] a=new int[n][m];
for (int i = 0; i <n ; i++) {
for (int j = 0; j <m ; j++) {
a[i][j]=sc.nextInt();
}
}
for (int i = 0; i <n ; i++) {
int need=0;
for (int j = 0; j <m ; j++) {
need+=treeSet.ceiling(a[i][j])-a[i][j];
}
if (need<min)
min=need;
}
for (int i = 0; i <m ; i++) {
int need=0;
for (int j = 0; j <n ; j++) {
need+=treeSet.ceiling(a[j][i])-a[j][i];
}
if (need<min)
min=need;
}
System.out.println(min);
out.close();
}
}
class node implements Comparable<node>{
Integer no;
Integer cost;
Vector<node> adj=new Vector<>();
public node(Integer no, Integer cost) {
this.no = no;
this.cost = cost;
}
@Override
public String toString() {
return "node{" +
"no=" + no +
", cost=" + cost +
'}';
}
@Override
public int compareTo(node o) {
return o.cost-this.cost;
}
}
class edge implements Comparable<edge>{
tuple u;
Double cost;
public edge(tuple u, Double cost) {
this.u = u;
this.cost = cost;
}
@Override
public int compareTo(edge o) {
return this.cost.compareTo(o.cost);
}
@Override
public String toString() {
return "edge{" +
"u=" + u +
", cost=" + cost +
'}';
}
}
///*
class tuple implements Comparable<tuple>{
Integer a;
Integer b;
public tuple(Integer a, Integer b) {
this.a = a;
this.b = b;
}
@Override
public int compareTo(tuple o) {
return (this.a-o.a);
}
@Override
public String toString() {
return "tuple{" +
"a=" + a +
", b=" + b +
'}';
}
}
//*/
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(String file_name) throws IOException {
din = new DataInputStream(new FileInputStream(file_name));
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public String readLine() throws IOException {
byte[] buf = new byte[64];
int cnt = 0, c;
while ((c = read()) != -1) {
if (c == '\n') break;
buf[cnt++] = (byte) c;
}
return new String(buf, 0, cnt);
}
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 | #include <bits/stdc++.h>
using namespace std;
long long n, m, primes[200005] = {0};
long long grid[505][505], movesReq[505][505] = {0};
int32_t main() {
cin >> n >> m;
primes[0] = 1;
primes[1] = 1;
for (long long i = 2; i * i <= 200000; i++)
if (!primes[i])
for (long long j = 2; i * j <= 200000; j++) primes[i * j] = 1;
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (m); j++) cin >> grid[i][j];
for (long long i = (0); i < (n); i++)
for (long long j = (0); j < (m); j++) {
while (primes[grid[i][j] + movesReq[i][j]]) movesReq[i][j]++;
}
long long ans = 1e9, temp = 0;
for (long long i = (0); i < (n); i++) {
temp = 0;
for (long long j = (0); j < (m); j++) temp += movesReq[i][j];
if (temp < ans) ans = temp;
}
for (long long j = (0); j < (m); j++) {
temp = 0;
for (long long i = (0); i < (n); i++) temp += movesReq[i][j];
if (temp < ans) ans = temp;
}
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 sys
from functools import lru_cache, cmp_to_key
from heapq import merge, heapify, heappop, heappush
from math import *
from collections import defaultdict as dd, deque, Counter as C
from itertools import combinations as comb, permutations as perm
from bisect import bisect_left as bl, bisect_right as br, bisect
from time import perf_counter
from fractions import Fraction
import copy
import time
starttime = time.time()
mod = int(pow(10, 9) + 7)
mod2 = 998244353
# from sys import stdin
# input = stdin.readline
def data(): return sys.stdin.readline().strip()
def out(*var, end="\n"): sys.stdout.write(' '.join(map(str, var))+end)
def L(): return list(sp())
def sl(): return list(ssp())
def sp(): return map(int, data().split())
def ssp(): return map(str, data().split())
def l1d(n, val=0): return [val for i in range(n)]
def l2d(n, m, val=0): return [l1d(n, val) for j in range(m)]
try:
# sys.setrecursionlimit(int(pow(10,7)))
sys.stdin = open("input.txt", "r")
# sys.stdout = open("../output.txt", "w")
except:
pass
def pmat(A):
for ele in A:
print(*ele,end="\n")
def seive():
prime=[1 for i in range(10**6+1)]
prime[0]=0
prime[1]=0
for i in range(10**6+1):
if(prime[i]):
for j in range(2*i,10**6+1,i):
prime[j]=0
return prime
n,m=L()
A=[L() for i in range(n)]
p=seive()
P=[]
for i in range(2,10**6+1):
if p[i]==1:
P.append(i)
r={}
c={}
rmax=cmax=0
for i in range(n):
for j in range(m):
idx=bl(P,A[i][j])
nxt=P[idx]
r[i]=r.get(i,0)+nxt-A[i][j]
c[j]=c.get(j,0)+nxt-A[i][j]
ans=10**20
for ele in r:
ans=min(ans,r[ele])
for ele in c:
ans=min(ans,c[ele])
print(ans)
endtime = time.time()
# print(f"Runtime of the program is {endtime - starttime}")
| 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
distancias[100000] = 3
for i in range(int(10e4) - 1, -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 | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 20 17:10:13 2020
@author: narayanaaramamurthy
"""
n,m=map(int,input().split())
c=100030
f=[0]*c
f[1]=1
for i in range(2,c):
if f[i]==0:
for j in range(i+i,c,i):
f[j]=1
t=0
for i in range(c-1,0,-1):
if f[i]==0:
t=i
f[i]=t
l=[[int(j) for j in input().split()] for i in range(n)]
for i in range(n):
for j in range(m):
t=l[i][j]
l[i][j]=f[t]-l[i][j]
mx=10**10
for i in range(n):
mx=min(mx,sum(l[i]))
for j in range(m):
t=0
for i in range(n):
t+=l[i][j]
mx=min(mx,t)
print(mx)
"""
3 3
1 2 3
5 6 1
4 4 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 | #include <bits/stdc++.h>
using namespace std;
int matrix[505][505];
int m, n;
int col[505];
int row[505];
int prime[110000];
int pc;
bool visit[110000];
void init() {
for (int i = 2; i < 110000; i++) {
if (visit[i]) continue;
for (int j = i * 2; j < 110000; j += i) visit[j] = true;
}
for (int i = 2; i < 110000; i++)
if (!visit[i]) prime[pc++] = i;
}
int next(int num) {
int l, r, mid;
l = 0;
r = pc - 1;
while (l < r) {
mid = (l + r) / 2;
if (prime[mid] < num)
l = mid + 1;
else
r = mid;
}
return prime[r] - num;
}
int main() {
int i, j, v, tmp, min;
cin >> n >> m;
init();
for (i = 0; i < n; i++)
for (j = 0; j < m; j++) cin >> matrix[i][j];
for (i = 0; i < n; i++) {
v = 0;
for (j = 0; j < m; j++) {
tmp = next(matrix[i][j]);
col[j] += tmp;
v += tmp;
}
row[i] = v;
}
min = INT_MAX;
for (i = 0; i < n; i++)
if (min > row[i]) min = row[i];
for (j = 0; j < m; j++)
if (min > col[j]) min = col[j];
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 | p=10**5+10
def sieve():
l=[True]*p
i=2
while i*i<=p:
if l[i]:
for j in range(i*i,p,i):
l[j]=False
i+=1
primes=[]
for i in range(2,p):
if l[i]:
primes.append(i)
return primes
primes=sieve()
from bisect import bisect_left as bl
n,m=map(int,input().split())
req=[[0 for i in range(m)]for j in range(n)]
mat=[]
for i in range(n):
mat.append([int(i) for i in input().split()])
for i in range(n):
for j in range(m):
curr=mat[i][j]
ind=bl(primes,curr)
g=primes[ind]
req[i][j]=g-curr
#print(req)
mini=1000000000
for i in range(n):
curr=sum(req[i])
if curr<mini:
mini=curr
for j in range(m):
curr=0
for i in range(n):
curr+=req[i][j]
if curr<mini: mini=curr
print(mini)
| 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
import os
import sys
from io import BytesIO, IOBase
from bisect import bisect_left as bl #c++ lowerbound bl(array,element)
from bisect import bisect_right as br #c++ upperbound br(array,element)
primes=[2]
import math
def getprime():
global primes
for x in range(2,111111):
chk=0
for y in range(2,math.floor(math.sqrt(x))+2):
if x%y==0:
chk=1
break
if chk==0:
primes.append(x)
def main():
getprime()
global primes
#print(primes[:100])
n,m=map(int,input().split(" "))
a=[list(map(int,input().split(" "))) for x in range(n)]
ans=int(1e19)
for x in range(n):
cnt=0
for y in range(m):
cnt+=primes[bl(primes,a[x][y])]-a[x][y]
ans=min(ans,cnt)
for x in range(m):
temp=[]
for y in range(n):
temp.append(a[y][x])
cnt=0
for x in temp:
cnt+=primes[bl(primes,x)]-x
ans=min(ans,cnt)
print(ans)
#-----------------------------BOSS-------------------------------------!
# region fastio
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
# endregion
if __name__ == "__main__":
main() | PYTHON3 |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | #include <bits/stdc++.h>
using namespace std;
int n, m;
long long ans = 1000000007;
int v[505][505];
int vis[1000005];
int main() {
cin >> n >> m;
for (int i = 1; i <= n; i++)
for (int h = 1; h <= m; h++) cin >> v[i][h];
for (int i = 3; i <= 1000000; i += 2)
if (!vis[i])
for (int h = i * 3; h <= 1000000; h += i * 2) vis[h] = 1;
vis[1] = 1;
int pr = 0;
for (int i = 1000000; i >= 1; i--) {
if (!vis[i] && (i % 2 == 1 || i == 2)) pr = i;
vis[i] = pr;
}
for (int i = 1; i <= n; i++) {
long long j = 0;
for (int h = 1; h <= m; h++) j += vis[v[i][h]] - v[i][h];
ans = min(ans, j);
}
for (int i = 1; i <= m; i++) {
long long j = 0;
for (int h = 1; h <= n; h++) j += vis[v[h][i]] - v[h][i];
ans = min(ans, j);
}
cout << ans;
}
| CPP |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | n,m=map(int,input().split())
limit=int(1e5+2)
l=[1,1]+[0]*limit
for i in range(2,limit):
#(limit-i*i)//i+1) gives number of multiples of i to given range
l[i*i::i]=[1]*((limit-i*i)//i +1)#floor division i , +1
#in l we have 0 values at prime places
for i in range(limit,-1,-1):
l[i]*=l[i+1]+1 #minimum number which need to be added to get a prime = prime_distance
s=[[l[j] for j in map(int,input().split())] for _ in ' '*n]#n is number of rows
#taking the input, replacing every element to its minimum prime_distance
print(min(min(sum(i) for i in s),min(sum(i) for i in zip(*s))))
'''
for i in ' '*5:
i will be a single space of type string
'''
| 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 static java.lang.Math.*;
import static java.util.Arrays.*;
public class CF271B {
static BufferedReader __in;
static PrintWriter __out;
static StringTokenizer input;
public static void main(String[] args) throws IOException {
__in = new BufferedReader(new InputStreamReader(System.in));
__out = new PrintWriter(new OutputStreamWriter(System.out));
boolean[] prime = new boolean[100111];
fill(prime, true);
prime[0] = false;
prime[1] = false;
for(int i = 2; i < 100111; ++i) {
if(prime[i]) {
int j = i + i;
while(j < 100111) {
prime[j] = false;
j += i;
}
}
}
int n = rni(), m = ni();
int[][] a = new int[n][m];
for(int r = 0; r < n; ++r) {
r();
for(int c = 0; c < m; ++c) {
a[r][c] = ni();
}
}
List<Integer> l = new ArrayList<>();
for(int r = 0; r < n; ++r) {
int temp = 0;
for(int c = 0; c < m; ++c) {
int x = a[r][c];
while(!prime[x]) {
++x;
}
temp += x - a[r][c];
}
l.add(temp);
}
for(int c = 0; c < m; ++c) {
int temp = 0;
for(int r = 0; r < n; ++r) {
int x = a[r][c];
while(!prime[x]) {
++x;
}
temp += x - a[r][c];
}
l.add(temp);
}
prln(Collections.min(l));
close();
}
// references
// IBIG = 1e9 + 7
// IRAND ~= 3e8
// IMAX ~= 2e10
// LMAX ~= 9e18
// constants
static final int IBIG = 1000000007;
static final int IRAND = 327859546;
static final int IMAX = 2147483647;
static final int IMIN = -2147483648;
static final long LMAX = 9223372036854775807L;
static final long LMIN = -9223372036854775808L;
// util
static int minof(int a, int b, int c) {return min(a, min(b, c));}
static int minof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
static int minstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
static long minof(long a, long b, long c) {return min(a, min(b, c));}
static long minof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? min(x[0], x[1]) : min(x[0], minstarting(1, x));}
static long minstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? min(x[offset], x[offset + 1]) : min(x[offset], minstarting(offset + 1, x));}
static int maxof(int a, int b, int c) {return max(a, max(b, c));}
static int maxof(int... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
static int maxstarting(int offset, int... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
static long maxof(long a, long b, long c) {return max(a, max(b, c));}
static long maxof(long... x) {return x.length == 1 ? x[0] : x.length == 2 ? max(x[0], x[1]) : max(x[0], maxstarting(1, x));}
static long maxstarting(int offset, long... x) {assert x.length > 2; return offset == x.length - 2 ? max(x[offset], x[offset + 1]) : max(x[offset], maxstarting(offset + 1, x));}
static int powi(int a, int b) {if(a == 0) return 0; int ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static long powl(long a, int b) {if(a == 0) return 0; long ans = 1; while(b > 0) {if((b & 1) > 0) ans *= a; a *= a; b >>= 1;} return ans;}
static int floori(double d) {return (int)d;}
static int ceili(double d) {return (int)ceil(d);}
static long floorl(double d) {return (long)d;}
static long ceill(double d) {return (long)ceil(d);}
// input
static void r() throws IOException {input = new StringTokenizer(__in.readLine());}
static int ri() throws IOException {return Integer.parseInt(__in.readLine());}
static long rl() throws IOException {return Long.parseLong(__in.readLine());}
static int[] ria(int n) throws IOException {int[] a = new int[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Integer.parseInt(input.nextToken()); return a;}
static long[] rla(int n) throws IOException {long[] a = new long[n]; input = new StringTokenizer(__in.readLine()); for(int i = 0; i < n; ++i) a[i] = Long.parseLong(input.nextToken()); return a;}
static char[] rcha() throws IOException {return __in.readLine().toCharArray();}
static String rline() throws IOException {return __in.readLine();}
static int rni() throws IOException {input = new StringTokenizer(__in.readLine()); return Integer.parseInt(input.nextToken());}
static int ni() {return Integer.parseInt(input.nextToken());}
static long rnl() throws IOException {input = new StringTokenizer(__in.readLine()); return Long.parseLong(input.nextToken());}
static long nl() {return Long.parseLong(input.nextToken());}
// output
static void pr(int i) {__out.print(i);}
static void prln(int i) {__out.println(i);}
static void pr(long l) {__out.print(l);}
static void prln(long l) {__out.println(l);}
static void pr(double d) {__out.print(d);}
static void prln(double d) {__out.println(d);}
static void pr(char c) {__out.print(c);}
static void prln(char c) {__out.println(c);}
static void pr(char[] s) {__out.print(new String(s));}
static void prln(char[] s) {__out.println(new String(s));}
static void pr(String s) {__out.print(s);}
static void prln(String s) {__out.println(s);}
static void pr(Object o) {__out.print(o);}
static void prln(Object o) {__out.println(o);}
static void prln() {__out.println();}
static void pryes() {__out.println("yes");}
static void pry() {__out.println("Yes");}
static void prY() {__out.println("YES");}
static void prno() {__out.println("no");}
static void prn() {__out.println("No");}
static void prN() {__out.println("NO");}
static void pryesno(boolean b) {__out.println(b ? "yes" : "no");};
static void pryn(boolean b) {__out.println(b ? "Yes" : "No");}
static void prYN(boolean b) {__out.println(b ? "YES" : "NO");}
static void prln(int... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
static void prln(long... a) {for(int i = 0, len = a.length - 1; i < len; __out.print(a[i]), __out.print(' '), ++i); __out.println(a[a.length - 1]);}
static <T> void prln(Collection<T> c) {int n = c.size() - 1; Iterator<T> iter = c.iterator(); for(int i = 0; i < n; __out.print(iter.next()), __out.print(' '), ++i); __out.println(iter.next());}
static void flush() {__out.flush();}
static void close() {__out.close();}} | JAVA |
271_B. Prime Matrix | You've got an n × m matrix. The matrix consists of integers. In one move, you can apply a single transformation to the matrix: choose an arbitrary element of the matrix and increase it by 1. Each element can be increased an arbitrary number of times.
You are really curious about prime numbers. Let us remind you that a prime number is a positive integer that has exactly two distinct positive integer divisors: itself and number one. For example, numbers 2, 3, 5 are prime and numbers 1, 4, 6 are not.
A matrix is prime if at least one of the two following conditions fulfills:
* the matrix has a row with prime numbers only;
* the matrix has a column with prime numbers only;
Your task is to count the minimum number of moves needed to get a prime matrix from the one you've got.
Input
The first line contains two integers n, m (1 ≤ n, m ≤ 500) — the number of rows and columns in the matrix, correspondingly.
Each of the following n lines contains m integers — the initial matrix. All matrix elements are positive integers. All numbers in the initial matrix do not exceed 105.
The numbers in the lines are separated by single spaces.
Output
Print a single integer — the minimum number of moves needed to get a prime matrix from the one you've got. If you've got a prime matrix, print 0.
Examples
Input
3 3
1 2 3
5 6 1
4 4 1
Output
1
Input
2 3
4 8 8
9 2 9
Output
3
Input
2 2
1 3
4 2
Output
0
Note
In the first sample you need to increase number 1 in cell (1, 1). Thus, the first row will consist of prime numbers: 2, 2, 3.
In the second sample you need to increase number 8 in cell (1, 2) three times. Thus, the second column will consist of prime numbers: 11, 2.
In the third sample you don't have to do anything as the second column already consists of prime numbers: 3, 2. | 2 | 8 | import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.StringTokenizer;
public class Main{
static class InputReader {
final private int BUFFER_SIZE = 1 << 17;
private DataInputStream din;
private byte[] buffer;
private int bufferPointer, bytesRead;
public InputReader(InputStream in) {
din = new DataInputStream(in);
buffer = new byte[BUFFER_SIZE];
bufferPointer = bytesRead = 0;
}
public byte next() {
try {
return read();
} catch (Exception e) {
throw new InputMismatchException();
}
}
public String nextString() {
StringBuilder sb = new StringBuilder("");
byte c = next();
while (c <= ' ') {
c = next();
}
do {
sb.append((char) c);
c = next();
} while (c > ' ');
return sb.toString();
}
public int nextInt() {
int ret = 0;
byte c = next();
while (c <= ' ') {
c = next();
}
boolean neg = c == '-';
if (neg) {
c = next();
}
do {
ret = (ret << 3) + (ret << 1) + c - '0';
c = next();
} while (c > ' ');
if (neg) {
return -ret;
}
return ret;
}
private void fillBuffer() {
try {
bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
} catch (IOException e) {
throw new InputMismatchException();
}
if (bytesRead == -1) {
buffer[0] = -1;
}
}
private byte read() {
if (bufferPointer == bytesRead) {
fillBuffer();
}
return buffer[bufferPointer++];
}
}
public static void main(String arg[]) throws IOException {
InputReader r=new InputReader(System.in);
// BufferedReader r=new BufferedReader(new FileReader("input.txt"));
// BufferedReader r=new BufferedReader(new InputStreamReader(System.in));
// BufferedWriter wr=new BufferedWriter(new PrintWriter("output.txt"));
PrintWriter p=new PrintWriter(System.out,false);
boolean a[]=new boolean[200000];
Arrays.fill(a,true);
for(int i=2;i*i<200000;i++)
{
if(a[i])
{
for(int x=i;x*i<200000;x++)
{
a[x*i]=false;
}
}
}
a[1]=false;
int n=r.nextInt();
int m=r.nextInt();
int row[]=new int[n];
int col[]=new int[m];int min=Integer.MAX_VALUE;
for(int i=0;i<n;i++)
{
for(int j=0;j<m;j++)
{
int x=r.nextInt();
int temp=x;
while(!a[temp])
{
temp++;
}
temp=temp-x;
row[i]+=temp;
col[j]+=temp;
}
if(min>row[i])
{
min=row[i];
}
}
for(int j=0;j<m;j++)
{
if(min>col[j])
min=col[j];
}
p.println(min);
p.flush();
}} | JAVA |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.