SICP Exercício 1.3 pedido de comentários
Pergunta
Eu estou tentando aprender esquema via SICP. Exercício 1.3 lê como segue: Defina um procedimento que leva três números como argumentos e retorna a soma dos quadrados dos dois números maiores. Por favor, comente sobre como posso melhorar a minha solução.
(define (big x y)
(if (> x y) x y))
(define (p a b c)
(cond ((> a b) (+ (square a) (square (big b c))))
(else (+ (square b) (square (big a c))))))
Solução
Looks ok para mim, há específica qualquer coisa que você quer melhorar?
Você poderia fazer algo como:
(define (max2 . l)
(lambda ()
(let ((a (apply max l)))
(values a (apply max (remv a l))))))
(define (q a b c)
(call-with-values (max2 a b c)
(lambda (a b)
(+ (* a a) (* b b)))))
(define (skip-min . l)
(lambda ()
(apply values (remv (apply min l) l))))
(define (p a b c)
(call-with-values (skip-min a b c)
(lambda (a b)
(+ (* a a) (* b b)))))
E este (proc p) podem ser facilmente convertidos para lidar com qualquer número de argumentos.
Outras dicas
Usando apenas os conceitos apresentados nesse ponto do livro, gostaria de fazê-lo:
(define (square x) (* x x))
(define (sum-of-squares x y) (+ (square x) (square y)))
(define (min x y) (if (< x y) x y))
(define (max x y) (if (> x y) x y))
(define (sum-squares-2-biggest x y z)
(sum-of-squares (max x y) (max z (min x y))))
big
é chamado max
. Use a funcionalidade de biblioteca padrão quando ele está lá.
A minha abordagem é diferente. Ao invés de muitos testes, eu simplesmente adicionar os quadrados dos três, em seguida, subtrair o quadrado da menor.
(define (exercise1.3 a b c)
(let ((smallest (min a b c))
(square (lambda (x) (* x x))))
(+ (square a) (square b) (square c) (- (square smallest)))))
Se você prefere esta abordagem, ou um monte de testes if
, é com você, é claro.
implementação alternativo utilizando SRFI 95 :
(define (exercise1.3 . args)
(let ((sorted (sort! args >))
(square (lambda (x) (* x x))))
(+ (square (car sorted)) (square (cadr sorted)))))
Como acima, mas como um one-liner (graças synx @ freenode #scheme); Também requer SRFI 1 e SRFI 26 :
(define (exercise1.3 . args)
(apply + (map! (cut expt <> 2) (take! (sort! args >) 2))))
Eu fiz isso com o seguinte código, que usa o built-in procedimentos min
, max
e square
. Eles são bastante simples de implementar usando apenas o que foi introduzido no texto até esse ponto.
(define (sum-of-highest-squares x y z)
(+ (square (max x y))
(square (max (min x y) z))))
O que sobre algo assim?
(define (p a b c)
(if (> a b)
(if (> b c)
(+ (square a) (square b))
(+ (square a) (square c)))
(if (> a c)
(+ (square a) (square b))
(+ (square b) (square c)))))
Usando apenas os conceitos introduzidos até esse ponto do texto, que eu acho que é bastante importante , aqui está uma solução diferente:
(define (smallest-of-three a b c)
(if (< a b)
(if (< a c) a c)
(if (< b c) b c)))
(define (square a)
(* a a))
(define (sum-of-squares-largest a b c)
(+ (square a)
(square b)
(square c)
(- (square (smallest-of-three a b c)))))
(define (sum-sqr x y)
(+ (square x) (square y)))
(define (sum-squares-2-of-3 x y z)
(cond ((and (<= x y) (<= x z)) (sum-sqr y z))
((and (<= y x) (<= y z)) (sum-sqr x z))
((and (<= z x) (<= z y)) (sum-sqr x y))))
(define (f a b c)
(if (= a (min a b c))
(+ (* b b) (* c c))
(f b c a)))
Com Scott Hoffman e alguns irc ajuda eu corrigi o meu código defeituoso, aqui está
(define (p a b c)
(cond ((> a b)
(cond ((> b c)
(+ (square a) (square b)))
(else (+ (square a) (square c)))))
(else
(cond ((> a c)
(+ (square b) (square a))))
(+ (square b) (square c)))))
Você também pode classificar a lista e adicione os quadrados do primeiro e do segundo elemento da lista ordenada:
(require (lib "list.ss")) ;; I use PLT Scheme
(define (exercise-1-3 a b c)
(let* [(sorted-list (sort (list a b c) >))
(x (first sorted-list))
(y (second sorted-list))]
(+ (* x x) (* y y))))
Aqui está ainda outra maneira de fazê-lo:
#!/usr/bin/env mzscheme #lang scheme/load (module ex-1.3 scheme/base (define (ex-1.3 a b c) (let* ((square (lambda (x) (* x x))) (p (lambda (a b c) (+ (square a) (square (if (> b c) b c)))))) (if (> a b) (p a b c) (p b a c)))) (require scheme/contract) (provide/contract [ex-1.3 (-> number? number? number? number?)])) ;; tests (module ex-1.3/test scheme/base (require (planet "test.ss" ("schematics" "schemeunit.plt" 2)) (planet "text-ui.ss" ("schematics" "schemeunit.plt" 2))) (require 'ex-1.3) (test/text-ui (test-suite "ex-1.3" (test-equal? "1 2 3" (ex-1.3 1 2 3) 13) (test-equal? "2 1 3" (ex-1.3 2 1 3) 13) (test-equal? "2 1. 3.5" (ex-1.3 2 1. 3.5) 16.25) (test-equal? "-2 -10. 3.5" (ex-1.3 -2 -10. 3.5) 16.25) (test-exn "2+1i 0 0" exn:fail:contract? (lambda () (ex-1.3 2+1i 0 0))) (test-equal? "all equal" (ex-1.3 3 3 3) 18)))) (require 'ex-1.3/test)
Exemplo:
$ mzscheme ex-1.3.ss 6 success(es) 0 failure(s) 0 error(s) 6 test(s) run 0
É bom ver como outras pessoas ter resolvido este problema. Esta foi a minha solução:
(define (isGreater? x y z)
(if (and (> x z) (> y z))
(+ (square x) (square y))
0))
(define (sumLarger x y z)
(if (= (isGreater? x y z) 0)
(sumLarger y z x)
(isGreater? x y z)))
Eu resolvi por iteração, mas eu gosto Ashitaka de e (+ (quadrado (máx xy)) (quadrado (max (min xy) z))) soluções melhor, pois na minha versão, se z é o menor número , é maior? chama-se duas vezes, criando um processo desnecessariamente lento e tortuoso.
(define (sum a b) (+ a b))
(define (square a) (* a a))
(define (greater a b )
( if (< a b) b a))
(define (smaller a b )
( if (< a b) a b))
(define (sumOfSquare a b)
(sum (square a) (square b)))
(define (sumOfSquareOfGreaterNumbers a b c)
(sumOfSquare (greater a b) (greater (smaller a b) c)))
Eu tive um ir:
(define (procedure a b c)
(let ((y (sort (list a b c) >)) (square (lambda (x) (* x x))))
(+ (square (first y)) (square(second y)))))
;exercise 1.3
(define (sum-square-of-max a b c)
(+ (if (> a b) (* a a) (* b b))
(if (> b c) (* b b) (* c c))))
Eu acho que este é o menor e mais eficiente maneira:
(define (square-sum-larger a b c)
(+
(square (max a b))
(square (max (min a b) c))))
A seguir é a solução que eu vim com. Acho que é mais fácil raciocinar sobre uma solução quando o código é decomposto em pequenas funções.
; Exercise 1.3
(define (sum-square-largest a b c)
(+ (square (greatest a b))
(square (greatest (least a b) c))))
(define (greatest a b)
(cond (( > a b) a)
(( < a b) b)))
(define (least a b)
(cond ((> a b) b)
((< a b) a)))
(define (square a)
(* a a))