Inclusão e exclusão de elementos em uma pilha

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

int empilhar(int *pilha, int elemento, int tam, int *pont)
{
    if(tam==*pont)
    {
        printf("\nPilha cheia!\n");
        return 0;
    }
    else{
        pilha[*pont]=elemento;
        *pont=*pont+1;
        return 1;
    }
}

int desempilhar(int *pilha, int tam, int *pont){
    if(*pont==0)
    {
        printf("\nPilha ja vazia!\n");
        return 0;
    }
    else{
        *pont=*pont-1;
        pilha[*pont]=NULL;
        return 1;
    }
}
int main() {

    char op;
    int ok, tam, *pilha, elemento,pont=0,i;
    printf("Informe o tamanho desejado para a pilha: ");
    scanf("%d",&tam);
    if((pilha=(int*)malloc(tam*sizeof(int)))==NULL) exit(1);
    do{
        printf("\n(e)mpilhar (d)esempilhar (s)air: ");
        getchar();
        scanf("%c",&op);
        switch (op){
            case 'e':
                printf("\nInforme o elemento a ser inserido: ");
                scanf("%d",&elemento);
                ok=empilhar(pilha,elemento,tam,&pont);
                if(ok)printf("\nEmpilhamento feito com sucesso!\n");
                else printf("\nNao foi possivel inserir o novo elemento\n");
                for(i=0;i<tam;i++){
                printf("%d\t",pilha[i]);}
                printf("\n");
                break;
            case 'd':
                ok=desempilhar(pilha,tam,&pont);
                if(ok)printf("\nElemento retirado com sucesso!\n");
                else printf("\nNao foi possivel retirar o elemento\n");
                for(i=0;i<tam;i++){
                printf("%d\t",pilha[i]);}
                printf("\n");
                break;
        }
    }while(op!='s');
    return 0;
}

Inclusão e exclusão de elementos em uma fila circular

#include <stdio.h>
#include <stdlib.h>
void entrar(int *fila,int v,int tam,int *ini,int *fim)
{
    int prov = (*fim+1) % (tam);
    if(prov != *ini)
    {
        *fim=prov;
        fila[*fim]=v;
        if(*ini==-1) *ini=0;
    }
    else printf("\nFila cheia!\n");
}
int sair(int *fila,int tam, int *ini,int *fim) {
    int v;
    if( *ini != -1 )
    {
        v=fila[*ini];
        if(*ini==*fim)
        {
            fila[*ini]=NULL;
            *ini=*fim=-1;
        }
        else
        {
            fila[*ini]=NULL;
            *ini = (*ini+1) % tam;
        }
        return v;
    }
    else {
        printf("\nFila vazia!\n");
        return -1;
    }
}

int main() {

    char op;
    int ok, tam, *fila, elemento,ini=-1,fim=-1,i;
    printf("Informe o tamanho desejado para a fila: ");
    scanf("%d",&tam);
    if((fila=(int*)malloc(tam*sizeof(int)))==NULL) exit(1);
    do{
        printf("\n(e)ntrar (s)air (f)echar: ");
        getchar();
        scanf("%c",&op);
        switch (op){
            case 'e':
                printf("\nInforme o elemento a ser inserido: ");
                scanf("%d",&elemento);
                entrar(fila,elemento,tam,&ini,&fim);
                break;
            case 's':
                ok=sair(fila,tam,&ini,&fim);
                printf("\nO elemento retirado foi: %d.\n",ok);
                break;
        }
        for(i=0;i<tam;i++) printf("%d\t",fila[i]);
        printf("\n");
    }while(op!='f');
    return 0;
}

Busca binária em uma struct

Lembrando que quando o usuário for entrar com as chaves (int), elas deverão estar em ordem, ou a busca binária não funcionará.

#include<stdio.h>
struct TPessoa{
int chave;
char nome[40];
};
struct TPessoa v[10];

