Cómo escribir un programa de operaciones cuadráticas con números grandes en C
/*----------------------------------------- ----------------------------------
* Nombre de la función: Suma de números grandes
*Proceso: 1 Compara dos números cuál es más largo
* 2 Usa el número más largo como número de bucles
* 3 Agrega los elementos correspondientes y almacena en la memoria hasta la siguiente suma superior
* 4 hasta el final del ciclo
* 5 !!!!!! La suma negativa no está diseñada
*Parámetros de entrada: numa, entumecido, cadena de resultado
*Parámetros de salida: Ninguno
*Entorno de edición: winSP2 VC2003 C
*----- -------------------------------------------- -------------- ---- ------------------*/
void add(char *numa, char *numb, char *result) // Calcular el suma de dos números grandes
{
char *pna = findend(numa); // Puntero a numa. pna apunta al bit más bajo del multiplicando,
char *pnb = findend(num); //Un puntero a entumecido//pnb apunta al bit más bajo del multiplicando,
int together=(int)strlen( numa);
int together=(int)strlen( numa); // Marca la longitud del número a; (int )strlen(num); // Marca la longitud del número b;
int times = 0; // Marca el número de veces a contar.
int carry=0, temp_result; // Almacena transporte y temp_result
Nodo *head, // Se utiliza para almacenar el puntero principal
*pstart, / / Se usa para almacenar el primer puntero en el cálculo
*pnew; // Se usa para solicitar un nuevo nodo
head = pstart = new Node // Inicializa el primer nodo y el nodo principal; .
pstart -gt; datos = 0;
pstart -gt; siguiente = NULL
pstart -gt; p>if (abigerb(numa,numb)gt;=1)
times = (int)strlen(numa); //Compara las longitudes de las dos cadenas y usa la más grande como recuento de bucles.
else
{
times = (int)strlen(numb);
pna = findend(numb); punteros
pnb = findend(numa);
along = (int)strlen(numb); //marca la longitud del número a;
blong = (int)strlen(numa); //marca la longitud del número b;
}
while ((times-- amp;amp; (timesgt;=0) )|| carry ! = 0)
{
if (!pstart-gt; next) //si el nodo está actualmente vacío, solicita un nuevo nodo
{
pnew = nuevo Nodo;
pnew -gt; datos = 0;
pnew -gt; siguiente = NULL; -gt; adelante = pstart;
pstart -gt; siguiente = pnew;
}
else temp_result = (pstart-gt;data (*pna- 48) (*pnb-48) llevar); //valor propio nuevo valor llevar como nuevo valor actual
pstart -gt; data = temp_result10; //almacenar bits
carry = temp_result/10; //almacenar transporte
pstart = pstart -gt.next; //movimiento de nodo
blong--;
if(blonggt; 0 )pnb--; //el puntero se mueve al máximo del número agregado
else *pnb=48; //después de eso, la resta se convierte en 0 sin ninguna operación;
pna-- ; //agregar movimiento del puntero,
}
pstart =head; //buscar el punto final de la tabla de cadenas
while(pstart-gt; next! = 0)
{
pstart-gt;data = 48; //! lt;lt;lt;Porque nuestra salida son caracteres.
Entonces agregue 48 gt;gt;gt;gt;salida inversa
pstart = pstart-gt;next;
}
int tip = 0; convertir a cadena
pstart = pstart-gt; //buscar palabras válidas
//coutlt;lt;"\n el resultado es: ";
while(pstart ! = 0) // genera el resultado en orden positivo
{
resultado[tip] = pstart-gt;data;
//coutlt; datos;
pstart = pstart-gt;
}
resultado[tip] = '\0';
p>pstart = head; //espacio libre
while(pstart-gt; next != 0)
{
pnew = pstart- gt; siguiente; eliminar pstart;
pnew;
}
regresar; // Función para comparar los tamaños de dos cadenas numéricas
// Descripción del valor de retorno: 0 es largoblong; 2 es largo=blong
int abigerb(char *numa, char *numb ) //Compara el que tiene el dígito más alto de los dos números
{
int together=(int)strlen(numa); //Marca la longitud del número a; ;
p>int blong=(int)strlen(numb); //Marca la longitud del número b;
char *pna = numa;
char *pna = numa ; // Apunta al bit más alto del número A;
char *pnb = nub; // Apunta al bit más alto del número B
if ( togethergt; blong) devuelve 1;
p>if (along==blong)
{
while(*pna) //Compara dos números cuál es más grande
{
si (*pnagt; *pnb) devuelve 1;
si no (*pnalt; *pnb) devuelve 0
;else if(*pna==* pnb){pna;pnb;}//1111 y 1112
}
return 2;
Esto muestra que encontrar el punto final sigue siendo congruente;
p>
}
Esto muestra que encontrar el punto final sigue siendo congruente.
p>devuelve 0;
}
/*---------------------- --------------------------------------------------
*Nombre de la función: Resta de números grandes
*Proceso 1 Compara los dos números cuál es más largo
* 2 Usa el más largo como el número de loops
* 3 Si los dos números tienen la misma longitud, comienza la comparación desde la posición más alta hasta descubrir cuál es mayor,
* 4 Resta el elemento correspondiente y almacena en la siguiente posición superior hasta la siguiente Suma de una posición superior
* 5 Al restar el elemento correspondiente en cada posición, hay tres situaciones posibles a tratar: a=b, ab;
* 5 cuando Al restar el valor correspondiente a cada posición se procesan tres situaciones posibles, a= b, ab;
* 6 Cuando a=b, calcular, 11-12, 111- 112, considere tomar prestado
* 7 hasta el final del ciclo
*Parámetros de entrada: numa, entumecido, cadena de resultado
*Parámetros de salida: Ninguno
* -------------------------------------------- ------- ------------------------*/
resta vacía(char *numa, char *numb , char *resultado)// Calcular la resta
{ char *pna = findend(numa); //un puntero a numa. pna apunta al bit más bajo del minuendo,
char *pnb = findend(numb); //un puntero a entumecido //pnb apunta al bit más bajo del minuendo,
int together=(int) strlen(numa);
int together=(int) strlen(numa);
int blong=; (int) strlen(numb); // Marca la longitud del número b;
int times = 0; // Marca el número de veces a contar.
int carry = 0; // Guarda los bits prestados
int clear0 = 0 // Elimina el impacto del "0" inútil en la parte superior del resultado 13-5. = 08!
int isnegative=0; // Se usa para agregar el último signo negativo cuando el minuendo es mayor que el sustraendo
Nodo *head, // Se usa para almacenar el puntero del encabezado
p> p>*pstart, // usado para almacenar el primer puntero en el cálculo
*pnew; // usado para solicitar un nuevo nodo
head = pstart = new Nodo; // Inicializa el primer nodo y el nodo principal.
pstart -gt; datos = 0;
pstart -gt; siguiente = NULL
pstart -gt; p>if (abigerb(numa,numb))
times = strlen (numa);
else //intercambia posiciones para hacerlo menos difícil
{
times = strlen(numb); //Deja que el número más largo (cadena) reste el número más corto (cadena)
pna = findend(numb); p>
pnb = findend(numa);
along=(int)strlen(numb); //marca la longitud del número a;
blong=(int); )strlen(numa); // Marca la longitud del número b;
isnegative=1 // Marca el final con un signo negativo
}
while ((times-- amp; amp; (timesgt;=0))||carry != 0)//carry ! = 0 significa que no hay préstamos
{
if (!pstart-gt; next) // Si el nodo actual está vacío, solicita un nuevo nodo
{
pnew = new Node;
pnew - gt; datos = 0;
pnew -gt.next = NULL;
pnew -gt; adelante = pstart; ;
}
if(timeslt;0)//Si después del cálculo, el bit prestado es igual a 1, significa que debe ser negativo;
{ pstart -gt; data = -3; // deja que sea igual al signo negativo '-'// -3 proviene del hecho de que el signo negativo difiere de 0 en 3.
break ; }
else
{
if ( *pna == *pnb )// Cuando el minuendo es igual al minuendo.
El resultado es igual al resultado de la resta directa; y establece el débito en 0
{
if (carry == 0) pstart -gt data = (*pna-48). )-(* pnb-48); // 111-11
else
{
pstart -gt; datos = (*pna-48)- (*pnb- 48); // situación 111-11
else
{
pstart-gt; datos = (*pna-48)-( *pnb- 48) 10 -llevar; //1121-1112 llevar=1;
}
}
if( *pna gt; *pnb ) // cuando Cuando el minuendo es mayor que el sustraendo. El resultado es igual al resultado de la resta directa y el bit de préstamo se establece en 0
{
pstart -gt; -48)- carry; //Almacena los bits
carry=0;
}
else if( *pna lt; *pnb )//Indica que el minuendo es mayor que Restar, suma 10 al resultado, lo que equivale a tomar prestado (llevar) 1
{ if(timesgt; 0)
part-gt; (*pna-48) -(*pnb-48) 10 -carry;//el caso 13-5 como nuevo valor
else
pstart -gt; data = ( *pnb-48)- (*pna-48) -carry; //3-5 como el nuevo valor actual
carry=1;
}
}
pstart = pstart -gt; next;
/Movimiento del nodo
blong--;
if(blonggt; 0 )pnb--;/ / El puntero se mueve al bit alto del minuendo
else *pnb=48; // Luego la resta se vuelve 0 sin ninguna operación, lo que en realidad se puede optimizar. ¡Pero el código será muy largo! Y es necesario reabrir el nodo. Así que ríndete; pna--; // Calculando el movimiento del puntero,
}
if(isnegative==1)//// Agrega un signo negativo.
Agregue una longitud y configúrela en signo negativo
{
pnew = new Node;
pnew -gt = 0;
pnew -gt; siguiente = NULL;
pnew -gt; pstart;
pstart -gt; siguiente =
pnew -gt; = pstart;
pstart -gt; next = pnew;
pstart -gt; //Porque para encontrar el final de la tabla de cadena necesitamos agregar de manera uniforme. 48. Debido a que '-' es 45, es igual a '-3'
}
pstart =head; //encuentra el punto final de la tabla de cadenas
mientras (pstart -gt; next ! = 0)
{
pstart -gt;data = 48; //! lt;
Entonces agregue 48gt;gt;gt;gt; para invertir la salida
pstart = pstart-gt;next;
}
int tip = 0;/ / conconvert to string
clear0=0; //elimina el inútil '0' 13-5 = 08 en la parte superior del resultado. gt;
pstart = pstart-gt; forward; // Encuentra palabras válidas
while (pstart ! = 0) // Muestra los resultados en orden positivo;
{ if(clear0==0 amp;amp; ((int)pstart-gt;data)==48amp;amp;pstart-gt;ahead!=0) //Elimina el "0" inútil en la parte superior del resultado ;
//No mostrar ningún contenido
else
resultado[tip] = pstart-gt;data;
if( ((int) pstart-gt; datos)! = 48amp; ((int) pstart-gt; datos)! = 45) clear0=1; //'-' símbolo
pstart = pstart-gt ; adelante ;
}
resultado[tip] = '\0';
pstart = cabeza; //espacio libre
while( pstart-gt; siguiente ! = 0)
{
pnew = pstart-gt; siguiente;
eliminar pstart;
pstart = pnew;
}
retorno;
}
/*----------- -------------------------------------------------- -- -----------
* Nombre de la función: Multiplicación de números grandes
*Proceso: 1 Ingrese dos números grandes en forma de cadena
* 2 Haz una lista doblemente enlazada
* 3 Dos punteros apuntan al bit más bajo de la cadena numérica
* 4 Compara el bit más bajo del primer número con el más bajo bit almacenado en la lista enlazada Multiplica todos los elementos de los dos números
* 5 Mueve el primer puntero de la lista enlazada
* 6 Repite 4 y 5 y multiplica desde el bit más bajo hasta el bit más alto
* 7 Después de la multiplicación, porque el bit más bajo es el primer bit de la lista vinculada y el último bit es el final de la lista vinculada. Entonces genere la lista vinculada en orden inverso.
* 4 hasta el final del bucle
* Parámetros de entrada: numa, entumecido, cadena de resultado
* Parámetros de salida: Ninguno
* ------------------------------------------------ -- ----------- ----------*/
void multiplicar(char *numa, char *numb, char *resultado)// usado para almacenar el resultado)//calcular el producto
{ char *pna = findend(numa); //un puntero a numa.pna apunta al bit más bajo del multiplicando,
char *pnb = findend(numb); //un puntero a entumecido
//pnb apunta al bit más bajo del multiplicando,
int a lo largo =(int)strlen(numa ); //longitud del marcador número a ;
int blong=(int)strlen(numb); //longitud del marcador número b;
int carry=0, temp_result; // Almacena redondeo y resultados temporales
Nodo *head, // usado para almacenar el puntero principal
*pstart, // usado para almacenar el primero parte del cálculo.
*pnew, // Se usa para solicitar un nuevo nodo
*pgo; // Se usa para devolver el nodo inicial de la siguiente línea después de calcular cada línea y usar el desplazamiento
head = pstart =new Node; // Inicializa el primer nodo y el nodo principal.
pstart -gt; datos = 0;
pstart -gt; siguiente = NULL
pstart -gt; p> while (a lo largo de--)
{
pgo = pstart; // Guarda el punto de entrada
blong = (int)strlen(numb); // Inicializar longitud
pnb = findend(numb); // Inicializar puntero
while ((blong-- amp; amp; (blonggt;=0))|| carry ! = 0)
{ if (!pstart-gt; next)//si el nodo actualmente está vacío, solicita un nuevo nodo
{ pnew = new Node;
pnew -gt; datos = 0;
pnew -gt; siguiente = NULL;
pnew -gt; pststart-gt; > pnew -gt; siguiente = NULL;
pnew -gt; adelante = pstart;
pstart -gt; >
if(blonglt;0)temp_result = carry; //maneja el caso donde solo hay progresiones disponibles
else temp_result =( pstart -gt;data (*pna-48)*(*pnb- 48 ) carry); //valor propio nuevo valor feed como nuevo valor
pstart -gt; data = temp_result10; //almacenar dígitos
carry = temp_result/10; redondeo
pstart = pstart -gt; //movimiento del nodo
pnb--;
pstart = pstart-gt; una posición ;
pna--; //Puntero al punto más alto del multiplicador
}
pstart = head; //Encuentra el final del lista enlazada
mientras(pstart-gt;siguiente! = 0) {
pstart-gt;data = 48; //! lt;lt;lt;Porque nuestra salida son caracteres.
Entonces agregue 48 gt; gt; gt; salida inversa
pstart = pstart-gt; next; p>
pstart = pstart-gt; //busca palabras válidas
while(pstart != 0) //Envía los resultados en orden positivo;
{ resultado [tip] = pstart-gt;data;
pstart = pstart-gt;ahead;}
resultado[tip] = '\0';
pstart =head; //Liberar espacios
while(pstart-gt; next != 0) {
pnew = pstart-gt;
eliminar pstart;
pstart =pnew;
}
return;
}
/ *--- -------------------------------------------------- ----------------------
* Nombre de la función: División de números grandes 2 -
*Ideas de funciones: 1 Guarde la cadena temporal con un puntero que apunte al bit más alto del divisor; tempstr[a] = pna
* 2. Si la cadena temporal es mayor que el divisor, réstela.
El resultado es igual al resto
* if (tempstrgt; numb)tempstr = tempstr - numb
* 3 Si es menor que el divisor y el puntero apunta a la cabeza, el resto es igual a la cadena temporal
* if(tempstr *
* Parámetros de entrada: numa, numb.result, cadena restante
*argumentos de salida: ninguno
*--- -------------------------------------- ------------ ----------------------*
void divide2( char *numa, char * entumecido, char *resultado, char *resto)// calculando división2
{ char one[]="1"; //cadena temporal ....
char one2[] ="1"; //
char zero[]="0"; //
char numb2[6048] //
char tempstr[ 6018]=""; //cadena temporal i
nt ia=0, ia2=0; //Indicador de tempstr
bool moveon=false; //Voltea la tarjeta
char *pna = numa; //un puntero al punto numa numa pna //apunta al bit más bajo del signo menos,
char *pnb = findend(numb); puntero a entumecido //pnb apunta al minuendo El bit más bajo
Nodo *head, // usado para almacenar el puntero principal
*pstart, // usado para almacenar el primer puntero en el cálculo
*pnew; // Se utiliza para solicitar un nuevo nodo
head = pstart =new Node; // Inicializa el primer nodo y el nodo principal. primer nodo y el nodo principal.
pstart -gt; datos = 0;
pstart -gt; siguiente = NULL
pstart -gt; p>moveon = false; while(*pna)
{ if(!pstart -gt; next)//Si el nodo actual está vacío, solicita un nuevo nodo
{ pnew = nuevo nodo;
pnew -gt; datos = 0;
pnew -gt; siguiente = NULL
pnew -gt; /p> p>
pstart -gt; next = pnew;}
ia=(int)strlen(tempstr); // longitud tomada
tempstr[ia] = *( pna );
tempstr[ia] = '\0'; //Convertir a cadena
if(tempstr[0]=='0')//Procesar el bits altos también El tipo de cadena que es 0, como g.00
{
ia2=0;
while(tempstr[ia2]= ='0') ia2;
while(ia2gt;=1)//Borrar 0's inútiles
{
ia=ia2-1;
tempstr[ia]=tempstr[ia2];
--ia2;
}
tempstr[ia2]='\0';
}
while (abigerb(tempstr,numb)gt;0)//Si tempstr es mayor o igual que entumecido
{
if(tempstr[ 0]=='0')//Los números de dígitos altos que se procesan también son 0, como 00----, este es un código redundante, guárdelo como memoria
{
ia2 = 0;
mientras(tempstr[ia2]=='0') ia2;
if(ia==ia2 )
{ moveon = true; break; }
}
strcpy(numb2, entumecido);
restar(tempstr, entumecido, tempstr); ///A-B strcpy( numb,numb2);
if(tempstr[0]=='-')//Si no se permite que el juicio se vuelva negativo, agregue B nuevamente.
{
strcpy(numb2, entumecido);
addition(tempstr, entumecido, tempstr); //A-B
strcpy(entumecido, numb2);
ia2=0; //Longitud corregida. Porque no hay operación negativa en la operación de suma
ia=0; // Para eliminar el último signo negativo, toda la operación avanza.
while(tempstr[ia2]!= '\0') ia2;
while(ia2gt;=1)//borrar 0 inútiles {
tempstr [ia]=tempstr[ia 1];
ia;
--ia2;}
tempstr[ia]='\0';
p>
moveon = true;
break; }
pstart -gt; //resultados selfadd
moveon = true;}
p>if(moveon) pstart = pstart -gt; next; //movimiento de nodo
}
strcpy(remainder, tempstr); //almacenar el resto
int tip = 0; //convertir a cadena
pstart = head; //encontrar el punto final de la tabla de cadenas
mientras (pstart -gt; next ! = 0) {
pstart-gt;data = 48 //! lt;lt;lt;Porque nuestra salida son caracteres. Entonces agregue 48 gt;gt;gt;gt;salida inversa
resultado[tip] = pstart-gt;data;
pstart = pstart-gt;next }
resultado[tip] = '\0'; //almacenar resultado
pstart = head; //espacio libre
while(pstart-gt ; next ! = 0 ) {
pnew = pstart-gt; siguiente; eliminar pstart; pstart = pnew }
regresar;