<jupyter_start><jupyter_text>Ejercicios Numpy II  Ejercicio 11. Crea un array que vaya del 0 al 9 y que se llame `my_array`2. Imprime por pantalla los elementos [9 7 5 3 1] en ese orden.<jupyter_code>import numpy as np

# 1.
my_array = np.arange(10)
print(my_array)

# 2.
print(my_array[::-2])<jupyter_output>[0 1 2 3 4 5 6 7 8 9]
[9 7 5 3 1]<jupyter_text>Ejercicio 2Imprime por pantalla la secuencia [8 7] del array `my_array`<jupyter_code>print(my_array)
print(my_array[-2:-4:-1])
print(my_array[8:6:-1])<jupyter_output>[8 7]<jupyter_text>Ejercicio 3Imprime por pantalla la secuencia [2 1 0] de `my_array`<jupyter_code>print(my_array)
print(my_array[-8::-1])
# Otra solución, en dos pasos
my_array[0:3][::-1]

array1 = my_array[0:3]
array2 = array1[::-1]
print(array1)
print(array2)
print(my_array[2::-1])<jupyter_output>[2 1 0]<jupyter_text>Ejercicio 41. Crea una matriz de 4x5, con una secuencia del 1 al 202. Invierte totalmente la matriz. Tanto las filas, como las columnas<jupyter_code>my_matrix = np.arange(1, 21).reshape((4,5))
print(my_matrix)
print(my_matrix[::-1, ::-1])<jupyter_output>[[20 19 18 17 16]
 [15 14 13 12 11]
 [10  9  8  7  6]
 [ 5  4  3  2  1]]<jupyter_text>Ejercicio 5Obtén el siguiente array, partiendo de la matriz del ejercicio 4```Pythonarray([[1, 2],       [6, 7]])```<jupyter_code>my_matrix = np.arange(1, 21).reshape((4,5))
print(my_matrix)
my_matrix[:2:, :2:]
my_matrix[:2, :2]<jupyter_output><empty_output><jupyter_text>Ejercicio 6Obtén el siguiente array, partiendo de la matriz del ejercicio 4```Pythonarray([[ 1,  3,  5],       [11, 13, 15]])```<jupyter_code>my_matrix = np.arange(1, 21).reshape((4,5))
print(my_matrix)
my_matrix[::2, ::2]<jupyter_output><empty_output><jupyter_text>Ejercicio 7Obtén el siguiente array, partiendo de la matriz del ejercicio 4```Pythonarray([[ 5,  4,  3,  2,  1],       [10,  9,  8,  7,  6],       [15, 14, 13, 12, 11]])```<jupyter_code>my_matrix = np.arange(1, 21).reshape((4,5))
print(my_matrix)
print(my_matrix[::, ::-1])
print(my_matrix[:-1:, ::-1])<jupyter_output>[[ 5  4  3  2  1]
 [10  9  8  7  6]
 [15 14 13 12 11]
 [20 19 18 17 16]]
[[ 5  4  3  2  1]
 [10  9  8  7  6]
 [15 14 13 12 11]]<jupyter_text>Ejercicio 8Dado el siguiente array:```Pythonx = np.array(["Loro", "Perro", "Gato", "Loro", "Perro"])```Filtra el array para quedarte únicamente con los loros.Resuélvelo de dos maneras diferentes<jupyter_code>x = np.array(["Loro", "Perro", "Gato", "Loro", "Perro"])

# Metodo 1
mask = np.array([True, False, False, True, False])

x[mask]
# Metodo 2
mask = x == "Loro"
print(mask)
x[mask]
# Metodo 3. Devuelve posiciones que luego aplico al array
mask = np.where(x == "Loro")
print(mask)
x[mask]<jupyter_output>(array([0, 3], dtype=int64),)<jupyter_text>Ejercicio 9Crea una secuencia de 20 elementos y transformala en un array compuesto por 2 matrices de 5x2<jupyter_code>x = np.arange(20).reshape((2,5,2))
print(x)<jupyter_output>[[[ 0  1]
  [ 2  3]
  [ 4  5]
  [ 6  7]
  [ 8  9]]

 [[10 11]
  [12 13]
  [14 15]
  [16 17]
  [18 19]]]<jupyter_text>Ejercicio 10Obtén el siguiente array, partiendo de la matriz del **ejercicio 4**```Pythonarray([[20, 19, 18, 17, 16],       [15, 14, 13, 12, 11],       [10,  9,  8,  7,  6],       [ 5,  4,  3,  2,  1]])```<jupyter_code>my_matrix = np.arange(1, 21).reshape((4,5))