int buscaBin(int tam,struct TPessoa v[], int pesq)
{
int ini=0,fim=tam-1,meio;
while(ini<=fim)
{
meio=(ini+fim)/2;
if(pesq==v[meio].chave) return meio;
else if(v[meio].chave<pesq) ini=meio+1;
else fim=meio-1;
}
return -1;

}
int main ()
{
int busca, i;
char ret;
printf("Informe os dados a serem armazenados:\n");
for(i=0;i<10;i++)
{
printf("\nChave: ");
scanf("%d",&v[i].chave);
getchar();
printf("Nome: ");
gets(v[i].nome);
}
printf("\nInforme a chave a ser encontrada: ");
scanf("%d",&busca);
ret=buscaBin(10,v,busca);
if(ret==-1)
printf("\nNao encontrado!\n\n");
else
printf("\nA chave foi encontrada e o %cndice correspondente %c %d. O nome que se encontra neste %cndice %c %s.\n\n",161,130,ret,161,130,v[ret].nome);

return 0;
}

Inclusão e exclusão em uma lista sequencial - modo fila

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

int inserir(int *fila, int elemento, int tam, int *ini,int *fim)
{
    if(*ini==*fim && *fim==-1)
    {
        fila[++*fim]=elemento;
        *ini=0;
        return 1;
    }
    if(*fim==(tam-1) && *ini==0)
    {
        printf("\nFila cheia!\n");
        return 0;
    }
    if(*fim==(tam-1))
    {
        int i;
        *fim=-1;
        for(int k=*ini;k<tam;k++)
        {
            fila[i++]=fila[k];
            fila[k]=NULL;
            *fim=*fim+1;
        }
        *ini=0;
    }
    fila[++*fim]=elemento;
    return 1;
}
  
int retirar(int *fila, int tam, int *ini,int *fim)
{
    if(*fim==*ini && *fim==-1)
        {
            printf("\nFila ja vazia!\n");
            return 0;
        }
    if(*fim==*ini)
        {
            fila[*ini]=NULL;
            *ini=-1;
            *fim=-1;
            return 1;
        }
    fila[*ini]=NULL;
    *ini=*ini+1;
    return 1;
}
int main() {

    char op;
    int ok, tam, *fila, elemento,ini=-1,fim=-1,i;
    printf("Informe o tamanho desejado para a fila: ");
    scanf("%d",&tam);
    if((fila=(int*)malloc(tam*sizeof(int)))==NULL) exit(1);
    do{
        printf("\n(i)nserir (r)etirar (s)air: ");
        getchar();
        scanf("%c",&op);
        switch (op){
            case 'i':
                printf("\nInforme o elemento a ser inserido: ");
                scanf("%d",&elemento);
                ok=inserir(fila,elemento,tam,&ini,&fim);
                if(ok)printf("\nElemento inserido com sucesso!\n");
                else printf("\nNao foi possivel inserir o novo elemento\n");
                break;
            case 'r':
                ok=retirar(fila,tam,&ini,&fim);
                if(ok)printf("\nElemento retirado com sucesso!\n");
                else printf("\nNao foi possivel retirar o elemento\n");
                break;
        }
        for(i=0;i<tam;i++) printf("%d\t",fila[i]);
        printf("\n");
    }while(op!='s');
    return 0;
}

Distância entre dois pontos com struct

#include<stdio.h>
#include<math.h>
struct Ponto{
    int x,y;
};
void main()
{
    struct Ponto p[2];
    float dist;
    printf("Informe a posi%c%co do primeiro ponto (x,y): ",135,198);
    scanf("%d%d",&p[0].x,&p[0].y);
    printf("Informe a posi%c%co do segundo ponto (x,y): ",135,198);
    scanf("%d%d",&p[1].x,&p[1].y);
    dist=sqrt(pow((float)(p[1].y-(float)p[0].y),2)+pow((float)(p[1].x-(float)p[0].x),2));
    printf("A dist%cncia entre os pontos %c: %.2f\n\n",131,130,dist);
}

Multiplicação de matrizes alocadas dinamicamente em C

