Ir ao conteúdo
  • Cadastre-se
LordScrew

C Não consigo implementar o Bubble Sort no meu código

Posts recomendados

Pessoal, to com um exercício aqui em linguagem C que diz o seguinte: "Crie um arquivo texto bd.txt, preencha com nomes, tel, cpf, idade e depois ordene pela técnica booble sort, usando os nomes.". Eu consegui fazer o código para criar o arquivo e fiz a estrutura de repetição para recolher os dados. O problema é que não to conseguindo implementar o bubblesort.

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include <string.h>
#define TAM 51

main(void){
	
	char  nome[TAM], tel[TAM], cpf[TAM], idade[TAM];
	
	int i = 1;
	int contador = 0;
	int g = 0;  // variável para usar no bubblesort
        int sab[TAM]; // vetor que irá receber as iniciais dos nomes
	
	
	FILE *file;
	file = fopen("bd.txt", "a");
	
	do {
		
	    contador++; // incremento apenas para ver quantas vezes o loop é realizado
	    
	    printf("Entre com o nome da pessoa:");
	    scanf("%s", &nome);
	    fprintf(file, "===============================================\n"); 
	    fprintf(file,"Nome: %s\n", nome);
	    
	    printf("Entre com o CPF da pessoa:");
	    canf("%s", &cpf);
	    fprintf(file,"CPF: %s\n", cpf);
		
	    printf("Entre com a idade da pessoa:");
	    scanf("%s", &idade);
	    fprintf(file,"Idade: %s\n", idade);
		
	    printf("Entre com o telefone da pessoa:");
	    scanf("%s", &tel);
	    fprintf(file,"Telefone: %s\n", tel);
	    fprintf(file, "===============================================\n\n");
		
	    printf("===============================================\n");
	    printf("Nome: %s\n", nome);
	    printf("CPF: %s\n", cpf);
	    printf("Idade: %s\n", idade);
	    printf("Telefone: %s\n", tel);
	    printf("===============================================\n");
		
	    printf("\n\n === O valor de g e %d\n", g);
		
	    sab[g]=nome[0]; // aqui é atribuido ao vetor sab as iniciais dos nomes
		
	    printf("%d", sab[g]);
		
	    printf("\n\ncontador: %d\n\n", contador);
	    
	    printf("Caso deseje continuar registrando dados digite qualquer número exceto o 0. Caso contrario, digite 0.\n");
	    scanf("%d", &i);
		
	    if(i!=0){
			g++;
		}
		
	}while(i!=0);
	
	
	
	// O algoritmo BubbleSort a seguir ordena apenas as iniciais dos nomes pelos valores da tabela ASCII
	
	int cont, y, aux, c;
	
	for(cont=0; cont<=g; cont++){
		for(y = 0; y<g; y++){
			if (sab[y]>sab[y+1]){
				aux = sab[y];
				sab[y]=sab[y+1];
				sab[y+1]=aux;
				
			}
		}
	}
	
	printf("Vetores em ordem crescente\n\n");
	
	for(c=0; c<=g; c++){
		printf("O valor da posição %d no vetor sab e %d\n", c, sab[c]);
		
	}
	
	fclose(file);	
	
}

