Centro Universitário Fundação Santo André

Gilmar Fernandes Filho RA 736418

Atividade 5 - Funções

Santo André
2019
Gilmar Fernandes Filho RA 736418

Atividade 5 - Funções

Trabalho de Algorítimo e Linguagem de Pro-

gramação apresentado como exigência parcial
para obtenção do grau de Engenheiro à Facul-
dade de Engenharia Engenheiro Celso Daniel
do Centro Universitário Fundação Santo An-
dré.

Orientador: Profo Marcos Forte

Santo André
2019
 Resumo
Este trabalho apresenta as soluções para os problemas apresentados na Lista de Exercícios
P5, aplicada à turma do Ciclo Básico de Engenharia no primeiro semestre de 2019. Nas
resoluções apresentadas nesse trabalho são utilizados os conceitos de decisão e repetição,
técnicas de manipulação de estruturas homogêneas e o uso de funções.
Este trabalho foi elaborado seguindo os padrões ABNT, segundo Laporta, Zampieri e
André (2006).

Palavras-chaves: linguagem C, programação, fluxograma, algorítimo, vetor, matriz,

função.
 Lista de ilustrações

Figura 1 – Fluxograma 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
Figura 2 – Fluxograma 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
Figura 3 – Fluxograma 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Figura 4 – Fluxograma 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
 Sumário

1 INTRODUÇÃO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2

2 RESULTADOS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.1 Exercício 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Exercício 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.3 Exercício 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Exercício 4 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Exercício 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.6 Exercício 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.7 Exercício 7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.8 Exercício 8 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.9 Exercício 9 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.10 Exercício 10 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.11 Exercício 11 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.12 Exercício 12 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

REFERÊNCIAS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Introdução
 2

1 Introdução

O uso de funções é uma técnica que visa simplificar a complexidade de um programa.

A isso é dado o nome de modularização. A função, por sua vez, trata-se de um bloco
de programa que é escrito fora da função principal e usado apenas quando solicitado no
main()(SOFFNER, 2017).
Resultados
 4

2 Resultados

Nesta seção são apresentados os problemas com os respectivos fluxogramas (do 1

ao 4) e os códigos em linguagem C.

2.1 Exercício 1
Faça uma função que recebe por parâmetro um valor inteiro e positivo e retorne 1
caso o valor seja primo e 0 caso não seja. Implemente na função main o código necessário
para a utilização dessa nova função.
A figura 1 apresenta a resolução gráfica do problema.

Figura 1 – Fluxograma 1

Abaixo, a implementação em linguagem C:

1 # include < stdio .h >
2 # include < stdlib .h >
3 int primo ( int n )
4 { int i ;
5 for ( i =n -1; i >1; i - -)
6 { if (( n % i ) ==0) { return 0;}}
7 return 1;}
8 int main ( int argc , char * argv []) {
9 int a ;
10 printf ( " Digite um numero inteiro positivo : ");
11 scanf ( " % i " ,& a ) ;
12 if ( primo ( a ) )
13 { printf ( " \ nO numero % i eh primo . " ,a ) ;}
14 else { printf ( " \ nO numero % i nao eh primo . " ,a ) ;}
15 return 0;}
 Capítulo 2. Resultados 5

2.2 Exercício 2
Faça uma função que recebe por parâmetro três números inteiros e retorne o maior
número. Implemente na função main o código necessário para a utilização dessa nova
função.
A figura 2 apresenta a resolução gráfica do problema.
Figura 2 – Fluxograma 2

Abaixo, a implementação em linguagem C:

1 # include < stdio .h >
2 # include < stdlib .h >
3 int maior ( int A , int B , int C )
4 { if (A > B ) { if (A > C ) { return A ;}
5 else { return C ;}}
6 else { if (B > C ) { return B ;}
7 else { return C ;}}}
8 int main ( int argc , char * argv []) {
9 int x , y , z ;
10 printf ( " Digite o valor de x : " ) ;
11 scanf ( " % i " ,& x ) ;
12 printf ( " Digite o valor de y : " ) ;
13 scanf ( " % i " ,& y ) ;
14 printf ( " Digite o valor de z : " ) ;
15 scanf ( " % i " ,& z ) ;
16 printf ( " O maior numero eh % i " , maior (x ,y , z ) ) ;
17 return 0;}
Capítulo 2. Resultados 6

2.3 Exercício 3
Faça uma função que verifique se um valor é perfeito ou não. Um valor é dito
perfeito quando ele é igual a soma dos seus divisores excetuando ele próprio. (Ex: 6 é
perfeito, 6 = 1 + 2 + 3, que são seus divisores). A função deve retornar 1 caso o valor seja
perfeito e 0 caso contrário. Implemente na função main o código necessário para exibir
todos os números perfeitos entre 1 e 1000 utilizando essa nova função.
A figura 3 apresenta a resolução gráfica do problema.

Figura 3 – Fluxograma 3
 Capítulo 2. Resultados 7

Abaixo, a implementação em linguagem C:

1 # include < stdio .h >
2 # include < stdlib .h >
3

4 int perfeito ( int n )

5 {
6 int cont , teste =0;
7 for ( cont =n -1 ; cont >0 ; cont - -)
8 {
9 if ( n % cont ==0)
10 {
11 teste = cont + teste ;
12 }
13 }
14 if ( teste == n )
15 {
16 return 1;
17 }
18 else
19 {
20 return 0;
21 }
22 }
23