#include<stdio.h>
#include<stdlib.h>
int** aloca (int linha,int coluna)
{
int **matriz,i;
if((matriz=(int **)malloc(coluna*sizeof(int*)))==NULL)
{
printf("Mem%cria n%co dispon%cvel!",162,198,161);
exit(1);
}
else
{
for(i=0;i<linha;i++)
{
if((matriz[i]=(int *)malloc(coluna*sizeof(int)))==NULL)
{
printf("Mem%cria n%co dispon%cvel!",162,198,161);
exit(1);
}
}
}
return matriz;
}
void le_matriz (int **matriz,int linha,int coluna)
{
int i,j;
for(i=0;i<linha;i++)
{
for(j=0;j<coluna;j++)
{
printf("\nPosi%c%co %d%d: ",135,198,i+1,j+1);
scanf("%d",&matriz[i][j]);
}
}
return;
}
void multiplica (int **matriz_final,int **matriz1,int **matriz2,int l1,int c2,int l2)
{
int i,j,k;
for(i=0;i<l1;i++)
{
for(j=0;j<c2;j++)
{
matriz_final[i][j]=0;

for(k=0;k<l2;k++)
{
matriz_final[i][j]=matriz_final[i][j]+(matriz1[i][k]*matriz2[k][j]);
}
}
}
}
void imprime (int **matriz,int linha,int coluna)
{
int i,j;
for(i=0;i<linha;i++)
{
printf("%c",186);
for(j=0;j<coluna;j++)
{
printf("\t%d",matriz[i][j]);
}
printf("\t%c\n",186);
}
return;
}
int main()
{
    int **matriz1,**matriz2,**matriz_final,l1,c1,l2,c2;
printf("Informe o n%cmero de linhas e colunas da primeira matriz respectivamente: ",163);
scanf("%d%d",&l1,&c1);
printf("Informe o n%cmero de linhas e colunas da segunda matriz respectivamente: ",163);
    scanf("%d%d",&l2,&c2);
if(l2!=c1){printf("N%co %c poss%cvel realizar a multiplica%c%co com os dados informados!\n\n",198,130,161,135,198);exit(1);}
matriz1=aloca(l1,c1);
matriz2=aloca(l2,c2);
printf("\nMatriz 1:");
le_matriz(matriz1,l1,c1);
imprime(matriz1,l1,c1);
printf("\nMatriz 2:\n");
le_matriz(matriz2,l2,c2);
imprime(matriz2,l2,c2);
matriz_final=aloca(l1,c2);
multiplica(matriz_final,matriz1,matriz2,l1,c2,l2);
printf("\n\nMatriz resultante da multiplica%c%co das matrizes 1 e 2:\n",135,198);
imprime(matriz_final,l1,c2);
return 0;
 }

Lista Encadeada em C (Matrícula e nome)

#include <stdio.h>
#include<stdlib.h>
struct registro
{
    long int matricula;
    char nome[81];
    struct registro *next;
};
struct registro *raiz;
void adiciona()
{
    struct registro *novoreg=(struct registro*)malloc(sizeof(struct registro));
    if(novoreg==NULL){printf("Mem%cria insuficiente!",162); exit(1);}
    printf("\nInforme a matr%ccula do funcion%crio: ",161,160);
    scanf("%d",&novoreg->matricula);
    getchar();
    printf("Informe o nome: ");
    gets(novoreg->nome);
    novoreg->next=raiz->next;
    raiz->next=novoreg;
}
void exclui()
{
    struct registro *reg_atual, *reg_ant;
    long int matric;
    reg_atual=raiz->next;
    reg_ant = raiz;   
    printf("\nInforme a matr%ccula do funcion%crio que ser%c exclu%cdo: ",161,160,160,161);
    scanf("%d",&matric);
    while(reg_atual!=NULL)
    {
        if(matric==reg_atual->matricula)
        {
            reg_ant->next=reg_atual->next;
            printf("\nMatr%ccula exclu%cda com sucesso!",161,161);
            free(reg_atual);
            return;
        }
        reg_ant = reg_atual;
        reg_atual=reg_atual->next;
    }       
    printf("Matr%ccula n%co encontrada!\n",161,198);
}
void imp_lista()
{
    struct registro *lista;
    lista=raiz->next;
    if(lista==NULL)
    {
        printf ("\n\n\a\a\a\a\tLista Vazia\n");
        system ("pause");
        exit(1);
    }
    else
    {
        while(lista!=NULL)
        {
            printf("\nMatr%ccula: %d",161,lista->matricula);
            printf("\nFuncion%crio: %s",160,lista->nome);
            lista=lista->next;
        }
    }
}