Eu to há 3 dias tentando fazer o bubblesort e não consigo 😅

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@LordScrew @LordScrew       seu código está bom , mas esse bubllesort contém erros ,  e seu código com algumas modificações poderia ser assim  :

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#define u GetStdHandle(STD_OUTPUT_HANDLE)
#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));
#define TAM 51
int main(void){
    char  nome[TAM][25], tel[TAM], cpf[TAM],
          idade[TAM],aux_y[25];
    int i=1,g=0,contador=0;
    int sab[TAM]; // vetor que irá receber as iniciais dos nomes
    FILE *file;
    file = fopen("bd.txt", "a");
    do {
        textcolor_2(14,0);
        printf("Entre com o nome da pessoa:");
        textcolor_2(11,0);
        scanf("%s",nome[contador]);
        fprintf(file, "===============================================\n");
        fprintf(file,"Nome: %s\n", nome[contador]);
        printf("Entre com o CPF da pessoa:");
        scanf("%s",cpf);
        fprintf(file,"CPF: %s\n", cpf);
        textcolor_2(14,0);
        printf("Entre com a idade da pessoa:");
        scanf("%s",idade);
        fprintf(file,"Idade: %s\n", idade);
        printf("Entre com o telefone da pessoa:");
        scanf("%s",tel);
        fprintf(file,"Telefone: %s\n", tel);
        fprintf(file, "===============================================\n\n");
        printf("===============================================\n");
        textcolor_2(11,0);
        printf("Nome -----: %s\n",nome[contador]);
        printf("CPF ------: %s\n",cpf           );
        printf("Idade ----: %s\n",idade         );
        printf("Telefone -: %s\n",tel           );
        printf("===============================================\n");
        textcolor_2(10,12);
        printf("\n ==> O valor de g eh %d  \n",g);
        sab[g]=nome[contador][0]; // aqui é atribuido ao vetor sab as iniciais dos nomes
        printf(" sab inicial do nome -: %c \n\n",sab[g]  );/* p/ imprimir letras use %c */
        printf(" contador ------------: %d \n\n",contador);
        textcolor_2(15,0);
        printf("Caso deseje continuar registrando dados digite qualquer número exceto o 0.\n");
        printf("Caso contrario, digite 0. ");
        scanf("%d",&i);
        /*if(i!=0){*//* precisa incrementar sempre */
            g++;
        /*}*/
        contador++; /* usado para inserir no vetor nome e como contador de registro */
    }while(i!=0);
    // O algoritmo BubbleSort a seguir ordena apenas as iniciais dos nomes pelos valores da tabela ASCII
    int cont, y, aux, c;
    for(cont=0; cont<g; cont++){
        for(y=cont+1; y<g; y++){
            if( sab[cont] > sab[   y]){
                printf("cont= %3d y= %3d\n",sab[cont],sab[y]);          /* ver as antes da troca */
                aux       = sab[cont] ;
                sab[cont] = sab[   y] ;
                sab[y]    = aux       ;
                printf("cont= %3d y= %3d     Tecle !\n",sab[cont],sab[y]);getch(); /* ver depois da troca */

                strcpy(aux_y     ,nome[cont]);                        /* organizar por nome */
                strcpy(nome[cont],nome[   y]);
                strcpy(nome[y]   ,aux_y     );
            }
        }
    }
    textcolor_2(12,14);
    printf("\n  Vetores em ordem crescente  \n\n");
    for(c=0; c<g; c++){
        textcolor_2(14,0);
        printf("O valor da posição %2d no vetor sab  eh %3d\n",c,sab[c]);/* letras são caracteres %c */
        textcolor_2(11,0);
        printf("O Nome  Na Posicao %2d Do Vetor Nome eh %s\n",c,nome[c]);
    }
    fclose(file);
    return 0;
}

 

  • Obrigado 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

@devair1010 , muito obrigado, amigo 😁.  Seu código ficou  bem mais completo.

