Relación 7 - Historial de revisiones

86.127.225.250 en 16:50 1 dic 2021

2021-12-01T16:50:38Z

← Revisión anterior		Revisión del 16:50 1 dic 2021
Línea 555:		Línea 555:
	-- listaNumeroR [0,0,1] == 1		-- listaNumeroR [0,0,1] == 1
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Lucía Hernández, Ana Sosa Caballero		-- Lucía Hernández, Ana Sosa Caballero, Lucía González
	listaNumeroR :: [Integer] -> Integer		listaNumeroR :: [Integer] -> Integer
	listaNumeroR [x] = x		listaNumeroR [x] = x
Línea 569:		Línea 569:
	-- listaNumeroC [0,0,1] == 1		-- listaNumeroC [0,0,1] == 1
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Lucía Hernández, Ana Sosa Caballero		-- Lucía Hernández, Ana Sosa Caballero, Lucía González
	listaNumeroC :: [Integer] -> Integer		listaNumeroC :: [Integer] -> Integer
	listaNumeroC xs = sum [x*(10^s) \| (x,s)<- zip xs ys]		listaNumeroC xs = sum [x*(10^s) \| (x,s)<- zip xs ys]
Línea 631:		Línea 631:
	-- primerDigitoR 425 == 4		-- primerDigitoR 425 == 4
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Lucía Hernández, Ana Sosa Caballero		-- Lucía Hernández, Ana Sosa Caballero, Lucía González
	primerDigitoR :: Integer -> Integer		primerDigitoR :: Integer -> Integer
	primerDigitoR n \| n<10 = n		primerDigitoR n \| n<10 = n
Línea 646:		Línea 646:
	primerDigitoNR n = head (digitos n) -- digitos era recursiva		primerDigitoNR n = head (digitos n) -- digitos era recursiva
	pDNR n = read [(head (show n))] -- esta es sin recursión		pDNR n = read [(head (show n))] -- esta es sin recursión

			--Lucía González
			primerDigitoNR :: Integer -> Integer
			primerDigitoNR n = head [n]
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones		-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones

86.127.225.250 en 23:00 30 nov 2021

2021-11-30T23:00:50Z

← Revisión anterior		Revisión del 23:00 30 nov 2021
Línea 74:		Línea 74:
	-- subconjunto y subconjuntoR son equivalentes.		-- subconjunto y subconjuntoR son equivalentes.
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero		-- Lucía Hernández, Elsa Domínguez, Ana Sosa Caballero, Lucía González
	-- La propiedad es		-- La propiedad es
	prop_subconjuntoR :: [Int] -> [Int] -> Bool		prop_subconjuntoR :: [Int] -> [Int] -> Bool
Línea 90:		Línea 90:
	-- subconjuntoA [1,3,4,3] [1,2,3] == False		-- subconjuntoA [1,3,4,3] [1,2,3] == False
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			---Lucía González
	subconjuntoA :: Eq a => [a] -> [a] -> Bool		subconjuntoA :: Eq a => [a] -> [a] -> Bool
	subconjuntoA = ~~undefined~~		subconjuntoA xs ys = all (subconjunto ys)[xs]

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

Anasoscab en 18:42 29 nov 2021

2021-11-29T18:42:00Z

Mostrar los cambios

Tchavez en 09:07 19 nov 2021

2021-11-19T09:07:05Z

← Revisión anterior		Revisión del 09:07 19 nov 2021
Línea 738:		Línea 738:
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 26. Dos números son equivalentes si la media de sus dígitos		-- Ejercicio 26. Dos números son equivalentes si la media de sus dígitos
	-- son iguales. Por ejemplo, 3205 y 41 son ~~equvalentes~~ ya que		-- son iguales. Por ejemplo, 3205 y 41 son equivalentes ya que
	-- (3+2+0+5)/4 = (4+1)/2. Definir la función		-- (3+2+0+5)/4 = (4+1)/2. Definir la función
	-- equivalentes :: Integer -> Integer -> Bool		-- equivalentes :: Integer -> Integer -> Bool
