;PREDICADOSSCHEMElenguajeR5RSv305/2005

;porRBJJCMGCEP.

;FUNCIONESLOGICASYMATEMATICAS

;Distinto
;Ej:(!=33)=>#f(!=36)=>#t

(define!=(lambda(N1N2)(not(=N1N2))))

;Ej:(notnull?4)=>#t(notnull?'())=>#f

(definenotnull?(lambda(E)(not(null?E))))

;Incrementa1
;Ej:(++1)=>2

(define++(lambda(N)(+N1)))

;Decrementa1
;Ej:(1)=>0

(define(lambda(N)(N1)))

;Par(seasumequeel0esnumeropar)
;Ej:(par?4)=>#t(par?7)=>#f


(definepar?(lambda(N)
(if(<N0)(parAux(*N1))(parAuxN))))

(defineparAux(lambda(N)
(if(=N0)#t(impar?(N1)))))

;Impar
;Ej:(impar?5)=>#t

(defineimpar?(lambda(N)
(if(<N0)(imparAux(*N1))(imparAuxN))))

(defineimparAux(lambda(N)
(if(=N0)#f(par?(N1)))))

;Potencia
;Ej:(potencia28)=>256

(definepotencia(lambda(BE)
(cond((=E0)1)
((=E1)B)
(else(*B(potenciaB(E1)))))))

;Calcularfactorial(2versiones)
;Ej:(factorial6)=>720


(definefactorial(lambda(N)(if(=N0)1(*N(fact1(N1))))))

;TRABAJOSCONLISTAGENERALIDADES

;Devuelveelnumerodeelementosquecomponeunalista.
;Ej:(long'(1234))=>4(long'(12(34)))=>3

(definelong(lambda(L)
(if(null?L)0(+1(long(cdrL))))))

;Devuelveelnumerodeelementos(atomos)quecomponeunalista.Multinivel.
;Ej:(longM'(1234))=>4(longM'(12(34)))=>4

(definelongM(lambda(L)
(long(listaAtomosL))))

;Devuelveelmaximoelementodeunalista.
;Ej:(maxL'(123456))=>6

(definemaxL(lambda(L)
(if(null?L)'()
(if(null?(cdrL))(carL)
(if(>=(carL)(maxl(cdrL)))(carL)

(maxl(cdrL)))))))

;Devuelveelmaximoelementodeunalista.Multinivel.
;Ej:(maxM'(123(456)(78)4(102)))=>10

(definemaxM(lambda(L)
(if(null?L)'()
(if(null?(cdrL))
(if(list?(carL))(maxM(carL))(carL))
(if(>(if(list?(carL))(maxM(carL))(carL))(maxM(cdrL)))
(if(list?(carL))(maxM(carL))(carL))
(maxM(cdrL)))))))

;Devuelveelmenorelementodeunalista.
;Ej:(minL'(123456))=>1

(defineminL(lambda(L)
(if(null?L)'()
(if(null?(cdrL))(carL)
(if(<=(carL)(minl(cdrL)))(carL)(minl(cdrL)))))))

;Devuelveelmenorelementodeunalista.Multinivel.
;Ej:(minM'(123(456)(78)4(1022)))=>2

(defineminM(lambda(L)
(if(null?L)'()

(if(null?(cdrL))
(if(list?(carL))(minM(carL))(carL))
(if(<(if(list?(carL))(minM(carL))(carL))(minM(cdrL)))
(if(list?(carL))(minM(carL))(carL))
(minM(cdrL)))))))

;Determinasiunalistaesestrictamentecreciente.
;Ej:(crece'(1234567))=>#t

(definecrece(lambda(L)
(if(null?(cdrL))#t
(if(<(carL)(cadrL))(crece(cdrL))#f))))

;Determinasiunalistaesestrictamentedecreciente.
;Ej:(decrece'(76543))=>#t

(definedecrece(lambda(L)
(if(null?(cdrL))#t
(if(>(carL)(cadrL))(decrece(cdrL))#f))))

;Verificasiunalistaescapicua
;Ej:(capicua'(135(246(8)642)531))=>#t
;(capicua'(135(246(8)742)531))=>#f

(definecapicua(lambda(L)
(if(null?L)#t

(if(equal?L(invertirML))#t#f))))

;L1esprefijodeL2?,nopuedenestarambasvacias
;Ej:(prefijo'(12)'(12345))=>#t

(defineprefijo(lambda(L1L2)
(if(null?L2)#f(if(or(null?L1)(equal?L1L2))#t(prefijoL1(quL2))))))

;Version2

(defineprefijo2(lambda(L1L2)
(if(equal?L1L2)#t(if(<(longL2)(longL1))#f(prefijo2L1(quL2))))))

;L1esposfijodeL2?
;Ej:(posfijo'(76)'(126576))=>#t

(defineposfijo(lambda(L1L2)
(if(null?L2)#f
(if(equal?L1L2)#t(posfijoL1(cdrL2))))))

;Version2

(defineposfijo2(lambda(L1L2)
(if(or(null?L1)(equal?L1L2))#t
(if(<(longL2)(longL1))#f(posfijo2L1(cdrL2))))))


;sublista!!L1deL2,nopuedenestarambasvacias
;Ej:(subLista'(123)'(3512378))=>#t

(definesubLista(lambda(L1L2)
(if(null?L2)#f
(if(prefijoL1L2)#t
(sublistaL1(cdrL2))))))

;subListaM!!L1essublistadeL2?Multinivel
;Ej:(subListaM'(357)'(123(76(3571)(23))2))=>#t

(definesubListaM(lambda(L1L2)
(if(not(list?L2))#f
(if(equal?L1L2)#t
(if(null?L2)#f
(or(subListaML1(cdrL2))(subListaML1(quL2))(subListaML1(carL2))))))))

;DeterminasilosvaloresXeYsonconsecutivoenL
;Ej:(consecutivo'(12345678)67)=>#t

(defineconsecutivo(lambda(LXY)
(sublista(listXY)L)))

;ConsecutivosMultinivel.
;Ej:(consecutivoM'(123(4(56))78)56)=>#t


(defineconsecutivoM(lambda(LXY)
(subListaM(listXY)L)))

;BUSQUEDADEELEMENTOS

;Obtenerelultimoelementodeunalista.
;Ej:(ultimoElem'(123456))=>6

(defineultimoElem(lambda(L)
(if(null?L)'()(if(equal?(cdrL)'())(carL)(ultimoElem(cdrL))))))

;Devuelveelenesimoelementodeunalista.
;Ej:(enesimoElem10'(78910))=>0(enesimoElem2'(78910))=>8

(defineenesimoElem(lambda(NL)
(if(<(longL)N)0
(if(equal?N1)(carL)
(enesimoElem(N1)(cdrL))))))

;DevuelveelnumerodeposiciondelaprimeraocurrenciadeX.
;Ej:(xPosicion2'(2345))=>1

(definexPosicion(lambda(XL)
(if(or(null?L)(not(perteneceXL)))0
(xBuscaXL))))


(definexBusca(lambda(XL)
(if(null?L)0
(if(equal?(carL)X)1
(+1(xBuscaX(cdrL)))))))

;DadounvalorX,buscaenunalistaL(simple)paradeterminarsiestaonoenella.
;Ej:(pertenece3'(123456))=>#t

(definepertenece(lambda(XL)
(if(null?L)#f(if(equal?(carL)X)#t(perteneceX(cdrL))))))

;DadounvalorX,buscaenunalistaLparadeterminarsiestaonoenella.Multinivel.
;Ej:(perteneceM3'(1(23)4(56)))=>#t

(defineperteneceM(lambda(XL)
(if(null?L)#f
(if(list?(carL))(perteneceMX(carL))
(if(equal?X(carL))#t
(perteneceMX(cdrL)))))))

;ELIMINACIONOREEMPLAZOSDELOSELEMENTOSENUNALISTA

;Noeliminaelnesimoelemento,sisuspredecesores.
;Ej:(sacaNpri3'(111345))=>(345)


(definesacaNpri(lambda(NL)
(if(=0N)L
(sacaNpri(N1)(cdrL)))))

;EliminaelelementoXdelalistaenel1ernivel.
;Ej:(eliminaX3'(345(37)3))=>(45(37))

(defineeliminaX(lambda(XL)
(if(null?L)'()
(if(equal?X(carL))
(eliminaXX(cdrL))
(cons(carL)(eliminaXX(cdrL)))))))

;EliminaelelementoXdelalistaentodoslosniveles
;Ej:(eliminaMx'((123)27(13(628)02))2)=>((13)7(13(68)0))

(defineeliminaMx(lambda(LX)
(if(null?L)'()
(if(equal?(carL)X)(eliminaMx(cdrL)X)
(if(list?(carL))(cons(eliminaMx(carL)X)(eliminaMx(cdrL)X))
(cons(carL)(eliminaMx(cdrL)X)))))))

;Eliminatodosloselementosdelalista2queestanenla1
;Ej:(elim12'(21)'((123)27(13(628)02)))=>((3)7(3(68)0))

(defineelim12(lambda(L1L2)
(if(null?L1)L2
(elim12(cdrL1)(eliminaMxL2(carL1))))))

;Devuelvelalistasinelementosrepetidos.Eliminalasprimerasocurrencias.
;(eliminaR'(3531923893))=>(512893)

(defineeliminaR(lambda(L)
(if(null?L)'()
(if(not(pertenece(carL)(cdrL)))
(cons(carL)(eliminaR(cdrL)))
(eliminaR(cdrL))))))

;Devuelvelalistasinelementosrepetidos.Dejalasprimerasocurrencias.
;(eliminaR2'(3531923893))=>(351928)

(defineeliminaR2(lambda(L)
(if(null?L)'()(invertir(eliminaR(invertirL))))))

;EliminaelprimerelementoXqueapareceenlalista.
;Ej:(eliminarPri2'(42121))=>(4121)

(defineeliminarPri(lambda(XL)
(if(null?L)'()
(if(equal?(carL)X)(cdrL)

(cons(carL)(eliminarPriX(cdrL)))))))

;Eliminaelelementoqueseencuentraenlaenesimaposicion.
;Ej:(xElimina'(4891275)3)=>(48275)

(definexElimina(lambda(LN)
(if(or(null?L)(>N(longL)))#f
(if(=N1)(cdrL)
(cons(carL)(xElimina(cdrL)(N1)))))))

;ReemplazarXporYenL
;Ej:(xReemplazar'(potencia)'t'n)=>(ponencia)

(definexReemplazar(lambda(LXY)
(if(null?L)'()

(if(equal?(carL)X)(consY(xReemplazar(cdrL)XY))

(cons(carL)(xReemplazar(cdrL)XY))))))

;ReemplazarXporYenL(multinivel)
;Ej:(xReemplazarM23'(21(12(22622)313)25))=>(31(13(33633)313)35)

(definexReemplazarM(lambda(XYL)
(if(null?L)'()
(if(list?(carL))(cons(xReemplazarMXY(carL))(xReemplazarMXY(cdrL)))
(if(equal?X(carL))
(consY(xReemplazarMXY(cdrL)))

(cons(carL)(xReemplazarMXY(cdrL))))))))

;EJERCICIO29:SustituirenLP1porP2(P1yP2sonlistas,patrones).
;Ej:(sust'(1234)'(12)'(4))=>(434)

(definesust(lambda(LP1P2)
(if(null?L)'()
(if(prefijoP1L)
(concatenarP2(sust(aPartirN(longP1)L)P1P2))
(cons(carL)(sust(cdrL)P1P2))))))

;QuitaelultimoElemelementodeunaL,siesvaciaretorna'()
;Ej:(qu'(12345))=>(1234)

(definequ(lambda(L)
(if(null?L)'()(if(equal?'()(cdrL))'()(cons(carL)(qu(cdrL)))))))

;ConstruyeunalistaconelprimeryultimoElemelementodeunalista.
;Ej:(leex'(12345))=>(15)

(defineleex(lambda(L)(list(carL)(ultimoElemL))))

;Quitalosextremosdeunalista.
;Ej:(quitaex'(12345))=>(234)

(definequitaex(lambda(L)

(if(>(longL)1)(qu(cdrL))'())))

;ReemplazaelelementoenlaposicionNporX.
;Ej:(insertarXenN'(13274)25)=>(1574)

(defineinsertarXenN(lambda(LNX)
(if(or(null?L)(=N0))L
(if(=N1)(consX(cdrL))
(cons(carL)(insertarXenN(cdrL)(N1)X))))))

;CREACIONDELISTAS

;Dadadoslistas,L1yL2,lasconcatena.
;Ej:(concatenar'(12)'(345))=>(12345)

(defineconcatenar(lambda(L1L2)
(if(null?L1)L2(cons(carL1)(concatenar(cdrL1)L2)))))

;Concatenarunelementoaunalista.
;Ej:(concatenarElem'(123)4)=>(1234)
;(concatenarElem'(123)'(4))=>(123(4))

(defineconcatenarElem(lambda(LX)
(if(null?L)(listX)(invertir(consX(invertirL))))))


;Versionampliadadeconcatenarenlaqueloselementosnodebensernecesariamentelistas.
;Ej:(concatenar2'(23)9)=>(239)
;(concatenar2'(123)'(4))=>(1234)

(defineconcatenar2(lambda(E1E2)
(if(and(list?E1)(list?E2))(concatenarE1E2)
(if(and(not(list?E1))(not(list?E2)))(concatenar(listE1)(listE2))
(if(list?E1)(concatenarE1(listE2))
(concatenar(listE1)E2))))))

;Devuelvetodaslassublistasposiblesdeunalistadada.
;Ej:(sublistas'(1(23)45))=>((1)(1(23))(1(23)4)(1(23)45)((23))((23)4)((23)45)(4)(45)
(5))
;(sublistas'(123))=>((1)(12)(123)(2)(23)(3))

(definesublistas(lambda(L)
(if(null?L)'()
(concatenar(sublistasAuxL1)(sublistas(cdrL))))))

(definesublistasAux(lambda(LN)
(if(>N(longL))'()
(cons(nPrimerosNL)(sublistasAuxL(+N1))))))

;Devuelveunalistaconloselementosatomicos.
;Ej:(listaAtomos'(34(68)(2(1011)19)12(3)))=>(34682101119123)


(definelistaAtomos(lambda(L)
(if(null?L)'()
(if(nodo?(carL))(cons(carL)(listaAtomos(cdrL)))
(concatenar(listaAtomos(carL))(listaAtomos(cdrL)))))))

;DevuelvelosNprimeroselementosdeL
;Ej:(nPrimeros4'(651247))=>(6512)

(definenPrimeros(lambda(NL)
(if(=N0)'()
(cons(carL)(nPrimeros(N1)(cdrL))))))

;Devuelvetodoslosresultadosposiblesdeprefijos.
;Ej:(nPrimerosT'(12345))=>((1)(12)(123)(1234)(12345))

(definenPrimerosT(lambda(L)
(if(null?L)'()
(nPrimerosTauxL1))))

(definenPrimerosTAux(lambda(LN)
(if(=N(longL))(listL)
(cons(nPrimerosNL)(nPrimerosTAuxL(+N1))))))

;DevuelvelosNultimoselementosdeL
;Ej:(nUltimos'(71822314256)3)=>(14256)


(definenUltimos(lambda(LN)
(if(or(null?L)(>N(longL)))#f
(cond((=N1)(cdrL))
((=N0)L)
(else(nUltimos(cdrL)(N1)))))))

;Devuelveapartirden(sintomarelelementodelaposicinn)
;Ej:(aPartirN3'(765432))=>(432)

(defineaPartirN(lambda(NL)
(if(=N0)L
(aPartirN(N1)(cdrL)))))

;MenoresqueN
;Ej:(xMenores'(1834527)4)=>(123)

(definexMenores(lambda(LN)(xMenoresAux(ordenar<=L)N)))

(definexMenoresAux(lambda(LN)
(if(null?L)'()
(if(<(ultimoElemL)N)L
(xMenoresAux(quL)N)))))

;MayoresqueN
;Ej:(xMayores'(1834527)4)=>(567)


(definexMayores(lambda(LN)(xMayoresAux(ordenar<=L)N)))

(definexMayoresAux(lambda(LN)
(if(null?L)'()
(if(>(carL)N)L
(xMayoresAux(cdrL)N)))))

;DevuelveunalistaconlosanterioreselementosaX
;Ej:(ant5'(123456789))=>(1234)

(defineant(lambda(XL)
(if(null?L)'()
(if(equal?(carL)X)'()
(cons(carL)(antX(cdrL)))))))

;DevuelveunalistaconlossiguienteselementosaX
;Ej:(sig5'(123456789))=>(6789)

(definesig(lambda(XL)
(if(null?L)'()
(if(equal?(carL)X)(cdrL)
(sigX(cdrL))))))

;Devuelveunalistaconteniendodoslistas,unaconloselementosanterioresaXyotraconlos
siguientesaX.

;Ej:(izq_der5'(123456789))=>((1234)(6789))

(defineizq_der(lambda(XL)
(if(null?L)'()
(cons(antXL)(list(sigXL))))))

;DevuelvelalistaLinvertida.
;Ej:(invertir'(123456))=>(654321)

;sinprimitivas
(defineinvertir(lambda(L)
(if(null?L)'()(cons(enesimoElem(longL)L)(invertir(quL))))))

;conprimitivas
(defineinvertir(lambda(L)
(if(null?L)'()(append(invertir(cdrL))(list(carL))))))

;Invierteunalistaentodossusniveles.
;Ej:(invertirM'(12(34(56)7)89(1011(1213))))=>(((1312)1110)98(7(65)43)21)

;sinprimitivas
(defineinvertirM(lambda(L)
(if(null?L)'()
(if(list?(enesimoElem(longL)L))
(cons(invertirM(enesimoElem(longL)L))(invertirM(quL)))
(cons(enesimoElem(longL)L)(invertirM(quL)))))))


;conprimitivas
(defineinvertirM(lambda(L)
(if(null?L)'()
(if(list?(carL))(append(invertirM(cdrL))(list(invertirM(carL))))
(append(invertirM(cdrL))(list(carL)))))))

;(invertirM'(123(456)9))=>(9(654)321)
;(invertirM'(a(b(c(d(e))))))=>(((((e)d)c)b)a)

;Devuelveunalistaconteniendodossublistas,unaconelementosmenoresqueNyotraconlos
mayoresaN
;Ej:(xMayMen'(1834527)4)=>((123)(567))

(definexMayMen(lambda(LN)(list(xMenoresLN)(xMayoresLN))))

;ArmaunalistacontodaslasposicionesdeXenL
;Ej:(ocurrencias'(13246573)3)=>(27)

(defineocurrencias(lambda(LX)(ocurrenciasAuxLX1)))

(defineocurrenciasAux(lambda(LXA)
(if(null?L)'()
(if(=(carL)X)(consA(ocurrenciasAux(cdrL)X(+A1)))
(ocurrenciasAux(cdrL)X(+A1))))))

;MoveratrasNelementosdeL
;Ej:(moverAtras'(123456)3)=>(456123)

(definemoverAtras(lambda(LN)
(if(or(equal?N0)(null?L))L
(moverAtras(concatenar(cdrL)(list(carL)))(N1)))))

;MoveradelanteNelementosdeL
;Ej:(moverAdelante'(123456)3)=>(456123)

(definemoverAdelante(lambda(LN)
(if(or(equal?N0)(null?L))L
(moverAdelante(concatenar(list(ultimoElemL))(quL))(N1)))))

;MATEMATICASCONLISTAS

;Sumaloselementosdeunalista.
;Ej:(sumaElem'(1234567))=>28

(definesumaElem(lambda(L)
(if(null?L)0(+(carL)(sumaElem(cdrL))))))

;Sumaloselementosdeunalista.Multinivel.
;Ej:(sumaElemM'(12(34)5(67)0))=>28

(definesumaElemM(lambda(L)
(if(null?L)0(sumaElem(listaAtomosL)))))

;Sumaloselementosrespectivosdedoslistas,generandootraconlosresultados.Ambaslistasde
igualtamano.
;Ej:(sumaListas'(174)'(936))=>(101010)

(definesumaListas(lambda(L1L2)
(if(null?L1)'()
(cons(+(carL1)(carL2))(sumaListas(cdrL1)(cdrL2))))))

;Restaloselementosrespectivosdedoslistas,generandootraconlosresultados.Ambaslistasde
igualtamano.
;Ej:(restaListas'(174)'(936))=>(842)

(definerestaListas(lambda(L1L2)
(if(null?L1)'()
(cons((carL1)(carL2))(restaListas(cdrL1)(cdrL2))))))

;Multiplicaciondeunalistaporunescalar
;Ej:(multiplicaEscalar2'(1234))=>(2468)

(definemultiplicaEscalar(lambda(NL)
(if(null?L)'()
(cons(*N(carL))(multiplicaEscalarN(cdrL))))))


;Productocartesianodedoslistas(ambasdeiguallongitud)
;Ej:(productoCA'(123)'(234))=>20

(defineproductoCA(lambda(L1L2)
(if(null?L1)0
(+(*(carL1)(carL2))(productoCA(cdrL1)(cdrL2))))))

;DeterminacuantasvecesserepiteXenunalista.
;Ej:(ocurre4'(1324894))=>2

(defineocurre(lambda(XL)
(if(null?L)0
(if(equal?(carL)X)(+1(ocurreX(cdrL)))
(ocurreX(cdrL))))))

;DeterminacuantasvecesserepiteXenunalista.(Multinivel)
;Ej:(ocurreM3'(12(463)(24)8(1(540))3))=>2

(defineocurreM(lambda(XL)
(if(null?L)0
(if(list?(carL))(+(ocurreMX(carL))(ocurreMX(cdrL)))
(if(equal?(carL)X)(+1(ocurreMX(cdrL)))
(ocurreMX(cdrL)))))))

;Calculalacantidaddeelementosigualesenlamismaposicionendoslistas.

;Ej:(elemIguales'(12345)'(72865))=>2(porel2y5)

(defineelemIguales(lambda(L1L2)
(if(or(null?L1)(null?L2))0
(if(equal?(carL1)(carL2))(+1(elemIguales(cdrL1)(cdrL2)))
(elemIguales(cdrL1)(cdrL2))))))

;METODOSDEORDENAMIENTO

;Ordenaacendentemente
;Ej:(ordenar<='(84219207))=>(01224789)

(defineordenar<=(lambda(L)
(if(null?L)'()
(if(<=(carL)(minlL))(concatenar(list(carL))(ordenar<=(cdrL)))
(ordenar<=(concatenar(cdrL)(list(carL))))))))

;Ordenadescendentemente
;Ej:(ordenar<='(84219207))=>(98742210)

(defineordenar>=(lambda(L)(invertir(ordenar<=L))))

;ARBOLESBINARIOS

;Ejemplos:
;(raiz'(a(b()())(c()())))=>a
;(izq'(a(b()())(c()())))=>(b()())
;(der'(a(b()())(c()())))=>(c()())

(defineraiz(lambda(A)(carA)))

(defineizq(lambda(A)(cadrA)))

(defineder(lambda(A)(caddrA)))

(definehoja?(lambda(A)(if(and(null?(izqA))(null?(derA)))#t#f)))

;losnodosdeunarbolpuedensernumerososimbolos
;Ej:(nodo?'A)=>#t

(definenodo?(lambda(C)(or(number?C)(symbol?C))))

;arbol?
;Ej:(arbol?'(a(b()())(c()())))=>#t

(definearbol?(lambda(A)
(cond((null?A)#t)
((nodo?A)#f)
((!=(longA)3)#f)
(else(and(nodo?(carA))

(arbol?(cadrA))
(arbol?(caddrA)))))))

;Ej:(arbolito?'(a(b()())(c()())))=>#t

(definearbolito?(lambda(L)
(if(equal?L'())#t
(if(and(not(nodo?L))(=(longL)3)(nodo?(carL)))
(and(arbolito?(cadrL))(arbolito?(caddrL)))
#f))))

;Ej:(arbusto?'(a(b()())(c()())))=>#t

(definearbusto?(lambda(A)
(if(null?A)#t
(if(=(longA)3)
(and(arbusto?(cadrA))(arbusto?(caddrA)))
#f))))

;PesodeunArbol:sumatoria(cadahojasporsunivel)
;Ej:(peso'(0(6()())(7(3()())()))0)=>12(6*1+3*2)

(definepeso(lambda(AN)
(if(null?A)0
(if(hoja?A)(*N(raizA))
(+(peso(izqA)(+1N))(peso(derA)(+1N)))))))


;Inorden
;Ej:(inorden'(a(b()())(c()())))=>(bac)
;(inorden'(a(b(d()())(e()()))(c(f()())(g()()))))=>(dbeafcg)

(defineinorden(lambda(A)
(if(not(arbol?A))#f
(if(null?A)'()

(if(and(nodo?A)(null?(cadrA))(null?(caddrA)))

(carA)
(concatenar(concatenar(inorden(cadrA))
(list(carA)))(inorden(caddrA))))))))

;Version2
(defineinorden2(lambda(A)(if(null?A)'()
(append(inorden2(izqA))
(list(raizA))
(inorden2(derA))))))

;Postorden
;Ej:(postorden'(a(b()())(c()())))=>(bca)
;(postorden'(a(b(d()())(e()()))(c(f()())(g()()))))=>(debfgca)

(definepostorden(lambda(A)
(if(not(arbol?A))#f
(if(null?A)'()

(if(and(nodo?A)(null?(cadrA))(null?(caddrA)))
(carA)
(concatenar(concatenar(postorden(cadrA))
(postorden(caddrA)))(list(carA))))))))

;Version2
(definepostorden2(lambda(A)(if(null?A)'()
(append(postorden2(izqA))(postorden2(derA))(list(raizA))))))

;Preorden
;Ej:(preorden'(a(b()())(c()())))=>(abc)
;(preorden'(a(b(d()())(e()()))(c(f()())(g()()))))=>(abdecfg)

(definepreorden(lambda(A)
(if(not(arbol?A))#f
(if(null?A)'()
(if(and(nodo?A)(null?(cadrA))(null?(caddrA)))
(carA)

(concatenar(concatenar(list(carA))(preorden(cadrA)))

(preorden(caddrA))))))))
;Version2
(definepreorden2(lambda(A)(if(null?A)'()
(append(list(raizA))
(preorden2(izqA))
(preorden2(derA))))))

;RecorridoHorizontal(ARBOLBINARIO)
;Ej:(RH'(a(b(d()())(e()()))(c(f()())(g()()))))=>(abcdefg)

(defineRH(lambda(A)(RHaux(listA))))

(defineRHaux(lambda(A)
(if(null?A)'()
(if(null?(carA))(RHaux(cdrA))
(cons(raiz(carA))
(RHaux(append(cdrA)(list(izq(carA))(der(carA))))))))))

;PerteneceelelementoNalarbolA?
;Ej:(aPertenece'd'(a(b()(f()()))(c(e()())(d()()))))=>#t

(defineaPertenece(lambda(NA)
(if(not(arbol?A))#f
(if(null?A)#f
(if(equal?N(carA))#t
(or(aPerteneceN(cadrA))(aPerteneceN(caddrA))))))))

;Arbolcompletodenivelnyfuncionesauxiliares
;Ejemplodearbolcompleto:'(a(b(d()())(e()()))(c(f()())(g()())))

;Arboldenivel0?
;Ej:(adn0?'())=>#t

(defineadn0?(lambda(A)(cond((null?A)#t)
((and(null?(izqA))
(null?(derA)))#t)
(else#f))))

;Devuelveelnumerodeniveldeunarbol
;Ej:(nivel'(a(b(d()())(e()()))(c(f()())(g()()))))=>2

(definenivel(lambda(A)
(if(adn0?A)0(+1(max(nivel(izqA))(nivel(derA)))))))

;#tsiunArboldenivelNescompleto.
;Ej:(completo?'(a(b(d()())(e()()))(c(f()())(g()()))))=>#t
;(completo?'(a(b(d()())(e()()))(c(f()())())))=>#f

(definecompleto?(lambda(A)(completoAuxA(nivelA))))

(definecompletoAux(lambda(AN)
(cond((null?A)#f)
((=N0)#t)
((=N1)(and(notnull?(izqA))(notnull?(derA))))
(else(and(completoAux(izqA)(N1))(completoAux(derA)(N1)))))))

;GRAFOS

;Representacin((ab)(ba)(ac))c<a<>b

;adyacentenodirigido
;nousalarepresentacindearriba,sino((ab)(ac))c<>a<>b

(defineadyacente(lambda(N1N2G)
(if(or(pertenece(listN1N2)G)(pertenece(listN2N1)G))#t#f)))

;adyacentedirigido
(defineadyacenteD(lambda(N1N2G)
(if(pertenece(listN1N2)G)#t#f)))

;Devuelveunalistadenodos
;(nodos'((ab)(bd)(da)(ac)(cb)))=>(dacb)

(definenodos(lambda(G)
(eliminaR(listaAtomosG))))

;ExisteuncaminoentrelosnodosE1yE2enelgrafoG?
;Ej:(camino'a'd'((ab)(bc)(cd)(ee)(bd)(ea)(de)))=>#t

(definecamino(lambda(E1E2G)
(caminoAuxE1E2(nodosG)G)))

(definecaminoAux(lambda(E1E2NG)
(if(or(null?N)(sumidero?E1G))#f

(if(adyacenteDE1E2G)#t
(if(adyacenteDE1(carN)G)
(caminoAux(carN)E2(eliminaXE1N)G)
(caminoAuxE1E2(moverAtrasN1)G))))))

;ExisteunsumideroenelgrafoG?
;Ej:(sumidero?'e'((ab)(bc)(cd)(ee)(bd)(ea)(de)))=>#f
;(sumidero?'e'((ab)(bc)(cd)(bd)(de)))=>#t

(definesumidero?(lambda(NG)
(if(null?G)#f
(sumidero?AuxNG))))

(definesumidero?Aux(lambda(NG)
(if(null?G)#t
(if(equal?(caarG)N)#f
(sumidero?AuxN(cdrG))))))

;EsconexoelgrafoG?
;Usamosunalgoritmodistintoalqueusamosenprolog,enlugardeversiparacadanodo
;hayuncaminoatodoslosdems,vemossienunalistadetodoslosnodossepuedellegar
;del1al2,del2al3...
;(conexo?'((ab)(bc)(ca)(ae)))=>#t
;(conexo?'((ab)(bc)(ca)(ae)(tr)))=>#f

(defineconexo?(lambda(G)

(conexoAux(nodosG)G)))

(defineconexoAux(lambda(LNG)
(if(null?(cdrLN))#t
(if(camino(carLN)(cadrLN)G)(conexoAux(cdrLN)G)
#f))))

;COMBINATORIA

;PERMUTACIONCONREPETICIONESTOMADASDEAN
;Ej:(perConRep'(123)2)=>((11)(12)(13)(21)(22)(23)(31)(32)(33))

(defineperConRep(lambda(Llong)
(if(=1long)(mapSlistL)
(distribuirPCRL(perConRepL(long1))))))

(definedistribuirPCR(lambda(L1L2)
(if(null?L1)'()
(concatenar(mapS(lambda(X)(cons(carL1)X))L2)
(distribuirPCR(cdrL1)L2)))))

;PERMUTACIONESSINREPETICIONESTOMADASDEAN
;Ej:(perSinRep'(331)2)=>((33)(31)(33)(31)(13)(13))
;(perSinRep'(123)2)=>((12)(13)(21)(23)(31)(32))

(defineperSinRep(lambda(LN)
(permutaAuxLLN)))

(definepermutaAux(lambda(LMN)
(if(or(<N1)(>N(longL)))()
(if(=N1)(listaElemL)
(if(>N2)
(permutaAux(map1LM)M(N1))(map1LM))))))

(definemap1
(lambda(LM)
(if(null?L)L
(append(distribuye(carL)(borraelemSLdeL(carL)M))(map1(cdrL)M)))))

;BorraloselementosdeSLenlalistaL.
(defineborraelemSLdeL
(lambda(SLL)
(if(null?SL)L
(if(list?SL)
(borraelemSLdeL(cdrSL)(elimina1raL(carSL)))
(elimina1raLSL)))))

;generaunalistadeltipo((XL1)(XL2)...(XLn))
(definedistribuye(lambda(XL)
(if(null?L)()

(if(list?X)
(append(list(appendX(list(carL))))(distribuyeX(cdrL)))
(append(list(listX(carL)))(distribuyeX(cdrL)))))))

(definelistaElem(lambda(L)
(if(null?L)()(append(list(list(carL)))(listaElem(cdrL))))))

;COMBINACIONESCONREPETICIONES
;Ej:(comConRep'(123)2)=>((11)(21)(22)(31)(32)(33))

(definecomConRep(lambda(Llong)
(elimComRep(perConRepLlong))))

;COMBINACIONESSINREPETICIONES
;Ej:(comSinRep'(123)2)=>((21)(31)(32))

(definecomSinRep(lambda(Llong)
(elimComRep(perSinRepLlong))))

;EliminarCombinacionesRepetidas

(defineelimComRep(lambda(L)
(if(null?L)'()
(if(perteneceCom(carL)(cdrL))(elimComRep(cdrL))
(cons(carL)(elimComRep(cdrL)))))))

(defineperteneceCom(lambda(XL)
(if(null?L)#f
(if(mismaComX(carL))#t
(perteneceComX(cdrL))))))

(definemismaCom(lambda(C1C2)
(if(null?C1)#t
(if(not(pertenece(carC1)C2))#f
(mismaCom(cdrC1)(elimina1raC2(carC1)))))))

(defineelimina1ra
(lambda(Le)
(if(null?L)'()
(if(equal?e(carL))(cdrL)
(cons(carL)(elimina1ra(cdrL)e))))))

;FUNCIONESDEORDENSUPERIOR

;((op+)23)=>5(laoperacionesbinaria>+)

(defineop(lambda(O)(lambda(XY)(OXY))))

;((op+)23)=>5(laoperacionesbinaria>+)

(defineop2(lambda(O)O))

(definedos(lambda(F)(lambda(X)
(F(FX)))))
;((dos++)1)=>3(laoperacionesunaria>++)

;Repetir(F(F(F(F..F(X)))))

(definerepetir(lambda(FN)(lambda(X)
(if(=N1)(FX)(F((repetirF(N1))X))))))

;Realizaunaaccion'F'sobretodosloselementosdeunalista(Ej++,...)
;Similaraldo:deSmallTalk
;((map++)'(1234))=>(2345)

(definemap(lambda(F)(lambda(L)
(if(null?L)'()
(cons(F(carL))((mapF)(cdrL)))))))

;Igualquemapperoconunsololambda

(definemapS(lambda(FL)
(if(null?L)'()
(cons(F(carL))(mapSF(cdrL))))))

;Ejemplodeusodemap.AcadaelementodelalistaselesumaN
;(usoMap12'(111))=>(444)

(defineusoMap(lambda(N1N2L)
((map(lambda(X)(+N1N2X)))L)))

(defineusoMap2(lambda(N1N2L)
(mapS(lambda(X)(+N1N2X))L)))

(definefilterT(lambda(FL)
(if(null?L)'()
(if(F(carL))(cons(carL)(filterTF(cdrL)))
(filterTF(cdrL))))))

(definefilterF(lambda(FL)(filterT(lambda(X)(not(FX)))L)))

;EJERCICIOSRESUELTOS

;SeriedeFibonacci:11235813...
;DevuelveelelementoenesimodelaseriedeFibonacci.
;
;Ej:(Fibonacci2)=>1(Fibonacci6)=>8

(defineFibonacci(lambda(N)
(cond((=N1)1)
((=N2)1)
(else(+(Fibonacci(N1))(Fibonacci(N2)))))))

;Fibonacciiterativo
;Ej:(Fibonacci2)=>1(Fibonacci6)=>8

(definefib
(lambda(n)
(fibiter10n)))

(definefibiter
(lambda(abcount)
(if(=count0)
b
(fibiter(+ab)a(count1)))))

;Tartaglia
;DevuelvelafiladeltriangulodeTartagliacorrespondienteaN
;
;Ej:(Tartaglia7)=>(1615201561)

(defineTartaglia(lambda(N)
(cond((=N1)'(1))
((=N2)'(11))

(else(append(append'(1)(sumaDeADos(Tartaglia(N1))))'(1))))))

(definesumaDeADos(lambda(L);L=(12345)=>(3579)
(if(>(longL)1)(cons(+(carL)(cadrL))(sumaDeADos(cdrL)))'())))

;AceptadordeEstadosFinitos(maquinadeestadosfinitos).
;(AEF'(121)'(ABA((AB1)(AC2)(BA2)(CB3))))=>t

(defineAEF(lambda(SM)
(if(null?S)
(if(equal?(FM)(AM))#t#f)
(AEF(cdrS)(trans(carS)MM)))))

(definetrans(lambda(TrM1M2)
(if(and(equal?(N1M1)(AM1))(equal?(TM1)Tr))
(list(IM1)(FM1)(N2M1)(GM2))
(transTr(list(IM1)(FM1)(AM1)(cdr(GM1)))M2))))

(defineIcar)(defineFcadr)(defineAcaddr)(defineGcadddr)

(defineN1(lambda(M)
(caar(GM))))

(defineN2(lambda(M)
(cadar(GM))))

(defineT(lambda(M)
(caddar(GM))))

;EJERCICIO34
;Representamseficientementeunamatrizrala.Devuelveunalistaconteniendoternas(XYV)
V<>0
;Ej:(convierte'((1000200)(01500)(20000)))=>((1110)(1420)(221)(235)(312))

(defineconvierte2(lambda(M)
(if(null?M)'()
(convierte2Aux1M))))

(defineconvierte2Aux(lambda(FM)
(if(null?M)'()
(concatenar(filaF1(carM))(convierte2Aux(++F)(cdrM))))))

(definefila(lambda(FCL)
(if(null?L)'()
(if(equal?(carL)0)(filaF(++C)(cdrL))
(cons(listFC(carL))(filaF(++C)(cdrL)))))))

;EJERCICIO37
;Dadounarbolnarioconnodos1o0,determinasiunapalabrapuedeleerserecorriendoalguna
rama
;Ej:(check'(1000)'(1(1(1(1))(1))(0(0))(1(0))))=>#f

;(check'(100)'(1(1(1(1))(1))(0(0))(1(0))))=>#t

(definecheck(lambda(PA)
(if(null?P)#t
(if(and(equal?(carA)(carP))(enHijo(cdrA)(cdrP)))#t#f))))

(defineenHijo(lambda(HP)
(if(and(null?H)(null?P))#t
(if(and(null?H)(not(null?P)))#f
(not(null?(filterT(lambda(X)(checkPX))H)))))))

;EJERCICIO38
;Dadaunalistadefunciones(deunargumento)yunadeelementos,aplicacadaunadelas
funciones
;aloselementosdelalista.
;(mapFun'(++par?)'(1235))=>((2346)(0124)(#f#t#f#f))

(definemapFun(lambda(FL)
(if(null?F)'()
(append(list(mapS(eval(carF))L))
(mapFun(cdrF)L)))))

;Ejercicio36:Funcionimpar
;FesunafuncionyLunalistadevaloresparaelargumentoxdeF
;(fi'(+1X)'(123))=>#f
;(fi'(*XX)'(123))=>#t

;(fi'(*(+X2)(+X2))'(123))=>#f
;(fi'(*(+X2)(X2))'(123))=>#t

(definefi(lambda(FL)
(if(equal?(fiAuxF1L)(fiAuxF1L))#t#f)))

(definefiAux(lambda(FVL)
(if(null?L)L
(cons(evaluar(xReemplazarM'X(*V(carL))F))(fiAuxFV(cdrL))))))

(defineevaluar(lambda(F)
(cond[(and(list?(cadrF))(list?(caddrF)))
((eval(carF))(evaluar(cadrF))(evaluar(caddrF)))]
[(list?(cadrF))((eval(carF))(evaluar(cadrF))(caddrF))]
[(list?(caddrF))((eval(carF))(cadrF)(evaluar(caddrF)))]
[else((eval(carF))(cadrF)(caddrF))])))

;EJERCICIO39b
;Dadaunalistaderboles,devuelveeldemenorpeso.
;Ej:(mapeoArboles'((0(6()())(7()()))(0(0(2()())(3()()))(5()()))))=>(0(6()())(7()()))

(definemapeoArboles(lambda(LA)
(if(null?LA)'0
(enesimoElem(car(ocurrencias(armalistaSumasLA)
(minL(armalistaSumasLA))))LA))))

(definearmalistaSumas(lambda(LA)
(if(null?LA)'()
(cons(peso(carLA)0)(armalistaSumas(cdrLA))))))

;EJERCICIO40
;Cambiadeunaformaderepresentacindegrafosaotra.
;Ej:(convierte'((abcde)((ab)(bc)(bd)(ce)(da)(de)(ea))))
;((a(b))(b(cd))(c(e))(d(ae))(e(a)))

(defineconvierte(lambda(L)
(if(null?L)'()
(convierteAux(carL)(cadrL)))))

(defineconvierteAux(lambda(LG)
(if(null?L)'()
(cons(list(carL)(extrae(carL)G))(convierteAux(cdrL)G)))))

(defineextrae(lambda(NG)
(if(null?G)'()
(if(equal?N(caarG))(cons(cadarG)(extraeN(cdrG)))
(extraeN(cdrG))))))

;EJERCICIO41
;Sequierecalcularlascomicionesdeunviajante.
;Ej:(comisiones'((Pepe(100A)(50B))(Ana(50A)(100B)(20C)))'((A0.5)(B0.2)(C0.1)))

;((pepe(100a)(50b)60.0)(ana(50a)(100b)(20c)47.0))

(definecomisiones(lambda(ViajantesP)
(if(null?Viajantes)'()
(append(list(append(carViajantes)
(list(sumaElem(comicionV(cdarViajantes)P)))))
(comisiones(cdrViajantes)P)))))

(definecomicionV(lambda(LVP)
(mapS(lambda(X)(comicionPPX))LV)))

(definecomicionP(lambda(PV)
(if(equal?(caarP)(cadrV))
(*(cadarP)(carV))
(comicionP(cdrP)V))))

;EJERCICIODEEXAMEN:05/08/2002
;CrearunafuncindeordensuperiorparacalcularelsenodeA(enradianes)
;conunaseriedeNelementos
;NOestaresultandoigualalafuncionseno,nodebesercorrectalaformulaquenosdieron.

(defineSerie(lambda(N)(lambda(A)
(if(=N1)0
(+(/(*(potencia1N)(potenciaA(+N1)))
(fact(+N1)))
((Serie(N1))A))))))


(defineSerieS(lambda(NA)
(if(=N1)0
(+(/(*(potencia1N)(potenciaA(+N1)))
(fact(+N1)))
(SerieS(N1)A)))))

;EJERCICIODEEXAMEN:Sumadordenmerosbinarios
;Ej:(SumaBin'(100)'(1))=>(101)
;(SumaBin'(11101)'(1001))=>(100110)

(defineSumaBin(lambda(N1N2)
(cond[(null?N2)N1]
[(null?N1)N2]
[else(if(=2(+(ultimoElemN1)(ultimoElemN2)))
(concatenar2(SumaBin(SumaBin'(1)(quN2))(quN1))0)
(concatenar2(SumaBin(quN2)(quN1))
(+(ultimoElemN2)(ultimoElemN1))))])))

;EJERCICIODEEXAMEN:Composiciondefunciones(fgh)=>(f(g(h)))
;(componer'((+(ln(^x2))x)(+x1)(sinx)))=>(+(ln(^(+(sinx)1)2))(+(sinx)1))

(definecomponer(lambda(L)
(if(=(longL)1)(carL)

(componer(cons(xReemplazarM'x(cadrL)(carL))
(cddrL))))))

;Orden(CriterioLista)
;Dadaunalistadenmerosyuncriteriodeordenacin(<,>,>=,...)devuelvelassubsecuencias
;(delongitudmayora1)completasqueverificanestecriterio.
;Ej:(orden<'(123171524667789))=>((123)(171524)(66778))

(defineorden(lambda(criterioL)
(if(null?L)L
(if(null?(ordenAuxcriterioL))(ordencriterio(cdrL))
(cons(cons(carL)(ordenAuxcriterioL))
(ordencriterio(sacaNpri(+1(long(ordenAuxcriterioL)))L)))))))

(defineordenAux(lambda(criterioL)
(if(=(longL)1)'()
(if(criterio(carL)(cadrL))
(cons(cadrL)(ordenAuxcriterio(cdrL)))
'()))))

;EJERCICIOFOR(notienemuchalogica..)
;Ej:(for120001'((lambda()#t)()()))=>()

(definefor(lambda(ifcs)
(if(<=if)
(and(evaluarFors)

(for(+ic)fcs)
()))))

(defineevaluarFor(lambda(s)
(if(null?s)s
(if((eval(cars)))(evaluarFor(cadrs))
(evaluarFor(caddrs))))))

;ARBOLDEDIRECTORIO
;Ej:(buscarar1'(d0d1a1))=>"archivo"
;Ej:((eval(lambda()"archivo")))=>"archivo"

(definebuscar(lambda(DA)
(if(null?A)((eval(carD)))
(buscar(cdar(filterT(lambda(X)(equal?(carA)(carX)))D))(cdrA)))))

(definear1'((d0(d1(a1(lambda()"archivo"))))))