C#: Um Pouco Mais Recursivo

E aí galera, tudo beleza?

Hoje o assunto é semelhante ao meu post a respeito de Recursividade (http://aterribili.blogspot.com.br/2014/01/haskell-recursividade.html), vou falar mais um pouco, só que ao invés de usarmos Haskell, vamos usar C#!

(Se por acaso você não possua uma forma de compilar C#, replique o exercício em Java, é bem parecido!)

Se você ainda não sabe o que é Recursividade, aconselho ler meu post anterior.

Vamos imaginar um problema simples e que você não possa usar um for para resolver?

Crie um método que Multiplica uma String, ou seja:

"a" * 3 = "aaa"
"ab" * 2 = "abab"

Consegue imaginar algo do tipo?

Com o uso da Resursividade, podemos resolver esse problema de forma simples e elegante.

Vamos ver o Teste de Unidade primeiro, assim fica mais simples de entender:

...
[TestMethod]
public void DeveMultiplicarString(){
  Assert.AreEqual("abab", new Multiplicador().MultiplicaString(2, "ab");
}

Daí ficou simples entender o que deve acontecer.

Vamos criar a classe Multiplicador:

public class Multiplicador() {
  public String MultiplicaString(int vezes, String string){
    if(vezes == 1) //Aqui definimos uma Guarda
      return string;

    return string + Multiplicador(--vezes, string); 
  }
}

Feito isso, entenda que a Guarda é um ponto onde a execução do método será parada.
A execução do método é efetuada de forma recursiva, toda vez que a variável vezes for maior que 1.
E existem n exemplos onde recursão é aplicável e criamos uma função muito mais legível aos olhos de outro programador.

Bom galera, por hoje é só! Estou preparando um post a respeito de Funcs no C#.

Qualquer coisa, email-me: abner.terribili@lambda3.com.br ou comente abaixo!

Cheers!

Haskell: Lazy Evaluation e Listas

E aí galera!

Continuando na saga Haskell, hoje vou falar a respeito de uma de suas maiores características: Lazy Evaluation. (Avaliação Preguiçosa)

O que é Lazy Evaluation?
É uma estratégia utilizada para avaliação de funções. Ela consiste em não avaliar nenhuma subexpressão ou função até que seu retorno seja conhecido como necessário, ou seja, no momento em que o valor, da expressão ou função, for requisitado para continuidade da função, ele será calculado.

Quais são as vantagens?
- Melhor desempenho ao evitar cálculos desnecessários, evitando condições de erro na avaliação de expressões compostas.
- Habilitade de representar potencialmente estruturas de dados infinitas, exemplo:
Você precisa fazer a soma de a partir de n até o infinito:

-- A função lista, recebe um inteiro e retorna uma lista de inteiros dados a partir de n

lista :: Int -> [Int]
lista = n : lista (n + 1)

Ou seja, a função lista gera infinitos números para uma lista de inteiros a partir de um número passado como parâmetro. Vamos executar esse código:

Main> lista 5
lista 5 = 5 : lista (5 + 1)
        = 5 : 6 : lista (6 + 1)
        = 5 : 6 : 7 : lista (7 + 1)
        ...
        ....
        .....
        ......

A soma só é executada quando necessária :).

Para maior compreensão do exemplo que citei, vou deixar algumas noções sobre Listas em Haskell.

Listas
Uma lista é uma estrutura de dados que representa uma coleção de objetos homogêneos. Ou seja, objetos que são do mesmo Tipo de Dado.

Listas em Haskell
Uma lista em Haskell é composta por head (cabeça) e tail (corpo). A cabeça é o primeiro objeto da lista, por onde é feito o nó de acesso da lista. A partir dela(head) temos acesso aos objetos que estão no tail da lista.

Para criar uma lista em Haskell é bem simples:

-- Lista de números
fibonacci :: [Int]
fibonacci = [1, 1, 2, 3, 5, 8]
-- Lista de Char
nome :: [Char]
nome = ['A', 'B', 'C', 'D']
-- Lista de String
lista_char :: [[Char]]
lista_char = ["Haskell", ['H', 'A', 'S', 'K', 'E', 'L', 'L']]
-- A string "Haskell" é uma lista de Char

Legal né?

Para criar uma lista vazia:

[]

Pronto, alguns exercícios serão os melhores exemplos.
Vá ao seu terminal e entre no interpretador Hugs.

Digite:

Main> 1 : []

[1]

Main> 1 : 2 : 3 : []

[1,2,3]

Acho que deu pra perceber o que estamos fazendo né? Adicionando elementos a lista. Bem simples, com o caractere ':' nós adicionamos elementos a lista.

Podemos até mesmo fazer comparações de listas:

Main> [1,2,3] == (1 : 2 : 5 : [])

False

Main> [a,b] == [b, a]

ERROR - Undefined variable "b"

Por que vemos esse erro?
Simplesmente porque estamos a usar um tipo de dado Char, que DEVE vir entre ' '.

Main> ['a', 'b'] == ['b', 'a']

False

Pronto.
Não se esqueça também que os elementos de uma lista estão entre [ ] e separados por vírgula.

Galera, por hoje é só. Qualquer dúvida, comente abaixo ou email-me: abner.terribili@gmail.com.

Cheers!

Ruby: Hello World!

E aí galera, hoje vou escrever sobre outra linguagem, que segundo alguns especialistas também tem algo funcional, não sei se é verdade, mas logo logo descubro e deixo aqui pra vocês :).

RUBY!

O Ruby foi lançado em 1995 por Yukihiro Matsumoto (também conhecido como Matz).
O objetivo de Matz ao fundamentar as bases do Ruby, foi pensar em algo expressivo, para assim ser simples de ler e ser compreendida. Com esses pensamentos, Matz criou uma linguagem orientada a objetos, com tipagem forte e dinâmica.

E fala sério, olha essa expressividade:

Vou deixar um material legal para vocês poderem ler a respeito :). A apostila aberta da Caelum vem ajudando muito no meu treinamento, se quiser dê uma olhadinha aqui. No site deles, Ruby, também existem alguns tutoriais bacanas.

