1)Realice un programa en Python con las siguientes características:

# Para construir dos vectores, va y vb respectivamente, debe solicitar al usuario

para cada uno de ellos, tres valores que representen el límite inferior, el límite
superior (incluido) y el paso de la secuencia de valores que almacenarán.

# Luego debe imprimir los valores de ambos vectores.

# Construir una matriz P, de rango (len(va), len(vb)), cuyos valores son los
productos de los valores de los vectores va[i] y vb[j], para todos los valores de i
con i en el intervalo [0, len(i)] y para todos los valores de j con j en el intervalo
[0, len(i)].

# Imprimir los valores de P por filas.

#Calcular los siguientes estadísticos a partir de los valores de la matriz P: mínimo,

máximo y promedio, la función estadísticos.

#Imprimir los valores de los estadísticos.

Programa:

a=int(raw_input("Ingrese el límite inferior del rango de va: "))

b=int(raw_input("Ingrese el límite superior del rango de va: "))
c=int(raw_input("Ingrese el paso de valor del rango de va:"))

d=int(raw_input("Ingrese el límite inferior del rango de vb: "))

e=int(raw_input("Ingrese el límite superior del rango de vb: "))
f=int(raw_input("Ingrese el paso de valor del rango de vb:"))

va=[]
i=0
for j in range(a,b+1,c):
#es b+1 ya que sino no incluye el valor del limite superio
va.append(j)
i+=1
print "Vector va:"
for i in range (len(va)):
print "va[%d]=%d"%(i,va[i])

vb=[]
i=0
for j in range(d,e+1,f):
vb.append(j)
i+=1
print "Vector vb:"
for i in range (len(vb)):
print "vb[%d]=%d"%(i,vb[i])

#creo la matriz P

P=[]
for i in range(len(va)):
p=[0]*len(vb)
P.append(p)

#hago el producto
for i in range(0,len(va)):
for j in range (0,len(va)):
P[i][j]=va[i]*vb[j]

print "Matriz P:"

for i in range(len(P)):
print P[i]

#En caso de que la matriz P no está ordenada

for i in range(len(P)): #filas
for j in range(1,len(P)): #pasadas
#print "pasada:", j
for g in range(0,len(P)-j): #iteraciones
#print "comparamos los elementos P[%d][%d] y P[%d][%d]"%(i,g,i,g+1)
if P[i][g]>P[i][g+1]:
elemento=P[i][g]
P[i][g]=P[i][g+1]
P[i][g+1]=elemento
#for i in range(len(P)):
#print P[i]

#saco el mínimo:
P1=[]
i=0
for j in range(0,len(P)):
P1.append(P[j][i])

min=P1[0]
for i in range (1,len(P1)):
if min>P1[i]:
min=P1[i]
print "Mínimo=[%d]"%(min)

#saco el maximo:
P2=[]
i=len(P)-1
for j in range(0,len(P)):
P2.append(P[j][i])

max=P2[0]
for i in range (1,len(P2)):
if max<P2[i]:
max=P2[i]
print "Maximo=[%d]"%(max)

#falta sacar el promedio:

suma=0
cantidad=0
for i in range(len(P)):
for j in range(len(P)):
suma=suma+P[i][j]
cantidad+=1
promedio=suma/cantidad
print "Promedio=%d"%(promedio)

2)Realice un programa en Python con las siguientes características:

# La cantidad de filas y columnas de dos matrices de igual tamaño se ingresa por

teclado. Verificar que la cantidad de filas y columnas sean mayores a cero en caso
contrario emitir un mensaje por pantalla un mensaje "Tamaño incorrecto" y finalizar
el programa.

# Ingresar los valores de las matrices desde el teclado.

# Generar una tercera matriz del mismo tamaño que las cargadas por el usuario y que
contenga los elementos correspondientes de la primera matriz si la suma del índice de
la fila y la columna es par y de la segunda matriz si es impar, los índices de la
primera fila y de la primera columna se asumen iguales a 0 (cero) y 0 (cero)se
considera par.

# Mostrar la matriz resultado en la consola por fila, en la primera línea muestre el

texto 'Resultados' y en las siguientes los resultados de la operación.

# Generar un vector que contenga los números de fila de la matriz resultado que
contienen al menos un número negativo (se considera la primera fila como la fila 0
(cero))

# Mostrar los elementos del vector, si el vector no tiene elementos, que muestre un
mensaje "No hay filas con valores negativos"

Programa:

#hacer dos matrices de igual tamaño y que el numero de filas o columnas sea mayor a
cero:

a=int(raw_input("dame el numero de filas: "))