Então, eu usei o seu para tentar fazer o que inicialmente estava proposto no exercício, de organizar esses dados em ordem no arquivo usando os nomes. Fiz que nem você de colocar os dados dentro dos vetores, mas aí quando vou no arquivo os dados estão fora de ordem,  mas os nomes ficam certinho. Explicando melhor, os nomes ficam em ordem alfabética, porém os dados referente ao nome da pessoa são de outra pessoa. Eu acrescentei um ciclo for e mudei algumas linhas referente ao file. 

 

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#define u GetStdHandle(STD_OUTPUT_HANDLE)
#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));
#define TAM 51
int main(void){
    char  nome[TAM][25], tel[TAM][25], cpf[TAM][25],
          idade[TAM][25],aux_y[25];
    int i=1,g=0,contador=0; 
    int sab[TAM],  sabcpf[TAM], sabidade[TAM], sabtel[TAM];// vetor que irá receber as iniciais dos nomes
    
    
    
    do {
        textcolor_2(14,0);
        printf("Entre com o nome da pessoa:");
        textcolor_2(11,0);
        scanf("%s",nome[contador]);
        
        printf("Entre com o CPF da pessoa:");
        scanf("%s",cpf[contador]);
        
        textcolor_2(14,0);
        printf("Entre com a idade da pessoa:");
        scanf("%s",idade[contador]);
        
        printf("Entre com o telefone da pessoa:");
        scanf("%s",tel[contador]);
        
        printf("===============================================\n");
        textcolor_2(11,0);
        printf("Nome -----: %s\n",nome[contador]);
        printf("CPF ------: %s\n",cpf [contador]);
        printf("Idade ----: %s\n",idade[contador]);
        printf("Telefone -: %s\n",tel [contador]);
        printf("===============================================\n");
        textcolor_2(10,12);
        printf("\n ==> O valor de g eh %d  \n",g);
        sab[g]=nome[contador][0]; // aqui é atribuido ao vetor sab as iniciais dos nomes
        sabcpf[g]=cpf[contador][0];
        sabidade[g]=idade[contador][0];
        sabtel[g]=tel[contador][0];
        printf(" sab inicial do nome -: %c \n\n",sab[g]  );/* p/ imprimir letras use %c */
        printf(" contador ------------: %d \n\n",contador);
        textcolor_2(15,0);
        printf("Caso deseje continuar registrando dados digite qualquer número exceto o 0.\n");
        printf("Caso contrario, digite 0. ");
        scanf("%d",&i);
        /*if(i!=0){*//* precisa incrementar sempre */
            g++;
        /*}*/
        contador++; /* usado para inserir no vetor nome e como contador de registro */
    }while(i!=0);
    
    // O algoritmo BubbleSort a seguir ordena apenas as iniciais dos nomes pelos valores da tabela ASCII
    int cont, y, aux, c;
    for(cont=0; cont<g; cont++){
        for(y=cont+1; y<g; y++){
            
                if( sab[cont] > sab[   y]){
                
				
                printf("cont= %3d y= %3d\n",sab[cont],sab[y]);          /* ver as antes da troca */
                aux       = sab[cont] ;
                sab[cont] = sab[   y] ;
                sab[y]    = aux       ;
                printf("cont= %3d y= %3d     Tecle !\n",sab[cont],sab[y]);getch(); /* ver depois da troca */

                strcpy(aux_y     ,nome[cont]);                        /* organizar por nome */
                strcpy(nome[cont],nome[   y]);
                strcpy(nome[y]   ,aux_y     );
            
            }
    
	   
		}
    
	
	
	}
	
	int v;
	
	for(v=0; v<g; v++){
        FILE *file;
        file = fopen("bd.txt", "a");
    
        fprintf(file,"==========================================\n");
        fprintf(file,"Nome: %s\n", nome[v]);
        fprintf(file,"CPF: %s\n", cpf[v]);
        fprintf(file,"Idade: %s\n", idade[v]);
        fprintf(file,"Telefone: %s\n", tel[v]);
        fprintf(file,"==========================================\n\n");
        fclose(file);
			
        printf("==========================================\n");
        printf("Nome: %s\n", nome[v]);
        printf("CPF: %s\n", cpf[v]);
        printf("Idade: %s\n", idade[v]);
        printf("Telefone: %s\n", tel[v]);
        printf("==========================================\n\n");     
		
    }
    
	
	textcolor_2(12,14);
        printf("\n  Vetores em ordem crescente  \n\n");
        for(c=0; c<g; c++){
        textcolor_2(14,0);
        printf("O valor da posição %2d no vetor sab  eh %3d\n",c,sab[c]); /* letras são caracteres %c */
        textcolor_2(11,0);
        printf("O Nome  Na Posicao %2d Do Vetor Nome eh %s\n",c,nome[c]);
    }
    
    return 0;
}

 

 

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@LordScrew      para que os nomes correspondam a seus próprios dados você precisa altera-los na mesma hora que trocar os nomes lá no vetor , então dentro dos dois loops que trocam os nomes colocando eles em ordem alfabética , troque também os outros dados .

  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@devair1010 , fiz o que você falou e acho que consegui, amigo haha 😁.  Ficou assim:

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include <string.h>
#include <windows.h>
#define u GetStdHandle(STD_OUTPUT_HANDLE)
#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));
#define TAM 51
int main(void){
    char  nome[TAM][25], tel[TAM][25], cpf[TAM][25],
          idade[TAM][25],aux_y[25];
    int i=1,g=0,contador=0; 
    int sab[TAM],  sabcpf[TAM], sabidade[TAM], sabtel[TAM];// vetor que irá receber as iniciais dos nomes
    
    
    
    do {
        textcolor_2(14,0);
        printf("Entre com o nome da pessoa:");
        textcolor_2(11,0);
        scanf("%s",nome[contador]);
        
        printf("Entre com o CPF da pessoa:");
        scanf("%s",cpf[contador]);
        
        textcolor_2(14,0);
        printf("Entre com a idade da pessoa:");
        scanf("%s",idade[contador]);
        
        printf("Entre com o telefone da pessoa:");
        scanf("%s",tel[contador]);
        
        printf("===============================================\n");
        textcolor_2(11,0);
        printf("Nome -----: %s\n",nome[contador]);
        printf("CPF ------: %s\n",cpf [contador]);
        printf("Idade ----: %s\n",idade[contador]);
        printf("Telefone -: %s\n",tel [contador]);
        printf("===============================================\n");
        textcolor_2(10,12);
        printf("\n ==> O valor de g eh %d  \n",g);
        sab[g]=nome[contador][0]; // aqui é atribuido ao vetor sab as iniciais dos nomes
        sabcpf[g]=cpf[contador][0];
        sabidade[g]=idade[contador][0];
        sabtel[g]=tel[contador][0];
        printf(" sab inicial do nome -: %c \n\n",sab[g]  );/* p/ imprimir letras use %c */
        printf(" contador ------------: %d \n\n",contador);
        textcolor_2(15,0);
        printf("Caso deseje continuar registrando dados digite qualquer número exceto o 0.\n");
        printf("Caso contrario, digite 0. ");
        scanf("%d",&i);
        /*if(i!=0){*//* precisa incrementar sempre */
            g++;
        /*}*/
        contador++; /* usado para inserir no vetor nome e como contador de registro */
    }while(i!=0);
    
    // O algoritmo BubbleSort a seguir ordena apenas as iniciais dos nomes pelos valores da tabela ASCII
    int cont, y, aux, c;
    for(cont=0; cont<g; cont++){
        for(y=cont+1; y<g; y++){
            
                if( sab[cont] > sab[   y]){
                
				
                printf("cont= %3d y= %3d\n",sab[cont],sab[y]);          /* ver as antes da troca */
                aux       = sab[cont] ;
                sab[cont] = sab[   y] ;
                sab[y]    = aux       ;
                printf("cont= %3d y= %3d     Tecle !\n",sab[cont],sab[y]);getch(); /* ver depois da troca */

                strcpy(aux_y     ,nome[cont]);                        /* organizar por nome */
                strcpy(nome[cont],nome[   y]);
                strcpy(nome[y]   ,aux_y     );
                
                strcpy(aux_y     ,cpf[cont]);                        
                strcpy(cpf[cont],cpf[   y]);
                strcpy(cpf[y]   ,aux_y     );
                
                strcpy(aux_y     ,idade[cont]);                       
                strcpy(idade[cont],idade[   y]);
                strcpy(idade[y]   ,aux_y     );
                
                strcpy(aux_y     ,tel[cont]);                        
                strcpy(tel[cont],tel[   y]);
                strcpy(tel[y]   ,aux_y     );
                
            
            }
    
	   
		}
    
	
	
	}
	
	int v;
	
	for(v=0; v<g; v++){
        FILE *file;
        file = fopen("bd.txt", "a");
    
        fprintf(file,"==========================================\n");
        fprintf(file,"Nome: %s\n", nome[v]);
        fprintf(file,"CPF: %s\n", cpf[v]);
        fprintf(file,"Idade: %s\n", idade[v]);
        fprintf(file,"Telefone: %s\n", tel[v]);
        fprintf(file,"==========================================\n\n");
        fclose(file);
			
        printf("==========================================\n");
        printf("Nome: %s\n", nome[v]);
        printf("CPF: %s\n", cpf[v]);
        printf("Idade: %s\n", idade[v]);
        printf("Telefone: %s\n", tel[v]);
        printf("==========================================\n\n");     
		
    }
    
	
	textcolor_2(12,14);
        printf("\n  Vetores em ordem crescente  \n\n");
        for(c=0; c<g; c++){
        textcolor_2(14,0);
        printf("O valor da posição %2d no vetor sab  eh %3d\n",c,sab[c]); /* letras são caracteres %c */
        textcolor_2(11,0);
        printf("O Nome  Na Posicao %2d Do Vetor Nome eh %s\n",c,nome[c]);
    }
    
    return 0;
}

 

  • Obrigado 1
  • Confuso 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

