Percursos
/
F#
F#
/
Exercícios
/
Tracks on Tracks on Tracks
Tracks on Tracks on Tracks

Tracks on Tracks on Tracks

Exercício de aprendizagem

Introdução

Listas

Uma list em F# é uma coleção imutável de zero ou mais valores. Todos os valores de uma lista têm de ser do mesmo tipo. Como as listas são imutáveis, depois de uma lista ser construída o seu valor nunca pode mudar. Quaisquer funções/operadores que pareçam modificar uma lista (como adicionar um elemento) devolvem, na verdade, uma nova lista.

As listas podem definir-se da seguinte forma:

let empty = []
let singleValue = [5]
let threeValues = ["a"; "b"; "c"]

A forma mais comum de adicionar um elemento a uma lista é através do operador :: (cons):

let twoToFour = [2; 3; 4]
let oneToFour = 1 :: twoToFour
// => [1; 2; 3; 4]

Uma lista em F# tem uma cabeça (o primeiro elemento) e uma cauda (tudo o que vem depois do primeiro elemento). A cauda de uma lista é, ela própria, uma lista.

As listas são manipuladas quer com funções e operadores definidos no módulo List, quer manualmente, recorrendo à correspondência de padrões com os padrões list e cons:

let describe list =
    match list with
    | [] -> "Empty list"
    | head::tail -> sprintf "Non-empty list with head: %d" head

describe []        // => "Empty list"
describe [1]       // => "Non-empty with head: 1"
describe [5; 7; 9] // => "Non-empty with head: 5"

Também podes descartar um valor ao fazer correspondência de padrões; quando não te importas com um valor num caso específico (ou seja, não o vais _usar), podes usar um underscore ('_') para o indicar:

let describe list =
    match list with
    | [] -> "Empty list"
    | [x] -> "List with one item"
    | [_; y] -> "List with two items (first item ignored)"
    | _ -> "List with many items (all items ignored)"

describe []        // => "Empty list"
describe [1]       // => "List with one item"
describe [5; 7]     // => "List with two items (first item ignored)"
describe [5; 7; 9] // => "List with many items (all items ignored)"

O '_' isolado deve vir sempre em último lugar na correspondência de padrões. Qualquer valor que não corresponda a nenhum dos outros casos será tratado por este caso.

Instruções

Neste exercício vais escrever código para acompanhar uma lista de linguagens de programação que queres aprender no Exercism.

Tens seis tarefas, e todas envolvem lidar com listas.

1. Cria uma nova lista

Para acompanhares as linguagens que queres aprender, vais precisar de criar uma nova lista. Define a ligação newList, que contém uma lista nova e vazia.

newList
// => []

2. Define uma lista existente

De momento, tens um papel com a lista das linguagens que queres aprender: F#, Clojure e Haskell. Define a ligação existingList para representar esta lista.

existingList
// => ["F#"; "Clojure"; "Haskell"]

3. Adiciona uma nova linguagem a uma lista

À medida que exploras o Exercism e encontras linguagens mais interessantes, vais querer adicioná-las à tua lista. Implementa a função addLanguage para acrescentar uma nova linguagem ao início da tua lista.

addLanguage "TypeScript" ["JavaScript"; "CoffeeScript"]
// => ["TypeScript"; "JavaScript"; "CoffeeScript"]

4. Conta as linguagens da lista

Contar as linguagens uma a uma é incómodo. Implementa a função countLanguages para contar o número de linguagens da tua lista.

countLanguages ["C#"; "Racket"; "Rust"; "Ruby"]
// => 4

5. Inverte a lista

A dada altura, dás conta de que a tua lista está, na verdade, pela ordem inversa! Implementa a função reverseList para inverter a tua lista.

reverseList ["Prolog"; "C"; "Idris"; "Assembly"]
// => ["Assembly"; "Idris"; "C"; "Prolog"]

6. Verifica se a lista é entusiasmante

Embora gostes de todas as linguagens, o F# tem um lugar especial no teu coração. Por isso, ficas mesmo entusiasmado com uma lista de linguagens se:

  • A primeira da lista for o F#.
  • O segundo item da lista for o F# e a lista tiver duas ou três linguagens.

Implementa a função excitingList para verificar se uma lista de linguagens é entusiasmante:

excitingList ["Nim"; "F#"]
// => true
Editar via GitHub A ligação abre numa nova janela ou separador
F# Exercism

Estás pronto para começar Tracks on Tracks on Tracks?

Inscreve-te no Exercism para aprenderes e dominares F# com 18 conceitos148 exercícios, e mentoria humana real, tudo grátis.