int main ()
{
    int op=3;
    raiz=(struct registro *)malloc(sizeof (struct registro));
    if(raiz==NULL) exit(1);
    raiz->next=NULL;
    do
    {
        printf("Digite 1 para adicionar um novo registro, 2 para excluir, 3 para listar e 4 para sair: ");
        scanf("%d",&op);
        if(op==1)adiciona();
        else if(op==2)exclui();
        else if(op==3)imp_lista();
        else if(op==4)exit(1);
        printf("\n");
    }while(op!=4);
    free(raiz);
    return 0;
}

Função que recebe um vetor de char e retorna um ponteiro com o vetor duplicado

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
char* dupl(char *s)
{
char *n_local;
int qtd;
qtd=strlen(s);
if((n_local=(char*)malloc((2*qtd+1)*(sizeof(char))))==NULL)
{
printf("Espaço insuficiente!");
exit(1);
}
strcpy(n_local,s);
strcat(n_local,s);
return n_local;
}

int main()
{
char cadeia[50],*c_final;
printf("Informe uma cadeia de caracteres: ");
gets(cadeia);
c_final=dupl(cadeia);
printf("%s",c_final);
printf("\n\n");
free(c_final);
return 0;
}

Alocação dinâmica em vetor

#include<stdio.h>
#include<stdlib.h>
int main()
{
int *vet,quant_int,i;
printf("Quantos inteiros serao armazenados?");
scanf("%d",&quant_int);
if((vet=(int*)malloc(quant_int*sizeof(int)))==NULL)
{
printf("Espaço insuficiente!"); exit(1);
}
for(i=0;i<quant_int;i++)
{
printf("\nInforme o valor da pos%d: ",i+1);
scanf("%d",&vet[i]);
}
for(i=0;i<quant_int;i++)
{
printf("\nvet%d: %d",i+1,vet[i]);
}
printf("\n\n");
free(vet);
return 0;
}

Ponteiros

http://www.juliobattisti.com.br/tutoriais/katiaduarte/cbasico007.asp - Ponteiros - descrições e usos
http://www.juliobattisti.com.br/tutoriais/katiaduarte/cbasico008.asp - Ponteiros - chamadas por referência
http://www.juliobattisti.com.br/tutoriais/katiaduarte/cbasico009.asp - Ponteiros - alocação dinâmica

Texto na íntegra: http://www.2shared.com/file/bkYn4ZW9/PONTEIROS.html

Série de Fibonacci em C (Com recursão)

#include<stdio.h>
void preencherSerieFibonacciRec(int v[],int tam)
{
 int fim=tam-1;
 if(tam==1)v[0]=0;
 if(tam==2)v[0]=0;v[1]=1;
 if(tam>2)
 {
  preencherSerieFibonacciRec(v,fim);
  v[fim]=v[fim-1]+v[fim-2];
 }

}
int main (void)
{
 int v[30],tam,i;
 printf("Informe o tamnho da serie de fibonacci (maximo=30):\n");
 scanf("%d",&tam);
 preencherSerieFibonacciRec(v,tam);
 while(tam>30)
 {
  printf("Informe um valor ate 30!");
  scanf("%i",&tam);
 }
 for(i=0;i<tam;i++) printf("%d ",v[i]);
 getchar();
 getchar();
}

Inserção por busca binária

#include<stdio.h>
int adicPorInsPesqBin(int tam,int v[],int pesq)
{
 int ini=0,fim=tam-1,i=0;
 while(ini<=fim)
 {
  int meio;
  meio=(ini+fim)/2;
  if(v[i]==pesq)
  {
   return -1;
  } 
  else if(v[meio]<pesq)
  {
   ini=meio+1;
  }
  else if(v[meio]>pesq)
  {
   fim=meio-1;
  }
  i++;
 }

 while(ini<=tam)
 {
  v[tam]=v[tam-1];
  tam--;
 }
 v[ini]=pesq;
 return ini;
}
int main (void)
{
 int v[4]={4,5,12,22},pos,x,i,k;
 printf("Informe o valor a ser inserido: ");
 scanf("%d",&x);
 pos=adicPorInsPesqBin(5,v,x);
 printf("O valor foi inserido na posicao: %d. (Se o programa retornou -1, significa que o valor a ser inserido ja existe no vetor\n)",pos);
 printf("\n\n");
 if(pos==-1)k=4;
 else k=5;
 for(i=0;i<k;i++)
 {
  printf("%d\t",v[i]);
 }
 return 0;
}

Nível de complexidade dos algoritmos