print(my_matrix)
my_matrix[::-1, ::-1]<jupyter_output><empty_output><jupyter_text>Ejercicio 11Crea un array de 10 0s. ¿Cuánto ocupa en memoria?Sustituye el 4to elemento por 1, e imprime el array por pantalla<jupyter_code>import numpy as np

x = np.zeros(10)
print(x)

print(x.itemsize) # Cada elemento
print(x.nbytes) # El array entero

x[3] = 1
print(x)<jupyter_output>[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
8
80
[0. 0. 0. 1. 0. 0. 0. 0. 0. 0.]<jupyter_text>Ejercicio 12Crea un vector que vaya del 10 al 49Inviértelo<jupyter_code>x = np.arange(10, 50)
print(x)
print(x[::-1])<jupyter_output>[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]
[49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26
 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10]<jupyter_text>Ejericio 13Encuentra los indices de los valores que no sean 0 del siguiente vector [1,2,0,0,4,0]. El output sería [0, 1, 4]. [Encuentra el método apropiado en la documentación.](https://numpy.org/doc/)<jupyter_code>np.nonzero([1,2,0,0,4,0])<jupyter_output><empty_output><jupyter_text>Ejercicio 14Crea una matriz de numeros aleatorios 10x10. Encuentra los valores mínimo y máximo.<jupyter_code>#x = np.random.random((10,10))
x = np.random.randint(1, 100, size = (10,10))
print(x)

print("\nel mínimo es: ",x.min())
print("\nel máximo es: ",x.max())<jupyter_output>[[64 13 25 37 17 65 58 10 89 38]
 [60 22  4 46 63  8 52 78 20 58]
 [34 80 47 26 12 30 84 38 61 15]
 [27 87 81 87 93 47  8 80 28 11]
 [14 87 30 67 46 88 57 98 62 33]
 [42 66 17 25 16 73 24 47 10 28]
 [ 2  1 29 56 52 50 76 32 49 75]
 [22 47 95  9 82 54 51 83 75 15]
 [73 83 45 62 36 36 22 67 62 79]
 [47 46 59 27 80  9 12 26 45 18]]

el mínimo es:  1

el máximo es:  98<jupyter_text>Ejercicio 15Crea un vector aleatorio de tamaño 30 y calcula su media<jupyter_code>x = np.random.random(30)
m = x.mean()
print("La media de x es: ", round(m, 2))<jupyter_output>La media de x es:  0.51<jupyter_text>Ejercicio 16Crea un array cuadrado de 2D, con las dimensiones que quieras, pero que todo el borde esté compuesto por 1s, y el interior por 0s<jupyter_code>x = np.ones((10,10))
x[1:-1:, 1:-1:] = 0
print(x)<jupyter_output>[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 0. 0. 0. 0. 0. 0. 0. 0. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]<jupyter_text>Ejercicio 17Crea una matriz de 8x8, y rellénala con 0s y 1s. Tienes que replicar:```Python[[0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0] [0 1 0 1 0 1 0 1] [1 0 1 0 1 0 1 0]]```<jupyter_code>x = np.zeros((8,8), dtype = int)
x[1::2, ::2] = 1
x[::2, 1::2] = 1
print(x)<jupyter_output>[[0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]]<jupyter_text>Ejercicio 18Replica la matriz del apartado anterior, pero en este caso usando [la función `tile`](https://numpy.org/doc/stable/reference/generated/numpy.tile.html)<jupyter_code>x = np.tile(np.array([[0,1], [1,0]]), (4,4))
print(x)<jupyter_output>[[0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]
 [0 1 0 1 0 1 0 1]
 [1 0 1 0 1 0 1 0]]<jupyter_text>Ejercicio 19Crea una matriz aleatoria de 5x5 y normaliza sus valores. Para normalizar tienes que restar sus valores por la media(`np.mean`) y dividir el resultado por la desviación estándar(`np.std`).<jupyter_code>x = np.random.randint(1, 20, (5,5))

x = (x - np.mean(x))/np.std(x)

print(x)<jupyter_output>[[ 1.87401721  1.87401721 -0.54928091  0.25848513 -1.55898845]
 [-0.75122241 -0.95316392 -1.35704694 -0.54928091 -0.3473394 ]
 [-1.15510543 -1.35704694 -1.15510543  0.66236815  0.86430966]
 [ 0.46042664  1.06625117  0.46042664 -0.14539789  1.47013419]
 [ 1.06625117  0.66236815  0.05654362 -0.3473394  -0.54928091]]<jupyter_text>Ejercicio 201. Crea una secuencia de números que vayan del 0 al 10.2. Crea un nuevo array, que parta del anterior, pero sustituya todos los elementos entre el 3 y el 8, por el valor -13. Crea un nuevo array que niegue todos los elementos entre el 3 y el 8<jupyter_code>x = np.arange(11)
print(x)

y = x.copy()
y[(y > 3) & (y <= 8)] = -1
print(y)
y = x.copy()
y[(y > 3) & (y <= 8)] *= -1
print(y)
# Equivalente
y[(y > 3) & (y <= 8)] = y[(y > 3) & (y <= 8)] * -1
x *= -1
x = x * (-1)<jupyter_output><empty_output><jupyter_text>Ejercicio 21 Bonus track. Mini hundir la flota para ir practicando. Te ayudará a entender la lógica de la tarea Hundir la Flota.1. Crea un tablero de 10x10 relleno del carácter espacio ( ).2. Posiciona un par de barcos en [(0,1), (1,1)] y [(1,3), (1,4), (1,5), (1,6)]. Los barcos serán Os mayúsculas. Como ves, un barco de dos posiciones de eslora y otro de cuatro.3. Recibe un disparo en uno de los barcos, sustituyendo la O por una X4. Recibe un disparo en agua, sustituyendo uno de los espacios por un guión: -5. Ignorando los disparos recibidos, ahora prueba a posicionar otro barco de 4 posiciones dentro del tablero, pero **de manera ALEATORIA.****TIP apartado 5**: El barco tendrá una posición inicial aleatoria dentro del tablero, y una orientación también aleatoria (N,S,E,O).Por ejemplo, si tu posicion inicial fuese (5,0) y la orientación O, no podrias ponerlo porque se sale del tablero. Ahora bien, si fuese orientación este, si podrías, y ocuparía las posiciones [(5,0), (5,1), (5,2), (5,3)]. Por tanto tendrás que iterar con un bucle si es posible encajar el barco en el tablero, y el bucle terminará cuando lo consigas encajar. **Ojo con las posiciones donde ya hay barco!!!**Usa `import random` para elegir las coordenadas aleatorias. **Te damos la solución porque somos más buenos que el pan, no lo copies, al menos, no todo, pero ojalá te sirva para desatascarte si es que lo estuvieras.**<jupyter_code>tablero = np.full(fill_value = ' ', shape = (10, 10))
tablero[0:2, 1] = 'O'
tablero[1, 3:7] = 'O'
tablero[0, 1] = 'X'
tablero[0, 0] = '-'
tablero
eslora = 4
import random
import numpy as np
tablero = np.full(fill_value = ' ', shape = (10, 10))

while True:
    # 'N' - 'S' - 'E' - 'O'
    orient = random.choice(['N', 'S', 'E', 'O'])

    # Posicion inicial del barco
    current_pos = np.random.randint(10, size = 2)
    
    fila = current_pos[0]
    col = current_pos[1]
    
    # Recogemos las 4 posiciones colindantes a current_pos
    coors_posiN = tablero[fila:fila - eslora:-1, col]
    coors_posiE = tablero[fila, col: col + eslora]
    coors_posiS = tablero[fila:fila + eslora, col]
    coors_posiO = tablero[fila, col: col - eslora:-1]
    
    # Comprobamos si esas posiciones son validas
    # Orientacion Norte
    if (orient == 'N') and len(coors_posiN) == eslora and ('O' not in coors_posiN):
        tablero[fila:fila - eslora:-1, col] = 'O'
        break

    # Orientacion Este
    elif (orient == 'E') and len(coors_posiE) == eslora and ('O' not in coors_posiE):
        tablero[fila, col: col + eslora] = 'O'
        break

    # Orientacion Sur
    elif (orient == 'S') and len(coors_posiS) == eslora and ('O' not in coors_posiS):
        tablero[fila:fila + eslora, col] = 'O'
        break

    # Orientacion Oeste
    elif (orient == 'O') and len(coors_posiO) == eslora and ('O' not in coors_posiO):
        tablero[fila, col: col - eslora:-1] = 'O'
        break

    else:
        continue
tablero<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.14751695070551585, 'fraction_numerical': 0.1297416162726773, 'mean_word_length': 3.502887788778878, 'pattern_counts': {'":': 0, '<': 74, '<?xml version=': 0, '>': 74, 'https://': 2, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '16146', 'license': 'MIT', 'n_tokens_mistral': 5812, 'n_tokens_neox': 4762, 'n_words': 1618, 'path': 'week4_EDA_np_pd_json_apis_regex/day1_numpy_pandas_I/Ejercicios Numpy II_RES.ipynb', 'repo_name': 'paleomau/MGOL_BOOTCAMP', 'size': '10914'}