HackaTruck - UFS

Algoritmos - Módulo 1
Nota: Material apenas de resumo, sendo indicado apenas para uma
rápida revisão antes ou após estudar o conteúdo.

Variáveis e Constantes em Swift

Há duas formas de declarar uma variável na linguagem Swift, podendo ser uma variável do tipo var(mutável) ou
utilizando uma variável do tipo constante let(imutável).

// Variável mutável
var saborPizza = "Calabresa" // Variável do tipo String
var tamanhoEmCm = 48 // Variável do tipo Int

// Variável imutável
let nomePizzaria = "PizzaForDevs" // Constante do tipo String
let precoUnico = 49.99 // Constante do tipo Float

// Função print() imprime o resultado na tela.

print(saborPizza)
print(tamanhoEmCm)
print(nomePizzaria)
print(precoUnico)

Padraões de Escrita e Nomenclaturas

Classes em Swift são escritas utilizando UpperCamelCase

O restante utiliza lowerCamelCase, como é o caso das variáveis.

Tipos de dados
Na linguagem Swift temos os tipos:

Int
Character
String
Float
Double
Bool

A linguagem Swift faz uma atribuição automática de tipo ao iniciarmos uma variável.

var firstName = "Douglas" // O tipo é String.

Essa atribuição automática é chamada de forma implícita.

Já a atribuição explícita funciona declarando o tipo de dado da variável.

 let firstName: String = "Douglas" // Tipo String.

Para verificar o tipo de uma variável utilizamos o operador type(of: variável)

let fullName: String = "Douglas Cunha de Jesus"

print(type(of: fullName)) // String

Nota: Qualquer decimal criado de forma implícita será automaticamente do tipo Double. Caso queiramos trabalhar com
float devemos declarar de forma explícita.

Vejamos alguns exemplos de variáveis e seus tipos

let firstName: String = "Douglas"

let piFloat: Float = 3.1415

let piDouble: Double = 3.1415

let isMe: Bool = true

let caractere: Character = "@"

Comandos de Atribuição
Veremos operações que podem ser realizadas dentro de um programa.

Utilizamos o símbolo = para realizar atribuições a variáveis.

let firstName: String = "Douglas" // Atribuímos o valor a variável.

Utilizamos o operador de adição para realizar concatenação(junção) de duas ou mais strings.

let firstName: String = "Douglas"

let lastName: String = "Cunha"
let fullName: String = firstName + " " + lastName
print(fullName) // Douglas Cunha

Operadores Aritméticos

Os operadores aritméticos que iremos utilizar na linguagem Swift são:

Adição: +
Subtração: -
Multiplicação: *
Divisão: /
Resto: %
 var x: Int = 10
var y: Int = 2

var total: Int

// Soma
total = x + y
print(total) // 12

// Subtração
total = x - y
print(total) // 8

// Multiplicação
total = x * y
print(total) // 20

// Divisão
total = x / y
print(total) // 5

// Resto
total = x % y
print(total) // 0

Os operadores pow() e sqrt() são os operadores de potênciação e radiciação

import Foundation // Nos permite utilizar os operadores pow() e sqrt()

var x1, y1, result: Double
x1 = 2.0
y1 = 9.0

result = pow(x1, 2.0)

print("\(x1) elevado ao quadrado é: \(result)")
// Essa barra \(valor) é chamado de interporlação
// é uma maneira mais simples de exibir um resultado.

result = sqrt(y1)
print("A raiz quadrada de \(y1) é: \(result)")

Operadores Lógicos

Operadores lógicos geram dois valores, true ou false. Podemos realizar algumas combinações envolvendo os
operadores lógicos, vejamos:

var resultado: Bool

resultado = !true
print("O resultado de !true é \(resultado)") // False. É uma negação.

resultado = !false
print("O resultado de !false é \(resultado)") // True, estamos negando o valor false.

Alguns operadores lógicos são:

AND (&&)
OR (||)
 NOT (!)

