Arquivo da tag: C

Concatenador de Strings – C

Deixe um comentário 
//================================================================
// Nome Do Arquivo: string_concatenar.c
// File Name: string_concatenar.c
//
// Descrição: O programa concatena duas strings na primeira delas
//================================================================

// Protótipo da função concatenatora de caracteres
void string_concatenar(char str1[], char str2[]);

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

// Função main
// Main Function
int main(int argc, char** argv)
{
 char str1[100], str2[100];
 
 // Lê as duas strings
 printf("Digite a primeira string: ");
 gets(str1);
 printf("Digite a segunda string: ");
 gets(str2);
 
 string_concatenar(str1, str2);
 
 printf("A string resultante: %sn", str1);
 
 system("pause");
 return 0;
}

// Função concatenadora de strings
void string_concatenar(char str1[], char str2[]) {
	int i, j;
	
	// Avança até o fim da primeira string
	for(i = 0; str1[i] != '&#092;&#048;'; i++);
	
	// Copia a segunda string na primeira
	for(j = 0; str2[j] != '&#092;&#048;'; j++, i++) {
		str1[i] = str2[j];
	}
	
	// Marca o fim da string concatenada
	str1[i] = '&#092;&#048;';
}

Contador de Caracteres em String – C

Deixe um comentário 
//================================================================
// Nome Do Arquivo: string_count.c
// File Name: string_count.c
//
// Descrição: O programa conta o número de caracteres em uma
// 			  string e exibe na tela.
//================================================================

// Protótipo da função contadora de caracteres
int string_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 contador;
 
 printf("Digite uma palavra: ");
 gets(str);
 
 contador = string_count(str);
 
 printf("A string possui %d caracteres.n", contador);
 
 system("pause");
 return 0;
}

int string_count(char str[]) {
	int i;
	
	for(i = 0; str[i] != '&#092;&#048;'; i++);
	
	return i;
}

Algoritmo Gerador de CNPJ em C

Deixe um comentário 

//================================================================
// Nome Do Arquivo: cnpj.c
// File Name: cnpj.c
//
// Descrição: Implementação do algoritmo gerador de cnpj
//================================================================

// Protótipo da função geradora de CNPJ
int* cnpj_generator();

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

// Função main
// Main Function
int main(int argc, char** argv)
{
 int *cnpj, i;

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

 // Gera um cpf aleatório
 cnpj = cnpj_generator();

 // Imprime o cnpj gerado na tela
 for(i = 0; i < 14; i++) {
 printf("%d", cnpj[i]);
 }
 printf("n");

 system("pause");

 // Libera a memória usada para o cnpj
 free(cnpj);
 return 0;
}

// Função Geradora de CNPJ
int* cnpj_generator() {
 int *cnpj, pesos[14], vetSoma[14], soma, resto, digito, i;

 // Aloca memória para o cnpj
 cnpj = (int *) malloc(sizeof(int) * 14);

 // Gera 12 números aleatórios
 for(i = 0; i < 12; i++) {
 cnpj[i] = rand() % 10;
 }

 // Cálculo do primeiro dígito verificador

 // Gera os 12 pesos
 for(i = 0; i < 4; i++) {
 pesos[i] = 5 - i;
 }
 for(i = 4; i< 12; i++) {
 pesos[i] = 13 - i;
 }

 // Multiplica os valores de cada coluna
 for(i = 0; i < 12; i++) {
 vetSoma[i] = cnpj[i] * pesos[i];
 }

 // Calcula o somatório dos resultados
 soma = 0;
 for(i = 0; i < 12; i++) {
 soma += vetSoma[i];
 }

 // Realiza-se a divisão inteira do resultado por 11
 resto = soma % 11;

 // Verifica o resto da divisão
 if(resto < 2) {
 digito = 0;
 } else {
 digito = 11 - resto;
 }

 // Adiciona o 1º dígito verificador ao cpf
 cnpj[12] = digito;

 // Cálculo do segundo dígito verificador

 // Gera os 13 pesos
 for(i = 0; i < 5; i++) {
 pesos[i] = 6 - i;
 }
 for(i = 5; i< 13; i++) {
 pesos[i] = 14 - i;
 }

 // Multiplica os valores de cada coluna
 for(i = 0; i < 13; i++) {
 vetSoma[i] = cnpj[i] * pesos[i];
 }

 // Calcula o somatório dos resultados
 soma = 0;
 for(i = 0; i < 13; i++) {
 soma += vetSoma[i];
 }

 // Realiza-se a divisão inteira do resultado por 11
 resto = soma % 11;

 // Verifica o resto da divisão
 if(resto < 2) {
 digito = 0;
 } else {
 digito = 11 - resto;
 }

 // Adiciona o 2º dígito verificador ao cpf
 cnpj[13] = digito;

 return cnpj;
}

Algoritmo Gerador de CPF em C

Deixe um comentário 
//================================================================
// Nome Do Arquivo: cpf.c
// File Name: cpf.c
//
// Descrição: Implementação do algoritmo gerador de cpf
//================================================================

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

