Lista de Exercícios de Linguagens de Programação I

Universidade Federal do Amazonas / Instituto de Computação

Marco Cristo

Funcional

1) Defina os seguintes conceitos como são compreendidos no paradigma funcional: (a) funções
anônimas, (b) funções de primeira classe, (c) funções de alta ordem, (d) funções recursivas,
(e) funções puras, (f) avaliação preguiçosa, (g) iteradores e (h) geradores ou streams.

2) Usando LCs, defina a função enc_consonantal(palavra) que retorna o número de encontros

consonantais em palavra. Considere um encontro consonantal a ocorrência de, pelo menos,
duas consoantes em sequência. Ex: enc_consonantal('teste') = 1;
enc_consonantal('banana') = 0.

3) Defina a função maisQueKEnc(string) que retorna as palavras em string com mais que k
encontros consonantais. Ex: maisQueKEnc('esse eh um trabalhinho mequetrefe', 1) =
['trabalhinho']. Dica: string.split() retorna uma lista onde cada elemento é uma palavra de
string.

4) Implemente a função pelo_menos_k que tem como parâmetros um limiar k, uma

propriedade (descrita como uma função anônima) e uma lista e retorna True se pelo menos
k elementos na lista têm a propriedade. Ex: pelo_menos_k(len(l)/2, lambda k:k%2==0, [12,
13, 15, 17, 14]).

5) Resolva os seguintes problemas em Python, relacionados com o jogo de blackjack, usando

o paradigma funcional

a) Dadas as listas naipes = ['p', 'o', 'c', 'e'] (paus, ouros, copas e espada) e ranks =
['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A'], crie uma lista
que represente um baralho com 52 cartas representadas como tuplas, usando uma LC.
Ex: [('2', 'p'), ('2', 'o'), ('2', 'c'), ('2', 'e'), ('3', 'p'), ('3', 'o'),...,
('A', 'p'), ('A', 'o'), ('A', 'c'), ('A', 'e')].

b) Crie uma função que dada uma lista l e um valor k, retorne a lista l sem o k-ésimo
elemento. Ex: semElementoK([1,2,3], 1) = [1, 3].

c) Crie uma função que dada a lista, retorne uma versão embaralhada da mesma. Ex:
dequeEmbaralhado([1, 2, 3, 4, 5]) = [2, 3, 5, 1, 4], usando recursão e a função
semElementoK. DIca: você pode criar uma lista embaralhada usando uma lista auxiliar.
Basta tirar um elemento aleatório da primeira e colocá-lo na segunda. A segunda lista
será uma versão embaralhada da primeira. Para gerar números aleatórios, utilize a
função randint do pacote random.

d) Uma mão é uma sequência de cartas. Escreva uma função que, dada uma sequência de
cartas na forma de uma lista, produza uma string correspondente à lista de cartas.
Exemplo: lista([('J','c'),('5','p'),('10','o')]) = 'Jc 5p 10o'.

e) Escreva uma função para avaliar uma mão de cartas no jogo blackjack. Neste jogo, as
cartas são avaliadas como segue. Rei (K), rainha (Q) e valete (J) valem 10 pontos cada.
As cartas 2 a 10 valem seus valores de face (ou seja, a carta 7 vale 7 pontos). A carta Ás
(A) vale 1 ou 11 pontos. O valor da mão corresponde à soma dos valores das cartas.
 Inicialmente, todos os ases na mão valem 11 pontos, cada. Caso a soma dos valores da
mão seja maior que 21, todos os ases são avaliados como 1 ponto, cada. Exs:
valorMao([('J','c'), ('5','p'), ('10','o')]) = 25; valorMao([('A','c'),
('Q','p')]) = 21; valorMao([('A','c'), ('A','p'), ('A','o')]) = 3;

f) Uma das formas do jogo de blackjack terminar é o usuário ter uma mão com mais de 21
pontos. Crie a função fimJogo(mao) que retorna True caso isso ocorra. Exs:
fimJogo([('J','c'), ('5','p'), ('10','o')]) = True;

g) No jogo de blackjack, o adversário do jogador é a mesa (ou a banca). Entre os dois, vence
aquele que alcançar o maior número de pontos, desde que menor ou igual a 21. Em caso
de empate, vence a mesa, bem como no caso em que ambos excedem os 21 pontos.
Escreva a função vencedor(maoJogador, maoMesa) que retorna uma string indicando
quem venceu o jogo: 'jogador' ou 'mesa'. Ex: vencedor([('10','e'), ('K','p')],
[('6','p'), ('8','o'), ('A','e'), ('6','e')]) = 'mesa';

h) Descreva a função descartar que, dada uma mão e um deque, retorna a mão acrescida
da primeira carta do deque e o deque, sem aquela carta. Ex: descartar([('10','e'),
('K','p')], [('6','p'), ('8','o'), ('A','e'), ('6','e')]) = ([('10','e'),
('K','p'), ('6','p')], [('8','o'), ('A','e'), ('6','e')]).

i) Descreva a função maoMesa(deque) que, dado um deque, retira dele cartas até que o
valor da mão da mesa seja maior que 16. Use recursão. Ex: maoMesa([('10','e'),
('K','p'), [('6','p'), ('8','o'), ('A','e'), ('6','e')]) = [('10','e'),
('K','p')].

j) No jogo de blackjack, o jogador aposta com a mesa pra ver quem alcança o valor mais
próximo de 21 pontos. Enquanto o valor na sua mão for menor que 21, o jogador pode
tirar quantas cartas quiser. Se ele decide parar de descartar ou soma mais que 21, a
mesa pode começar a jogar. Considerando a estratégia descrita em (i), a mesa irá
descartar até atingir um valor maior que 16, quando irá parar. Neste momento, usando
a descrição feita em (g), é possível determinar o vencedor do jogo. Portanto, o código
do jogo pode ser completado pelas seguintes funções em Python:

def blackjack():
print 'Bem vindo ao jogo de blackjack!'
loopJogo([], dequeEmbaralhado(deque))

def loopJogo(mao, deque):

print 'Sua mao: [', lista(mao), '] =', valorMao(mao)
if fimJogo(mao):
fim(mao, maoMesa(deque));
else:
resp = raw_input('Quer outra carta? [s] ')
if not resp or resp in ['s', 'S']:
loopJogo(*descartar(mao, deque)) # tupla expandida em 2 argumentos
else:
fim(mao, maoMesa(deque))

def fim(maoJogador, maoMesa):

print 'Mao da mesa: [', lista(maoMesa), '] =', valorMao(maoMesa)
print 'Vencedor:', vencedor(maoJogador, maoMesa)

Como você modificaria a função dada em (i) para melhorar a estratégia da mesa?
Observações:

• Trabalhos para, no máximo, dois alunos, sem exceções;

• Plágio não será tolerado com cancelamento de ambas as listas;
• Data de entrega definida no site da disciplina;