# The 20 numbers 1, 2,... and 20 are arranged in a row, so that the sum of the two adjacent numbers is a prime number, and the first and last two digits are also a prime number.

Source: Internet
Author: User

The 20 numbers 1, 2,... and 20 are arranged in a row, so that the sum of the two adjacent numbers is a prime number, and the first and last two digits are also a prime number.

Three methods are provided:
(Note: In order to make the program faster, according to the characteristics of the arrangement, each method has fixed the last element. In this way, the output is only part of the condition, but you can modify the output of each method, all elements are output by moving a position, such as 123. The first output is 123, 2nd, 231, and 3rd, so that all the solutions can be obtained .)

The following is a brief description of the brute force method.
Idea of brute-force method: arrange 1-n all, and then check each order to see whether the conditions and outputs are met.
Recursion only sorts data. The idea of recursion is to choose one from 1 to n to the last position, and (recursion) select one from the remaining number to the next position, and then **, follow this loop.
By the way, this method is very slow. After completing all the arrangement, it will take several hundred million recursion times. You have to wait a long time (maybe several hours, haha) to see the result. However, you can replace the for statement I have commented on with the for statement below to quickly see the result.

If you understand the brute force method, you can understand method 3. You don't need to read it. You may not understand it. Although the speed is the three faster ones, it is more difficult to understand.

If you don't understand it, it's your problem. Maybe you don't know what the arrangement is, or you don't know what the recursion is. (You should read this book instead of simply asking .)

# Include <stdio. h>
# Include <malloc. h>
# Include <memory. h>
# Include <math. h>
# Include <time. h>

{/* Determine the prime number */
Int I;
Int sqrootN;
If (n = 2 ){
Return true;
} Else if (n % 2 = 0 | n = 1 ){
Return false;
}
SqrootN = (int) (sqrt (n) + 0.1) + 1;
I = 3;
While (I <sqrootN ){
If (n % I = 0 ){
Return false;
}
I + = 2;
}
Return true;
}

Void Swap (int * a, int * B)
{/* Swap two numbers */
Int tmp;
Tmp = *;
* A = * B;
* B = tmp;
}