// Protótipo da função geradora de CPF
int* cpf_generator();

// Função main
// Main Function
int main(int argc, char** argv)
{
 int *cpf, i;
 
 // Inicia o gerador de números aleatórios
 srand(time(NULL));
 
 // Gera um cpf aleatório
 cpf = cpf_generator();
 
 // Imprime o cpf gerado na tela
 for(i = 0; i < 11; i++) {
  printf("%d", cpf[i]);
 }
 printf("n");
 
 system("pause");
 
 // Libera a memória usada para o cpf
 free(cpf);
 return 0;
}

// Função Geradora de CPF
int* cpf_generator() {
	int *cpf, pesos[11], vetSoma[11], soma, resto, digito,  i;
	
	// Aloca memória para o cpf
	cpf = (int *) malloc(sizeof(int) * 11);
	
	// Gera 9 números aleatórios
	for(i = 0; i < 9; i++) {
		cpf[i] = rand() % 10;
	}
	
	// Cálculo do primeiro dígito verificador
	
	// Gera os 9 pesos
	for(i = 0; i < 9; i++) {
		pesos[i] = 10 - i;
	}
	
	// Multiplica os valores de cada coluna
	for(i = 0; i < 9; i++) {
		vetSoma[i] = cpf[i] * pesos[i];
	}
	
	// Calcula o somatório dos resultados
	soma = 0;
	for(i = 0; i < 9; i++) {
		soma += vetSoma[i];
	}
	
	// Realiza-se a divisão inteira do resultado por 11
	resto = soma % 11;
	
	// Verifica o resto da divisão
	if(resto < 2) {
		digito = 0;
	} else {
		digito = 11 - resto;
	}
	
	// Adiciona o 1º dígito verificador ao cpf
	cpf[9] = digito;
	
	// Cálculo do segundo dígito verificador
	
	// Gera os 10 pesos
	for(i = 0; i < 10; i++) {
		pesos[i] = 11 - i;
	}
	
	// Multiplica os valores de cada coluna
	for(i = 0; i < 10; i++) {
		vetSoma[i] = cpf[i] * pesos[i];
	}
	
	// Calcula o somatório dos resultados
	soma = 0;
	for(i = 0; i < 10; i++) {
		soma += vetSoma[i];
	}
	
	// Realiza-se a divisão inteira do resultado por 11
	resto = soma % 11;
	
	// Verifica o resto da divisão
	if(resto < 2) {
		digito = 0;
	} else {
		digito = 11 - resto;
	}
	
	// Adiciona o 2º dígito verificador ao cpf
	cpf[10] = digito;
	
	return cpf;
}

Algoritmo Quick Sort em C (Quicksort)

6 respostas 
//================================================================
// Nome Do Arquivo: quick.c
// File Name: quick.c
//
// Descrição: Implementação do algoritmo quicksort
// Description: Quick sort Algorithm
//================================================================

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

// Define uma constante
// Define a constant
#define MAX 10

// Protótipo da função de ordenação
// Ordination function prototype
void quick_sort(int *a, int left, int right);

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

 // Lê MAX ou 10 valores
 // Read MAX or 10 values
 for(i = 0; i < MAX; i++)
 {
  printf("Digite um valor: ");
  scanf("%d", &vet[i]);
 }

 // Ordena os valores
 // Order values
 quick_sort(vet, 0, MAX - 1);

 // Imprime os valores ordenados
 // Print values in order ascendant
 printf("nnValores ordenadosn");
 for(i = 0; i < MAX; i++)
 {
  printf("%dn", vet[i]);
 }
 system("pause");
 return 0;
}

// Função de Ordenação por Seleção
// Quick sort function
void quick_sort(int *a, int left, int right) {
	int i, j, x, y;
	
	i = left;
	j = right;
	x = a[(left + right) / 2];
	
	while(i <= j) {
		while(a[i] < x && i < right) {
			i++;
		}
		while(a[j] > x && j > left) {
			j--;
		}
		if(i <= j) {
			y = a[i];
			a[i] = a[j];
			a[j] = y;
			i++;
			j--;
		}
	}
	
	if(j > left) {
		quick_sort(a, left, j);
	}
	if(i < right) {
		quick_sort(a, i, right);
	}
}

Algoritmo de Ordenação por Seleção em C (Selection Sort)

Deixe um comentário 
//================================================================
// Nome Do Arquivo: selection.c
// File Name: selection.c
//
// Descrição: Implementação do algoritmo de ordenação por seleção
// Description: Selection sort Algorithm
//================================================================

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

// Define uma constante
// Define a constant
#define MAX 10

// Protótipo da função de ordenação
// Ordination function prototype
void selection_sort(int *a);

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

 // Lê MAX ou 10 valores
 // Read MAX or 10 values
 for(i = 0; i &lt; MAX; i++)
 {
  printf(&quot;Digite um valor: &quot;);
  scanf(&quot;%d&quot;, &amp;vet[i]);
 }

 // Ordena os valores
 // Order values
 selection_sort(vet);

 // Imprime os valores ordenados
 // Print values in order ascendant
 printf(&quot;nnValores ordenadosn&quot;);
 for(i = 0; i &lt; MAX; i++)
 {
  printf(&quot;%dn&quot;, vet[i]);
 }
 system(&quot;pause&quot;);
 return 0;
}

