Programa de preguntas de programación con puntuación alta (lenguaje C)
Hombre, esas preguntas tuyas son muy aburridas y muy confusas.
1. ¿Cómo dividir un archivo? ¿Cómo dividir un archivo si tiene 5.30004MB? Quitarlo hasta B? ¿Cómo montar? ¿Fusión aleatoria?
2. ¿Su ejemplo es binario o hexadecimal? ¿Por qué es 0 000000b?
3. ¿Cuál es la entrada? ¿Archivo de texto? ¿O ingresar desde la terminal? ¿La clave se determina con antelación o mientras se ejecuta el programa?
4. Esto no está mal. Pruébalo.
5. Esto es muy aburrido, ¿por qué no incluyes todos los dialectos del país?
Habla claro antes de hacer preguntas, de lo contrario nadie lo hará por ti aunque tengas 10.000 puntos.
Esta es la cuarta pregunta. Aunque la respuesta está bien, una vez que la entrada es demasiado grande, será muy lenta.
#include
#include
#include
estructura dígito{
char d;
struct dígito *anterior;
struct dígito *siguiente;
};
typedef struct dígito Dígito;
struct bigint{
Dígito *cabeza;
Dígito *cola;
}; p>
typedef struct bigint BigInt;
void display(BigInt b){
int c=0;
while(b.tail != 0){
printf("%d",b.tail->d);
c++;
b.tail=b.tail -> anterior;
}
printf("\n");
printf("%d dígitos en total.\n",c);
p>}
void free_memory(BigInt *b){
Dígito *p;
while(b->head! =0){
p=b->cabeza->siguiente;
gratis(b->cabeza);
b->cabeza=p;
}
b->cabeza=0;
b->cola=0;
}
Copia BigInt( BigInt b){
BigInt b2={0,0};
Dígito *p,*q;
q=b.head ;
while(q!=0){
if(b2.head==0){
b2.head=(Dígito *)malloc( sizeof(Dígito) );
b2.head->next=0;
b2.head->anterior=0;
p=b2.head ;
}
else{
p->next=(Dígito *)malloc(tamañode(Dígito));
p ->siguiente- >anterior=p;
p=p->siguiente;
p->siguiente=0;
}
p- >d=q->d;
q=q->siguiente;
}
b2.tail=p;
return b2;
}
BigInt add(BigInt b1,BigInt b2){
char carry=0;
Resultado BigInt= {0,0};
Dígito *p;
while(b1.head!=0&&b2.head!=0){
si (resultado. cabeza == 0
){
resultado.head=(Dígito *)malloc(sizeof(Dígito));
resultado.head->next=0;
resultado. head->anterior=0;
p=resultado.head;
}
else{
p->siguiente=( Dígito *)malloc(sizeof(Dígito));
p->siguiente->anterior=p;
p=p->siguiente;
p ->siguiente=0;
}
char c=b1.head->d+b2.head->d+carry;
si(c >=10){
llevar=1;
c=c-10;
}
más llevar=0;
p->d=c;
b1.head=b1.head->siguiente;
b2.head=b2.head->siguiente;
}
while(b1.head!=0){
p->next=(Digit *)malloc(sizeof(Digit)); p>
p->siguiente->anterior=p;
p=p->siguiente;
p->siguiente=0;
p->d=b1.head->d+carry;
b1.head=b1.head->siguiente;
carry=0;
}
while(b2.head!=0){
p->next=(Dígito *)malloc(sizeof(Dígito));
p ->siguiente->anterior=p;
p=p->siguiente;
p->siguiente=0;
p->d =b2 .head->d+carry;
b2.head=b2.head->siguiente;
carry=0;
}
if(carry>0){
p->siguiente=(Dígito *)malloc(tamañode(Dígito));
p->siguiente->anterior= p;
p=p->siguiente;
p->siguiente=0;
p->d=llevar;
}
resultado.tail=p;
devolver resultado;
}
Resta BigInt(BigInt b,char d){
Resultado BigInt={0,0};
Dígito *p;
char prestamo=0,d2;
if( b. cabeza->d>=d) d2=b.head->d-d;
else{
d2=b.head->d+10-d;
p>
pedir prestado=1;
}
mientras(b.head!=0){
si(result.head==0) {
resultado.head=(Dígito *)malloc(sizeof(Dígito));
resultado.head->next=0;
resultado.head ->anterior=0;
resultado.head->d=d2;
p=result.head;
}
else{
p->siguiente=(Dígito *)malloc(tamañode(Dígito));
p->siguiente->anterior=p;
p=p->siguiente;
p->siguiente=0;
if(b.head->d>=borrow){
p- >d=b.head->d-borrow;
prestamo=0;
}
else{
p-> d=b.head->d+10-pedir prestado;
pedir prestado=1;
}
}
b.head =b.head->siguiente;
}
if(p->d==0&&p!=result.head){
resultado.tail= p->anterior;
resultado.tail->siguiente=0;
gratis(p);
}
más resultado .tail=p;
devolver resultado;
}
BigInt multiplicar(BigInt b1,BigInt b2){
resultado BigInt, temp1,temp2={0,0},temp3,b;
result.head=(Digit *)malloc(sizeof(Digit));
result.head->anterior =0;
resultado.head->next=0;
resultado.tail=result.head;
resultado.head->d=0;
char d1,d2,carry;
Dígito *p;
b=copiar(b1);
hacer{
temp1=b;
d1=b2.head->d;
b2.head=b2.head->siguiente;
llevar=0;
while(temp1.head!=0){
if(temp2.head==0){
temp2.head=( Dígito *)malloc(sizeof(Dígito));
temp2.head->next=0;
temp2.head->anterior=0;
p=temp2.cabeza;<
/p>
}
else{
p->next=(Dígito *)malloc(tamañode(Dígito));
p-> siguiente->anterior=p;
p=p->siguiente;
p->siguiente=0;
}
d2=temp1.head->d*d1+carry;
if(d2>=10){
carry=d2/10;
d2= d2%10;
}
else carry=0;
p->d=d2;
temp1.head=temp1 .head->siguiente;
}
if(carry>0){
p->siguiente=(Dígito *)malloc(sizeof(Dígito) );
p->siguiente->anterior=p;
p=p->siguiente;
p->siguiente=0;
p->d=carry;
}
temp3=resultado;
temp2.tail=p;
resultado=add(temp3,temp2);
memoria_libre(&temp2);
memoria_libre(&temp3);
Dígito *d2=(Dígito *)malloc( sizeof(Dígito));
d2->anterior=0;
d2->siguiente=b.head;
b.head->anterior= d2;
d2->d=0;
b.head=d2;
}mientras(b2.head!=0);
free_memory(&b);
devolver resultado;
}
factorial BigInt(BigInt b){
resultado BigInt ,temp1,temp2=copiar(b);
resultado.head=(Dígito *)malloc(tamañode(Dígito));
resultado.head->anterior=0;
resultado.head->next=0;
resultado.tail=result.head;
resultado.head->d=1;
while(temp2.tail->d!=0){
temp1=resultado;
resultado=multiplicar(temp1,temp2);
free_memory(&temp1);
temp1=temp2;
temp2=sustra(temp1,1);
free_memory(&temp1);
}
memoria_libre(&temp2);
p> devolver resultado;
}
int main(){
BigInt b={0,0};
Dígito * p;
char c;
int i;
c=getchar();
while(c!='\n '){
if(!isdigit(c)){
printf("Entrada no válida.\n");
devuelve 1;
}
if(b.tail==0){
b.tail=(Dígito *)malloc(sizeof(Dígito));
b.tail->siguiente=0;
b.tail->anterior=0;
p=b.tail;
}
else{
p->anterior=(Dígito *)malloc(tamañode(Dígito));
p->anterior->siguiente=p;
p=p->anterior;
p->anterior=0;
}
i=c-'0';
p->d=(char)i;
c=getchar();
}
b.head=p;
BigInt r=factorial(b);
display(r);
memoria_libre(&r);
memoria_libre(&b) ;
devuelve 0;
}