Complexidade n - Quando uma operação é realizada em cada elemento de entrada (ex. inserção)
Complexidade log n - Quando se divide o problema em outros menores (ex. busca binária)
Complexidade n log n - Quando se divide o problema em outros menores e depois os resultados de cada um são unidos (ex. merge, quick)
Complexidade quadrática - Quando há 2 loops (um encaixado no outro) (ex. seleção)
Complexidade cúbica - Quando há 3 loops (um encaixado nos outros dois)
Complexidade exponencial - Quando se utiliza a "força bruta" na resolução

Ordenação de vetores em C (Método da bolha)

#include<stdio.h>
#include<string.h>
void ordenaVetorString(char v[][40], int tam)
{
int i,j;
char aux[40];
for(j=0;j<tam-1;j++){
for(i=0;i<tam-1;i++){
if(strcmp(v[i],v[i+1])>0){
strcpy(aux,v[i]);
strcpy(v[i],v[i+1]);
strcpy(v[i+1],aux);}}}
}
int main ()
{
char nome[10][40],i;
printf("Informe os nomes dos alunos:\n");
for(i=0;i<10;i++){
printf("Nome pos %d: ",i+1);
gets(nome[i]);}
ordenaVetorString(nome,10);
for(i=0;i<10;i++){
printf(nome[i]);
printf("\n");}
return 0;
}

Adivinhe o número!

Programa em C que escolhe um número aleatório entre 1 e 1000. Duas pessoas tentam adivinhar o número gerado pelo pc. O participante que inicia o jogo também é escolhido de forma aleatória.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main(){
char jogador[2][40];
int turno,secreto,lance;
srand(time(NULL));
printf("Nome do jogador 1:");
gets(jogador[0]);
printf("Nome do jogador 2:");
gets(jogador[1]);
turno = rand() % 2;
secreto = (rand() % 1000) + 1;
do {
printf("Lance do jogador %s:", jogador[turno] );
scanf("%d",&lance);
if(lance==secreto) {
printf("Jogador %s ganhou!\n", jogador[turno] );
} else if(lance > secreto) {
printf("O numero eh menor!\n");
} else {
printf("O numero eh maior!\n");
}
if(turno==0)turno=1;
else turno=0;
} while (lance!=secreto);
getchar();
}

Conversão de base

Converte um valor em uma base escolhida para a base decimal.


#include<stdio.h>
#include<math.h>
#include<string.h>
int BASTODEC(int base,char v[],int qtd)
{
int numdec=0,x,exp=0;
if (base==16)
{
for(x=qtd-1;x>=0;x--)
{
if(v[x]=='A' || v[x]=='a') v[x]=58;
if(v[x]=='B' || v[x]=='b') v[x]=59;
if(v[x]=='C' || v[x]=='c') v[x]=60;
if(v[x]=='D' || v[x]=='d') v[x]=61;
if(v[x]=='E' || v[x]=='e') v[x]=62;
if(v[x]=='F' || v[x]=='f') v[x]=63;
}
}
for(x=qtd-1;x>=0;x--)
{
numdec=numdec+(v[x]-48)*pow(float (base),exp++);
}
return int(numdec);
}
int main ()
{
int base,qt;
char num[10],k;
printf("Informe a base que deseja usar: ");
scanf("%d",&base);
getchar();
printf("\nInforme o numero que sera transformado a partir da base escolhida anteriormente (ate 9 digitos): ");
gets(num);
qt=strlen(num);
printf("\nO valor informado convertido em decimal eh: %d.\n\n",BASTODEC(base,num,qt));
getchar();
}

Soma de 1 até um natural x (com recursão)

#include<stdio.h>
int SomatRec(int n)
{
int soma;
if(n==1){
soma=1;}
else{
soma=n+SomatRec(n-1);}
return soma;
}
int main ()
{
int n,somaT;
printf("Informe um nunero natural: ");
scanf("%d",&n);
while(n<0){
printf("Informe um nunero natural: ");
scanf("%d",&n);}
somaT=SomatRec(n);
printf("O somatorio de 1 ate %d eh %d.\n",n,somaT);
return 0;
}

Ordenação em C pelo método quicksort