b=int(raw_input("dame el numero de columnas: "))
#creo las matrices:

if a>0 and b>0:

M1=[]
for i in range (a):
m1=[0]*b
M1.append(m1)
for i in range(a):
for j in range(b):
M1[i][j]=int(raw_input("dame el valor del elemento M1[%d][%d]: "%(i,j)))
print "la primera matriz es:"
for i in range (a):
print M1[i]
M2=[]
for i in range (a):
m2=[0]*b
M2.append(m2)
for i in range(a):
for j in range(b):
M2[i][j]=int(raw_input("dame el valor del elemento M2[%d][%d]: "%(i,j)))
print "la segunda matriz es:"
for i in range (a):
print M2[i]
else:
print "Tamaño incorrecto"

#hacer una tercera matriz del mismo tamaño que la primera y hacer el resto

R=[]
for i in range (a):
r=[0]*b
R.append(r)
for i in range (b):
for j in range (a):
if (i+j)%2==0:
print "es par"
R[j][i]=M1[j][i]
else:
print "es impar"
R[j][i]=M2[j][i]
print "Resultado:"
for i in range (3):
print R[i]

#busco filas negativas

N=[]
contar=0
for i in range(3):
for j in range (2):
if R[i][j]<0:
N.append(i)
contar+=1
break
if contar>0:
print "Filas con negativos"
for i in range(len(N)):
print N[i]
else:
print "no hay filas con valores negativos"

3)Realice un programa en Python con las siguientes características:

#La cantidad de filas y columnas de un arreglo se ingresa por teclado.

# Validar que la matriz es cuadrada, sino emitir un mensaje en la consola "La matriz
no es cuadrada" y terminar.

# Debe ingresar los valores del arreglo desde el teclado. Se debe verificar, antes de
agregar el valor al arreglo, que dicho valor sea un número par. Si el valor ingresado
no cumple la condición, mostrar un mensaje por consola ("El valor ingresado no es
par") y solicitar nuevamente el valor. Una vez cargada se debe mostrar por consola,
en la primera línea debe mostrar el texto "Matriz Ingresada" y en las siguientes los
datos de la matriz con formato de matriz.

# Generar un arreglo unidimensional con el promedio de cada fila.

# Mostrar el resultado en la consola, en la primera línea muestre el texto "Promedio

de Cada Fila" y en las siguientes los promedios encontrados.

# Generar una NUEVA matriz que contendrá en cada fila los datos del arreglo generado
en (3) ordenados de menor a MAYOR alternando con un ordenamiento de MAYOR a menor en
la siguiente fila y así sucesivamente.

# Mostrar la nueva matriz por consola, en la primera línea debe mostrar el texto
"Matriz Generada" y en las siguientes los datos de la matriz con formato de matriz.

Programa:

a=int(raw_input("Numero de filas: "))

b=int(raw_input("Numero de columnas: "))
if a!=b:
print "La matriz no es cuadrada"
else:
#creo una matriz nula:
M=[]
for i in range(a):
m=[0]*b
M.append(m)
#ingreso los valores:
for i in range (a):
for j in range (b):
M[i][j]=int(raw_input("Valor [%d][%d]: "%(i,j)))
if not (M[i][j])%2==0:
print "El valor ingresado no es par"
M[i][j]=int(raw_input("Valor [%d][%d]: "%(i,j)))
print "Matriz Ingresada"
for i in range(a):
print M[i]
#saco el promedio de cada fila:
P=[]
for i in range(a):
suma=0
for j in range(b):
suma= suma + M[i][j]
promedio=suma/a
P.append(promedio)
print "Promedio de Cada Fila"
for i in range (a):
print P[i]
#creo una matriz
G=[]
for i in range(4):
g=[0]*4
G.append(g)
N1=[]
N1=N1+P
N1.sort()
N2=[]
N2=N2+P
N2.sort()
for i in range(0,4):
if i%2==0:
#la ordeno de menor a mayor
G[i]=N1
else:
#la ordeno de mayor a menor
for g in range(1,len(N2)):
for j in range(0,len(N2)-i):
if N2[j]<N2[j+1]:
elemento=N2[j]
N2[j]=N2[j+1]
N2[j+1]=elemento
G[i]=N2
print "Matriz Generada"
for i in range(4):
print G[i]

3)Generar un arreglo unidimensional con los elementos de la diagonal secundaria

Programa:
M=[[5,1,3,7],[13,3,-1,11],[11,5,3,-7],[-3,-5,7,5]]

print "la matriz ingresada"

for i in range(len(M)):
print M[i]

#sacar la diagonal secundaria

