Racket Lab4 - Leonardo Reis e Bruno Corrêa de Almeida|01-06

;;EXERÍCIOS DA AULA(exercícios extraclasse começam na linha 287) | Dupla: Leonardo Reis da Silva e Bruno Corrêa de Almeida.

(define-struct disciplina(nm_disciplina nota))
;; Um elemento do tipo disciplna é:
;; (make-disciplina nd n) onde:
;; nd: Nome da disciplina do tipo String
;; n: Nota recebida na disciplina do tipo Número

;; Uma Lista-de-Disciplinas é:

;; OU empty
;; OU (cons d ldd), onde:
;; - d: disciplina
;; - ldd: Lista-de-Disciplinas

(define-struct aluno(matricula nome curso historico))
;; Um elemento do tipo aluno é:
;; (make-aluno m n c h) onde:
;; m: Número de matrícula do tipo Número
;; n: Nome do aluno do tipo String
;; c: Curso do aluno do tipo String
;; h: Histórico do aluno do tipo Lista-de-Disciplinas


;; Definição de alunos para testes
(define Carlos
  (make-aluno 107 "Carlos" "Ciencia da Computaçao" (list (make-disciplina "Calculo" 8.5)(make-disciplina "MatDiscreta" 8)(make-disciplina "AlgProg" 9))))
(define Rubens
  (make-aluno 72 "Rubens" "Engenharia da Computaçao" (list (make-disciplina "Calculo" 7)(make-disciplina "MatDiscreta" 5)(make-disciplina "Fisica" 6))))
(define Manuela
  (make-aluno 540 "Manuela" "Biologia" (list (make-disciplina "Calculo" 7)(make-disciplina "Quimica" 8)(make-disciplina "Fisica" 9))))
(define Joao
  (make-aluno 400 "Joao" "Ciencia da Computaçao" (list (make-disciplina "Calculo" 5)(make-disciplina "MatDiscreta" 9)(make-disciplina "AlgProg" 10))))
(define James
  (make-aluno 52 "James" "Biologia" empty))


(define-struct no_aluno(id aluno esq dir))
;; Um elemento do tipo no_aluno é:
;; OU empty
;; OU
;; (make-no_aluno id aluno esq dir) onde:
;; id: Número de matrícula do aluno do tipo Número
;; aluno: elemento do tipo Aluno
;; esq: elemento do tipo no_aluno com id menor do que este aluno
;; dir: elemento do tipo no_aluno com id maior do que este aluno


;; Uma ABP é:
;; OU empty
;; OU no_aluno


;; Definição da ABP para testes

(define arvoreAlunos
  (make-no_aluno 107 Carlos
                 (make-no_aluno 72 Rubens
                                (make-no_aluno 52 James empty empty)
                                empty)
                 (make-no_aluno 400 Joao
                                empty
                                (make-no_aluno 540 Manuela empty empty)
                                )
                 )
  )


(define-struct NomeCurso(nome curso))
;; Um elemento NomeCurso é:
;; (make-NomeCurso n c) onde:

;; n: Nome do aluno encontrado do tipo String
;; c: Curso do aluno encontrado do tipo String

;; Tipo misto: RetornoBuscaAluno é:
;; OU NomeCurso
;; OU String


;; buscaAluno: ABP Número -> RetornoBuscaAluno

;; Objetivo: A partir de uma árvore de alunos e um número de matrícula, encontrar o nome e curso do aluno correspondente, retornando uma estrutura com tais atributos ou uma String
;; no caso do aluno não existir na árvore

;; Exemplos: (buscaAluno arvoreAlunos 107) -> (make-NomeCurso "Carlos" "Ciencia da Computaçao")
;;           (buscaAluno arvoreAlunos 52) -> (make-NomeCurso "James" "Biologia")
;;           (buscaAluno arvoreAlunos 400) -> (make-NomeCurso "Joao" "Ciencia da Computaçao")
;;           (buscaAluno empty 52) -> "Aluno não encontrado"
;;           (buscaAluno arvoreAlunos 189) -> "Aluno não encontrado"

