ayuda para ordenar fechas de nacimiento en c

[novatita19]

Ola espero que me puedan ayudar plis lo que pasa es que necesito hacer un programa en c , que sea asi

en dos arreglos x e y ingresar fechas con el siguiente formato [15][07][1980]

1° llenar X e Y
2° ordenar cada uno de los arreglos con las fechas de menor a mayor año
3° por ultimo mezclar los dos arreglos ordenando todas las fechas por orden de menor a mayor año


espero me puedan a yudar plisss !!!!!

[vnvnation]

Hola, primero hasta que cantidad de fechas vas a ingresar, por que tu arreglo puede tener "X" cantidad de datos. y no sabras hasta donde terminar de ingresar en tu arreglo x y y.

[novatita19]

Me tiene que preguntar cuantas fechas voy a ingresar en cada arreglo, osea n, espero me ayudes

[novatita19]

Iniciado por vnvnation

Hola, primero hasta que cantidad de fechas vas a ingresar, por que tu arreglo puede tener "X" cantidad de datos. y no sabras hasta donde terminar de ingresar en tu arreglo x y y.

Me tiene que preguntar cuantas fechas voy a ingresar en cada arreglo, osea n, espero me ayudes

[vnvnation]

Aver si entendi implemente algo sencillo nada mas para que te diga el Num de fechas que vas a ingresar y despues introduces las fechas en tu arreglo X,no complemente por que no tengo una idea clara de como tu lo estes haciendo

Código C++:

#include <iostream.h>
#include <conio.h>
 
main ()
{
 char X[999999],Y[100],j;
 int i=0;
 
cout<<"Cuantas fechas quiere ingresar:";
cin>> i;
fflush( stdin );
for(j=1;j<=i;j++)
 
{
cout<<"Ingrese una fecha: ";
gets(X);
}
getch ();
}
 

[sam90]

Yo pensaria como porder representar una fecha. Si utilizas C haria una estructura:

struct fecha
{
int dia,mes,anio;
}

Si estas en c++ lo podrias hacer con objetos, que va a ser mucho mas comodo.

Luego haria una funcion que compare una fecha con otra, y diga cual es la menor. Esto simplemente comparas cual tiene el año mas chico, sino sigues con el mes, y si coiciden comparas los dias.

Por ultimo tienes un monton de algoritmo de ordenamientos. Con tu funcion que los comparas no deberia ser dificil!!!

[Trovaz]

Bueno pues me agarraste de buenas y me puse a resolver este problemita, aqui tienes el como lo hize, ESTUDIA el codigo y si tienes dudas hasmelas saber.

Código c:

#include <stdio.h>
#include <string.h>
#include <strings.h>
#include <stdlib.h>
 
#define COLS 20
 
int comparaFechas(char *fecha1, char *fecha2);
int ordenaArreglo(char (*fechas)[COLS], int limite);
 
