Programação em Scheme

Objetivo

Reunir anotações e exercícios que farei durante meu aprendizado da linguagem de programação "Scheme".

Cálculo de Juros Simples e Composto

A seguir coloco dois programas que calculam juros simples e composto.

Usei as fórmulas encontradas no artigo da wikipedia.

Juros Simples

(define (valor-futuro-simples valor-presente juros meses) 
  (* valor-presente 
     (+ 1 
        (* 
         (/ juros 100) 
         meses))))

(define juros
  (lambda ()
    (display "Informe valor, juros(%) e meses, e veja resposta em juros simples e composto.")
    (newline)
    (let ((valor (begin
                             (display "Valor(R$): ")
                             (read)))
          (juros (begin
                             (display "Juros(%): ")
                             (read)))
          (meses (begin
                             (display "Meses: ")
                             (read)))
          )
      (if (and (number? valor) (number? juros) (number? meses))
          (begin
            (display "Valor futuro, em juros simples, para o valor R$")
            (display valor)
            (display " com juros de ")
            (display juros)
            (display "% em ")
            (display meses)
            (display " parcela(s) será: R$")
            (display (valor-futuro-simples valor juros meses))
            (display ".")
            (newline))
          (error "juros: Use somente números para valor de entrada.")))))

Juros Compostos

(define (valor-futuro-composto valor-presente juros meses) 
  (* valor-presente 
     (expt 
      (+ 1 
         (/ juros 100)
         ) 
      meses)))

(define juros-c
  (lambda ()
    (display "Informe valor, juros(%) e meses, e veja resposta em juros simples e composto.")
    (newline)
    (let ((valor (begin
                             (display "Valor(R$): ")
                             (read)))
          (juros (begin
                             (display "Juros(%): ")
                             (read)))
          (meses (begin
                             (display "Meses: ")
                             (read)))
          )
      (if (and (number? valor) (number? juros) (number? meses))
          (begin
            (display "Valor futuro, em juros compostos, para o valor R$")
            (display valor)
            (display " com juros de ")
            (display juros)
            (display "% em ")
            (display meses)
            (display " parcela(s) será: R$")
            (display (valor-futuro-composto valor juros meses))
            (display ".")
            (newline))
          (error "juros: Use somente números para valor de entrada.")))))

Aplicação do código para cálculo de juros usando GUILE

guile> (juros-c)
Informe valor, juros(%) e meses, e veja resposta em juros simples e composto.
Valor(R$): 100
Juros(%): 0.5
Meses: 24
Valor futuro, em juros compostos, para o valor R$100 com juros de 0.5% em 24 parcela(s) será: R$112.715977620539.
guile> (juros)
Informe valor, juros(%) e meses, e veja resposta em juros simples e composto.
Valor(R$): 100
Juros(%): 0.5
Meses: 24
Valor futuro, em juros simples, para o valor R$100 com juros de 0.5% em 24 parcela(s) será: R$112.0.
guile>

Notas sobre o livro "Simply Scheme"

Exercícios

Respostas do exercícios do livro "Simply Scheme" por capítulo.

Nota: estou colocando somente as respostas, a pergunta deve ser localizada no capítulo respectivo do livro.

Clique no link em cada capítulo para acessar o conteúdo on-line do livro

Capítulo 4

Link: http://www.cs.berkeley.edu/~bh/ssch4/defining.html

Definições criadas para responder os exercícios (conforme numeração abaixo)

(define (scientific x y)
   (* x (expt 10 y)))

(define (discount x y)
   (* x (- 1 (/ y 100))))

4.10

(define (tip v)
   (- (ceiling (* v 1.15)) v))

Capítulo 5

Link: http://www.cs.berkeley.edu/~bh/ssch5/words.html

Definições criadas para responder os exercícios (conforme numeração abaixo)

5.15

(define (first-two n)
        (word (first n) (first (bf n))))

5.16

(define (two-first n m)
        (word (first n) (first m)))

5.14

(define (third n)
        (first (bf (bf n))))

5.19