var isTrue: Bool = true

var isFalse: Bool = false

print(isTrue && isFalse) // False

print(isTrue && (!isFalse)) // True

Operadores de Comparação
Operadores de comparação atuam sobre dois operandos e retornam um valor do tipo lógico.

Vejamos alguns desses operadores:

Igualdade (==)
Diferente (!=)
Menor que (<)
Maior que (>)
Menor ou igual que (<=)
Maior ou igual que (>=)

var salarioJoao, salarioPedro, salarioMarcos: Double

var resultado: Bool

salarioJoao = 1300
salarioPedro = 1000
salarioMarcos = 1000

resultado = salarioJoao == salarioPedro // False

print("O salário do João é igual ao salário do pedro? \(resultado)")

resultado = salarioJoao != salarioPedro // True

print("O salário do João é diferente do salário do Pedro? \(resultado)")

resultado = salarioJoao > salarioPedro // True

print("O salário do João é maior que o salário do pedro? \(resultado)")

resultado = salarioJoao < salarioPedro // False

print("O salário do João é menor que o salário do Pedro? \(resultado)")

resultado = salarioJoao <= salarioPedro // False

print("O salário do João é menor ou igual ao salário do Pedro? \(resultado)")

resultado = salarioJoao >= salarioPedro // True

print("O salário do João é maior ou igual ao salário do Pedro? \(resultado)")

resultado = salarioPedro <= salarioMarcos // True

print("O salário do Pedro é menor ou igual ao salário do Marcos? \(resultado)")

resultado = salarioPedro >= salarioMarcos // True

print("O salário do Pedro é maior ou igual ao salário do Marcos? \(resultado)")
Estrutura Condicional
Comando IF-ELSE

Uma estrutura condicional serve para avaliar uma condição, caso ela seja verdadeira iremos executar o nosso
bloco de código.

var minhaIdade = 22

// 22 > 18, logo é true.

if (minhaIdade >= 18) {
print("Maior de idade")
}
else {
print("Menor de idade!")
}

Além disso, temos múltiplas condições utilizando o comando ELSE-IF.

Comando Switch

O comando Switch serve para evitar um grande aninhamento de if-else, ele é praticamente igual ao comando if,
mas utilizado de outra forma.

var diaSemana: String = "Sexta"

switch diaSemana {
case "Segunda":
print("Segundou!")
case "Terça":
print("Terçou!")
case "Quarta":
print("Quartou!")
case "Quinta":
print("Quintou!")
case "Sexta":
print("Sextou!")
case "Sábado":
print("Sabadou!")
case "Domingo":
print("Domingou!")
default:
print("Valor inválido!")
}

Ou seja, o valor da variável diaSemana é testado em todas os casos até que encontremos um respectivo valor.

Operador de Intervalo usando Switch:

 let reais = 10

switch reais {
// O 5 não está incluso, pois é menor que cinco.
case 0..<5:
print("O preço está entre 0 e 4 reais!")
case 5...10:
print("O preço está entre 5 e 10 reais!")
default:
print("O preço é maior que 10 reais!")
}

A notação de intervalos é utilizada pra representar uma sequência de valores. O operador < na frente de um número
serve para excluir esse valor do intervalo.

Estrutura de Repetição
O comando While repete uma determinada instrução até que a condição seja verdadeira.

var count = 1

while count <= 5 {

print(count)
// Incrementa uma unidade
count += 1
}

Podemos utilizar o comando break para finalizar um laço de repetição, vejamos:

var i = 10;

while i >= 10 {
print(i)
if i == 1 {
print("Feliz ano novo!")
break
}
// Decrementa i
i -= 1
}