Línea 748:		Línea 748:

	equivalentes :: Integer -> Integer -> Bool		equivalentes :: Integer -> Integer -> Bool
	equivalentes x y =		equivalentes x y = media1 x == media1 y
			media1 x = sum(digitos x) / fromIntegral( length (show x))
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 27. Un número x es especial si el número de ocurrencias de		-- Ejercicio 27. Un número x es especial si el número de ocurrencias de
Línea 767:		Línea 767:

	especial :: Integer -> Bool		especial :: Integer -> Bool
	especial x = ~~undefined~~		especial x = and [ocur d (x^2) == 2*(ocur d x)\| d <-digitos x]
			ocur x n = sum[1 \| y <-digitos n, x==y]
	-- El cálculo es		-- El cálculo es

	</source>		</source>

Tchavez en 08:52 19 nov 2021

2021-11-19T08:52:57Z

← Revisión anterior		Revisión del 08:52 19 nov 2021
Línea 484:		Línea 484:

	-- La propiedad es		-- La propiedad es
	prop_numeroBloquesR n = ~~undefined~~		prop_numeroBloquesR :: Integer -> Bool
			prop_numeroBloquesR n =(abs n) + n^2 == numeroBloquesC (abs n)

			prop_numeroBloquesR :: Integer -> Property
			prop_numeroBloquesR n =
			n>=0 ==> n + n^2 == numeroBloquesC n

	-- La comprobación es		-- La comprobación es
Línea 509:		Línea 514:
	convertirLista 0 = []		convertirLista 0 = []
	convertirLista n = [rem n 10] ++ convertirLista (div n 10)		convertirLista n = [rem n 10] ++ convertirLista (div n 10)

			esDigito1 :: Integer -> Integer -> Bool
			esDigito1 x n = elem head(show x) (show n)

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 568:		Línea 576:
	pegaNumerosR1 :: Integer -> Integer -> Integer		pegaNumerosR1 :: Integer -> Integer -> Integer
	pegaNumerosR1 x y = x * 10^length(digitosR y) + y		pegaNumerosR1 x y = x * 10^length(digitosR y) + y
	pN x y ~~\| y<10~~ = x*10^(length (show y)) + y		-- Sin usar dígitos recursiva, me da igual trabajar con caracteres ya que --- no voy a operar como números
			pegaNumerosR2 :: Integer -> Integer -> Integer
			pegaNumerosR2 x y = x * 10^(length (show y)) + y
			-- Definición de pN recursiva:
			pN x y \| y<10 = x*10 + y
	\| otherwise = (pN x (div y 10) ) * 10 + rem y 10		\| otherwise = (pN x (div y 10) ) * 10 + rem y 10
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 585:		Línea 597:
	-- ESA USA RECURSIÓN YA QUE DIGITOS ES RECURSIVA		-- ESA USA RECURSIÓN YA QUE DIGITOS ES RECURSIVA
	-- PRUEBA A USAR SHOW READ o bien listanumeroR:		-- PRUEBA A USAR SHOW READ o bien listanumeroR:
			pegaNumerosNR1 :: Integer -> Integer -> Integer
			pegaNumerosNR1 x y = read (show x ++ show y)

	pegaNumerosNR :: Integer -> Integer -> Integer		pegaNumerosNR :: Integer -> Integer -> Integer
	pegaNumerosNR x y = listaNumeroR (digitosR x ++ digitosR y)		pegaNumerosNR x y = listaNumeroR (digitosR x ++ digitosR y)
Línea 606:		Línea 621:
	primerDigitoR :: Integer -> Integer		primerDigitoR :: Integer -> Integer
	primerDigitoR n \| n<10 = n		primerDigitoR n \| n<10 = n
	\| otherwise = primerDigitoR (div n 10)		\| otherwise = primerDigitoR (div n 10)

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 20.2. Definir, sin usar recursión, la función		-- Ejercicio 20.2. Definir, sin usar recursión, la función
Línea 616:		Línea 631:
	-- Lucía Hernández		-- Lucía Hernández
	primerDigitoNR :: Integer -> Integer		primerDigitoNR :: Integer -> Integer
	primerDigitoNR n = head (digitos n)		primerDigitoNR n = head (digitos n) -- digitos era recursiva
			pDNR n = read [(head (show n))] -- esta es sin recursión
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones		-- Ejercicio 20.3. Comprobar con QuickCheck que las funciones
Línea 650:		Línea 665:

	inverso' :: Integer -> Integer		inverso' :: Integer -> Integer
	inverso' n = ~~undefined~~		inverso' n = read (reverse (show n))
			-- Mejor:
			inverso' = read.reverse.show

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 665:		Línea 682:
	-- Ejercicio 23. Definir la función		-- Ejercicio 23. Definir la función
	-- capicua :: Integer -> Bool		-- capicua :: Integer -> Bool
	-- tal que (capicua n) se verifica si si los dígitos ~~que~~ n son las mismas		-- tal que (capicua n) se verifica si los dígitos de n son las mismas
	-- de izquierda a derecha que de derecha a izquierda. Por ejemplo,		-- de izquierda a derecha que de derecha a izquierda. Por ejemplo,
	-- capicua 1234 = False		-- capicua 1234 = False
