Introdução
Imagina que queres todos os números inteiros não negativos até 1000.
Seria ridículo teres de os escrever todos num array.
Para isso existe o tipo range:
julia> 0:1000
0:1000
julia> typeof(0:1000)
UnitRange{Int64}
Os intervalos são muito comuns: não só para te poupar trabalho a escrever, mas também como tipos devolvidos por funções.
Repara que os intervalos não são vetores.
São apenas um conjunto de instruções para gerar uma sequência (avaliação "preguiçosa", ou um "iterador").
Se precisares de um intervalo como vetor, usa a função collect() para o converter:
julia> collect(0:5)
6-element Vector{Int64}:
0
1
2
3
4
5
É possível especificar o tamanho do passo, neste caso 0.3:
julia> collect(1.0:0.3:2.0)
4-element Vector{Float64}:
1.0
1.3
1.6
1.9
Portanto, a sintaxe é start:stepsize:stop.
Ambos os limites são inclusivos, como se vê no exemplo com inteiros.
Se o tamanho do passo não dividir exatamente stop - start, o último elemento não ultrapassa stop.
Intervalos de letras
Também se podem usar sequências não numéricas em intervalos.
O exemplo mais simples são as letras ASCII:
julia> 'a':'d'
'a':1:'d'
julia> typeof('a':'d')
StepRange{Char, Int64}
julia> collect('a':'d')
4-element Vector{Char}:
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)
'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)
O tipo Char será abordado com mais detalhe noutro conceito.
Por agora, trata-os apenas como carateres individuais entre plicas.
Funções e operadores para intervalos
Verifica os limites de um intervalo com first() e last().
r = 1:10 # => 1:10
first(r) # => 1
last(r) # => 10
Mais sobre indexação de vetores
Intervalos de inteiros e vetores podem ser usados na indexação de vetores:
nums = collect(10.0:50.0)
nums[3:2:7] # gives [12.0, 14.0, 16.0]
nums[ [3, 5, 7] ] # also gives [12.0, 14.0, 16.0]
Instruções
Como entusiasta de xadrez, gostarias de escrever a tua própria versão do jogo. Sim, já deve haver por aí muitas implementações de xadrez disponíveis online, mas a tua vai ser única!
Mas antes de dares asas à imaginação, tens de tratar do básico. Vamos começar por gerar o tabuleiro.
Cada casa do tabuleiro de xadrez é identificada por um par letra-número. As colunas verticais de casas, chamadas colunas, são etiquetadas de A a H. As linhas horizontais de casas, chamadas filas, são numeradas de 1 a 8.
1. Define o intervalo de filas
Implementa a função rank_range(). Deve devolver um intervalo de inteiros, de 1 a 8.
julia> rank_range()
# output omitted
2. Define o intervalo de colunas
Implementa a função file_range().
Deve devolver um intervalo de carateres, da letra A maiúscula à letra H maiúscula.
julia> file_range()
# output omitted
Implementa a função ranks(). Deve devolver um vetor de inteiros, de 1 a 8.
Não escrevas o vetor à mão, gera-o a partir do intervalo devolvido pela função rank_range().
julia> ranks()
[1, 2, 3, 4, 5, 6, 7, 8]
Implementa a função files. Deve devolver um vetor de carateres, de 'A' a 'H'.
Não escrevas o vetor à mão, gera-o a partir do intervalo devolvido pela função file_range().
julia> files()
['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H']
Exercício de aprendizagem
