Arquivo

Archive for setembro \24\UTC 2010

Calcular idade completa com Flex

Bueno, Essa função recebe como parâmetro uma data de nascimento e retorna uma String com o ano, mes e dia. A função foi feita validando o resultado no site http://www.timeanddate.com


public static function calcularIdadeCompleta(niver:Date, hoje:Date = null):String
{
	if (!hoje)
	{
		hoje = new Date();
	}

	var idade:String;

	var dias:Number;
	var meses:Number;
	var anos:Number;

	// Já fez aniversário
	if (hoje.getMonth() > niver.getMonth())
	{
		anos = hoje.getFullYear() - niver.getFullYear();

		if (hoje.getDate() < niver.getDate())
		{
			/* remove 1 mês, porque no mês corrente ainda
			 não ultrapassou o dia da data de aniversário */
			meses = hoje.getMonth() - niver.getMonth() - 1;

			// a soma dos dias ultrapassados após o dia da data de aniversário
			dias = hoje.getDate() + (31 - niver.getDate());
		}
		else
		{
			meses = hoje.getMonth() - niver.getMonth();
			dias = hoje.getDate() - niver.getDate();
		}
	}
	else if (hoje.getMonth() < niver.getMonth())
	{
		// remove 1 ano porque ainda não fez aniversário
		anos = hoje.getFullYear() - niver.getFullYear() - 1;

		if (hoje.getDate() < niver.getDate())
		{
			meses = hoje.getMonth();

			// a soma dos dias ultrapassados após o dia da data de aniversário
			dias = hoje.getDate() + (31 - niver.getDate());
		}
		else
		{
			// adiciona 1 mês porque já passou do dia da data de aniversário
			meses = hoje.getMonth() + 1;
			dias = hoje.getDate() - niver.getDate();
		}
	}
	else if (hoje.getMonth() == niver.getMonth())
	{
		if (hoje.getDate() < niver.getDate())
		{
			// remove 1 ano porque ainda não fez aniversário
			anos = hoje.getFullYear() - niver.getFullYear() - 1;
			meses = hoje.getMonth() + 1;
			// a soma dos dias ultrapassados após o dia da data de aniversário
			dias = hoje.getDate() + (31 - niver.getDate());
		}
		else
		{
			anos = hoje.getFullYear() - niver.getFullYear();
			meses = hoje.getMonth() - niver.getMonth();
			dias = hoje.getDate() - niver.getDate();
		}
	}
	idade = anos + "a " + meses + "m " + dias + "d ";
	return idade;
}


Abraço.

Categorias:Flex Tags:, ,

Transformando RGB para Decimal

Conforme solicitado por e-mail segue a baixo outro exemplo de “cast” de RGB mas agora transformandoo em Decimal, no post anterior tem o exemplo para transformar RGB para Hexadecimal.


public static function rgbDecimal(cp:ColorPicker):String
{
	var input:String = rgbHexaDecimal(cp);
	input = input.substring(input.length - 6, input.length);
	var rgbDecimal:String = "";
	var r:int;
	var g:int;
	var b:int;

	for(var i:int = 0; i < input.length; i++)
	{
		r = parseInt(input.charAt(i), 16);
		i++;
		g = parseInt(input.charAt(i), 16)
		b = (r * 16) + (g * 1);
		rgbDecimal += new String(b) + ",";
	}
	rgbDecimal = rgbDecimal.substring(0, rgbDecimal.length - 1);

	return rgbDecimal;
}

Abraços.

Categorias:Flex Tags:, , , ,

Transformando RGB para Hexadecimal

Bueno, para salvar uma cor no banco normalmente se utiliza uma string no formato RGB, e na aplicação é necessário que essa informação esteja em formato Hexadecimal para ser utilizada, portanto fiz essa função que recebe como parâmetro uma string com o código em RGB e transforma em Hexadecimal.
Exemplo: Formato RGB = “r255g255b255” transforma em Hexadecinal “#ffffff”.


public static function rgbToHex(str:String):String
{
	if (str == null)
	{
		return "";
	}
	var r:Number, g:Number, b:Number = 0;
	var regExp:RegExp = /[rgb]/g;
	var match:String;
	while((match = regExp.exec(str)) != null)
	{
		var s:String = "";
		for (var i:Number = regExp.lastIndex; i  -1)
                {
			var char:String = str.charAt(i);
                        if (char.search("[0-9]") > -1){
				s += char;
			} else {
				break;
			}
		}
		if (match == "r")
		{
			r = new Number(s);
		} else if (match == "g")
		{
			g = new Number(s);
		} else
		{
			b = new Number(s);
		}
	}
	return "#" + toHex(r) + toHex(g) + toHex(b);
}