Deixarei dois exemplos mais básicos, para você que ainda não configurou seu ambiente, vamos lá.

O site do Ruby, explica detalhadamente como configurar o seu ambiente. Então não vou estender muito essa parte, porque é "desnecessário".

Mas basicamente é isso:

Linux:

apt-get install ruby irb rdoc

Mac, com gerenciador Homebrew:

brew install ruby

Windows:
https://www.ruby-lang.org/pt/downloads/

Depois de instalado, podemos testar se ocorreu tudo certo assim, abra seu terminal e digite:

ruby --version

Verá algo como:

ruby 2.0.0p247 (2013-06-27 revision 41674) [universal.x86_64-darwin13]

E pronto! Podemos brincar.

Vamos ao Hello World descolado. Crie um arquivo em seu diretório favorito, com o nome de hello_world.rb. A extensão .rb significa Ruby, e é a extensão usada para o interpretador Ruby reconhecer como arquivo Ruby.

Abra seu arquivo com editor seu editor e digite em seu interior:

# Assim fazemos comentário de uma linha no Ruby

puts "Digite seu nome: "

nome = gets

puts "Hello #{nome.capitalize}!"

O que aconteceu aí em cima, é o seguinte:

puts = imprime conteúdo e pula uma linha.

nome = variável que recebe a string digitada pelo usuário, através de:

gets = um método que permite atribuir um valor do tipo string a uma variável.

#{sua_variavel} = Faz a interpolação da sua String com a variável inserida.

.capitalize = Deixa a primeira letra da sua cadeira de caracteres maiúscula.

Como você pode ver, não precisamos declarar o tipo da variável, e isso não quer dizer que Ruby é fracamente tipada, muito pelo contrário, seu interpretador reconhece e faz o trabalho por você. Mas lembre-se que ruby também é dinamicamente tipada, ou seja, pode ser trocado o valor da variável em tempo de execução. Mais para frente, dou alguns exemplos e melhores explicações.

Vamos exercitar na segunda função:
Podemos fazer esse hello_world ser mais moderno, como?

puts "Digite seu nome: "

nome = gets

def hello_world(nome)

 return "Hello , #{nome.capitalize)

end



puts hello_world(nome)

Agora só testar no seu terminal, digitando:

ruby hello_world.rb

E anime-se com o resultado! rs

Esse foi o primeiro post sobre Ruby e quero escrever muito mais. Qualquer dúvida comente abaixo, ou mande email: abner.terribili@gmail.com. Eu curto muito feedback. O exemplo está no GitHub.

Cheers!