Proyecto

(require 2htdp/batch-io)
;Estructuras:
(define-struct aspirante (codigo nombre apellido c1 c2 c3 c4 c5 programa))
(define-struct aspiprom (codigo nombre apellido promedio))
;Listas:
(define lista-aspirantes empty)

;Proyecto final FDP
;Autores: Juan Sebastian Grajales, 202059897. Juan Felipe Arango Guzman, 202060066. Diego Fernando Llanos Mondragón, 202060029
;Fecha: 27-09-20

;Punto 1
;Contrato: cargar-aspirantes: string -> void  (el void es debido que usamos set!, este no devuelve un resultado si no que hace un cambio a la variable)
;Propósito: Cargar una lista, pudiendo cambiarla por otra si se desea
;Ejemplos:
;Definicion:

(define  (cargar-aspirantes rutaarchivo)
  (cond
    [(not (string? rutaarchivo)) (error "El dato ingresado debe ser una ruta de archivo puesta como cadena de texto")]
    [else
     (local
       (
        (define (cargar archivo)
          (read-words/line archivo))
        (define (tostruct lsst)
          (cond
            [(empty? lsst) empty]
            [else (cons (make-aspirante
                         (string->number (first (first lsst)) )
                         (second (first lsst))
                         (third (first lsst))
                         (string->number (fourth (first lsst)) )
                         (string->number (fifth (first lsst)) )
                         (string->number (first (rest (rest (rest (rest (rest (first lsst))))))) )
                         (string->number (first (rest (rest (rest (rest (rest (rest (first lsst)))))))) )
                         (string->number (first (rest (rest (rest (rest (rest (rest (rest (first lsst))))))))) )
                         (first (rest (rest (rest (rest (rest (rest (rest (rest (first lsst)))))))))) )
                        (tostruct (rest lsst)) )]
            )
          )
        )

       (set! lista-aspirantes (list->vector (tostruct (cargar rutaarchivo))))

       )]
    )
  )

;Punto 2
;Contrato: string, string -> archivo.txt
;Propósito: generar un archivo que contenga los datos de los estudiantes, sacando el promedio con respecto al ICFES según el programa al que el aspirante solicite y ordenándolos de mayor a menor
;Ejemplos:
;Definicion:

(define (generar-listado programa nombrearchivo)
  (cond
    [(not (and (string? programa) (string? programa))) (error "Los elementos ingresados deben ser cadenas de texto")]
    [else
     (local
       (
        (define (filtro lst prog)
          (cond
            [(empty? lst) empty]
            [(equal? prog (aspirante-programa (first lst))) (cons (first lst) (filtro (rest lst) prog))]
            [else (filtro (rest lst) prog)]
            )
          )
        (define (listaprom lstf prog)
          (cond
            [(empty? lstf) empty]
            [else
             (local
               (
                (define (promedio aspi prog)
                  (cond
                    [(or (equal? prog "2724") (equal? prog "3743"))
                     (+ (* (aspirante-c1 aspi) 0.21)
                        (* (aspirante-c2 aspi) 0.26)
                        (* (aspirante-c3 aspi) 0.15)
                        (* (aspirante-c4 aspi) 0.15)
                        (* (aspirante-c5 aspi) 0.23))]

                    [(equal? prog "2710")
                     (+ (* (aspirante-c1 aspi) 0.25)
                        (* (aspirante-c2 aspi) 0.25)
                        (* (aspirante-c3 aspi) 0.25)
                        (* (aspirante-c4 aspi) 0.15)
                        (* (aspirante-c5 aspi) 0.10))]


                    [(equal? prog "3753")
                     (+ (* (aspirante-c1 aspi) 0.15)
                        (* (aspirante-c2 aspi) 0.35)
                        (* (aspirante-c3 aspi) 0.30)
                        (* (aspirante-c4 aspi) 0.15)
                        (* (aspirante-c5 aspi) 0.05))]

                    [(equal? prog "2712")
                     (+ (* (aspirante-c1 aspi) 0.15)
                        (* (aspirante-c2 aspi) 0.35)
                        (* (aspirante-c3 aspi) 0.40)
                        (* (aspirante-c4 aspi) 0.05)
                        (* (aspirante-c5 aspi) 0.05))]

                    [(equal? prog "3249")
                     (+ (* (aspirante-c1 aspi) 0.40)
                        (* (aspirante-c2 aspi) 0.10)
                        (* (aspirante-c3 aspi) 0.10)
                        (* (aspirante-c4 aspi) 0.40)
                        (* (aspirante-c5 aspi) 0))]

                    [(equal? prog "3841")
                     (+ (* (aspirante-c1 aspi) 0.20)
                        (* (aspirante-c2 aspi) 0.35)
                        (* (aspirante-c3 aspi) 0.15)
                        (* (aspirante-c4 aspi) 0.20)
                        (* (aspirante-c5 aspi) 0.10))]

                    [(equal? prog "3845")
                     (+ (* (aspirante-c1 aspi) 0.30)
                        (* (aspirante-c2 aspi) 0.30)
                        (* (aspirante-c3 aspi) 0.10)
                        (* (aspirante-c4 aspi) 0.20)
                        (* (aspirante-c5 aspi) 0.10))]

                    [else (error "programa ingresado no valido")]
                    )
                  )
                )
               (cons (make-aspiprom (aspirante-codigo (first lstf))
                                    (aspirante-nombre (first lstf))
                                    (aspirante-apellido (first lstf))
                                    (promedio (first lstf) prog))
                     (listaprom (rest lstf) prog))
               )]
            )
          )


        (define (ordenar lstp)
          (cond
            [(empty? lstp) empty]
            [else
             (local
               (
                (define (ordenaraux aspirantep lstpo)
                  (cond
                    [(empty? lstpo) (cons aspirantep empty)]
                    [(> (aspiprom-promedio aspirantep ) (aspiprom-promedio (first lstpo)) )
                     (cons aspirantep lstpo)]
                    [else (cons (first lstpo) (ordenaraux aspirantep (rest lstpo)))]
                    )
                  )
                )
               (ordenaraux (first lstp) (ordenar (rest lstp)))
               )]
            )
          )
        (define (totext lstp)
          (cond
            [(empty? lstp) " "]
            [else (string-append (number->string (aspiprom-codigo (first lstp))) " "
                                 (aspiprom-nombre (first lstp)) " "
                                 (aspiprom-apellido (first lstp)) " "
                                 (number->string (aspiprom-promedio (first lstp))) " "
                                 "\n"
                                 (totext (rest lstp)) )]
            )
          )
        )
       (begin
         (set! lista-aspirantes (vector->list lista-aspirantes))
         (write-file nombrearchivo (totext (ordenar (listaprom (filtro lista-aspirantes programa) programa))))
         (set! lista-aspirantes (list->vector lista-aspirantes)) )
       )]
    )
  )