24 int main ( int argc , char * argv []) {

25 int i ;
26 printf ( " Os numeros considerados perfeitos entre 1 e 1000
sao :\ n " ) ;
27 for ( i =1 ; i <=1000 ; i ++)
28 {
29 perfeito ( i ) ;
30 if ( perfeito ( i ) ==1)
31 {
32 printf ( " % i \ n " ,i ) ;
33 }
34 }
35 return 0;
36 }
 Capítulo 2. Resultados 8

2.4 Exercício 4
Faça uma função que recebe, por parâmetro, dois valores X e Z e retorna X Z .
Implemente na função main o código necessário para a utilização dessa nova função. Obs:
não utilizar funções ou operadores de potência prontos.
A figura 4 apresenta a resolução gráfica do problema.

Figura 4 – Fluxograma 4

Abaixo, a implementação em linguagem C:

1 # include < stdio .h >
2 # include < stdlib .h >
3 int exp ( int A , int B )
4 { int produto =1 , n ;
5 for ( n =0 ; n < B ; n ++)
6 { produto = A * produto ;}
7 return produto ;}
8 int main ( int argc , char * argv []) {
9 int x , z ;
10 printf ( " Digite um valor inteiro para x : " ) ;
11 scanf ( " % i " ,& x ) ;
12 printf ( " Digite um valor inteiro para z : " ) ;
13 scanf ( " % i " ,& z ) ;
14 printf ( " \ n \ n % i elevado a potencia % i = % i " ,x ,z , exp (x , z ) )
;
15 return 0;}
 Capítulo 2. Resultados 9

2.5 Exercício 5
Faça uma função que recebe por parâmetro o raio de uma esfera e retorne o seu
volume (v = 4/3.PI.R3). Implemente na função main o código necessário para a utilização
dessa nova função.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3

4 float volume ( float raio )

5 {
6 return ((4*3.141592645* raio * raio * raio ) /3) ;
7 }
8

9 int main ( int argc , char * argv []) {

10 float r ;
11 printf ( " Digite o valor do raio da esfera [ un ]: " ) ;
12 scanf ( " % f " ,& r ) ;
13 printf ( " O volume da esfera eh : % f [ un ^3] " , volume ( r ) ) ;
14 return 0;
15 }

2.6 Exercício 6
Faça quatro funções que calculem a soma, a soma dos pares, a soma dos ímpares e
a média dos n primeiros números inteiros positivos. Implemente na função main o código
necessário para a utilização dessas novas funções.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3 int n =20;
4 int soma ( int V [ n ])
5 {
6 int i , s =0;
7 for ( i =0; i < n ; i ++)
8 {
9 s = s + V [ i ];
10 }
11 return s ;
12 }
 Capítulo 2. Resultados 10

13 int pares ( int V [ n ])

14 {
15 int i , p =0;
16 for ( i =0; i < n ; i ++)
17 {
18 if (( V [ i ]%2) ==0)
19 {
20 p = p + V [ i ];
21 }
22 }
23 return p ;
24 }
25 int impares ( int V [ n ])
26 {
27 int i , imp =0;
28 for ( i =0; i < n ; i ++)
29 {
30 if (( V [ i ]%2) !=0)
31 {
32 imp = imp + V [ i ];
33 }
34 }
35 return imp ;
36 }
37 float media ( int V [ n ])
38 {
39 int i , s =0 , cont =0;
40 float m =0;
41 for ( i =0; i < n ; i ++)
42 {
43 if ( V [ i ] >0)
44 {
45 if (( V [ i ]%2) ==0)
46 {
47 s = s + V [ i ];
48 cont ++;
49 }
50 }
51

52 }
53 m = s / cont ;
54 return m ;
 Capítulo 2. Resultados 11

55 }
56 int main ( int argc , char * argv []) {
57 int i ;
58 int numeros [ n ];
59 printf ( " Digite uma serie de % i numeros :\ n " ,n ) ;
60 for ( i =0; i < n ; i ++)
61 {
62 printf ( " % i % c numero : " ,i +1 ,167) ; // simbolo de
numero tabela ASCII
63 scanf ( " % i " ,& numeros [ i ]) ;
64 }
65 printf ( " \ nA soma dos numeros eh : % i " , soma ( numeros ) ) ;
66 printf ( " \ nA soma dos pares eh : % i " , pares ( numeros ) ) ;
67 printf ( " \ nA soma dos impares eh : % i " , impares ( numeros ) ) ;
68 printf ( " \ nA media dos positivo eh : % f " , media ( numeros ) ) ;
69 return 0;
70 }

2.7 Exercício 7
Faça uma função com a seguinte assinatura “void trocaChar(char ch1, char ch2);”,
que substitua todas as ocorrências do caractere ch1 em f1 pelo caractere ch2 ( obs: a
String f1 deve ser declarada como variável global). Implemente na função main o código
necessário para a utilização dessa nova função.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3 # include < string .h >
4 char f1 [30];
5 void trocaChar ( char ch1 , char ch2 )
6 { int i ;
7 for ( i =0; f1 [ i ]!= ’ \0 ’; i ++)
8 { if ( f1 [ i ]== ch1 )
9 { f1 [ i ]= ch2 ; }}
10 return f1 ;}
11 int main ( int argc , char * argv []) {
12 char ch1 , ch2 ;
13 printf ( " Digite a letra a ser trocada : " ) ;
14 scanf ( " % c " ,& ch1 ) ;
15 fflush ( stdin ) ;
16 printf ( " Digite a letra substituta : " ) ;
 Capítulo 2. Resultados 12

17 scanf ( " % c " ,& ch2 ) ;

18 fflush ( stdin ) ;
19 printf ( " Digite uma palavra / frase : " ) ;
20 gets ( f1 ) ;
21 trocaChar ( ch1 , ch2 ) ;
22 printf ( " A nova palavra / frase eh : " ) ;
23 puts ( f1 ) ;
24 return 0;}

2.8 Exercício 8
Faça uma função chamada MMC que calcule o Mínimo Múltiplo Comum de dois
números inteiros positivos dados. Implemente na função main o código necessário para a
utilização dessa nova função. Sugestão: utilize a função primo desenvolvida no exercício
anterior.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3 /* Funcao MMC */
4 int MMC ( int A , int B )
5 {
6 int a , b , m =2 , mmc =1;
7 a=A;
8 b=B;
9 while (a >1|| b >1)
10 {
11 if ( a % m ==0&& b % m ==0)
12 {
13 a=a/m;
14 b=b/m;
15 mmc = mmc * m ;
16 }
17 else
18 {
19 if ( a % m ==0)
20 {
21 a=a/m;
22 mmc = mmc * m ;
23 }
24 if ( b % m ==0)
25 {
 Capítulo 2. Resultados 13

26 b=b/m;
27 mmc = mmc * m ;
28 }
29 else
30 {
31 m ++;
32 }
33 }
34 }
35 return mmc ;
36 }
37 /* Funcao Principal */
38 int main ( int argc , char * argv []) {
39 int a , b ;
40 printf ( " Digite o 1% c numero : " ,167) ;
41 scanf ( " % i " ,& a ) ;
42 printf ( " Digite o 2% c numero : " ,167) ;
43 scanf ( " % i " ,& b ) ;
44 printf ( " \ nMMC eh % i \ n " , MMC (a , b ) ) ;
45 system ( " pause " ) ;
46 return 0;
47 }

2.9 Exercício 9
Faça uma função que calcule e retorne a determinante de uma matriz 3 x3. Imple-
mente na função main o código necessário para a utilização dessa nova função. Abaixo, a
implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3

4 int Det ( int N [3][3])

5 { return (( N [0][0]* N [1][1]* N [2][2]+ N [0][1]* N [1][2]* N [2][0]+ N
[0][2]* N [1][0]* N [2][1]) -( N [0][2]* N [1][1]* N [2][0]+ N [0][0]* N
[1][2]* N [2][1]+ N [0][1]* N [1][0]* N [2][2]) ) ;}
6

7 int main ( int argc , char * argv []) {

8 int Det ( int N [3][3]) ;
9 int i , j , l =3 , c =3;
10 int M [3][3];
11
 Capítulo 2. Resultados 14

12 /* Coleta da matriz */
13 printf ( " Entre com valores inteiros para a matriz :\ n " ) ;
14 for ( i =0; i < l ; i ++)
15 { for ( j =0; j < c ; j ++)
16 { printf ( " Digite o valor da linha %i ,
coluna % i : " ,i +1 , j +1) ;
17 scanf ( " % i " ,& M [ i ][ j ]) ;
18 }
19 }
20

21 /* Impressao da matriz dada */

22 printf ( " \ nA matriz dada eh :\ n " ) ;
23 for ( i =0; i < l ; i ++)
24 { printf ( " | " ) ;
25 for ( j =0; j <c -1; j ++)
26 { printf ( " % i " ,M [ i ][ j ]) ;
27 }
28 printf ( " % i |\ n " ,M [ i ][ j ]) ;
29 }
30

31 /* Retorno do valor da determinante */

32 printf ( " \ nA determinante da matriz dada eh : % i " , Det ( M ) ) ;
33 return 0;
34 }
 Capítulo 2. Resultados 15

2.10 Exercício 10
Faça uma função que recebe a idade de uma pessoa em anos, meses e dias e retorna
essa idade expressa em dias (considerar: ano = 365 dias e mês = 30 dias). Implemente na
função main o código necessário para a utilização dessa nova função.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3 int tempo ( int anos , int meses , int dias )
4 { int tempo =0;
5 tempo =( anos *365) +( meses *30) +( dias ) ;
6 return tempo ;}
7 int main ( int argc , char * argv []) {
8 int a , m , d ;
9 printf ( " Digite quantos anos voce tem : " ) ;
10 scanf ( " % i " ,& a ) ;
11 printf ( " Meses : " ) ;
12 scanf ( " % i " ,& m ) ;
13 printf ( " Dias : " ) ;
14 scanf ( " % i " ,& d ) ;
15 printf ( " \ nVoce tem % i dias . " , tempo (a ,m , d ) ) ;
16 return 0;}

2.11 Exercício 11
Faça um programa em linguagem C para o cálculo da resistência equivalente em
uma associação em série ou em paralelo. Neste programa, o usuário deverá informar o
valor de dois resistores, e o tipo de associação (em série ou em paralelo). O cálculo da
resistência equivalente deverá ser realizado por duas funções (uma para série e outra para
paralelo).
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3

4 float serie ( float r1 , float r2 )

5 { float req ;
6 req = r1 + r2 ;
7 return req ;}
8

9 float paralelo ( float r1 , float r2 )

 Capítulo 2. Resultados 16

10 { float req ;
11 req =( r1 * r2 ) /( r1 + r2 ) ;
12 return req ;}
13

14 int main ( int argc , char * argv []) {

15 float a , b ;
16 char assoc ;
17 printf ( " Digite [ s ] para associacao em Serie e [ p ] para
associacao em paralelo : ");
18 assoc = getchar () ;
19 if ( assoc == ’s ’ || assoc == ’p ’)
20 { printf ( " \ nDigite os valores das resistencias :\ n " )
;
21 printf ( " R1 : " ) ;
22 scanf ( " % f " ,& a ) ;
23 printf ( " R2 : " ) ;
24 scanf ( " % f " ,& b ) ;
25 if ( assoc == ’s ’)
26 { printf ( " \ nA resistencia equivalente eh :
% f " , serie (a , b ) ) ;}
27 else
28 if ( assoc == ’p ’)
29 {{ printf ( " \ nA resistencia equivalente eh :
% f " , paralelo (a , b ) ) ;}}
30 }
31 else
32 { printf ( " \ nInvalido " ) ;}
33 return 0;
34 }
 Capítulo 2. Resultados 17

2.12 Exercício 12
Faça um programa que leia as medidas dos lados de um triângulo e a partir desses
valores exibe a sua classificação. O programa deve aceitar apenas valores positivos para as
medidas dos lados. Para obter o código da classificação utilize a função TipoTriangulo que
retorna: 0 » não formam um triângulo. 1 » triângulo equilátero. 2 » triângulo isósceles. 3 »
triângulo escaleno. Implemente na função main o código necessário para a utilização dessa
nova função.
Abaixo, a implementação em linguagem C:
1 # include < stdio .h >
2 # include < stdlib .h >
3

4 int TipoTriangulo ( float A , float B , float C )

5 {
6 if ( A ==0 || B ==0 || C ==0) { return 0;}
7 if ( A == B )
8 { if ( B == C ) { return 1;}
9 else { return 2;}}
10 else
11 { if ( B == C ) { return 2;}
12 else
13 { if ( A == C ) { return 2;}
14 else { return 3;}}}
15 }
16

17 int main ( int argc , char * argv []) {

18 float LadoA , LadoB , LadoC ;
19 printf ( " Digite as dimensoes dos lados do triangulo :\ n " ) ;
20 scanf ( " % f " ,& LadoA ) ;
21 scanf ( " % f " ,& LadoB ) ;
22 scanf ( " % f " ,& LadoC ) ;
23 printf ( " \ n \ nO triangulo eh do tipo % i " , TipoTriangulo (
LadoA , LadoB , LadoC ) ) ;
24 printf ( " \ n \ nLegenda :\ n0 - Nao forma triangulo \ n1 - Triangulo
equilatero \ n2 - Triangulo isosceles \ n3 - Triangulo escaleno
");
25 return 0;
26 }
 18

Referências

LAPORTA, M. Z.; ZAMPIERI, M. F.; ANDRÉ, S. Manual para elaboração de trabalhos

acadêmicos. São Paulo: Fundação Santo André, 2006.

SOFFNER, R. K. Algoritmos e programação em linguagem C. [S.l.]: Editora Saraiva, 2017.