Flw.

Categorias:Flex Tags:, , , ,

Lista duplamente encadeada em C

Bueno, vou postar meu primeiro trabalho de programação que eu fiz em C no segundo nível de Ciência da Computação na UPF, não sei como mas tiramos 10 neste trabalho 😀


/*..::Bibliotecas incluidas::..*/ 

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>

 /*..::Definicao da constante::..*/
#define TAMANHO 6

/*..::Prototipagem::..*/
void cria_pnd( void );
void cria_nc( void );
int obtem( void );
void mostra_lista( void );
int inclusao( void );
void consulta( void );
void retirada( void );
void libera( int indice );
void mostra_elo_a ( void );
void mostra_elo_p ( void );
void nodos_disp ( void );
void esvazia_lista ( void );
void total ( void );
void dados_pessoais ( void );
void menu ( char *p );
void processa_menu ( char *a );
void alerta( void );

/*..::declaracao da estrutura..::*/
struct nodo {
       char  descricao[20];
       char  unidade[3];
       float quantidade;
       float vlr_unitario;
       int   elo_a;
       int   elo_p;
};

/*..::Declaracao de variaveis globais::..*/
struct nodo lista[TAMANHO];
int nc;
int disp;
char  aux_descricao[20];
char  aux_unidade[3];
float aux_quantidade;
float aux_vlr_unitario;

/* ....::::INICIO DO PROGRAMA PRINCIPAL::::.... */
int main(void)
{
/*..::Declaracao das variaveis do prog principal::..*/
    char  opcao;

    system("color 1f");
    dados_pessoais();
    cria_pnd();
    cria_nc();

    while ( 1 ){
        menu ( &opcao );
        processa_menu ( &opcao );
    }
fflush(stdin); getchar(); return(0);
}

/*.........::::::::::::::::::FUNÇÕES::::::::::::::::::.........*/
void alerta(void){
     int i=0;
        for(i=1; i<=50; i++){
              if(i%8 == 0)
                  system ("color 9f");
              else
                  system("color 4f");
        }
fflush(stdin);
}

/*Função que mostra os dados do do programador*/
void dados_pessoais ( void ){

    printf("\n\n\n\n");
    printf("\n  _________________________________________________________________________\n");
    printf("\n   ......:T R A B A L H O _ ESTRUTURA DE DADOS I_ V I A P I A N A:......   \n");
    printf("\n   ...........ALUNOS:   ...:Alison Rodrigues de Souza   92524@upf.br:...   \n");
    printf("\n                        ...:Jaqueline Pizzi Zilli       48793@upf.br:...   \n");
    printf("\n  _________________________________________________________________________\n");
    printf("\t\t\t  ________________\n");
    printf("\t\t\t  |              |\n ");
    printf("\t\t\t  | Digite ENTER |\n");
    printf("\t\t\t  |______________|\n");
    printf("\t\t\t  \n");
    fflush(stdin); getchar();
    system("cls");
}

/*..::Função que cria a pilhe de nodos disponiveis::..*/
void cria_pnd (void){
     int indice = 0;

     while( indice < TAMANHO - 1 ){
          lista[indice].elo_p = indice + 1;
          indice++;
     }
     lista[ TAMANHO - 1 ].elo_p = -1;
     disp = 0;
     printf("\nPilha de Nodos Disponiveis criada: \nPrecione ENTER para ir ao proximo passo!");
     fflush(stdin); getchar();
}

/*..::Função que obtem um indice::..*/
int obtem (void){
    int indice;

    if(disp == -1) /*..::a lista esta vazia?..::*/
         return( -1 );
    else{
         indice = disp;
         disp = lista[disp].elo_p;
    }
return(indice);
}

/*..::Função que cria o nodo-cabeça::..*/
void cria_nc (void){
     int nc;
     char aux[]="nodo-cabeca";

     nc = obtem(); /*..::obtem um indice disponivel::..*/

     lista[nc].elo_a = nc;
     lista[nc].elo_p = nc;
     strcpy(lista[nc].descricao, aux);
     printf("\nNodo-Cabeca criado: \nPrecione ENTER para ativar o MENU.\n");
     fflush(stdin); getchar();
}