(define (buscaAluno abp matricula)
  (cond
    [(empty? abp) "Aluno não encontrado"]
    [(> matricula (no_aluno-id abp)) (buscaAluno (no_aluno-dir abp) matricula)]
    [(< matricula (no_aluno-id abp)) (buscaAluno (no_aluno-esq abp) matricula)]
    [else (make-NomeCurso (aluno-nome (no_aluno-aluno abp)) (aluno-curso(no_aluno-aluno abp)))]
    )
  )

;;testes:
(check-expect (buscaAluno arvoreAlunos 107) (make-NomeCurso "Carlos" "Ciencia da Computaçao"))
(check-expect (buscaAluno arvoreAlunos 52) (make-NomeCurso "James" "Biologia"))
(check-expect (buscaAluno arvoreAlunos 400) (make-NomeCurso "Joao" "Ciencia da Computaçao"))
(check-expect (buscaAluno empty 52) "Aluno não encontrado")
(check-expect (buscaAluno arvoreAlunos 189) "Aluno não encontrado")

;; alunosDeCurso: ABP String -> Lista-de-Alunos

;; Uma Lista-de-Alunos é:
;; OU empty
;; OU (cons (make-aluno matricula nome curso historico) lda) onde lda é uma Lista-de-Alunos

;; Objetivo: A partir de uma árvore de alunos e um curso, retorna uma lista de elementos aluno que pertencem ao curso

;; Exemplos: (alunosDeCurso arvoreAlunos "Ciencia da Computaçao") -> (list Carlos Joao)
;;           (alunosDeCurso arvoreAlunos "Biologia") -> (list James Manuela)
;;           (alunosDeCurso empty "Biologia") -> empty
;;           (alunosDeCurso arvoreAlunos "Engenharia Quimica") -> empty

(define (alunosDeCurso abp curso)
  (cond
    [(empty? abp) empty]
    [(string=?(aluno-curso (no_aluno-aluno abp)) curso) (cons (no_aluno-aluno abp) (append(alunosDeCurso (no_aluno-esq abp) curso)(alunosDeCurso (no_aluno-dir abp) curso)))]
    [else (append(alunosDeCurso (no_aluno-esq abp) curso)(alunosDeCurso (no_aluno-dir abp) curso))]
    )
  )

;;testes:
(check-expect (alunosDeCurso arvoreAlunos "Ciencia da Computaçao")(list Carlos Joao))
(check-expect (alunosDeCurso arvoreAlunos "Biologia") (list James Manuela))
(check-expect (alunosDeCurso empty "Biologia") empty)
(check-expect (alunosDeCurso arvoreAlunos "Engenharia Quimica") empty)


;; contaElementos: Lista -> Número

;; Objetivo: conta elementos de uma lista qualquer

;; Exemplo: (contaElementos (list 1 2 3)) -> 3
;;          (contaElementos empty) -> 0

(define (contaElementos lista)
  (cond
    [(empty? lista) 0]
    [else (+ 1 (contaElementos (rest lista)))]
    )
  )

;;testes:
(check-expect (contaElementos (list 1 2 3)) 3)
(check-expect (contaElementos empty) 0)

;; Tipo misto RetornoNumD é:
;; OU String
;; OU Número


;; contaDisciplinas: ABP Número -> RetornoNumD

;; Objetivo: A partir de uma árvore de alunos e um número de matrícula, retorna o número de disciplinas cursadas pelo aluno ou uma String no caso de não encontrá-lo

;; Exemplos: (contaDisciplinas arvoreAlunos 72) -> 3
;;           (contaDisciplinas arvoreAlunos 52) -> 0
;;           (contaDisciplinas empty 52) -> "Aluno não encontrado"
;;           (contaDisciplinas arvoreAlunos 89) -> "Aluno não encontrado"