@LordScrew e @devair1010, alguns pontos:

 

1) MÉTODO DE ORDENAÇÃO

Citando:

Em 25/11/2019 às 01:16, LordScrew disse:

    int cont, y, aux, c;
    for(cont=0; cont<g; cont++){
        for(y=cont+1; y<g; y++){
                if( sab[cont] > sab[   y]){

 

Este trecho NÃO é do Bubble Sort. O if do BS funciona "comparando a posição atual, com a posição posterior", assim como estava no seu código original:

 

Em 22/11/2019 às 20:47, LordScrew disse:

if (sab[y] > sab[y+1]) {


Ou seja: funciona como "uma BOLHA que vai flutuando os valores maiores para o fim do vetor". É esse if é que sintetiza a ideia do método... daí, as construções dos for também devem ser ajustados com esse princípio, é claro.

 

O Bubble Sort funciona assim:

Bubble-sort-300px.gif

 


Do jeito que ficou atualmente, ele está "comparando a posição atual, com cada uma das posições posteriores". Lá, a cada loop, a posição atual ficará com o menor valor!, daí vai para próxima posição, e repete o processo anterior, ou seja: É UM OUTRO ALGORITMO. 😃 (apesar do resultado ser igual [deixar ordenado], o processo está errado).

 

 

2) USO MAIS CORRETO DOS ARQUIVOS PARA O CONTEXTO DO ENUNCIADO

Basicamente o enunciado pede para ordenar um arquivo de texto utilizando o método de ordenação Bubble Sort... certo? mas no teu código, você está criando um vetor, ordenando esse vetor e após criando um arquivo baseado neste vetor... e não foi isto que foi pedido. Ele quer que você ordene o arquivo... os dados devem vir de lá! e não simplesmente "criar um arquivo com dados ordenados".

 

Você precisaria fazer o seguinte:

- criar um arquivo com os registros (cada um contendo nome, tel, cpf e idade)

- após, ordenar o arquivo tomando como referencia o nome, e utilizado o método de ordenação Bubble Sort.

 

 

3) NOMENCLATURA DE VARIÁVEIS
Procure usar nomenclaturas de variáveis mais sugestíveis... por exemplo: que raios significa "g"? rs. Pelo que eu vi ele está servindo para "contar" os registros... poderia se chamar cont ou contador. Então.. por sinal já existe uma variável contador no código. (repare como ele tem o mesmo valor de g).

 

 

SUGESTÃO

Separe as tarefas...

- Primeiro foque em construir um arquivo com os registros e após releia esse arquivo exibindo os registros na tela;

- Só depois focará em como ordenar os registros dos arquivos...

 

Resumindo: esqueça por enquanto o Bubble Sort.

 

DICA:

Para facilitar o processo de teste, subdivida esta tarefa... simplesmente crie um arquivo de texto já preenchido, daí leia os registros desse arquivo exibindo os dados na tela. Por que isso? por quê escrever no arquivo é fácil... difícil é extrair os dados corretamente (você vai entender quando for testar, rs). Então.... escrevendo um arquivo pelo por editor de texto, vai poupar o trabalho de ficar digitando um monte de dados, para só depois efetuar os testes de extração... Daí, após conseguir ler de boa, implementa o recurso para criar o arquivo pelo programa... ;)

 

Só após conseguir "escrever no arquivo" e "ler os dados deste arquivo corretamente", que vai entrar o processo de ordenação... (aqui, terá que analisar como vai funcionar o fluxo.. inclusive se vai poder utiliza vetores ou não, ou seja: talvez tenha que ordenada utilizando apenas o próprio arquivo... só vendo depois).

 

 

No aguardo.

  • Curtir 1
  • Obrigado 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 23/11/2019 às 08:09, devair1010 disse:

#define u GetStdHandle(STD_OUTPUT_HANDLE)

#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));

 

 Eu disse outro dia que não se justificava ter uma função como essa textcolor_2() e postei um #define para textcolor_2() com a ideia de mostrar que era meio besta existir tal função, mas parece que essa, como  gotoxy() já entraram para a cultura popular, talvez pela idade e alcance dos antigos compiladores da Borland e o header conio afinal.

 

Vi que trocou essa função por um #define --- dois na verdade --- em um programa que postou. E vou  dar uns palpites a mais, e espero não parecer arrogante ou off-topic. Espero que não se importe

 

Já escrevi isso outras vezes aqui: na console do Windows a cor é codificada em um único byte e é um bitmask. E em bitmask se usam operadores de bit, de modo que não se encontra na literatura algo como 

color = l+(f<<4));

