Arquivo da tag: C

Contador de Palavras – C

2 respostas

 


//================================================================
// Nome Do Arquivo: string_word_count.c
// File Name: string_word_count.c
//
// Descrição: O programa conta o número de palavras em uma string
//================================================================

// Protótipo da função
int string_word_count(char str[]);

// Libs
#include <stdio.h>
#include <stdlib.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str[100];
 int result;

 // Lê a url
 printf("Digite a string: ");
 gets(str);

 // Converte a string
 result = string_word_count(str);

 // Imprime o total de palavras
 printf("O resultado: %dn", result);

 system("pause");
 return 0;
}

int string_word_count(char str[]) {
 int i, result = 1;

 for(i = 0; str[i] != '&#092;&#048;'; i++) {
 if(str[i] == ' ') {
 result++;
 }
 }

 return result;
}

Conversor para Letras Minúsculas – C

Deixe um comentário 


//================================================================
// Nome Do Arquivo: string_to_lowercase.c
// File Name: string_to_to_lowercase.c
//
// Descrição: O programa muda todas as letras de uma string para
// mainúsculas. Não inclui letras com acentos ou
// cedilha.
//================================================================

// Protótipo da função
void string_to_lowercase(char str[]);

// Libs
#include <stdio.h>
#include <stdlib.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str[100];

 // Lê a url
 printf("Digite a string: ");
 gets(str);

 // Converte a string
 string_to_lowercase(str);

 // Imprime a string convertida
 printf("A string resultante: %sn", str);

 system("pause");
 return 0;
}

// A função muda todos as letras para minúsculas
void string_to_lowercase(char str[]) {
 int i;

 // Verifica cada caractere da string
 for(i = 0; str[i] != '&#092;&#048;'; i++) {
 // Verifica se é uma letra maiúscula
 // segundo a tabela ascii
 if(str[i] >= 65 && str[i] <= 90) {
 // Transforma em uma letra minúscula
 str[i] += 32;
 }
 }
}

Conversor para Letras Maiúsculas – C

Deixe um comentário 


//================================================================
// Nome Do Arquivo: string_to_uppercase.c
// File Name: string_to_uppercase.c
//
// Descrição: O programa muda todas as letras de uma string para
// maiúsculas. Não inclui letras com acentos ou cedilha
//================================================================

// Protótipo da função
void string_to_uppercase(char str[]);

// Libs
#include <stdio.h>
#include <stdlib.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str[100];

 // Lê a url
 printf("Digite a string: ");
 gets(str);

 // Converte a string
 string_to_uppercase(str);

 // Imprime a string convertida
 printf("A string resultante: %sn", str);

 system("pause");
 return 0;
}

// A função muda todos as letras para maiúsculas
void string_to_uppercase(char str[]) {
 int i;

 // Verifica cada caractere da string
 for(i = 0; str[i] != '&#092;&#048;'; i++) {
 // Verifica se é uma letra minúscula
 // segundo a tabela ascii
 if(str[i] >= 97 && str[i] <= 122) {
 // Transforma em uma letra maiúscula
 str[i] -= 32;
 }
 }
}

Inversor de URL – C

Deixe um comentário

 


//================================================================
// Nome Do Arquivo: string_reverse.c
// File Name: string_reverse.c
//
// Descrição: O programa inverte uma url e mostra o resultado.
//================================================================

// Protótipo da função
void string_reverse(char str[]);

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str[100];

 // Lê a url
 printf("Digite a url: ");
 gets(str);

 // Inverte a url
 string_reverse(str);

 // Imprime a url invertida
 printf("A url resultante: %sn", str);

 system("pause");
 return 0;
}

// A função inverte uma string
void string_reverse(char str[]) {
 int i, j, size;
 char *aux;

 // Calcula o tamanho da string original
 size = strlen(str);
 // Cria uma string auxiliar de mesmo tamanho
 aux = (char *)malloc(sizeof(char) * size);
 // Copia a string original para a auxiliar
 strcpy(aux, str);

 // Copia a string de forma ivertida
 // para a string original caracter por caracter
 for(i = (size-1), j = 0; i >= 0; i--, j++) {
 str[j] = aux[i];
 }

 // Marca o fim da string
 str[j] = '&#092;&#048;';
}

Comparador de Strings – C

Deixe um comentário 

//================================================================
// Nome Do Arquivo: string_compare.c
// File Name: string_compare.c
//
// Descrição: O programa compara duas strings e diz se são iguais
// ou diferentes.
//================================================================

// Protótipo da função comparadora de strings
int string_compare(char str1[], char str2[]);

// Libs
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str1[100], str2[100];

 // Lê a primeira string
 printf("Digite a primeira string: ");
 gets(str1);
 // Lê a segunda string
 printf("Digite a segunda string: ");
 gets(str2);

 // Copara se as strings são iguais e imprime o resultado
 if(string_compare(str1, str2)) {
 printf("Strings iguais.n");
 } else {
 printf("Strings diferentes.n");
 }

 system("pause");
 return 0;
}

// A função compara duas strings
// Se são iguais retorna 1
// Se são diferentes retorna 0
int string_compare(char str1[], char str2[]) {
 int i;

 for(i = 0; str1[i] != '&#092;&#048;', str2[i] != '&#092;&#048;'; i++) {
 if(str1[i] != str2[i]) {
 return 0;
 }
 }

 return 1;
}

Copiador de Strings – C

Deixe um comentário 

//================================================================
// Nome Do Arquivo: string_copy.c
// File Name: string_copy.c
//
// Descrição: O programa copia uma string em outra
//================================================================

// Protótipo da função copiadora de strings
void string_copy(char origin[], char destiny[]);

// Libs
#include &lt;stdio.h&gt;
#include &lt;stdlib.h&gt;