#include<stdio.h>
int Pivode3 (int v[],int ini,int fim)
{
int meio;
meio=(ini+fim)/2;
if (v[ini]<v[fim] && v[ini]>v[meio] || v[ini]>v[fim] && v[ini]<v[meio]) return ini;
if (v[meio]<v[fim] && v[meio]>v[ini] || v[meio]>v[fim] && v[meio]<v[ini]) return meio;
return fim;
}
void quicksort (int v[],int ini,int fim)
{
int esq,dir,pivo,aux;
esq=ini;
dir=fim-1;
if ((fim-ini)<1) return;
if ((fim-ini)==1)
{
if(v[ini]>v[fim]){
aux=v[fim];
v[fim]=v[ini];
v[ini]=aux;}
return;
}
else
{
pivo=Pivode3(v,ini,fim);
if(v[fim]!=v[pivo]){
aux=v[fim];
v[fim]=v[pivo];
v[pivo]=aux;}
while(esq<dir){
if(v[esq]>v[fim]){
if(v[dir]<v[fim]){
aux=v[esq];
v[esq]=v[dir];
v[dir]=aux;
esq++;dir--;}
else{
dir--;}}
else{
esq++;}
}
quicksort(v,ini,esq);
quicksort(v,esq,fim);
}
}
int main (void)
{
int v[10]={9,0,8,1,7,2,6,3,5,4},i;
quicksort(v,0,9);
for(i=0;i<10;i++){
printf("%d\t",v[i]);}
return 0;
}

Contador de caracteres de entrada em C

Escreva um programa que leia uma linha de texto e que conte a quantidade de vogais existente na linha.

O programa deverá imprimir o número total de caracteres lidos, o número de ocorrências de vogais e a respectiva

percentagem relativamente ao total de caracteres.

#include<stdio.h>

#include<string.h>

int main (void)

{

char linha[80];

int x,vogais=0,total;

printf("Digite a linha: ");

gets (linha);

total=strlen(linha);

for(x=0;x<total;x++)

{

if(linha[x]=='a'||linha[x]=='A'||linha[x]=='e'||linha[x]=='E'||linha[x]=='i'||linha[x]=='I'||linha[x]=='o'||linha[x]=='O'||linha[x]=='u'||linha[x]=='U')

{

vogais++;

}

}

printf("\nTotal de caracteres: %d. Ocorrencias de vogais: %d. Porcentagem: %.2f %\n\n",total,vogais,((float) vogais*100)/total);

return 0;

}

Calcula fatorial em C

#include<stdio.h>
int main (void)
{
int num, fat=0,y;
printf("Informe um numero inteiro: ");
scanf("%d",&num);
printf("\nO fatorial de %i eh: ",num);
y=num-1;
fat=num*y;
y--;
while(y>0)
{
fat=fat*y;
y--;
}
printf("%d\n\n",fat);

return 0;
}

Busca sequencial em C

#include<stdio.h>
int buscaSequencial(int tamanho, int vetor[],int p)
{
int i;
for(i=0;i<=tamanho;i++)
{
if(vetor[i]==p){
return i;
}
}
return -1;

}
int main (void)
{
int vetor_tst[8]={8,4,0,8,3,4,6,5},fun,x;
printf("Informe o valor a ser encontrado: ");
scanf("%d",&x);
fun=buscaSequencial(8,vetor_tst,x);
printf("%d",fun);
printf("\n\n");
return 0;
}

Pesquisa binária (Retorna o índice do elemento)

#include<stdio.h>
int buscaBinPos(int tam,int v[],int pesq)
{
int ini=0,fim=9;
while(ini<=fim)
{
int meio;
meio=(ini+fim)/2;
if(v[meio]==pesq)
{
return meio;
}
else if(v[meio]<pesq)
{
ini=meio+1;
}
else
{
fim=meio-1;
}
}
return ini;

}
int main (void)
{
int v[10]={4,5,12,22,23,34,56,76,83,90},pos,fun,x;
printf("Informe o valor a ser encontrado: ");
scanf("%d",&x);
fun=buscaBinPos(10,v,x);
printf("O valor esta ou deveria estar na posicao: %d",fun);
printf("\n\n");
return 0;
}

Modelo de struct em C

