De tempos em tempos nos reunimos no trabalho para incentivar práticas de programação e design através de Dojos, e nos próximos dias teremos um Coding Dojo para exercitar desenvolvimento em Java, e o problema que apresentaremos será decompor um valor em cédulas de uma determinada moeda. A prática do Dojo será evolutiva, partindo do problema inicial como sendo a decomposição de valores inteiros em cédulas inteiras, evoluindo para o tratamento de centavos e finalizando com um controle de cédulas disponíveis. Resolvi praticar este problema individualmente, com Clojure (claro) e de início cheguei na seguinte implementação do problema inicial:
(ns troco)
(def cedulas-reais { :cem 100, :cinquenta 50, :vinte 20, :dez 10, :cinco 5, :dois 2, :um 1 })
(defn decompor [montante cedulas]
(loop [ total-em-cedulas {}
valor-restante montante
notas (seq cedulas)]
(if (not-empty notas)
(let [ face ((first notas) 0),
quanto-vale ((first notas) 1) ]
(recur (assoc total-em-cedulas face (quot valor-restante quanto-vale))
(mod valor-restante quanto-vale)
(rest notas)))
total-em-cedulas)))
(defn decompor-em-cedulas [valor moeda]
(filter #(> (% 1) 0) (seq (decompor valor moeda))))
;(decompor-em-cedulas 37 cedulas-reais)
Desta minha solução, tenho alguns pontos a melhorar
1 - O uso de seq para transformar o map em seqüência de vetores "cédula x valor" é necessário?
2 - Ao invés de declarar variáveis auxiliares (let) para obter a cédula e o valor, não seria melhor criar uma função ou então algum tipo de dado?
3 - Para ignorar as cédulas não utilizadas a melhor forma é utilizar um filter sobre - novamente - um map convertido em seqüência?
(ns troco)
(def cedulas-reais { :cem 100, :cinquenta 50, :vinte 20, :dez 10, :cinco 5, :dois 2, :um 1 })
(defn decompor [montante cedulas]
(loop [ total-em-cedulas {}
valor-restante montante
notas cedulas]
(if (not-empty notas)
(let [ face ((first notas) 0),
quanto-vale ((first notas) 1) ]
(recur (assoc total-em-cedulas face (quot valor-restante quanto-vale))
(mod valor-restante quanto-vale)
(rest notas)))
total-em-cedulas)))
(defn decompor-em-cedulas [valor moeda]
(filter #(> (% 1) 0) (decompor valor moeda)))
Hoje li que a função (first) já opera sobre maps como sendo seqs, retornando um vetor com o primeiro key/value deste.
(questão 2 respondida)
(ns troco)
(def cedulas-reais { :cem 100, :cinquenta 50, :vinte 20, :dez 10, :cinco 5, :dois 2, :um 1 })
(defn face [cedula]
(cedula 0))
(defn valor [cedula]
(cedula 1))
(defn decompor [montante cedulas]
(loop [ total-em-cedulas {}
valor-restante montante
notas cedulas]
(if (not-empty notas)
(let [ cedula (first notas)]
(recur (assoc total-em-cedulas (face cedula) (quot valor-restante (valor cedula)))
(rem valor-restante (valor cedula))
(rest notas)))
total-em-cedulas)))
(defn decompor-em-cedulas [valor moeda]
(filter #(> (% 1) 0) (decompor valor moeda)))
Não sei dizer se fez diferença em termos de clareza: acabou por ficar um (let) para referenciar a cédula topo do map, e as duas funções para retornar o primeiro e segundo elementos do vetor key/value, respectivamente.
Sobre utilizar algum tipo de dado, até pensei em tornar o map em um vetor de maps, composto por duas chaves. Algo assim:
(ns troco)
(def cedulas-reais [{:face :cem, :valor 100}
{:face :cinquenta, :valor 50}
{:face :vinte, :valor 20}
{:face :dez, :valor 10}
{:face :cinco, :valor 5}
{:face :dois, :valor 2}
{:face :um, :valor 1}])
(defn decompor [montante cedulas]
(loop [ total-em-cedulas {}
valor-restante montante
notas cedulas]
(if (not-empty notas)
(let [ cedula (first notas)]
(recur (assoc total-em-cedulas (cedula :face) (quot valor-restante (cedula :valor)))
(rem valor-restante (cedula :valor))
(rest notas)))
total-em-cedulas)))
(defn decompor-em-cedulas [valor moeda]
(filter #(> (% 1) 0) (decompor valor moeda)))
Mas não sei ainda afirmar o que parece "mais correto" em clojure =/
Ah, sutilmente =) troquei (mod) por (rem). Puramente por questões sintáticas.
(questão 3 respondida)
(ns troco)
(def cedulas-reais [{:face :cem, :valor 100}
{:face :cinquenta, :valor 50}
{:face :vinte, :valor 20}
{:face :dez, :valor 10}
{:face :cinco, :valor 5}
{:face :dois, :valor 2}
{:face :um, :valor 1}])
(defn decompor-em-cedulas [valor cedulas]
(loop [ total-em-cedulas {}
valor-restante valor
notas cedulas]
(if (not-empty notas)
(let [ cedula (first notas)]
(if (>= valor-restante (cedula :valor))
(recur (assoc total-em-cedulas (cedula :face) (quot valor-restante (cedula :valor)))
(rem valor-restante (cedula :valor))
(rest notas))
(recur total-em-cedulas
valor-restante
(rest notas))))
total-em-cedulas)))
Não me passou pela cabeça que pudesse colocar 2 (recur) mas faz sentido, já que o (recur) é uma substituição à chamada recursiva da 'função' definida como (loop). Só não estou gostando de ter estes dois (if), e ainda me pergunto se não dá pra resolver com somente um (recur), mas continuarei pesquisando.
Por hoje era isto ;-)
