#lang scheme

;todo animal es mortal
;todo hombre es animal
;todo hombre es mortal

;todo animal es mortal
;todo hombre es animal
;algún hombre es mortal

;ningún animal es inmortal
;todo hombre es animal
;ningún hombre es inmortal

;ningún animal es inmortal
;todo hombre es animal
;algún hombre no es inmortal

(define string->list-symbols
  (lambda (s temp)
    (if (null? s)
        (list (list->string (reverse temp)))
        (if (char=? (first s) #\space)
            (cons
             (list->string (reverse temp))
             (string->list-symbols (rest s) '()))
            (string->list-symbols 
             (rest s)
             (cons (first s) temp))
            )
        )
    )
  )
(define palabras-especiales '("todo" "ningún" "ningun" "algún" "algun" "alguno" "no" "es"))
(define transforma-terminos
  (lambda (lst-term)
    (cond
      ((null? lst-term) '())
      ((member (first lst-term) palabras-especiales)
       (cons
        (transforma-especiales (first lst-term))
        (transforma-terminos (rest lst-term))))
      (else
       (cons
        (string 
         (char-upcase (string-ref (first lst-term) 0)))
        (transforma-terminos (rest lst-term))))
      )
    ))
(define transforma-especiales
  (lambda (palabra)
    (cond
      ((string=? palabra "todo") "a")
      ((string=? palabra "ningún") "e")
      ((string=? palabra "ningun") "e")
      ((string=? palabra "algún") "i")
      ((string=? palabra "algun") "i")
      ((string=? palabra "alguno") "i")
      ((string=? palabra "es") "")
      ((string=? palabra "no") "neg")
      (else "no sé")
      )
    ))
(define haz-negativas
  (lambda (lst id flag)
    (cond
      ((null? lst) 
       (if flag (list id) '()))
      ((string=? (first lst) "neg")
       (cond
         ((string=? id "a")
          (cons "e"
                (haz-negativas (rest lst) id #f)))
         ((string=? id "i")
          (cons "o"
                (haz-negativas (rest lst) id #f)))
         ))
      (else
       (cons (first lst)
             (haz-negativas (rest lst) id flag)))
      )
    ))
(define reconstruye-input
  (lambda ()
    (let* ((s (string->list (read-line)))
           (s1 (string->list-symbols s '()))
           (s2 (transforma-terminos s1))
           (s3 (haz-negativas (rest s2) (first s2) #t))
           )
      (apply string-append (salida s3))
      )
    ))
(define salida
  (lambda (lst)
    (letrec
        ((aux
          (lambda (lista)
            (if (null? lista)
                '()
                (if (string=? (first lista) "")
                    (aux (rest lista))
                    (cons (first lista)
                          (aux (rest lista)))))
            ))
         (aux2
          (lambda (lst)
            (let ((t1 (first lst))
                  (t2 (second lst))
                  (t3 (third lst))
                  (ids (list "a" "e" "i" "o"))
                  )
              (cond
                ((member t1 ids)
                 (list t1 t2 t3))
                ((member t2 ids)
                 (list t2 t1 t3))
                ((member t3 ids)
                 (list t3 t1 t2))
                (else 'no-se)
                )
              )))
         )
      (aux2 (aux lst))
      )
    ))
(provide reconstruye-input)