Gabarito Lista 02 - C

Prévia do material em texto

GABARITO LISTA 02 – C
Exercício 1
/*
Faça uma função que recebe a idade de uma pessoa em anos, meses e dias e
retorna essa idade expressa em dias.
*/
// VERSÃO COMPLETA (alguns gabaritos usarão tanto este modelo quanto o
próximo)
#include <stdio.h>
#include <stdlib.h>
int idade_dias(int a, int m, int d) //3 parâmetros inteiros
{
int id; //variável que será retornada
id = a*360+m*30+d; //cálculo dos dias (1 ano tem 360 dias e 1 mes tem 30 dias)
return id; //retornei a idade em dias
}
int main( )
{
int anos,meses,dias,idade; //3 variáveis que serão lidas e o retorno da função
//leitura da idade
printf("Informe a idade em anos, meses e dias (nesta ordem): ");
scanf("%d%d%d",&anos,&meses,&dias);
//idade receberá o retorno da função
idade=idade_dias(anos,meses,dias);
//impressaõ da idade
printf("A idade em dias eh: %d",idade);
return 0;
}
//VERSÃO COMPACTA (assimilem este modelo, às vezes é melhor utilizá­lo)
#include <stdio.h>
#include <stdlib.h>
int idade(int a, int m, int d)
{
//em vez de criar uma variável que recebe o cálculo e retornar esta variável
//pode­se optar em retornar o cálculo
return a*360+m*30+d;
}
int main()
{
int anos,meses,dias;
printf("Informe a idade em anos, meses e dias (nesta ordem): ");
scanf("%d%d%d",&anos,&meses,&dias);
//em vez de criar uma variável que receberá o retorno da função e imprimí­la
//impriminos de uma vez o retorno sem usar variável como intermediário
printf("A idade em dias eh: %d",idade(anos,meses,dias));
/*
Para facilitar, pense que onde se tem a função(parâmetros),
é como se tivesse o retorno no lugar
Então, acima, é como se estivesse:
printf("A idade em dias eh: %d",anos*360+meses*30+dias);
*/
return 0;
}
Exercício 2
/*
Faça uma função que recebe a média final de um aluno por parâmetro
e retorna o seu conceito:
De 0 a 49 D
De 50 a 69 C
De 70 a 89 B
De 90 a 100 A
Observe que se informar um float, a variável int só pegará a parte inteira
*/
#include <stdio.h>
#include <stdlib.h>
char conceito(int media) //um parâmetro
{
/*
Observe que a função termina quando se encontra um return
Abaixo há 4 return's, mas só entrará neles caso as condições do if sejam aceitas
Como elas são mutuamente excludentes (só entrará em uma delas),
o programa só entrará em um return de cada vez, dependendo da nota
*/
if (media>=0 && media<=49)
return 'D';
else if (media>=50 && media<=69)
return 'C';
else if (media>=70 && media<=89)
return 'B';
else if (media>=90 && media<=100)
return 'A';
//'N' significará que a média está inválida. Lá no main, cuidaremos disso
else return 'N';
}
int main( )
{
int m;
char conc;
printf("Informe a media final (inteiro):");
scanf("%d",&m);
//aqui usaremos uma variável para receber o conceito,
//somente se não for 'N', eu imprimo
conc=conceito(m);
if(conc!='N') //podíamos ter usado if(conceito(m)!='N')
{
printf("O conceito eh %c",conc);
}
else
{
printf("Media invalida.");
}
return 0;
}
Exercício 3
/*
Faça uma função que recebe por parâmetro o raio de uma esfera e calcula o
seu volume (v = (4*PI*R³)/3).
Vocês podem calcular R³ como R*R*R e adotar pi como 3.14
Usaremos dois recursos matemáticos. A potência pela função pow e o valor pi
Essas são pré­programadas que vcs podem usar
Para isso, temos que inserir uma nova biblioteca (math.h)
digite “math.h c” no google. Vc achará as funções disponíveis
*/
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
float volume(float R)
{
float vol;
//Valor de pi: M_PI (é uma constante)
//Potencia: float pow (float base,float exponent);
vol = 4 * M_PI * pow(R,3) / 3;
return vol;
}
int main( )
{
float raio;
printf("Informe o raio: ");
scanf("%f",&raio);
printf("O volume eh: %.2f",volume(raio));
return 0;
}
Exercício 4
/*
Escrever uma função int contaimpar( int n1, int n2) que retorna o número de
inteiros impares que existem entre n1 e n2 (inclusive ambos, se for o caso).
A função deve funcionar inclusive se o valor de n2 for menor que n1.
n=contaimpar(10,19); n recebe 5 (11,13,15,17,19)
n=contaimpar(5,1); n recebe 3 (1,3,5)
*/
#include <stdio.h>
#include <stdlib.h>
int contaimpar(int n1,int n2)
{
int aux,i,cont=0;
//1º Passo: Vamos fazer com que n1 seja o menor nº e n2 o maior
if(n2<n1)
{
aux=n1;
n1=n2;
n2=aux;
}
//com i, correremos todos os valores de n1 a n2 e contaremos os ímpares
for(i=n1;i<=n2;i++)
{
if(i%2==1) cont++;
}
//retornamos a quantidade de ímpares
return cont;
}
int main()
{
int n;
//Vamos verificar se funciona
n=contaimpar(10,19); //n recebe 5
printf("Entre 10 e 19 existem %d numeros impares \n",n);
n=contaimpar(5,1); //n recebe 3
printf("Entre 5 e 1 existem %d numeros impares \n",n);
return 0;
}
Exercício 5
/*
Escrever uma função void estacao( int dia, int mes), que exibe qual a estação
do ano da data passada.
O outono começa em 21 de março, O inverno em 21 de junho, A primavera em
23 de setembro e O verão em 21 de dezembro
Ex.: estacao(25,10); // 25/10 é primavera.
*/
#include <stdio.h>
#include <stdlib.h>
void estacao(int dia, int mes)
{
//aqui iremos corrigir somente uma parte do problema (dias negativos e maiores que 31)
if(dia>=1 && dia<=31)
{
switch(mes)
{
case 1: printf("%d/%d é verão.",dia,mes);
break;
case 2: printf("%d/%d é verão.",dia,mes);
break;
case 3: if (dia<21)
printf("%d/%d é verão.",dia,mes);
 else
printf("%d/%d é outono.",dia,mes);
break;
case 4: printf("%d/%d é outono.", dia, mes);
break;
case 5: printf("%d/%d é outono.", dia, mes);
break;
case 6: if (dia < 21)
printf("%d/%d é outono.", dia, mes);
else
printf("%d/%d é inverno.", dia, mes);
break;
case 7: printf("%d/%d é inverno.", dia, mes);
break;
case 8: printf("%d/%d é inverno.", dia, mes);
break;
case 9: if (dia < 23)
printf("%d/%d é inverno.", dia, mes);
 else
printf("%d/%d é primavera.", dia, mes);
break;
case 10: printf("%d/%d é primavera.", dia, mes);
break;
case 11: printf("%d/%d é primavera.", dia, mes);
break;
case 12: if (dia < 21)
printf("%d/%d é primavera.", dia, mes);
  else
printf("%d/%d é verão.", dia, mes);
break;
default: printf("Mes Invalido"); //qualquer outro mês
}
}
else printf("Dia invalido"); //dias negativos e maiores que 31 são inválidos
}
//Perceba que dias como 31/02 serão considerados. Deveria arrumar isto também. Tente...
int main()
{
int d,m;
printf("Informe o dia e o mes: ");
scanf("%d%d",&d,&m);
//verificação do procedimento
estacao(d,m);
return 0;
}
Exercício 6
/*
função int divisao(int dividendo,int divisor,int * resto)
retorna a divisão inteira (sem casas decimais) de dividendo por divisor
armazena no resto, passado por referência, o resto da divisão.
int r, d;
d = divisao(5,2,&r);
printf("Resultado:%d Resto:%d", d, r); // Resultado:2 Resto:1
*/
#include <stdio.h>
#include <stdlib.h>
int divisao(int dividendo,int divisor,int *resto)
{
*resto=dividendo%divisor; //o *resto recebe o resto da divisão. Assim r foi modificado
return dividendo/divisor; //retorna a divisão inteira entre dois inteiros
}
int main()
{
int r,d;
d=divisao(5,2,&r); //exemplo considerado no enunciado
printf("Resultado: %d Resto: %d",d,r);
return 0;
}
Exercício 7
/*
função long somaintervalo(int n1,int n2)
retorna a soma dos inteiros entre n1 e n2 (inclusive ambos)
inclusive se o valor de n2 for menor que n1
n=somaintervalo(3, 6); // n recebe 18 (3 + 4 + 5 + 6)
n=somaintervalo(5,5); // n recebe 5 (5)
n=somaintervalo(­2,3); // n recebe 3 (­2 + ­1 + 0 + 1 + 2 + 3)
n=somaintervalo(4, 0); // n recebe 10 (4 + 3 + 2 + 1 + 0)
*/
#include <stdio.h>
#include <stdlib.h>
long somaintervalo(int n1, int n2) //long ­> maior capacidade de armazenagem de valor
{
    int aux,i,soma=0;
    //1º Passo: Vamos fazer com que n1 seja o menor nº e n2 o maior
    if(n2<n1)
    {
        aux=n1;
        n1=n2;
        n2=aux;
    }
    //com i, correremos todos os valores de n1 a n2 e somaremos
    //se n1==n2 deve­se retornar somente um deles
    if(n1==n2) soma=n1;
    else
    for(i=n1;i<=n2;i++) //este for soma todos se n1 != n2, mas se for igual só soma o n1
        soma+=i; //soma=soma+i;
    //retornamos a quantidade de ímpares
    return soma;}