P=[]
for i in range(len(M)): #filas
a=len(M)-1-i
for j in range(a,-1,-1): #columna
if a==j:
p = M[i][j]
P.append(p)
print "diagonal secundaria"
for i in range(len(P)):
print P[i]

4)Con el objetivo de determinar para un arreglo bidimensional cuadrado de elementos

binarios, 'Arreglo_Dato', cuán alejado está de otro, 'Arreglo_Patron', Ud. debe
realizar un programa en Python con las siguientes caracteristicas:

# Que permita al usuario ingresar desde el teclado, para una grilla de tamaño de n*n,
los valores actuales de 'Arreglo_Dato'(representado por la grilla), los cuales sólo
pueden ser 0 (ceros) o 1 (unos).
# Ingresará previamente el valor de n, debiendo validar que sea entero positivo y
menor que 20 -hacer testing con n pequeño-
# El programa debe contemplar tratamiento de excepciones para que el usuario no
ingrese un arreglo de todos 1 (unos), ó todos 0 (ceros), mostrando la leyenda 'Usted
ha ingresado un arreglo incorrecto, intente nuevamente, evitando usar arreglos con
idéntico valor para todos sus elementos'.

# Que genere otro arreglo, el que se utiliza como patrón, 'Arreglo_Patron', el cual
tiene el mismo tamaño que el anterior y la forma de una matriz triangular inferior,
es decir: 0 (cero) para todo elemento a la derecha de la diagonal principal y 1 (uno)
para los demás elementos.

# Que, mediante la función 'Genera_Arreglo_Distancia', recorra sólo la zona

triangular inferior de 'Arreglo_Dato' con el fin generar un tercer arreglo,
'Arreglo_Distancia' del mismo tamaño, cuyos elementos en la zona triangular respondan
a las siguientes reglas:
A) Tenga signo - (menos) si el elemento correspondiente en 'Arreglo_Dato' es 0
(cero), y signo + (más), si el elemento correspondiente es 1 (uno).
B) Su valor indique la cantidad de elementos vecinos inmediatos (es decir: contiguos
horizontales, verticales y diagonales) cuyo valor es 0 (cero) cuando DEBERIA ser 1
(uno) conforme al patrón. -Función 1-
# Ejemplo:
Arreglo_Dato: Arreglo_Patron: Arreglo_Distancia:

1 0 1 0 1 0 0 0 +2 0 0 0
0 0 0 1 1 1 0 0 -2 -2 0 0
1 0 1 1 1 1 1 0 +3 -2 +3 0
1 1 1 0 1 1 1 1 +1 +1 +2 -0

# No es necesario que indique el signo + en los elementos del 'Arreglo_Distancia',

sin signo se considera positivo.
Programa:
M=[[1,0,1,0],[0,0,0,1],[1,0,1,1],[1,1,1,0]]
#Hacemos la diagonal inferior:
#1-creamos una matriz nula.
P=[]
for i in range (4):
p=[0]*4
P.append(p)
#2-hago la digonal:
for i in range(4):
for j in range (i,4):
P[j][i]=1

#SOLO si en M hay un cero y en P hay un uno se cuenta.

print "la matriz M es: "
for i in range (len(M)):
print M[i]
print "la matriz P es: "
for i in range (len(P)):
print P[i]
#Creo una matriz nula D3:
D3=[]
for i in range (4):
d3=[0]*4
D3.append(d3)

#PRIMERO: comparo filas para adelante:

for i in range(0,3):
for j in range(i+1,4):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(j,i)
print "los elementos son M[%d][%d] y P[%d][%d]"%(j,i+1,j,i+1)
if M[j][i+1]!= P[j][i+1]:
contar+=1
print contar
D3[j][i]=contar
for i in range (4):
print D3[i]
#Creo una matriz nula D4:
D4=[]
for i in range (4):
d4=[0]*4
D4.append(d4)

#SEGUNDO: comparo filas para atras:

for i in range(3,0,-1):
for j in range(i,0,-1):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(i,j)
print "los elementos son M[%d][%d] y P[%d][%d]"%(i,j-1,i,j-1)
if M[i][j-1]!= P[i][j-1]:
contar+=1
print contar
D4[j][i]=contar
for i in range(4):
print D4[i]

M2=[]
for i in range (4):
m2=[0]*4
M2.append(m2)

for i in range (4):

for j in range(4):
M2[i][j]=D3[i][j]+D4[i][j]
print "la suma de SOLO las filas es: "
for i in range(4):
print M2[i]
#Creo una matriz nula D2:
D2=[]
for i in range (4):
d2=[0]*4
D2.append(d2)

#TERCERO: comparo las columnas (hacia abajo):

