dia3+dia4_hws.swift

/// ARRAYS

var beatles = ["John", "Paul", "George", "Ringo"]
let numbers = [4, 8, 15, 16, 23, 42]
var temperatures = [25.3, 28.2, 26.4]

// Em Swift, guardamos vários itens em um único objeto chamado array. Arrays são feitos com []. Para encontrar um item dentro de um array, o Swift indexa em zero.

print(beatles[0])
print(numbers[1])
print(temperatures[2])

    // Podemos apensionar um item a um array com o método .append() 

beatles.append("Adrian")
print(beatles)

    // É preciso prestar atenção ao TIPO de dado. Ou seja, não podemos juntar 26.0 ao array beatles. 

let firstBeatle = beatles[0]
let firstNumber = numbers[0]
// let notAllowed = firstBeatle + firstNumber
// Erro no último comando! Swift é type safe. 

var scores = Array<Int>()
scores.append(100)
scores.append(80)
scores.append(85)
print(scores[1])

    // Esse Array<Int> é o tipo de array que criamos. No R, faríamos algo simples como vetor = c(), e no Python, vetor = [] para criar um array vazio. Aqui, precisamos explicitar o tipo a ser guardado.

var albums = [String]()
albums.append("Folklore")
albums.append("Fearless")
albums.append("Reputation")
albums.append("Red")
print(albums)
    // Ao escrevermos [String] é o mesmo que dizer Array<String>.

print(albums.count)
    // O método count aqui funciona pra quantos items existem no array! 

albums.append("Tábua de Esmeralda")
print(albums)
albums.remove(at: 4)
print(albums)
albums.removeAll()
print(albums)
    // Podemos remover um item com .remove(at: ) ou .removeAll()

let bondMovies = ["Casino Royale", "Spectre", "No Time To Die"]
print(bondMovies.contains("Frozen"))
    // .contains() verifica se o array contém um elemento

let cities = ["London", "Tokyo", "Rome", "Budapest", "Teresópolis"]
print(cities.sorted())
let cities2 = cities.reversed()
print(cities2)
    // .sorted() coloca em ordem alfanumérica e .reversed() inverte o array (mas não expõe isso simplesmente). .sorted() também funciona pra strings! 

    /// DICIONÁRIOS

let empregado = [
    "nome": "Matheus Pestana", 
    "cargo": "Pesquisador",
    "localização": "Rio de Janeiro",
    "tipo de trabalho":"Remoto"
]

// Dicionários fazem uma junção de chave-valor em um array. Assim, deixa de ser um array e vira realmente um dicionário, onde cada chave tem um valor específico e pode ser por ele referenciado.

print(empregado["nome"])
print(empregado["cargo"])
print(empregado["localização"])
print(empregado["tipo de trabalho"])

    // No output, o Swift coloca Optional("Matheus Pestana") ao invés de Matheus Pestana. Isso é pelo fato de que eu posso, em um dicionário, receber um valor mas isso não é garantido. A isso, o Swift dá o nome de Optional. 

print(empregado["nome", default: "Unknown"])
print(empregado["cargo", default: "Unknown"])
print(empregado["localização", default: "Unknown"])
print(empregado["tipo de trabalho", default: "Unknown"])
    // Quando colocamos um default, ele automaticamente corrige e remove o Optional(), indicando que o valor que obtemos é o valor verdadeiro, e não um valor que talvez não exista. Se não existisse, teríamos "Unknown". 

var alturas = [String: Int]()
alturas["Matheus"] = 171
alturas["Gabriela"] = 160
alturas["Weslley"] = 169
alturas["Keki"] = 173

    // Criamos um dicionário vazio, mas determinamos o tipo de chave e o tipo de valor. Se eu errase uma altura, eu poderia reescrever da mesma forma.
alturas["Gabriela"] = 163

    // Os métodos .count e .removeAll() também existem para dicionários.

    /// SETS

var people = Set(["Denzel Washington", "Tom Cruise", "Nicolas Cage", "Samuel L. Jackson"])
// Além de arrays e dicionários, existe o tipo Set, que não permite adicionar itens duplicados e nõa armazena os itens em uma ordem particular. Primeiro, criamos um array e então atribuimos o Set(). 
print(people)

people = Set<String>()
people.insert("Denzel Washington")
people.insert("Tom Cruise")
people.insert("Nicolas Cage")
people.insert("Samuel L Jackson")

    // Para inserirmos um item em um Set, usamos .insert e não .append. O insert insere sem se preocupar com a ordem, e o append sempre adiciona à última casa.
print(people)

    // Por qual motivo usar Set ao invés de arrays? Às vezes, não queremos nomes duplicados mesmo. E sobre a ordem, a ordem colocada pelo Set é otimizada, ou seja, se quiséssemos localizar um item, ele faria muito mais rápido (com o .contains()) do que em um array.

    /// ENUM

enum Semana {
    case Segunda
    case Terça
    case Quarta
    case Quinta
    case Sexta
}

// Enum é um tipo de coleção que nos permite criar um array com possibilidades de valores. 

var dia = Semana.Segunda
dia = Semana.Terça
dia = Semana.Quarta
print(dia)

enum Semana2 {
    case segunda, terça, quarta, quinta, sexta
}
// Podemos criar também dessa forma, escrevendo case apenas uma vez.

print(Semana2.self)

    // Não podemos printar Semana2 e suas opções, nem usando .self. Enums também são salvos de forma otimizada, atribuindo-se internamente no Swift um número à cada um. Mal comparando, é como os fatores no R.

    /// Type Annotations

    // Swift consegue inferir qual o tipo de dado de um objeto. Mas e se quiséssemos especificar?
var score: Double = 0
let playerName: String = "Matheus"
var numeroDaSorte: Int = 13
let pi: Double = 3.1415
var éReal: Bool = true
var albumsJorgeBen: [String] = ["Tábua de Esmeralda", "Samba Esquema Novo", "África Brasil"]
var user: [String: String] = ["instagram":"@mateuspestana"]
var books: Set<String> = Set(["O Pequeno Príncipe", "Os Románov", "Poemas - Maiakovski"])
var soda: [String] = ["Coke", "Pepsi", "Fanta"]
// Para criar um array vazio:
var teams: [String] = [String]()
// Mas também poderíamos fazer:
var cities3: [String] = []
// Mas é melhor explicitar ao máximo.
var cities4 = [String]()

/// CHECKPOINT 2 - This time the challenge is to create an array of strings, then write some code that prints the number of items in the array and also the number of unique items in the array.

var discosPaulinho: [String] = ["Dança da Solidão", "Acústico MTV", "Bebadosamba", "Foi um Rio que passou em minha vida", "Nervos de Aço", "Eu canto samba", "Bebadachama", "Prisma Luminoso", "Prisma Luminoso"]
    // Criamos um array com um disco duplicado.
print("O número de discos no array é \(discosPaulinho.count)")
    // Na hora do count, ele ainda é considerado.

let discosPaulinhoSet: Set<String> = Set(discosPaulinho)
print("O número verdadeiro de discos é \(discosPaulinhoSet.count)")

    // Resolvido =)