;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)

(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"))))))