Bool IsOk (int * arr, int arrsize)
{/* Determine whether conditions are met */
If (! IsPrimeNumber (arr [arrsize-1] + arr [0]) {
Return false;
}

While (-- arrsize> 0 ){
If (! IsPrimeNumber (arr [arrsize] + arr [arrsize-1]) {
Return false;
}
}
Return true;
}

//////////////////////////////////////// ////////////////
// Method 1:
Bool Adjust_Pair (int * arr, int arrsize, int depth)
{
Static int total = 0;
Bool ret = false;
Int I;
If (depth = 2 ){
If (IsPrimeNumber (arr [0] + arr [arrsize-1]) {
Total ++;
Printf ("\ n % 03d:", total );
For (I = 0; I <arrsize; I + = 2 ){
Printf ("% 02d-% 02d", arr [I], arr [I + 1]);
}
Return true;
} Else {
Return false;
}
}
For (I = depth-2; I> 1; I-= 2 ){
If (IsPrimeNumber (arr [I-1] + arr [depth-2]) {
Swap (arr + depth-3, arr + i-1 );
Swap (arr + depth-4, arr + I-2 );
If (Adjust_Pair (arr, arrsize, depth-2 )){
Ret = true;
}
Swap (arr + depth-3, arr + i-1 );
Swap (arr + depth-4, arr + I-2 );
}
}
Return ret;
}

Bool Make_Pair (int * arr, int arrsize, int depth)
{
Bool ret = false;
Int I;
Static int total1 = 0;
Static int total2 = 0;
If (depth = 0 ){
Return Adjust_Pair (arr, arrsize, arrsize );
}

For (I = 0; I <depth-1; I + = 2 ){
If (IsPrimeNumber (arr [depth-1] + arr [I]) {
Swap (arr + depth-2, arr + I );
If (Make_Pair (arr, arrsize, depth-2 )){
Ret = true;
}
Swap (arr + depth-2, arr + I );
}
}
Return ret;
}
Void DoPermutation (int * arr, int arrsize)
{
If (arrsize % 2 = 1 ){
Printf ("\ n result: nonexistent (the array size must be an even number ).");
Return;
}

If (! Make_Pair (arr, arrsize, arrsize )){
Printf ("\ n Result: No .");
}
}

//////////////////////////////////////// //////////////
// Brute force method: unconditionally arrange all rules and determine whether conditions are met one by one.
Bool _ DoPermutation2 (int * arr, int arrsize, int depth)
{
Static int total = 0;
Bool ret = false;
Int I;
If (depth = 0) {/* sorted */
If (IsOk (arr, arrsize) {/* determine whether the condition is met. if the condition is met, output */
Total ++;
Printf ("\ n % 03d:", total );
For (I = 0; I <arrsize; I + = 2 ){
Printf ("% 02d-% 02d", arr [I], arr [I + 1]);
}
Return true;
} Else {
Return false;
}
}

/* For (I = (depth + 1) % 2; I <depth; I + = 2) {changing the for below to this for can optimize the speed by half */
For (I = 0; I <depth; I ++) {/* depth-1 is equivalent to the last position of the array */
Swap (arr + depth-1, arr + I);/* select arr [I] to the last position in the array. arr [depth-1] */
If (_ DoPermutation2 (arr, arrsize, depth-1) {/* depth-1 element before recursive arrangement */
Ret = true;
}
Swap (arr + depth-1, arr + I);/* switch back to keep the original array unchanged */
}
Return ret;
}

Void DoPermutation2 (int * arr, int arrsize)
{
If (arrsize % 2 = 1 ){
Printf ("\ n result: nonexistent (the array size must be an even number ).");
Return;
}

If (! _ DoPermutation2 (arr, arrsize, arrsize-1 )){
Printf ("\ n Result: No .");
}
}

//////////////////////////////////////// //////////////
// Method 3: recursion is performed only when the ongoing arrangement meets some conditions.
Bool _ DoPermutation3 (int * arr, int arrsize, int depth)
{
Static int total = 0;
Bool ret = false;
Int I;
If (depth = 0 ){
If (IsPrimeNumber (arr [arrsize-1] + arr [0]) {
Total ++;
Printf ("\ n % 03d:", total );
For (I = 0; I <arrsize; I + = 2 ){
Printf ("% 02d-% 02d", arr [I], arr [I + 1]);
}
Return true;
} Else {
Return false;
}
}

For (I = (depth + 1) % 2; I <depth; I + = 2 ){
/* For (I = 0; I <depth; I ++) {You can replace the preceding statement with one, but the preceding statement is better */
If (! IsPrimeNumber (arr [depth] + arr [I]) {
Continue;
}
Swap (arr + depth-1, arr + I );
If (_ DoPermutation3 (arr, arrsize, depth-1 )){
Ret = true;
}
Swap (arr + depth-1, arr + I );
}
Return ret;
}

Void DoPermutation3 (int * arr, int arrsize)
{
If (arrsize % 2 = 1 ){
Printf ("\ n result: nonexistent (the array size must be an even number ).");
Return;
}

If (! _ DoPermutation3 (arr, arrsize, arrsize-1 )){
Printf ("\ n Result: No .");
}
}

Int main (int argc, char * argv [])
{
Clock_t start, finish;
Int arr [100], I;
For (I = 0; I <100; I ++ ){
Arr [I] = I + 1;
}

/* Method 1 */
DoPermutation (arr, 18 );
/* Brute Force Method */
/* DoPermutation2 (arr, 18 );*/
/* Method 3 */
/* DoPermutation3 (arr, 18 );*/

Return 0;
}

Related Keywords:

The content source of this page is from Internet, which doesn't represent Alibaba Cloud's opinion; products and services mentioned on that page don't have any relationship with Alibaba Cloud. If the content of the page makes you feel confusing, please write us an email, we will handle the problem within 5 days after receiving your email.

If you find any instances of plagiarism from the community, please send an email to: info-contact@alibabacloud.com and provide relevant evidence. A staff member will contact you within 5 working days.

## A Free Trial That Lets You Build Big!

Start building with 50+ products and up to 12 months usage for Elastic Compute Service

• #### Sales Support

1 on 1 presale consultation

• #### After-Sales Support

24/7 Technical Support 6 Free Tickets per Quarter Faster Response

• Alibaba Cloud offers highly flexible support services tailored to meet your exact needs.