Línea 674:		Línea 691:
	capicua :: Integer -> Bool		capicua :: Integer -> Bool
	capicua n = reverse(digitos n) == digitos n		capicua n = reverse(digitos n) == digitos n
			cap n = inverso' n == n
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 24. (Problema 16 del proyecto Euler) El problema se		-- Ejercicio 24. (Problema 16 del proyecto Euler) El problema se
Línea 731:		Línea 748:

	equivalentes :: Integer -> Integer -> Bool		equivalentes :: Integer -> Integer -> Bool
	equivalentes x y = ~~undefined~~		equivalentes x y =

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 27. Un número x es especial si el número de ~~ocurrencia~~ de		-- Ejercicio 27. Un número x es especial si el número de ocurrencias de
	-- cada dígito d de x en x^2 es el doble del número de ocurrencias de d		-- cada dígito d de x en x^2 es el doble del número de ocurrencias de d
	-- en x. Por ejemplo, 72576 es especial porque tiene un 2, un 5, un 6 y		-- en x. Por ejemplo, 72576 es especial porque tiene un 2, un 5, un 6 y

10.100.152.61 en 08:21 19 nov 2021

2021-11-19T08:21:37Z

← Revisión anterior		Revisión del 08:21 19 nov 2021
Línea 520:		Línea 520:
	numeroDeDigitos x = length(digitos x)		numeroDeDigitos x = length(digitos x)
	-- NOTA: PRUEBA CON SHOW		-- NOTA: PRUEBA CON SHOW
			-- Adolfo Sagrera Vivancos
			numeroDeDigitos1 :: Integer -> Int
			numeroDeDigitos1 x = sum [ 1 \| x <- cifras x]
			cifras x = [read [c] :: Int \| c <- show x]

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

Tchavez en 17:37 18 nov 2021

2021-11-18T17:37:52Z

← Revisión anterior		Revisión del 17:37 18 nov 2021
Línea 519:		Línea 519:
	numeroDeDigitos :: Integer -> Int		numeroDeDigitos :: Integer -> Int
	numeroDeDigitos x = length(digitos x)		numeroDeDigitos x = length(digitos x)
			-- NOTA: PRUEBA CON SHOW

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 557:		Línea 558:
	-- pegaNumerosR 100 100 == 100100		-- pegaNumerosR 100 100 == 100100
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- AYUDA: HAZ RECURSIÓN EN EL SEGUNDO NÚMERO
	pegaNumerosR :: Integer -> Integer -> Integer		pegaNumerosR :: Integer -> Integer -> Integer
	pegaNumerosR x y = undefined		pegaNumerosR x y = undefined
			-- T: DOS OPCIONES
			pegaNumerosR1 :: Integer -> Integer -> Integer
			pegaNumerosR1 x y = x * 10^length(digitosR y) + y
			pN x y \| y<10 = x*10^(length (show y)) + y
			\| otherwise = (pN x (div y 10) ) * 10 + rem y 10
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 19.2. Definir, sin usar recursión, la función		-- Ejercicio 19.2. Definir, sin usar recursión, la función
Línea 573:		Línea 578:
	pegaNumerosNR :: Integer -> Integer -> Integer		pegaNumerosNR :: Integer -> Integer -> Integer
	pegaNumerosNR x y = x*10^(length (digitos y)) + y		pegaNumerosNR x y = x*10^(length (digitos y)) + y
			-- T:
			-- ESA USA RECURSIÓN YA QUE DIGITOS ES RECURSIVA
			-- PRUEBA A USAR SHOW READ o bien listanumeroR:
			pegaNumerosNR :: Integer -> Integer -> Integer
			pegaNumerosNR x y = listaNumeroR (digitosR x ++ digitosR y)
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 19.3. Comprobar con QuickCheck que las funciones		-- Ejercicio 19.3. Comprobar con QuickCheck que las funciones