#include<stdio.h>
struct voluntario
{
char sexo;
int idade, escol;
float rendaM;
};
int main()
{
struct voluntario v[3];
int i=0;
float RENDAM;
while(i<3)
{
printf("Sexo (F ou M): ");
scanf("%c",&v[i].sexo);
while(v[i].sexo!='f'&&v[i].sexo!='F'&&v[i].sexo!='m'&&v[i].sexo!='M')
{
printf("Sexo (F ou M): ");
scanf("%c",&v[i].sexo);
}
printf("Idade: ");
scanf("%d",&v[i].idade);
while(v[i].idade<0)
{
printf("Idade: ");
scanf("%d",&v[i].idade);
}
printf("Escolaridade (0-analfabeta, 1-fundamental, 2-medio, 3-superior): ");
scanf("%d",&v[i].escol);
while(v[i].escol!=0&&v[i].escol!=1&&v[i].escol!=2&&v[i].escol!=3)
{
printf("Escolaridade (0-analfabeta, 1-fundamental, 2-medio, 3-superior): ");
scanf("%d",&v[i].escol);
}
printf("Renda mensal: R$");
scanf("%f",&v[i].rendaM);
}
return 0;
}

Matriz quadrática com símbolos em C

A diagonal principal possui um símbolo diferente.


#include<stdio.h>
int main (void)
{
int num,j,i=0;
printf("******************DIAGQUAD******************");
printf("\n\nInforme um numero inteiro positivo: ");
scanf("%d",&num);
while (num<0)
{
printf("Informe um numero inteiro positivo: ");
scanf("%d",&num);
}
while(num>i)
{
for(j=0;j<num;j++)
{
if(j==i)
{
printf(":");
}
else
{
printf("+");
}
}
printf("\n");
i++;
}
printf("\n\n");
return 0;
}

Bilheteria de metrô em C

Fazer um algoritmo para ajudar a bilheteria do metrô. O operador deve informar o tipo do bilhete (unitário, duplo ou 10 viagens) e o valor pago pelo passageiro. O sistema deve mostrar, então, a quantidade de bilhetes possíveis e o troco que o passageiro deve receber.

Considere a seguinte tabela de preço:

0.

Bilhete unitário R$2,30

Bilhete duplo R$4,60

Bilhete com 10 viagens R$23,00

#include <stdio.h>

int main (void)

{

float pagamento,troco,preco;

int bilhete,quantidade,i;

printf("***************************BITMETRO***************************\n\n\n");

printf("Informe o tipo de bilhete: 1 para Unitario, 2 para duplo e 3 para 10 viagens.\nTecle 0 para terminar o programa: ");

scanf("%d",&bilhete);

while (bilhete!=0)

{

while(bilhete!=1&&bilhete!=2&&bilhete!=3)

{

printf("\nTipo de bilhete invalido!");

printf("\nInforme o tipo de bilhete: 1 para Unitario, 2 para duplo e 3 para 10 viagens.\nTecle 0 para terminar o programa: ");

scanf("%d",&bilhete);

}

printf("\nInforme o valor pago pelo passageiro: R$");

scanf("%f",&pagamento);

if(bilhete==1)

{

preco=2.3;

quantidade=pagamento/preco;

if (pagamento<preco)

{

printf("Dinheiro insuficiente!\n");

}

}

else

{

if(bilhete==2)

{

preco=4.6;

quantidade=pagamento/preco;

if (pagamento<preco)

{

printf("Dinheiro insuficiente!\n");

}

}

else

{

if(bilhete==3)

{

preco=23;

quantidade=pagamento/preco;

if (pagamento<preco)

{

printf("Dinheiro insuficiente!\n");

}

}

}

}

for (i=quantidade;i>0;i--)

{

printf("Total de bilhetes: %d. Troco: R$%.2f\n",i, pagamento-(preco*i));

}

printf("\n\nInforme o tipo de bilhete: 1 para Unitario, 2 para duplo e 3 para 10 viagens.\nTecle 0 para terminar o programa: ");

scanf("%d",&bilhete);

}

return 0;

}

Área a ser pintada.

Faça um programa para uma loja de tintas. O programa deverá pedir o tamanho em metros quadrados da área a ser pintada. Considere que a cobertura da tinta é de 1 litro para cada 3 metros quadrados e que a tinta é vendida em latas de 18 litros, que custam R$ 80,00. Informe ao usuário a quantidades de latas de tinta a serem compradas e o preço total.

#include <stdio.h>