(define (contaDisciplinas abp matricula)
  (cond
    [(empty? abp) "Aluno não encontrado"]
    [(> (aluno-matricula(no_aluno-aluno abp)) matricula) (contaDisciplinas (no_aluno-esq abp) matricula)]
    [(< (aluno-matricula(no_aluno-aluno abp)) matricula) (contaDisciplinas (no_aluno-dir abp) matricula)]
    [else (contaElementos (aluno-historico(no_aluno-aluno abp)))]
    )
  )

;;testes:
(check-expect (contaDisciplinas arvoreAlunos 72) 3)
(check-expect (contaDisciplinas arvoreAlunos 52) 0)
(check-expect (contaDisciplinas empty 42) "Aluno não encontrado")
(check-expect (contaDisciplinas arvoreAlunos 89) "Aluno não encontrado")



;; Uma Lista-de-Funcionarios é:
;; OU empty
;; OU (cons f ldf), onde:
;; - f: funcionario
;; - ldf: Lista-de-Funcionarios

(define-struct funcionario(nome cargo salario subordinados))
;; Um elemento funcionario é:

;; (make-funcionario n c s sub) onde:

;; n: Nome do funcionario do tipo String
;; c: Cargo do funcionario do tipo String
;; s: Salário do funcionario do tipo Número
;; sub: Lista de subordinados do tipo Lista-de-Funcionarios

;; Definição de funcionarios para teste


(define Silvao
  (make-funcionario "Silvao" "Monitor" 12000 empty))
(define Hermanoteu
  (make-funcionario "Hermanoteu" "Monitor" 12000 empty))
(define Ribas
  (make-funcionario "Ribas" "Monitor" 10000 empty))
(define Jacques
  (make-funcionario "Jacques" "Substituto" 15000 empty))
(define Lucio
  (make-funcionario "Lucio" "Professor" 20000 (list Hermanoteu Silvao)))
(define Zumbi
  (make-funcionario "Zumbi" "Entidade" 40000 empty))
(define Marcelo
  (make-funcionario "Marcelo" "Professor" 20000 (list Ribas Jacques)))
(define Bruno
  (make-funcionario "Bruno" "Reitor" 50000 (list Marcelo Lucio Zumbi)))






;; Uma ArvoreDeFuncionarios é:
;; OU empty
;; OU (make-funcionario n c s sub), onde:
;; - n: String, nome do funcionário
;; - c: String, cargo do funcionário
;; - s: Número, salário do funcionário
;; - sub: Lista-de-Funcionarios, lista de subordinados do funcionário

;; Definição da árvore de funcionários para testes

(define arvoreFuncionarios
  Bruno)


;; numFuncionariosAcima: ArvoreDeFuncionarios Número -> Número

;; Objetivo: A partir de uma árvore de funcionários e um valor, retorna quantos funcionários, incluido a raíz da árvore e seus subordinados, possusem um salário acima desse valor

;; Exemplos: (numFuncionariosAcima arvoreFuncionarios 15000) -> 4
;;           (numFuncionariosAcima arvoreFuncionarios 20000) -> 2
;;           (numFuncionariosAcima arvoreFuncionarios 100000) -> 0
;;           (numFuncionariosAcima empty 500) -> 0



(define (numFuncionariosAcima arvoreFuncionarios valor)
  (cond
    [(empty? arvoreFuncionarios) 0]
    [(> (funcionario-salario arvoreFuncionarios) valor) (+(verificaLista (funcionario-subordinados arvoreFuncionarios) valor) 1)]
    [else (verificaLista (funcionario-subordinados arvoreFuncionarios) valor)]
    )
  )

;;testes:
(check-expect (numFuncionariosAcima arvoreFuncionarios 15000) 4)
(check-expect (numFuncionariosAcima arvoreFuncionarios 20000) 2)
(check-expect (numFuncionariosAcima arvoreFuncionarios 100000) 0)
(check-expect (numFuncionariosAcima empty 500) 0)