Sarcertor en 18:50 17 nov 2021

2021-11-17T18:50:15Z

← Revisión anterior		Revisión del 18:50 17 nov 2021
Línea 503:		Línea 503:
	esDigito :: Integer -> Integer -> Bool		esDigito :: Integer -> Integer -> Bool
	esDigito x n = elem x (digitos n)		esDigito x n = elem x (digitos n)

			-- Sara Cerro
			esDigito :: Integer -> Integer -> Bool
			esDigito x n = elem x (convertirLista n)
			convertirLista 0 = []
			convertirLista n = [rem n 10] ++ convertirLista (div n 10)

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

Elsdomgon en 18:13 17 nov 2021

2021-11-17T18:13:03Z

← Revisión anterior		Revisión del 18:13 17 nov 2021
Línea 309:		Línea 309:
	-- propiedad: A \ B ⊂ A		-- propiedad: A \ B ⊂ A
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- Elsa Domínguez
	-- La propiedad es		-- La propiedad es
	prop_diferencia_subconjunto :: [Int] -> [Int] -> Bool		prop_diferencia_subconjunto :: [Int] -> [Int] -> Bool
	prop_diferencia_subconjunto = ~~undefined~~		prop_diferencia_subconjunto a b = subconjunto (diferencia a b) a

	-- La comprobación es		-- La comprobación es quickCheck prop_diferencia_subconjunto
			-- +++ OK, passed 100 tests.

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 320:		Línea 321:
	-- propiedad: (A \ B) ∩ B = ∅.		-- propiedad: (A \ B) ∩ B = ∅.
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- Elsa Domínguez
	-- La propiedad es		-- La propiedad es
	prop_diferencia_interseccion :: [Int] -> [Int] -> Bool		prop_diferencia_interseccion :: [Int] -> [Int] -> Bool
	prop_diferencia_interseccion = ~~undefined~~		prop_diferencia_interseccion a b = interseccion (diferencia a b) b == []

	-- La comprobación es		-- La comprobación es quickCheck prop_diferencia_interseccion
			-- +++ OK, passed 100 tests.

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 338:		Línea 340:
	producto xs ys = [(a,b) \| (a,b) <- zip xs ys ++ zip xs ys']		producto xs ys = [(a,b) \| (a,b) <- zip xs ys ++ zip xs ys']
	where ys' = reverse ys		where ys' = reverse ys
			-- Elsa Domínguez
			producto' :: Eq a => [a] -> [a] -> [(a,a)]
			producto' xs ys= [(x,y) \| x <- xs, y <- ys]

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 356:		Línea 361:
	productoR [] _ = []		productoR [] _ = []
	productoR (x:xs) ys = zip (take (length ys) (repeat x) ) ys ++ productoR xs ys		productoR (x:xs) ys = zip (take (length ys) (repeat x) ) ys ++ productoR xs ys

	--Fernando Ruiz Mazo		--Fernando Ruiz Mazo
	productoR'' :: Eq a => [a] -> [a] -> [(a,a)]		productoR'' :: Eq a => [a] -> [a] -> [(a,a)]
Línea 362:		Línea 366:
	productoR'' xs [] = []		productoR'' xs [] = []
	productoR'' (x:xs) ys = [ (x,b) \| b <- ys ] ++ productoR xs ys		productoR'' (x:xs) ys = [ (x,b) \| b <- ys ] ++ productoR xs ys

	--José Manuel García		--José Manuel García
	productoR :: Eq a => [a] -> [a] -> [(a,a)]		productoR :: Eq a => [a] -> [a] -> [(a,a)]