int main(){
    char (*FechasX)[COLS];
    char (*FechasY)[COLS];
    char (*FechasXY)[COLS];
    int contador, contador2, pos;
    int elementosX = 0, elementosY = 0;
    int elementosXY = 0;
 
    printf("Elementos X: ");
    scanf("%i", &elementosX);
    while(getchar() != '\n');
 
    printf("Elementos Y: ");
    scanf("%i", &elementosY);
    while(getchar() != '\n');
 
    FechasX = malloc(elementosX * COLS * sizeof(char));
    FechasY = malloc(elementosY * COLS * sizeof(char));
    FechasXY = malloc((elementosX + elementosY) * COLS * sizeof(char));
 
    printf("===============================\n");
    printf("Digita las fechas del arreglo X\n");
    printf("===============================\n");
    for(contador = 0; contador < elementosX; contador++){
        bzero(FechasX[contador], sizeof(FechasX[contador]));
        printf("FechasX[%i]: ", contador);
        scanf("%s", FechasX[contador]);
        while(getchar() != '\n');
    }
 
    printf("===============================\n");
    printf("Digita las fechas del arreglo Y\n");
    printf("===============================\n");
    for(contador = 0; contador < elementosY; contador++){
        bzero(FechasY[contador], sizeof(FechasY[contador]));
        printf("FechasY[%i]: ", contador);
        scanf("%s", FechasY[contador]);
        while(getchar() != '\n');
    }
 
    printf("===============================\n");
    printf("Ordenando X\n");
    printf("===============================\n");
    ordenaArreglo(FechasX, elementosX);
    printf("===============================\n");
    printf("Ordenando Y\n");
    printf("===============================\n");
    ordenaArreglo(FechasY, elementosY);
 
    printf("===============================\n");
    printf("Mostrando Elementos Ordenados X\n");
    printf("===============================\n");
    for(contador = 0; contador < elementosX; contador++){
        printf("FechasX[%i]: %s\n", contador, FechasX[contador]);
    }
 
    printf("===============================\n");
    printf("Mostrando Elementos Ordenados Y\n");
    printf("===============================\n");
    for(contador = 0; contador < elementosY; contador++){
        printf("FechasY[%i]: %s\n", contador, FechasY[contador]);
    }
 
    elementosXY = elementosX + elementosY;
 
    contador = 0;
    contador2 = 0;
    pos = 0;
    while(pos < elementosXY){
        if(contador < elementosX && contador2 < elementosY){
            if(comparaFechas(FechasX[contador], FechasY[contador2]) <= 0){
                bzero((char *)&FechasXY[pos], sizeof(FechasXY[pos]));
                strcpy(FechasXY[pos++], FechasX[contador++]);
            }
            else{
                bzero((char *)&FechasXY[pos], sizeof(FechasXY[pos]));
                strcpy(FechasXY[pos++], FechasY[contador2++]);
            }
        }
        if(contador == elementosX){
            bzero((char *)&FechasXY[pos], sizeof(FechasXY[pos]));
            strcpy(FechasXY[pos++], FechasY[contador2++]);
        }
        if(contador2 == elementosY){
            bzero((char *)&FechasXY[pos], sizeof(FechasXY[pos]));
            strcpy(FechasXY[pos++], FechasX[contador++]);
        }
    }
 
    printf("=======================================\n");
    printf("Mostrando Todos loe Elementos ordenados\n");
    printf("=======================================\n");
    for(contador = 0; contador < elementosXY; contador++){
        printf("FechasXY[%i]: %s\n", contador, FechasXY[contador]);
    }
 
    free(FechasX);
    free(FechasY);
    free(FechasXY);
    return 0;
}
 
int comparaFechas(char *fecha1, char *fecha2){
    int anio1 = 0, anio2 = 0;
    int mes1 = 0, mes2 = 0;
    int dia1 = 0, dia2 = 0;
    sscanf(fecha1, "[%d][%d][%d]", &dia1, &mes1, &anio1);
    sscanf(fecha2, "[%d][%d][%d]", &dia2, &mes2, &anio2);
    if(anio1 == anio2)
        if(mes1 == mes2)
            return dia1 - dia2;
        else
            return mes1 - mes2;
    else
        return anio1 - anio2;
 
    return 0;
}
 
int ordenaArreglo(char (*fechas)[COLS], int limite){
    char temp[COLS];
    char temp2[COLS];
    int contador, pibote;
    for(pibote = 0; pibote < (limite - 1); pibote++){
        for(contador = pibote; contador < (limite - 1); contador++){
            if(comparaFechas(fechas[contador], fechas[contador + 1]) > 0){
                bzero((char *)&temp, sizeof(temp));
                bzero((char *)&temp2, sizeof(temp2));
                strcpy(temp, fechas[contador]);
                strcpy(temp2, fechas[contador + 1]);
                strcpy(fechas[contador + 1], temp);
                strcpy(fechas[contador], temp2);
            }
        }
    }
 
    return 0;
}
 

Mi salida

Código:

Elementos X: 2
Elementos Y: 2
===============================
Digita las fechas del arreglo X
===============================
FechasX[0]: [16][9][2000]
FechasX[1]: [15][9][2000]
===============================
Digita las fechas del arreglo Y
===============================
FechasY[0]: [13][9][2000]
FechasY[1]: [11][9][2000]
===============================
Ordenando X
===============================
===============================
Ordenando Y
===============================
===============================
Mostrando Elementos Ordenados X
===============================
FechasX[0]: [15][9][2000]
FechasX[1]: [16][9][2000]
===============================
Mostrando Elementos Ordenados Y
===============================
FechasY[0]: [11][9][2000]
FechasY[1]: [13][9][2000]
=======================================
Mostrando Todos loe Elementos ordenados
=======================================
FechasXY[0]: [11][9][2000]
FechasXY[1]: [13][9][2000]
FechasXY[2]: [15][9][2000]
FechasXY[3]: [16][9][2000]