// Função de Ordenação por Seleção
// Selection sort function
void selection_sort(int *a)
{
 int i, j, k, tmp, troca;
 
 for(i = 0; i &lt; MAX-1; i++)
 {
  troca = 0;
  k = i;
  tmp = a[i];
  for(j = i+1; j &lt; MAX; j++)
  {
   if(a[j] &lt; tmp)
   {
    k = j;
    tmp = a[j];
    troca = 1;
   }
  }
  if(troca)
  {
   a[k] = a[i];
   a[i] = tmp;
  }
 }
}

Algoritmo de Ordenação por Inserção em C (Insertion Sort)

1 resposta 
//================================================================
// Nome Do Arquivo: insertion.c
// File Name: insertion.c
//
// Descrição: Implementação do algoritmo de ordenação por inserção
// Description: Insertion sort Algorithm
//================================================================

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

// Define uma constante
// Define a constant
#define MAX 10

// Protótipo da função de ordenação
// Ordination function prototype
void insertion_sort(int *a);

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

 // Lê MAX ou 10 valores
 // Read MAX or 10 values
 for(i = 0; i < MAX; i++)
 {
  printf("Digite um valor: ");
  scanf("%d", &vet[i]);
 }

 // Ordena os valores
 // Order values
 insertion_sort(vet);

 // Imprime os valores ordenados
 // Print values in order ascendant
 printf("nnValores ordenadosn");
 for(i = 0; i < MAX; i++)
 {
  printf("%dn", vet[i]);
 }
 system("pause");
 return 0;
}

// Função de Ordenação por Inserção
// Insertion sort function
void insertion_sort(int *a)
{
 int i, j, tmp;
 
 for(i = 1; i < MAX; i++)
 {
  tmp = a[i];
  for(j = i-1; j >= 0 && tmp < a[j]; j--)
  {
   a[j+1] = a[j];
  }
  a[j+1] = tmp;
 }
}

Algoritmo de Ordenação Shell em C (Shell Sort)

Deixe um comentário 
//================================================================
// Nome Do Arquivo: shell.cpp
// File Name: shell.cpp
//
// Descrição: Implementação do algoritmo de ordenação Shell
// Description: Shellsort Algorithm
//================================================================

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

// Define uma constante
// Define a constant
#define MAX 10

// Protótipo da função de ordenação
// Ordination function prototype
void shell_sort(int *a, int size);

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

 // Lê MAX ou 10 valores
 // Read MAX or 10 values
 for(i = 0; i < MAX; i++)
 {
  printf("Digite um valor: ");
  scanf("%d", &vet[i]);
 }

 // Ordena os valores
 // Order values
 shell_sort(vet, MAX);

 // Imprime os valores ordenados
 // Print values in order ascendant
 printf("nnValores ordenadosn");
 for(i = 0; i < MAX; i++)
 {
  printf("%dn", vet[i]);
 }
 system("pause");
 return 0;
}

// Função de ordenação Shell
// Shellsort function
void shell_sort(int *a, int size)
{
 int i , j , value;
 int gap = 1;
 
 do {
  gap = 3*gap+1;
 } while(gap < size);
 
 do {
  gap /= 3;
  for(i = gap; i < size; i++) {
   value = a[i];
   j = i - gap;
   
   while (j >= 0 && value < a[j]) {
    a[j + gap] = a[j];
    j -= gap;
   }
   a[j + gap] = value;
  }
 }while(gap > 1);
}

Algoritmo de Ordenação Bolha em C (Bubble Sort)

Deixe um comentário 
//================================================================
// Nome Do Arquivo: bubble.cpp
// File Name: bubble.cpp
//
// Includes: stdio.h
//
// Descrição: Implementação do algoritmo de ordenação por seleção
// Description: Bubble Sort Algorithm
//================================================================

// Define uma constante
// Define a constant
#define MAX 10

// Protótipo da função de ordenação
// Ordination function prototype
void bubble_sort(int *a);

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

 // Lê MAX ou 10 valores
 // Read MAX or 10 values
 for(i = 0; i < MAX; i++)
 {
  printf("Digite um valor: ");
  scanf("%d", &vet[i]);
 }

 // Ordena os valores
 // Order values
 bubble_sort(vet);

 // Imprime os valores ordenados
 // Print values in order ascendant
 printf("nnValores ordenadosn");
 for(i = 0; i < MAX; i++)
 {
  printf("%dn", vet[i]);
 }

 return 0;
}

// Função de ordenação bolha
// Bubble sort function
void bubble_sort(int *a)
{
 int i, j, tmp;

  for(i = 0; i < MAX; i++)
  {
   for(j = i+1; j < MAX; j++)
   {
    if(a[j] < a[i])
    {
     tmp = a[i];
     a[i] = a[j];
     a[j] = tmp;
    }
  }
 }
}