for i in range (0,3):
for j in range (i,3):
print "comparo los elementos vecinos del elemento M[%d][%d]"%(j,i)
print "los elementos son M[%d][%d] y P[%d][%d]"%(j+1,i,j+1,i)
contar=0
if M[j+1][i]!= P[j+1][i]:
contar+=1
print contar
D2[j][i]=contar
for i in range(4):
print D2[i]

#Creo una matriz nula D5:

D5=[]
for i in range (4):
d5=[0]*4
D5.append(d5)

#CUARTO: comparo las columnas (hacia abajo):

for i in range(3,0,-1):
for j in range(i-1,-1,-1):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(i,j)
print "los elementos son M[%d][%d] y P[%d][%d]"%(i-1,j,i-1,j)
if M[i-1][j]!= P[i-1][j]:
contar+=1
print contar
D5[i][j]=contar
for i in range(4):
print D5[i]

M1=[]
for i in range (4):
m1=[0]*4
M1.append(m1)

for i in range (4):

for j in range(4):
M1[i][j]=D5[i][j]+D2[i][j]
print "comparando SOLO las columnas la suma es: "
for i in range(4):
 print M1[i]

#creo una matriz D6

D6=[]
for i in range (4):
d6=[0]*4
D6.append(d6)

#QUINTO: comparo diagonal hacia adelante:

for i in range (0,3):

for j in range(i,3):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(j,i)
print "los elementos son M[%d][%d] y P[%d][%d]"%(j+1,i+1,j+1,i+1)
if M[j+1][i+1]!= P[j+1][i+1]:
contar+=1
print contar
D6[j][i]=contar
for i in range(4):
print D6[i]

#creo una matriz D7

D7=[]
for i in range (4):
d7=[0]*4
D7.append(d7)

#SEXTO: comparo diagonal hacia atras:

for i in range (3,0,-1):

for j in range(i,0,-1):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(i,j)
print "los elementos son M[%d][%d] y P[%d][%d]"%(i-1,j-1,i-1,j-1)
if M[i-1][j-1]!= P[i-1][j-1]:
contar+=1
print contar
D7[i][j]=contar
for i in range(4):
print D7[i]

#creo una matriz D8

D8=[]
for i in range (4):
d8=[0]*4
D8.append(d8)

#SEXTO: comparo diagonal inversa hacia adelante:

for i in range (1,3):

for j in range(i,3):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(j,i)
print "los elementos son M[%d][%d] y P[%d][%d]"%(j+1,i-1,j+1,i-1)
if M[j+1][i-1]!= P[j+1][i-1]:
contar+=1
print contar
D8[j][i]=contar
for i in range(4):
 print D8[i]

#creo una matriz D9

D9=[]
for i in range (4):
d9=[0]*4
D9.append(d9)

#SEPTIMO: comparo diagonal inversa hacia atras:

for i in range (0,2):

for j in range(i+2,4):
contar=0
print "comparo los elementos vecinos del elemento M[%d][%d]"%(j,i)
print "los elementos son M[%d][%d] y P[%d][%d]"%(j-1,i+1,j-1,i+1)
if M[j-1][i+1]!= P[j-1][i+1]:
contar+=1
print contar
D9[j][i]=contar
for i in range(4):
print D9[i]

M3=[]
for i in range(4):
m3=[0]*4
M3.append(m3)

for i in range (4):

for j in range(4):
M3[i][j]=D9[i][j]+D8[i][j]+D6[i][j]+D7[i][j]
print "comparando SOLO las diagonales la suma es: "
for i in range(4):
print M3[i]

#Creo una matriz nula Direccion:

Dir=[]
for i in range (4):
dir=[0]*4
Dir.append(dir)
#sumo las matrices

for i in range (4):

for j in range(4):
Dir[i][j]=M1[i][j]+M2[i][j]+M3[i][j]

print "la matriz direccion es: "

for i in range(4):
print Dir[i]

#pongo los signos:

#1)creo una matriz

signo=[]
for i in range(4):
s=[0]*4
signo.append(s)

for i in range (4):

 for j in range(i,4):
if M[j][i]==0:
signo[j][i]="-"
else:
signo[j][i]="+"
print "la matriz signo es:"
for i in range (4):
print signo[i]

#No es necesario pero para poner los signos debo

#cambiar "-" y "+" por -1 y +1 y hacer:
#Final=[]
#for i in range(4):
# f=[0]*4
# Final.append(f)
#
#for i in range (4):
# for j in range(4):
# Final[i][j]=Dir[i][j]*signo[i][j]
#print "la matriz final es: "
#for i in range(4):
# print Final[i]