Comando repeat-while é igual ao do-while da linguagem C, a repetição executa ao menos uma vez e após isso é realizado
uma checagem da condição de execução. ```swift var x = 5

// Executa ao menos uma vez. repeat { print(x) x += 1 } while x <= 10 // Condição

Comando for é semelhante ao comando while.

// Percorre de 1 a 5.
for i in 1...5 {
print("Bom dia!")
}
 // Exemplo de loop que gera a tabuada de 10
for i in 1...10 {
print("10 x \(i) = \(10 * i)")
}

// Exemplo de loop que gera toda a tabuada

for x in 1...10 {
for y in 1...10 {
print("\(x) x \(y) = \(x * y)")
}
}

No exemplo acima temos que o primeiro loop irá executar e logo em seguida, o segundo loop irá executar ate que
o valor(condição de existência) y for igual a 10. Após isso o primeiro loop executa e o valor de x se torna 2 e
executa o segundo loop novamente, tudo isso ocorre até que o primeiro loop tenha valor 11, o que torna a
condição falsa.

Funções
Uma função é um bloco de código responsável por executar determinadas instruções. Utilizar funções faz com que
nosso código fique mais legível além de permitir o reuso dessas funções dentro do nosso código.

// Declaração de função
func displaySomething() {
print("Hello, world!")
}

// Realizamos a chamada da função para executpa-la.

displaySomething() // Hello, world!

Utilizar parâmetros nas nossas funções nos permite passar valores como entrada para a função, vejamos:

func sumOfTwoNumbers(numUm: Int, numDois: Int) {

print("A soma entre \(numUm) + \(numDois) = \(numUm + numDois)") // 5
}
// Chamamos a função e passamos dois argumentos para os nossos parâmetros numUm e numDois.
sumOfTwoNumbers(numUm: 2, numDois: 3)

Na função acima passamos dois parâmetros do tipo Int com seus respectivos nomes, em seguida, utilizamos a
função print e realizamos a soma desses parâmetros. Após isso, chamamos a nossa função e passamos dois
valores como argumento para a nossa função. Note que temos que especificar o nome de cada parâmetro.

Tipo de Retorno de uma função é basicamente o que a função retorna como valor após a sua execução, vejamos:

// Note que após os parênteses temos o tipo de retorno

// da nossa função, nesse caso um valor inteiro.
func sumOfTwoNumbers(numUm: Int, numDois: Int) -> Int {
// Retornamos a soma dos nossos parâmetros.
return numUm + numDois
}

// Chamamos a função
print(sumOfTwoNumbers(numUm: 2, numDois: 3)) // 5

Recursão
 Recursão é basicamente uma função que chama a sí própria x vezes. Após criarmos nossa função, é necessário
definirmos um caso base para que não haja uma chamada infinita da função(nesse caso um loop). Vejamos um
exemplo de recursão infinita:

func helloWorld() {
// Chamamos a própria função dentro da nossa função.
helloWorld()
}

// Chamamos a função para realizar sua execução.

helloWorld()

No exemplo acima temos que nossa função irá chamar a sí própria infinitas vezes, o que resultará em um
"estouro" de memória, o que causa a parada do programa.

Utilizando um caso base nos permite controla a recursão para que não haja infinitas chamadas da função, vejamos:

func countDownTimer(time: Int) {

print("Contagem regressiva: \(time)")

// Caso base.
if time > 0 {
// Chamamos a própria função e fazemos a decrementação do nosso parâmetro.
countDownTimer(time: time - 1)
}
// Exibe a mensagem abaixo.
if time == 0 {
print("Feliz ano novo!!!")
}
}
// Chamamos a função para realizar a sua execução.
countDownTimer(time: 10)

Exemplo de recursão envolvendo fatorial de um número

func fatorial(num: Int) -> Int {

// Caso base.
if num <= 1 {
return 1
}
// Chamamos a função e em seguida, realizamos a multiplicação entre os valores.
return (fatorial(num: num - 1) * num)
}

var valor = 5
print("O fatorial de \(valor) é: ", fatorial(num: valor)) // 120 pois 5 * 4 * 3 * 2 * 1 = 120.

Fim do primeiro módulo.