Ir ao conteúdo
  • Cadastre-se
GustavoMdancers

C Codigo para comparar datas não funcionando corretamente

Recommended Posts

 

Eu não to conseguindo fazer com que quando a segunda data for maior que a primeira o printf dentro da chave seja impresso

#include<stdio.h>

int main () {

int dia_1, dia_2, mes_1, mes_2, ano_1, ano_2;

printf ("Insira a primeira data: ");
scanf  ("%d %d %d", &dia_1, &mes_1, &ano_1);

printf ("Insira a segunda data: ");
scanf  ("%d %d %d", &dia_2, &mes_2, &ano_2);

if (dia_1 >= dia_2 && mes_1 >= mes_2 && ano_1 >= ano_2 && dia_2 > dia_1 && mes_2 > mes_1 && ano_2 > ano_1)
{

   if (ano_1 == ano_2)
   {
      if (mes_1 == mes_2)
      {
         if (dia_1 == dia_2)
         {
            printf ("As datas são iguais! \n");
         }
         else if (dia_1 > dia_2)
         {
                 printf ("A primeira data é mais recente que a segunda! \n");
         }
         else if (dia_2 > dia_1)
         {
                 printf ("A segunda data é mais recente que a primeira! \n");
         }
      }
      else if (mes_1 > mes_2)
      {
              printf ("A primeira data é mais recente que a segunda! \n");
      }
      else if (mes_2 > mes_1)
      {
              printf ("A segunda data é mais recente que a primeira! \n");
      }
  }
  else if (ano_1 > ano_2)
  {
          printf ("A primeira data é mais recente que a segunda! \n");
  }
  else if (ano_2 > ano_1)
  {
          printf ("A segunda data é mais recente que a primeira! \n");
  }
}

return 0;
            }

 

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

Quer um truque de programador para facilitar DEMAIS essa comparação de datas ? 

 

dia1, mes1, ano1 ... é maior ou menor que dia2, mes2, ano2 ? 

ë tudo inteiro certo ? 

então faz assim

float wdata1 = (ano1 * 10000 + mes1 * 100 + dia1);
float wdata2 = (ano2 * 10000 + mes2 * 100 + dia2); 
/*agora é só comparar, wdata1 com wdata2
Se for igual, datas iguais
se wdata1 for maior que wdata2 então dia1,mes1,ano1 é uma data MAIOR que dia2, mes2, ano2.
*/ 
if (wdata1 == wdata2) { 
     printf("as datas sao iguais\n") ;
} else if (wdata1 > wdata2) {
    printf("a primeira data é mais recente que a segunda\n") ;
 } else {
    printf("a segunda data é mais recente que a primeira\n");
}


Agora me explica que mágica é essa que funciona ? 

Dá uma olhada aqui
https://repl.it/@bokomoko/comparar-datas-inteiras

 

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites
#include<stdio.h>

int main () {

int dia1, dia2, mes1, mes2, ano1, ano2;

printf ("Insira a primeira data: ");
scanf  ("%d %d %d", &dia1, &mes1, &ano1);

printf ("Insira a segunda data: ");
scanf  ("%d %d %d", &dia2, &mes2, &ano2);

float data1 = (ano1 * 1000 + mes1 * 100 + dia1);
float data2 = (ano2 * 1000 + mes2 * 100 + dia2);

if (data1 == data2)
{
   printf ("As datas são iguais! \n");
}
   else if (data1 > data2)
   {
           printf ("A primeira data é mais recente que a segunda! \n");
   }
    else {
          printf ("A segunda data é mais recente que a primeira! \n");
         }

return 0;
            }

Obrigado mesmo colega, as vezes uma coisa é tão simples de ser feita e a gente não pensa. Segue o codigo final !

  • Curtir 1
  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Se multiplicar o mes por qualquer coisa maior que 31 e o ano por qualquer coisa maior que 365 essa forma vai funcionar.

 

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

@vangodp Muito curioso. Consegui reproduzir a situação aqui. Contornei o problema usando long em vez de int/float e resolveu. Só posso creditar esse problema a um erro na rotina de ponto flutuante do compilador C.

 

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá a todos.

 