/*..::Função menu::..*/
void menu ( char *p ){

        system("cls");

        printf("\n\t            ___________________________________________");
        printf("\n\t           |__--__--__--__....:MENU:....__--__--__--__|");
        printf("\n\t            ___________________________________________");
        printf("\n\t           |     I   -   ..:Inclusao:..               |");
        printf("\n\t           |     R   -   ..:Retirada:..               |");
        printf("\n\t           |     C   -   ..:Consulta:..               |");
        printf("\n\t           |     M   -   ..:Mostra Lista:. .          |");
        printf("\n\t           |     A   -   ..:Ordem Logica ELO_A:..     |");
        printf("\n\t           |     P   -   ..:Ordem Logica ELO_P:..     |");
        printf("\n\t           |     D   -   ..:Disponiveis:..            |");
        printf("\n\t           |     E   -   ..:Esvazia Lista:..          |");
        printf("\n\t           |     T   -   ..:Total:..                  |");
        printf("\n\t           |     F   -   ..:Fim:..                    |");
        printf("\n\t           |__________________________________________|");
        printf("\n\n\n\n\t           .......:Digite sua opcao: ");
        fflush(stdin);
        scanf("%c", p );

fflush(stdin);
}

/*..::Função que processa uma informação do menu::..*/
void processa_menu ( char *a ){

        *a = toupper( *a );
        switch( *a ){
           case 'I' : system("cls");
                      inclusao();
                      break;
           case 'C' : system("cls");
                      consulta();
                      break;
           case 'R' : system("cls");
                      retirada();
                      break;
           case 'M' : system("cls");
                      mostra_lista();
                      break;
           case 'A' : system("cls");
                      mostra_elo_a();
                      break;
           case 'P' : system("cls");
                      mostra_elo_p();
                      break;
           case 'D' : system("cls");
                      nodos_disp();
                      break;
           case 'E' : system("cls");
                      esvazia_lista();
                      break;
           case 'T' : system("cls");
                      total();
                      break;
           case 'F' : system("cls");
                      printf("Adios");
                      exit( 0 );
        }
}

/*..::Função que libera todos os nodos e os tornam disponiveis::..*/
void libera (int indice){
     char limpa[]="";

     lista[indice].elo_p = disp;
     disp = indice;
     /*..::limpa os nodos do indice excluido::..*/
     strcmp(lista[indice].descricao, limpa);
     lista[indice].quantidade = 0.00;
     strcmp(lista[indice].unidade, limpa);
     lista[indice].vlr_unitario = 0.00;
     lista[indice].elo_a = 0;
}

/*..::Função que inclui uma informação na lista::..*/
int inclusao (void){
    int indice;
    int anterior;
    int posterior;
    int n;
    int cont = 0;
    int i;

    if(disp == -1){
        printf("\n O V E R F L O W ! \nL I S T A    C H E I A \n");
        alerta();
        system("color 1f");
        fflush(stdin);
    }
    else{
        anterior = nc;
        posterior = lista[nc].elo_p;

        printf("Digite a Descricao : ");
        fflush(stdin); gets(aux_descricao);
        n = strlen(aux_descricao);
        while(cont <= n){
             aux_descricao[cont] = tolower(aux_descricao[cont]);
             cont++;
        }
        while (posterior != nc){
              if((strcmp(aux_descricao, lista[posterior].descricao) == 0)){
				   printf("Repetido!\n");
				   printf("\n\nTecle algo... ");
                   fflush(stdin); getchar(); return(0);
              }
              else{
                   anterior = posterior;
                   posterior = lista[posterior].elo_p;
              }
        }
        printf("Digite a Unidade : ");
        fflush(stdin); gets(aux_unidade);
        n = strlen(aux_unidade);
        cont = 0;
        while(cont <= n){
             aux_unidade[cont] = tolower(aux_unidade[cont]);
             cont++;
        }
        printf("Digite a Quantidade : ");
        fflush(stdin); scanf("%f", &aux_quantidade);
        printf("Digite o valor unitario do produto : ");
        fflush(stdin); scanf("%f", &aux_vlr_unitario);
        anterior = nc;
        posterior = lista[nc].elo_p;

        while(posterior != nc){
            if( strcmp(aux_descricao, lista[posterior].descricao) < 0)
                break;
            else{
                anterior= posterior;
                posterior = lista[posterior].elo_p;
            }
        }
        indice = obtem();
        /*..::copia informações das aux para a estrutura::..*/
        strcpy(lista[indice].descricao, aux_descricao);
        strcpy(lista[indice].unidade, aux_unidade);
        lista[indice].quantidade = aux_quantidade;
        lista[indice].vlr_unitario = aux_vlr_unitario;
        /*..::atualiza os nodos elos::..*/
        lista[anterior].elo_p = indice;
        lista[indice].elo_p = posterior;
        lista[posterior].elo_a = indice;
        lista[indice].elo_a = anterior;

        printf("\nIncluido com sucesso ! \n\n\nPrecione ENTER para voltar ao MENU: \n");
        fflush(stdin); getchar(); return(0);
    }
fflush(stdin);
}