// Função main
// Main Function
int main(int argc, char** argv)
{
 char origin[100], destiny[100];

 // Lê a string a ser copiada
 printf(&quot;Digite a string: &quot;);
 gets(origin);

 // Copia a string para outra variável
 string_copy(origin, destiny);

 printf(&quot;A string resultante: %sn&quot;, destiny);

 system(&quot;pause&quot;);
 return 0;
}

// Função concatenadora de strings
void string_copy(char origin[], char destiny[]) {
 int i;

 // Copia a segunda string na primeira
 for(i = 0; origin[i] != '&#092;&#048;'; i++) {
 destiny[i] = origin[i];
 }

 // Marca o fim da string cópia
 destiny[i] = '&#092;&#048;';
}

Polígonos Aleatórios em Allegro – C

Deixe um comentário 

//================================================================
// Nome do Arquivo: random_polygons.c
// Filename: random_polygons.c
//
// Descrição: O programa exibe polígonos preenchidas em posições
//            e cores aleatórias, com 3 a 12 vértices, usando a
//            função polygon da biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Total de vértices e ponteiro de pontos do polígono
    int vertices, *points;
    // Cor do polígono
    int color;
    // Contador
    int i;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// A falta de acento é proposital
	// Muda o título da janela
	set_window_title("Poligonos");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Gera um total aleatório de vértices
	    vertices = (rand() % 10) + 3;
	    // Aloca memória para o polígono
	    points = (int *) malloc(sizeof(int) * vertices * 2);
	    // Gera os pontos do polígono de forma aleatória
	    for(i = 0; i &lt; vertices; i++) {
	         points[i * 2]     = rand() % 640;
	         points[i * 2 + 1] = rand() % 480;
        }
        // Cria uma cor aleatória
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha um polígono em uma posição e cor aleatória
	    polygon(screen, vertices, points, color);
	    free(points);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Triângulos Aleatórios em Allegro – C

Deixe um comentário 

//================================================================
// Nome do Arquivo: random_triangles.c
// Filename: random_triangles.c
//
// Descrição: O programa exibe triangulos preenchidas em posições e
//            cores aleatórias usando a função triangle da
//            biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Pontos do triângulo
    int x1, y1, x2, y2, x3, y3;
    // Cor da elipse
    int color;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// A falta de acento é proposital
	// Muda o título da janela
	set_window_title("Triangulos");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da elipse
	    x1 = rand() % 640;
	    y1 = rand() % 480;
	    x2 = rand() % 640;
	    y2 = rand() % 480;
	    x3 = rand() % 640;
	    y3 = rand() % 480;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha um triângulo em uma posição e cor aleatória
	    triangle(screen, x1, y1, x2, y2, x3, y3, color);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Curvas de Bezier Aleatórias em Allegro – C

Deixe um comentário 

//================================================================
// Nome do Arquivo: random_arcs.c
// Filename: random_arcs.c
//
// Descrição: O programa exibe curvas de bezier em posições e
//            cores aleatórias usando a função arc da biblioteca
//            allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Coordenadas dos 4 pontos de controle da curva
    int points[8];

    // Cor da curva
    int color;

    // Contador
    int i;

	// Inicializa a biblioteca Allegro
	allegro_init();

	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);

	// Muda o título da janela
	set_window_title("Curvas de Bezier");

	// Inicia o gerador de números aleatórios
	srand(time(NULL));

	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos da curva
	    for(i = 0; i &lt; 4; i++) {
	    	points[i*2] = rand() % 640;
	    	points[i*2 + 1] = rand() % 480;
     	}
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);

	    // Desenha uma curva de bezier em posição e cor aleatória
	    spline(screen, points, color);

	    // Espera 300 milisegundos para economizar processamento
	    rest(300);

		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();

Arcos aleatórios em Allegro – C

Deixe um comentário 

//================================================================
// Nome do Arquivo: random_arcs.c
// Filename: random_arcs.c  
//
// Descrição: O programa exibe arcos em posições e cores
//            aleatórias usando a função arc da biblioteca allegro
//================================================================

#include <stdlib.h>
#include <time.h>
#include <allegro.h>

int main(int argc, char *argv[])
{
    // Ponto central do arco, os ângulos de rotação e o raio
    int x, y, ang1, ang2, r;
	
    // Cor da elipse
    int color;
    
	// Inicializa a biblioteca Allegro
	allegro_init();
	
	// Inicializa o módulo do relógio
	install_timer();

	// Inicializa o teclado
	install_keyboard();

	// Define a profundidade de cores para 32 bits
	set_color_depth(32);

	// Define a resolução de 640x480 no modo janela
	set_gfx_mode(GFX_AUTODETECT_WINDOWED, 640, 480, 0, 0);
	
	// Muda o título da janela
	set_window_title("Arcs");
	
	// Inicia o gerador de números aleatórios
	srand(time(NULL));
	
	// Fica em loop até pressionar a tecla ESC
	while(!key[KEY_ESC])
	{
	    // Configura os atributos do arco
	    x      = rand() % 640;
	    y      = rand() % 480;
	    ang1   = rand() % 257;
	    ang2   = rand() % 257;
	    r      = rand() % 240;
	    color  = makecol(rand() % 256, rand() % 256, rand() % 256);
	    
	    // Desenha um arco em uma posição e cor aleatória
	    arc(screen, x, y, itofix(ang1), itofix(ang2), r, color);
	    
	    // Espera 300 milisegundos para economizar processamento
	    rest(300);
	    
		// Espera a sincronização vertical
		vsync();
	}

	// Sai do programa
	allegro_exit();
	return 0;     
}
// Esta macro converte o main para WinMain()
END_OF_MAIN();