Planificación de instalaciones
El programa utiliza principalmente dos tecnologías: expresiones regulares (el contenido de los principios de compilación) y expresiones que calculan representaciones de cadenas.
La forma general de calcular 24 puntos se puede expresar mediante una expresión regular de la siguiente manera:
(((E O E ) O E ) O E ) = 24
( (E O ( E O E ) ) O E ) = 24
((E O E ) O ( E O E ) ) = 24
((E O E ) O ( E O E ) ) = 24
(E O ( ( E O E ) O E ) ) = 24
(E O ( E O ( E O E ) ) ) = 24
Donde e representa un número y o representa un operador.
La idea del programa es un método exhaustivo. Reemplace e en las seis fórmulas anteriores con números legales,
reemplace o con operadores legales y vea si puede. obtener el resultado. Obviamente, al evaluar el resultado, debes evaluar la expresión representada por la cadena.
Por ejemplo, (((1 2) 3) * 4) = 24 es una alternativa, con uno a la izquierda del signo igual.
Una expresión representada por una cadena.
La ventaja de este método es que es sencillo y fácil de ampliar.
(Si se usa cualquier número en lugar de cuatro números, y se pueden usar operaciones distintas a la suma, resta, multiplicación y división)
Por supuesto, la desventaja de este método es que produce una gran cantidad de números que generalmente pensamos que es una fórmula repetida.
Por ejemplo ((1 2) 3) * 4) = 24 y ((1 (2 3)) * 4) = 24.
Eliminar corchetes innecesarios y la suma puede convertirse en:
(1 2 3)*4 = 24, por lo que generalmente pensamos que las dos fórmulas anteriores son iguales.
*/
# incluir ltiostream gt
# incluir ltcstring gt
# incluir ltcmath gt
# incluir lt string gt
# incluir ltctime gt
# incluir ltcstdlib gt
Usar espacio de nombres std
const int MAX _ disponible _ NÚMERO _ NUM = 20;
const int MAX _ disponible _ OPERADOR _ NUM = 10;
const int MAX _ REGULAR _ EXPRESIÓN _ NUM = 100; const int MAX _ LEAGAL _ EXPRESSION _ NUM = 4000
const int MAX _ LEN = MAX _ disponible _ NUMBER _ NUM * 10
#Definición guardar 0
#Define print 1
#Define vacío-1
//Reemplace el número entero con una cadena y guárdelo en s.
char * Num_To_Str(char s[], int num)
{
int len =(int)log 10(num) 1;
s[len-]= ' \ 0 ';
Hacer
{
s[len-]=(num 10) ' 0 ';
num/= 10;
} mientras(num);
Devuelve s;
}
//Reemplace el carácter s[p] con la cadena t.
char* Reemplazar(char s[], int p, char t[])
{
int ls, lt, I, j, k;
ls = strlen(s);
lt = strlen(t
for(I = ls lt-1; i gt=(p lt); );I-)
s[I]= s[I-lt 1];
for(j=p, k = 0; t[k]!='\ 0';j,k)
s[j]= t[k];
Devuelve s;
}
typedef Estructura
{
int número;
int aparecer _ tiempo
} nodo;
//registro Información necesaria para generar la expresión.
Categoría Expression_Information
{
Público:
void Init();
void Init _ Todo _ Respuesta();
anular Init_Calculate().
void Init _ Guess();
void Generate _ Expression(char start[], char rule[], int T, int T
); void Calcular(int num _ de _ elegir _ número, int num _ de _ elegir _ operador
int prioridad (char op);
double Calcular _ Expresión(char *); s 1, bool ampis _ A _ Leagal _ Expresión);
char* Transform(char *S1, bool ampis _ A _ Leagal _ Expresión
Privado:
int num _ of _ used _ number//De forma predeterminada, la cantidad de datos necesarios para generar la expresión es 4.
Resultado doble; //El resultado de la expresión, el valor predeterminado es 24.
//Rango de datos disponibles, el valor predeterminado es 1-13, cada dato puede aparecer varias veces.
int num _ of _ available _ number
El número de nodos disponibles [número máximo disponible]
//El tipo de símbolo que se puede utilizar. El valor predeterminado es suma, resta, multiplicación y división.
int num _ of _ operador _ disponible
char disponible _ OPERADOR[MAX _ disponible _ OPERADOR _ NUM][5];
//expresión regular Fórmula
//Por ejemplo ((E O E) O (E O E))
//Donde e representa datos y o representa operador.
int num _ de _expresión regular;
char expresión regular [MAX _ REGULAR _ EXPRESSION _ NUM][MAX _ LEN]
/ /Coincidencia de expresiones; el resultado
int num _ de _ leagal _ expresión
char LEAGAL _ EXPRESSION[MAX _ LEAGAL _ EXPRESSION _ NUM][MAX _ LEN]
p><; p>//Variable temporal, utilizada por la función Generate_Expression.int elige _ NÚMERO [MAX _ disponible _ NÚMERO _ NUM];
char elige _ operador [MAX _ disponible _ NÚMERO _ NUM-1][5]; >
int save _ o _ print // Controla si el resultado se genera directamente o se guarda.
};
void Expression_information::Init()
{
Cantidad usada = 4;
reslut = 24.0
Operandos disponibles = 4;
strcpy(available_operator[0], " ";
strcpy(available_operator[1 ], "-";
strcpy(available_operator[2], " * ");
strcpy(available_operator[3], "/");
//Generar expresión regular.
núm_de_expresión_regular = 0;
char start[MAX_LEN] = " E ";
char rule[MAX_LEN]= " (E O E)";
Generate_Expression(start, rule, num_of_used_number-1, 0);
//cout lt; lt número de expresión regular lt ltendl
//for(int I = 0; i ltnum _ de _expresión regular; i)
//cout lt; ltI 1 lt; lt" " " lt expresión regular [I] lt; ltendl
núm_ de_expresión_legal = 0;
guardar_ o _imprimir = IMPRIMIR
}
void Expresión_información::Init _ Todos _ Respuesta()
{
init();
cout lt lt "* * * * * * * * * * * * Todos _ Respuestas * * * * * * * * * * lt; ltendl
Cantidad disponible = 13;
for( int I = 0; i lt número disponible; i )
{
número_disponible[i]. número = I 1;
número_disponible[i].
Tiempo de aparición = número de usos;
}
guardar _ o _ imprimir = IMPRIMIR
núm_ de _ expresión _ legal = 0;
Calcular (0, 0);
}
Expresión vacía _ información:: Init _ Calcular()
{
int i, j, temp
opción char [MAX_LEN];
init();
mientras(1)
{
cout lt "* * * * * * * * * * * * * * * * * * * * *" lt; ltendl
Cantidad disponible = 0 ;
for(int I = 0; I lt cantidad usada; i )
{
cout lt lt"input" lt ltI 1 lt "No.:" ;
CIN gt; gt temperatura;
for(j = 0; j lt cantidad disponible; j)
if(temp == número_disponible[j] ). número)
Descanso;
if(j lt; número_disponible)
número_disponible[j]. Ocurrencia_hora;
Otro
{
número_disponible[j]. número = temp
número_disponible[j].
ocurrencia_time = 1;
Cantidad de cantidades disponibles;
}
}
guardar _ o _ imprimir = IMPRIMIR
num_of_leagal_expression = 0;
Calcular (0, 0);
if (aprendizaje multiplicado por expresión == 0)
cout lt lt"¡No hay solución!" lt ltendl
cout lt lt"¿Continuar? (Y/N)" lt; ltendl
CIN gt option;
p >Si (!(strcmp(opción, "Y")==0 || strcmp(opción, "Y))== 0)
Devolver;
}
}
void Expression_information::Init_Guess()
{
opción de carácter [MAX_LEN]
; char respuesta[MAX_LEN];
int i, j, temp
bool is_A_Leagal_Expression
int try _ time = 3
init; ();
srand(time(NULL));
mientras(1)
{
cout lt lt"* * * * * * * * * * * * * * * * adivinar* * * * * * * * * * * * * lt; ltendl
num_ of_leagal_expression = 0;
while(expresión de tiempos de aprendizaje == 0)
{
Cantidad disponible = 0;
for(I = 0; ya estaba usado cantidad; i )
{
temp = rand() 13 1;
for(j = 0; j lt número disponible; j )
if(temp == número_disponible[j]). número)
Descanso;
if(j lt; número_disponible)
número_disponible[j]. Ocurrencia_hora;
Otro
{
número_disponible[j]. número = temp
número_disponible[j]. ocurrencia_time = 1;
Cantidad de cantidades disponibles;
}
}
guardar _ o _ imprimir = GUARDAR
p>Calcular (0, 0);
}
cout lt lt" pregunta: ";
for(I = 0; i lt Cantidad disponible; i )
for(j = 0; j número_disponible[i]. tiempo_ocurrencia; j )
cout lt número_disponible[i].
número lt lt" ";
cout lt ltendl
try_time = 3;
mientras(try_time -)
{
cout lt lt"Su respuesta:";
CIN gt; gtanswer;
if(Calculate_Expression(answer,Is_A_Leagal_Expression) = = reslut amp; ampIs_A_Leagal_Expression == verdadero)
{
cout lt lt"¡Sí!"
Pausa;
}
Otro
cout lt lt"¡Incorrecto!" lt ltendl
}
for(I = 0; i ltnum _ of _ leagal _expresioni)
cout lt lt"Solución # " lt ltI 1 lt;": " lt ltendl lt ltleagal _ expresión[I] lt; ltendl lt ltendl
cout lt lt"¿Continuar? (Y/ N)" lt; ltendl
CIN gt; gtoption;
if (!(strcmp(opción, "Y")== 0 || strcmp(opción, " Y)) = = 0)
Retorno;
}
}
Expresión vacía _ información:: Generate_Expression(char start[], char regla[], int t, int T)
{
int I;
Temperatura del carácter [MAX_LEN];
Si ( t==T)
{
strcpy(regular_expression[num_of_regular_expression], inicio
Retorno
}
Otros
{
for(I = 0; iniciar [I]! ='\0';i)
if(iniciar[ i]=='E ')
{
strcpy(temp, inicio);
Reemplazar(inicio, I, regla);
Generar_Expresión(inicio, regla, T, T 1);
strcpy(inicio, temperatura);
}
}
}
Expresión nula _ información:: Calcular(int num _ de _ elegir _ número, int num _ de _ elegido _ operador)
{
int i, j, p, contador
int p _ eligió _ número, p _ eligió _ operador
char temp[MAX_LEN], int _ to _ num
[MAX_LEN];
bool es _ A _ Leagal _ Expression
if (seleccione cantidad == cantidad de uso)
{
if(Seleccionar operador de cantidad==(Seleccionar cantidad - 1))
{
//Enumerar todas las expresiones regulares
for(p = 0; p ltnum _ de _ expresión regular; p )
{
strcpy(temp, regular _ expresión[p]);
p _ elegir_número = p_choose_operator = 0;
//Reemplace e (número) y o (operador) en la expresión regular.
for(I = 0;temp[i]!='\0';i)
{
if(temp[i]==' E ')
{
Reemplazar(temp,I,Num_To_Str(int_to_num,choose_number[p_choose_number]);
I = strlen (int _ to _ num
p _ elige _ número
}
si no(temp[i]=='O ')
{
Reemplazar(temp, yo, elijo _ operador[p _ elijo _ operador]);
I = strlen(elijo _ operador[p _ elijo _ operador]);
p _ elegir _ operador;
}
}//for(i)
if(reslut = = Calculate_Expression(temp, Is_A_Leagal_Expression))
{
if(Guardar o Imprimir == Imprimir)
cout lt lt" Soultion # " lt lt(num _ de _ legal _ expresión 1) lt; lt":" lt ltendl lt lttemp lt ltendl lt ltendl
Otro
strcpy(leagal _ expresión[número_de_expresión_leagal] , temp);
num_ de_expresión_legal ;
}
}//for(p)
}
Otros
{
for(I = 0; i lt número de operadores disponibles; i )
{
strcpy(choose_operator[num_of_choose_operator], available_operator [I]);
calcular(num_of_choose_number,num_of_choose_operator 1 );
}
}
}
Otro
{
para (I = 0; hay cantidad disponible; i )
{
Contador = 0; /p>
for(j = 0; j ltnum _ del _ número _ elegido; j )
if(número _ elegido [j]= = número _ disponible [I]. número)
contador;
if(contador lt; número_disponible[i]. tiempo de ocurrencia)
{
Seleccione cantidad[seleccione cantidad] = cantidad disponible[i].
número;
calcular(núm _ de _ elegido _ número 1, núm _ de _ elegido _ operador
}
}
<); p>}}
//Prioridad del operador
int Expresión _ información::Precedencia(char op)
{
Cambiar
{
Caso " ":
Caso '-':
Retorno 1 ;
Caso ' * ':
Caso "/": devuelve 2;
caso '^': devuelve 3;
Caso '(' :
Caso "@":
Predeterminado:
Devuelve 0
}
}
//Convierta la expresión ordinal en la cadena S1 en una expresión anticipada.
char *Expression_information::Transform(char *s 1, bool ampIs_A_Leagal_Expression)
{
pila de caracteres[MAX_ LEN];
int pila _ top = VACÍO
char * S2 = nuevo char[strlen(s 1)];
int i=0, j = 0
pila[ pila _ top] = ' @ ';
Es _ A _ Leagal _ Expresión = true
mientras(ch)
{
si(ch = = ' ')ch = s 1[ I];
si no(ch== ' (')
{
pila[ pila_top]= ch;
ch = s 1[ I] ;
}
else if(ch== ')')
{
while(stack_top!=empty amp ampstack[ stack_top]! ='(')
S2[j]= pila[stack _ top-];
if(stack_top == VACÍO)
{
Is_A_Leagal_Expression = false
Ir a la etiqueta;
}
stack_top-;
ch = s 1[ I];
}
Otro if(ch==' '||ch=='-'||ch=='* '||ch=='/'||ch=='^' )
{
if(stack_top == EMPTY)
{
Es _ A _ Leagal _ Expresión = false
Ir a la etiqueta;
}
char w = stack[stack _ top]
while(priority(w)>=priority( ch))
{
S2[j]= w;
stack_top-;
if(stack_top == VACÍO)
romper;
w = pila[stack_top];
}
pila[ pila _ top] = ch;
ch = s 1[ I];
}
Otros
{
Si ((ch lt0 ' | | ch gt9') amp; ='.')
{
Es _ A _ Leagal _ Expression = false
Ir a la etiqueta;
}
mientras((ch gt;= ' 0 ' amp ampch lt='9')||ch== ',')
{
S2[j ]= cap;
p>
ch = s 1[ I];
}
S2[j]=“”;
}
}//Hora de finalización
if(stack_top == EMPTY)
{
Es _ A _ Leagal _ Expresión = false
Ir a la etiqueta;
}
ch = stack[stack _ top-];
Y (ch!='@')
{
if(ch== '(')
{
Es _ A _ Leagal _ Expresión = false
Ir a la etiqueta;
}
Otro
{
S2[j]= ch;
ch = pila[pila_top-];
}
}
S2[j]= '\0';
strcpy(S1, S2);
Etiqueta:
Eliminar[]S2;
Devolver s 1;
}
//Calcular el valor de la expresión S1.
información_expresión_doble:: Calculate_Expression(char * s 1, bool ampIs_A_Leagal_Expression)
{
doble S[MAX _ LEN]
>int S _ top = EMPTY
Double x, y;
int i=0, k
Verificación de nodo [número máximo disponible]; p>
int check _ p = 0;
char * str = new char[strlen(s 1)]
strcpy(str, s 1); p>
Transform(str, Is _ A _ Leagal _ Expression);
if (Es _ A _ Leagal _ Expression == false)
Devuelve 0.0;
mientras(str[i])
{
si(str[i]== ' ')
{
i;
Continuar;
}
Cambiar(Cadena[i])
{
Caso " ":
if(S _ top lt; 1)
{
Es _ A _ Leagal _ Expresión = false
Ir a la etiqueta;
}
x = S[S_top] S[S_top-1];
s_top-= 2;
i;
Romper;
Caso '-':
if(S_top lt;1)
{
Is_A_Leagal_Expression = false
Ir a etiqueta;
}
x = S[S_top-1]-S[S_top ];
s _ top-= 2
i ;
Romper;
Caso ' * ':
if(S_top lt;1)
{
Es _ A _ Leagal _ Expression = false
Ir a etiqueta;
}
x = S[S_top-1] * S[S_top];
s_top-= 2;
i;
Romper;
Caso "/”:
if(S_top lt;1)
{
Is_A_Leagal_Expression = false
Transferir a etiqueta;
}
x = S[S_top-1]/S[S_top];
s_top-= 2;
i;
Romper;
Keith '^':
if(S_top lt;1)
p>
{
Es _ A _ Leagal _ Expresión = false
Ir a etiqueta;
}
x = poder(S[
S_top-1], S[S_top]);
s_top-= 2;
i;
Interrupción;
Valor predeterminado :
x = 0;
mientras(str[i]>= ' 0 ' amp ampstr[I] lt; = '9')
{
x = x * 10 cadena[I]-' 0 ';
i
}
si (cadena[i] ]== ' . ')
{
i;
y = 0;
doble j = 10.0 ;
while(str[i]>= ' 0 ' amp ampstr[I] lt;='9')
{
y = y ( str[I] -' 0 ')/j;
i
j * = 10
}
x = y;
//Registra el número ingresado.
for(k = 0; k ltcheck _ p; k )
if (check [k]. número == (int)x)
Verificar [k]. ocurre_time;
if(k==check_p)
{
comprobar [check_p]. número =(int)x;
Marque [check_p]. ocurre_time = 1;
check_p;
}
}
}//cambiar
S[ S_top ]= x;
}//Hora de finalización
if(S_top == EMPTY)
{
Es _ A _ legal _ Expresión = false
Ir a etiqueta;
}
//Comprueba la legalidad del número ingresado.
for(k = 0; k ltcheck _ p; k )
{
for(I = 0; i lt cantidad disponible; i )
{ p>
if(número_disponible[i].número == cheque[k]. cantidad y cantidad. ampnúmero_disponible[i]. tiempo de ocurrencia gt = cheque[check_p]. tiempo de ocurrencia)
Romper;
if(I = =cantidad disponible)
romper
}
if(k lt; check_p)
p>
{
Es _ A _ Leagal _ Expression = false
Ir a la etiqueta;
}
x = S[S_top-];
Etiqueta:
Devolver x;
}
int main(int argc, char * argv[])
{
Juego de clase expresión_información;
//El usuario ingresa números y el sistema resuelve (da todos soluciones).
Juegos. init _ Compute();
//El sistema da un número y el usuario puede resolverlo (la solución está garantizada). Los usuarios deben utilizar los números proporcionados por el sistema para resolver el problema e intentarlo hasta tres veces.
Juegos.
init_Guess();
//Dado el rango de datos (como 1-13) y los operadores disponibles (como suma, resta, multiplicación y división), encuentre todas las soluciones.
Juegos. Init_All_Answer().
Devuelve 0;
}