/*..::Funcao que consulta uma informação na lista::..*/
void consulta (void){
     int aux;
     int i;
     int cont = 0;
     int n;

     aux = lista[nc].elo_p;

     if(lista[nc].elo_p == 0){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          }
     else{
          printf("Digite o nome a ser consultado : ");
          fflush(stdin); gets (aux_descricao);
          n = strlen(aux_descricao);
          while(cont <= n){
               aux_descricao[cont] = tolower(aux_descricao[cont]);
               cont++;
          }
          while(aux != nc){
               if(strcmp(aux_descricao, lista[aux].descricao) == 0)
                    break;
               else
                    aux = lista[aux].elo_p;
          }
          if(aux == nc)
             printf("valor nao encontrado na lista.\n\n");
          else
             printf("\nEncontrado no indice [%d]: %s\n\n", aux, lista[aux].descricao);
     printf("\n\n\nPrecione ENTER para voltar para o MENU:\n\n");
     fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao retira informação da lista::..*/
void retirada (void){
     char limpa[] = " ";
     int indice;
     int anterior;
     int posterior;
     int n;
     int cont = 0;
     int i;

     if(lista[nc].elo_p == nc){
          printf("U N D E R F L O W  \nL I S T A    V A Z I A !\n\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nDigite o nome da descricao a ser retirada da lista : ");
          fflush(stdin); gets (aux_descricao);
          n = strlen(aux_descricao);

          while(cont <= n){
                aux_descricao[cont] = tolower(aux_descricao[cont]);
                cont++;
          }
          anterior = nc;
          indice = lista[nc].elo_p;   

          while(indice != nc){
               if(strcmp(aux_descricao, lista[indice].descricao) == 0){
                    posterior = lista[indice].elo_p;
                    break;
               }
               else{
                    anterior = indice;
                    indice = lista[indice].elo_p;
               }
          }
          if(indice == nc)
               printf("Valor nao encontrado.\n");
          else{
               /*..::atualiza os nodos elos::..*/
               lista[anterior].elo_p = lista[indice].elo_p;
               lista[posterior].elo_a = lista[indice].elo_a;

               libera(indice);
               /*..::limpa os nodos::..*/
               strcpy(lista[indice].descricao, limpa);
               strcpy(lista[indice].unidade, limpa);
               lista[indice].quantidade = 0.00;
               lista[indice].vlr_unitario = 0.00;
               printf("\nRetirado com sucesso [ %s ] da lista da lista.\n", aux_descricao);
          }
          printf("\n\n\nPrecione ENTER para voltar para o MENU.\n");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao mostra elo A::..*/
void mostra_elo_a ( void ){
     int aux;
     int i;

     aux = lista[nc].elo_a;

     if(aux == nc){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nOrdem logica Elo_A");
          printf("\n\n\n    Elo A|  descricao");
          printf("\n|-------------------------------");
          while(aux != nc){
               printf("\n|%-8d| %-20s| ", lista[aux].elo_a, lista[aux].descricao);
               printf("\n|-------------------------------");

               aux = lista[aux].elo_a;
          }
          printf("\n\n\n\nPrecione ENTER para voltar ao MENU:");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao mostra elo P::..*/
void mostra_elo_p(void){
     int aux;
     int i;

     aux = lista[nc].elo_p;

     if( aux == nc ){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("\nOrdem logica Elo_P");
          printf("\n\n\n    Elo P|  descricao");
          printf("\n|-------------------------------");
          while(aux != nc){
               printf("\n|%-8d| %-20s| ", lista[aux].elo_p, lista[aux].descricao);
               printf("\n|-------------------------------");

               aux = lista[aux].elo_p;
          }
          printf("\n\n\n\nPrecione ENTER para voltar ao MENU:");
          fflush(stdin); getchar();
     }
fflush(stdin);
}

/*..::Funcao nodos disponiveis::..*/
void nodos_disp (void){
     int aux;

     aux = disp;

     while( 1 ){
          if(aux == -1){
               printf("\nNao ha nodos disponiveis.\n");
               break;
          }
          else{
               printf("\n - [%d]", aux);

               if(lista[aux].elo_p == -1)
                  break;
               aux = lista[aux].elo_p;
          }
     }
printf("\nPrecione ENTER para voltar para o MENU:");
fflush(stdin); getchar();
}

/*..::Funcao mostra a lista::..*/
void mostra_lista( void ){
     int i;
     printf("\n              ELO A       DESCRICAO      UNIDAD  QTD   VLR UNIT   ELO P");
     printf("\n              ----------------------------------------------------------");
     for( i = 0 ; i ":(i == nc)?"NC---->":"" , i ,
               lista[i].elo_a , lista[i].descricao, lista[i].unidade, lista[i].quantidade, lista[i].vlr_unitario,
               lista[i].elo_p );
        printf("\n              ----------------------------------------------------------");
     }
     printf("\n\n\n\t\tNC: %2d\t\t\t\t\tDisp: %2d", nc, disp );
     fflush( stdin ); getchar();
}

/*..::Funcao esvazia a lista::..*/
void esvazia_lista( void ){
     char opcao;
     char limpa[]="";
     int aux;
     int i;

     if(lista[nc].elo_p == nc){
          printf("L I S T A    V A Z I A !");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          printf("Tem certeza de que deseja esvaziar a lista?   [S/N] : \n");
          fflush(stdin); scanf("%c", &opcao);
          opcao = toupper(opcao);
          if(opcao == 'S'){

               aux = lista[nc].elo_p;

               printf("\nEsvaziando informacaes :\n");

               while(aux != 0){
                    system("cls");
                    printf("\n\nPrecione ENTER para excluir %s da lista:", lista[aux].descricao);
                    fflush(stdin); getchar();
                    strcpy(lista[aux].descricao, limpa);
                    strcpy(lista[aux].unidade, limpa);
                    lista[aux].elo_a = nc;
                    lista[aux].quantidade = 0.00;
                    lista[aux].vlr_unitario = 0.00;
                    aux = lista[aux].elo_p;
               }
               printf("\nLista esvaziada !\n\n");
               cria_pnd();
               cria_nc();
          }
     }
}

/*..::Funcao total::..*/
void total (void){
     int aux;
     int i;

     aux = lista[nc].elo_p;
     if(lista[nc].elo_p == 0){
          printf("L I S T A    V A Z I A !\n");
          alerta();
          system("color 1f");
          fflush(stdin);
     }
     else{
          aux_quantidade = 0.00;
          aux_vlr_unitario = 0.00;
          while(aux != nc){
                if(aux != nc){
                     aux_quantidade += lista[aux].quantidade;
                     aux_vlr_unitario += lista[aux].vlr_unitario;
                }
                aux = lista[aux].elo_p;
          }
     printf("\n\tT O T A L\n");
     printf("\n|----------------------------|");
     printf("\n| Quantidade  |  Vlr Unitario|");
     printf("\n|----------------------------|");
     aux = lista[nc].elo_p;
     printf("\n|%13.2f|%14.2f| ", aux_quantidade, aux_vlr_unitario);
     printf("\n|----------------------------|");
     printf("\n\n\nPrecione ENTER para voltar para o MENU: ");
     fflush(stdin); getchar();
     }
fflush(stdin);
}

  /**************************************************************************
   * (C) Copyright 2008 by Alison & Jaqueline.                              *
   * All Rights Reserved.                                                   *
   *                                                                        *
   *            ....::::trabalho de estrutura de dados::::....              *
   *               ....::::Alison Rodrigues de Souza::::....                *
   *                 ....::::Jaqueline Pizzi Zilli::::....                  *
   *************************************************************************/

Flw pessoal.