int main( )
{
    long n;
    n=somaintervalo(3, 6); // n recebe 18 (3 + 4 + 5 + 6)
    printf("%ld ",n);
    n=somaintervalo(5,5); // n recebe 10 (5 + 5)
    printf("%ld ",n);
    n=somaintervalo(­2,3); // n recebe 3 (­2 + ­1 + 0 + 1 + 2 + 3)
    printf("%ld ",n);
    n=somaintervalo(4, 0); // n recebe 10 (4 + 3 + 2 + 1 + 0)
    printf("%ld ",n);
    return 0;
}
Exercício 8
/*Criação da função para calcular a soma proposta. Passa por parâmetro ‘n’
que é um numero inteiro e positivo*/
#include <stdio.h>
#include <stdlib.h>
float soma_inversa(int n)
{
//Declaração das variáveis
//‘i’ é para variar de 1 ate n e ‘s’ é para calcular a soma
float i, s;
s=0;
for(i=1 ; i<=n; i++)
s=s+(float)1/i;
return s;
}
int main( )
{
//Declaração das variáveis
int n ;
float s;
printf("Digite um valor inteiro e positivo: ");
scanf("%d",&n);
s=soma_inversa(n);
printf("O vaalor da soma eh: %.2f",s);
return 0;
}
Exercicio 9
//Escrever uma função que receba um vetor com 10 valores e retorne quantos
//destes valores são negativos.
#include <stdio.h>
#include <stdlib.h>
int conta_negativos(float v[],int tam)
{
//Declaração de variáveis
//"i" para percorrer o vetor e "neg" para contar os negativos desse vetor
int i, neg;
neg=0;
for(i=0;i<tam;i++)
if(v[i]<0)
neg++;
return neg;
}
int main( )
{
//Declaração de variáveis
//Cria um vetor do tipo real com 10 valores
float v[10];
//Idem ao da função
int i, neg;
printf("Digite os valores do seu vetor:\n");
for(i=0; i<10;i++)
{
//"i+1" só para começar aparecendo [1]
printf("V[%d]= ",i+1);
scanf("%f",&v[i]);
}
neg= conta_negativos(v,10);
printf("O seu vetor tem %d numeros negativos!",neg);
return 0;
}
Exercício 10
/*
Implemente uma função que retorne o maior elemento de um vetor de inteiros
de tamanho 10.
*/
#include <stdio.h>
#include <stdlib.h>
#define tamanho 10 //variável global ­> vale para TODO seu código. Altere
aqui e será alterado em tudo
//função inteiro que receberá um vetor de inteiros qualquer (sempre por
referência) e o tamanho do vetor
int maior(int vetor[],int tam)
{
int m,i; //m será o maior inteiro
for(i=0;i<tam;i++) //lembre­se que o índice do vetor vai de 0 até o tam­1.
 //i  corre estes valores
if(i==0) m=vetor[i]; //se for o 1º valor inteiro que ocupa o índice 0, m será ele
else if(vetor[i]>m) m=vetor[i]; //o restante será comparado com o m
  //atual. Se for maior, m recebe o inteiro.
return m; //retornei o maior
}
int main( )
{
int vetor[tamanho],i; //vetor de inteiros com "tamanho" posições possíveis
printf("Informe %d valores para seu vetor: ",tamanho); //leitura dos
valores inteiros
for(i=0;i<tamanho;i++) //estou "correndo" o vetor: i<=tamanho­1 é a mesma
     //coisa que i<tamanho
scanf("%d",&vetor[i]); //leitura do inteiro que entrará na posição i do vetor
printf("O maior valor dentre os %d informados é %d",tamanho,maior(vetor,tamanho)); 
//impressão do maior inteiro
//poderia ter criado uma variável ma = maior(vetor,tamanho) e mandar imprimir ma. 
//Aqui imprimi direto.
//esta variável não pode ter o mesmo nome da subrotina
return 0;
}
Exercício 11
//Implemente uma função que retorne o menor elemento de um vetor de
//inteiros de tamanho 10.
#include <stdio.h>
#include <stdlib.h>
int menor_elemento_no_vetor(int v[],int tam)
{
//Declaração de variáveis
//'i' para percorrer o vetor e menor para armazenar o menor elemento do vetor
int i,menor;
//menor inicializa com o primeiro elemento do vetor para poder comparar com os outros
menor=v[0];
1. for(i=1;i<tam;i++)
if(v[i]<menor)
menor=v[i];
return menor;
}
int main( )
{
//Declaração de variáveis
//Cria um vetor do tipo inteiro com 10 valores
int v[10];
//Idem ao da função
int i, menor;
printf("Digite os valores do seu vetor:\n");
for(i=0; i<10;i++)
{
//"i+1" só para começar aparecendo [1]
printf("V[%d]= ",i+1);
scanf("%d",&v[i]);
}
menor= menor_elemento_no_vetor(v,10);
printf("O menor elemento no vetor eh %d!",menor);
return 0;
}
Exercício 12
// Implemente um procedimento que ordene um vetor de inteiros de tamanho
// 10.
#include <stdio.h>
#include <stdlib.h>
#define tamanho 10
void ordena(int vet[],int tam)
{
int i,j,aux;
for(i=0;i<=(tam­2);i++) // o i vai "correr" a 1ª posição do vetor até a penúltima
{
for(j=tam­1;j>i;j­­)
// o j vai "correr" da última posição até uma a mais que o i
{
if(vet[j]<vet[j­1])
{
//aqui eu estou trocando os valores se vet[j] for menor que vet[j­1].
//Este deve receber o menor
aux=vet[j];
vet[j]= vet[j­1];
vet[j­1]=aux;
}
}
}
/*
Basicamente, meu i vai indicar qual é a posição que vou armazenar o menor
de todos dali pra frente
NA 1ª vez, i vale 0. Na 1ª posição (i==0), eu irei guardar o menor de todos
Meu j vai começar no último e vai ser comparado com o anterior. O anterior
recebe o menor.
Assim, o menor vai passando de "posição em posição" até chegar onde o i
indica.
Depois meu i aumenta +1. E recomeço tudo de novo.
O j só chegará até 1 a + que o i, pois ao comparar com onde está o i, eu irei
joguei o menor no i (objetivo)
Meu i só chegará na penúltima posição. Aqui, j será o último e irei fazer a
última comparação
*/
}
int main()
{
int vetor[tamanho],i;
printf("Informe %d valores para seu vetor: ",tamanho);
for(i=0;i<tamanho;i++) //estou "correndo" o vetor
scanf("%d",&vetor[i]); //leitura do inteiro que entrará na posição i do vetor
printf("O vetor ordenado eh: \n");
ordena(vetor,tamanho); //chamei o procedimento
for(i=0;i<tamanho;i++)
printf("%d ",vetor[i]); //imprimi cada número que compõe o vetor 
//(aqui já está ordenado)
return 0;
}
Exercício 13
/*Escrever uma função long somavet( int vetor[], int tamanho) , que recebe por
parâmetro o endereço (ponteiro) de um vetor de inteiros e o seu tamanho e
retorna a soma de seus elementos.*/
#include <stdio.h>
#include <stdlib.h>
long somavet(int v[],int tam)
{
//Declaração de variáveis
//'i' para percorrer o vetor e "soma" para armazenar a soma dos elementos
do vetor
int i;
long soma;
soma=0;
for(i=0;i<tam;i++)
{
soma=soma+v[i];
}
return soma;
}
int main( )
{
//Declaração de variáveis
//Cria um vetor do tipo inteiro com 4 valores
int v[4]={100,20,10,5};
//Idem ao da função
long soma;
soma= somavet(v,4);
printf("O soma dos elementos do vetor eh %ld!",soma);
return 0;
}
Exercício 14
/*
Implemente uma função que, dado um valor, retorne se esse valor pertence ou
não a um vetor de inteiros de tamanho 10.
*/
#include <stdio.h>
#include <stdlib.h>
#define tamanho 10
int pertence(int vet[],int tam, int valor)
{
//irei fazer o seguinte: se retornar 1, pertence. Se for 0, não pertence.
int i;
for(i=0;i<tam;i++) //irei "correr" todo o meu vetor
if (vet[i]==valor) //se houver pelo menos uma posição onde o valor passado se encontra
return 1; //irei retornar 1. A função termina no 1º retorno que encontrar
return 0; //se eu cheguei aqui, quer dizer que não entrei no return 1, ou seja,
    //o valor não está no vetor
}
int main( )
{
int vetor[tamanho],i,numero,p;
printf("Informe %d valores para seu vetor: ",tamanho);
for(i=0;i<tamanho;i++)
scanf("%d",&vetor[i]); //leitura do inteiro que entrará na posição i do vetor
printf("Insira o valor: ");
scanf("%d",&numero);
p = pertence(vetor,tamanho,numero); //receberá 1 se pertencer ou 0 se não pertencer
if(p==1)
printf("O valor %d pertence ao vetor",numero);
else
printf("O valor %d nao pertence ao vetor",numero);
return 0;
}
Exercício 15
/*
Implemente uma função que retorne a média dos valores armazenados em um
vetor de inteiros de tamanho 10.
*/
#include <stdio.h>
#include <stdlib.h>
#define tamanho 10
float media(int vet[],int tam)
{
int i,soma=0;
float media;
for(i=0;i<tam;i++) //irei "correr" todo o meu vetor
soma+=vet[i]; // é o mesmo que soma = soma + vet[i];
media = (float)soma/tam;
return media; //podíamos retornar diretamente return (float)soma/tam; 
  //Assim, não precisaríamos de media.
}
int main()
{
int vetor[tamanho],i;
printf("Informe %d valores para seu vetor: ",tamanho);
for(i=0;i<tamanho;i++)
scanf("%d",&vetor[i]); //leitura do inteiro que entrará na posição i do vetor
printf("A mediaeh: %.2f", media(vetor,tamanho) );
return 0;
}
Exercício 16
/*
função int so_positivo( int vetor[], int tamanho)
substitui por zero todos os números negativos do vetor
o número de elementos do vetor é passado para a função no parâmetro
tamanho
A função deve retornar o número de valores que foram substituídos
int v[5] = {3, ­5, 2, ­1, 4};
tr = so_positivo(v,5);
printf("%d", tr); // 2
*/
#include <stdio.h>
#include <stdlib.h>
int so_positivo (int vetor[],int tamanho) //pode­se colocar vetor[] ou *vetor. Tanto faz
{
int i,cont=0; //cont será a quantidade de substituições
for(i=0;i<tamanho;i++) //estou "correndo" o vetor
{
if(vetor[i]<0) //se o valor é negativo
{
vetor[i]=0; //a posição recebe zero
cont++; //houve +1 substituição
}
}
return cont; //retornei o número de substituições
}
int main()
{
int tr,v[5]={3,­5,2,­1,4}; //exemplo do enunciado
tr = so_positivo(v,5); //passei o vetor e o tamanho
printf("%d",tr); //imprimi a quantidade de substituições
return 0;
}
Exercício 17
/*
função int contc(char str[], char c)
Retorna o número de vezes que c aparece na string str
char texto[]="EXEMPLO";
x=contc(texto,'E'); // x recebe 2
x=contc(texto,'L'); // x recebe 1
x=contc(texto,'W'); // x recebe 0
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h> //Biblioteca referente a operações com string
int contc(char str[], char c) 
{
int tam,i,cont=0; //tam tamanho da string, i corre a string e cont é o nº de vezes
tam=strlen(str); //tamanho da string até a posição anterior a '\0'
for(i=0;i<tam;i++) //se não usar strlen, a condição no for seria str[i]!='\0'
{
if (str[i]==c) cont++; //se a atring foi encontrada, soma +1 no cont
}
return cont;
}
int main()
{
char texto[ ]="EXEMPLO";
int x; //quantidade
x=contc(texto,'E'); // x recebe 2
printf("%d \n",x);
x=contc(texto,'L'); // x recebe 1
printf("%d \n",x);
x=contc(texto,'W'); // x recebe 0
printf("%d \n",x);
return 0;
}
Exercício 18
/*
procedimento void stringup(char destino[], char origem[])
copia todos os caracteres da string origem para destino, convertendo­os para
maiúscula.
char s1[20], s2[20]="aula de c";
stringup(s1, s2);
printf("%s", s1); //AULA DE C */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h> //biblioteca de char
void stringup(char destino[], char origem[])
{
int tamanho,i;
tamanho=strlen(origem); //tamanho da origem (até um antes de '\0')
for(i=0;i<tamanho;i++)
{
destino[i]=toupper(origem[i]);
/*
a posição i do destino recebe o char da origem na mesma posição i, em
maiúsculo toupper(char c) ­> função da biblioteca ctype.h que converte o char
de dentro (c) para maiúsculo */
}
destino[i]='\0';
/* aqui o meu i indica a posição '\0' da origem. No destino, deve colocar
manualmente '\0'. Outra alternativa é copiar toda a string com
"strcpy(destino,origem);" antes do for e depois converter para maiúsculo no for
*/
}
int main()
{
char s1[20],s2[20]="aula de c";
stringup(s1,s2);
printf("%s",s1);
return 0;
}
Exercício 19
/*
função int ultima(char string[], char c)
retorna qual a última posição na string em que aparece o c
Se c não estiver na string, retornar ­1
char str[]="teste";
int q;
q=ultima(str, 't'); //q recebe 3
q=ultima(str, 'x'); //q recebe ­1
*/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int ultima(char string[],char c)
{
int tamanho,i,posicao=­1; //posicao recebe ­1 (ainda não achei nenhum)
tamanho=strlen(string);
for(i=0;i<tamanho;i++)
{
if(string[i]==c) posicao=i; //se eu achei, minha posicao muda.
    //Se não, continua o anterior
}
return posicao; //retornei a posicao. Se não achou, continua sendo ­1
}
int main()
{
char str[]="teste";
int q;
q=ultima(str,'t'); //q recebe 3
printf("%d \n",q);
q=ultima(str,'x'); //q recebe ­1
printf("%d \n",q);
return 0;
}
Exercício 20
//Cria a função para receber uma string e retornar a quantidade de elementos
iguais a espaço em branco
#include <stdio.h>
#include <stdlib.h>
int contabranco(char string[])
{
//Declaração de variáveis
//'i'para percorrer a string
int i;
//'soma' para receber a soma dos elementos iguais a espaço em branco
int soma=0;
for(i=0;string[i]!='\0';i++)
{
if(string[i]==' ')
soma++;
}
return soma;
}
int main( )
{
//Declaração de variáveis
//Cria uma variável para receber a soma de espaços em branco
int n;
n = contabranco(" a b c");
printf("A string possui %d espacos em branco!\n",n);
n = contabranco(" abc ");
printf("A string possui %d espacos em branco!\n",n);
n = contabranco("abc");
printf("A string possui %d espacos em branco!\n",n);
return 0;
}
Exercício 21
//Cria a função para receber uma string destino ,uma origem e uma variável
//‘num’ para fazer a copia da string origem ate a quantidade indicada na
// variável ‘num’ na string destino
#include <stdio.h>
#include <stdlib.h>
void ninvert(char destino[], char origem[], int num)
{
//Declaração de variável
//'i'para percorrer a string
int i;
// string auxiliar
char s3[80];
//copia a string origem ate 'num' na string s3
for(i=0;(i<num)&&(origem[i]!='\0');i++)
{
s3[i]=origem[i];
}
//finaliza string s3
s3[i]='\0';
//copia a s3 ao contrario na string destino
//a função strlen retorna o tamanho da string
for(i=strlen(s3)­1;i>=0;i­­)
{
destino[i]=s3[i];
}
//finaliza a string destino
destino[i]='\0';
}
int main( )
{
//Declaração de variáveis
//Cria dois vetores de caracter
//'s1' origem
//'s2' destino
char s1[80] = "ABCDE";
char s2[80];
ninvert(s2, s1, 3);
printf("Copiou ate: ");
puts(s2);
ninvert(s2, s1, 10);
printf("Copiou ate: ");
puts(s2);
return 0;
}
Exercício 22
/*Escrever um procedimento void copiaate(char destino[], char origem[], char
parar) que copia para a string destino os caracteres da string origem que estão
antes da primeira ocorrência do caracter parar ou até o final de origem, se
parar não for encontrado.*/
#include <stdio.h>
#include <stdlib.h>
void copiaate(char destino[],char origem[], char parar)
{
//Declaração de variáveis
//’i’ para percorrer as strings origem e destino
int i;
for(i=0;(origem[i]!=parar)&&(origem[i]!='\0');i++)
{
destino[i]=origem[i];
}
//Finaliza a string
destino[i]='\0';
}
int main( )
{
//Declaração de variáveis
//Cria uma string de 80
char str[80];
copiaate(str, "testando a funcao", 'a');
printf("Copiou ate: ");
puts(str);
copiaate(str, "testando a funcao", 'n');
printf("Copiou ate: ");
puts(str);
copiaate(str, "testando a funcao", 'o');
printf("Copiou ate: ");
puts(str);
return 0;
}