Compreensão de Listas Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html.

Apresentação em tema: "Compreensão de Listas Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html."— Transcrição da apresentação:

1 Compreensão de Listas Leonardo Lucena – IFRN, 2011 Adaptação das Transparências de Graham Hutton (http://www.cs.nott.ac.uk/~gmh/book.html)http://www.cs.nott.ac.uk/~gmh/book.html These slides may be used or modified for any educational purpose on a non-profit-making basis, provided that I am acknowledged as the original author.

2  Em Matemática, a notação de compreensão pode ser usada para construir novos conjuntos a partir de outros 1 {x 2 | x  {1...5}} O conjunto {1,4,9,16,25} de todos os números x 2 tal que x é um elemento do conjunto {1…5}.

3  Em Scala, uma notação similar de compreensão pode ser usada para contruir novas listas a partir de outras 2 for(x<-1 to 5) yield x*x A lista [1,4,9,16,25] de todos os números x*x tal que x é um elemento da lista 1 to 5.

4  A expressão x <- 1 to 5 é chamada de geradora, já que ela define os valores de x. z Compreensão pode ter múltiplos geradores (separados por vírgulas). Por exemplo: 3 for(x  List(1,2,3), y  List(4,5)) yield (x,y) // List((1,4),(1,5),(2,4),(2,5),(3,4),(3,5))

5  A modificação da ordem dos geradores modifica a ordem dos elementos na lista final:  Múltiplos geradores são como laços aninhados Os últimos geradores são como laços mais internos cujas variáveis mudam de valor mais frequentemente. 4 for(y  List(4,5), x  List(1,2,3)) yield (x,y) // List((1,4),(2,4),(3,4),(1,5),(2,5),(3,5))

6 5 for(y  List(4,5), x  List(1,2,3)) yield (x,y) [(1,4),(2,4),(3,4),(1,5),(2,5),(3,5)] x  List(1,2,3) é o último gerador, assim o valor do componente x de cada para muda mais frequentemente.

7  Geradores posteriores podem depender de variáveis que são introduzidas por geradores anteriores. 6 for(x  1 to 3, y  x to 3) yield (x,y) A lista [(1,1),(1,2),(1,3),(2,2),(2,3),(3,3)] de todos os pares dos números (x, y) tal que x e y são elementos da lista [1..3] e y  x.

8  Usando um gerador dependente nós podemos definir uma função que concatena uma lista de listas:  Por exemplo 7 def concat[T](xss:List[List[T]]) = for(xs  xss, x  xs) yield x > concat(List(List(1,2,3),List(4,5),List(6))) List(1,2,3,4,5,6)

9  Compreensões de listas podem usar guardas para restringir os valores produzidos por geradores anteriores. 8 for(x  1 to 10; if par(x)) yield x A lista [2,4,6,8,10] de todos os números x tal que x é um elemento da lista [1..10] e x é par.

10  Usando uma guarda nós podemos definir uma função que mapeia um inteiro positivo em uma lista de fatores: 9 def fatores(n: Int) = for(x  1 to n; n % x == 0) yield x > fatores(15) List(1,3,5,15)

11  Um inteiro positivo é primo se seus únicos fatores forem 1 e ele mesmo. Assim, usando fatores nós podemos definir uma função que decide se um número é primo:  Por exemplo: 10 def primo(n: Int) = fatores(n) == List(1,n) > primo(15) false > primo(7) true

12  Usando uma guarda nós podemos definir uma função que devolve uma lista de todos os primos até um dado limit  Exemplo 11 def primos(n: Int) = for(x  2 to n; primo(x)) yield x > primos(40) List(2,3,5,7,11,13,17,19,23,29,31,37)

13  A função zip mapeia duas listas para uma lista de pares.  Exemplo 12 def zip[A,B](a: A, b: B):List[(A,B)] = … > List(’a’,’b’,’c’) zip List(1,2,3,4) List((’a’,1),(’b’,2),(’c’,3))

14  Usando zip podemos definir uma função que devolve a lista de todos os pares de elementos adjacentes de uma lista:  Exemplo 13 pares[T](xs: List[T]) = xs zip (xs tail) > pares(List(1,2,3,4)) List((1,2),(2,3),(3,4))

15  Usando pares podemos definir uma função que decide se os elementos em uma lista estão ordenados:  Exemplo 14 def ordenado[T](xs: List[T]) = and(for((x,y)  pares(xs)) yield (x<=y)) > ordenado(List(1,2,3,4)) true > ordenado(List(1,3,2,4)) false

16  Usando zip podemos definir uma função que devolve a lista de todas as posições de um valor em uma lista: 15 def posições[T](x:T, xs: List[T]) = { val ps = 0 until (xs length) for((x1,i)  xs zip ps; if x==x1) yield i } > posições(0, List(1,0,0,1,0,1,1,0)) List(1,2,4,7)

17  Uma String é uma sequência de caracteres inclusos em aspas duplas. Internamente, entretanto, strings são representadas como uma lista de caracteres. 16 val abc: String = "abc” Significa val abc: List[Char] = List(’a’,’b’,’c’)

18  Já que Strings são um caso especial de listas, qualquer função polimórfica que opera em listas pode também ser aplicada a strings. Por exemplo: 17 > "abcde".length 5 > "abcde" take 3 "abc“ > "abc" zip List(1,2,3,4) List((’a’,1),(’b’,2),(’c’,3))

19  Compreensões de listas podem ser usadas para definir funções sobre Strings, tal como a função que conta as letras minúsculas em uma string: 18 def minusculas(xs: String) = (for(x  xs; isLower(x)) yield x) length > minusculas("Scala") 4

20 1. Uma tripla (x,y,z) de inteiros positivos é chamada de pitagoreana se x 2 + y 2 = z 2. Usando compreensão de listas, defina a função: que mapeia um inteiro n para todas as triplas com componentes em [1..n]. Por exemplo: 19 def pitagoreana(n:Int):List[(Int,Int,Int)] > pitagoreana(5) List((3,4,5),(4,3,5))

21 2. Um inteiro positivo é perfeito se ele for igual a soma de seus fatores, excluindo o próprio número. Usando compreensão de listas, defina uma função que devolve a lista de todos os números perfeitos até um dado limite. Por example: 20 def perfeitos(n: Int) = … > perfeitos(500) List(6,28,496)

22 3. O produto escalar de duas listas de inteiros xs e ys de tamanho n é dado pela soma dos produtos dos inteiros correspondentes: Usando compreensão de listas, defina uma função que devolve o produto escalar de duas listas. 21 (xs i * ys i )  i = 0 n-1