por exemplo, como escreveu no #define. Pode ver isso em fontes do Windows, do Linux e milhões de códigos open source. Para configurar bitmasks se usa operadores de bit e o normal seria como postei

    color = letras|(fundo<<4); // em bitmasks, operadores bitwise

Imagino que tenha escrito 

#define u GetStdHandle(STD_OUTPUT_HANDLE)
#define textcolor_2(l,f) SetConsoleTextAttribute(u,l+(f<<4));

porque a linha ia ficar muito larga na tela. Note que os argumentos de um #define são expandidos ANTES da compilação então não precisa economizar e pode escrever algo mais legível, e que você pode continuar um macro --- #define --- por várias linhas, simplesmente usando um backslash "\" para indicar continuação, como em 

#define textcolor_2( letras,  fundo)       \
    SetConsoleTextAttribute(	           \
        GetStdHandle(STD_OUTPUT_HANDLE),   \
        (letras|(fundo<<4))	           \
    )

Talvez usar #define para as cores fosse prático também. algo como

#define        _preto_            0
#define        _azul_             1
#define        _verde_            2
#define        _ciano_            3
#define        _vermelho_         4
#define        _magenta_          5
#define        _marron_           6
#define        _cinza_claro_      7
#define        _cinza_escuro_     8
#define        _azul_claro_       9
#define        _verde_claro_     10
#define        _ciano_claro_     11
#define        _vermelho_claro_  12
#define        _magenta_claro_   13
#define        _amarelo_         14
#define        _branco_          15

Usei um underline antes e depois da cor para evitar colisão com variáveis do programa e para indicar que é uma constante criada por #define. É uma técnica comum. Os compiladores já mudam em geral a cor na edição do programa, e os __ ajudam a separar as coisas e a diminuir a preocupação com colisão de nomes

 

Isso substituiria o super chato enum com as cores. E você poderia escrever ao invés de 

textcolor_2(11,0);

o mais legível

textcolor_2( _ciano_claro_, _preto_ );

sem ter que declarar aquele enum

 

E o bloco de definições ficaria

#define		_preto_            0
#define		_azul_             1
#define		_verde_            2
#define		_ciano_            3
#define		_vermelho_         4
#define		_magenta_          5
#define		_marron_           6
#define		_cinza_claro_      7
#define		_cinza_escuro_     8
#define		_azul_claro_       9
#define		_verde_claro_     10
#define		_ciano_claro_     11
#define		_vermelho_claro_  12
#define		_magenta_claro_   13
#define		_amarelo_         14
#define		_branco_          15

#define textcolor_2( letras,  fundo)       \
    SetConsoleTextAttribute(	           \
        GetStdHandle(STD_OUTPUT_HANDLE),   \
        (letras|(fundo<<4))	               \
    )

:) Espero que ajude alguém

 

  • Obrigado 2

Compartilhar este post


Link para o post
Compartilhar em outros sites