int calcula (int val, int div)

{

int res;

if (val%div==0)

{

res=val/div;

}

else

{

res=(val/div)+1;

}

return res;

}

int main (void)

{

float area;

int area2,litros,latas;

printf("***************************LOJTINTA***************************\n\n\n");

printf("Informe quantos metros quadrados serao pintados:");

scanf("%f",&area);

area2=area;

if(area-area2>0)

{

area2++;

}

litros=calcula (area2,3);

latas=calcula (litros,18);

printf("\nPara pintar a area informada, voce precisara de %d latas de tinta e pagara R$%d,00.\n\n",latas,latas*80);

return 0;

}

Pesquisa binária (Com recursividade)

#include<stdio.h>

int buscaBinRec(int vetor[],int ini,int fim,int pesq)

{

while(ini<=fim)

{

int meio;

meio=(ini+fim)/2;

if(vetor[meio]==pesq)

{

return meio;

}

else if (vetor[meio]<pesq)

{

return buscaBinRec(vetor,meio+1,fim,pesq);

}

else

{

return buscaBinRec(vetor,ini,meio-1,pesq);

}

}

return -1;

}

int main (void)

{

int vetor_tst[4]={2,3,4,7},fun,x;

printf("Informe o valor a ser encontrado: ");

scanf("%d",&x);

fun=buscaBinRec(vetor_tst,0,3,x);

printf("%d",fun);

printf("\n\n");

return 0;

}

Ordenação pelo método da bolha (Não otimizado)

#include<stdio.h>
void ordemBolha(int v[],int tam)
{
int aux,i,j;
for(i=0;i<tam;i++)
{
for(j=0;j<tam;j++)
{
if(v[j]>v[j+1])
{
aux=v[j];
v[j]=v[j+1];
v[j+1]=aux;
}
}
}
}
int main ()
{
int v[6]={3,7,12,2,34,15},i;
ordemBolha(v,6);
for(i=0;i<6;i++){
printf("%d\t",v[i]);}
return 0;
}

Algoritmo da inserção em C

Algoritmo que insere um valor em um vetor previamente ordenado.


#include<stdio.h>
int insereNovo(int tam,int vetor[],int novo)
{
int i,j=tam-2;
for(i=0;i<tam;i++)
{
if(novo<=vetor[i]){
while(j>=i){
vetor[j+1]=vetor[j];
j--;}
return i;}
}
return tam-1;
}
int main (void)
{
int v[7]={12,15,23,34,46,65},valn,i,inov;
for(i=0;i<6;i++){
printf("%d\t",v[i]);}
printf("Informe o valor que sera inserido no vetor: ");
scanf("%d",&valn);
inov=insereNovo(7,v,valn);
v[inov]=valn;
for(i=0;i<7;i++){
printf("%d\t",v[i]);}
return 0;
}

Algoritmo Mergesort em C

Algoritmo que ordena um vetor através da recursividade. A ideia é subdividir o vetor em 2 outros de mesmo tamanho ou com apenas a diferença de uma unidade (caso o vetor seja ímpar), ordená-los e depois intercalar, retornando o vetor inicial totalmente ordenado.

#include<stdio.h>
void intercalar (int v[],int aux[],int ini1, int ini2,int fim2)
{
int in1=ini1,in2=ini2,fim1=in2-1,au=0,i;
while(in1<=fim1 && in2<=fim2)
{
if (v[in1]<v[in2])
{
aux[au++] = v[in1++];
}
else
{
aux[au++] = v[in2++];
}
}
while(in1<=fim1)
{
aux[au++] = v[in1++];
}
while(in2<=fim2)
{
aux[au++] = v[in2++];
}

for(i=0;i<au;i++){
v[i+ini1]=aux[i];}
}
void mergeSort (int v[], int aux[],int esq, int dir)
{
int meio,i;
if(esq<dir)
{
meio=(esq+dir)/2;
mergeSort(v,aux,esq,meio);
mergeSort(v,aux,meio+1,dir);
intercalar(v,aux,esq,meio+1,dir);
}
}
int main()
{
int v[10]={45,23,10,25,89,75,46,32,20,1},aux[10],i;
mergeSort(v,aux,0,9);
for(i=0;i<10;i++)
{
printf("%d\t",v[i]);
}
return 0;
}