Programación UFC
#¿Incluir? & ltstdio.h & gt
¿#Contiene? & ltstring.h & gt
#¿Contiene? & ltmalloc.h & gt
¿#Contiene? & ltctype.h & gt
typedef? intBOOL
typedef? ¿No firmado? ¿corto? LINT_B;
typedef? ¿No firmado? B2 Longlint;
typedef? ¿LINT_B? *?lint;
typedef? constante? ¿LINT_B? *?Clint;
#¿Definición? ¿En realidad? 1
¿#Definición? FALSE0
#¿Definición? ¿base? 0x10000ul
#¿Definición? BASEDIV2?0x8000ul
¿#Definición? ¿BASEMINONA? 0xFFFFul
¿#Definición? ¿DIGITAL? 64?//?¿Cuándo? ¿DIGITAL? =?64?Cuando se puede llegar a un factorial dentro de 200.
¿#Definición? Max(a,?b)((a)?<?(b)?(b)?:?(一))
#Definición? Rmldzrs(l,h)¿hacer? {mientras(*( - h)?==?0);? ++h;? h? =?Max(l,?h);}?mientras(0);
const? int? ¿Bitperdgt? =?tamañode(LINT_B)? *?8;
//?Copiar números grandes
LINT? Copiar(CLINT?f,?Clint?l,?LINT?x)
{
¿Y (f?!=?l)? *x++? =?* f++;
¿Regresión? x;
}
//? ¿El número más grande es 0?
¿Integrado? ¿Booleano? isZero(CLINT?l,?Clint?h)
{
Rmldzrs(l,h);
¿Regresar? (l?==?h)? ¿En realidad? :?False;
}
//?Cambiar el orden de las cadenas
¿No es válido? Invertir(char?*s)
{
¿Carácter? t;
¿Carácter? *¿sl? =?s;
Ciel? *¿Shhh? =?sl? +?strlen(s);
¿Y (sl?<?sh)? {t? =?* sl? *sl++? =?*(-sh)? ;? *¿Shhh? =?t;}
}
//?Intercambiar punteros numéricos grandes
¿No es válido? swapCLINT(CLINT?*a,?Clint?*b)
{
Clint? t;
t? =?* un;? *¿a? =?*b;? *¿b? =?t;
}
//?¿Adición? ¿do? =?¿Respuesta? +?B
¿PELUSA? Suplemento (¿CLINT? ¿Al. Clint? ¿Ah? ¿Clint? bl,? ¿Clint? bh,? ¿LINT? cl)
{
B2 ¿Lint? ¿llevar? =?(LINT_ B2)0;
LINT? ¿ch? =?cl;
Si ((ah?-?al)?<?(bh?-?bl))? intercambiar Clint(&Al. &bl),? intercambiar Clint(& ah?& ampBH);? //Asegúrese de que la longitud de A sea mayor o igual que b.
//?Suma dos números.
¿Cuándo? (bl?<?bh)
*ch++? =?(LINT_B)(¿Llevar?=?(LINT_B2)*al++?+?(LINT_B2)*bl++?+?(LINT_B2)(LINT_B)(¿Llevar?& gt& gt?sBitperdgt));
//¿Procesarlo? ¿respuesta? ¿Comparar? ¿b? Longitud extra
¿Cuándo? (al?<?ah)
{
si (carry?>=?base)? *ch++? =?(LINT_B)(Carry?=?(LINT_B2)*al++?+?(LINT_B2)(LINT_B)(Carry?& gt& gt?sBitperdgt));
¿Qué más? *ch++? =?* al++;
}
//?manejar llevar
si (¿llevar? &? base)? *ch++? =?(LINT_B)1;
¿Volver? ch;
}
//?¿Multiplicación corta? ¿do? =?¿Respuesta? *?b
¿PELUSA? umul(CLINT? ¿Al. Clint? Ah? ¿LINT_B? b,? ¿LINT? cl)
{
LINT? ch;
B2 ¿Pelusa? * pc
CLINTpa
LINT_B2llevar,? bv;
Si (b?==?0?||?isZero(al, ah))? {si(cl)? *cl? =?0;? ¿devolver? cl;}
Si (ah?-?Al. ==?1)?//?¿Respuesta? La longitud es solo un número.
{
pc=? (lint_B2?*)cl;
*pc? =?(Pelusa_B2)*al? *?(Lint_ B2)b;
ch? =?cl? +?2;
Rmldzrs(cl,ch);
¿Regresar? ch;
}
ch? =?cl;
¿Papá? =?al;
¿Llevar? =?(Pelusa_B2)0,? bv? =?(Lint_ B2)b;
//?Cálculo del bucle
¿Y (pa? & lt? Ah)? *ch++? =?(LINT_B)(Carry?=?bv?*?(LINT_B2)*pa++?+?(LINT_B2)(LINT_B)(Carry?& gt& gt?sBitperdgt));
/ /?Handle manejo
*ch++? =?(LINT_B)(¿Llevar?>>?sBitperdgt);
Rmldzrs(cl,ch);
¿Volver? ch;
}
//? ¿División corta? ¿respuesta? =?b? *?¿do? +?d
//?cl? ¿aún? ¿d? Puede ser un puntero nulo.
¿PELUSA? udiv(CLINT?Al. Clint?ah?LINT_B?b,?LINT?cl,?LINT?d)
{
int? Lena. lenC
LINTbufC? =? NULO,? ¿ch? pch
LINT _ Bc
¿Clint? pah
B2 ¿Pelusa? rdach,? bv,? RV;
//? Manejar casos especiales
If (b?==?0)
{
Printf("Usar División por 0 error en división de exceso y escasez");
if(d)*d=? 0;
si(cl)? *cl? =?0;?
¿Volver? cl;
}
Lina.
=?¿Eh? -?al;
Si (Lina?==?0)?{si (d)? *¿d? =?0;? si(cl)? *cl? =?0;? ¿devolver? cl;}?//?La división es igual a 0, el cociente resultante es igual a 0 y el resto es igual a 0.
Si (Lina?==?1)?//?El dividendo tiene solo 1 dígito.
{
si(*al?<?b)? {Si(d)? *¿d? =?*al? si(cl)? *cl? =?0;}?//?El dividendo es menor que el divisor, el cociente es igual a 0 y el resto es igual al dividendo.
Otro
{
c? =?*Al? /?b;
si(cl)? *cl++? =?c;
si(d)*d=? *¿Alabama? -?¿do? *?b;
}
¿Volver? cl;
}
lenC? =?Lina. -?1;? //Calcular longitud
If (cl?==?empty)
{
bufC? =?(LINT)malloc((lenC?+?1)?*?sizeof(LINT _ B));? //? Solicite memoria para asegurarse de que cl no esté vacío.
If (bufC?==?Empty)
{
Printf("¡Error al solicitar memoria temporal usando redundancia y división!\n ");
¿Qué pasa si (d)? *¿d? =?0;
¿Volver? NULL
}
cl? =?bufC
}
ch? =?cl? +?lenC
//?Empieza a calcular
Bah. =?¿Eh? -?1;
pch? =?ch;
bv=? b,? ¿RV? =?0;
Y (Al?& lt=?pah)
{
*pch? =?(LINT_B)((rdach?=?((rv?& lt& lt?sBitperdgt)?+?(LINT_B2)*pah -))?/?bv);
RV? =?(rdach?-?bv?*?(lint_ B2)* PCH-);
}
Si (d)? *¿d? =?(LINT_B)RV;
if(bufC)
{
Gratis(bufC);
¿Devolver? NULL
}
¿Devolver? (*ch?==?0)?ch? :?++ ch;
}
//?Un número entero grande se convierte en una cadena numérica.
¿constante? ¿Ciel? *?LInt2Str(char?*?o, ?Clint?l, ?Clint?h, ?LINT_B?base, ?Boolean?uppercase)
{
const ? ¿Ciel? *?Dulce Cooper? =?"0123456789 abcdef";
const? ¿Ciel? *?Swiklow? =?"0123456789abcdef",? * Vec
Car? *Orden de compra;
LINT_B? incógnita,? t[DIGITAL],? ii[DIGITLEN];
¿PELUSA? ¿th? tl,? ¿Illinois? Hola;
CLINTxl? xh;
¿Booleano? ¿bandera? =?Verdadero;
po=? o;
il=? 2;
ih=? copiar(l,?h,?il);
Rmldzrs(il,ih);
if(isZero(il,ih))
{
*o++? =?'0';
*o++? =?0;
¿Volver? po;
}
Vec? =?mayúscula? ¿Swee Cooper? :?sVecLower
xl=? &x;
xh=? ¿SG? +?1;
th=? ¿TL? =?t;
Interruptor (base)
{
¿Funda? 2:?Caso? 8:?Caso? 10:?Caso? 16:?Pausa;
Predeterminado:? ¿base? =?10;
}
mientras(1)
{
si(bandera)
{
¿ésimo? =?udiv(il,ih,?base,?tl,?&x);
¿Marca? =?Falso;
}
Otros
{
¿eh? =?udiv(tl,th?base,?il?&x);
¿Bandera? =?Verdadero;
}
*o++? =?vec[x];
Si (th?==?tl?||?ih?==?il)? Descanso;
}
*o++? =?0;
Inversa (po);
¿Regresión? po;
}
//? El factor factorial puede calcular con precisión factoriales dentro de 200 y definir DIGITLEN más grandes para lograr factoriales de números mayores.
¿PELUSA? Jiecheng(lint?l,?LINT_B?x)
{
LINT? h? =?l? +?1,?tl,?
LINT_B? ¿I? =?1,?t[DIGITLEN];
¿Booleano? ¿bandera? =?Verdadero;
*l? =?1;
ésimo? =?tl? =?t;
Y (yo?& lt=?x)
{
si(bandera)? {¿bandera? =?Falso;? ¿th? =?umul(?l,h,?i++,?TL);}
¿Y si? {¿bandera? =Verdadero;? h=? umul(tl,?th?i++,l);}
}
if(!flag)? h? =?Copiar(tl,?th?l);
¿Devolver? h;
}
int? Señor()
{
¿Ciel? buf[512];
LINT_B? ¿Un [hombre digital]? b[DIGITAL],? c[DIGITAL],? ¿I? =?5;
PELUSA? Alabama. ah? licenciado en Derecho,? bh,? cl,? ch;
¿Eh? =Al.
=?1,? bh? =?bl? =?b,? ¿ch? =?cl? =?c;
Y (yo?<?30)
{
printf("%d!?",?I);
p>ch=? Añadir (Al, ah? bl,? Jiecheng (bl,? I),? cl);
Ah=? copiar(cl,?ch,?al);
I +=? 11;
Si (yo?<?30)?printf("+?");
}
printf("=?%s\ n ", LInt2Str(buf,? Al. Ah? 10,? FALSE));
¿Regresar? 0;
}