;Punto 3
;Contrato: eliminar-aspirante: lista numerica -> display (datos de aspirantes eliminados)
;Proposito: Eliminar de la lista de aspirantes quienes tengan la ficha de inscripcion que este dentro de la lista que se le da a la funcion y luego mostrar en pantalla los datos de estos
;Ejemplos:
;Definicion:
(define (eliminar-aspirante listanum)
  (cond
    [(empty? listanum) (error "El aspirante buscado no esta en la lista")]
    [else
     (local
       (
        (define (v  lsta  listanum)
          (cond
            ((empty? lsta) empty)
            ((vaux (aspirante-codigo (first lsta)) listanum) (v (rest lsta) listanum))
            (else (cons (first lsta ) (v(rest lsta) listanum)))
            )
          )
        (define (vaux codigo listanum)
          (cond
            ((empty? listanum) #f)
            ((equal? codigo (first listanum)) #t)
            (else (vaux codigo (rest listanum)))
            )
          )
        (define (w  lsta  listanum)
          (cond
            ((empty? lsta) empty)
            ((waux (aspirante-codigo (first lsta)) listanum) (w (rest lsta) listanum))
            (else (cons (first lsta ) (w(rest lsta) listanum)))
            )
          )
        (define (waux num u)
          (cond
            ((empty? u) #t)
            ((equal? num (first u)) #f)
            (else (waux num (rest u)))
            )
          )
        )
       (begin
         (set! lista-aspirantes (vector->list lista-aspirantes))
         (display (w lista-aspirantes listanum))
         (set! lista-aspirantes (v lista-aspirantes listanum))
         (set! lista-aspirantes (list->vector lista-aspirantes))
         ))]
    )
  )

;Punto 4
;Contrato: string -> archivo.txt
;Proposito: Guardar en un archivo de texto el valor de la lista de los aspirantes actualizado las veces que se desee, cada vez que se borre un estudiante, esta función actualiza la lista guardando los cambios.
;Ejemplos:
;Definicion:
(define (guardar-aspirantes nombrearchivo)
  (cond
    [(not (string? nombrearchivo)) (error "La entrada debe ser una cadena que represente el nombre con el que se guardara el archivo")]
    [else
     (local
       (
        (define (totext2 lstp)
          (cond
            [(empty? lstp) " "]
            [else (string-append (number->string (aspirante-codigo (first lstp))) " "
                                 (aspirante-nombre (first lstp)) " "
                                 (aspirante-apellido (first lstp)) " "
                                 (number->string (aspirante-c1 (first lstp))) " "
                                 (number->string (aspirante-c2 (first lstp))) " "
                                 (number->string (aspirante-c3 (first lstp))) " "
                                 (number->string (aspirante-c4 (first lstp))) " "
                                 (number->string (aspirante-c5 (first lstp))) " "
                                 (aspirante-programa (first lstp)) " "
                                 "\n"
                                 (totext2 (rest lstp)) )]

            )
          )
        )
       (begin
         (set! lista-aspirantes (vector->list lista-aspirantes))
         (write-file nombrearchivo (totext2 lista-aspirantes))
         (set! lista-aspirantes (list->vector lista-aspirantes))
         ))]
    )
  )