int main(){
//carregamento das informacoes
int tam1;
scanf("%d", &tam1);
int * vetor1 = carregar_vetor(tam1);
int tam2;
scanf("%d", &tam2);
int * vetor2 = carregar_vetor(tam2);
//algoritmo
int iguais = 1;
int i = 0;
for(i = 0; i < tam1; i++){
int x = vetor1[i];
if (contar(x, vetor1, tam1) != contar(x, vetor2, tam2)) {
iguais = 0;
break;
}
}
if (iguais)
printf("sim\n");
else
printf("nao\n");
return 0;
}
/**
*
* funcion que cuenta el numero de nodos de un arbol
*
**/
int contar(Arbol *a)
{
if(a != NULL)
return contar(a->izq) + contar(a->der) + 1;
else
return 0;
}
/**
*
* Funcion que llama a un funcion de C++, que evalua el arbol y le retorna el
* fitness de este
*
**/
void conexion(Arbol *a, bool grafica)
{
void *manejador;
double (*vcp)(Arbol *, int, int, int);
char *error;
manejador = dlopen ("./include/libvcp.so", RTLD_LAZY);
if(!manejador)
{
printf("No se pudo leer la libreria libvcp.so\n");
exit(1);
}
*(double**)(&vcp) = dlsym(manejador, "fitness");
if((error = dlerror()) != NULL)
{
printf("No se pudo leer la funcion fitness\n");
exit(1);
}
altura = alturaMaxima(a);
num_nodos = contar(a);
aptitud = (*vcp)(a, grafica, altura, num_nodos);
dlclose(manejador);
}
int main()
{
Lista L;
int e, x;
L = NULL;
printf("INGRESE DATO : ");
scanf("%d",&e);
while(e != 0)
{
agregar(&L, e);
printf("INGRESE DATO : ");
scanf("%d",&e);
}
listar(L);
x = contar(L);
printf("Cantidad de nodos es %d\n",x);
x = contarImpares(L);
printf("Cantidad de nodos impares es %d\n",x);
printf("el ultimo es %d\n",ultimo(L));
printf("INGRESE DATO a BUSCAR : ");
scanf("%d",&e);
printf("El dato %d esta? (1:SI / 0: NO) %d\n",e,buscar(L,e));
}
int main()
{
int x, y;
printf("Ingrese valor ");
scanf("%d",&x);
printf("Digitos %d\n",contar(x));
contardig(x, &y);
printf("Digitos %d\n",y);
}
int main(){
int t;
unsigned long long n;
scanf("%d",&t);
while(t--){
scanf("%llu",&n);
printf("%llu\n",contar(n));
}
return 0;
}
int main( )
{ int n;
printf("Ingrese numero ");
scanf("%d",&n);
printf("La cantidad de digitos es %d\n",contar(n));
printf("El invertido es %d\n",invertir(n));
printf("Primer digito : %d\n",primerDig(n));
system("pause");
}
int main(void)
{
int contador=0;
while (contador<100)
{
contar();
contador++;
}
system("pause");
return(0);
}
void main(void) {
char cadena[MAXTAM];
introduce(cadena);
inic(cadena);
fin(cadena);
inter(cadena);
puts(cadena);
printf("\nLA CADENA TIENE %d PALABRAS", contar(cadena));
}
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// proceso principal del juego que recibe el tablero, y las direcciones en las que indica el jugador la fila y la columna y la se?al de ready que indica que se han actualizado fila y columna
void reversi6(char tablero[][TAM_TABLERO]) // en esta versi?n el usuario lleva negras y el ordenador blancas
{ // no se comprueba que el jugador mueva bien. S?lo que el ordenador realice un movimiento correcto.
int done; // nos indica si se ha conseguido mover
int move = 0; //indica que el jugador ha movido;
tiempo = 0; // inicializa el valor del tiempo transcurrido a 0
display_tiempo(); // mostrar mensaje de tiempo
display_actualizar_tiempo(tiempo); // mostrar el valor del tiempo
display_mensaje_ayuda(); // mostrar mensaje de ayuda
int fin = 0;// fin se pone a 1 si el jugador no ha podido mover (ha introducido un valor de movimiento con alg?n 6) y luego el ordenador tampoco puede.
int blancas = 2, negras = 2; // se usan para contar el n?mero de fichas de cada color.
char f,c; // fila y columna elegidas por el programa para su movimiento
init_table(tablero);
actualizar_lcd(tablero, blancas, negras);
timer4_init(); // comienza el contador de tiempo transcurrido
while (fin == 0) {
move = 0;
esperar_mov();
if (((fila) != TAM_TABLERO) && ((columna) != TAM_TABLERO)) { // si la fila o columna son 8 asumimos que el jugador no puede mover
tablero[fila][columna] = 2;
actualizar_tablero(fila, columna, 2, tablero);
contar(&blancas, &negras, tablero);
actualizar_lcd(tablero, blancas, negras);
actualizar_candidatos(fila, columna);
move = 1;
}
done = elegir_mov(&f, &c, tabla_valor, tablero); //escribe el movimiento en las variables globales fila columna
if (done == -1 && move == 0){
fin = 1;
}
else {
tablero[f][c] = 1;
actualizar_tablero(f, c, 1, tablero);
contar(&blancas, &negras, tablero);
actualizar_lcd(tablero, blancas, negras);
actualizar_candidatos(f, c);
}
}
timer4_stop(); // parar reloj del tiempo transcurrido
display_final(blancas,negras); // mostrar resultado final
}
int main()
{
Lista L;
int i;
L = NULL;
for(i=1; i<=4; i++)
agregarUltimo(&L, i);
imprimir(L);
printf("La cantidad de nodos es %d\n",contar(L));
convertir(L);
imprimirLLS(L);
}
int main()
{
int i, n, c, s, a;
printf("Ingrese n:\n");
scanf("%d",&n);
c = contar(n);
printf("Cantidad de digitos es %d\n",c);
printf("ingrese dijito:\n");
scanf("%d", &n);
i = digito(n);
printf("Cantidad dijitos en forma xD es %d\n", i);
system("pause");
}
int main()
{
int lon, i;
char *palabra, *aux, *evaluadas;
int *guarda;
i = 0;
printf("Máximo de caracteres\n");
scanf("%d", &lon);
palabra = (char*)malloc(sizeof(char)*lon);
evaluadas = (char*)malloc(sizeof(char)*lon);
printf("Dame una palabra \n");
scanf("\n%[^\n]", palabra);
for(aux = palabra; aux > palabra; --aux)
{
if(aux != (evaluadas+i))
{
*(evaluadas+i) = aux;
*(guarda+i) = contar(palabra, aux, lon);
i++;
}
}
ordenamela(palabra, asc, lon);
for(aux = palabra; aux > palabra; --aux)
printf("La letra %s, se repite %d veces\n", aux, guarda);
free(palabra);
free(guarda);
return 0;
}
int main(){
struct no *inicio, *p;// Ponteiros para tipos struct no
int i, opcao, elemento;
// Inicializando o ponteiro com o valor NULL
inicio = NULL;
//
do {
system("cls");
printf("==================================================================\n");
printf(" \t\tESCOLHA A OPCAO:");
printf("\n==================================================================");
printf("\n\n 1 - Adicionar elemento");
printf("\n------------------------------------------------------------------");
printf("\n 2 - Mostrar elementos");
printf("\n------------------------------------------------------------------");
printf("\n 3 - Liberar memoria");
printf("\n------------------------------------------------------------------");
printf("\n 4 - Mostrar a quantidade de elementos");
printf("\n------------------------------------------------------------------");
printf("\n 5 - Mostrar a media");
printf("\n------------------------------------------------------------------");
printf("\n 6 - Adicionar elemento no final");
printf("\n------------------------------------------------------------------");
printf("\n 7 - Buscar Elemento");
printf("\n------------------------------------------------------------------");
printf("\n 8 - Apagar Elemento");
printf("\n------------------------------------------------------------------");
printf("\n 9 - Apagar o Ultimo Elemento");
printf("\n------------------------------------------------------------------");
printf("\n 10 - Apagar o Primeiro Elemento");
printf("\n------------------------------------------------------------------");
printf("\n 11 - Inserir Elemento no meio");
printf("\n------------------------------------------------------------------");
printf("\n 0 - Sair \n\n -> ");
scanf("%d", &opcao);
//
switch (opcao){
case 0:
printf("\n O programa sera encerrado");
break;
case 1:
printf("Entre com o elemento\n");
scanf("%d", &elemento);
inserir_inicio(&inicio, elemento);
break;
case 2:
mostra(inicio);
break;
case 3:
liberaMemoria(&inicio);
break;
case 4:
printf(" %d elementos", contar(inicio));
getch();
break;
case 5:
printf(" Media: %.f", media(inicio));
getch();
break;
case 6:
printf("Entre com o elemento\n");
scanf("%d", &elemento);
inserirNoFinal(&inicio, elemento);
printf("\t Inserido \n");
getch();
break;
case 7:
printf("Entre com o elemento\n");
scanf("%d", &elemento);
printf(" %d", buscar(inicio, elemento));
getch();
break;
case 8:
printf("Entre com o elemento\n");
scanf("%d", &elemento);
apagarElemento(&inicio, elemento);
getch();
break;
case 9:
if (inicio == NULL) {
printf("\n A lista esta vazia");
}
else {
printf("Elemento lemento %d removido.\n", removeUltimo(&inicio));
}
getch();
break;
case 10:
if (inicio == NULL) {
printf("\n A lista esta vazia");
}
else {
printf("Elemento lemento %d removido.\n", removePrimeiro(&inicio));
}
getch();
break;
case 11:
printf("Entre com o elemento\n");
scanf("%d", &elemento);
inserirNoMeio(&inicio, elemento);
printf("\t Inserido \n");
getch();
break;
default:
printf("\n\n Opcao invalida!!");
getch();
break;
}
}
while(opcao != 0);
printf("\n");
getch();
return 0;
}
int main(){
int i;
PILHA_DINAMICA pilha;
for (i = 0; i < 5; i++){
ITEM item;
item.valor = i;
if (empilhar(&pilha, &item)){
printf("Entrou na pilha: %d", item.valor);
}
else {
printf("%d: Erro na alocação.\n", item.valor);
}
}
printf("\nPilha atual: ");
imprime(&pilha);
printf("\n");
printf("Tamanho: %d\n--\n", contar(&pilha));
ITEM item1;
item1.valor = 100;
if (empilhar(&pilha, &item1)){
printf("Entrou na pilha: %d", item.valor);
}
else {
printf("%d: Erro na alocação.\n", item.valor);
}
printf("\nPilha atual: ");
imprime(&pilha);
printf("\n");
printf("Tamanho: %d\n--\n", contar(&pilha));
frente(&pilha, &item1);
printf("Elemento do topo: %d\n--\n, item1.valor");
if (desempilhar(&pilha, &item1)){
printf("Saiu na pilha: %d", item.valor);
}
else {
printf("Pilha vazia.\n", item1.valor);
}
item1.valor = 9;
if (empilhar(&pilha, &item1)){
printf("Entrou na pilha: %d", item.valor);
}
else {
printf("%d: Erro na alocação.\n", item.valor);
}
printf("\nPilha atual: ");
imprime(&pilha);
printf("\n");
printf("Tamanho: %d\n--\n", contar(&pilha));
return 0;
}
void evaluar()
{
double nota =0;
NodoTrinario* nt1=new NodoTrinario(1);
NodoTrinario* nt2=new NodoTrinario(2);
NodoTrinario* nt3=new NodoTrinario(3);
NodoTrinario* nt4=new NodoTrinario(4);
NodoTrinario* nt5=new NodoTrinario(5);
NodoTrinario* nt6=new NodoTrinario(6);
NodoTrinario* nt7=new NodoTrinario(7);
NodoTrinario* nt8=new NodoTrinario(8);
NodoTrinario* nt9=new NodoTrinario(9);
nt1->izq = nt2;
nt1->medio = nt3;
nt1->der = nt4;
nt2->izq = nt5;
nt2->medio = nt6;
nt6->izq = nt7;
nt3->izq = nt8;
nt3->medio = nt9;
cout<<"existe() - trinario:\t";
if(!existe(nt1,10) && !existe(nt1,12) && !existe(nt2,1) && existe(nt1,1) && existe(nt1,5) && existe(nt6,7))
{
cout<<"Correcto"<<endl;
nota+=2.5;
}else
{
cout<<"Incorrecto"<<endl;
}
NodoNario* n1=new NodoNario(1);
NodoNario* n2=new NodoNario(2);
NodoNario* n3=new NodoNario(3);
NodoNario* n4=new NodoNario(4);
NodoNario* n5=new NodoNario(5);
NodoNario* n6=new NodoNario(1);
NodoNario* n7=new NodoNario(1);
NodoNario* n8=new NodoNario(2);
n1->hijos.push_back(n2);
n1->hijos.push_back(n3);
n2->hijos.push_back(n4);
n4->hijos.push_back(n5);
n5->hijos.push_back(n6);
n5->hijos.push_back(n7);
n5->hijos.push_back(n8);
cout<<"existe() - nario:\t";
if(!existe(n1,10) && !existe(n1,12) && !existe(n8,1) && existe(n1,1) && existe(n1,5) && existe(n5,2))
{
cout<<"Correcto"<<endl;
nota+=2.5;
}else
{
cout<<"Incorrecto"<<endl;
}
NodoBinario* nb1=new NodoBinario(1);
NodoBinario* nb2=new NodoBinario(2);
NodoBinario* nb3=new NodoBinario(3);
NodoBinario* nb4=new NodoBinario(4);
NodoBinario* nb5=new NodoBinario(5);
NodoBinario* nb6=new NodoBinario(1);
NodoBinario* nb7=new NodoBinario(2);
NodoBinario* nb8=new NodoBinario(1);
nb1->izq=nb2;
nb1->der=nb3;
nb3->der=nb4;
nb4->izq=nb5;
nb5->izq=nb6;
nb2->izq=nb7;
nb2->der=nb8;
cout<<"contar():\t\t";
if(contar(nb1,1)==3 && contar(nb1,2)==2 && contar(nb1,3)==1 && contar(nb1,50)==0 && contar(nb7,1)==0)
{
cout<<"Correcto"<<endl;
nota+=5;
}else
{
cout<<"Incorrecto"<<endl;
}
int arr[5][5]= {{0,1,1,0,0},
{0,1,0,0,0},
{0,1,1,0,1},
{0,1,2,0,1},
{0,0,0,1,1}};
cout<<"puedoLLegar():\t\t";
if(!puedoLLegar(arr,0,0,2,1,11)
&& puedoLLegar(arr,0,0,2,1,12))
{
cout<<"Correcto"<<endl;
nota+=5;
}else
{
cout<<"Incorrecto"<<endl;
}
cout<<endl<<"Nota: "<<nota<<"/15"<<endl;
}
int main (int argc, char** argv)
{
//Abrir el archivo
FILE* file;
file = fopen(argv[1], "r");
//Si no hay argumentos salir del programa.
if(argc<2){
printf("No se recibe el archivo.\n");
exit(496);
}
if(!(file=fopen(argv[1], "r"))){
printf("Problema abriendo el archivo %s\n", argv[1]);
exit(1);
}
//Declaración de arreglos de condiciones iniciales.
double *id_array;
double *x0_array;
double *y0_array;
double *vx0_array;
double *vy0_array;
double *masa_central1;
double *masa_central2;
//Declaración de números usados durante el programa.
int i,j,k, N, np, nc, id;
double h;
h = 0.001;//Paso
N = 5;//Límite de la iteracion.
np = (int)(N+h)/h;
nc=contar(argv[1]);//Número de lineas del archivo.
//reserva de memoria para arreglos.
id_array = malloc(nc * sizeof(double));
x0_array = malloc(nc * sizeof(double));
y0_array = malloc(nc * sizeof(double));
vx0_array = malloc(nc * sizeof(double));
vy0_array = malloc(nc * sizeof(double));
masa_central1 = malloc(5 * sizeof(double));
masa_central1 = malloc(5 * sizeof(double));
double k1xM1 =0;
double k1yM1 =0;
double l1xM1 =0;
double l1yM1 =0;
double k2xM1 =0;
double k2yM1 =0;
double l2xM1 =0;
double l2yM1 =0;
double k3xM1 =0;
double k3yM1 =0;
double l3xM1 =0;
double l3yM1 =0;
double k4xM1 =0;
double k4yM1 =0;
double l4xM1 =0;
double l4yM1 =0;
double avgkxM1=0;
double avgkyM1=0;
double avglxM1=0;
double avglyM1=0;
double k1xM2 =0;
double k1yM2 =0;
double l1xM2 =0;
double l1yM2 =0;
double k2xM2 =0;
double k2yM2 =0;
double l2xM2 =0;
double l2yM2 =0;
double k3xM2 =0;
double k3yM2 =0;
double l3xM2 =0;
double l3yM2 =0;
double k4xM2 =0;
double k4yM2 =0;
double l4xM2 =0;
double l4yM2 =0;
double avgkxM2=0;
double avgkyM2=0;
double avglxM2=0;
double avglyM2=0;
double k1x =0;
double k1y =0;
double l1x =0;
double l1y =0;
double k2x =0;
double k2y =0;
double l2x =0;
double l2y =0;
double k3x =0;
double k3y =0;
double l3x =0;
double l3y =0;
double k4x =0;
double k4y =0;
double l4x =0;
double l4y =0;
double avgkx =0;
double avgky =0;
double avglx =0;
double avgly =0;
//Lectura del archivo de condiciones iniciales. Llenado de arreglos de posiciones y velocidades.
for(i=0; i<nc; i++){
fscanf(file, "%lf %lf %lf %lf %lf\n", &id_array[i], &x0_array[i], &y0_array[i], &vx0_array[i], &vy0_array[i]);
}
printf("LEYENDO EL ARCHIVO...\n");
fclose(file);
//Llenar arreglos con las condiciones de las masas centrales.
for(i=0; i<nc; i++){
if(id_array[i]<0){
//Para las masa central 1.
if(id_array[i]==-1){
k=i;
masa_central1[0]=id_array[k];
masa_central1[1]=x0_array[k];
masa_central1[2]=y0_array[k];
masa_central1[3]=vx0_array[k];
masa_central1[4]=vy0_array[k];
}
}
}
printf("ARCHIVO LEIDO CON EXITO...\n");
//Arreglos usados durante el RK4.
double *x;
double *y;
double *vx;
double *vy;
double *t;
double *xsol1;
double *ysol1;
double *xsol2;
double *ysol2;
double *xsol3;
double *ysol3;
double *xsol4;
double *ysol4;
double *xsol5;
double *ysol5;
//Reserva de memoria para arreglos.
x=(double *) malloc(nc*sizeof(double*));
y=(double *) malloc(nc*sizeof(double*));
vx=(double *) malloc(nc*sizeof(double*));
vy=(double *) malloc(nc*sizeof(double*));
xsol1=(double *) malloc(nc*sizeof(double*));
ysol1=(double *) malloc(nc*sizeof(double*));
xsol2=(double *) malloc(nc*sizeof(double*));
ysol2=(double *) malloc(nc*sizeof(double*));
xsol3=(double *) malloc(nc*sizeof(double*));
ysol3=(double *) malloc(nc*sizeof(double*));
xsol4=(double *) malloc(nc*sizeof(double*));
ysol4=(double *) malloc(nc*sizeof(double*));
xsol5=(double *) malloc(nc*sizeof(double*));
ysol5=(double *) malloc(nc*sizeof(double*));
//Reserva de memoria para el arreglo de tiempos.
t = malloc(np * sizeof(double));
//Condición inicial del tiempo.
t[0]=0;
id=0;
//Llenar los arreglos con las condiciones iniciales de la i-ésima masa.
for(i=0; i<nc;i++){
x[i]=x0_array[i];
y[i]=y0_array[i];
vx[i]=vx0_array[i];
vy[i]=vy0_array[i];
}
printf("INICIANDO LA RUTINA RK4...\n");
//CHECKPOINT!
if(nc==121){
for(j=1; j<np; j++){
for(i=0; i<nc; i++){
id=1;
//Primer paso.
double k1x = x_punto(t[j-1],vx[i]);
double k1y = y_punto(t[j-1],vy[i]);
double l1x = v_x_punto1(t[j-1],x[i],y[i],masa_central1[1],masa_central1[2]);
double l1y = v_y_punto1(t[j-1],x[i],y[i],masa_central1[1],masa_central1[2]);
double t1 = t[j-1] + (h/2.0);
double x1=x[i] + (h/2.0)*k1x;
double y1=y[i] + (h/2.0)*k1y;
double vx1=vx[i] + (h/2.0)*l1x;
double vy1=vy[i] + (h/2.0)*l1y;
//Segundo paso.
double k2x = x_punto(t1,vx1);
double k2y = y_punto(t1,vy1);
double l2x = v_x_punto1(t1,x1,y1,masa_central1[1],masa_central1[2]);
double l2y = v_y_punto1(t1,x1,y1,masa_central1[1],masa_central1[2]);
double t2 = t[j-1] + (h/2.0);
double x2=x[i] + (h/2.0)*k2x;
double y2=y[i] + (h/2.0)*k2y;
double vx2=vx[i] + (h/2.0)*l2x;
double vy2=vy[i] + (h/2.0)*l2y;
//Tercer paso.
double k3x = x_punto(t2,vx2);
double k3y = y_punto(t2,vy2);
double l3x = v_x_punto1(t2,x2,y2,masa_central1[1],masa_central1[2]);
double l3y = v_y_punto1(t2,x2,y2,masa_central1[1],masa_central1[2]);
double t3 = t[j-1] + h;
double x3=x[i] + h*k3x;
double y3=y[i] + h*k3y;
double vx3=vx[i] + h*l3x;
double vy3=vy[i] + h*l3y;
//Cuarto paso.
double k4x = x_punto(t3,vx3);
double k4y = y_punto(t3,vy3);
double l4x = v_x_punto1(t3,x3,y3,masa_central1[1],masa_central1[2]);
double l4y = v_y_punto1(t3,x3,y3,masa_central1[1],masa_central1[2]);
double avgkx = (k1x + 2.0*k2x + 2*k3x + k4x)/6.0;
double avgky = (k1y + 2.0*k2y + 2*k3y + k4y)/6.0;
double avglx = (l1x + 2.0*l2x + 2*l3x + l4x)/6.0;
double avgly = (l1y + 2.0*l2y + 2*l3y + l4y)/6.0;
//Actualizar las i-ésima masa al j-ésimo intervalo de tiempo.
t[j] = t[j-1] + h;
x[i] = x[i] + h*avgkx;
vx[i] = vx[i] + h*avglx;
y[i] = y[i] + h*avgky;
vy[i] = vy[i] + h*avgly;
if (j==1000){
xsol1[i]=x[i];
ysol1[i]=y[i];
}else if (j==2000) {
xsol2[i]=x[i];
ysol2[i]=y[i];
}else if (j==3000) {
xsol3[i]=x[i];
ysol3[i]=y[i];
}else if (j==4000) {
xsol4[i]=x[i];
ysol4[i]=y[i];
}else if (j==4999) {
xsol5[i]=x[i];
ysol5[i]=y[i];
}
}
}
}
else if(nc==242){
for(j=1; j<np; j++){
for(i=0; i<nc; i++){
int pm1 = 0;
int pm2 = 121;
id=2;
//EVOLUCIONA LA MASA CENTRAL DE LA PRIMERA GALAXIA.
if(i==pm1)
{
//Primer paso.
k1xM1 = x_punto(t[j-1],vx[pm1]);
k1yM1 = y_punto(t[j-1],vy[pm1]);
l1xM1 = v_x_puntoMG1(t[j-1],x[pm1],y[pm1],x[pm2],y[pm2]);
l1yM1 = v_y_puntoMG1(t[j-1],x[pm1],y[pm1],x[pm2],y[pm2]);
double t1M1 = t[j-1] + (h/2.0);
double x1M1 = x[pm1] + (h/2.0)*k1xM1;
double y1M1 = y[pm1] + (h/2.0)*k1yM1;
double vx1M1 = vx[pm1] + (h/2.0)*l1xM1;
double vy1M1 = vy[pm1] + (h/2.0)*l1yM1;
//Segundo paso.
k2xM1 = x_punto(t1M1,vx1M1);
k2yM1 = y_punto(t1M1,vy1M1);
l2xM1 = v_x_puntoMG1(t1M1,x1M1,y1M1,x[pm2],y[pm2]);
l2yM1 = v_y_puntoMG1(t1M1,x1M1,y1M1,x[pm2],y[pm2]);
double t2M1 = t[j-1] + (h/2.0);
double x2M1 = x[pm1] + (h/2.0)*k2xM1;
double y2M1 = y[pm1] + (h/2.0)*k2yM1;
double vx2M1 = vx[pm1] + (h/2.0)*l2xM1;
double vy2M1 = vy[pm1] + (h/2.0)*l2yM1;
//Tercer paso.
k3xM1 = x_punto(t2M1,vx2M1);
k3yM1 = y_punto(t2M1,vy2M1);
l3xM1 = v_x_puntoMG1(t2M1,x2M1,y2M1,x[pm2],y[pm2]);
l3yM1 = v_y_puntoMG1(t2M1,x2M1,y2M1,x[pm2],y[pm2]);
double t3M1 = t[j-1] + h;
double x3M1 = x[pm1] + h*k3xM1;
double y3M1 = y[pm1] + h*k3yM1;
double vx3M1 = vx[pm1] + h*l3xM1;
double vy3M1 = vy[pm1] + h*l3yM1;
//Cuarto paso.
k4xM1 = x_punto(t3M1,vx3M1);
k4yM1 = y_punto(t3M1,vy3M1);
l4xM1 = v_x_puntoMG1(t3M1,x3M1,y3M1,x[pm2],y[pm2]);
l4yM1 = v_y_puntoMG1(t3M1,x3M1,y3M1,x[pm2],y[pm2]);
avgkxM1 = (k1xM1 + 2.0*k2xM1 + 2*k3xM1 + k4xM1)/6.0;
avgkyM1 = (k1yM1 + 2.0*k2yM1 + 2*k3yM1 + k4yM1)/6.0;
avglxM1 = (l1xM1 + 2.0*l2xM1 + 2*l3xM1 + l4xM1)/6.0;
avglyM1 = (l1yM1 + 2.0*l2yM1 + 2*l3yM1 + l4yM1)/6.0;
}
//EVOLUCIONA LA MASA CENTRAL DE LA SEGUNDA GALAXIA.
else if(i==pm2)
{
//Primer paso.
k1xM2 = x_punto(t[j-1],vx[pm2]);
k1yM2 = y_punto(t[j-1],vy[pm2]);
l1xM2 = v_x_puntoMG2(t[j-1],x[pm1],y[pm1],x[pm2],y[pm2]);
l1yM2 = v_x_puntoMG2(t[j-1],x[pm1],y[pm1],x[pm2],y[pm2]);
double t1M2 = t[j-1] + (h/2.0);
double x1M2 = x[pm2] + (h/2.0)*k1xM2;
double y1M2 = y[pm2] + (h/2.0)*k1yM2;
double vx1M2 = vx[pm2] + (h/2.0)*l1xM2;
double vy1M2 = vy[pm2]+ (h/2.0)*l1yM2;
//Segundo paso.
k2xM2 = x_punto(t1M2,vx1M2);
k2yM2 = y_punto(t1M2,vy1M2);
l2xM2 = v_x_puntoMG2(t1M2,x[pm1],y[pm1],x1M2,y1M2);
l2yM2 = v_y_puntoMG2(t1M2,x[pm1],y[pm1],x1M2,y1M2);
double t2M2 = t[j-1] + (h/2.0);
double x2M2 = x[pm2] + (h/2.0)*k2xM2;
double y2M2 = y[pm2] + (h/2.0)*k2yM2;
double vx2M2 = vx[pm2] + (h/2.0)*l2xM2;
double vy2M2 = vy[pm2] + (h/2.0)*l2yM2;
//Tercer paso.
k3xM2 = x_punto(t2M2,vx2M2);
k3yM2 = y_punto(t2M2,vy2M2);
l3xM2 = v_x_puntoMG2(t2M2,x[pm1],y[pm1],x2M2,y2M2);
l3yM2 = v_y_puntoMG2(t2M2,x[pm1],y[pm1],x2M2,y2M2);
double t3M2 = t[j-1] + h;
double x3M2 = x[pm2] + h*k3xM2;
double y3M2 = y[pm2] + h*k3yM2;
double vx3M2 = vx[pm2] + h*l3xM2;
double vy3M2 = vy[pm2] + h*l3yM2;
//Cuarto paso.
k4xM2 = x_punto(t3M2,vx3M2);
k4yM2 = y_punto(t3M2,vy3M2);
l4xM2 = v_x_puntoMG2(t3M2,x[pm1],y[pm1],x3M2,y3M2);
l4yM2 = v_y_puntoMG2(t3M2,x[pm1],y[pm1],x3M2,y3M2);
avgkxM2 = (k1xM2 + 2.0*k2xM2 + 2*k3xM2 + k4xM2)/6.0;
avgkyM2 = (k1yM2 + 2.0*k2yM2 + 2*k3yM2 + k4yM2)/6.0;
avglxM2 = (l1xM2 + 2.0*l2xM2 + 2*l3xM2 + l4xM2)/6.0;
avglyM2 = (l1yM2 + 2.0*l2yM2 + 2*l3yM2 + l4yM2)/6.0;
}
//EVOLUCIONA LA I-ÉSIMA MASA.
else
{
//Primer paso.
k1x = x_punto(t[j-1],vx[i]);
k1y = y_punto(t[j-1],vy[i]);
l1x = v_x_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
l1y = v_y_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
double t1 = t[j-1] + (h/2.0);
double x1=x[i] + (h/2.0)*k1x;
double y1=y[i] + (h/2.0)*k1y;
double vx1=vx[i] + (h/2.0)*l1x;
double vy1=vy[i] + (h/2.0)*l1y;
//Segundo paso.
k2x = x_punto(t1,vx1);
k2y = y_punto(t1,vy1);
l2x = v_x_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
l2y = v_y_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
double t2 = t[j-1] + (h/2.0);
double x2=x[i] + (h/2.0)*k2x;
double y2=y[i] + (h/2.0)*k2y;
double vx2=vx[i]+ (h/2.0)*l2x;
double vy2=vy[i] + (h/2.0)*l2y;
//Tercer paso.
k3x = x_punto(t2,vx2);
k3y = y_punto(t2,vy2);
l3x = v_x_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
l3y = v_y_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
double t3 = t[j-1] + h;
double x3=x[i] + h*k3x;
double y3=y[i] + h*k3y;
double vx3=vx[i] + h*l3x;
double vy3=vy[i] + h*l3y;
//Cuarto paso.
k4x = x_punto(t3,vx3);
k4y = y_punto(t3,vy3);
l4x = v_x_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
l4y = v_y_punto2(t[j-1],x[i],y[i],x[pm1],y[pm1],x[pm2],y[pm2]);
avgkx = (k1x + 2.0*k2x + 2*k3x + k4x)/6.0;
avgky = (k1y + 2.0*k2y + 2*k3y + k4y)/6.0;
avglx = (l1x + 2.0*l2x + 2*l3x + l4x)/6.0;
avgly = (l1y + 2.0*l2y + 2*l3y + l4y)/6.0;
}
if (i==pm1) {
x[pm1] = x[pm1] + h*avgkxM1;
vx[pm1] = vx[pm1] + h*avglxM1;
y[pm1] = y[pm1] + h*avgkyM1;
vy[pm1] = vy[pm1] + h*avglyM1;
}else if (i==pm2) {
x[pm2] = x[pm1] + h*avgkxM2;
vx[pm2] = vx[pm1] + h*avglxM2;
y[pm2] = y[pm1] + h*avgkyM2;
vy[pm2] = vy[pm1] + h*avglyM2;
}else if(i!=pm1 || i!=pm2) {
//Actualizar las i-ésima masa al j-ésimo intervalo de tiempo.
t[j] = t[j-1] + h;
x[i] = x[i] + h*avgkx;
vx[i] = vx[i] + h*avglx;
y[i] = y[i] + h*avgky;
vy[i] = vy[i] + h*avgly;
}
if (j==1000){
xsol1[i]=x[i];
ysol1[i]=y[i];
}else if (j==2000) {
xsol2[i]=x[i];
ysol2[i]=y[i];
}else if (j==3000) {
xsol3[i]=x[i];
ysol3[i]=y[i];
}else if (j==4000) {
xsol4[i]=x[i];
ysol4[i]=y[i];
}else if (j==4999) {
xsol5[i]=x[i];
ysol5[i]=y[i];
}
}
}
}
printf("EXPORTANDO ARCHIVOS...\n");
if(id==1){
//Exportando archivos con datos de posiciones en X y Y para k*10^9 años | k={1,2,3,4,5}.
//10^9
FILE *datos;
char *nombre1 = "1 Galaxia-10^9.dat";
datos = fopen(nombre1, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol1[k], ysol1[k]);
}
fclose(datos);
//2*10^9
char *nombre2 = "1 Galaxia-2*10^9.dat";
datos = fopen(nombre2, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol2[k], ysol2[k]);
}
//3*10^9
fclose(datos);
char *nombre3 = "1 Galaxia-3*10^9.dat";
datos = fopen(nombre3, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol3[k], ysol3[k]);
}
fclose(datos);
//4*10^9
char *nombre4 = "1 Galaxia-4*10^9.dat";
datos = fopen(nombre4, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol4[k], ysol4[k]);
}
fclose(datos);
//5*10^9
char *nombre5 = "1 Galaxia-5*10^9.dat";
datos = fopen(nombre5, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol5[k], ysol5[k]);
}
fclose(datos);
}else if (id==2) {
//Exportando archivos con datos de posiciones en X y Y para k*10^9 años | k={1,2,3,4,5}.
//10^9
FILE *datos;
char *nombre1 = "2 Galaxias-10^9.dat";
datos = fopen(nombre1, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol1[k], ysol1[k]);
}
fclose(datos);
//2*10^9
char *nombre2 = "2 Galaxias-2*10^9.dat";
datos = fopen(nombre2, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol2[k], ysol2[k]);
}
//3*10^9
fclose(datos);
char *nombre3 = "2 Galaxias-3*10^9.dat";
datos = fopen(nombre3, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol3[k], ysol3[k]);
}
fclose(datos);
//4*10^9
char *nombre4 = "2 Galaxias-4*10^9.dat";
datos = fopen(nombre4, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol4[k], ysol4[k]);
}
fclose(datos);
//5*10^9
char *nombre5 = "2 Galaxias-5*10^9.dat";
datos = fopen(nombre5, "w");
for(k=0; k<nc; k++){
fprintf(datos, "%lf %lf %lf\n", id_array[k], xsol5[k], ysol5[k]);
}
fclose(datos);
}
printf("EJECUCIÓN EXITOSA!\n");
return 9812;
}
