Para cada casilla en cada fila y columna, generar un aleatorio de dos posibilidades que mínimo puede ser cero.
aleatorio = int(rnd.random()*2)+0
con lo que se genera la matriz de números aleatorios.
Al finalizar una fila, considere la suma de fila para revisar la paridad con el residuo de la división para 2.
residuo = sumafila % 2
Si hay residuo el número es impar y se debe escribir el número 1 en la última casilla de toda la fila (fila, n), es decir se completa la paridad.
En el caso opuesto, que no hay residuo=0, el conteo de '1' ya es par y se deja el valor cero en la última casilla.
Algoritmo en Python
# 1Eva_IIT2004_T4 Matriz de paridadimport numpy as np
import random as rnd
# INGRESO
n = 7 # tamaño matriz# PROCEDIMIENTO# matriz de n filas y n+1 columnas
matriz = np.zeros(shape=(n,n+1),dtype=int)
# recorre matrizfor fila inrange(0,n,1):
sumafila = 0
for columna inrange(0,n,1):
aleatorio = int(rnd.random()*2)+0
matriz[fila,columna] = aleatorio
sumafila = sumafila + aleatorio
# revisa residuo paridad
residuo = sumafila % 2
if residuo: # sumafila es impar
matriz[fila,n] = 1
# SALIDAprint(' Matriz obtenida')
print(matriz)
# 1Eva_IIT2004_T3 Estimar Pi por Montecarlo# Propuesta de solución. edelros@espol.edu.ec# se usa todo el círculoimport random as rnd
import numpy as np
# INGRESO
n = int(input('¿Cuántos puntos?: '))
radio = 1
# PROCEDIMIENTO
punto = np.zeros(shape=(n,2),dtype=float)
k = 0
i = 0
while i<n:
x = rnd.random()*(2*radio)-1
y = rnd.random()*(2*radio)-1
d = np.sqrt(x**2+y**2)
if d<=radio:
k = k + 1
punto[i] = [x,y]
i = i + 1
estimadopi = 4*k/n
# SALIDAprint(k,n)
print('estimador pi: ', estimadopi)
print(punto)
la estimación de π con números aleatorios que se ubican dentro del círculo de radio 1 es:
La variable n indica el número de parejas o tamaño de los vectores para almacenar la "pareja" y el contador de "veces" que juega cada una.
# INGRESO
n = int(input('cuantas parejas: '))
El ejercicio se divide en dos partes: la primera para seleccionar de forma aleatoria la pareja de la dama (una por una), es decir se sortean los caballeros (quien), y la segunda parte se realiza el proceso para los caballeros.
dama = n+1
whilenot(dama>(2*n)):
quien = int(rnd.random()*n)+1
pareja[dama] = quien
veces[quien] = veces[quien]+1
dama = dama + 1
En cada sorteo se registra cuántas veces participa cada uno.
Algoritmo en Python
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 1Eva_IT2004_T3 Sortear parejas para tenisimport random as rnd
import numpy as np
# INGRESO
n = int(input('cuantas parejas: '))
# PROCEDIMIENTO
pareja = np.zeros(2*n+1,dtype=int)
veces = np.zeros( n+1,dtype=int)
dama = n+1
whilenot(dama>(2*n)):
quien = int(rnd.random()*n)+1
pareja[dama] = quien
veces[quien] = veces[quien]+1
dama = dama + 1
# SALIDAprint(pareja[n+1:])
print('veces: ')
print(veces)
print('juegan varias veces: ')
caballero = 1
whilenot(caballero>n):
if (veces[caballero]>1):
print(caballero)
caballero = caballero + 1
print('los que no juegan: ')
caballero = 1
whilenot(caballero>n):
if (veces[caballero]==0):
print(caballero)
caballero = caballero + 1
con un ejemplo de resultado:
cuantas parejas: 10
[ 6 2 1 8 3 9 10 1 7 9]
veces:
[0 2 1 1 0 0 1 1 1 2 1]
juegan varias veces:
1
9
los que no juegan:
4
5
>>>
Propuesta de solución en Python, para un número ISBN dado
ISBN = 9684443242
Luego de pedir el número ISBN, se inicia extrayendo el dígito verificador escrito, quedando el resto de dígitos del número hacia la izquierda para realizar los cálculos.
vescrito = ISBN%10
n = ISBN//10
Tarea: verificar el número de dígitos del ISBN
Para la posición del dígito se usa un contador.
Las operaciones se acumulan en suma, de la que se obtiene el residuo de la división para 11.
El residuo corresponde al verificador calculado que se compara con el verificador escrito para dar el veredicto.
Se deben comparar las cadenas U y V en los elementos de las mismas posiciones.
Primero se plantea un algoritmo para determinar el número de parejas diferentes que existen dentro de cada cadena.
Si las cadenas difieren en el tamaño, la respuesta será '-1'.
Algoritmo en Python
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 2Eva_IIIT2003_T3 Distancia de Hamming# INGRESO
U = '20001'
V = '10103'# PROCEDIMIENTO
n = len(U)
m = len(V)
diferente= -1 # tamaño diferente U,Vif n == m:
diferente = 0
i = 0
whilenot(i>=n):
if U[i] != V[i]:
diferente = diferente +1
i = i + 1
# SALIDAprint('distancia Hamming: ', diferente)
resultado del algoritmo
distancia Hamming: 3
>>>
Luego se procede a convertir el algoritmo a una función y hacer la llamada desde un programa, con lo que se cumple lo requerido en cada literal
Instrucciones en Python usando una función
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 2Eva_IIIT2003_T3 Distancia de Hamming# literal a. funciondefdHamming(U,V):
n = len(U)
m = len(V)
diferente = -1
if n == m:
diferente = 0
i = 0
whilenot(i>=n):
if U[i] != V[i]:
diferente = diferente +1
i = i + 1
return(diferente)
# Programa -------------# INGRESO
U = '20001'
V = '10103'# PROCEDIMIENTO
diferente = dHamming(U,V)
# SALIDAprint('distancia Hamming: ', diferente)
Tarea: Añadir la lectura de los datos desde un archivo.
La función no debe admitir valores de x negativos o cero, de darse el caso se responde np.NaN que corresponde a no es un número o 'Not a Number'.
# 2Eva_IIIT2003_T2 Raíz cuadrada por Newtonimport numpy as np
# literal a. función recursivadefraizNewton(x,n)
if n<=0 or x<=0:
# no se admiten negativos o cero
f = np.NaN
else:
if n == 1:
f = x/2 # valor inicialif n>1:
f = 0.5 *(raizNewton(x,n-1)+x/raizNewton(x,n-1))
return (f)
# literal b. Programa ---------------# INGRESO
x = float(input('ingrese x: '))
n = int(input('aproximación n-esima: '))
# PROCEDIMIENTOprint(' i , f(i)')
for i inrange(0,n+1,1):
print(i , raizNewton(x,i))
# 1Eva_IIIT2003_T3 Coordenadas enteras en un círculoimport numpy as np
# INGRESO
radio = 10
# PROCEDIMIENTO
a = - int(radio)
b = int(radio)
encirculo = 0
sumadist = 0
y = a
while y<=b+1:
x = a
while x<=b+1:
dist = np.sqrt(x**2 + y**2)
if dist<=radio:
encirculo = encirculo + 1
sumadist = sumadist + dist
x = x + 1
y = y + 1
promdist = sumadist/encirculo
# SALIDAprint(' coordenadas enteras en círculo: ')
print(encirculo)
print('promedio distancias al centro: ')
print(promdist)
El problema planteado es semejante a construir una pirámide, en la que se disponen de solo t bloques y se requiere saber si el número de bloques es exacto para formar una pirámide.
El ejercicio se desarrolla suponiendo que se construirá una pirámide con bloques de varios "pisos".
Se observa que el número de bloques coincide con el número de piso a construir.
Ejemplo:
Piso 1 tiene 1 bloque,
piso 2 tiene 2 bloques,
etc.
piso = 1 # contador
usados = 0 # acumulador
Cada piso usa una cierta cantidad de bloques que se cuentan como "usados", es decir se acumulan. La cantidad de bloques por piso es la misma que el número del piso, contador que se inicia con 1.
El lazo o bucle repite el proceso de tal forma que los bloques usados se acumulan en cada piso.
while (usados<t):
usados = usados + piso
piso = piso+1
Dado un número t de bloques ,se calcula la secuencia de números triangulares mientras los bloques usados sean menores que los t disponibles.
En caso que el número “usados” de la secuencia es igual a t, se considera al número t como un número triangular.
La respuesta es un valor de verdad, si es triangular 1, si no lo es 0.
Para crear la matriz de Pascal en Python se usa la librería Numpy, con lo que se crea un arreglo de tamaño nxn lleno de ceros.
ejemplo:
1
1
1
1
2
1
1
3
3
1
1
4
6
4
1
1
5
10
10
5
1
….
….
….
….
….
….
Al recorrer la matriz por cada fila f y columna c, si la posición matriz[f,c] es la primera columna a la izquierda (c==0) o la diagonal (f==c) se escribe 1.
Si la posición de la matriz[f,c] es debajo de la diagonal, se suman los valores de las casilla inmediata superior e izquierda superior.
pascal[f,c] = pascal[f-1,c] + pascal[f-1,c-1]
Al terminar el recorrido se tendrá la matriz con el triángulo de Pascal.
Propuesta de solución en Python: py_pdf, también en versión matlab: m_pdf
Tarea: Convertir el algoritmo a función.
Algoritmo en Python
# ICM00794-Fundamentos de Computación - FCNM-ESPOL# 2Eva_IIT2003_T2 Mostrar un triángulo de Pascal# propuesta: edelros@espol.edu.ecimport numpy as np
# INGRESO
n = int(input('tamaño del triangulo: '))
# PROCEDIMIENTO
pascal = np.zeros(shape=(n,n),dtype=int)
f = 0
while (f<n):
c = 0
while (c<=f):
if (c==0 or c==f):
pascal[f,c] = 1
else:
pascal[f,c] = pascal[f-1,c] + pascal[f-1,c-1]
c = c+1
f = f+1
print(pascal)