Línea 369:		Línea 372:
	productoR [] _ = []		productoR [] _ = []
	productoR (x:xs) (y:ys) = (productoR1 (x:xs) (y:ys) ) ++ (productoR xs (y:ys))		productoR (x:xs) (y:ys) = (productoR1 (x:xs) (y:ys) ) ++ (productoR xs (y:ys))
			-- Elsa Domínguez
			productoR2 :: Eq a => [a] -> [a] -> [(a,a)]
			productoR2 xs ys = nub (productoR2' xs ys)
			productoR2' _ [] = []
			productoR2' [] _ = []
			productoR2' (x:xs) (y:ys) = (x,y):producto (x:xs) ys ++ (producto xs (y:ys))
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 11.3. Comprobar con QuickCheck que producto y productoR		-- Ejercicio 11.3. Comprobar con QuickCheck que producto y productoR
	-- son equivalentes.		-- son equivalentes.
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- Elsa Domínguez
	-- La propiedad es		-- La propiedad es
	prop_producto :: [Int] -> [Int] -> Bool		prop_producto :: [Int] -> [Int] -> Bool
	prop_producto = ~~undefined~~		prop_producto xs ys = iguales (producto xs ys) (productoR xs ys)

	-- La comprobación es		-- La comprobación es quickCheck prop_producto
			-- +++ OK, passed 100 tests.

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 386:		Línea 395:
	-- ys.		-- ys.
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- Elsa Domínguez
	-- La propiedad es		-- La propiedad es
	prop_elementos_producto :: [Int] -> [Int] -> Bool		prop_elementos_producto :: [Int] -> [Int] -> Bool
	prop_elementos_producto = ~~undefined~~		prop_elementos_producto xs ys = length (producto xs ys) == length xs * length ys

	-- La comprobación es		-- La comprobación es quickCheck prop_elementos_producto
			-- +++ OK, passed 100 tests.

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 404:		Línea 414:
	-- [2,3,4], [2,3], [2,4], [2], [3,4], [3], [4], []]		-- [2,3,4], [2,3], [2,4], [2], [3,4], [3], [4], []]
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	Adriana Gordillo		-- Adriana Gordillo
	subconjuntos :: [a] -> [[a]]		subconjuntos :: [a] -> [[a]]
	subconjuntos = subconjuntos xs = [take k cs \| cs<-css, k<-[1..length xs-1]]++[xs,[]]		subconjuntos = subconjuntos xs = [take k cs \| cs<-css, k<-[1..length xs-1]]++[xs,[]]
	where css= [ (drop n xs) ++ (take n xs) \|n<-[0..length xs -1]]		where css= [ (drop n xs) ++ (take n xs) \|n<-[0..length xs -1]]
			--Fernando Ruiz Mazo, Elsa Domínguez
	--Fernando Ruiz Mazo
	subconjuntosR :: [a] -> [[a]]		subconjuntosR :: [a] -> [[a]]
	subconjuntosR [] = [[]]		subconjuntosR [] = [[]]
Línea 422:		Línea 431:
	-- quickCheckWith (stdArgs {maxSize=7}) prop_subconjuntos		-- quickCheckWith (stdArgs {maxSize=7}) prop_subconjuntos
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
			-- Elsa Domínguez
	-- La propiedad es		-- La propiedad es
	prop_subconjuntos :: [Int] -> Bool		prop_subconjuntos :: [Int] -> Bool
	prop_subconjuntos = ~~undefined~~		prop_subconjuntos xs = length (subconjuntos xs) == 2^(length xs)

	~~-- La comprobación es~~

			-- La comprobación es quickCheckWith (stdArgs {maxSize=7}) prop_subconjuntos
			-- +++ OK, passed 100 tests.

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

Sarcertor en 18:08 17 nov 2021

2021-11-17T18:08:46Z

← Revisión anterior		Revisión del 18:08 17 nov 2021
Línea 450:		Línea 450:
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

			--Sara Cerro
	numeroBloquesR :: Integer -> Integer		numeroBloquesR :: Integer -> Integer
	numeroBloquesR = ~~undefined~~		numeroBloquesR 1 = 2
			numeroBloquesR n = 2*n + numeroBloquesR (n-1)

	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
Línea 463:		Línea 465:
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------

	numeroBloquesC :: Integer -> Integer		--Sara Cerro
	numeroBloquesC n = ~~undefined~~		numeroBloquesC :: Integer -> Integer
			numeroBloquesC n = sum [ 2*x \| x <- xs]
			where xs = [1..n]
	-- ---------------------------------------------------------------------		-- ---------------------------------------------------------------------
	-- Ejercicio 15.3. Comprobar con QuickCheck que (numeroBloquesC n) es		-- Ejercicio 15.3. Comprobar con QuickCheck que (numeroBloquesC n) es