Soluciones de programación de alta puntuación
0?Error? 0? Advertencia
# include & ltstdio.h & gt
# include & ltmath.h & gt
int? Número[210][5];? /*Almacenamiento de números primos reversibles y números después de la descomposición prima*/
int? Seleccione[110];? /*Los subíndices de los números primos se pueden colocar en la primera y última fila de la matriz*/
int? matriz[4][5];? /*matriz 4X4, en qué elemento 0 de cada fila almacena el subíndice del array correspondiente al número primo reversible*/
int? Contar;? /*El número de números primos reversibles*/
int? seleccionar recuento? /*El número de números primos reversibles que se pueden colocar en la primera y última fila de la matriz*/
int? larray[2][200];? /*Contador de números correspondiente a la matriz temporal utilizada para almacenar los primeros dos o tres dígitos del número primo*/
int? lcount[2];
int? núm(int? número);
int? ok(int? número);
¿No válido? Proceso(int?I);
¿Anulado? copy_num(int?I);
int? comp_num(int?n);
int? encontrar1(int?I);
int? encontrar 2(vacío);
int? find0(int?num);
¿No es válido? p_array(void);
¿Nulo? principal()
{
int? I, k, flag, cc=0, i1, i4;
printf("¿Ahí? ¿Es? ¿Mágico? ¿Cuadrado? ¿Qué usar? ¿Reversible? ¿Número primo? ¿Como? Sigue:\ n ") ;
para(I = 1001;i<9999;i+=2)? /*Encuentra el número primo reversible que satisface las condiciones*/
{
k = I/1000;
if(k%2!= 0 & amp& ampk! = 5 & amp& ampnum(i))? /*Si el primer dígito del número primo reversible no es un número par o 5*/
{
número[count][0]= I;? /*Almacenado en una matriz*/
proceso(count++);? /*Descomponer el número de números primos*/
if(number[count-1][2]%2!= 0 & amp& amp?/*Si el número primo reversible cumple con los requisitos para ser colocado en la primera fila de la matriz* /
número[count-1][3]%2! = 0 & amp& amp? /*Y la condición de la última línea, registrar*/
Número[count-1] [2]! = 5 & amp& amp? /*Subíndice, suma 1 al contador*/
¡Número [count-1][3]! )
select[sele count++]= count-1;
}
}
larray[0][lcount[0] ++]= número[0][0] /100;? /*La primera fila de la matriz temporal almacena los dos primeros dígitos*/
larray[1][lcount[1]++]= número[0][0]/10;? /*La segunda fila de la matriz temporal almacena los primeros tres dígitos*/
for(I = 1;i<count;i++)? /*Almacena los primeros dos o tres dígitos del número primo en una matriz temporal*/
{
if(larray[0][lcount[0]-1]!= número [i][0]/100)
larray[0][lcount[0]++]= número[I][0]/100;
if(larray [ 1][lcuenta[1]-1
]! =número[i][0]/10)
larray[1][lcount[1]++]= número[I][0]/10;
}
for(I 1 = 0; I 1 & lt; selecounti1++)? /*Exhaustivo dentro del rango de convergencia permitido de la primera línea*/
{
array[0][0]= select[I 1];? /*Obtener el exponente del número primo correspondiente*/
copiar _ num(0);? /*Copiar los números primos descompuestos*/
for(array[1][0]= 0; array[1][0]& lt; count; array[1][0]++) ? /*Segunda línea exhaustiva*/
{
copiar _ num(1);? /*Copiar el número descompuesto*/
If (!comp_num(2))
Continuar;? /*Si la composición de los dos primeros números de cada columna entra en conflicto con un número primo, pruebe con el siguiente número*/
for(array[2][0]= 0; array[2][0 ]& lt; contar; matriz[2][0]++)? /*Agotar la tercera línea*/
{
copiar _ num(2);? /*Copiar el número descompuesto*/
If (!comp_num(3))
Continuar;? /*Si la composición de los primeros tres números de cada columna entra en conflicto con un número primo, pruebe con el siguiente número*/
for(i4 = 0; i4 & ltselecounti4++)? /*Exhaustivo dentro del rango permitido de la última línea*/
{
array[3][0]= select[i4];
copiar _ número(3);? /*Copiar el número descompuesto*/
for(flag=1, I = 1; flag&&i<=4;i++)? /*Determinar si cada columna es un número primo reversible*/
If (!find 1(I)) flag = 0;
If (flag& amp& ampfind2())? /*Determinar si la diagonal es un número primo reversible*/
{?printf("Número %d\n ",++ cc);? p_array();? }?/*Matriz del cuadrado mágico de salida*/
}
}
}
}
}
int? número(int? número)? /*Determinar si el número primo es reversible*/
{
int? j;
Si (!ok(número))? ¿devolver? 0;
for(j = 0;número>0;número/=10)? /*Convierte números primos en números inversos*/
j = j * 1número % 10;
¿Qué pasa si (!ok(j))? ¿devolver? 0;? /*Determinar si el número invertido es un número primo*/
¿Regresión? 1;
}
int? ok(int? número)? /*Juzga si es un número primo*/
{
int? Yo;
¿Doble? j;
si (número %2==0)? ¿devolver? 0;
j=sqrt(número (par))+1;
for(I = 3;i<= j;i+=2)
si (número%i==0)? ¿devolver? 0;
¿Volver? 1;
}
¿Anulado? proceso(int?i)? /*Descomponer el entero I-ésimo en números y almacenarlos en la matriz*/
{
int? j, num
num = número[I][0];
for(j = 4; j>=1;j -, num/=10)
Número[I][j]=número % 10;
}
>
¿Anulado? número_copia(int?i)? /*Copiar el número de dígitos del número primo señalado por la matriz[i][0] a la matriz[i] */
{
int? j;
for(j = 1; j & lt=4;j++)
Matriz[I][j]=Número[Matriz[I][0]][j ];
}
int? comp_num(int?n)? /*Determinar si los primeros n bits de cada columna de la matriz entran en conflicto con los primeros n bits permitidos para números primos reversibles*/
{
¿Electricidad estática? int? dos;? /*Usar variables estáticas internas para guardar el subíndice del último elemento encontrado*/
¿Electricidad estática? int? jj;? /*ii: Los primeros dos subíndices se buscaron la última vez, jj: Los primeros tres subíndices se buscaron la última vez*/
int? I,núm,k,*p;? /*p: Apunta al subíndice anterior correspondiente ii o jj*/
int? *cuenta? /*pcount: Contador que apunta al número de matrices temporales que se utilizarán*/
Switch(n){? /*Seleccione un conjunto correspondiente de variables de control según el valor de n*/
¿Caso? 2: pcount = &lcount[0];p=&break;
¿Caso? 3:pcount = &lcount[1];p=&jj;break;
Predeterminado: ¿Volver? 0;
}
para(I = 1;i<=4;i++)? /*Cuatro columnas se procesan por separado*/
{
for(num=0, k = 0; k & ltn; k++)? /*Calcular el valor representado por los primeros n dígitos*/
num = num * 1array[k][I];
if(num & lt;=larray[ n-2][*p])? /*Comparar con el último elemento encontrado*/
for(;* p & gt= 0 & amp& ampnum & ltlarray[n-2][* p]; (* p)-);/ * Si el elemento encontrado anteriormente es grande, busque hacia adelante*/
Otro
for(;p & ltpcount & amp& ampnum & gtlarray[n-2][* p] ;(* p)++);? /* De lo contrario, mira hacia atrás*/
if(* p & lt; 0 | | * p & gt=*pcount)
{
* p = 0;? ¿devolver? 0;
}
Si (num!=larray[n-2][*p])
¿Devolver? 0;? /*Si los primos reversibles no permiten los primeros n dígitos, 0*/
}
¿Regresar? 1;
}
int? encontrar1(int?i)? /*Determinar si la dirección de la columna es un número primo reversible*/
{
int? num, j;
for(num=0, j = 0; j & lt4;j++)
num = num * 1array[j][I]; p>
¿Volver? encontrar 0(núm);
}
int? encontrar2 (vacío)? /*Determinar si la dirección diagonal es un número primo reversible*/
{
int? num1, num2, I, j;
for(num1=0, j = 0; j & lt4;j++)
num 1 = num 1 * 1matriz[j] [j+1];
for(num2=0,j=0,I = 4;j<4;j++,i-)
num 2 = num 2 * 10 +matriz [j][I];
if(buscar0(núm1
))? return(find 0(num 2));
¿Y si? ¿devolver? 0;
}
int? encontrar0(int?núm)? /*Ver si es un número primo reversible que cumple los requisitos*/
{
¿Electricidad estática? int? j;
if(num & lt;= número[j][0])for(;j & gt= 0 & amp& ampnum & ltnúmero[j][0];j-);< / p>
¿Y si? for(j<count&&num>number[j][0]j++);
if(j<0 | | j>=count){? j = 0; regresión? 0;? }
if(num==número[j][0])? ¿devolver? 1;
¿Y si? ¿devolver? 0;
}
¿Nulo? p_array(nulo)? /*Matriz de salida*/
{
int? Yo, j;
for(I = 0; i<4;i++)
{
for(j = 1; j & lt=4; j++) ? printf("%d?",matriz[I][j]);
printf("\n");
}
}
p>