1#

@GustavoMdancers, em relação ao sua lógica inicial, o programa é que você está comparando as datas de forma equivocada... a referência de "data maior" ou "data menor" é uma cascata, ou seja, vem da "maior" referência para "menor".. como assim? então, inicialmente o que importa é só o ANO. É ele que manda! se empatar, vem o MES, se empatar vem o DIA... se empatar são iguais... sacou? (se fosse seguir a cascata, viria a HORA, se empatar viria os MINUTOS... depois SEGUNDOS, depois DÉCIMOS_DE_SEGUNDOS, depois CENTÉSIMOS_DE_SEGUNDOS, MILÉSIMOS_DE_SEGUNDOS.... etc)

 

Só importa a o nível atual... o que vem depois não faz diferença!

 

Veja:

Em 16/04/2018 às 19:11, GustavoMdancers disse:

if (dia_1 >= dia_2 && mes_1 >= mes_2 && ano_1 >= ano_2 && dia_2 > dia_1 && mes_2 > mes_1 && ano_2 > ano_1)

 

Observação inicial: acho que a sintaxe ficou errada também, no caso precisaria dos parênteses para separar as expressões, ficaria algo assim:

if ((dia_1 >= dia_2) && (mes_1 >= mes_2) && (ano_1 >= ano_2) && (dia_2 > dia_1) && (mes_2 > mes_1) && (ano_2 > ano_1))

 

Então, perceba que você compara o dia, o mês e ano como se tivessem no mesmo nível da cascata... ou seja, como se todos os "níveis" tivessem que ser "maior" ou "menor" ao mesmo tempo... mas não precisa... ex.:

 

30/12/1980 é menor que 20/11/2015. Perceba que o dia e mês não importou... quem decidiu foi o ano... pois ele está no "início da cascata". Entende?

 

"Corrigindo" a sua lógica, ficaria algo assim:

#include<stdio.h>
int main () {
    int dia_1, dia_2, mes_1, mes_2, ano_1, ano_2;
    printf ("Insira a primeira data:\n");
    scanf  ("%d %d %d", &dia_1, &mes_1, &ano_1);
    printf ("Insira a segunda data :\n");
    scanf  ("%d %d %d", &dia_2, &mes_2, &ano_2);
    
    if (ano_1 > ano_2)
        printf("A primeira data é mais recente que a segunda! \n");
    else
        if (ano_2 > ano_1)
            printf("A segunda data é mais recente que a primeira! \n");
        else
            if (mes_1 > mes_2)
                printf("A primeira data é mais recente que a segunda! \n");
            else
                if (mes_2 > mes_1)
                    printf("A segunda data é mais recente que a primeira! \n");
                else
                    if (dia_1 > dia_2)
                        printf("A primeira data é mais recente que a segunda! \n");
                    else
                        if (dia_2 > dia_1)
                            printf("A segunda data é mais recente que a primeira! \n");
                        else
                            printf("As datas são iguais! \n");    
   return 0;
}

 

Uma forma de deixar o código seria assim:

#include<stdio.h>
int main () {
    int dia_1, dia_2, mes_1, mes_2, ano_1, ano_2;
    printf ("Insira a primeira data:\n");
    scanf  ("%d %d %d", &dia_1, &mes_1, &ano_1);
    printf ("Insira a segunda data :\n");
    scanf  ("%d %d %d", &dia_2, &mes_2, &ano_2);
    
    if      (ano_1 > ano_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (ano_2 > ano_1) printf("A segunda data é mais recente que a primeira! \n");
    else if (mes_1 > mes_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (mes_2 > mes_1) printf("A segunda data é mais recente que a primeira! \n");
    else if (dia_1 > dia_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (dia_2 > dia_1) printf("A segunda data é mais recente que a primeira! \n");
    else                    printf("As datas são iguais! \n");    
   return 0;
}

Perceba que não precisou de ifs para "iguais". Pois são condições mutuamente excludentes, ou seja, se for uma, não pode ser outras... Como assim? então, só existem 3 possibilidades. OU é maior, OU é menor OU é igual. Logo, se não foi uma das duas primeiras, NECESSARIAMENTE será a terceira. Não existe outra possibilidade lógica!!! É uma tricotomia. Ao mesmo tempo que se for uma das duas anteriores não tem como ser uma posterior... logo, entrando a necessidade dos else entre um mesmo nível... ou seja, se ano1 > ano2, não tem como ao mesmo tempo ano2 > ano1... é uma impossibilidade lógica!

 

Obs.: perceba que já entre ano e mês também tem else devido a tal hierarquia da cascata, ou seja, ANO temais mais prioridade que mês, logo, um ano for maior que o outro, não se deve tentar verificar o mês e nada que vêm depois!

 

 

 

2#

Ai, uma outra forma seria a demonstrada por @Boko Moko. Perceba que a base é a mesma, ou seja, é voltada na cascata... A ideia continua que o ANO define o maior e menor... se empatar, vem o MES.. se empatar vem o DIA. Então, essa lógica funciona através do peso... ao dar um peso maior, grande o suficiente para um nível superior, fará que os níveis inferiores percam a sua força, suficientemente para não conseguir interferir no resultado final... Veja... ao multiplicar ANO por 10000, a data que tiver o ano maior, sempre terá um resultado (na adição com MES e DIA) maior que a outra data... pois, independente do MES e DIA que o menor tiver, não conseguirá ultrapassa o que o ano do maior ano já deu. Ex.:

 

1/1/2 e 31/12/1

Na primeira data, teremos 2*10000, que dá 20000. Na segunda, teremos 1*10000, que dá 10000... Até ai o subtotal da primeira data é maior, correto? então, se incluir lá a conta do mês e dia para a segunda data, jamais seria maior que 20000, pois o MES e DIA juntos não tem peso suficiente para ser maior que 10000, logo necessariamente vai dar um valor menor, e a primeira data continuará sendo maior.

 

 

Obs.:

Sobre:

1 hora atrás, Boko Moko disse:

Contornei o problema usando long em vez de int/float e resolveu. Só posso creditar esse problema a um erro na rotina de ponto flutuante do compilador C.

 

Então, o possível problema aqui está na "sintaxe" e características da linguagem, ou seja, a lógica em si parece está certa, mas devido as funcionalidades do C, acabou dando problemas de cálculos computacionais, ou seja, mais uma coisa que precisaria se atentar: "Por que usar um tipo numérico ou outro?

 

 

 

***

 

RESUMINDO:

Entendo que a tua base é mais didática... partindo do TUA lógica inicial, e com "auxílios externos";

Já a segunda é mais "evoluída", e parte da lógica de TERCEIROS, ou seja, "necessariamente" teria que "assumir" ao professor/facilitador que "aprendeu" a partir de uma base externa a sua mente.  (no caso, que não partiu da sua própria evolução e raciocínio no desenvolvimento do algoritmo).

 

Minha sugestão?

Independente de qual for usar, contextualize o aprendizado... num que precisou "corrigir" a sua lógica, noutro que "copiou" de terceiros, mas que conseguiu absorver a lógica.

 

Resumindo: seja honesto...    a depender, entrega/mostra os dois códigos!

 

 

No aguardo.

  • Curtir 2

Compartilhar este post


Link para o post
Compartilhar em outros sites
21 minutos atrás, Simon Viegas disse:

Então, o possível problema aqui está na "sintaxe" e características da linguagem, ou seja, a lógica em si parece está certa, mas devido as funcionalidades do C, acabou dando problemas de cálculos computacionais, ou seja, mais uma coisa que precisaria se atentar: "Por que usar um tipo numérico ou outro?

Acho que tem a ver com  a quantidade de dígitos significativos na variável do tipo float. 
No caso, teríamos 4 dígitos do ano + 2 dígitos do mês + 2 dígitos do dia, total de 8 dígitos. Segundo o padrão C, float tem apenas 6 dígitos significativos. Curioso é que eu testei em dois compiladores C distintos e deu o mesmo erro. Quando mudei para long, nos dois compiladores resolveu. Esse é mais um exemplo de como C é muito dependente da plataforma em que foi implementada.


Btw, a explicação do método ponderado foi brilhante. Parabens.

 

adicionado 6 minutos depois
Em 16/04/2018 às 22:01, Boko Moko disse:

Se multiplicar o mes por qualquer coisa maior que 31 e o ano por qualquer coisa maior que 365 essa forma vai funcionar.

 

Depois do "bug" que Vangodp descobriu, o fato de multiplicar apenas por 1000 é até melhor !

 

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 16/04/2018 às 22:01, Boko Moko disse:

Se multiplicar o mes por qualquer coisa maior que 31 e o ano por qualquer coisa maior que 365 essa forma vai funcionar.

Parei para pensar aqui agora... apenas para efeito didático, acho que o limite inferior do peso do ano está abaixo do necessário, ou seja, está inválido (já que poderia ocorrer do "mes+dia" superar)

 

Vejamos:

Partimos do menor para o maior... ou seja, pegar os pesos da direita para esquerda...

 

Então, os dias com seu peso tem que ser menor que 1 mês com o seu peso (pois se com 1 é maior, com qualquer outro valor também será). Algo assim:

 

A condição geral seria:

mesX * pesoM >  diaY *pesoD

Ou seja, o resultado de um mês (mês x peso) de uma data, não pode ser maior que o resultado do dia (dia x peso) para a outra data. Caso contrário, poderia ocorrer de um resultado do dia ultrapassar um resultado de um mês (o que procuramos é que NUNCA ocorra isso).

 

Então, a pior hipótese possível seria a quantidade máxima de dias pela quantidade mínima de meses. Algo assim:

mesX = 1
diaY = 31
mesX * pesoM >  diaY *pesoD //o mesmo que "1 * pesoM >  31 * pesoD"

Logo,

1 * pesoM >  31 * pesoD
pesoM > 31pesoD

Ou seja, o pesoM tem que ser maior que o pesoD * 31.

 

Para facilitar o raciocínio, daremos pesoD = 1. Logo, de fato pesoM > 31. OK.

 

 

Agora vamos tentar verificar o peso do Ano (para que NUNCA seja ultrapasso pelo "mes + dia").

 

Então, da mesma forma, a pior hipótese seria quantidade máxima de dias, mais a quantidade máxima de meses pela quantidade mínima de anos. Algo assim:

anoX = 1
diaY = 31
mesY = 12
anoX * pesoA  >  mesY * pesoM + diaY * pesoD //o mesmo que "1 * pesoA  >  12 * pesoM + 31 * pesoD"

Logo,

1 * pesoA  >  12 * pesoM + 31 * pesoD"
pesoA  >  12*pesoM + 31pesoD

Então, se predefinirmos os pesos anteriores, por exemplo:

pesoD = 1

pesoM = 32 (poderia ser 31,000...1 em diante, mas para arredondar)

 

Teríamos algo como:

pesoA  >  12*32 + 31*1
pesoA  >  384 + 31
pesoA  > 415

Daí, teríamos:

pesoD = 1

pesoM = 32

pesoA = 416 (poderia ser 415,000...1 em diante, mas para arredondar)

 

RESUMINDO:

Pelos argumentos apresentados, o menor peso inteiro para o ano seria 416.

 

Correto?

 

Não, acho que não está, rs... pois não estou levando em consideração que um ano vai ser maior que o outro, OU o mês vai ser maior que o outro... logo, teria que rever tudo ai... kkkkk

 

Mas como já escrevi, vou deixar para analisar depois... tô com fome!!!

 

Se alguém quiser arriscar descobrir "os mínimos pesos" fiquem a vontade...

 

T+

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Simon Viegas O raciocínio é esse mesmo, o peso do ano tem que ser maior que o peso do mês * mes

No caso, o maor mês possível é 12, que multiplicado pelo peso do mês (32) vai dar 384. Seria o caso absurdo de 12 meses de 32 dias, que é impossível na vida real, mas que é possível nessa conta ponderada


Voltemos ao caso do peso do mês.
Imagine datas apenas com mes e dia. Para comparar duas datas, se o mês for maior, nao importa qual o dia da outra data, Portanto, mesmo que a data menor tenha dia 31, a data maior erá 31 + 1 dia (Nõ existe dia 0).

Então mês * 31 + dia da data maior sempre vai ser maior que o mês * 31 + dia da data menor. O peso do mes pode ser 31 apenas.

agora imagine datas apenas com ano e mês. O raciocínio é o mesmo. O maior mês possível é 12. O peso do ano então pode ser 12 pois não há ano 0. Se uma data x é maior que uma data y, ano * 12 + mês da data x sempre será maior que ano * 12 + mês da data y.


Então como fica a data completa  ? Ano * 12 + mês * 31 + dia ?  NÃO !! Porque estamos comparando na verdade "dias", entào o ano tem que ser multiplicado por 365! Mas será suficiente ?  

Imagine a situação de comparação de uma data de dezembro de um ano =  12 meses, de 31 dias cada um mais 31 dias do mês. Teríamos 12 * 31 = 372 + 31 = 403 dias 

Portanto, o peso do ano tem que ser no mínimo 403
Então a fórmula mínima para comparaçào de dia/mes/ano seria

wano = ano * 403 + mes * 31 + dia 

Considerando anos 1900 a 2100, essa fórmula daria como resultados valores entre 765732 (6 dígitos) e 846703 (também 6 dígitos). Ou seja, nesse caso, daria para usar uma variável float.

<também estou com fome, tomara que o café hoje seja biodegradável>

 

Compartilhar este post


Link para o post
Compartilhar em outros sites
1 hora atrás, Boko Moko disse:

wano = ano * 403 + mes * 31 + dia 

Já concordamos que de fato não seria

 

Em 16/04/2018 às 22:01, Boko Moko disse:

o ano por qualquer coisa maior que 365

:D

 

Agora estou um pouco ocupado... mais tarde vou tentar dar uma revisada na sua lógica..

 

PS: eu acho que o peso na verdade será bem menor... como sugerido:

1 hora atrás, Simon Viegas disse:

não está levando em consideração que um ano vai ser maior que o outro, OU o mês vai ser maior que o outro... logo, teria que rever tudo ai...

Ou seja, ao levar isso em consideração, a conta (acho que) muda. Mas como disse, preciso deixar para mais tarde.

 

 

Att.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Eu faria usando uma simples função de comparação de datas que retorna um inteiro positivo se data1 > data2, negativo de data1 < data2, e 0 se as datas forem iguais. Desse jeito:

 

#include <stdio.h>

typedef struct {
    int dia, mes, ano;
} Data;

/* Compara as datas e retorna:
    número > 0  se  data1 >  data2
    número < 0  se  data1 <  data2
    0           se  data1 == data2
*/
int compara_datas(Data data1, Data data2){
    if (data1.ano - data2.ano != 0)
        return data1.ano - data2.ano;
  
    if (data1.mes - data2.mes != 0)
        return data1.mes - data2.mes;
  
    return data1.dia - data2.dia;
}

int main()
{
    
    Data data1, data2;
    printf ("Insira a primeira data:\n");
    scanf  ("%d %d %d", &data1.dia, &data1.mes, &data1.ano);
    printf ("Insira a segunda data :\n");
    scanf  ("%d %d %d", &data2.dia, &data2.mes, &data2.ano);
    
    if (compara_datas(data1, data2) > 0)
        printf("A primeira data e' posterior a segunda data! \n");
    else if (compara_datas(data1, data2) < 0)
        printf("A segunda data e' posterior a primeira data! \n");
    else
        printf("As datas sao iguais! \n");

    return 0;
}

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Aqui a muito tempo fiz uma coisa parecida com a sua proposta @isrnick

int difdatas_( const int data_1_vet[], const int data_2_vet[] ){
	int dif_i;
  
  
	if(dif_i = data_1_vet[ANO] - data_2_vet[ANO])return( dif_i );
	if(dif_i = data_1_vet[MES] - data_2_vet[MES])return( dif_i );
	if(dif_i = data_1_vet[DIA] - data_2_vet[DIA])return( dif_i );
                                                     return( 0 ); }
    /* a diferença de datas iguais é 0 */

Na época serviu bem.

 

Ps.: Ainda serve!

Compartilhar este post


Link para o post
Compartilhar em outros sites

Serie realmente interessante, se o problema fosse a diferença entre datas em no formato data, mas não é o caso.:P

Compartilhar este post


Link para o post
Compartilhar em outros sites

Olá.

 

@GustavoMdancers, alguma novidade?

 

Como pode ver, já foram apresentados algumas formas diferentes para resolver o mesmo problema:

 

1#

Usando uma fórmula simples com peso:

Em 16/04/2018 às 19:58, Boko Moko disse:

float wdata1 = (ano1 * 10000 + mes1 * 100 + dia1);
float wdata2 = (ano2 * 10000 + mes2 * 100 + dia2); 

obs.: só que usando LONG no lugar no FLOAT.

 

 

2#

Utilizando uma cadeia de if/else:

23 horas atrás, Simon Viegas disse:

    if      (ano_1 > ano_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (ano_2 > ano_1) printf("A segunda data é mais recente que a primeira! \n");
    else if (mes_1 > mes_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (mes_2 > mes_1) printf("A segunda data é mais recente que a primeira! \n");
    else if (dia_1 > dia_2) printf("A primeira data é mais recente que a segunda! \n");
    else if (dia_2 > dia_1) printf("A segunda data é mais recente que a primeira! \n");
    else                    printf("As datas são iguais! \n");    

 

 

3#

Usando struct e uma método:

17 horas atrás, isrnick disse:

typedef struct {
    int dia, mes, ano;
} Data;

/* Compara as datas e retorna:
    número > 0  se  data1 >  data2
    número < 0  se  data1 <  data2
    0           se  data1 == data2
*/
int compara_datas(Data data1, Data data2){
    if (data1.ano - data2.ano != 0)
        return data1.ano - data2.ano;
  
    if (data1.mes - data2.mes != 0)
        return data1.mes - data2.mes;
  
    return data1.dia - data2.dia;
}

 

 

4#

E usando vetores e um método

16 horas atrás, AnsiC disse:

int difdatas_( const int data_1_vet[], const int data_2_vet[] ){
	int dif_i;
  
  
	if(dif_i = data_1_vet[ANO] - data_2_vet[ANO])return( dif_i );
	if(dif_i = data_1_vet[MES] - data_2_vet[MES])return( dif_i );
	if(dif_i = data_1_vet[DIA] - data_2_vet[DIA])return( dif_i );
                                                     return( 0 ); }
    /* a diferença de datas iguais é 0 */

 

 

****

 

Ai, a sugestão seria verificar o que se encaixa melhor para você. Caso deseje, tente implementar um código, ai posta o código completo final, e caso tenha dúvidas, indicar onde.

 

 

 

 

 

 

@Boko Moko, para não poluir o comentário... basta abrir o o botão abaixo:

 

Spoiler

Então...

 

21 horas atrás, Boko Moko disse:

O peso do mes pode ser 31 apenas.

Sim. Teoricamente pode, ou seja, em vez de >31, pode ser =31. Entendi sua lógica e concordo.

 

Ao mesmo tempo concordo que PODE ser:

21 horas atrás, Boko Moko disse:

wano = ano * 403 + mes * 31 + dia 

 

Mas veja, o objetivo aqui seria encontrar o "mínimo", correto?  obs.: "poder por poder,  poderia ser os 10000 para o ano e 100 para o mês... a "brincadeira" aqui é para achar os menores pesos possíveis.

 

Entretanto:

21 horas atrás, Boko Moko disse:

Portanto, o peso do ano tem que ser no mínimo 403
Então a fórmula mínima para comparaçào de dia/mes/ano seria

 

É nisso que estou discordando inicialmente... eu ACHO que os mínimos são menores!!!

 

Estou começando a esboçar as ideias agora... daqui a pouco posto o que conseguir desenvolver.

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Boko Moko, achei:

 

Ficaria assim:

    float data1 = (ano1 * 372 + mes1 * 31 + dia1);
    float data2 = (ano2 * 372 + mes2 * 31 + dia2);

obs.: eu tinha a impressão que o pesoM também poderia ser menor, mas me enganei.

 

 

Então, APARENTEMENTE a fórmula seria:

pesoA=maxMes*pesoMes

Mas já adianto que NÃO É!!!  rs.  Teria que se aprofundar mais um pouco para achar... kkkk

 

 

 

RESUMINDO:

De fato o peso mínimo do ano é menor (372, em vez de 403)... mas o peso do mês fica em 31 mesmo.. isso tudo se usarmos pesoD = 1.

 

Daí, fica faltando apenas achar as fórmulas gerais para os pesos... :rezando:

 

 

Correto?

 

Att

adicionado 38 minutos depois

ps: achei a fórmula geral. Mas por enquanto deixo para quem quiser tentar. Att.

 

Compartilhar este post


Link para o post
Compartilhar em outros sites

Também pode fazer a função que compara datas sem struct ou vetor:

int compara_datas(int dia1, int mes1, int ano1, int dia2, int mes2, int ano2){
    int d;
    if (d = ano1 - ano2) return d;
    if (d = mes1 - mes2) return d;
    return dia1 - dia2;
}

 

Ou até usando a sua fórmula se os multiplicadores estiverem corretos:

int compara_datas(int dia1, int mes1, int ano1, int dia2, int mes2, int ano2){
    return (ano1 - ano2) * 372 + (mes1 - mes2) * 31 + dia1 - dia2;
}

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@isrnick, essa fórmula 

28 minutos atrás, isrnick disse:

int compara_datas(int dia1, int mes1, int ano1, int dia2, int mes2, int ano2){
    int d;
    if (d = ano1 - ano2) return d;
    if (d = mes1 - mes2) return d;
    return dia1 - dia2;
}

 

É absurdamente simples.. mas ao mesmo tempo, talvez, não tão trivial para entender e também para se chegar a ela!

 

Deixa eu vê se eu entendi direito:

int compara_datas(int dia1, int mes1, int ano1, int dia2, int mes2, int ano2){
    int d;
    if (d = ano1 - ano2) return d; //se os anos são diferentes, retorne a difirença entre eles
    if (d = mes1 - mes2) return d; //senão, se meses são diferentes, retorne a diferença entre eles
    return dia1 - dia2; //senão, retorna a diferença dos dias
    
    //no programa principal, se a resposta for negativa, um delete é maior, se positiva, o outro é maior... ou são iguais
}

 

Seria isso?   (obs.: fiquei com preguiça de associar o positivo e negativo à respectiva ordem)

 

Mas o mais interessante é a sentença do if... pelo que eu entendi, faz uma atribuição na própria sentença, e verifica o valor de d. No caso, usado 0 como "falso" e diferente de 0 "verdadeiro"... Correto?    Show de bola!

 

PS: só para deixar mais claro:

Seria o mesmo que isso:

int compara_datas(int dia1, int mes1, int ano1, int dia2, int mes2, int ano2){
    int d;
    d = ano1 - ano2;
    if (d) return d;
    d = mes1 - mes2;
    if (d) return d; 
    return dia1 - dia2;
}

Confere?

 

Muito bacana!

adicionado 2 minutos depois

 

 

43 minutos atrás, isrnick disse:

Ou até usando a sua fórmula se os multiplicadores estiverem corretos:

Tudo indica que sim... tanto pelos cálculos, tanto por testes.

 

 

ADENDO:

3 horas atrás, Simon Viegas disse:

ps: achei a fórmula geral. Mas por enquanto deixo para quem quiser tentar. Att.

Se habilita?

Compartilhar este post


Link para o post
Compartilhar em outros sites

@Simon Viegas É isso mesmo, trata-se da mesma lógica do meu primeiro post que usava uma struct, e do post do @AnsiC com vetores.

 

Para entender a lógica acho que o meu primeiro post é mais fácil que essa versão reduzida, pois lá eu fiz propositalmente pra facilitar o entendimento pra quem ler o código, sempre deixando as subtrações explicitas e também usando "!= 0" no if o que não é necessário.

 

Em todos os casos o retorno da função segue as mesmas regras:

número > 0  se  data1 >  data2
número < 0  se  data1 <  data2
0           se  data1 == data2

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×