@arfneto      obrigado , gostei muito dessa explicação   ,  eu nem sabia que se podia colocar comandos no define ,  e outro dia estava testando como diminuir o tamanho dessas funções gotoxy e textcolor e tive a ideia  de tentar colocar no define , aí no principio não deu certo e fui tentando até que o gotoxy funcionou , aí fiz no textcolor também  e deu bastante trabalho , fui criando vários códigos e testando e demorou as quatro horas até que funcionou ,  e para quem está começando essas funções são muito boas , pois acrescentam coisas interessantes a fazer , e não apenas uma tela preta que apenas imprime letras e números preto e branco ,   e  tem poucos dias que estudo a linguagem  c  ,  e de vez enquando tento fazer algo no c++ , mas esse parece mais difícil ,  e será que você pode me ajudar , estou querendo fazer um programa que copia a tela do pc , como o botão printscreen  ,  mas determinar a área onde copiar , informando isso no início do programa ,  tipo um label , e aí  dar run e copiar aquela área 25 vezes por segundo e já gravar essas fotos tiradas da tela , no hd ,  mas que o programa não mostre nenhuma janela enquanto copia a tela ,   já consegui um código que faz a captura dos pixeis da tela e até imprime esses mesmos pixeis em outra área da tela , por enquanto apenas para testar , e funcionou bem , mas não estou conseguindo gravar esass imagens no hd ,  você teria uma função que faça essa gravação ?   e também notei que para copiar uma pequena área o programa fica bem  lento , e se for uma área grande creio que seria extremamente lento , não conseguindo fazer 25 imagens por segundo .  teria outro modo de fazer essas cópias de maneira rápida ?    agradeço qualquer ajuda .

tenho esse código aqui   :

#if defined(UNICODE) && !defined(_UNICODE)
    #define _UNICODE
#elif defined(_UNICODE) && !defined(UNICODE)
    #define UNICODE
#endif

#include <tchar.h>
#include <windows.h>
#include <math.h>
#include <iostream>                          /* biblioteca para entrada e saida               */
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <cstring>
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
TCHAR szClassName[ ] = _T("Copiando Imagem Da Tela");
static int i,f;
int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) 5/*COLOR_BACKGROUND*/;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           _T("Copiando Imagem Da Tela , e um triangulo "), /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           1024,                 /* The programs width */
           600,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}