;;verificaLista: Lista-de-Funcionarios Número -> Número
;;Objetivo: Auxiliar de numFuncionariosAcima. Dada uma Lista-de-Funcarios(de subordinados, nesse caso) e o valor,
;;conta quantos funcionários recebem um valor maior que o passado usando recursão mútua com numFuncionariosAcima.
;;Exemplos:
;;(verificaLista (funcionario-subordinados arvoreFuncionarios) 100) -> 7
;;(verificaLista (funcionario-subordinados arvoreFuncionarios) 20000) -> 1
;;(verificaLista empty 100) -> 0
;;(verificaLista (funcionario-subordinados arvoreFuncionarios) 9999999) -> 0
(define (verificaLista listaSub valor)
  (cond
    [(empty? listaSub) 0]
    [else (+(numFuncionariosAcima (first listaSub) valor)(verificaLista(rest listaSub) valor))]
    )
  )

;;testes:
(check-expect (verificaLista (funcionario-subordinados arvoreFuncionarios) 100) 7)
(check-expect (verificaLista (funcionario-subordinados arvoreFuncionarios) 20000) 1)
(check-expect (verificaLista empty 100) 0)
(check-expect (verificaLista (funcionario-subordinados arvoreFuncionarios) 9999999) 0)


;;EXERCÍCIOS EXTRACLASSE:

;;EXTRACLASSE 1:

;;nomeAlunoMenorMatricula: ABP -> String
;;Objetivo: dada uma ABP de alunos, retorna o nome(String) do aluno com menor número de matrícula. Caso a ABP seja vazia, retorna mensagem avisando.
;;Exemplos:
;;(nomeAlunoMenorMatricula arvoreAlunos) -> "James"
;;(nomeAlunoMenorMatricula empty) -> "ABP vazia"
(define (nomeAlunoMenorMatricula ABP_alunos)
  (cond
    [(empty? ABP_alunos) "ABP vazia"]
    [else
     (cond
       [(not(empty? (no_aluno-esq ABP_alunos))) (nomeAlunoMenorMatricula (no_aluno-esq ABP_alunos))]
       [else (aluno-nome (no_aluno-aluno ABP_alunos))])]
    ))

;;testes:
(check-expect (nomeAlunoMenorMatricula arvoreAlunos) "James")
(check-expect (nomeAlunoMenorMatricula empty) "ABP vazia")





;;EXTRACLASSE 2:

;;somaNotas: Lista-de-disciplinas -> Número
;;Objetivo: Auxiliar para mediaAritmeticaAluno: Dada um histórico(Lista-de-disciplinas), retorna a soma de todas as notas.
;;Exemplos:
;;(somaNotas (aluno-historico Rubens)) -> 18
;;(somaNotas empty) -> 0
(define (somaNotas histórico)
  (cond
    [(empty? histórico) 0]
    [else (+ (disciplina-nota(first histórico)) (somaNotas (rest histórico)))]))

(check-expect (somaNotas (aluno-historico Rubens)) 18)
(check-expect (somaNotas empty) 0)

;;Um elemento retornoMediaAritmeticaAluno é:
;; - String
;;    ou
;; - Número

;;mediaAritmeticaAluno: ABP Número -> retornoMediaAritmeticaAluno
;;Objetivo: Dada uma ABP de alunos e um número de matrícula, retorna a média aritmética
;;das notas do aluno informado. Caso não encontre o aluno, retorna uma mensagem de aviso.
;;Caso encontre o aluno, mas o mesmo não possua registro em seu histórico, retorna mensagem de aviso.
;;Exemplos:
;;(mediaAritmeticaAluno arvoreAlunos 72) --> 6
;;(mediaAritmeticaAluno arvoreAlunos 107) --> 8.5
;;(mediaAritmeticaAluno empty 72) --> "Aluno não encontrado"
;;(mediaAritmeticaAluno arvoreAlunos 999) --> "Aluno não encontrado"
;;(mediaAritmeticaAluno arvoreAlunos 52) --> "Aluno possui histórico vazio"