(define (insert-and n)
        (se (bl n) 'and  (last n)))

5.20

(define (middle-names n)
        (bl (bf n)))

5.21

(define (query n)
        (se (first (bf n)) (first n) (last n) '?))

Capítulo 6

Link: http://www.cs.berkeley.edu/~bh/ssch6/true.html

Exercícos executados na linha de comando para avaliar a resposta

guile> (nowhere man)

guile> (cond (empty? 3)
      (square 7)
      (else 9))
Backtrace:
In standard input:
   7: 0* (cond (empty? 3) (square 7) (else 9))

standard input:7:1: In expression (cond (empty? 3) (square 7) ...):
standard input:7:1: Unbound variable: empty?
ABORT: (unbound-variable)

guile> (load "simply.scm")
guile> (define (third-person-singular verb)
  (cond ((equal? verb 'be) 'is)
        ((equal? (last verb) 'o) (word verb 'es))
        (else (word verb 's))))

(third-person-singular 'go)

guile> goes

guile> (or #f #f #f #t)
 #t
guile> (and #f #f #f #t)
 #f
guile> (or (= 2 3) (= 4 3))
 #f
guile> (not #f)
 #t
guile> (or (not (= 2 3) (= 4 3)))

Backtrace:
In standard input:
   5: 0* (or (not (= 2 3) (= 4 3)))
   5: 1  [not #f #f]

standard input:5:5: In procedure not in expression (not (= 2 3) (= 4 3)):
standard input:5:5: Wrong number of arguments to #<primitive-procedure not>
ABORT: (wrong-number-of-args)

guile> (or (and (= 2 3) (= 3 3) (and (< 2 3) (< 3 4))))
 #f

(define (sign number)
  (cond ((< number 0) 'negative)
        ((equal? number 0) 'zero)
        (else 'positive)))

(define (utensil meal)
  (if (equal? meal 'chinese) 
      'chopsticks
      'fork))

;;
;; EXERCÍCIO 6.5
;;

;; Verifica se é am
(define (is-am suffix)
  (if (equal? suffix 'am)
      (or #t)
      (or #f)))

;; Verifica se yé pm 
(define (is-pm suffix)
  (if (equal? suffix 'pm)
      (or #t)
      (or #f)))

;; Calcula e mostra a hora no formato europeu
(define (european-time hour)
  (cond ((equal? (is-am (car(cdr hour))) #t) (display hour))
        ((equal? (is-pm (car(cdr hour))) #t) (display (+ (car hour) 12)))
        (else (display "Please, enter a american style time, for example, 4 pm"))))

;; Verifica se a faixa está entre 0-24 h
(define (is-range-ok? hour)
  (if (<= (- hour 24) 0)
         (or #t)
         (or #f)))

;; Retorna a hora em formato americano
(define (calc-time hour)
  (cond ((<= hour 12) (list hour 'am)))
        ((>= hour 12) (list (- hour 12) 'pm))
        (else (or #f))))

;; Calcula e mostra a hora no formato americano
(define (american-time hour)
  (if (is-range-ok? hour)  
      (calc-time hour)
      (display "Wrong value \n\n")))

Capítlo 7

Link: http://www.cs.berkeley.edu/~bh/ssch7/variables.html
A seguir as funções que fiz quando estudava o capitulo 7 do livro "Simply Scheme"

;;
;; Estudo capítulo 7 do livro "Simply Scheme"
;;
;; Ref.: http://www.cs.berkeley.edu/~bh/ssch7/variables.html
;;

;;
;; Estudo
;;

;; Primeira versão da fórmula computando duas raízes
(define (roots a b c)
  (begin 
    (/ 
     (+ 
      (- b) 
      (sqrt 
       (- (* b b) (* 4 a c))))
     (* 2 a))
      (/ 
       (- 
        (- b) 
        (sqrt 
         (- (* b b) (* 4 a c))))
      (* 2 a))))

;; Segunda versão da fórmula computando duas raízes com ajuda de um procedimento auxiliar roots1
(define (roots a b c)
  (roots1 a b c (sqrt (- (* b b) (* 4 a c)))))

(define (roots1 a b c discriminant)
  (begin (/ (+ (- b) discriminant) (* 2 a))
         (/ (- (- b) discriminant) (* 2 a))))

;; Terceira versão da fórmula computando duas raízes usando let
(define (roots a b c)
  (let ((discriminant (sqrt (- (* b b) (* 4 a c)))))
    (begin (/ (+ (- b) discriminant) (* 2 a))
           (/ (- (- b) discriminant) (* 2 a)))))

;; Quarta versão da fórmula usando let com três pares de nome-valor para eliminar redundâncias da fórmula
(define (roots a b c)
  (let ((discriminant (sqrt (- (* b b) (* 4 a c))))
        (minus-b (- b))
        (two-a (* 2 a)))
    (begin (/ (+ minus-b discriminant) two-a)
           (/ (- minus-b discriminant) two-a))))

Exercícios 7.1 até 7.4 resolvidos

;;
;; Exercício 7.1
;;

;; Auxiliar para verificar se é vogal
(define (vowel? letter)
  (member? letter 'aeiou))

;; Versão sem usar let
(define (gertrude wd)
    (se (if (vowel? (first wd)) 'an 'a)
      wd
      'is
      (if (vowel? (first wd)) 'an 'a)
      wd
      'is
      (if (vowel? (first wd)) 'an 'a)
      wd))

;; Versão usando let
(define (gertrude2 wd)
   (let ((v? (if (vowel? (first wd)) 'an 'a))
         (r (list wd 'is)))
      (se v?
          r
          v?
          r
          v?
          wd))) 

;;
;; Exercício 7.2
;;

;; Errado
(let pi 3.14159
       pie 'lemon meringue
    se 'pi is pi 'but pie is pie)

;; Correto
(let ((pi 3.14159)
      (pie '(lemon meringue)))
      (se 'pi 'is pi 'but 'pie 'is pie))


;;
;; Exercício 7.3
;;

;; Errado porque o argumento word tem o mesmo nome do procedimento word, 
;; quando o procedimento for avaliado será substituido pelo procedimento 
;; que não será executado como procedimento pois é apenas um símbolo
(define (superlative adjective word)
  (se (word adjective 'est) word))

;; Certo
(define (superlative adjective wd)
  (se (word adjective 'est) wd))

;;
;; Exercício 7.4
;; 

;; Nesse procedimento let atribui ao símbolo '+' o procedimento *
;; e atribui ao símbolo '*' o procedimento +, portanto o procedimento
;; deve multiplicar onde encontrar o '+' e somar onde encontrar '*'
(define (sum-square a b)
  (let ((+ *)
        (* +))
    (* (+ a a) (+ b b))))

;; Para (sum-square 2 3) o resultado será 13

flaviosouza.org | blog | @flaviosouza