Ir ao conteúdo
  • Comunicados

    • Gabriel Torres

      Seja um moderador do Clube do Hardware!   12-02-2016

      Prezados membros do Clube do Hardware, Está aberto o processo de seleção de novos moderadores para diversos setores ou áreas do Clube do Hardware. Os requisitos são:   Pelo menos 500 posts e um ano de cadastro; Boa frequência de participação; Ser respeitoso, cordial e educado com os demais membros; Ter bom nível de português; Ter razoável conhecimento da área em que pretende atuar; Saber trabalhar em equipe (com os moderadores, coordenadores e administradores).   Os interessados deverão enviar uma mensagem privada para o usuário @Equipe Clube do Hardware com o título "Candidato a moderador". A mensagem deverá conter respostas às perguntas abaixo:   Qual o seu nome completo? Qual sua data de nascimento? Qual sua formação/profissão? Já atuou como moderador em algo outro fórum, se sim, qual? De forma sucinta, explique o porquê de querer ser moderador do fórum e conte-nos um pouco sobre você.   OBS: Não se trata de função remunerada. Todos que fazem parte do staff são voluntários.
    • DiF

      Poste seus códigos corretamente!   21-05-2016

      Prezados membros do Fórum do Clube do Hardware, O Fórum oferece um recurso chamado CODE, onde o ícone no painel do editor é  <>     O uso deste recurso é  imprescindível para uma melhor leitura, manter a organização, diferenciar de texto comum e principalmente evitar que os compiladores e IDEs acusem erro ao colar um código copiado daqui. Portanto convido-lhes para ler as instruções de como usar este recurso CODE neste tópico:  
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.

 

Editado por Boko Moko
erro
  • 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
3 horas atrás, Simon Viegas disse:

Já concordamos que de fato não seria

.

Porque ? 

 

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!

Editado por AnsiC
PS.:

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

Editado por AnsiC

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.

Editado por Simon Viegas

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






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

×