tarefa 1 - Versao 3

Versão 3: veja no final um exemplo de entrada e saida.

Benford law

Benford law é uma lei sobre a frequências dos diferentes dígitos como o primeiro dígito de números que ocorrem naturalmente.

ATE meia noite de 29/10

Pode ser feito por grupos de ate 3 pessoas.

Coloque o nome e RA dos membros do grupo como comentário no início do programa

Apenas um membro do grupo submete via susy

Voce pode usar todos os módulos padrão do Haskell (não pode usar módulos que precisam ser instalados usando o cabal, por exemplo)

Escreva um programa em haskell que conta o número de vezes que cada dígito (1 a 9) aparece como o primeiro dígito em um texto (string) qualquer (na versão 1 eu ainda não especifiquei o encoding to texto). O texto pode conter palavras, pontuação e números. Os números podem estar separados por brancos do resto do texto:

ou não

Nos tres casos só estamos interessados no primeiro digito (o 3).

A saída do seu programa deve ser

1 : n1
2 : n2
3 : n3
4 : n4
5 : n5
6 : n6
7 : n7
8 : n8 
9 : n9

onde n1 é a frequência do 1 como primeiro digito (número com 1 como primeiro digito dividido pelo número total de números no texto)

Se seu arquivo chama proj1.hs, eu rodarei seu programa como:

 ghc proj1.hs
 ./prog1 < arquivo.in

ou seja voce le o string do standard input

Versão 2

UTF8

eu escrevi a minha solução não usando nada de UTF8. Há um pacote de haskell sobre utf8 em http://hackage.haskell.org/package/utf8-string-1.0.1.1/docs/Data-String-UTF8.html mas eu escrevi o programa tratando apenas o 1, 2, .. 9 e o “.” e o programa funciona bem com arquivos UTF8. Os dígitos e o “.” são representados no utf8 pelos seus caracteres ascii assim o meu programa trata esses caracteres corretamente, e mesmo que os outros caracteres ele esteja processando errado, por exemplo quebrando um caracter utf8 de 2 bytes em 2 caracteres “inexistentes” de 1 byte, o programa não processa esses caracteres de uma forma especial, apenas testa se eles sao iguais ao 1, 2, etc.

Eu testei meu programa no arquivo exemplo1.txt que eu criei e que contem letras acentuadas e ate um lambda grego, e no arquivo utf8_sequence_0-0x10ffff_assigned_printable.txt que eu acho contem todos os caracteres uft8 e o programa funcionou nos 2 (e deu o resultado certo).

De qq forma, eu nao vou testar seu programa com dados uft8 - mas se voce fizer na linha do que eu fiz, seu programa deve funcionar com qualquer arquivo

Formatação na saída

A versão 1 detalha a formatação. Mantenha ela. Mas se for possível, formate as proporções com 2 casas decimais.

Esta pergunta no StackOverflow https://stackoverflow.com/questions/1559590/haskell-force-floats-to-have-two-decimals mostra como controlar o formato de um Float.

Eu usei a solução:

import Numeric 

formatFloatN floatNum numOfDecimals = showFFloat (Just numOfDecimals) floatNum ""

A outra que usa o printf me deu problemas. Note que essa função é complexa, ja que ela tem 2 comportamentos: ou imprime (que equivale ao prinfdo C) ou retorna um string (que equivale ao sprintf). Eu queria usar essa segunda versão, ja que eu monto o string se saída na minha função principal, e no main eu so leio, chamo a função com o string e ela me devolve o string de saída (com os newlines apropriados) e eu imprimo esse string no main (usando o putStrLn).

Versão 3

Alguns alunos estão me pedindo exemplos de entrada e saída para o projeto de haskell.

DO jeito que eu implementei o meu código eu olho para o primeiro digito que se segue a um não dígito. Desta forma, a saída para o exemplo1.txt seria

1 : 0.29
2 : 0.00
3 : 0.00
4 : 0.43
5 : 0.00
6 : 0.00
7 : 0.00
8 : 0.00
9 : 0.29

Mas não é isso que eu escrevi no texto. No texto fala no primeiro digito que se segue a um branco, mudança de linha ou $. Assim a saida do exemplo1.txt seria

1 : 0.33
2 : 0.00
3 : 0.00
4 : 0.33
5 : 0.00
6 : 0.00
7 : 0.00
8 : 0.00
9 : 0.33

ou, dois 1, dois 4 e dois 9 ja que o 4 seguindo o lambda não seria contado.

Eu vou testar o programa de voces usando as regras descritas, ou seja meus testes não terão exemplos de outro caracter que nao os discutidos acima antecedendo o primeiro dígito