API tools faq
paste
Guest User

Untitled

a guest
Nov 14th, 2018
132
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
text 31.51 KB | None | 0 0
raw download clone embed print report
  1. /*Manejo de listas con el tablero
  2. Ejercicio 0
  3. ¿qué es lo primero que tenés que escribir en cada ejercicio?
  4. . Escribir el contrato.
  5. */
  6.  
  7. /*Ejercicio 1
  8. Escribir el procedimiento PonerColoresEnCeldaActual(colores) que, dada una lista de Colores
  9. [c1,c2,c3,...,ck], ponga en la celda actual una bolita de color ci por cada i = 1,2,3,...,k.
  10. Ejemplo: PonerColoresEnCeldaActual([Verde, Verde, Azul]) pone dos bolitas Verdes y una Azul
  11. en la Celda Actual.*/
  12.  
  13. procedure PonerColoresEnCeldaActual (colores){
  14. /* PROPOSITO: Poner colores de acuerdo a cada color en la lista
  15. PRECONDICIÓN: Ninguna
  16. PARAMETRO: colores es una lista de colores */
  17. foreach color in colores {
  18. Poner (color)
  19. }
  20. }
  21.  
  22. /*Ejercicio 2
  23. Escribir el procedimiento RecorrerCamino(direcciones) que, dada una lista de Direcciones
  24. [d1,d2,...,dk], mueva el cabezal primero en dirección d1, después en dirección d2, y así
  25. sucesivamente hasta mover el cabezal en dirección dk. Ejemplo: dada la lista [Este, Este, Norte,
  26. Este], el procedimiento debe mover el cabezal primero hacia el Este dos veces, luego hacia el
  27. Norte 1 vez y por último se mueve hacia el Este. ¿Cuál es la precondición de este
  28. procedimiento?*/
  29.  
  30. procedure RecorrerCamino (direcciones){
  31. /*PROPOSITO: Se mueve de acuerdo a cada elemento de la lista de direcciones
  32. PRECONDICION: Debe haber un tablero tan grande como la lista lo indique
  33. PRECONDICION: Todas las direcciones de la lista deben ser movimientos validos*/
  34. foreach dirección in direcciones{
  35. Mover(dirección)
  36. }
  37. }
  38.  
  39. /*Ejercicio 3
  40. Escribir la función aparicionesDeColor(colorBuscado) que, dado un colorBuscado, recorra
  41. todas las celdas del tablero y describa la lista de booleanos que se consiguen en un recorrido
  42. por celdas con dirección principal Norte y dirección secundaria Oeste, consultando si hay o no
  43. bolitas del colorBuscado en cada celda del tablero.*/
  44.  
  45. function aparicionesDeColor (colorBuscado){
  46. /*PROPOSITO: Denota cada elemento del tablero con un booleano.
  47. PRECONDICIÓN: Ninguno
  48. PARAMETRO: es un color
  49. RESULTADO: Denota una lista de booleanos*/
  50. listaDeBooleanosSegúnColor := []
  51. while (not esLaÚltimaCelda(Norte, Oeste)){
  52. listaDeBooleanosSegúnColor := listaDeBooleanosSegúnColor ++ resultadoDeLaCeldaSegun(colorBuscado)
  53. // IrALaSiguienteCelda()
  54. }return (listaDeBooleanosSegúnColor ++ resultadoDeLaCeldaSegun(colorBuscado))
  55. }
  56.  
  57. function esLaÚltimaCelda(dir1, dir2){
  58. return (not puedeMover(dir1) && not puedeMover(dir2))
  59. }
  60.  
  61. function resultadoDeLaCeldaSegun(color){
  62. /*PROPOSITO: DENOTA UNA LISTA CON VALOR "BOOLEANO" DE ACUEROD AL COLOR EXISTENTE EN LA CELDA
  63. PRECONDICIÓN: NINGUNA
  64. PARAMETRO: "color" es un color*/
  65. return (hayBolitas(color))
  66. }
  67.  
  68.  
  69. /*Ejercicio 4
  70. Escribir la función coloresEnCeldaActual() que describa la lista de los colores que aparecen en
  71. la Celda Actual.*/
  72.  
  73. function coloresEnCeldaActual (){
  74. /*PROPOSITO: Denota una lista de colores de la celda actual
  75. PRECONDICIÓN: ninguna
  76. RESULTADO: Arma una lista de colores de la celda*/
  77. listaDeColoresDeLaCelda := []
  78. foreach color in [minColor()..maxColor()]{
  79. listaDeColoresDeLaCelda := listaDeColoresDeLaCelda ++ singularSi(color, hayBolitas(color))
  80. }return (listaDeColoresDeLaCelda)
  81. }
  82.  
  83.  
  84. function singularSi(elemento, condición) {
  85. /*PROPOSITO: Devolver una lista con el color de "colorActual" si es que existe
  86. PRECONDICIÓN: NO TIENE
  87. PARAMETROS: colorActual es un color*/
  88. return (choose [elemento] when (condición)
  89. [] otherwise)
  90. }
  91.  
  92.  
  93. /*Ejercicio 5
  94. Escribir la función aparicionesDeColorEnCamino(colorBuscado,direcciones) que, dado un
  95. colorBuscado y una lista de Direcciones, describa la lista con la cantidad de bolitas de
  96. colorBuscado en las celdas recorridas, si las mismas se recorren en el orden en que indica
  97. direcciones, (incluyendo la celda en que se encuentra el cabezal antes de empezar y al nalizar
  98. el recorrido). ¿Cuál es la precondición del procedimiento?*/
  99.  
  100. function aparicionesDeColorEnCamino (colorBuscado, direcciones) {
  101. /*PROPOSITO: denota una lista con la cantidad de bolitas de "colorBuscado" en el recorrido
  102. de la lista "direcciones"
  103. PRECONDICION: Todas las direcciones de la lista deben ser movimientos validos*/
  104. listaDeCantidadDeColores := []
  105. foreach direccion in direcciones {
  106. listaDeCantidadDeColores := listaDeCantidadDeColores ++
  107. devolverNúmeroDeBolitas (colorBuscado)
  108. Mover(direccion)
  109. }return (listaDeCantidadDeColores++
  110. devolverNúmeroDeBolitas (colorBuscado))
  111. }
  112.  
  113.  
  114. function devolverNúmeroDeBolitas (colorBuscado){
  115. return(choose [nroBolitas(colorBuscado)] when (hayBolitas(colorBuscado))
  116. [0] otherwise)
  117. }
  118.  
  119.  
  120. /*Ejercicio 6
  121. Escribir la función longitud(lista) que, dada una lista, describa la cantidad de elementos de la
  122. misma. Ejemplo: longitud([Azul, Azul, Verde, Rojo]) describe 4.*/
  123.  
  124. function longitud(lista) {
  125. /*PROPOSITO: Denota la cantidad de elementos en la lista
  126. PRECONDICIÓN: Ninguna
  127. PARAMETRO: "lista" es una lista
  128. RESULTADO: La cantidad de elementos en la lista*/
  129. cantidadDeElementos := 0
  130. foreach elementos in lista {
  131. cantidadDeElementos := cantidadDeElementos + 1
  132. }return (cantidadDeElementos)
  133. }
  134.  
  135.  
  136.  
  137. /*Ejercicio 7
  138. Escribir la función sumatoria(lista) que, dada una lista de Números, describa la suma de todos
  139. los elementos de la misma. Ejemplo: sumatoria([1, 5, 7, 9]) describe 1+5+7+9, es decir, 22.*/
  140.  
  141. function sumatoria(lista){
  142. /*PROPOSITO: Denota la sumatoria de la lista
  143. PRECONDICION: Ninguna
  144. PARAMETROS: "lista" es una lista de números*/
  145. elementosSumados := 0
  146. foreach elemento in lista {
  147. elementosSumados := elementosSumados + elemento
  148. }return (elementosSumados)
  149. }
  150.  
  151.  
  152.  
  153. /*Ejercicio 8
  154. Escribir la función multiplicatoria(lista) que, dada una lista de Números, describa la
  155. multiplicación de todos los elementos de la misma. Ejemplo: multiplicatoria([1, 5, 7, 9]) describe
  156. 1*5*7*9, es decir, 315.*/
  157.  
  158. function multiplicatoria (lista) {
  159. /*PROPOSITO: Denota la multiplicación de la lista
  160. PRECONDICION: Ninguna
  161. PARAMETROS: "lista" es una lista de números*/
  162. elementosMultiplicados := primero(lista)
  163. foreach elemento in lista {
  164. elementosMultiplicados := elementosMultiplicados * elemento
  165. }return (elementosMultiplicados)
  166. }
  167.  
  168. /*Ejercicio 9
  169. Escribir la función repetición(cantidad,elemento) que, dado una cantidad y un elemento (de
  170. cualquier tipo), describa una lista con cantidad repeticiones de elemento. Si n ≤ 0, retorna la
  171. lista vacía.
  172. Ejemplo: repetición(3, 8) describe la lista [8, 8, 8] , mientras que repetición(5, Verde) describe la
  173. lista [Verde, Verde, Verde, Verde, Verde]*/
  174.  
  175. function repetición (cantidad, elemento) {
  176. /*PROPOSITO: Denota la cantidad de veces que se repite el "elemento"
  177. PRECONDICIÓN: "cantidad" no puede ser 0
  178. PARAMETROS: "Cantidad" corresponde a un número y "elemento" a un elemento
  179. RESULTADO: Devuelve una repeticion del elemento "cantidad" veces*/
  180. elementosRepetidos := []
  181. repeat (cantidad){
  182. elementosRepetidos := elementosRepetidos ++ [elemento]
  183. }
  184. return (elementosRepetidos)
  185. }
  186.  
  187. /*Ejercicio 10
  188. Escribir la función clonados_veces(cantidad, valores) que dado un número cantidad y una lista
  189. de valores, describa la lista que contenga los elementos de valores en el orden de dicha
  190. listarepetida cantidad de veces. Ejemplo: clonados_veces(3, [Rojo, Azul, Verde]) retorna [Rojo,
  191. Azul, Verde, Rojo, Azul, Verde, Rojo, Azul, Verde].*/
  192. function clonados_Veces (cantidad, valores){
  193. /*PROPOSITO: Denotar una lista que se repite "cantidad" veces
  194. PRECONDICIÓN: Ninguna
  195. PARAMETROS: cantidad es un nùmero, valores es una lista*/
  196. elementosRepetidos := valores
  197. repeat (cantidad){
  198. elementosRepetidos := elementosRepetidos ++ valores
  199. }
  200. return (elementosRepetidos)
  201. }
  202.  
  203.  
  204.  
  205.  
  206.  
  207. /*Ejercicio 11
  208. Escribir la función multiplicadosInternamente_veces(cantidad, valores) que dado un número
  209. cantidad y una lista de valores, describa la lista que contenga los elementos de valores repetida
  210. cantidad de veces cada uno. Ejemplo: multiplicadosInternamente_veces(3, [Rojo, Azul, Verde])
  211. retorna [Rojo, Rojo, Rojo, Azul, Azul, Azul, Verde, Verde, Verde].*/
  212.  
  213. function multiplicadosInternamente_veces (cantidad, valores){
  214. /*PROPOSITO: Clonar cada elemento de la lista "cantidad" veces
  215. PRECONDICIÓN: NINGUNA
  216. PARAMETROS: "cantidad" es un nùmero, valores corresponde a una lista*/
  217. valorDeLista := []
  218. foreach valor in valores{
  219. valorDeLista := valorDeLista ++ repetición(cantidad, valor)
  220. }return (valorDeLista)
  221. }
  222.  
  223.  
  224. /*Ejercicio 12
  225. En tu solución anterior, ¿reutilizaste repetición(cantidad, elemento)?
  226. Si no lo hiciste, resolvé nuevamente utilizando esa función combinada con el operador ++.*/
  227.  
  228. //SI LO HICE (?)
  229.  
  230.  
  231. /*Ejercicio 13
  232. Escribir la función reverso(lista) que, dada una lista [e1,...,ek], describa la lista [ek,...,e1].
  233. Ejemplo: reverso([Azul, Azul, Verde, Rojo]) describe [Rojo, Verde, Azul, Azul].*/
  234.  
  235. function reverso(lista) {
  236. /*PROPOSITO: Describe una lista de elementos de manera que la lista comienza desde el final y
  237. avanza hacia el primero
  238. PRECONDICIÓN: La lista no puede estar vacía
  239. PARAMETROS: "lista" es una lista :P*/
  240. listaReversa := []
  241. foreach elemento in lista {
  242. listaReversa := [elemento] ++ listaReversa
  243. }return (listaReversa)
  244. }
  245.  
  246.  
  247.  
  248. /*Ejercicio 14
  249. Escribir la función direccionesOpuestas(listaDeDirecciones) que, dada una lista de direcciones
  250. [d1, ...,dk], describa la lista de direcciones en donde cada elemento es el opuesto al de la
  251. posición original, [opuesto(d1), ..., opuesto(dk)].
  252. Ejemplo: direccionesOpuestas([Oeste, Sur, Norte]) describe [Este, Norte, Sur].*/
  253.  
  254. function direccionesOpuestas (listaDeDirecciones) {
  255. /*PROPOSITO: Describe una lista de direcciones donde se obtienen los opuestos de cada elemento
  256. de la lista
  257. PRECONDICIÓN: Es una lista de direcciones
  258. PARAMETROS: "listaDeDirecciones" corresponde a una lista*/
  259. listaDeDireccionesOpuesta := []
  260. foreach dirección in listaDeDirecciones{
  261. listaDeDireccionesOpuesta := listaDeDireccionesOpuesta ++ [opuesto(dirección)]
  262. }return (listaDeDireccionesOpuesta)
  263. }
  264.  
  265. /*Ejercicio 15
  266. Escribir la función coloresSiguientes(listaDeColores) que, dada una lista de colores [c1, ...,ck],
  267. describa la lista de colores en donde cada elemento es el siguiente del original, [siguiente(c1),
  268. ..., siguiente(ck)].
  269. Ejemplo: coloresSiguientes([Rojo, Azul, Verde]) describe [Verde, Negro, Azul].*/
  270.  
  271. function coloresSiguientes(listaDeColores){
  272. listaDeColoresSiguientes := []
  273. foreach color in listaDeColores {
  274. listaDeColoresSiguientes := listaDeColoresSiguientes ++ [siguiente(color)]
  275. }return (listaDeColoresSiguientes)
  276. }
  277.  
  278. /*Ejercicio 16
  279. Escribir la función homologar(listaDeNúmeros, umbral, default) que, dada una lista de números
  280. [n1, ...,nk], y dos números umbral, y default, denote otra lista de números [m1, ...,mk] en donde,
  281. aquellos números que son mayores al umbral, permanecen iguales, pero aquellos que son
  282. menores son reemplazados por el valor default. Es decir, cada elemento es
  283. mi = ni sii ni >= umbral
  284. mi =default sii ni < umbral
  285. Ejemplo: homologar([3, 7, 8, 5, 1, 3, 2, 4], 4, 2) describe [2, 7, 8, 5, 2, 2, 2, 4].*/
  286.  
  287. function homologar (listaDeNúmeros, umbral, default) {
  288. /*PROPOSITO: Denota una lista con valores donde si un número de la lista es > umbral permanece igual
  289. si es < a umbral su valor se convierte en default
  290. PRECONDICION: DEBE SER UNA LISTA DE NUMEROS*/
  291. listaHomologada := []
  292. foreach numero in listaDeNúmeros {
  293. listaHomologada := listaHomologada ++ homologarElemento(numero, umbral, default)
  294. } return (listaHomologada)
  295. }
  296. function homologarElemento(numero, umbral, default){
  297. return (choose [numero] when (numero >= umbral)
  298. [default] when (numero < umbral)
  299. [] otherwise)
  300. }
  301.  
  302.  
  303.  
  304. /*Ejercicio 17
  305. Escribir la función númerosPares(valores) que, dada valores (una lista de Números), describa
  306. la lista de números pares que aparecen en valores.
  307. Ejemplo: númerosPares([3, 4, 5, 2, 5]) describe [4, 2].*/
  308.  
  309. function númerosPares (valores) {
  310. /*PROPOSITO: DENOTA UNA NUEVA LISTA CON LOS VALORES PARES DE UNA LISTA DADA
  311. PRECONDICION: NINGUNA*/
  312. listaDeNumerosPares := []
  313. foreach valor in valores {
  314. listaDeNumerosPares := listaDeNumerosPares ++ singularSi(valor, esPar(valor))
  315. }return (listaDeNumerosPares)
  316. }
  317.  
  318. function esPar (número){
  319. return (número mod 2 == 0)
  320. }
  321. /*Ejercicio 18
  322. Escribir la función sinElemento(lista,elemento) que, dada una lista y un elemento, describa la
  323. lista que resulta de quitar todas las apariciones de elemento que ocurren en lista.
  324. ¿de qué tipo debe ser elemento?
  325. Ejemplo: sinElemento([Azul, Verde, Azul, Rojo], Azul) describe [Verde, Rojo].*/
  326.  
  327. function sinElemento (lista, elemento){
  328. /*PROPOSITO: Denota una lista sin "elemento"
  329. PRECONDICION: NINGUNA
  330. */
  331. listaSinElemento := []
  332. foreach elem in lista{
  333. listaSinElemento := listaSinElemento ++
  334. singularSi(element2, not es_iguala_(elem, elemento))
  335. } return (listaSinElemento)
  336. }
  337.  
  338. function es_iguala_(elem, elemento) {
  339. return (elem == elemento)
  340.  
  341. }
  342.  
  343. /*Ejercicio 19
  344. Escribir la función soloLosDePosicionesImpares(lista) que, dada una lista, describa la lista que
  345. se obtiene de quitar los elementos en las posiciones pares.
  346. Ejemplo: soloLosDePosicionesImpares([2, 2, 8, 4, 5, 6]) describe [2, 8, 5]*/
  347.  
  348. function soloLosDePosicionesImpares (lista) {
  349. /*
  350. PROPOSITO: DADA UNA LISTA SOLO ELIJE LOS ELEMENTOS EN POSICIONES IMPARES Y ARMA UNA NUEVA LISTA
  351. PRECONDICION: NINGUNA
  352. */
  353. listaDeElemImpares := []
  354. listaATrabajar := lista
  355. while (not esVacía(listaATrabajar) && (longitud(listaATrabajar) >= 2)){
  356. listaDeElemImpares := listaDeElemImpares ++ [primero(listaATrabajar)]
  357. listaATrabajar := sinLosDosPrimeros(listaATrabajar)
  358. }
  359. return (listaDeElemImpares ++ [primero(listaATrabajar)])
  360. }
  361.  
  362. function sinLosDosPrimeros(lista){
  363. /*PROPOSITO: DADA UNA LISTA se le restan los primeros dos elementos
  364. PRECONDICION: NINGUNA
  365. */
  366. return (resto(resto(lista))) /////REVISAR
  367. }
  368.  
  369. /*Ejercicio 20
  370. Un elemento de una lista se dice interno si es igual al anterior de la lista. Escribir la función
  371. reducciónDeBloques(valores) que, dada valores (una lista de Números), describa la lista que se
  372. obtiene de quitar todos los elementos internos.
  373. Ejemplo: reducciónDeBloques([1, 1, 2, 2, 2, 2, 3, 1, 2, 2]) describe [1, 2, 3, 1, 2].*/
  374.  
  375. function reducciónDeBloques (valores) {
  376. /*PROPOSITO: Denotar una lista sin los valores internos
  377. PRECONDICION: no tiene
  378. PARAMETROS: "valores" corresponde a una lista de cualquier tipo*/
  379. listaSinInternos := [primero(valores)]
  380. valorAnterior := primero(valores)
  381. foreach valor in resto(valores) {
  382. listaSinInternos := listaSinInternos ++ singularSi(valor, not es_iguala_(valor, valorAnterior))
  383. valorAnterior := valor
  384. }return (listaSinInternos)
  385. }
  386.  
  387.  
  388.  
  389. /*Ejercicio 21
  390. Escribir la función sinDuplicados(lista) que, dada una lista, describa una lista que tenga todos
  391. los elementos de lista, pero donde no aparecen elementos repetidos.
  392. Ejemplo: sinDuplicados([1, 3, 4, 2, 4, 3, 5]) describe [1, 3, 4, 2, 5] (también es válido el
  393. resultado [1, 2, 4, 3, 5]).*/
  394.  
  395. function sinDuplicados(lista) {
  396. /*PROPOSITO: Denota una lista sin valores duplicados
  397. PRECONDICIÓN: Ninguna
  398. PARAMETROS: "lista" corresponde a una lista de valores de cualquier tipo*/
  399. listaSinDupli := []
  400. listaDeValores := lista
  401. while (not esVacía(listaDeValores)){
  402. valorActual := primero(listaDeValores)
  403. listaSinDupli := listaSinDupli ++ singularSi(valorActual, not contiene(listaSinDupli, valorActual))
  404. listaDeValores := resto(listaDeValores)
  405. } return (listaSinDupli)
  406. }
  407.  
  408. /*Ejercicio 22
  409. Escribir la función uniónDe_con_(lista1,lista2) que, dadas lista1 y lista2 que no contienen
  410. elementos repetidos, describe una lista sin repetidos que contenga todos los elementos que
  411. aparecen en alguna de las 2 listas. Ejemplo: uniónDe_con_([1, 3, 4], [2, 4, 3, 5]) describe [1, 3,
  412. 4, 2, 5]. ¿de qué tipo es lista1? ¿y de qué tipo es lista2? ¿pueden ser ambas de otro tipo?*/
  413.  
  414. function uniónDe_con_(lista1, lista2) {
  415. /*PROPOSITO: Denota una lista unificada entre "lista1" y "lista2" sin elementos repetidos
  416. PRECONDICIÓN: No tiene
  417. PARAMETROS: "Lista1" y "lista2" son listas del mismo tipo*/
  418. return (sinDuplicados(lista1++lista2))
  419. }
  420.  
  421.  
  422.  
  423. /*Ejercicio 23
  424. Escribir la función intersecciónDe_con_(lista1,lista2) que, dadas lista1 y lista2 que no contienen
  425. elementos repetidos, describe la lista de todos los elementos que aparecen tanto en lista1
  426. como en lista2. Ejemplo: intersecciónDe_con_([1, 3, 4], [2, 4, 3, 5]) describe [3, 4].*/
  427.  
  428. function intersecciónde_con_(lista1, lista2) {
  429. /*PROPOSITO: Denota una nueva lista con los elementos repetidos en "lista1" y "lista2"
  430. PRECONDICIÓN: Las listas dadas no contienen elementos repetidos
  431. PARAMETROS: "Lista1" y "lista2" son dos listas del mismo tipo*/
  432. listaDeIntersección := []
  433. foreach valor in lista1{
  434. listaDeIntersección := listaDeIntersección ++ singularSi(valor, contiene(lista2, valor))
  435. }
  436. return (listaDeIntersección)
  437. }
  438.  
  439. /*Ejercicio 24
  440. Escribir la función contiene(lista, elemento) que, dada una lista y un elemento, describa
  441. verdadero si el elemento está en la lista.
  442. Ejemplo: contiene([2,3,4], 3) describe True.
  443. contiene([2,3,4], 5) describe False.*/
  444.  
  445.  
  446. function contiene (lista, elemento){
  447. /*PROPOSITO: Denota verdadero, si "elemento" se encuentra en la "lista".
  448. PRECONDICION: No tiene
  449. PARAMETROS: "Lista" es una lista de cualquier tipo, "elemento" es del mismo tipo que "lista"*/
  450. listaDeValores := lista
  451. while (not esVacía(listaDeValores) && not esElemento(primero(listaDeValores), elemento)){
  452. listaDeValores := resto(listaDeValores)
  453. }return (not esVacía(listaDeValores))
  454. }
  455. function esElemento (elem1, elem2){
  456. return (elem1 == elem2)
  457. }
  458.  
  459.  
  460. /*Ejercicio 25
  461. Escribir la función algunoEnMedioDe(lista, desde, hasta) que, dada una lista de Números y dos
  462. números desde y hasta, describa verdadero si la lista contiene un elemento que se encuentre
  463. entre los números desde y hasta, sin incluirlos. Es decir, si algún elemento k de la lista, cumple
  464. desde < k < hasta.
  465. Ejemplo: algunoEnMedioDe([7, 3, 25, 16], 13, 18) describe True.
  466. algunoEnMedioDe([7, 3, 25, 16], 13, 15) describe False.*/
  467.  
  468. function algunoEnMedioDe(lista, desde, hasta) {
  469. /*PROPOSITO: Denota verdadero si los valores númericos de la lista, son >desde y <hasta
  470. PRECONDICIÓN: NINGUNA
  471. PARAMETROS: "Lista" corresponde a una lista de números.
  472. *"desde" corresponde a un número
  473. *"hasta" corresponde a un número*/
  474. listaDeNúmeros := lista
  475. while (not esVacía(listaDeNúmeros) && not contiene([desde+1 .. hasta-1], primero(listaDeNúmeros))){
  476. listaDeNúmeros := resto (listaDeNúmeros)
  477. }
  478. return (not esVacía(listaDeNúmeros))
  479. }
  480.  
  481.  
  482. /*Ejercicio 26
  483. Escribir la función lista_estáIncluídaEn_(lista1,lista2) que dadas lista1 y lista2 que no contienen
  484. elementos repetidos, describe si lista1 se encuentra contenida en lista2.
  485. Ejemplos: lista_estáIncluídaEn_([4,5] , [2,3,4,5,6]) denota True.
  486. lista_estáIncluídaEn_([4,5,8] , [2,3,4,5,6]) denota False.
  487. lista_estáIncluídaEn_([4,5] , [2,3,4,6,5]) denota True.*/
  488.  
  489. function lista_estáIncluídaEn_(lista1, lista2) {
  490. /*PROPOSITO: Describe si lista1 está incluida en lista2
  491. PRECONDICIÓN: Las Listas no poseen números repetidos
  492. PARAMETROS: lista1 y lista2 son listas de cualquier tipo*/
  493. listaCorta := longitudDeListasCorta (lista1, lista2)
  494. listaLarga := longitudDeListasLarga(lista1, lista2)
  495. while (not esVacía(listaCorta) && contiene (listaLarga, primero(listaCorta))) {
  496. listaCorta := resto(listaCorta)
  497.  
  498. }return (esVacía(listaCorta))
  499. }
  500.  
  501.  
  502. function longitudDeListasCorta (lista1, lista2){
  503. return (choose lista1 when (longitud (lista1) < longitud(lista2))
  504. lista2 when (longitud (lista2) < longitud(lista1))
  505. lista1 otherwise)
  506. }
  507. function longitudDeListasLarga (lista1, lista2){
  508. return (choose lista1 when (longitud(lista1) > longitud(lista2))
  509. lista2 when (longitud(lista2) > longitud(lista1))
  510. lista2 otherwise)
  511. }
  512.  
  513. /*Ejercicio 27
  514. Escribir la función estáOrdenada(valores) que, dada valores (una lista de Números) describe si
  515. está ordenada de menor a mayor. Para que una lista esté ordenada, cada elemento debe ser
  516. menor al que le sigue.
  517. Ejemplos: estáOrdenada([2, 7, 9, 15]) describe True
  518. estáOrdenada([2, 15, 9, 7]) describe False.*/
  519.  
  520. function estáOrdenada(valores) {
  521. /*PROPOSITO: Dada una lista de números describe si está ordenada de menor a mayor
  522. PRECONDICIÓN: NINGUNA
  523. PARÁMETROS: "valores" corresponde a una lista de números*/
  524. valorAnterior := primero(valores)
  525. listaDeValores := resto(valores)
  526. while(not esVacía(listaDeValores) && esMenor(valorAnterior, primero(listaDeValores))){
  527. valorAnterior := primero(listaDeValores)
  528. listaDeValores := resto(listaDeValores)
  529. }return (esVacía(listaDeValores))
  530. }
  531.  
  532. function esMenor (valor1, valor2){
  533. return (valor1 < valor2)
  534. }
  535.  
  536. /*Ejercicio 28
  537. Escribir la función tomar(cantidad, valores) que, dado un número cantidad y una lista valores,
  538. describe la lista que se obtiene de quedarse únicamente con los primeros cantidad elementos
  539. de la lista. ¿Cuál es la precondición de esta función?
  540. Ejemplo: tomar(4, [4, 8, 15, 16, 23, 42]) describe [4, 8, 15, 16]
  541. tomar(2, [4, 8, 15, 16, 23, 42]) describe [4, 8]*/
  542.  
  543. function tomar(cantidad, valores) {
  544. /*PROPOSITO: Denota una nueva lista con los primeros "cantidad" elementos de la lista "valores"
  545. PRECONDICIÓN: La lista debe tener al menos "cantidad" elementos.
  546. PARAMETROS: "cantidad": es un valor numérico
  547. "valores": corresponde a una lista de cualquier tipo.*/
  548. listaTomar := []
  549. listaValores := valores
  550. cantidadDeElementos := cantidad
  551. while(cantidadDeElementos /= 0){
  552. listaTomar := listaTomar ++ [primero(listaValores)]
  553. listaValores := resto(listaValores)
  554. cantidadDeElementos := cantidadDeElementos-1
  555. }
  556. return (listaTomar)
  557. }
  558.  
  559. /*Ejercicio 29
  560. Escribir la función tirar(cantidad, valores) que, dado un número cantidad y una lista valores,
  561. describe la lista que se obtiene de quedarse con todos los elementos menos los primeros
  562. cantidad elementos de la lista. ¿Cuál es la precondición de esta función?
  563. Ejemplo: tirar(4, [4, 8, 15, 16, 23, 42]) describe [23, 42]
  564. tirar(2, [4, 8, 15, 16, 23, 42]) describe [15, 16, 23, 42]*/
  565.  
  566. function tirar (cantidad, valores){
  567. /*PROPÓSITO: Denota una nueva lista sin los primeros "cantidad" elementos de la lista
  568. PRECONDICIÓN: "cantidad" no puede ser mayor a la cantidad de elementos de la lista
  569. PARAMETROS: "cantidad": corresponde a un valor numérico
  570. "valores": es una lista de valores de cualquier tipo*/
  571. listaValores := valores
  572. repeat (cantidad){
  573. listaValores := resto(listaValores)
  574. }
  575. return (listaValores)
  576. }
  577.  
  578. /*Ejercicio 30
  579. Escribir la función posiciónEnLaQueAprece(elemento, valores) que, dado un elemento y una
  580. lista de valores, describe la posición de la lista en la que aparece el elemento en dicha lista.
  581. ¿Cuál es la precondición de la función?
  582. Ejemplo: posiciónEnLaQueAprece(8, [4, 8, 15, 16, 23, 42]) describe 2
  583. posiciónEnLaQueAprece(16, [4, 8, 15, 16, 23, 42]) describe 4*/
  584.  
  585. function posiciónEnLaQueAparece(elemento, valores){
  586. /*PROPOSITO: Denota la posición de "elemento" en la lista "valores"
  587. PRECONDICIÓN: No tiene ////////////////////////////////////////////////////////////////////
  588. PARAMETRO: "elemento": corresponde a un elemento de la lista "valores"
  589. "valores": es una lista de cualquier tipo*/
  590. listaValores := valores
  591. posiciónElemento := 0
  592. while (primero(listaValores) /= elemento){
  593. listaValores := resto(listaValores)
  594. posiciónElemento := posiciónElemento+1
  595. }return(posiciónElemento+1)
  596. }
  597.  
  598. /*Ejercicio 31
  599. Escribir la función sinPrimerAparición(elemento, valores) que, dado un elemento y una lista de
  600. valores, describe la lista que se obtiene de eliminar una única vez el elemento, si es que este
  601. aparece en la lista.
  602. Ejemplo: sinPrimerAparición(8, [4, 8, 42, 15, 8, 16, 42]) describe [4, 42, 15, 8, 16, 42]
  603. sinPrimerAparición(42, [4, 8, 42, 15, 8, 16, 42]) describe [4, 8, 15, 8, 16, 42]*/
  604.  
  605. function sinPrimerAparición (elemento, valores) {
  606. /*PROPOSITO: Describe una lista que elimina la primer aparición de "elemento" de la lista si es que
  607. se encuentra en ella
  608. PRECONDICIÓN: NINGUNA
  609. PARAMETROS:"elemento": corresponde a un elemento de la lista "valores"
  610. "valores": es una lista de cualquier tipo */
  611. return (listaHastaElemento(elemento, valores) ++ listaDesdeSinElemento(elemento, valores))
  612. }
  613. function listaDesdeSinElemento (elemento, valores) {
  614. listaDeValores := valores
  615. while (not esVacía(listaDeValores) && primero(listaDeValores) /= elemento){
  616. listaDeValores := resto(listaDeValores)
  617. }return (resto(listaDeValores))
  618. }
  619.  
  620. function listaHastaElemento (elemento, valores) {
  621. listaDeValores := valores
  622. listaDeValoresVistos := []
  623. while (not esVacía(listaDeValores) && primero(listaDeValores) /= elemento){
  624. listaDeValoresVistos := listaDeValoresVistos ++ [primero(listaDeValores)]
  625. listaDeValores := resto(listaDeValores)
  626. } return (listaDeValoresVistos)
  627. }
  628. /*Ejercicio 32
  629. Escribir la función minimoElemento(valores) que, dada valores (una lista de Números), describe
  630. el elemento más chico que se encuentra en la lista. ¿Cuál es la precondición de la función?
  631. Ejemplo: minimoElemento([3, 21, 9, 45, 3, 7]) describe 3*/
  632.  
  633. function minimoElemento (valores) {
  634. /*PROPOSITO: Denota el menor elemento de una lista numérica
  635. PRECONDICIÓN: La lista no puede ser vacía
  636. Parametros: "valores" denota una lista de números*/
  637. valorMinimo := primero(valores)
  638. foreach valor in resto(valores) {
  639. valorMinimo := valorMenor(valorMinimo, valor)
  640. }return (valorMinimo)
  641. }
  642.  
  643. function valorMenor (valor1, valor2) {
  644. return (choose valor1 when (valor1 < valor2)
  645. valor2 otherwise)
  646. }
  647.  
  648.  
  649. /*Ejercicio 33
  650. Escribir la función máximoElemento(valores) que, dada valores (una lista de Números),
  651. describe el elemento más grande que se encuentra en la lista. ¿Cuál es la precondición de la
  652. función?
  653. Ejemplo: máximoElemento([3, 21, 9, 45, 3, 7]) describe 45*/
  654.  
  655. function maximoElemento (valores) {
  656. /*PROPOSITO: Denota el mayor elemento de una lista numérica
  657. PRECONDICIÓN: La lista no puede ser vacía
  658. Parametros: "valores" denota una lista de números*/
  659. valorMaximo := primero(valores)
  660. foreach valor in resto(valores) {
  661. valorMaximo := valorMayor(valorMaximo, valor)
  662. }return (valorMaximo)
  663. }
  664.  
  665. function valorMayor (valor1, valor2) {
  666. return (choose valor1 when (valor1 > valor2)
  667. valor2 otherwise)
  668. }
  669.  
  670.  
  671. /*Ejercicio 34
  672. Escribir la función sinElMínimoElemento(valores) que, dada valores (una lista de Números),
  673. describe la lista que se obtiene de eliminar una única vez el elemento más chico. ¿Cuál es la
  674. precondición de la función?
  675. Ejemplo: sinElMínimoElemento([3, 21, 9, 45, 3, 7]) describe [21, 9, 45, 3, 7]*/
  676.  
  677. function sinElMínimoElemento (valores){
  678. /*PROPOSITO: Devuelve una lista sin el valor mínimo de una lista de números
  679. PRECONDICIÓN: No tiene
  680. PARAMETROS: "VALORES" corresponde a una lista de números*/
  681. return (sinPrimerAparición(minimoElemento(valores), valores))
  682. }
  683.  
  684. /*Ejercicio 35
  685. Escribir la función sinElMáximoElemento(valores) que, dada valores (una lista de Números),
  686. describe la lista que se obtiene de eliminar una única vez el elemento más chico. ¿Cuál es la
  687. precondición de la función?
  688. Ejemplo: sinElMáximoElemento([3, 21, 9, 45, 3, 7]) describe [3, 21, 9, 3, 7]*/
  689.  
  690. function sinElMáximoElemento (valores){
  691. /*PROPOSITO: Devuelve una lista sin el valor mínimo de una lista de números
  692. PRECONDICIÓN: No tiene
  693. PARAMETROS: "VALORES" corresponde a una lista de números*/
  694. return (sinPrimerAparición(maximoElemento(valores), valores))
  695. }
  696.  
  697.  
  698. /*Ejercicio 36
  699. Escribir la función listaOrdenada(valores) que, dada valores (una lista de Números), describe la
  700. lista ordenada de menor a mayor. ¿Se puede elaborar una estrategia combinando los ejercicios
  701. anteriores? ¿Se le ocurre alguna otra estrategia?
  702. Ejemplo: listaOrdenada([2, 1, 0, 3]) describe [0,1,2,3].*/
  703.  
  704. function listaOrdenada (valores) {
  705. /*PROPOSITO: Denota una lista con los elementos ordenados de menos a mayor de la lista "valores"
  706. PRECONDICIÓN: Ninguna
  707. PARAMETROS: "valores" denota una lista de números*/
  708. listaOrdenada := []
  709. listaDeValores := valores
  710. while (not esVacía(listaDeValores)) {
  711. listaOrdenada := listaOrdenada ++ [minimoElemento(listaDeValores)]
  712. listaDeValores := sinElMínimoElemento (listaDeValores)
  713. }return (listaOrdenada)
  714. }
  715.  
  716.  
  717. /*Ejercicio 37
  718. Escribir la función agrupar_deA_(lista,cantidad) que, dada lista y cantidad, describe la lista de
  719. listas que agrupa los elementos de lista en grupos de cantidad elementos. El último grupo
  720. puede no tener cantidad de elemento, y tener menos.
  721. Ejemplo: agrupar([1,2,3,4,5,6,7,8, 9, 10, 11], 3) denota [[1,2,3], [4,5,6], [7,8, 9], [10, 11]].*/
  722.  
  723. function agrupar_deA_ (lista, cantidad) {
  724. /* PROPOSITO: Devuelve una lista que agrupa en listas "cantidad" de elementos
  725. con los elementos de "lista"
  726. PRECONDICIÓN: "Lista" debe tener al menos "cantidad" de elemntos
  727. PARAMETROS: "lista" es una lista de elementos de cualquier tipo
  728. "cantidad" corresponde a la cantidad de elementos que debe poseer la lista de resultado
  729. RESULTADO: Denota una lista que contiene los elementos de "lista" repartidos según "cantidad" como
  730. parámetros para definir la cantidad de elementos de cada lista*/
  731. listaSuperior := []
  732. listaDeValores := lista
  733. while (not esVacía (listaDeValores) && quedanAlMenos_(listaDeValores, cantidad)){
  734. listaSuperior := listaSuperior ++ elemDeListaASumar(listaDeValores, cantidad)
  735. repeat (cantidad){listaDeValores := resto(listaDeValores)}
  736. }return (listaSuperior++ [listaDeValores])
  737. }
  738. function quedanAlMenos_ (lista, cantidad){
  739. /*PROPOSITO: Denota si al menos queda "cantidad" elementos en la lista
  740. PRECONDICIÓN: NINGUNA
  741. PARAMETROS: "lista" corresponde a una lista de valores de cualquier tipo
  742. "cantidad" denota un número*/
  743. return (longitud(lista) >= cantidad)
  744. }
  745.  
  746.  
  747. function elemDeListaASumar(lista, cantidad) {
  748. /*PROPOSITO: Devuelve una lista con cantidad de elementos según "cantidad"
  749. PRECONDICIÓN: Ninguna
  750. PARAMETROS: "lista" corresponde a una lista de valores de cualquier tipo
  751. "cantidad" denota un número*/
  752. listaDeValores := lista
  753. listaDeElemASumar := []
  754. while (not esVacía(listaDeValores) && longitud(listaDeElemASumar) /= cantidad) {
  755. listaDeElemASumar := listaDeElemASumar ++ [primero(listaDeValores)]
  756. listaDeValores := resto (listaDeValores)
  757. }return ([listaDeElemASumar])
  758. }
  759.  
  760.  
  761. program { return (desagruparLista([[1,2,3,4],[5,6,7],[8,9,10]]))}
  762.  
  763.  
  764. /*Ejercicio 38
  765. Escribir la función desagruparLista(listaDeListas) que, dada listaDeListas, describe una lista
  766. que contiene cada uno de los elementos de las listas internas de listaDeListas.
  767. Ejemplo: desagruparLista([[1,2,3],[4,5,6],[7,8,9]]) describe [1,2,3,4,5,6,7,8,9].*/
  768.  
  769. function desagruparLista (listaDeListas){
  770. /*PROPOSITO: Denota una nueva lista con todos los elementos de cada lista que cotiene
  771. PRECONDICIÓN: Ninguna
  772. PARAMETROS: "listaDeListas" corresponde a una lista con listas todas del mismo tipo*/
  773. listaCompleta := []
  774. foreach lista in listaDeListas {
  775. listaCompleta := listaCompleta ++ lista
  776. }return (listaCompleta)
  777. }
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!