-
Notifications
You must be signed in to change notification settings - Fork 0
/
trabajo_practico_4_arreglos_sendra.py
355 lines (245 loc) · 11.2 KB
/
trabajo_practico_4_arreglos_sendra.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
# -*- coding: utf-8 -*-
"""Trabajo practico 4 - Arreglos_SENDRA.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1W34duFtntSLft4ct6GI_h8YtSLYimxoS
#  **Trabajo Práctico 4: Arreglos uni y multidimensionales** 
En este trabajo práctico, vamos a trabajar con arreglos uni y multidimensionales en Python. Recuerden crear una copia de este archivo en su ***Google Drive*** para tener permisos de edición.
### email Sergio: **[email protected]**
### email Ariel: **[email protected]**
### **Ejercicio 1**
Escribir un programa que le pida al usuario que ingrese 10 números enteros (primero uno, luego otro, y así hasta que el usuario ingrese 10 numeros). Al final, el programa debe imprimir los números que fueron ingresados en orden inverso, la suma total de los valores y el promedio.
"""
"""
for i in range (cantNum):
numIngresado = int(input("Ingrese un número entero: "))
vector[cantNum - i - 1 ] = numIngresado #el último en la nueva matriz es vector[-1]
sumaTotal+= numIngresado
"""
import numpy as np
cantNum = int(input())
sumaTotal= 0
vector = np.zeros((cantNum),int)
vectorInverso = None
for i in range(len(vector)): # de 0 a la cant de espacios del vector
numIngresado = int(input("Ingrese un número entero: "))
vector[len(vector)-1 -i ] = numIngresado
sumaTotal+= numIngresado
print (f" Vector inversa: {vector} Suma Total: {sumaTotal} Promedio: {sumaTotal / cantNum}")
"""### **Ejercicio 2**
Escribir una función que recibe un arreglo de enteros por parámetro y lo retorna con el contenido desplazado una posición hacia la derecha: el primero pasa a ser el segundo, el segundo pasa a ser el tercero y así sucesivamente. El último pasa a ser el primero.
Luego, escribir un programa que cargue un arreglo con valores ingresados por el usuario y llame a la función con ese arreglo. Mostrar el contenido del arreglo por pantalla, antes y después de la función.
"""
## vector = [1 2 3 6 2 54 7]
## vector = [7 1 2 3 6 2 54]
import numpy as np
def correADerecha(vector):
nVector = len(vector)
aux = vector[nVector-1]
for pos in reversed(range(1,nVector)):
vector[pos] = vector[pos - 1]
vector[0] = aux
v = np.array([1,2,3,6,2,54,7])
print(v)
correADerecha(v)
print(v)
"""### **Ejercicio 3**
Desarrollar una función que inserte un elemento en un arreglo de enteros dada la posición de inserción. Al insertar un elemento en una posición, se produce un desplazamiento a la derecha, si el arreglo estaba lleno, el último elemento se pierde.
"""
## vector = [1 2 4 5 3]
##Insertamos el 10 en la posicion 1
## vector = [1 10 2 4 5]
def insertarDezplazandoAlaDerecha(vector,valor,posicion):
"""### **Ejercicio 4**
Escribir una función que elimine el elemento que ocupa una determinada posición de un arreglo de enteros. Al eliminar se debe mantener la continuidad, es decir, los elementos a la derecha del eliminado, deben desplazarse a la izquierda un lugar.
"""
## vector = [1 2 8 5 3 4 5]
## Eliminar el elemento de la posicion 3
## vector = [1 2 8 3 4 5 0]
def eliminarElemento(vector, posEliminar):
if 0 > posEliminar > len(vector)-1:
raise Exception("Posicion invalida.")
for pos in range(posEliminar,len(vector)-1):
vector[pos] = vector[pos+1]
vector[len(vector)-1] = 0
v = np.array([1, 2, 8, 5, 3, 4, 5])
print(v)
eliminarElemento(v,3)
print(v)
"""### **Ejercicio 5**
Escribir una función que elimine todas las apariciones de un determinado elemento de un arreglo de enteros.
"""
## vector = [1 3 3 4 5 6 3 7 3]
## vector = [1 3 4 5 6 3 7 3 0]
"""### **Ejercicio 6**
Escribir una función recursiva que reciba un arreglo de números reales como parámetro y retorne la suma de todos los elementos del arreglo.
"""
## vector = [1 2 6 2 5 7 3 3 5 6]
## sum(vector) = vector[0] + sum([2 6 2 5 7 3 3 5 6])
## Caso base = Vector de un elemento
def sumaVector(vector):
suma = 0
if len(vector) == 1:
suma = vector[0]
else:
suma = vector[0] + sumaVector(vector[1:])
return suma
v = np.array([1, 2, 8, 5, 3, 4, 5])
print(v)
print(sumaVector(v))
def sumaVector2(vector, posActual = 0):
suma = 0
if posActual == len(vector)-1:
suma = vector[posActual]
else:
suma = vector[posActual] + sumaVector2(vector, posActual+1)
return suma
print(sumaVector2(v))
"""### **Ejercicio 7**
Escribir un programa que crea y cargar dos matrices de tamaño 3x3, las suma y muestra el resultado.
"""
"""### **Ejercicio 8**
Escribir una función que recibe una matriz y la rellena de la siguiente forma: En la posición M[ n , m ] debe contener n + m.
"""
### 0 1 2
### 1 2 3
### 2 3 4
def llenaMatriz(matriz):
nFilas, nColumnas = matriz.shape
for fila in range(nFilas): ###for fila in range(len(matriz))
for columna in range(nColumnas):
matriz[fila,columna] = fila + columna
m = np.zeros((8,4), int)
print(m)
llenaMatriz(m)
print(m)
"""### **Ejercicio 9**
Desarrollar una función que recibe una matriz cuadrada de números reales (N x N) por parámetro y calcula la suma de los elementos que están por encima de la diagonal principal (excluyendo la diagonal).
En el ejemplo de la imagen, la función deberia retornar: *b + c + f*
"""
import random as rdm
def asignarValoresAleatorios(matriz):
for j in range(len(matriz)):
for k in range(len(matriz[j])):
h = rdm.randint(0,9)
matriz[j][k] = h
m = np.zeros((4,4),int)
asignarValoresAleatorios(m)
## 62 38 51 26 fila 0 -> 1:final
## 68 9 75 40 fila 1 -> 2:final
## 63 12 69 24 fila 2 -> 3:final
## 74 3 64 10
print(m)
def sumaSobreDiagonal(matriz):
nFilas, nColumnas = matriz.shape
suma = 0
for fila in range(nFilas-1):
for columna in range(fila+1,nColumnas):
print("pos:",fila,",",columna)
print(matriz[fila, columna])
suma += matriz[fila, columna]
return suma
print(sumaSobreDiagonal(m))
"""### **Ejercicio 10**
Escribir una función que retorna *True* si una matriz cuadrada de enteros es matriz diagonal y *False* en caso contrario.
Una matriz diagonal es una matriz que tiene ceros en todos sus elementos, menos en la diagonal principal.
"""
"""### **Ejercicio 11**
Escribir una función que retorna *True* si una matriz cuadrada de enteros es simétrica y *False* en caso contrario.
Una matriz simétrica es como la de la imagen (no importan los elementos de la diagonal principal):
"""
"""### **Ejercicio 12**
Escribir una función recursiva, que calcule la suma de los elementos de la diagonal principal de una matriz.
Nota: La suma de los elementos de la diagonal principal de una matriz se llama "traza de la matriz".
"""
### 1 2 5
### 3 6 1
### 5 6 8
## 1 + sum 6 1
## 6 8
## Caso base = Matriz de 1x1
# m[1:,1:]
"""### **Comentario**
En los ejercicios que usan cadenas de caracteres, pueden usar el tipo *str*, salvo que necesiten modificar elementos de la cadena luego de crearla, en ese caso, tienen que usar arreglos de caracteres.
### **Ejercicio 13**
Escribir 3 procedimientos que reciben una cadena de caracteres y..:
- Imprima los dos primeros caracteres.
- Imprima los tres últimos caracteres.
- Imprima la cadena cada dos caracteres. Por ej.: 'recta' debería imprimir 'rca'
"""
cadena = "carrera"
for pos in range(len(cadena)):
print(cadena[pos])
"""### **Ejercicio 14**
Desarrollar una función recursiva que retorna *True* si una cadena de caracteres es un palíndromo y *False* en caso contrario.
Nota: Palíndromo es la forma elegante de "capicua"
"""
## palabra = neuquen
## comparo primer letra con ultima y llamado recursivo con el resto
def esPalindromo(palabra):
resultado = True
if len(palabra) <= 3:
resultado = palabra[0] == palabra[len(palabra)-1]
else:
resultado = (palabra[0] == palabra[len(palabra)-1]) and esPalindromo(palabra[1:len(palabra)-1])
return resultado
esPalindromo("neuqwequen")
"""### **Ejercicio 15**
Escribir una función que recibe una cadena de caracteres y un caracter y retorna una nueva cadena que tiene el caracter entre cada letra de la cadena de entrada.
Por ej si la cadena es: ' separar ' y el caracter es: ' , ', debería retornar ' s,e,p,a,r,a,r '
"""
"""### **Ejercicio 16**
Escribir una función que recibe un arreglo variables de tipo "Tiempo" (TDA del ejercicio 4 del TP de TDA) y retorna un nuevo arreglo solo con los tiempos que son mayores a una hora (1:00:00).
Escribir un programa para probar a la función.
Nota: Van a tener que copiar el TDA "Tiempo" en el bloque de código de abajo y para que un *print* de un vector de variables de tipo "Tiempo" funcione, tienen que programar la operacion "\_\_repr__()" en el TDA "Tiempo". Pueden hacer a la operación "\_\_repr__()" igual a "\_\_str__()", porque *repr* es una generalización de *str*.
"""
class Tiempo:
def __init__(self, h, m, s):
self.horas = h
self.minutos = m
self.segundos = s
def __repr__(self):
return str(self.horas)+":"+str(self.minutos)+":"+str(self.segundos)
v = np.zeros(10,Tiempo)
v[0] = Tiempo(2,34,45)
v[2] = Tiempo(20,3,21)
print(v)
"""### **Ejercicio 17**
Una de las aplicaciones de matrices en programación es la representación y procesamiento de imágenes. Vamos a ver algunas cosas que se pueden hacer. Para esto primero tenemos que cargarnos una imagen en el colab y generar una matriz a partir de ella.
- Descarguen el archivo "felix.csv" del siguiente link:
https://drive.google.com/file/d/19CkOd04p6zw9qoKrF88TR2j-UFZnV9Uh/view?usp=sharing
- Suban el archivo "felix.csv" al "colab" para poder cargarlo con el programa de Python de abajo (haciendo click en el icono de la carpeta , de arriba a la izquierda y luego en "Subir")
- Completen el programa, procesando a la imagen guardada en la matriz "felix" para obtener las imágenes de la siguiente figura (La "A" es la imagen original), pueden hacer funciones que generen cada transformación en la imagen:
"""
import numpy as np
import matplotlib.pyplot as plt
###Lectura del archivo en la matriz#####
felix = np.genfromtxt('felix.csv', delimiter=',')
########################################
######Para mostrar matriz como imagen###########
plt.imshow(felix)
plt.show()
########################################
print(felix[0:4,0:4])
######Completar procesamiento en matriz felix para obtener imagenes################
print(felix.shape)
###Figura B
def matrizTraspuesta(matriz):
nFilas,nColumnas = felix.shape
traspuesta = np.zeros((nColumnas,nFilas),int)
for f in range(nFilas):
traspuesta[:,f] = matriz[f,:]
return traspuesta
def matrizTraspuesta2(matriz):
nFilas,nColumnas = felix.shape
traspuesta = np.zeros((nColumnas,nFilas),int)
for f in range(nFilas):
for c in range(nColumnas):
traspuesta[c,f] = matriz[f,c]
return traspuesta
figuraB = matrizTraspuesta(felix)
plt.imshow(figuraB)
plt.show()