(define (mediaAritmeticaAluno ABP_aluno matrícula)
  (cond
    [(empty? ABP_aluno) "Aluno não encontrado"]
    [(= (no_aluno-id ABP_aluno) matrícula)
     (cond
       [(empty? (aluno-historico (no_aluno-aluno ABP_aluno))) "Aluno possui histórico vazio"]
       [else (/ (somaNotas (aluno-historico (no_aluno-aluno ABP_aluno))) (contaElementos (aluno-historico (no_aluno-aluno ABP_aluno))))])]
    [(> matrícula (no_aluno-id ABP_aluno)) (mediaAritmeticaAluno (no_aluno-dir ABP_aluno) matrícula)]
    [else (mediaAritmeticaAluno (no_aluno-esq ABP_aluno) matrícula)]))

;;testes:
(check-expect (mediaAritmeticaAluno arvoreAlunos 72) 6)
(check-expect (mediaAritmeticaAluno arvoreAlunos 107) 8.5)
(check-expect (mediaAritmeticaAluno empty 72) "Aluno não encontrado")
(check-expect (mediaAritmeticaAluno arvoreAlunos 999) "Aluno não encontrado")
(check-expect (mediaAritmeticaAluno arvoreAlunos 52) "Aluno possui histórico vazio")



;;Um elemento Lista-de-string é:
;;ou empty
;;ou (cons String lds), onde:
;; String: String, uma String qualquer
;; lds: Lista-de-string


;;EXTRACLASSE 3:

;;funcionariosComCargo: ArvoreDeFuncionarios String -> Lista-de-string
;;Objetivo: Dada uma árvore de funcionários(do tipo ArvoreDeFuncionarios)e um cargo(do tipo String),
;;retorna uma lista(do tipo Lista-de-string) contendo os nomes(String) de todos os funcionários
;;daquela árvore que sejam do cargo informado.
;;Exemplos:
;;(funcionariosComCargo arvoreFuncionarios "Reitor") -> (list "Bruno")
;;(funcionariosComCargo arvoreFuncionarios "Professor") -> (list "Marcelo" "Lucio")
;;(funcionariosComCargo arvoreFuncionarios "Padeiro") -> empty
;;(funcionariosComCargo empty "Professor") -> empty
(define (funcionariosComCargo arvore_funcionarios cargo)
  (cond
    [(empty? arvore_funcionarios) empty]
    [(string=? cargo (funcionario-cargo arvore_funcionarios)) (cons (funcionario-nome arvore_funcionarios)
                                                                    (auxiliarCargos (funcionario-subordinados arvore_funcionarios) cargo))]
    [else (auxiliarCargos (funcionario-subordinados arvore_funcionarios) cargo)]
    )

  )

;;testes:
(check-expect (funcionariosComCargo arvoreFuncionarios "Reitor") (list "Bruno"))
(check-expect (funcionariosComCargo arvoreFuncionarios "Professor") (list "Marcelo" "Lucio"))
(check-expect (funcionariosComCargo arvoreFuncionarios "Padeiro") empty)
(check-expect (funcionariosComCargo empty "Professor") empty)


;;auxiliarCargos: Lista-de-Funcionarios cargo -> Lista-de-string
;;Objetivo: Auxiliar de funcionariosComCargo. Dado uma lista de subordinados(do tipo Lista-de-Funcionarios), retorna
;;uma lista de nomes dos funcionários subordinados que possuem o cargo informado, utilizando recursão mútua e concatenação de listas.
;;Exemplos:
;;(auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Professor") -> (list "Marcelo" "Lucio")
;;(auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Entidade")  -> (list "Zumbi")
;;(auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Padeiro")   -> empty
;;(auxiliarCargos empty "Professor") -> empty
(define (auxiliarCargos lista_subordinados cargo)
  (cond
    [(empty? lista_subordinados) empty]
    [else (append (funcionariosComCargo (first lista_subordinados) cargo) (auxiliarCargos (rest lista_subordinados) cargo))]
  ))

;;testes:
(check-expect (auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Professor") (list "Marcelo" "Lucio"))
(check-expect (auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Entidade") (list "Zumbi"))
(check-expect (auxiliarCargos (funcionario-subordinados arvoreFuncionarios) "Padeiro") empty)
(check-expect (auxiliarCargos empty "Professor") empty)