/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    HDC tela ;
    COLORREF clrf;
    static TCHAR frase[] = _T("Tecle ESC Para Sair !");
    PAINTSTRUCT ps ;
    int j,w;
    tela = GetDC (hwnd) ;
    switch (message)            /* handle the messages */
    {
        case WM_KEYDOWN:
            if (wParam == VK_ESCAPE) //  se pressionar a tecla ESC
                PostQuitMessage (0) ;
        case WM_PAINT :
            tela = BeginPaint (hwnd, &ps) ;
            TextOut(tela, 650, 50, frase, _tcslen(frase));// escreve mensagem na tela*/
            MoveToEx(tela,  static_cast<int>(sin(i*3.141615/180)*100+700),
                            static_cast<int>(cos(i*3.141615/180)*100+250),NULL) ;//posição de inicio do triangulo
            for(j=1;j<4;j++)
                LineTo(tela,static_cast<int>(sin((i+ j*120+00)*3.141615/180)*100+700) ,
                            static_cast<int>(cos((i+ j*120+00)*3.141615/180)*100+250));//vai para essas posições

            TextOut(tela, 650, 50, frase, _tcslen(frase));// escreve mensagem na tela
            i++;                               /* girar o triangulo */
            if(i>360)i=0;
            InvalidateRect (hwnd, NULL, TRUE) ;//limpa a tela*/
            EndPaint (hwnd, &ps) ;
            tela = GetDC(0);    /* precisa para pegar a cor */
            f++;
            if(f>1150)f=0;
            //Rectangle(tela,1098,348,1153,403);
            MoveToEx(tela,1099,349,0);
            LineTo  (tela,1151,349  );
            LineTo  (tela,1151,401  );
            LineTo  (tela,1099,401  );
            LineTo  (tela,1099,349  );
            for(w=0; w<50; w++)
                for(j=0; j<50; j++){
                    clrf=GetPixel(tela,w+f,j);/* pega a cor dessa posição da tela */
                    SetPixel(tela,w+1100,j+350,clrf);
                }

            /*
                aqui nessa parte
                quero salvar essas
                imagens em um arquivo

            */
            return 0 ;
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

 

adicionado 35 minutos depois

@Simon Viegas    pesquisei e vi que realmente esse código que postei ali em cima não é igual ao bubble sort , pois o segundo loop do bubble sort começa em zero e esse ali começa da posição do primeiro loop mais um , e vai até o final ,  então esse código de ordenação de vetor eu fiz sem ver isso em lugar algum , e de acordo com minhas ideias e por acaso funcionou até bem ,  e creio que seja melhor que o bubble sort pois ,  em ordem crescente , na primeira passada ele já define o menor , na segunda  define o que seja menor dos que ainda não foram ordenados , até chegar ao maior e o bubble sort  repete o segundo loop inteiro todas as vezes , e assim demora mais  .

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
2 horas atrás, devair1010 disse:

 tem poucos dias que estudo a linguagem  c  ,  e de vez enquando tento fazer algo no c++ , mas esse parece mais difícil

 

escrever em C é mais rápido e compacto mas pode ser bem mais difícil modelar uma solução sofisticada. Por outro lado em C++ você tem muito muito mais suporte da linguagem e das classes e da STL, a biblioteca gigante, com coisas como árvores, filas, conjuntos, pilhas, o diabo. Exceções definidas pelo usuário seria uma boa lembrança também. Mais opções de interface gráfica mais segurança de acesso e coisas assim. Sim, vai rodar mais devagar, mas nada perto de java ou Python. E você pode usar C e C++ sem stress no mesmo projeto. Em geral não é assim com outras linguagens.

 

2 horas atrás, devair1010 disse:

estou querendo fazer um programa que copia a tela do pc , como o botão printscreen  ,  mas determinar a área onde copiar , informando isso no início do programa

 

O Windows faz isso com Windows+shift+S há eras e já salva a imagem na área de transferência. Ou Windows+PrintScreen para copiar a tela inteira direto para a pasta Capturas de Tela no windows em português. E funciona muito bem. Mesmo para recortar áreas que estão em terminais separados, tipo um retângulo do centro de 3 telas numa máquina que tenha vários terminais. E seria o diabo programar algo assim. Como isso já faz parte do sistema você podia simular a sequência de teclas no seu programa e ficar com isso de graça. E depois usar a própria área de transferência para copiar o resultado para o seu programa.

 

2 horas atrás, devair1010 disse:

dar run e copiar aquela área 25 vezes por segundo e já gravar essas fotos tiradas da tela , no hd ,  mas que o programa não mostre nenhuma janela enquanto copia a tela

 

Também tem vários produtos, alguns grátis, que a gente usa para produzir material de treinamento por exemplo, e talvez pudesse ajudar a resolver seu problema ou inspirar sua solução.

Camtasia Studio é sensacional e pode ser usado por um mês de graça

TinyTake é bem legal e grátis

Flashback Pro é pago mas pode ser usado por 30 dias de graça. Bem legal

 

Sobre a performance na captura

Em geral se usa algum tipo de gatilho -- alarme -- para saber se algo mudou na tela entre cada acionamento para aumentar a performance. E mecanismos de comparação entre as telas para copiar só o que mudou. Uma boa razão para escrever em C++ seria usar DirectX ou OpenGL para tratar o vídeo. São as bibliotecas usadas por exemplo para escrever jogos então a performance é máxima.

 

Sobre C e C++

Uma boa maneira de aprender C++ é reescrever algo que escreveu ou conhece em C em C++. Minha opinião, claro. Alguma leitura sobre Objetos, Classes, Herança e Polimorfismo ajudaria pra caramba.  C++ é uma linguagem enorme e muito muito poderosa. Se tiver um projeto desse tipo, talvez eu possa te ajudar. 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites
Em 28/11/2019 às 21:03, Simon Viegas disse:

Ou seja: funciona como "uma BOLHA que vai flutuando os valores maiores para o fim do vetor". É esse if é que sintetiza a ideia do método... daí, as construções dos for também devem ser ajustados com esse princípio, é claro

 

:D Essa nomenclatura é mesmo folclórica. É muito comum a gente ler nos livros de referência explicação tentando a analogia com as bolhas subindo no líquido e depois ver aos autores descrevendo o algoritmo para classificar em ordem crescente e começando do primeiro, ou usando recursão a partir do penúltimo até reduzir o vetor a um elemento.

 

Como descrito aqui.

 

Mas então devia se chamar Anchor Sort, o sort da âncora, porque as bolhas como se sabe sobem. E o algoritmo geralmente publicado --- e até algumas animações que a gente vê por aí --- "desce" seguindo a lei da gravidade e afundando como uma âncora e não subindo como as bolhas. 

 

A implementação correspondente ao nome de bolha seria começar do fundo e comparar até o início de modo que o menor elemento fosse subindo como as tais bolhas afinal. 

 

  • Curtir 1

Compartilhar este post


Link para o post
Compartilhar em outros sites

Sobre:

Em 29/11/2019 às 15:15, devair1010 disse:

@Simon Viegas    pesquisei e vi que realmente esse código que postei ali em cima não é igual ao bubble sort , pois o segundo loop do bubble sort começa em zero e esse ali começa da posição do primeiro loop mais um , e vai até o final ,  então esse código de ordenação de vetor eu fiz sem ver isso em lugar algum , e de acordo com minhas ideias e por acaso funcionou até bem ,  e creio que seja melhor que o bubble sort pois ,  em ordem crescente , na primeira passada ele já define o menor , na segunda  define o que seja menor dos que ainda não foram ordenados , até chegar ao maior e o bubble sort  repete o segundo loop inteiro todas as vezes , e assim demora mais  .

 

Aí entra 2 pontos:

[1] o que proponho que está em jogo não é ser melhor; ou mais simples; ou mais eficiente etc, mas se está fazendo o que foi pedido. Eu costumo fazer a analogia, de algo como, ir a um Fast Food, pedir um cachorro-quente, e o garçom me trazer um apetitoso hambúrguer artesanal à moda da casa, ou seja: eu não quero um (supostamente) mais gostoso, eu quero comer um cachorro-quente e pronto! ("chama o gerente, por favor!"). O que poderiam-se fazer, por exemplo, é me oferecer uma mudança... ou seja: "mudar o enunciado". Ou faz o que foi pedido, ou muda o pedido...

 

Ah! eu acho que o cerne não está na construção dos for, mas sim na sentença de comparação:

 

Em 28/11/2019 às 21:03, Simon Viegas disse:

É esse if é que sintetiza a ideia do método... daí, as construções dos for também devem ser ajustados com esse princípio, é claro.

 

Ou seja: as "regras" dos for são feitas para se adequar ao if (que contém a característica da bolha). Ao mudar a sentença do if para outra, seria como mudar de salsicha do cachorro-quente para outra coisa... sei lá, para uma calabresa. Deixou de ser Bubble Sort, assim como deixaria de ser cachorro-quente.

 

[2] a segunda parte tem relação com a anterior... um outro ponto é das características do que foi pedido... aqui, mais uma vez fazendo uma analogia a um pedido no Fast Food, se eu pedir um cachorro-quente, poderia talvez entrar na questão das especificações desse cachorro-quente, algo como o tamanho, ingredientes, temperatura etc... a questão de ser bom ou não outra coisa! Também poderia entrar na questão de reanalisar o pedido (enunciado)... algo como "posso trazer qualquer cachorro-quente, ou tem que ter determinadas características específicas?". Um cachorro-quente simples (pão, salsicha e molho) frio é um cachorro-quente, assim como um completão...que vem até camarão no recheio, também é. Ambos são cachorros-quentes (ou não, né? - teria que ter outro debate sobre os limites, rs. Deixar a salsicha, como citado, seria um ponto importante para mim). Aqui, o que importa é se ainda é ou não o que estou pedindo, ou seja: um Bubble Sort lento poderia ser aprimorado para se tornar mais eficiente... ou não... mas o importante é que seja um Bubble Sort.

 

 

 

Sobre:

18 horas atrás, arfneto disse:

:D Essa nomenclatura é mesmo folclórica. É muito comum a gente ler nos livros de referência explicação tentando a analogia com as bolhas subindo no líquido e depois ver aos autores descrevendo o algoritmo para classificar em ordem crescente e começando do primeiro, ou usando recursão a partir do penúltimo até reduzir o vetor a um elemento.

 

Como descrito aqui.

 

Mas então devia se chamar Anchor Sort, o sort da âncora, porque as bolhas como se sabe sobem. E o algoritmo geralmente publicado --- e até algumas animações que a gente vê por aí --- "desce" seguindo a lei da gravidade e afundando como uma âncora e não subindo como as bolhas. 

 

A implementação correspondente ao nome de bolha seria começar do fundo e comparar até o início de modo que o menor elemento fosse subindo como as tais bolhas afinal. 

 

 

Boa questão.. não sei exatamente o porque dessa possível inversão da coisa 😁.. mas tomemos como o WIkipedia:

 

Citação

A ideia é percorrer o vector diversas vezes, e a cada passagem fazer flutuar para o topo o maior elemento da sequência. Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo.

https://pt.wikipedia.org/wiki/Bubble_sort

 

De alguma forma considerando o "fim do algoritmo" como sendo o topo, rs.

 

Acredito que seja mais voltado à direção do movimento, e não tanto para o seu sentido. Tanto que, para inverter de crescente para decrescente, talvez não faça diferença entre trocar apenas a condição do if de ">" pra "<", e em trocar o sentido da bolha (fazer o maior ir para base [início do vetor]). O importante que exista aqui lá "que vai comparando ao do lado".

 

 

@devair1010, nesse link fala e demonstra sobre a melhoria em evitar percorrer todo o vetor novamente, e sobre a melhoria d eparar caso não tenha ocorrido trocas (2 melhorias):

 

 

Usou esse link para demosntrar: https://visualgo.net/pt/sorting

Dá para brincar lá!

 

Mas perceba: a comparação é feita com a tal bolha, que vai flutuando até o "topo" (fim do vetor) e que e esse topo que vai ficando atualizado. Já ao mudar o if, como você fez, é a posição atual que vai ficar ordenada (início do vetor), onde vai sendo comparado a atual posição com cada uma das outras, ou seja: a bolha deixa de existir (tira a salsicha do cachorro-quente). Para comparar, no seu, um lado fica parado, o outro vai andando. No Bubble Sort, as duas referencias vão andando.

 

 

 

 

 

Aproveitando, segue um vídeo com demonstrações de funcionamento de 16 algoritmos:

 

 

 

A diferente de performance é bastante variada...

 

 

  • 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

×
×
  • Criar novo...