Exercício PF:

Q1: function fareaRet(x, y) {

return x*y
}

const l1 = 6.1
const l2 = 4.4

const area = fareaRet(l1,l2)

//Compor texto na saída para ajudar o usuário

const texto = `Retângulo de lados ${l1} e ${l2} tem área igual à
${area}.`
console.log(texto)

Q2:

function fareaEli(x, pi=3.14) {

return pi*(x**2)
}

const raio = 5.0

//Se não informarmos o valor de pi, ele usa o padrão

//já pré-definido no parâmetro durante a definição da
//função. Ou seja, o valor 3.14.
const area = fareaEli(raio)

//Compor texto na saída para ajudar o usuário

const texto = `Circunferência de raio ${raio} tem área igual à
${area}.`

console.log(texto)

Q3:

function podeSerTriangulo(x, y, z) {
const somaXY = x+y
const somaXZ = x+z
const somaYZ = y+z
return (somaXY > z && somaXZ > y && somaYZ > x)
}
//Experimente testar com outros valores
const l1 = 2
const l2 = 3
const l3 = 4

const teste = podeSerTriangulo(l1,l2,l3)

//Função auxiliar para ajudar a formar o texto de saída

function auxSN(t) {
if (t) return ''
else return 'não'
}
const texto = `Lados ${l1}, ${l2} e ${l3} ${auxSN(teste)} podem formar
um triângulo.`

console.log(texto)

Q4:

function podeSerTriangulo(x, y, z) {
const somaXY = x+y
const somaXZ = x+z
const somaYZ = y+z
return (somaXY > z && somaXZ > y && somaYZ > x)
}

function tipoTriangulo(x, y, z) {
//A primeira constante abaixo é verdade se todos lados forem
iguais.
//A segunda é verdade se todos forem diferentes.
//Não sendo nenhum dos dois casos, então.... :)
const iguaisXYZ = x==y && y==z
const difXYZ = x!=y && x!=z && y!=z
if (iguaisXYZ) return 'Equilátero'
else if (difXYZ) return 'Escaleno'
else return 'Isósceles'
}

//Experimente testar com outros valores

const l1 = 3
const l2 = 4
const l3 = 3

//Texto de saída. Estou aproveitando o teste da questão anterior. ;)

if (podeSerTriangulo(l1, l2, l3)) {
console.log(`Triângulo ${tipoTriangulo(l1, l2, l3)}.`)

} else console.log('Não é triângulo!')

Q5:

function distancia(x1,y1,x2,y2) {
//Função Math.abs é pré-definida de Javascript
//e serve para retornar o módulo de um valor
//Função Math.sqrt calcula a raiz quadrada
const x1x2 = Math.abs(x1-x2)
const y1y2 = Math.abs(y1-y2)
if (x1 == x2) return y1y2 //paralela à ordenada
else if (y1 == y2) return x1x2
else return Math.sqrt(x1x2**2 + y1y2**2) //ou seja, hipotenusa
}

//Experimente testar com outros valores

const ponto1x = 3
const ponto1y = 4
const ponto2x = 6
const ponto2y = 0

const resultado = distancia(ponto1x,ponto1y,ponto2x,ponto2y)

//Texto de saída.

console.log(`Distância entre os pontos é ${resultado}.`)

Q6:

function fquantosIguais(x, y, z) {
if (x==y && y==z) return 3
else if (x!=y && y!=z && x!= z) return 0
else return 2
}

const a = 6
const b = 5
const c = 4

const resultado = fquantosIguais(a,b,c)

 console.log(resultado)

Q7:

function menor(x, y) {
if (x<y) return x
else return y
}

const a = -3
const b = 0
const c = 9

//Observe que não é necessário criar uma função

//para comparar três valores. Basta reaproveitar
//a função de comparação entre dois valores quantas
//vezes desejar para comparar muitos valores e descobrir
//o menor.
const resultado = menor(a,menor(b,c))

console.log(resultado)

Q8:

function quadrado(x) {
return x**2
}

const a = -3

//Idem à questão da comparação entre três números

//para descobrir o menor.

console.log(`Quarta potência de ${a} é ${quadrado(quadrado(a))}.`)

Q9:

function xor (x,y) {

return (x || y) && !(x && y)
}

const v1 = false
const v2 = true
 console.log(`${v1} ⊗ ${v2} = ${xor(v1,v2)}.`)

Q10:

function f(a, b) {
return `${b}, ${a}.`
}
const n1 = 'John'
const n2 = 'Nash'

console.log(f(n1, n2))

Q11:

function fmedia(x, y, z) {
return (x+y+z)/3
}

function fmaior(x, m) {
if (x>m) return 1
else return 0
}

const a = 3
const b = 7
const c = 9

//A estratégia aqui foi criar uma função que retorna 1

//se um valor for maior que média. Dessa forma, evita-se
//vários "ifs".
const media = fmedia(a,b,c)
const total = fmaior(a,media) + fmaior(b,media) + fmaior(c,media)

//O caracter '\n' representa 'quebra de linha'. Com isso,

//conseguimos colocar quebra de linhas dentro do texto de saída.

console.log(`Quantos maiores que a média entre ${a}, ${b} e

${c}?\nResp: ${total}`)

Q12:

//O último parâmetro serve para indicar qual a raiz

//desejada naquele cálculo: + ou -
function fraiz(a,b,c,r) {
const delta = b**2 - 4*a*c
if (r>0) return ((-1)*b + Math.sqrt(delta))/(2*a)
else return ((-1)*b - Math.sqrt(delta))/(2*a)
}

//Esses valores abaixam representam a equação -2x² +x +3 = 0

//Você pode altera-los para fazer outros testes, mas lembre
//que pode acontecer de não existir raízes reais. Nesse caso,
//será impresso algo como NaN (significa Not a Number).
const a = -2
const b = 1
const c = 3

//Último argumento serve apenas para indicar qual a raiz desejada

//entre as duas possíveis.
const raiz1 = fraiz(a,b,c,-1)
const raiz2 = fraiz(a,b,c,1)

console.log(`As raízes da equação são: ${raiz1} e ${raiz2}.`)

Q13:

const ta = 0
const xa = 500
const tb = 30
const xb = 2000

const velocidade = (t,x,t0=0,x0=0) => (x-x0)/(t-t0)

console.log(velocidade(tb,xb))

Q14:

//Usei o switch al invés de vários 'ifs' apenas

//para mostrar novas possibilidades da linguagem.
function extenso(n) {
switch (n) {
case 0: return 'ZERO'; break;
case 1: return 'UM'; break;
case 2: return 'DOIS'; break;
case 3: return 'TRÊS'; break;
 case 4: return 'QUATRO'; break;
case 5: return 'CINCO'; break;
case 6: return 'SEIS'; break;
case 7: return 'SETE'; break;
case 8: return 'OITO'; break;
case 9: return 'NOVE'; break;
default: return 'NÃO é um algarismo'
}
}

const alg1 = 7
const alg2 = '13'

console.log(`${alg1} por extenso: ${extenso(alg1)}.`)

console.log(`${alg2} por extenso: ${extenso(alg2)}.`)